lib/asn1/lex.l

   1 %{
   2 /*
   3  * Copyright (c) 1997 - 2005 Kungliga Tekniska Högskolan
   4  * (Royal Institute of Technology, Stockholm, Sweden).
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * 3. Neither the name of the Institute nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 /* $Id$ */
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include <config.h>
  39 #endif
  40 #include <stdio.h>
  41 #include <stdarg.h>
  42 #include <stdlib.h>
  43 #include <stdint.h>
  44 #include <string.h>
  45 #ifdef HAVE_UNISTD_H
  46 #include <unistd.h>
  47 #endif
  48 #undef ECHO
  49 #include "symbol.h"
  50 #include "asn1parse.h"
  51 #include "lex.h"
  52 #include "gen_locl.h"
  53
  54 static unsigned lineno = 1;
  55
  56 #undef ECHO
  57
  58 static void unterminated(const char *, unsigned);
  59
  60 %}
  61
  62 /* This is for broken old lexes (solaris 10 and hpux) */
  63 %e 2000
  64 %p 5000
  65 %a 5000
  66 %n 1000
  67 %o 10000
  68
  69 %%
  70 ABSENT                  { return kw_ABSENT; }
  71 ABSTRACT-SYNTAX         { return kw_ABSTRACT_SYNTAX; }
  72 ALL                     { return kw_ALL; }
  73 APPLICATION             { return kw_APPLICATION; }
  74 AUTOMATIC               { return kw_AUTOMATIC; }
  75 BEGIN                   { return kw_BEGIN; }
  76 BIT                     { return kw_BIT; }
  77 BMPString               { return kw_BMPString; }
  78 BOOLEAN                 { return kw_BOOLEAN; }
  79 BY                      { return kw_BY; }
  80 CHARACTER               { return kw_CHARACTER; }
  81 CHOICE                  { return kw_CHOICE; }
  82 CLASS                   { return kw_CLASS; }
  83 COMPONENT               { return kw_COMPONENT; }
  84 COMPONENTS              { return kw_COMPONENTS; }
  85 CONSTRAINED             { return kw_CONSTRAINED; }
  86 CONTAINING              { return kw_CONTAINING; }
  87 DEFAULT                 { return kw_DEFAULT; }
  88 DEFINITIONS             { return kw_DEFINITIONS; }
  89 EMBEDDED                { return kw_EMBEDDED; }
  90 ENCODED                 { return kw_ENCODED; }
  91 END                     { return kw_END; }
  92 ENUMERATED              { return kw_ENUMERATED; }
  93 EXCEPT                  { return kw_EXCEPT; }
  94 EXPLICIT                { return kw_EXPLICIT; }
  95 EXPORTS                 { return kw_EXPORTS; }
  96 EXTENSIBILITY           { return kw_EXTENSIBILITY; }
  97 EXTERNAL                { return kw_EXTERNAL; }
  98 FALSE                   { return kw_FALSE; }
  99 FROM                    { return kw_FROM; }
 100 GeneralString           { return kw_GeneralString; }
 101 GeneralizedTime         { return kw_GeneralizedTime; }
 102 GraphicString           { return kw_GraphicString; }
 103 IA5String               { return kw_IA5String; }
 104 IDENTIFIER              { return kw_IDENTIFIER; }
 105 IMPLICIT                { return kw_IMPLICIT; }
 106 IMPLIED                 { return kw_IMPLIED; }
 107 IMPORTS                 { return kw_IMPORTS; }
 108 INCLUDES                { return kw_INCLUDES; }
 109 INSTANCE                { return kw_INSTANCE; }
 110 INTEGER                 { return kw_INTEGER; }
 111 INTERSECTION            { return kw_INTERSECTION; }
 112 ISO646String            { return kw_ISO646String; }
 113 MAX                     { return kw_MAX; }
 114 MIN                     { return kw_MIN; }
 115 MINUS-INFINITY          { return kw_MINUS_INFINITY; }
 116 NULL                    { return kw_NULL; }
 117 NumericString           { return kw_NumericString; }
 118 OBJECT                  { return kw_OBJECT; }
 119 OCTET                   { return kw_OCTET; }
 120 OF                      { return kw_OF; }
 121 OPTIONAL                { return kw_OPTIONAL; }
 122 ObjectDescriptor        { return kw_ObjectDescriptor; }
 123 PATTERN                 { return kw_PATTERN; }
 124 PDV                     { return kw_PDV; }
 125 PLUS-INFINITY           { return kw_PLUS_INFINITY; }
 126 PRESENT                 { return kw_PRESENT; }
 127 PRIVATE                 { return kw_PRIVATE; }
 128 PrintableString         { return kw_PrintableString; }
 129 REAL                    { return kw_REAL; }
 130 RELATIVE_OID            { return kw_RELATIVE_OID; }
 131 SEQUENCE                { return kw_SEQUENCE; }
 132 SET                     { return kw_SET; }
 133 SIZE                    { return kw_SIZE; }
 134 STRING                  { return kw_STRING; }
 135 SYNTAX                  { return kw_SYNTAX; }
 136 T61String               { return kw_T61String; }
 137 TAGS                    { return kw_TAGS; }
 138 TRUE                    { return kw_TRUE; }
 139 TYPE-IDENTIFIER         { return kw_TYPE_IDENTIFIER; }
 140 TeletexString           { return kw_TeletexString; }
 141 UNION                   { return kw_UNION; }
 142 UNIQUE                  { return kw_UNIQUE; }
 143 UNIVERSAL               { return kw_UNIVERSAL; }
 144 UTCTime                 { return kw_UTCTime; }
 145 UTF8String              { return kw_UTF8String; }
 146 UniversalString         { return kw_UniversalString; }
 147 VideotexString          { return kw_VideotexString; }
 148 VisibleString           { return kw_VisibleString; }
 149 WITH                    { return kw_WITH; }
 150 [-,;{}()|]              { return *yytext; }
 151 "["                     { return *yytext; }
 152 "]"                     { return *yytext; }
 153 ::=                     { return EEQUAL; }
 154 --                      {
 155                             int c, start_lineno = lineno;
 156                             int f = 0;
 157                             while((c = input()) != EOF) {
 158                                 if(f && c == '-')
 159                                     break;
 160                                 if(c == '-') {
 161                                     f = 1;
 162                                     continue;
 163                                 }
 164                                 if(c == '\n') {
 165                                     lineno++;
 166                                     break;
 167                                 }
 168                                 f = 0;
 169                             }
 170                             if(c == EOF)
 171                                 unterminated("comment", start_lineno);
 172                         }
 173 \/\*                    {
 174                             int c, start_lineno = lineno;
 175                             int level = 1;
 176                             int seen_star = 0;
 177                             int seen_slash = 0;
 178                             while((c = input()) != EOF) {
 179                                 if(c == '/') {
 180                                     if(seen_star) {
 181                                         if(--level == 0)
 182                                             break;
 183                                         seen_star = 0;
 184                                         continue;
 185                                     }
 186                                     seen_slash = 1;
 187                                     continue;
 188                                 }
 189                                 if(seen_star && c == '/') {
 190                                     if(--level == 0)
 191                                         break;
 192                                     seen_star = 0;
 193                                     continue;
 194                                 }
 195                                 if(c == '*') {
 196                                     if(seen_slash) {
 197                                         level++;
 198                                         seen_star = seen_slash = 0;
 199                                         continue;
 200                                     }
 201                                     seen_star = 1;
 202                                     continue;
 203                                 }
 204                                 seen_star = seen_slash = 0;
 205                                 if(c == '\n') {
 206                                     lineno++;
 207                                     continue;
 208                                 }
 209                             }
 210                             if(c == EOF)
 211                                 unterminated("comment", start_lineno);
 212                         }
 213 "\""                    {
 214                             int start_lineno = lineno;
 215                             int c;
 216                             char buf[1024];
 217                             char *p = buf;
 218                             int f = 0;
 219                             int skip_ws = 0;
 220
 221                             while((c = input()) != EOF) {
 222                                 if(isspace(c) && skip_ws) {
 223                                     if(c == '\n')
 224                                         lineno++;
 225                                     continue;
 226                                 }
 227                                 skip_ws = 0;
 228
 229                                 if(c == '"') {
 230                                     if(f) {
 231                                         *p++ = '"';
 232                                         f = 0;
 233                                     } else
 234                                         f = 1;
 235                                     continue;
 236                                 }
 237                                 if(f == 1) {
 238                                     unput(c);
 239                                     break;
 240                                 }
 241                                 if(c == '\n') {
 242                                     lineno++;
 243                                     while(p > buf && isspace((unsigned char)p[-1]))
 244                                         p--;
 245                                     skip_ws = 1;
 246                                     continue;
 247                                 }
 248                                 *p++ = c;
 249                             }
 250                             if(c == EOF)
 251                                 unterminated("string", start_lineno);
 252                             *p++ = '\0';
 253                             fprintf(stderr, "string -- %s\n", buf);
 254                             yylval.name = estrdup(buf);
 255                             return STRING;
 256                         }
 257
 258 -?0x[0-9A-Fa-f]+|-?[0-9]+ { char *e, *y = yytext;
 259                           yylval.constant = strtoll((const char *)yytext,
 260                                                    &e, 0);
 261                           if(e == y)
 262                             lex_error_message("malformed constant (%s)", yytext);
 263                           else
 264                             return NUMBER;
 265                         }
 266 [A-Za-z][-A-Za-z0-9_]*  {
 267                           yylval.name =  estrdup ((const char *)yytext);
 268                           return IDENTIFIER;
 269                         }
 270 [ \t]                   ;
 271 \n                      { ++lineno; }
 272 \.\.\.                  { return ELLIPSIS; }
 273 \.\.                    { return RANGE; }
 274 .                       { lex_error_message("Ignoring char(%c)\n", *yytext); }
 275 %%
 276
 277 #ifndef yywrap /* XXX */
 278 int
 279 yywrap ()
 280 {
 281      return 1;
 282 }
 283 #endif
 284
 285 void
 286 lex_error_message (const char *format, ...)
 287 {
 288     va_list args;
 289
 290     va_start (args, format);
 291     fprintf (stderr, "%s:%d: ", get_filename(), lineno);
 292     vfprintf (stderr, format, args);
 293     va_end (args);
 294     error_flag++;
 295 }
 296
 297 static void
 298 unterminated(const char *type, unsigned start_lineno)
 299 {
 300     lex_error_message("unterminated %s, possibly started on line %d\n", type, start_lineno);
 301 }