jbrowselineparser.java

java写的多功能文件编辑器

							messageElement = new UML.Message(msgStr, UML.Type.ERROR,
									parentNode.getElement().getParentElement(), curTokenLine);
							insertAsNode(messageElement, curElementStartPos, 
									(UMLTree.Node) parentNode.getParent());

							// attempt to continue by falling into body
						}


						if ( isBodyRequired && token.equals("{") ) {

							parseSubState = ParseSubState.OP_BODY;
							methodBraceCount++;

						} else if ( !isBodyRequired && token.equals(";") ) {

							// handle method with no body
							UMLTree.Node o = (UMLTree.Node) nodeStack.pop();
							parentNode = (UMLTree.Node) nodeStack.peek();
							if (parentNode == root ) {
								parseState = ParseState.POST_HEADER;
								parseSubState = ParseSubState.SCANNING;
							} else {
								parseState = ParseState.PACKAGE_MEMBER;
								parseSubState = ParseSubState.BODY;
								mod = 0;
								memberType = null;
								memberName = null;
							}
							curElementStartPos = -1;

						} else {

							// error
							if (isBodyRequired) {
								msgStr = "Expecting body for the method.";
								parseSubState = ParseSubState.BODY;
								curElementStartPos = -1;
								mod = 0;
								memberType = null;
								memberName = null;

							} else {
								msgStr = "Expecting ';' after abstract or native method.";
								parseSubState = ParseSubState.OP_BODY;
								methodBraceCount++;
							}


							// pop off stack
							nodeStack.pop();
							parentNode = (UMLTree.Node) nodeStack.peek();

							// Create error node and increment count
							results.incErrorCount();

							messageElement = new UML.Message(msgStr, UML.Type.ERROR,
									parentNode.getElement(), curTokenLine);
							insertAsNode(messageElement, curElementStartPos, parentNode);

							continue;
						} // if-else for "}" or ";"


					} else if (token.equals(",") ) {

						// expect more throws classes/interfaces
						if (throwsFound && throwsOK ) {

							throwsOK = false;

						} else {
							// phrase before ',' not OK
							badFlag = true;
						}

					} else if ( Character.isJavaIdentifierStart(tokenStartChar) ) {

						if (token.equals("throws")) {
							if (throwsFound) {
								badFlag = true;
							} else {
								throwsFound = true;
								throwsOK = false;
							}
							
						} else {
							// implements/extends what indentifier
							if (!throwsOK) {

								curElementStartPos = ls.getStartOffset() + curTokenPos;
								curTokenLine = ts.getCurrentLineNum();

								throwsOK = true;

								currentElement = new UML.Throws(token,
										parentNode.getElement(), curTokenLine);
								insertAsNode(currentElement, curElementStartPos, parentNode);

							} else {
								badFlag = true;
							}
						}

					} else {
						// unexpected token
						badFlag = true;

					} // if-else if by token for PACKAGE_MEMBER - OP_POST_PARMS


					if (badFlag) {

						msgStr = "Error in 'throws' phrase.";

						// Create error node and increment count
						results.incErrorCount();

						messageElement = new UML.Message(msgStr, UML.Type.ERROR,
								parentNode.getElement().getParentElement(), curTokenLine);
						insertAsNode(messageElement, curElementStartPos, 
								(UMLTree.Node) parentNode.getParent());

						// attempt to continue by skipping to beginning of body
						boolean skipSuccess = false;
						boolean popRequired = false;

						if ( isBodyRequired ) {

							skipSuccess = ts.skipUntil( "{" );

							// entering operation body
							parseSubState = ParseSubState.OP_BODY;
							methodBraceCount++;

						} else {
							popRequired = true;
							skipSuccess = ts.skipUntil( ";" );
						}

						if (!skipSuccess )  {

							if ( isBodyRequired ) {
								msgStr = "Expected '{' not found.";
							} else {
								msgStr = "Expected ';' not found.";
							}

							// Create error node and increment count
							results.incErrorCount();

							messageElement = new UML.Message(msgStr, UML.Type.ERROR,
									parentNode.getElement().getParentElement(), curTokenLine);
							insertAsNode(messageElement, curElementStartPos, 
									(UMLTree.Node) parentNode.getParent());

							popRequired = true;
						}

						if ( popRequired ) {							
							nodeStack.pop();
							parentNode = (UMLTree.Node) nodeStack.peek();

							// returning to package member body
							parseSubState = ParseSubState.BODY;
							curElementStartPos = -1;
							mod = 0;
							memberType = null;
							memberName = null;
						}

					} // if (badFlag)

					// end of code block for PACKAGE MEMBER - OP_POST_PARMS


				// ------------------------------
				// PACKAGE_MEMBER - OP_BODY
				// ------------------------------
				} else if (parseSubState == ParseSubState.OP_BODY) {

					if (token.equals("{") ) {
						methodBraceCount++;

					} else if (token.equals("}") ) {
						methodBraceCount--;

						if (methodBraceCount == 0) {

							nodeStack.pop();
							parentNode = (UMLTree.Node) nodeStack.peek();

							// return to body of this method's container
							parseSubState = ParseSubState.BODY;
							curElementStartPos = -1;
							mod = 0;
							memberType = null;
							memberName = null;
						}

					} // if - else if for PACKAGE_MEMBER - OP_BODY

				} else {

					msgStr = "Unexpected State/Sub-State.";

					// Create error node and increment count
					results.incErrorCount();

					messageElement = new UML.Message(msgStr, UML.Type.ERROR,
							parentNode.getElement().getParentElement(), curTokenLine);
					insertAsNode(messageElement, curElementStartPos, 
							(UMLTree.Node) parentNode.getParent());


				} // if...else if by parseState & parseSubState

				// log every token at end of loop!
//%				JBrowse.log(12, this, "(" + tokenCount + ") " + parseState + " "
//%						+ parseSubState + " " + curTokenLine + "-" + curTokenPos
//%						+ ":" + token);


			} while (token != null);



		} catch (TokenSource.Exception e) {

			exceptionThrown = true;

			curTokenLine = ts.getCurrentLineNum();
			curTokenPos  = ts.getCurrentPos();
			curElementStartPos = ls.getStartOffset() + curTokenPos;

			// Unterminated multi-line comment, String or char expression
			msgStr = e.getMessage();

			// Create error node and increment count
			results.incErrorCount();

			try {
				parentNode = (UMLTree.Node) nodeStack.peek();
				currentElement = parentNode.getElement();
			} catch (Exception ex) {
				parentNode = null;
				currentElement = null;
			}
			messageElement = new UML.Message(msgStr, UML.Type.ERROR,
					currentElement, curTokenLine);
			insertAsNode(messageElement, curElementStartPos, parentNode);


		} catch (java.util.EmptyStackException e) {

			exceptionThrown = true;

//%			msgStr = "Caught java.util.EmptyStackException: " + e.getMessage();

		} // end try-catch


		// Report Final Errors

		curTokenLine = ts.getCurrentLineNum();
		curTokenPos  = ts.getCurrentPos();
		curElementStartPos = ls.getStartOffset() + curTokenPos;


		if ( !exceptionThrown &&
				( methodBraceCount != 0 || parseState == ParseState.PACKAGE_MEMBER) ) {

			msgStr = "Unbalanced braces";

			// Create error node and increment count
			results.incErrorCount();

			try {
				parentNode = (UMLTree.Node) nodeStack.peek();
				currentElement = parentNode.getElement();
			} catch (Exception e) {
				parentNode = null;
				currentElement = null;
			}

			messageElement = new UML.Message(msgStr, UML.Type.ERROR,
					currentElement, curTokenLine);
			insertAsNode(messageElement, curElementStartPos, parentNode);
		}


		if (results.getClassCount() == 0
				&& results.getInterfaceCount() == 0) {

			msgStr = "No package members found!";

			// Show only this error
			root.removeAllChildren();

			// Create error node and increment count
			results.setErrorCount(1);

			messageElement = new UML.Message(msgStr, UML.Type.ERROR,
					null, curTokenLine);
			insertAsNode(messageElement, curElementStartPos, root);

		} // if no package members found

		if (displayOpt.getAlphaSort())
		{
			root.alphaSort();
		}//end if alpha sort methods
		
		return results;

	} // parse(): JBrowseParser.Results


	//-------------------------------------------------------------------------
	private final UMLTree.Node insertAsNode(UML.Element e, int pos,
			UMLTree.Node parentNode)
	{
//%		JBrowse.log(12, this, "Inserting node: " + e.toString(displayOpt)
//%				+ "\n\tParent Node: " + parentNode);

		// Insert Node
		UMLTree.Node node = new UMLTree.Node(e);
		node.setPosition( ls.createPosition(pos) );

		// line below is faster than: treeModel.insertNodeInto(node, parentNode, index);
		parentNode.insert(node, parentNode.getChildCount() );

//%		JBrowse.log(10, this, "Inserted node: " + e.toString(displayOpt) );

		return node;

	} // insertAsNode(UML.Element, int, UMLTree.Node, int): UMLTree.Node

} // class JBrowseLineParser implements JBrowseParser


//=============================================================================
class ParseState
{
	public static final ParseState
		HEADER         = new ParseState("*HEADER********"),
		POST_HEADER    = new ParseState("*POST_HEADER***"),
		PACKAGE_MEMBER = new ParseState("*PACKAGE_MEMBER");

	// use POSSIBLE_VALUES to build an iterator
	public static final ParseState[] POSSIBLE_VALUES = {
		HEADER, POST_HEADER, PACKAGE_MEMBER };

	protected String label = null;

	//-------------------------------------------------------------------------
	private ParseState(String label)
	{
		this.label = label;
	}

	public boolean equals(Object o)
	{
		if (!(o instanceof ParseState)) return false;
		return (this == o);
	}

	public String toString() { return label.toString(); }

} // class ParseState


//=============================================================================
class ParseSubState
{
	public static final ParseSubState
	// HEADER
		PACKAGE       = new ParseSubState("-PACKAGE-------", ParseState.HEADER),
		POST_PACKAGE  = new ParseSubState("-POST_PACKAGE--", ParseState.HEADER),
		IMPORT        = new ParseSubState("-IMPORT--------", ParseState.HEADER),
	// POST_HEADER
		SCANNING      = new ParseSubState("-SCANNING------", ParseState.POST_HEADER),
	// PACKAGE_MEMBER
		POST_NAME     = new ParseSubState("-POST_NAME-----", ParseState.PACKAGE_MEMBER),
		BODY          = new ParseSubState("-BODY----------", ParseState.PACKAGE_MEMBER),
		OP_PARMS      = new ParseSubState("-OP_PARMS------", ParseState.PACKAGE_MEMBER),
		OP_POST_PARMS = new ParseSubState("-OP_POST_PARMS-", ParseState.PACKAGE_MEMBER),
		OP_BODY       = new ParseSubState("-OP_BODY-------", ParseState.PACKAGE_MEMBER);

	// use POSSIBLE_VALUES to build an iterator
	public static final ParseSubState[] POSSIBLE_VALUES = {
			PACKAGE, POST_PACKAGE, IMPORT, SCANNING, POST_NAME, BODY, 
			OP_PARMS, OP_POST_PARMS, OP_BODY };

	protected String label = null;
	protected ParseState parentState = null;

	//-------------------------------------------------------------------------
	private ParseSubState(String label, ParseState parentState)
	{
		this.label = label;
		this.parentState = parentState;
	}

	public ParseState getParentState() { return parentState; }

	public boolean equals(Object o)
	{
		if (!(o instanceof ParseSubState)) return false;
		return (this == o);
	}

	public String toString() { return label.toString(); }

} // class ParseSubState