← 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:02:23 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
11110µs1180µ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
14233µ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
24712µs if ($yys = $ENV{'YYDEBUG'})
248 {
249 $yydebug = int($1) if $yys =~ /^(\d)/;
250 }
251
252
2531900ns $yynerrs = 0;
2541800ns $yyerrflag = 0;
2551400ns $yychar = (-1);
256
2571400ns $yyssp = 0;
2581700ns $yyvsp = 0;
25912µs $yyss[$yyssp] = $yystate = 0;
260
2611283µsyyloop: while(1)
262 {
26333192.04ms yyreduce: {
26433191.11ms last yyreduce if ($yyn = $yydefred[$yystate]);
26518361.44ms if ($yychar < 0)
266 {
26712444.61ms124445.5ms if (($yychar = &yylex) < 0) { $yychar = 0; }
# spent 45.5ms making 1244 calls to Convert::ASN1::parser::yylex, avg 37µs/call
268 }
26918364.55ms if (($yyn = $yysindex[$yystate]) && ($yyn += $yychar) >= 0 &&
270 $yyn <= $#yycheck && $yycheck[$yyn] == $yychar)
271 {
272
- -
27612431.08ms $yyss[++$yyssp] = $yystate = $yytable[$yyn];
27712431.15ms $yyvs[++$yyvsp] = $yylval;
2781243392µs $yychar = (-1);
2791243568µs --$yyerrflag if $yyerrflag > 0;
2801243887µs next yyloop;
281 }
282593902µs if (($yyn = $yyrindex[$yystate]) && ($yyn += $yychar) >= 0 &&
283 $yyn <= $#yycheck && $yycheck[$yyn] == $yychar)
284 {
285593324µs $yyn = $yytable[$yyn];
286593410µs last yyreduce;
287 }
288 if (! $yyerrflag) {
289 &yyerror('syntax error');
290 ++$yynerrs;
291 }
292 return undef if &yy_err_recover;
293 } # yyreduce
294
- -
2982076891µs $yym = $yylen[$yyn];
29920762.41ms $yyval = $yyvs[$yyvsp+1-$yym];
30020762.03ms switch:
301 {
3022076600µsmy $label = "State$yyn";
30320764.52msgoto $label if exists $yystate{$label};
304423208µslast switch;
305State1: {
306# 96 "parser.y"
307{ $yyval = { '' => $yyvs[$yyvsp-0] };
308last switch;
309} }
310State3: {
311# 101 "parser.y"
31211µs{
31329µs $yyval = { $yyvs[$yyvsp-2], [$yyvs[$yyvsp-0]] };
314
31511µslast switch;
316} }
317State4: {
318# 105 "parser.y"
3197225µs{
32014487µs $yyval=$yyvs[$yyvsp-3];
32172396µs $yyval->{$yyvs[$yyvsp-2]} = [$yyvs[$yyvsp-0]];
322
3237249µslast switch;
324} }
325State5: {
326# 112 "parser.y"
3277123µs{
328142182µs $yyvs[$yyvsp-1]->[cTAG] = $yyvs[$yyvsp-3];
32971101µs $yyval = $yyvs[$yyvsp-2] ? explicit($yyvs[$yyvsp-1]) : $yyvs[$yyvsp-1];
330
3317143µslast switch;
332} }
333State11: {
334# 126 "parser.y"
33542µs{
3361237µs @{$yyval = []}[cTYPE,cCHILD] = ('COMPONENTS', $yyvs[$yyvsp-0]);
337
33843µslast switch;
339} }
340State14: {
341# 136 "parser.y"
342178µs{
3433452µs $yyvs[$yyvsp-1]->[cTAG] = $yyvs[$yyvsp-3];
34434175µs @{$yyval = []}[cTYPE,cCHILD,cLOOP,cOPT] = ($yyvs[$yyvsp-5], [$yyvs[$yyvsp-1]], 1, $yyvs[$yyvsp-0]);
3451721µs $yyval = explicit($yyval) if $yyvs[$yyvsp-2];
346
3471714µslast switch;
348} }
349State18: {
350# 149 "parser.y"
3514417µs{
352132384µs @{$yyval = []}[cTYPE,cCHILD] = ('SEQUENCE', $yyvs[$yyvsp-1]);
353
3544431µslast 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"
36593µs{
3662760µs @{$yyval = []}[cTYPE,cCHILD] = ('CHOICE', $yyvs[$yyvsp-1]);
367
36895µslast switch;
369} }
370State21: {
371# 163 "parser.y"
372104µs{
3733066µs @{$yyval = []}[cTYPE] = ('ENUM');
374
375108µslast switch;
376} }
377State22: {
378# 168 "parser.y"
3796801.05ms{ @{$yyval = []}[cTYPE] = $yyvs[$yyvsp-0];
380170107µslast 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"
4162417µs{ $yyval = $yyvs[$yyvsp-0];
41786µslast switch;
418} }
419State31: {
420# 186 "parser.y"
42132µs{ $yyval = $yyvs[$yyvsp-1];
4221800nslast switch;
423} }
424State32: {
425# 190 "parser.y"
42694µs{
4271825µs $yyval = [ $yyvs[$yyvsp-0] ];
428
42996µslast switch;
430} }
431State33: {
432# 194 "parser.y"
43331µs{
434911µs push @{$yyval=$yyvs[$yyvsp-2]}, $yyvs[$yyvsp-0];
435
43632µslast switch;
437} }
438State34: {
439# 198 "parser.y"
4403912µs{
441117122µs push @{$yyval=$yyvs[$yyvsp-2]}, $yyvs[$yyvsp-0];
442
4433922µslast switch;
444} }
445State35: {
446# 204 "parser.y"
4475119µs{
448153289µs @{$yyval=$yyvs[$yyvsp-0]}[cVAR,cTAG] = ($yyvs[$yyvsp-3],$yyvs[$yyvsp-2]);
4495138µs $yyval = explicit($yyval) if $yyvs[$yyvsp-1];
450
4515132µslast switch;
452} }
453State36: {
454# 211 "parser.y"
455{ $yyval = [];
456last switch;
457} }
458State37: {
459# 212 "parser.y"
46012380µs{ $yyval = $yyvs[$yyvsp-0];
4614128µslast switch;
462} }
463State38: {
464# 213 "parser.y"
46595µs{ $yyval = $yyvs[$yyvsp-1];
46632µslast switch;
467} }
468State39: {
469# 217 "parser.y"
4704418µs{
47188109µs $yyval = [ $yyvs[$yyvsp-0] ];
472
4734428µslast switch;
474} }
475State40: {
476# 221 "parser.y"
4775721µs{
478171226µs push @{$yyval=$yyvs[$yyvsp-2]}, $yyvs[$yyvsp-0];
479
4805734µslast switch;
481} }
482State41: {
483# 225 "parser.y"
484124µs{
4853654µs push @{$yyval=$yyvs[$yyvsp-2]}, $yyvs[$yyvsp-0];
486
487128µslast switch;
488} }
489State42: {
490# 231 "parser.y"
4919131µs{
492273535µs @{$yyval=$yyvs[$yyvsp-1]}[cOPT] = ($yyvs[$yyvsp-0]);
493
4949159µslast switch;
495} }
496State46: {
497# 240 "parser.y"
49810938µs{
499327573µs @{$yyval=$yyvs[$yyvsp-0]}[cVAR,cTAG] = ($yyvs[$yyvsp-3],$yyvs[$yyvsp-2]);
500109130µs $yyval->[cOPT] = $yyvs[$yyvsp-3] if $yyval->[cOPT];
50110970µs $yyval = explicit($yyval) if $yyvs[$yyvsp-1];
502
50310966µslast switch;
504} }
505State48: {
506# 247 "parser.y"
5072900ns{
50868µs @{$yyval=$yyvs[$yyvsp-0]}[cTAG] = ($yyvs[$yyvsp-2]);
50922µs $yyval = explicit($yyval) if $yyvs[$yyvsp-1];
510
51121µslast switch;
512} }
513State49: {
514# 253 "parser.y"
51520792µs{ $yyval = undef;
5166952µslast switch;
517} }
518State50: {
519# 254 "parser.y"
52011751µs{ $yyval = 1;
5213927µslast switch;
522} }
523State51: {
524# 258 "parser.y"
525528211µs{ $yyval = undef;
526176112µslast switch;
527} }
528State53: {
529# 262 "parser.y"
530750264µs{ $yyval = undef;
531250144µslast 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"
545104µs{
5462010µslast switch;
547} }
548State57: {
549# 268 "parser.y"
5508029µs{
55116067µslast switch;
552} }
553State58: {
554# 271 "parser.y"
5559033µs{
55618086µslast switch;
557} }
558State59: {
559# 274 "parser.y"
560279µs{
5615426µslast switch;
562} }
563State60: {
564# 275 "parser.y"
5654417µs{
5668843µslast switch;
567} }
568 } # switch
5692076874µs $yyssp -= $yym;
57020761.02ms $yystate = $yyss[$yyssp];
5712076692µs $yyvsp -= $yym;
5722076978µs $yym = $yylhs[$yyn];
5732076816µs if ($yystate == 0 && $yym == 0)
574 {
575
- -
5791400ns $yystate = constYYFINAL();
5801700ns $yyss[++$yyssp] = constYYFINAL();
5811700ns $yyvs[++$yyvsp] = $yyval;
5821400ns if ($yychar < 0)
583 {
584 if (($yychar = &yylex) < 0) { $yychar = 0; }
585 }
58618µs return $yyvs[$yyvsp] if $yychar == 0;
587 next yyloop;
588 }
58920753.73ms if (($yyn = $yygindex[$yym]) && ($yyn += $yystate) >= 0 &&
590 $yyn <= $#yycheck && $yycheck[$yyn] == $yystate)
591 {
5921001630µs $yystate = $yytable[$yyn];
593 } else {
5941074615µs $yystate = $yydgoto[$yym];
595 }
596
- -
60020751.14ms $yyss[++$yyssp] = $yystate;
60120751.63ms $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 {
64513µs local(*asn) = \($_[0]);
64612µs ($pos,$last_pos,@stacked) = ();
647
64817µs eval {
64916µs local $SIG{__DIE__};
650121µs3103ms 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 {
655320129µs my $tree = shift;
65632091µs my $ops = shift;
657320120µs my $name = shift;
658320479µs foreach my $op (@$ops) {
659555288µs next unless ref($op) eq 'ARRAY';
660250315µs bless $op;
661250172µs my $type = $op->[cTYPE];
662250196µs if (exists $base_type{$type}) {
66312797µs $op->[cTYPE] = $base_type{$type}->[1];
664127180µs2969µ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 {
66712366µs die "Unknown type '$type'\n" unless exists $tree->{$type};
668123386µs1230s 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 );
673123124µs if (defined($op->[cTAG]) && $ref->[0][cTYPE] == opCHOICE) {
674 @{$op}[cTYPE,cCHILD] = (opSEQUENCE,$ref);
675 }
676 else {
677121235µs @{$op}[cTYPE,cCHILD,cLOOP] = @{$ref->[0]}[cTYPE,cCHILD,cLOOP];
678 }
679123214µs45106µ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 }
681250240µs $op->[cTAG] |= chr(ASN_CONSTRUCTOR)
682 if length $op->[cTAG] && ($op->[cTYPE] == opSET || $op->[cTYPE] == opSEQUENCE);
683
684250265µs if ($op->[cCHILD]) {
685 ;# If we have children we are one of
686 ;# opSET opSEQUENCE opCHOICE
687
688124354µs1240s 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
69112458µs if ($op->[cTYPE] == opCHOICE && defined($op->[cTAG]) && length($op->[cTAG])) {
692 $op = bless explicit($op);
693 $op->[cTYPE] = opSEQUENCE;
694 }
695
696124106µs 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 ;#}
7019438µs 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
7153015µs $op->[cTYPE] = opSEQUENCE if $op->[cTYPE] == opSET;
716 }
717 }
718 }
719320801µs $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 {
72311µ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
7361194µs735.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
740113µs $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 {
74411µs my $tree = shift or return;
7451900ns 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
7521128µs while(my($name,$ops) = each %$tree) {
7537334µs my $stash = {};
7547322µs my @scope = ();
7557320µs my $path = "";
7567315µs my $idx = 0;
757
7587327µs while($ops) {
759414306µs if ($idx < @$ops) {
760269133µs my $op = $ops->[$idx++];
76126952µs my $var;
762269345µs if (defined ($var = $op->[cVAR])) {
763
764 $err .= "$name: $path.$var used multiple times\n"
765 if $stash->{$var}++;
766
767 }
768269127µs if (defined $op->[cCHILD]) {
7697677µs474µs if (ref $op->[cCHILD]) {
# spent 74µs making 4 calls to Convert::ASN1::parser::expand_ops, avg 19µs/call
7707295µs push @scope, [$stash, $path, $ops, $idx];
7717220µs if (defined $var) {
772167µs $stash = {};
7731611µs $path .= "." . $var;
774 }
7757216µs $idx = 0;
7767231µs $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 {
787145113µs my $s = pop @scope
788 or last;
7897293µs ($stash,$path,$ops,$idx) = @$s;
790 }
791 }
792 }
79311µs die $err if length $err;
794120µs $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 {
79844µs my $tree = shift;
79943µs my $want = shift;
80044µs my $seen = shift || { };
801
80247µs die "COMPONENTS OF loop $want\n" if $seen->{$want}++;
80343µs die "Undefined macro $want\n" unless exists $tree->{$want};
80442µs my $ops = $tree->{$want};
80548µs 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];
80942µs $ops = $ops->[0][cCHILD];
81044µs for(my $idx = 0 ; $idx < @$ops ; ) {
811115µs my $op = $ops->[$idx++];
8121113µs if ($op->[cTYPE] eq 'COMPONENTS') {
813 splice(@$ops,--$idx,1,expand_ops($tree, $op->[cCHILD], $seen));
814 }
81541µs }
816
817433µs @$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 {
82712441.25ms return shift @stacked if @stacked;
828
829118126.5ms475813.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
85723782.80ms ($last_pos,$pos) = ($pos,pos($asn));
858
85923783.81ms next if defined $1; # comment or whitespace
860
86111801.54ms 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 '}'
864519811µs push @stacked, constPOSTRBRACE() if defined $2 and $+ eq '}';
865
8665192.82ms return $reserved{$yylval = $+};
867 }
868
869661510µs if (defined $4) {
87018203µs18105µs ($yylval = $+) =~ s/\s+/_/g;
# spent 105µs making 18 calls to Convert::ASN1::parser::CORE:subst, avg 6µs/call
8711866µs return constWORD();
872 }
873
874643679µs if (defined $5) {
875479615µs $yylval = $+;
8764791.84ms return constWORD();
877 }
878
879164147µs if (defined $6) {
88074849µs74475µs my($class,$num) = ($+ =~ /^([A-Z]*)\s*(\d+)$/);
# spent 475µs making 74 calls to Convert::ASN1::parser::CORE:match, avg 6µs/call
88174357µs74638µs $yylval = asn_tag($tag_class{$class}, $num);
# spent 638µs making 74 calls to Convert::ASN1::asn_tag, avg 9µs/call
88274264µs return constCLASS();
883 }
884
88590105µs if (defined $7) {
88690103µs $yylval = $+;
88790346µs return constNUMBER();
888 }
889
890 die "Internal error\n";
891
892 }
893
89411µs die "Parse error before ",substr($asn,$pos,40),"\n"
895 unless $pos == length($asn);
896
89712µs 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.