吾等前方绝无敌手

SNL语法分析器以及语法树的绘画

前几天做了语法分析器，，，最近才有时间发表出来

总共有四个包，12个类，

common包主要是公用的变量和公用类：

Enum（是枚举类型的类）

Error（表示错误的类）

Node（词法token节点）

Predict（predict集的数据结构）

SNLPredict（SNL的predict集）

production（产生式的数据结构）

SNLproduction（SNL的产生式集）

treeNode（语法树节点的数据结构）

lex包是用于词法分析的：

scanner（词法分析器）

main包就不解释了

parser包是用于语法分析的：

Parser（语法分析器）

drawTree（画树）

接下来就是代码了：

Enum.java

package common;

public interface Enum {
	public enum lexType{
		/* 簿记单词符号 */
	    ENDFILE,	ERROR,
		/* 保留字 */
	    PROGRAM,	 PROCEDURE,	    TYPE,	        VAR,		 IF,
		THEN,		 ELSE,		    FI,		        WHILE,		 DO,
		ENDWH,		 BEGIN,		    END,	        READ,		 WRITE,
		ARRAY,		 OF,		    RECORD,	        RETURN, 

		INTEGER,	 CHAR,
		/* 多字符单词符号 */
	    ID,			 INTC,		    CHARC,
	    /*特殊符号 */
		ASSIGN,		 EQ,		    LT,		        PLUS,		 MINUS,
		TIMES,		 OVER,		    LPAREN,	        RPAREN,		 DOT,
		COLON,		 SEMI,		    COMMA,	        LMIDPAREN,	 RMIDPAREN,
		UNDERANGE ; 
	}
	/*非终极符*/
	public enum nonTerminals{
		Program,     ProgramHead,   ProgramName,    DeclarePart, TypeDecpart,
		TypeDec,     TypeDecList,   TypeDecMore,    TypeId,      TypeDef,
		BaseType,    StructureType, ArrayType,      Low,         Top,
		RecType,     FieldDecList,  FieldDecMore,   IdList,      IdMore,
		VarDecpart,  VarDec,        VarDecList,     VarDecMore,  VarIdList,   VarIdMore,
		ProcDecpart, ProcDec,       ProcDecMore,    ProcName,    ParamList,   ProcDeclaration ,
		ParamDecList,ParamMore,     Param,          FormList,    FidMore,
		ProcDecPart, ProcBody,      ProgramBody,    StmList,     StmMore,     Stm,
		AssCall,     AssignmentRest,ConditionalStm, LoopStm,     InputStm,
		Invar,		 OutputStm,     ReturnStm,      CallStmRest, ActParamList,
		ActParamMore,RelExp,        OtherRelE,      Exp,         OtherTerm,
		Term,        OtherFactor,   Factor,         Variable,    VariMore,    FieldVar,
		FieldVarMore,CmpOp,         AddOp,          MultOp ;
	}
	public enum nodeKind {
		ProK ,  PheadK , TypeK , VarK , ProcDecK , StmLK , DecK , StmtK , ExpL ;
	}
	public enum decKind {
		ArrayK , CharK , IntegerK , RecordK , IdK ;
	}
	public enum stmtKind {
		IfK , WhileK , AssignK , ReadK , WriteK , CallK , ReturnK ;
	}
	public enum expKind {
		OpK , ConstK , VariK ; 
	}
	public enum varKind {
		IdV , ArrayMembV , FieldMembV ;
	}
	public enum expType {
		Void , Integer , Boolean ;
	}
	public enum paramType {
		ValParamType , VarparamType ; 
	}
}

Error.java:

package common;

public class Error {
	static int  Line ;
	static int Row;
	static int  ErrorType  ;
	static boolean  Flag ;
	public Error(){
		Line = 0 ; 
		Row  = 0 ;
		ErrorType = 0 ; 
		Flag = false ;
	}
	public static void printError() {
		if( ErrorType == 1 ) System.out.print( "词法错误" ) ; 
		else if( ErrorType == 2 ) System.out.print( "语法错误" ) ;
		System.out.println( "  行:" + Line + "  列: " + Row  ) ; 
	}
	public static void setLine( int line ) {
		Line = line ; 
	}
	public static void setRow( int row ) {
		Row = row ; 
	}
	public static void setErrorType( int type ) {
		ErrorType = type ;
	}
	public static void setFlag( boolean flag ) {
		Flag = flag ; 
	}
	public static int getLine() {
		return Line ;
	}
	public static int getRow()  {
		return Row  ;
	}
	public static int getErrorType() {
		return ErrorType ;
	}
	public static boolean getFlag() {
		return Flag ; 
	}
	public static void setError( int line , int row , int type ) {
		Line = line ; 
		Row  = row  ;
		ErrorType = type ;
		Flag = true    ;
	}
}

Node.java:

package common;

import common.Enum.*;

public class Node {
	String Data ;
	int    Line , Row ;
	lexType    type ;
	public Node(){
	}
	public String getData() {
		return Data;
	}
	public void setData(String data) {
		Data = data;
	}
	public int getLine() {
		return Line;
	}
	public void setLine(int line) {
		Line = line;
	}
	public int getRow() {
		return Row;
	}
	public void setRow(int row) {
		Row = row;
	}
	public lexType getType() {
		return type;
	}
	public void setType(lexType integer) {
		this.type = integer;
	}
}

predict.java:

package common;

public class Predict {
	int         predictNum ;
	Enum.lexType[] predict = new Enum.lexType[20] ;
	
	public Predict() {
		predictNum = 0 ; 
	}
	
	public void setPredict( Enum.lexType pre ) {
		predict[predictNum] = pre ;
		predictNum ++ ;
	}
	
	public int getPredictNum() {
		return predictNum ;
	}
	
	public Enum.lexType getPredict( int number ) {
		return predict[number] ;
	}
}

SNLPredict:

package common;

public class SNLpredict {
	public Predict[] predict = new Predict[105] ;
	public SNLpredict() {
		for( int i = 0 ; i <= 104 ; i ++ )
			predict[i] = new Predict() ;
		predict[1].setPredict( Enum.lexType.PROGRAM ) ;
		
		predict[2].setPredict( Enum.lexType.PROGRAM ) ;
		
		predict[3].setPredict( Enum.lexType.ID ) ;
		
		predict[4].setPredict( Enum.lexType.TYPE ) ; 			predict[4].setPredict( Enum.lexType.VAR ) ;
		predict[4].setPredict( Enum.lexType.PROCEDURE ) ;		predict[4].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[5].setPredict( Enum.lexType.VAR ) ;				predict[5].setPredict( Enum.lexType.PROCEDURE ) ;
		predict[5].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[6].setPredict( Enum.lexType.TYPE ) ;
		
		predict[7].setPredict( Enum.lexType.TYPE ) ;
		
		predict[8].setPredict( Enum.lexType.ID ) ;
		
		predict[9].setPredict( Enum.lexType.VAR ) ;				predict[9].setPredict( Enum.lexType.PROCEDURE ) ;
		predict[9].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[10].setPredict( Enum.lexType.ID ) ;
		
		predict[11].setPredict( Enum.lexType.ID ) ;
		
		predict[12].setPredict( Enum.lexType.INTEGER ) ;		predict[12].setPredict( Enum.lexType.CHAR ) ;
		
		predict[13].setPredict( Enum.lexType.ARRAY ) ;			predict[13].setPredict( Enum.lexType.RECORD ) ;
		
		predict[14].setPredict( Enum.lexType.ID ) ;
		
		predict[15].setPredict( Enum.lexType.INTEGER ) ;
		
		predict[16].setPredict( Enum.lexType.CHAR ) ;
		
		predict[17].setPredict( Enum.lexType.ARRAY ) ;
		
		predict[18].setPredict( Enum.lexType.RECORD ) ;
		
		predict[19].setPredict( Enum.lexType.ARRAY ) ;
		
		predict[20].setPredict( Enum.lexType.INTC ) ;
		
		predict[21].setPredict( Enum.lexType.INTC ) ;
		
		predict[22].setPredict( Enum.lexType.RECORD ) ;
		
		predict[23].setPredict( Enum.lexType.INTEGER ) ; 		predict[23].setPredict( Enum.lexType.CHAR ) ;
		
		predict[24].setPredict( Enum.lexType.ARRAY ) ;
		
		predict[25].setPredict( Enum.lexType.END ) ;
		
		predict[26].setPredict( Enum.lexType.INTEGER ) ;		predict[26].setPredict( Enum.lexType.CHAR ) ;
		predict[26].setPredict( Enum.lexType.ARRAY ) ;
		
		predict[27].setPredict( Enum.lexType.ID ) ;
		
		predict[28].setPredict( Enum.lexType.SEMI ) ;
		
		predict[29].setPredict( Enum.lexType.COMMA ) ;
		
		predict[30].setPredict( Enum.lexType.PROCEDURE ) ; 		predict[30].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[31].setPredict( Enum.lexType.VAR ) ;
		
		predict[32].setPredict( Enum.lexType.VAR ) ;
		
		predict[33].setPredict( Enum.lexType.INTEGER ) ;		predict[33].setPredict( Enum.lexType.CHAR ) ;
		predict[33].setPredict( Enum.lexType.ARRAY ) ;			predict[33].setPredict( Enum.lexType.RECORD ) ;
		predict[33].setPredict( Enum.lexType.ID ) ;
		
		predict[34].setPredict( Enum.lexType.PROCEDURE ) ;		predict[34].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[35].setPredict( Enum.lexType.INTEGER ) ;		predict[35].setPredict( Enum.lexType.CHAR ) ;
		predict[35].setPredict( Enum.lexType.ARRAY ) ;			predict[35].setPredict( Enum.lexType.RECORD ) ;
		predict[35].setPredict( Enum.lexType.ID ) ;
		
		predict[36].setPredict( Enum.lexType.ID ) ;
		
		predict[37].setPredict( Enum.lexType.SEMI ) ;
		
		predict[38].setPredict( Enum.lexType.COMMA ) ;
		
		predict[39].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[40].setPredict( Enum.lexType.PROCEDURE ) ;
		
		predict[41].setPredict( Enum.lexType.PROCEDURE ) ;
		
		predict[42].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[43].setPredict( Enum.lexType.PROCEDURE ) ;
		
		predict[44].setPredict( Enum.lexType.ID ) ;
		
		predict[45].setPredict( Enum.lexType.RPAREN ) ;
		
		predict[46].setPredict( Enum.lexType.INTEGER ) ;		predict[46].setPredict( Enum.lexType.CHAR ) ;
		predict[46].setPredict( Enum.lexType.ARRAY ) ;			predict[46].setPredict( Enum.lexType.RECORD ) ;
		predict[46].setPredict( Enum.lexType.ID	) ;				predict[46].setPredict( Enum.lexType.VAR ) ;
		
		predict[47].setPredict( Enum.lexType.INTEGER ) ;		predict[47].setPredict( Enum.lexType.CHAR ) ;
		predict[47].setPredict( Enum.lexType.ARRAY ) ;			predict[47].setPredict( Enum.lexType.RECORD ) ;
		predict[47].setPredict( Enum.lexType.ID	) ;				predict[47].setPredict( Enum.lexType.VAR ) ;
		
		predict[48].setPredict( Enum.lexType.RPAREN ) ;
		
		predict[49].setPredict( Enum.lexType.SEMI ) ;
		
		predict[50].setPredict( Enum.lexType.INTEGER ) ;		predict[50].setPredict( Enum.lexType.CHAR ) ;
		predict[50].setPredict( Enum.lexType.ARRAY ) ;			predict[50].setPredict( Enum.lexType.RECORD ) ;
		predict[50].setPredict( Enum.lexType.ID ) ;
		
		predict[51].setPredict( Enum.lexType.VAR ) ;
		
		predict[52].setPredict( Enum.lexType.ID ) ;
		
		predict[53].setPredict( Enum.lexType.SEMI ) ;			predict[53].setPredict( Enum.lexType.RPAREN ) ;
		
		predict[54].setPredict( Enum.lexType.COMMA ) ;
		
		predict[55].setPredict( Enum.lexType.TYPE ) ;			predict[55].setPredict( Enum.lexType.VAR ) ;
		predict[55].setPredict( Enum.lexType.PROCEDURE ) ;		predict[55].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[56].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[57].setPredict( Enum.lexType.BEGIN ) ;
		
		predict[58].setPredict( Enum.lexType.ID ) ;				predict[58].setPredict( Enum.lexType.IF ) ;
		predict[58].setPredict( Enum.lexType.WHILE ) ;			predict[58].setPredict( Enum.lexType.RETURN ) ;
		predict[58].setPredict( Enum.lexType.READ ) ;			predict[58].setPredict( Enum.lexType.WRITE ) ;
		predict[58].setPredict( Enum.lexType.END ) ;			predict[58].setPredict( Enum.lexType.SEMI ) ;
		
		predict[59].setPredict( Enum.lexType.ELSE ) ;			predict[59].setPredict( Enum.lexType.FI ) ;
		predict[59].setPredict( Enum.lexType.END ) ;			predict[59].setPredict( Enum.lexType.ENDWH ) ;
		
		predict[60].setPredict( Enum.lexType.SEMI ) ;	
		
		predict[61].setPredict( Enum.lexType.IF ) ;
		
		predict[62].setPredict( Enum.lexType.WHILE ) ;
		
		predict[63].setPredict( Enum.lexType.READ ) ;
		
		predict[64].setPredict( Enum.lexType.WRITE ) ;
		
		predict[65].setPredict( Enum.lexType.RETURN ) ;
		
		predict[66].setPredict( Enum.lexType.ID ) ;
		
		predict[67].setPredict( Enum.lexType.ASSIGN ) ;			predict[67].setPredict( Enum.lexType.DOT ) ;
		predict[67].setPredict( Enum.lexType.LMIDPAREN ) ;
		
		predict[68].setPredict( Enum.lexType.LPAREN ) ;
		
		predict[69].setPredict( Enum.lexType.LMIDPAREN ) ;		predict[69].setPredict( Enum.lexType.DOT ) ;
		predict[69].setPredict( Enum.lexType.ASSIGN ) ;
		
		predict[70].setPredict( Enum.lexType.IF ) ;
		
		predict[71].setPredict( Enum.lexType.WHILE ) ;
		
		predict[72].setPredict( Enum.lexType.READ ) ;
		
		predict[73].setPredict( Enum.lexType.ID ) ;
		
		predict[74].setPredict( Enum.lexType.WRITE ) ;
		
		predict[75].setPredict( Enum.lexType.RETURN ) ;
		
		predict[76].setPredict( Enum.lexType.LPAREN ) ;
		
		predict[77].setPredict( Enum.lexType.RPAREN ) ;
		
		predict[78].setPredict( Enum.lexType.LPAREN ) ;			predict[78].setPredict( Enum.lexType.INTC ) ;
		predict[78].setPredict( Enum.lexType.ID ) ;
		
		predict[79].setPredict( Enum.lexType.RPAREN ) ;
		
		predict[80].setPredict( Enum.lexType.COMMA ) ;
		
		predict[81].setPredict( Enum.lexType.LPAREN ) ;			predict[81].setPredict( Enum.lexType.INTC ) ;
		predict[81].setPredict( Enum.lexType.ID ) ;
		
		predict[82].setPredict( Enum.lexType.LT ) ;				predict[82].setPredict( Enum.lexType.EQ ) ;

		predict[83].setPredict( Enum.lexType.LPAREN ) ;			predict[83].setPredict( Enum.lexType.INTC ) ;
		predict[83].setPredict( Enum.lexType.ID ) ;
		
		predict[84].setPredict( Enum.lexType.LT ) ;				predict[84].setPredict( Enum.lexType.EQ ) ;
		predict[84].setPredict( Enum.lexType.RMIDPAREN ) ;		predict[84].setPredict( Enum.lexType.THEN ) ;
		predict[84].setPredict( Enum.lexType.ELSE ) ;			predict[84].setPredict( Enum.lexType.FI ) ;
		predict[84].setPredict( Enum.lexType.DO ) ;				predict[84].setPredict( Enum.lexType.ENDWH ) ;
		predict[84].setPredict( Enum.lexType.RPAREN ) ;			predict[84].setPredict( Enum.lexType.END ) ;
		predict[84].setPredict( Enum.lexType.SEMI ) ;			predict[84].setPredict( Enum.lexType.COMMA ) ;
		
		predict[85].setPredict( Enum.lexType.PLUS ) ;			predict[85].setPredict( Enum.lexType.MINUS ) ;
		
		predict[86].setPredict( Enum.lexType.LPAREN ) ;			predict[86].setPredict( Enum.lexType.INTC ) ;
		predict[86].setPredict( Enum.lexType.ID ) ;
		
		predict[87].setPredict( Enum.lexType.PLUS ) ;			predict[87].setPredict( Enum.lexType.MINUS ) ;
		predict[87].setPredict( Enum.lexType.LT ) ;				predict[87].setPredict( Enum.lexType.EQ ) ;
		predict[87].setPredict( Enum.lexType.RMIDPAREN ) ;		predict[87].setPredict( Enum.lexType.THEN ) ;
		predict[87].setPredict( Enum.lexType.ELSE ) ;			predict[87].setPredict( Enum.lexType.FI ) ;
		predict[87].setPredict( Enum.lexType.DO ) ;				predict[87].setPredict( Enum.lexType.ENDWH ) ;
		predict[87].setPredict( Enum.lexType.RPAREN ) ;			predict[87].setPredict( Enum.lexType.END ) ;
		predict[87].setPredict( Enum.lexType.SEMI ) ;			predict[87].setPredict( Enum.lexType.COMMA ) ;
		
		predict[88].setPredict( Enum.lexType.TIMES ) ;			predict[88].setPredict( Enum.lexType.OVER ) ;
		
		predict[89].setPredict( Enum.lexType.LPAREN ) ;		
		
		predict[90].setPredict( Enum.lexType.INTC ) ;
		
		predict[91].setPredict( Enum.lexType.ID ) ;
		
		predict[92].setPredict( Enum.lexType.ID ) ;
		
		predict[93].setPredict( Enum.lexType.ASSIGN ) ;			predict[93].setPredict( Enum.lexType.TIMES ) ;
		predict[93].setPredict( Enum.lexType.OVER ) ;			predict[93].setPredict( Enum.lexType.PLUS ) ;
		predict[93].setPredict( Enum.lexType.MINUS ) ;			predict[93].setPredict( Enum.lexType.LT ) ;
		predict[93].setPredict( Enum.lexType.EQ ) ;				predict[93].setPredict( Enum.lexType.THEN ) ;
		predict[93].setPredict( Enum.lexType.ELSE ) ;			predict[93].setPredict( Enum.lexType.FI ) ;
		predict[93].setPredict( Enum.lexType.DO ) ;				predict[93].setPredict( Enum.lexType.ENDWH ) ;
		predict[93].setPredict( Enum.lexType.RPAREN ) ;			predict[93].setPredict( Enum.lexType.END ) ;
		predict[93].setPredict( Enum.lexType.SEMI ) ;			predict[93].setPredict( Enum.lexType.COMMA ) ;
		predict[93].setPredict( Enum.lexType.RMIDPAREN ) ;
		
		predict[94].setPredict( Enum.lexType.LMIDPAREN ) ;
		
		predict[95].setPredict( Enum.lexType.DOT ) ;
		
		predict[96].setPredict( Enum.lexType.ID ) ;
		
		predict[97].setPredict( Enum.lexType.ASSIGN ) ;			predict[97].setPredict( Enum.lexType.TIMES ) ;
		predict[97].setPredict( Enum.lexType.OVER ) ;			predict[97].setPredict( Enum.lexType.PLUS ) ;
		predict[97].setPredict( Enum.lexType.MINUS ) ;			predict[97].setPredict( Enum.lexType.LT ) ;
		predict[97].setPredict( Enum.lexType.EQ ) ;				predict[97].setPredict( Enum.lexType.THEN ) ;
		predict[97].setPredict( Enum.lexType.ELSE ) ;			predict[97].setPredict( Enum.lexType.FI ) ;
		predict[97].setPredict( Enum.lexType.DO ) ;				predict[97].setPredict( Enum.lexType.ENDWH ) ;
		predict[97].setPredict( Enum.lexType.RPAREN ) ;			predict[97].setPredict( Enum.lexType.END ) ;
		predict[97].setPredict( Enum.lexType.SEMI ) ;			predict[97].setPredict( Enum.lexType.COMMA ) ;
		predict[97].setPredict( Enum.lexType.RMIDPAREN ) ;
		
		predict[98].setPredict( Enum.lexType.LMIDPAREN ) ;
		
		predict[99].setPredict( Enum.lexType.LT ) ;
		
		predict[100].setPredict( Enum.lexType.EQ ) ;
		
		predict[101].setPredict( Enum.lexType.PLUS ) ;
		
		predict[102].setPredict( Enum.lexType.MINUS ) ;
		
		predict[103].setPredict( Enum.lexType.TIMES ) ;
		
		predict[104].setPredict( Enum.lexType.OVER ) ;
	}
}

production.java:

package common;

public class Production {
	Enum.nonTerminals Head ;
	int productNum ; 
	class product {
		public int flag ;                 // 0表示终极符，1表示非终极符
		public Enum.nonTerminals nonterminals ;
		public Enum.lexType      terminals    ;
	}
	
	product[] Product = new product[10] ;
	
	public Production(){
		productNum = 0 ; 
	}
	public void setHead( Enum.nonTerminals head ) {
		Head = head ;
	}
	public void setProduction( Enum.nonTerminals nonterminal ){
		Product[productNum] = new product() ;
		Product[productNum].flag = 1 ;
		Product[productNum].nonterminals = nonterminal ; 
		productNum ++ ; 
	}
	public void setProduction( Enum.lexType  terminal ){
		Product[productNum] = new product() ; 
		Product[productNum].flag = 0 ;
		Product[productNum].terminals = terminal ;
		productNum ++ ;
	}
	public Enum.nonTerminals getHead(){
		return Head ;
	}
	public int getproductNum() {
		return productNum ;
	}
	public int getflag( int number ) {
		if( Product[number].flag == 1 ) return 1 ;
		else return 0 ;
	}
	public Enum.nonTerminals getProductNonterminal( int number ) {
		return Product[number].nonterminals ;
	}
	public Enum.lexType getProductTerminal( int number ) {
		return Product[number].terminals ;
	}
} ;

SNLProduction.java:

package common;

public class SNLproduct {
	public Production[] product = new Production[105] ;
	public SNLproduct() {
		for( int i = 0 ; i <= 104 ; i ++ )
			product[i] = new Production() ;
		product[1].setHead( Enum.nonTerminals.Program ) ;    			product[1].setProduction( Enum.nonTerminals.ProgramHead ) ;
		product[1].setProduction( Enum.nonTerminals.DeclarePart ) ;  	product[1].setProduction( Enum.nonTerminals.ProgramBody ) ;
		
		product[2].setHead( Enum.nonTerminals.ProgramHead ) ; 			product[2].setProduction( Enum.lexType.PROGRAM ) ;
		product[2].setProduction( Enum.nonTerminals.ProgramName ) ;
		
		product[3].setHead( Enum.nonTerminals.ProgramName ) ;			product[3].setProduction( Enum.lexType.ID ) ;
		
		product[4].setHead( Enum.nonTerminals.DeclarePart ) ;			product[4].setProduction( Enum.nonTerminals.TypeDecpart ) ;
		product[4].setProduction( Enum.nonTerminals.VarDecpart ) ;      product[4].setProduction( Enum.nonTerminals.ProcDecpart ) ;
		
		product[5].setHead( Enum.nonTerminals.TypeDecpart ) ;
		
		product[6].setHead( Enum.nonTerminals.TypeDecpart ) ;			product[6].setProduction( Enum.nonTerminals.TypeDec ) ;
		
		product[7].setHead( Enum.nonTerminals.TypeDec ) ;				product[7].setProduction( Enum.lexType.TYPE ) ;
		product[7].setProduction( Enum.nonTerminals.TypeDecList ) ;
		
		product[8].setHead( Enum.nonTerminals.TypeDecList ) ;			product[8].setProduction( Enum.nonTerminals.TypeId ) ;
		product[8].setProduction( Enum.lexType.EQ ) ;					product[8].setProduction( Enum.nonTerminals.TypeDef ) ;
		product[8].setProduction( Enum.lexType.SEMI ) ;					product[8].setProduction( Enum.nonTerminals.TypeDecMore ) ;
		
		product[9].setHead( Enum.nonTerminals.TypeDecMore ) ;			
		
		product[10].setHead( Enum.nonTerminals.TypeDecMore ) ; 			product[10].setProduction( Enum.nonTerminals.TypeDecList ) ;
		
		product[11].setHead( Enum.nonTerminals.TypeId ) ; 				product[11].setProduction( Enum.lexType.ID ) ;
		
		product[12].setHead( Enum.nonTerminals.TypeDef ) ;				product[12].setProduction( Enum.nonTerminals.BaseType ) ;
		
		product[13].setHead( Enum.nonTerminals.TypeDef ) ;				product[13].setProduction( Enum.nonTerminals.StructureType ) ;
		
		product[14].setHead( Enum.nonTerminals.TypeDef ) ;				product[14].setProduction( Enum.lexType.ID ) ;
		
		product[15].setHead( Enum.nonTerminals.BaseType ) ;				product[15].setProduction( Enum.lexType.INTEGER ) ;
		
		product[16].setHead( Enum.nonTerminals.BaseType ) ;				product[16].setProduction( Enum.lexType.CHAR ) ;
		
		product[17].setHead( Enum.nonTerminals.StructureType ) ;		product[17].setProduction( Enum.nonTerminals.ArrayType ) ;
		
		product[18].setHead( Enum.nonTerminals.StructureType ) ;		product[18].setProduction( Enum.nonTerminals.RecType ) ;
		
		product[19].setHead( Enum.nonTerminals.ArrayType ) ;			product[19].setProduction( Enum.lexType.ARRAY ) ;
		product[19].setProduction( Enum.lexType.LMIDPAREN ) ;			product[19].setProduction( Enum.nonTerminals.Low ) ;
		product[19].setProduction( Enum.lexType.UNDERANGE ) ;			product[19].setProduction( Enum.nonTerminals.Top ) ;
		product[19].setProduction( Enum.lexType.RMIDPAREN ) ;			product[19].setProduction( Enum.lexType.OF ) ;					
		product[19].setProduction( Enum.nonTerminals.BaseType ) ;
		
		product[20].setHead( Enum.nonTerminals.Low ) ;					product[20].setProduction( Enum.lexType.INTC ) ;
		
		product[21].setHead( Enum.nonTerminals.Top ) ;					product[21].setProduction( Enum.lexType.INTC ) ;
		
		product[22].setHead( Enum.nonTerminals.RecType ) ;				product[22].setProduction( Enum.lexType.RECORD ) ;
		product[22].setProduction( Enum.nonTerminals.FieldDecList ) ;	product[22].setProduction( Enum.lexType.END ) ;
		
		product[23].setHead( Enum.nonTerminals.FieldDecList ) ;			product[23].setProduction( Enum.nonTerminals.BaseType ) ;
		product[23].setProduction( Enum.nonTerminals.IdList ) ;			product[23].setProduction( Enum.lexType.SEMI ) ;
		product[23].setProduction( Enum.nonTerminals.FieldDecMore ) ;
		
		product[24].setHead( Enum.nonTerminals.FieldDecList ) ;			product[24].setProduction( Enum.nonTerminals.ArrayType ) ;
		product[24].setProduction( Enum.nonTerminals.IdList ) ;			product[24].setProduction( Enum.lexType.SEMI ) ;
		product[24].setProduction( Enum.nonTerminals.FieldDecMore ) ;
		
		product[25].setHead( Enum.nonTerminals.FieldDecMore ) ;
		
		product[26].setHead( Enum.nonTerminals.FieldDecMore ) ;			product[26].setProduction( Enum.nonTerminals.FieldDecList ) ;
		
		product[27].setHead( Enum.nonTerminals.IdList ) ;				product[27].setProduction( Enum.lexType.ID ) ;
		product[27].setProduction( Enum.nonTerminals.IdMore ) ;
		
		product[28].setHead( Enum.nonTerminals.IdMore ) ;
		
		product[29].setHead( Enum.nonTerminals.IdMore ) ;				product[29].setProduction( Enum.lexType.COMMA ) ;
		product[29].setProduction( Enum.nonTerminals.IdList ) ;
		
		product[30].setHead( Enum.nonTerminals.VarDecpart ) ;
		
		product[31].setHead( Enum.nonTerminals.VarDecpart ) ;			product[31].setProduction( Enum.nonTerminals.VarDec ) ;
		
		product[32].setHead( Enum.nonTerminals.VarDec ) ;				product[32].setProduction( Enum.lexType.VAR ) ;
		product[32].setProduction( Enum.nonTerminals.VarDecList ) ;
		
		product[33].setHead( Enum.nonTerminals.VarDecList ) ;			product[33].setProduction( Enum.nonTerminals.TypeDef ) ;
		product[33].setProduction( Enum.nonTerminals.VarIdList ) ;		product[33].setProduction( Enum.lexType.SEMI ) ;
		product[33].setProduction( Enum.nonTerminals.VarDecMore ) ;
		
		product[34].setHead( Enum.nonTerminals.VarDecMore ) ;
		
		product[35].setHead( Enum.nonTerminals.VarDecMore ) ;			product[35].setProduction( Enum.nonTerminals.VarDecList ) ;
		
		product[36].setHead( Enum.nonTerminals.VarIdList ) ;			product[36].setProduction( Enum.lexType.ID ) ;
		product[36].setProduction( Enum.nonTerminals.VarIdMore ) ;
		
		product[37].setHead( Enum.nonTerminals.VarIdMore ) ;
		
		product[38].setHead( Enum.nonTerminals.VarIdMore ) ;			product[38].setProduction( Enum.lexType.COMMA ) ;
		product[38].setProduction( Enum.nonTerminals.VarIdList ) ;
		
		product[39].setHead( Enum.nonTerminals.ProcDecpart ) ;			
		
		product[40].setHead( Enum.nonTerminals.ProcDecpart ) ;  		product[40].setProduction( Enum.nonTerminals.ProcDec ) ;
		
		product[41].setHead( Enum.nonTerminals.ProcDec ) ;				product[41].setProduction( Enum.lexType.PROCEDURE ) ;
		product[41].setProduction( Enum.nonTerminals.ProcName ) ;		product[41].setProduction( Enum.lexType.LPAREN ) ;
		product[41].setProduction( Enum.nonTerminals.ParamList ) ;		product[41].setProduction( Enum.lexType.RPAREN ) ;
		product[41].setProduction( Enum.lexType.SEMI ) ;				product[41].setProduction( Enum.nonTerminals.ProcDecPart ) ;
		product[41].setProduction( Enum.nonTerminals.ProcBody ) ;		product[41].setProduction( Enum.nonTerminals.ProcDecMore ) ;
		
		product[42].setHead( Enum.nonTerminals.ProcDecMore ) ;
		
		product[43].setHead( Enum.nonTerminals.ProcDecMore ) ;			product[43].setProduction( Enum.nonTerminals.ProcDec ) ;
		
		product[44].setHead( Enum.nonTerminals.ProcName ) ;				product[44].setProduction( Enum.lexType.ID ) ;
		
		product[45].setHead( Enum.nonTerminals.ParamList ) ;			
		
		product[46].setHead( Enum.nonTerminals.ParamList ) ;			product[46].setProduction( Enum.nonTerminals.ParamDecList ) ;
		
		product[47].setHead( Enum.nonTerminals.ParamDecList ) ;			product[47].setProduction( Enum.nonTerminals.Param ) ;
		product[47].setProduction( Enum.nonTerminals.ParamMore ) ;
		
		product[48].setHead( Enum.nonTerminals.ParamMore ) ;
		
		product[49].setHead( Enum.nonTerminals.ParamMore ) ;			product[49].setProduction( Enum.lexType.SEMI ) ;
		product[49].setProduction( Enum.nonTerminals.ParamDecList ) ;
		
		product[50].setHead( Enum.nonTerminals.Param ) ;				product[50].setProduction( Enum.nonTerminals.TypeDef ) ;
		product[50].setProduction( Enum.nonTerminals.FormList ) ;
		
		product[51].setHead( Enum.nonTerminals.Param ) ;				product[51].setProduction( Enum.lexType.VAR ) ;
		product[51].setProduction( Enum.nonTerminals.TypeDef ) ;		product[51].setProduction( Enum.nonTerminals.FormList ) ;
		
		product[52].setHead( Enum.nonTerminals.FormList ) ;				product[52].setProduction( Enum.lexType.ID ) ;
		product[52].setProduction( Enum.nonTerminals.FidMore ) ;
		
		product[53].setHead( Enum.nonTerminals.FidMore ) ;
		
		product[54].setHead( Enum.nonTerminals.FidMore ) ;				product[54].setProduction( Enum.lexType.COMMA ) ;
		product[54].setProduction( Enum.nonTerminals.FormList ) ;
		
		product[55].setHead( Enum.nonTerminals.ProcDecPart ) ;			product[55].setProduction( Enum.nonTerminals.DeclarePart ) ;
		
		product[56].setHead( Enum.nonTerminals.ProcBody ) ;				product[56].setProduction( Enum.nonTerminals.ProgramBody ) ;
		
		product[57].setHead( Enum.nonTerminals.ProgramBody ) ;			product[57].setProduction( Enum.lexType.BEGIN ) ;
		product[57].setProduction( Enum.nonTerminals.StmList ) ;		product[57].setProduction( Enum.lexType.END ) ;
		
		product[58].setHead( Enum.nonTerminals.StmList ) ;				product[58].setProduction( Enum.nonTerminals.Stm ) ;
		product[58].setProduction( Enum.nonTerminals.StmMore ) ;
		
		product[59].setHead( Enum.nonTerminals.StmMore ) ;
		
		product[60].setHead( Enum.nonTerminals.StmMore ) ;				product[60].setProduction( Enum.lexType.SEMI ) ;
		product[60].setProduction( Enum.nonTerminals.StmList ) ;
		
		product[61].setHead( Enum.nonTerminals.Stm ) ;					product[61].setProduction( Enum.nonTerminals.ConditionalStm ) ;
		
		product[62].setHead( Enum.nonTerminals.Stm ) ;					product[62].setProduction( Enum.nonTerminals.LoopStm ) ;
		
		product[63].setHead( Enum.nonTerminals.Stm ) ;					product[63].setProduction( Enum.nonTerminals.InputStm ) ;
		
		product[64].setHead( Enum.nonTerminals.Stm ) ;					product[64].setProduction( Enum.nonTerminals.OutputStm ) ;
		
		product[65].setHead( Enum.nonTerminals.Stm ) ;					product[65].setProduction( Enum.nonTerminals.ReturnStm ) ;
		
		product[66].setHead( Enum.nonTerminals.Stm ) ;					product[66].setProduction( Enum.lexType.ID ) ;
		product[66].setProduction( Enum.nonTerminals.AssCall ) ;
		
		product[67].setHead( Enum.nonTerminals.AssCall );				product[67].setProduction( Enum.nonTerminals.AssignmentRest ) ;
		
		product[68].setHead( Enum.nonTerminals.AssCall ) ; 				product[68].setProduction( Enum.nonTerminals.CallStmRest ) ;
		
		product[69].setHead( Enum.nonTerminals.AssignmentRest ) ;		product[69].setProduction( Enum.nonTerminals.VariMore ) ; 
		product[69].setProduction( Enum.lexType.ASSIGN ) ;				product[69].setProduction( Enum.nonTerminals.Exp ) ;
		
		product[70].setHead( Enum.nonTerminals.ConditionalStm ) ;		product[70].setProduction( Enum.lexType.IF ) ;
		product[70].setProduction( Enum.nonTerminals.RelExp ) ; 		product[70].setProduction( Enum.lexType.THEN ) ; 
		product[70].setProduction( Enum.nonTerminals.StmList ) ;		product[70].setProduction( Enum.lexType.ELSE ) ;
		product[70].setProduction( Enum.nonTerminals.StmList ) ;		product[70].setProduction( Enum.lexType.FI ) ;
		
		product[71].setHead( Enum.nonTerminals.LoopStm ) ;				product[71].setProduction( Enum.lexType.WHILE ) ;
		product[71].setProduction( Enum.nonTerminals.RelExp ) ;			product[71].setProduction( Enum.lexType.DO ) ;
		product[71].setProduction( Enum.nonTerminals.StmList ) ;		product[71].setProduction( Enum.lexType.ENDWH ) ;
		
		product[72].setHead( Enum.nonTerminals.InputStm ) ;				product[72].setProduction( Enum.lexType.READ ) ;
		product[72].setProduction( Enum.lexType.LPAREN ) ;				product[72].setProduction( Enum.nonTerminals.Invar ) ;
		product[72].setProduction( Enum.lexType.RPAREN ) ;
		
		product[73].setHead( Enum.nonTerminals.Invar ) ;				product[73].setProduction( Enum.lexType.ID ) ;
		
		product[74].setHead( Enum.nonTerminals.OutputStm ) ;			product[74].setProduction( Enum.lexType.WRITE ) ;
		product[74].setProduction( Enum.lexType.LPAREN ) ;				product[74].setProduction( Enum.nonTerminals.Exp ) ;
		product[74].setProduction( Enum.lexType.RPAREN ) ;
		
		product[75].setHead( Enum.nonTerminals.ReturnStm ) ;			product[75].setProduction( Enum.lexType.RETURN ) ;
		
		product[76].setHead( Enum.nonTerminals.CallStmRest ) ;			product[76].setProduction( Enum.lexType.LPAREN );
		product[76].setProduction( Enum.nonTerminals.ActParamList ) ;	product[76].setProduction( Enum.lexType.RPAREN ) ;
		
		product[77].setHead( Enum.nonTerminals.ActParamList ) ;	
		
		product[78].setHead( Enum.nonTerminals.ActParamList ) ;			product[78].setProduction( Enum.nonTerminals.Exp ) ;
		product[78].setProduction( Enum.nonTerminals.ActParamMore ) ;
		
		product[79].setHead( Enum.nonTerminals.ActParamMore ) ;	
		
		product[80].setHead( Enum.nonTerminals.ActParamMore ) ; 		product[80].setProduction( Enum.lexType.COMMA ) ;
		product[80].setProduction( Enum.nonTerminals.ActParamList ) ;
		
		product[81].setHead( Enum.nonTerminals.RelExp ) ;				product[81].setProduction( Enum.nonTerminals.Exp ) ;
		product[81].setProduction( Enum.nonTerminals.OtherRelE ) ;
		
		product[82].setHead( Enum.nonTerminals.OtherRelE ) ;			product[82].setProduction( Enum.nonTerminals.CmpOp ) ;
		product[82].setProduction( Enum.nonTerminals.Exp ) ;
		
		product[83].setHead( Enum.nonTerminals.Exp ) ;					product[83].setProduction( Enum.nonTerminals.Term ) ;
		product[83].setProduction( Enum.nonTerminals.OtherTerm ) ;
		
		product[84].setHead( Enum.nonTerminals.OtherTerm ) ;			
		
		product[85].setHead( Enum.nonTerminals.OtherTerm ) ;			product[85].setProduction( Enum.nonTerminals.AddOp ) ;
		product[85].setProduction( Enum.nonTerminals.Exp ) ;
		
		product[86].setHead( Enum.nonTerminals.Term ) ;					product[86].setProduction( Enum.nonTerminals.Factor ) ;
		product[86].setProduction( Enum.nonTerminals.OtherFactor ) ;
		
		product[87].setHead( Enum.nonTerminals.OtherFactor ) ;			
		
		product[88].setHead( Enum.nonTerminals.OtherFactor ) ;			product[88].setProduction( Enum.nonTerminals.MultOp ) ;
		product[88].setProduction( Enum.nonTerminals.Term ) ;
		
		product[89].setHead( Enum.nonTerminals.Factor ) ;				product[89].setProduction( Enum.lexType.LPAREN ) ;
		product[89].setProduction( Enum.nonTerminals.Exp ) ;			product[89].setProduction( Enum.lexType.RPAREN ) ;
		
		product[90].setHead( Enum.nonTerminals.Factor ) ;				product[90].setProduction( Enum.lexType.INTC ) ;
		
		product[91].setHead( Enum.nonTerminals.Factor ) ;				product[91].setProduction( Enum.nonTerminals.Variable ) ;
		
		product[92].setHead( Enum.nonTerminals.Variable ) ;				product[92].setProduction( Enum.lexType.ID ) ;
		product[92].setProduction( Enum.nonTerminals.VariMore ) ;
		
		product[93].setHead( Enum.nonTerminals.VariMore ) ;	
		
		product[94].setHead( Enum.nonTerminals.VariMore ) ;				product[94].setProduction( Enum.lexType.LMIDPAREN ) ;
		product[94].setProduction( Enum.nonTerminals.Exp ) ;			product[94].setProduction( Enum.lexType.RMIDPAREN ) ;
		
		product[95].setHead( Enum.nonTerminals.VariMore ) ;				product[95].setProduction( Enum.lexType.DOT ) ;
		product[95].setProduction( Enum.nonTerminals.FieldVar ) ;
		
		product[96].setHead( Enum.nonTerminals.FieldVar ) ;				product[96].setProduction( Enum.lexType.ID ) ;
		product[96].setProduction( Enum.nonTerminals.FieldVarMore ) ;
		
		product[97].setHead( Enum.nonTerminals.FieldVarMore ) ;
		
		product[98].setHead( Enum.nonTerminals.FieldVarMore ) ;			product[98].setProduction( Enum.lexType.LMIDPAREN ) ;
		product[98].setProduction( Enum.nonTerminals.Exp ) ;			product[98].setProduction( Enum.lexType.RMIDPAREN ) ;
		
		product[99].setHead( Enum.nonTerminals.CmpOp ) ;				product[99].setProduction( Enum.lexType.LT ) ;
		
		product[100].setHead( Enum.nonTerminals.CmpOp ) ;				product[100].setProduction( Enum.lexType.EQ ) ;
		
		product[101].setHead( Enum.nonTerminals.AddOp ) ;				product[101].setProduction( Enum.lexType.PLUS ) ;
		
		product[102].setHead( Enum.nonTerminals.AddOp ) ;				product[102].setProduction( Enum.lexType.MINUS ) ;
		
		product[103].setHead( Enum.nonTerminals.MultOp ) ;				product[103].setProduction( Enum.lexType.TIMES ) ;
		
		product[104].setHead( Enum.nonTerminals.MultOp ) ;				product[104].setProduction( Enum.lexType.OVER ) ;
	}
}

treeNode.java:

package common;

public  class treeNode {
	
	int childNum ; 
	treeNode[] child = new treeNode[10] ; 
	treeNode father ;
	
	int flag ;     // 0 表示叶子节点
	Enum.nonTerminals NonTerminal ;
	Enum.lexType Terminal ;
	String data ;
	
	int x , y , width , length ;
	
	public treeNode() {
		childNum = 0 ;
	}
	
	public void setChild( treeNode node ) {
		child[childNum] = new treeNode() ;
		child[childNum] = node ;
		childNum ++ ;
	}
	
	public void setFather( treeNode node ) {
		father = new treeNode() ;
		father = node ;
	}
	
	public void setflag( int FLAG ) {
		flag = FLAG ;
	}
	
	public void setData( String DATA ) {
		data = DATA ; 
	}
	
	public void setNonTerminal( Enum.nonTerminals nonTerminal ) {
		NonTerminal = nonTerminal ;
	}
	
	public void setTerminal( Enum.lexType terminal ) {
		Terminal = terminal ;
	}
	
	public int getchildNum() {
		return childNum ;
	}
	
	public treeNode getChild( int num ) {
		return child[num] ;
	}
	
	public treeNode getFather() {
		return father ;
	}
	
	public int getflag() {
		return flag ; 
	}
	
	public Enum.nonTerminals getNonTerminal() {
		return NonTerminal ; 
	}
	
	public Enum.lexType getTerminal() {
		return Terminal ; 
	}
	
	public String getData() {
		return data ; 
	}
	
	public void setX( int X ) {
		x = X ;
	}
	public int  getX() {
		return x ;
	}
	
	public void setY( int Y ) {
		y = Y ;
	}
	public int  getY() {
		return y ; 
	}
	
	public void setWidth( int Width ) {
		width = Width ;
	}
	public int  getWidth() {
		return width ;
	}
	
	public void setLength( int Length ) {
		length = Length ;
	}
	public int  getLength() {
		return length ;
	}
	
}

scanner.java:

/**********************/
/* auther:    lishicao*/
/* date  :    2013.3.7*/
/* lexical analyzer   */
/**********************/

package lex;

import java.io.*    ; 
import common.Enum  ;
import common.Enum.lexType;
import common.Node  ; 
import common.Error ;
import java.util.*  ;


public class scanner {
	
	static int line , row , cur ;
	static String Buffer ;
	//public static Error error = new Error() ;
	
	
	public scanner() {
		line = 1 ; 
		row = 1 ; 
		cur = 0 ; 
	}
	
	/************************************/
	/*传入文件地址(string)，读入源文件，返回string */
	/*       功能是将源文件读入Buffer中                             */
	/************************************/
	public static String readTxt( String filePath ) throws Exception {
		FileReader file = new FileReader( filePath ) ;
		BufferedReader reader = new BufferedReader( file ) ;
		String temp = "" ;
		while( reader.ready() ) {
			temp += reader.readLine() ;
			temp += '\n' ;
		}
		return temp ;
	}
	
	
	/************************************/
	/*  取得下一个非空字符，并将该字符的下标赋值给cur  */
	/*          如果到了文件结束返回‘\0’       */
	/************************************/
	public static char getNextChar() {
		int   i  ;
		char  ch = '\0' ;
		if( cur == Buffer.length() - 1 ) {
			ch = '\0' ;
			return ch ; 
		}
		for( i = cur ; i < Buffer.length() ; i ++ ) {
			if( Buffer.charAt( i ) == '\n' ) {
				line ++ ;
				row = 1 ;
			}
			else if( Buffer.charAt( i ) == ' ' ) row ++ ;
			else if( Buffer.charAt( i ) == '\t' ) row += 4 ;
			else break ;
		}
		if( i != Buffer.length() ) {
			ch = Buffer.charAt( i ) ;
		}
		else ch = '\0' ;
		cur = i ;
		return ch ;
	}
	
	
	/***********************************/
	/*	        	识别数字                                                 */
	/***********************************/
	public static String isNumber( char ch ){
		String res = "" ;
		int  temp = cur ; 
		while( Buffer.charAt( temp ) >= '0' && Buffer.charAt( temp ) <= '9' ){
			res += Buffer.charAt( temp ) ; 
			temp ++ ;
			row  ++ ;
		}
		if( ( Buffer.charAt( temp ) >= 'a' && Buffer.charAt( temp ) <= 'z' ) || ( Buffer.charAt( temp ) >= 'A' && Buffer.charAt( temp ) <= 'Z' ) )
			res = null ;
		cur = temp ;
		return res ; 
	}
	
	
	/***********************************/
	/*			识别标示符或者保留字                                    */
	/***********************************/
	public static String isName( char ch ){
		String res = "" ;
		int  temp = cur ; 
		while( ( Buffer.charAt( temp ) >= '0' && Buffer.charAt( temp ) <= '9' ) || ( Buffer.charAt( temp ) >= 'a' && Buffer.charAt( temp ) <= 'z' ) 
				|| ( Buffer.charAt( temp ) >= 'A' && Buffer.charAt( temp ) <= 'Z' ) ) {
			res += Buffer.charAt( temp ) ;
			temp ++ ;
			row  ++ ;
		}
		cur = temp ;
		return res ;
	}
	
	
	/***********************************/
	/*			识别具体是哪个保留字		   */
	/***********************************/
	public static lexType recognizeName( String name ){
		switch( name ) {
			case "program"   : return Enum.lexType.PROGRAM   ;
			case "type"      : return Enum.lexType.TYPE      ;
			case "var"       : return Enum.lexType.VAR       ;
			case "procedure" : return Enum.lexType.PROCEDURE ;
			case "begin"     : return Enum.lexType.BEGIN     ;
			case "end"		 : return Enum.lexType.END       ;
			case "array"	 : return Enum.lexType.ARRAY	 ;
			case "of"		 : return Enum.lexType.OF 		 ; 
			case "record"    : return Enum.lexType.RECORD    ;
			case "if"		 : return Enum.lexType.IF        ;
			case "then"		 : return Enum.lexType.THEN		 ; 
			case "else"		 : return Enum.lexType.ELSE 	 ;
			case "fi"		 : return Enum.lexType.FI		 ;
			case "while"	 : return Enum.lexType.WHILE	 ;
			case "do"		 : return Enum.lexType.DO		 ; 
			case "endwh"	 : return Enum.lexType.ENDWH	 ;
			case "read"		 : return Enum.lexType.READ		 ; 
			case "write"	 : return Enum.lexType.WRITE	 ; 
			case "return"	 : return Enum.lexType.RETURN	 ;
			case "integer"	 : return Enum.lexType.INTEGER	 ; 
			case "char"		 : return Enum.lexType.CHAR		 ;
			default          : return Enum.lexType.ID		 ; 		
		} 
	}
	
	
	/***********************************/
	/*        识别该字符具体是哪个符号                                  */
	/***********************************/
	public static lexType recognizeSymbol( char symbol ) {
		switch( symbol ) {
			case '+'		 : return Enum.lexType.PLUS		 ; 
			case '-'		 : return Enum.lexType.MINUS	 ; 
			case '*'		 : return Enum.lexType.TIMES	 ;
			case '/'		 : return Enum.lexType.OVER		 ;
			case '('		 : return Enum.lexType.LPAREN	 ; 
			case ')'		 : return Enum.lexType.RPAREN	 ;
			case '.'		 : return Enum.lexType.DOT		 ; 
			case '['		 : return Enum.lexType.LMIDPAREN ;
			case ']'		 : return Enum.lexType.RMIDPAREN ; 
			case ';'		 : return Enum.lexType.SEMI		 ; 
			case ':'		 : return Enum.lexType.COLON	 ; 
			case ','		 : return Enum.lexType.COMMA	 ; 
			case '<'		 : return Enum.lexType.LT		 ; 
			case '='		 : return Enum.lexType.EQ		 ; 
			case '\''		 : return Enum.lexType.CHARC	 ;
			case '\0' 		 : return Enum.lexType.ENDFILE	 ;
		}
		return null ;
	}
	
	
	/************************************/
	/*         得到下一个 token             */
	/************************************/
	public static Node getNextToken() {
		Node now = new Node() ;
		char c ;
		c = getNextChar() ;
		if( c == '\0' ) return null ;
		now.setLine( line ) ;
		now.setRow(  row  ) ;
		if( c >= '0' && c <= '9' ){
			String temp = isNumber( c ) ;
			if( temp != null ) {
				now.setData( temp ) ;
				now.setType( Enum.lexType.INTC ) ;
			}
			else {
				now = null ;
				Error.setError( line , row , 1 ) ;
			}
		}
		else if( ( c >= 'a' && c<= 'z' ) || ( c >= 'A' && c <= 'Z' ) ){
			String temp = isName( c ) ;
			if( temp != null ) now.setData( temp ) ;
			else now = null ;
			now.setType( recognizeName( temp ) ) ;
		}
		else if( c == '{' ) {
			int  i ;
			int  num = 1 ;
			for( i = cur + 1 ; i < Buffer.length() ; i ++ ) {
				if( Buffer.charAt( i ) == '{' ) num ++ ;
				else if( Buffer.charAt( i ) == '}' ) num -- ;
				if( Buffer.charAt( i ) == '\n' ) {
					line ++ ;
					row = 1 ;
				}
				else if( Buffer.charAt( i ) == '\t' ) row += 4 ;
				else row ++ ;
				if( num == 0 ) break ;
			}
			if( num != 0 ) {
				cur = i ; 
				Error.setError( line , row , 1 ) ;
			}
			else cur = i + 1 ;
			now.setData( null ) ;
		}
		else{
			if( c == ':' && Buffer.charAt( cur + 1 ) == '=' ) {
				now.setData( ":=" ) ;
				now.setType( Enum.lexType.ASSIGN ) ;
				cur += 2 ; row += 2 ;
			}
			else if( c == '.' && Buffer.charAt( cur + 1 ) == '.' ) {
				now.setData( ".." ) ;
				now.setType( Enum.lexType.UNDERANGE ) ;
				cur += 2 ; row += 2 ; 
			}
			else {
				String temp = new String() ;
				temp += c ;
				now.setType( recognizeSymbol( c ) ) ;
				now.setData( temp ) ;
				if( now.getType() == null ) {
					Error.setError( line , row , 1) ;
				}
				cur ++ ; row ++ ;
			}
		}
		return now ;
	}


	/************************************/
	/*        用String传入源文件地址                                  */
	/*        返回一个链表，就是token链                             */
	/************************************/
	public ArrayList< Node > getTokenList( String filePath ) throws Exception {
		Buffer = readTxt( filePath ) ;
		ArrayList< Node > TokenList = new ArrayList < Node > () ;
		while( true ) {
			Node temp = new Node () ;
			temp = getNextToken() ;
			if( temp == null ){
				Node tmp = new Node() ;
				tmp.setType( lexType.ENDFILE ) ;
				tmp.setLine( line + 1 ) ;
				tmp.setRow( 0 ) ;
				TokenList.add( tmp ) ;
				break ;
			}
			if( temp.getData() == null ) continue ; 
			if( Error.getFlag() ) break ; 
			TokenList.add( temp ) ;
		}
		return TokenList ;
	}

}

Parser.java:

package parser;

import java.util.*;

import  lex.scanner  ; 
import  common.* ;
import  common.Enum  ;
import  common.Error ;

public class Parser {
	
	static SNLproduct Product = new SNLproduct() ;
	static SNLpredict Predict = new SNLpredict() ;
	static scanner Scanner = new scanner() ;
	static ArrayList < Node > TokenList = new ArrayList< Node > () ;
	static int cur ;

	public Parser() {
		cur = 0 ; 
	}
	
	
	/*****************/
	/*递归地匹配一个非终极符*/
	/*****************/
	public static treeNode match( Enum.nonTerminals NonTerminal , treeNode father ) {
		
		int  i , j , choose = -1 ;
		treeNode root = new treeNode() ;
		Enum.nonTerminals temp ;
		Enum.lexType curLex = TokenList.get(cur).getType() ;
			
		root.setflag( 1 ) ;
		root.setNonTerminal( NonTerminal ) ;
		root.setFather( father ) ;
		
		for( i = 1 ; i <= 104 ; i ++ ) {
			int flag = 0 ; 
			temp = Product.product[i].getHead() ;
			for( j = 0 ; j < Predict.predict[i].getPredictNum() ; j ++ ) {
				if( curLex == Predict.predict[i].getPredict( j ) ) {
					flag = 1 ; 
					break ;
				}
			}
			if(  flag == 1 && temp == NonTerminal ) {
				choose = i ; 
				break ;
			}
		}
		
		if( choose == -1 ) {
			Error.setError( TokenList.get(cur).getLine() , TokenList.get(cur).getRow() , 2 ) ;
			return null ;
		}
		else {
			for( i = 0 ; i < Product.product[choose].getproductNum() ; i ++ ) {
				if( Product.product[choose].getflag( i ) == 0 ) {
					treeNode leaf = new treeNode() ;
					leaf.setFather( father ) ;
					leaf.setflag( 0 ) ;
					leaf.setTerminal( Product.product[choose].getProductTerminal( i ) ) ;
					leaf.setData( TokenList.get( cur ).getData() ) ;
					root.setChild( leaf ) ;
					cur ++ ;
				}
				else {
					treeNode child ;
					Enum.nonTerminals NonTerminals = Product.product[choose].getProductNonterminal(i) ;
					child = match( NonTerminals , root ) ;
					root.setChild( child ) ;
				}
			}
		}
		
		return root ; 
	}
	
	
	/*********************/
	/*得到一个语法分析树，返回树根*/
	/*********************/
	public static treeNode getTree( String filePath ) throws Exception {
		
		TokenList = Scanner.getTokenList( filePath ) ;
		
		if( Error.getFlag() == true ) {
			return null ;
		}
		else {
			treeNode root = new treeNode() ;
			cur = 0 ;
			root = match( Enum.nonTerminals.Program , root ) ;
			if( TokenList.get(cur).getType() != Enum.lexType.ENDFILE ){
				Error.setError( TokenList.get(cur).getLine() , TokenList.get(cur).getRow() , 2 ) ;
			}
			if( Error.getFlag() == true ) {
				Error.printError() ;
				return null ;
			}
			return root ; 
		}
	}
}

drawTree.java:

package parser;

import common.treeNode;
import javax.swing.* ;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics ;

public class drawTree extends JFrame {
	
	static int  X ;
	static int  Space = 30 ;
	static int  Width , High ;
	static NewPanel Panel ;
	
	public static void main( String[] args ) throws Exception {
		
		treeNode root = new treeNode() ;	
		
		Parser parser = new Parser() ;
		
		root = parser.getTree( "source.txt" ) ;
		
		drawtree( root ) ;
	}
	
	public  drawTree() {
		Panel = new NewPanel() ;
		Panel.setPreferredSize( new Dimension( Width , High ) ) ;
		JScrollPane pane = new JScrollPane( Panel );
		add( pane ) ;
	}
	
	public  static int getTreeInf( treeNode root , int Y ) {
		int  temp , Length , width = 0 ;			
		String str = "" ;
		
		if( root.getflag() == 0 || ( root.getchildNum() == 0 ) ) {
			if( root.getflag() == 0 ) str += root.getData() ;
			else str += root.getNonTerminal() ;
			Length = str.length() * 8 ;
			width = Length + Space ;
			root.setLength( Length ) ;
			root.setWidth( width ) ;
			root.setX( X ) ;
			root.setY( Y ) ;
			X += width ;
		}
		else {
			str += root.getNonTerminal() ;
			Length = str.length() * 8 ;
			root.setLength( Length ) ;
			root.setY( Y ) ;
			temp = X ;
			for( int i = 0 ; i < root.getchildNum() ; i ++ ) {
				width += getTreeInf( root.getChild( i ) , Y + 150 ) ;
			}
			root.setX( temp + width / 2 - Length / 2 ) ;
			if( width < Length ) {
				width = Length / 2 + width / 2 ;
				X += Length - width + Space ;
			}
			root.setWidth( width ) ;
			
		}
		return width ;
	}
	
	public  static void drawtree( treeNode root ) {
		X = 20 ;
		High = getTreeInf( root , 20 ) ;
		Width = X ;
		Panel.Root = root ;
		
		drawTree frame = new drawTree() ;
		frame.setTitle( "语法分析树" ) ;
		frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ) ;
		frame.setSize( 800 , 600 ) ;
		frame.setVisible( true ) ;
	}
}

class NewPanel extends JLabel {
	
	public static treeNode Root ;
	
	public void draw( treeNode root , Graphics g ) {
		g.drawRect( root.getX() - 3 , root.getY() - 15 , root.getLength() + 1 , 20 ) ;
		if( root.getflag() == 0 ) {
			g.drawString( root.getData() , root.getX() , root.getY() ) ;
		}
		else {
			g.drawString( "" + root.getNonTerminal() , root.getX() , root.getY() ) ;
			if( root.getchildNum() != 0 ) {
				for( int i = 0 ; i < root.getchildNum() ; i ++ ) {
					g.drawLine( root.getX() + root.getLength() / 2 , root.getY() + 5  , root.getChild(i).getX() + root.getChild(i).getLength() / 2 , root.getChild(i).getY() - 15 ) ;
					draw( root.getChild( i ) , g ) ;
				}
			}
		}
	}
	
	public void paint( Graphics g ) {
		super.paint( g ) ;
		g.setColor( Color.white ) ;
		g.fillRect(0, 0, this.getWidth(), this.getHeight());
		g.setColor( Color.black ) ;
		draw( Root , g ) ;
	}
}

== 好冗长的代码

你可能感兴趣的:(风雨飘摇路)

孤独的守望者崩塌灬信仰
今天的我突然想提笔写点什么，但却又不知从何写起，那就随便写点什么吧。你有没有发现，突然有那么一瞬间，仿佛整个世界都窒息了，静止了。你会觉得有点怅然若失，像过了几个世纪那么漫长。图片发自App我也不知道你是不是，偶尔也有这样的感觉，想找个人聊聊天，却觉得有些心事不知道该说给谁听，通讯列表几十页，微信好友几百个，越翻反而越觉得孤独深重。尤其是当你一个人出去旅游的时候，这种感觉尤为强烈。在青岛的时候，路
斑驳疏影之《武当印象》航海家_c9db
斑驳疏影之《武当印象》作者蒋兴国某年某月15日，约几个朋友前往湖北十堰市，来到武当山。购票，换乘，到南岩，开始了登武当之旅。下车才知天气清冷，凉气袭人。有人选择加衣，有人就地购买透明雨衣既防雨又保暖，我则选择加大运动量预热。满心一路小跑上山的，可是刚过几十米的乌鸦岭，眼前的路哪里是登山啊，分明是一道十分陡峭的深不可测的下山之路。坡陡，梯滑，已露险峻。但眼前景色不错，黛黒色山峦上，青树发芽，点缀着醒
我的第二个长沙湘马 - 草稿策划运营I周长胜
4.21长沙的第2次城市湘江马拉松。海之言华谊小镇，湘江马拉松。图片发自App这是我第2个非常准备充分的湘江马拉松，在这次马拉松的，总距离是12公里。距离从贺龙体育馆到橘子洲头。一路风景非常美好。报名人数达到5000人。4月21下着小雨，约好的三个小伙伴一起跑，在集合处碰到了。带着我的后勤队长，武哥图片发自App，帮我拿着东西。早上5:50起床，6:10点吃了早点，出发，在这个过程我有用营养品，氮
一堆零食爱生活的小吴老师
又是被班上的娃们感动的一天晚饭时因为要给十几个学生下载志愿汇错过了打饭时间上完两节晚自习回到办公室看到我的办公桌被零食“占领”了还有一杯晾到刚好能喝的水那一刻真是被感动了感动于孩子们的细心与关心平时我对学生特别严格作业书写，读书音量，课本摆放，墩布放置，甚至宿舍的鞋都要鞋跟朝外排成一条直线学生从开始的不习惯到慢慢接受再到养成良好的习惯这个过程真是酸甜苦辣咸五味皆俱一路走来慢慢走进彼此的心里便有了更
【RK3576】【Android14】摄像头&MIPI开发调试
获取更多相关的【RK3576】【Android14】驱动开发，可收藏系列博文，持续更新中：【RK3576】Android14驱动开发实战指南简介RK3576支持摄像头相关功能：MIPIDCPHYCSIRX：一路4LaneDPHY或者一路3TriosMIPICPHY信号输入，通过80pin座子接入。MIPIDPHYCSIRX：两路4LaneDPHY信号输入，均支持可拆分成2x2Lane，通过80pi
2019.12.28 星期六晴陪孩子成长第五十九篇可可儿kker
昨晚姐姐特激动，因为今天要去参加小记者，第一次参加，老激动了，以前礼拜五咋滴也得十点睡觉，这还不到九点就说去睡觉……开心的……今早七点起床，姐姐就把该准备的东西都准备好了，放在门口桌子上，洗漱完后吃饭，八点十五就出家门，我们去民德校区集合，激动毁啦……中午十一点接姐姐，姐姐开心的一路说啊：妈妈，今天老师讲课了，问谁做小记者的代表，我举手了，老师夸奖我了，老师还给我们布置了作业，关于过年的，采访奶奶
桃花源里的狼与羊苏小步
【壹●阿丑】有一小溪，溪边有一个巨大的磐石，阻断了大部分的船只，普通人往下瞧只得见一片片的竹林。没多少人发现，随着小溪流下去约七八里路就有一座小山，人若沿着小山走过去，约一里路就会出现一大片桃花林，桃花林里面是一大片草原，草原里住着一群羊，这些羊群世代居住在此、从来没有离开过这片土地。但如果你往羊群里细看，还会发现有一个头部宽阔、耳朵呈三角形的其他动物，小羊们都称它为“阿丑”。“阿丑”没有父母，村
想你想飞的树不如草
想你，空气中好像都是你的气息。一回头，都是虚无。。想你，在那孤寂的梦里，曾今的心动，变成了如今的心痛。想你，曾今的年少，不懂情的青涩，都化成了美好的回忆。想你，望望流云，聚合分离，。那不舍却必须舍的情绪。哦，原来你不在那里。哦，原来我们已经偏离了轨迹。哦，只是一起走过一段路，何必把怀念弄得比经过还长。哦，春雨淅沥沥。
第十四天脱变钟净意
2018年5月4日今天早上大脑一直想着早起，3点钟就醒了看了下手机，又睡了下4点钟醒来开始喝阴阳水，喝完后开始做吐纳300个，外面在下雨就在家里做很热，就到了外面去做。背部在发热。又继续做了200个画龙骨，能听见背部脊柱一节节的响。海螺做了1000个。鹿回头做了21个戌狗10分钟。在小区怕影响他人，就没有做哼哈功。感恩每天自己的精进，感恩老师们的监督，感恩一路传承的所有老师。
随笔一篇暴君也想做女侠
今天有心事，无精打采的走出万源街地铁站，突然听到好像有人唱歌，而且唱的很有带感。抬头，就是他了，一个大高个的黑人。他穿着藏蓝色大衣，衣服半敞开，很长直到脚脖子，双手插兜，头戴一顶帽子，帽子也是藏蓝色。他微微低着头，只顾往前走，不看路，也不看人，脖子有点抽动，嘴巴一开一合。我没太看清他有没有戴耳机，但他忘情的样子，似乎周边跟他无关。也确实，他和周围的一切都不一样。我每天往返亦庄线，也许是从东二环到南
《一路向前》：从星巴克一天内同时关闭7100家门店，读懂企业为何走向倒闭英木子
人的一生中，最光辉的一天并非是功成名就那天，而是从悲叹与绝望中产生对人生的挑战，以勇敢迈向意志那天。——居斯塔夫·福楼拜以前总觉得这句话很不妥，我认为一个人只有在功成名就时才是光辉的，当身处绝望中，哪还有光辉可言，没想到，深感绝望的我，却是用这句话来拯救自己、获取力量。回想这些年来，我日以继夜地忙碌，只为有一天能出人头地，总的来说，老天爷对我还是很眷顾的，经过一番打拼，有了自己的公司，而且发展速度
2022-08-19 晴 21.35 婆家远方有颗星
昨晚凌晨1点被叫起来去做核酸……我是有起床气的人。所以很是郁闷。特别是1岁两个月的小小宝也需要去。宝爸让我先换衣服，说是工作人员在等，只剩下我们了。我快快的换完衣服。宝爸则是用抱被包着小小宝，打算直接把她抱起来。不出意料，小小宝醒了，但她没有哭。做核酸的地点是在村口，距离不是很远。我们也就没开车，打算走下去。一路上碰到了好几个做完核酸回来的人。小小宝第一次走夜路，很是兴奋。时不时地还指指天空中朦胧
开心一笑青儿小语
今天早上到路口打车，焦急等待中发现：咦，对面的出租车就没有直直开过来的，都是左转弯，掉头走了，远远的几个警察就站在路口，怎么回事，有事故，也不像呀。我赶快问身边的一位男士：你看，那边的车怎么就没有到咱们这边来的?他也被我说了个癔症，我正想走到路对面打车，这时见有车向我们这个方向驶来，我兴奋地说：来了，来了!他也打车，问了一下，我俩顺路，于是一前一后坐上了车。到车上后，我突然反应过来，刚才指示灯提示
【日记星球第196篇】——骑行蟠龙湖神秘园的简书
2020年6月14日星期日图片发自App时过半年才开始今年的第一次跟队骑行，选了集合点离家最近路程也最短的逍遥游蟠龙湖之行，往返60公里。因为天热又是很多队友初次恢复骑行，领队这次没有发挥他的正常领骑速度，去程基本保持匀速25-26左右，居然我也混迹第一队里全程跟上，并且没有感觉累。看来每周一到两次的跑步虽然慢速，还是起到锻炼作用。由于路程太近，到蟠龙湖才十点多，部分骑友继续骑向上面的蟠龙湖小天路
要写……就不能只写…… 鹿缘
要写夜，就不能只写夜。要写月明，写星稀，写北斗横直河汉纵横。要写梧桐缺处明、空庭风易入。写望钟声客船，写叹抱影无眠，写床前一缕月光的悲凉与凄切。写自问归期未有期，空把思念相寄，写万家灯火，却照不清来时的路，何夜无月、何夜无风，悄然便把离人浸透，只等一梦到白昼。
日更第一百八十八天清幽励志文苑
图片发自App日子不知觉的流逝着，生活在闹心与和解中过着，每日闲暇之余总是会抽出点时间来上看看。涂鸦几笔，记录光阴，留下足迹，最初也许是为日更而更，但后来就已成为习惯，没有目的，只是想写，想发表下字符。再这里几乎不怎么和文友们互动，只是随心而看，每一篇点赞过得文章都是用心阅读厚的赞赏。也很是感谢简友们的关注品读赏阅，你们的每一次赞赏都是对清幽的鼓励，感谢一路有你们同行，晚安，好梦，简友们！
坚持分享第181天。《捋一把春光》刘乐丹的
偶遇一幽处：下午放学，太阳还高，外面一片明媚。遂骑上电动车，前面带个娃，后面带个娃，一路往乡下驶去。行约二十分钟，遇见一个岔路口，拐了进去，见一派田园景象。一条土路蜿蜒，路旁草地上几只鸡悠闲惬意地啄食，不远处农家废弃的瓦房掩映在绿丛之中。恍惚之间仿佛隔了数十年。小朋友高兴地说：妈妈这里适合野餐！确实，这是个适合野餐的地方。图片发自App闻一缕芬芳路两旁长满了槐树，此时正是槐树开花的时节。已经开开的
归途昆悠
回家的路即长非长，即难非难。开阔胸怀：何处不是你的家园，何处不是你的身影。只有一步是相反的，那一步可能是当初迈出的第一步：你曾犹豫不决，曾怀疑自己所做的一切都是徒劳的，换取的是一连串的失败。你也曾不想平凡，曾幻想着拥有这一切，以为会一直守护在心爱的人身边。你曾说过他人说出的话，那曾是自己的模样，用热血撒下并含泪说出的誓言。你却不知“命由己造相由心生”对每一个人的深刻含义：世界是由孤独与琐碎组成的，
我们大多在食用二次知识――论知识的阶级性 Yo有灵L0
不论是《美丽新世界》，还是《未来简史》，对人类未来的预计都没有很美好。这其中包含了太多集权的观点。即：人类的绝大多数资源被极少数人所掌控，而绝大多数人沦为平庸。在《美丽新世界》里，阶级的划分直接由人为控制出生来决定；在《未来简史》里，当人们把越来越多的事情交给算法去处理之后，人类自身则降至被动的地位。这些看起来和知识不搭边？不，知识这条路，竟然也存在着阶级划分。这种阶级划分，有自身的因素，也有环境
BGP服务器该如何处理不同的路由策略？ wanhengidc 服务器运维
BGP（边界网关协议）是现在互联网社会中的重要基石，主要功能是在不同的自治系统之间交换路由信息，为了能够保障数据流畅稳定的传输，BGP服务器需要对于各种路由策略进行灵活的处理，那么对于不同的路由策略BGP服务器该怎样进行处理呢？BGP服务器在运行的过程中，在选择最佳的路由路径时会考虑到多个属性，BGP会优先选择具有最高本地优先级的路由，当多个路由都具有相同的优先级，则会优先选择经过最少自治系统的路
再给孙翔一年，他能够得着巅峰时期的韩文清吗？颚之巨人马赛尔
在动漫中，孙翔虽然出场次数不多，但存在感一直很强，让别人不得不注意到他。文/颚之巨人马赛尔如果孙翔没有足够的实力，他这般狂傲，早就被人黑得爬不起来了。应该说，孙翔确实有自傲的资本，不说别的，光是带着越云这支弱旅一路逆风翻盘，就不是一般人能做得到的。他足够年轻，上升劲头非常猛，外形也很不错，至少是能让各大战队手握主动权的高层们眼前一亮的人物。如果他不是被恰好被陶轩挖走、如果他没有阴错阳差地踏入嘉王朝
“趟着走”还是换种方式水墨烟岚
如果把家长教育孩子比作走路一种方式，那么“趟着走”也是其中的一种。谁都不知道要翻越一座山峰会遇到什么人、碰到什么事、经过什么样的路，承受什么样的跌倒之痛，甚至会有什么样的狂风暴雨、什么样的断桥低谷。但是人生总要前行，无论是否愿意，不管准备是否充足。“趟着走”，一边低头拉车，一边抬头看路。低头拉车会很累，但再累也得脚踏实地；抬头看路就能看到希望，探视到目标，但得把眼下的事做好。所有的物质享受都会成为
爱自己 Kiss14
这世上没有永世的爱情更没有一横不变的亲情也没有不经维护的友情哪怕是自己也是在经历之后轻轻的改变着所以每一个阶段的自己都是宝贵的自己不爱护自己又能指望谁爱护自己世间万物都是有蝴蝶效应的人间俗物也是丝丝缕缕的生活教会了我们天真烂漫单纯善良成熟稳重让我们懂得了内敛的人才是最美的成长的一路是一条五味陈杂的大道每一条都有无数的分叉口都要自己去选择都是一路荆棘不管我们哭喊也好欢心喜乐也罢都得自己走完人生的道路
腾讯音乐要去美国上市了，但能先解决音乐人的版权费吗？财经宅急送
传闻已久的腾讯音乐IPO的消息，今天终于得到了证实。7月9日，腾讯发布公告宣布拟将旗下的在线音乐业务分拆，以腾讯音乐集团的身份在美国独立上市，该提议已得到联交所确认。如此一来，腾讯音乐的估值也在一路飙升，最初盛传是100亿美元，随后变成了25亿美元，最新的数字已经达到了300亿美元。就想问，坐拥如此高估值，能先将音乐人的版权费结一下吗？最近著名音乐人李志被腾讯《明日之子》逼上了维权道路。《明日之子
【七律】返乡游子吟青颜珠珠
七律：返乡游子吟（终稿）作者：雨苗三径归兮如梦醒，门前垂柳笑风尘。频年泪滴长亭路，屡次眸凝老父身。奔碌难休惊瘦影，浮沉远渡见丰薪。芳华旧日疑裁剪，潘鬓青丝不再春。七律：返乡游子吟（修改）作者：雨苗三径归兮如梦醒，门前垂柳笑风尘。频年泪滴长亭路，屡次眸凝老父身。奔碌直过惊瘦影，浮沉远渡见丰薪。芳华旧日疑裁剪，潘鬓青丝不再春。七律：返乡游子吟（原稿）作者：雨苗三径归兮如梦醒，门前垂柳笑风尘。频年泪滴长
女儿被碰到冯世琴
吃过晚饭，女儿要去楼下找小朋友玩。我收拾完后与儿子准备去买点水果。刚到楼下，女儿在一旁哭，她的两个小朋友跑来跟我说。巧巧(女儿的名字)被一辆摩托车给撞了，我和儿子走上去看，还好没事，身上完好无损，问她是怎么撞的？小朋友说:“巧巧只顾跑，不看路，被摩托车撞了，骑车的是穿红衣服送外卖的，骑车的人说声对不起后走了，保安也看见了，没说什么，也走了”。这下儿子火了，骑车的人找不到了，但能找到保安。问几个小朋
生命在于运动李思睿vicky
不动会上瘾，运动也会使人上瘾并越来越更高的要求和自律，总之，在运动中的收获满满都是surprises。炎热的夏季，被汗水浸透的酸爽比在凉爽的空调房里更让人觉得舒服和有生命力。无论走在烈日骄阳下，还是搬起东西浑身冒汗水，我都更愿意舍弃在冰意凉爽的车子里一脚踩油门的就到达那种方便快捷。每天早上醒来，头重脚轻，浑身无力，头脑昏沉的感觉就像是中了空调的毒，更愿意每天下午在孩子放学的时候，踩一辆共享单车在路
画童八周年，生日快乐！（草稿）孙晓梅
今天刚好是画童成立8周年的日子，非常感谢各位家长朋友们给予画童的周年祝福，群里满屏都是家长朋友们的爱与祝福。画童走过8年风雨历程，可谓是有喜有忧！从蹒跚学步到稳步前进，再到阔步昂扬，离不开我们这么多智慧优秀的家长朋友们，有你们相伴，再难的路走着也有希望，再难的路走着一路也有你们的鲜花和掌声，也使我们有了前行的动力！我们相伴走到今天，更多的是互相理解着，互相支持着，互相配合着，我们彼此都感觉被爱包围
每天进步一点点姓林字子涯
文/子涯年幼时候，故乡的母校是一生中最美好的时光。一路走来，忘却了许多趣事，唯有钉在墙上的醒目的标语一直铭记于心:每天进步一点点，迈上成功路。年少时不懂这句话的含义，总会指着这段话与同学一笑而过。长大之后，内心逐渐成熟，方才发现原来这句话是才是人生的至理名言，朴实而又真诚。一个人是否有所改变，看的就是这个人是否每天都有在进步。一天的进步，不足以改变一个人的一生，但一生中的每一天都在进步，那么这个人
服务器采购和选型中兔西维亚实用工具服务器运维网络
1.CPU双路CPU，0号位和1号位，只要0号位CPU正常，服务器就能工作，若1号位CPU故障，服务器会报警。若0号位CPU故障，1号位CPU正常，服务器不能启动，需要将1号位的CPU换到0号位上才可以启动服务器。双路CPU，坏一个，另一个能正常工作吗？还是都不能用了，懂得告知，万谢cpu主频和最大睿频都是什么意思？CPU的主频，即CPU内核工作的时钟频率。睿频是指当启动一个运行程序后，处理器会自
Java序列化进阶篇 g21121 java序列化
1.transient 类一旦实现了Serializable 接口即被声明为可序列化，然而某些情况下并不是所有的属性都需要序列化，想要人为的去阻止这些属性被序列化，就需要用到transient 关键字。
escape()、encodeURI()、encodeURIComponent()区别详解 aigo JavaScript Web
原文：http://blog.sina.com.cn/s/blog_4586764e0101khi0.html JavaScript中有三个可以对字符串编码的函数，分别是： escape,encodeURI,encodeURIComponent，相应3个解码函数：,decodeURI,decodeURIComponent 。下面简单介绍一下它们的区别 1 escape()函
ArcgisEngine实现对地图的放大、缩小和平移 Cb123456 添加矢量数据对地图的放大、缩小和平移 Engine
ArcgisEngine实现对地图的放大、缩小和平移: 个人觉得是平移，不过网上的都是漫游，通俗的说就是把一个地图对象从一边拉到另一边而已。就看人说话吧. 具体实现: 一、引入命名空间 using ESRI.ArcGIS.Geometry; using ESRI.ArcGIS.Controls; 二、代码实现.
Java集合框架概述天子之骄 Java集合框架概述
集合框架集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。简单介绍： Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
旗正4.0页面跳转传值问题何必如此 java jsp
跳转和成功提示 a) 成功字段非空forward 成功字段非空forward，不会弹出成功字段，为jsp转发，页面能超链接传值,传输变量时需要拼接。接拼接方式list.jsp?test="+strweightUnit+"或list.jsp?test="+weightUnit+&qu
全网唯一:移动互联网服务器端开发课程 cocos2d-x小菜 web开发移动开发移动端开发移动互联程序员
移动互联网时代来了！ App市场爆发式增长为Web开发程序员带来新一轮机遇，近两年新增创业者，几乎全部选择了移动互联网项目！传统互联网企业中超过98%的门户网站已经或者正在从单一的网站入口转向PC、手机、Pad、智能电视等多端全平台兼容体系。据统计，AppStore中超过85%的App项目都选择了PHP作为后端程
Log4J通用配置|注意问题笔记 7454103 DAO apache tomcat log4j Web
关于日志的等级那些去百度就知道了！这几天要搭个新框架配置了日志记下来！做个备忘！ #这里定义能显示到的最低级别,若定义到INFO级别,则看不到DEBUG级别的信息了~! log4j.rootLogger=INFO,allLog # DAO层 log记录到dao.log 控制台和总日志文件 log4j.logger.DAO=INFO,dao,C
SQLServer TCP/IP 连接失败问题 ---SQL Server Configuration Manager darkranger sql c windows SQL Server XP
当你安装完之后,连接数据库的时候可能会发现你的TCP/IP 没有启动.. 发现需要启动客户端协议 : TCP/IP 需要打开 SQL Server Configuration Manager... 却发现无法打开 SQL Server Configuration Manager..?? 解决方法: C:\WINDOWS\system32目录搜索framedyn.
[置顶] 做有中国特色的程序员 aijuans 程序员
从出版业说起网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有些技术书读得可
document.domain 跨域问题 avords document
document.domain用来得到当前网页的域名。比如在地址栏里输入：javascript:alert(document.domain); //www.315ta.com我们也可以给document.domain属性赋值，不过是有限制的，你只能赋成当前的域名或者基础域名。比如：javascript:alert(document.domain = "315ta.com");
关于管理软件的一些思考 houxinyou 管理
工作好多看年了,一直在做管理软件,不知道是我最开始做的时候产生了一些惯性的思维,还是现在接触的管理软件水平有所下降.换过好多年公司,越来越感觉现在的管理软件做的越来越乱. 在我看来,管理软件不论是以前的结构化编程,还是现在的面向对象编程,不管是CS模式,还是BS模式.模块的划分是很重要的.当然,模块的划分有很多种方式.我只是以我自己的划分方式来说一下. 做为管理软件,就像现在讲究MVC这
NoSQL数据库之Redis数据库管理(String类型和hash类型) bijian1013 redis 数据库 NoSQL
一.Redis的数据类型 1.String类型及操作 String是最简单的类型，一个key对应一个value，string类型是二进制安全的。Redis的string可以包含任何数据，比如jpg图片或者序列化的对象。 Set方法：设置key对应的值为string类型的value
Tomcat 一些技巧征客丶 java tomcat dos
以下操作都是在windows 环境下一、Tomcat 启动时配置 JAVA_HOME 在 tomcat 安装目录，bin 文件夹下的 catalina.bat 或 setclasspath.bat 中添加 set JAVA_HOME=JAVA 安装目录 set JRE_HOME=JAVA 安装目录/jre 即可；二、查看Tomcat 版本在 tomcat 安装目
【Spark七十二】Spark的日志配置 bit1129 spark
在测试Spark Streaming时，大量的日志显示到控制台，影响了Spark Streaming程序代码的输出结果的查看(代码中通过println将输出打印到控制台上)，可以通过修改Spark的日志配置的方式，不让Spark Streaming把它的日志显示在console 在Spark的conf目录下，把log4j.properties.template修改为log4j.p
Haskell版冒泡排序 bookjovi 冒泡排序 haskell
面试的时候问的比较多的算法题要么是binary search，要么是冒泡排序，真的不想用写C写冒泡排序了，贴上个Haskell版的，思维简单，代码简单，下次谁要是再要我用C写冒泡排序，直接上个haskell版的，让他自己去理解吧。 sort [] = [] sort [x] = [x] sort (x:x1:xs) | x>x1 = x1:so
java 路径配置文件读取 bro_feng java
这几天做一个项目，关于路径做如下笔记，有需要供参考。取工程内的文件，一般都要用相对路径，这个自然不用多说。在src统计目录建配置文件目录res,在res中放入配置文件。读取文件使用方式： 1. MyTest.class.getResourceAsStream("/res/xx.properties") 2. properties.load(MyTest.
读《研磨设计模式》-代码笔记-简单工厂模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 个人理解：简单工厂模式就是IOC; * 客户端要用到某一对象，本来是由客户创建的，现在改成由工厂创建，客户直接取就好了 */ interface IProduct {
SVN与JIRA的关联 chenyu19891124 SVN
SVN与JIRA的关联一直都没能装成功，今天凝聚心思花了一天时间整合好了。下面是自己整理的步骤：一、搭建好SVN环境，尤其是要把SVN的服务注册成系统服务二、装好JIRA，自己用是jira-4.3.4破解版三、下载SVN与JIRA的插件并解压，然后拷贝插件包下lib包里的三个jar，放到Atlassian\JIRA 4.3.4\atlassian-jira\WEB-INF\lib下，再
JWFDv0.96 最新设计思路 comsci 数据结构算法工作企业应用公告
随着工作流技术的发展，工作流产品的应用范围也不断的在扩展，开始进入了像金融行业(我已经看到国有四大商业银行的工作流产品招标公告了)，实时生产控制和其它比较重要的工程领域，而
vi 保存复制内容格式粘贴 daizj vi 粘贴复制保存原格式不变形
vi是linux中非常好用的文本编辑工具，功能强大无比，但对于复制带有缩进格式的内容时，粘贴的时候内容错位很严重，不会按照复制时的格式排版，vi能不能在粘贴时，按复制进的格式进行粘贴呢？答案是肯定的，vi有一个很强大的命令可以实现此功能。在命令模式输入:set paste，则进入paste模式，这样再进行粘贴时
shell脚本运行时报错误：/bin/bash^M: bad interpreter 的解决办法 dongwei_6688 shell脚本
出现原因：windows上写的脚本，直接拷贝到linux系统上运行由于格式不兼容导致解决办法： 1. 比如文件名为myshell.sh，vim myshell.sh 2. 执行vim中的命令 : set ff?查看文件格式，如果显示fileformat=dos，证明文件格式有问题 3. 执行vim中的命令 :set fileformat=unix 将文件格式改过来就可以了，然后:w
高一上学期难记忆单词 dcj3sjt126com word english
honest 诚实的；正直的 argue 争论 classical 古典的 hammer 锤子 share 分享；共有 sorrow 悲哀；悲痛 adventure 冒险 error 错误；差错 closet 壁橱；储藏室 pronounce 发音；宣告 repeat 重做；重复 majority 大多数；大半 native 本国的，本地的，本国
hibernate查询返回DTO对象，DTO封装了多个pojo对象的属性 frankco POJO hibernate查询 DTO
DTO-数据传输对象；pojo-最纯粹的java对象与数据库中的表一一对应。简单讲：DTO起到业务数据的传递作用，pojo则与持久层数据库打交道。有时候我们需要查询返回DTO对象，因为DTO
Partition List hcx2013 partition
Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x. You should preserve the original relative order of th
Spring MVC测试框架详解——客户端测试 jinnianshilongnian
上一篇《Spring MVC测试框架详解——服务端测试》已经介绍了服务端测试，接下来再看看如果测试Rest客户端，对于客户端测试以前经常使用的方法是启动一个内嵌的jetty/tomcat容器，然后发送真实的请求到相应的控制器；这种方式的缺点就是速度慢；自Spring 3.2开始提供了对RestTemplate的模拟服务器测试方式，也就是说使用RestTemplate测试时无须启动服务器，而是模拟一
关于推荐个人观点 liyonghui160com 推荐系统关于推荐个人观点
回想起来，我也做推荐了3年多了，最近公司做了调整招聘了很多算法工程师，以为需要多么高大上的算法才能搭建起来的，从实践中走过来，我只想说【不是这样的】第一次接触推荐系统是在四年前入职的时候，那时候，机器学习和大数据都是没有的概念，什么大数据处理开源软件根本不存在，我们用多台计算机web程序记录用户行为，用.net的w
不间断旋转的动画 pangyulei 动画
CABasicAnimation* rotationAnimation; rotationAnimation = [CABasicAnimation animationWithKeyPath:@"transform.rotation.z"]; rotationAnimation.toValue = [NSNumber numberWithFloat: M
自定义annotation sha1064616837 java enum annotation reflect
对象有的属性在页面上可编辑，有的属性在页面只可读，以前都是我们在页面上写死的，时间一久有时候会混乱，此处通过自定义annotation在类属性中定义。越来越发现Java的Annotation真心很强大，可以帮我们省去很多代码，让代码看上去简洁。下面这个例子主要用到了 1.自定义annotation：@interface，以及几个配合着自定义注解使用的几个注解 2.简单的反射 3.枚举
Spring 源码 up2pu spring
1.Spring源代码 https://github.com/SpringSource/spring-framework/branches/3.2.x 注：兼容svn检出 2.运行脚本 import-into-eclipse.bat 注：需要设置JAVA_HOME为jdk 1.7 build.gradle compileJava { sourceCompatibilit
利用word分词来计算文本相似度 yangshangchuan word word分词文本相似度余弦相似度简单共有词
word分词提供了多种文本相似度计算方式：方式一：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度实现类：org.apdplat.word.analysis.CosineTextSimilarity 用法如下： String text1 = "我爱购物"; String text2 = "我爱读书"; String text3 =