source/heimdal/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: lex.l,v 1.31 2006/10/21 11:57:22 lha Exp $ */
  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 <string.h>
  44 #ifdef HAVE_UNISTD_H
  45 #include <unistd.h>
  46 #endif
  47 #undef ECHO
  48 #include "symbol.h"
  49 #include "parse.h"
  50 #include "lex.h"
  51 #include "gen_locl.h"
  52
  53 static unsigned lineno = 1;
  54
  55 #undef ECHO
  56
  57 static void unterminated(const char *, unsigned);
  58
  59 %}
  60
  61 /* This is for broken old lexes (solaris 10 and hpux) */
  62 %e 2000
  63 %p 5000
  64 %a 5000
  65 %n 1000
  66 %o 10000
  67
  68 %%
  69 ABSENT                  { return kw_ABSENT; }
  70 ABSTRACT-SYNTAX         { return kw_ABSTRACT_SYNTAX; }
  71 ALL                     { return kw_ALL; }
  72 APPLICATION             { return kw_APPLICATION; }
  73 AUTOMATIC               { return kw_AUTOMATIC; }
  74 BEGIN                   { return kw_BEGIN; }
  75 BIT                     { return kw_BIT; }
  76 BMPString               { return kw_BMPString; }
  77 BOOLEAN                 { return kw_BOOLEAN; }
  78 BY                      { return kw_BY; }
  79 CHARACTER               { return kw_CHARACTER; }
  80 CHOICE                  { return kw_CHOICE; }
  81 CLASS                   { return kw_CLASS; }
  82 COMPONENT               { return kw_COMPONENT; }
  83 COMPONENTS              { return kw_COMPONENTS; }
  84 CONSTRAINED             { return kw_CONSTRAINED; }
  85 CONTAINING              { return kw_CONTAINING; }
  86 DEFAULT                 { return kw_DEFAULT; }
  87 DEFINITIONS             { return kw_DEFINITIONS; }
  88 EMBEDDED                { return kw_EMBEDDED; }
  89 ENCODED                 { return kw_ENCODED; }
  90 END                     { return kw_END; }
  91 ENUMERATED              { return kw_ENUMERATED; }
  92 EXCEPT                  { return kw_EXCEPT; }
  93 EXPLICIT                { return kw_EXPLICIT; }
  94 EXPORTS                 { return kw_EXPORTS; }
  95 EXTENSIBILITY           { return kw_EXTENSIBILITY; }
  96 EXTERNAL                { return kw_EXTERNAL; }
  97 FALSE                   { return kw_FALSE; }
  98 FROM                    { return kw_FROM; }
  99 GeneralString           { return kw_GeneralString; }
 100 GeneralizedTime         { return kw_GeneralizedTime; }
 101 GraphicString           { return kw_GraphicString; }
 102 IA5String               { return kw_IA5String; }
 103 IDENTIFIER              { return kw_IDENTIFIER; }
 104 IMPLICIT                { return kw_IMPLICIT; }
 105 IMPLIED                 { return kw_IMPLIED; }
 106 IMPORTS                 { return kw_IMPORTS; }
 107 INCLUDES                { return kw_INCLUDES; }
 108 INSTANCE                { return kw_INSTANCE; }
 109 INTEGER                 { return kw_INTEGER; }
 110 INTERSECTION            { return kw_INTERSECTION; }
 111 ISO646String            { return kw_ISO646String; }
 112 MAX                     { return kw_MAX; }
 113 MIN                     { return kw_MIN; }
 114 MINUS-INFINITY          { return kw_MINUS_INFINITY; }
 115 NULL                    { return kw_NULL; }
 116 NumericString           { return kw_NumericString; }
 117 OBJECT                  { return kw_OBJECT; }
 118 OCTET                   { return kw_OCTET; }
 119 OF                      { return kw_OF; }
 120 OPTIONAL                { return kw_OPTIONAL; }
 121 ObjectDescriptor        { return kw_ObjectDescriptor; }
 122 PATTERN                 { return kw_PATTERN; }
 123 PDV                     { return kw_PDV; }
 124 PLUS-INFINITY           { return kw_PLUS_INFINITY; }
 125 PRESENT                 { return kw_PRESENT; }
 126 PRIVATE                 { return kw_PRIVATE; }
 127 PrintableString         { return kw_PrintableString; }
 128 REAL                    { return kw_REAL; }
 129 RELATIVE_OID            { return kw_RELATIVE_OID; }
 130 SEQUENCE                { return kw_SEQUENCE; }
 131 SET                     { return kw_SET; }
 132 SIZE                    { return kw_SIZE; }
 133 STRING                  { return kw_STRING; }
 134 SYNTAX                  { return kw_SYNTAX; }
 135 T61String               { return kw_T61String; }
 136 TAGS                    { return kw_TAGS; }
 137 TRUE                    { return kw_TRUE; }
 138 TYPE-IDENTIFIER         { return kw_TYPE_IDENTIFIER; }
 139 TeletexString           { return kw_TeletexString; }
 140 UNION                   { return kw_UNION; }
 141 UNIQUE                  { return kw_UNIQUE; }
 142 UNIVERSAL               { return kw_UNIVERSAL; }
 143 UTCTime                 { return kw_UTCTime; }
 144 UTF8String              { return kw_UTF8String; }
 145 UniversalString         { return kw_UniversalString; }
 146 VideotexString          { return kw_VideotexString; }
 147 VisibleString           { return kw_VisibleString; }
 148 WITH                    { return kw_WITH; }
 149 [-,;{}()|]              { return *yytext; }
 150 "["                     { return *yytext; }
 151 "]"                     { return *yytext; }
 152 ::=                     { return EEQUAL; }
 153 --                      {
 154                             int c, start_lineno = lineno;
 155                             int f = 0;
 156                             while((c = input()) != EOF) {
 157                                 if(f && c == '-')
 158                                     break;
 159                                 if(c == '-') {
 160                                     f = 1;
 161                                     continue;
 162                                 }
 163                                 if(c == '\n') {
 164                                     lineno++;
 165                                     break;
 166                                 }
 167                                 f = 0;
 168                             }
 169                             if(c == EOF)
 170                                 unterminated("comment", start_lineno);
 171                         }
 172 \/\*                    {
 173                             int c, start_lineno = lineno;
 174                             int level = 1;
 175                             int seen_star = 0;
 176                             int seen_slash = 0;
 177                             while((c = input()) != EOF) {
 178                                 if(c == '/') {
 179                                     if(seen_star) {
 180                                         if(--level == 0)
 181                                             break;
 182                                         seen_star = 0;
 183                                         continue;
 184                                     }
 185                                     seen_slash = 1;
 186                                     continue;
 187                                 }
 188                                 if(seen_star && c == '/') {
 189                                     if(--level == 0)
 190                                         break;
 191                                     seen_star = 0;
 192                                     continue;
 193                                 }
 194                                 if(c == '*') {
 195                                     if(seen_slash) {
 196                                         level++;
 197                                         seen_star = seen_slash = 0;
 198                                         continue;
 199                                     }
 200                                     seen_star = 1;
 201                                     continue;
 202                                 }
 203                                 seen_star = seen_slash = 0;
 204                                 if(c == '\n') {
 205                                     lineno++;
 206                                     continue;
 207                                 }
 208                             }
 209                             if(c == EOF)
 210                                 unterminated("comment", start_lineno);
 211                         }
 212 "\""                    {
 213                             int start_lineno = lineno;
 214                             int c;
 215                             char buf[1024];
 216                             char *p = buf;
 217                             int f = 0;
 218                             int skip_ws = 0;
 219
 220                             while((c = input()) != EOF) {
 221                                 if(isspace(c) && skip_ws) {
 222                                     if(c == '\n')
 223                                         lineno++;
 224                                     continue;
 225                                 }
 226                                 skip_ws = 0;
 227
 228                                 if(c == '"') {
 229                                     if(f) {
 230                                         *p++ = '"';
 231                                         f = 0;
 232                                     } else
 233                                         f = 1;
 234                                     continue;
 235                                 }
 236                                 if(f == 1) {
 237                                     unput(c);
 238                                     break;
 239                                 }
 240                                 if(c == '\n') {
 241                                     lineno++;
 242                                     while(p > buf && isspace((unsigned char)p[-1]))
 243                                         p--;
 244                                     skip_ws = 1;
 245                                     continue;
 246                                 }
 247                                 *p++ = c;
 248                             }
 249                             if(c == EOF)
 250                                 unterminated("string", start_lineno);
 251                             *p++ = '\0';
 252                             fprintf(stderr, "string -- %s\n", buf);
 253                             yylval.name = estrdup(buf);
 254                             return STRING;
 255                         }
 256
 257 -?0x[0-9A-Fa-f]+|-?[0-9]+ { char *e, *y = yytext;
 258                           yylval.constant = strtol((const char *)yytext,
 259                                                    &e, 0);
 260                           if(e == y)
 261                             error_message("malformed constant (%s)", yytext);
 262                           else
 263                             return NUMBER;
 264                         }
 265 [A-Za-z][-A-Za-z0-9_]*  {
 266                           yylval.name =  estrdup ((const char *)yytext);
 267                           return IDENTIFIER;
 268                         }
 269 [ \t]                   ;
 270 \n                      { ++lineno; }
 271 \.\.\.                  { return ELLIPSIS; }
 272 \.\.                    { return RANGE; }
 273 .                       { error_message("Ignoring char(%c)\n", *yytext); }
 274 %%
 275
 276 #ifndef yywrap /* XXX */
 277 int
 278 yywrap ()
 279 {
 280      return 1;
 281 }
 282 #endif
 283
 284 void
 285 error_message (const char *format, ...)
 286 {
 287     va_list args;
 288
 289     va_start (args, format);
 290     fprintf (stderr, "%s:%d: ", get_filename(), lineno);
 291     vfprintf (stderr, format, args);
 292     va_end (args);
 293     error_flag++;
 294 }
 295
 296 static void
 297 unterminated(const char *type, unsigned start_lineno)
 298 {
 299     error_message("unterminated %s, possibly started on line %d\n", type, start_lineno);
 300 }