jbrowselineparser.java

java写的多功能文件编辑器

									packageMemberLine);
							nodeStack.push( parentNode = insertAsNode(
									currentElement, packageMemberStartPos, parentNode) );

							// Check if TopLevel is OK
							if ( RWModifier.isPublic(mod) ) {
								
								if (! className.equals(expectedTopLevelName) ) {

									msgStr = "This top-level public " + eType + " must be defined in file " + className + ".java";

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

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

									if (results.getTopLevelPath() == null ) {
										// assume first public found is the intended anyway
										results.setTopLevelPath(parentNode.getPathFrom(root));
									}
								} else if (results.getTopLevelPath() == null ) {
									results.setTopLevelPath(parentNode.getPathFrom(root));

								} else {
									msgStr = "Can only have one top-level public";

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

									messageElement = new UML.Message(msgStr, UML.Type.ERROR,
											parentNode.getElement(), curTokenLine);
									insertAsNode(messageElement, curElementStartPos, parentNode);
								}
							} // Check if TopLevel is OK

						} else {
							currentElement = new UML.NestedMember(className, eType, mod,
									parentNode.getElement(), packageMemberLine);
							nodeStack.push( parentNode = insertAsNode(
									currentElement, packageMemberStartPos, parentNode) );
						}

						// Setup for next state, if required
						if ( token.equals(className) ) {
							parseState    = ParseState.PACKAGE_MEMBER;
							parseSubState = ParseSubState.POST_NAME;

							extendsFound = false;
							implementsFound = false;

							extendsOK = true;
							implementsOK = true;

						} else {
							msgStr = "Missing class/interface name.";

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

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

							// entering package member body
							parseState    = ParseState.PACKAGE_MEMBER;
							parseSubState = ParseSubState.BODY;
							curElementStartPos = -1;
							mod = 0;
							memberType = null;
							memberName = null;
						}
						continue;
					} // if (className != null)

					if (badFlag) {

						String lastMsgStr = "Expecting package member (class or interface).";

						if (!lastMsgStr.equals(msgStr) || lastTokenLine != curTokenLine ) {

							// i.e. log only if not already logged for this line.
							msgStr = lastMsgStr;

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

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

						} // suppress repeats

						badFlag = false;

					}
					
					if ("{".equals(token) ) {
						ts.skipUntil( "}" );
						curElementStartPos = -1;
					} // if - else if for POST_HEADER - SCANNING


				// ----------------------------
				// PACKAGE MEMBER - POST_NAME
				// ----------------------------
				} else if ( parseSubState == ParseSubState.POST_NAME ) {

					badFlag = false;

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

						if (!extendsOK || !implementsOK) {

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

							msgStr = "Bad tokens between member name and '{'.";

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

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

							// attempt to continue by falling into body
						}

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

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

						if (token.equals("extends")) {

							if (extendsFound || implementsFound) {
								badFlag = true;
							} else {
								extendsFound = true;
								extendsOK = false;
							}

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

							if ( RWModifier.isInterface(mod)
									|| implementsFound || !extendsOK) {

								badFlag = true;
							} else {
								implementsFound = true;
								implementsOK = false;
							}

						} else {
							// implements/extends what indentifier
							curElementStartPos = ls.getStartOffset() + curTokenPos;
							curTokenLine = ts.getCurrentLineNum();

							if (!extendsOK) {

								extendsOK = true;
								currentElement = new UML.Generalization(token, UML.Type.EXTENDS,
										parentNode.getElement(), curTokenLine);
								insertAsNode(currentElement, curElementStartPos, parentNode);

							} else if (!implementsOK) {

								implementsOK = true;
								currentElement = new UML.Generalization(token, UML.Type.IMPLEMENTS,
										parentNode.getElement(), curTokenLine);
								insertAsNode(currentElement, curElementStartPos, parentNode);

							} else {
								badFlag = true;
							}
						}


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

						// expect more implements interfaces
						if (implementsFound && implementsOK
								&& RWModifier.isClass(mod) ) {

							implementsOK = false;

						} else if (extendsFound && extendsOK
								&& RWModifier.isInterface(mod) ) {

							extendsOK = false;

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

					} else {
						// unexpected token
						badFlag = true;

					} // if-else if by token


					if (badFlag) {

						msgStr = "Error in 'extends'/'implements' phrase.";

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

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

						// attempt to continue by skipping to beginning of body
						boolean skipSuccess = ts.skipUntil( "{" );

						if (skipSuccess) {

							// Determine node type and insert
							if ( RWModifier.isInterface(mod) ) {
								eType = UML.Type.INTERFACE;
								results.incInterfaceCount();
							} else if (parentNode != root && !(RWModifier.isStatic(mod))) {
								eType = UML.Type.INNER_CLASS;
								results.incClassCount();
							} else {
								eType = UML.Type.CLASS;
								results.incClassCount();
							}

							if (parentNode == root) {
								currentElement = new UML.PackageMember(className, eType, mod,
										packageMemberLine);
							} else {
								currentElement = new UML.NestedMember(className, eType, mod,
										parentNode.getElement(), packageMemberLine);
							}

							// Create and insert class/interface node
							nodeStack.push( parentNode = insertAsNode(
									currentElement, packageMemberStartPos, parentNode) );

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

						} else {

							msgStr = "Expected '{' not found.";

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

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

							// skip and continue scanning
							curElementStartPos = -1;
							parseState    = ParseState.POST_HEADER;
							parseSubState = ParseSubState.SCANNING;
						}

					} // if (badFlag)

					// end of code block for PACKAGE MEMBER - POST_NAME


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

					if (curElementStartPos == -1) {
						// n.b. cannot re-set the others here, may be a list of attributes.
						curElementStartPos = ls.getStartOffset() + curTokenPos;
						badFlag = false;
						resetFlag = false;
					}

					// these tokens should put me in a method and lead me to its parms

					if ( Character.isJavaIdentifierStart(tokenStartChar) ) {

						if (memberType == null) {

							if (token.equals("abstract") ) {
								mod = RWModifier.setAbstract(mod);
							} else if (token.equals("final") ) {
								mod = RWModifier.setFinal(mod);

							} else if ( token.equals("class") ) {
								mod = RWModifier.setClass(mod);
								parseState = ParseState.POST_HEADER;
								parseSubState = parseSubState.SCANNING;
								className = null;

							} else if ( token.equals("interface") ) {
								mod = RWModifier.setInterface(mod);
								parseState = ParseState.POST_HEADER;
								parseSubState = parseSubState.SCANNING;
								className = null;

							} else if (token.equals("native") ) {
								mod = RWModifier.setNative(mod);
							} else if (token.equals("private") ) {
								mod = RWModifier.setPrivate(mod);
							} else if (token.equals("protected") ) {
								mod = RWModifier.setProtected(mod);
							} else if (token.equals("public") ) {
								mod = RWModifier.setPublic(mod);
							} else if (token.equals("static") ) {
								mod = RWModifier.setStatic(mod);
							} else if (token.equals("strictfp") ) {
								mod = RWModifier.setStrict(mod);
							} else if (token.equals("synchronized") ) {
								mod = RWModifier.setSynchronized(mod);
							} else if (token.equals("transient") ) { // attribute only
								mod = RWModifier.setTransient(mod);
							} else if (token.equals("volatile") ) {	 // attribute only
								mod = RWModifier.setVolatile(mod);

							} else {
								memberType = token;
							}

						} else if (memberName == null) {

							memberName = token;

						} else {

							msgStr = "Unexpected identifier after member name '" + memberName +"'";

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

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

							// attempt to continue by skipping to ";"
							boolean skipSuccess = ts.skipUntil( ";" );

							if (!skipSuccess) {

								msgStr = "Expected ';' not found.";

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

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

							}
							// Skip and continue
							curElementStartPos = -1;
							memberType = null;
							memberName = null;

						} // if (memberType == null) else if...


					} else if ( token.equals(";")
							||  token.equals("=")
							||  token.equals(",") ) {

						if ( memberType == null ) {

							if (token.equals(";") && mod == 0 ) {
								// assume empty statement
								curElementStartPos = -1;
								continue;
							}

							msgStr = "Expecting type & identifier for member.";


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

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

							// attempt to continue
							if (token.equals(";") ) {
								curElementStartPos = -1;
							}

						} else {
						
							// assume this is an attribute

							if ( memberName == null ) {

								msgStr = "Expecting type & identifier for attribute.";

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

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

								// attempt to continue as if name was specified
								memberName = MISSING_LABEL;