| blob | 54872dde9474ea49a1c73296b77441569ba6a818 |
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 */
35 /* $Heimdal: lex.l 18738 2006-10-21 11:57:22Z lha $
36 $NetBSD$ */
38 #ifdef HAVE_CONFIG_H
39 #include <config.h>
40 #endif
41 #include <stdio.h>
42 #include <stdarg.h>
43 #include <stdlib.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 "parse.h"
51 #include "lex.h"
52 #include "gen_locl.h"
54 static unsigned lineno = 1;
56 #undef ECHO
58 static void unterminated(const char *, unsigned);
60 %}
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
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;
221 while((c = input()) != EOF) {
222 if(isspace(c) && skip_ws) {
223 if(c == '\n')
224 lineno++;
225 continue;
226 }
227 skip_ws = 0;
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 }
258 -?0x[0-9A-Fa-f]+|-?[0-9]+ { char *e, *y = yytext;
259 yylval.constant = strtol((const char *)yytext,
260 &e, 0);
261 if(e == y)
262 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 . { error_message("Ignoring char(%c)\n", *yytext); }
275 %%
277 #ifndef yywrap /* XXX */
278 int
279 yywrap ()
280 {
281 return 1;
282 }
283 #endif
285 void
286 error_message (const char *format, ...)
287 {
288 va_list args;
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 }
297 static void
298 unterminated(const char *type, unsigned start_lineno)
299 {
300 error_message("unterminated %s, possibly started on line %d\n", type, start_lineno);
301 }