← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source4/heimdal/lib/asn1/lex.l

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
source4/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$ */
 
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
}