static void declarePredefines(void) { TreeNode *input; TreeNode *output; TreeNode *temp; /* define "int input(void)" */ input = newDecNode(FuncDecK); input->name = copyString("input"); input->functionReturnType = Integer; input->expressionType = Function; /* define "void output(int)" */ temp = newDecNode(ScalarDecK); temp->name = copyString("arg"); temp->variableDataType = Integer; temp->expressionType = Integer; output = newDecNode(FuncDecK); output->name = copyString("output"); output->functionReturnType = Void; output->expressionType = Function; output->child[0] = temp; /* get input() and output() added to global scope */ insertSymbol("input", input, 0); insertSymbol("output", output, 0); }
/*Maintain Symbol Table*/ bool insertSymbolDriver(SymbolType type, nodeType* p){ int i; int *size; if(!p) return false; switch(p->type){ case typeId://A variable size = (int *)malloc(sizeof(int)); *size = 1; return insertSymbol(p->id.i,type,1,size);//name type dimesion size break; case typeArr://An array size = (int *)malloc(sizeof(int) * p->arr.dimension); int tempsize; for(i = 0;i < p->arr.dimension; i++){ tempsize = inter(p->arr.index[i]); if(tempsize > 0) size[i] = tempsize; else{ strcat(err,"Error: size of array is zero or negative"); errtext = p->arr.id; return false; } } return insertSymbol(p->arr.id, type, p->arr.dimension, size);//last parameter: size break; } }
/**************************************************************** * mdsdcl_insert_symbols: ****************************************************************/ void mdsdcl_insert_symbols( /* Returns: void */ struct descriptor *dsc_cmdline /* <m> command line */ ,struct descriptor *dsc_prmList /* <r> parameter list */ ) { int doubleQuotes; int offsetStart; char *p; p = dsc_cmdline->dscA_pointer; if (!p) return; doubleQuotes = 0; for ( ; *p ; p++) { if (*p == '"') { /*========= Double-quote char =========*/ if (!doubleQuotes) doubleQuotes = 1; else if (*(p+1) == '"') p++; else doubleQuotes = 0; } else if (*p == '\'') { /*========= Single-quote char =========*/ if (!doubleQuotes) { /* normal unquoted string ... */ if (*(p+1) == '\'') strcpy(p,p+1); /* replace by single quote */ else { /*...else, replace symbol */ offsetStart = p - dsc_cmdline->dscA_pointer; p = insertSymbol(dsc_cmdline,offsetStart,offsetStart+1, dsc_prmList); } } else { /* inside quoted string ... */ if (*(p+1) == '\'') { /* 2 single quotes denote symbol */ offsetStart = p - dsc_cmdline->dscA_pointer; p = insertSymbol(dsc_cmdline,offsetStart,offsetStart+2, dsc_prmList); } } } } return; }
Stack::Stack(QWidget* parent) : QWidget(parent), m_symbols_dialog(0), m_printer(0), m_current_document(0), m_footer_margin(0), m_header_margin(0), m_footer_visible(0), m_header_visible(0) { setMouseTracking(true); m_contents = new QStackedWidget(this); m_alerts = new AlertLayer(this); m_scenes = new SceneList(this); setScenesVisible(false); m_menu = new QMenu(this); m_menu_group = new QActionGroup(this); m_menu_group->setExclusive(true); connect(m_menu_group, SIGNAL(triggered(QAction*)), this, SLOT(actionTriggered(QAction*))); m_find_dialog = new FindDialog(this); connect(m_find_dialog, SIGNAL(findNextAvailable(bool)), this, SIGNAL(findNextAvailable(bool))); connect(ActionManager::instance(), SIGNAL(insertText(QString)), this, SLOT(insertSymbol(QString))); m_layout = new QGridLayout(this); m_layout->setMargin(0); m_layout->setSpacing(0); m_layout->setRowMinimumHeight(1, 6); m_layout->setRowMinimumHeight(4, 6); m_layout->setRowStretch(2, 1); m_layout->setColumnMinimumWidth(1, 6); m_layout->setColumnMinimumWidth(4, 6); m_layout->setColumnStretch(1, 1); m_layout->setColumnStretch(2, 1); m_layout->setColumnStretch(3, 1); m_layout->addWidget(m_contents, 1, 0, 4, 6); m_layout->addWidget(m_scenes, 1, 0, 4, 3); m_layout->addWidget(m_alerts, 3, 3); m_resize_timer = new QTimer(this); m_resize_timer->setInterval(50); m_resize_timer->setSingleShot(true); connect(m_resize_timer, SIGNAL(timeout()), this, SLOT(updateBackground())); m_theme_renderer = new ThemeRenderer(this); connect(m_theme_renderer, SIGNAL(rendered(QImage,QRect,Theme)), this, SLOT(updateBackground(QImage,QRect))); setHeaderVisible(Preferences::instance().alwaysShowHeader()); setFooterVisible(Preferences::instance().alwaysShowFooter()); // Always draw background setAttribute(Qt::WA_OpaquePaintEvent); setAutoFillBackground(false); updateBackground(); }
void SymbolTable::insertSymbols(const SymbolList& symbols) { for (SymbolList::const_iterator it = symbols.begin(); it != symbols.end(); ++it) { insertSymbol(*it); } }
void SymbolTable::registrarImprima() { Symbol f(SymbolTable::GlobalScope, "imprima", 0, true, TIPO_NULO, false); f.cd = currentCod++; f.param.setVariable(true); f.isBuiltin = true; insertSymbol(f, SymbolTable::GlobalScope); }
void OSSymbolPool::reconstructSymbols(bool grow) { unsigned int new_nBuckets = nBuckets; OSSymbol *insert; OSSymbolPoolState state; if (grow) { new_nBuckets += new_nBuckets + 1; } else { /* Don't shrink the pool below the default initial size. */ if (nBuckets <= INITIAL_POOL_SIZE) { return; } new_nBuckets = (new_nBuckets - 1) / 2; } /* Create old pool to iterate after doing above check, cause it * gets finalized at return. */ OSSymbolPool old(this); count = 0; nBuckets = new_nBuckets; buckets = (Bucket *) kalloc(nBuckets * sizeof(Bucket)); ACCUMSIZE(nBuckets * sizeof(Bucket)); /* @@@ gvdl: Zero test and panic if can't set up pool */ bzero(buckets, nBuckets * sizeof(Bucket)); state = old.initHashState(); while ( (insert = old.nextHashState(&state)) ) insertSymbol(insert); }
void addQueryToCache(Client c) { MalBlkPtr mb; backend *be; str msg = 0, pipe; be = (backend *) c->sqlcontext; assert(be && be->mvc); /* SQL clients should always have their state set */ pipe = getSQLoptimizer(be->mvc); insertSymbol(c->nspace, c->curprg); trimMalBlk(c->curprg->def); c->blkmode = 0; mb = c->curprg->def; chkProgram(c->fdout, c->nspace, mb); #ifdef _SQL_OPTIMIZER_DEBUG mnstr_printf(GDKout, "ADD QUERY TO CACHE\n"); printFunction(GDKout, mb, 0, LIST_MAL_ALL); #endif /* * An error in the compilation should be reported to the user. * And if the debugging option is set, the debugger is called * to allow inspection. */ if (mb->errors) { showErrors(c); if (c->listing) printFunction(c->fdout, mb, 0, c->listing); if (be->mvc->debug) { msg = runMALDebugger(c, c->curprg); if (msg != MAL_SUCCEED) GDKfree(msg); /* ignore error */ } return; } addOptimizers(c, mb, pipe); msg = optimizeMALBlock(c, mb); if (msg != MAL_SUCCEED) { showScriptException(c->fdout, mb, 0, MAL, "%s", msg); GDKfree(msg); return; } /* time to execute the optimizers */ if (c->debug) optimizerCheck(c, mb, "sql.baseline", -1, 0); #ifdef _SQL_OPTIMIZER_DEBUG mnstr_printf(GDKout, "ADD optimized QUERY TO CACHE\n"); printFunction(GDKout, mb, 0, LIST_MAL_ALL); #endif }
void addQueryToCache(Client c) { str msg = NULL; insertSymbol(c->nspace, c->curprg); msg = optimizeQuery(c); if (msg != MAL_SUCCEED) { showScriptException(c->fdout, c->curprg->def, 0, MAL, "%s", msg); GDKfree(msg); } }
int main (){ node *list; list = createList(list); node *SymbolTeste; insertSymbol(list, "TESTE"); SymbolTeste = findSymbol(list, "TESTE"); destroyList(list); }
Stack::Stack(QWidget* parent) : QWidget(parent), m_symbols_dialog(0), m_current_document(0), m_background_position(0), m_margin(0), m_footer_margin(0), m_header_margin(0), m_footer_visible(0), m_header_visible(0) { setMouseTracking(true); m_contents = new QStackedWidget(this); m_alerts = new AlertLayer(this); m_scenes = new SceneList(this); setScenesVisible(false); m_load_screen = new LoadScreen(this); m_find_dialog = new FindDialog(this); connect(m_find_dialog, SIGNAL(findNextAvailable(bool)), this, SIGNAL(findNextAvailable(bool))); connect(ActionManager::instance(), SIGNAL(insertText(QString)), this, SLOT(insertSymbol(QString))); m_layout = new QGridLayout(this); m_layout->setMargin(0); m_layout->setSpacing(0); m_layout->setRowMinimumHeight(1, 6); m_layout->setRowMinimumHeight(4, 6); m_layout->setRowStretch(2, 1); m_layout->setColumnMinimumWidth(1, 6); m_layout->setColumnMinimumWidth(4, 6); m_layout->setColumnStretch(1, 1); m_layout->setColumnStretch(2, 1); m_layout->setColumnStretch(3, 1); m_layout->addWidget(m_contents, 1, 0, 4, 6); m_layout->addWidget(m_scenes, 1, 0, 4, 3); m_layout->addWidget(m_alerts, 3, 3); m_layout->addWidget(m_load_screen, 0, 0, 6, 6); m_resize_timer = new QTimer(this); m_resize_timer->setInterval(50); m_resize_timer->setSingleShot(true); connect(m_resize_timer, SIGNAL(timeout()), this, SLOT(updateBackground())); connect(&background_loader, SIGNAL(finished()), this, SLOT(updateBackground())); }
bool saveSymbol (tNodePtr * currTS, char * key, char * name, int type, int argCount, bool errOnRedef) { /* Otestujem či už náhodou neexistuje daný symbol */ if (searchSymbol (currTS, key) == 0) { /* Alokujem si miesto pre data pre nový symbol v tabulke */ tData newsymbol = malloc (sizeof (struct tData)); /* Ak alokácia zlyhala alebo predaný name či key je NULL volám chybu 99 */ /* Ak alokácia prebehla bez problémov a názvy sú neprázdne, pokračujem */ if (newsymbol != NULL || key != NULL || name != NULL) { /*Do dátovej štruktúry uložím dáta predané funkcii*/ newsymbol -> name = name; newsymbol -> type = type; newsymbol -> nextArg = NULL; newsymbol -> argCount = argCount; newsymbol -> localTSadr = NULL; newsymbol -> localILadr = NULL; //newsymbol -> content.integer = rand() % 100; /*Uložím do aktuálnej tabulky nový symbol ktorý som si práve pripravil*/ /*Ak vloženie zlyhá, vraciam internú chybu errInt(99) */ if (insertSymbol (currTS, key, newsymbol) == 0) { printf ("jkebol saveSymbol\n"); errorHandler (errInt); } return true; } else { printf ("jebol saveSymbol 2\n"); errorHandler (errInt); } } else if (errOnRedef == true) errorHandler (errSemDef); return false; }
void Stack::showSymbols() { // Load symbols dialog on demand if (!m_symbols_dialog) { window()->setCursor(Qt::WaitCursor); m_symbols_dialog = new SymbolsDialog(this); m_symbols_dialog->setInsertEnabled(!m_current_document->isReadOnly()); m_symbols_dialog->setPreviewFont(m_current_document->text()->font()); connect(m_symbols_dialog, SIGNAL(insertText(QString)), this, SLOT(insertSymbol(QString))); window()->unsetCursor(); } // Show dialog m_symbols_dialog->show(); m_symbols_dialog->raise(); m_symbols_dialog->activateWindow(); }
bool LineOfSymbols::replaceVar(const QString &pattern, modbusVar *var, unsigned int pos) { variable curVar; QVector<quint16> curSymbols; for(int i=0;i<vars.count();i++) { unsigned char startPos = vars[i].view.getPosition(); unsigned char endPos = startPos + vars[i].view.getLength()-1; if((pos>=startPos)&&(pos<=endPos)) { curVar = vars[i]; for(int j=startPos;j<=endPos;j++) curSymbols+=symbols.at(j); break; } } for(int i=0;i<vars.count();i++) { unsigned char startPos = vars[i].view.getPosition(); unsigned char endPos = startPos + vars[i].view.getLength()-1; if((pos>=startPos)&&(pos<=endPos)) { vars.remove(i); for(int j=startPos;j<=endPos;j++) { if(j<symbols.count()) deleteSymbol(startPos); } bool res = insertVar(pattern,var,startPos); if(res==false) { for(int j=startPos;j<=endPos;j++) { insertSymbol(curSymbols[j-startPos],j); } vars+=curVar; } return res; } } return false; }
void MSinitClientPrg(Client cntxt, str mod, str nme) { InstrPtr p; MalBlkPtr mb; if (cntxt->curprg && idcmp(nme, cntxt->curprg->name) == 0) { MSresetClientPrg(cntxt); return; } cntxt->curprg = newFunction(putName("user", 4), putName(nme, strlen(nme)), FUNCTIONsymbol); mb = cntxt->curprg->def; p = getSignature(cntxt->curprg); if (mod) setModuleId(p, mod); else setModuleScope(p, cntxt->nspace); setVarType(mb, findVariable(mb, nme), TYPE_void); insertSymbol(cntxt->nspace, cntxt->curprg); cntxt->glb = 0; assert(cntxt->curprg->def != NULL); }
void Font::loadSymbols(std::string name){ std::string path = "../res/fonts/"; std::ifstream file; file.open(path + name + ".fnt", std::ios::in); std::string infoFaceLine, commonLine, countLine, buff; getline(file, infoFaceLine); getline(file, commonLine); getline(file, buff); // non used getline(file, countLine); // float sizeU = (float)rgxIntSearch(commonLine, R"(scaleW=([\-]?[0-9]+))"); float sizeV = (float)rgxIntSearch(commonLine, R"(scaleH=([\-]?[0-9]+))"); int charCount = rgxIntSearch(countLine, R"(count=([\-]?[0-9]+))"); std::vector<std::string> lines; lines.resize(charCount); this->height = rgxIntSearch(commonLine, R"(lineHeight=([\-]?[0-9]+))");; for (int i = 0; i < charCount; i++) getline(file, lines[i]); for(auto &it : lines) insertSymbol(it, sizeU, sizeV); }
void constructParsingTable() { /*read the set of Productions and constructs Parsing Table*/ FILE *fp; int i,j,num,prod_count; char name[50]; Symbol symbol,nonterminal; List prod_right, first_set; Production production; fp = fopen("productions","r"); while(!feof(fp)) { fscanf(fp,"%d %s",&num,name); //abstract out the non terminal whose production it is nonterminal = findSymbol(name); //construct list of symbols on the right hand side of production prod_right = (List)malloc(sizeof(struct list)*(num-1)); for(i=0;i<(num-1);i++) { fscanf(fp,"%s",name); symbol = findSymbol(name); if(symbol==NULL) symbol = insertSymbol(name,TERMINAL); prod_right[i].symbol=symbol; } //now we need to fill the parsing table corresponding to nonterminal and the production if(nonterminal->prodtable==NULL) { nonterminal->prodtable = (ProductionTable)malloc(sizeof(struct prodtable)); nonterminal->prodtable->productions = (Production)malloc((PROD_TABLE_SIZE)*sizeof(struct production)); } //enter production X->beta in row X, column T for each T in FIRST[beta] for(i=0;i<(num-1);i++) { first_set=prod_right[i].symbol->first; for(j=0;j<prod_right[i].symbol->num_first;j++) { production = insertProduction(nonterminal->prodtable, first_set[j].symbol); production->prod_right=prod_right; production->num_symbols=(num-1); } if(prod_right[i].symbol->nullable==YES) continue; else break; } //enter production X->beta in row X, column T for each T in FOLLOW[X], if nullable(beta) if(i==(num-1)) { //nullable(beta)==YES for(j=0;j<nonterminal->num_follow;j++) { production = insertProduction(nonterminal->prodtable, nonterminal->follow[j].symbol); production->prod_right=prod_right; production->num_symbols=(num-1); } } //calculate number of production criteria entered for the current symbol prod_count=0; for(i=0;i<PROD_TABLE_SIZE;i++) { if(nonterminal->prodtable->productions[i].terminal!=NULL) prod_count++; } nonterminal->prodtable->num_productions=prod_count; } fclose(fp); }
void loadParsingTables(FILE *fp) { /*loads the saved data structures from the file*/ int i,j,k,num; Nullable nullable; Type type; char sname[20]; symbols = (STable)malloc(sizeof(struct stable)); symbols->symbol = (Symbol *)malloc(sizeof(struct symbol)*S_TABLE_SIZE); symbols->size = S_TABLE_SIZE; Symbol s,term; Production production; while(!feof(fp)) { //read symbol name, nullable & type fscanf(fp,"%s %d %d",sname,(int*)&nullable,(int*)&type); s=insertSymbol(sname,type); s->nullable=nullable; //read in FIRST set fscanf(fp,"%d",&num); s->num_first = num; s->first=(List)malloc(sizeof(struct list)*num); for(i=0;i<num;i++) { fscanf(fp,"%s",sname); term = findSymbol(sname); if(term==NULL) term = insertSymbol(sname,TERMINAL); s->first[i].symbol=term; } if(type==NONTERMINAL) { //read in FOLLOW set fscanf(fp,"%d",&num); s->num_follow=num; s->follow=(List)malloc(sizeof(struct list)*num); for(i=0;i<num;i++) { fscanf(fp,"%s",sname); term = findSymbol(sname); if(term==NULL) term = insertSymbol(sname,TERMINAL); s->follow[i].symbol=term; } //read in ProductionTable if(s->prodtable==NULL) { s->prodtable = (ProductionTable)malloc(sizeof(struct prodtable)); s->prodtable->productions = (Production)malloc((PROD_TABLE_SIZE)*sizeof(struct production)); } fscanf(fp,"%d",&num); s->prodtable->num_productions=num; for(i=0;i<num;i++) { fscanf(fp,"%s",sname); term = findSymbol(sname); if(term==NULL) term = insertSymbol(sname,TERMINAL); production = insertProduction(s->prodtable,term); fscanf(fp,"%d",&k); production->num_symbols = k; production->prod_right = (List)malloc(sizeof(struct list)*k); for(j=0;j<k;j++) { fscanf(fp,"%s %d",sname,(int*)&type); term = findSymbol(sname); if(term==NULL) term = insertSymbol(sname,type); production->prod_right[j].symbol=term; } } } } }
static void buildSymbolTable2(TreeNode *syntaxTree) { int i; /* iterate over node children */ HashNodePtr luSymbol; /* symbol being looked up */ char errorMessage[80]; /* used to decorate RETURN nodes with enclosing procedure */ static TreeNode *enclosingFunction = NULL; while (syntaxTree != NULL) { /* * Examine current symbol: if it's a declaration, insert into * symbol table. */ if (syntaxTree->nodekind == DecK) insertSymbol(syntaxTree->name, syntaxTree, syntaxTree->lineno); /* If entering a new function, tell the symbol table */ if ((syntaxTree->nodekind == DecK) && (syntaxTree->kind.dec == FuncDecK)) { /* record the enclosing procedure declaration */ enclosingFunction = syntaxTree; if (TraceAnalyse) /* * For functions at least, it's nice to tell the user * whereabouts in the program the variable comes into * scope. We don't bother printing out compound-stmt * scopes */ drawRuler(listing, syntaxTree->name); newScope(); ++scopeDepth; } /* If entering a compound-statement, create a new scope as well */ if ((syntaxTree->nodekind == StmtK) && (syntaxTree->kind.stmt == CompoundK)) { newScope(); ++scopeDepth; } /* * If the current node is an identifier, it needs to be checked * against the symbol table, and annotated with a pointer back to * it's declaration. */ if (((syntaxTree->nodekind == ExpK) /* identifier reference... */ && (syntaxTree->kind.exp == IdK)) || ((syntaxTree->nodekind == StmtK) /* function call... */ && (syntaxTree->kind.stmt == CallK))) { DEBUG_ONLY( fprintf(listing, "*** Annotating identifier \"%s\" on line %d\n", syntaxTree->name, syntaxTree->lineno); ); luSymbol = lookupSymbol(syntaxTree->name); if (luSymbol == NULL) { /* operation failed; say so to user */ sprintf(errorMessage, "identifier \"%s\" unknown or out of scope\n", syntaxTree->name); flagSemanticError(errorMessage); } else { /* * Annotate identifier tree-node with a pointer to it's * declaration. */ syntaxTree->declaration = luSymbol->declaration; } }
void constructSTable() { /*Reads in FIRST-FOLLOW Sets and puts all grammar symbols into Hash Table*/ FILE *fp; char symbol[20]; int i,num; symbols = (STable)malloc(sizeof(struct stable)); symbols->symbol = (Symbol *)malloc(sizeof(struct symbol)*S_TABLE_SIZE); symbols->size = S_TABLE_SIZE; for(i=0;i<S_TABLE_SIZE;i++) { symbols->symbol[i]=NULL; } Symbol nonterm,term; fp=fopen("ffsets","r"); while(!feof(fp)) { //read symbol name and if nullable fscanf(fp,"%s",symbol); nonterm = insertSymbol(symbol,NONTERMINAL); fscanf(fp,"%s",symbol); if(strcmp(symbol,"NO")==0) nonterm->nullable = NO; else nonterm->nullable = YES; //read FIRST set fscanf(fp,"%d",&num); nonterm->num_first=num; nonterm->first=(List)malloc(sizeof(struct list)*num); for(i=0;i<num;i++) { fscanf(fp,"%s",symbol); term = findSymbol(symbol); if(term==NULL) term = insertSymbol(symbol,TERMINAL); nonterm->first[i].symbol=term; } //read FOLLOW set fscanf(fp,"%d",&num); nonterm->num_follow=num; nonterm->follow=(List)malloc(sizeof(struct list)*num); for(i=0;i<num;i++) { fscanf(fp,"%s",symbol); term = findSymbol(symbol); if(term==NULL) term = insertSymbol(symbol,TERMINAL); nonterm->follow[i].symbol=term; } } fclose(fp); //manually add terminal entry for ε (null production) term = insertSymbol("ε",TERMINAL); term->nullable = YES; term->num_first = 0; term->num_follow = 0; term->first=NULL; term->follow=NULL; term->prodtable=NULL; }
void SymbolTable::registrarLeia() { Symbol f(SymbolTable::GlobalScope, "leia", 0, true, TIPO_ALL, false); f.cd = currentCod++; f.isBuiltin = true; insertSymbol(f, SymbolTable::GlobalScope); }
void block(){ int jmpLoc = reserveCode(); int thisScope; int numVars = 0; char tempSymbol[MAX_IDENT_LENGTH + 1]; if(currentToken == constsym){ /***************************************************************/ /* const-declaration ::= [ "const" ident "=" number */ /* {"," ident "=" number} ";"] */ /***************************************************************/ do{ readToken(); if(currentToken != identsym){ throwError(ID_FOLLOW_CONST_VAR_PROC); }else{ strcpy(tempSymbol, tokenVal.string); } readToken(); if(currentToken != eqsym){ if(currentToken == becomessym) throwError(EQ_NOT_BECOMES); else throwError(EQ_FOLLOW_ID); } readToken(); if(currentToken != numbersym){ throwError(NUM_FOLLOW_EQ); }else{ insertSymbol(symTable, newSymbol(CONST, tempSymbol, scope, 0, tokenVal.numeric)); } readToken(); }while(currentToken == commasym); if(currentToken != semicolonsym) throwError(SEMICOL_COMMA_MISS); readToken(); } if(currentToken == intsym){ /*******************************************************/ /* var-declaration ::= ["int" ident {"," ident} ";"] */ /*******************************************************/ do{ readToken(); if(currentToken != identsym){ throwError(ID_FOLLOW_CONST_VAR_PROC); }else{ insertSymbol(symTable, newSymbol(VAR, tokenVal.string, scope, BASE_OFFSET + numVars++, 0)); } readToken(); }while(currentToken == commasym); if(currentToken != semicolonsym) throwError(SEMICOL_COMMA_MISS); readToken(); } //Saving the scope before moving into procedure declarations thisScope = scope; while(currentToken == procsym){ /**********************************************************************/ /* proc-declaration ::= {"procedure" ident ";" block ";"} statement */ /**********************************************************************/ readToken(); if(currentToken != identsym) throwError(ID_FOLLOW_CONST_VAR_PROC); //Storing the function name in the symbol table insertSymbol(symTable, newSymbol(FUNC, tokenVal.string, thisScope, genLabel(), 0)); readToken(); if(currentToken != semicolonsym) throwError(SEMICOL_COMMA_MISS); readToken(); //Incrementing the scope for our new function and saving its parent //in the disjoint set scope++; scopeParent[scope] = thisScope; block(); if(currentToken != semicolonsym) throwError(WRONG_SYM_AFTER_PROC); readToken(); } //Restoring the scope scope = thisScope; backPatch(jmpLoc, JMP, 0, genLabel()); genCode(INC, 0, BASE_OFFSET + numVars); statement(); genCode(OPR, 0, RET); return; }
AnnotationTerminals::AnnotationTerminals() { insertSymbol("[", ID_LBRACKET); insertSymbol("]", ID_RBRACKET); insertSymbol("@", ID_AT); insertSymbol("=", ID_EQUAL); insertSymbol(",", ID_COMMA); insertSymbol("\"", ID_QUOTE); insertSymbol("'", ID_APOSTROPHE); insertSymbol("true", ID_TRUE, true); insertSymbol("false", ID_FALSE, true); insertSymbol("IDENTIFIER", ID_IDENTIFIER); insertSymbol("INTCONST", ID_INTCONST); insertSymbol("FLOATCONST", ID_FLOATCONST); insertSymbol("STRING", ID_STRING); insertSymbol("CHARACTER", ID_CHARACTER); }
PlotFunctionTerminals::PlotFunctionTerminals() { insertSymbol("(", ID_LPAREN); insertSymbol(")", ID_RPAREN); insertSymbol("[", ID_LBRACKET); insertSymbol("]", ID_RBRACKET); insertSymbol(".", ID_DOT); insertSymbol(",", ID_COMMA); insertSymbol(":", ID_COLON); insertSymbol(";", ID_SEMICOLON); insertSymbol("-", ID_DASH); insertSymbol("+", ID_PLUS); insertSymbol("*", ID_STAR); insertSymbol("/", ID_SLASH); insertSymbol("^", ID_CARET); insertSymbol("|", ID_VERTICAL_BAR); insertSymbol("RANGE_TERM", ID_RANGE_TERM); insertSymbol("FUNCTION-TERM",ID_FUNCTION_TERM); insertSymbol("FUNCTION", ID_FUNCTION); insertSymbol("INTCONST", ID_INTCONST); insertSymbol("FLOATCONST", ID_FLOATCONST); insertSymbol("VARIABLE", ID_VARIABLE); insertSymbol("EMPTY",ID_EMPTY); }
void hoistSymbols(uint32_t slot, Node *table, symtab_t *symbols, symtab_t *block) { while (slot) switch (table[slot].type) { case node_endlist: case node_list: { listNode *ln; do { ln = (listNode *)(table + slot); hoistSymbols(ln->elem, table, symbols, block); slot -= sizeof(listNode) / sizeof(Node); } while ( ln->hdr->type == node_list ); return; } case node_elem: { binaryNode *bn = (binaryNode *)(table + slot); slot = bn->right; continue; } case node_obj: { objNode *on = (objNode *)(table + slot); slot = on->elemlist; continue; } case node_pipe: case node_fcncall: { fcnCallNode *fc = (fcnCallNode *)(table + slot); hoistSymbols(fc->name, table, symbols, block); slot = fc->args; continue; } case node_ifthen: { ifThenNode *iftn = (ifThenNode *)(table + slot); hoistSymbols(iftn->thenstmt, table, symbols, block); slot = iftn->elsestmt; continue; } case node_while: case node_dowhile: { whileNode *wn = (whileNode *)(table + slot); slot = wn->stmt; continue; } case node_forin: { forInNode *forn = (forInNode*)(table + slot); // make a new scope frame forn->symbols.depth = symbols->depth; forn->symbols.parent = block; block = &forn->symbols; hoistSymbols(forn->var, table, symbols, block); if (forn->symbols.parent) { if (forn->symbols.parent->scopeCnt < block->frameIdx) forn->symbols.parent->scopeCnt = block->frameIdx; } else { if (symbols->scopeCnt < block->frameIdx) symbols->scopeCnt = block->frameIdx; } slot = forn->stmt; continue; } case node_for: { forNode *forn = (forNode*)(table + slot); // make a new scope frame forn->symbols.depth = symbols->depth; forn->symbols.parent = block; block = &forn->symbols; hoistSymbols(forn->init, table, symbols, block); if (forn->symbols.parent) { if (forn->symbols.parent->scopeCnt < block->frameIdx) forn->symbols.parent->scopeCnt = block->frameIdx; } else { if (symbols->scopeCnt < block->frameIdx) symbols->scopeCnt = block->frameIdx; } slot = forn->stmt; continue; } case node_opassign: case node_assign: { binaryNode *bn = (binaryNode *)(table + slot); hoistSymbols(bn->left, table, symbols, block); slot = bn->right; continue; } case node_var: { symNode *sym = (symNode *)(table + slot); stringNode *sn = (stringNode *)(table + sym->name); if (sym->hdr->flag & flag_decl) { if (sym->hdr->flag & flag_scope && block) insertSymbol(&sn->str, block, true); else insertSymbol(&sn->str, symbols, false); } return; } case node_block: { blkEntryNode *be = (blkEntryNode *)(table + slot); // make new scope be->symbols.depth = symbols->depth; be->symbols.parent = block; block = &be->symbols; hoistSymbols(be->body, table, symbols, block); if (be->symbols.parent) { if (be->symbols.parent->scopeCnt < block->frameIdx) be->symbols.parent->scopeCnt = block->frameIdx; } else { if (symbols->scopeCnt < block->frameIdx) symbols->scopeCnt = block->frameIdx; } return; } case node_fcndef: { fcnDeclNode *fd = (fcnDeclNode *)(table + slot); // install the function name in symbol table symNode *sym = (symNode *)(table + fd->name); stringNode *sn = (stringNode *)(table + sym->name); sym->frameIdx = insertSymbol(&sn->str, symbols, false); sym->level = 0; if (hoistDebug) printf("node %d hoist fcndecl: %s\n", slot, sn->str.val); // add to list of child fcns fd->next = symbols->childFcns; symbols->childFcns = slot; } case node_fcnexpr: { fcnDeclNode *fd = (fcnDeclNode *)(table + slot); fd->symbols.depth = symbols->depth + 1; fd->symbols.parent = symbols; hoistSymbols(fd->params, table, &fd->symbols, block); fd->nparams = fd->symbols.frameIdx; // install fcn name from fcn expression if (fd->hdr->type == node_fcnexpr) if (fd->name && table[fd->name].type == node_var) { symNode *sym = (symNode *)(table + fd->name); stringNode *sn = (stringNode *)(table + sym->name); // install the function name in the table sym->frameIdx = insertSymbol(&sn->str, &fd->symbols, false); sym->level = 0; if (hoistDebug) printf("node %d hoist fcnexpr: %s\n", slot, sn->str.val); } // hoist function body declarations hoistSymbols(fd->body, table, &fd->symbols, block); return; } case node_return: { exprNode *en = (exprNode *)(table + slot); slot = en->expr; continue; } default: if (hoistDebug) printf("node %d unprocessed: %d\n", slot, (int)table[slot].type); return; } }
GLSLTerminals::GLSLTerminals() { insertSymbol("<<", ID_LSHIFT_OP); insertSymbol(">>", ID_RSHIFT_OP); insertSymbol("++", ID_INC_OP); insertSymbol("--", ID_DEC_OP); insertSymbol("<=", ID_LE_OP); insertSymbol(">=", ID_GE_OP); insertSymbol("==", ID_EQ_OP); insertSymbol("!=", ID_NE_OP); insertSymbol("&&", ID_AND_OP); insertSymbol("||", ID_OR_OP); insertSymbol("^^", ID_XOR_OP); insertSymbol("<<=", ID_LSHIFT_ASSIGN); insertSymbol(">>=", ID_RSHIFT_ASSIGN); insertSymbol("+=", ID_ADD_ASSIGN); insertSymbol("/=", ID_DIV_ASSIGN); insertSymbol("*=", ID_MUL_ASSIGN); insertSymbol("-=", ID_SUB_ASSIGN); insertSymbol("%=", ID_MOD_ASSIGN); insertSymbol("&=", ID_AND_ASSIGN); insertSymbol("|=", ID_OR_ASSIGN); insertSymbol("^=", ID_XOR_ASSIGN); insertSymbol("(", ID_LPAREN); insertSymbol(")", ID_RPAREN); insertSymbol("[", ID_LBRACKET); insertSymbol("]", ID_RBRACKET); insertSymbol("{", ID_LBRACE); insertSymbol("}", ID_RBRACE); insertSymbol("<", ID_LANGLE); insertSymbol(">", ID_RANGLE); insertSymbol(".", ID_DOT); insertSymbol(",", ID_COMMA); insertSymbol(":", ID_COLON); insertSymbol(";", ID_SEMICOLON); insertSymbol("=", ID_EQUAL); insertSymbol("!", ID_BANG); insertSymbol("-", ID_DASH); insertSymbol("~", ID_TILDE); insertSymbol("+", ID_PLUS); insertSymbol("*", ID_STAR); insertSymbol("/", ID_SLASH); insertSymbol("%", ID_PERCENT); insertSymbol("|", ID_VERTICAL_BAR); insertSymbol("^", ID_CARET); insertSymbol("&", ID_AMPERSAND); insertSymbol("?", ID_QUESTION); insertSymbol("attribute", ID_ATTRIBUTE, true); insertSymbol("const", ID_CONST, true); insertSymbol("in", ID_IN, true); insertSymbol("inout", ID_INOUT, true); insertSymbol("out", ID_OUT, true); insertSymbol("uniform", ID_UNIFORM, true); insertSymbol("varying", ID_VARYING, true); insertSymbol("centroid", ID_CENTROID, true); insertSymbol("invariant", ID_INVARIANT, true); insertSymbol("flat", ID_FLAT, true); insertSymbol("layout", ID_LAYOUT, true); insertSymbol("noperspective", ID_NONPERSPECTIVE, true); insertSymbol("smooth", ID_SMOOTH, true); // precision qualifiers // insertSymbol("highp", ID_HIGHP, true); insertSymbol("lowp", ID_LOWP, true); insertSymbol("mediump", ID_MEDIUMP, true); insertSymbol("precision", ID_PRECISION, true); // program control / statements // insertSymbol("case", ID_CASE, true); insertSymbol("default", ID_DEFAULT, true); insertSymbol("do", ID_DO, true); insertSymbol("else", ID_ELSE, true); insertSymbol("for", ID_FOR, true); insertSymbol("if", ID_IF, true); insertSymbol("switch", ID_SWITCH, true); insertSymbol("while", ID_WHILE, true); insertSymbol("break", ID_BREAK, true); insertSymbol("continue", ID_CONTINUE, true); insertSymbol("discard", ID_DISCARD, true); insertSymbol("return", ID_RETURN, true); insertSymbol("false", ID_FALSE, true); insertSymbol("true", ID_TRUE, true); insertSymbol("struct", ID_STRUCT, true); // "primitive" types // insertSymbol("bool", ID_BOOL, true); insertSymbol("float", ID_FLOAT, true); insertSymbol("int", ID_INT, true); insertSymbol("uint", ID_UINT, true); insertSymbol("void", ID_VOID, true); // "complexe" types // insertSymbol("bvec2", ID_BVEC2, true); insertSymbol("bvec3", ID_BVEC3, true); insertSymbol("bvec4", ID_BVEC4, true); insertSymbol("ivec2", ID_IVEC2, true); insertSymbol("ivec3", ID_IVEC3, true); insertSymbol("ivec4", ID_IVEC4, true); insertSymbol("uvec2", ID_UVEC2, true); insertSymbol("uvec3", ID_UVEC3, true); insertSymbol("uvec4", ID_UVEC4, true); insertSymbol("vec2", ID_VEC2, true); insertSymbol("vec3", ID_VEC3, true); insertSymbol("vec4", ID_VEC4, true); insertSymbol("mat2", ID_MAT2, true); insertSymbol("mat3", ID_MAT3, true); insertSymbol("mat4", ID_MAT4, true); insertSymbol("mat2x2", ID_MAT2X2, true); insertSymbol("mat2x3", ID_MAT2X3, true); insertSymbol("mat2x4", ID_MAT2X4, true); insertSymbol("mat3x2", ID_MAT3X2, true); insertSymbol("mat3x3", ID_MAT3X3, true); insertSymbol("mat3x4", ID_MAT3X4, true); insertSymbol("mat4x2", ID_MAT4X2, true); insertSymbol("mat4x3", ID_MAT4X3, true); insertSymbol("mat4x4", ID_MAT4X4, true); insertSymbol("sampler1D", ID_SAMPLER1D, true); insertSymbol("sampler2D", ID_SAMPLER2D, true); insertSymbol("sampler3D", ID_SAMPLER3D, true); insertSymbol("samplerCube", ID_SAMPLERCUBE, true); insertSymbol("sampler1DShadow", ID_SAMPLER1DSHADOW, true); insertSymbol("sampler2DShadow", ID_SAMPLER2DSHADOW, true); insertSymbol("sampler1DArray", ID_SAMPLER1DARRAY, true); insertSymbol("sampler2DArray", ID_SAMPLER2DARRAY, true); insertSymbol("sampler1DArrayShadow", ID_SAMPLER1DARRAYSHADOW, true); insertSymbol("sampler2DArrayShadow", ID_SAMPLER2DARRAYSHADOW, true); insertSymbol("isampler1D", ID_ISAMPLER1D, true); insertSymbol("isampler2D", ID_ISAMPLER2D, true); insertSymbol("isampler3D", ID_ISAMPLER3D, true); insertSymbol("isamplerCube", ID_ISAMPLERCUBE, true); insertSymbol("isampler1DArray", ID_ISAMPLER1DARRAY, true); insertSymbol("isampler2DArray", ID_ISAMPLER2DARRAY, true); insertSymbol("usampler1D", ID_USAMPLER1D, true); insertSymbol("usampler2D", ID_USAMPLER2D, true); insertSymbol("usampler3D", ID_USAMPLER3D, true); insertSymbol("usamplerCube", ID_USAMPLERCUBE, true); insertSymbol("usampler1DArray", ID_USAMPLER1DARRAY, true); insertSymbol("usampler2DArray", ID_USAMPLER2DARRAY, true); insertSymbol("sampler2DRect", ID_SAMPLER2DRECT, true); insertSymbol("sampler2DRectShadow", ID_SAMPLER2DRECTSHADOW, true); insertSymbol("isampler2DRect", ID_ISAMPLER2DRECT, true); insertSymbol("usampler2DRect", ID_USAMPLER2DRECT, true); insertSymbol("samplerBuffer", ID_SAMPLERBUFFER, true); insertSymbol("isamplerBuffer", ID_ISAMPLERBUFFER, true); insertSymbol("usamplerBuffer", ID_USAMPLEBUFFER, true); insertSymbol("sampler2DMS", ID_SAMPLER2DMS, true); insertSymbol("isampler2DMS", ID_ISAMPLER2DMS, true); insertSymbol("usampler2DMS", ID_USAMPLER2DMS, true); insertSymbol("sampler2DMSArray", ID_SAMPLER2DMSARRY, true); insertSymbol("isampler2DMSArray", ID_ISAMPLER2DMSARRAY, true); insertSymbol("usampler2DMSArray", ID_USAMPLER2DMSARRAY, true); insertSymbol("IDENTIFIER", ID_IDENTIFIER); insertSymbol("INTCONSTANT", ID_INTCONST); insertSymbol("UINTCONSTANT", ID_UINTCONST); insertSymbol("FLOATCONSTANT", ID_FLOATCONST); insertSymbol("TYPE-NAME", ID_TYPE_NAME); insertSymbol("FIELD-SELECTION", ID_FIELDSELECTION); insertSymbol("NATIVE-TYPE", ID_NATIVE_TYPE); insertSymbol("LEADING-ANNOTATION", ID_LEADING_ANNOTATION); insertSymbol("TRAILING-ANNOTATION", ID_TRAILING_ANNOTATION); // other keywords reserved by GLSL specification 1.50 // const size_t NUM_OTHERS = 70; std::string others[NUM_OTHERS] = { "common", "partition", "active", "asm", "class", "union", "enum", "typedef", "template", "this", "packed", "goto", "inline", "noinline", "volatile", "public", "static", "extern", "external", "interface", "long", "short", "double", "half", "fixed", "unsigned", "superp", "input", "output", "hvec2", "hvec3", "hvec4", "dvec2", "dvec3", "dvec4", "fvec2", "fvec3", "fvec4", "sampler3DRect", "filter", "image1D", "image2D", "image3D", "imageCube", "iimage1D", "iimage2D", "iimage3D", "iimageCube", "uimage1D", "uimage2D", "uimage3D", "uimageCube", "image1DArray", "image2DArray", "iimage1DArray", "iimage2DArray", "uimage1DArray", "uimage2DArray", "image1DShadow", "image2DShadow", "image1DArrayShadow", "image2DArrayShadow", "imageBuffer", "iimageBuffer", "uimageBuffer", "sizeof", "cast", "namespace", "using", "row_major" }; for (size_t i = 0; i < NUM_OTHERS; ++i) insertSymbol(others[i], ID_RESERVED_KEYWORD, true); }
/* queries are added to the MAL catalog under the client session namespace */ void SQLaddQueryToCache(Client c) { insertSymbol(c->usermodule, c->curprg); }