int coertion(int x, int exp){ /*Quando é necessario atribuir a x uma expressao de outro tipo retorna o tipo da exp apos a coerção */ if(x==exp) return x; else if(x==IKS_FLOAT && exp==IKS_INT) return IKS_FLOAT; else if(x==IKS_INT && exp==IKS_FLOAT) return IKS_INT; else if(x==IKS_FLOAT && exp==IKS_BOOL) return IKS_FLOAT; else if(x==IKS_BOOL && exp==IKS_FLOAT) return IKS_BOOL; else if(x==IKS_INT && exp==IKS_BOOL) return IKS_INT; else if(x==IKS_BOOL && exp==IKS_INT) return IKS_BOOL; else if(exp==IKS_STRING){ printf("Impossivel fazer coerção para o tipo String (linha %d)\n", getLineNumber()-1); exit(IKS_ERROR_STRING_TO_X); } else if(exp==IKS_CHAR){ printf("Impossivel fazer coerção para o tipo Char (linha %d)\n", getLineNumber()-1); exit(IKS_ERROR_CHAR_TO_X); } else if(x==IKS_STRING || x==IKS_CHAR ){ printf("Tipos incompativeis (linha %d)\n", getLineNumber()-1); exit(IKS_ERROR_WRONG_TYPE); } }
int inference(int val1, int val2){ if(val1==val2) return val1; else if((val1==IKS_INT && val2==IKS_FLOAT) || (val2==IKS_INT && val1==IKS_FLOAT)) return IKS_FLOAT; else if((val1==IKS_INT && val2==IKS_BOOL) || (val2==IKS_INT && val1==IKS_BOOL)) return IKS_INT; else if((val1==IKS_BOOL && val2==IKS_FLOAT) || (val2==IKS_BOOL && val1==IKS_FLOAT)) return IKS_FLOAT; else if(val2==IKS_STRING){ printf("Impossivel fazer coerção para o tipo String (linha %d)\n", getLineNumber()-1); exit(IKS_ERROR_STRING_TO_X); } else if(val2==IKS_CHAR){ printf("Impossivel fazer coerção para o tipo Char (linha %d)\n", getLineNumber()-1); exit(IKS_ERROR_CHAR_TO_X); } else if(val1==IKS_STRING){ printf("Tipos incompativeis (linha %d)\n", getLineNumber()-1); exit(IKS_ERROR_WRONG_TYPE); } else if(val1==IKS_CHAR){ printf("Tipos incompativeis (linha %d)\n", getLineNumber()-1); exit(IKS_ERROR_WRONG_TYPE); } }
ASTREE* ParamLookup(ASTREE* param_i, List* param_list){ /*Precisaremos fazer um caminhamento a direita da arvore*/ List* ListNode; if(param_i == NULL && param_list==NULL) /*chegou ao fim dos parametros*/{ return NULL; } else if(param_i== NULL && param_list!= NULL){ printf("Faltando argumentos na função (linha %d)\n", getLineNumber()-1); exit(IKS_ERROR_MISSING_ARGS); } else if(param_i!= NULL && param_list== NULL){ printf("Excesso de argumentos na funcao (linha %d)\n", getLineNumber()-1); exit(IKS_ERROR_EXCESS_ARGS); } else if(param_list->type == param_i->symbol->type){ param_i = param_i->scc[0]; param_list = param_list->next; return ParamLookup(param_i,param_list); } else if(inference_three(param_list->type,param_i->symbol->type)){ param_i->symbol->type = inference_three(param_list->type,param_i->symbol->type); param_i = param_i->scc[0]; param_list = param_list->next; return ParamLookup(param_i,param_list); } else{ printf("Argumentos com tipos nao condizentes (linha %d)\n", getLineNumber()-1); exit(IKS_ERROR_WRONG_TYPE_ARGS); } }
NodePointer Parser::factor() { NodePointer result; SymbolType type = currentSymbol_.symbolType_; if (TheOperatorFactory::getInstance().isOperator(type)) { if (type == SUBSTRACTION) { type = MINUS; } OperatorPointer theOperator = TheOperatorFactory::getInstance().create(type); if (!theOperator->isUnary()) { throw ErrorMessage("Unary operator expected", getLineNumber()); } getNextSymbol(); NodePointer subExpressionTree = expression(theOperator->precedence()); result = NodePointer(new Expression(theOperator, NodePointerInserter()(subExpressionTree), getLineNumber())); } else if (type == LEFT_PARENTHESIS) { getNextSymbol(); NodePointer subExpressionTree = expression(); accept(RIGHT_PARENTHESIS); result = subExpressionTree; } else if (type == IDENTIFIER || type == GLOBAL) { result = NodePointer(new Variable(currentSymbol_.value_.toString(), tables_, type == GLOBAL)); getNextSymbol(); } else if (type == ARGUMENT) { result = NodePointer(new Argument(tables_.subroutineStack_, currentSymbol_.value_, getLineNumber())); getNextSymbol(); } else if (type == CONSTANT) { result = NodePointer(new Constant(currentSymbol_.value_)); getNextSymbol(); } else if (type == CALL) { return procedureCall(); } else { throw ErrorMessage("Unexpected symbol " + symbolToString(currentSymbol_), getLineNumber()); } return result; }
bool SourceLocation::operator< (const SourceLocation& other) const { if (fileName < other.fileName) return true; if (fileName > other.fileName) return false; return (getLineNumber() < other.getLineNumber()); }
bool KCFFile::readEDGE_(KCFFile::IndexAtomMap& index_to_atom) { if (!getLine().hasPrefix(EDGE_TAG)) { throw Exception::ParseError(__FILE__, __LINE__, String("'") + getLine() + "' (line " + String(getLineNumber()) + " of " + getName() + "'", String("Expected EDGE tag: ")); } Size number_of_edges = getLine().getField(1).toInt(); bool ok = true; for (Position i = 0; ok && (i < number_of_edges); i++) { // Get the next line readLine(); // Make sure the line starts with a blank ok &= getLine().hasPrefix(CONTINUED_LINE); // ??? Comments still mising Position first = getLine().getField(1).toInt(); Position second = getLine().getField(2).toInt(); Position order = getLine().getField(3).toInt(); // Make sure the indices refered to do exist ok &= index_to_atom.has(first) && index_to_atom.has(second); if (ok) { Bond* bond = index_to_atom[first]->createBond(*index_to_atom[second]); bond->setOrder(order); } } return (ok && readLine()); }
bool KCFFile::read(System& system) throw(Exception::ParseError) { Molecule* molecule = 0; bool read_anything = false; // Read all molecules. try { while ((molecule = read()) != 0) { // add the molecule to the system system.append(*molecule); molecule = 0; read_anything = true; } } catch (Exception::ParseError& e) { #ifdef DEBUG Log.info() << "KCFFile::read(System&): caught exception while parsing line " << getLineNumber() << ": " << e << std::endl; #endif // clean up and rethrow delete molecule; throw e; } // Make sure to return false if nothing could be read. return read_anything; }
bool Unit::compileTimeFatal(const StringData*& msg, int& line) const { // A compile-time fatal is encoded as a pseudomain that contains precisely: // // String <id>; Fatal; // // Decode enough of pseudomain to determine whether it contains a // compile-time fatal, and if so, extract the error message and line number. const Opcode* entry = getMain()->getEntry(); const Opcode* pc = entry; // String <id>; Fatal; // ^^^^^^ if (*pc != OpString) { return false; } pc++; // String <id>; Fatal; // ^^^^ Id id = *(Id*)pc; pc += sizeof(Id); // String <id>; Fatal; // ^^^^^ if (*pc != OpFatal) { return false; } msg = lookupLitstrId(id); line = getLineNumber(Offset(pc - entry)); return true; }
void frame_get_location(FrameIndex index, SerialNumber *pserial_num, jmethodID *pmethod, jlocation *plocation, jint *plineno) { FrameKey *pkey; FrameInfo *info; jint lineno; pkey = get_pkey(index); *pmethod = pkey->method; *plocation = pkey->location; info = get_info(index); lineno = (jint)info->lineno; if ( info->lineno_state == LINENUM_UNINITIALIZED ) { info->lineno_state = LINENUM_UNAVAILABLE; if ( gdata->lineno_in_traces ) { if ( pkey->location >= 0 && !isMethodNative(pkey->method) ) { lineno = getLineNumber(pkey->method, pkey->location); if ( lineno >= 0 ) { info->lineno = (unsigned short)lineno; /* save it */ info->lineno_state = LINENUM_AVAILABLE; } } } } if ( info->lineno_state == LINENUM_UNAVAILABLE ) { lineno = -1; } *plineno = lineno; *pserial_num = info->serial_num; }
int main(int argv, char **argc) { initMe(); //extern int yydebug; //int simb; if (argv < 2) { printf("Digite o nome do arquivo!\n"); exit(1); } yyin = fopen(argc[1],"r"); printf("Arquivo de entrada: %s\n",argc[1]); //yydebug = 1; yyparse(); //printTokens(); printf("╔═╗╦ ╦╔═╗╔═╗╔═╗╔═╗╔═╗\n"); printf("╚═╗║ ║║ ║╣ ╚═╗╚═╗║ ║\n"); printf("╚═╝╚═╝╚═╝╚═╝╚═╝╚═╝╚═╝\n"); printf("Analise sintatica feita com sucesso. Nenhum erro encontrado.\n"); printf("Numero de linhas do arquivo de entrada: %d\n", getLineNumber()); printf("TABELA HASH\n-----------\n"); hashPrint(); exit(0); }
/*************************************** * Function: astCreate * Description: * Input: * Output: ***************************************/ ast_t* astCreate(int type, hash_t *symbol, ast_t *s0,ast_t *s1, ast_t *s2, ast_t *s3) { ast_t *newNode; newNode = (ast_t*) calloc(1,sizeof(ast_t)); newNode->type = type; newNode->symbol = symbol; newNode->son[0]= s0; newNode->son[1]= s1; newNode->son[2]= s2; newNode->son[3]= s3; newNode->printFlag = 0; newNode->lineNumber = getLineNumber(); if (symbol) { gv_declare(type,newNode,symbol->text); } else { gv_declare(type,newNode,NULL); } if(newNode->son[0] !=NULL) gv_connect(newNode,newNode->son[0]); if(newNode->son[1] !=NULL) gv_connect(newNode,newNode->son[1]); if(newNode->son[2] !=NULL) gv_connect(newNode,newNode->son[2]); if(newNode->son[3] !=NULL) gv_connect(newNode,newNode->son[3]); return newNode; }
void SkDisplayXMLParserError::setInnerError(SkAnimateMaker* parent, const SkString& src) { SkString inner; getErrorString(&inner); inner.prepend(": "); inner.prependS32(getLineNumber()); inner.prepend(", line "); inner.prepend(src); parent->setErrorNoun(inner); }
/*! @decl int getLineNumber() */ static void f_getLineNumber(INT32 args) { pop_n_elems(args); if (!THIS->ctxt) push_int(-1); else push_int(getLineNumber(THIS->ctxt)); }
void Exception::formatEntry(std::ostream &stream, size_t depth) const { LocaleUtils::CLocaleScope localeScope(stream); if (depth > maxDepth_) { return; } if (hasTypeName(depth)) { formatTypeName(stream, depth); } else { stream << "(Unknown exception)"; } if (hasFileName(depth)) { stream << " "; formatFileName(stream, depth); } if (hasFunctionName(depth)) { stream << " "; formatFunctionName(stream, depth); } if (hasLineNumber(depth)) { stream << " line=" << getLineNumber(depth); } if (hasErrorCode(depth)) { stream << " ["; if (!hasErrorCodeName(depth)) { stream << "Code:"; } stream << getErrorCode(depth); if (hasErrorCodeName(depth)) { stream << ":"; formatErrorCodeName(stream, depth); } stream << "]"; } if (hasMessage(depth)) { stream << " " ; formatMessage(stream, depth); } #ifdef UTIL_STACK_TRACE_ENABLED if (hasStackTrace(depth)) { stream << " : " ; formatStackTrace(stream, depth); } #endif }
void ExceptionLocation::dump(ostream& s) const throw() { s << getFileName() << ":" #ifdef __FUNCTION__ << getFunctionName() << ":" #endif << getLineNumber(); }
List* FunctionListInsert(List* function_list,DICT_NODE* node, int type, int size, int label){ if(list_lookup(function_list,node->text)==NULL){ function_list=list_insert(function_list,type,size,node->text,label); } else{ printf("->Redeclaracao de funcao (linha %d)\n", getLineNumber()); exit(IKS_ERROR_DECLARED); } return function_list; }
List* LocalVarListInsert(List* local_var,DICT_NODE* node, int type, int size, List* function_list){ if(list_lookup(local_var,node->text)==NULL){ local_var=list_insert(local_var,type,size,node->text,0); } else{ printf("->Redeclaracao de variavel local (linha %d)\n", getLineNumber()); exit(IKS_ERROR_DECLARED); } return local_var; }
void Parser::accept(SymbolType symbolType) { if (currentSymbol_.symbolType_ == symbolType) { getNextSymbol(); } else { throw ErrorMessage("Expected " + keywordToString(symbolType), getLineNumber()); } }
static Variant HHVM_FUNCTION(assert, const Variant& assertion, const Variant& message /* = null */) { if (!s_option_data->assertActive) return true; CallerFrame cf; Offset callerOffset; auto const fp = cf(&callerOffset); auto const passed = [&]() -> bool { if (assertion.isString()) { if (RuntimeOption::EvalAuthoritativeMode) { // We could support this with compile-time string literals, // but it's not yet implemented. throw_not_supported("assert()", "assert with strings argument in RepoAuthoritative mode"); } return eval_for_assert(fp, assertion.toString()).toBoolean(); } return assertion.toBoolean(); }(); if (passed) return true; if (!s_option_data->assertCallback.isNull()) { auto const unit = fp->m_func->unit(); PackedArrayInit ai(3); ai.append(String(const_cast<StringData*>(unit->filepath()))); ai.append(Variant(unit->getLineNumber(callerOffset))); ai.append(assertion.isString() ? assertion : empty_string_variant_ref); HHVM_FN(call_user_func)(s_option_data->assertCallback, ai.toArray()); } if (s_option_data->assertException) { if (message.isObject()) { Object exn = message.toObject(); if (exn.instanceof(SystemLib::s_AssertionErrorClass)) { throw_object(exn); } } SystemLib::throwExceptionObject(message.toString()); } if (s_option_data->assertWarning) { String name(message.isNull() ? "Assertion" : message.toString()); auto const str = !assertion.isString() ? " failed" : concat3(" \"", assertion.toString(), "\" failed"); raise_warning("assert(): %s%s", name.data(), str.data()); } if (s_option_data->assertBail) { throw ExitException(1); } return init_null(); }
/* LLBVHLoader::LLBVHLoader(const char* buffer) { reset(); mStatus = loadTranslationTable("anim.ini"); if (mStatus == LLBVHLoader::ST_NO_XLT_FILE) { LL_WARNS() << "NOTE: No translation table found." << LL_ENDL; return; } else { if (mStatus != LLBVHLoader::ST_OK) { LL_WARNS() << "ERROR: [line: " << getLineNumber() << "] " << mStatus << LL_ENDL; return; } } char error_text[128]; // Flawfinder: ignore S32 error_line; mStatus = loadBVHFile(buffer, error_text, error_line); if (mStatus != LLBVHLoader::ST_OK) { LL_WARNS() << "ERROR: [line: " << getLineNumber() << "] " << mStatus << LL_ENDL; return; } applyTranslations(); optimize(); mInitialized = TRUE; } */ LLBVHLoader::LLBVHLoader(const char* buffer, ELoadStatus &loadStatus, S32 &errorLine) { reset(); errorLine = 0; mStatus = loadTranslationTable("anim.ini"); loadStatus = mStatus; LL_INFOS() << "Load Status 00 : " << loadStatus << LL_ENDL; if (mStatus == E_ST_NO_XLT_FILE) { //LL_WARNS() << "NOTE: No translation table found." << LL_ENDL; loadStatus = mStatus; return; } else { if (mStatus != E_ST_OK) { //LL_WARNS() << "ERROR: [line: " << getLineNumber() << "] " << mStatus << LL_ENDL; errorLine = getLineNumber(); loadStatus = mStatus; return; } } char error_text[128]; /* Flawfinder: ignore */ S32 error_line; mStatus = loadBVHFile(buffer, error_text, error_line); if (mStatus != E_ST_OK) { //LL_WARNS() << "ERROR: [line: " << getLineNumber() << "] " << mStatus << LL_ENDL; loadStatus = mStatus; errorLine = getLineNumber(); return; } applyTranslations(); optimize(); mInitialized = TRUE; }
int sserror(int errCode, DictItem *symEntry) { switch(errCode) { /* Verificação de declarações */ case IKS_ERROR_UNDECLARED: printf("IKS-ssa:@l:%d Identificador ' %s ' não declarado. \n", symEntry->occLine, symEntry->symbol.name); break; case IKS_ERROR_DECLARED: printf("IKS-ssa:@l:%d Redefinindo identificador ' %s ' (definido originalmente @l:%d). \n", getLineNumber(), symEntry->symbol.name, symEntry->occLine); break; /* Uso correto de identificadores */ case IKS_ERROR_VARIABLE: printf("IKS-ssa:@l:%d Identificador ' %s ' deve ser utilizado como variável. \n", getLineNumber(), symEntry->symbol.name); break; case IKS_ERROR_VECTOR: printf("IKS-ssa:@l:%d Identificador ' %s ' deve ser utilizado como vetor.\n", getLineNumber(), symEntry->symbol.name); break; case IKS_ERROR_FUNCTION : printf("IKS-ssa:@l:%d Identificador ' %s ' deve ser utilizado como função.\n",getLineNumber(), symEntry->symbol.name); break; /* Tipos e tamanho de dados */ case IKS_ERROR_WRONG_TYPE: printf("IKS-ssa:@l:%d Tipos incompatíveis.\n", getLineNumber()); break; case IKS_ERROR_STRING_TO_X: printf("IKS-ssa:@l:%d Coerção impossível do tipo string.\n", getLineNumber()); break; case IKS_ERROR_CHAR_TO_X: printf("IKS-ssa:@l:%d Coerção impossível do tipo char.\n", getLineNumber()); break; /* Argumentos e parâmetros */ case IKS_ERROR_MISSING_ARGS: printf("IKS-ssa:@l:%d Faltam argumentos para funcao.\n", getLineNumber()); break; case IKS_ERROR_EXCESS_ARGS: printf("IKS-ssa:@l:%d Excesso de argumentos para funcao. \n", getLineNumber()); break; case IKS_ERROR_WRONG_TYPE_ARGS: printf("IKS-ssa:@l:%d Argumentos incompatíveis para funcao. \n", getLineNumber()); break; /* Verificação de tipos em comandos */ case IKS_ERROR_WRONG_PAR_INPUT: printf("IKS-ssa:@l:%d Parâmetro no comando 'input' não é identificador. \n", getLineNumber()); break; case IKS_ERROR_WRONG_PAR_OUTPUT: printf("IKS-ssa:@l:%d Parâmetro no comando 'output' não é literal string ou expressão.\n", getLineNumber()); break; case IKS_ERROR_WRONG_PAR_RETURN: printf("IKS-ssa:@l:%d - Parâmetro no comando 'return' não é expressão compatível com tipo do retorno . \n", getLineNumber()); break; } }
List* GlobalVarListInsert(List* list,DICT_NODE* node,int control,int type, int size){ switch(control){ case GLOBAL_VAR_DEC_IDENTIFIER_CONTROL: if(list_lookup(list,node->text)==NULL) list=list_insert(list,type,size,node->text,0); else{ printf("->Redeclaracao de variavel global (linha = %d)\n", getLineNumber()); exit(IKS_ERROR_DECLARED); } break; case GLOBAL_VET_DEC_IDENTIFIER_CONTROL: if(list_lookup(list,node->text)==NULL){ list=list_insert(list,type,size,node->text,0); } else{ printf("->Redeclaracao de vetor (linha %d)\n", getLineNumber()); exit(IKS_ERROR_DECLARED); } break; } return list; }
NodePointer Parser::localVariable() { accept(MY); if (currentSymbol_.symbolType_ == IDENTIFIER) { return NodePointer(new LocalVariable(currentSymbol_.value_.toString(), tables_)); } else { throw ErrorMessage("Variable expected", getLineNumber()); } }
static int64_t HHVM_FUNCTION(xdebug_call_line) { // PHP5 xdebug returns 0 when it can't determine the line number. Offset pc; auto fp = get_call_fp(&pc); if (fp == nullptr) { return 0; } auto const unit = fp->m_func->unit(); assert(unit); return unit->getLineNumber(pc); }
std::string show(SrcKey sk) { auto func = sk.func(); auto unit = sk.unit(); const char *filepath = "*anonFile*"; if (unit->filepath()->data() && unit->filepath()->size()) { filepath = unit->filepath()->data(); } return folly::format("{}:{} in {}(id 0x{:#x})@{: >6}", filepath, unit->getLineNumber(sk.offset()), func->isPseudoMain() ? "pseudoMain" : func->fullName()->data(), (unsigned long long)sk.getFuncId(), sk.offset()).str(); }
NodePointer Parser::procedureDefinition() { getNextSymbol(); std::string name = "&" + currentSymbol_.value_.toString(); accept(DEFINITION); NodePointer definition = blockStatement(); if (tables_.subroutineTable_.find(name) != tables_.subroutineTable_.end()) { throw ErrorMessage("Multiple definition of subroutine " + name, getLineNumber()); } tables_.subroutineTable_[name] = definition; return NodePointer(new EmptyNode()); }
int main (int argc, char ** argv) { FILE *srcFilePointer = NULL; if (argc != 3) { fprintf(stderr, "ERROR! Input and output files must be defined! \nUsage: etapa6 inputFile outputFile\n"); exit(2); } initMe(); srcFilePointer = fopen(argv[1], "r"); if (srcFilePointer == NULL) { fprintf(stderr, "ERROR! The input file could not be opened! \nUsage: etapa6 inputFile outputFile\n"); exit(2); } yyin = srcFilePointer; if (yyparse() != 0) { fprintf(stderr, "Syntax error in line: %i\n\n", getLineNumber()+1); exit(3); } DEST_FILE = fopen(argv[2], "w"); if (DEST_FILE == NULL) { fprintf(stderr, "ERROR! The output file could not be opened! \nUsage: etapa6 inputFile outputFile\n"); exit(2); } //descompileTree(astTree); //astPrint(astTree, 0); hashPrint(); if (semanticErrors > 0) { printf("\n\nSemantic error!\n"); exit(4); } else { printf("\n\nProgram sucessful!\n\n"); exit(0); } }
list<string> getOutgroup(string fn){ list<string> result; int lineNb=getLineNumber(fn); FILE * o = fopen(fn.c_str(),"rt"); if (o==NULL) cout<<"Impossible to open outgroup file"<<endl; else{ int ino=readInt(o,"Error in the outgroup file, the file should begin with an integer (the number of outgroups)"); if (lineNb-1<ino) { cout<<"The number of given outgroups is small than the number of outgroups to read. Please change the number of outgroups to read at the first line of the outgroup file."<<endl; exit(EXIT_FAILURE); } for (int i=0;i<ino;i++) result.push_back(readWord(o,fn)); } return result; }
void QFCompleterTextEditWidget::cursorChanged() { emit cursorMoved(getLineNumber(), getColumnNumber()); QString s=validTextUnderCursor().trimmed(); //std::cout<<s.toLatin1().data()<<std::endl; if (currentTextUnderCursor!=s) { currentTextUnderCursor=s; emit wordUnderCursorChanged(s); } /*std::cout<<"document()->documentLayout()->documentSize() = "<<document()->documentLayout()->documentSize().width()<<" "<<document()->documentLayout()->documentSize().height()<<std::endl; std::cout<<"verticalScrollBar()->value() = "<<verticalScrollBar()->value()<<std::endl; std::cout<<"verticalScrollBar()->min max = "<<verticalScrollBar()->minimum()<<" "<<verticalScrollBar()->maximum()<<std::endl; std::cout<<"viewport()->height() = "<<viewport()->height()<<std::endl; std::cout<<"viewport()->width() = "<<viewport()->width()<<std::endl;*/ }
int getLineNumber(ASTNode* AT) { if(AT == NULL) return -1; if(isTerminal(AT->nodeid)) return AT->tk.lineNum; int i; for (i = 0; i < AT->child_cnt; ++i) { int ln = getLineNumber(AT->children[i]); if(ln != -1) return ln; } return -1; }