colin
/
tripwire-open-source
mirror of https://github.com/Tripwire/tripwire-open-source.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
tripwire-open-source/src/twparser/yyparse.cpp

1487 lines
40 KiB
C++
Raw Blame History

//
// The developer of the original code and/or files is Tripwire, Inc.
// Portions created by Tripwire, Inc. are copyright (C) 2000 Tripwire,
// Inc. Tripwire is a registered trademark of Tripwire, Inc. All rights
// reserved.
//
// This program is free software. The contents of this file are subject
// to the terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at your
// option) any later version. You may redistribute it and/or modify it
// only in compliance with the GNU General Public License.
//
// This program is distributed in the hope that it will be useful.
// However, this program is distributed AS-IS WITHOUT ANY
// WARRANTY; INCLUDING THE IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS
// FOR A PARTICULAR PURPOSE. Please see the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
//
// Nothing in the GNU General Public License or any other license to use
// the code or files shall permit you to use Tripwire's trademarks,
// service marks, or other intellectual property without Tripwire's
// prior written consent.
//
// If you have any questions, please contact Tripwire, Inc. at either
// info@tripwire.org or www.tripwire.org.
//
/* ..\. -LC -o ..\twparser\yyparse.cpp -P ..\..\mkslexyacc\etc\yyparse.cpp -D yyparse.h policy.y */
#line 74 "policy.y"
#include "stdtwparser.h"
#include "core/debug.h"
#include "parserhelper.h"
#include "genreparseinfo.h"
#include "policyparser.h"
#include "fco/genreswitcher.h"
#include "fco/twfactory.h"
#include "fco/fconameinfo.h"
#include "fco/parsergenreutil.h"
#include "fco/fconametranslator.h"
#include "core/usernotify.h"
#ifndef YYNEWLINE
# include "parser/yylex.h"
# include "parser/yyparse.h"
#endif
// global variables
int yaccdebuglevel;
// in MKS Yacc in C++ mode, we need to explicitly declare yylavl
YYSTYPE yylval;
static TSTRING ConcatenateStrings( const std::list<TSTRING>* plist )
{
TSTRING strRet;
for( std::list<TSTRING>::const_iterator i = plist->begin(); i != plist->end(); i++ )
strRet += *i;
return strRet;
}
static std::list<TSTRING>* MergeIntoList( std::list<TSTRING>* plistLHS, const std::list<TSTRING>* plistRHS )
{
for( std::list<TSTRING>::const_iterator i = plistRHS->begin(); i != plistRHS->end(); i++ )
plistLHS->push_back( *i );
return plistLHS;
}
extern YYSTYPE yylval;
#if YYDEBUG
enum YY_Types { YY_t_NoneDefined, YY_t_mpString, YY_t_mpNode, YY_t_mpAttr, YY_t_mpAttrList, YY_t_mpStringList
};
#endif
#if YYDEBUG
yyTypedRules yyRules[] = {
{ "&00: %18 &00", 0},
{ "%18: %19", 0},
{ "%19: %20", 0},
{ "%19:", 0},
{ "%20: %20 %21", 0},
{ "%20: %21", 0},
{ "%21: %22 &07", 0},
{ "%21: %23 &07", 0},
{ "%21: %24 &07", 0},
{ "%21: &07", 0},
{ "%21: %25", 0},
{ "%21: %26", 0},
{ "%27:", 0},
{ "%26: &03 %04 &04 &08 %27 %19 &09", 0},
{ "%28:", 0},
{ "%25: &19 %16 %28 %19 %29 &21", 0},
{ "%25: &18 %09", 0},
{ "%25: &23 %09", 0},
{ "%25: &22 %09", 0},
{ "%16: %16 &29 %15", 5},
{ "%16: %15", 5},
{ "%30:", 0},
{ "%29: &20 %30 %19", 0},
{ "%29:", 0},
{ "%22: %13 &33 %10", 0},
{ "%23: %14 &33 %11", 0},
{ "%24: %06 &17 %01", 0},
{ "%24: &13 %06", 0},
{ "%01: %17 %05", 2},
{ "%05: &03 %04 &04", 4},
{ "%05:", 4},
{ "%04: %03 %31", 4},
{ "%03: %03 &02 %02", 4},
{ "%03: %02", 4},
{ "%02: %07 &33 %08", 3},
{ "%31: &02", 0},
{ "%31:", 0},
{ "%12: &12 &03 %13 &04", 1},
{ "%17: %10", 1},
{ "%07: %09", 1},
{ "%08: %10", 1},
{ "%06: %10", 5},
{ "%06: %10 &11 %10", 5},
{ "%15: %09", 1},
{ "%13: &06", 1},
{ "%10: %10 %09", 5},
{ "%10: %09", 5},
{ "%11: %11 %14", 5},
{ "%11: %14", 5},
{ "%09: &06", 1},
{ "%09: %12", 1},
{ "%14: &34", 1},
{ "$accept", 0},{ "error", 0}
};
yyNamedType yyTokenTypes[] = {
{ "$end", 0, 0},
{ "error", 256, 0},
{ "TWP_COMMA", 257, 0},
{ "TWP_LPAREN", 258, 0},
{ "TWP_RPAREN", 259, 0},
{ "TWP_COMMENT", 260, 0},
{ "TWP_STRING", 261, 1},
{ "TWP_SEMICOLON", 262, 0},
{ "TWP_LBRACE", 263, 0},
{ "TWP_RBRACE", 264, 0},
{ "TWP_DEFAULT", 265, 0},
{ "TWP_PIPE", 266, 0},
{ "TWP_DOLLAR", 267, 0},
{ "TWP_BANG", 268, 0},
{ "TWP_PLUS", 269, 0},
{ "TWP_MINUS", 270, 0},
{ "TWP_DQUOTE", 271, 0},
{ "TWP_RARROW", 272, 0},
{ "TWP_SECTION", 273, 0},
{ "TWP_IFHOST", 274, 0},
{ "TWP_ELSE", 275, 0},
{ "TWP_ENDIF", 276, 0},
{ "TWP_ECHO", 277, 0},
{ "TWP_ERROR", 278, 0},
{ "TWP_DEFINE", 279, 0},
{ "TWP_UNDEF", 280, 0},
{ "TWP_CONTENTS", 281, 0},
{ "TWP_DBASEVERSION", 282, 0},
{ "TWP_ANDAND", 283, 0},
{ "TWP_OROR", 284, 0},
{ "TWP_BSLASH", 285, 0},
{ "TWP_ESCCHAR", 286, 0},
{ "TWP_QSTRING", 287, 0},
{ "TWP_EQUALS", 288, 0},
{ "TWP_GLOBAL_STRING", 289, 1}
};
#endif
static short yydef[] = {
65535, 65531, 9, 53, 65527, 3, 65523, 10, 7, 65519,
5, 4, 65515, 50, 65509, 8, 65505, -35
};
static short yyex[] = {
0, 52, 65535, 1, 288, 18, 65535, 13, 0, 0,
65535, 1, 259, 49, 65535, 1, 262, 6, 65535, 1,
275, 52, 276, 52, 65535, 1, 276, 51, 65535, 1,
264, 52, 65535, 1, 276, 52, 65535, 1
};
static short yyact[] = {
65499, 65534, 65455, 65490, 65491, 65497, 65498, 65495, 65496, 65489,
289, 278, 277, 274, 273, 268, 267, 262, 261, 258,
65487, 65503, 65490, 267, 266, 261, 65504, 258, 65487, 65490,
267, 261, 65505, 272, 65506, 288, 65507, 288, 65461, 262,
65460, 262, 65459, 262, 65482, 261, 65489, 289, 65511, 284,
65512, 288, 65522, 257, 65513, 259, 65479, 259, 65514, 258,
65462, 263, 65470, 275, 65474, 259, 65464, 276, 65463, 264, -1
};
static short yypact[] = {
10, 20, 23, 10, 44, 49, 53, 30, 30, 59,
47, 30, 10, 30, 63, 30, 10, 10, 69, 67,
65, 30, 61, 30, 30, 57, 55, 51, 30, 47,
30, 45, 30, 43, 41, 39, 30, 30, 30, 30,
30, 37, 35, 33, 30, 27
};
static short yygo[] = {
65471, 65476, 65477, 13, 65529, 65515, 65509, 21, 65473, 65472,
65492, 44, 65508, 65478, 65483, 65483, 65483, 65483, 65480, 65483,
65480, 65481, 65480, 65481, 65465, 65466, 65467, 65484, 40, 39,
38, 37, 36, 24, 21, 15, 13, 11, 8, 7,
2, 65520, 65524, 65527, 65528, 65533, 32, 30, 28, 23,
65525, 65488, 65510, 65494, 31, 65485, 65486, 65493, 29, 10,
65468, 65469, 24, 65530, 65526, 65531, 65521, 65517, 65452, 65458,
17, 16, 12, 65532, 65457, 65456, 3, 65502, 65501, 65500,
65454, 65453, 65519, 65523, 65516, 65518, 65475, -1
};
static short yypgo[] = {
0, 0, 0, 83, 77, 78, 8, 64, 13, 10,
10, 57, 27, 27, 50, 50, 45, 45, 53, 61,
12, 51, 2, 4, 4, 6, 8, 0, 79, 79,
85, 63, 63, 80, 80, 80, 80, 81, 82, 75,
75, 75, 65, 73, 73, 75, 75, 75, 84, 86,
86, 84, 69, 69, 0
};
static short yyrlen[] = {
0, 0, 0, 0, 3, 3, 0, 1, 1, 1,
3, 1, 1, 1, 1, 2, 1, 2, 1, 1,
1, 4, 3, 1, 3, 2, 3, 2, 2, 3,
0, 1, 3, 2, 2, 2, 6, 7, 0, 2,
2, 2, 1, 2, 1, 1, 1, 1, 3, 0,
1, 0, 0, 1, 2
};
#define YYS0 0
#define YYDELTA 35
#define YYNPACT 46
#define YYNDEF 18
#define YYr52 0
#define YYr53 1
#define YYr54 2
#define YYr14 3
#define YYr24 4
#define YYr25 5
#define YYr30 6
#define YYr38 7
#define YYr40 8
#define YYr41 9
#define YYr42 10
#define YYr51 11
#define YYr50 12
#define YYr49 13
#define YYr48 14
#define YYr47 15
#define YYr46 16
#define YYr45 17
#define YYr44 18
#define YYr43 19
#define YYr39 20
#define YYr37 21
#define YYr34 22
#define YYr33 23
#define YYr32 24
#define YYr31 25
#define YYr29 26
#define YYr28 27
#define YYr27 28
#define YYr26 29
#define YYr21 30
#define YYr20 31
#define YYr19 32
#define YYr18 33
#define YYr17 34
#define YYr16 35
#define YYr15 36
#define YYr13 37
#define YYr12 38
#define YYr8 39
#define YYr7 40
#define YYr6 41
#define YYrACCEPT YYr52
#define YYrERROR YYr53
#define YYrLR2 YYr54
#if YYDEBUG
char * yysvar[] = {
"$accept",
"spec_masks",
"attribute",
"attribute_list",
"attribute_list_with_opt_trailing_comma",
"opt_spec_attributes",
"fco_name",
"attribute_name",
"attribute_value",
"string",
"multi_string",
"global_multi_string",
"variable",
"variable_name",
"global_string",
"host_name",
"host_name_list",
"prop_vector",
"policy",
"opt_statement_list",
"statement_list",
"statement",
"variable_assignment",
"global_variable_assignment",
"rule",
"directive_block",
"scoped_block",
"$12",
"$14",
"opt_else_host",
"$21",
"opt_comma",
0
};
short yyrmap[] = {
52, 53, 54, 14, 24, 25, 30, 38, 40, 41,
42, 51, 50, 49, 48, 47, 46, 45, 44, 43,
39, 37, 34, 33, 32, 31, 29, 28, 27, 26,
21, 20, 19, 18, 17, 16, 15, 13, 12, 8,
7, 6, 1, 4, 5, 9, 10, 11, 22, 36,
35, 23, 3, 2, 0
};
short yysmap[] = {
0, 4, 5, 23, 25, 39, 43, 49, 52, 53,
56, 57, 59, 61, 69, 70, 77, 79, 81, 76,
74, 65, 63, 60, 58, 51, 44, 41, 33, 32,
31, 29, 28, 21, 20, 19, 15, 14, 13, 12,
11, 10, 9, 8, 7, 6, 1, 2, 26, 55,
67, 3, 27, 50, 37, 40, 64, 71, 42, 72,
62, 78, 66, 30, 54, 75, 38, 68, 34, 35,
36, 80, 83, 73, 45, 46, 47, 24, 48, 22,
18, 17, 16, 82
};
int yy_parse::yyntoken = 35;
int yy_parse::yynvar = 32;
int yy_parse::yynstate = 84;
int yy_parse::yynrule = 55;
#endif
#line 2 "..\\..\\mkslexyacc\\etc\\yyparse.cpp"
// C++ YACC parser code
// Copyright 1991 by Mortice Kern Systems Inc. All rights reserved.
//
// If YYDEBUG is defined as 1 and yy_parse::yydebug is set to 1,
// yyparse() will print a travelogue of its actions as it reads
// and parses input.
//
// YYSYNC can be defined to cause yyparse() to attempt to always
// hold a lookahead token
const int YY_MIN_STATE_NUM = 20; // not useful to be too small!
#if YYDEBUG
#ifdef YYTRACE
long * yy_parse::States = yyStates;
#endif
yyTypedRules * yy_parse::Rules = yyRules;
yyNamedType * yy_parse::TokenTypes = yyTokenTypes;
#define YY_TRACE(fn) { done = 0; fn(); if (done) YYRETURN(-1); }
#endif
// Constructor for yy_parse: user-provided tables
yy_parse::yy_parse(int sz, short * states, YYSTYPE * stack)
{
mustfree = 0;
if ((size = sz) < YY_MIN_STATE_NUM
|| (stateStack = states) == (short *) 0
|| (valueStack = stack) == (YYSTYPE *) 0) {
fprintf(stderr,"Bad state/stack given");
exit(1);
}
reset = 1; // force reset
#if YYDEBUG
yydebug = 0;
typeStack = new short[size+1];
if (typeStack == (short *) 0) {
fprintf(stderr,"Cannot allocate typeStack");
exit(1);
}
#endif
}
// Constructor for yy_parse: allocate tables with new
yy_parse::yy_parse(int sz)
{
size = sz;
reset = 1; // force reset
mustfree = 1; // delete space in deconstructor
#if YYDEBUG
yydebug = 0;
typeStack = new short[size+1];
#endif
stateStack = new short[size+1];
valueStack = new YYSTYPE[size+1];
if (stateStack == (short *) 0 || valueStack == (YYSTYPE *) 0
#if YYDEBUG
|| typeStack == (short *) 0
#endif
) {
fprintf(stderr,"Not enough space for parser stacks");
exit(1);
}
}
// Destructor for class yy_parse
// Free up space
yy_parse::~yy_parse()
{
if (mustfree) {
delete stateStack;
delete valueStack;
}
stateStack = (short *) 0;
#if YYDEBUG
delete typeStack;
#endif
}
#ifdef YACC_WINDOWS
// The initial portion of the yacc parser.
// In an windows environment, it will load the desired
// resources, obtain pointers to them, and then call
// the protected member win_yyparse() to acutally begin the
// parsing. When complete, win_yyparse() will return a
// value back to our new yyparse() function, which will
// record that value temporarily, release the resources
// from global memory, and finally return the value
// back to the caller of yyparse().
int
yy_parse::yyparse(yy_scan* ps)
{
int wReturnValue;
HANDLE hRes_table;
short far *old_yydef; // the following are used for saving
short far *old_yyex; // the current pointers
short far *old_yyact;
short far *old_yypact;
short far *old_yygo;
short far *old_yypgo;
short far *old_yyrlen;
// the following code will load the required
// resources for a Windows based parser.
hRes_table = LoadResource (hInst,
FindResource (hInst, "UD_RES_yyYACC", "yyYACCTBL"));
// return an error code if any
// of the resources did not load
if (hRes_table == (HANDLE)NULL)
return (1);
// the following code will lock the resources
// into fixed memory locations for the parser
// (also, save away the old pointer values)
old_yydef = yydef;
old_yyex = yyex;
old_yyact = yyact;
old_yypact = yypact;
old_yygo = yygo;
old_yypgo = yypgo;
old_yyrlen = yyrlen;
yydef = (short far *)LockResource (hRes_table);
yyex = (short far *)(yydef + Sizeof_yydef);
yyact = (short far *)(yyex + Sizeof_yyex);
yypact = (short far *)(yyact + Sizeof_yyact);
yygo = (short far *)(yypact + Sizeof_yypact);
yypgo = (short far *)(yygo + Sizeof_yygo);
yyrlen = (short far *)(yypgo + Sizeof_yypgo);
// call the official yyparse() function
wReturnValue = win_yyparse (ps);
// unlock the resources
UnlockResource (hRes_table);
// and now free the resource
FreeResource (hRes_table);
//
// restore previous pointer values
//
yydef = old_yydef;
yyex = old_yyex;
yyact = old_yyact;
yypact = old_yypact;
yygo = old_yygo;
yypgo = old_yypgo;
yyrlen = old_yyrlen;
return (wReturnValue);
} // end yyparse()
// The parser proper.
// Note that this code is reentrant; you can return a value
// and then resume parsing by recalling yyparse().
// Call yyreset() before yyparse() if you want a fresh start
int
yy_parse::win_yyparse(yy_scan* ps)
#else /* YACC_WINDOWS */
// The parser proper.
// Note that this code is reentrant; you can return a value
// and then resume parsing by recalling yyparse().
// Call yyreset() before yyparse() if you want a fresh start
int
yy_parse::yyparse(yy_scan* ps)
#endif /* YACC_WINDOWS */
{
#ifdef YACC_WINDOWS
short far *yyp; // needed as res tables locked in far memory
short far *yyq;
#else
short * yyp, * yyq; // table lookup
#endif /* YACC_WINDOWS */
int yyj;
#if YYDEBUG
int yyruletype = 0;
#endif
if ((scan = ps) == (yy_scan *) 0) { // scanner
fprintf(stderr,"No scanner");
exit(1);
}
if (reset) { // start new parse
yynerrs = 0;
yyerrflag = 0;
yyps = stateStack;
yypv = valueStack;
#if YYDEBUG
yytp = typeStack;
#endif
yystate = YYS0;
yyclearin();
reset = 0;
} else // continue saved parse
goto yyNext; // after action
yyStack:
if (++yyps > &stateStack[size]) {
scan->yyerror("Parser stack overflow");
YYABORT;
}
*yyps = yystate; /* stack current state */
*++yypv = yyval; /* ... and value */
#if YYDEBUG
if (yydebug) {
*++yytp = yyruletype; /* ... and type */
YY_TRACE(yyShowState)
}
#endif
/*
* Look up next action in action table.
*/
yyEncore:
#ifdef YYSYNC
if (yychar < 0) {
if ((yychar = scan->yylex()) < 0) {
if (yychar == -2) YYABORT;
yychar = 0;
} /* endif */
yylval = ::yylval;
#if YYDEBUG
if (yydebug)
yyShowRead(); // show new input token
#endif
}
#endif
#ifdef YACC_WINDOWS
if (yystate >= Sizeof_yypact) /* simple state */
#else /* YACC_WINDOWS */
if (yystate >= (int)sizeof yypact/(int)sizeof yypact[0]) /* simple state */
#endif /* YACC_WINDOWS */
yyi = yystate - YYDELTA; /* reduce in any case */
else {
if(*(yyp = &yyact[yypact[yystate]]) >= 0) {
/* Look for a shift on yychar */
#ifndef YYSYNC
if (yychar < 0) {
if ((yychar = scan->yylex()) < 0) {
if (yychar == -2) YYABORT;
yychar = 0;
} /* endif */
yylval = ::yylval;
#if YYDEBUG
if (yydebug)
yyShowRead(); // show new input token
#endif
}
#endif
yyq = yyp;
yyi = yychar;
while (yyi < *yyp++)
;
if (yyi == yyp[-1]) {
yystate = yyneg(yyq[yyq-yyp]);
#if YYDEBUG
if (yydebug) {
yyruletype = yyGetType(yychar);
YY_TRACE(yyShowShift)
}
#endif
yyval = yylval; /* stack value */
yyclearin(); /* clear token */
if (yyerrflag)
yyerrflag--; /* successful shift */
goto yyStack;
}
}
/*
* Fell through - take default action
*/
#ifdef YACC_WINDOWS
if (yystate >= Sizeof_yydef) /* simple state */
#else /* YACC_WINDOWS */
if (yystate >= (int)sizeof yydef /(int)sizeof yydef[0])
#endif /* YACC_WINDOWS */
goto yyError;
if ((yyi = yydef[yystate]) < 0) { /* default == reduce? */
/* Search exception table */
yyp = &yyex[yyneg(yyi)];
#ifndef YYSYNC
if (yychar < 0) {
if ((yychar = scan->yylex()) < 0) {
if (yychar == -2) YYABORT;
yychar = 0;
} /* endif */
yylval = ::yylval;
#if YYDEBUG
if (yydebug)
yyShowRead(); // show new input token
#endif
}
#endif
while((yyi = *yyp) >= 0 && yyi != yychar)
yyp += 2;
yyi = yyp[1];
}
}
yyj = yyrlen[yyi];
#if YYDEBUG
if (yydebug) {
npop = yyj; rule = yyi;
YY_TRACE(yyShowReduce)
yytp -= yyj;
}
#endif
yyps -= yyj; /* pop stacks */
yypvt = yypv; /* save top */
yypv -= yyj;
yyval = yypv[1]; /* default action $ = $1 */
#if YYDEBUG
if (yydebug)
yyruletype = yyRules[yyrmap[yyi]].type;
#endif
switch (yyi) { /* perform semantic action */
case YYr6: { /* statement : variable_assignment TWP_SEMICOLON */
#line 194 "policy.y"
cParserHelper::IncrementScopeStatementCount();
} break;
case YYr7: { /* statement : global_variable_assignment TWP_SEMICOLON */
#line 195 "policy.y"
cParserHelper::IncrementScopeStatementCount();
} break;
case YYr8: { /* statement : rule TWP_SEMICOLON */
#line 196 "policy.y"
cParserHelper::IncrementScopeStatementCount();
} break;
case YYr12: { /* scoped_block : TWP_LPAREN attribute_list_with_opt_trailing_comma TWP_RPAREN TWP_LBRACE */
#line 204 "policy.y"
cDebug d("Parse::scope");
// create new scope
cAttrScopeInfo* pScopeInfo = new cAttrScopeInfo;
// init scope info
pScopeInfo->SetAttributes( yypvt[-2].mpAttrList );
// push onto scope stack
cParserHelper::PushScope( pScopeInfo );
d.TraceDebug("push\n");
} break;
case YYr13: { /* scoped_block : TWP_LPAREN attribute_list_with_opt_trailing_comma TWP_RPAREN TWP_LBRACE $12 opt_statement_list TWP_RBRACE */
#line 218 "policy.y"
if( 0 == cParserHelper::GetScopeStatementCount() && iUserNotify::GetInstance()->GetVerboseLevel() == iUserNotify::V_VERBOSE )
{
eParserNoStatementsInScope e;
e.SetFatality( false );
cParserHelper::GetErrorBucket()->AddError( e );
}
cDebug d("Parse::scope");
cParserHelper::PopScope();
d.TraceDebug("pop\n");
} break;
case YYr14: { /* directive_block : TWP_IFHOST host_name_list */
#line 234 "policy.y"
cDebug d("Parse::#ifhost");
if( cPreprocessor::GetState() == cPreprocessor::STATE_ACCEPT )
{
if( cParserUtil::AnyOfTheseHostsExists( yypvt[0].mpStringList ) )
{
cPreprocessor::PushState( cPreprocessor::STATE_ACCEPT );
}
else
{
cPreprocessor::PushState( cPreprocessor::STATE_IGNORE );
}
d.TraceDebug(_T("\n"));
}
else
{
cPreprocessor::PushState( cPreprocessor::STATE_IGNORE );
d.TraceDebug(_T("ignoring ifhost\n"));
}
} break;
case YYr15: { /* directive_block : TWP_IFHOST host_name_list $14 opt_statement_list opt_else_host TWP_ENDIF */
#line 257 "policy.y"
cDebug d("Parse::#endif");
cPreprocessor::PopState();
delete yypvt[-4].mpStringList;
} break;
case YYr16: { /* directive_block : TWP_SECTION string */
#line 264 "policy.y"
cDebug d("Parse::#section");
if( ! ( cPreprocessor::AtTopLevel() && cParserHelper::AtTopScope() ) )
throw eParserSectionInsideBlock( *yypvt[0].mpString );
cParserHelper::SetSection( *yypvt[0].mpString );
delete yypvt[0].mpString;
} break;
case YYr17: { /* directive_block : TWP_ERROR string */
#line 275 "policy.y"
if( cPreprocessor::GetState() == cPreprocessor::STATE_ACCEPT && !cParserHelper::ParseOnly() )
{
iUserNotify::GetInstance()->Notify( iUserNotify::V_NORMAL, yypvt[0].mpString->c_str());
iUserNotify::GetInstance()->Notify( iUserNotify::V_NORMAL, _T("\n") );
YYRETURN(-1);
}
delete yypvt[0].mpString;
} break;
case YYr18: { /* directive_block : TWP_ECHO string */
#line 286 "policy.y"
if( cPreprocessor::GetState() == cPreprocessor::STATE_ACCEPT && !cParserHelper::ParseOnly() )
{
iUserNotify::GetInstance()->Notify( iUserNotify::V_NORMAL, yypvt[0].mpString->c_str());
iUserNotify::GetInstance()->Notify( iUserNotify::V_NORMAL, _T("\n") );
}
delete yypvt[0].mpString;
} break;
case YYr19: { /* host_name_list : host_name_list TWP_OROR host_name */
#line 299 "policy.y"
yyval.mpStringList = yypvt[-2].mpStringList;
yyval.mpStringList->push_back( *yypvt[0].mpString );
} break;
case YYr20: { /* host_name_list : host_name */
#line 304 "policy.y"
yyval.mpStringList = new cParseStringList;
yyval.mpStringList->push_back( *yypvt[0].mpString );
} break;
case YYr21: { /* opt_else_host : TWP_ELSE */
#line 312 "policy.y"
cDebug d("Parse::#else");
if( cPreprocessor::GetLastState() == cPreprocessor::STATE_ACCEPT )
{
cPreprocessor::ToggleTopState();
d.TraceDebug(_T("\n"));
}
else
{
d.TraceDebug(_T("ignoring #else\n"));
}
} break;
case YYr24: { /* variable_assignment : variable_name TWP_EQUALS multi_string */
#line 332 "policy.y"
cDebug d("Parse::variable_assignment");
if( cPreprocessor::GetState() == cPreprocessor::STATE_IGNORE )
{
d.TraceDebug(_T(" ignoring variable assignment\n"));
}
else
{
TSTRING strVal = ConcatenateStrings( yypvt[0].mpStringList );
d.TraceDebug("*** assigning <%s> to <%s>\n", yypvt[-2].mpString->c_str(), strVal.c_str() );
cParserHelper::GetGenreInfo()->InsertVariable( *yypvt[-2].mpString, strVal );
}
delete yypvt[-2].mpString;
delete yypvt[0].mpStringList;
} break;
case YYr25: { /* global_variable_assignment : global_string TWP_EQUALS global_multi_string */
#line 353 "policy.y"
cDebug d("Parse::global variable_assignment");
if( cPreprocessor::GetState() == cPreprocessor::STATE_IGNORE )
{
d.TraceDebug(_T(" ignoring global variable assignment\n"));
}
else
{
TSTRING strVal = ConcatenateStrings( yypvt[0].mpStringList );
d.TraceDebug("*** assigning <%s> to <%s>\n", yypvt[-2].mpString->c_str(), strVal.c_str() );
cParserHelper::InsertGlobalVariable( *yypvt[-2].mpString, strVal );
}
delete yypvt[-2].mpString;
delete yypvt[0].mpStringList;
} break;
case YYr26: { /* rule : fco_name TWP_RARROW spec_masks */
#line 374 "policy.y"
cDebug d("Parse::rule(fco_name TWP_RARROW spec_masks)");
if( cPreprocessor::GetState() == cPreprocessor::STATE_IGNORE )
{
d.TraceDebug(_T(" ignoring rule\n"));
}
else
{
// bind to children
cParseStringList *pnamelist = yypvt[-2].mpStringList;
cParseRule *pnode = yypvt[0].mpNode;
cFCOName fcoName;
// create the fco name from string
iParserGenreUtil* pGU = iTWFactory::GetInstance()->CreateParserGenreUtil();
pGU->InterpretFCOName( *pnamelist, fcoName );
if( ! pGU->IsAbsolutePath( iTWFactory::GetInstance()->GetNameTranslator()->ToStringRaw( fcoName ) ) )
throw eParserRelativePath( iTWFactory::GetInstance()->GetNameTranslator()->ToStringDisplay( fcoName ) );
else if( cParserHelper::GetGenreInfo()->RulePointAlreadyDefined( fcoName ) )
throw eParserPointAlreadyDefined( iTWFactory::GetInstance()->GetNameTranslator()->ToStringDisplay( fcoName ) );
// assign parse node the name, attributes
pnode->SetName( fcoName );
d.TraceDebug("*** rule(%s: %d specifiers, default=%s) (%d named attributes) (is%s case sensitive)\n",
pnode->GetName().AsString().c_str(), pnode->GetNumSpecMasks(),
pnode->GetDefSpecMask().GetPropVectorString().c_str(),
pnode->GetNumNamedAttrs(),
iTWFactory::GetInstance()->GetNameInfo()->IsCaseSensitive() ? "" : " not" );
pnode->Dump();
// add to our lists
cParserHelper::GetGenreInfo()->AddStopPoint( fcoName );
cParserHelper::GetGenreInfo()->AddRule( pnode );
}
delete yypvt[-2].mpStringList;
} break;
case YYr27: { /* rule : TWP_BANG fco_name */
#line 416 "policy.y"
cDebug d("Parse::rule(!fconame)");
if( cPreprocessor::GetState() == cPreprocessor::STATE_IGNORE )
{
d.TraceDebug(_T(" ignoring rule\n"));
}
else
{
// create the fco name from string
cFCOName fcoName;
iParserGenreUtil* pGU = iTWFactory::GetInstance()->CreateParserGenreUtil();
pGU->InterpretFCOName( *yypvt[0].mpStringList, fcoName );
if( ! pGU->IsAbsolutePath( iTWFactory::GetInstance()->GetNameTranslator()->ToStringRaw( fcoName ) ) )
throw eParserRelativePath( iTWFactory::GetInstance()->GetNameTranslator()->ToStringDisplay( fcoName ) );
if( cParserHelper::GetGenreInfo()->RulePointAlreadyDefined( fcoName ) )
throw eParserPointAlreadyDefined( iTWFactory::GetInstance()->GetNameTranslator()->ToStringDisplay( fcoName ) );
d.TraceDebug( "*** omit(%s)\n", fcoName.AsString().c_str() );
// add to stop list
cParserHelper::GetGenreInfo()->AddStopPoint( fcoName );
}
delete yypvt[0].mpStringList;
} break;
case YYr28: { /* spec_masks : prop_vector opt_spec_attributes */
#line 447 "policy.y"
if( cPreprocessor::GetState() == cPreprocessor::STATE_ACCEPT )
{
iParserGenreUtil* pGU = iTWFactory::GetInstance()->CreateParserGenreUtil();
TSTRING strDefault = _T("default");
cParseRule* pNode = new cParseRule( cParseSpecMask( strDefault, *yypvt[-1].mpString, pGU ) );
pNode->SetAttrList( yypvt[0].mpAttrList );
yypvt[0].mpAttrList->MergeNoOverwrite( cParserHelper::GetGlobalAttrList() );
yyval.mpNode = pNode;
}
delete yypvt[-1].mpString;
} break;
case YYr29: { /* opt_spec_attributes : TWP_LPAREN attribute_list_with_opt_trailing_comma TWP_RPAREN */
#line 485 "policy.y"
yyval.mpAttrList = yypvt[-1].mpAttrList;
} break;
case YYr30: { /* opt_spec_attributes : */
#line 489 "policy.y"
yyval.mpAttrList = new cParseNamedAttrList;
} break;
case YYr31: { /* attribute_list_with_opt_trailing_comma : attribute_list opt_comma */
#line 515 "policy.y"
yyval.mpAttrList = yypvt[-1].mpAttrList;
} break;
case YYr32: { /* attribute_list : attribute_list TWP_COMMA attribute */
#line 522 "policy.y"
cDebug d("Parse::attribute_list");
ASSERT( yypvt[-2].mpAttrList && yypvt[0].mpAttr );
// add attribute to list
yypvt[-2].mpAttrList->Add( yypvt[0].mpAttr );
d.TraceDebug("added attribute (%s=%s)\n", yypvt[0].mpAttr->GetName().c_str(), yypvt[0].mpAttr->GetValue().c_str());
yyval.mpAttrList = yypvt[-2].mpAttrList;
} break;
case YYr33: { /* attribute_list : attribute */
#line 535 "policy.y"
cDebug d("Parse::attribute_list");
cParseNamedAttrList *pAttrList = new cParseNamedAttrList; ASSERT( pAttrList );
pAttrList->Add( yypvt[0].mpAttr );
d.TraceDebug("added attribute (%s=%s)\n", yypvt[0].mpAttr->GetName().c_str(), yypvt[0].mpAttr->GetValue().c_str());
yyval.mpAttrList = pAttrList;
} break;
case YYr34: { /* attribute : attribute_name TWP_EQUALS attribute_value */
#line 548 "policy.y"
cDebug d("Parse::attribute");
cParseNamedAttr *pAttr = new cParseNamedAttr( *yypvt[-2].mpString, *yypvt[0].mpString );
ASSERT(pAttr);
d.TraceDebug("attribute (%s=%s)\n", yypvt[-2].mpString->c_str(), yypvt[0].mpString->c_str());
yyval.mpAttr = pAttr;
delete yypvt[-2].mpString;
delete yypvt[0].mpString;
} break;
case YYr37: { /* variable : TWP_DOLLAR TWP_LPAREN variable_name TWP_RPAREN */
#line 618 "policy.y"
cDebug d( " parser::variable" );
cParseString* pVarValue = new cParseString;
if( cPreprocessor::GetState() == cPreprocessor::STATE_ACCEPT )
{
// we want to replace the keyword with its value, (e.g. replacing <dollar><lparen>ReadOnly<rparen>
// with "pingus" (or whatever readonly means). So it is a rote replacement.
if( ! cParserHelper::GetGenreInfo()->LookupVariable( *yypvt[-1].mpString, *pVarValue ) )
throw eParserUseUndefVar( *yypvt[-1].mpString );
// return the lval
d.TraceDetail("--(STRING)--> got variable (%s) mapped to (%s)\n",
yypvt[-1].mpString->c_str(),
pVarValue->c_str());
}
yyval.mpString = pVarValue;
delete yypvt[-1].mpString;
} break;
case YYr38: { /* prop_vector : multi_string */
#line 662 "policy.y"
yyval.mpString = new cParseString;
*yyval.mpString = ConcatenateStrings( yypvt[0].mpStringList );
delete yypvt[0].mpStringList;
} break;
case YYr39: { /* attribute_name : string */
#line 671 "policy.y"
cDebug d(" parser::string(attribute_name)");
yyval.mpString = yypvt[0].mpString;
} break;
case YYr40: { /* attribute_value : multi_string */
#line 679 "policy.y"
yyval.mpString = new cParseString;
cDebug d(" parser::multi_string(attribute_value)");
*yyval.mpString = ConcatenateStrings( yypvt[0].mpStringList );
delete yypvt[0].mpStringList;
} break;
case YYr41: { /* fco_name : multi_string */
#line 689 "policy.y"
cDebug d(" parser::multi_string(fco_name)");
yyval.mpStringList = yypvt[0].mpStringList;
} break;
case YYr42: { /* fco_name : multi_string TWP_PIPE multi_string */
#line 695 "policy.y"
yypvt[-2].mpStringList->push_back( _T("|") );
MergeIntoList( yypvt[-2].mpStringList, yypvt[0].mpStringList );
yyval.mpStringList = yypvt[-2].mpStringList;
delete yypvt[0].mpStringList;
} break;
case YYr43: { /* host_name : string */
#line 710 "policy.y"
cDebug d(" parser::multi_string(host_name)");
yyval.mpString = yypvt[0].mpString;
} break;
case YYr44: { /* variable_name : TWP_STRING */
#line 719 "policy.y"
cDebug d(" parser::string(variable_name)");
yyval.mpString = yypvt[0].mpString;
} break;
case YYr45: { /* multi_string : multi_string string */
#line 728 "policy.y"
yyval.mpStringList->push_back( *yypvt[0].mpString );
delete yypvt[0].mpString;
} break;
case YYr46: { /* multi_string : string */
#line 733 "policy.y"
yyval.mpStringList = new cParseStringList;
yyval.mpStringList->push_back( *yypvt[0].mpString );
delete yypvt[0].mpString;
} break;
case YYr47: { /* global_multi_string : global_multi_string global_string */
#line 742 "policy.y"
yyval.mpStringList->push_back( *yypvt[0].mpString );
delete yypvt[0].mpString;
} break;
case YYr48: { /* global_multi_string : global_string */
#line 747 "policy.y"
yyval.mpStringList = new cParseStringList;
yyval.mpStringList->push_back( *yypvt[0].mpString );
delete yypvt[0].mpString;
} break;
case YYr49: { /* string : TWP_STRING */
#line 757 "policy.y"
cDebug d(" parser::string(normal)");
d.TraceNever("--(STRING)--> got string (%s)\n", yypvt[0].mpString);
yyval.mpString = yypvt[0].mpString;
} break;
case YYr50: { /* string : variable */
#line 763 "policy.y"
cDebug d(" parser::string(normal)");
d.TraceNever("--(STRING)--> got string (%s)\n", yypvt[0].mpString);
yyval.mpString = yypvt[0].mpString;
} break;
case YYr51: { /* global_string : TWP_GLOBAL_STRING */
#line 772 "policy.y"
cDebug d(" parser::string(normal)");
d.TraceNever("--(STRING)--> got string (%s)\n", yypvt[0].mpString);
yyval.mpString = yypvt[0].mpString;
} break;
#line 343 "..\\..\\mkslexyacc\\etc\\yyparse.cpp"
case YYrACCEPT:
YYACCEPT;
case YYrERROR:
goto yyError;
}
yyNext:
/*
* Look up next state in goto table.
*/
yyp = &yygo[yypgo[yyi]];
yyq = yyp++;
yyi = *yyps;
while (yyi < *yyp++) /* busy little loop */
;
yystate = yyneg(yyi == *--yyp? yyq[yyq-yyp]: *yyq);
#if YYDEBUG
if (yydebug)
YY_TRACE(yyShowGoto)
#endif
goto yyStack;
yyerrlabel: ; /* come here from YYERROR */
yyerrflag = 1;
if (yyi == YYrERROR) {
yyps--, yypv--;
#if YYDEBUG
if (yydebug) yytp--;
#endif
}
yyError:
switch (yyerrflag) {
case 0: /* new error */
yynerrs++;
yyi = yychar;
scan->yyerror("Syntax error");
if (yyi != yychar) {
/* user has changed the current token */
/* try again */
yyerrflag++; /* avoid loops */
goto yyEncore;
}
case 1: /* partially recovered */
case 2:
yyerrflag = 3; /* need 3 valid shifts to recover */
/*
* Pop states, looking for a
* shift on `error'.
*/
for ( ; yyps > stateStack; yyps--, yypv--
#if YYDEBUG
, yytp--
#endif
) {
#ifdef YACC_WINDOWS
if (*yyps >= Sizeof_yypact) /* simple state */
#else /* YACC_WINDOWS */
if (*yyps >= (int)sizeof yypact/(int)sizeof yypact[0])
#endif /* YACC_WINDOWS */
continue;
yyp = &yyact[yypact[*yyps]];
yyq = yyp;
do
;
while (YYERRCODE < *yyp++);
if (YYERRCODE == yyp[-1]) {
yystate = yyneg(yyq[yyq-yyp]);
goto yyStack;
}
/* no shift in this state */
#if YYDEBUG
if (yydebug && yyps > stateStack+1)
YY_TRACE(yyShowErrRecovery)
#endif
/* pop stacks; try again */
}
/* no shift on error - abort */
break;
case 3:
/*
* Erroneous token after
* an error - discard it.
*/
if (yychar == 0) /* but not EOF */
break;
#if YYDEBUG
if (yydebug)
YY_TRACE(yyShowErrDiscard)
#endif
yyclearin();
goto yyEncore; /* try again in same state */
}
YYABORT;
}
#if YYDEBUG
/*
* Return type of token
*/
int
yy_parse::yyGetType(int tok)
{
yyNamedType * tp;
for (tp = &yyTokenTypes[yyntoken-1]; tp > yyTokenTypes; tp--)
if (tp->token == tok)
return tp->type;
return 0;
}
// Print a token legibly.
char *
yy_parse::yyptok(int tok)
{
yyNamedType * tp;
for (tp = &yyTokenTypes[yyntoken-1]; tp > yyTokenTypes; tp--)
if (tp->token == tok)
return tp->name;
return "";
}
/*
* Read state 'num' from YYStatesFile
*/
#ifdef YYTRACE
char *
yy_parse::yygetState(int num)
{
int size;
char *cp;
static FILE *yyStatesFile = (FILE *) 0;
static char yyReadBuf[YYMAX_READ+1];
if (yyStatesFile == (FILE *) 0
&& (yyStatesFile = fopen(YYStatesFile, "r")) == (FILE *) 0)
return "yyExpandName: cannot open states file";
if (num < yynstate - 1)
size = (int)(States[num+1] - States[num]);
else {
/* length of last item is length of file - ptr(last-1) */
if (fseek(yyStatesFile, 0L, 2) < 0)
goto cannot_seek;
size = (int) (ftell(yyStatesFile) - States[num]);
}
if (size < 0 || size > YYMAX_READ)
return "yyExpandName: bad read size";
if (fseek(yyStatesFile, States[num], 0) < 0) {
cannot_seek:
return "yyExpandName: cannot seek in states file";
}
(void) fread(yyReadBuf, 1, size, yyStatesFile);
yyReadBuf[size] = '\0';
return yyReadBuf;
}
#endif /* YYTRACE */
/*
* Expand encoded string into printable representation
* Used to decode yyStates and yyRules strings.
* If the expansion of 's' fits in 'buf', return 1; otherwise, 0.
*/
int
yy_parse::yyExpandName(int num, int isrule, char * buf, int len)
{
int i, n, cnt, type;
char * endp, * cp, * s;
if (isrule)
s = yyRules[num].name;
else
#ifdef YYTRACE
s = yygetState(num);
#else
s = "*no states*";
#endif
for (endp = buf + len - 8; *s; s++) {
if (buf >= endp) { /* too large: return 0 */
full: (void) strcpy(buf, " ...\n");
return 0;
} else if (*s == '%') { /* nonterminal */
type = 0;
cnt = yynvar;
goto getN;
} else if (*s == '&') { /* terminal */
type = 1;
cnt = yyntoken;
getN:
if (cnt < 100)
i = 2;
else if (cnt < 1000)
i = 3;
else
i = 4;
for (n = 0; i-- > 0; )
n = (n * 10) + *++s - '0';
if (type == 0) {
if (n >= yynvar)
goto too_big;
cp = yysvar[n];
} else if (n >= yyntoken) {
too_big:
cp = "<range err>";
} else
cp = yyTokenTypes[n].name;
if ((i = strlen(cp)) + buf > endp)
goto full;
(void) strcpy(buf, cp);
buf += i;
} else
*buf++ = *s;
}
*buf = '\0';
return 1;
}
#ifndef YYTRACE
/*
* Show current state of yyparse
*/
void
yy_parse::yyShowState()
{
(void) printf("state %d (%d), char %s (%d)\n%d stateStack entries\n",
yysmap[yystate],yystate,yyptok(yychar),yychar,
yypv - valueStack);
}
// show results of reduction: yyi is rule number
void
yy_parse::yyShowReduce()
{
(void) printf("Reduce by rule %d (pop#=%d)\n", yyrmap[rule], npop);
}
// show read token
void
yy_parse::yyShowRead()
{
(void) printf("read %s (%d)\n", yyptok(yychar), yychar);
}
// show Goto
void
yy_parse::yyShowGoto()
{
(void) printf("goto %d (%d)\n", yysmap[yystate], yystate);
}
// show Shift
void
yy_parse::yyShowShift()
{
(void) printf("shift %d (%d)\n", yysmap[yystate], yystate);
}
// show error recovery
void
yy_parse::yyShowErrRecovery()
{
(void) printf("Error recovery pops state %d (%d), uncovers %d (%d)\n",
yysmap[*(yyps-1)], *(yyps-1), yysmap[yystate], yystate);
}
// show token discards in error processing
void
yy_parse::yyShowErrDiscard()
{
(void) printf("Error recovery discards %s (%d), ",
yyptok(yychar), yychar);
}
#endif /* ! YYTRACE */
#endif /* YYDEBUG */
Reference in New Issue View Git Blame Copy Permalink