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         int 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 digit           [0-9]
  71 digit_s         [1-9]
  72 digit_n         [0]
  73 bindigit        [0-1]
  74 bindigit_b      [b]
  75 hex             [a-fA-F0-9]
  76 hex_x           [x]
  77
  78 number_dec      {digit_n}|{digit_s}{digit}*
  79 number_oct      {digit_n}{digit}+
  80 number_hex      {digit_n}{hex_x}{hex}+
  81 number_bin      {digit_n}{bindigit_b}{bindigit}+
  82
  83 %%
  84
  85 {alpha}{alphanum}* {
  86                 zzlval.idx = bpf_symtab_find(zztext);
  87                 if (zzlval.idx < 0) {
  88                         zzlval.idx = bpf_symtab_insert(zztext, K_NAME);
  89                         return K_NAME;
  90                   } else {
  91                         return bpf_symtab_type(zzlval.idx);
  92                 }}
  93
  94 "("             { return '('; }
  95 ")"             { return ')'; }
  96 "{"             { return '{'; }
  97 "}"             { return '}'; }
  98 "="             { return '='; }
  99 ";"             { return ';'; }
 100 ","             { return ','; }
 101 "+"             { return '+'; }
 102 "-"             { return '-'; }
 103 "&"             { return '&'; }
 104 "|"             { return '|'; }
 105 "^"             { return '^'; }
 106 "!"             { return '!'; }
 107 "<"             { return '<'; }
 108 ">"             { return '>'; }
 109 "*"             { return '*'; }
 110 "/"             { return '/'; }
 111 "%"             { return '%'; }
 112
 113 {number_hex}    { zzlval.number = strtoul(zztext, NULL, 16);
 114                   return number_hex; }
 115
 116 {number_dec}    { zzlval.number = strtol(zztext, NULL, 10);
 117                   return number_dec; }
 118
 119 {number_oct}    { zzlval.number = strtol(zztext, NULL, 8);
 120                   return number_oct; }
 121
 122 {number_bin}    { zzlval.number = strtol(zztext + 2, NULL, 2);
 123                   return number_bin; }
 124
 125 "/*"([^\*]|\*[^/])*"*/" { /* NOP */ }
 126 ";"[^\n]*       {/* NOP */}
 127 "\n"            { zzlineno++; }
 128 [ \t]+          {/* NOP */ }
 129 .               { printf("Unknown character '%s'", zztext);
 130                   zzerror("lex Unknown character"); }
 131
 132 %%