/* * condition_macro: * * i) cc token * i) target current target */ static void condition_macro(int cc, int target) { cur = &pifstack[piflevel]; if (cc == SHARP_IFDEF || cc == SHARP_IFNDEF || cc == SHARP_IF) { DBG_PRINT(piflevel, "#if"); if (++piflevel >= MAXPIFSTACK) die("#if pifstack over flow. [%s]", curfile); ++cur; cur->start = level; cur->end = -1; cur->if0only = 0; if (peekc(0) == '0') cur->if0only = 1; else if ((cc = nexttoken(NULL, cpp_reserved_word)) == SYMBOL && !strcmp(token, "notdef")) cur->if0only = 1; else pushbacktoken(); } else if (cc == SHARP_ELIF || cc == SHARP_ELSE) { DBG_PRINT(piflevel - 1, "#else"); if (cur->end == -1) cur->end = level; else if (cur->end != level && wflag) warning("uneven level. [+%d %s]", lineno, curfile); level = cur->start; cur->if0only = 0; } else if (cc == SHARP_ENDIF) { int minus = 0; --piflevel; if (piflevel < 0) { minus = 1; piflevel = 0; } DBG_PRINT(piflevel, "#endif"); if (minus) { if (wflag) warning("#if block unmatched. reseted. [+%d %s]", lineno, curfile); } else { if (cur->if0only) level = cur->start; else if (cur->end != -1) { if (cur->end != level && wflag) warning("uneven level. [+%d %s]", lineno, curfile); level = cur->end; } } } while ((cc = nexttoken(NULL, cpp_reserved_word)) != EOF && cc != '\n') { if (cc == SYMBOL && strcmp(token, "defined") != 0) { if (target == REF) { if (defined(token)) PUT(token, lineno, sp); } else if (target == SYM) { if (!defined(token)) PUT(token, lineno, sp); } } } }
/** * condition_macro: * * @param param * @param[in] cc token */ static void condition_macro(const struct parser_param *param, int cc) { cur = &stack[piflevel]; if (cc == SHARP_IFDEF || cc == SHARP_IFNDEF || cc == SHARP_IF) { DBG_PRINT(piflevel, "#if"); if (++piflevel >= MAXPIFSTACK) die("#if stack over flow. [%s]", curfile); ++cur; cur->start = level; cur->end = -1; cur->if0only = 0; if (peekc(0) == '0') cur->if0only = 1; else if ((cc = nexttoken(NULL, c_reserved_word)) == SYMBOL && !strcmp(token, "notdef")) cur->if0only = 1; else pushbacktoken(); } else if (cc == SHARP_ELIF || cc == SHARP_ELSE) { DBG_PRINT(piflevel - 1, "#else"); if (cur->end == -1) cur->end = level; else if (cur->end != level && (param->flags & PARSER_WARNING)) warning("uneven level. [+%d %s]", lineno, curfile); level = cur->start; cur->if0only = 0; } else if (cc == SHARP_ENDIF) { int minus = 0; --piflevel; if (piflevel < 0) { minus = 1; piflevel = 0; } DBG_PRINT(piflevel, "#endif"); if (minus) { if (param->flags & PARSER_WARNING) warning("unmatched #if block. reseted. [+%d %s]", lineno, curfile); } else { if (cur->if0only) level = cur->start; else if (cur->end != -1) { if (cur->end != level && (param->flags & PARSER_WARNING)) warning("uneven level. [+%d %s]", lineno, curfile); level = cur->end; } } } while ((cc = nexttoken(NULL, c_reserved_word)) != EOF && cc != '\n') { if (cc == SYMBOL && strcmp(token, "defined") != 0) PUT(PARSER_REF_SYM, token, lineno, sp); } }
void netlist_parser::netdev_device(const pstring &dev_type) { pstring devname; net_device_t_base_factory *f = m_setup.factory().factory_by_name(dev_type, m_setup); netlist_device_t *dev; nl_util::pstring_list termlist = f->term_param_list(); pstring def_param = f->def_param(); int cnt; skipws(); devname = getname2(',', ')'); dev = f->Create(); m_setup.register_dev(dev, devname); NL_VERBOSE_OUT(("Parser: IC: %s\n", devname.cstr())); if (def_param != "") { pstring paramfq = devname + "." + def_param; NL_VERBOSE_OUT(("Defparam: %s\n", def_param.cstr())); check_char(','); skipws(); if (peekc() == '"') { pstring val = getstring(); m_setup.register_param(paramfq, val); } else { double val = eval_param(); m_setup.register_param(paramfq, val); } if (termlist.count() > 0) check_char(','); } cnt = 0; while (getc() != ')' && cnt < termlist.count()) { skipws(); pstring output_name = getname2(',', ')'); m_setup.register_link(devname + "." + termlist[cnt], output_name); skipws(); cnt++; } if (cnt != termlist.count()) fatalerror("netlist: input count mismatch for %s - expected %d found %d\n", devname.cstr(), termlist.count(), cnt); }
void geta_discard(int verbose) { char tempstr[256]; if (verbose == TRUE) ctlmsg1("Discarding following unneeded tokens at end of line:\n\t"); while (ctlflag != iflf) { peekc(tempstr); if (strcmp(tempstr,"$") != 0) { geta(tempstr); if (verbose == TRUE) ctlmsg1(tempstr); if (ps != NULL) { if (*ps == '$') { ps = NULL; break; } } } } if (verbose == TRUE) ctlmsg(""); }
int getfarg( double *farg, int lentar ) { char sym[128] ; int len,ifun ; peekc(sym) ; if (isbeta(sym)) { geta(sym) ; ifun = isargfun(sym) ; if (RGST_QUERY_OBJECT_ATTR(sym,"DomainVar") == TRUE) { len = getfpaa(sym,farg); } else if (RGST_QUERY_OBJECT_ATTR(sym,"GlobalArray") == TRUE) { len = getfpaa(sym,farg); } else if (ifun >= 0) { len = doarg_fun(ifun,farg,lentar); } else if (rgst_check_for_obj(sym) == TRUE) { len = getrgstdata(R_DOUBLE,sym,(void **)&farg,lentar); } else { } } else { len = getflst(&farg,lentar) ; } return(len) ; }
U8_EXPORT int u8_peekc(struct U8_INPUT *f) { return peekc(f,0); }
U8_EXPORT int u8_probec(struct U8_INPUT *f) { return peekc(f,1); }
/** * @param[in] param source file * @param[in] type #TYPE_C, #TYPE_YACC, #TYPE_LEX */ static void C_family(const struct parser_param *param, int type) { int c, cc; int savelevel; int startmacro, startsharp; const char *interested = "{}=;"; STRBUF *sb = strbuf_open(0); /* * yacc file format is like the following. * * declarations * %% * rules * %% * programs * */ int yaccstatus = (type == TYPE_YACC) ? DECLARATIONS : PROGRAMS; int inC = (type == TYPE_YACC) ? 0 : 1; /* 1 while C source */ level = piflevel = externclevel = 0; savelevel = -1; startmacro = startsharp = 0; if (!opentoken(param->file)) die("'%s' cannot open.", param->file); cmode = 1; /* allow token like '#xxx' */ crflag = 1; /* require '\n' as a token */ if (type == TYPE_YACC) ymode = 1; /* allow token like '%xxx' */ while ((cc = nexttoken(interested, c_reserved_word)) != EOF) { switch (cc) { case SYMBOL: /* symbol */ if (inC && peekc(0) == '('/* ) */) { if (param->isnotfunction(token)) { PUT(PARSER_REF_SYM, token, lineno, sp); } else if (level > 0 || startmacro) { PUT(PARSER_REF_SYM, token, lineno, sp); } else if (level == 0 && !startmacro && !startsharp) { char arg1[MAXTOKEN], savetok[MAXTOKEN], *saveline; int savelineno = lineno; strlimcpy(savetok, token, sizeof(savetok)); strbuf_reset(sb); strbuf_puts(sb, sp); saveline = strbuf_value(sb); arg1[0] = '\0'; /* * Guile function entry using guile-snarf is like follows: * * SCM_DEFINE (scm_list, "list", 0, 0, 1, * (SCM objs), * "Return a list containing OBJS, the arguments to `list'.") * #define FUNC_NAME s_scm_list * { * return objs; * } * #undef FUNC_NAME * * We should assume the first argument as a function name instead of 'SCM_DEFINE'. */ if (function_definition(param, arg1)) { if (!strcmp(savetok, "SCM_DEFINE") && *arg1) strlimcpy(savetok, arg1, sizeof(savetok)); PUT(PARSER_DEF, savetok, savelineno, saveline); } else { PUT(PARSER_REF_SYM, savetok, savelineno, saveline); } } } else { PUT(PARSER_REF_SYM, token, lineno, sp); } break; case '{': /* } */ DBG_PRINT(level, "{"); /* } */ if (yaccstatus == RULES && level == 0) inC = 1; ++level; if ((param->flags & PARSER_BEGIN_BLOCK) && atfirst) { if ((param->flags & PARSER_WARNING) && level != 1) warning("forced level 1 block start by '{' at column 0 [+%d %s].", lineno, curfile); /* } */ level = 1; } break; /* { */ case '}': if (--level < 0) { if (externclevel > 0) externclevel--; else if (param->flags & PARSER_WARNING) warning("missing left '{' [+%d %s].", lineno, curfile); /* } */ level = 0; } if ((param->flags & PARSER_END_BLOCK) && atfirst) { if ((param->flags & PARSER_WARNING) && level != 0) /* { */ warning("forced level 0 block end by '}' at column 0 [+%d %s].", lineno, curfile); level = 0; } if (yaccstatus == RULES && level == 0) inC = 0; /* { */ DBG_PRINT(level, "}"); break; case '\n': if (startmacro && level != savelevel) { if (param->flags & PARSER_WARNING) warning("different level before and after #define macro. reseted. [+%d %s].", lineno, curfile); level = savelevel; } startmacro = startsharp = 0; break; case YACC_SEP: /* %% */ if (level != 0) { if (param->flags & PARSER_WARNING) warning("forced level 0 block end by '%%' [+%d %s].", lineno, curfile); level = 0; } if (yaccstatus == DECLARATIONS) { PUT(PARSER_DEF, "yyparse", lineno, sp); yaccstatus = RULES; } else if (yaccstatus == RULES) yaccstatus = PROGRAMS; inC = (yaccstatus == PROGRAMS) ? 1 : 0; break; case YACC_BEGIN: /* %{ */ if (level != 0) { if (param->flags & PARSER_WARNING) warning("forced level 0 block end by '%%{' [+%d %s].", lineno, curfile); level = 0; } if (inC == 1 && (param->flags & PARSER_WARNING)) warning("'%%{' appeared in C mode. [+%d %s].", lineno, curfile); inC = 1; break; case YACC_END: /* %} */ if (level != 0) { if (param->flags & PARSER_WARNING) warning("forced level 0 block end by '%%}' [+%d %s].", lineno, curfile); level = 0; } if (inC == 0 && (param->flags & PARSER_WARNING)) warning("'%%}' appeared in Yacc mode. [+%d %s].", lineno, curfile); inC = 0; break; case YACC_UNION: /* %union {...} */ if (yaccstatus == DECLARATIONS) PUT(PARSER_DEF, "YYSTYPE", lineno, sp); break; /* * #xxx */ case SHARP_DEFINE: case SHARP_UNDEF: startmacro = 1; savelevel = level; if ((c = nexttoken(interested, c_reserved_word)) != SYMBOL) { pushbacktoken(); break; } if (peekc(1) == '('/* ) */) { PUT(PARSER_DEF, token, lineno, sp); while ((c = nexttoken("()", c_reserved_word)) != EOF && c != '\n' && c != /* ( */ ')') if (c == SYMBOL) PUT(PARSER_REF_SYM, token, lineno, sp); if (c == '\n') pushbacktoken(); } else { PUT(PARSER_DEF, token, lineno, sp); } break; case SHARP_IMPORT: case SHARP_INCLUDE: case SHARP_INCLUDE_NEXT: case SHARP_ERROR: case SHARP_LINE: case SHARP_PRAGMA: case SHARP_WARNING: case SHARP_IDENT: case SHARP_SCCS: while ((c = nexttoken(interested, c_reserved_word)) != EOF && c != '\n') ; break; case SHARP_IFDEF: case SHARP_IFNDEF: case SHARP_IF: case SHARP_ELIF: case SHARP_ELSE: case SHARP_ENDIF: condition_macro(param, cc); break; case SHARP_SHARP: /* ## */ (void)nexttoken(interested, c_reserved_word); break; case C_EXTERN: /* for 'extern "C"/"C++"' */ if (peekc(0) != '"') /* " */ continue; /* If does not start with '"', continue. */ while ((c = nexttoken(interested, c_reserved_word)) == '\n') ; /* * 'extern "C"/"C++"' block is a kind of namespace block. * (It doesn't have any influence on level.) */ if (c == '{') /* } */ externclevel++; else pushbacktoken(); break; case C_STRUCT: case C_ENUM: case C_UNION: while ((c = nexttoken(interested, c_reserved_word)) == C___ATTRIBUTE__) process_attribute(param); if (c == SYMBOL) { if (peekc(0) == '{') /* } */ { PUT(PARSER_DEF, token, lineno, sp); } else { PUT(PARSER_REF_SYM, token, lineno, sp); } c = nexttoken(interested, c_reserved_word); } if (c == '{' /* } */ && cc == C_ENUM) { enumerator_list(param); } else { pushbacktoken(); } break; /* control statement check */ case C_BREAK: case C_CASE: case C_CONTINUE: case C_DEFAULT: case C_DO: case C_ELSE: case C_FOR: case C_GOTO: case C_IF: case C_RETURN: case C_SWITCH: case C_WHILE: if ((param->flags & PARSER_WARNING) && !startmacro && level == 0) warning("Out of function. %8s [+%d %s]", token, lineno, curfile); break; case C_TYPEDEF: { /* * This parser is too complex to maintain. * We should rewrite the whole. */ char savetok[MAXTOKEN]; int savelineno = 0; int typedef_savelevel = level; savetok[0] = 0; /* skip type qualifiers */ do { c = nexttoken("{}(),;", c_reserved_word); } while (IS_TYPE_QUALIFIER(c) || c == '\n'); if ((param->flags & PARSER_WARNING) && c == EOF) { warning("unexpected eof. [+%d %s]", lineno, curfile); break; } else if (c == C_ENUM || c == C_STRUCT || c == C_UNION) { char *interest_enum = "{},;"; int c_ = c; while ((c = nexttoken(interest_enum, c_reserved_word)) == C___ATTRIBUTE__) process_attribute(param); /* read tag name if exist */ if (c == SYMBOL) { if (peekc(0) == '{') /* } */ { PUT(PARSER_DEF, token, lineno, sp); } else { PUT(PARSER_REF_SYM, token, lineno, sp); } c = nexttoken(interest_enum, c_reserved_word); } if (c_ == C_ENUM) { if (c == '{') /* } */ c = enumerator_list(param); else pushbacktoken(); } else { for (; c != EOF; c = nexttoken(interest_enum, c_reserved_word)) { switch (c) { case SHARP_IFDEF: case SHARP_IFNDEF: case SHARP_IF: case SHARP_ELIF: case SHARP_ELSE: case SHARP_ENDIF: condition_macro(param, c); continue; default: break; } if (c == ';' && level == typedef_savelevel) { if (savetok[0]) PUT(PARSER_DEF, savetok, savelineno, sp); break; } else if (c == '{') level++; else if (c == '}') { if (--level == typedef_savelevel) break; } else if (c == SYMBOL) { PUT(PARSER_REF_SYM, token, lineno, sp); /* save lastest token */ strlimcpy(savetok, token, sizeof(savetok)); savelineno = lineno; } } if (c == ';') break; } if ((param->flags & PARSER_WARNING) && c == EOF) { warning("unexpected eof. [+%d %s]", lineno, curfile); break; } } else if (c == SYMBOL) { PUT(PARSER_REF_SYM, token, lineno, sp); } savetok[0] = 0; while ((c = nexttoken("(),;", c_reserved_word)) != EOF) { switch (c) { case SHARP_IFDEF: case SHARP_IFNDEF: case SHARP_IF: case SHARP_ELIF: case SHARP_ELSE: case SHARP_ENDIF: condition_macro(param, c); continue; default: break; } if (c == '(') level++; else if (c == ')') level--; else if (c == SYMBOL) { if (level > typedef_savelevel) { PUT(PARSER_REF_SYM, token, lineno, sp); } else { /* put latest token if any */ if (savetok[0]) { PUT(PARSER_REF_SYM, savetok, savelineno, sp); } /* save lastest token */ strlimcpy(savetok, token, sizeof(savetok)); savelineno = lineno; } } else if (c == ',' || c == ';') { if (savetok[0]) { PUT(PARSER_DEF, savetok, lineno, sp); savetok[0] = 0; } } if (level == typedef_savelevel && c == ';') break; } if (param->flags & PARSER_WARNING) { if (c == EOF) warning("unexpected eof. [+%d %s]", lineno, curfile); else if (level != typedef_savelevel) warning("unmatched () block. (last at level %d.)[+%d %s]", level, lineno, curfile); } } break; case C___ATTRIBUTE__: process_attribute(param); break; default: break; } } strbuf_close(sb); if (param->flags & PARSER_WARNING) { if (level != 0) warning("unmatched {} block. (last at level %d.)[+%d %s]", level, lineno, curfile); if (piflevel != 0) warning("unmatched #if block. (last at level %d.)[+%d %s]", piflevel, lineno, curfile); } closetoken(); }
int nexttoken(const char *interested, int (*reserved)(const char *, int)) { int c; char *p; int sharp = 0; int percent = 0; /* check push back buffer */ if (ptok[0]) { strlimcpy(token, ptok, sizeof(token)); ptok[0] = '\0'; return lasttok; } for (;;) { /* skip spaces */ if (!crflag) while ((c = nextchar()) != EOF && isspace(c)) ; else while ((c = nextchar()) != EOF && isspace(c) && c != '\n') ; if (c == EOF || c == '\n') break; if (c == '"' || c == '\'') { /* quoted string */ int quote = c; while ((c = nextchar()) != EOF) { if (c == quote) break; if (quote == '\'' && c == '\n') break; if (c == '\\' && (c = nextchar()) == EOF) break; } } else if (c == '/') { /* comment */ if ((c = nextchar()) == '/') { while ((c = nextchar()) != EOF) if (c == '\n') { pushbackchar(); break; } } else if (c == '*') { while ((c = nextchar()) != EOF) { if (c == '*') { if ((c = nextchar()) == '/') break; pushbackchar(); } } } else pushbackchar(); } else if (c == '\\') { if (nextchar() == '\n') continued_line = 1; } else if (isdigit(c)) { /* digit */ while ((c = nextchar()) != EOF && (c == '.' || isalnum(c))) ; pushbackchar(); } else if (c == '#' && cmode) { /* recognize '##' as a token if it is reserved word. */ if (peekc(1) == '#') { p = token; *p++ = c; *p++ = nextchar(); *p = 0; if (reserved && (c = (*reserved)(token, tlen)) == 0) break; } else if (!continued_line && atfirst_exceptspace()) { sharp = 1; continue; } } else if (c == ':' && cppmode) { if (peekc(1) == ':') { p = token; *p++ = c; *p++ = nextchar(); *p = 0; if (reserved && (c = (*reserved)(token, tlen)) == 0) break; } } else if (c == '%' && ymode) { /* recognize '%%' as a token if it is reserved word. */ if (atfirst) { p = token; *p++ = c; if ((c = peekc(1)) == '%' || c == '{' || c == '}') { *p++ = nextchar(); *p = 0; if (reserved && (c = (*reserved)(token, tlen)) != 0) break; } else if (!isspace(c)) { percent = 1; continue; } } } else if (c & 0x80 || isalpha(c) || c == '_') {/* symbol */ p = token; if (sharp) { sharp = 0; *p++ = '#'; } else if (percent) { percent = 0; *p++ = '%'; } else if (c == 'L') { int tmp = peekc(1); if (tmp == '\"' || tmp == '\'') continue; } for (*p++ = c; (c = nextchar()) != EOF && (c & 0x80 || isalnum(c) || c == '_');) { if (tlen < sizeof(token)) *p++ = c; } if (tlen == sizeof(token)) { warning("symbol name is too long. (Ignored)[+%d %s]", lineno, curfile); continue; } *p = 0; if (c != EOF) pushbackchar(); /* convert token string into token number */ c = SYMBOL; if (reserved) c = (*reserved)(token, tlen); break; } else { /* special char */ if (interested == NULL || strchr(interested, c)) break; /* otherwise ignore it */ } sharp = percent = 0; } return lasttok = c; }
/* * Cpp: read C++ file and pickup tag entries. */ void Cpp(const struct parser_param *param) { int c, cc; int savelevel; int startclass, startthrow, startmacro, startsharp, startequal; char classname[MAXTOKEN]; char completename[MAXCOMPLETENAME]; int classlevel; struct { char *classname; char *terminate; int level; } stack[MAXCLASSSTACK]; const char *interested = "{}=;~"; STRBUF *sb = strbuf_open(0); *classname = *completename = 0; stack[0].classname = completename; stack[0].terminate = completename; stack[0].level = 0; level = classlevel = piflevel = namespacelevel = 0; savelevel = -1; startclass = startthrow = startmacro = startsharp = startequal = 0; if (!opentoken(param->file)) die("'%s' cannot open.", param->file); cmode = 1; /* allow token like '#xxx' */ crflag = 1; /* require '\n' as a token */ cppmode = 1; /* treat '::' as a token */ while ((cc = nexttoken(interested, cpp_reserved_word)) != EOF) { if (cc == '~' && level == stack[classlevel].level) continue; switch (cc) { case SYMBOL: /* symbol */ if (startclass || startthrow) { PUT(PARSER_REF_SYM, token, lineno, sp); } else if (peekc(0) == '('/* ) */) { if (param->isnotfunction(token)) { PUT(PARSER_REF_SYM, token, lineno, sp); } else if (level > stack[classlevel].level || startequal || startmacro) { PUT(PARSER_REF_SYM, token, lineno, sp); } else if (level == stack[classlevel].level && !startmacro && !startsharp && !startequal) { char savetok[MAXTOKEN], *saveline; int savelineno = lineno; strlimcpy(savetok, token, sizeof(savetok)); strbuf_reset(sb); strbuf_puts(sb, sp); saveline = strbuf_value(sb); if (function_definition(param)) { /* ignore constructor */ if (strcmp(stack[classlevel].classname, savetok)) PUT(PARSER_DEF, savetok, savelineno, saveline); } else { PUT(PARSER_REF_SYM, savetok, savelineno, saveline); } } } else { PUT(PARSER_REF_SYM, token, lineno, sp); } break; case CPP_USING: /* * using namespace name; * using ...; */ if ((c = nexttoken(interested, cpp_reserved_word)) == CPP_NAMESPACE) { if ((c = nexttoken(interested, cpp_reserved_word)) == SYMBOL) { PUT(PARSER_REF_SYM, token, lineno, sp); } else { if (param->flags & PARSER_WARNING) warning("missing namespace name. [+%d %s].", lineno, curfile); pushbacktoken(); } } else pushbacktoken(); break; case CPP_NAMESPACE: crflag = 0; /* * namespace name = ...; * namespace [name] { ... } */ if ((c = nexttoken(interested, cpp_reserved_word)) == SYMBOL) { PUT(PARSER_DEF, token, lineno, sp); if ((c = nexttoken(interested, cpp_reserved_word)) == '=') { crflag = 1; break; } } /* * Namespace block doesn't have any influence on level. */ if (c == '{') /* } */ { namespacelevel++; } else { if (param->flags & PARSER_WARNING) warning("missing namespace block. [+%d %s](0x%x).", lineno, curfile, c); } crflag = 1; break; case CPP_EXTERN: /* for 'extern "C"/"C++"' */ if (peekc(0) != '"') /* " */ continue; /* If does not start with '"', continue. */ while ((c = nexttoken(interested, cpp_reserved_word)) == '\n') ; /* * 'extern "C"/"C++"' block is a kind of namespace block. * (It doesn't have any influence on level.) */ if (c == '{') /* } */ namespacelevel++; else pushbacktoken(); break; case CPP_CLASS: DBG_PRINT(level, "class"); if ((c = nexttoken(interested, cpp_reserved_word)) == SYMBOL) { strlimcpy(classname, token, sizeof(classname)); /* * Ignore forward definitions. * "class name;" */ if (peekc(0) != ';') { startclass = 1; PUT(PARSER_DEF, token, lineno, sp); } } break; case '{': /* } */ DBG_PRINT(level, "{"); /* } */ ++level; if ((param->flags & PARSER_BEGIN_BLOCK) && atfirst) { if ((param->flags & PARSER_WARNING) && level != 1) warning("forced level 1 block start by '{' at column 0 [+%d %s].", lineno, curfile); /* } */ level = 1; } if (startclass) { char *p = stack[classlevel].terminate; char *q = classname; if (++classlevel >= MAXCLASSSTACK) die("class stack over flow.[%s]", curfile); if (classlevel > 1) *p++ = '.'; stack[classlevel].classname = p; while (*q) *p++ = *q++; stack[classlevel].terminate = p; stack[classlevel].level = level; *p++ = 0; } startclass = startthrow = 0; break; /* { */ case '}': if (--level < 0) { if (namespacelevel > 0) namespacelevel--; else if (param->flags & PARSER_WARNING) warning("missing left '{' [+%d %s].", lineno, curfile); /* } */ level = 0; } if ((param->flags & PARSER_END_BLOCK) && atfirst) { if ((param->flags & PARSER_WARNING) && level != 0) /* { */ warning("forced level 0 block end by '}' at column 0 [+%d %s].", lineno, curfile); level = 0; } if (level < stack[classlevel].level) *(stack[--classlevel].terminate) = 0; /* { */ DBG_PRINT(level, "}"); break; case '=': /* dirty hack. Don't mimic this. */ if (peekc(0) == '=') { throwaway_nextchar(); } else { startequal = 1; } break; case ';': startthrow = startequal = 0; break; case '\n': if (startmacro && level != savelevel) { if (param->flags & PARSER_WARNING) warning("different level before and after #define macro. reseted. [+%d %s].", lineno, curfile); level = savelevel; } startmacro = startsharp = 0; break; /* * #xxx */ case SHARP_DEFINE: case SHARP_UNDEF: startmacro = 1; savelevel = level; if ((c = nexttoken(interested, cpp_reserved_word)) != SYMBOL) { pushbacktoken(); break; } if (peekc(1) == '('/* ) */) { PUT(PARSER_DEF, token, lineno, sp); while ((c = nexttoken("()", cpp_reserved_word)) != EOF && c != '\n' && c != /* ( */ ')') if (c == SYMBOL) PUT(PARSER_REF_SYM, token, lineno, sp); if (c == '\n') pushbacktoken(); } else { PUT(PARSER_DEF, token, lineno, sp); } break; case SHARP_IMPORT: case SHARP_INCLUDE: case SHARP_INCLUDE_NEXT: case SHARP_ERROR: case SHARP_LINE: case SHARP_PRAGMA: case SHARP_WARNING: case SHARP_IDENT: case SHARP_SCCS: while ((c = nexttoken(interested, cpp_reserved_word)) != EOF && c != '\n') ; break; case SHARP_IFDEF: case SHARP_IFNDEF: case SHARP_IF: case SHARP_ELIF: case SHARP_ELSE: case SHARP_ENDIF: condition_macro(param, cc); break; case SHARP_SHARP: /* ## */ (void)nexttoken(interested, cpp_reserved_word); break; case CPP_NEW: if ((c = nexttoken(interested, cpp_reserved_word)) == SYMBOL) PUT(PARSER_REF_SYM, token, lineno, sp); break; case CPP_STRUCT: case CPP_ENUM: case CPP_UNION: c = nexttoken(interested, cpp_reserved_word); if (c == SYMBOL) { if (peekc(0) == '{') /* } */ { PUT(PARSER_DEF, token, lineno, sp); } else { PUT(PARSER_REF_SYM, token, lineno, sp); } c = nexttoken(interested, cpp_reserved_word); } if (c == '{' /* } */ && cc == CPP_ENUM) { enumerator_list(param); } else { pushbacktoken(); } break; case CPP_TEMPLATE: { int level = 0; while ((c = nexttoken("<>", cpp_reserved_word)) != EOF) { if (c == '<') ++level; else if (c == '>') { if (--level == 0) break; } else if (c == SYMBOL) { PUT(PARSER_REF_SYM, token, lineno, sp); } } if (c == EOF && (param->flags & PARSER_WARNING)) warning("template <...> isn't closed. [+%d %s].", lineno, curfile); } break; case CPP_OPERATOR: while ((c = nexttoken(";{", /* } */ cpp_reserved_word)) != EOF) { if (c == '{') /* } */ { pushbacktoken(); break; } else if (c == ';') { break; } else if (c == SYMBOL) { PUT(PARSER_REF_SYM, token, lineno, sp); } } if (c == EOF && (param->flags & PARSER_WARNING)) warning("'{' doesn't exist after 'operator'. [+%d %s].", lineno, curfile); /* } */ break; /* control statement check */ case CPP_THROW: startthrow = 1; case CPP_BREAK: case CPP_CASE: case CPP_CATCH: case CPP_CONTINUE: case CPP_DEFAULT: case CPP_DELETE: case CPP_DO: case CPP_ELSE: case CPP_FOR: case CPP_GOTO: case CPP_IF: case CPP_RETURN: case CPP_SWITCH: case CPP_TRY: case CPP_WHILE: if ((param->flags & PARSER_WARNING) && !startmacro && level == 0) warning("Out of function. %8s [+%d %s]", token, lineno, curfile); break; case CPP_TYPEDEF: { /* * This parser is too complex to maintain. * We should rewrite the whole. */ char savetok[MAXTOKEN]; int savelineno = 0; int typedef_savelevel = level; savetok[0] = 0; /* skip CV qualifiers */ do { c = nexttoken("{}(),;", cpp_reserved_word); } while (IS_CV_QUALIFIER(c) || c == '\n'); if ((param->flags & PARSER_WARNING) && c == EOF) { warning("unexpected eof. [+%d %s]", lineno, curfile); break; } else if (c == CPP_ENUM || c == CPP_STRUCT || c == CPP_UNION) { char *interest_enum = "{},;"; int c_ = c; c = nexttoken(interest_enum, cpp_reserved_word); /* read tag name if exist */ if (c == SYMBOL) { if (peekc(0) == '{') /* } */ { PUT(PARSER_DEF, token, lineno, sp); } else { PUT(PARSER_REF_SYM, token, lineno, sp); } c = nexttoken(interest_enum, cpp_reserved_word); } if (c_ == CPP_ENUM) { if (c == '{') /* } */ c = enumerator_list(param); else pushbacktoken(); } else { for (; c != EOF; c = nexttoken(interest_enum, cpp_reserved_word)) { switch (c) { case SHARP_IFDEF: case SHARP_IFNDEF: case SHARP_IF: case SHARP_ELIF: case SHARP_ELSE: case SHARP_ENDIF: condition_macro(param, c); continue; default: break; } if (c == ';' && level == typedef_savelevel) { if (savetok[0]) PUT(PARSER_DEF, savetok, savelineno, sp); break; } else if (c == '{') level++; else if (c == '}') { if (--level == typedef_savelevel) break; } else if (c == SYMBOL) { PUT(PARSER_REF_SYM, token, lineno, sp); /* save lastest token */ strlimcpy(savetok, token, sizeof(savetok)); savelineno = lineno; } } if (c == ';') break; } if ((param->flags & PARSER_WARNING) && c == EOF) { warning("unexpected eof. [+%d %s]", lineno, curfile); break; } } else if (c == SYMBOL) { PUT(PARSER_REF_SYM, token, lineno, sp); } savetok[0] = 0; while ((c = nexttoken("(),;", cpp_reserved_word)) != EOF) { switch (c) { case SHARP_IFDEF: case SHARP_IFNDEF: case SHARP_IF: case SHARP_ELIF: case SHARP_ELSE: case SHARP_ENDIF: condition_macro(param, c); continue; default: break; } if (c == '(') level++; else if (c == ')') level--; else if (c == SYMBOL) { if (level > typedef_savelevel) { PUT(PARSER_REF_SYM, token, lineno, sp); } else { /* put latest token if any */ if (savetok[0]) { PUT(PARSER_REF_SYM, savetok, savelineno, sp); } /* save lastest token */ strlimcpy(savetok, token, sizeof(savetok)); savelineno = lineno; } } else if (c == ',' || c == ';') { if (savetok[0]) { PUT(PARSER_DEF, savetok, lineno, sp); savetok[0] = 0; } } if (level == typedef_savelevel && c == ';') break; } if (param->flags & PARSER_WARNING) { if (c == EOF) warning("unexpected eof. [+%d %s]", lineno, curfile); else if (level != typedef_savelevel) warning("unmatched () block. (last at level %d.)[+%d %s]", level, lineno, curfile); } } break; case CPP___ATTRIBUTE__: process_attribute(param); break; default: break; } } strbuf_close(sb); if (param->flags & PARSER_WARNING) { if (level != 0) warning("unmatched {} block. (last at level %d.)[+%d %s]", level, lineno, curfile); if (piflevel != 0) warning("unmatched #if block. (last at level %d.)[+%d %s]", piflevel, lineno, curfile); } closetoken(); }
/* * function_definition: return if function definition or not. * * r) target type */ static int function_definition(const struct parser_param *param) { int c; int brace_level; brace_level = 0; while ((c = nexttoken("()", cpp_reserved_word)) != EOF) { switch (c) { case SHARP_IFDEF: case SHARP_IFNDEF: case SHARP_IF: case SHARP_ELIF: case SHARP_ELSE: case SHARP_ENDIF: condition_macro(param, c); continue; default: break; } if (c == '('/* ) */) brace_level++; else if (c == /* ( */')') { if (--brace_level == 0) break; } /* pick up symbol */ if (c == SYMBOL) PUT(PARSER_REF_SYM, token, lineno, sp); } if (c == EOF) return 0; if (peekc(0) == ';') { (void)nexttoken(";", NULL); return 0; } brace_level = 0; while ((c = nexttoken(",;[](){}=", cpp_reserved_word)) != EOF) { switch (c) { case SHARP_IFDEF: case SHARP_IFNDEF: case SHARP_IF: case SHARP_ELIF: case SHARP_ELSE: case SHARP_ENDIF: condition_macro(param, c); continue; case CPP___ATTRIBUTE__: process_attribute(param); continue; default: break; } if (c == '('/* ) */ || c == '[') brace_level++; else if (c == /* ( */')' || c == ']') brace_level--; else if (brace_level == 0 && (c == ';' || c == ',')) break; else if (c == '{' /* } */) { pushbacktoken(); return 1; } else if (c == /* { */'}') break; else if (c == '=') break; /* pick up symbol */ if (c == SYMBOL) PUT(PARSER_REF_SYM, token, lineno, sp); } return 0; }
/* * java: read java file and pickup tag entries. */ void java(const struct parser_param *param) { int c; int level; /* brace level */ int startclass, startthrows, startequal; char classname[MAXTOKEN]; char completename[MAXCOMPLETENAME]; int classlevel; struct { char *classname; char *terminate; int level; } stack[MAXCLASSSTACK]; const char *interested = "{}=;"; *classname = *completename = 0; stack[0].classname = completename; stack[0].terminate = completename; stack[0].level = 0; level = classlevel = 0; startclass = startthrows = startequal = 0; if (!opentoken(param->file)) die("'%s' cannot open.", param->file); while ((c = nexttoken(interested, java_reserved_word)) != EOF) { switch (c) { case SYMBOL: /* symbol */ for (; c == SYMBOL && peekc(1) == '.'; c = nexttoken(interested, java_reserved_word)) { PUT(PARSER_REF_SYM, token, lineno, sp); } if (c != SYMBOL) break; if (startclass || startthrows) { PUT(PARSER_REF_SYM, token, lineno, sp); } else if (peekc(0) == '('/* ) */) { if (level == stack[classlevel].level && !startequal) /* ignore constructor */ if (strcmp(stack[classlevel].classname, token)) PUT(PARSER_DEF, token, lineno, sp); if (level > stack[classlevel].level || startequal) PUT(PARSER_REF_SYM, token, lineno, sp); } else { PUT(PARSER_REF_SYM, token, lineno, sp); } break; case '{': /* } */ DBG_PRINT(level, "{"); /* } */ ++level; if (startclass) { char *p = stack[classlevel].terminate; char *q = classname; if (++classlevel >= MAXCLASSSTACK) die("class stack over flow.[%s]", curfile); if (classlevel > 1) *p++ = '.'; stack[classlevel].classname = p; while (*q) *p++ = *q++; stack[classlevel].terminate = p; stack[classlevel].level = level; *p++ = 0; } startclass = startthrows = 0; break; /* { */ case '}': if (--level < 0) { if (param->flags & PARSER_WARNING) warning("missing left '{' (at %d).", lineno); /* } */ level = 0; } if (level < stack[classlevel].level) *(stack[--classlevel].terminate) = 0; /* { */ DBG_PRINT(level, "}"); break; case '=': startequal = 1; break; case ';': startclass = startthrows = startequal = 0; break; case JAVA_CLASS: case JAVA_INTERFACE: case JAVA_ENUM: if ((c = nexttoken(interested, java_reserved_word)) == SYMBOL) { strlimcpy(classname, token, sizeof(classname)); startclass = 1; PUT(PARSER_DEF, token, lineno, sp); } break; case JAVA_NEW: case JAVA_INSTANCEOF: while ((c = nexttoken(interested, java_reserved_word)) == SYMBOL && peekc(1) == '.') PUT(PARSER_REF_SYM, token, lineno, sp); if (c == SYMBOL) PUT(PARSER_REF_SYM, token, lineno, sp); break; case JAVA_THROWS: startthrows = 1; break; case JAVA_BOOLEAN: case JAVA_BYTE: case JAVA_CHAR: case JAVA_DOUBLE: case JAVA_FLOAT: case JAVA_INT: case JAVA_LONG: case JAVA_SHORT: case JAVA_VOID: if (peekc(1) == '.' && (c = nexttoken(interested, java_reserved_word)) != JAVA_CLASS) pushbacktoken(); break; default: break; } } closetoken(); }
/* * function_definition: return if function definition or not. * * r) target type */ static int function_definition(int target) { int c; int brace_level; brace_level = 0; while ((c = nexttoken("()", cpp_reserved_word)) != EOF) { switch (c) { case SHARP_IFDEF: case SHARP_IFNDEF: case SHARP_IF: case SHARP_ELIF: case SHARP_ELSE: case SHARP_ENDIF: condition_macro(c, target); continue; default: break; } if (c == '('/* ) */) brace_level++; else if (c == /* ( */')') { if (--brace_level == 0) break; } /* pick up symbol */ if (c == SYMBOL) { if (target == REF) { if (seems_datatype(token) && defined(token)) PUT(token, lineno, sp); } else if (target == SYM) { if (!seems_datatype(token) || !defined(token)) PUT(token, lineno, sp); } } } if (c == EOF) return 0; if (peekc(0) == ';') { (void)nexttoken(";", NULL); return 0; } brace_level = 0; while ((c = nexttoken(",;[](){}=", cpp_reserved_word)) != EOF) { switch (c) { case SHARP_IFDEF: case SHARP_IFNDEF: case SHARP_IF: case SHARP_ELIF: case SHARP_ELSE: case SHARP_ENDIF: condition_macro(c, target); continue; case CPP___ATTRIBUTE__: process_attribute(target); continue; default: break; } if (c == '('/* ) */ || c == '[') brace_level++; else if (c == /* ( */')' || c == ']') brace_level--; else if (brace_level == 0 && (c == ';' || c == ',')) break; else if (c == '{' /* } */) { pushbacktoken(); return 1; } else if (c == /* { */'}') break; else if (c == '=') break; /* pick up symbol */ if (c == SYMBOL) { if (target == REF) { if (seems_datatype(token) && defined(token)) PUT(token, lineno, sp); } else if (target == SYM) { if (!seems_datatype(token) || !defined(token)) PUT(token, lineno, sp); } } } return 0; }
int blockin0( int type ) { char *me = "blockin0"; char op[10],msg[MAXLINE]; int cflag; int imax, jmax, kmax; int gblk; if (nblk >= nblkx-1) { sprintf(msg,"number of blocks exceeds nblkx = %d",nblkx); ctlwarning(me,msg); return(1); } if ((type == QUAD2D) && (ndims == 3)) { sprintf(msg,"You are specifying a 2D mesh in a 3D problem.\n\t\tYou might want to use hex instead of the quad command."); ctlerror(me,msg); } if ((type == HEX3D) && (ndims == 2)) { sprintf(msg,"You are specifying a 3D mesh in a 2D problem.\n\t\tYou might want to use quad instead of the hex command.\n\t\tOr you might want to set ndims to 3."); ctlerror(me,msg); } if (type == QUAD2D) { imax = geti(&cflag) + NPNL - 1; jmax = geti(&cflag) + NPNL - 1; domains[nblk].type = QUAD2D ; domains[nblk].imin = NPNL ; domains[nblk].jmin = NPNL ; domains[nblk].kmin = 0 ; domains[nblk].imax = imax; domains[nblk].jmax = jmax; domains[nblk].kmax = 0 ; } else if (type == HEX3D) { imax = geti(&cflag) + NPNL - 1; jmax = geti(&cflag) + NPNL - 1; kmax = geti(&cflag) + NPNL - 1; domains[nblk].type = HEX3D ; domains[nblk].imin = NPNL ; domains[nblk].jmin = NPNL ; domains[nblk].kmin = NPNL ; domains[nblk].imax = imax; domains[nblk].jmax = jmax; domains[nblk].kmax = kmax; } else { sprintf(msg,"unknown block type '%s'",op); ctlwarning(me,msg); return(1); } if (ifparallel) { if (unblk > 1) { sprintf(msg,"You may not use parallel mesh generation on multi-block problems."); ctlerror(me,msg); } blknum = unblk ; domains[nblk].jp = domains[nblk].imax - domains[nblk].imin + 1 + NPNL + NPNR; domains[nblk].kp = 0; if (ndims == 3) { domains[nblk].kp = domains[nblk].jp * (domains[nblk].jmax - domains[nblk].jmin + 1 + NPNL + NPNR); } setumap( &domains[nblk] ) ; peekc(op); if (strcmp(op,"blkdiv")) { if (nblkx <= num_procs) { sprintf(msg,"Number of domains (%i) exceeds nblkx (%i). Please increase nblkx.",num_procs,nblkx); ctlerror(me,msg); } blkdivin(1); } else { geta(op); blkdivin(0); } if (nblkx <= num_procs) { sprintf(msg,"Number of domains (%i) exceeds nblkx (%i). Please increase nblkx.",num_procs,nblkx); ctlerror(me,msg); } calculate_mappings(); for (gblk = 0; gblk < gnblk; gblk++) { if (gmap[gblk].proc == myid) { domains[nblk].type = type ; domains[nblk].sclnamix = sclnamix ; TRSEXT(domains[nblk],gmap[gblk],gmap[gblk]); if (ndims == 2) { domains[nblk].kmin = 0; domains[nblk].kmax = 0; } initblk(nblk,&domains[nblk]); domains[nblk].gblk = gblk; domain_hash_tbl_rgst(&(domains[nblk])); nblk++; } } if (ifparallel) { bndry_init(); initcom( NULL, 0); varcom_bufinit(); } } else { peekc(op); if (!strcmp(op,"blkdiv")) { sprintf(msg,"blkdiv command may only appear after quad or hex during parallel \n\t\tgeneration."); ctlerror(me,msg); } domains[nblk].sclnamix = sclnamix ; initblk( nblk, &domains[nblk] ) ; setumap( &domains[nblk] ) ; blknum = nblk ; nblk++ ; } return(0) ; }