void _int_14() { reportError("Interrupts", "Interrupt 14: #PF (Page Fault)", TRUE); }
void CheckNullPointer::nullPointerDefaultArgError(const Token *tok, const std::string &varname) { reportError(tok, Severity::warning, "nullPointer", "Possible null pointer dereference if the default parameter value is used: " + varname); }
void CheckCondition::badBitmaskCheckError(const Token *tok) { reportError(tok, Severity::warning, "badBitmaskCheck", "Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?"); }
// }}} // {{{ error mgnt void FlowParser::reportUnexpectedToken() { reportError("Unexpected token '%s'", token().c_str()); }
void CheckNullPointer::nullPointerError(const Token *tok) { reportError(tok, Severity::error, "nullPointer", "Null pointer dereference"); }
void CheckAutoVariables::errorReturnTempReference(const Token *tok) { reportError(tok, Severity::error, "returnTempReference", "Reference to temporary returned."); }
void error(std::error_code EC) { if (!EC) return; reportError(EC.message()); }
int main( int argc, char** argv ) { char cmd[ 2048 ]; BoronApp app( argc, argv ); UThread* ut; UBuffer rstr; int fileN = 0; int ret = 0; { UEnvParameters param; ut = boron_makeEnv( boron_envParam(¶m) ); } if( ! ut ) { printf( "boron_makeEnv failed\n" ); return -1; } ur_freezeEnv( ut ); boron_initQt( ut ); if( argc > 1 ) { int i; char* arg; for( i = 1; i < argc; ++i ) { arg = argv[i]; if( arg[0] == '-' ) { switch( arg[1] ) { case 's': //ur_disable( env, UR_ENV_SECURE ); break; case 'h': usage( argv[0] ); return 0; } } else { fileN = i; break; } } } ur_strInit( &rstr, UR_ENC_UTF8, 0 ); #ifdef _WIN32 { WORD wsver; WSADATA wsdata; wsver = MAKEWORD( 2, 2 ); WSAStartup( wsver, &wsdata ); } #endif if( fileN ) { char* pos; pos = cmd; cmd[ sizeof(cmd) - 1 ] = -1; // Create args block for any command line parameters. if( (argc - fileN) > 1 ) { int i; pos = str_copy( pos, "args: [" ); for( i = fileN + 1; i < argc; ++i ) { *pos++ = '"'; pos = str_copy( pos, argv[i] ); *pos++ = '"'; *pos++ = ' '; } *pos++ = ']'; } else { pos = str_copy( pos, "args: none " ); } pos = str_copy( pos, "do load {" ); pos = str_copy( pos, argv[fileN] ); *pos++ = '}'; assert( cmd[ sizeof(cmd) - 1 ] == -1 && "cmd buffer overflow" ); if( ! boron_evalUtf8( ut, cmd, pos - cmd ) ) { UCell* ex = ur_exception( ut ); if( ur_is(ex, UT_ERROR) ) { OPEN_CONSOLE reportError( ut, ex, &rstr ); goto prompt; } else if( ur_is(ex, UT_WORD) ) { switch( ur_atom(ex) ) { case UR_ATOM_QUIT: goto quit; case UR_ATOM_HALT: goto prompt; break; } } } } else { OPEN_CONSOLE printf( APPNAME " %s (%s)\n", UR_VERSION_STR, __DATE__ ); prompt: while( 1 ) { printf( ")> " ); fflush( stdout ); /* Required on Windows. */ fgets( cmd, sizeof(cmd), stdin ); #if 0 { char* cp = cmd; while( *cp != '\n' ) printf( " %d", (int) *cp++ ); printf( "\n" ); } #endif if( cmd[0] == ESC ) { // Up 27 91 65 // Down 27 91 66 printf( "\n" ); } else if( cmd[0] != '\n' ) { #if 0 if( cmd[0] == 'q' ) goto quit; #endif UCell* val = boron_evalUtf8( ut, cmd, -1 ); if( val ) { if( ur_is(val, UT_UNSET) || ur_is(val, UT_CONTEXT) ) goto prompt; rstr.used = 0; ur_toStr( ut, val, &rstr, 0 ); if( rstr.ptr.c ) { ur_strTermNull( &rstr ); if( rstr.used > PRINT_MAX ) { char* cp = str_copy( rstr.ptr.c + PRINT_MAX - 4, "..." ); *cp = '\0'; } printf( "== %s\n", rstr.ptr.c ); } } else { UCell* ex = ur_exception( ut ); if( ur_is(ex, UT_ERROR) ) { reportError( ut, ex, &rstr ); } else if( ur_is(ex, UT_WORD) ) { switch( ur_atom(ex) ) { case UR_ATOM_QUIT: goto quit; case UR_ATOM_HALT: printf( "**halt\n" ); break; default: printf( "**unhandled excepetion %s\n", ur_atomCStr(ut,ur_atom(ex)) ); break; } } boron_reset( ut ); } } } } quit: ur_strFree( &rstr ); boron_freeQt(); boron_freeEnv( ut ); #ifdef _WIN32 WSACleanup(); #endif return ret; }
void IOSCfgParser::rule_std() { try { // for error handling { hostaddr_std(); if ( inputState->guessing==0 ) { #line 360 "iosacl.g" importer->SaveTmpAddrToSrc(); *dbg << "(std) "; #line 1505 "IOSCfgParser.cpp" } { switch ( LA(1)) { case LOG: case LOG_INPUT: { log(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } } if ( inputState->guessing==0 ) { #line 363 "iosacl.g" *dbg << std::endl; #line 1546 "IOSCfgParser.cpp" } } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { if( inputState->guessing == 0 ) { reportError(ex); recover(ex,_tokenSet_2); } else { throw; } } }
/**** Local functions definitions. ****/ static ErrorNumber test_index( TA_Libc *libHandle, TA_UDBase *udb ) { TA_RetCode retCode; TA_AddDataSourceParam param; TA_History *history; ErrorNumber errNumber; (void)libHandle; /* Add the Yaho! data source. */ memset( ¶m, 0, sizeof( param ) ); param.id = TA_YAHOO_WEB; param.location = "us"; retCode = TA_AddDataSource( udb, ¶m ); if( retCode != TA_SUCCESS ) { reportError( "TA_AddDataSource", retCode ); return TA_YAHOO_ADDDATASOURCE_USA_FAILED; } /* Get something from NASDAQ. */ retCode = TA_HistoryAlloc( udb, "US.NASDAQ.STOCK", "MSFT", TA_DAILY, 0, 0, TA_CLOSE|TA_TIMESTAMP|TA_VOLUME, &history ); if( retCode != TA_SUCCESS ) { reportError( "TA_HistoryAlloc", retCode ); return TA_YAHOO_HISTORYALLOC_1_FAILED; } if( history->nbBars < 3000 ) { printf( "Insufficient nbBars returned for MSFT ticker test (%d < 3000)\n", history->nbBars ); return TA_YAHOO_VALUE_1_FAILED; } if( !history->close || !history->timestamp || !history->volume ) { return TA_YAHOO_FIELD_MISSING_1; } retCode = TA_HistoryFree( history ); if( retCode != TA_SUCCESS ) { reportError( "TA_HistoryFree", retCode ); return TA_YAHOO_HISTORYFREE_FAILED; } /* Add canadian index. */ param.id = TA_YAHOO_WEB; param.location = "ca"; retCode = TA_AddDataSource( udb, ¶m ); if( retCode != TA_SUCCESS ) { reportError( "TA_AddDataSource", retCode ); return TA_YAHOO_ADDDATASOURCE_CAN_FAILED; } /* Get something from NYSE. */ retCode = TA_HistoryAlloc( udb, "US.NYSE.STOCK", "IBM", TA_WEEKLY, 0, 0, TA_OPEN, &history ); if( retCode != TA_SUCCESS ) { reportError( "TA_HistoryAlloc", retCode ); return TA_YAHOO_HISTORYALLOC_2_FAILED; } if( history->nbBars < 2065 ) { return TA_YAHOO_VALUE_2_FAILED; } if( !history->open ) { return TA_YAHOO_FIELD_MISSING_2; } retCode = TA_HistoryFree( history ); if( retCode != TA_SUCCESS ) { reportError( "TA_HistoryFree", retCode ); return TA_YAHOO_HISTORYFREE_FAILED; } /* Get something from canadian market. * Also test stock using 200 price bar slice. */ retCode = TA_HistoryAlloc( udb, "CA.CDNX.STOCK", "MRY", TA_DAILY, 0, 0, TA_ALL, &history ); if( retCode != TA_SUCCESS ) { reportError( "TA_HistoryAlloc", retCode ); return TA_YAHOO_HISTORYALLOC_3_FAILED; } if( history->nbBars < 700 ) { return TA_YAHOO_VALUE_3_FAILED; } if( !history->open || !history->high || !history->low || !history->close || !history->volume || !history->timestamp ) { return TA_YAHOO_FIELD_MISSING_3; } errNumber = checkRangeSame( udb, history, &history->timestamp[0], &history->timestamp[0], 0, 1 ); if( errNumber != TA_TEST_PASS ) { printf( "Failed: Test getting first price bar only.\n" ); return errNumber; } errNumber = checkRangeSame( udb, history, &history->timestamp[1], &history->timestamp[1], 1, 1 ); if( errNumber != TA_TEST_PASS ) { printf( "Failed: Test getting second price bar only.\n" ); return errNumber; } errNumber = checkRangeSame( udb, history, &history->timestamp[history->nbBars-2], &history->timestamp[history->nbBars-2], history->nbBars-2, 1 ); if( errNumber != TA_TEST_PASS ) { printf( "Failed: Test getting before last price bar only.\n" ); return errNumber; } errNumber = checkRangeSame( udb, history, &history->timestamp[history->nbBars-1], &history->timestamp[history->nbBars-1], history->nbBars-1, 1 ); if( errNumber != TA_TEST_PASS ) { printf( "Failed: Test getting last price bar only.\n" ); return errNumber; } errNumber = checkRangeSame( udb, history, &history->timestamp[history->nbBars-200], &history->timestamp[history->nbBars-1], history->nbBars-200, 200 ); if( errNumber != TA_TEST_PASS ) { printf( "Failed: Test getting last 200 price bars only.\n" ); return errNumber; } errNumber = checkRangeSame( udb, history, &history->timestamp[0], &history->timestamp[199], 0, 200 ); if( errNumber != TA_TEST_PASS ) { printf( "Failed: Test getting first 200 price bars only.\n" ); return errNumber; } retCode = TA_HistoryFree( history ); if( retCode != TA_SUCCESS ) { reportError( "TA_HistoryFree", retCode ); return TA_YAHOO_HISTORYFREE_FAILED; } return TA_TEST_PASS; }
static ErrorNumber checkRangeSame( TA_UDBase *udb, const TA_History *historyRef, const TA_Timestamp *start, const TA_Timestamp *end, unsigned int startIdx, unsigned int nbPriceBar ) { TA_History *history; unsigned int i; TA_RetCode retCode; #if 1 /* Do not retry... no forgiveness! */ retCode = TA_HistoryAlloc( udb, "CA.CDNX.STOCK", "MRY", TA_DAILY, start, end, TA_ALL, &history ); #else int retry, again; /* Try up to 10 times to get the requested number of * price bar (sometimes Yahoo! or the Web do fail to * return the data). */ again = 1; for( retry=0; (retry < 10) && again; retry++ ) { retCode = TA_HistoryAlloc( udb, "CA.CDNX.STOCK", "MRY", TA_DAILY, start, end, TA_ALL, &history ); if( (retCode == TA_SUCCESS) && (history->nbBars == nbPriceBar) ) again = 0; else { printf( "Warning: Yahoo! history alloc retry #%d of 10\n", retry+1 ); if( retCode == TA_SUCCESS ) { TA_HistoryFree( history ); } TA_Sleep( 10 /* seconds */ ); } } #endif if( retCode != TA_SUCCESS ) { reportError( "TA_HistoryAlloc", retCode ); return TA_YAHOO_CRS_HISTORYALLOC_FAILED; } /* Check that the expected number of price bar is returned. */ if( history->nbBars != nbPriceBar ) { printf( "Failed: nbBars (received != requested)=(%d != %d)\n", history->nbBars, nbPriceBar ); TA_HistoryFree( history ); return TA_YAHOO_CRS_NBBARSBAD; } /* Check that the data is the same for the range. */ for( i=0; i < nbPriceBar; i++ ) { if( !TA_TimestampEqual( &history->timestamp[i], &historyRef->timestamp[startIdx+i] ) || (history->open[i] != historyRef->open[startIdx+i]) || (history->high[i] != historyRef->high[startIdx+i]) || (history->low[i] != historyRef->low[startIdx+i]) || (history->close[i] != historyRef->close[startIdx+i]) || (history->volume[i] != historyRef->volume[startIdx+i]) ) { printf( "Failed: Price Bar value different\n" ); printf( "Failed: Data = %f,%f,%f,%f,%d\n", history->open[i], history->high[i], history->low[i], history->close[i], history->volume[i] ); printf( "Failed: Ref = %f,%f,%f,%f,%d\n", historyRef->open[startIdx+i], historyRef->high[startIdx+i], historyRef->low[startIdx+i], historyRef->close[startIdx+i], historyRef->volume[startIdx+i] ); TA_HistoryFree( history ); return TA_YAHOO_CRS_PRICEBARBAD; } } retCode = TA_HistoryFree( history ); if( retCode != TA_SUCCESS ) { reportError( "TA_HistoryFree", retCode ); return TA_YAHOO_HISTORYFREE_FAILED; } return TA_TEST_PASS; }
void CheckFunctions::mathfunctionCallWarning(const Token *tok, const std::string& oldexp, const std::string& newexp) { reportError(tok, Severity::style, "unpreciseMathCall", "Expression '" + oldexp + "' can be replaced by '" + newexp + "' to avoid loss of precision."); }
void CheckFunctions::ignoredReturnValueError(const Token* tok, const std::string& function) { reportError(tok, Severity::warning, "ignoredReturnValue", "Return value of function " + function + "() is not used.", 0U, false); }
void CheckFunctions::invalidFunctionArgBoolError(const Token *tok, const std::string &functionName, int argnr) { std::ostringstream errmsg; errmsg << "Invalid " << functionName << "() argument nr " << argnr << ". A non-boolean value is required."; reportError(tok, Severity::error, "invalidFunctionArgBool", errmsg.str()); }
void CheckAutoVariables::errorReturnAddressToAutoVariable(const Token *tok) { reportError(tok, Severity::error, "returnAddressOfAutoVariable", "Address of an auto-variable returned."); }
void IOSCfgParser::hostaddr_ext() { ANTLR_USE_NAMESPACE(antlr)RefToken h = ANTLR_USE_NAMESPACE(antlr)nullToken; ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken; ANTLR_USE_NAMESPACE(antlr)RefToken m = ANTLR_USE_NAMESPACE(antlr)nullToken; try { // for error handling switch ( LA(1)) { case HOST: { { match(HOST); h = LT(1); match(IPV4); } if ( inputState->guessing==0 ) { #line 423 "iosacl.g" importer->tmp_a = h->getText(); importer->tmp_nm = "0.0.0.0"; *dbg << h->getText() << "/0.0.0.0"; #line 1620 "IOSCfgParser.cpp" } break; } case IPV4: { { a = LT(1); match(IPV4); m = LT(1); match(IPV4); } if ( inputState->guessing==0 ) { #line 430 "iosacl.g" importer->tmp_a = a->getText(); importer->tmp_nm = m->getText(); *dbg << a->getText() << "/" << m->getText(); #line 1639 "IOSCfgParser.cpp" } break; } case ANY: { match(ANY); if ( inputState->guessing==0 ) { #line 437 "iosacl.g" importer->tmp_a = "0.0.0.0"; importer->tmp_nm = "0.0.0.0"; *dbg << "0.0.0.0/0.0.0.0"; #line 1653 "IOSCfgParser.cpp" } break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { if( inputState->guessing == 0 ) { reportError(ex); recover(ex,_tokenSet_8); } else { throw; } } }
void CheckAutoVariables::errorReturnPointerToLocalArray(const Token *tok) { reportError(tok, Severity::error, "returnLocalVariable", "Pointer to local array variable returned."); }
void IOSCfgParser::hostaddr_std() { ANTLR_USE_NAMESPACE(antlr)RefToken h = ANTLR_USE_NAMESPACE(antlr)nullToken; ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken; ANTLR_USE_NAMESPACE(antlr)RefToken m = ANTLR_USE_NAMESPACE(antlr)nullToken; try { // for error handling if ((LA(1) == IPV4) && (_tokenSet_12.member(LA(2)))) { { h = LT(1); match(IPV4); } if ( inputState->guessing==0 ) { #line 446 "iosacl.g" importer->tmp_a = h->getText(); importer->tmp_nm = "0.0.0.0"; *dbg << h->getText() << "/0.0.0.0"; #line 1896 "IOSCfgParser.cpp" } } else if ((LA(1) == IPV4) && (LA(2) == IPV4)) { { a = LT(1); match(IPV4); m = LT(1); match(IPV4); } if ( inputState->guessing==0 ) { #line 453 "iosacl.g" importer->tmp_a = a->getText(); importer->tmp_nm = m->getText(); *dbg << a->getText() << "/" << m->getText(); #line 1913 "IOSCfgParser.cpp" } } else if ((LA(1) == ANY)) { match(ANY); if ( inputState->guessing==0 ) { #line 460 "iosacl.g" importer->tmp_a = "0.0.0.0"; importer->tmp_nm = "0.0.0.0"; *dbg << "0.0.0.0/0.0.0.0"; #line 1925 "IOSCfgParser.cpp" } } else { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { if( inputState->guessing == 0 ) { reportError(ex); recover(ex,_tokenSet_12); } else { throw; } } }
static PyObject* kin_getarray(PyObject *self, PyObject *args) { int kin; int job; if (!PyArg_ParseTuple(args, "ii:kin_getarray", &kin, &job)) return NULL; // array attributes int iok = -22; size_t nrxns = kin_nReactions(kin); size_t nsp = kin_nSpecies(kin); size_t ix; if (job < 45 || job >= 90) ix = nrxns; else ix = nsp; #ifdef HAS_NUMPY npy_intp nix = ix; PyArrayObject* x = (PyArrayObject*)PyArray_SimpleNew(1, &nix, PyArray_DOUBLE); #else int nix = int(ix); PyArrayObject* x = (PyArrayObject*)PyArray_FromDims(1, &nix, PyArray_DOUBLE); #endif double* xd = (double*)x->data; switch (job) { case 10: iok = kin_getFwdRatesOfProgress(kin, nrxns, xd); break; case 20: iok = kin_getRevRatesOfProgress(kin, nrxns, xd); break; case 30: iok = kin_getNetRatesOfProgress(kin, nrxns, xd); break; case 32: iok = kin_getActivationEnergies(kin, nrxns, xd); break; case 34: iok = kin_getFwdRateConstants(kin, nrxns, xd); break; case 35: iok = kin_getRevRateConstants(kin, 1, nrxns, xd); case 36: iok = kin_getRevRateConstants(kin, 0, nrxns, xd); break; case 40: iok = kin_getEquilibriumConstants(kin, nrxns, xd); break; case 50: iok = kin_getCreationRates(kin, nsp, xd); break; case 60: iok = kin_getDestructionRates(kin, nsp, xd); break; case 70: iok = kin_getNetProductionRates(kin, nsp, xd); break; case 80: iok = kin_getSourceTerms(kin, nsp, xd); break; case 90: iok = kin_getDelta(kin, 0, nrxns, xd); break; case 91: iok = kin_getDelta(kin, 1, nrxns, xd); break; case 92: iok = kin_getDelta(kin, 2, nrxns, xd); break; case 93: iok = kin_getDelta(kin, 3, nrxns, xd); break; case 94: iok = kin_getDelta(kin, 4, nrxns, xd); break; case 95: iok = kin_getDelta(kin, 5, nrxns, xd); break; default: ; } if (iok >= 0) { return PyArray_Return(x); } else return reportError(iok); }
void IOSCfgParser::cfgfile() { try { // for error handling { // ( ... )+ int _cnt3=0; for (;;) { switch ( LA(1)) { case LINE_COMMENT: { comment(); break; } case IOSVERSION: { version(); break; } case HOSTNAME: { hostname(); break; } case IP: { ip_commands(); break; } case INTRFACE: { intrface(); break; } case CONTROLLER: { controller(); break; } case VLAN: { vlan(); break; } case ACCESS_LIST: { access_list_commands(); break; } case EXIT: { exit(); break; } case DESCRIPTION: { description(); break; } case SHUTDOWN: { shutdown(); break; } case CERTIFICATE: { certificate(); break; } case QUIT: { quit(); break; } case WORD: { unknown_command(); break; } case NEWLINE: { match(NEWLINE); break; } default: { if ( _cnt3>=1 ) { goto _loop3; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} } } _cnt3++; } _loop3:; } // ( ... )+ } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { if( inputState->guessing == 0 ) { reportError(ex); recover(ex,_tokenSet_0); } else { throw; } } }
std::unique_ptr<Stmt> FlowParser::callStmt() { // callStmt ::= NAME ['(' exprList ')' | exprList] (';' | LF) // | NAME '=' expr [';' | LF] // NAME may be a builtin-function, builtin-handler, handler-name, or variable. FNTRACE(); FlowLocation loc(location()); std::string name = stringValue(); nextToken(); // IDENT std::unique_ptr<Stmt> stmt; Symbol* callee = scope()->lookup(name, Lookup::All); if (!callee) { // XXX assume that given symbol is a auto forward-declared handler. callee = (Handler*) globalScope()->appendSymbol(std::make_unique<Handler>(name, loc)); } bool callArgs = false; switch (callee->type()) { case Symbol::Variable: { // var '=' expr (';' | LF) if (!consume(FlowToken::Assign)) return nullptr; std::unique_ptr<Expr> value = expr(); if (!value) return nullptr; stmt = std::make_unique<AssignStmt>(static_cast<Variable*>(callee), std::move(value), loc.update(end())); break; } case Symbol::BuiltinHandler: case Symbol::BuiltinFunction: stmt = std::make_unique<CallStmt>(loc, (Callable*) callee); callArgs = true; break; case Symbol::Handler: stmt = std::make_unique<CallStmt>(loc, (Callable*) callee); break; default: break; } if (callArgs) { CallStmt* callStmt = static_cast<CallStmt*>(stmt.get()); if (token() == FlowToken::RndOpen) { nextToken(); ExprList args; bool rv = listExpr(args); consume(FlowToken::RndClose); if (!rv) return nullptr; callStmt->setArgs(std::move(args)); } else if (lexer_->line() == loc.begin.line) { ExprList args; if (!listExpr(args)) return nullptr; callStmt->setArgs(std::move(args)); } // match call parameters FlowVM::Signature sig; sig.setName(name); sig.setReturnType(callStmt->callee()->signature().returnType()); // XXX cheetah std::vector<FlowType> argTypes; for (const auto& arg: callStmt->args()) { argTypes.push_back(arg->getType()); } sig.setArgs(argTypes); if (sig != callStmt->callee()->signature()) { reportError("Callee parameter type signature mismatch: %s passed, but %s expected.\n", sig.to_s().c_str(), callStmt->callee()->signature().to_s().c_str()); return nullptr; } } switch (token()) { case FlowToken::If: case FlowToken::Unless: return postscriptStmt(std::move(stmt)); case FlowToken::Semicolon: // stmt ';' nextToken(); stmt->location().update(end()); return stmt; default: if (stmt->location().end.line != lexer_->line()) return stmt; reportUnexpectedToken(); return nullptr; } }
void IOSCfgParser::ip_access_list_ext() { ANTLR_USE_NAMESPACE(antlr)RefToken name = ANTLR_USE_NAMESPACE(antlr)nullToken; try { // for error handling match(ACCESS_LIST); match(EXTENDED); name = LT(1); match(WORD); if ( inputState->guessing==0 ) { #line 238 "iosacl.g" importer->newUnidirRuleSet( name->getText(), libfwbuilder::Policy::TYPENAME ); *dbg << name->getLine() << ":" << " ACL ext " << name->getText() << std::endl; #line 608 "IOSCfgParser.cpp" } match(NEWLINE); { // ( ... )* for (;;) { switch ( LA(1)) { case PERMIT: { permit_ext(); break; } case DENY: { deny_ext(); break; } case REMARK: { remark(); break; } default: if ((LA(1) == LINE_COMMENT) && (_tokenSet_1.member(LA(2)))) { comment(); } else if ((LA(1) == NEWLINE) && (_tokenSet_1.member(LA(2)))) { match(NEWLINE); } else { goto _loop18; } } } _loop18:; } // ( ... )* if ( inputState->guessing==0 ) { #line 255 "iosacl.g" *dbg << LT(0)->getLine() << ":" << " ACL end" << std::endl << std::endl; #line 649 "IOSCfgParser.cpp" } } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { if( inputState->guessing == 0 ) { reportError(ex); recover(ex,_tokenSet_2); } else { throw; } } }
// primaryExpr ::= NUMBER // | STRING // | variable // | function '(' exprList ')' // | '(' expr ')' std::unique_ptr<Expr> FlowParser::primaryExpr() { FNTRACE(); static struct { const char* ident; long long nominator; long long denominator; } units[] = { { "byte", 1, 1 }, { "kbyte", 1024llu, 1 }, { "mbyte", 1024llu * 1024, 1 }, { "gbyte", 1024llu * 1024 * 1024, 1 }, { "tbyte", 1024llu * 1024 * 1024 * 1024, 1 }, { "bit", 1, 8 }, { "kbit", 1024llu, 8 }, { "mbit", 1024llu * 1024, 8 }, { "gbit", 1024llu * 1024 * 1024, 8 }, { "tbit", 1024llu * 1024 * 1024 * 1024, 8 }, { "sec", 1, 1 }, { "min", 60llu, 1 }, { "hour", 60llu * 60, 1 }, { "day", 60llu * 60 * 24, 1 }, { "week", 60llu * 60 * 24 * 7, 1 }, { "month", 60llu * 60 * 24 * 30, 1 }, { "year", 60llu * 60 * 24 * 365, 1 }, { nullptr, 1, 1 } }; FlowLocation loc(location()); switch (token()) { case FlowToken::Ident: { std::string name = stringValue(); nextToken(); Symbol* symbol = scope()->lookup(name, Lookup::All); if (!symbol) { // XXX assume that given symbol is a auto forward-declared handler. Handler* href = (Handler*) globalScope()->appendSymbol(std::make_unique<Handler>(name, loc)); return std::make_unique<HandlerRefExpr>(href, loc); } if (auto variable = dynamic_cast<Variable*>(symbol)) return std::make_unique<VariableExpr>(variable, loc); if (auto handler = dynamic_cast<Handler*>(symbol)) return std::make_unique<HandlerRefExpr>(handler, loc); if (symbol->type() == Symbol::BuiltinFunction) { if (token() != FlowToken::RndOpen) return std::make_unique<FunctionCallExpr>((BuiltinFunction*) symbol, ExprList()/*args*/, loc); nextToken(); ExprList args; bool rv = listExpr(args); consume(FlowToken::RndClose); if (!rv) return nullptr; return std::make_unique<FunctionCallExpr>((BuiltinFunction*) symbol, std::move(args), loc); } reportError("Unsupported symbol type of '%s' in expression.", name.c_str()); return nullptr; } case FlowToken::Boolean: { std::unique_ptr<BoolExpr> e = std::make_unique<BoolExpr>(booleanValue(), loc); nextToken(); return std::move(e); } case FlowToken::RegExp: { std::unique_ptr<RegExpExpr> e = std::make_unique<RegExpExpr>(RegExp(stringValue()), loc); nextToken(); return std::move(e); } case FlowToken::InterpolatedStringFragment: return interpolatedStr(); case FlowToken::String: case FlowToken::RawString: { std::unique_ptr<StringExpr> e = std::make_unique<StringExpr>(stringValue(), loc); nextToken(); return std::move(e); } case FlowToken::Number: { // NUMBER [UNIT] auto number = numberValue(); nextToken(); if (token() == FlowToken::Ident) { std::string sv(stringValue()); for (size_t i = 0; units[i].ident; ++i) { if (sv == units[i].ident || (sv[sv.size() - 1] == 's' && sv.substr(0, sv.size() - 1) == units[i].ident)) { nextToken(); // UNIT number = number * units[i].nominator / units[i].denominator; loc.update(end()); break; } } } return std::make_unique<NumberExpr>(number, loc); } case FlowToken::IP: { std::unique_ptr<IPAddressExpr> e = std::make_unique<IPAddressExpr>(lexer_->ipValue(), loc); nextToken(); return std::move(e); } case FlowToken::Cidr: { std::unique_ptr<CidrExpr> e = std::make_unique<CidrExpr>(lexer_->cidr(), loc); nextToken(); return std::move(e); } case FlowToken::StringType: case FlowToken::NumberType: case FlowToken::BoolType: return castExpr(); case FlowToken::Begin: { // lambda-like inline function ref char name[64]; static unsigned long i = 0; ++i; snprintf(name, sizeof(name), "__lambda_%lu", i); FlowLocation loc = location(); auto st = std::make_unique<SymbolTable>(scope(), name); enter(st.get()); std::unique_ptr<Stmt> body = compoundStmt(); leave(); if (!body) return nullptr; loc.update(body->location().end); Handler* handler = new Handler(name, std::move(st), std::move(body), loc); // TODO (memory leak): add handler to unit's global scope, i.e. via: // - scope()->rootScope()->insert(handler); // - unit_->scope()->insert(handler); // to get free'd return std::make_unique<HandlerRefExpr>(handler, loc); } case FlowToken::RndOpen: { nextToken(); std::unique_ptr<Expr> e = expr(); consume(FlowToken::RndClose); e->setLocation(loc.update(end())); return e; } default: TRACE(1, "Expected primary expression. Got something... else."); reportUnexpectedToken(); return nullptr; } }
void IOSCfgParser::rule_ext() { try { // for error handling { switch ( LA(1)) { case IP: case WORD: { ip_protocols(); hostaddr_ext(); if ( inputState->guessing==0 ) { #line 320 "iosacl.g" importer->SaveTmpAddrToSrc(); *dbg << "(src) "; #line 935 "IOSCfgParser.cpp" } hostaddr_ext(); if ( inputState->guessing==0 ) { #line 321 "iosacl.g" importer->SaveTmpAddrToDst(); *dbg << "(dst) "; #line 941 "IOSCfgParser.cpp" } { switch ( LA(1)) { case TIME_RANGE: { time_range(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case LOG: case LOG_INPUT: case FRAGMENTS: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1)) { case FRAGMENTS: { fragments(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case LOG: case LOG_INPUT: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1)) { case LOG: case LOG_INPUT: { log(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } break; } case ICMP: { match(ICMP); if ( inputState->guessing==0 ) { #line 327 "iosacl.g" importer->protocol = LT(0)->getText(); *dbg << "protocol " << LT(0)->getText() << " "; #line 1065 "IOSCfgParser.cpp" } hostaddr_ext(); if ( inputState->guessing==0 ) { #line 331 "iosacl.g" importer->SaveTmpAddrToSrc(); *dbg << "(src) "; #line 1071 "IOSCfgParser.cpp" } hostaddr_ext(); if ( inputState->guessing==0 ) { #line 332 "iosacl.g" importer->SaveTmpAddrToDst(); *dbg << "(dst) "; #line 1077 "IOSCfgParser.cpp" } { if ((LA(1) == WORD || LA(1) == INT_CONST) && (_tokenSet_4.member(LA(2)))) { icmp_spec(); } else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { } else { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } { switch ( LA(1)) { case TIME_RANGE: { time_range(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case LOG: case LOG_INPUT: case FRAGMENTS: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1)) { case FRAGMENTS: { fragments(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case LOG: case LOG_INPUT: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1)) { case LOG: case LOG_INPUT: { log(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } break; } case TCP: case UDP: { { switch ( LA(1)) { case TCP: { match(TCP); break; } case UDP: { match(UDP); break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } if ( inputState->guessing==0 ) { #line 339 "iosacl.g" importer->protocol = LT(0)->getText(); *dbg << "protocol " << LT(0)->getText() << " "; #line 1230 "IOSCfgParser.cpp" } hostaddr_ext(); if ( inputState->guessing==0 ) { #line 343 "iosacl.g" importer->SaveTmpAddrToSrc(); *dbg << "(src) "; #line 1236 "IOSCfgParser.cpp" } { switch ( LA(1)) { case P_EQ: case P_GT: case P_LT: case P_NEQ: case P_RANGE: { xoperator(); if ( inputState->guessing==0 ) { #line 344 "iosacl.g" importer->SaveTmpPortToSrc(); #line 1250 "IOSCfgParser.cpp" } break; } case HOST: case IPV4: case ANY: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } hostaddr_ext(); if ( inputState->guessing==0 ) { #line 345 "iosacl.g" importer->SaveTmpAddrToDst(); *dbg << "(dst) "; #line 1270 "IOSCfgParser.cpp" } { switch ( LA(1)) { case P_EQ: case P_GT: case P_LT: case P_NEQ: case P_RANGE: { xoperator(); if ( inputState->guessing==0 ) { #line 346 "iosacl.g" importer->SaveTmpPortToDst(); #line 1284 "IOSCfgParser.cpp" } break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case LOG: case LOG_INPUT: case ESTABLISHED: case FRAGMENTS: case TIME_RANGE: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1)) { case ESTABLISHED: { established(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case LOG: case LOG_INPUT: case FRAGMENTS: case TIME_RANGE: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1)) { case TIME_RANGE: { time_range(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case LOG: case LOG_INPUT: case FRAGMENTS: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1)) { case FRAGMENTS: { fragments(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case LOG: case LOG_INPUT: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } { switch ( LA(1)) { case LOG: case LOG_INPUT: { log(); break; } case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE: case NEWLINE: case IP: case QUIT: case WORD: case CERTIFICATE: case IOSVERSION: case HOSTNAME: case ACCESS_LIST: case PERMIT: case DENY: case VLAN: case CONTROLLER: case INTRFACE: case DESCRIPTION: case REMARK: case SHUTDOWN: case EXIT: case LINE_COMMENT: { break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } break; } default: { throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); } } } if ( inputState->guessing==0 ) { #line 352 "iosacl.g" *dbg << std::endl; #line 1484 "IOSCfgParser.cpp" } } catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { if( inputState->guessing == 0 ) { reportError(ex); recover(ex,_tokenSet_1); } else { throw; } } }
void CheckNullPointer::nullPointerError(const Token *tok, const std::string &varname, bool inconclusive) { reportError(tok, Severity::error, "nullPointer", "Possible null pointer dereference: " + varname, inconclusive); }
void UpdateInstaller::run() throw () { if (!m_script || !m_script->isValid()) { reportError("Unable to read update script"); return; } if (m_installDir.empty()) { reportError("No installation directory specified"); return; } std::string updaterPath; try { updaterPath = ProcessUtils::currentProcessPath(); } catch (const FileUtils::IOException&) { LOG(Error,"error reading process path with mode " + intToStr(m_mode)); reportError("Unable to determine path of updater"); return; } if (m_mode == Setup) { if (m_waitPid != 0) { LOG(Info,"Waiting for main app process to finish"); ProcessUtils::waitForProcess(m_waitPid); } std::list<std::string> args = updaterArgs(); args.push_back("--mode"); args.push_back("main"); args.push_back("--wait"); args.push_back(intToStr(ProcessUtils::currentProcessId())); int installStatus = 0; if (m_forceElevated || !checkAccess()) { LOG(Info,"Insufficient rights to install app to " + m_installDir + " requesting elevation"); // start a copy of the updater with admin rights installStatus = ProcessUtils::runElevated(updaterPath,args,AppInfo::name()); } else { LOG(Info,"Sufficient rights to install app - restarting with same permissions"); installStatus = ProcessUtils::runSync(updaterPath,args); } if (installStatus == 0) { LOG(Info,"Update install completed"); } else { LOG(Error,"Update install failed with status " + intToStr(installStatus)); } // restart the main application - this is currently done // regardless of whether the installation succeeds or not restartMainApp(); // clean up files created by the updater cleanup(); } else if (m_mode == Main) { LOG(Info,"Starting update installation"); // the detailed error string returned by the OS std::string error; // the message to present to the user. This may be the same // as 'error' or may be different if a more helpful suggestion // can be made for a particular problem std::string friendlyError; try { LOG(Info,"Installing new and updated files"); installFiles(); LOG(Info,"Uninstalling removed files"); uninstallFiles(); LOG(Info,"Removing backups"); removeBackups(); postInstallUpdate(); } catch (const FileUtils::IOException& exception) { error = exception.what(); friendlyError = friendlyErrorForError(exception); } catch (const std::string& genericError) { error = genericError; } if (!error.empty()) { LOG(Error,std::string("Error installing update ") + error); try { revert(); } catch (const FileUtils::IOException& exception) { LOG(Error,"Error reverting partial update " + std::string(exception.what())); } if (m_observer) { if (friendlyError.empty()) { friendlyError = error; } m_observer->updateError(friendlyError); } } if (m_observer) { m_observer->updateFinished(); } } }
void flowdevicemethods(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) { int m, iok = 0, n; int job = getInt(prhs[1]); int i = getInt(prhs[2]); double r = Undef; double v = Undef; if (nrhs > 3) { v = getDouble(prhs[3]); } // constructor if (job == 0) { n = flowdev_new(i); plhs[0] = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL); double* h = mxGetPr(plhs[0]); *h = double(n); if (n < 0) { reportError(); } return; } // options that do not return a value if (job < 20) { switch (job) { case 1: iok = flowdev_del(i); break; case 2: m = getInt(prhs[4]); iok = flowdev_install(i, int(v), m); break; case 3: iok = flowdev_setMassFlowRate(i, v); break; case 4: iok = flowdev_setParameters(i, 1, &v); break; case 5: iok = flowdev_setFunction(i, int(v)); break; case 6: iok = flowdev_ready(i); break; case 7: iok = flowdev_setMaster(i, int(v)); break; default: mexErrMsgTxt("unknown job parameter"); } plhs[0] = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL); double* h = mxGetPr(plhs[0]); *h = double(iok); if (iok < 0) { reportError(); } return; } // options that return a value of type 'double' else if (job < 40) { switch (job) { case 21: r = flowdev_massFlowRate(i, v); break; default: mexErrMsgTxt("unknown job parameter"); } plhs[0] = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL); double* h = mxGetPr(plhs[0]); *h = r; if (r == Undef) { reportError(); } return; } }
void reactormethods( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { int iok, n; int job = getInt(prhs[1]); int i = getInt(prhs[2]); double r = Undef; double v = Undef; if (nrhs > 3) v = getDouble(prhs[3]); // constructor if (job == 0) { n = reactor_new(i); plhs[0] = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL); double *h = mxGetPr(plhs[0]); *h = double(n); if (n < 0) reportError(); return; } // options that do not return a value if (job < 20) { switch (job) { case 1: iok = reactor_del(i); break; case 2: iok = reactor_copy(i); break; case 3: iok = reactor_assign(i,int(v)); break; case 4: iok = reactor_setInitialVolume(i, v); break; case 5: iok = reactor_setInitialTime(i, v); break; case 6: iok = reactor_setThermoMgr(i, int(v)); break; case 7: iok = reactor_setKineticsMgr(i, int(v)); break; case 8: iok = reactor_advance(i, v); break; case 9: iok = reactor_setEnergy(i, int(v)); break; default: mexErrMsgTxt("unknown job parameter"); } plhs[0] = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL); double *h = mxGetPr(plhs[0]); *h = double(iok); if (iok < 0) reportError(); return; } // options that return a value of type 'double' else if (job < 40) { switch (job) { case 21: r = reactor_step(i, v); break; case 22: r = reactor_time(i); break; case 23: r = reactor_mass(i); break; case 24: r = reactor_volume(i); break; case 25: r = reactor_density(i); break; case 26: r = reactor_temperature(i); break; case 27: r = reactor_enthalpy_mass(i); break; case 28: r = reactor_intEnergy_mass(i); break; case 29: r = reactor_pressure(i); break; case 30: r = reactor_massFraction(i, int(v)); break; default: mexErrMsgTxt("unknown job parameter"); } plhs[0] = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL); double *h = mxGetPr(plhs[0]); *h = r; if (r == Undef) reportError(); return; } }
void CheckCondition::redundantConditionError(const Token *tok, const std::string &text) { reportError(tok, Severity::style, "redundantCondition", "Redundant condition: " + text, CWE398, false); }
void _int_13() { reportError("Interrupts", "Interrupt 13: #GP (General Protection)", TRUE); }