Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Class Members | File Members | Examples
libycp » src

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/YSymbolEntry.h"
#include "ycp/Point.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  switchstack_t
 stack for switch 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 SELECT   297
#define SWITCH   298
#define CASE   299
#define DEFAULT   300
#define SYM_NAMESPACE   301
#define IDENTIFIER   302
#define STRING   303
#define C_VOID   304
#define C_BOOLEAN   305
#define C_INTEGER   306
#define C_FLOAT   307
#define C_BYTEBLOCK   308
#define C_PATH   309
#define C_SYMBOL   310
#define C_TYPE   311
#define OR   312
#define AND   313
#define NEQ   314
#define EQUALS   315
#define GE   316
#define LE   317
#define RIGHT   318
#define LEFT   319
#define ELSE   320
#define UMINUS   321
#define DO_DEBUG   0
#define YYDEBUG   0
#define YYERROR_VERBOSE   1
#define YYINITDEPTH   1000
#define YYMAXDEPTH   50000
#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->scanner()->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 switchstack_push(s, e)   stack_push ((stack_t **)&(s), (stack_t *)e)
#define switchstack_pop(s)   ((switchstack_t *)stack_pop ((stack_t **)&(s)))
#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   55
#define YYLAST   1346
#define YYNTOKENS   90
#define YYNNTS   48
#define YYNRULES   155
#define YYNSTATES   309
#define YYUNDEFTOK   2
#define YYMAXUTOK   321
#define YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
#define YYPACT_NINF   -245
#define YYTABLE_NINF   -152
#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 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, SELECT = 297,
  SWITCH = 298, CASE = 299, DEFAULT = 300, SYM_NAMESPACE = 301,
  IDENTIFIER = 302, STRING = 303, C_VOID = 304, C_BOOLEAN = 305,
  C_INTEGER = 306, C_FLOAT = 307, C_BYTEBLOCK = 308, C_PATH = 309,
  C_SYMBOL = 310, C_TYPE = 311, OR = 312, AND = 313,
  NEQ = 314, EQUALS = 315, GE = 316, LE = 317,
  RIGHT = 318, LEFT = 319, ELSE = 320, UMINUS = 321
}
enum  scan_states { SCAN_FILE, SCAN_START_INCLUDE, SCAN_INCLUDE }

Functions

static void yyerror_with_lineinfo (Parser *parser, int lineno, const char *s)
static void yywarning_with_lineinfo (Parser *parser, int lineno, const char *s)
static void yyerror_with_code (Parser *parser, int lineno, YCodePtr c, constTypePtr t)
static void yyerror_with_name (Parser *parser, int lineno, const char *s)
static void yyerror_with_file (Parser *parser, int lineno, const char *s)
static void yyerror_with_tableentry (Parser *parser, int lineno, const char *s, TableEntry *entry)
static void yywarning_with_tableentry (Parser *parser, int lineno, TableEntry *entry)
static void yyerror_type_mismatch (Parser *parser, int lineno, const char *s, constTypePtr expected_type, constTypePtr seen_type)
static void yyerror_missing_argument (Parser *parser, int lineno, constTypePtr type)
static 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_no_module (Parser *parser, int lineno, const char *module)
static constTypePtr attach_parameter (Parser *parser, YCodePtr code, YYSTYPE *parm, YYSTYPE *parm1=0)
static YBlockPtr start_block (Parser *parser, constTypePtr type)
int yylex (YYSTYPE *, void *)
static void i_check_unary_op (YYSTYPE *result, YYSTYPE *e1, const char *op, Parser *parser)
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_void_assign (YYSTYPE *lhs, YYSTYPE *rhs, Parser *parser)
static void stack_push (stack_t **stack, stack_t *element)
 push element to stack
static stack_t * stack_pop (stack_t **stack)
 pop element to stack
static YYSIZE_T yystrlen (yystr) const char *yystr
int yyparse (YYPARSE_PARAM) void *YYPARSE_PARAM

Variables

static constTypePtr declared_return_type = Type::Unspec
 set by function declaration in order to predefine a definitions block return type
static constTypePtr found_return_type = Type::Unspec
 set when a return statement is encountered
StaticDeclaration static_declarations
ExecutionEnvironment ee
static bool in_switch = false
static bool inside_module = false
static int repeat_count = 0
static int do_while_count = 0
static const unsigned char yytranslate []
static const char *const yytname []
static const unsigned char yyr1 []
static const unsigned char yyr2 []
static const unsigned char yydefact []
static const short yydefgoto []
static const short yypact []
static const short yypgoto []
static const short yytable []
static const short yycheck []
static const unsigned char yystos []
const char * yysrc
YYSTYPE * yyvaluep

Define Documentation

#define AND   313
 

#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   305
 

#define C_BYTEBLOCK   308
 

#define C_FLOAT   307
 

#define C_INTEGER   306
 

#define C_PATH   309
 

#define C_SYMBOL   310
 

#define C_TYPE   311
 

#define C_VOID   304
 

#define CASE   299
 

#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 DEFAULT   300
 

#define DEFINE   265
 

#define DO   272
 

#define DO_DEBUG   0
 

#define ELSE   320
 

#define EMPTY   260
 

#define END_OF_FILE   259
 

#define EQUALS   315
 

#define EXPORT   287
 

#define EXTERN   295
 

#define FILE_NOW   (p_parser->scanner()->filename ())
 

#define FULLNAME   293
 

#define GE   316
 

#define GLOBAL   290
 

#define I18N   267
 

#define IDENTIFIER   302
 

#define IF   271
 

#define IMPORT   286
 

#define INCLUDE   289
 

#define IS   276
 

#define ISNIL   277
 

#define LE   317
 

#define LEFT   319
 

#define LINE_NOW   (p_parser->m_lineno)
 

#define LIST   261
 

#define LOOKUP   296
 

#define MAP   262
 

#define MAPEXPR   288
 

#define MODULE   285
 

#define NEQ   314
 

#define OR   312
 

#define p_parser   ((Parser *) vp_parser)
 

#define QUOTED_BLOCK   281
 

#define QUOTED_EXPRESSION   282
 

#define REPEAT   274
 

#define RETURN   268
 

#define RIGHT   318
 

#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 SELECT   297
 

#define STATIC   294
 

#define STRING   303
 

#define STRUCT   263
 

#define SWITCH   298
 

#define switchstack_pop (  s   )     ((switchstack_t *)stack_pop ((stack_t **)&(s)))
 

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

#define SYM_NAMESPACE   301
 

#define SYMBOL   278
 

#define TEXTDOMAIN   291
 

#define TYPEDEF   284
 

#define UMINUS   321
 

#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   55
 

#define YYINITDEPTH   1000
 

#define YYLAST   1346
 

#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   50000
 

#define YYMAXUTOK   321
 

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

#define YYNNTS   48
 

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

#define YYNRULES   155
 

#define YYNSTATES   309
 

#define YYNTOKENS   90
 

#define YYPACT_NINF   -245
 

#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   -152
 

#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
 

Enumerator:
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
 

Enumerator:
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 
SELECT 
SWITCH 
CASE 
DEFAULT 
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

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

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

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

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

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

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

pop element to stack

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

push element to stack

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

begin of a block

Parameters:
type declared return type

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

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

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

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

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

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

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

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

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

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

int yylex (  YYSTYPE *  ,
void * 
) 
 

int yyparse (  YYPARSE_PARAM   ) 
 

static YYSIZE_T yystrlen (  yystr   )  const [static]
 

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

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
 

constTypePtr found_return_type = Type::Unspec [static]
 

set when a return statement is encountered

bool in_switch = false [static]
 

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,    23,    51,    41,   214,    42,    43,    44,    25,    54,
      35,    61,    62,   128,   243,   129,   288,   181,   267,   183,
     269,   290,   296,   206,   207,   212,   130,   131,   132,   133,
     201,   246,   247,   248,   134,    33,    26,    27,    52,    95,
      28,    47,    29,   102,   173,    30,    31,   188
}

const short yypact[] [static]
 

const short yypgoto[] [static]
 

Initial value:

{
    -245,  -245,    -6,    53,  -245,    72,     3,  -245,   -46,  -245,
    -245,   -50,  -245,  -244,  -245,  -245,  -245,  -245,  -245,  -245,
    -245,  -245,  -245,    -4,  -134,  -245,  -245,  -245,  -245,  -245,
    -245,  -245,  -245,   -61,  -245,   158,  -245,  -245,   -85,   166,
    -245,  -245,   -60,  -245,  -245,  -245,   -56,   -14
}

const unsigned char yyr1[] [static]
 

Initial value:

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

const unsigned char yyr2[] [static]
 

Initial value:

{
       0,     2,     1,     1,     0,     1,     1,     1,     1,     5,
       0,     1,     1,     1,     4,     1,     8,     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,     3,     2,     6,     0,     6,     0,     0,
       9,     0,     0,     9,     2,     2,     2,     3,     0,     6,
       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,     2,     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", "SELECT", "SWITCH", "CASE", 
  "DEFAULT", "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", "@9", "opt_else", 
  "type", "type_gt", "types", "definition", "function_start", 
  "opt_global_identifier", "opt_global", "opt_define", "tupletypes", 
  "tupletype", "formal_param", "assignment", "string", "constant", "list", 
  "list_elements", "opt_comma", "map", "map_elements", "function_call", 
  "@10", "parameters", "function_name", "identifier", "identifier_list", 0
}

const unsigned char yytranslate[] [static]
 

YYSTYPE* yyvaluep
 

Generated on Wed Sep 14 10:34:29 2005 for yast2-core by  doxygen 1.4.4