src/bpf_hla_lexer.l

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * By Daniel Borkmann <daniel@netsniff-ng.org>
   4  * Copyright 2012 Daniel Borkmann <dborkma@tik.ee.ethz.ch>,
   5  * Swiss federal institute of technology (ETH Zurich)
   6  * Subject to the GPL, version 2.
   7  */
   8
   9 /* lex-func-prefix: zz */
  10
  11 %{
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <ctype.h>
  17
  18 #include "bpf_hla_parser.tab.h"
  19 #include "bpf_symtab.h"
  20 #include "built_in.h"
  21
  22 void bpf_hla_lex_init(void);
  23
  24 struct res_keywords {
  25         const char *key;
  26         int token;
  27 };
  28
  29 #define KEYPAIR(k,t)    { .key = (k), .token = (t)}
  30 static const struct res_keywords keytab[] = {
  31         KEYPAIR("def",  K_DEF),
  32         KEYPAIR("pkt",  K_PKT),
  33         KEYPAIR("ret",  K_RET),
  34         KEYPAIR("if",   K_IF),
  35         KEYPAIR("elif", K_ELIF),
  36         KEYPAIR("else", K_ELSE),
  37         /* short macros */
  38         KEYPAIR("ipv4", K_MACRO_IPV4),
  39         KEYPAIR("ipv6", K_MACRO_IPV6),
  40         KEYPAIR("ip",   K_MACRO_IP),
  41         KEYPAIR("udp",  K_MACRO_UDP),
  42         KEYPAIR("tcp",  K_MACRO_TCP),
  43 };
  44
  45 void bpf_hla_lex_init(void)
  46 {
  47         size_t i;
  48         for (i = 0; i < array_size(keytab); ++i)
  49                 bpf_symtab_insert(keytab[i].key, keytab[i].token);
  50 }
  51
  52 #define YY_USER_INIT    bpf_hla_lex_init();
  53
  54 extern void zzerror(const char *);
  55
  56 %}
  57
  58 %option align
  59 %option nounput
  60 %option noyywrap
  61 %option noreject
  62 %option 8bit
  63 %option caseless
  64 %option noinput
  65 %option nodefault
  66
  67 alpha           [A-Za-z]
  68 alphanum        [A-Za-z0-9]
  69
  70 number_oct      ([0][0-9]+)
  71 number_hex      ([0][x][a-fA-F0-9]+)
  72 number_bin      ([0][b][0-1]+)
  73 number_dec      (([0])|([-+]?[1-9][0-9]*))
  74
  75 %%
  76
  77 {alpha}{alphanum}* {
  78                 zzlval.idx = bpf_symtab_find(zztext);
  79                 if (zzlval.idx < 0) {
  80                         zzlval.idx = bpf_symtab_insert(zztext, K_NAME);
  81                         return K_NAME;
  82                   } else {
  83                         return bpf_symtab_type(zzlval.idx);
  84                 }}
  85
  86 "("             { return '('; }
  87 ")"             { return ')'; }
  88 "{"             { return '{'; }
  89 "}"             { return '}'; }
  90 "="             { return '='; }
  91 ";"             { return ';'; }
  92 ","             { return ','; }
  93 "+"             { return '+'; }
  94 "-"             { return '-'; }
  95 "&"             { return '&'; }
  96 "|"             { return '|'; }
  97 "^"             { return '^'; }
  98 "!"             { return '!'; }
  99 "<"             { return '<'; }
 100 ">"             { return '>'; }
 101 "*"             { return '*'; }
 102 "/"             { return '/'; }
 103 "%"             { return '%'; }
 104
 105 {number_hex}    { zzlval.number = strtoul(zztext, NULL, 16);
 106                   return number; }
 107
 108 {number_dec}    { zzlval.number = strtol(zztext, NULL, 10);
 109                   return number; }
 110
 111 {number_oct}    { zzlval.number = strtol(zztext + 1, NULL, 8);
 112                   return number; }
 113
 114 {number_bin}    { zzlval.number = strtol(zztext + 2, NULL, 2);
 115                   return number; }
 116
 117 "/*"([^\*]|\*[^/])*"*/" { /* NOP */ }
 118 ";"[^\n]*       {/* NOP */}
 119 "\n"            { zzlineno++; }
 120 [ \t]+          {/* NOP */ }
 121 .               { printf("Unknown character '%s'", zztext);
 122                   zzerror("lex Unknown character"); }
 123
 124 %%