examples/pullscan.rl

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #define BUFSIZE 4096
   6
   7 typedef struct _Scanner {
   8         /* Scanner state. */
   9     int cs;
  10     int act;
  11     int have;
  12     int curline;
  13     char *ts;
  14     char *te;
  15     char *p;
  16     char *pe;
  17     char *eof;
  18         FILE *file;
  19         int done;
  20
  21         /* Token data */
  22         char *data;
  23         int len;
  24     int value;
  25
  26         char buf[BUFSIZE];
  27 } Scanner;
  28
  29
  30 %%{
  31         machine Scanner;
  32         write data;
  33 }%%
  34
  35 void scan_init( Scanner *s, FILE *file )
  36 {
  37         memset (s, '\0', sizeof(Scanner));
  38         s->curline = 1;
  39         s->file = file;
  40         s->eof = 0;
  41         %% write init;
  42 }
  43
  44 #define TK_NO_TOKEN (-1)
  45 #define TK_ERR 128
  46 #define TK_EOF 129
  47 #define TK_Identifier 130
  48 #define TK_Number 131
  49 #define TK_String 132
  50
  51 #define ret_tok( _tok ) token = _tok; s->data = s->ts
  52
  53 int scan( Scanner *s )
  54 {
  55         int token = TK_NO_TOKEN;
  56         int space, readlen;
  57
  58         while ( 1 ) {
  59                 if ( s->p == s->pe ) {
  60                         printf("scanner: need more data\n");
  61
  62                         if ( s->ts == 0 )
  63                                 s->have = 0;
  64                         else {
  65                                 /* There is data that needs to be shifted over. */
  66                                 printf("scanner: buffer broken mid token\n");
  67                                 s->have = s->pe - s->ts;
  68                                 memmove( s->buf, s->ts, s->have );
  69                                 s->te -= (s->ts-s->buf);
  70                                 s->ts = s->buf;
  71                         }
  72
  73                         s->p = s->buf + s->have;
  74                         space = BUFSIZE - s->have;
  75
  76                         if ( space == 0 ) {
  77                                 /* We filled up the buffer trying to scan a token. */
  78                                 printf("scanner: out of buffer space\n");
  79                                 return TK_ERR;
  80                         }
  81
  82                         if ( s->done ) {
  83                                 printf("scanner: end of file\n");
  84                                 s->p[0] = 0;
  85                                 readlen = 1;
  86                         }
  87                         else {
  88                                 readlen = fread( s->p, 1, space, s->file );
  89                                 if ( readlen < space )
  90                                         s->done = 1;
  91                         }
  92
  93                         s->pe = s->p + readlen;
  94                 }
  95
  96                 %%{
  97                         machine Scanner;
  98                         access s->;
  99                         variable p s->p;
 100                         variable pe s->pe;
 101                         variable eof s->eof;
 102
 103                         main := |*
 104
 105                         # Identifiers
 106                         ( [a-zA-Z_] [a-zA-Z0-9_]* ) =>
 107                                 { ret_tok( TK_Identifier ); fbreak; };
 108
 109                         # Whitespace
 110                         [ \t\n];
 111
 112                         '"' ( [^\\"] | '\\' any ) * '"' =>
 113                                 { ret_tok( TK_String ); fbreak; };
 114
 115                         # Number
 116                         digit+ =>
 117                                 { ret_tok( TK_Number ); fbreak; };
 118
 119                         # EOF
 120                         0 =>
 121                                 { ret_tok( TK_EOF ); fbreak; };
 122
 123                         # Anything else
 124                         any =>
 125                                 { ret_tok( *s->p ); fbreak; };
 126
 127                         *|;
 128
 129                         write exec;
 130                 }%%
 131
 132                 if ( s->cs == Scanner_error )
 133                         return TK_ERR;
 134
 135                 if ( token != TK_NO_TOKEN ) {
 136                         /* Save p and pe. fbreak does not advance p. */
 137                         s->len = s->p - s->data;
 138                         return token;
 139                 }
 140         }
 141 }
 142
 143
 144 int main (int argc, char** argv)
 145 {
 146         Scanner ss;
 147         int tok;
 148
 149         scan_init(&ss, stdin);
 150
 151         while ( 1 ) {
 152                 tok = scan (&ss);
 153                 if ( tok == TK_EOF ) {
 154                         printf ("parser: EOF\n");
 155                         break;
 156                 }
 157                 else if ( tok == TK_ERR ) {
 158                         printf ("parser: ERR\n");
 159                         break;
 160                 }
 161                 else {
 162                         printf ("parser: %d \"", tok);
 163                         fwrite ( ss.data, 1, ss.len, stdout );
 164                         printf ("\"\n" );
 165                 }
 166         }
 167
 168         return 0;
 169 }
 170
 171