// Create as much of the parse tree as possible. public override int CreateParseSubTree(ref CLexicalAnalyzer plexAnal, ref CSymbolTable pSymbolTable) { CExpParser expParser = new CExpParser(); CToken pToken = null; //try { m_pIfExpression = expParser.ParseExpression(ref plexAnal, ref pSymbolTable, STMT_EXPR_TYPE.EXPR_ASSIGN, false); if (m_pIfExpression == null) { //throw (C_IF_ERROR_MISSINGEXP); } //Munch a <?> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || !((pToken.GetType() == RUL_TOKEN_TYPE.RUL_SYMBOL) && (pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_QMARK))) { //throw (C_RS_ERROR_MISSINGSC); } m_pTrueExpression = expParser.ParseExpression(ref plexAnal, ref pSymbolTable, STMT_EXPR_TYPE.EXPR_ASSIGN, false); if (m_pTrueExpression == null) { //throw (C_RS_ERROR_MISSINGSC); } //Munch a <:> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || !((pToken.GetType() == RUL_TOKEN_TYPE.RUL_SYMBOL) && (pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_COLON))) { //throw (C_RS_ERROR_MISSINGSC); } m_pFalseExpression = expParser.ParseExpression(ref plexAnal, ref pSymbolTable, STMT_EXPR_TYPE.EXPR_ASSIGN, false); //Vibhor 110205: Changed from EXPR_FOR if (m_pFalseExpression == null) { //throw (C_RS_ERROR_MISSINGSC); } //Munch a <;> /* if((LEX_FAIL == plexAnal.GetNextToken(&pToken,pSymbolTable)) || !pToken || !pToken.IsEOS()) || { || throw(C_RS_ERROR_MISSINGSC); || }*/ return(0); } /* * catch (...) * { * return PARSE_FAIL; * } * return 0; */ }
// Create as much of the parse tree as possible. public override int CreateParseSubTree(ref CLexicalAnalyzer plexAnal, ref CSymbolTable pSymbolTable) { CToken pToken = null; //try { //Munch a <FOR> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || !pToken.IsFORStatement()) { //throw (C_UM_ERROR_INTERNALERR); } //Munch a <(> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || !(pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_LPAREN)) { //ADD_ERROR(C_WHILE_ERROR_MISSINGLP); plexAnal.UnGetToken(); } //Munch a Initialization Statement... CParserBuilder builder = new CParserBuilder(); m_pInitializationStatement = (CAssignmentStatement)builder.CreateParser(ref plexAnal, STATEMENT_TYPE.STMT_asic); if (null != (m_pInitializationStatement)) { m_pInitializationStatement.CreateParseSubTree(ref plexAnal, ref pSymbolTable); } else { //Munch a <;> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || !(pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_SEMICOLON)) { //ADD_ERROR(C_WHILE_ERROR_MISSINGLP); plexAnal.UnGetToken(); } } //Munch & Parse the expression. //we got to give the expression string to the expression parser. // CParserBuilder builder2 = new CParserBuilder(); CExpParser expParser = new CExpParser(); CGrammarNode pNode; pNode = builder2.CreateParser(ref plexAnal, STATEMENT_TYPE.STMT_asic); m_pExpression = null; m_pExpressionStatement = null; if (null != pNode) { expressionNodeType = pNode.GetNodeType(); if (expressionNodeType == GRAMMAR_NODE_TYPE.NODE_TYPE_ASSIGN) { expressionNodeType = GRAMMAR_NODE_TYPE.NODE_TYPE_ASSIGN; m_pExpressionStatement = (CAssignmentStatement)pNode; m_pExpressionStatement.CreateParseSubTree(ref plexAnal, ref pSymbolTable, STATEMENT_TYPE.STMT_asic); } else if (expressionNodeType == GRAMMAR_NODE_TYPE.NODE_TYPE_EXPRESSION) { expressionNodeType = GRAMMAR_NODE_TYPE.NODE_TYPE_EXPRESSION; m_pExpression = expParser.ParseExpression(ref plexAnal, ref pSymbolTable, STMT_EXPR_TYPE.EXPR_FOR); if (m_pExpression == null) { //ADD_ERROR(C_WHILE_ERROR_MISSINGEXP); } } else if (expressionNodeType == GRAMMAR_NODE_TYPE.NODE_TYPE_INVALID) { pToken = null; //try { if ((CLexicalAnalyzer.LEX_FAIL != (plexAnal.LookAheadToken(ref pToken))) && pToken != null) { if ((pToken.GetType() == RUL_TOKEN_TYPE.RUL_SYMBOL) && (pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_SEMICOLON)) { // This code is to handle for(;;) for Yokagawa EJX expressionNodeType = GRAMMAR_NODE_TYPE.NODE_TYPE_EXPRESSION; CToken pToken2 = new CToken("1"); pToken2.SetType(RUL_TOKEN_TYPE.RUL_NUMERIC_CONSTANT); m_pExpression = new CPrimaryExpression(pToken2); } } } /* * catch (...) * { * } */ } } else { //ADD_ERROR(C_WHILE_ERROR_MISSINGSTMT); } //Munch a <;> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || !(pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_SEMICOLON)) { //ADD_ERROR(C_WHILE_ERROR_MISSINGLP); plexAnal.UnGetToken(); } //Munch a Increment Statement... pNode = builder2.CreateParser(ref plexAnal, STATEMENT_TYPE.STMT_asic); m_pIncrementExpression = null; m_pIncrementStatement = null; if (null != pNode) { incrementNodeType = pNode.GetNodeType(); if (incrementNodeType == GRAMMAR_NODE_TYPE.NODE_TYPE_ASSIGN) { incrementNodeType = GRAMMAR_NODE_TYPE.NODE_TYPE_ASSIGN; m_pIncrementStatement = (CAssignmentStatement)pNode; m_pIncrementStatement.CreateParseSubTree(ref plexAnal, ref pSymbolTable, STATEMENT_TYPE.STMT_ASSIGNMENT_FOR); } else if (incrementNodeType == GRAMMAR_NODE_TYPE.NODE_TYPE_EXPRESSION) { incrementNodeType = GRAMMAR_NODE_TYPE.NODE_TYPE_EXPRESSION; m_pIncrementExpression = expParser.ParseExpression(ref plexAnal, ref pSymbolTable, STMT_EXPR_TYPE.EXPR_FOR); if (m_pIncrementExpression == null) { //ADD_ERROR(C_WHILE_ERROR_MISSINGEXP); } } } else { //ADD_ERROR(C_WHILE_ERROR_MISSINGSTMT); } //Munch a <)> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || !(pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_RPAREN)) { //ADD_ERROR(C_WHILE_ERROR_MISSINGLP); plexAnal.UnGetToken(); } //Munch the statement CParserBuilder builder3 = new CParserBuilder(); m_pStatement = (CStatement)builder.CreateParser(ref plexAnal, STATEMENT_TYPE.STMT_asic); if (null != (m_pStatement)) { m_pStatement.CreateParseSubTree(ref plexAnal, ref pSymbolTable); } else { //ADD_ERROR(C_WHILE_ERROR_MISSINGSTMT); } return(1); } /* * catch (CRIDEError* perr) * { * pvecErrors.push_back(perr); * plexAnal.MovePast( * RUL_SYMBOL, * RUL_SEMICOLON, * pSymbolTable); * } * catch (...) * { * throw (C_UM_ERROR_UNKNOWNERROR); * } * return PARSE_FAIL; */ }
public CGrammarNode CreateParser(ref CLexicalAnalyzer plexAnal, STATEMENT_TYPE stmt_type) { CGrammarNode pNode = null; CToken pToken = null; if ((CLexicalAnalyzer.LEX_FAIL != (plexAnal.LookAheadToken(ref pToken))) && pToken != null) { if (((stmt_type == STATEMENT_TYPE.STMT_DECL) || (stmt_type == STATEMENT_TYPE.STMT_asic)) && ((pToken.GetType() == RUL_TOKEN_TYPE.RUL_SYMBOL) && (pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_SEMICOLON))) { pNode = new CEmptyStatement(); } else if ( ((stmt_type == STATEMENT_TYPE.STMT_DECL) || (stmt_type == STATEMENT_TYPE.STMT_asic)) && ((pToken.GetType() == RUL_TOKEN_TYPE.RUL_SYMBOL) && (pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_LPAREN)) ) { pNode = new CExpression(); } else if (((stmt_type == STATEMENT_TYPE.STMT_DECL) || (stmt_type == STATEMENT_TYPE.STMT_asic)) && pToken.IsDeclaration()) //Declaration Statement { pNode = new CDeclaration(); } else if (((stmt_type == STATEMENT_TYPE.STMT_asic)) && (RUL_TOKEN_TYPE.RUL_KEYWORD == pToken.GetType()) && !pToken.IsIteration() && !pToken.IsFunctionToken()) { if (pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_IF)// IF Selection Statement { pNode = new CSelectionStatement(); } else if (pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_SWITCH)//SWITCH Statement { pNode = new CSwitchStatement(); } else if (RUL_TOKEN_TYPE.RUL_KEYWORD == pToken.GetType() && RUL_TOKEN_SUBTYPE.RUL_RULE_ENGINE == pToken.GetSubType()) //Rule Statement { pNode = new CRuleServiceStatement(); } else if (RUL_TOKEN_TYPE.RUL_KEYWORD == pToken.GetType() && RUL_TOKEN_SUBTYPE.RUL_BREAK == pToken.GetSubType()) //break Statement { pNode = new CBreakStatement(); } else if (RUL_TOKEN_TYPE.RUL_KEYWORD == pToken.GetType() && RUL_TOKEN_SUBTYPE.RUL_CONTINUE == pToken.GetSubType()) //continue Statement { pNode = new CContinueStatement(); } else if (RUL_TOKEN_TYPE.RUL_KEYWORD == pToken.GetType() && RUL_TOKEN_SUBTYPE.RUL_RETURN == pToken.GetSubType()) //continue Statement { pNode = new CReturnStatement(); } } else if (((stmt_type == STATEMENT_TYPE.STMT_ITERATION) || (stmt_type == STATEMENT_TYPE.STMT_asic)) && pToken.IsIteration()) //Iteration Statement { if (pToken.IsWHILEStatement()) { pNode = new CIterationStatement(); } else if (pToken.IsDOStatement()) { pNode = new CIterationDoWhileStatement(); } else if (pToken.IsFORStatement()) { pNode = new CIterationForStatement(); } } else if (((stmt_type == STATEMENT_TYPE.STMT_ASSIGNMENT) || (stmt_type == STATEMENT_TYPE.STMT_asic)) && (pToken.IsFunctionToken())) //Assignment Statement { pNode = new CExpression(); } else if (((stmt_type == STATEMENT_TYPE.STMT_ASSIGNMENT) || (stmt_type == STATEMENT_TYPE.STMT_asic)) && (pToken.IsVariable() || pToken.IsArrayVar() || pToken.IsDDItem() ||//Added By Anil August 4 2005 pToken.IsOMToken() || pToken.IsNumeric() || pToken.IsConstant() || pToken.IsFunctionToken() || pToken.IsOperator() || ((pToken.GetType() == RUL_TOKEN_TYPE.RUL_SYMBOL) && (pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_LPAREN)) )) //Assignment Statement { CToken pNewToken = null; //TSRPRASAD 09MAR2004 Fix the memory leaks */ bool bLineIsAssignment = false; if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ARITHMETIC_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_PLUS_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } else if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ASSIGNMENT_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_MINUS_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } else if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ASSIGNMENT_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_DIV_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } else if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ASSIGNMENT_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_MOD_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } else if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ASSIGNMENT_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_MUL_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } else if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ASSIGNMENT_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_BIT_AND_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } else if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ASSIGNMENT_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_BIT_OR_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } else if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ASSIGNMENT_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_BIT_XOR_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } else if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ASSIGNMENT_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_BIT_RSHIFT_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } else if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ASSIGNMENT_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_BIT_LSHIFT_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } else if (plexAnal.ScanLineForToken(RUL_TOKEN_TYPE.RUL_ASSIGNMENT_OPERATOR, RUL_TOKEN_SUBTYPE.RUL_ASSIGN, ref pNewToken)) //TSRPRASAD 09MAR2004 Fix the memory leaks */ { bLineIsAssignment = true; } if (bLineIsAssignment) { pNode = new CAssignmentStatement(); } else { pNode = new CExpression(); } } else if (((stmt_type == STATEMENT_TYPE.STMT_ASSIGNMENT) || (stmt_type == STATEMENT_TYPE.STMT_asic)) && pToken.IsFunctionToken()) //Assignment Statement { pNode = new CAssignmentStatement(); } else if (((stmt_type == STATEMENT_TYPE.STMT_COMPOUND) || (stmt_type == STATEMENT_TYPE.STMT_asic)) && pToken.IsCompound()) //Compound Statement { pNode = new CCompoundStatement(); } else if (((stmt_type == STATEMENT_TYPE.STMT_SERVICE) || (stmt_type == STATEMENT_TYPE.STMT_asic) || (stmt_type == STATEMENT_TYPE.STMT_ASSIGNMENT_FOR)) && pToken.IsService()) //Service Statement { pNode = new CServiceStatement(); } else if (((stmt_type == STATEMENT_TYPE.STMT_SELECTION)) && (RUL_TOKEN_TYPE.RUL_KEYWORD == pToken.GetType())) { if ((pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_CASE) || (pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_DEFAULT))//CASE or DEFAULT Statement { pNode = new CCASEStatement(); } else if (pToken.GetSubType() == RUL_TOKEN_SUBTYPE.RUL_ELSE)//ELSE Statement { pNode = new CELSEStatement(); } } else { //error //the natural control flow is allowed to take care of this //erroneous condition. } } return(pNode); }
// Create as much of the parse tree as possible. public override int CreateParseSubTree(ref CLexicalAnalyzer plexAnal, ref CSymbolTable pSymbolTable) { CToken pToken = new CToken(); CToken pSymToken = null; //try { if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null) { //throw (C_UM_ERROR_INTERNALERR); } RUL_TOKEN_SUBTYPE SubType = pToken.GetSubType(); bool lboxState = false; bool rboxState = false; bool numState = false; bool idState = true; bool commaState = false; CToken pArrToken = null; int dimCnt = 0; // stevev 25apr13 - we have to reuse bracket scoped arrays while ((CLexicalAnalyzer.LEX_FAIL != plexAnal.GetNextVarToken(ref pToken, ref pSymbolTable, SubType)) && pToken != null && (!pToken.IsEOS())) { int idex = 0; CVariable cv = pSymbolTable.Find(pToken.GetLexeme(), ref idex); if (cv != null) { pSymToken = cv.Token; } if ((!pToken.IsSymbol() && pSymToken != null) || (RUL_TOKEN_SUBTYPE.RUL_LBOX == pToken.GetSubType()) || (RUL_TOKEN_SUBTYPE.RUL_RBOX == pToken.GetSubType()) || (pToken.IsNumeric())) { if (pToken.IsArrayVar()) { lboxState = true; rboxState = false; numState = false; idState = false; commaState = false; pSymToken.SetSubType(SubType); //Make a copy of the array Token pArrToken = new CToken(pToken); } else if (lboxState) { if (pToken.GetSubType() != RUL_TOKEN_SUBTYPE.RUL_LBOX) { //ADD_ERROR(C_DECL_ERROR_LBOX); plexAnal.SynchronizeTo(PRODUCTION.DECLARATION, pSymbolTable); } lboxState = false; rboxState = true; numState = false; idState = false; commaState = false; } else if (rboxState) { if ((null == pArrToken) || !pToken.IsNumeric()) { //ADD_ERROR(C_DECL_ERROR_NUM); plexAnal.SynchronizeTo(PRODUCTION.DECLARATION, pSymbolTable); } lboxState = false; rboxState = false; numState = true; idState = false; commaState = false; //This is a number and with pArrToken get the symbol table token int i32Idx = pArrToken.GetSymbolTableIndex(); CVariable pVar = pSymbolTable.GetAt(i32Idx); //INTER_VARIANT varArray = pVar.GetValue(); VARIANT_TYPE vtSafeArray = new VARIANT_TYPE(); //increment the dimension and set the limit of that dimension if (pVar.GetValue().GetVarType() != VARIANT_TYPE.RUL_SAFEARRAY || dimCnt == 0)// stevev 25apr13 { // WS:EMP-17jul07:varArray.Clear(); // WS:EMP-17jul07:varArray.varType = RUL_SAFEARRAY; // WS:EMP-17jul07:__VAL& val = (__VAL&)varArray.GetValue(); // stevev-14feb08:make it more flexible...INTER_SAFEARRAYBOUND rgbound[1] = {atoi(pToken.GetLexeme())}; INTER_SAFEARRAYBOUND rgbound = new INTER_SAFEARRAYBOUND(); rgbound.cElements = Convert.ToUInt32(pToken.GetLexeme()); //INTER_SAFEARRAYBOUND rgbound[1] = { strtoul(pToken->GetLexeme(), NULL, 0) }; INTER_SAFEARRAY sa = new INTER_SAFEARRAY(); // WS:EMP-17jul07 was::>val.prgsa = new INTER_SAFEARRAY(); ushort cDims = 0; // WS:EMP-17jul07 was::>_USHORT cDims = (val.prgsa).GetDims(); TokenType_to_VariantType(pToken.GetType(), SubType, ref vtSafeArray); // WS:EMP-17jul07 was::>(val.prgsa).SetAllocationParameters(vtSafeArray, ++cDims, rgbound); sa.SetAllocationParameters(vtSafeArray, ++cDims, rgbound); sa.Allocate(); // stevev 11jun09 - get rid of error message, destructor will deallocate //varArray = sa; // added WS:EMP-17jul07 pVar.GetValue().SetValue(sa); pSymbolTable.SetAt(i32Idx, pVar); dimCnt = 1; } else// isa RUL_SAFEARRAY && dimCnt > 0 { __VAL val = pVar.GetValue().GetValue(); //INTER_SAFEARRAYBOUND rgbound[1] = { strtoul(pToken.GetLexeme(), NULL, 0) }; INTER_SAFEARRAYBOUND rgbound = new INTER_SAFEARRAYBOUND(); rgbound.cElements = 3; (val.prgsa).AddDim(rgbound); dimCnt++; } } else if (numState) { if (pToken.GetSubType() != RUL_TOKEN_SUBTYPE.RUL_RBOX) { //ADD_ERROR(C_DECL_ERROR_RBOX); plexAnal.SynchronizeTo(PRODUCTION.DECLARATION, pSymbolTable); } //accept a Right box. lboxState = true; rboxState = false; numState = false; commaState = true; idState = false; } else { if (idState) { if (pToken.GetType() != RUL_TOKEN_TYPE.RUL_SIMPLE_VARIABLE) { //ADD_ERROR(C_DECL_ERROR_IDMISSING); plexAnal.SynchronizeTo(PRODUCTION.DECLARATION, pSymbolTable); } pSymToken.SetSubType(SubType); } else { //ADD_ERROR(C_DECL_ERROR_COMMAMISSING); plexAnal.SynchronizeTo(PRODUCTION.DECLARATION, pSymbolTable); } lboxState = false; rboxState = false; numState = false; idState = false; commaState = true; } } else if (commaState) { if (pToken.GetSubType() != RUL_TOKEN_SUBTYPE.RUL_COMMA) { //ADD_ERROR(C_DECL_ERROR_COMMAMISSING); plexAnal.SynchronizeTo(PRODUCTION.DECLARATION, pSymbolTable); } idState = true; commaState = false; lboxState = false; rboxState = false; numState = false; } else { //Of course, this is a problem case. //Unfortunately, expressions in the declarations are not handled //ADD_ERROR(C_DECL_ERROR_EXPRESSION); plexAnal.SynchronizeTo(PRODUCTION.DECLARATION, pSymbolTable); //accept a Right box. //VMKP added on 030404 /* Synchronizing was not proper when an expression * present in the variable declaration, With that the * below lines one declaration next to the expression * declaration is skipping */ lboxState = true; rboxState = false; numState = false; commaState = true; idState = false; } }//end of while loop //Validate the exit criteria... if (!(rboxState == numState == idState == false) || !(commaState == true)) { //ADD_ERROR(C_DECL_ERROR_UNKNOWN); plexAnal.SynchronizeTo(PRODUCTION.DECLARATION, pSymbolTable); } return(1); } /* * catch (CRIDEError* perr) * { * pvecErrors.push_back(perr); * plexAnal.MovePast( * RUL_SYMBOL, * RUL_SEMICOLON, * pSymbolTable); * } * catch (...) * { * throw (C_UM_ERROR_UNKNOWNERROR); * } * * return PARSE_FAIL; */ }
public void setCVariable(CToken pToken) { Token = pToken; m_Value = new INTER_VARIANT(); RUL_TOKEN_TYPE Type = pToken.GetType(); RUL_TOKEN_SUBTYPE SubType = pToken.GetSubType(); if (Type == RUL_TOKEN_TYPE.RUL_SIMPLE_VARIABLE) { byte[] data; switch (SubType) { case RUL_TOKEN_SUBTYPE.RUL_CHAR_DECL: data = BitConverter.GetBytes(' '); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_CHAR); // = (char)' '; break; case RUL_TOKEN_SUBTYPE.RUL_LONG_LONG_DECL: //m_Value = (Int64)0; data = BitConverter.GetBytes((Int64)0); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_LONGLONG); // = (char)' '; break; // Walt EPM 08sep08 - added case RUL_TOKEN_SUBTYPE.RUL_UNSIGNED_SHORT_INTEGER_DECL: //m_Value = (ushort)0; data = BitConverter.GetBytes((ushort)0); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_USHORT); // = (char)' '; break; case RUL_TOKEN_SUBTYPE.RUL_SHORT_INTEGER_DECL: //m_Value = (short)0; data = BitConverter.GetBytes((short)0); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_SHORT); // = (char)' '; break; case RUL_TOKEN_SUBTYPE.RUL_UNSIGNED_INTEGER_DECL: //m_Value = (uint)0; data = BitConverter.GetBytes((uint)0); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_UINT); // = (char)' '; break; // Walt EPM 08sep08 - end added case RUL_TOKEN_SUBTYPE.RUL_INTEGER_DECL: case RUL_TOKEN_SUBTYPE.RUL_LONG_DECL: //m_Value = (long)0; data = BitConverter.GetBytes((int)0); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_INT); // = (char)' '; break; case RUL_TOKEN_SUBTYPE.RUL_BOOLEAN_DECL: //m_Value = (bool)false; data = BitConverter.GetBytes(false); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_BOOL); // = (char)' '; break; case RUL_TOKEN_SUBTYPE.RUL_REAL_DECL: //m_Value = (float)0.0; data = BitConverter.GetBytes((float)0.0); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_FLOAT); // = (char)' '; break; case RUL_TOKEN_SUBTYPE.RUL_DOUBLE_DECL: //m_Value = (double)0.0;//WS:EPM 10aug07 data = BitConverter.GetBytes((double)0); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_DOUBLE); // = (char)' '; break; case RUL_TOKEN_SUBTYPE.RUL_STRING_DECL: case RUL_TOKEN_SUBTYPE.RUL_DD_STRING_DECL: //Added By Anil July 07 2005 //m_Value = (string)""; data = System.Text.Encoding.Default.GetBytes(""); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_DD_STRING); // = (char)' '; break; case RUL_TOKEN_SUBTYPE.RUL_UNSIGNED_CHAR_DECL: //m_Value = (byte)' ';//WHS EP June17-2008 have changed this to make sure that it works for all data types data = BitConverter.GetBytes(' '); m_Value.SetValue(data, 0, VARIANT_TYPE.RUL_UNSIGNED_CHAR); // = (char)' '; break; } } }
// Create as much of the parse tree as possible. public override int CreateParseSubTree(ref CLexicalAnalyzer plexAnal, ref CSymbolTable pSymbolTable) { CToken pToken = null; //try { //Munch a <RuleEngine> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || (RUL_TOKEN_TYPE.RUL_KEYWORD != pToken.GetType()) || (RUL_TOKEN_SUBTYPE.RUL_RULE_ENGINE != pToken.GetSubType())) { //throw (C_UM_ERROR_INTERNALERR); } //Munch a <::> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || (RUL_TOKEN_TYPE.RUL_SYMBOL != pToken.GetType()) || RUL_TOKEN_SUBTYPE.RUL_SCOPE != pToken.GetSubType()) { //ADD_ERROR(C_RS_ERROR_MISSINGSCOPE); plexAnal.UnGetToken(); } //Munch a <Invoke> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || (RUL_TOKEN_TYPE.RUL_KEYWORD != pToken.GetType()) || (RUL_TOKEN_SUBTYPE.RUL_INVOKE != pToken.GetSubType())) { //ADD_ERROR(C_RS_ERROR_MISSINGINVOKE); plexAnal.UnGetToken(); } //Munch a <(> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || (RUL_TOKEN_TYPE.RUL_SYMBOL != pToken.GetType()) || RUL_TOKEN_SUBTYPE.RUL_LPAREN != pToken.GetSubType()) { //ADD_ERROR(C_RS_ERROR_MISSINGLPAREN); plexAnal.UnGetToken(); } //Munch a <RuleName> -- this is a string if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || (RUL_TOKEN_SUBTYPE.RUL_STRING_CONSTANT != pToken.GetSubType() && RUL_TOKEN_SUBTYPE.RUL_STRING_DECL != pToken.GetSubType())) { //ADD_ERROR(C_RS_ERROR_MISSINGRNAME); plexAnal.UnGetToken(); } m_pRuleName = pToken; pToken = null; //Munch a <)> if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || RUL_TOKEN_SUBTYPE.RUL_RPAREN != pToken.GetSubType()) { //ADD_ERROR(C_RS_ERROR_MISSINGRPAREN); plexAnal.UnGetToken(); } if ((CLexicalAnalyzer.LEX_FAIL == plexAnal.GetNextToken(ref pToken, ref pSymbolTable)) || pToken == null || (RUL_TOKEN_SUBTYPE.RUL_SEMICOLON != pToken.GetSubType())) { //ADD_ERROR(C_RS_ERROR_MISSINGSC); plexAnal.UnGetToken(); } return(1); } /* * catch (CRIDEError* perr) * { * pvecErrors.push_back(perr); * plexAnal.MovePast( * RUL_TOKEN_TYPE.RUL_SYMBOL, * RUL_TOKEN_TYPE.RUL_SEMICOLON, * pSymbolTable); * } * catch (...) * { * //throw (C_UM_ERROR_UNKNOWNERROR); * } * return PARSE_FAIL; */ }