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 %{
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <ctype.h>
  15
  16 #include "bpf_hla_parser.tab.h"
  17 #include "bpf_symtab.h"
  18 #include "built_in.h"
  19
  20 void bpf_hla_lex_init(void);
  21
  22 struct res_keywords {
  23         const char *key;
  24         int token;
  25 };
  26
  27 #define KEYPAIR(k,t)    { .key = (k), .token = (t)}
  28 static const struct res_keywords keytab[] = {
  29         KEYPAIR("def",  K_DEF),
  30         KEYPAIR("pkt",  K_PKT),
  31         KEYPAIR("ret",  K_RET),
  32         KEYPAIR("if",   K_IF),
  33         KEYPAIR("elif", K_ELIF),
  34         KEYPAIR("else", K_ELSE),
  35         /* short macros */
  36         KEYPAIR("ipv4", K_MACRO_IPV4),
  37         KEYPAIR("ipv6", K_MACRO_IPV6),
  38         KEYPAIR("ip",   K_MACRO_IP),
  39         KEYPAIR("udp",  K_MACRO_UDP),
  40         KEYPAIR("tcp",  K_MACRO_TCP),
  41 };
  42
  43 void bpf_hla_lex_init(void)
  44 {
  45         int i;
  46         for (i = 0; i < array_size(keytab); ++i)
  47                 bpf_symtab_insert(keytab[i].key, keytab[i].token);
  48 }
  49
  50 #define YY_USER_INIT    bpf_hla_lex_init();
  51
  52 extern void zzerror(const char *);
  53
  54 %}
  55
  56 %option align
  57 %option nounput
  58 %option noyywrap
  59 %option noreject
  60 %option 8bit
  61 %option caseless
  62 %option noinput
  63 %option nodefault
  64
  65 alpha           [A-Za-z]
  66 alphanum        [A-Za-z0-9]
  67
  68 digit           [0-9]
  69 digit_s         [1-9]
  70 digit_n         [0]
  71 bindigit        [0-1]
  72 bindigit_b      [b]
  73 hex             [a-fA-F0-9]
  74 hex_x           [x]
  75
  76 number_dec      {digit_n}|{digit_s}{digit}*
  77 number_oct      {digit_n}{digit}+
  78 number_hex      {digit_n}{hex_x}{hex}+
  79 number_bin      {digit_n}{bindigit_b}{bindigit}+
  80
  81 %%
  82
  83 {alpha}{alphanum}* {
  84                 zzlval.idx = bpf_symtab_find(zztext);
  85                 if (zzlval.idx < 0) {
  86                         zzlval.idx = bpf_symtab_insert(zztext, K_NAME);
  87                         return K_NAME;
  88                   } else {
  89                         return bpf_symtab_type(zzlval.idx);
  90                 }}
  91
  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 "!"             { return '!'; }
 105 "<"             { return '<'; }
 106 ">"             { return '>'; }
 107 "*"             { return '*'; }
 108 "/"             { return '/'; }
 109 "%"             { return '%'; }
 110
 111 {number_hex}    { zzlval.number = strtoul(zztext, NULL, 16);
 112                   return number_hex; }
 113
 114 {number_dec}    { zzlval.number = strtol(zztext, NULL, 10);
 115                   return number_dec; }
 116
 117 {number_oct}    { zzlval.number = strtol(zztext, NULL, 8);
 118                   return number_oct; }
 119
 120 {number_bin}    { zzlval.number = strtol(zztext + 2, NULL, 2);
 121                   return number_bin; }
 122
 123 "/*"([^\*]|\*[^/])*"*/" { /* NOP */ }
 124 ";"[^\n]*       {/* NOP */}
 125 "\n"            { zzlineno++; }
 126 [ \t]+          {/* NOP */ }
 127 .               { printf("Unknown character '%s'", zztext);
 128                   zzerror("lex Unknown character"); }
 129
 130 %%