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 YYBISON_VERSION   "2.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)   _blockstack_push(&(s), e)
#define blockstack_pop(s)   _blockstack_pop(p_parser, &(s))
#define blockstack_at_toplevel()   (p_parser->m_blockstack_depth == 1)
#define switchstack_push(s, e)   _switchstack_push(&(s), e)
#define switchstack_pop(s)   _switchstack_pop(&(s))
#define scannerstack_push(s, e)   _scannerstack_push(&(s), e)
#define scannerstack_pop(s)   _scannerstack_pop (&(s))
#define scannerstack_empty()   (p_parser->m_scanner_stack == 0)
#define YYERROR_VERBOSE   1
#define YYTOKEN_TABLE   0
#define YYSIZE_T   unsigned int
#define YY_(msgid)   msgid
#define YYSTACK_ALLOC   YYMALLOC
#define YYSTACK_FREE   YYFREE
#define YYSTACK_ALLOC_MAXIMUM   ((YYSIZE_T) -1)
#define YYMALLOC   malloc
#define YYFREE   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 yyerrok   (yyerrstatus = 0)
#define yyclearin   (yychar = YYEMPTY)
#define YYEMPTY   (-2)
#define YYEOF   0
#define YYACCEPT   goto yyacceptlab
#define YYABORT   goto yyabortlab
#define YYERROR   goto yyerrorlab
#define YYFAIL   goto yyerrlab
#define YYRECOVERING()   (!!yyerrstatus)
#define YYBACKUP(Token, Value)
#define YYTERROR   1
#define YYERRCODE   256
#define YYRHSLOC(Rhs, K)   ((Rhs)[K])
#define YYLLOC_DEFAULT(Current, Rhs, N)
#define YY_LOCATION_PRINT(File, Loc)   ((void) 0)
#define YYLEX   yylex (&yylval, YYLEX_PARAM)
#define YYDPRINTF(Args)
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
#define YY_STACK_PRINT(Bottom, Top)
#define YY_REDUCE_PRINT(Rule)
#define YYPOPSTACK   (yyvsp--, yyssp--)
#define YYERROR_VERBOSE_ARGS_MAXIMUM   5

Typedefs

typedef stack stack_t
 general stack handling
typedef short int 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_tstack_pop (stack_t **stack)
 pop element to stack
static void _blockstack_push (blockstack_t **blockstackptr, blockstack_t *blockelement)
static blockstack_t_blockstack_pop (Parser *parser, blockstack_t **blockstackptr)
static void _switchstack_push (switchstack_t **switchstack, stack_t *e)
static switchstack_t_switchstack_pop (switchstack_t **switchstack)
static void _scannerstack_push (scannerstack_t **scannerstackptr, stack_t *element)
static scannerstack_t_scannerstack_pop (scannerstack_t **scannerstackptr)
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 int yydefgoto []
static const short int yypact []
static const short int yypgoto []
static const short int yytable []
static const short int yycheck []
static const unsigned char yystos []
const char * yysrc
int yytype
YYSTYPEyyvaluep

Define Documentation

#define AND   313
 

#define BLOCK   264
 

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

#define blockstack_pop  )     _blockstack_pop(p_parser, &(s))
 

#define blockstack_push s,
 )     _blockstack_push(&(s), 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  )     _scannerstack_pop (&(s))
 

#define scannerstack_push s,
 )     _scannerstack_push(&(s), e)
 

#define SELECT   297
 

#define STATIC   294
 

#define STRING   303
 

#define STRUCT   263
 

#define SWITCH   298
 

#define switchstack_pop  )     _switchstack_pop(&(s))
 

#define switchstack_push s,
 )     _switchstack_push(&(s), 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_ msgid   )     msgid
 

#define YY_LOCATION_PRINT File,
Loc   )     ((void) 0)
 

#define YY_REDUCE_PRINT Rule   ) 
 

#define YY_STACK_PRINT Bottom,
Top   ) 
 

#define YY_SYMBOL_PRINT Title,
Type,
Value,
Location   ) 
 

#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 (YY_("syntax error: cannot back up")); \
      YYERROR;                                                  \
    }                                                           \
while (0)

#define YYBISON   1
 

#define YYBISON_VERSION   "2.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                                      \
        {                                       \
          YYSIZE_T yyi;                         \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (To)[yyi] = (From)[yyi];            \
        }                                       \
      while (0)

#define YYDEBUG   0
 

#define YYDPRINTF Args   ) 
 

#define YYEMPTY   (-2)
 

#define YYEOF   0
 

#define YYERRCODE   256
 

#define yyerrok   (yyerrstatus = 0)
 

#define YYERROR   goto yyerrorlab
 

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

#define YYERROR_VERBOSE   1
 

#define YYERROR_VERBOSE   1
 

#define YYERROR_VERBOSE_ARGS_MAXIMUM   5
 

#define YYFAIL   goto yyerrlab
 

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

#define YYFINAL   55
 

#define YYFREE   free
 

#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,
 ) 
 

Value:

do                                                                      \
      if (N)                                                            \
        {                                                               \
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
        }                                                               \
      else                                                              \
        {                                                               \
          (Current).first_line   = (Current).last_line   =              \
            YYRHSLOC (Rhs, 0).last_line;                                \
          (Current).first_column = (Current).last_column =              \
            YYRHSLOC (Rhs, 0).last_column;                              \
        }                                                               \
    while (0)

#define YYLSP_NEEDED   0
 

#define YYMALLOC   malloc
 

#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 YYRHSLOC Rhs,
 )     ((Rhs)[K])
 

#define YYSIZE_T   unsigned int
 

#define YYSKELETON_NAME   "yacc.c"
 

#define YYSTACK_ALLOC   YYMALLOC
 

#define YYSTACK_ALLOC_MAXIMUM   ((YYSIZE_T) -1)
 

#define YYSTACK_BYTES  ) 
 

Value:

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

#define YYSTACK_FREE   YYFREE
 

#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 YYTOKEN_TABLE   0
 

#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 int 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 blockstack_t* _blockstack_pop Parser parser,
blockstack_t **  blockstackptr
[static]
 

static void _blockstack_push blockstack_t **  blockstackptr,
blockstack_t blockelement
[static]
 

static scannerstack_t* _scannerstack_pop scannerstack_t **  scannerstackptr  )  [static]
 

static void _scannerstack_push scannerstack_t **  scannerstackptr,
stack_t element
[static]
 

static switchstack_t* _switchstack_pop switchstack_t **  switchstack  )  [static]
 

static void _switchstack_push switchstack_t **  switchstack,
stack_t e
[static]
 

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 int yycheck[] [static]
 

const unsigned char yydefact[] [static]
 

const short int 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 int yypact[] [static]
 

const short int 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 int 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]
 

int yytype
 

YYSTYPE* yyvaluep
 


Generated on Fri Jun 16 18:07:45 2006 for yast2-core by  doxygen 1.4.6