← Index
NYTProf Performance Profile   « block view • line view • sub view »
For /usr/share/koha/opac/cgi-bin/opac/opac-search.pl
  Run on Tue Oct 15 11:58:52 2013
Reported on Tue Oct 15 12:01:07 2013

Filename/usr/share/perl5/Convert/ASN1/parser.pm
StatementsExecuted 76189 statements in 107ms
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
11150.3ms95.8msConvert::ASN1::parser::::yyparseConvert::ASN1::parser::yyparse
12441130.9ms45.5msConvert::ASN1::parser::::yylexConvert::ASN1::parser::yylex
24703112.5ms12.5msConvert::ASN1::parser::::CORE:matchConvert::ASN1::parser::CORE:match (opcode)
320314.98ms5.16msConvert::ASN1::parser::::compile_oneConvert::ASN1::parser::compile_one (recurses: max depth 10, inclusive time 13.2ms)
1111.70ms1.77msConvert::ASN1::parser::::verifyConvert::ASN1::parser::verify
2379111.35ms1.35msConvert::ASN1::parser::::CORE:regcompConvert::ASN1::parser::CORE:regcomp (opcode)
111257µs5.42msConvert::ASN1::parser::::compileConvert::ASN1::parser::compile
1811105µs105µsConvert::ASN1::parser::::CORE:substConvert::ASN1::parser::CORE:subst (opcode)
41174µs74µsConvert::ASN1::parser::::expand_opsConvert::ASN1::parser::expand_ops
11164µs103msConvert::ASN1::parser::::parseConvert::ASN1::parser::parse
11119µs24µsConvert::ASN1::parser::::BEGIN@9Convert::ASN1::parser::BEGIN@9
11116µs105µsConvert::ASN1::parser::::BEGIN@16Convert::ASN1::parser::BEGIN@16
11115µs606µsConvert::ASN1::parser::::BEGIN@10Convert::ASN1::parser::BEGIN@10
11114µs194µsConvert::ASN1::parser::::BEGIN@11Convert::ASN1::parser::BEGIN@11
11110µs10µsConvert::ASN1::parser::::CORE:sortConvert::ASN1::parser::CORE:sort (opcode)
0000s0sConvert::ASN1::parser::::YYERRORConvert::ASN1::parser::YYERROR
0000s0sConvert::ASN1::parser::::_yylexConvert::ASN1::parser::_yylex
0000s0sConvert::ASN1::parser::::explicitConvert::ASN1::parser::explicit
0000s0sConvert::ASN1::parser::::yy_err_recoverConvert::ASN1::parser::yy_err_recover
0000s0sConvert::ASN1::parser::::yyclearinConvert::ASN1::parser::yyclearin
0000s0sConvert::ASN1::parser::::yyerrokConvert::ASN1::parser::yyerrok
0000s0sConvert::ASN1::parser::::yyerrorConvert::ASN1::parser::yyerror
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1#$yysccsid = "@(#)yaccpar 1.8 (Berkeley) 01/20/91 (Perl 2.0 12/31/92)";
2# 23 "parser.y"
3;# Copyright (c) 2000-2005 Graham Barr <gbarr@pobox.com>. All rights reserved.
4;# This program is free software; you can redistribute it and/or
5;# modify it under the same terms as Perl itself.
6
7package Convert::ASN1::parser;
8
9331µs228µs
# spent 24µs (19+4) within Convert::ASN1::parser::BEGIN@9 which was called: # once (19µs+4µs) by Convert::ASN1::BEGIN@415 at line 9
use strict;
# spent 24µs making 1 call to Convert::ASN1::parser::BEGIN@9 # spent 4µs making 1 call to strict::import
10351µs21.20ms
# spent 606µs (15+591) within Convert::ASN1::parser::BEGIN@10 which was called: # once (15µs+591µs) by Convert::ASN1::BEGIN@415 at line 10
use Convert::ASN1 qw(:all);
# spent 606µs making 1 call to Convert::ASN1::parser::BEGIN@10 # spent 591µs making 1 call to Exporter::import
111180µs
# spent 194µs (14+180) within Convert::ASN1::parser::BEGIN@11 which was called: # once (14µs+180µs) by Convert::ASN1::BEGIN@415 at line 14
use vars qw(
# spent 180µs making 1 call to vars::import
12 $asn $yychar $yyerrflag $yynerrs $yyn @yyss
13 $yyssp $yystate @yyvs $yyvsp $yylval $yys $yym $yyval
14343µs1194µs);
# spent 194µs making 1 call to Convert::ASN1::parser::BEGIN@11
15
1614.42ms2195µs
# spent 105µs (16+89) within Convert::ASN1::parser::BEGIN@16 which was called: # once (16µs+89µs) by Convert::ASN1::BEGIN@415 at line 16
BEGIN { Convert::ASN1->_internal_syms }
# spent 105µs making 1 call to Convert::ASN1::parser::BEGIN@16 # spent 89µs making 1 call to Convert::ASN1::_internal_syms
17
181600nsmy $yydebug=0;
191200nsmy %yystate;
20
21178µs3142µsmy %base_type = (
# spent 42µs making 31 calls to Convert::ASN1::asn_encode_tag, avg 1µs/call
22 BOOLEAN => [ asn_encode_tag(ASN_BOOLEAN), opBOOLEAN ],
23 INTEGER => [ asn_encode_tag(ASN_INTEGER), opINTEGER ],
24 BIT_STRING => [ asn_encode_tag(ASN_BIT_STR), opBITSTR ],
25 OCTET_STRING => [ asn_encode_tag(ASN_OCTET_STR), opSTRING ],
26 STRING => [ asn_encode_tag(ASN_OCTET_STR), opSTRING ],
27 NULL => [ asn_encode_tag(ASN_NULL), opNULL ],
28 OBJECT_IDENTIFIER => [ asn_encode_tag(ASN_OBJECT_ID), opOBJID ],
29 REAL => [ asn_encode_tag(ASN_REAL), opREAL ],
30 ENUMERATED => [ asn_encode_tag(ASN_ENUMERATED), opINTEGER ],
31 ENUM => [ asn_encode_tag(ASN_ENUMERATED), opINTEGER ],
32 'RELATIVE-OID' => [ asn_encode_tag(ASN_RELATIVE_OID), opROID ],
33
34 SEQUENCE => [ asn_encode_tag(ASN_SEQUENCE | ASN_CONSTRUCTOR), opSEQUENCE ],
35 SET => [ asn_encode_tag(ASN_SET | ASN_CONSTRUCTOR), opSET ],
36
37 ObjectDescriptor => [ asn_encode_tag(ASN_UNIVERSAL | 7), opSTRING ],
38 UTF8String => [ asn_encode_tag(ASN_UNIVERSAL | 12), opUTF8 ],
39 NumericString => [ asn_encode_tag(ASN_UNIVERSAL | 18), opSTRING ],
40 PrintableString => [ asn_encode_tag(ASN_UNIVERSAL | 19), opSTRING ],
41 TeletexString => [ asn_encode_tag(ASN_UNIVERSAL | 20), opSTRING ],
42 T61String => [ asn_encode_tag(ASN_UNIVERSAL | 20), opSTRING ],
43 VideotexString => [ asn_encode_tag(ASN_UNIVERSAL | 21), opSTRING ],
44 IA5String => [ asn_encode_tag(ASN_UNIVERSAL | 22), opSTRING ],
45 UTCTime => [ asn_encode_tag(ASN_UNIVERSAL | 23), opUTIME ],
46 GeneralizedTime => [ asn_encode_tag(ASN_UNIVERSAL | 24), opGTIME ],
47 GraphicString => [ asn_encode_tag(ASN_UNIVERSAL | 25), opSTRING ],
48 VisibleString => [ asn_encode_tag(ASN_UNIVERSAL | 26), opSTRING ],
49 ISO646String => [ asn_encode_tag(ASN_UNIVERSAL | 26), opSTRING ],
50 GeneralString => [ asn_encode_tag(ASN_UNIVERSAL | 27), opSTRING ],
51 CharacterString => [ asn_encode_tag(ASN_UNIVERSAL | 28), opSTRING ],
52 UniversalString => [ asn_encode_tag(ASN_UNIVERSAL | 28), opSTRING ],
53 BMPString => [ asn_encode_tag(ASN_UNIVERSAL | 30), opSTRING ],
54 BCDString => [ asn_encode_tag(ASN_OCTET_STR), opBCD ],
55
56 CHOICE => [ '', opCHOICE ],
57 ANY => [ '', opANY ],
58);
59
60;# Given an OP, wrap it in a SEQUENCE
61
62sub explicit {
63 my $op = shift;
64 my @seq = @$op;
65
66 @seq[cTYPE,cCHILD,cVAR,cLOOP] = ('SEQUENCE',[$op],undef,undef);
67 @{$op}[cTAG,cOPT] = ();
68
69 \@seq;
70}
71
72sub constWORD () { 1 }
73sub constCLASS () { 2 }
74sub constSEQUENCE () { 3 }
75sub constSET () { 4 }
76sub constCHOICE () { 5 }
77sub constOF () { 6 }
78sub constIMPLICIT () { 7 }
79sub constEXPLICIT () { 8 }
80sub constOPTIONAL () { 9 }
81sub constLBRACE () { 10 }
82sub constRBRACE () { 11 }
83sub constCOMMA () { 12 }
84sub constANY () { 13 }
85sub constASSIGN () { 14 }
86sub constNUMBER () { 15 }
87sub constENUM () { 16 }
88sub constCOMPONENTS () { 17 }
89sub constPOSTRBRACE () { 18 }
90sub constDEFINED () { 19 }
91sub constBY () { 20 }
92sub constYYERRCODE () { 256 }
9314µsmy @yylhs = ( -1,
94 0, 0, 2, 2, 3, 3, 6, 6, 6, 6,
95 8, 13, 13, 12, 14, 14, 14, 9, 9, 9,
96 10, 18, 18, 18, 18, 18, 19, 19, 11, 16,
97 16, 20, 20, 20, 21, 1, 1, 1, 22, 22,
98 22, 24, 24, 24, 24, 23, 23, 23, 15, 15,
99 4, 4, 5, 5, 5, 17, 17, 25, 7, 7,
100);
10113µsmy @yylen = ( 2,
102 1, 1, 3, 4, 4, 1, 1, 1, 1, 1,
103 3, 1, 1, 6, 1, 1, 1, 4, 4, 4,
104 4, 1, 1, 1, 2, 1, 0, 3, 1, 1,
105 2, 1, 3, 3, 4, 0, 1, 2, 1, 3,
106 3, 2, 1, 1, 1, 4, 1, 3, 0, 1,
107 0, 1, 0, 1, 1, 1, 3, 2, 0, 1,
108);
10915µsmy @yydefred = ( 0,
110 0, 52, 0, 0, 1, 0, 0, 47, 0, 39,
111 0, 0, 0, 0, 55, 54, 0, 0, 0, 3,
112 0, 6, 0, 11, 0, 0, 0, 0, 48, 0,
113 40, 41, 0, 22, 0, 0, 0, 0, 45, 43,
114 0, 44, 0, 29, 46, 4, 0, 0, 0, 0,
115 7, 8, 9, 10, 0, 25, 0, 50, 42, 0,
116 0, 0, 0, 0, 0, 32, 60, 5, 0, 0,
117 0, 56, 0, 18, 19, 0, 20, 0, 0, 28,
118 58, 21, 0, 0, 0, 34, 33, 57, 0, 0,
119 17, 15, 16, 0, 35, 14,
120);
12111µsmy @yydgoto = ( 4,
122 5, 6, 20, 7, 17, 50, 68, 8, 51, 52,
123 53, 54, 43, 94, 59, 64, 71, 44, 56, 65,
124 66, 9, 10, 45, 72,
125);
12619µsmy @yysindex = ( 7,
127 9, 0, 12, 0, 0, 19, 51, 0, 34, 0,
128 75, 51, 31, -1, 0, 0, 90, 55, 55, 0,
129 51, 0, 114, 0, 75, 26, 53, 61, 0, 77,
130 0, 0, 114, 0, 26, 53, 64, 76, 0, 0,
131 89, 0, 96, 0, 0, 0, 55, 55, 111, 103,
132 0, 0, 0, 0, 94, 0, 130, 0, 0, 77,
133 122, 128, 77, 141, 78, 0, 0, 0, 155, 147,
134 33, 0, 51, 0, 0, 51, 0, 111, 111, 0,
135 0, 0, 130, 119, 114, 0, 0, 0, 26, 53,
136 0, 0, 0, 89, 0, 0,
137);
13817µsmy @yyrindex = ( 150,
139 100, 0, 0, 0, 0, 166, 106, 0, 39, 0,
140 100, 133, 0, 0, 0, 0, 0, 165, 140, 0,
141 133, 0, 0, 0, 100, 0, 0, 0, 0, 100,
142 0, 0, 0, 0, 16, 29, 42, 69, 0, 0,
143 37, 0, 0, 0, 0, 0, 156, 156, 0, 125,
144 0, 0, 0, 0, 0, 0, 0, 0, 0, 100,
145 0, 0, 100, 0, 154, 0, 0, 0, 0, 0,
146 0, 0, 133, 0, 0, 133, 0, 0, 160, 0,
147 0, 0, 0, 0, 0, 0, 0, 0, 73, 88,
148 0, 0, 0, 3, 0, 0,
149);
15012µsmy @yygindex = ( 0,
151 28, 0, 149, 1, -11, 91, 0, 8, -17, -18,
152 -16, 152, 0, 0, 83, 0, 0, 0, 0, 0,
153 50, 0, 123, 0, 95,
154);
155sub constYYTABLESIZE () { 178 }
156111µsmy @yytable = ( 29,
157 23, 12, 49, 49, 40, 39, 41, 1, 2, 33,
158 2, 21, 25, 49, 49, 23, 23, 13, 22, 14,
159 49, 12, 11, 3, 23, 21, 23, 23, 24, 24,
160 12, 24, 22, 23, 13, 47, 49, 24, 37, 24,
161 24, 27, 27, 82, 83, 18, 24, 49, 49, 37,
162 27, 19, 27, 27, 49, 30, 2, 15, 16, 27,
163 73, 84, 48, 76, 85, 92, 91, 93, 26, 26,
164 49, 3, 23, 23, 61, 62, 2, 26, 2, 26,
165 26, 23, 55, 23, 23, 57, 26, 24, 24, 78,
166 23, 3, 26, 27, 28, 79, 24, 58, 24, 24,
167 51, 60, 51, 51, 51, 24, 51, 51, 53, 53,
168 53, 63, 51, 69, 34, 51, 35, 36, 28, 34,
169 67, 89, 90, 28, 59, 59, 37, 86, 87, 38,
170 70, 37, 74, 53, 38, 53, 53, 53, 75, 38,
171 31, 32, 51, 51, 51, 53, 51, 51, 53, 36,
172 38, 77, 51, 51, 51, 80, 51, 51, 51, 51,
173 51, 81, 51, 51, 30, 2, 36, 51, 51, 51,
174 31, 51, 51, 46, 42, 95, 96, 88,
175);
176110µsmy @yycheck = ( 17,
177 12, 1, 0, 1, 23, 23, 23, 1, 2, 21,
178 2, 11, 14, 11, 12, 0, 1, 6, 11, 1,
179 18, 6, 14, 17, 9, 25, 11, 12, 0, 1,
180 30, 1, 25, 18, 6, 10, 0, 9, 0, 11,
181 12, 0, 1, 11, 12, 12, 18, 11, 12, 11,
182 9, 18, 11, 12, 18, 1, 2, 7, 8, 18,
183 60, 73, 10, 63, 76, 84, 84, 84, 0, 1,
184 10, 17, 0, 1, 47, 48, 2, 9, 2, 11,
185 12, 9, 19, 11, 12, 10, 18, 0, 1, 12,
186 18, 17, 3, 4, 5, 18, 9, 9, 11, 12,
187 1, 6, 3, 4, 5, 18, 7, 8, 3, 4,
188 5, 1, 13, 20, 1, 16, 3, 4, 5, 1,
189 18, 3, 4, 5, 0, 1, 13, 78, 79, 16,
190 1, 13, 11, 1, 16, 3, 4, 5, 11, 0,
191 18, 19, 3, 4, 5, 13, 7, 8, 16, 0,
192 11, 11, 3, 4, 5, 1, 7, 8, 3, 4,
193 5, 15, 7, 8, 11, 0, 11, 3, 4, 5,
194 11, 7, 8, 25, 23, 85, 94, 83,
195);
196sub constYYFINAL () { 4 }
197
- -
200sub constYYMAXTOKEN () { 20 }
201sub yyclearin { $yychar = -1; }
202sub yyerrok { $yyerrflag = 0; }
203sub YYERROR { ++$yynerrs; &yy_err_recover; }
204sub yy_err_recover
205{
206 if ($yyerrflag < 3)
207 {
208 $yyerrflag = 3;
209 while (1)
210 {
211 if (($yyn = $yysindex[$yyss[$yyssp]]) &&
212 ($yyn += constYYERRCODE()) >= 0 &&
213 $yyn <= $#yycheck && $yycheck[$yyn] == constYYERRCODE())
214 {
215
- -
219 $yyss[++$yyssp] = $yystate = $yytable[$yyn];
220 $yyvs[++$yyvsp] = $yylval;
221 next yyloop;
222 }
223 else
224 {
225
- -
229 return(1) if $yyssp <= 0;
230 --$yyssp;
231 --$yyvsp;
232 }
233 }
234 }
235 else
236 {
237 return (1) if $yychar == 0;
238 $yychar = -1;
239 next yyloop;
240 }
2410;
242} # yy_err_recover
243
244sub yyparse
245
# spent 95.8ms (50.3+45.5) within Convert::ASN1::parser::yyparse which was called: # once (50.3ms+45.5ms) by Convert::ASN1::parser::parse at line 650
{
246
2475647149.5ms if ($yys = $ENV{'YYDEBUG'})
248 {
249 $yydebug = int($1) if $yys =~ /^(\d)/;
250 }
251
252
253 $yynerrs = 0;
254 $yyerrflag = 0;
255 $yychar = (-1);
256
257 $yyssp = 0;
258 $yyvsp = 0;
259 $yyss[$yyssp] = $yystate = 0;
260
261yyloop: while(1)
262 {
263 yyreduce: {
264 last yyreduce if ($yyn = $yydefred[$yystate]);
265 if ($yychar < 0)
266 {
267124445.5ms if (($yychar = &yylex) < 0) { $yychar = 0; }
# spent 45.5ms making 1244 calls to Convert::ASN1::parser::yylex, avg 37µs/call
268 }
269 if (($yyn = $yysindex[$yystate]) && ($yyn += $yychar) >= 0 &&
270 $yyn <= $#yycheck && $yycheck[$yyn] == $yychar)
271 {
272
- -
276 $yyss[++$yyssp] = $yystate = $yytable[$yyn];
277 $yyvs[++$yyvsp] = $yylval;
278 $yychar = (-1);
279 --$yyerrflag if $yyerrflag > 0;
280 next yyloop;
281 }
282 if (($yyn = $yyrindex[$yystate]) && ($yyn += $yychar) >= 0 &&
283 $yyn <= $#yycheck && $yycheck[$yyn] == $yychar)
284 {
285 $yyn = $yytable[$yyn];
286 last yyreduce;
287 }
288 if (! $yyerrflag) {
289 &yyerror('syntax error');
290 ++$yynerrs;
291 }
292 return undef if &yy_err_recover;
293 } # yyreduce
294
- -
298 $yym = $yylen[$yyn];
299 $yyval = $yyvs[$yyvsp+1-$yym];
300 switch:
301 {
302my $label = "State$yyn";
303goto $label if exists $yystate{$label};
304last switch;
305State1: {
306# 96 "parser.y"
307{ $yyval = { '' => $yyvs[$yyvsp-0] };
308last switch;
309} }
310State3: {
311# 101 "parser.y"
312{
313 $yyval = { $yyvs[$yyvsp-2], [$yyvs[$yyvsp-0]] };
314
315last switch;
316} }
317State4: {
318# 105 "parser.y"
319{
320 $yyval=$yyvs[$yyvsp-3];
321 $yyval->{$yyvs[$yyvsp-2]} = [$yyvs[$yyvsp-0]];
322
323last switch;
324} }
325State5: {
326# 112 "parser.y"
327{
328 $yyvs[$yyvsp-1]->[cTAG] = $yyvs[$yyvsp-3];
329 $yyval = $yyvs[$yyvsp-2] ? explicit($yyvs[$yyvsp-1]) : $yyvs[$yyvsp-1];
330
331last switch;
332} }
333State11: {
334# 126 "parser.y"
335{
336 @{$yyval = []}[cTYPE,cCHILD] = ('COMPONENTS', $yyvs[$yyvsp-0]);
337
338last switch;
339} }
340State14: {
341# 136 "parser.y"
342{
343 $yyvs[$yyvsp-1]->[cTAG] = $yyvs[$yyvsp-3];
344 @{$yyval = []}[cTYPE,cCHILD,cLOOP,cOPT] = ($yyvs[$yyvsp-5], [$yyvs[$yyvsp-1]], 1, $yyvs[$yyvsp-0]);
345 $yyval = explicit($yyval) if $yyvs[$yyvsp-2];
346
347last switch;
348} }
349State18: {
350# 149 "parser.y"
351{
352 @{$yyval = []}[cTYPE,cCHILD] = ('SEQUENCE', $yyvs[$yyvsp-1]);
353
354last switch;
355} }
356State19: {
357# 153 "parser.y"
358{
359 @{$yyval = []}[cTYPE,cCHILD] = ('SET', $yyvs[$yyvsp-1]);
360
361last switch;
362} }
363State20: {
364# 157 "parser.y"
365{
366 @{$yyval = []}[cTYPE,cCHILD] = ('CHOICE', $yyvs[$yyvsp-1]);
367
368last switch;
369} }
370State21: {
371# 163 "parser.y"
372{
373 @{$yyval = []}[cTYPE] = ('ENUM');
374
375last switch;
376} }
377State22: {
378# 168 "parser.y"
379{ @{$yyval = []}[cTYPE] = $yyvs[$yyvsp-0];
380last switch;
381} }
382State23: {
383# 169 "parser.y"
384{ @{$yyval = []}[cTYPE] = $yyvs[$yyvsp-0];
385last switch;
386} }
387State24: {
388# 170 "parser.y"
389{ @{$yyval = []}[cTYPE] = $yyvs[$yyvsp-0];
390last switch;
391} }
392State25: {
393# 172 "parser.y"
394{
395 @{$yyval = []}[cTYPE,cCHILD,cDEFINE] = ('ANY',undef,$yyvs[$yyvsp-0]);
396
397last switch;
398} }
399State26: {
400# 175 "parser.y"
401{ @{$yyval = []}[cTYPE] = $yyvs[$yyvsp-0];
402last switch;
403} }
404State27: {
405# 178 "parser.y"
406{ $yyval=undef;
407last switch;
408} }
409State28: {
410# 179 "parser.y"
411{ $yyval=$yyvs[$yyvsp-0];
412last switch;
413} }
414State30: {
415# 185 "parser.y"
416{ $yyval = $yyvs[$yyvsp-0];
417last switch;
418} }
419State31: {
420# 186 "parser.y"
421{ $yyval = $yyvs[$yyvsp-1];
422last switch;
423} }
424State32: {
425# 190 "parser.y"
426{
427 $yyval = [ $yyvs[$yyvsp-0] ];
428
429last switch;
430} }
431State33: {
432# 194 "parser.y"
433{
434 push @{$yyval=$yyvs[$yyvsp-2]}, $yyvs[$yyvsp-0];
435
436last switch;
437} }
438State34: {
439# 198 "parser.y"
440{
441 push @{$yyval=$yyvs[$yyvsp-2]}, $yyvs[$yyvsp-0];
442
443last switch;
444} }
445State35: {
446# 204 "parser.y"
447{
448 @{$yyval=$yyvs[$yyvsp-0]}[cVAR,cTAG] = ($yyvs[$yyvsp-3],$yyvs[$yyvsp-2]);
449 $yyval = explicit($yyval) if $yyvs[$yyvsp-1];
450
451last switch;
452} }
453State36: {
454# 211 "parser.y"
455{ $yyval = [];
456last switch;
457} }
458State37: {
459# 212 "parser.y"
460{ $yyval = $yyvs[$yyvsp-0];
461last switch;
462} }
463State38: {
464# 213 "parser.y"
465{ $yyval = $yyvs[$yyvsp-1];
466last switch;
467} }
468State39: {
469# 217 "parser.y"
470{
471 $yyval = [ $yyvs[$yyvsp-0] ];
472
473last switch;
474} }
475State40: {
476# 221 "parser.y"
477{
478 push @{$yyval=$yyvs[$yyvsp-2]}, $yyvs[$yyvsp-0];
479
480last switch;
481} }
482State41: {
483# 225 "parser.y"
484{
485 push @{$yyval=$yyvs[$yyvsp-2]}, $yyvs[$yyvsp-0];
486
487last switch;
488} }
489State42: {
490# 231 "parser.y"
491{
492 @{$yyval=$yyvs[$yyvsp-1]}[cOPT] = ($yyvs[$yyvsp-0]);
493
494last switch;
495} }
496State46: {
497# 240 "parser.y"
498{
499 @{$yyval=$yyvs[$yyvsp-0]}[cVAR,cTAG] = ($yyvs[$yyvsp-3],$yyvs[$yyvsp-2]);
500 $yyval->[cOPT] = $yyvs[$yyvsp-3] if $yyval->[cOPT];
501 $yyval = explicit($yyval) if $yyvs[$yyvsp-1];
502
503last switch;
504} }
505State48: {
506# 247 "parser.y"
507{
508 @{$yyval=$yyvs[$yyvsp-0]}[cTAG] = ($yyvs[$yyvsp-2]);
509 $yyval = explicit($yyval) if $yyvs[$yyvsp-1];
510
511last switch;
512} }
513State49: {
514# 253 "parser.y"
515{ $yyval = undef;
516last switch;
517} }
518State50: {
519# 254 "parser.y"
520{ $yyval = 1;
521last switch;
522} }
523State51: {
524# 258 "parser.y"
525{ $yyval = undef;
526last switch;
527} }
528State53: {
529# 262 "parser.y"
530{ $yyval = undef;
531last switch;
532} }
533State54: {
534# 263 "parser.y"
535{ $yyval = 1;
536last switch;
537} }
538State55: {
539# 264 "parser.y"
540{ $yyval = 0;
541last switch;
542} }
543State56: {
544# 267 "parser.y"
545{
546last switch;
547} }
548State57: {
549# 268 "parser.y"
550{
551last switch;
552} }
553State58: {
554# 271 "parser.y"
555{
556last switch;
557} }
558State59: {
559# 274 "parser.y"
560{
561last switch;
562} }
563State60: {
564# 275 "parser.y"
565{
566last switch;
567} }
568 } # switch
569 $yyssp -= $yym;
570 $yystate = $yyss[$yyssp];
571 $yyvsp -= $yym;
572 $yym = $yylhs[$yyn];
573 if ($yystate == 0 && $yym == 0)
574 {
575
- -
579 $yystate = constYYFINAL();
580 $yyss[++$yyssp] = constYYFINAL();
581 $yyvs[++$yyvsp] = $yyval;
582 if ($yychar < 0)
583 {
584 if (($yychar = &yylex) < 0) { $yychar = 0; }
585 }
586 return $yyvs[$yyvsp] if $yychar == 0;
587 next yyloop;
588 }
589 if (($yyn = $yygindex[$yym]) && ($yyn += $yystate) >= 0 &&
590 $yyn <= $#yycheck && $yycheck[$yyn] == $yystate)
591 {
592 $yystate = $yytable[$yyn];
593 } else {
594 $yystate = $yydgoto[$yym];
595 }
596
- -
600 $yyss[++$yyssp] = $yystate;
601 $yyvs[++$yyvsp] = $yyval;
602 } # yyloop
603} # yyparse
604# 279 "parser.y"
605
606110µsmy %reserved = (
607 'OPTIONAL' => constOPTIONAL(),
608 'CHOICE' => constCHOICE(),
609 'OF' => constOF(),
610 'IMPLICIT' => constIMPLICIT(),
611 'EXPLICIT' => constEXPLICIT(),
612 'SEQUENCE' => constSEQUENCE(),
613 'SET' => constSET(),
614 'ANY' => constANY(),
615 'ENUM' => constENUM(),
616 'ENUMERATED' => constENUM(),
617 'COMPONENTS' => constCOMPONENTS(),
618 '{' => constLBRACE(),
619 '}' => constRBRACE(),
620 ',' => constCOMMA(),
621 '::=' => constASSIGN(),
622 'DEFINED' => constDEFINED(),
623 'BY' => constBY()
624);
625
6261881µs1827µsmy $reserved = join("|", reverse sort grep { /\w/ } keys %reserved);
# spent 17µs making 17 calls to Convert::ASN1::parser::CORE:match, avg 994ns/call # spent 10µs making 1 call to Convert::ASN1::parser::CORE:sort
627
62816µsmy %tag_class = (
629 APPLICATION => ASN_APPLICATION,
630 UNIVERSAL => ASN_UNIVERSAL,
631 PRIVATE => ASN_PRIVATE,
632 CONTEXT => ASN_CONTEXT,
633 '' => ASN_CONTEXT # if not specified, its CONTEXT
634);
635
636;##
637;## This is NOT thread safe !!!!!!
638;##
639
6401200nsmy $pos;
6411100nsmy $last_pos;
6421300nsmy @stacked;
643
644
# spent 103ms (64µs+103) within Convert::ASN1::parser::parse which was called: # once (64µs+103ms) by Convert::ASN1::prepare at line 154 of Convert/ASN1.pm
sub parse {
645538µs local(*asn) = \($_[0]);
646 ($pos,$last_pos,@stacked) = ();
647
648 eval {
649 local $SIG{__DIE__};
6503103ms compile(verify(yyparse()));
# spent 95.8ms making 1 call to Convert::ASN1::parser::yyparse # spent 5.42ms making 1 call to Convert::ASN1::parser::compile # spent 1.77ms making 1 call to Convert::ASN1::parser::verify
651 }
652}
653
654
# spent 5.16ms (4.98+174µs) within Convert::ASN1::parser::compile_one which was called 320 times, avg 16µs/call: # 124 times (3.05ms+-3.05ms) by Convert::ASN1::parser::compile_one at line 688, avg 0s/call # 123 times (1.17ms+-1.17ms) by Convert::ASN1::parser::compile_one at line 668, avg 0s/call # 73 times (769µs+4.39ms) by Convert::ASN1::parser::compile at line 736, avg 71µs/call
sub compile_one {
65547684.97ms my $tree = shift;
656 my $ops = shift;
657 my $name = shift;
658 foreach my $op (@$ops) {
659 next unless ref($op) eq 'ARRAY';
660 bless $op;
661 my $type = $op->[cTYPE];
662 if (exists $base_type{$type}) {
663 $op->[cTYPE] = $base_type{$type}->[1];
6642969µs $op->[cTAG] = defined($op->[cTAG]) ? asn_encode_tag($op->[cTAG]): $base_type{$type}->[0];
# spent 69µs making 29 calls to Convert::ASN1::asn_encode_tag, avg 2µs/call
665 }
666 else {
667 die "Unknown type '$type'\n" unless exists $tree->{$type};
6681230s my $ref = compile_one(
# spent 2.82ms making 123 calls to Convert::ASN1::parser::compile_one, avg 23µs/call, recursion: max depth 10, sum of overlapping time 2.82ms
669 $tree,
670 $tree->{$type},
671 defined($op->[cVAR]) ? $name . "." . $op->[cVAR] : $name
672 );
673 if (defined($op->[cTAG]) && $ref->[0][cTYPE] == opCHOICE) {
674 @{$op}[cTYPE,cCHILD] = (opSEQUENCE,$ref);
675 }
676 else {
677 @{$op}[cTYPE,cCHILD,cLOOP] = @{$ref->[0]}[cTYPE,cCHILD,cLOOP];
678 }
67945106µs $op->[cTAG] = defined($op->[cTAG]) ? asn_encode_tag($op->[cTAG]): $ref->[0][cTAG];
# spent 106µs making 45 calls to Convert::ASN1::asn_encode_tag, avg 2µs/call
680 }
681 $op->[cTAG] |= chr(ASN_CONSTRUCTOR)
682 if length $op->[cTAG] && ($op->[cTYPE] == opSET || $op->[cTYPE] == opSEQUENCE);
683
684 if ($op->[cCHILD]) {
685 ;# If we have children we are one of
686 ;# opSET opSEQUENCE opCHOICE
687
6881240s compile_one($tree, $op->[cCHILD], defined($op->[cVAR]) ? $name . "." . $op->[cVAR] : $name);
# spent 10.3ms making 124 calls to Convert::ASN1::parser::compile_one, avg 83µs/call, recursion: max depth 9, sum of overlapping time 10.3ms
689
690 ;# If a CHOICE is given a tag, then it must be EXPLICIT
691 if ($op->[cTYPE] == opCHOICE && defined($op->[cTAG]) && length($op->[cTAG])) {
692 $op = bless explicit($op);
693 $op->[cTYPE] = opSEQUENCE;
694 }
695
696 if ( @{$op->[cCHILD]} > 1) {
697 ;#if ($op->[cTYPE] != opSEQUENCE) {
698 ;# Here we need to flatten CHOICEs and check that SET and CHOICE
699 ;# do not contain duplicate tags
700 ;#}
701 if ($op->[cTYPE] == opSET) {
702 ;# In case we do CER encoding we order the SET elements by thier tags
703 my @tags = map {
704 length($_->[cTAG])
705 ? $_->[cTAG]
706 : $_->[cTYPE] == opCHOICE
707 ? (sort map { $_->[cTAG] } $_->[cCHILD])[0]
708 : ''
709 } @{$op->[cCHILD]};
710 @{$op->[cCHILD]} = @{$op->[cCHILD]}[sort { $tags[$a] cmp $tags[$b] } 0..$#tags];
711 }
712 }
713 else {
714 ;# A SET of one element can be treated the same as a SEQUENCE
715 $op->[cTYPE] = opSEQUENCE if $op->[cTYPE] == opSET;
716 }
717 }
718 }
719 $ops;
720}
721
722
# spent 5.42ms (257µs+5.16) within Convert::ASN1::parser::compile which was called: # once (257µs+5.16ms) by Convert::ASN1::parser::parse at line 650
sub compile {
7233208µs my $tree = shift;
724
725 ;# The tree should be valid enough to be able to
726 ;# - resolve references
727 ;# - encode tags
728 ;# - verify CHOICEs do not contain duplicate tags
729
730 ;# once references have been resolved, and also due to
731 ;# flattening of COMPONENTS, it is possible for an op
732 ;# to appear in multiple places. So once an op is
733 ;# compiled we bless it. This ensure we dont try to
734 ;# compile it again.
735
736735.16ms while(my($k,$v) = each %$tree) {
# spent 5.16ms making 73 calls to Convert::ASN1::parser::compile_one, avg 71µs/call
737 compile_one($tree,$v,$k);
738 }
739
740 $tree;
741}
742
743
# spent 1.77ms (1.70+74µs) within Convert::ASN1::parser::verify which was called: # once (1.70ms+74µs) by Convert::ASN1::parser::parse at line 650
sub verify {
74424731.70ms my $tree = shift or return;
745 my $err = "";
746
747 ;# Well it parsed correctly, now we
748 ;# - check references exist
749 ;# - flatten COMPONENTS OF (checking for loops)
750 ;# - check for duplicate var names
751
752 while(my($name,$ops) = each %$tree) {
753 my $stash = {};
754 my @scope = ();
755 my $path = "";
756 my $idx = 0;
757
758 while($ops) {
759 if ($idx < @$ops) {
760 my $op = $ops->[$idx++];
761 my $var;
762 if (defined ($var = $op->[cVAR])) {
763
764 $err .= "$name: $path.$var used multiple times\n"
765 if $stash->{$var}++;
766
767 }
768 if (defined $op->[cCHILD]) {
769474µs if (ref $op->[cCHILD]) {
# spent 74µs making 4 calls to Convert::ASN1::parser::expand_ops, avg 19µs/call
770 push @scope, [$stash, $path, $ops, $idx];
771 if (defined $var) {
772 $stash = {};
773 $path .= "." . $var;
774 }
775 $idx = 0;
776 $ops = $op->[cCHILD];
777 }
778 elsif ($op->[cTYPE] eq 'COMPONENTS') {
779 splice(@$ops,--$idx,1,expand_ops($tree, $op->[cCHILD]));
780 }
781 else {
782 die "Internal error\n";
783 }
784 }
785 }
786 else {
787 my $s = pop @scope
788 or last;
789 ($stash,$path,$ops,$idx) = @$s;
790 }
791 }
792 }
793 die $err if length $err;
794 $tree;
795}
796
797
# spent 74µs within Convert::ASN1::parser::expand_ops which was called 4 times, avg 19µs/call: # 4 times (74µs+0s) by Convert::ASN1::parser::verify at line 769, avg 19µs/call
sub expand_ops {
7986689µs my $tree = shift;
799 my $want = shift;
800 my $seen = shift || { };
801
802 die "COMPONENTS OF loop $want\n" if $seen->{$want}++;
803 die "Undefined macro $want\n" unless exists $tree->{$want};
804 my $ops = $tree->{$want};
805 die "Bad macro for COMPUNENTS OF '$want'\n"
806 unless @$ops == 1
807 && ($ops->[0][cTYPE] eq 'SEQUENCE' || $ops->[0][cTYPE] eq 'SET')
808 && ref $ops->[0][cCHILD];
809 $ops = $ops->[0][cCHILD];
810 for(my $idx = 0 ; $idx < @$ops ; ) {
811 my $op = $ops->[$idx++];
812 if ($op->[cTYPE] eq 'COMPONENTS') {
813 splice(@$ops,--$idx,1,expand_ops($tree, $op->[cCHILD], $seen));
814 }
815 }
816
817 @$ops;
818}
819
820sub _yylex {
821 my $ret = &_yylex;
822 warn $ret;
823 $ret;
824}
825
826
# spent 45.5ms (30.9+14.6) within Convert::ASN1::parser::yylex which was called 1244 times, avg 37µs/call: # 1244 times (30.9ms+14.6ms) by Convert::ASN1::parser::yyparse at line 267, avg 37µs/call
sub yylex {
8271235545.6ms return shift @stacked if @stacked;
828
829475813.4ms while ($asn =~ /\G(?:
# spent 12.0ms making 2379 calls to Convert::ASN1::parser::CORE:match, avg 5µs/call # spent 1.35ms making 2379 calls to Convert::ASN1::parser::CORE:regcomp, avg 569ns/call
830 (\s+|--[^\n]*)
831 |
832 ([,{}]|::=)
833 |
834 ($reserved)\b
835 |
836 (
837 (?:OCTET|BIT)\s+STRING
838 |
839 OBJECT\s+IDENTIFIER
840 |
841 RELATIVE-OID
842 )\b
843 |
844 (\w+(?:-\w+)*)
845 |
846 \[\s*
847 (
848 (?:(?:APPLICATION|PRIVATE|UNIVERSAL|CONTEXT)\s+)?
849 \d+
850 )
851 \s*\]
852 |
853 \((\d+)\)
854 )/sxgo
855 ) {
856
857 ($last_pos,$pos) = ($pos,pos($asn));
858
859 next if defined $1; # comment or whitespace
860
861 if (defined $2 or defined $3) {
862 # A comma is not required after a '}' so to aid the
863 # parser we insert a fake token after any '}'
864 push @stacked, constPOSTRBRACE() if defined $2 and $+ eq '}';
865
866 return $reserved{$yylval = $+};
867 }
868
869 if (defined $4) {
87018105µs ($yylval = $+) =~ s/\s+/_/g;
# spent 105µs making 18 calls to Convert::ASN1::parser::CORE:subst, avg 6µs/call
871 return constWORD();
872 }
873
874 if (defined $5) {
875 $yylval = $+;
876 return constWORD();
877 }
878
879 if (defined $6) {
88074475µs my($class,$num) = ($+ =~ /^([A-Z]*)\s*(\d+)$/);
# spent 475µs making 74 calls to Convert::ASN1::parser::CORE:match, avg 6µs/call
88174638µs $yylval = asn_tag($tag_class{$class}, $num);
# spent 638µs making 74 calls to Convert::ASN1::asn_tag, avg 9µs/call
882 return constCLASS();
883 }
884
885 if (defined $7) {
886 $yylval = $+;
887 return constNUMBER();
888 }
889
890 die "Internal error\n";
891
892 }
893
894 die "Parse error before ",substr($asn,$pos,40),"\n"
895 unless $pos == length($asn);
896
897 0
898}
899
900sub yyerror {
901 die @_," ",substr($asn,$last_pos,40),"\n";
902}
903
9041200ns1;
905
906136µs%yystate = ('State51','','State34','','State11','','State33','','State24',
907'','State40','','State31','','State37','','State23','','State22','',
908'State21','','State57','','State39','','State56','','State20','','State25',
909'','State38','','State14','','State19','','State46','','State5','',
910'State53','','State26','','State27','','State50','','State36','','State4',
911'','State3','','State32','','State49','','State30','','State35','',
912'State48','','State55','','State42','','State28','','State58','','State41',
913'','State18','','State59','','State1','','State54','','State60',
914'');
915
916196µs1;
 
# spent 12.5ms within Convert::ASN1::parser::CORE:match which was called 2470 times, avg 5µs/call: # 2379 times (12.0ms+0s) by Convert::ASN1::parser::yylex at line 829, avg 5µs/call # 74 times (475µs+0s) by Convert::ASN1::parser::yylex at line 880, avg 6µs/call # 17 times (17µs+0s) by Convert::ASN1::BEGIN@415 at line 626, avg 994ns/call
sub Convert::ASN1::parser::CORE:match; # opcode
# spent 1.35ms within Convert::ASN1::parser::CORE:regcomp which was called 2379 times, avg 569ns/call: # 2379 times (1.35ms+0s) by Convert::ASN1::parser::yylex at line 829, avg 569ns/call
sub Convert::ASN1::parser::CORE:regcomp; # opcode
# spent 10µs within Convert::ASN1::parser::CORE:sort which was called: # once (10µs+0s) by Convert::ASN1::BEGIN@415 at line 626
sub Convert::ASN1::parser::CORE:sort; # opcode
# spent 105µs within Convert::ASN1::parser::CORE:subst which was called 18 times, avg 6µs/call: # 18 times (105µs+0s) by Convert::ASN1::parser::yylex at line 870, avg 6µs/call
sub Convert::ASN1::parser::CORE:subst; # opcode
Report produced by the NYTProf 4.04 Perl profiler, developed by Tim Bunce and Adam Kaplan.