Convert some more files to GPLv3.
[jra/samba/.git] / 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 }