* @param config
	 */
	private static void readconfig(String config) {
		SimpleElement configuration = null;
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(config));
			SimpleDomParser sdp = new SimpleDomParser();
			configuration = sdp.parse(br);

			if (configuration == null)
				throw new Exception("Error reading configuration file");
			// System.out.println( "configuration == " + configuration );
			preferencesFromXML(configuration);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private static void preferencesFromXML(SimpleElement configuration) {

		for (int i = 0; i < configuration.getChildElements().size(); i++) {
			SimpleElement element = configuration.getChildElements().get(i);
			if (element.getTagName().equals("preference")) {
				String name = element.getAttribute("name");
				String value = element.getAttribute("value");
				preferences.put(name, value);
			}
		}
	}

port = Integer.parseInt(preferences.get("port"));
		maxLength = Integer.parseInt(preferences.get("maxLength"));
		lexparserModel = preferences.get("lexparser");
		postaggerModelFile = preferences.get("postagger");
		sentenceDelimiter = preferences.get("sentence");
                String[] options = { "-maxLength", Integer.toString(maxLength),
				"-outputFormat", "oneline" };

		Options op = new Options();
		op.setOptions(options);
try {
			posTagger = new MaxentTagger(postaggerModelFile);
			lexparser = LexicalizedParser.loadModel(lexparserModel);
			lexparser.setOptionFlags(options);
			

		} catch (IllegalArgumentException e) {
			System.err.println("Error loading parser, exiting...");
			System.exit(0);
		}

while (true) {
	System.err.println("Waiting for Connection on Port: " + port);
	try {
		clientSocket = parseServer.accept();
		System.err.println("Connection Accepted From: "
				+ clientSocket.getInetAddress());
		br = new BufferedReader(new InputStreamReader(
				new DataInputStream(clientSocket.getInputStream()),
				"UTF-8"));
		outputWriter = new PrintWriter(
				new OutputStreamWriter(clientSocket.getOutputStream(),
						StandardCharsets.UTF_8), true);

		String doc = "";

		do {
			doc += br.readLine();
		} while (br.ready());
		System.err.println("received: " + doc);

		// PARSE
		try {
			

			Reader sr = new StringReader(doc);
			List<List<HasWord>> sentences = MaxentTagger
					.tokenizeText(sr);

			List<TaggedWord> tSentence = posTagger.tagSentence(sentences
					.get(0));
			System.err.println("Taggedwords: " + tSentence);
			Tree tree = lexparser.apply(tSentence);

			String output = tree.toString();
			outputWriter.println(output);

			System.err.println("best factored parse:\n"
					+ tree.toString());

		} catch (Exception e) {
			outputWriter.println("(ROOT (. .))");
			outputWriter.println("-999999999.0");
			e.printStackTrace();
		}

		outputWriter.flush();
		outputWriter.close();

	} catch (IOException e) {
		e.printStackTrace();
	}
}

	 * function which sends the sentence to the stanford parser and retrieves
	 * the parse tree from it.
	 * 
	 * @param sentence
	 *            source sentence
	 * @return the parsed result
	 */
	public ParseResult parseEnglishSentence(String sentence) {
		String result = "";
		// Tree parse = null;
		// double parseScore = Double.MIN_VALUE;
		//
		// System.err.println(sentence);
		// see if a parser socket server is available
		int port = 5556;
		String host = "127.0.0.1";
		Socket client;
		PrintWriter pw;
		BufferedReader br;
		String line;
		Tree parse = null;
		double parseScore = Double.MIN_VALUE;

		try {
			client = new Socket(host, port);

			pw = new PrintWriter(client.getOutputStream());
			br = new BufferedReader(new InputStreamReader(
					client.getInputStream()));
			pw.println(sentence);
			pw.flush(); // flush to complete the transmission

			/**
			 * 1)Removed the ready method. It was giving issues 2)Removed the
			 * else condition and parseScore method
			 */
			while ((line = br.readLine()) != null) {
				line = line.replaceAll("\n", "");
				line = line.replaceAll("\\s+", " ");
				result += line + " ";

			}

			br.close();
			pw.close();
			client.close();

			if (parse == null) {
				parse = readTreeFromString("(ROOT (. .))");
				parseScore = -99999.0;
			}

			System.err.println("result (parse):" + result);
			parse = readTreeFromString(result);
			return new ParseResult(true, parse, parseScore);

		} catch (Exception ex) {

			System.err.println("Could not connect to parser server.");
			// ex.printStackTrace();
		}

/** if socket server not available, then use a local parser object */

		if (englishStanfordParser == null) {
			try {
				readconfig(CONFIG_FILE);
				port = Integer.parseInt(preferences.get("port"));
				int maxLength = Integer.parseInt(preferences.get("maxLength"));
				String lexparserModel = preferences.get("lexparser");

				Options op = new Options();

				String[] options = { "-maxLength", Integer.toString(maxLength),
						"-outputFormat", "oneline" };

				op.setOptions(options);
				englishStanfordParser = LexicalizedParser.loadModel(
						lexparserModel, op);

				/**
				 * Not applicable in the new version of Stanford.
				 */
				// parser.setMaxLength();
				// parser.setOptionFlags("maxLength",
				// Integer.toString(maxLength),"-outputFormat", "oneline");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		try {

			parse = englishStanfordParser.parse(sentence);
			if (parse != null) {

				// remove all the parent annotations (this is a hacky way to do
				// it)
				String ps = parse.toString().replaceAll(
						"\\[[^\\]]+/[^\\]]+\\]", "");
				// System.out.println("Hello......   " + ps);
				parse = ParserUtilities.getInstance().readTreeFromString(ps);

				parseScore = 0.0;
				return new ParseResult(true, parse, parseScore);
			}
		} catch (Exception e) {
		}