C++ TokenScanner::nextToken方法代码示例

/* Function: powFunction()
 * Usage: is called by formulaStringScanning() function if it detect pow token in formula
 * -----------------------------------------------------------------------------------------//
 * Library pow function execution. Believe that it's normalized function -
 * without any variables like "x" or "y" - just pow(<value>, <power for value>):
 * pow(2, 4) = 16
 * Expects brackets, and return pow function result for values in brackets.
 *
 * @param scanner      TokenScanner for user formula */
double powFunction(TokenScanner& scanner) {
    bool powFail = false;
    string token = "";
    string num1 = "";
    string num2 = "";
    while(scanner.hasMoreTokens()) {
        token = scanner.nextToken();//waiting for brackets at this place
        if(token == "(") {
            num1 = scanner.nextToken();//pow function param1
            token = scanner.nextToken();//waiting coma at this place
            if(token == ",") {
                num2 = scanner.nextToken();//pow function param2
                token = scanner.nextToken();//waiting for brackets at this place
                if(token == ")") {
                    break;
                } else {
                    powFail = true;
                }
            } else {
                powFail = true;
            }
        } else {
            powFail = true;
        }

        if(powFail) {
            cout <<  "   - POW FUNCTION INPUT FAULT!" << endl;
            failFlag = true;
            return 0;
        }
    }
    /* Returns pow function result */
    return pow(stringToDouble(num1), stringToDouble(num2));
}

LetStmt::LetStmt(TokenScanner &scanner) {
    identifier = scanner.nextToken();
    op = scanner.nextToken();
    exp = readE(scanner, 0);
    if (scanner.hasMoreTokens()) {
        error("Extraneous token " + scanner.nextToken());
    }
}

/*
 * Implementation notes: the InputStmt subclass
 * ----------------------------------------------
 * Instances of this class read the identifier from the scanner and notify
 * the user if its format is illegal. In the execute method, it records
 * the input of the user as the value of the identifier in "state".
 */
InputStmt::InputStmt(TokenScanner & scanner){
    string nextToken = scanner.nextToken();
    if (isdigit(nextToken[0]))
        error("Invalid identifier for Input Statement -- can't start with an integer.");
    if (scanner.hasMoreTokens())
        error("Unexpected token: " + scanner.nextToken());
    identifier = nextToken;
}

/*
 * Function: listProgram
 * Usage: listProgram(program, scanner);
 * -------------------------------------------
 * Displays the lines of the program.  It calls either version of program.toString()
 * depending on whether the user specifies line numbers.
 */
void listProgram(Program & program, TokenScanner & scanner) {
    if (!scanner.hasMoreTokens()) {
        program.toString();
    }
    else {
        int startLine = stringToInteger(scanner.nextToken());
        scanner.nextToken();
        int endLine = stringToInteger(scanner.nextToken());
        program.toString(startLine, endLine);
    }
}

void processLine(string line, Program & program, EvalState & state) {
	TokenScanner scanner;
	scanner.ignoreWhitespace();
	scanner.scanNumbers();
	scanner.setInput(line);
    string str=scanner.nextToken();
    if (scanner.getTokenType(str)==NUMBER) {
		
        int lineNumber=stringToInteger(str);
        string token=scanner.nextToken();
        scanner.saveToken(token);
        if (token!="") {
            program.addSourceLine(lineNumber, line);
            program.setParsedStatement(lineNumber, parseStatement(scanner));
        }
        else {
            program.removeSourceLine(lineNumber);
        }
		
		
    }
	
    else if (str=="LIST") {
        for (int i=program.getFirstLineNumber(); i!=-1; i=program.getNextLineNumber(i)) {
            cout << program.getSourceLine(i)<<endl;
        }
    }
    else if (str=="CLEAR") {
        program.clear();
    }
    else if(str=="QUIT") exit(0);
    else if (str=="HELP") cout<<"This is a minimal BASIC interpreter."<<endl;
	
    else if (str=="RUN") {
        int currentLine=program.getFirstLineNumber();
        state.setCurrentLine(currentLine);
        while (currentLine!=-1) {                       
            program.getParsedStatement(currentLine)->execute(state);
			
            if(currentLine!=state.getCurrentLine()) {
                currentLine=state.getCurrentLine();
            }
            else {
                currentLine=program.getNextLineNumber(currentLine);
                state.setCurrentLine(currentLine);
            }
        }
    }
	
	
}

static bool isFormula(string& mainFormula, string& formula, string& cellname1, string& cellname2, TokenScanner& scanner, SSModel& cellsheet) {
    if (cellsheet.isFormula(formula)) {
        cellname1 = toUpperCase(scanner.nextToken());
        mainFormula += cellname1 + scanner.nextToken();
        cellname2 = toUpperCase(scanner.nextToken());
        if (checkRange(cellname1,cellname2, cellsheet)) {
            string bracket = scanner.nextToken();
            if (bracket == ")") {
                mainFormula += cellname2 + bracket;
                return true;
            }
        }
    }
    return false;
}

/* Function: sqrtFunction()
 * -------------------------
 * Library sqrt function execution. Expects for brackets and involves
 * formulaStringScanning process for expression in brackets. Return sqrt function result
 * for obtained value in brackets.
 *
 * @param scanner   TokenScanner for user formula */
double sqrtFunction(TokenScanner& scanner) {
    bool sqrtFailFlag = false;
    string token = "";
    double sqrtParam = 0;

    if (scanner.hasMoreTokens()) {
        token = scanner.nextToken();//waiting for brackets at this place
        if (token == "(") {
            bool bracketsOpened = true;
            /* Calls internal scanFormulaString process for expression in brackets */
            sqrtParam = scanFormulaString(scanner, bracketsOpened);
        } else {
            sqrtFailFlag = true;
        }
    }

    if (sqrtFailFlag) {
        cout << "   - SQRT FUNCTION FAULT" << endl;
        FAIL_FLAG = true;
        return 0;
    }

    /* Returns sqrt function result */
    return sqrt(sqrtParam);
}

/**
 * Receive information from file, processes and displays the result on the screen.
 */
void processText(TokenScanner & scanner){
    int counterSentences = 0;
    int counterWords = 0;
    int counterSyllable = 0;
    double grade = 0.0;

    scanner.ignoreWhitespace(); // ignores spaces
    scanner.addWordCharacters("'"); // does part of the token is the character "'"

    // processes each token
    while (scanner.hasMoreTokens()){
        string token = scanner.nextToken();
        counterSentences += checkSentences(token);
        if(checkWords(token)){
            counterWords ++;
            counterSyllable += colSyllable(token);
        }
    }
    // If the file does not contain any words or sentences, assume that their one
    if(counterWords == 0 || counterSentences == 0) counterSentences = counterWords = 1;

    grade = getGrade(counterSentences, counterWords, counterSyllable);

    cout << "Words : " << counterWords << endl;
    cout << "Syllable : " << counterSyllable << endl;
    cout << "Sentences : " << counterSentences << endl;
    cout << "Grade : " << grade << endl;
}

bool isHaiku(string filename) {
    fstream infile;
    infile.open(filename.c_str());
    string temp;
    int count = 0;
    TokenScanner scanner;
    while(getline(infile, temp)){
        count++;
        int syllables = 0;
        scanner.setInput(temp);
        while (scanner.hasMoreTokens()){
            syllables += syllablesIn(scanner.nextToken());
        }
        if((count == 1 || count ==3)&&syllables!=5){
            infile.close();
            return false;
        }
        if (count == 2 && syllables !=7){
            infile.close();
            return false;
        }
        if (count >3){
            infile.close();
            return false;
        }
            
    }
    return true;
}

/* Function: sqrtFunction()
 * Usage: is called by formulaStringScanning() function if it detect sqrt token in formula
 * -----------------------------------------------------------------------------------------//
 * Library sqrt function execution. Expects for brackets and involves
 * formulaStringScanning process for expression in brackets. Return sqrt function result
 * for obtained value in brackets.
 *
 * @param scanner   TokenScanner for user formula
 * @param xValue    Value for x variable in user equation */
double sqrtFunction(TokenScanner& scanner, double xValue) {
    bool sqrtFail = false;
    string token = "";
    double num1 = 0;
    if(scanner.hasMoreTokens()) {
        token = scanner.nextToken();
        if(token == "(") { //waiting for brackets at this place
            bool bracketsOpened = true;
            /* Calls internal formulaStringScanning process for expression in brackets */
            num1 = formulaStringScanning(scanner,
                                         bracketsOpened,
                                         xValue);
        } else {
            sqrtFail = true;
        }
    }

    if(sqrtFail) {
        cout << "   - SQRT FUNCTION FAULT" << endl;
        failFlag = true;
        return 0;
    }

    /* Returns sqrt function result */
    return sqrt(num1);
}

/*
 * Implementation notes: the IfStmt subclass
 * ----------------------------------------------
 * Instances of this class check if the expression that follows "IF" is true.
 * If it is, the program goes to the line indicated; if not, the program continues
 * to the next line.
 */
IfStmt::IfStmt(TokenScanner & scanner, Program & program){
    string lhs = "";
    string nextToken = scanner.nextToken();
    while (nextToken != "=" && nextToken != ">" && nextToken != "<" && nextToken != "") {
        lhs += nextToken;
        nextToken = scanner.nextToken();
    }

    if (!(nextToken == "=" || nextToken == ">" || nextToken == "<"))
        error("Illegal operator for IF command");
    op = nextToken;

    nextToken = scanner.nextToken();
    string rhs = "";

    while (nextToken != "THEN" && nextToken != "then" && nextToken != "") {
        rhs += nextToken;
        nextToken = scanner.nextToken();
    }
    if (nextToken != "THEN" && nextToken != "then")
        error("Incorrect argument for IF command.");

    //scanner for the lhs expression
    TokenScanner scanner2;
    scanner2.ignoreWhitespace();
    scanner2.scanNumbers();
    scanner2.setInput(lhs);
    lhsExp = parseExp(scanner2);

    //scanner for the rhs expression
    TokenScanner scanner3;
    scanner3.ignoreWhitespace();
    scanner3.scanNumbers();
    scanner3.setInput(rhs);
    rhsExp = parseExp(scanner3);

    lineNumber = stringToInteger(scanner.nextToken()); //CHECK FOR ERRORS HERE
}

/* Function: powFunction()
 * ------------------------
 * Library pow function execution. Expects sequentally:
 * - brackets, param1, coma, param2, brackets.
 *
 * @param scanner      TokenScanner for user formula */
double powFunction(TokenScanner& scanner) {
    bool powFailFlag = false;
    string token = "";
    string powParam_1 = "";     //pow function param1
    string powParam_2 = "";     //pow function param2
    while (scanner.hasMoreTokens()) {
        token = scanner.nextToken();//waiting for brackets at this place
        if (token == "(") {
            powParam_1 = scanner.nextToken();
            token = scanner.nextToken();//waiting for coma at this place
            if (token == ",") {
                powParam_2 = scanner.nextToken();
                token = scanner.nextToken();//waiting for brackets - end of pow params input
                if (token == ")") {
                    break;
                } else {
                    powFailFlag = true;
                }
            } else {
                powFailFlag = true;
            }
        } else {
            powFailFlag = true;
        }

        if (powFailFlag) {
            cout << "   - POW FUNCTION INPUT FAULT!" << endl;
            FAIL_FLAG = true;
            return 0;
        }
    }

    /* Returns pow function result */
    double param1 = stringToDouble(powParam_1);
    double param2 = stringToDouble(powParam_2);
    return pow(param1, param2);
}

void toAlpha(std::string word, Map<std::string, std::string>& symbolTable) {
	TokenScanner scanner;
	scanner.ignoreWhitespace();

	for(char i = 'A'; i < 'Z'; i++)
		scanner.addWordCharacters(symbolTable.get(charToString(i)));

	scanner.setInput(word);

	while(scanner.hasMoreTokens()) {
		std::string symbol = scanner.nextToken();
		cout << symbolTable.get(symbol);
	}
	cout << endl;
}

void processLine(string line, Program & program, EvalState & state) {
   TokenScanner scanner;
   scanner.ignoreWhitespace();
   scanner.scanNumbers();
   scanner.setInput(line);
//   Expression *exp = parseExp(scanner);
//   int value = exp->eval(state);
//   cout << value << endl;
//   delete exp;
   if (!scanner.hasMoreTokens()) {
       return;
   }
   string firstToken = toUpperCase(scanner.nextToken());
   if (firstToken == "RUN") {
       runProgram(program, state);
   }
   else if (firstToken == "QUIT") {
       exit(0);
   }
   else if (firstToken == "HELP") {
       dspHelp();
   }
   else if (firstToken == "CLEAR") {
       program.clear();
   }
   else if (firstToken == "LIST") {
       listCmd(program);
   }
   else if (firstToken == "INPUT" || firstToken == "PRINT" || firstToken == "LET") {
       scanner.saveToken(firstToken);
       Statement * stmt = parseStatement(scanner);
       stmt->execute(state);
       delete stmt;
   }
   else {
       int lineNumber = stringToInteger(firstToken);
       if (!scanner.hasMoreTokens()) {
           program.removeSourceLine(lineNumber);
       }
       else {
           int length = firstToken.length();
           string source = line.substr(length);
           program.addSourceLine(lineNumber, source);
           Statement * stmt = parseStatement(scanner);
           program.setParsedStatement(lineNumber, stmt);
       }
   }
}

void interpreter(void) {
	std::string line;
	TokenScanner scanner;
	scanner.ignoreWhitespace();
	scanner.scanNumbers();
	Map<std::string, std::string> symbolTable;

	cout << "Interpreter is running: " << endl;

	// Main loop:
	std::string key, value;
	while(true) {
		cout << "> ";
		line = getLine();

		if(line == "quit")
			break;

		else if(line == "list") {
			for(std::string key : symbolTable) {
				cout << key << " = " << symbolTable.get(key) << endl;
			}
		}

		else if(symbolTable.containsKey(line))
			cout << symbolTable.get(line) << endl;

		// Parse statements:
		else {
			scanner.setInput(line);
			bool isValue = false;
			while(scanner.hasMoreTokens()) {
				std::string token = scanner.nextToken();
				if(isValue)
					value = token;
				else if(token == "=")
					isValue = true;
				else
					key = token;
			}
			symbolTable.add(key, value);
		}
	}

	cout << "Interpreter is stopped." << endl;
}