static void unsigned_dec(char **typep) { token tok; peek(&tok); switch (tok.kind) { case TOK_CHAR: get_token(&tok); *typep = "u_char"; break; case TOK_SHORT: get_token(&tok); *typep = "u_short"; (void) peekscan(TOK_INT, &tok); break; case TOK_LONG: get_token(&tok); *typep = "u_long"; (void) peekscan(TOK_INT, &tok); break; case TOK_INT: get_token(&tok); *typep = "u_int"; break; default: *typep = "u_int"; break; } }
static void get_type (const char **prefixp, const char **typep, defkind dkind) { token tok; *prefixp = NULL; get_token (&tok); switch (tok.kind) { case TOK_IDENT: *typep = tok.str; break; case TOK_STRUCT: case TOK_ENUM: case TOK_UNION: *prefixp = tok.str; scan (TOK_IDENT, &tok); *typep = tok.str; break; case TOK_UNSIGNED: unsigned_dec (typep); break; case TOK_SHORT: *typep = "short"; (void) peekscan (TOK_INT, &tok); break; case TOK_LONG: *typep = "long"; (void) peekscan (TOK_INT, &tok); break; case TOK_HYPER: *typep = "quad_t"; (void) peekscan(TOK_INT, &tok); break; case TOK_VOID: if (dkind != DEF_UNION && dkind != DEF_PROGRAM) { error ("voids allowed only inside union and program definitions with one argument"); } *typep = tok.str; break; case TOK_STRING: case TOK_OPAQUE: case TOK_CHAR: case TOK_INT: case TOK_FLOAT: case TOK_DOUBLE: case TOK_BOOL: *typep = tok.str; break; default: error ("expected type specifier"); } }
static void get_declaration(declaration *dec, defkind dkind) { token tok; get_type(&dec->prefix, &dec->type, dkind); dec->rel = REL_ALIAS; if (streq(dec->type, "void")) { return; } check_type_name(dec->type, 0); scan2(TOK_STAR, TOK_IDENT, &tok); if (tok.kind == TOK_STAR) { dec->rel = REL_POINTER; scan(TOK_IDENT, &tok); } dec->name = tok.str; if (peekscan(TOK_LBRACKET, &tok)) { if (dec->rel == REL_POINTER) { error("no array-of-pointer declarations -- use typedef"); } dec->rel = REL_VECTOR; scan_num(&tok); dec->array_max = tok.str; scan(TOK_RBRACKET, &tok); } else if (peekscan(TOK_LANGLE, &tok)) { if (dec->rel == REL_POINTER) { error("no array-of-pointer declarations -- use typedef"); } dec->rel = REL_ARRAY; if (peekscan(TOK_RANGLE, &tok)) { dec->array_max = "~0"; /* unspecified size, use max */ } else { scan_num(&tok); dec->array_max = tok.str; scan(TOK_RANGLE, &tok); } } if (streq(dec->type, "opaque")) { if (dec->rel != REL_ARRAY && dec->rel != REL_VECTOR) { error("array declaration expected"); } } else if (streq(dec->type, "string")) { if (dec->rel != REL_ARRAY) { error("variable-length array declaration expected"); } } }
static void get_prog_declaration (declaration * dec, defkind dkind, int num /* arg number */ ) { token tok; char name[10]; /* argument name */ if (dkind == DEF_PROGRAM) { peek (&tok); if (tok.kind == TOK_RPAREN) { /* no arguments */ dec->rel = REL_ALIAS; dec->type = "void"; dec->prefix = NULL; dec->name = NULL; return; } } get_type (&dec->prefix, &dec->type, dkind); dec->rel = REL_ALIAS; if (peekscan (TOK_IDENT, &tok)) /* optional name of argument */ strcpy (name, tok.str); else sprintf (name, "%s%d", ARGNAME, num); /* default name of argument */ dec->name = (char *) strdup (name); if (streq (dec->type, "void")) { return; } if (streq (dec->type, "opaque")) { error ("opaque -- illegal argument type"); } if (peekscan (TOK_STAR, &tok)) { if (streq (dec->type, "string")) { error ("pointer to string not allowed in program arguments\n"); } dec->rel = REL_POINTER; if (peekscan (TOK_IDENT, &tok)) /* optional name of argument */ dec->name = strdup (tok.str); } if (peekscan (TOK_LANGLE, &tok)) { if (!streq (dec->type, "string")) { error ("arrays cannot be declared as arguments to procedures -- use typedef"); } dec->rel = REL_ARRAY; if (peekscan (TOK_RANGLE, &tok)) { dec->array_max = "~0"; /* unspecified size, use max */ } else { scan_num (&tok); dec->array_max = tok.str; scan (TOK_RANGLE, &tok); } } if (streq (dec->type, "string")) { if (dec->rel != REL_ARRAY) { /* .x specifies just string as * type of argument * - make it string<> */ dec->rel = REL_ARRAY; dec->array_max = "~0"; /* unspecified size, use max */ } } }
static void def_union (definition *defp) { token tok; declaration dec; case_list *cases; /* case_list *tcase; */ case_list **tailp; #if 0 int flag; #endif defp->def_kind = DEF_UNION; scan (TOK_IDENT, &tok); defp->def_name = tok.str; scan (TOK_SWITCH, &tok); scan (TOK_LPAREN, &tok); get_declaration (&dec, DEF_UNION); defp->def.un.enum_decl = dec; tailp = &defp->def.un.cases; scan (TOK_RPAREN, &tok); scan (TOK_LBRACE, &tok); scan (TOK_CASE, &tok); while (tok.kind == TOK_CASE) { scan2 (TOK_IDENT, TOK_CHARCONST, &tok); cases = ALLOC (case_list); cases->case_name = tok.str; scan (TOK_COLON, &tok); /* now peek at next token */ #if 0 flag = 0; #endif if (peekscan (TOK_CASE, &tok)) { do { scan2 (TOK_IDENT, TOK_CHARCONST, &tok); cases->contflag = 1; /* continued case statement */ *tailp = cases; tailp = &cases->next; cases = ALLOC (case_list); cases->case_name = tok.str; scan (TOK_COLON, &tok); } while (peekscan (TOK_CASE, &tok)); } #if 0 else if (flag) { *tailp = cases; tailp = &cases->next; cases = ALLOC (case_list); }; #endif get_declaration (&dec, DEF_UNION); cases->case_decl = dec; cases->contflag = 0; /* no continued case statement */ *tailp = cases; tailp = &cases->next; scan (TOK_SEMICOLON, &tok); scan3 (TOK_CASE, TOK_DEFAULT, TOK_RBRACE, &tok); } *tailp = NULL; if (tok.kind == TOK_DEFAULT) { scan (TOK_COLON, &tok); get_declaration (&dec, DEF_UNION); defp->def.un.default_decl = ALLOC (declaration); *defp->def.un.default_decl = dec; scan (TOK_SEMICOLON, &tok); scan (TOK_RBRACE, &tok); } else { defp->def.un.default_decl = NULL; } }
static void def_program (definition * defp) { token tok; declaration dec; decl_list *decls; decl_list **tailp; version_list *vlist; version_list **vtailp; proc_list *plist; proc_list **ptailp; int num_args; bool_t isvoid = FALSE; /* whether first argument is void */ defp->def_kind = DEF_PROGRAM; scan (TOK_IDENT, &tok); defp->def_name = tok.str; scan (TOK_LBRACE, &tok); vtailp = &defp->def.pr.versions; tailp = &defp->def.st.decls; scan (TOK_VERSION, &tok); do { scan (TOK_IDENT, &tok); vlist = ALLOC (version_list); vlist->vers_name = tok.str; scan (TOK_LBRACE, &tok); ptailp = &vlist->procs; do { /* get result type */ plist = ALLOC (proc_list); get_type (&plist->res_prefix, &plist->res_type, DEF_PROGRAM); if (streq (plist->res_type, "opaque")) { error ("illegal result type"); } scan (TOK_IDENT, &tok); plist->proc_name = tok.str; scan (TOK_LPAREN, &tok); /* get args - first one */ num_args = 1; isvoid = FALSE; /* type of DEF_PROGRAM in the first * get_prog_declaration and DEF_STURCT in the next * allows void as argument if it is the only argument */ get_prog_declaration (&dec, DEF_PROGRAM, num_args); if (streq (dec.type, "void")) isvoid = TRUE; decls = ALLOC (decl_list); plist->args.decls = decls; decls->decl = dec; tailp = &decls->next; /* get args */ while (peekscan (TOK_COMMA, &tok)) { num_args++; get_prog_declaration (&dec, DEF_STRUCT, num_args); decls = ALLOC (decl_list); decls->decl = dec; *tailp = decls; if (streq (dec.type, "void")) isvoid = TRUE; tailp = &decls->next; } /* multiple arguments are only allowed in newstyle */ if (!newstyle && num_args > 1) { error ("only one argument is allowed"); } if (isvoid && num_args > 1) { error ("illegal use of void in program definition"); } *tailp = NULL; scan (TOK_RPAREN, &tok); scan (TOK_EQUAL, &tok); scan_num (&tok); scan (TOK_SEMICOLON, &tok); plist->proc_num = tok.str; plist->arg_num = num_args; *ptailp = plist; ptailp = &plist->next; peek (&tok); } while (tok.kind != TOK_RBRACE); *ptailp = NULL; *vtailp = vlist; vtailp = &vlist->next; scan (TOK_RBRACE, &tok); scan (TOK_EQUAL, &tok); scan_num (&tok); vlist->vers_num = tok.str; /* make the argument structure name for each arg */ for (plist = vlist->procs; plist != NULL; plist = plist->next) { plist->args.argname = make_argname (plist->proc_name, vlist->vers_num); /* free the memory ?? */ } scan (TOK_SEMICOLON, &tok); scan2 (TOK_VERSION, TOK_RBRACE, &tok); } while (tok.kind == TOK_VERSION); scan (TOK_EQUAL, &tok); scan_num (&tok); defp->def.pr.prog_num = tok.str; *vtailp = NULL; }