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

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <unistd.h>
   5 #include <assert.h>
   6
   7 #include "lexer.h"
   8 #include "parser.h"
   9 #include "types.h"
  10
  11 #ifndef BSIZE
  12 /*!max:re2c*/
  13 #define BSIZE 256
  14 #endif
  15 #if BSIZE < YYMAXFILL
  16 # error BSIZE must be greater than YYMAXFILL
  17 #endif
  18
  19 PSI_Token *PSI_TokenAlloc(PSI_Lexer *L, token_t t)
  20 {
  21         PSI_Token *T;
  22         size_t token_len;
  23
  24         if (L->cur <= L->tok) {
  25                 return NULL;
  26         }
  27
  28         token_len = L->cur - L->tok;
  29
  30         T = malloc(sizeof(*T) + token_len);
  31         T->type = t;
  32         T->line = L->line;
  33         T->size = token_len;
  34         T->text[token_len] = 0;
  35         memcpy(T->text, L->tok, token_len);
  36
  37         return T;
  38 }
  39
  40 size_t PSI_LexerFill(PSI_Lexer *L, size_t n)
  41 {
  42         // printf("+ Fill: n=%zu\n", n);
  43         if (!n) {
  44                 L->cur = L->tok = L->lim = L->mrk = L->buf;
  45                 L->eof = NULL;
  46         }
  47
  48         if (!L->eof) {
  49                 size_t consumed = L->tok - L->buf;
  50                 size_t reserved = L->lim - L->tok;
  51                 size_t available = BSIZE - reserved;
  52                 size_t didread;
  53
  54                 if (consumed) {
  55                         memmove(L->buf, L->tok, reserved);
  56                         L->tok -= consumed;
  57                         L->cur -= consumed;
  58                         L->lim -= consumed;
  59                         L->mrk -= consumed;
  60                 }
  61
  62                 didread = fread(L->lim, 1, available, L->fp);
  63                 L->lim += didread;
  64                 if (didread < available) {
  65                         L->eof = L->lim;
  66                 }
  67
  68                 // printf("+ Fill: consumed=%zu reserved=%zu available=%zu didread=%zu\n",
  69                         // consumed, reserved, available, didread);
  70         }
  71         // printf("+ Fill: avail=%zu\n", L->lim - L->cur);
  72         return L->lim - L->cur;
  73 }
  74
  75 void PSI_LexerDtor(PSI_Lexer *L)
  76 {
  77         if (L->fp) {
  78                 fclose(L->fp);
  79         }
  80         if (L->fn) {
  81                 free(L->fn);
  82         }
  83         if (L->lib) {
  84                 free(L->lib);
  85         }
  86         if (L->defs) {
  87                 free_decl_typedefs(L->defs);
  88         }
  89         if (L->decls) {
  90                 free_decls(L->decls);
  91         }
  92         if (L->impls) {
  93                 free_impls(L->impls);
  94         }
  95         memset(L, 0, sizeof(*L));
  96 }
  97
  98 void PSI_LexerFree(PSI_Lexer **L)
  99 {
 100         if (*L) {
 101                 PSI_LexerDtor(*L);
 102                 free(*L);
 103                 *L = NULL;
 104         }
 105 }
 106
 107 PSI_Lexer *PSI_LexerInit(PSI_Lexer *L, const char *filename)
 108 {
 109         FILE *fp = fopen(filename, "r");
 110
 111         if (!fp) {
 112                 perror(filename);
 113                 return NULL;
 114         }
 115
 116         if (!L) {
 117                 L = malloc(sizeof(*L));
 118         }
 119         memset(L, 0, sizeof(*L));
 120
 121         L->fp = fp;
 122         L->fn = strdup(filename);
 123         L->line = 1;
 124
 125         PSI_LexerFill(L, 0);
 126
 127         return L;
 128 }
 129
 130
 131 token_t PSI_LexerScan(PSI_Lexer *L)
 132 {
 133         for (;;) {
 134                 L->tok = L->cur;
 135                 /*!re2c
 136                 re2c:indent:top = 2;
 137                 re2c:define:YYCTYPE = "unsigned char";
 138                 re2c:define:YYCURSOR = L->cur;
 139                 re2c:define:YYLIMIT = L->lim;
 140                 re2c:define:YYMARKER = L->mrk;
 141                 re2c:define:YYFILL = "{ if (!PSI_LexerFill(L,@@)) 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" { ++L->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] { ++L->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 }