formats/ctf/metadata/ctf-lexer.l

   1 %{
   2 #include <stdio.h>
   3 #include "ctf-parser.h"
   4 #include "ctf-ast.h"
   5
   6 extern YYSTYPE yylval;
   7 extern void setstring(const char *src);
   8 %}
   9
  10 %x comment_ml comment_sl string_lit char_const
  11 INTEGER_SUFFIX                  [ \n\t]*(U|UL|ULL|LU|LLU|Ul|Ull|lU|llU|u|uL|uLL|Lu|LLu|ul|ull|lu|llu)
  12 DIGIT                           [0-9]
  13 NONDIGIT                        [a-zA-Z_]
  14 HEXDIGIT                        [0-9A-Fa-f]
  15 OCTALDIGIT                      [0-7]
  16 UCHARLOWERCASE                  \\u{HEXDIGIT}{4}
  17 UCHARUPPERCASE                  \\U{HEXDIGIT}{8}
  18 ID_NONDIGIT                     {NONDIGIT}|{UCHARLOWERCASE}|{UCHARUPPERCASE}
  19 IDENTIFIER                      {ID_NONDIGIT}({ID_NONDIGIT}|{DIGIT})*
  20 ESCSEQ                          \\(\'|\"|\?|\\|a|b|f|n|r|t|v|{OCTALDIGIT}{1,3}|u{HEXDIGIT}{4}|U{HEXDIGIT}{8}|x{HEXDIGIT}+)
  21 %%
  22
  23                                 /*
  24                                  * Using start conditions to deal with comments
  25                                  * and strings.
  26                                  */
  27
  28 "/*"                            BEGIN(comment_ml);
  29 <comment_ml>[^*\n]*             /* eat anything that's not a '*' */
  30 <comment_ml>"*"+[^*/\n]*        /* eat up '*'s not followed by '/'s */
  31 <comment_ml>\n                  ++yylineno;
  32 <comment_ml>"*"+"/"             BEGIN(INITIAL);
  33
  34 "//"                            BEGIN(comment_sl);
  35 <comment_sl>[^\n]*\n            ++yylineno; BEGIN(INITIAL);
  36
  37 L\'                             BEGIN(char_const); return CHARACTER_CONSTANT_START;
  38 \'                              BEGIN(char_const); return CHARACTER_CONSTANT_START;
  39 <char_const>\'                  BEGIN(INITIAL); return SQUOTE;
  40
  41 L\"                             BEGIN(string_lit); return STRING_LITERAL_START;
  42 \"                              BEGIN(string_lit); return STRING_LITERAL_START;
  43 <string_lit>\"                  BEGIN(INITIAL); return DQUOTE;
  44
  45 <char_const,string_lit>ESCSEQ   return ESCSEQ;
  46 <char_const,string_lit>\n       ; /* ignore */
  47 <char_const,string_lit>.        return CHAR_STRING_TOKEN;
  48
  49 "["                             return LSBRAC;
  50 "]"                             return RSBRAC;
  51 "("                             return LPAREN;
  52 ")"                             return RPAREN;
  53 "{"                             return LBRAC;
  54 "}"                             return RBRAC;
  55 "->"                            return RARROW;
  56 "*"                             return STAR;
  57 "+"                             return PLUS;
  58 "-"                             return MINUS;
  59 "<"                             return LT;
  60 ">"                             return GT;
  61 :=                              return TYPEASSIGN;
  62 :                               return COLON;
  63 ;                               return SEMICOLON;
  64 "..."                           return DOTDOTDOT;
  65 "."                             return DOT;
  66 =                               return EQUAL;
  67 ","                             return COMMA;
  68 const                           return CONST;
  69 char                            return CHAR;
  70 double                          return DOUBLE;
  71 enum                            return ENUM;
  72 event                           return EVENT;
  73 floating_point                  return FLOATING_POINT;
  74 float                           return FLOAT;
  75 integer                         return INTEGER;
  76 int                             return INT;
  77 long                            return LONG;
  78 short                           return SHORT;
  79 signed                          return SIGNED;
  80 stream                          return STREAM;
  81 string                          return STRING;
  82 struct                          return STRUCT;
  83 trace                           return TRACE;
  84 typealias                       return TYPEALIAS;
  85 typedef                         return TYPEDEF;
  86 unsigned                        return UNSIGNED;
  87 variant                         return VARIANT;
  88 void                            return VOID;
  89 _Bool                           return _BOOL;
  90 _Complex                        return _COMPLEX;
  91 _Imaginary                      return _IMAGINARY;
  92 [1-9]{DIGIT}*{INTEGER_SUFFIX}?  return DECIMAL_CONSTANT;
  93 0{OCTALDIGIT}*{INTEGER_SUFFIX}? return OCTAL_CONSTANT;
  94 0[xX]{HEXDIGIT}+{INTEGER_SUFFIX}?       return HEXADECIMAL_CONSTANT;
  95 {IDENTIFIER}                    fprintf(stderr, "<IDENTIFIER %s>\n", yytext); setstring(yytext); if (is_type(yytext)) return ID_TYPE; else return IDENTIFIER;
  96 [ \t\n]+                        ; /* ignore */
  97 .                               return ERROR;
  98 %%