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 <string.h> 44 #ifdef HAVE_UNISTD_H 45 #include <unistd.h> 46 #endif 47 #undef ECHO 48 #include "symbol.h" 49 #include "asn1parse.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 lex_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 . { lex_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 lex_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 lex_error_message("unterminated %s, possibly started on line %d\n", type, start_lineno); 300 } 301