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