home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume6 / rpc2 / part10 / rpc / rpcgen / rpc_parse.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-30  |  7.9 KB  |  407 lines
  1. #ifndef lint 
  2. static char sccsid[] = "@(#)rpc_parse.c 1.1 86/03/26 (C) 1986 SMI";
  3. #endif
  4.  
  5. /* 
  6.  * rpc_parse.c, Parser for the RPC protocol compiler
  7.  * Copyright (C) 1986 Sun Microsystems, Inc.
  8.  */
  9.  
  10. #include <stdio.h> 
  11. #include "rpc_util.h"
  12. #include "rpc_scan.h"
  13. #include "rpc_parse.h"
  14.  
  15. /*
  16.  * return the next definition you see
  17.  */
  18. definition *
  19. get_definition()
  20. {
  21.     definition *defp;
  22.     token tok;
  23.  
  24.  
  25.     defp = ALLOC(definition);
  26.     get_token(&tok);
  27.     switch (tok.kind) {
  28.     case TOK_STRUCT:
  29.         def_struct(defp);
  30.         break;
  31.     case TOK_UNION:
  32.         def_union(defp);
  33.         break;
  34.     case TOK_TYPEDEF:
  35.         def_typedef(defp);
  36.         break;
  37.     case TOK_ARRAY:
  38.         def_array(defp);
  39.         break;
  40.     case TOK_ENUM:
  41.         def_enum(defp);
  42.         break;
  43.     case TOK_PROGRAM:
  44.         def_program(defp);    
  45.         break;
  46.     case TOK_EOF:
  47.         return(NULL);    
  48.         break;
  49.     default:
  50.         error("definition keyword expected");
  51.     }
  52.     scan(TOK_SEMICOLON,&tok);
  53.     isdefined(defp);
  54.     return(defp);
  55. }
  56.  
  57. static 
  58. isdefined(defp)
  59.     definition *defp;
  60. {
  61.     STOREVAL(&defined,defp); 
  62. }
  63.  
  64.  
  65. static
  66. def_struct(defp)
  67.     definition *defp;
  68. {
  69.     token tok;
  70.     declaration dec;
  71.     decl_list *decls;
  72.     decl_list **tailp;
  73.  
  74.     defp->def_kind = DEF_STRUCT;
  75.  
  76.     scan(TOK_IDENT,&tok);
  77.     defp->def_name = tok.str;
  78.     scan(TOK_LBRACE,&tok);
  79.     tailp = &defp->def.st.decls;
  80.     do {
  81.         get_declaration(&dec,DEF_STRUCT);
  82.         decls = ALLOC(decl_list);
  83.         decls->decl = dec;
  84.         *tailp = decls;
  85.         tailp = &decls->next;
  86.         scan(TOK_SEMICOLON,&tok);
  87.         peek(&tok);    
  88.     } while (tok.kind != TOK_RBRACE);
  89.     get_token(&tok);    
  90.     *tailp = NULL;    
  91. }
  92.  
  93. static
  94. def_program(defp)
  95.     definition *defp;
  96. {
  97.     token tok;
  98.     version_list *vlist;
  99.     version_list **vtailp;
  100.     proc_list *plist;
  101.     proc_list **ptailp;
  102.     
  103.     defp->def_kind = DEF_PROGRAM;
  104.     scan(TOK_IDENT,&tok);
  105.     defp->def_name = tok.str;
  106.     scan(TOK_LBRACE,&tok);
  107.     vtailp = &defp->def.pr.versions;
  108.     scan(TOK_VERSION,&tok);
  109.     do {
  110.         scan(TOK_IDENT,&tok);
  111.         vlist = ALLOC(version_list);
  112.         vlist->vers_name = tok.str;
  113.         scan(TOK_LBRACE,&tok);
  114.         ptailp = &vlist->procs;
  115.         do {
  116.             plist = ALLOC(proc_list);
  117.             get_type(&plist->res_prefix,&plist->res_type,DEF_PROGRAM);
  118.             if (streq(plist->res_type,"string") || 
  119.                     streq(plist->res_type,"opaque")) {
  120.                 error("illegal result type");
  121.             }
  122.             scan(TOK_IDENT,&tok);
  123.             plist->proc_name = tok.str;
  124.             scan(TOK_LPAREN,&tok);
  125.             get_type(&plist->arg_prefix,&plist->arg_type,DEF_PROGRAM);
  126.             if (streq(plist->arg_type,"string") || 
  127.                     streq(plist->arg_type,"opaque")) {
  128.                 error("illegal argument type");
  129.             }
  130.             scan(TOK_RPAREN,&tok);
  131.             scan(TOK_EQUAL,&tok);
  132.             scan_num(&tok);
  133.             scan(TOK_SEMICOLON,&tok);
  134.             plist->proc_num = tok.str;
  135.             *ptailp = plist;
  136.             ptailp = &plist->next;
  137.             peek(&tok);
  138.         } while (tok.kind != TOK_RBRACE);
  139.         *vtailp = vlist;
  140.         vtailp = &vlist->next;
  141.         scan(TOK_RBRACE,&tok);
  142.         scan(TOK_EQUAL,&tok);
  143.         scan_num(&tok);
  144.         vlist->vers_num = tok.str;
  145.         scan(TOK_SEMICOLON,&tok);
  146.         scan2(TOK_VERSION,TOK_RBRACE,&tok);
  147.     } while (tok.kind == TOK_VERSION);
  148.     scan(TOK_EQUAL, &tok);
  149.     scan_num(&tok);
  150.     defp->def.pr.prog_num = tok.str;
  151.     *vtailp = NULL;
  152. }
  153.     
  154. static    
  155. def_enum(defp)
  156.     definition *defp;
  157. {
  158.     token tok;
  159.     enumval_list *elist;
  160.     enumval_list **tailp;
  161.  
  162.     defp->def_kind = DEF_ENUM;
  163.     scan(TOK_IDENT,&tok);
  164.     defp->def_name = tok.str;
  165.     scan(TOK_LBRACE,&tok);
  166.     tailp = &defp->def.en.vals;
  167.     do {
  168.         scan(TOK_IDENT,&tok);
  169.         elist = ALLOC(enumval_list);
  170.         elist->name = tok.str;
  171.         elist->assignment = NULL;
  172.         scan3(TOK_COMMA,TOK_RBRACE,TOK_EQUAL,&tok);    
  173.         if (tok.kind == TOK_EQUAL) {
  174.             scan_num(&tok);
  175.             elist->assignment = tok.str;
  176.             scan2(TOK_COMMA,TOK_RBRACE,&tok);
  177.         }
  178.         *tailp = elist;
  179.         tailp = &elist->next;
  180.     } while (tok.kind != TOK_RBRACE);
  181.     *tailp = NULL;
  182. }
  183.     
  184. static
  185. def_array(defp)
  186.     definition *defp;
  187. {
  188.     token tok;
  189.     declaration dec;
  190.  
  191.     defp->def_kind = DEF_ARRAY;
  192.     scan(TOK_IDENT,&tok);
  193.     defp->def_name = tok.str;
  194.     scan(TOK_LBRACE,&tok);
  195.     get_declaration(&dec,DEF_ARRAY);
  196.     if (! streq(dec.type,"u_int")) {
  197.         error("array length must be of type unsigned");
  198.     }
  199.     if (dec.rel != REL_ALIAS) {
  200.         error("array length may not be pointer or vector");
  201.     }
  202.     scan(TOK_SEMICOLON,&tok);
  203.     defp->def.ar.len_name = dec.name;
  204.     get_declaration(&dec,DEF_ARRAY);
  205.     if (dec.rel != REL_VECTOR) {
  206.         error("expected array declaration");
  207.     }
  208.     if (streq(dec.type,"string")) {
  209.         error("string declarations don't make sense here");
  210.     }
  211.     scan(TOK_SEMICOLON,&tok);
  212.     defp->def.ar.array_prefix = dec.prefix;
  213.     defp->def.ar.array_type = dec.type;
  214.     defp->def.ar.array_name = dec.name;
  215.     defp->def.ar.array_max = dec.array_max;
  216.     scan(TOK_RBRACE,&tok);
  217. }
  218.  
  219.  
  220.  
  221. static
  222. def_union(defp)
  223.     definition *defp;
  224. { 
  225.     token tok;
  226.     declaration dec;
  227.     case_list *cases;
  228.     case_list **tailp;
  229.  
  230.     defp->def_kind = DEF_UNION;
  231.     scan(TOK_IDENT,&tok);
  232.     defp->def_name = tok.str;
  233.     scan(TOK_SWITCH,&tok);
  234.     scan(TOK_LPAREN,&tok);
  235.     get_declaration(&dec,DEF_UNION);
  236.     defp->def.un.enum_decl = dec;
  237.     tailp = &defp->def.un.cases;
  238.     scan(TOK_RPAREN,&tok);
  239.     scan(TOK_LBRACE,&tok);
  240.     scan(TOK_CASE, &tok);
  241.     while (tok.kind == TOK_CASE) {
  242.         scan(TOK_IDENT,&tok);
  243.         cases = ALLOC(case_list);
  244.         cases->case_name = tok.str;
  245.         scan(TOK_COLON,&tok);
  246.         get_declaration(&dec,DEF_UNION);
  247.         cases->case_decl = dec;
  248.         *tailp = cases;
  249.         tailp = &cases->next;
  250.         scan(TOK_SEMICOLON,&tok);
  251.         scan3(TOK_CASE,TOK_DEFAULT,TOK_RBRACE,&tok);
  252.     }
  253.     *tailp = NULL;
  254.     if (tok.kind == TOK_DEFAULT) {
  255.         scan(TOK_COLON,&tok);
  256.         get_declaration(&dec,DEF_UNION);
  257.         defp->def.un.default_decl =  ALLOC(declaration);
  258.         *defp->def.un.default_decl = dec;
  259.         scan(TOK_SEMICOLON,&tok);
  260.         scan(TOK_RBRACE,&tok);
  261.     }
  262. }
  263.  
  264.  
  265. static
  266. def_typedef(defp)
  267.     definition *defp;
  268. { 
  269.     declaration dec;
  270.  
  271.     defp->def_kind = DEF_TYPEDEF;
  272.     get_declaration(&dec,DEF_TYPEDEF);
  273.     defp->def_name = dec.name;
  274.     defp->def.ty.old_prefix = dec.prefix;
  275.     defp->def.ty.old_type = dec.type;
  276.     defp->def.ty.rel = dec.rel;
  277.     defp->def.ty.array_max = dec.array_max;
  278. }
  279.  
  280.  
  281. static
  282. get_declaration(dec,dkind)
  283.     declaration *dec;
  284.     defkind dkind;
  285. {
  286.     token tok;
  287.  
  288.     get_type(&dec->prefix,&dec->type,dkind);
  289.     dec->rel = REL_ALIAS;
  290.     scan2(TOK_STAR,TOK_IDENT,&tok);
  291.     if (tok.kind == TOK_STAR) {
  292.         dec->rel = REL_POINTER;
  293.         scan(TOK_IDENT,&tok);
  294.     }
  295.     dec->name = tok.str; 
  296.     if (peekscan(TOK_LBRACKET,&tok)) {
  297.         if (dec->rel == REL_POINTER) {
  298.             error("no array-of-pointer declarations -- use typedef");
  299.         }
  300.         dec->rel = REL_VECTOR;
  301.         if (streq(dec->type,"string") && peekscan(TOK_RBRACKET,&tok)) {
  302.             dec->array_max = NULL;     /* means unspecified */
  303.         } else {    
  304.             dec->rel = REL_VECTOR;
  305.             scan_num(&tok);    
  306.             dec->array_max = tok.str;
  307.             scan(TOK_RBRACKET,&tok);
  308.         }
  309.     }
  310.     if (streq(dec->type,"opaque") || streq(dec->type,"string")) {
  311.         if (dec->rel != REL_VECTOR) {
  312.             error("vector declaration expected");
  313.         }
  314.     } else if (streq(dec->type,"void")) {
  315.         if (dec->rel != REL_ALIAS) {
  316.             error("no vector-of-void or pointer-to-void declarations");
  317.         }
  318.     }
  319. }
  320.  
  321.  
  322. static
  323. get_type(prefixp,typep, dkind)
  324.     char **prefixp;
  325.     char **typep;
  326.     defkind dkind;
  327. {
  328.     token tok;
  329.  
  330.     *prefixp = NULL; 
  331.     get_token(&tok);
  332.     switch (tok.kind) {
  333.     case TOK_IDENT:
  334.         *typep = tok.str;
  335.         break;
  336.     case TOK_STRUCT:
  337.     case TOK_ENUM:
  338.     case TOK_ARRAY:
  339.     case TOK_UNION:
  340.         *prefixp = tok.str;
  341.         scan(TOK_IDENT,&tok);    
  342.         *typep = tok.str;
  343.         break;
  344.     case TOK_UNSIGNED:
  345.         unsigned_dec(typep);
  346.         break;
  347.     case TOK_SHORT:
  348.         *typep = "short"; 
  349.         (void) peekscan(TOK_INT,&tok);
  350.         break;
  351.     case TOK_LONG:
  352.         *typep = "long"; 
  353.         (void) peekscan(TOK_INT,&tok);
  354.         break;
  355.     case TOK_VOID:
  356.         if (dkind != DEF_UNION && dkind != DEF_PROGRAM) {
  357.             error("voids allowed only inside union and program definitions");
  358.         }
  359.         *typep = tok.str;
  360.         break;
  361.     case TOK_STRING:
  362.     case TOK_OPAQUE:
  363.     case TOK_CHAR:
  364.     case TOK_INT:
  365.     case TOK_FLOAT:
  366.     case TOK_DOUBLE:
  367.     case TOK_BOOL:
  368.         *typep = tok.str;
  369.         break;    
  370.     default:
  371.         error("expected type specifier");
  372.     }
  373. }
  374.  
  375.  
  376. static
  377. unsigned_dec(typep)
  378.     char **typep;
  379. {
  380.     token tok;
  381.  
  382.     peek(&tok);
  383.     switch (tok.kind) {
  384.     case TOK_CHAR:
  385.         get_token(&tok);
  386.         *typep = "u_char";
  387.         break;
  388.     case TOK_SHORT:
  389.         get_token(&tok);
  390.         *typep = "u_short";
  391.         (void) peekscan(TOK_INT,&tok);
  392.         break;
  393.     case TOK_LONG:
  394.         get_token(&tok);
  395.         *typep = "u_long";
  396.         (void) peekscan(TOK_INT,&tok);
  397.         break;
  398.     case TOK_INT:
  399.         get_token(&tok);
  400.         *typep = "u_int";
  401.         break;
  402.     default:
  403.         *typep = "u_int";
  404.         break;
  405.     }
  406. }
  407.