One Level Up Top Level

userspace/ffi/cparser.c - ktap

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. #include <stdarg.h>
  2. #include "../cparser.h"

  4. ‌#define IS_CONST(tok) (IS_LITERAL(tok, "const") || IS_LITERAL(tok, "__const") \
  5.             || IS_LITERAL(tok, "__const__"))
  6. ‌#define IS_VOLATILE(tok) (IS_LITERAL(tok, "volatile") || \
  7.                 IS_LITERAL(tok, "__volatile") || \
  8.                 IS_LITERAL(tok, "__volatile__"))
  9. ‌#define IS_RESTRICT(tok) (IS_LITERAL(tok, "restrict") || \
  10.                 IS_LITERAL(tok, "__restrict") || \
  11.                 IS_LITERAL(tok, "__restrict__"))

  13. ‌#define max(a,b) ((a) < (b) ? (b) : (a))
  14. ‌#define min(a,b) ((a) < (b) ? (a) : (b))


  17. ‌enum etoken {
  18.     /* 0 - 3 */
  19.     TOK_NIL,
  20.     TOK_NUMBER,
  21.     TOK_STRING,
  22.     TOK_TOKEN,

  24.     /* the order of these values must match the token strings in lex.c */

  26.     /* 4 - 5 */
  27.     TOK_3_BEGIN,
  28.     TOK_VA_ARG,

  30.     /* 6 - 14 */
  31.     TOK_2_BEGIN,
  32.     TOK_LEFT_SHIFT, TOK_RIGHT_SHIFT, TOK_LOGICAL_AND, TOK_LOGICAL_OR,
  33.     TOK_LESS_EQUAL, TOK_GREATER_EQUAL, TOK_EQUAL, TOK_NOT_EQUAL,

  35.     /* 15 - 20 */
  36.     TOK_1_BEGIN,
  37.     TOK_OPEN_CURLY, TOK_CLOSE_CURLY, TOK_SEMICOLON, TOK_COMMA, TOK_COLON,
  38.     /* 21 - 30 */
  39.     TOK_ASSIGN, TOK_OPEN_PAREN, TOK_CLOSE_PAREN, TOK_OPEN_SQUARE, TOK_CLOSE_SQUARE,
  40.     TOK_DOT, TOK_AMPERSAND, TOK_LOGICAL_NOT, TOK_BITWISE_NOT, TOK_MINUS,
  41.     /* 31 - 40 */
  42.     TOK_PLUS, TOK_STAR, TOK_DIVIDE, TOK_MODULUS, TOK_LESS,
  43.     TOK_GREATER, TOK_BITWISE_XOR, TOK_BITWISE_OR, TOK_QUESTION, TOK_POUND,

  45.     /* 41 - 43 */
  46.     TOK_REFERENCE = TOK_AMPERSAND,
  47.     TOK_MULTIPLY = TOK_STAR,
  48.     TOK_BITWISE_AND = TOK_AMPERSAND,
  49. };

  51. ‌struct token {
  52.     enum etoken type;
  53.     int64_t integer;
  54.     const char *str;
  55.     size_t size;
  56. };

  58. ‌#define IS_LITERAL(TOK, STR) \
  59.     (((TOK).size == sizeof(STR) - 1) && \
  60.         0 == memcmp((TOK).str, STR, sizeof(STR) - 1))


  63. static int parse_type_name(struct parser *P, char *type_name);
  64. static void parse_argument(struct parser *P, struct cp_ctype *ct,
  65.         struct token *pname, struct parser *asmname);
  66. static int parse_attribute(struct parser *P, struct token *tok,
  67.         struct cp_ctype *ct, struct parser *asmname);
  68. static int parse_record(struct parser *P, struct cp_ctype *ct);
  69. static void instantiate_typedef(struct parser *P, struct cp_ctype *tt,
  70.         const struct cp_ctype *ft);


  73. /* the order of tokens _must_ match the order of the enum etoken enum */

  75. ‌static char tok3[][4] = {
  76.     "...", /* unused ">>=", "<<=", */
  77. };

  79. ‌static char tok2[][3] = {
  80.     "<<", ">>", "&&", "||", "<=",
  81.     ">=", "==", "!=",
  82.     /* unused "+=", "-=", "*=", "/=", "%=", "&=", "^=",
  83.      * "|=", "++", "--", "->", "::", */
  84. };

  86. ‌static char tok1[] = {
  87.     '{', '}', ';', ',', ':',
  88.     '=', '(', ')', '[', ']',
  89.     '.', '&', '!', '~', '-',
  90.     '+', '*', '/', '%', '<',
  91.     '>', '^', '|', '?', '#'
  92. };


  95. /* this function never returns, but it's an idiom to use it in C functions
  96. * as return cp_error */
  97. ‌void cp_error(const char *err_msg_fmt, ...)
  98. {
  99.     va_list ap;

  101.     fprintf(stderr, "cparser error:\n");

  103.     va_start(ap, err_msg_fmt);
  104.     vfprintf(stderr, err_msg_fmt, ap);
  105.     va_end(ap);

  107.     exit(EXIT_FAILURE);
  108. }

  110. ‌static int set_type_name(char *dst, unsigned type, const char *src, int len)
  111. {
  112.     int prefix_len;
  113.     char *prefix = NULL;

  115.     if (type == STRUCT_TYPE)
  116.         prefix = "struct ";
  117.     else if (type == UNION_TYPE)
  118.         prefix = "union ";
  119.     else
  120.         cp_error("Only set type name for struct or union\n");
  121.     prefix_len = sizeof(prefix);

  123.     if (len + prefix_len > MAX_TYPE_NAME_LEN)
  124.         return -1;

  126.     memset(dst, 0, MAX_TYPE_NAME_LEN);
  127.     strcpy(dst, prefix);
  128.     strncat(dst, src, len);

  130.     return 0;
  131. }

  133. ‌static void increase_ptr_deref_level(struct parser *P, struct cp_ctype *ct)
  134. {
  135.     if (ct->pointers == POINTER_MAX) {
  136.         cp_error("maximum number of pointer derefs reached - use a "
  137.             "struct to break up the pointers on line %d", P->line);
  138.     } else {
  139.         ct->pointers++;
  140.         ct->const_mask <<= 1;
  141.     }
  142. }

  144. ‌static int next_token(struct parser *P, struct token *tok)
  145. {
  146.     size_t i;
  147.     const char *s = P->next;

  149.     /* UTF8 BOM */
  150.     if (s[0] == '\xEF' && s[1] == '\xBB' && s[2] == '\xBF') {
  151.         s += 3;
  152.     }

  154.     /* consume whitespace and comments */
  155.     for (;;) {
  156.         /* consume whitespace */
  157.         while (*s == '\t' || *s == '\n' || *s == ' '
  158.                 || *s == '\v' || *s == '\r') {
  159.             if (*s == '\n') {
  160.                 P->line++;
  161.             }
  162.             s++;
  163.         }

  165.         /* consume comments */
  166.         if (*s == '/' && *(s+1) == '/') {

  168.             s = strchr(s, '\n');
  169.             if (!s) {
  170.                 cp_error("non-terminated comment");
  171.             }

  173.         } else if (*s == '/' && *(s+1) == '*') {
  174.             s += 2;

  176.             for (;;) {
  177.                 if (s[0] == '\0') {
  178.                     cp_error("non-terminated comment");
  179.                 } else if (s[0] == '*' && s[1] == '/') {
  180.                     s += 2;
  181.                     break;
  182.                 } else if (s[0] == '\n') {
  183.                     P->line++;
  184.                 }
  185.                 s++;
  186.             }

  188.         } else if (*s == '\0') {
  189.             tok->type = TOK_NIL;
  190.             return 0;

  192.         } else {
  193.             break;
  194.         }
  195.     }

  197.     P->prev = s;

  199.     for (i = 0; i < sizeof(tok3) / sizeof(tok3[0]); i++) {
  200.         if (s[0] == tok3[i][0] && s[1] == tok3[i][1] && s[2] == tok3[i][2]) {
  201.             tok->type = (enum etoken) (TOK_3_BEGIN + 1 + i);
  202.             P->next = s + 3;
  203.             goto end;
  204.         }
  205.     }

  207.     for (i = 0; i < sizeof(tok2) / sizeof(tok2[0]); i++) {
  208.         if (s[0] == tok2[i][0] && s[1] == tok2[i][1]) {
  209.             tok->type = (enum etoken) (TOK_2_BEGIN + 1 + i);
  210.             P->next = s + 2;
  211.             goto end;
  212.         }
  213.     }

  215.     for (i = 0; i < sizeof(tok1) / sizeof(tok1[0]); i++) {
  216.         if (s[0] == tok1[i]) {
  217.             tok->type = (enum etoken) (TOK_1_BEGIN + 1 + i);
  218.             P->next = s + 1;
  219.             goto end;
  220.         }
  221.     }

  223.     if (*s == '.' || *s == '-' || ('0' <= *s && *s <= '9')) {
  224.         /* number */
  225.         tok->type = TOK_NUMBER;

  227.         /* split out the negative case so we get the full range of
  228.          * bits for unsigned (eg to support 0xFFFFFFFF where
  229.          * sizeof(long) == 4 */
  230.         if (*s == '-') {
  231.             tok->integer = strtol(s, (char**) &s, 0);
  232.         } else {
  233.             tok->integer = strtoul(s, (char**) &s, 0);
  234.         }

  236.         while (*s == 'u' || *s == 'U' || *s == 'l' || *s == 'L') {
  237.             s++;
  238.         }

  240.         P->next = s;
  241.         goto end;

  243.     } else if (*s == '\'' || *s == '\"') {
  244.         /* "..." or '...' */
  245.         char quote = *s;
  246.         s++; /* jump over " */

  248.         tok->type = TOK_STRING;
  249.         tok->str = s;

  251.         while (*s != quote) {
  252.             if (*s == '\0' || (*s == '\\' && *(s+1) == '\0')) {
  253.                 cp_error("string not finished\n");
  254.             }
  255.             if (*s == '\\') {
  256.                 s++;
  257.             }
  258.             s++;
  259.         }

  261.         tok->size = s - tok->str;
  262.         s++; /* jump over " */
  263.         P->next = s;
  264.         goto end;

  266.     } else if (('a' <= *s && *s <= 'z') || ('A' <= *s && *s <= 'Z')
  267.             || *s == '_') {
  268.         /* tokens */
  269.         tok->type = TOK_TOKEN;
  270.         tok->str = s;

  272.         while (('a' <= *s && *s <= 'z') || ('A' <= *s && *s <= 'Z')
  273.                 || *s == '_' || ('0' <= *s && *s <= '9')) {
  274.             s++;
  275.         }

  277.         tok->size = s - tok->str;
  278.         P->next = s;
  279.         goto end;
  280.     } else {
  281.         cp_error("invalid character %d", P->line);
  282.     }

  284. end:
  285.     return 1;
  286. }

  288. ‌static void require_token(struct parser *P, struct token *tok)
  289. {
  290.     if (!next_token(P, tok)) {
  291.         cp_error("unexpected end");
  292.     }
  293. }

  295. ‌static void check_token(struct parser *P, int type, const char *str,
  296.                 const char *err, ...)
  297. {
  298.     va_list ap;
  299.     struct token tok;
  300.     if (!next_token(P, &tok) || tok.type != type
  301.             || (tok.type == TOK_TOKEN && (tok.size != strlen(str)
  302.                 || memcmp(tok.str, str, tok.size) != 0))) {

  304.         va_start(ap, err);
  305.         vfprintf(stderr, err, ap);
  306.         va_end(ap);

  308.         exit(EXIT_FAILURE);
  309.     }
  310. }

  312. ‌static void put_back(struct parser *P) {
  313.     P->next = P->prev;
  314. }

  316. int64_t calculate_constant(struct parser *P);

  318. /* parses out the base type of a type expression in a function declaration,
  319. * struct definition, typedef etc
  320. *
  321. * leaves the usr value of the type on the stack
  322. */
  323. ‌int parse_type(struct parser *P, struct cp_ctype *ct)
  324. {
  325.     struct token tok;

  327.     memset(ct, 0, sizeof(*ct));

  329.     require_token(P, &tok);

  331.     /* get function attributes before the return type */
  332.     while (parse_attribute(P, &tok, ct, NULL)) {
  333.         require_token(P, &tok);
  334.     }

  336.     /* get const/volatile before the base type */
  337.     for (;;) {
  338.         if (tok.type != TOK_TOKEN) {
  339.             cp_error("unexpected value before type name on line %d",
  340.                     P->line);
  341.             return 0;
  342.         } else if (IS_CONST(tok)) {
  343.             ct->const_mask = 1;
  344.             require_token(P, &tok);
  345.         } else if (IS_VOLATILE(tok) || IS_RESTRICT(tok)) {
  346.             /* ignored for now */
  347.             require_token(P, &tok);
  348.         } else {
  349.             break;
  350.         }
  351.     }

  353.     /* get base type */
  354.     if (tok.type != TOK_TOKEN) {
  355.         cp_error("unexpected value before type name on line %d", P->line);
  356.         return 0;
  357.     } else if (IS_LITERAL(tok, "struct")) {
  358.         ct->type = STRUCT_TYPE;
  359.         parse_record(P, ct);
  360.     } else if (IS_LITERAL(tok, "union")) {
  361.         ct->type = UNION_TYPE;
  362.         parse_record(P, ct);
  363.     } else if (IS_LITERAL(tok, "enum")) {
  364.         ct->type = ENUM_TYPE;
  365.         parse_record(P, ct);
  366.     } else {
  367.         put_back(P);

  369.         /* lookup type */
  370.         struct cp_ctype *lct;
  371.         char cur_type_name[MAX_TYPE_NAME_LEN];

  373.         memset(cur_type_name, 0, MAX_TYPE_NAME_LEN);
  374.         parse_type_name(P, cur_type_name);
  375.         lct = ctype_lookup_type(cur_type_name);
  376.         if (!lct)
  377.             cp_error("unknow type: \"%s\"\n", cur_type_name);

  379.         instantiate_typedef(P, ct, lct);
  380.     }

  382.     while (next_token(P, &tok)) {
  383.         if (tok.type != TOK_TOKEN) {
  384.             put_back(P);
  385.             break;
  386.         } else if (IS_CONST(tok) || IS_VOLATILE(tok)) {
  387.             /* ignore for now */
  388.         } else {
  389.             put_back(P);
  390.             break;
  391.         }
  392.     }

  394.     return 0;
  395. }

  397. ‌enum test {TEST};

  399. /* Parses an enum definition from after the open curly through to the close
  400. * curly. Expects the user table to be on the top of the stack
  401. */
  402. ‌static int parse_enum(struct parser *P, struct cp_ctype *type)
  403. {
  404.     struct token tok;
  405.     int value = -1;

  407.     /*@TODO clean up this function when enum support is added*/
  408.     cp_error("TODO: enum not supported!\n");

  410.     for (;;) {
  411.         require_token(P, &tok);

  413.         if (tok.type == TOK_CLOSE_CURLY) {
  414.             break;
  415.         } else if (tok.type != TOK_TOKEN) {
  416.             cp_error("unexpected token in enum at line %d", P->line);
  417.             return 0;
  418.         }
  419.         require_token(P, &tok);

  421.         if (tok.type == TOK_COMMA || tok.type == TOK_CLOSE_CURLY) {
  422.             /* we have an auto calculated enum value */
  423.             value++;
  424.         } else if (tok.type == TOK_ASSIGN) {
  425.             /* we have an explicit enum value */
  426.             value = (int) calculate_constant(P);
  427.             require_token(P, &tok);
  428.         } else {
  429.             cp_error("unexpected token in enum at line %d", P->line);
  430.             return 0;
  431.         }

  433.         if (tok.type == TOK_CLOSE_CURLY) {
  434.             break;
  435.         } else if (tok.type != TOK_COMMA) {
  436.             cp_error("unexpected token in enum at line %d", P->line);
  437.             return 0;
  438.         }
  439.     }

  441.     type->base_size = sizeof(enum test);
  442.     type->align_mask = sizeof(enum test) - 1;

  444.     return 0;
  445. }

  447. /* Parses a struct from after the open curly through to the close curly. */
  448. ‌static int parse_struct(struct parser *P, const struct cp_ctype *ct)
  449. {
  450.     struct token tok;

  452.     /* parse members */
  453.     for (;;) {
  454.         struct cp_ctype mbase;

  456.         /* see if we're at the end of the struct */
  457.         require_token(P, &tok);
  458.         if (tok.type == TOK_CLOSE_CURLY) {
  459.             break;
  460.         } else if (ct->is_variable_struct) {
  461.             cp_error("can't have members after a variable sized "
  462.                     "member on line %d", P->line);
  463.             return -1;
  464.         } else {
  465.             put_back(P);
  466.         }

  468.         /* members are of the form
  469.          * <base type> <arg>, <arg>, <arg>;
  470.          * eg struct foo bar, *bar2[2];
  471.          * mbase is 'struct foo'
  472.          * mtype is '' then '*[2]'
  473.          * mname is 'bar' then 'bar2'
  474.          */

  476.         parse_type(P, &mbase);

  478.         for (;;) {
  479.             struct token mname;
  480.             struct cp_ctype mt = mbase;

  482.             memset(&mname, 0, sizeof(mname));

  484.             if (ct->is_variable_struct) {
  485.                 cp_error("can't have members after a variable "
  486.                     "sized member on line %d", P->line);
  487.                 return -1;
  488.             }

  490.             parse_argument(P, &mt, &mname, NULL);

  492.             if (!mt.is_defined && (mt.pointers - mt.is_array) == 0) {
  493.                 cp_error("member type is undefined on line %d",
  494.                         P->line);
  495.                 return -1;
  496.             }

  498.             if (mt.type == VOID_TYPE
  499.                     && (mt.pointers - mt.is_array) == 0) {
  500.                 cp_error("member type can not be void on line %d",
  501.                         P->line);
  502.                 return -1;
  503.             }

  505.             mt.has_member_name = (mname.size > 0);
  506.             if (mt.has_member_name) {
  507.                 cp_push_ctype_with_name(&mt,
  508.                         mname.str, mname.size);
  509.             } else {
  510.                 cp_push_ctype(&mt);
  511.             }

  513.             require_token(P, &tok);
  514.             if (tok.type == TOK_SEMICOLON) {
  515.                 break;
  516.             } else if (tok.type != TOK_COMMA) {
  517.                 cp_error("unexpected token in struct "
  518.                     "definition on line %d", P->line);
  519.             }
  520.         }
  521.     }

  523.     return 0;
  524. }

  526. /* copy over attributes that could be specified before the typedef eg
  527. * __attribute__(packed) const type_t */
  528. ‌static void instantiate_typedef(struct parser *P, struct cp_ctype *tt,
  529.         const struct cp_ctype *ft)
  530. {
  531.     struct cp_ctype pt = *tt;
  532.     *tt = *ft;

  534.     tt->const_mask |= pt.const_mask;
  535.     tt->is_packed = pt.is_packed;

  537.     if (tt->is_packed) {
  538.         tt->align_mask = 0;
  539.     } else {
  540.         /* Instantiate the typedef in the current packing. This may be
  541.          * further updated if a pointer is added or another alignment
  542.          * attribute is applied. If pt.align_mask is already non-zero
  543.          * than an increased alignment via __declspec(aligned(#)) has
  544.          * been set. */
  545.         tt->align_mask = max(min(P->align_mask, tt->align_mask),
  546.                     pt.align_mask);
  547.     }
  548. }

  550. /* this parses a struct or union starting with the optional
  551. * name before the opening brace
  552. * leaves the type usr value on the stack */
  553. ‌static int parse_record(struct parser *P, struct cp_ctype *ct)
  554. {
  555.     struct token tok;
  556.     char cur_type_name[MAX_TYPE_NAME_LEN];
  557.     int has_name;

  559.     require_token(P, &tok);

  561.     /* name is optional */
  562.     memset(cur_type_name, 0, MAX_TYPE_NAME_LEN);
  563.     if (tok.type == TOK_TOKEN) {
  564.         /* declaration */
  565.         struct cp_ctype *lct;

  567.         set_type_name(cur_type_name, ct->type, tok.str, tok.size);

  569.         /* lookup the name to see if we've seen this type before */
  570.         lct = ctype_lookup_type(cur_type_name);

  572.         if (!lct) {
  573.             /* new type, delay type registration to the end
  574.              * of this function */
  575.             ct->ffi_base_cs_id = ct->ffi_cs_id = -1;
  576.         } else {
  577.             /* get the exsting declared type */
  578.             if (lct->type != ct->type) {
  579.                 cp_error("type '%s' previously declared as '%s'",
  580.                     cur_type_name,
  581.                     csym_name(ct_ffi_cs(lct)));
  582.             }

  584.             instantiate_typedef(P, ct, lct);
  585.         }

  587.         /* if a name is given then we may be at the end of the string
  588.          * eg for ffi.new('struct foo') */
  589.         if (!next_token(P, &tok)) {
  590.             return 0;
  591.         }
  592.         has_name = 1;
  593.     } else {
  594.         char anon_name[MAX_TYPE_NAME_LEN];
  595.         /* create a new unnamed record */
  596.         sprintf(anon_name, "%d line", P->line);
  597.         set_type_name(cur_type_name, ct->type,
  598.                 anon_name, strlen(anon_name));
  599.         ct->ffi_base_cs_id = ct->ffi_cs_id = -1;
  600.         has_name = 0;
  601.     }

  603.     if (tok.type != TOK_OPEN_CURLY) {
  604.         /* this may just be a declaration or use of the type as an
  605.          * argument or member */
  606.         put_back(P);
  607.         if (!has_name)
  608.             cp_error("noname record type declaration\n");

  610.         /* build symbol for vm */
  611.         ct->ffi_base_cs_id =
  612.             cp_symbol_build_fake_record(cur_type_name, ct->type);
  613.         ct->ffi_cs_id = ct->ffi_base_cs_id;
  614.         return 0;
  615.     }

  617.     if (ct->is_defined) {
  618.         cp_error("redefinition in line %d", P->line);
  619.         return 0;
  620.     }

  622.     if (ct->type == ENUM_TYPE) {
  623.         parse_enum(P, ct);
  624.         cp_set_defined(ct);
  625.     } else {
  626.         int start_top = ctype_stack_top();
  627.         /* we do a two stage parse, where we parse the content first
  628.          * and build up the temp user table. We then iterate over that
  629.          * to calculate the offsets and fill out ct_usr. This is so we
  630.          * can handle out of order members (eg vtable) and attributes
  631.          * specified at the end of the struct. */
  632.         parse_struct(P, ct);
  633.         cp_set_defined(ct);
  634.         /* build symbol for vm */
  635.         ct->ffi_base_cs_id = cp_symbol_build_record(
  636.                 cur_type_name, ct->type, start_top);
  637.         ct->ffi_cs_id = ct->ffi_base_cs_id;
  638.         /* save cp_ctype for parser */
  639.         cp_ctype_reg_type(cur_type_name, ct);
  640.     }

  642.     return 0;
  643. }

  645. /* parses single or multi work built in types, and pushes it onto the stack */
  646. ‌static int parse_type_name(struct parser *P, char *type_name)
  647. {
  648.     struct token tok;
  649.     int flags = 0;

  651.     enum {
  652.         UNSIGNED = 0x01,
  653.         SIGNED = 0x02,
  654.         LONG = 0x04,
  655.         SHORT = 0x08,
  656.         INT = 0x10,
  657.         CHAR = 0x20,
  658.         LONG_LONG = 0x40,
  659.         INT8 = 0x80,
  660.         INT16 = 0x100,
  661.         INT32 = 0x200,
  662.         INT64 = 0x400,
  663.     };

  665.     require_token(P, &tok);

  667.     /* we have to manually decode the builtin types since they can take up
  668.      * more then one token */
  669.     for (;;) {
  670.         if (tok.type != TOK_TOKEN) {
  671.             break;
  672.         } else if (IS_LITERAL(tok, "unsigned")) {
  673.             flags |= UNSIGNED;
  674.         } else if (IS_LITERAL(tok, "signed")) {
  675.             flags |= SIGNED;
  676.         } else if (IS_LITERAL(tok, "short")) {
  677.             flags |= SHORT;
  678.         } else if (IS_LITERAL(tok, "char")) {
  679.             flags |= CHAR;
  680.         } else if (IS_LITERAL(tok, "long")) {
  681.             flags |= (flags & LONG) ? LONG_LONG : LONG;
  682.         } else if (IS_LITERAL(tok, "int")) {
  683.             flags |= INT;
  684.         } else if (IS_LITERAL(tok, "__int8")) {
  685.             flags |= INT8;
  686.         } else if (IS_LITERAL(tok, "__int16")) {
  687.             flags |= INT16;
  688.         } else if (IS_LITERAL(tok, "__int32")) {
  689.             flags |= INT32;
  690.         } else if (IS_LITERAL(tok, "__int64")) {
  691.             flags |= INT64;
  692.         } else if (IS_LITERAL(tok, "register")) {
  693.             /* ignore */
  694.         } else {
  695.             break;
  696.         }

  698.         if (!next_token(P, &tok)) {
  699.             break;
  700.         }
  701.     }

  703.     if (flags) {
  704.         put_back(P);
  705.     }

  707.     if (flags & CHAR) {
  708.         if (flags & SIGNED) {
  709.             strcpy(type_name, "int8_t");
  710.         } else if (flags & UNSIGNED) {
  711.             strcpy(type_name, "uint8_t");
  712.         } else {
  713.             if (((char) -1) > 0) {
  714.                 strcpy(type_name, "uint8_t");
  715.             } else {
  716.                 strcpy(type_name, "int8_t");
  717.             }
  718.         }
  719.     } else if (flags & INT8) {
  720.         strcpy(type_name, (flags & UNSIGNED) ? "uint8_t" : "int8_t");
  721.     } else if (flags & INT16) {
  722.         strcpy(type_name, (flags & UNSIGNED) ? "uint16_t" : "int16_t");
  723.     } else if (flags & INT32) {
  724.         strcpy(type_name, (flags & UNSIGNED) ? "uint32_t" : "int32_t");
  725.     } else if (flags & INT64) {
  726.         strcpy(type_name, (flags & UNSIGNED) ? "uint64_t" : "int64_t");
  727.     } else if (flags & LONG_LONG) {
  728.         strcpy(type_name, (flags & UNSIGNED) ? "uint64_t" : "int64_t");
  729.     } else if (flags & SHORT) {
  730. ‌#define SHORT_TYPE(u) (sizeof(short) == sizeof(int64_t) ? \
  731.         u "int64_t" : sizeof(short) == sizeof(int32_t) ? \
  732.         u "int32_t" : u "int16_t")
  733.         if (flags & UNSIGNED) {
  734.             strcpy(type_name, SHORT_TYPE("u"));
  735.         } else {
  736.             strcpy(type_name, SHORT_TYPE(""));
  737.         }
  738. ‌#undef SHORT_TYPE
  739.     } else if (flags & LONG) {
  740. ‌#define LONG_TYPE(u) (sizeof(long) == sizeof(int64_t) ? \
  741.         u "int64_t" : u "int32_t")
  742.         if (flags & UNSIGNED) {
  743.             strcpy(type_name, LONG_TYPE("u"));
  744.         } else {
  745.             strcpy(type_name, LONG_TYPE(""));
  746.         }
  747. ‌#undef LONG_TYPE
  748.     } else if (flags) {
  749. ‌#define INT_TYPE(u) (sizeof(int) == sizeof(int64_t) ? \
  750.         u "int64_t" : sizeof(int) == sizeof(int32_t) ? \
  751.         u "int32_t" : u "int16_t")
  752.         if (flags & UNSIGNED) {
  753.             strcpy(type_name, INT_TYPE("u"));
  754.         } else {
  755.             strcpy(type_name, INT_TYPE(""));
  756.         }
  757. ‌#undef INT_TYPE
  758.     } else {
  759.         strncpy(type_name, tok.str, tok.size);
  760.     }

  762.     return 0;
  763. }

  765. /* parse_attribute parses a token to see if it is an attribute. It may then
  766. * parse some following tokens to decode the attribute setting the appropriate
  767. * fields in ct. It will return 1 if the token was used (and possibly some
  768. * more following it) or 0 if not. If the token was used, the next token must
  769. * be retrieved using next_token/require_token. */
  770. ‌static int parse_attribute(struct parser *P, struct token *tok,
  771.         struct cp_ctype *ct, struct parser *asmname)
  772. {
  773.     if (tok->type != TOK_TOKEN) {
  774.         return 0;
  775.     } else if (asmname && (IS_LITERAL(*tok, "__asm__")
  776.                 || IS_LITERAL(*tok, "__asm"))) {
  777.         check_token(P, TOK_OPEN_PAREN, NULL,
  778.                 "unexpected token after __asm__ on line %d",
  779.                 P->line);
  780.         *asmname = *P;

  782.         require_token(P, tok);
  783.         while (tok->type == TOK_STRING) {
  784.             require_token(P, tok);
  785.         }

  787.         if (tok->type != TOK_CLOSE_PAREN) {
  788.             cp_error("unexpected token after __asm__ on line %d",
  789.                     P->line);
  790.         }
  791.         return 1;

  793.     } else if (IS_LITERAL(*tok, "__attribute__")
  794.             || IS_LITERAL(*tok, "__declspec")) {
  795.         int parens = 1;
  796.         check_token(P, TOK_OPEN_PAREN, NULL,
  797.                 "expected parenthesis after __attribute__ or "
  798.                 "__declspec on line %d", P->line);

  800.         for (;;) {
  801.             require_token(P, tok);
  802.             if (tok->type == TOK_OPEN_PAREN) {
  803.                 parens++;
  804.             } else if (tok->type == TOK_CLOSE_PAREN) {
  805.                 if (--parens == 0) {
  806.                     break;
  807.                 }

  809.             } else if (tok->type != TOK_TOKEN) {
  810.                 /* ignore unknown symbols within parentheses */

  812.             } else if (IS_LITERAL(*tok, "align") ||
  813.                     IS_LITERAL(*tok, "aligned") ||
  814.                     IS_LITERAL(*tok, "__aligned__")) {
  815.                 unsigned align = 0;
  816.                 require_token(P, tok);

  818.                 switch (tok->type) {
  819.                 case TOK_CLOSE_PAREN:
  820.                     align = ALIGNED_DEFAULT;
  821.                     put_back(P);
  822.                     break;

  824.                 case TOK_OPEN_PAREN:
  825.                     require_token(P, tok);

  827.                     if (tok->type != TOK_NUMBER) {
  828.                         cp_error("expected align(#) "
  829.                             "on line %d", P->line);
  830.                     }

  832.                     switch (tok->integer) {
  833.                     case 1: align = 0; break;
  834.                     case 2: align = 1; break;
  835.                     case 4: align = 3; break;
  836.                     case 8: align = 7; break;
  837.                     case 16: align = 15; break;
  838.                     default:
  839.                         cp_error("unsupported align "
  840.                             "size on line %d",
  841.                             P->line);
  842.                     }

  844.                     check_token(P, TOK_CLOSE_PAREN, NULL,
  845.                         "expected align(#) on line %d",
  846.                         P->line);
  847.                     break;

  849.                 default:
  850.                     cp_error("expected align(#) on line %d",
  851.                             P->line);
  852.                 }

  854.                 /* __attribute__(aligned(#)) is only supposed
  855.                  * to increase alignment */
  856.                 ct->align_mask = max(align, ct->align_mask);

  858.             } else if (IS_LITERAL(*tok, "packed")
  859.                     || IS_LITERAL(*tok, "__packed__")) {
  860.                 ct->align_mask = 0;
  861.                 ct->is_packed = 1;

  863.             } else if (IS_LITERAL(*tok, "mode")
  864.                     || IS_LITERAL(*tok, "__mode__")) {

  866.                 check_token(P, TOK_OPEN_PAREN, NULL,
  867.                     "expected mode(MODE) on line %d",
  868.                     P->line);

  870.                 require_token(P, tok);
  871.                 if (tok->type != TOK_TOKEN) {
  872.                     cp_error("expected mode(MODE) on line %d",
  873.                             P->line);
  874.                 }


  877.                 struct {char ch; uint16_t v;} a16;
  878.                 struct {char ch; uint32_t v;} a32;
  879.                 struct {char ch; uint64_t v;} a64;

  881.                 if (IS_LITERAL(*tok, "QI")
  882.                         || IS_LITERAL(*tok, "__QI__")
  883.                         || IS_LITERAL(*tok, "byte")
  884.                         || IS_LITERAL(*tok, "__byte__")
  885.                    ) {
  886.                     ct->type = INT8_TYPE;
  887.                     ct->base_size = sizeof(uint8_t);
  888.                     ct->align_mask = 0;

  890.                 } else if (IS_LITERAL(*tok, "HI")
  891.                         || IS_LITERAL(*tok, "__HI__")) {
  892.                     ct->type = INT16_TYPE;
  893.                     ct->base_size = sizeof(uint16_t);
  894.                     ct->align_mask = ALIGNOF(a16);

  896.                 } else if (IS_LITERAL(*tok, "SI")
  897.                         || IS_LITERAL(*tok, "__SI__")
  898. #if defined ARCH_X86 || defined ARCH_ARM
  899.                         || IS_LITERAL(*tok, "word")
  900.                         || IS_LITERAL(*tok, "__word__")
  901.                         || IS_LITERAL(*tok, "pointer")
  902.                         || IS_LITERAL(*tok, "__pointer__")
  903. #endif
  904.                       ) {
  905.                     ct->type = INT32_TYPE;
  906.                     ct->base_size = sizeof(uint32_t);
  907.                     ct->align_mask = ALIGNOF(a32);

  909.                 } else if (IS_LITERAL(*tok, "DI")
  910.                         || IS_LITERAL(*tok, "__DI__")
  911. #if defined ARCH_X64
  912.                         || IS_LITERAL(*tok, "word")
  913.                         || IS_LITERAL(*tok, "__word__")
  914.                         || IS_LITERAL(*tok, "pointer")
  915.                         || IS_LITERAL(*tok, "__pointer__")
  916. #endif
  917.                       ) {
  918.                     ct->type = INT64_TYPE;
  919.                     ct->base_size = sizeof(uint64_t);
  920.                     ct->align_mask = ALIGNOF(a64);

  922.                 } else {
  923.                     cp_error("unexpected mode on line %d",
  924.                             P->line);
  925.                 }

  927.                 check_token(P, TOK_CLOSE_PAREN, NULL,
  928.                     "expected mode(MODE) on line %d", P->line);

  930.             } else if (IS_LITERAL(*tok, "cdecl")
  931.                     || IS_LITERAL(*tok, "__cdecl__")) {
  932.                 ct->calling_convention = C_CALL;

  934.             } else if (IS_LITERAL(*tok, "fastcall")
  935.                     || IS_LITERAL(*tok, "__fastcall__")) {
  936.                 ct->calling_convention = FAST_CALL;

  938.             } else if (IS_LITERAL(*tok, "stdcall")
  939.                     || IS_LITERAL(*tok, "__stdcall__")) {
  940.                 ct->calling_convention = STD_CALL;
  941.             }
  942.             /* ignore unknown tokens within parentheses */
  943.         }
  944.         return 1;

  946.     } else if (IS_LITERAL(*tok, "__cdecl")) {
  947.         ct->calling_convention = C_CALL;
  948.         return 1;

  950.     } else if (IS_LITERAL(*tok, "__fastcall")) {
  951.         ct->calling_convention = FAST_CALL;
  952.         return 1;

  954.     } else if (IS_LITERAL(*tok, "__stdcall")) {
  955.         ct->calling_convention = STD_CALL;
  956.         return 1;

  958.     } else if (IS_LITERAL(*tok, "__extension__")
  959.             || IS_LITERAL(*tok, "extern")) {
  960.         /* ignore */
  961.         return 1;
  962.     } else {
  963.         return 0;
  964.     }
  965. }

  967. /* parses from after the opening paranthesis to after the closing parenthesis */
  968. ‌static void parse_function_arguments(struct parser* P, struct cp_ctype* ct)
  969. {
  970.     struct token tok;
  971.     int args = 0;

  973.     for (;;) {
  974.         require_token(P, &tok);

  976.         if (tok.type == TOK_CLOSE_PAREN)
  977.             break;

  979.         if (args) {
  980.             if (tok.type != TOK_COMMA) {
  981.                 cp_error("unexpected token in function "
  982.                         "argument %d on line %d",
  983.                         args, P->line);
  984.             }
  985.             require_token(P, &tok);
  986.         }

  988.         if (tok.type == TOK_VA_ARG) {
  989.             ct->has_var_arg = true;
  990.             check_token(P, TOK_CLOSE_PAREN, "",
  991.                     "unexpected token after ... in "
  992.                     "function on line %d",
  993.                     P->line);
  994.             break;
  995.         } else if (tok.type == TOK_TOKEN) {
  996.             struct cp_ctype at;

  998.             put_back(P);
  999.             parse_type(P, &at);
  1000.             parse_argument(P, &at, NULL, NULL);

  1002.             /* array arguments are just treated as their
  1003.              * base pointer type */
  1004.             at.is_array = 0;

  1006.             /* check for the c style int func(void) and error
  1007.              * on other uses of arguments of type void */
  1008.             if (at.type == VOID_TYPE && at.pointers == 0) {
  1009.                 if (args) {
  1010.                     cp_error("can't have argument of type "
  1011.                             "void on line %d",
  1012.                             P->line);
  1013.                 }

  1015.                 check_token(P, TOK_CLOSE_PAREN, "",
  1016.                     "unexpected void in function on line %d",
  1017.                     P->line);
  1018.                 break;
  1019.             }
  1020.             cp_push_ctype(&at);
  1021.             args++;
  1022.         } else {
  1023.             cp_error("unexpected token in function argument %d "
  1024.                     "on line %d", args+1, P->line);
  1025.         }
  1026.     }
  1027. }

  1029. ‌static int max_bitfield_size(int type)
  1030. {
  1031.     switch (type) {
  1032.     case BOOL_TYPE:
  1033.         return 1;
  1034.     case INT8_TYPE:
  1035.         return 8;
  1036.     case INT16_TYPE:
  1037.         return 16;
  1038.     case INT32_TYPE:
  1039.     case ENUM_TYPE:
  1040.         return 32;
  1041.     case INT64_TYPE:
  1042.         return 64;
  1043.     default:
  1044.         return -1;
  1045.     }
  1046. }

  1048. static struct cp_ctype *parse_argument2(struct parser *P, struct cp_ctype *ct,
  1049.         struct token *name, struct parser *asmname);

  1051. /* parses from after the first ( in a function declaration or function pointer
  1052. * can be one of:
  1053. * void foo(...) before ...
  1054. * void (foo)(...) before foo
  1055. * void (* <>)(...) before <> which is the inner type */
  1056. ‌static struct cp_ctype *parse_function(struct parser *P, struct cp_ctype *ct,
  1057.                 struct token *name, struct parser *asmname)
  1058. {
  1059.     /* We have a function pointer or a function. The usr table will
  1060.      * get replaced by the canonical one (if there is one) in
  1061.      * find_canonical_usr after all the arguments and returns have
  1062.      * been parsed. */
  1063.     struct token tok;
  1064.     struct cp_ctype *ret = ct;

  1066.     cp_push_ctype(ct);

  1068.     memset(ct, 0, sizeof(*ct));
  1069.     ct->base_size = sizeof(void (*)());
  1070.     ct->align_mask = min(FUNCTION_ALIGN_MASK, P->align_mask);
  1071.     ct->type = FUNCTION_TYPE;
  1072.     ct->is_defined = 1;

  1074.     if (name->type == TOK_NIL) {
  1075.         for (;;) {
  1076.             require_token(P, &tok);

  1078.             if (tok.type == TOK_STAR) {
  1079.                 if (ct->type == FUNCTION_TYPE) {
  1080.                     ct->type = FUNCTION_PTR_TYPE;
  1081.                 } else {
  1082.                     increase_ptr_deref_level(P, ct);
  1083.                 }
  1084.             } else if (parse_attribute(P, &tok, ct, asmname)) {
  1085.                 /* parse_attribute sets the appropriate fields */
  1086.             } else {
  1087.                 /* call parse_argument to handle the inner
  1088.                  * contents e.g. the <> in "void (* <>)
  1089.                  * (...)". Note that the inner contents can
  1090.                  * itself be a function, a function ptr,
  1091.                  * array, etc (e.g. "void (*signal(int sig,
  1092.                  * void (*func)(int)))(int)" ). */
  1093.                 cp_error("TODO: inner function not supported for now.");
  1094.                 put_back(P);
  1095.                 ct = parse_argument2(P, ct, name, asmname);
  1096.                 break;
  1097.             }
  1098.         }

  1100.         check_token(P, TOK_CLOSE_PAREN, NULL,
  1101.             "unexpected token in function on line %d", P->line);
  1102.         check_token(P, TOK_OPEN_PAREN, NULL,
  1103.             "unexpected token in function on line %d", P->line);
  1104.     }

  1106.     parse_function_arguments(P, ct);

  1108.     /*@TODO support for inner function  24.11 2013 (houqp)*/
  1109.     /* if we have an inner function then set the outer function ptr as its
  1110.      * return type and return the inner function
  1111.      * e.g. for void (* <signal(int, void (*)(int))> )(int) inner is
  1112.      * surrounded by <>, return type is void (*)(int) */

  1114.     return ret;
  1115. }

  1117. ‌static struct cp_ctype *parse_argument2(struct parser *P, struct cp_ctype *ct,
  1118.                 struct token *name, struct parser *asmname)
  1119. {
  1120.     struct token tok;

  1122.     for (;;) {
  1123.         if (!next_token(P, &tok)) {
  1124.             /* we've reached the end of the string */
  1125.             break;
  1126.         } else if (tok.type == TOK_STAR) {
  1127.             increase_ptr_deref_level(P, ct);

  1129.             /* __declspec(align(#)) may come before the type in a
  1130.              * member */
  1131.             if (!ct->is_packed) {
  1132.                 ct->align_mask = max(min(PTR_ALIGN_MASK, P->align_mask),
  1133.                             ct->align_mask);
  1134.             }
  1135.         } else if (tok.type == TOK_REFERENCE) {
  1136.             cp_error("NYI: c++ reference types");
  1137.             return 0;
  1138.         } else if (parse_attribute(P, &tok, ct, asmname)) {
  1139.             /* parse attribute has filled out appropriate fields in type */

  1141.         } else if (tok.type == TOK_OPEN_PAREN) {
  1142.             ct = parse_function(P, ct, name, asmname);
  1143.         } else if (tok.type == TOK_OPEN_SQUARE) {
  1144.             /* array */
  1145.             if (ct->pointers == POINTER_MAX) {
  1146.                 cp_error("maximum number of pointer derefs "
  1147.                     "reached - use a struct to break up "
  1148.                     "the pointers");
  1149.             }
  1150.             ct->is_array = 1;
  1151.             ct->pointers++;
  1152.             ct->const_mask <<= 1;
  1153.             require_token(P, &tok);

  1155.             if (ct->pointers == 1 && !ct->is_defined) {
  1156.                 cp_error("array of undefined type on line %d",
  1157.                         P->line);
  1158.             }

  1160.             if (ct->is_variable_struct || ct->is_variable_array) {
  1161.                 cp_error("can't have an array of a variably "
  1162.                     "sized type on line %d", P->line);
  1163.             }

  1165.             if (tok.type == TOK_QUESTION) {
  1166.                 ct->is_variable_array = 1;
  1167.                 ct->variable_increment = (ct->pointers > 1) ?
  1168.                         sizeof(void*) : ct->base_size;
  1169.                 check_token(P, TOK_CLOSE_SQUARE, "",
  1170.                     "invalid character in array on line %d",
  1171.                     P->line);

  1173.             } else if (tok.type == TOK_CLOSE_SQUARE) {
  1174.                 ct->array_size = 0;

  1176.             } else if (tok.type == TOK_TOKEN && IS_RESTRICT(tok)) {
  1177.                 /* odd gcc extension foo[__restrict] for arguments */
  1178.                 ct->array_size = 0;
  1179.                 check_token(P, TOK_CLOSE_SQUARE, "",
  1180.                     "invalid character in array on line %d",
  1181.                     P->line);
  1182.             } else {
  1183.                 int64_t asize;
  1184.                 put_back(P);
  1185.                 asize = calculate_constant(P);
  1186.                 if (asize < 0) {
  1187.                     cp_error("array size can not be "
  1188.                         "negative on line %d", P->line);
  1189.                     return 0;
  1190.                 }
  1191.                 ct->array_size = (size_t) asize;
  1192.                 check_token(P, TOK_CLOSE_SQUARE, "",
  1193.                     "invalid character in array on line %d",
  1194.                     P->line);
  1195.             }

  1197.         } else if (tok.type == TOK_COLON) {
  1198.             int64_t bsize = calculate_constant(P);

  1200.             if (ct->pointers || bsize < 0
  1201.                     || bsize > max_bitfield_size(ct->type)) {
  1202.                 cp_error("invalid bitfield on line %d", P->line);
  1203.             }

  1205.             ct->is_bitfield = 1;
  1206.             ct->bit_size = (unsigned) bsize;

  1208.         } else if (tok.type != TOK_TOKEN) {
  1209.             /* we've reached the end of the declaration */
  1210.             put_back(P);
  1211.             break;

  1213.         } else if (IS_CONST(tok)) {
  1214.             ct->const_mask |= 1;

  1216.         } else if (IS_VOLATILE(tok) || IS_RESTRICT(tok)) {
  1217.             /* ignored for now */

  1219.         } else {
  1220.             *name = tok;
  1221.         }
  1222.     }

  1224.     return ct;
  1225. }



  1229. /* parses after the main base type of a typedef, function argument or
  1230. * struct/union member
  1231. * eg for const void* bar[3] the base type is void with the subtype so far of
  1232. * const, this parses the "* bar[3]" and updates the type argument
  1233. *
  1234. * type must be as filled out by parse_type
  1235. *
  1236. * pushes the updated user value on the top of the stack
  1237. */
  1238. ‌void parse_argument(struct parser *P, struct cp_ctype *ct, struct token *pname,
  1239.             struct parser *asmname)
  1240. {
  1241.     struct token tok, name;

  1243.     memset(&name, 0, sizeof(name));
  1244.     parse_argument2(P, ct, &name, asmname);

  1246.     for (;;) {
  1247.         if (!next_token(P, &tok)) {
  1248.             break;
  1249.         } else if (parse_attribute(P, &tok, ct, asmname)) {
  1250.             /* parse_attribute sets the appropriate fields */
  1251.         } else {
  1252.             put_back(P);
  1253.             break;
  1254.         }
  1255.     }

  1257.     if (pname) {
  1258.         *pname = name;
  1259.     }
  1260. }

  1262. ‌static void parse_typedef(struct parser *P)
  1263. {
  1264.     struct token tok;
  1265.     struct cp_ctype base_type;
  1266.     char typedef_name[MAX_TYPE_NAME_LEN];

  1268.     parse_type(P, &base_type);

  1270.     for (;;) {
  1271.         struct cp_ctype arg_type = base_type;
  1272.         struct token name;

  1274.         memset(&name, 0, sizeof(name));

  1276.         parse_argument(P, &arg_type, &name, NULL);

  1278.         if (!name.size) {
  1279.             cp_error("Can't have a typedef without a name on line %d",
  1280.                     P->line);
  1281.         } else if (arg_type.is_variable_array) {
  1282.             cp_error("Can't typedef a variable length array on line %d",
  1283.                     P->line);
  1284.         }

  1286.         memset(typedef_name, 0, sizeof(typedef_name));
  1287.         strncpy(typedef_name, name.str, name.size);
  1288.         /* link typedef name with ctype for parser */
  1289.         cp_ctype_reg_type(typedef_name, &arg_type);

  1291.         require_token(P, &tok);

  1293.         if (tok.type == TOK_SEMICOLON) {
  1294.             break;
  1295.         } else if (tok.type != TOK_COMMA) {
  1296.             cp_error("Unexpected character in typedef on line %d",
  1297.                     P->line);
  1298.         }
  1299.     }
  1300. }

  1302. ‌#define END 0
  1303. ‌#define PRAGMA_POP 1

  1305. ‌static int parse_root(struct parser *P)
  1306. {
  1307.     struct token tok;

  1309.     while (next_token(P, &tok)) {
  1310.         /* we can have:
  1311.          * struct definition
  1312.          * enum definition
  1313.          * union definition
  1314.          * struct/enum/union declaration
  1315.          * typedef
  1316.          * function declaration
  1317.          * pragma pack
  1318.          */

  1320.         if (tok.type == TOK_SEMICOLON) {
  1321.             /* empty semicolon in root continue on */

  1323.         } else if (tok.type == TOK_POUND) {

  1325.             check_token(P, TOK_TOKEN, "pragma",
  1326.                 "unexpected pre processor directive on line %d",
  1327.                 P->line);
  1328.             check_token(P, TOK_TOKEN, "pack",
  1329.                 "unexpected pre processor directive on line %d",
  1330.                 P->line);
  1331.             check_token(P, TOK_OPEN_PAREN, "",
  1332.                 "invalid pack directive on line %d",
  1333.                 P->line);
  1334.             require_token(P, &tok);

  1336.             if (tok.type == TOK_NUMBER) {
  1337.                 if (tok.integer != 1 && tok.integer != 2
  1338.                         && tok.integer != 4
  1339.                         && tok.integer != 8
  1340.                         && tok.integer != 16) {
  1341.                     cp_error("pack directive with invalid "
  1342.                             "pack size on line %d",
  1343.                             P->line);
  1344.                     return 0;
  1345.                 }

  1347.                 P->align_mask = (unsigned) (tok.integer - 1);
  1348.                 check_token(P, TOK_CLOSE_PAREN, "",
  1349.                     "invalid pack directive on line %d",
  1350.                     P->line);
  1351.             } else if (tok.type == TOK_TOKEN && IS_LITERAL(tok, "push")) {
  1352.                 /*int line = P->line;*/
  1353.                 unsigned previous_alignment = P->align_mask;

  1355.                 check_token(P, TOK_CLOSE_PAREN, "",
  1356.                     "invalid pack directive on line %d",
  1357.                     P->line);

  1359.                 if (parse_root(P) != PRAGMA_POP) {
  1360.                     cp_error("reached end of string "
  1361.                         "without a pragma pop to "
  1362.                         "match the push on line %d",
  1363.                         P->line);
  1364.                     return 0;
  1365.                 }

  1367.                 P->align_mask = previous_alignment;

  1369.             } else if (tok.type == TOK_TOKEN && IS_LITERAL(tok, "pop")) {
  1370.                 check_token(P, TOK_CLOSE_PAREN, "",
  1371.                     "invalid pack directive on line %d",
  1372.                         P->line);
  1373.                 return PRAGMA_POP;
  1374.             } else {
  1375.                 cp_error("invalid pack directive on line %d",
  1376.                         P->line);
  1377.                 return 0;
  1378.             }
  1379.         } else if (tok.type != TOK_TOKEN) {
  1380.             cp_error("unexpected character on line %d", P->line);
  1381.             return 0;
  1382.         } else if (IS_LITERAL(tok, "__extension__")) {
  1383.             /* ignore */
  1384.             continue;
  1385.         } else if (IS_LITERAL(tok, "extern")) {
  1386.             /* ignore extern as data and functions can only be
  1387.              * extern */
  1388.             continue;
  1389.         } else if (IS_LITERAL(tok, "typedef")) {
  1390.             parse_typedef(P);
  1391.         } else if (IS_LITERAL(tok, "static")) {
  1392.             /*@TODO we haven't tested static so far */
  1393.             cp_error("TODO: support static keyword.\n");
  1394.         } else {
  1395.             /* type declaration, type definition, or function
  1396.              * declaration */
  1397.             struct cp_ctype type;
  1398.             struct token name;
  1399.             struct parser asmname;

  1401.             memset(&name, 0, sizeof(name));
  1402.             memset(&asmname, 0, sizeof(asmname));

  1404.             put_back(P);
  1405.             parse_type(P, &type);

  1407.             for (;;) {
  1408.                 parse_argument(P, &type, &name, &asmname);

  1410.                 if (name.size) {
  1411.                     /* global/function declaration */
  1412.                     cp_symbol_build_func(&type, name.str, name.size);
  1413.                     /* @TODO asmname is not used for now
  1414.                      * since we are not supporting __asm__
  1415.                      * as this point.
  1416.                      * might need to bind it with function
  1417.                      * name later. */
  1418.                 } else {
  1419.                     /* type declaration/definition -
  1420.                      * already been processed */
  1421.                 }
  1422.                 require_token(P, &tok);

  1424.                 if (tok.type == TOK_SEMICOLON) {
  1425.                     break;
  1426.                 } else if (tok.type != TOK_COMMA) {
  1427.                     cp_error("missing semicolon on line %d",
  1428.                             P->line);
  1429.                 }
  1430.             }
  1431.         }
  1432.     }

  1434.     return END;
  1435. }

  1437. static int64_t calculate_constant2(struct parser *P, struct token *tok);

  1439. /* () */
  1440. ‌static int64_t calculate_constant1(struct parser *P, struct token *tok)
  1441. {
  1442.     int64_t ret;

  1444.     if (tok->type == TOK_NUMBER) {
  1445.         ret = tok->integer;
  1446.         next_token(P, tok);
  1447.         return ret;

  1449.     } else if (tok->type == TOK_TOKEN) {
  1450.         /* look up name in constants table */
  1451.         cp_error("TODO: support name lookup in constant table\n");
  1452.         next_token(P, tok);
  1453.         return ret;

  1455.     } else if (tok->type == TOK_OPEN_PAREN) {
  1456.         struct parser before_cast = *P;
  1457.         cp_error("TODO: handle open parent token in constant1\n");
  1458.         *P = before_cast;
  1459.         ret = calculate_constant(P);

  1461.         require_token(P, tok);
  1462.         if (tok->type != TOK_CLOSE_PAREN) {
  1463.             cp_error("error whilst parsing constant at line %d",
  1464.                     P->line);
  1465.         }

  1467.         next_token(P, tok);
  1468.         return ret;
  1469.     } else {
  1470.         cp_error("unexpected token whilst parsing constant at line %d",
  1471.                 P->line);
  1472.         return 0;
  1473.     }
  1474. }

  1476. /* ! and ~, unary + and -, and sizeof */
  1477. ‌static int64_t calculate_constant2(struct parser *P, struct token *tok)
  1478. {
  1479.     if (tok->type == TOK_LOGICAL_NOT) {
  1480.         require_token(P, tok);
  1481.         return !calculate_constant2(P, tok);

  1483.     } else if (tok->type == TOK_BITWISE_NOT) {
  1484.         require_token(P, tok);
  1485.         return ~calculate_constant2(P, tok);

  1487.     } else if (tok->type == TOK_PLUS) {
  1488.         require_token(P, tok);
  1489.         return calculate_constant2(P, tok);

  1491.     } else if (tok->type == TOK_MINUS) {
  1492.         require_token(P, tok);
  1493.         return -calculate_constant2(P, tok);

  1495.     } else if (tok->type == TOK_TOKEN &&
  1496.             (IS_LITERAL(*tok, "sizeof")
  1497.              || IS_LITERAL(*tok, "alignof")
  1498.              || IS_LITERAL(*tok, "__alignof__")
  1499.              || IS_LITERAL(*tok, "__alignof"))) {
  1500.         cp_error("TODO: support sizeof\n");
  1501.         bool issize = IS_LITERAL(*tok, "sizeof");
  1502.         struct cp_ctype type;

  1504.         require_token(P, tok);
  1505.         if (tok->type != TOK_OPEN_PAREN) {
  1506.             cp_error("invalid sizeof at line %d", P->line);
  1507.         }

  1509.         parse_type(P, &type);
  1510.         parse_argument(P, &type, NULL, NULL);

  1512.         require_token(P, tok);
  1513.         if (tok->type != TOK_CLOSE_PAREN) {
  1514.             cp_error("invalid sizeof at line %d", P->line);
  1515.         }

  1517.         next_token(P, tok);

  1519.         return issize ? ctype_size(&type) : type.align_mask + 1;

  1521.     } else {
  1522.         return calculate_constant1(P, tok);
  1523.     }
  1524. }

  1526. /* binary * / and % (left associative) */
  1527. ‌static int64_t calculate_constant3(struct parser *P, struct token *tok)
  1528. {
  1529.     int64_t left = calculate_constant2(P, tok);

  1531.     for (;;) {
  1532.         if (tok->type == TOK_MULTIPLY) {
  1533.             require_token(P, tok);
  1534.             left *= calculate_constant2(P, tok);

  1536.         } else if (tok->type == TOK_DIVIDE) {
  1537.             require_token(P, tok);
  1538.             left /= calculate_constant2(P, tok);

  1540.         } else if (tok->type == TOK_MODULUS) {
  1541.             require_token(P, tok);
  1542.             left %= calculate_constant2(P, tok);

  1544.         } else {
  1545.             return left;
  1546.         }
  1547.     }
  1548. }

  1550. /* binary + and - (left associative) */
  1551. ‌static int64_t calculate_constant4(struct parser *P, struct token *tok)
  1552. {
  1553.     int64_t left = calculate_constant3(P, tok);

  1555.     for (;;) {
  1556.         if (tok->type == TOK_PLUS) {
  1557.             require_token(P, tok);
  1558.             left += calculate_constant3(P, tok);

  1560.         } else if (tok->type == TOK_MINUS) {
  1561.             require_token(P, tok);
  1562.             left -= calculate_constant3(P, tok);

  1564.         } else {
  1565.             return left;
  1566.         }
  1567.     }
  1568. }

  1570. /* binary << and >> (left associative) */
  1571. ‌static int64_t calculate_constant5(struct parser *P, struct token *tok)
  1572. {
  1573.     int64_t left = calculate_constant4(P, tok);

  1575.     for (;;) {
  1576.         if (tok->type == TOK_LEFT_SHIFT) {
  1577.             require_token(P, tok);
  1578.             left <<= calculate_constant4(P, tok);

  1580.         } else if (tok->type == TOK_RIGHT_SHIFT) {
  1581.             require_token(P, tok);
  1582.             left >>= calculate_constant4(P, tok);

  1584.         } else {
  1585.             return left;
  1586.         }
  1587.     }
  1588. }

  1590. /* binary <, <=, >, and >= (left associative) */
  1591. ‌static int64_t calculate_constant6(struct parser *P, struct token *tok)
  1592. {
  1593.     int64_t left = calculate_constant5(P, tok);

  1595.     for (;;) {
  1596.         if (tok->type == TOK_LESS) {
  1597.             require_token(P, tok);
  1598.             left = (left < calculate_constant5(P, tok));

  1600.         } else if (tok->type == TOK_LESS_EQUAL) {
  1601.             require_token(P, tok);
  1602.             left = (left <= calculate_constant5(P, tok));

  1604.         } else if (tok->type == TOK_GREATER) {
  1605.             require_token(P, tok);
  1606.             left = (left > calculate_constant5(P, tok));

  1608.         } else if (tok->type == TOK_GREATER_EQUAL) {
  1609.             require_token(P, tok);
  1610.             left = (left >= calculate_constant5(P, tok));

  1612.         } else {
  1613.             return left;
  1614.         }
  1615.     }
  1616. }

  1618. /* binary ==, != (left associative) */
  1619. ‌static int64_t calculate_constant7(struct parser *P, struct token *tok)
  1620. {
  1621.     int64_t left = calculate_constant6(P, tok);

  1623.     for (;;) {
  1624.         if (tok->type == TOK_EQUAL) {
  1625.             require_token(P, tok);
  1626.             left = (left == calculate_constant6(P, tok));

  1628.         } else if (tok->type == TOK_NOT_EQUAL) {
  1629.             require_token(P, tok);
  1630.             left = (left != calculate_constant6(P, tok));

  1632.         } else {
  1633.             return left;
  1634.         }
  1635.     }
  1636. }

  1638. /* binary & (left associative) */
  1639. ‌static int64_t calculate_constant8(struct parser *P, struct token *tok)
  1640. {
  1641.     int64_t left = calculate_constant7(P, tok);

  1643.     for (;;) {
  1644.         if (tok->type == TOK_BITWISE_AND) {
  1645.             require_token(P, tok);
  1646.             left = (left & calculate_constant7(P, tok));

  1648.         } else {
  1649.             return left;
  1650.         }
  1651.     }
  1652. }

  1654. /* binary ^ (left associative) */
  1655. ‌static int64_t calculate_constant9(struct parser *P, struct token *tok)
  1656. {
  1657.     int64_t left = calculate_constant8(P, tok);

  1659.     for (;;) {
  1660.         if (tok->type == TOK_BITWISE_XOR) {
  1661.             require_token(P, tok);
  1662.             left = (left ^ calculate_constant8(P, tok));

  1664.         } else {
  1665.             return left;
  1666.         }
  1667.     }
  1668. }

  1670. /* binary | (left associative) */
  1671. ‌static int64_t calculate_constant10(struct parser *P, struct token *tok)
  1672. {
  1673.     int64_t left = calculate_constant9(P, tok);

  1675.     for (;;) {
  1676.         if (tok->type == TOK_BITWISE_OR) {
  1677.             require_token(P, tok);
  1678.             left = (left | calculate_constant9(P, tok));

  1680.         } else {
  1681.             return left;
  1682.         }
  1683.     }
  1684. }

  1686. /* binary && (left associative) */
  1687. ‌static int64_t calculate_constant11(struct parser *P, struct token *tok)
  1688. {
  1689.     int64_t left = calculate_constant10(P, tok);

  1691.     for (;;) {
  1692.         if (tok->type == TOK_LOGICAL_AND) {
  1693.             require_token(P, tok);
  1694.             left = (left && calculate_constant10(P, tok));

  1696.         } else {
  1697.             return left;
  1698.         }
  1699.     }
  1700. }

  1702. /* binary || (left associative) */
  1703. ‌static int64_t calculate_constant12(struct parser *P, struct token *tok)
  1704. {
  1705.     int64_t left = calculate_constant11(P, tok);

  1707.     for (;;) {
  1708.         if (tok->type == TOK_LOGICAL_OR) {
  1709.             require_token(P, tok);
  1710.             left = (left || calculate_constant11(P, tok));

  1712.         } else {
  1713.             return left;
  1714.         }
  1715.     }
  1716. }

  1718. /* ternary ?: (right associative) */
  1719. ‌static int64_t calculate_constant13(struct parser *P, struct token *tok)
  1720. {
  1721.     int64_t left = calculate_constant12(P, tok);

  1723.     if (tok->type == TOK_QUESTION) {
  1724.         int64_t middle, right;
  1725.         require_token(P, tok);
  1726.         middle = calculate_constant13(P, tok);
  1727.         if (tok->type != TOK_COLON) {
  1728.             cp_error("invalid ternery (? :) in constant on line %d",
  1729.                     P->line);
  1730.         }
  1731.         require_token(P, tok);
  1732.         right = calculate_constant13(P, tok);
  1733.         return left ? middle : right;

  1735.     } else {
  1736.         return left;
  1737.     }
  1738. }

  1740. ‌int64_t calculate_constant(struct parser* P)
  1741. {
  1742.     struct token tok;
  1743.     int64_t ret;
  1744.     require_token(P, &tok);
  1745.     ret = calculate_constant13(P, &tok);

  1747.     if (tok.type != TOK_NIL) {
  1748.         put_back(P);
  1749.     }

  1751.     return ret;
  1752. }

  1754. ‌void cp_init_parser(struct parser *P, const char *s)
  1755. {
  1756.     memset(P, 0, sizeof(struct parser));
  1757.     P->line = 1;
  1758.     P->prev = P->next = s;
  1759.     P->align_mask = DEFAULT_ALIGN_MASK;
  1760. }

  1762. /* used for ffi.cdef */
  1763. ‌int ffi_parse_cdef(const char *s)
  1764. {
  1765.     struct parser P;

  1767.     cp_init_parser(&P, s);
  1768.     if (parse_root(&P) == PRAGMA_POP) {
  1769.         cp_error("pragma pop without an associated push on line %d",
  1770.                 P.line);
  1771.     }

  1773.     return 0;
  1774. }

  1776. /* used for ffi.new */
  1777. ‌void ffi_parse_new(const char *s, struct cp_ctype *ct)
  1778. {
  1779.     struct parser P;

  1781.     cp_init_parser(&P, s);
  1782.     parse_type(&P, ct);
  1783.     parse_argument(&P, ct, NULL, NULL);
  1784.     cp_update_csym_in_ctype(ct);
  1785. }

  1787. ‌int ffi_lookup_csymbol_id_by_name(const char *s)
  1788. {
  1789.     struct parser P;
  1790.     struct cp_ctype ct;

  1792.     cp_init_parser(&P, s);
  1793.     parse_type(&P, &ct);
  1794.     cp_update_csym_in_ctype(&ct);
  1795.     return ct.ffi_cs_id;
  1796. }

  1798. ‌void ffi_cparser_init(void)
  1799. {
  1800.     cp_ctype_init();
  1801. }

  1803. ‌void ffi_cparser_free(void)
  1804. {
  1805.     cp_ctype_free();
  1806. }

One Level Up Top Level