/** \brief Check whether the token at a given position is a function token. \param a_Tok [out] If a value token is found it will be placed here. \throw ParserException if Syntaxflags do not allow a function at a_iPos \return true if a function token has been found false otherwise. \pre [assert] m_pParser!=0 */ bool ParserTokenReader::IsFunTok(token_type &a_Tok) { string_type strTok; int iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos); if (iEnd==m_iPos) return false; funmap_type::const_iterator item = m_pFunDef->find(strTok); if (item==m_pFunDef->end()) return false; // Check if the next sign is an opening bracket const char_type *szFormula = m_strFormula.c_str(); if (szFormula[iEnd]!='(') return false; a_Tok.Set(item->second, strTok); m_iPos = (int)iEnd; if (m_iSynFlags & noFUN) Error(ecUNEXPECTED_FUN, m_iPos-(int)a_Tok.GetAsString().length(), a_Tok.GetAsString()); m_iSynFlags = noANY ^ noBO; return true; }
bool isSkipCharacter(char_type ch) const { for (typename token_type::const_iterator itor = skipTokens.begin(); itor != skipTokens.end(); ++itor) { if (*itor == ch) return true; } return false; }
/** \brief Check whether the token at a given position is a value token. Value tokens are either values or constants. \param a_Tok [out] If a value token is found it will be placed here. \return true if a value token has been found. */ bool ParserTokenReader::IsValTok(token_type &a_Tok) { assert(m_pConstDef); assert(m_pParser); string_type strTok; value_type fVal(0); int iEnd(0); // 2.) Check for user defined constant // Read everything that could be a constant name iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos); if (iEnd!=m_iPos) { valmap_type::const_iterator item = m_pConstDef->find(strTok); if (item!=m_pConstDef->end()) { m_iPos = iEnd; a_Tok.SetVal(item->second, strTok); if (m_iSynFlags & noVAL) Error(ecUNEXPECTED_VAL, m_iPos - (int)strTok.length(), strTok); m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN; return true; } } // 3.call the value recognition functions provided by the user // Call user defined value recognition functions std::list<identfun_type>::const_iterator item = m_vIdentFun.begin(); for (item = m_vIdentFun.begin(); item!=m_vIdentFun.end(); ++item) { int iStart = m_iPos; if ( (*item)(m_strFormula.c_str() + m_iPos, &m_iPos, &fVal)==1 ) { strTok.assign(m_strFormula.c_str(), iStart, m_iPos); if (m_iSynFlags & noVAL) Error(ecUNEXPECTED_VAL, m_iPos - (int)strTok.length(), strTok); a_Tok.SetVal(fVal, strTok); m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN; return true; } } return false; }
/** \brief Check wheter a token at a given position is a variable token. \param a_Tok [out] If a variable token has been found it will be placed here. \return true if a variable token has been found. */ bool ParserTokenReader::IsVarTok(token_type &a_Tok) { if (!m_pVarDef->size()) return false; string_type strTok; int iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos); if (iEnd==m_iPos) return false; varmap_type::const_iterator item = m_pVarDef->find(strTok); if (item==m_pVarDef->end()) return false; if (m_iSynFlags & noVAR) Error(ecUNEXPECTED_VAR, m_iPos, strTok); m_pParser->OnDetectVar(&m_strFormula, m_iPos, iEnd); m_iPos = iEnd; a_Tok.SetVar(item->second, strTok); m_UsedVar[item->first] = item->second; // Add variable to used-var-list m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR; // Zur Info hier die SynFlags von IsVal(): // m_iSynFlags = noVAL | noVAR | noFUN | noBO | noINFIXOP | noSTR | noASSIGN; return true; }
static token_type change_value( const string_type& value_, const token_type& t_ ) { return token_type(t_, value_, t_.get_position()); }
/** \brief Check wheter a token at a given position is a string. \param a_Tok [out] If a variable token has been found it will be placed here. \return true if a string token has been found. \sa IsOprt, IsFunTok, IsStrFunTok, IsValTok, IsVarTok, IsEOF, IsInfixOpTok, IsPostOpTok \throw nothrow */ bool ParserTokenReader::IsString(token_type &a_Tok) { if (m_strFormula[m_iPos]!='"') return false; string_type strBuf(&m_strFormula[m_iPos+1]); std::size_t iEnd(0), iSkip(0); // parser over escaped '\"' end replace them with '"' for(iEnd=(int)strBuf.find( _T("\"") ); iEnd!=0 && iEnd!=string_type::npos; iEnd=(int)strBuf.find( _T("\""), iEnd)) { if (strBuf[iEnd-1]!='\\') break; strBuf.replace(iEnd-1, 2, _T("\"") ); iSkip++; } if (iEnd==string_type::npos) Error(ecUNTERMINATED_STRING, m_iPos, _T("\"") ); string_type strTok(strBuf.begin(), strBuf.begin()+iEnd); if (m_iSynFlags & noSTR) Error(ecUNEXPECTED_STR, m_iPos, strTok); m_pParser->m_vStringBuf.push_back(strTok); // Store string in internal buffer a_Tok.SetString(strTok, m_pParser->m_vStringBuf.size()); m_iPos += (int)strTok.length() + 2 + (int)iSkip; // +2 wg Anführungszeichen; +iSkip für entfernte escape zeichen m_iSynFlags = noANY ^ ( noARG_SEP | noBC | noOPT | noEND ); return true; }
//--------------------------------------------------------------------------- bool ParserTokenReader::IsStrVarTok(token_type &a_Tok) { if (!m_pStrVarDef || !m_pStrVarDef->size()) return false; string_type strTok; int iEnd = ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos); if (iEnd==m_iPos) return false; strmap_type::const_iterator item = m_pStrVarDef->find(strTok); if (item==m_pStrVarDef->end()) return false; if (m_iSynFlags & noSTR) Error(ecUNEXPECTED_VAR, m_iPos, strTok); m_iPos = iEnd; if (!m_pParser->m_vStringVarBuf.size()) Error(ecINTERNAL_ERROR); a_Tok.SetString(m_pParser->m_vStringVarBuf[item->second], m_pParser->m_vStringVarBuf.size() ); m_iSynFlags = noANY ^ ( noBC | noOPT | noEND | noARG_SEP); return true; }
/** \brief Check if a string position contains a binary operator. \param a_Tok [out] Operator token if one is found. This can either be a binary operator or an infix operator token. \return true if an operator token has been found. */ bool ParserTokenReader::IsOprt(token_type &a_Tok) { const char_type *const szExpr = m_strFormula.c_str(); string_type strTok; int iEnd = ExtractOperatorToken(strTok, m_iPos); if (iEnd==m_iPos) return false; // Check if the operator is a built in operator, if so ignore it here const char_type **const pOprtDef = m_pParser->GetOprtDef(); for (int i=0; m_pParser->HasBuiltInOprt() && pOprtDef[i]; ++i) { if (string_type(pOprtDef[i])==strTok) return false; } // Note: // All tokens in oprt_bin_maptype are have been sorted by their length // Long operators must come first! Otherwise short names (like: "add") that // are part of long token names (like: "add123") will be found instead // of the long ones. // Length sorting is done with ascending length so we use a reverse iterator here. funmap_type::const_reverse_iterator it = m_pOprtDef->rbegin(); for ( ; it!=m_pOprtDef->rend(); ++it) { const string_type &sID = it->first; if ( sID == string_type(szExpr + m_iPos, szExpr + m_iPos + sID.length()) ) { a_Tok.Set(it->second, strTok); // operator was found if (m_iSynFlags & noOPT) { // An operator was found but is not expected to occur at // this position of the formula, maybe it is an infix // operator, not a binary operator. Both operator types // can share characters in their identifiers. if ( IsInfixOpTok(a_Tok) ) return true; else { // nope, no infix operator return false; //Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString()); } } m_iPos += (int)sID.length(); m_iSynFlags = noBC | noOPT | noARG_SEP | noPOSTOP | noEND | noBC | noASSIGN; return true; } } return false; }
/** \brief Check wheter a token at a given position is an undefined variable. \param a_Tok [out] If a variable tom_pParser->m_vStringBufken has been found it will be placed here. \return true if a variable token has been found. \throw nothrow */ bool ParserTokenReader::IsUndefVarTok(token_type &a_Tok) { string_type strTok; int iEnd( ExtractToken(m_pParser->ValidNameChars(), strTok, m_iPos) ); if ( iEnd==m_iPos ) return false; if (m_iSynFlags & noVAR) { // <ibg/> 20061021 added token string strTok instead of a_Tok.GetAsString() as the // token identifier. // related bug report: // http://sourceforge.net/tracker/index.php?func=detail&aid=1578779&group_id=137191&atid=737979 Error(ecUNEXPECTED_VAR, m_iPos - (int)a_Tok.GetAsString().length(), strTok); } // If a factory is available implicitely create new variables if (m_pFactory) { value_type *fVar = m_pFactory(strTok.c_str(), m_pFactoryData); a_Tok.SetVar(fVar, strTok ); // Do not use m_pParser->DefineVar( strTok, fVar ); // in order to define the new variable, it will clear the // m_UsedVar array which will kill previousely defined variables // from the list // This is safe because the new variable can never override an existing one // because they are checked first! (*m_pVarDef)[strTok] = fVar; m_UsedVar[strTok] = fVar; // Add variable to used-var-list } else { a_Tok.SetVar((value_type*)&m_fZero, strTok); m_UsedVar[strTok] = 0; // Add variable to used-var-list } m_iPos = iEnd; // Call the variable factory in order to let it define a new parser variable m_iSynFlags = noVAL | noVAR | noFUN | noBO | noPOSTOP | noINFIXOP | noSTR; return true; }
/** \brief Check if a string position contains a unary infix operator. \return true if a function token has been found false otherwise. */ bool ParserTokenReader::IsInfixOpTok(token_type &a_Tok) { string_type sTok; int iEnd = ExtractToken(m_pParser->ValidInfixOprtChars(), sTok, m_iPos); if (iEnd==m_iPos) return false; funmap_type::const_iterator item = m_pInfixOprtDef->find(sTok); if (item==m_pInfixOprtDef->end()) return false; a_Tok.Set(item->second, sTok); m_iPos = (int)iEnd; if (m_iSynFlags & noINFIXOP) Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString()); m_iSynFlags = noPOSTOP | noINFIXOP | noOPT | noBC | noSTR | noASSIGN; return true; }
/** \brief Check if a string position contains a unary infix operator. \return true if a function token has been found false otherwise. */ bool ParserTokenReader::IsInfixOpTok(token_type &a_Tok) { string_type sTok; int iEnd = ExtractToken(m_pParser->ValidInfixOprtChars(), sTok, m_iPos); if (iEnd==m_iPos) return false; // iteraterate over all postfix operator strings funmap_type::const_reverse_iterator it = m_pInfixOprtDef->rbegin(); for ( ; it!=m_pInfixOprtDef->rend(); ++it) { if (sTok.find(it->first)!=0) continue; a_Tok.Set(it->second, it->first); m_iPos += (int)it->first.length(); if (m_iSynFlags & noINFIXOP) Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString()); m_iSynFlags = noPOSTOP | noINFIXOP | noOPT | noBC | noSTR | noASSIGN; return true; } return false; /* a_Tok.Set(item->second, sTok); m_iPos = (int)iEnd; if (m_iSynFlags & noINFIXOP) Error(ecUNEXPECTED_OPERATOR, m_iPos, a_Tok.GetAsString()); m_iSynFlags = noPOSTOP | noINFIXOP | noOPT | noBC | noSTR | noASSIGN; return true; */ }
/** \brief Check if a string position contains a unary post value operator. */ bool ParserTokenReader::IsPostOpTok(token_type &a_Tok) { // <ibg 20110629> Do not check for postfix operators if they are not allowed at // the current expression index. // // This will fix the bug reported here: // // http://sourceforge.net/tracker/index.php?func=detail&aid=3343891&group_id=137191&atid=737979 // if (m_iSynFlags & noPOSTOP) return false; // </ibg> // Tricky problem with equations like "3m+5": // m is a postfix operator, + is a valid sign for postfix operators and // for binary operators parser detects "m+" as operator string and // finds no matching postfix operator. // // This is a special case so this routine slightly differs from the other // token readers. // Test if there could be a postfix operator string_type sTok; int iEnd = ExtractToken(m_pParser->ValidOprtChars(), sTok, m_iPos); if (iEnd==m_iPos) return false; // iteraterate over all postfix operator strings funmap_type::const_reverse_iterator it = m_pPostOprtDef->rbegin(); for ( ; it!=m_pPostOprtDef->rend(); ++it) { if (sTok.find(it->first)!=0) continue; a_Tok.Set(it->second, sTok); m_iPos += (int)it->first.length(); m_iSynFlags = noVAL | noVAR | noFUN | noBO | noPOSTOP | noSTR | noASSIGN; return true; } return false; }
/** \brief Check for End of Formula. \return true if an end of formula is found false otherwise. \param a_Tok [out] If an eof is found the corresponding token will be stored there. \throw nothrow \sa IsOprt, IsFunTok, IsStrFunTok, IsValTok, IsVarTok, IsString, IsInfixOpTok, IsPostOpTok */ bool ParserTokenReader::IsEOF(token_type &a_Tok) { const char_type* szFormula = m_strFormula.c_str(); // check for EOF if ( !szFormula[m_iPos] /*|| szFormula[m_iPos] == '\n'*/) { if ( m_iSynFlags & noEND ) Error(ecUNEXPECTED_EOF, m_iPos); if (m_iBrackets>0) Error(ecMISSING_PARENS, m_iPos, _T(")")); m_iSynFlags = 0; a_Tok.Set(cmEND); return true; } return false; }
//--------------------------------------------------------------------------- bool ParserTokenReader::IsArgSep(token_type &a_Tok) { const char_type* szFormula = m_strFormula.c_str(); if (szFormula[m_iPos]==m_cArgSep) { // copy the separator into null terminated string char_type szSep[2]; szSep[0] = m_cArgSep; szSep[1] = 0; if (m_iSynFlags & noARG_SEP) Error(ecUNEXPECTED_ARG_SEP, m_iPos, szSep); m_iSynFlags = noBC | noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN; m_iPos++; a_Tok.Set(cmARG_SEP, szSep); return true; } return false; }
static void print(Out& out, token_type const& val) { out << '['; spirit::traits::print_token(out, val.value()); out << ']'; }
/** \brief Check if a built in operator or other token can be found \param a_Tok [out] Operator token if one is found. This can either be a binary operator or an infix operator token. \return true if an operator token has been found. */ bool ParserTokenReader::IsBuiltIn(token_type &a_Tok) { const char_type **const pOprtDef = m_pParser->GetOprtDef(), *const szFormula = m_strFormula.c_str(); // Compare token with function and operator strings // check string for operator/function for (int i=0; pOprtDef[i]; i++) { std::size_t len( std::char_traits<char_type>::length(pOprtDef[i]) ); if ( string_type(pOprtDef[i]) == string_type(szFormula + m_iPos, szFormula + m_iPos + len) ) { switch(i) { //case cmAND: //case cmOR: //case cmXOR: case cmLAND: case cmLOR: case cmLT: case cmGT: case cmLE: case cmGE: case cmNEQ: case cmEQ: case cmADD: case cmSUB: case cmMUL: case cmDIV: case cmPOW: case cmASSIGN: //if (len!=sTok.length()) // continue; // The assignement operator need special treatment if (i==cmASSIGN && m_iSynFlags & noASSIGN) Error(ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef[i]); if (!m_pParser->HasBuiltInOprt()) continue; if (m_iSynFlags & noOPT) { // Maybe its an infix operator not an operator // Both operator types can share characters in // their identifiers if ( IsInfixOpTok(a_Tok) ) return true; Error(ecUNEXPECTED_OPERATOR, m_iPos, pOprtDef[i]); } m_iSynFlags = noBC | noOPT | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE; m_iSynFlags |= ( (i != cmEND) && ( i != cmBC) ) ? noEND : 0; break; case cmBO: if (m_iSynFlags & noBO) Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]); if (m_lastTok.GetCode()==cmFUNC) m_iSynFlags = noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN | noIF | noELSE; else m_iSynFlags = noBC | noOPT | noEND | noARG_SEP | noPOSTOP | noASSIGN| noIF | noELSE; ++m_iBrackets; break; case cmBC: if (m_iSynFlags & noBC) Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]); m_iSynFlags = noBO | noVAR | noVAL | noFUN | noINFIXOP | noSTR | noASSIGN; if (--m_iBrackets<0) Error(ecUNEXPECTED_PARENS, m_iPos, pOprtDef[i]); break; case cmELSE: if (m_iSynFlags & noELSE) Error(ecUNEXPECTED_CONDITIONAL, m_iPos, pOprtDef[i]); m_iSynFlags = noBC | noPOSTOP | noEND | noOPT | noIF | noELSE; break; case cmIF: if (m_iSynFlags & noIF) Error(ecUNEXPECTED_CONDITIONAL, m_iPos, pOprtDef[i]); m_iSynFlags = noBC | noPOSTOP | noEND | noOPT | noIF | noELSE; break; default: // The operator is listed in c_DefaultOprt, but not here. This is a bad thing... Error(ecINTERNAL_ERROR); } // switch operator id m_iPos += (int)len; a_Tok.Set( (ECmdCode)i, pOprtDef[i] ); return true; } // if operator string found } // end of for all operator strings return false; }
bool checkIfNodeMaps(token_type tok, SgNode* node) { bool nodeMaps = false; using namespace boost::wave; //By definition a compiler generated node can //not map to the token stream SgLocatedNode* compilerGeneratedNode = isSgLocatedNode(node); if( compilerGeneratedNode != NULL ) if(compilerGeneratedNode->get_file_info()->isCompilerGenerated() == true) return false; // std::cout << get_token_name(tok) << " " << std::string(tok.get_value().c_str()) << " " << node->class_name() << " " << node->get_file_info()->get_line() << std::endl; //Mapping literal token id's switch(token_id(tok)){ case T_PP_NUMBER:{ if(isSgValueExp(node)!=NULL) nodeMaps=true; break; } case T_CHARLIT:{ if( ( isSgCharVal(node) != NULL ) | ( isSgUnsignedCharVal(node) != NULL ) ) nodeMaps = true; break; } case T_FLOATLIT:{ if( isSgFloatVal(node) != NULL ) nodeMaps = true; break; } case T_INTLIT:{ if( ( isSgIntVal(node) != NULL ) || ( isSgUnsignedIntVal(node) != NULL ) ) nodeMaps = true; break; } case T_LONGINTLIT: { if( ( isSgLongIntVal(node) != NULL ) | ( isSgLongLongIntVal(node) != NULL ) | ( isSgUnsignedLongLongIntVal(node) != NULL ) ) nodeMaps = true; break; } case T_STRINGLIT: { if( isSgStringVal(node) != NULL ) nodeMaps = true; break; } case T_QUESTION_MARK: { if( isSgConditionalExp(node) != NULL ) nodeMaps = true; break; } case T_FALSE: case T_TRUE: if( isSgBoolValExp(node) != NULL ) nodeMaps = true; break; default: break; } //map keyword token id's switch(token_id(tok)){ case T_ASM: if( isSgAsmStmt(node) != NULL ) nodeMaps = true; break; case T_AUTO: //auto //dont know break; /*case T_BOOL: //dont think this can be mapped break;*/ case T_BREAK: if( isSgBreakStmt(node) != NULL ) nodeMaps = true; break; case T_CASE: if( isSgCaseOptionStmt(node) != NULL ) nodeMaps = true; break; case T_CATCH: if( isSgCatchOptionStmt(node) != NULL ) nodeMaps = true; break; /* case T_CHAR: //dont know break; */ case boost::wave::T_CLASS: if( isSgClassDeclaration(node) != NULL ) nodeMaps = true; break; case T_CONST: // is it SgConstVolatileModifier? //dont know break; case T_CONTINUE: if( isSgContinueStmt(node) != NULL ) nodeMaps = true; break; //case T_DEFAULT: //Dont know // break; case T_DELETE: if( isSgDeleteExp(node) != NULL ) nodeMaps = true; break; case T_DO: if( isSgDoWhileStmt(node) != NULL ) nodeMaps = true; break; case T_ELSE: //dont know break; case T_EXPLICIT: //dont know break; case T_EXPORT: case T_EXTERN: break; case T_FOR: if( isSgForStatement(node) != NULL ) nodeMaps = true; break; case T_FRIEND: //dont know break; case T_GOTO: if( isSgGotoStatement(node) != NULL ) nodeMaps = true; break; case T_IF: //dont know how to handle this because if if-else break; case T_INLINE: //dont know break; case T_MUTABLE: //dont know break; case T_NAMESPACE: if( ( isSgNamespaceAliasDeclarationStatement(node) != NULL ) | (isSgNamespaceDeclarationStatement(node) != NULL ) ) nodeMaps = true; break; case T_NEW: if( isSgNewExp(node) != NULL ) nodeMaps = true; break; case T_OPERATOR: case T_PRIVATE: case T_PROTECTED: case T_PUBLIC: case T_REGISTER: case T_REINTERPRETCAST: //dont know break; case T_RETURN: if( isSgReturnStmt(node) != NULL ) nodeMaps = true; break; case T_SIZEOF: if( isSgSizeOfOp(node) != NULL ) nodeMaps = true; break; case T_STATIC: case T_STATICCAST: //dont know break; case T_STRUCT: if( isSgClassDeclaration(node) != NULL ) nodeMaps = true; break; case T_SWITCH: if( isSgSwitchStatement(node) != NULL ) nodeMaps = true; break; //case T_TEMPLATE: //dont know // break; case T_THIS: if( isSgThisExp(node) != NULL ) nodeMaps = true; break; case T_THROW: if( isSgThrowOp(node) != NULL ) nodeMaps = true; break; case T_TRY: if( isSgTryStmt(node) != NULL ) nodeMaps = true; break; case boost::wave::T_TYPEDEF: if( isSgTypedefDeclaration(node) != NULL ) nodeMaps = true; break; case T_TYPEID: if( isSgTypeIdOp(node) != NULL ) nodeMaps = true; break; case T_TYPENAME: //dont know break; case T_UNION: if( isSgClassDeclaration(node) != NULL ) nodeMaps = true; break; case T_USING: if( isSgUsingDeclarationStatement(node) != NULL ) nodeMaps = true; break; case T_VIRTUAL: //dont know break; case T_VOLATILE: //is it SgConstVolatileModifier ? break; case T_WHILE: if( isSgWhileStmt(node) != NULL ) nodeMaps = true; break; default: break; } //map operator token id's switch(token_id(tok)){ case T_AND: case T_ANDAND: if( isSgAndOp(node) != NULL | isSgBitAndOp(node) != NULL ) nodeMaps = true; break; case T_ASSIGN: if ( isSgAssignOp(node) != NULL | isSgAssignInitializer(node) != NULL ) nodeMaps = true; break; case T_ANDASSIGN: //do not know break; case T_OR: if ( isSgBitOrOp(node) != NULL || isSgOrOp(node) != NULL ) nodeMaps = true; break; case T_ORASSIGN: //do not know break; case T_XOR: if ( isSgBitXorOp(node) != NULL ) nodeMaps = true; break; case T_XORASSIGN: if ( isSgXorAssignOp(node) != NULL ) nodeMaps = true; break; case T_COMMA: if ( isSgCommaOpExp(node) != NULL ) nodeMaps = true; break; case T_COLON: //dont know break; case T_DIVIDE: if ( isSgDivideOp(node) != NULL ) nodeMaps = true; break; case T_DIVIDEASSIGN: if ( isSgDivAssignOp(node) != NULL ) nodeMaps = true; break; case T_DOT: if ( isSgDotExp(node) != NULL ) nodeMaps = true; break; case T_DOTSTAR: if ( isSgDotExp(node) != NULL ) nodeMaps = true; break; case T_ELLIPSIS: //Dont know break; case T_EQUAL: if ( isSgEqualityOp(node) != NULL ) nodeMaps = true; break; case T_GREATER: if ( isSgGreaterThanOp(node) != NULL ) nodeMaps = true; break; case T_GREATEREQUAL: if ( isSgGreaterOrEqualOp(node) != NULL ) nodeMaps = true; break; case T_LEFTBRACE: //Dont know break; case T_LESS: if ( isSgLessThanOp(node) != NULL ) nodeMaps = true; break; case T_LESSEQUAL: if ( isSgLessOrEqualOp(node) != NULL ) nodeMaps = true; break; case T_LEFTPAREN: //Dont know break; case T_LEFTBRACKET: case T_RIGHTBRACKET: if ( isSgPntrArrRefExp(node) != NULL ) nodeMaps = true; break; case T_MINUS: if ( ( isSgSubtractOp(node) != NULL ) | ( isSgMinusOp(node) != NULL ) ) nodeMaps = true; break; case T_MINUSASSIGN: if ( isSgMinusAssignOp(node) != NULL ) nodeMaps = true; break; case T_MINUSMINUS: if ( isSgMinusMinusOp(node) != NULL ) nodeMaps = true; break; case T_PERCENT: if ( isSgModOp(node) != NULL ) nodeMaps = true; break; case T_PERCENTASSIGN: if ( isSgModAssignOp(node) != NULL ) nodeMaps = true; break; case T_NOT: if ( isSgNotOp(node) != NULL ) nodeMaps = true; break; case T_NOTEQUAL: if ( isSgNotEqualOp(node) != NULL ) nodeMaps = true; break; case T_OROR: if ( isSgOrOp(node) != NULL ) nodeMaps = true; break; case T_PLUS: if ( isSgAddOp(node) != NULL ) nodeMaps = true; break; case T_PLUSASSIGN: if ( isSgPlusAssignOp(node) != NULL ) nodeMaps = true; break; case T_PLUSPLUS: if ( isSgPlusPlusOp(node) != NULL ) nodeMaps = true; break; case T_ARROW: if ( isSgArrowExp(node) != NULL ) nodeMaps = true; break; case T_ARROWSTAR: if ( isSgArrowStarOp(node) != NULL ) nodeMaps = true; break; case T_QUESTION_MARK: //dont know break; case T_RIGHTBRACE: case T_RIGHTPAREN: case T_COLON_COLON: case T_SEMICOLON: //dont know break; case T_SHIFTLEFT: if ( isSgLshiftOp(node) != NULL ) nodeMaps = true; break; case T_SHIFTLEFTASSIGN: if ( isSgLshiftAssignOp(node) != NULL ) nodeMaps = true; break; case T_SHIFTRIGHT: if ( isSgRshiftOp(node) != NULL ) nodeMaps = true; break; case T_SHIFTRIGHTASSIGN: if ( isSgRshiftAssignOp(node) != NULL ) nodeMaps = true; break; case T_STAR: //dont know if ( isSgMultiplyOp(node) != NULL || isSgPointerType(node) ) nodeMaps = true; break; case T_COMPL://~ if( isSgBitComplementOp(node) != NULL ) nodeMaps = true; //Dont know break; case T_STARASSIGN: if ( isSgMultAssignOp(node) != NULL ) nodeMaps = true; break; case T_POUND_POUND: case T_POUND: //dont know break; case T_AND_ALT: case T_ANDASSIGN_ALT: case T_OR_ALT: case T_ORASSIGN_ALT: case T_XOR_ALT: case T_XORASSIGN_ALT: case T_LEFTBRACE_ALT: case T_LEFTBRACKET_ALT: case T_NOT_ALT: case T_NOTEQUAL_ALT: case T_RIGHTBRACE_ALT: case T_RIGHTBRACKET_ALT: case T_COMPL_ALT: case T_POUND_POUND_ALT: case T_POUND_ALT: case T_OR_TRIGRAPH: case T_XOR_TRIGRAPH: case T_LEFTBRACE_TRIGRAPH: case T_LEFTBRACKET_TRIGRAPH: case T_RIGHTBRACE_TRIGRAPH: case T_RIGHTBRACKET_TRIGRAPH: case T_COMPL_TRIGRAPH: case T_POUND_POUND_TRIGRAPH: case T_POUND_TRIGRAPH: //dont know break; default: break; } switch(token_id(tok)){ case T_FALSE: case T_TRUE: break; case T_CHARLIT: if(SgProject::get_verbose() >= 1) std::cout << "char " << std::string(tok.get_value().c_str()) << std::endl; if( isSgCharVal(node) != NULL ){ SgCharVal* charVal = isSgCharVal(node); if(SgProject::get_verbose() >= 1) std::cout << std::string(tok.get_value().c_str()) << std::endl; char tmp = charVal->get_value(); if(SgProject::get_verbose() >= 1) std::cout << "From charlit: " << tmp << std::endl; if(("\""+std::string(&tmp)+"\"") == std::string(tok.get_value().c_str()) ) nodeMaps = true; } break; case T_STRINGLIT: { if(SgProject::get_verbose() >= 1) std::cout << "string " <<std::string(tok.get_value().c_str()) << std::endl; if( isSgStringVal(node) != NULL ){ SgStringVal* stringVal = isSgStringVal(node); if(SgProject::get_verbose() >= 1){ std::cout << std::string(tok.get_value().c_str()) << std::endl; std::cout << "stringlit: " << stringVal->get_value() << std::endl; } if(("\""+stringVal->get_value()+"\"") == std::string(tok.get_value().c_str()) ) nodeMaps = true; } break; } /*case V_SgWcharVal: if( isSgWcharVal(node) != NULL ) if( std::string(isSgWcharVal(node)->get_value()) == std::string(tok.get_value().c_str()) ) nodeMaps = true; break;*/ default: break; } if( token_id(tok) == T_IDENTIFIER ){ if( isSgInitializedName(node) != NULL ){ std::cout << "Identifier" << std::endl; SgInitializedName* initName = isSgInitializedName(node); std::cout << initName->get_name().getString() << " " << std::string(tok.get_value().c_str()) << std::endl; if( initName->get_name().getString() == std::string(tok.get_value().c_str()) ){ nodeMaps = true; } }else if( isSgVarRefExp(node) != NULL ){ SgVariableSymbol* varSymbol = isSgVarRefExp(node)->get_symbol(); SgInitializedName* initName = varSymbol->get_declaration(); if( initName->get_name().getString() == std::string(tok.get_value().c_str()) ){ nodeMaps = true; std::cout << "Maps:" << initName->get_name().getString() << " " << std::string(tok.get_value().c_str()) << std::endl; }else std::cout << "DONT Map:" << initName->get_name().getString() << " " << std::string(tok.get_value().c_str()) << std::endl; }else if( isSgFunctionRefExp(node) != NULL){ SgFunctionRefExp* funcRef = isSgFunctionRefExp(node); SgFunctionSymbol* funcSymbol = funcRef->get_symbol_i(); if( funcSymbol->get_declaration()->get_name().getString() == std::string(tok.get_value().c_str()) ) nodeMaps = true; }else if( isSgMemberFunctionRefExp(node) != NULL){ SgMemberFunctionRefExp* funcRef = isSgMemberFunctionRefExp(node); SgMemberFunctionSymbol* funcSymbol = funcRef->get_symbol(); if( funcSymbol->get_declaration()->get_name().getString() == std::string(tok.get_value().c_str()) ) nodeMaps = true; } } //Exceptions to the general rule switch(token_id(tok)){ case T_CHARLIT: { switch(node->variantT()) { case V_SgCharVal: case V_SgComplexVal: case V_SgDoubleVal: case V_SgEnumVal: case V_SgFloatVal: case V_SgIntVal: case V_SgLongDoubleVal: case V_SgLongIntVal: case V_SgLongLongIntVal: case V_SgShortVal: case V_SgStringVal: case V_SgUnsignedCharVal: case V_SgUnsignedIntVal: case V_SgUnsignedLongLongIntVal: case V_SgUnsignedLongVal: case V_SgUnsignedShortVal: case V_SgWcharVal: { nodeMaps=true; break; } default: break; }; break; }; } switch(boost::wave::token_id(tok)){ case boost::wave::T_CHAR: { if(isSgTypeChar(node) != NULL) nodeMaps=true; break; } case boost::wave::T_CONST: break; case boost::wave::T_DOUBLE: if(isSgTypeDouble(node) != NULL) nodeMaps=true; break; case boost::wave::T_INT: if(isSgTypeInt(node) != NULL) nodeMaps=true; break; case boost::wave::T_LONG: if(isSgTypeLong(node) != NULL) nodeMaps=true; break; case boost::wave::T_SHORT: if(isSgTypeShort(node) != NULL) nodeMaps=true; break; case boost::wave::T_SIGNED: case boost::wave::T_UNSIGNED: case boost::wave::T_VOID: if(isSgTypeVoid(node) != NULL) nodeMaps=true; break; default: break; }; return nodeMaps; }
static bool is_comma(const token_type& t_) { return t_.category() == metashell::data::token_category::operator_token && t_.value() == ","; }
static bool is_c_comment(const token_type& t_) { return t_.category() == metashell::data::token_category::comment && t_.value().size() >= 4 && t_.value()[0] == '/' && t_.value()[1] == '*'; }
static bool is_double_colon(const token_type& t_) { return t_.category() == metashell::data::token_category::operator_token && t_.value() == "::"; }
static string_type value(const token_type& t_) { return t_.value(); }
static token_type change_value(const string_type& value_, const token_type& t_) { return token_type(value_, t_.type()); }
static bool is_space(const token_type& t_) { return t_.category() == metashell::data::token_category::unknown || t_.category() == metashell::data::token_category::whitespace; }