301 lines
7.7 KiB
Plaintext
301 lines
7.7 KiB
Plaintext
%{
|
|
/*
|
|
* Copyright (c) 1997 - 2005 Kungliga Tekniska Högskolan
|
|
* (Royal Institute of Technology, Stockholm, Sweden).
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the Institute nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
/* $Id$ */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#undef ECHO
|
|
#include "symbol.h"
|
|
#include "asn1parse.h"
|
|
#include "lex.h"
|
|
#include "gen_locl.h"
|
|
|
|
static unsigned lineno = 1;
|
|
|
|
#undef ECHO
|
|
|
|
static void unterminated(const char *, unsigned);
|
|
|
|
%}
|
|
|
|
/* This is for broken old lexes (solaris 10 and hpux) */
|
|
%e 2000
|
|
%p 5000
|
|
%a 5000
|
|
%n 1000
|
|
%o 10000
|
|
|
|
%%
|
|
ABSENT { return kw_ABSENT; }
|
|
ABSTRACT-SYNTAX { return kw_ABSTRACT_SYNTAX; }
|
|
ALL { return kw_ALL; }
|
|
APPLICATION { return kw_APPLICATION; }
|
|
AUTOMATIC { return kw_AUTOMATIC; }
|
|
BEGIN { return kw_BEGIN; }
|
|
BIT { return kw_BIT; }
|
|
BMPString { return kw_BMPString; }
|
|
BOOLEAN { return kw_BOOLEAN; }
|
|
BY { return kw_BY; }
|
|
CHARACTER { return kw_CHARACTER; }
|
|
CHOICE { return kw_CHOICE; }
|
|
CLASS { return kw_CLASS; }
|
|
COMPONENT { return kw_COMPONENT; }
|
|
COMPONENTS { return kw_COMPONENTS; }
|
|
CONSTRAINED { return kw_CONSTRAINED; }
|
|
CONTAINING { return kw_CONTAINING; }
|
|
DEFAULT { return kw_DEFAULT; }
|
|
DEFINITIONS { return kw_DEFINITIONS; }
|
|
EMBEDDED { return kw_EMBEDDED; }
|
|
ENCODED { return kw_ENCODED; }
|
|
END { return kw_END; }
|
|
ENUMERATED { return kw_ENUMERATED; }
|
|
EXCEPT { return kw_EXCEPT; }
|
|
EXPLICIT { return kw_EXPLICIT; }
|
|
EXPORTS { return kw_EXPORTS; }
|
|
EXTENSIBILITY { return kw_EXTENSIBILITY; }
|
|
EXTERNAL { return kw_EXTERNAL; }
|
|
FALSE { return kw_FALSE; }
|
|
FROM { return kw_FROM; }
|
|
GeneralString { return kw_GeneralString; }
|
|
GeneralizedTime { return kw_GeneralizedTime; }
|
|
GraphicString { return kw_GraphicString; }
|
|
IA5String { return kw_IA5String; }
|
|
IDENTIFIER { return kw_IDENTIFIER; }
|
|
IMPLICIT { return kw_IMPLICIT; }
|
|
IMPLIED { return kw_IMPLIED; }
|
|
IMPORTS { return kw_IMPORTS; }
|
|
INCLUDES { return kw_INCLUDES; }
|
|
INSTANCE { return kw_INSTANCE; }
|
|
INTEGER { return kw_INTEGER; }
|
|
INTERSECTION { return kw_INTERSECTION; }
|
|
ISO646String { return kw_ISO646String; }
|
|
MAX { return kw_MAX; }
|
|
MIN { return kw_MIN; }
|
|
MINUS-INFINITY { return kw_MINUS_INFINITY; }
|
|
NULL { return kw_NULL; }
|
|
NumericString { return kw_NumericString; }
|
|
OBJECT { return kw_OBJECT; }
|
|
OCTET { return kw_OCTET; }
|
|
OF { return kw_OF; }
|
|
OPTIONAL { return kw_OPTIONAL; }
|
|
ObjectDescriptor { return kw_ObjectDescriptor; }
|
|
PATTERN { return kw_PATTERN; }
|
|
PDV { return kw_PDV; }
|
|
PLUS-INFINITY { return kw_PLUS_INFINITY; }
|
|
PRESENT { return kw_PRESENT; }
|
|
PRIVATE { return kw_PRIVATE; }
|
|
PrintableString { return kw_PrintableString; }
|
|
REAL { return kw_REAL; }
|
|
RELATIVE_OID { return kw_RELATIVE_OID; }
|
|
SEQUENCE { return kw_SEQUENCE; }
|
|
SET { return kw_SET; }
|
|
SIZE { return kw_SIZE; }
|
|
STRING { return kw_STRING; }
|
|
SYNTAX { return kw_SYNTAX; }
|
|
T61String { return kw_T61String; }
|
|
TAGS { return kw_TAGS; }
|
|
TRUE { return kw_TRUE; }
|
|
TYPE-IDENTIFIER { return kw_TYPE_IDENTIFIER; }
|
|
TeletexString { return kw_TeletexString; }
|
|
UNION { return kw_UNION; }
|
|
UNIQUE { return kw_UNIQUE; }
|
|
UNIVERSAL { return kw_UNIVERSAL; }
|
|
UTCTime { return kw_UTCTime; }
|
|
UTF8String { return kw_UTF8String; }
|
|
UniversalString { return kw_UniversalString; }
|
|
VideotexString { return kw_VideotexString; }
|
|
VisibleString { return kw_VisibleString; }
|
|
WITH { return kw_WITH; }
|
|
[-,;{}()|] { return *yytext; }
|
|
"[" { return *yytext; }
|
|
"]" { return *yytext; }
|
|
::= { return EEQUAL; }
|
|
-- {
|
|
int c, start_lineno = lineno;
|
|
int f = 0;
|
|
while((c = input()) != EOF) {
|
|
if(f && c == '-')
|
|
break;
|
|
if(c == '-') {
|
|
f = 1;
|
|
continue;
|
|
}
|
|
if(c == '\n') {
|
|
lineno++;
|
|
break;
|
|
}
|
|
f = 0;
|
|
}
|
|
if(c == EOF)
|
|
unterminated("comment", start_lineno);
|
|
}
|
|
\/\* {
|
|
int c, start_lineno = lineno;
|
|
int level = 1;
|
|
int seen_star = 0;
|
|
int seen_slash = 0;
|
|
while((c = input()) != EOF) {
|
|
if(c == '/') {
|
|
if(seen_star) {
|
|
if(--level == 0)
|
|
break;
|
|
seen_star = 0;
|
|
continue;
|
|
}
|
|
seen_slash = 1;
|
|
continue;
|
|
}
|
|
if(seen_star && c == '/') {
|
|
if(--level == 0)
|
|
break;
|
|
seen_star = 0;
|
|
continue;
|
|
}
|
|
if(c == '*') {
|
|
if(seen_slash) {
|
|
level++;
|
|
seen_star = seen_slash = 0;
|
|
continue;
|
|
}
|
|
seen_star = 1;
|
|
continue;
|
|
}
|
|
seen_star = seen_slash = 0;
|
|
if(c == '\n') {
|
|
lineno++;
|
|
continue;
|
|
}
|
|
}
|
|
if(c == EOF)
|
|
unterminated("comment", start_lineno);
|
|
}
|
|
"\"" {
|
|
int start_lineno = lineno;
|
|
int c;
|
|
char buf[1024];
|
|
char *p = buf;
|
|
int f = 0;
|
|
int skip_ws = 0;
|
|
|
|
while((c = input()) != EOF) {
|
|
if(isspace(c) && skip_ws) {
|
|
if(c == '\n')
|
|
lineno++;
|
|
continue;
|
|
}
|
|
skip_ws = 0;
|
|
|
|
if(c == '"') {
|
|
if(f) {
|
|
*p++ = '"';
|
|
f = 0;
|
|
} else
|
|
f = 1;
|
|
continue;
|
|
}
|
|
if(f == 1) {
|
|
unput(c);
|
|
break;
|
|
}
|
|
if(c == '\n') {
|
|
lineno++;
|
|
while(p > buf && isspace((unsigned char)p[-1]))
|
|
p--;
|
|
skip_ws = 1;
|
|
continue;
|
|
}
|
|
*p++ = c;
|
|
}
|
|
if(c == EOF)
|
|
unterminated("string", start_lineno);
|
|
*p++ = '\0';
|
|
fprintf(stderr, "string -- %s\n", buf);
|
|
yylval.name = estrdup(buf);
|
|
return STRING;
|
|
}
|
|
|
|
-?0x[0-9A-Fa-f]+|-?[0-9]+ { char *e, *y = yytext;
|
|
yylval.constant = strtol((const char *)yytext,
|
|
&e, 0);
|
|
if(e == y)
|
|
lex_error_message("malformed constant (%s)", yytext);
|
|
else
|
|
return NUMBER;
|
|
}
|
|
[A-Za-z][-A-Za-z0-9_]* {
|
|
yylval.name = estrdup ((const char *)yytext);
|
|
return IDENTIFIER;
|
|
}
|
|
[ \t] ;
|
|
\n { ++lineno; }
|
|
\.\.\. { return ELLIPSIS; }
|
|
\.\. { return RANGE; }
|
|
. { lex_error_message("Ignoring char(%c)\n", *yytext); }
|
|
%%
|
|
|
|
#ifndef yywrap /* XXX */
|
|
int
|
|
yywrap ()
|
|
{
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
void
|
|
lex_error_message (const char *format, ...)
|
|
{
|
|
va_list args;
|
|
|
|
va_start (args, format);
|
|
fprintf (stderr, "%s:%d: ", get_filename(), lineno);
|
|
vfprintf (stderr, format, args);
|
|
va_end (args);
|
|
error_flag++;
|
|
}
|
|
|
|
static void
|
|
unterminated(const char *type, unsigned start_lineno)
|
|
{
|
|
lex_error_message("unterminated %s, possibly started on line %d\n", type, start_lineno);
|
|
}
|