git.m6w6.name Git - m6w6/ext-psi/blob - src/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 void PSI_ParserProcTrace(FILE *, const char*);
  11
  12 PSI_Parser *PSI_ParserInit(PSI_Parser *P, const char *filename, psi_error_cb error, unsigned flags)
  13 {
  14         FILE *fp;
  15
  16         if (!P) {
  17                 P = malloc(sizeof(*P));
  18         }
  19         memset(P, 0, sizeof(*P));
  20
  21         fp = fopen(filename, "r");
  22
  23         if (!fp) {
  24                 perror(filename);
  25                 return NULL;
  26         }
  27
  28         if (!P) {
  29                 P = malloc(sizeof(*P));
  30         }
  31         memset(P, 0, sizeof(*P));
  32
  33         P->psi.file.fn = strdup(filename);
  34         P->fp = fp;
  35         P->line = 1;
  36         P->error = error;
  37         P->flags = flags;
  38
  39         P->proc = PSI_ParserProcAlloc(malloc);
  40         if (flags & PSI_PARSER_DEBUG) {
  41                 PSI_ParserProcTrace(stderr, "PSI> ");
  42         }
  43
  44         PSI_ParserFill(P, 0);
  45
  46         return P;
  47 }
  48
  49 void PSI_ParserSyntaxError(PSI_Parser *P, const char *fn, size_t ln, const char *msg, ...) {
  50         char buf[0x1000] = {0};
  51         va_list argv;
  52
  53         va_start(argv, msg);
  54         vsnprintf(buf, 0x1000-1, msg, argv);
  55         va_end(argv);
  56
  57         P->error(PSI_WARNING, "PSI syntax error on line %zu in '%s'%s%s",
  58                         ln, fn, msg ? ": ": "", buf);
  59
  60         ++P->errors;
  61 }
  62
  63 size_t PSI_ParserFill(PSI_Parser *P, size_t n)
  64 {
  65         if (P->flags & PSI_PARSER_DEBUG) {
  66                 fprintf(stderr, "PSI> Fill: n=%zu\n", n);
  67         }
  68         if (!n) {
  69                 P->cur = P->tok = P->lim = P->mrk = P->buf;
  70                 P->eof = NULL;
  71         }
  72
  73         if (!P->eof) {
  74                 size_t consumed = P->tok - P->buf;
  75                 size_t reserved = P->lim - P->tok;
  76                 size_t available = BSIZE - reserved;
  77                 size_t didread;
  78
  79                 if (consumed) {
  80                         memmove(P->buf, P->tok, reserved);
  81                         P->tok -= consumed;
  82                         P->cur -= consumed;
  83                         P->lim -= consumed;
  84                         P->mrk -= consumed;
  85                 }
  86
  87                 didread = fread(P->lim, 1, available, P->fp);
  88                 P->lim += didread;
  89                 if (didread < available) {
  90                         P->eof = P->lim;
  91                 }
  92
  93                 if (P->flags & PSI_PARSER_DEBUG) {
  94                         fprintf(stderr, "PSI> Fill: consumed=%zu reserved=%zu available=%zu didread=%zu\n",
  95                                 consumed, reserved, available, didread);
  96                 }
  97         }
  98         if (P->flags & PSI_PARSER_DEBUG) {
  99                 fprintf(stderr, "PSI> Fill: avail=%zu\n", P->lim - P->cur);
 100         }
 101         return P->lim - P->cur;
 102 }
 103
 104 void PSI_ParserParse(PSI_Parser *P, PSI_Token *T)
 105 {
 106         if (T) {
 107                 PSI_ParserProc(P->proc, T->type, T, P);
 108         } else {
 109                 PSI_ParserProc(P->proc, 0, NULL, P);
 110         }
 111 }
 112
 113 void PSI_ParserDtor(PSI_Parser *P)
 114 {
 115         PSI_ParserProcFree(P->proc, free);
 116
 117         if (P->fp) {
 118                 fclose(P->fp);
 119         }
 120
 121         PSI_DataDtor((PSI_Data *) P);
 122
 123         memset(P, 0, sizeof(*P));
 124 }
 125
 126 void PSI_ParserFree(PSI_Parser **P)
 127 {
 128         if (*P) {
 129                 PSI_ParserDtor(*P);
 130                 free(*P);
 131                 *P = NULL;
 132         }
 133 }
 134
 135 /*!max:re2c*/
 136 #define BSIZE 256
 137
 138 #if BSIZE < YYMAXFILL
 139 # error BSIZE must be greater than YYMAXFILL
 140 #endif
 141
 142 #define RETURN(t) do { \
 143         P->num = t; \
 144         if (P->flags & PSI_PARSER_DEBUG) { \
 145                 fprintf(stderr, "PSI> TOKEN: %d %.*s (EOF=%d)\n", P->num, (int) (P->cur-P->tok), P->tok, P->num == PSI_T_EOF); \
 146         } \
 147         return t; \
 148 } while(1)
 149
 150 token_t PSI_ParserScan(PSI_Parser *P)
 151 {
 152         for (;;) {
 153                 P->tok = P->cur;
 154                 /*!re2c
 155                 re2c:indent:top = 2;
 156                 re2c:define:YYCTYPE = "unsigned char";
 157                 re2c:define:YYCURSOR = P->cur;
 158                 re2c:define:YYLIMIT = P->lim;
 159                 re2c:define:YYMARKER = P->mrk;
 160                 re2c:define:YYFILL = "{ if (!PSI_ParserFill(P,@@)) RETURN(PSI_T_EOF); }";
 161                 re2c:yyfill:parameter = 0;
 162
 163                 B = [^a-zA-Z0-9_];
 164                 W = [a-zA-Z0-9_];
 165                 NAME = [a-zA-Z_]W*;
 166                 NSNAME = (NAME)? ("\\" NAME)+;
 167                 QUOTED_STRING = "\"" ([^\"])+ "\"";
 168                 NUMBER = [+-]? [0-9]* "."? [0-9]+ ([eE] [+-]? [0-9]+)?;
 169
 170                 ("#"|"//") .* "\n" { ++P->line; continue;}
 171                 "(" {RETURN(PSI_T_LPAREN);}
 172                 ")" {RETURN(PSI_T_RPAREN);}
 173                 ";" {RETURN(PSI_T_EOS);}
 174                 "," {RETURN(PSI_T_COMMA);}
 175                 ":" {RETURN(PSI_T_COLON);}
 176                 "{" {RETURN(PSI_T_LBRACE);}
 177                 "}" {RETURN(PSI_T_RBRACE);}
 178                 "[" {RETURN(PSI_T_LBRACKET);}
 179                 "]" {RETURN(PSI_T_RBRACKET);}
 180                 "=" {RETURN(PSI_T_EQUALS);}
 181                 "$" {RETURN(PSI_T_DOLLAR);}
 182                 "*" {RETURN(PSI_T_ASTERISK);}
 183                 "&" {RETURN(PSI_T_AMPERSAND);}
 184                 "+" {RETURN(PSI_T_PLUS);}
 185                 "-" {RETURN(PSI_T_MINUS);}
 186                 "/" {RETURN(PSI_T_SLASH);}
 187                 [\r\n] { ++P->line; continue; }
 188                 [\t ]+ { continue; }
 189                 'TRUE' {RETURN(PSI_T_TRUE);}
 190                 'FALSE' {RETURN(PSI_T_FALSE);}
 191                 'NULL' {RETURN(PSI_T_NULL);}
 192                 'MIXED' {RETURN(PSI_T_MIXED);}
 193                 'VOID' {RETURN(PSI_T_VOID);}
 194                 'BOOL' {RETURN(PSI_T_BOOL);}
 195                 'INT' {RETURN(PSI_T_INT);}
 196                 'FLOAT' {RETURN(PSI_T_FLOAT);}
 197                 'DOUBLE' {RETURN(PSI_T_DOUBLE);}
 198                 'INT8_T' {RETURN(PSI_T_INT8);}
 199                 'UINT8_T' {RETURN(PSI_T_UINT8);}
 200                 'INT16_T' {RETURN(PSI_T_INT16);}
 201                 'UINT16_T' {RETURN(PSI_T_UINT16);}
 202                 'INT32_T' {RETURN(PSI_T_INT32);}
 203                 'UINT32_T' {RETURN(PSI_T_UINT32);}
 204                 'INT64_T' {RETURN(PSI_T_INT64);}
 205                 'UINT64_T' {RETURN(PSI_T_UINT64);}
 206                 'UNSIGNED' {RETURN(PSI_T_UNSIGNED);}
 207                 'STRING' {RETURN(PSI_T_STRING);}
 208                 'ARRAY' {RETURN(PSI_T_ARRAY);}
 209                 'OBJECT' {RETURN(PSI_T_OBJECT);}
 210                 'FUNCTION' {RETURN(PSI_T_FUNCTION);}
 211                 'TYPEDEF' {RETURN(PSI_T_TYPEDEF);}
 212                 'STRUCT' {RETURN(PSI_T_STRUCT);}
 213                 'CONST' {RETURN(PSI_T_CONST);}
 214                 'LIB' {RETURN(PSI_T_LIB);}
 215                 'LET' {RETURN(PSI_T_LET);}
 216                 'SET' {RETURN(PSI_T_SET);}
 217                 'RETURN' {RETURN(PSI_T_RETURN);}
 218                 'FREE' {RETURN(PSI_T_FREE);}
 219                 'STRLEN' {RETURN(PSI_T_STRLEN);}
 220                 'STRVAL' {RETURN(PSI_T_STRVAL);}
 221                 'PATHVAL' {RETURN(PSI_T_PATHVAL);}
 222                 'INTVAL' {RETURN(PSI_T_INTVAL);}
 223                 'FLOATVAL' {RETURN(PSI_T_FLOATVAL);}
 224                 'BOOLVAL' {RETURN(PSI_T_BOOLVAL);}
 225                 'ARRVAL' {RETURN(PSI_T_ARRVAL);}
 226                 'OBJVAL' {RETURN(PSI_T_OBJVAL);}
 227                 'CALLOC' {RETURN(PSI_T_CALLOC);}
 228                 'TO_OBJECT' {RETURN(PSI_T_TO_OBJECT);}
 229                 'TO_ARRAY' {RETURN(PSI_T_TO_ARRAY);}
 230                 'TO_STRING' {RETURN(PSI_T_TO_STRING);}
 231                 'TO_INT' {RETURN(PSI_T_TO_INT);}
 232                 'TO_FLOAT' {RETURN(PSI_T_TO_FLOAT);}
 233                 'TO_BOOL' {RETURN(PSI_T_TO_BOOL);}
 234                 NUMBER {RETURN(PSI_T_NUMBER);}
 235                 NAME {RETURN(PSI_T_NAME);}
 236                 NSNAME {RETURN(PSI_T_NSNAME);}
 237                 QUOTED_STRING {RETURN(PSI_T_QUOTED_STRING);}
 238                 [^] {break;}
 239                 */
 240         }
 241         return -1;
 242 }