class ParsingMethod
{
	
	////////symbol table/////////////
	SymbolTable symbolTable[];
    public static int symbolTableLength;
    
    IncludeFile includeFile[];
    public static int fileNum;
	
	String symbolType;
	String symbolName;
	
	String fileName;
	String fileType;
	
	/////////other/////////
	public static boolean successFlag;
	
	
	///////errorMethod.error method////////////
	ErrorMethod errorMethod;
	public static int errorNum;
	public static int errorLines[];
	
	//////language meaning//////////////////
	String matchStack[];
	public static int matchStackPointer;
	
	String matchQueue[];
	public static int matchQueueHead;
	public static int matchQueueTail;
	
	public static boolean logicFlag;
	public static boolean feiFlag;
	
	
	
	public ParsingMethod()
	{
		/////give the room for symbol table////////
		symbolTable = new SymbolTable[100];
		for(int i=0;i<100;i++)
		{
			symbolTable[i]=new SymbolTable();
		}
		
		includeFile = new IncludeFile[20];
		for(int i=0;i<20;i++)
		{
			includeFile[i] = new IncludeFile(); 
		}
		
		////give the room////////
		symbolType = new String();
		symbolName = new String();
		
		fileName = new String();
		fileType = new String();
		
		///////////////////////////
		errorMethod = new ErrorMethod();
		errorLines = new int[100];
		
		matchStack = new String[100];
		matchQueue = new String[100];
	}
	
	/////the operation of matchStack//////////////////
	public void pushIntoStack(String s)
	{
		matchStack[matchStackPointer]=s;
		matchStackPointer++;
		
	}
	public String popOutStack()
	{
	
		matchStackPointer--;
		return (matchStack[matchStackPointer]);
	
	}
	
	public String getTopStack()
	{
		if(!stackIsEmpty())
		{
			return matchStack[matchStackPointer-1];

		}
		else
		{
			return "null";
		}
	}
	
	public void clearStack()
	{
		matchStackPointer=0;
	}
	
	public boolean stackIsEmpty()
	{
		boolean flag = true;
		if(matchStackPointer==0)
		{
			flag=true;
		}
		else
		{
			flag=false;
		}
		return flag;
	}
	
	public void showStack()
	{
		CompileFrame.errorArea.append("The stack's content is :"+String.valueOf('\n'));
		int i = matchStackPointer;
		while(i>=1)
		{
			CompileFrame.errorArea.append(""+matchStack[i-1]);
			i--;
			
		}
			
	}
	
	////////operation of queue//////
	public void pushIntoQueue(String s)
	{
		matchQueue[matchQueueTail++]=s;
	}
	public String popOutQueue()
	{
		return matchQueue[matchQueueHead++];
	}
	public void clearQueue()
	{
		matchQueueHead = matchQueueTail =0;
	}
	public boolean queueIsEmpty()
	{
		boolean flag = true;
		if(matchQueueHead == matchQueueTail)
		{
			flag = true;
		}
		else
		{
			flag = false;
		}
		return flag;
	}
	public String getHeadQueue()
	{
		if(!queueIsEmpty())
		{
			return matchQueue[matchQueueHead];
		}
		else
		{
			return "null";
		}
	}
	public void showQueue()
	{
		CompileFrame.errorArea.append("The queue's content is:"+String.valueOf('\n'));
		int i=matchQueueHead;
		while(i<matchQueueTail)
		{
			CompileFrame.errorArea.append(""+matchQueue[i]+String.valueOf('\n'));
			i++;
		}
		
	} 
	
	////////////////////////////////////
	
	
	public String getSymbolType(String s)
	{
		boolean flag = true;
		int position = 0;
		for(int i=0;i<symbolTableLength&&flag;i++)
		{
			if(symbolTable[i].getSymbolName().equals(s))
			{
				flag = false;
			}
			position = i;
		}
		
		return symbolTable[position].getSymbolType();
		
	}
	
	
	
	////////store symbol into symboltable/////////////////////
	public void storeSymbol(String name,String type)
	{
		if(symbolTableLength<100)
		{
			symbolTable[symbolTableLength].setSymbolName(name);
			symbolTable[symbolTableLength].setSymbolType(type);
			
			symbolTableLength++;
		}
		else
		{
			CompileFrame.errorArea.append("There is no place for symboltable"+String.valueOf('\n'));
		}
		
	}
	
	public void storeIncludeFile(String name,String type)
	{
		if(fileNum<20)
		{
			includeFile[fileNum].setFileName(name);
			includeFile[fileNum].setFileType(type);
			
			fileNum++;
		}
		else
		{
			CompileFrame.errorArea.append("There is no place for import file"+String.valueOf('\n'));
		}
	}
	
	//////////////judge type//////////////////
	public boolean judgeType(String s)
	{
		boolean flag=false;		
		if(s.equals("int")||s.equals("double")
			||s.equals("float")||s.equals("char"))
		{
			flag = true;
		}
		else 
		{
			flag = false;
		}
		return flag;
	}
	
	///////////////judge number/////////////////
	public boolean judgeNum(String s)
	{
		boolean flag = false;
		char wordBuffer[]=s.toCharArray();
		int length = s.length();
		if(length==1&&wordBuffer[0]>='0'&&wordBuffer[0]<='9')
		{
			flag = true;
		}
		else
		if(wordBuffer[0]>'0'&&wordBuffer[0]<='9')
		{
			flag = true;
			for(int i=1;i<length&&flag;i++)
			{
				if(wordBuffer[i]<'0'||wordBuffer[i]>'9')
				{
					flag = false;
				}
			}
		}
		return flag;
	}
	
	///////////////judge the operator//////////////
	
	public boolean judgeOperator(String s)
	{
		boolean flag = false;
		
		if(s.equals("+")||s.equals("-")||s.equals("*")
			||s.equals("/")||s.equals("%"))
			{
				flag = true;
			}
		else
		{
		
		}
		return flag;
	}
	
	////////////////judge the symbol//////////
	public boolean judgeSymbol(String s)
	{
		boolean flag =false;
		char wordBuffer[]=s.toCharArray();
		int length = s.length();
		
		if(s.equals("int")||s.equals("float")||s.equals("double")
		||s.equals("char")||s.equals("if")||s.equals("while")||s.equals("for")
		||s.equals("include")||s.equals("main")||s.equals("printf")||s.equals("scanf"))
		{
			flag = false;
			////////////////////
			errorMethod.error("symbol",0,s,WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
			
		}
		else
		if((wordBuffer[0]>='a'&&wordBuffer[0]<='z')||(wordBuffer[0]>='A'&&wordBuffer[0]<='Z'))
		{
			flag=true;
			for(int i=1;i<length&&flag;i++)
			{
				if((wordBuffer[i]>='a'&&wordBuffer[i]<='z')||(wordBuffer[i]>='A'&&wordBuffer[i]<='Z')||(wordBuffer[i]=='_'))
				{
					
				}	
				else
				{
					flag = false;
				}			
			}	
		}
		else
		{
			flag = false;
		}
		
		return flag;
	}
	///////judge logic operator//////////////
	public boolean judgeLogicOperator(String s)
	{
		if(s.equals("<=")||s.equals(">=")||s.equals("==")
			||s.equals("<")||s.equals(">")||s.equals("!="))
			{
				return true;
			}
		else
		{
			return false;
		}
	}
	
/////////////////the part of expression analyzing////////////////////
	public void advance()
	{
		WordAnalyze.wordPointer++;
	}
	
	public void mainProgram()
	{
	
		
		if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("void"))
		{
			advance();
		}
		if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("main"))
		{
			advance();
			{
				if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("("))
				{
					advance();
					if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("int"))
					{
						advance();
						if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("argc"))
						{
							advance();
							if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals(","))
							{
								advance();
								if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("char"))
								{
									advance();
									if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("*"))
									{
										advance();
										if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("argv"))
										{
											advance();
											if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("["))
											{
												advance();
												if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("]"))
												{
													advance();
		
												}
												else
												{
													errorMethod.error("main",1,"mainprogram'parameter internal define",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
												}
											}
											else
											{
												errorMethod.error("main",1,"mainprogram'parameter internal define",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
											}
										}
										else
										{
											errorMethod.error("main",1,"mainprogram'parameter internal define",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
										}
									}
									else
									{
										errorMethod.error("main",1,"mainprogram'parameter internal define",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
									}
								}
								else
								{
									errorMethod.error("main",1,"mainprogram'parameter internal define",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
								}
							}
							else
							{
								errorMethod.error("main",1,"mainprogram'parameter internal define",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
							}
						}
						else 
						{
							errorMethod.error("main",1,"mainprogram'parameter internal define",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
						}
					}
					
				
					
					if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals(")"))
					{
						advance();
						if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("{"))
						{
							advance();
							//////////program analyze///////////////
							
							programAnalyze();
			
			
							if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("}"))
							{
								success();
							}
							else
							{
								errorMethod.error("sign",0,"}",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
							}

							
						}
						else
						{
							errorMethod.error("sign",0,"{",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
						}
					}
					
					else
					{
						errorMethod.error("sign",0,")",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
					}
					
				}
				else
				{
					errorMethod.error("sign",0,"(",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
				}
			}
		}
		else
		{
			
			errorMethod.error("main",0,"main",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
		}
	}
	
	
	/////////////////////sentence/////////////////////////////////
	//////////the importing file 's part//////////
	public void includeOtherFile()
	{
		while(WordAnalyze.wordPointer<WordAnalyze.wordStringLength&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("#"))
		{
			includeA();
			if(WordAnalyze.wordPointer<WordAnalyze.wordStringLength
			&&!WordAnalyze.wordString[WordAnalyze.wordPointer].equals("#")
			&&!WordAnalyze.wordString[WordAnalyze.wordPointer].equals("main")
			&&!(WordAnalyze.wordString[WordAnalyze.wordPointer].equals("void")&&WordAnalyze.wordPointer<WordAnalyze.wordStringLength-1&&WordAnalyze.wordString[WordAnalyze.wordPointer+1].equals("main"))
			)
			{
				errorMethod.error("file",4,"",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
			}
			while(WordAnalyze.wordPointer<WordAnalyze.wordStringLength
			&&!WordAnalyze.wordString[WordAnalyze.wordPointer].equals("#")
			&&!WordAnalyze.wordString[WordAnalyze.wordPointer].equals("main")
			&&!(WordAnalyze.wordString[WordAnalyze.wordPointer].equals("void")&&WordAnalyze.wordPointer<WordAnalyze.wordStringLength-1&&WordAnalyze.wordString[WordAnalyze.wordPointer].equals("main"))
			)
			{
				advance();
			}
			
			
		}
	}
	public void includeA()
	{
		if(WordAnalyze.wordString[WordAnalyze.wordPointer].equals("#"))
		{
			advance();
			if(WordAnalyze.wordString[WordAnalyze.wordPointer].equals("include"))
			{
				advance();
				includeB();
			}
			else
			{
				errorMethod.error("file",0,"",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
			}
		}
	}
	public void includeB()
	{
		if(WordAnalyze.wordString[WordAnalyze.wordPointer].equals("<"))
		{
			advance();
			includeC();
			if(WordAnalyze.wordString[WordAnalyze.wordPointer].equals(">"))
			{
				advance();
			}
			else
			{
				errorMethod.error("file",1,">",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
			}
			
			
		}
		else
		{
			errorMethod.error("file",0,"",WordAnalyze.lineOfWord[WordAnalyze.wordPointer]);
		}
	}
	
	public void includeC()
	{
		if(judgeSymbol(WordAnalyze.wordString[WordAnalyze.wordPointer]))
		{
			fileName = WordAnalyze.wordString[WordAnalyze.wordPointer];