/* recursively convert an AST expression into a BDD */ DdNode* bdd_expr(DdManager* m, symbol** symtab, ast_node* expr) { int i; DdNode* ret, *tmp1, *tmp2; switch (expr->tag) { case _id_expr: /* simply return that variable's BDD */ if ((i = symtab_lookup(symtab, expr->name)) < 0) { printf("Error: variable '%s' not found in symbol table\n", expr->name); exit(1); } ret = Cudd_bddIthVar(m, symtab_lookup(symtab, expr->name)); break; case _lit_expr: /* return a BDD 1 or 0 */ ret = expr->val ? Cudd_ReadOne(m) : Cudd_ReadLogicZero(m); break; case _not_expr: /* return complement BDD */ tmp1 = bdd_expr(m, symtab, expr->children[EXPR1]); ret = Cudd_Not(tmp1); Cudd_Ref(ret); Cudd_RecursiveDeref(m, tmp1); break; case _and_expr: /* return logical AND */ tmp1 = bdd_expr(m, symtab, expr->children[EXPR1]); tmp2 = bdd_expr(m, symtab, expr->children[EXPR2]); ret = Cudd_bddAnd(m, tmp1, tmp2); Cudd_Ref(ret); Cudd_RecursiveDeref(m, tmp1); Cudd_RecursiveDeref(m, tmp2); break; case _or_expr: /* return logical OR */ tmp1 = bdd_expr(m, symtab, expr->children[EXPR1]); tmp2 = bdd_expr(m, symtab, expr->children[EXPR2]); ret = Cudd_bddOr(m, tmp1, tmp2); Cudd_Ref(ret); Cudd_RecursiveDeref(m, tmp1); Cudd_RecursiveDeref(m, tmp2); break; case _eq_expr: /* check for equality, return 1 or 0 */ tmp1 = bdd_expr(m, symtab, expr->children[EXPR1]); tmp2 = bdd_expr(m, symtab, expr->children[EXPR2]); if (Cudd_EquivDC(m, tmp1, tmp2, Cudd_ReadLogicZero(m))) ret = Cudd_ReadOne(m); else ret = Cudd_ReadLogicZero(m); Cudd_RecursiveDeref(m, tmp1); Cudd_RecursiveDeref(m, tmp2); break; case _impl_expr: /* return logical implication (!a|b) */ tmp1 = Cudd_Not(bdd_expr(m, symtab, expr->children[EXPR1])); tmp2 = bdd_expr(m, symtab, expr->children[EXPR2]); ret = Cudd_bddOr(m, tmp1, tmp2); Cudd_Ref(ret); Cudd_RecursiveDeref(m, tmp1); Cudd_RecursiveDeref(m, tmp2); break; default: printf("Error: invalid expression\n"); exit(1); } return ret; }
static symbol_t * find_tag (ty_meta_e meta, symbol_t *tag, type_t *type) { const char *tag_name; symbol_t *sym; if (tag) { tag_name = va ("tag %s", tag->name); } else { const char *path = GETSTR (pr.source_file); const char *file = strrchr (path, '/'); if (!file++) file = path; tag_name = va ("tag .%s.%d", file, pr.source_line); } sym = symtab_lookup (current_symtab, tag_name); if (sym) { if (sym->table == current_symtab && sym->type->meta != meta) error (0, "%s defined as wrong kind of tag", tag->name); if (sym->type->meta == meta) return sym; } sym = new_symbol (tag_name); if (!type) type = new_type (); if (!type->name) type->name = sym->name; sym->type = type; sym->type->type = ev_invalid; sym->type->meta = meta; sym->sy_type = sy_type; return sym; }
/** * Allocate a prefix as a shorthand for the URI. * * @return prefix string to use, which will be freed by symbol tables * when leaving scope. */ static const char * xfmt_new_prefix(struct xfmt_pass2 *xp2, const char *uri) { const char *prefix = NULL; bool free_prefix = FALSE; /* The URI must not already exist in the symbol table */ g_assert(NULL == symtab_lookup(xp2->uris, uri)); /* * Check whether user has a preference for the prefix to use. * * If there is a prefix, there must be no identical prefix in scope * currently. */ if (xp2->uri2prefix != NULL) prefix = nv_table_lookup_str(xp2->uri2prefix, uri); if (prefix != NULL) { const char *used_uri = symtab_lookup(xp2->prefixes, prefix); if (used_uri != NULL) { g_carp("XFMT cannot use prefix '%s' for '%s': " "already used by '%s'", prefix, uri, used_uri); prefix = NULL; } } /* * Allocate a new prefix if required. */ if (NULL == prefix) { prefix = h_strdup_printf("ns%u", xp2->pcount++); free_prefix = TRUE; } /* * Record associations in the symbol tables. */ xfmt_ns_declare(xp2, prefix, uri, free_prefix); return prefix; }
/* formula for assignment: pc ^ var' <=> expr ^ pc' ^ same(pc, var) */ DdNode* bdd_mk_assign(DdManager *m, pos* postab, cfg_node* host, int proc) { DdNode* tmp1 = Cudd_bddIthVar(m, symtab_lookup(postab->vars_, host->node->name)); DdNode* tmp2 = bdd_expr(m, postab->vars, host->node->children[EXPR]); DdNode* ret = Cudd_bddXnor(m, tmp1, tmp2); Cudd_Ref(ret); /* encode assignment with XNOR */ Cudd_RecursiveDeref(m, tmp2); ret = bdd_encode_pc(m, ret, postab->pc, postab->pc_size, proc, host->node->id); /* encode program counter */ tmp1 = bdd_same(m, postab, symtab_lookup(postab->vars, host->node->name), proc); /* encode unchanging variables */ tmp2 = ret; ret = Cudd_bddAnd(m, tmp1, tmp2); Cudd_Ref(ret); Cudd_RecursiveDeref(m, tmp1); Cudd_RecursiveDeref(m, tmp2); return ret; }
static jl_sym_t *_jl_symbol(const char *str, size_t len) { jl_sym_t *volatile *slot; jl_sym_t *node = symtab_lookup(&symtab, str, len, &slot); if (node == NULL) { JL_LOCK(&symbol_table_lock); // Might GC // Someone might have updated it, check and look up again if (*slot != NULL && (node = symtab_lookup(slot, str, len, &slot))) { JL_UNLOCK(&symbol_table_lock); // Might GC return node; } node = mk_symbol(str, len); jl_atomic_store_release(slot, node); JL_UNLOCK(&symbol_table_lock); // Might GC } return node; }
value_t symbol(char *str) { symbol_t **pnode; pnode = symtab_lookup(&symtab, str); if (*pnode == NULL) *pnode = mk_symbol(str); return tagptr(*pnode, TAG_SYM); }
IDENT * lookup_struct (char *name) { ENTRY *e = symtab_lookup(symtab[OTH], name); if (e == NULL) return(NULL); else return(e->ident); }
jl_sym_t *jl_symbol(const char *str) { jl_sym_t **pnode; pnode = symtab_lookup(&symtab, str); if (*pnode == NULL) *pnode = mk_symbol(str); return *pnode; }
void inifile_del(inifile_t *self, const char *sec, const char *key) { inisec_t *s = symtab_lookup(&self->if_sections, sec); if( s != 0 ) { inisec_del(s, key); } }
double retrieve(char *varname) { int address; if (address = symtab_lookup(varname) != -1) { return memory[address]; } exit(UNDECLARED_VARIABLE_EXCEPTION); }
jl_sym_t *jl_symbol(const char *str) { jl_sym_t **pnode; jl_sym_t *parent; pnode = symtab_lookup(&symtab, str, &parent); if (*pnode == NULL) { *pnode = mk_symbol(str); if (parent != NULL) gc_wb(parent, *pnode); } return *pnode; }
static jl_sym_t *_jl_symbol(const char *str, size_t len) { jl_sym_t **pnode; jl_sym_t *parent; pnode = symtab_lookup(&symtab, str, len, &parent); if (*pnode == NULL) { *pnode = mk_symbol(str, len); if (parent != NULL) jl_gc_wb(parent, *pnode); } return *pnode; }
/** * Transform a namespace URI into its prefix. */ static const char * xfmt_uri_to_prefix(const struct xfmt_pass2 *xp2, const char *uri) { const char *prefix; g_assert(uri != NULL); prefix = symtab_lookup(xp2->uris, uri); g_assert(prefix != NULL); return prefix; }
char *new_nodename (char *eqname) { static int maxindex = 0 ; static char name [MAXLINE] ; do { sprintf (name, "%s:%d", eqname, ++maxindex) ; } while (symtab_lookup (name) != NULL) ; return name ; }
/*symtab_verify - verifica se a variável foi declarada*/ int symtab_verify(char const *symbol) { int position = symtab_lookup(symbol); if (symtab[symtab_nextentry-1].valtype==1) { //printf( "variável declarada"); }else { printf (" ATENCAO!, VARIAVEL %s ,NAO DECLARADA\n",symbol); // exit(getch()); } }
static int internal(int argc, char *argv[]) { char *name = argv[0]; symbol_t *symbol = symtab_lookup(symtab, name); int status = -1; if (symbol && symbol->type == SYM_INTERNAL) { status = ((internal_t)symbol->value)(argc, argv); } else { #if !defined(LSH_ENABLE_EXTERNAL) lsh_not_impl(argv[0]); #endif } return status; }
IDENT * new_struct (char *name, BOOLEAN add_to_symtab) { CTYPE *c = STRUCT_CTYPE; IDENT *i = new_ident(SUE, name, c, NULL, FALSE); c->ident = i; if (add_to_symtab) { #ifndef NDEBUG ENTRY *e = symtab_lookup(symtab[SUE], name); if (e != NULL && e->ident->scope == scope) assertion_failed("struct %s already exists in scope", name); #endif /* NDEBUG */ add_ident_to_symtab1(symtab[SUE], i); } return(i); }
void storage(char *varname) { int address; if (address = symtab_lookup(varname) == -1) { // assigns symtab_next_entry to address and add symtab_next_entry address = symtab_next_entry++; if (add_symbol(varname, address)) { memory[address] = stack[top]; } } }
/*fact parser:*/ void fact (void) { switch (lookahead) { case INTCTE://constante inteira match (INTCTE); break; case '('://parênteses match ('('); expr (); match (')'); break; case ID://identificador { /*geração de código de máquina*/ {printf("\tmov %s, %%eax\n", lexeme);} if (symtab_lookup (lexeme) == -1) { deupau (); } } match (ID); if (lookahead == '(') { match ('('); exprlist (); match (')'); } else { while (lookahead == '[') { idxsynt (); } } break; default: ; } }
int asmout_make_rom(struct SymTab **curSyms, char *out, char *data) { FILE *handle; int x, y, t, datasize; /* sanity check */ if (symtab_lookup(curSyms, "$filesize", NULL, &datasize) != 0) { fprintf(stderr, "ERROR - Unknown file size\n"); return -1; } /* open output */ if ((handle = fopen(out, "w")) == NULL) { perror("ERROR - Could not open output file"); return -1; } /* dump ROM header (none for now) */ DEBUG(1) printf("Max Address %d\n", datasize); /* output each row */ for (x=0; x<datasize; x+=8) { fprintf(handle, "0x%04X |", x); for (y=0; y<8; y++) { if ((x+y)<datasize) { t = (data[x+y] & 0xff); fprintf(handle, " %02X", t); } else { fprintf(handle, " 00"); } } fprintf(handle, "\n"); } /* dump ROM trailer (none for now) */ /* done */ fclose(handle); return 0; }
static void print_id_string(FILE *file, int id, bool print_long) { switch (id) { $$PRINT_IDS$$ default: { symtab_entry_t *e = symtab_lookup(id); if (!e) { fprintf(file, "(UNKNOWN-SYM[%d])", id); } else { if (print_long) { fprintf(file, "(SYM[%d] ", id); } symtab_entry_name_dump(file, e); if (print_long) { fprintf(file, ")"); } } } } }
int symtab_add(char const *newsymbol) { int i; if ((i = symtab_lookup(newsymbol)) < 0 || symtab[i].lexlevel < lexlevel) { if (symtab_nextentry < MAXTBENTRIES) { strcpy(symtab[symtab_nextentry].symbol, newsymbol); symtab[symtab_nextentry].lexlevel = lexlevel; return ++symtab_nextentry; } else { fprintf(stderr, "maximum symbol entries exceeded... exiting\n"); exit(-4); } } else { fprintf(stderr, "%s already declared in the same lexical level... exiting\n", newsymbol); exit(-3); } }
symbol_t * make_symbol (const char *name, type_t *type, defspace_t *space, storage_class_t storage) { symbol_t *sym; struct reloc_s *relocs = 0; if (storage != sc_extern && storage != sc_global && storage != sc_static) internal_error (0, "invalid storage class for %s", __FUNCTION__); if (storage != sc_extern && !space) internal_error (0, "null space for non-external storage"); sym = symtab_lookup (pr.symtab, name); if (!sym) { sym = new_symbol_type (name, type); } if (sym->type != type) { if (is_array (sym->type) && is_array (type) && !sym->type->t.array.size) { sym->type = type; } else { error (0, "%s redefined", name); sym = new_symbol_type (name, type); } } if (sym->s.def && sym->s.def->external && storage != sc_extern) { //FIXME this really is not the right way relocs = sym->s.def->relocs; free_def (sym->s.def); sym->s.def = 0; } if (!sym->s.def) { sym->s.def = new_def (name, type, space, storage); reloc_attach_relocs (relocs, &sym->s.def->relocs); } return sym; }
/** * Emit namespace declarations. */ static void xfmt_pass2_declare_ns(struct xfmt_pass2 *xp2, GSList *ns) { GSList *sl; GM_SLIST_FOREACH(ns, sl) { const char *prefix = sl->data; const char *uri; int c; /* * Do not declare the "xml" namespace. */ if (0 == strcmp(prefix, VXS_XML)) continue; /* * We don't need to declare the default namespace though, unless * it is used in attributes (since there is no default namespace * for attributes). */ uri = symtab_lookup(xp2->prefixes, prefix); if ( xp2->default_ns != NULL && 0 == strcmp(uri, xp2->default_ns) && !hset_contains(xp2->attr_uris, xp2->default_ns) ) continue; c = xfmt_quoting_char(uri); g_assert(c != '\0'); ostream_printf(xp2->os, " xmlns:%s=%c%s%c", prefix, c, uri, c); } }
int asmgen_parse_value(struct ScanData *scanner, struct SymTab **curSyms, unsigned int *pResult) { struct Token curToken; unsigned int lval, rval; /* scan next token or expression */ switch (get_token(&curToken, scanner)) { case TOK_INT: /* integer value, just pass it back */ DEBUG(1) printf("Got an integer - %d\n", curToken.value); lval = curToken.value; if (curToken.limHigh - curToken.limLow < 8*sizeof(lval) - 1) { /* if token is specified with a bitslice, use only those bits */ lval = GETBITS(curToken.limLow, curToken.limHigh, lval); } *pResult = lval; return 0; break; case TOK_IDENT: /* identifier, locate it in the symbol table */ DEBUG(1) printf("Got a symbol lookup - '%s'\n", curToken.token); if (symtab_lookup(curSyms, curToken.token, NULL, (int*)&lval) == 0) { /* symbol table lookup success */ if (curToken.limHigh - curToken.limLow < 8*sizeof(lval) - 1) { /* if token is specified with a bitslice, use only those bits */ lval = GETBITS(curToken.limLow, curToken.limHigh, lval); } *pResult = lval; return 0; } printf("ERROR - Symbol '%s' Not Found\n", curToken.token); break; case TOK_LPAREN: /* left parentheses, beginning of an arithmetic expression */ /* start by evaluating first term (may be another expression */ if (asmgen_parse_value(scanner, curSyms, &lval) != 0) { /* error parsing sub-expression */ printf("ERROR - Cannot Parse Arithmetic Expression\n"); return -1; } /* inner loop to evalate left-to-right arithmetic expressions */ while (1) { /* get next token */ switch (get_token(&curToken, scanner)) { case TOK_RPAREN: /* close parentheses, end of sub-expression */ *pResult = lval; return 0; break; case TOK_ARITHOP: /* arithmetic operation (+/-), get right hand value */ if (asmgen_parse_value(scanner, curSyms, &rval) != 0) { /* error parsing sub-expression */ printf("ERROR - Cannot Parse Arithmetic Expression\n"); return -1; } /* handle arithmetic operation */ switch (curToken.token[0]) { case '+': lval += rval; break; case '-': lval -= rval; break; default: /* unhandled */ printf("ERROR - Unknown Arithmetic operation '%s'\n", curToken.token); return -1; break; } break; default: printf("ERROR - Unexpected token '%s' while parsing subexpression\n", curToken.token); return -1; break; } } break; default: /* unknown token */ printf("Unhandled token \'%s\'\n", curToken.token); break; } return -1; }
JL_DLLEXPORT jl_sym_t *jl_symbol_lookup(const char *str) { return symtab_lookup(&symtab, str, strlen(str), NULL); }
const char * inifile_get(inifile_t *self, const char *sec, const char *key, const char *val) { inisec_t *s = symtab_lookup(&self->if_sections, sec); return s ? inisec_get(s, key, val) : val; }
inisec_t * inifile_get_section(inifile_t *self, const char *sec) { return symtab_lookup(&self->if_sections, sec); }
jl_sym_t *jl_symbol_lookup(const char *str) { return *symtab_lookup(&symtab, str); }
int inifile_has(inifile_t *self, const char *sec, const char *key) { inisec_t *s = symtab_lookup(&self->if_sections, sec); return s ? inisec_has(s, key) : 0; }