/usr/local/CPAN/perlrpcgen/RPCLParser.pm
"@(#)yaccpar 1.8 (Berkeley) 01/20/91 (JAKE-P5BP-0.5 12/16/96)";
package RPCLParser;
;# Copyright 1997 Jake Donham <jake@organic.com>
;# You may distribute under the terms of either the GNU General
;# Public License or the Artistic License, as specified in the README
;# file.
;# $Id: RPCLParser.pm,v 1.1 1997/04/30 21:15:18 jake Exp $
use perlrpcgen::RPCL;
$CONST=257;
$IDENT=258;
$CONSTANT=259;
$ENUM=260;
$STRUCT=261;
$TYPE=262;
$UNION=263;
$SWITCH=264;
$CASE=265;
$DEFAULT=266;
$TYPEDEF=267;
$PROGRAM=268;
$VERSION=269;
$OPAQUE=270;
$STRING=271;
$INT=272;
$UNSIGNED=273;
$FLOAT=274;
$DOUBLE=275;
$BOOL=276;
$VOID=277;
$YYERRCODE=256;
@yylhs = ( -1,
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 4, 4, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 5, 8,
9, 9, 6, 10, 11, 11, 7, 12, 13, 13,
14, 14, 15, 16, 17, 17, 17, 17, 17, 18,
19, 19, 20, 21, 21, 22, 23, 23, 23, 1,
1,
);
@yylen = ( 2,
1, 2, 5, 5, 4, 5, 5, 4, 5, 4,
3, 1, 1, 1, 1, 2, 1, 1, 1, 1,
1, 1, 1, 1, 1, 2, 2, 2, 2, 3,
3, 5, 2, 3, 2, 3, 2, 7, 1, 2,
5, 6, 4, 5, 3, 4, 4, 5, 4, 8,
1, 2, 8, 1, 2, 8, 1, 1, 1, 1,
2,
);
@yydefred = ( 0,
0, 0, 0, 0, 0, 0, 0, 0, 58, 57,
59, 60, 0, 0, 0, 0, 0, 25, 0, 0,
0, 0, 0, 15, 0, 18, 19, 20, 0, 0,
0, 22, 23, 24, 0, 61, 0, 0, 0, 0,
0, 0, 0, 0, 28, 29, 26, 33, 27, 37,
0, 0, 16, 45, 0, 0, 0, 0, 0, 0,
46, 0, 0, 47, 0, 0, 49, 0, 0, 0,
0, 0, 11, 0, 0, 51, 44, 0, 30, 0,
35, 34, 0, 48, 0, 14, 13, 0, 8, 0,
10, 0, 0, 5, 0, 0, 0, 52, 31, 0,
36, 0, 6, 7, 9, 3, 4, 0, 0, 0,
0, 21, 0, 0, 54, 0, 32, 0, 0, 0,
0, 0, 55, 50, 0, 38, 0, 0, 40, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
53, 41, 0, 43, 0, 42, 0, 56,
);
@yydgoto = ( 7,
8, 30, 31, 88, 32, 33, 34, 39, 60, 41,
63, 44, 119, 120, 129, 9, 10, 11, 75, 76,
114, 115, 12,
);
@yysindex = ( -161,
-239, -230, -38, -222, -187, -216, 0, -161, 0, 0,
0, 0, -28, -79, -78, -210, -215, 0, -114, -111,
-229, -208, -206, 0, -217, 0, 0, 0, 0, -2,
-37, 0, 0, 0, -65, 0, -200, -198, 2, -187,
3, -78, 23, 16, 0, 0, 0, 0, 0, 0,
-45, 17, 0, 0, -44, -180, -190, 21, 30, -30,
0, 33, -118, 0, 34, -187, 0, -228, -56, -54,
-228, -52, 0, -176, -103, 0, 0, -228, 0, -164,
0, 0, 38, 0, 57, 0, 0, 8, 0, 42,
0, 46, 18, 0, 48, -11, 52, 0, 0, 53,
0, -8, 0, 0, 0, 0, 0, -207, -143, -228,
-148, 0, -140, -112, 0, 60, 0, -228, -5, -225,
81, 61, 0, 0, 65, 0, -228, 66, 0, -207,
-134, -187, 68, -187, 86, 69, 70, -187, 71, 72,
0, 0, 73, 0, -128, 0, 75, 0,
);
@yyrindex = ( 0,
0, 0, 0, 0, 0, 0, 0, 135, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, -39, 0, 0, 0, -41, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, -21, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 11,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
);
@yygindex = ( 0,
0, -29, -87, -46, 0, 0, 0, 118, 0, -3,
0, 117, 0, 0, 0, 0, 0, 0, 0, 64,
0, 27, 142,
);
$YYTABLESIZE=221;
@yytable = ( 12,
21, 17, 17, 16, 56, 89, 82, 91, 38, 94,
62, 40, 122, 80, 69, 72, 48, 12, 13, 2,
113, 97, 90, 92, 93, 95, 113, 14, 49, 86,
87, 99, 37, 83, 43, 17, 85, 2, 65, 127,
128, 35, 135, 38, 40, 68, 71, 42, 43, 51,
18, 52, 19, 20, 53, 21, 54, 57, 58, 59,
61, 64, 66, 117, 24, 25, 26, 27, 28, 112,
18, 125, 19, 20, 67, 21, 70, 73, 74, 77,
133, 96, 22, 23, 24, 25, 26, 27, 28, 29,
78, 81, 84, 100, 79, 1, 101, 102, 2, 3,
103, 4, 137, 104, 139, 5, 6, 105, 143, 107,
106, 108, 109, 110, 111, 116, 118, 121, 124, 126,
130, 131, 132, 134, 136, 138, 140, 141, 142, 144,
147, 146, 145, 148, 1, 39, 46, 50, 98, 18,
123, 19, 20, 45, 21, 18, 47, 19, 20, 36,
21, 22, 23, 24, 25, 26, 27, 28, 29, 24,
25, 26, 27, 28, 112, 74, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 86, 87, 86, 87, 86, 87, 0, 0, 0,
0, 0, 0, 0, 0, 0, 21, 0, 17, 15,
55,
);
@yycheck = ( 41,
42, 41, 42, 42, 42, 62, 125, 62, 123, 62,
40, 123, 125, 44, 60, 60, 20, 59, 258, 41,
108, 125, 69, 70, 71, 72, 114, 258, 258, 258,
259, 78, 61, 63, 264, 258, 66, 59, 42, 265,
266, 258, 130, 123, 123, 91, 91, 258, 264, 258,
258, 258, 260, 261, 272, 263, 59, 123, 259, 258,
59, 59, 40, 110, 272, 273, 274, 275, 276, 277,
258, 118, 260, 261, 59, 263, 60, 258, 269, 59,
127, 258, 270, 271, 272, 273, 274, 275, 276, 277,
61, 59, 59, 258, 125, 257, 59, 41, 260, 261,
93, 263, 132, 62, 134, 267, 268, 62, 138, 62,
93, 123, 61, 61, 123, 259, 265, 258, 59, 125,
40, 61, 58, 58, 259, 58, 41, 59, 59, 59,
259, 59, 61, 59, 0, 125, 19, 21, 75, 258,
114, 260, 261, 258, 263, 258, 258, 260, 261, 8,
263, 270, 271, 272, 273, 274, 275, 276, 277, 272,
273, 274, 275, 276, 277, 269, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 258, 259, 258, 259, 258, 259, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 258, -1, 258, 258,
258,
);
$YYFINAL=7;
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
$YYMAXTOKEN=277;
#if YYDEBUG
@yyname = (
"end-of-file",'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
'','','','','','',"'('","')'","'*'",'',"','",'','','','','','','','','','','','','',"':'","';'",
"'<'","'='","'>'",'','','','','','','','','','','','','','','','','','','','','','','','','','','','',"'['",
'',"']'",'','','','','','','','','','','','','','','','','','','','','','','','','','','','','',"'{'",'',"'}'",
'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
'','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','','',
'','','','','','','','','','','',"CONST","IDENT","CONSTANT","ENUM","STRUCT","TYPE","UNION",
"SWITCH","CASE","DEFAULT","TYPEDEF","PROGRAM","VERSION","OPAQUE","STRING","INT",
"UNSIGNED","FLOAT","DOUBLE","BOOL","VOID",
);
@yyrule = (
"\$accept : start",
"start : specification",
"declaration : type_specifier IDENT",
"declaration : type_specifier IDENT '[' value ']'",
"declaration : type_specifier IDENT '<' value '>'",
"declaration : type_specifier IDENT '<' '>'",
"declaration : OPAQUE IDENT '[' value ']'",
"declaration : OPAQUE IDENT '<' value '>'",
"declaration : OPAQUE IDENT '<' '>'",
"declaration : STRING IDENT '<' value '>'",
"declaration : STRING IDENT '<' '>'",
"declaration : type_specifier '*' IDENT",
"declaration : VOID",
"value : CONSTANT",
"value : IDENT",
"type_specifier : INT",
"type_specifier : UNSIGNED INT",
"type_specifier : UNSIGNED",
"type_specifier : FLOAT",
"type_specifier : DOUBLE",
"type_specifier : BOOL",
"type_specifier : VOID",
"type_specifier : enum_type_spec",
"type_specifier : struct_type_spec",
"type_specifier : union_type_spec",
"type_specifier : IDENT",
"type_specifier : STRUCT IDENT",
"type_specifier : UNION IDENT",
"type_specifier : ENUM IDENT",
"enum_type_spec : ENUM enum_body",
"enum_body : '{' enum_list '}'",
"enum_list : IDENT '=' value",
"enum_list : enum_list ',' IDENT '=' value",
"struct_type_spec : STRUCT struct_body",
"struct_body : '{' struct_list '}'",
"struct_list : declaration ';'",
"struct_list : struct_list declaration ';'",
"union_type_spec : UNION union_body",
"union_body : SWITCH '(' declaration ')' '{' switch_body '}'",
"switch_body : case_list",
"switch_body : case_list default",
"case_list : CASE value ':' declaration ';'",
"case_list : case_list CASE value ':' declaration ';'",
"default : DEFAULT ':' declaration ';'",
"constant_def : CONST IDENT '=' CONSTANT ';'",
"type_def : TYPEDEF declaration ';'",
"type_def : ENUM IDENT enum_body ';'",
"type_def : STRUCT IDENT struct_body ';'",
"type_def : STRUCT '*' IDENT struct_body ';'",
"type_def : UNION IDENT union_body ';'",
"program_def : PROGRAM IDENT '{' version_list '}' '=' CONSTANT ';'",
"version_list : version_def",
"version_list : version_list version_def",
"version_def : VERSION IDENT '{' procedure_list '}' '=' CONSTANT ';'",
"procedure_list : procedure_def",
"procedure_list : procedure_list procedure_def",
"procedure_def : type_specifier IDENT '(' type_specifier ')' '=' CONSTANT ';'",
"definition : type_def",
"definition : constant_def",
"definition : program_def",
"specification : definition",
"specification : specification definition",
);
#endif
sub yyclearin { $_[0]->{'yychar'} = -1; }
sub yyerrok { $_[0]->{'yyerrflag'} = 0; }
sub new {
my $p = {'yylex' => $_[1], 'yyerror' => $_[2], 'yydebug' => $_[3]};
bless $p, $_[0];
}
sub YYERROR { ++$_[0]->{'yynerrs'}; $_[0]->yy_err_recover; }
sub yy_err_recover {
my ($p) = @_;
if ($p->{'yyerrflag'} < 3)
{
$p->{'yyerrflag'} = 3;
while (1)
{
if (($p->{'yyn'} = $yysindex[$p->{'yyss'}->[$p->{'yyssp'}]]) &&
($p->{'yyn'} += $YYERRCODE) >= 0 &&
$yycheck[$p->{'yyn'}] == $YYERRCODE)
{
warn("yydebug: state " .
$p->{'yyss'}->[$p->{'yyssp'}] .
", error recovery shifting to state" .
$yytable[$p->{'yyn'}] . "\n")
if $p->{'yydebug'};
$p->{'yyss'}->[++$p->{'yyssp'}] =
$p->{'yystate'} = $yytable[$p->{'yyn'}];
$p->{'yyvs'}->[++$p->{'yyvsp'}] = $p->{'yylval'};
next yyloop;
}
else
{
warn("yydebug: error recovery discarding state ".
$p->{'yyss'}->[$p->{'yyssp'}]. "\n")
if $p->{'yydebug'};
return(undef) if $p->{'yyssp'} <= 0;
--$p->{'yyssp'};
--$p->{'yyvsp'};
}
}
}
else
{
return (undef) if $p->{'yychar'} == 0;
if ($p->{'yydebug'})
{
$p->{'yys'} = '';
if ($p->{'yychar'} <= $YYMAXTOKEN) { $p->{'yys'} =
$yyname[$p->{'yychar'}]; }
if (!$p->{'yys'}) { $p->{'yys'} = 'illegal-symbol'; }
warn("yydebug: state " . $p->{'yystate'} .
", error recovery discards " .
"token " . $p->{'yychar'} . "(" .
$p->{'yys'} . ")\n");
}
$p->{'yychar'} = -1;
next yyloop;
}
0;
} # yy_err_recover
sub yyparse {
my ($p, $s) = @_;
if ($p->{'yys'} = $ENV{'YYDEBUG'})
{
$p->{'yydebug'} = int($1) if $p->{'yys'} =~ /^(\d)/;
}
$p->{'yynerrs'} = 0;
$p->{'yyerrflag'} = 0;
$p->{'yychar'} = (-1);
$p->{'yyssp'} = 0;
$p->{'yyvsp'} = 0;
$p->{'yyss'}->[$p->{'yyssp'}] = $p->{'yystate'} = 0;
yyloop: while(1)
{
yyreduce: {
last yyreduce if ($p->{'yyn'} = $yydefred[$p->{'yystate'}]);
if ($p->{'yychar'} < 0)
{
if ((($p->{'yychar'}, $p->{'yylval'}) =
&{$p->{'yylex'}}($s)) < 0) { $p->{'yychar'} = 0; }
if ($p->{'yydebug'})
{
$p->{'yys'} = '';
if ($p->{'yychar'} <= $#yyname)
{ $p->{'yys'} = $yyname[$p->{'yychar'}]; }
if (!$p->{'yys'}) { $p->{'yys'} = 'illegal-symbol'; };
warn("yydebug: state " . $p->{'yystate'} .
", reading " . $p->{'yychar'} . " (" .
$p->{'yys'} . ")\n");
}
}
if (($p->{'yyn'} = $yysindex[$p->{'yystate'}]) &&
($p->{'yyn'} += $p->{'yychar'}) >= 0 &&
$yycheck[$p->{'yyn'}] == $p->{'yychar'})
{
warn("yydebug: state " . $p->{'yystate'} .
", shifting to state " .
$yytable[$p->{'yyn'}] . "\n") if $p->{'yydebug'};
$p->{'yyss'}->[++$p->{'yyssp'}] = $p->{'yystate'} =
$yytable[$p->{'yyn'}];
$p->{'yyvs'}->[++$p->{'yyvsp'}] = $p->{'yylval'};
$p->{'yychar'} = (-1);
--$p->{'yyerrflag'} if $p->{'yyerrflag'} > 0;
next yyloop;
}
if (($p->{'yyn'} = $yyrindex[$p->{'yystate'}]) &&
($p->{'yyn'} += $p->{'yychar'}) >= 0 &&
$yycheck[$p->{'yyn'}] == $p->{'yychar'})
{
$p->{'yyn'} = $yytable[$p->{'yyn'}];
last yyreduce;
}
if (! $p->{'yyerrflag'}) {
&{$p->{'yyerror'}}('syntax error', $s);
++$p->{'yynerrs'};
}
return(undef) if $p->yy_err_recover;
} # yyreduce
warn("yydebug: state " . $p->{'yystate'} .
", reducing by rule " .
$p->{'yyn'} . " (" . $yyrule[$p->{'yyn'}] .
")\n") if $p->{'yydebug'};
$p->{'yym'} = $yylen[$p->{'yyn'}];
$p->{'yyval'} = $p->{'yyvs'}->[$p->{'yyvsp'}+1-$p->{'yym'}];
if ($p->{'yyn'} == 2) {
{ $p->{'yyval'} = RPCL::Decl->new($p->{'yyvs'}->[$p->{'yyvsp'}-1], $p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 3) {
{ $p->{'yyval'} = RPCL::Decl->new
(RPCL::TypeFixedArr->new($p->{'yyvs'}->[$p->{'yyvsp'}-4], $p->{'yyvs'}->[$p->{'yyvsp'}-1]), $p->{'yyvs'}->[$p->{'yyvsp'}-3]); }
}
if ($p->{'yyn'} == 4) {
{ $p->{'yyval'} = RPCL::Decl->new
(RPCL::TypeVarArr->new($p->{'yyvs'}->[$p->{'yyvsp'}-4], $p->{'yyvs'}->[$p->{'yyvsp'}-1], $p->{'yyvs'}->[$p->{'yyvsp'}-3]), $p->{'yyvs'}->[$p->{'yyvsp'}-3]); }
}
if ($p->{'yyn'} == 5) {
{ $p->{'yyval'} = RPCL::Decl->new
(RPCL::TypeVarArr->new($p->{'yyvs'}->[$p->{'yyvsp'}-3], undef, $p->{'yyvs'}->[$p->{'yyvsp'}-2]), $p->{'yyvs'}->[$p->{'yyvsp'}-2]); }
}
if ($p->{'yyn'} == 6) {
{ $p->{'yyval'} = RPCL::Decl->new
(RPCL::TypeFixedOpq->new($p->{'yyvs'}->[$p->{'yyvsp'}-1]), $p->{'yyvs'}->[$p->{'yyvsp'}-3]); }
}
if ($p->{'yyn'} == 7) {
{ $p->{'yyval'} = RPCL::Decl->new
(RPCL::TypeVarOpq->new($p->{'yyvs'}->[$p->{'yyvsp'}-1], $p->{'yyvs'}->[$p->{'yyvsp'}-3]), $p->{'yyvs'}->[$p->{'yyvsp'}-3]); }
}
if ($p->{'yyn'} == 8) {
{ $p->{'yyval'} = RPCL::Decl->new
(RPCL::TypeVarOpq->new(undef, $p->{'yyvs'}->[$p->{'yyvsp'}-2]), $p->{'yyvs'}->[$p->{'yyvsp'}-2]); }
}
if ($p->{'yyn'} == 9) {
{ $p->{'yyval'} = RPCL::Decl->new
(RPCL::TypeVarStr->new($p->{'yyvs'}->[$p->{'yyvsp'}-1], $p->{'yyvs'}->[$p->{'yyvsp'}-3]), $p->{'yyvs'}->[$p->{'yyvsp'}-3]); }
}
if ($p->{'yyn'} == 10) {
{ $p->{'yyval'} = RPCL::Decl->new
(RPCL::TypeVarStr->new(undef, $p->{'yyvs'}->[$p->{'yyvsp'}-2]), $p->{'yyvs'}->[$p->{'yyvsp'}-2]); }
}
if ($p->{'yyn'} == 11) {
{ $p->{'yyval'} = RPCL::Decl->new
(RPCL::TypePtr->new($p->{'yyvs'}->[$p->{'yyvsp'}-2]), $p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 12) {
{ $p->{'yyval'} = RPCL::Decl->new
(RPCL::TypeVoid->new(), undef); }
}
if ($p->{'yyn'} == 13) {
{ $p->{'yyval'} = RPCL::Constant->new($p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 14) {
{ $p->{'yyval'} = RPCL::NamedConstant->new($p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 15) {
{ $p->{'yyval'} = RPCL::TypeInt->new(); }
}
if ($p->{'yyn'} == 16) {
{ $p->{'yyval'} = RPCL::TypeUInt->new(); }
}
if ($p->{'yyn'} == 17) {
{ $p->{'yyval'} = RPCL::TypeUInt->new(); }
}
if ($p->{'yyn'} == 18) {
{ $p->{'yyval'} = RPCL::TypeFloat->new(); }
}
if ($p->{'yyn'} == 19) {
{ $p->{'yyval'} = RPCL::TypeDouble->new(); }
}
if ($p->{'yyn'} == 20) {
{ $p->{'yyval'} = RPCL::TypeBool->new(); }
}
if ($p->{'yyn'} == 21) {
{ $p->{'yyval'} = RPCL::TypeVoid->new(); }
}
if ($p->{'yyn'} == 25) {
{ $p->{'yyval'} = RPCL::TypeName->new($p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 26) {
{ $p->{'yyval'} = RPCL::TypeName->new($p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 27) {
{ $p->{'yyval'} = RPCL::TypeName->new($p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 28) {
{ $p->{'yyval'} = RPCL::TypeName->new($p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 29) {
{ $p->{'yyval'} = RPCL::EnumDef->new(&gensym('enum'), $p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 30) {
{ $p->{'yyval'} = $p->{'yyvs'}->[$p->{'yyvsp'}-1]; }
}
if ($p->{'yyn'} == 31) {
{ $p->{'yyval'} = [ RPCL::EnumVal->new($p->{'yyvs'}->[$p->{'yyvsp'}-2], $p->{'yyvs'}->[$p->{'yyvsp'}-0]) ]; }
}
if ($p->{'yyn'} == 32) {
{ $p->{'yyval'} = $p->{'yyvs'}->[$p->{'yyvsp'}-4]; push(@{$p->{'yyval'}}, RPCL::EnumVal->new($p->{'yyvs'}->[$p->{'yyvsp'}-2], $p->{'yyvs'}->[$p->{'yyvsp'}-0])); }
}
if ($p->{'yyn'} == 33) {
{ $p->{'yyval'} = RPCL::StructDef->new(&gensym('struct'), $p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 34) {
{ $p->{'yyval'} = $p->{'yyvs'}->[$p->{'yyvsp'}-1]; }
}
if ($p->{'yyn'} == 35) {
{ $p->{'yyval'} = [ $p->{'yyvs'}->[$p->{'yyvsp'}-1] ]; }
}
if ($p->{'yyn'} == 36) {
{ $p->{'yyval'} = $p->{'yyvs'}->[$p->{'yyvsp'}-2]; push(@{$p->{'yyval'}}, $p->{'yyvs'}->[$p->{'yyvsp'}-1]); }
}
if ($p->{'yyn'} == 37) {
{ $p->{'yyval'} = RPCL::UnionDef
(&gensym('union'), $p->{'yyvs'}->[$p->{'yyvsp'}-0]->[0], $p->{'yyvs'}->[$p->{'yyvsp'}-0]->[1]); }
}
if ($p->{'yyn'} == 38) {
{ $p->{'yyval'} = [ $p->{'yyvs'}->[$p->{'yyvsp'}-4], $p->{'yyvs'}->[$p->{'yyvsp'}-1] ]; }
}
if ($p->{'yyn'} == 39) {
{ $p->{'yyval'} = [ $p->{'yyvs'}->[$p->{'yyvsp'}-0] ]; }
}
if ($p->{'yyn'} == 40) {
{ $p->{'yyval'} = $p->{'yyvs'}->[$p->{'yyvsp'}-1]; push(@{$p->{'yyval'}}, $p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 41) {
{ $p->{'yyval'} = [ RPCL::Case->new($p->{'yyvs'}->[$p->{'yyvsp'}-3], $p->{'yyvs'}->[$p->{'yyvsp'}-1]) ] }
}
if ($p->{'yyn'} == 42) {
{ $p->{'yyval'} = $p->{'yyvs'}->[$p->{'yyvsp'}-5]; push(@{$p->{'yyval'}}, RPCL::Case->new($p->{'yyvs'}->[$p->{'yyvsp'}-3], $p->{'yyvs'}->[$p->{'yyvsp'}-1])); }
}
if ($p->{'yyn'} == 43) {
{ $p->{'yyval'} = RPCL::CaseDefault->new($p->{'yyvs'}->[$p->{'yyvsp'}-1]); }
}
if ($p->{'yyn'} == 44) {
{ $p->{'yyval'} = RPCL::ConstDef->new($p->{'yyvs'}->[$p->{'yyvsp'}-3], $p->{'yyvs'}->[$p->{'yyvsp'}-1]);
$main::consts{$p->{'yyvs'}->[$p->{'yyvsp'}-3]} = $p->{'yyvs'}->[$p->{'yyvsp'}-1]; }
}
if ($p->{'yyn'} == 45) {
{ $p->{'yyval'} = RPCL::TypedefDef->new($p->{'yyvs'}->[$p->{'yyvsp'}-1]->ident, $p->{'yyvs'}->[$p->{'yyvsp'}-1]->type);
$main::types{$p->{'yyvs'}->[$p->{'yyvsp'}-1]->ident} = $p->{'yyval'}; }
}
if ($p->{'yyn'} == 46) {
{ $p->{'yyval'} = RPCL::EnumDef->new($p->{'yyvs'}->[$p->{'yyvsp'}-2], $p->{'yyvs'}->[$p->{'yyvsp'}-1]);
$main::types{$p->{'yyvs'}->[$p->{'yyvsp'}-2]} = $p->{'yyval'}; }
}
if ($p->{'yyn'} == 47) {
{ $p->{'yyval'} = RPCL::StructDef->new($p->{'yyvs'}->[$p->{'yyvsp'}-2], $p->{'yyvs'}->[$p->{'yyvsp'}-1]);
$main::types{$p->{'yyvs'}->[$p->{'yyvsp'}-2]} = $p->{'yyval'}; }
}
if ($p->{'yyn'} == 48) {
{ $p->{'yyval'} = RPCL::StructPDef->new($p->{'yyvs'}->[$p->{'yyvsp'}-2], $p->{'yyvs'}->[$p->{'yyvsp'}-1]);
$main::types{$p->{'yyvs'}->[$p->{'yyvsp'}-2]} = $p->{'yyval'}; }
}
if ($p->{'yyn'} == 49) {
{ $p->{'yyval'} = RPCL::UnionDef->new($p->{'yyvs'}->[$p->{'yyvsp'}-2], $p->{'yyvs'}->[$p->{'yyvsp'}-1]->[0], $p->{'yyvs'}->[$p->{'yyvsp'}-1]->[1]);
$main::types{$p->{'yyvs'}->[$p->{'yyvsp'}-2]} = $p->{'yyval'}; }
}
if ($p->{'yyn'} == 50) {
{ $p->{'yyval'} = RPCL::ProgramDef->new($p->{'yyvs'}->[$p->{'yyvsp'}-6], $p->{'yyvs'}->[$p->{'yyvsp'}-4], $p->{'yyvs'}->[$p->{'yyvsp'}-1]); }
}
if ($p->{'yyn'} == 51) {
{ $p->{'yyval'} = [ $p->{'yyvs'}->[$p->{'yyvsp'}-0] ]; }
}
if ($p->{'yyn'} == 52) {
{ $p->{'yyval'} = $p->{'yyvs'}->[$p->{'yyvsp'}-1]; push(@{$p->{'yyval'}}, $p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 53) {
{ $p->{'yyval'} = RPCL::Version->new($p->{'yyvs'}->[$p->{'yyvsp'}-6], $p->{'yyvs'}->[$p->{'yyvsp'}-4], $p->{'yyvs'}->[$p->{'yyvsp'}-1]); }
}
if ($p->{'yyn'} == 54) {
{ $p->{'yyval'} = [ $p->{'yyvs'}->[$p->{'yyvsp'}-0] ]; }
}
if ($p->{'yyn'} == 55) {
{ $p->{'yyval'} = $p->{'yyvs'}->[$p->{'yyvsp'}-1]; push(@{$p->{'yyval'}}, $p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
if ($p->{'yyn'} == 56) {
{ $p->{'yyval'} = RPCL::Procedure->new($p->{'yyvs'}->[$p->{'yyvsp'}-7], $p->{'yyvs'}->[$p->{'yyvsp'}-6], $p->{'yyvs'}->[$p->{'yyvsp'}-4], $p->{'yyvs'}->[$p->{'yyvsp'}-1]); }
}
if ($p->{'yyn'} == 60) {
{ $p->{'yyval'} = [ $p->{'yyvs'}->[$p->{'yyvsp'}-0] ]; }
}
if ($p->{'yyn'} == 61) {
{ $p->{'yyval'} = $p->{'yyvs'}->[$p->{'yyvsp'}-1]; push(@{$p->{'yyval'}}, $p->{'yyvs'}->[$p->{'yyvsp'}-0]); }
}
$p->{'yyssp'} -= $p->{'yym'};
$p->{'yystate'} = $p->{'yyss'}->[$p->{'yyssp'}];
$p->{'yyvsp'} -= $p->{'yym'};
$p->{'yym'} = $yylhs[$p->{'yyn'}];
if ($p->{'yystate'} == 0 && $p->{'yym'} == 0)
{
warn("yydebug: after reduction, shifting from state 0 ",
"to state $YYFINAL\n") if $p->{'yydebug'};
$p->{'yystate'} = $YYFINAL;
$p->{'yyss'}->[++$p->{'yyssp'}] = $YYFINAL;
$p->{'yyvs'}->[++$p->{'yyvsp'}] = $p->{'yyval'};
if ($p->{'yychar'} < 0)
{
if ((($p->{'yychar'}, $p->{'yylval'}) =
&{$p->{'yylex'}}($s)) < 0) { $p->{'yychar'} = 0; }
if ($p->{'yydebug'})
{
$p->{'yys'} = '';
if ($p->{'yychar'} <= $#yyname)
{ $p->{'yys'} = $yyname[$p->{'yychar'}]; }
if (!$p->{'yys'}) { $p->{'yys'} = 'illegal-symbol'; }
warn("yydebug: state $YYFINAL, reading " .
$p->{'yychar'} . " (" . $p->{'yys'} . ")\n");
}
}
return ($p->{'yyvs'}->[1]) if $p->{'yychar'} == 0;
next yyloop;
}
if (($p->{'yyn'} = $yygindex[$p->{'yym'}]) &&
($p->{'yyn'} += $p->{'yystate'}) >= 0 &&
$p->{'yyn'} <= $#yycheck &&
$yycheck[$p->{'yyn'}] == $p->{'yystate'})
{
$p->{'yystate'} = $yytable[$p->{'yyn'}];
} else {
$p->{'yystate'} = $yydgoto[$p->{'yym'}];
}
warn("yydebug: after reduction, shifting from state " .
$p->{'yyss'}->[$p->{'yyssp'}] . " to state " .
$p->{'yystate'} . "\n") if $p->{'yydebug'};
$p->{'yyss'}[++$p->{'yyssp'}] = $p->{'yystate'};
$p->{'yyvs'}[++$p->{'yyvsp'}] = $p->{'yyval'};
} # yyloop
} # yyparse
%keywords =
('const' => $CONST,
'enum' => $ENUM,
'struct' => $STRUCT,
'union' => $UNION,
'switch' => $SWITCH,
'case' => $CASE,
'default' => $DEFAULT,
'typedef' => $TYPEDEF,
'program' => $PROGRAM,
'version' => $VERSION,
'opaque' => $OPAQUE,
'string' => $STRING,
'int' => $INT,
'unsigned' => $UNSIGNED,
'float' => $FLOAT,
'double' => $DOUBLE,
'bool' => $BOOL,
'void' => $VOID);
%main::consts = ();
sub gensym {
my ($sym) = @_;
$sym = 'g' unless $sym;
return $sym . $gensyms{$sym}++;
}
sub yylex {
my ($s) = @_;
my ($c, $val);
AGAIN:
while (($c = $s->getc) eq ' ' || $c eq "\t" || $c eq "\n") {
}
if ($c eq '') {
return 0;
}
elsif ($c eq '%') { # RPCL pass-through character
while (($c = $s->getc) ne "\n" && $c ne '') {
}
$s->ungetc;
goto AGAIN;
}
elsif ($c =~ /[a-zA-Z_]/) {
$val = $c;
while (($c = $s->getc) =~ /[0-9a-zA-Z_]/) {
$val .= $c;
}
$s->ungetc;
if ($keywords{$val}) {
return $keywords{$val};
}
else {
return ($IDENT, $val);
}
}
elsif ($c =~ /[0-9-]/) {
$val = $c;
while (($c = $s->getc) =~ /[0-9]/) {
$val .= $c;
}
$s->ungetc;
return ($CONSTANT, $val);
}
else {
return ord($c);
}
}
sub yyerror {
my ($msg, $s) = @_;
die "$msg at " . $s->name . " line " . $s->lineno . ".\n";
}
1;