git.m6w6.name Git - m6w6/ext-psi/blob - idl/parser.re

   1 #include <stdio.h>
   2 #include <assert.h>
   3
   4 #include "parser.h"
   5
   6 PSI_Parser *PSI_ParserInit(PSI_Parser *P)
   7 {
   8         FILE *fp;
   9
  10         if (!P) {
  11                 P = malloc(sizeof(*P));
  12         }
  13         memset(P, 0, sizeof(*P));
  14
  15         fp = fopen(filename, "r");
  16
  17         if (!fp) {
  18                 perror(filename);
  19                 return NULL;
  20         }
  21
  22         if (!P) {
  23                 P = malloc(sizeof(*P));
  24         }
  25         memset(P, 0, sizeof(*P));
  26
  27         P->fp = fp;
  28         P->fn = strdup(filename);
  29         P->line = 1;
  30
  31         P->proc = PSI_ParserProcAlloc(malloc);
  32
  33         PSI_ParserFill(P, 0);
  34 }
  35
  36 size_t PSI_ParserFill(PSI_Parser *P, size_t n)
  37 {
  38         // printf("+ Fill: n=%zu\n", n);
  39         if (!n) {
  40                 P->cur = P->tok = P->lim = P->mrk = P->buf;
  41                 P->eof = NULL;
  42         }
  43
  44         if (!P->eof) {
  45                 size_t consumed = P->tok - P->buf;
  46                 size_t reserved = P->lim - P->tok;
  47                 size_t available = BSIZE - reserved;
  48                 size_t didread;
  49
  50                 if (consumed) {
  51                         memmove(P->buf, P->tok, reserved);
  52                         P->tok -= consumed;
  53                         P->cur -= consumed;
  54                         P->lim -= consumed;
  55                         P->mrk -= consumed;
  56                 }
  57
  58                 didread = fread(P->lim, 1, available, P->fp);
  59                 P->lim += didread;
  60                 if (didread < available) {
  61                         P->eof = P->lim;
  62                 }
  63
  64                 // printf("+ Fill: consumed=%zu reserved=%zu available=%zu didread=%zu\n",
  65                         // consumed, reserved, available, didread);
  66         }
  67         // printf("+ Fill: avail=%zu\n", P->lim - P->cur);
  68         return P->lim - P->cur;
  69 }
  70
  71 int PSI_ParserParse(PSI_Parser *P)
  72 {
  73         PSI_Token *T = NULL;
  74
  75         if (-1 == PSI_ParserScan(P)) {
  76                 PSI_ParserProc(P->proc, 0, NULL, P);
  77                 return 0;
  78         }
  79         if (!(T = PSI_TokenAlloc(P, t))) {
  80                 return 0;
  81         }
  82
  83         PSI_ParserProc(P->proc, P->num, T, P);
  84         return 1;
  85 }
  86
  87 void PSI_ParserDtor(PSI_Parser *P)
  88 {
  89         PSI_ParserProcFree(P->proc, free);
  90         if (P->fp) {
  91                 fclose(P->fp);
  92         }
  93         if (P->fn) {
  94                 free(P->fn);
  95         }
  96         if (P->lib) {
  97                 free(P->lib);
  98         }
  99         if (P->defs) {
 100                 free_decl_typedefs(P->defs);
 101         }
 102         if (P->decls) {
 103                 free_decls(P->decls);
 104         }
 105         if (P->impls) {
 106                 free_impls(P->impls);
 107         }
 108         memset(P, 0, sizeof(*P));
 109 }
 110
 111 void PSI_ParserFree(PSI_Parser **P)
 112 {
 113         if (*P) {
 114                 PSI_ParserDtor(*P);
 115                 free(*P);
 116                 *P = NULL;
 117         }
 118 }
 119
 120 /*!max:re2c*/
 121 #define BSIZE 256
 122
 123 #if BSIZE < YYMAXFILL
 124 # error BSIZE must be greater than YYMAXFILL
 125 #endif
 126
 127 #define RETURN(t) do { \
 128         P->num = t; \
 129         return t; \
 130 }
 131 token_t PSI_ParserScan(PSI_Parser *P)
 132 {
 133         for (;;) {
 134                 P->tok = P->cur;
 135                 /*!re2c
 136                 re2c:indent:top = 2;
 137                 re2c:define:YYCTYPE = "unsigned char";
 138                 re2c:define:YYCURSOR = P->cur;
 139                 re2c:define:YYLIMIT = P->lim;
 140                 re2c:define:YYMARKER = P->mrk;
 141                 re2c:define:YYFILL = "{ if (!fill(P,@@)) RETURN(-1); }";
 142                 re2c:yyfill:parameter = 0;
 143
 144                 B = [^a-zA-Z0-9_];
 145                 W = [a-zA-Z0-9_];
 146                 NAME = W+;
 147                 NSNAME = (NAME)? ("\\" NAME)+;
 148                 QUOTED_STRING = "\"" ([^\"])+ "\"";
 149                 NULL = 'NULL';
 150                 MIXED = 'mixed';
 151                 VOID = 'void';
 152                 BOOL = 'bool';
 153                 INT = 'int';
 154                 FLOAT = 'float';
 155                 DOUBLE = 'double';
 156                 SINT8 = 'sint8';
 157                 UINT8 = 'uint8';
 158                 SINT16 = 'sint16';
 159                 UINT16 = 'uint16';
 160                 SINT32 = 'sint32';
 161                 UINT32 = 'uint32';
 162                 SINT64 = 'sint64';
 163                 UINT64 = 'uint64';
 164                 STRING = 'string';
 165                 ARRAY = 'array';
 166                 FUNCTION = 'function';
 167                 TYPEDEF = 'typedef';
 168                 LIB = 'lib';
 169                 LET = 'let';
 170                 SET = 'set';
 171                 RET = 'ret';
 172                 STRVAL = 'strval';
 173                 INTVAL = 'intval';
 174                 FLOATVAL = 'floatval';
 175                 BOOLVAL = 'boolval';
 176                 TO_STRING = 'to_string';
 177                 TO_INT = 'to_int';
 178                 TO_FLOAT = 'to_float';
 179                 TO_BOOL = 'to_bool';
 180
 181                 "#" .* "\n" { ++P->line; RETURN(PSI_T_COMMENT);}
 182                 "(" {RETURN(PSI_T_LPAREN);}
 183                 ")" {RETURN(PSI_T_RPAREN);}
 184                 ";" {RETURN(PSI_T_EOS);}
 185                 "," {RETURN(PSI_T_COMMA);}
 186                 ":" {RETURN(PSI_T_COLON);}
 187                 "{" {RETURN(PSI_T_LBRACE);}
 188                 "}" {RETURN(PSI_T_RBRACE);}
 189                 "." {RETURN(PSI_T_DOT);}
 190                 "=" {RETURN(PSI_T_EQUALS);}
 191                 "$" {RETURN(PSI_T_DOLLAR);}
 192                 "*" {RETURN(PSI_T_POINTER);}
 193                 "&" {RETURN(PSI_T_REFERENCE);}
 194                 [\r\n] { ++P->line; continue; }
 195                 [\t ]+ { continue; }
 196                 NULL {RETURN(PSI_T_NULL);}
 197                 MIXED {RETURN(PSI_T_MIXED);}
 198                 VOID {RETURN(PSI_T_VOID);}
 199                 BOOL {RETURN(PSI_T_BOOL);}
 200                 INT {RETURN(PSI_T_INT);}
 201                 FLOAT {RETURN(PSI_T_FLOAT);}
 202                 DOUBLE {RETURN(PSI_T_DOUBLE);}
 203                 SINT8 {RETURN(PSI_T_SINT8);}
 204                 UINT8 {RETURN(PSI_T_UINT8);}
 205                 SINT16 {RETURN(PSI_T_SINT16);}
 206                 UINT16 {RETURN(PSI_T_UINT16);}
 207                 SINT32 {RETURN(PSI_T_SINT32);}
 208                 UINT32 {RETURN(PSI_T_UINT32);}
 209                 SINT64 {RETURN(PSI_T_SINT64);}
 210                 UINT64 {RETURN(PSI_T_UINT64);}
 211                 STRING {RETURN(PSI_T_STRING);}
 212                 ARRAY {RETURN(PSI_T_ARRAY);}
 213                 FUNCTION {RETURN(PSI_T_FUNCTION);}
 214                 TYPEDEF {RETURN(PSI_T_TYPEDEF);}
 215                 LIB {RETURN(PSI_T_LIB);}
 216                 LET {RETURN(PSI_T_LET);}
 217                 SET {RETURN(PSI_T_SET);}
 218                 RET {RETURN(PSI_T_RET);}
 219                 STRVAL {RETURN(PSI_T_STRVAL);}
 220                 INTVAL {RETURN(PSI_T_INTVAL);}
 221                 FLOATVAL {RETURN(PSI_T_FLOATVAL);}
 222                 BOOLVAL {RETURN(PSI_T_BOOLVAL);}
 223                 TO_STRING {RETURN(PSI_T_TO_STRING);}
 224                 TO_INT {RETURN(PSI_T_TO_INT);}
 225                 TO_FLOAT {RETURN(PSI_T_TO_FLOAT);}
 226                 TO_BOOL {RETURN(PSI_T_TO_BOOL);}
 227                 [0-9] {RETURN(PSI_T_DIGIT);}
 228                 NAME {RETURN(PSI_T_NAME);}
 229                 NSNAME {RETURN(PSI_T_NSNAME);}
 230                 QUOTED_STRING {RETURN(PSI_T_QUOTED_STRING);}
 231                 */
 232         }
 233         return -1;
 234 }