← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source4/build/pasn1/asn1.yp

  • 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/build/pasn1/asn1.yp
 
1
########################
 
2
# ASN.1 Parse::Yapp parser
 
3
# Copyright (C) Stefan (metze) Metzmacher <metze@samba.org>
 
4
# released under the GNU GPL version 3 or later
 
5
 
 
6
 
 
7
 
 
8
# the precedence actually doesn't matter at all for this grammer, but
 
9
# by providing a precedence we reduce the number of conflicts
 
10
# enormously
 
11
%left   '-' '+' '&' '|' '*' '>' '.' '/' '(' ')' '[' ']' ':' ',' ';'
 
12
 
 
13
 
 
14
################
 
15
# grammer
 
16
%%
 
17
 
 
18
asn1: 
 
19
        identifier asn1_definitions asn1_delimitter asn1_begin asn1_decls asn1_end
 
20
                {{
 
21
                        "OBJECT"        =>      "ASN1_DEFINITION",
 
22
                        "IDENTIFIER"    =>      $_[1],
 
23
                        "DATA"          =>      $_[5]
 
24
                }}
 
25
;
 
26
 
 
27
asn1_delimitter: 
 
28
        delimitter
 
29
;
 
30
 
 
31
asn1_definitions:
 
32
        'DEFINITIONS'
 
33
;
 
34
 
 
35
asn1_begin:
 
36
        'BEGIN'
 
37
;
 
38
 
 
39
asn1_end:
 
40
        'END'
 
41
;
 
42
 
 
43
asn1_decls:
 
44
        asn1_def
 
45
                { [ $_[1] ] }
 
46
        | asn1_decls asn1_def 
 
47
                { push(@{$_[1]}, $_[2]); $_[1] }
 
48
;
 
49
 
 
50
 
 
51
 
 
52
asn1_def: 
 
53
        asn1_target asn1_delimitter asn1_application asn1_type
 
54
                {{ 
 
55
                    "OBJECT"            => "ASN1_DEF",
 
56
                    "IDENTIFIER"        => $_[1],
 
57
                    "APPLICATION"       => $_[3],
 
58
                    "STRUCTURE"         => $_[4]
 
59
                }}
 
60
;
 
61
 
 
62
asn1_target:
 
63
        identifier
 
64
;
 
65
 
 
66
asn1_application:
 
67
        #empty
 
68
        | '[' 'APPLICATION' constant ']'
 
69
                { $_[3] }
 
70
;
 
71
 
 
72
asn1_type: 
 
73
        asn1_boolean
 
74
        | asn1_integer
 
75
        | asn1_bit_string
 
76
        | asn1_octet_string
 
77
        | asn1_null
 
78
        | asn1_object_identifier
 
79
        | asn1_real
 
80
        | asn1_enumerated
 
81
        | asn1_sequence
 
82
        | identifier
 
83
;
 
84
 
 
85
asn1_boolean:
 
86
        'BOOLEAN'
 
87
                {{
 
88
                        "TYPE"          => "BOOLEAN",
 
89
                        "TAG"           => 1
 
90
                }}
 
91
;
 
92
 
 
93
asn1_integer:
 
94
        'INTEGER'
 
95
                {{
 
96
                        "TYPE"          => "INTEGER",
 
97
                        "TAG"           => 2
 
98
                }}
 
99
        | 'INTEGER' '(' constant '.' '.' constant ')'
 
100
                {{
 
101
                        "TYPE"          => "INTEGER",
 
102
                        "TAG"           => 2,
 
103
                        "RANGE_LOW"     => $_[3],
 
104
                        "RENAGE_HIGH"   => $_[6]
 
105
                }}
 
106
;
 
107
 
 
108
asn1_bit_string:
 
109
        'BIT' 'STRING'
 
110
                {{
 
111
                        "TYPE"          => "BIT STRING",
 
112
                        "TAG"           => 3
 
113
                }}
 
114
;
 
115
 
 
116
asn1_octet_string:
 
117
        'OCTET' 'STRING'
 
118
                {{
 
119
                        "TYPE"          => "OCTET STRING",
 
120
                        "TAG"           => 4
 
121
                }}
 
122
;
 
123
 
 
124
asn1_null:
 
125
        'NULL'
 
126
                {{
 
127
                        "TYPE"          => "NULL",
 
128
                        "TAG"           => 5
 
129
                }}
 
130
;
 
131
 
 
132
asn1_object_identifier:
 
133
        'OBJECT' 'IDENTIFIER'
 
134
                {{
 
135
                        "TYPE"          => "OBJECT IDENTIFIER",
 
136
                        "TAG"           => 6
 
137
                }}
 
138
;
 
139
 
 
140
asn1_real:
 
141
        'REAL'
 
142
                {{
 
143
                        "TYPE"          => "REAL",
 
144
                        "TAG"           => 9
 
145
                }}
 
146
;
 
147
 
 
148
asn1_enumerated:
 
149
        'ENUMERATED'
 
150
                {{
 
151
                        "TYPE"          => "ENUMERATED",
 
152
                        "TAG"           => 10
 
153
                }}
 
154
;
 
155
 
 
156
asn1_sequence:
 
157
        'SEQUENCE' '{' asn1_var_dec_list '}'
 
158
                {{
 
159
                        "TYPE"          => "SEQUENCE",
 
160
                        "TAG"           => 16,
 
161
                        "STRUCTURE"     => $_[3]
 
162
                }}
 
163
;
 
164
 
 
165
asn1_var_dec_list:
 
166
        asn1_var_dec
 
167
                { [ $_[1] ] }
 
168
        | asn1_var_dec_list ',' asn1_var_dec 
 
169
                { push(@{$_[1]}, $_[3]); $_[1]  }
 
170
;
 
171
 
 
172
asn1_var_dec: 
 
173
        identifier asn1_type
 
174
        {{
 
175
                "NAME" => $_[1],
 
176
                "TYPE" => $_[2]
 
177
        }}
 
178
;
 
179
 
 
180
anytext:  #empty { "" }
 
181
    | identifier | constant | text
 
182
    | anytext '-' anytext  { "$_[1]$_[2]$_[3]" }
 
183
    | anytext '.' anytext  { "$_[1]$_[2]$_[3]" }
 
184
    | anytext '*' anytext  { "$_[1]$_[2]$_[3]" }
 
185
    | anytext '>' anytext  { "$_[1]$_[2]$_[3]" }
 
186
    | anytext '|' anytext  { "$_[1]$_[2]$_[3]" }
 
187
    | anytext '&' anytext  { "$_[1]$_[2]$_[3]" }
 
188
    | anytext '/' anytext  { "$_[1]$_[2]$_[3]" }
 
189
    | anytext '+' anytext  { "$_[1]$_[2]$_[3]" }
 
190
    | anytext '(' anytext ')' anytext  { "$_[1]$_[2]$_[3]$_[4]$_[5]" }
 
191
;
 
192
 
 
193
delimitter: DELIMITTER
 
194
;
 
195
 
 
196
identifier: IDENTIFIER
 
197
;
 
198
 
 
199
constant: CONSTANT
 
200
;
 
201
 
 
202
text: TEXT { "\"$_[1]\"" }
 
203
;
 
204
 
 
205
#####################################
 
206
# start code
 
207
%%
 
208
 
 
209
use util;
 
210
 
 
211
sub _ASN1_Error {
 
212
        if (exists $_[0]->YYData->{ERRMSG}) {
 
213
                print $_[0]->YYData->{ERRMSG};
 
214
                delete $_[0]->YYData->{ERRMSG};
 
215
                return;
 
216
        };
 
217
        my $line = $_[0]->YYData->{LINE};
 
218
        my $last_token = $_[0]->YYData->{LAST_TOKEN};
 
219
        my $file = $_[0]->YYData->{INPUT_FILENAME};
 
220
        
 
221
        print "$file:$line: Syntax error near '$last_token'\n";
 
222
}
 
223
 
 
224
sub _ASN1_Lexer($)
 
225
{
 
226
        my($parser)=shift;
 
227
 
 
228
        $parser->YYData->{INPUT}
 
229
        or  return('',undef);
 
230
 
 
231
again:
 
232
        $parser->YYData->{INPUT} =~ s/^[ \t]*//;
 
233
 
 
234
        for ($parser->YYData->{INPUT}) {
 
235
                if (/^\#/) {
 
236
                        if (s/^\# (\d+) \"(.*?)\"( \d+|)//) {
 
237
                                $parser->YYData->{LINE} = $1-1;
 
238
                                $parser->YYData->{INPUT_FILENAME} = $2;
 
239
                                goto again;
 
240
                        }
 
241
                        if (s/^\#line (\d+) \"(.*?)\"( \d+|)//) {
 
242
                                $parser->YYData->{LINE} = $1-1;
 
243
                                $parser->YYData->{INPUT_FILENAME} = $2;
 
244
                                goto again;
 
245
                        }
 
246
                        if (s/^(\#.*)$//m) {
 
247
                                goto again;
 
248
                        }
 
249
                }
 
250
                if (s/^(\n)//) {
 
251
                        $parser->YYData->{LINE}++;
 
252
                        goto again;
 
253
                }
 
254
                if (s/^(--.*\n)//) {
 
255
                        $parser->YYData->{LINE}++;
 
256
                        goto again;
 
257
                }
 
258
                if (s/^(::=)//) {
 
259
                        $parser->YYData->{LAST_TOKEN} = $1;
 
260
                        return('DELIMITTER',$1); 
 
261
                }
 
262
                if (s/^\"(.*?)\"//) {
 
263
                        $parser->YYData->{LAST_TOKEN} = $1;
 
264
                        return('TEXT',$1); 
 
265
                }
 
266
                if (s/^(\d+)(\W|$)/$2/) {
 
267
                        $parser->YYData->{LAST_TOKEN} = $1;
 
268
                        return('CONSTANT',$1); 
 
269
                }
 
270
                if (s/^([\w_-]+)//) {
 
271
                        $parser->YYData->{LAST_TOKEN} = $1;
 
272
                        if ($1 =~ 
 
273
                            /^(SEQUENCE|INTEGER|OCTET|STRING|
 
274
                               APPLICATION|OPTIONAL|NULL|COMPONENTS|OF|
 
275
                               BOOLEAN|ENUMERATED|CHOISE|REAL|BIT|OBJECT|IDENTIFIER|
 
276
                               DEFAULT|FALSE|TRUE|SET|DEFINITIONS|BEGIN|END)$/x) {
 
277
                                return $1;
 
278
                        }
 
279
                        return('IDENTIFIER',$1);
 
280
                }
 
281
                if (s/^(.)//s) {
 
282
                        $parser->YYData->{LAST_TOKEN} = $1;
 
283
                        return($1,$1);
 
284
                }
 
285
        }
 
286
}
 
287
 
 
288
sub parse_asn1($$)
 
289
{
 
290
        my $self = shift;
 
291
        my $filename = shift;
 
292
 
 
293
        my $saved_delim = $/;
 
294
        undef $/;
 
295
        my $cpp = $ENV{CPP};
 
296
        if (! defined $cpp) {
 
297
                $cpp = "cpp"
 
298
        }
 
299
        my $data = `$cpp -xc $filename`;
 
300
        $/ = $saved_delim;
 
301
 
 
302
        $self->YYData->{INPUT} = $data;
 
303
        $self->YYData->{LINE} = 0;
 
304
        $self->YYData->{LAST_TOKEN} = "NONE";
 
305
        return $self->YYParse( yylex => \&_ASN1_Lexer, yyerror => \&_ASN1_Error );
 
306
}