parser.java

JAVA 数学程序库 提供常规的数值计算程序包

        else if (isExpectedDelimiter( next, '{' ))
        {
            getNextToken();
            cellB = true;
        }
        else if(next instanceof DotOperatorToken)
        {
            return func;
        }

        Stack parameterStack  = new Stack();
        
        // if a first parameter is supplied, put it on the stack
        if(firstParam != null)
        {
           firstParam.setDisplayResult(false);
           parameterStack.push(firstParam);
           func.setOperand(firstParam);
        }

        int i=0;
        while (true)
        {
            i++;
            ErrorLogger.debugLine("Parser: function parse Parameter "+i);

            //parse next parameter                    
               OperandToken operand = parseArithExpression(SINGLE);        

            // check if a parameter is returned (e.g. who() returns no parameter)
            if (operand == null)
            {
                // who() returns no parameter, but still need to remove ")" from scanner
                if (isExpectedDelimiter(peekNextToken(), ')') && !cellB)
                    getNextToken();
                if (isExpectedDelimiter(peekNextToken(), '}') &&  cellB)
                    getNextToken();
            
                break;
            }
            
            //values of parameters are not displayed at the prompt
            operand.setDisplayResult(false);
            
            //add parameter to expression tree
            parameterStack.push(operand);

            // get current token to see if more parameters expected or if closing ')'
            Token current = peekNextToken();

            if (current != null)
                ErrorLogger.debugLine("Parser: function parse Parameter current "+current.toString());            

            if (isExpectedDelimiter(peekNextToken(), ',' )) 
            {
                getNextToken();
            }
            else if (isExpectedDelimiter(peekNextToken(), ')' ) && !cellB) 
            {
                getNextToken();
                break;
            }
            else if (isExpectedDelimiter(peekNextToken(), '}' ) && cellB) 
            {
                getNextToken();
                break;
            }
            //else if (isExpectedDelimiter(peekNextToken(), ';' )) 
            //{
            //       getNextToken();
            //    break;
            //}
            else
                Errors.throwParserException(" error parsing parameter");
            

        }
        
        // copy parameters from stack into operands array
        int            parSize    = parameterStack.size();
        OperandToken[] parameters = new OperandToken[parSize];
        
        // reverse order, because stack is last in first out
        for( int p=parSize-1; p>=0; p--)
        {
            parameters[p] = ((OperandToken)parameterStack.pop());
        }
        
        // e.g. foo{888}=...
        if (cellB)
        {
            return new VariableToken(func.getName(),parameters, "cell");
        }
        
        
        func.setOperands(parameters); // = ( (OperatorToken)nextToken , parameters, parSize);
        
        return func;
    } // end parseFunctionParameters

    /***********************************************************************************/
    /** parse <if>(<relation>){<expression>} else {<expression>}                       */
    /*  parse <if>(<relation>) <expression> else <expression> endif
    /* @param                                                                 		   */
    /* @param                                                                           */
    /* @return                                                                         */
    private OperandToken parseIf()
    {
        // parse releation (e.g. if (3<5) ...)
    	// next Token must be a "(" 
        if (!isExpectedDelimiter(getNextToken(), '('))
            Errors.throwParserException(" if missing (");

        // get argument inside (...)
        OperandToken ifRelation = parseArithExpression(SINGLE);         

        // check if argument is terminated by ")"
        if (!isExpectedDelimiter(peekNextToken(), ')' )) 
            Errors.throwParserException("If: missing )");
        else
            getNextToken();
            
        ErrorLogger.debugLine("Parser: if after relation: "+ifRelation.toString());


        // parse commands (e.g. if(3<5) {some_commands} or
        //                      if(3<5)  some_commands  endif
        ErrorLogger.debugLine("Parser: if-command");
        OperandToken ifCode = parseCommandList();       
        ErrorLogger.debugLine("Parser: if command: "+ifCode.toString());
        
        // If(..) {...}
        IfThenOperatorToken ifToken = new IfThenOperatorToken(ifRelation, ifCode);
        
        // start parsing elseif, ... , else
        while(true)
        {
            
            Token nextToken = peekNextToken();
            ErrorLogger.debugLine("Parser: if "+nextToken);
            
            if(isExpectedDelimiter(peekNextToken(), "elseif"))
            {
                // this is at least some if-elseif-else
            	getNextToken(); // remove "elseif"-token 
        
                // elseif(..) {...} 
                ErrorLogger.debugLine("Parser: if: found elseif");

                if (!isExpectedDelimiter(getNextToken(), '(' ))
                    Errors.throwParserException(" if missing (");

                // get argument inside (...)
                OperandToken elseIfRelation = parseArithExpression(SINGLE);         
   		
                // check if argument is terminated by ")"
                if (!isExpectedDelimiter(peekNextToken(), ')' ) ) 
                    Errors.throwParserException("If: missing )");
                else
                    getNextToken();
                
                ErrorLogger.debugLine("Parser: elseIf after relation: "+elseIfRelation.toString());
                
                // parse commands (e.g. elseif(3<5) {some_commands} or
                //                      elseif(3<5)  some_commands  endif
                OperandToken elseIfCode = parseCommandList();       
              
                ErrorLogger.debugLine("Parser: elseIf code: "+elseIfCode.toString());
                
                ifToken.addCondition(elseIfRelation, elseIfCode);
            }
            else if (isExpectedDelimiter(peekNextToken(), "else") )
            {
                getNextToken(); // remove "else"-token 
        
                // If(..) {...} else {...}
                ErrorLogger.debugLine("Parser: if: found else");

                // get commands inside {...}
                OperandToken elseCode = parseCommandList();       
                
                ErrorLogger.debugLine("Parser: else code: "+elseCode.toString());

                ifToken.addCondition(null, elseCode);
            }
	        else if (isExpectedDelimiter(peekNextToken(), "endif") ||
	        		 isExpectedDelimiter(peekNextToken(), "end")      )
	        {
	        	getNextToken();  // remove endif token
	        	break;
	        }
	        else
	        	Errors.throwParserException("If: some error");
        } // end while
        
        ErrorLogger.debugLine("Parser: if: end of parsing");
        return ifToken;
    } // end parseIf        


    /***********************************************************************************/
    /** parse  switch(<variable>)                                                      */
    /*         {                                                                       */
    /*            case(<number>): { <expression> }                                     */
    /*                  ...                                                            */
    /*            case(<number>): { <expression> }                                     */
    /*            default:        { <expression> }                                     */
    /*         }                                                                       */
    /* @param                                                                            */
    /* @param                                                                           */
    /* @return                                                                         */
    private OperandToken parseSwitch()
    {
        Token nextToken = null;
        
        // next Token must be a "(" 
        if (!isExpectedDelimiter(getNextToken(), '(' ))
            ErrorLogger.debugLine("Parser: switch missing (");

        // get argument inside (...)
        OperandToken switchRelation = parseArithExpression(SINGLE);         

        if (!isExpectedDelimiter(peekNextToken(), ')' )) 
            Errors.throwParserException("Switch: missing )");
        else
            getNextToken();
        
        
        if (!isExpectedDelimiter(peekNextToken(), '\n')    ) 
            Errors.throwParserException("switch: missing \\n");
        else
            getNextToken();

        ErrorLogger.debugLine("Parser: switch after relation");

        
        //parse switch statement
        Vector cases = new Vector(10);

        // if the next Token is a "{" then remove it
        //if(isExpectedDelimiter(peekNextToken(), '{' ))
        //    nextToken = getNextToken();
            
        // parse case,default,otherwise commands
        while(peekNextToken() != null)
        {

            if(isExpectedDelimiter(peekNextToken(), "case"))
            {
            	getNextToken();
            	ErrorLogger.debugLine("Parser: switch: case     *****");
                cases.addElement(parseCase());
                ErrorLogger.debugLine("Parser: switch: case end *****");
            }
            else if(isExpectedDelimiter(peekNextToken(), "default")  ||
            		isExpectedDelimiter(peekNextToken(), "otherwise")   )
            {
            	getNextToken();
            	ErrorLogger.debugLine("Parser: switch: default");
                cases.addElement(parseDefault());
            }
            else if(isExpectedDelimiter(peekNextToken(), "end")      ||
            		isExpectedDelimiter(peekNextToken(), "endswitch")   )
            {
            	getNextToken();
                ErrorLogger.debugLine("Parser: switch: end");
                break;
            }
            else 
            {
                Errors.throwParserException(" switch error");
            }
            
            
        }  // end while
        
        ErrorLogger.debugLine("Parser: switch returning");
        return new SwitchToken(switchRelation, cases);
    }
    
    /**
     * parsing of "case" commands
     * @return
     */
    private OperandToken parseCase()
    {
        if (!isExpectedDelimiter(getNextToken(), '(' ))
            ErrorLogger.debugLine("Parser: case missing (");

        // get argument inside (...)
        ErrorLogger.debugLine("Parser: switch: case relation     *****");
        OperandToken caseRelation = parseArithExpression(SINGLE);         

        if (!isExpectedDelimiter(peekNextToken(), ')' )) 
            Errors.throwParserException("Switch case: missing )");
        else
            getNextToken();

        ErrorLogger.debugLine("Parser: switch: case relation end *****");
        
        // get commands 
        ErrorLogger.debugLine("Parser: switch: case code     *****");
        OperandToken caseCode  = parseCommandList();       
        
	    ErrorLogger.debugLine("Parser: switch: case code end *****");

        return new CaseToken(caseRelation, caseCode);
    }

    /**
     *  parse "default" or "otherwise" command of switch
     * @return
     */
    private OperandToken parseDefault()
    {
        ErrorLogger.debugLine("Parser: switch default");

        // get default commands 
        OperandToken defaultCode  = parseCommandList();