Symbol parseSwitchStatement(CharacterSource* source) { Span startSpan; static String switchKeyword("switch"); if (!Space::parseKeyword(source, switchKeyword, &startSpan)) return Symbol(); Span span; Space::assertCharacter(source, '(', &span); Symbol expression = parseExpressionOrFail(source); Space::assertCharacter(source, ')', &span); Space::assertCharacter(source, '{', &span); Symbol defaultCase; CharacterSource s = *source; SymbolList cases; do { Symbol c = parseCase(source); if (!c.valid()) break; if (c.atom() == atomDefaultCase) { if (defaultCase.valid()) s.location().throwError( "This switch statement already has a default case"); defaultCase = c; } else cases.add(c); } while (true); Space::assertCharacter(source, '}', &span); return Symbol(atomSwitchStatement, expression, defaultCase, SymbolArray(cases), newSpan(startSpan + span)); }
/*** Parse a statement ***/ Node* Parser::parseStatement() { if(hasTokens(2) && peekToken().getType() == T_IDENTIFIER && peekToken(2).getType() == T_ASSIGN) return parseAssign(); if(hasTokens(2) && peekToken().getType() == T_IDENTIFIER && peekToken(2).getType() == T_LPAREN) return parseCall(); if(hasTokens() && peekToken().getType() == T_CALL) return parseCall(); if(hasTokens() && peekToken().getType() == T_CASE) return parseCase(); if(hasTokens() && peekToken().getType() == T_DO) return parseDo(); if(hasTokens() && peekToken().getType() == T_END) return parseEnd(); if(hasTokens() && peekToken().getType() == T_EXIT) return parseExit(); if(hasTokens() && peekToken().getType() == T_FOR) return parseFor(); if(hasTokens() && peekToken().getType() == T_IF) return parseIf(); if(hasTokens() && peekToken().getType() == T_INPUT) return parseInput(); if(hasTokens() && peekToken().getType() == T_OUTPUT) return parseOutput(); if(hasTokens() && peekToken().getType() == T_REPEAT) return parseRepeat(); if(hasTokens() && peekToken().getType() == T_RETURN) return parseReturn(); if(hasTokens(2) && peekToken(1).getType() == T_IDENTIFIER && peekToken(2).getType() == T_LBRACKET) return parseSliceSelectAssign(); if(hasTokens() && peekToken().getType() == T_WHILE) return parseWhile(); throw ParserSyntaxException(getToken(), "Invalid statement!"); return 0; }
//Core Method shared_ptr<Statement> Parser::parseStatement() { Tag tags[] = { EQ, UNEQ, LT, GT, LE, GE }; auto isRealOp = [&](Tag t){ for (auto i : tags) { if (t == i) { return true; } } return false; }; switch (it->tag) { //VAR,TYPE,Function call,If,Else,While,For,有的可改变currNode,有的不可 /*case BEGIN: break;*/ case IDENT://此处默认为赋值表达式,实际上大错特错,如果是 函数调用 何如? if (advance(BIND)) { shared_ptr<AssignStmt> assign = parseAssign(); //currNode->addNode(assign); return assign; } else if (advance(OpenBracket)) { shared_ptr<FuncCall> funcCall = parseFunctionCall(); //currNode->addNode(funcCall); return funcCall; } //暂不支持嵌套函数 /*case FUNCTION: break; case PROCEDURE: break;*/ case IF: { shared_ptr<Node> tmp = currNode; shared_ptr<IfStmt> ifstmt = static_pointer_cast<IfStmt>(parseIf()); currNode = tmp; //currNode->addNode(ifstmt); return ifstmt; } case WHILE: { shared_ptr<Node> tmp = currNode; shared_ptr<WhileStmt> whStmt = static_pointer_cast<WhileStmt>(parseWhile()); currNode = tmp; //currNode->addNode(whStmt); return whStmt; } case REPEAT: { shared_ptr<Node> tmp = currNode; shared_ptr<RepeatStmt> repeatStmt = static_pointer_cast<RepeatStmt>(parseRepeat()); currNode = tmp; //currNode->addNode(repeatStmt); return repeatStmt; } case FOR: { shared_ptr<Node> tmp = currNode; shared_ptr<ForStmt> forStmt = static_pointer_cast<ForStmt>(parseFor()); currNode = tmp; //currNode->addNode(forStmt); return forStmt; } case CASE: { shared_ptr<Node> tmp = currNode; shared_ptr<CaseStmt> caseStmt = static_pointer_cast<CaseStmt>(parseCase()); currNode = tmp; //currNode->addNode(caseStmt); return caseStmt; } default: return NULL; } return NULL; }
// --------------------------------------------------------------------------- // Program entry point // --------------------------------------------------------------------------- int main(int argC, char* argV[]) { // Check command line and extract arguments. if (argC < 2) { usage(); return 1; } memset(localeStr, 0, sizeof localeStr); int argInd; for (argInd = 1; argInd < argC; argInd++) { // Break out on first parm not starting with a dash if (argV[argInd][0] != '-') break; // Watch for special case help request if (!strcmp(argV[argInd], "-?")) { usage(); return 2; } else if (!strncmp(argV[argInd], "-v=", 3) || !strncmp(argV[argInd], "-V=", 3)) { const char* const parm = &argV[argInd][3]; if (!strcmp(parm, "never")) valScheme = SAX2XMLReader::Val_Never; else if (!strcmp(parm, "auto")) valScheme = SAX2XMLReader::Val_Auto; else if (!strcmp(parm, "always")) valScheme = SAX2XMLReader::Val_Always; else { XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl; return 2; } } else if (!strcmp(argV[argInd], "-n") || !strcmp(argV[argInd], "-N")) { doNamespaces = false; } else if (!strcmp(argV[argInd], "-s") || !strcmp(argV[argInd], "-S")) { doSchema = false; } else if (!strcmp(argV[argInd], "-f") || !strcmp(argV[argInd], "-F")) { schemaFullChecking = true; } else if (!strcmp(argV[argInd], "-l") || !strcmp(argV[argInd], "-L")) { doList = true; } else if (!strcmp(argV[argInd], "-p") || !strcmp(argV[argInd], "-P")) { namespacePrefixes = true; } else if (!strcmp(argV[argInd], "-special:nel")) { // turning this on will lead to non-standard compliance behaviour // it will recognize the unicode character 0x85 as new line character // instead of regular character as specified in XML 1.0 // do not turn this on unless really necessary recognizeNEL = true; } else if (!strncmp(argV[argInd], "-locale=", 8)) { // Get out the end of line strcpy(localeStr, &(argV[argInd][8])); } else { XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd] << "', ignoring it\n" << XERCES_STD_QUALIFIER endl; } } // // There should at least one parameter left, and that // should be the file name(s). // if (argInd == argC) { usage(); return 1; } // Initialize the XML4C2 system try { if (strlen(localeStr)) { XMLPlatformUtils::Initialize(localeStr); } else { XMLPlatformUtils::Initialize(); } if (recognizeNEL) { XMLPlatformUtils::recognizeNEL(recognizeNEL); } } catch (const XMLException& toCatch) { XERCES_STD_QUALIFIER cerr << "Error during initialization! Message:\n" << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl; return 1; } XERCES_STD_QUALIFIER ifstream fin; // the input is a list file if (doList) fin.open(argV[argInd]); if (fin.fail()) { XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER endl; return 2; } while (true) { char fURI[1000]; //initialize the array to zeros memset(fURI,0,sizeof(fURI)); if (doList) { if (! fin.eof() ) { fin.getline (fURI, sizeof(fURI)); if (!*fURI) continue; else { xmlFile = fURI; XERCES_STD_QUALIFIER cerr << "==Parsing== " << xmlFile << XERCES_STD_QUALIFIER endl; } } else break; } else { if (argInd < argC) { xmlFile = argV[argInd]; argInd++; } else break; } parseCase(xmlFile); } if (doList) fin.close(); // And call the termination method XMLPlatformUtils::Terminate(); if (errorOccurred) return 4; else return 0; }