Main Page | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members | File Members | Examples

parser.cc File Reference

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <fstream>
#include <string>
#include <list>
#include "YCP.h"
#include "ycp/Scanner.h"
#include "ycp/y2log.h"
#include "ycp/pathsearch.h"
#include "ycp/ExecutionEnvironment.h"
#include "ycp/StaticDeclaration.h"
#include "ycp/YCode.h"
#include "ycp/Type.h"
#include "ycp/YExpression.h"
#include "ycp/YStatement.h"
#include "ycp/YBlock.h"
#include "ycp/SymbolTable.h"
#include "ycp/SymbolEntry.h"
#include "ycp/Bytecode.h"
#include "ycp/Parser.h"

Classes

struct  yystype_type
struct  stack
 general stack handling More...

struct  blockstack_t
 stack for blocks More...

struct  scannerstack_t
 stack for scanners More...

union  yyalloc

Defines

#define YYBISON   1
#define YYSKELETON_NAME   "yacc.c"
#define YYPURE   1
#define YYLSP_NEEDED   0
#define SCANNER_ERROR   258
#define END_OF_FILE   259
#define EMPTY   260
#define LIST   261
#define MAP   262
#define STRUCT   263
#define BLOCK   264
#define DEFINE   265
#define UNDEFINE   266
#define I18N   267
#define RETURN   268
#define CONTINUE   269
#define BREAK   270
#define IF   271
#define DO   272
#define WHILE   273
#define REPEAT   274
#define UNTIL   275
#define IS   276
#define ISNIL   277
#define SYMBOL   278
#define DCSYMBOL   279
#define DCQUOTED_BLOCK   280
#define QUOTED_BLOCK   281
#define QUOTED_EXPRESSION   282
#define CLOSEBRACKET   283
#define TYPEDEF   284
#define MODULE   285
#define IMPORT   286
#define EXPORT   287
#define MAPEXPR   288
#define INCLUDE   289
#define GLOBAL   290
#define TEXTDOMAIN   291
#define CONST   292
#define FULLNAME   293
#define STATIC   294
#define EXTERN   295
#define LOOKUP   296
#define SYM_NAMESPACE   297
#define IDENTIFIER   298
#define STRING   299
#define C_VOID   300
#define C_BOOLEAN   301
#define C_INTEGER   302
#define C_FLOAT   303
#define C_BYTEBLOCK   304
#define C_PATH   305
#define C_SYMBOL   306
#define C_TYPE   307
#define OR   308
#define AND   309
#define NEQ   310
#define EQUALS   311
#define GE   312
#define LE   313
#define RIGHT   314
#define LEFT   315
#define ELSE   316
#define UMINUS   317
#define DO_DEBUG   0
#define YYDEBUG   0
#define YYERROR_VERBOSE   1
#define YYSTYPE   yystype_type
#define YYPARSE_PARAM   vp_parser
#define YYLEX_PARAM   vp_parser
#define p_parser   ((Parser *) vp_parser)
#define LINE_NOW   (p_parser->m_lineno)
#define FILE_NOW   (p_parser->filename ())
#define yyerror(text)   yyerror_with_lineinfo (p_parser, -1, text)
#define yywarning(text, lineno)   yywarning_with_lineinfo (p_parser, lineno, text)
#define yyConstAssignError(name, lineno)   yyerror_assign_const (p_parser, lineno, name)
#define yyLerror(text, lineno)   yyerror_with_lineinfo (p_parser, lineno, text)
#define yyCerror(code, type, lineno)   yyerror_with_code (p_parser, lineno, code, type)
#define yyVerror(name, lineno)   yyerror_with_name (p_parser, lineno, name)
#define yyFerror(name, lineno)   yyerror_with_file (p_parser, lineno, name)
#define yyTerror(text, lineno, tentry)   yyerror_with_tableentry (p_parser, lineno, text, tentry)
#define yyTwarning(tentry)   yywarning_with_tableentry (p_parser, 0, tentry)
#define yyTypeMismatch(text, expected, seen, lineno)   yyerror_type_mismatch (p_parser, lineno, text, expected, seen)
#define yyMissingArgument(type, lineno)   yyerror_missing_argument (p_parser, lineno, type)
#define yyCantCast(from, to, lineno)   yyerror_cant_cast (p_parser, lineno, from, to)
#define yyNoModule(module, lineno)   yyerror_no_module (p_parser, lineno, module)
#define check_unary_op(result, e1, op)   i_check_unary_op (result, e1, op, p_parser)
#define check_binary_op(result, e1, op, e2)   i_check_binary_op (result, e1, op, e2, p_parser)
#define check_compare_op(result, e1, op, e2)   i_check_compare_op (result, e1, op, e2, p_parser)
#define check_void_assign(lhs, rhs)   i_check_void_assign (lhs, rhs, p_parser)
#define blockstack_push(s, e)   stack_push ((stack_t **)&(s), (stack_t *)e)
#define blockstack_pop(s)   (p_parser->m_blockstack_depth--, (blockstack_t *)stack_pop ((stack_t **)&(s)))
#define blockstack_at_toplevel()   (p_parser->m_blockstack_depth == 1)
#define scannerstack_push(s, e)   stack_push ((stack_t **)&(s), (stack_t *)e)
#define scannerstack_pop(s)   (scannerstack_t *)stack_pop ((stack_t **)&(s))
#define scannerstack_empty()   (p_parser->m_scanner_stack == 0)
#define YYERROR_VERBOSE   1
#define YYSTACK_ALLOC   malloc
#define YYSTACK_FREE   free
#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)
#define YYSTACK_BYTES(N)
#define YYCOPY(To, From, Count)
#define YYSTACK_RELOCATE(Stack)
#define YYFINAL   52
#define YYLAST   1183
#define YYNTOKENS   86
#define YYNNTS   46
#define YYNRULES   148
#define YYNSTATES   288
#define YYUNDEFTOK   2
#define YYMAXUTOK   317
#define YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
#define YYPACT_NINF   -229
#define YYTABLE_NINF   -145
#define YYSIZE_T   unsigned int
#define yyerrok   (yyerrstatus = 0)
#define yyclearin   (yychar = YYEMPTY)
#define YYEMPTY   (-2)
#define YYEOF   0
#define YYACCEPT   goto yyacceptlab
#define YYABORT   goto yyabortlab
#define YYERROR   goto yyerrlab1
#define YYFAIL   goto yyerrlab
#define YYRECOVERING()   (!!yyerrstatus)
#define YYBACKUP(Token, Value)
#define YYTERROR   1
#define YYERRCODE   256
#define YYLLOC_DEFAULT(Current, Rhs, N)
#define YYLEX   yylex (&yylval, YYLEX_PARAM)
#define YYDPRINTF(Args)
#define YYDSYMPRINT(Args)
#define YYDSYMPRINTF(Title, Token, Value, Location)
#define YY_STACK_PRINT(Bottom, Top)
#define YY_REDUCE_PRINT(Rule)
#define YYINITDEPTH   200
#define YYMAXDEPTH   10000
#define YYPOPSTACK   (yyvsp--, yyssp--)

Typedefs

typedef stack stack_t
 general stack handling

typedef short yysigned_char

Enumerations

enum  yytokentype {
  SCANNER_ERROR = 258, END_OF_FILE = 259, EMPTY = 260, LIST = 261,
  MAP = 262, STRUCT = 263, BLOCK = 264, DEFINE = 265,
  UNDEFINE = 266, I18N = 267, RETURN = 268, CONTINUE = 269,
  BREAK = 270, IF = 271, DO = 272, WHILE = 273,
  REPEAT = 274, UNTIL = 275, IS = 276, ISNIL = 277,
  SYMBOL = 278, DCSYMBOL = 279, DCQUOTED_BLOCK = 280, QUOTED_BLOCK = 281,
  QUOTED_EXPRESSION = 282, CLOSEBRACKET = 283, TYPEDEF = 284, MODULE = 285,
  IMPORT = 286, EXPORT = 287, MAPEXPR = 288, INCLUDE = 289,
  GLOBAL = 290, TEXTDOMAIN = 291, CONST = 292, FULLNAME = 293,
  STATIC = 294, EXTERN = 295, LOOKUP = 296, SYM_NAMESPACE = 297,
  IDENTIFIER = 298, STRING = 299, C_VOID = 300, C_BOOLEAN = 301,
  C_INTEGER = 302, C_FLOAT = 303, C_BYTEBLOCK = 304, C_PATH = 305,
  C_SYMBOL = 306, C_TYPE = 307, OR = 308, AND = 309,
  NEQ = 310, EQUALS = 311, GE = 312, LE = 313,
  RIGHT = 314, LEFT = 315, ELSE = 316, UMINUS = 317
}
enum  scan_states { SCAN_FILE, SCAN_START_INCLUDE, SCAN_INCLUDE }

Functions

void yyerror_with_lineinfo (Parser *parser, int lineno, const char *s)
void yywarning_with_lineinfo (Parser *parser, int lineno, const char *s)
void yyerror_with_code (Parser *parser, int lineno, YCodePtr c, constTypePtr t)
void yyerror_with_name (Parser *parser, int lineno, const char *s)
void yyerror_with_file (Parser *parser, int lineno, const char *s)
void yyerror_with_tableentry (Parser *parser, int lineno, const char *s, TableEntry *entry)
void yywarning_with_tableentry (Parser *parser, int lineno, TableEntry *entry)
void yyerror_type_mismatch (Parser *parser, int lineno, const char *s, constTypePtr expected_type, constTypePtr seen_type)
void yyerror_missing_argument (Parser *parser, int lineno, constTypePtr type)
void yyerror_assign_const (Parser *parser, int lineno, const char *s)
void yyerror_cant_cast (Parser *parser, int lineno, constTypePtr from, constTypePtr to)
void yyerror_no_module (Parser *parser, int lineno, const char *module)
constTypePtr attach_parameter (Parser *parser, YCodePtr code, YYSTYPE *parm, YYSTYPE *parm1=0)
YBlockPtr start_block (Parser *parser, constTypePtr type)
int yylex (YYSTYPE *, void *)
void i_check_unary_op (YYSTYPE *result, YYSTYPE *e1, const char *op, Parser *parser)
void i_check_binary_op (YYSTYPE *result, YYSTYPE *e1, const char *op, YYSTYPE *e2, Parser *parser)
void i_check_compare_op (YYSTYPE *result, YYSTYPE *e1, YECompare::c_op op, YYSTYPE *e2, Parser *parser)
void i_check_void_assign (YYSTYPE *lhs, YYSTYPE *rhs, Parser *parser)
void stack_push (stack_t **stack, stack_t *element)
 push element to stack

stack_t * stack_pop (stack_t **stack)
 pop element to stack

YYSIZE_T yystrlen (yystr) const char *yystr
int yyparse (YYPARSE_PARAM) void *YYPARSE_PARAM

Variables

constTypePtr declared_return_type = Type::Unspec
 set by function declaration in order to predefine a definitions block return type

StaticDeclaration static_declarations
ExecutionEnvironment ee
bool inside_module = false
int repeat_count = 0
int do_while_count = 0
const unsigned char yytranslate []
const char *const  yytname []
const unsigned char yyr1 []
const unsigned char yyr2 []
const unsigned char yydefact []
const short yydefgoto []
const short yypact []
const short yypgoto []
const short yytable []
const short yycheck []
const unsigned char yystos []
const char * yysrc
YYSTYPE * yyvaluep

Define Documentation

#define AND   309
 

#define BLOCK   264
 

 
#define blockstack_at_toplevel (   )     (p_parser->m_blockstack_depth == 1)
 

#define blockstack_pop (  s   )     (p_parser->m_blockstack_depth--, (blockstack_t *)stack_pop ((stack_t **)&(s)))
 

#define blockstack_push (  s,
e   )     stack_push ((stack_t **)&(s), (stack_t *)e)
 

#define BREAK   270
 

#define C_BOOLEAN   301
 

#define C_BYTEBLOCK   304
 

#define C_FLOAT   303
 

#define C_INTEGER   302
 

#define C_PATH   305
 

#define C_SYMBOL   306
 

#define C_TYPE   307
 

#define C_VOID   300
 

#define check_binary_op (  result,
e1,
op,
e2   )     i_check_binary_op (result, e1, op, e2, p_parser)
 

#define check_compare_op (  result,
e1,
op,
e2   )     i_check_compare_op (result, e1, op, e2, p_parser)
 

#define check_unary_op (  result,
e1,
op   )     i_check_unary_op (result, e1, op, p_parser)
 

#define check_void_assign (  lhs,
rhs   )     i_check_void_assign (lhs, rhs, p_parser)
 

#define CLOSEBRACKET   283
 

#define CONST   292
 

#define CONTINUE   269
 

#define DCQUOTED_BLOCK   280
 

#define DCSYMBOL   279
 

#define DEFINE   265
 

#define DO   272
 

#define DO_DEBUG   0
 

#define ELSE   316
 

#define EMPTY   260
 

#define END_OF_FILE   259
 

#define EQUALS   311
 

#define EXPORT   287
 

#define EXTERN   295
 

#define FILE_NOW   (p_parser->filename ())
 

#define FULLNAME   293
 

#define GE   312
 

#define GLOBAL   290
 

#define I18N   267
 

#define IDENTIFIER   298
 

#define IF   271
 

#define IMPORT   286
 

#define INCLUDE   289
 

#define IS   276
 

#define ISNIL   277
 

#define LE   313
 

#define LEFT   315
 

#define LINE_NOW   (p_parser->m_lineno)
 

#define LIST   261
 

#define LOOKUP   296
 

#define MAP   262
 

#define MAPEXPR   288
 

#define MODULE   285
 

#define NEQ   310
 

#define OR   308
 

#define p_parser   ((Parser *) vp_parser)
 

#define QUOTED_BLOCK   281
 

#define QUOTED_EXPRESSION   282
 

#define REPEAT   274
 

#define RETURN   268
 

#define RIGHT   314
 

#define SCANNER_ERROR   258
 

 
#define scannerstack_empty (   )     (p_parser->m_scanner_stack == 0)
 

#define scannerstack_pop (  s   )     (scannerstack_t *)stack_pop ((stack_t **)&(s))
 

#define scannerstack_push (  s,
e   )     stack_push ((stack_t **)&(s), (stack_t *)e)
 

#define STATIC   294
 

#define STRING   299
 

#define STRUCT   263
 

#define SYM_NAMESPACE   297
 

#define SYMBOL   278
 

#define TEXTDOMAIN   291
 

#define TYPEDEF   284
 

#define UMINUS   317
 

#define UNDEFINE   266
 

#define UNTIL   275
 

#define WHILE   273
 

#define YY_REDUCE_PRINT (  Rule   ) 
 

#define YY_STACK_PRINT (  Bottom,
Top   ) 
 

#define YYABORT   goto yyabortlab
 

#define YYACCEPT   goto yyacceptlab
 

#define YYBACKUP (  Token,
Value   ) 
 

Value:

do                                                              \
  if (yychar == YYEMPTY && yylen == 1)                          \
    {                                                           \
      yychar = (Token);                                         \
      yylval = (Value);                                         \
      yytoken = YYTRANSLATE (yychar);                           \
      YYPOPSTACK;                                               \
      goto yybackup;                                            \
    }                                                           \
  else                                                          \
    {                                                           \
      yyerror ("syntax error: cannot back up");\
      YYERROR;                                                  \
    }                                                           \
while (0)

#define YYBISON   1
 

#define yyCantCast (  from,
to,
lineno   )     yyerror_cant_cast (p_parser, lineno, from, to)
 

#define yyCerror (  code,
type,
lineno   )     yyerror_with_code (p_parser, lineno, code, type)
 

#define yyclearin   (yychar = YYEMPTY)
 

#define yyConstAssignError (  name,
lineno   )     yyerror_assign_const (p_parser, lineno, name)
 

#define YYCOPY (  To,
From,
Count   ) 
 

Value:

do                                      \
        {                                       \
          register YYSIZE_T yyi;                \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (To)[yyi] = (From)[yyi];            \
        }                                       \
      while (0)

#define YYDEBUG   0
 

#define YYDPRINTF (  Args   ) 
 

#define YYDSYMPRINT (  Args   ) 
 

#define YYDSYMPRINTF (  Title,
Token,
Value,
Location   ) 
 

#define YYEMPTY   (-2)
 

#define YYEOF   0
 

#define YYERRCODE   256
 

#define yyerrok   (yyerrstatus = 0)
 

#define YYERROR   goto yyerrlab1
 

#define yyerror (  text   )     yyerror_with_lineinfo (p_parser, -1, text)
 

#define YYERROR_VERBOSE   1
 

#define YYERROR_VERBOSE   1
 

#define YYFAIL   goto yyerrlab
 

#define yyFerror (  name,
lineno   )     yyerror_with_file (p_parser, lineno, name)
 

#define YYFINAL   52
 

#define YYINITDEPTH   200
 

#define YYLAST   1183
 

#define yyLerror (  text,
lineno   )     yyerror_with_lineinfo (p_parser, lineno, text)
 

#define YYLEX   yylex (&yylval, YYLEX_PARAM)
 

#define YYLEX_PARAM   vp_parser
 

#define YYLLOC_DEFAULT (  Current,
Rhs,
N   ) 
 

Value:

Current.first_line   = Rhs[1].first_line;      \
  Current.first_column = Rhs[1].first_column;    \
  Current.last_line    = Rhs[N].last_line;       \
  Current.last_column  = Rhs[N].last_column;

#define YYLSP_NEEDED   0
 

#define YYMAXDEPTH   10000
 

#define YYMAXUTOK   317
 

#define yyMissingArgument (  type,
lineno   )     yyerror_missing_argument (p_parser, lineno, type)
 

#define YYNNTS   46
 

#define yyNoModule (  module,
lineno   )     yyerror_no_module (p_parser, lineno, module)
 

#define YYNRULES   148
 

#define YYNSTATES   288
 

#define YYNTOKENS   86
 

#define YYPACT_NINF   -229
 

#define YYPARSE_PARAM   vp_parser
 

#define YYPOPSTACK   (yyvsp--, yyssp--)
 

#define YYPURE   1
 

 
#define YYRECOVERING (   )     (!!yyerrstatus)
 

#define YYSIZE_T   unsigned int
 

#define YYSKELETON_NAME   "yacc.c"
 

#define YYSTACK_ALLOC   malloc
 

#define YYSTACK_BYTES (  N   ) 
 

Value:

((N) * (sizeof (short) + sizeof (YYSTYPE))                              \
      + YYSTACK_GAP_MAXIMUM)

#define YYSTACK_FREE   free
 

#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)
 

#define YYSTACK_RELOCATE (  Stack   ) 
 

Value:

do                                                                      \
      {                                                                 \
        YYSIZE_T yynewbytes;                                            \
        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
        Stack = &yyptr->Stack;                                          \
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / sizeof (*yyptr);                          \
      }                                                                 \
    while (0)

#define YYSTYPE   yystype_type
 

#define YYTABLE_NINF   -145
 

#define YYTERROR   1
 

#define yyTerror (  text,
lineno,
tentry   )     yyerror_with_tableentry (p_parser, lineno, text, tentry)
 

#define YYTRANSLATE (  YYX   )     ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 

#define yyTwarning (  tentry   )     yywarning_with_tableentry (p_parser, 0, tentry)
 

#define yyTypeMismatch (  text,
expected,
seen,
lineno   )     yyerror_type_mismatch (p_parser, lineno, text, expected, seen)
 

#define YYUNDEFTOK   2
 

#define yyVerror (  name,
lineno   )     yyerror_with_name (p_parser, lineno, name)
 

#define yywarning (  text,
lineno   )     yywarning_with_lineinfo (p_parser, lineno, text)
 

Typedef Documentation

typedef struct stack stack_t
 

general stack handling

typedef short yysigned_char
 

Enumeration Type Documentation

enum scan_states
 

Enumeration values:
SCAN_FILE  a plain file
SCAN_START_INCLUDE  before the first token of an include file (see start_block())
SCAN_INCLUDE  inside an include file

enum yytokentype
 

Enumeration values:
SCANNER_ERROR 
END_OF_FILE 
EMPTY 
LIST 
MAP 
STRUCT 
BLOCK 
DEFINE 
UNDEFINE 
I18N 
RETURN 
CONTINUE 
BREAK 
IF 
DO 
WHILE 
REPEAT 
UNTIL 
IS 
ISNIL 
SYMBOL 
DCSYMBOL 
DCQUOTED_BLOCK 
QUOTED_BLOCK 
QUOTED_EXPRESSION 
CLOSEBRACKET 
TYPEDEF 
MODULE 
IMPORT 
EXPORT 
MAPEXPR 
INCLUDE 
GLOBAL 
TEXTDOMAIN 
CONST 
FULLNAME 
STATIC 
EXTERN 
LOOKUP 
SYM_NAMESPACE 
IDENTIFIER 
STRING 
C_VOID 
C_BOOLEAN 
C_INTEGER 
C_FLOAT 
C_BYTEBLOCK 
C_PATH 
C_SYMBOL 
C_TYPE 
OR 
AND 
NEQ 
EQUALS 
GE 
LE 
RIGHT 
LEFT 
ELSE 
UMINUS 

Function Documentation

constTypePtr attach_parameter (  Parser *  parser,
YCodePtr  code,
YYSTYPE *  parm,
YYSTYPE *  parm1 = 0
)  [static]
 

void i_check_binary_op (  YYSTYPE *  result,
YYSTYPE *  e1,
const char *  op,
YYSTYPE *  e2,
Parser *  parser
)  [static]
 

void i_check_compare_op (  YYSTYPE *  result,
YYSTYPE *  e1,
YECompare::c_op  op,
YYSTYPE *  e2,
Parser *  parser
)  [static]
 

void i_check_unary_op (  YYSTYPE *  result,
YYSTYPE *  e1,
const char *  op,
Parser *  parser
)  [static]
 

void i_check_void_assign (  YYSTYPE *  lhs,
YYSTYPE *  rhs,
Parser *  parser
)  [static]
 

stack_t* stack_pop (  stack_t **  stack  )  [static]
 

pop element to stack

void stack_push (  stack_t **  stack,
stack_t *  element
)  [static]
 

push element to stack

YBlockPtr start_block (  Parser *  parser,
constTypePtr  type
)  [static]
 

begin of a block

Parameters:
type declared return type

void yyerror_assign_const (  Parser *  parser,
int  lineno,
const char *  s
)  [static]
 

void yyerror_cant_cast (  Parser *  parser,
int  lineno,
constTypePtr  from,
constTypePtr  to
)  [static]
 

void yyerror_missing_argument (  Parser *  parser,
int  lineno,
constTypePtr  type
)  [static]
 

void yyerror_no_module (  Parser *  parser,
int  lineno,
const char *  module
)  [static]
 

void yyerror_type_mismatch (  Parser *  parser,
int  lineno,
const char *  s,
constTypePtr  expected_type,
constTypePtr  seen_type
)  [static]
 

void yyerror_with_code (  Parser *  parser,
int  lineno,
YCodePtr  c,
constTypePtr  t
)  [static]
 

void yyerror_with_file (  Parser *  parser,
int  lineno,
const char *  s
)  [static]
 

void yyerror_with_lineinfo (  Parser *  parser,
int  lineno,
const char *  s
)  [static]
 

void yyerror_with_name (  Parser *  parser,
int  lineno,
const char *  s
)  [static]
 

void yyerror_with_tableentry (  Parser *  parser,
int  lineno,
const char *  s,
TableEntry *  entry
)  [static]
 

int yylex (  YYSTYPE *  ,
void * 
) 
 

int yyparse (  YYPARSE_PARAM   ) 
 

YYSIZE_T yystrlen (  yystr   )  const [static]
 

void yywarning_with_lineinfo (  Parser *  parser,
int  lineno,
const char *  s
)  [static]
 

void yywarning_with_tableentry (  Parser *  parser,
int  lineno,
TableEntry *  entry
)  [static]
 

Variable Documentation

constTypePtr declared_return_type = Type::Unspec [static]
 

set by function declaration in order to predefine a definitions block return type

int do_while_count = 0 [static]
 

ExecutionEnvironment ee
 

bool inside_module = false [static]
 

int repeat_count = 0 [static]
 

StaticDeclaration static_declarations
 

const short yycheck[] [static]
 

const unsigned char yydefact[] [static]
 

const short yydefgoto[] [static]
 

Initial value:

{
      -1,    22,    48,    39,   202,    40,    41,    42,    24,    51,
      33,    57,    58,   120,   228,   121,   270,   172,   251,   174,
     253,   276,   194,   195,   200,   122,   123,   124,   125,   189,
     231,   232,   233,   126,    25,    26,    49,    91,    27,    45,
      28,    97,   164,    29,    30,   179
}

const short yypact[] [static]
 

const short yypgoto[] [static]
 

Initial value:

{
    -229,  -229,    -6,    70,  -229,    72,     5,  -229,   -41,  -229,
    -229,   -49,  -229,  -228,  -229,  -229,  -229,  -229,  -229,  -229,
    -229,  -229,    -4,  -125,  -229,  -229,  -229,  -229,  -229,  -229,
    -229,  -229,   -48,  -229,  -229,  -229,   -81,   164,  -229,  -229,
     -55,  -229,  -229,  -229,   -54,   -12
}

const unsigned char yyr1[] [static]
 

Initial value:

{
       0,    86,    87,    87,    87,    88,    88,    88,    88,    89,
      90,    90,    90,    90,    91,    92,    92,    92,    92,    92,
      92,    92,    92,    92,    92,    92,    92,    92,    93,    93,
      93,    93,    93,    93,    93,    93,    93,    93,    93,    93,
      93,    93,    93,    93,    93,    93,    93,    93,    93,    93,
      95,    94,    96,    94,    97,    98,    98,    99,   100,    99,
      99,    99,    99,    99,    99,    99,    99,    99,    99,    99,
      99,    99,   101,   102,   101,   103,   104,   101,   105,   106,
     101,   101,   101,   101,   101,   107,   107,   108,   108,   108,
     108,   108,   108,   108,   108,   108,   108,   109,   109,   110,
     110,   111,   111,   111,   111,   112,   113,   114,   114,   115,
     115,   116,   116,   117,   117,   118,   119,   119,   120,   120,
     120,   120,   120,   120,   120,   120,   121,   121,   122,   122,
     123,   123,   124,   124,   125,   125,   127,   126,   128,   128,
     128,   128,   128,   129,   129,   130,   130,   131,   131
}

const unsigned char yyr2[] [static]
 

Initial value:

{
       0,     2,     1,     1,     0,     1,     1,     1,     1,     5,
       0,     1,     1,     1,     4,     1,     8,     1,     3,     3,
       6,     1,     7,     3,     1,     1,     1,     1,     3,     3,
       3,     3,     3,     3,     3,     3,     3,     3,     2,     3,
       3,     3,     3,     3,     3,     3,     3,     2,     2,     5,
       0,     3,     0,     3,     2,     2,     0,     1,     0,     4,
       3,     3,     3,     3,     3,     3,     4,     1,     2,     2,
       1,     1,     6,     0,     6,     0,     0,     9,     0,     0,
       9,     2,     2,     2,     3,     2,     0,     1,     1,     3,
       1,     5,     3,     2,     2,     3,     4,     2,     2,     1,
       3,     4,     2,     2,     4,     4,     4,     1,     0,     1,
       0,     0,     1,     1,     3,     2,     3,     6,     1,     1,
       1,     1,     1,     1,     1,     1,     2,     4,     1,     3,
       1,     0,     2,     4,     3,     5,     0,     5,     0,     2,
       1,     4,     3,     1,     1,     1,     1,     1,     3
}

const char* yysrc
 

const unsigned char yystos[] [static]
 

const short yytable[] [static]
 

const char* const yytname[] [static]
 

Initial value:

{
  "$end", "error", "$undefined", "SCANNER_ERROR", "END_OF_FILE", "EMPTY", 
  "LIST", "MAP", "STRUCT", "BLOCK", "DEFINE", "UNDEFINE", "I18N", 
  "RETURN", "CONTINUE", "BREAK", "IF", "DO", "WHILE", "REPEAT", "UNTIL", 
  "IS", "ISNIL", "SYMBOL", "DCSYMBOL", "DCQUOTED_BLOCK", "QUOTED_BLOCK", 
  "QUOTED_EXPRESSION", "CLOSEBRACKET", "TYPEDEF", "MODULE", "IMPORT", 
  "EXPORT", "MAPEXPR", "INCLUDE", "GLOBAL", "TEXTDOMAIN", "CONST", 
  "FULLNAME", "STATIC", "EXTERN", "LOOKUP", "SYM_NAMESPACE", "IDENTIFIER", 
  "STRING", "C_VOID", "C_BOOLEAN", "C_INTEGER", "C_FLOAT", "C_BYTEBLOCK", 
  "C_PATH", "C_SYMBOL", "C_TYPE", "'='", "'?'", "OR", "AND", "'|'", "'^'", 
  "'&'", "NEQ", "EQUALS", "'<'", "'>'", "GE", "LE", "RIGHT", "LEFT", 
  "'+'", "'-'", "'*'", "'/'", "'%'", "'!'", "ELSE", "'~'", "UMINUS", 
  "':'", "'['", "'('", "')'", "','", "'{'", "'}'", "';'", "']'", 
  "$accept", "ycp", "expression", "bracket_expression", 
  "castable_expression", "casted_expression", "compact_expression", 
  "infix_expression", "block", "@1", "@2", "block_end", "statements", 
  "statement", "@3", "control_statement", "@4", "@5", "@6", "@7", "@8", 
  "opt_else", "type", "type_gt", "types", "definition", "function_start", 
  "opt_global_identifier", "opt_global", "opt_define", "tupletypes", 
  "tupletype", "formal_param", "assignment", "constant", "list", 
  "list_elements", "opt_comma", "map", "map_elements", "function_call", 
  "@9", "parameters", "function_name", "identifier", "identifier_list", 0
}

const unsigned char yytranslate[] [static]
 

YYSTYPE* yyvaluep
 

Generated on Sat Oct 15 12:18:09 2005 for yast2-core by doxygen 1.3.6