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 = L->cur - L->tok;
  23
  24         T = malloc(sizeof(*T) + token_len);
  25         T->type = t;
  26         T->line = L->line;
  27         T->text[token_len] = 0;
  28         memcpy(T->text, L->tok, token_len);
  29
  30         return T;
  31 }
  32
  33 size_t PSI_LexerFill(PSI_Lexer *L, size_t n)
  34 {
  35         // printf("+ Fill: n=%zu\n", n);
  36         if (!n) {
  37                 L->cur = L->tok = L->lim = L->mrk = L->buf;
  38                 L->eof = NULL;
  39         }
  40
  41         if (!L->eof) {
  42                 size_t consumed = L->tok - L->buf;
  43                 size_t reserved = L->lim - L->tok;
  44                 size_t available = BSIZE - reserved;
  45                 size_t didread;
  46
  47                 if (consumed) {
  48                         memmove(L->buf, L->tok, reserved);
  49                         L->tok -= consumed;
  50                         L->cur -= consumed;
  51                         L->lim -= consumed;
  52                         L->mrk -= consumed;
  53                 }
  54
  55                 didread = fread(L->lim, 1, available, L->fp);
  56                 L->lim += didread;
  57                 if (didread < available) {
  58                         L->eof = L->lim;
  59                 }
  60
  61                 // printf("+ Fill: consumed=%zu reserved=%zu available=%zu didread=%zu\n",
  62                         // consumed, reserved, available, didread);
  63         }
  64         // printf("+ Fill: avail=%zu\n", L->lim - L->cur);
  65         return L->lim - L->cur;
  66 }
  67
  68 void PSI_LexerDtor(PSI_Lexer *L)
  69 {
  70         if (L->fp) {
  71                 fclose(L->fp);
  72         }
  73         if (L->fn) {
  74                 free(L->fn);
  75         }
  76         if (L->decl.list) {
  77                 size_t i;
  78
  79                 for (i = 0; i < L->decl.count; ++i) {
  80                         free_decl(L->decl.list[i]);
  81                 }
  82                 free(L->decl.list);
  83         }
  84         if (L->impl.list) {
  85                 size_t i;
  86
  87                 for (i = 0; i < L->impl.count; ++i) {
  88                         free_impl(L->impl.list[i]);
  89                 }
  90                 free(L->impl.list);
  91         }
  92         memset(L, 0, sizeof(*L));
  93 }
  94
  95 void PSI_LexerFree(PSI_Lexer **L)
  96 {
  97         if (*L) {
  98                 PSI_LexerDtor(*L);
  99                 free(*L);
 100                 *L = NULL;
 101         }
 102 }
 103
 104 PSI_Lexer *PSI_LexerInit(PSI_Lexer *L, const char *filename)
 105 {
 106         FILE *fp = fopen(filename, "r");
 107
 108         if (!fp) {
 109                 perror(filename);
 110                 return NULL;
 111         }
 112
 113         if (!L) {
 114                 L = malloc(sizeof(*L));
 115         }
 116         memset(L, 0, sizeof(*L));
 117
 118         L->fp = fp;
 119         L->fn = strdup(filename);
 120         L->line = 1;
 121
 122         PSI_LexerFill(L, 0);
 123
 124         return L;
 125 }
 126
 127
 128 token_t PSI_LexerScan(PSI_Lexer *L)
 129 {
 130         for (;;) {
 131                 L->tok = L->cur;
 132                 /*!re2c
 133                 re2c:indent:top = 2;
 134                 re2c:define:YYCTYPE = "unsigned char";
 135                 re2c:define:YYCURSOR = L->cur;
 136                 re2c:define:YYLIMIT = L->lim;
 137                 re2c:define:YYMARKER = L->mrk;
 138                 re2c:define:YYFILL = "{ if (!PSI_LexerFill(L,@@)) return -1; }";
 139                 re2c:yyfill:parameter = 0;
 140
 141                 B = [^a-zA-Z0-9_];
 142                 W = [a-zA-Z0-9_];
 143                 NAME = W+;
 144                 NSNAME = NAME ("\\" NAME)+;
 145                 NULL = 'NULL';
 146                 MIXED = 'mixed';
 147                 VOID = 'void';
 148                 BOOL = 'bool';
 149                 INT = 'int';
 150                 FLOAT = 'float';
 151                 DOUBLE = 'double';
 152                 SINT8 = 'sint8';
 153                 UINT8 = 'uint8';
 154                 STRING = 'string';
 155                 ARRAY = 'array';
 156                 FUNCTION = 'function';
 157                 LET = 'let';
 158                 SET = 'set';
 159                 RET = 'ret';
 160                 STRVAL = 'strval';
 161                 INTVAL = 'intval';
 162                 FLOATVAL = 'floatval';
 163                 BOOLVAL = 'boolval';
 164                 TO_STRING = 'to_string';
 165                 TO_INT = 'to_int';
 166                 TO_FLOAT = 'to_float';
 167                 TO_BOOL = 'to_bool';
 168
 169                 "#" .* "\n" { ++L->line; return PSI_T_COMMENT;}
 170                 "(" {return PSI_T_LPAREN;}
 171                 ")" {return PSI_T_RPAREN;}
 172                 ";" {return PSI_T_EOS;}
 173                 "," {return PSI_T_COMMA;}
 174                 ":" {return PSI_T_COLON;}
 175                 "{" {return PSI_T_LCURLY;}
 176                 "}" {return PSI_T_RCURLY;}
 177                 "." {return PSI_T_DOT;}
 178                 "=" {return PSI_T_EQUALS;}
 179                 "$" {return PSI_T_DOLLAR;}
 180                 "*" {return PSI_T_POINTER;}
 181                 "&" {return PSI_T_REFERENCE;}
 182                 [\r\n] { ++L->line; continue; }
 183                 [\t ]+ { continue; }
 184                 NULL {return PSI_T_NULL;}
 185                 MIXED {return PSI_T_MIXED;}
 186                 VOID {return PSI_T_VOID;}
 187                 BOOL {return PSI_T_BOOL;}
 188                 INT {return PSI_T_INT;}
 189                 FLOAT {return PSI_T_FLOAT;}
 190                 DOUBLE {return PSI_T_DOUBLE;}
 191                 SINT8 {return PSI_T_SINT8;}
 192                 UINT8 {return PSI_T_UINT8;}
 193                 STRING {return PSI_T_STRING;}
 194                 ARRAY {return PSI_T_ARRAY;}
 195                 FUNCTION {return PSI_T_FUNCTION;}
 196                 LET {return PSI_T_LET;}
 197                 SET {return PSI_T_SET;}
 198                 RET {return PSI_T_RET;}
 199                 STRVAL {return PSI_T_STRVAL;}
 200                 INTVAL {return PSI_T_INTVAL;}
 201                 FLOATVAL {return PSI_T_FLOATVAL;}
 202                 BOOLVAL {return PSI_T_BOOLVAL;}
 203                 TO_STRING {return PSI_T_TO_STRING;}
 204                 TO_INT {return PSI_T_TO_INT;}
 205                 TO_FLOAT {return PSI_T_TO_FLOAT;}
 206                 TO_BOOL {return PSI_T_TO_BOOL;}
 207                 [0-9] {return PSI_T_DIGIT;}
 208                 NSNAME {return PSI_T_NSNAME;}
 209                 NAME {return PSI_T_NAME;}
 210                 */
 211         }
 212         return -1;
 213 }