diff --git a/harbour/ChangeLog b/harbour/ChangeLog index 2d4913edbb..fe038077c5 100644 --- a/harbour/ChangeLog +++ b/harbour/ChangeLog @@ -16,6 +16,90 @@ The license applies to all entries newer than 2009-04-28. */ +2012-05-16 19:23 UTC+0200 Przemyslaw Czerpak (druzus/at/poczta.onet.pl) + * harbour/src/vm/classes.c + % small optimization in __CLSGetProperties() function + + * harbour/src/rtl/tpersist.prg + ! force linkin ARRAY() function when HBPersistent class is used + ! use hb_ValToExp() instead of local ValToText() function which + didn't work correctly for memos and some other types + ! fixed infinite loop in HBPersistent:LoadFromText() used with + empty text. The problem was also exploited by :LoadFromFile() + method if file does not exists or it's empty() + ! fixed deserialization of strings containing "=" char inside + ! fixed deserialization of strings containing "::" + ! added support for decoding nested objects - the code was not + finished and this part was not implemented at all + + added support for serialized text using ":=" assign operator + instead of "=" + * use ":=" instead of "=" as assign operator in new serialized + text + + ignore lines starting with "//" and added support for files + which do not start with OBJECT directive + * ignore pointer and codeblock items stored in instance variables + during serialization + ; now HBPersistent class in Harbour should read serialized files + created in xHarbour with few exceptions: + - Harbour does not allow to serialize codeblocks + See "CODEBLOCK SERIALIZATION / DESERIALIZATION" in + doc/xhb-diff.txt for the reasons. + If Harbour application restores xHarbour HBPersistent files + with serialized codeblocks then RTE + Undefined function: HB_RESTOREBLOCK + is generated. + - xHarbour serialize pointer items as numeric items + saved in hexadecimal notation. Then restore them as numbers. + - HBPersistent does not support hash arrays - they are + serialized by default serialization code used by both + compilers to generate expressions. + In Harbour it's done by hb_valToExp() function and + in xHarbour it's ValToPrg() is used. + ValToPrg() does not create valid macrocompiler expressions + for arrays and objects so HBPersistent files created + by xHarbour are broken and cannot be correctly deserialized. + It happens if objects has hash arrays in instance variables + and these hash arrays contain normal arrays or object + If Harbour application restores such xHarbour HBPersistent + file then RTE "Syntax error: &" is generated. + ; xHarbour encapsulates deserialization code inside TRY/CATCH/END + statement saving errors to trace.log file. Harbour generates RTE. + If programmer needs similar behavior then he should + call :LoadFromText() and :LoadFromFile() methods inside + BEGIN SEQUENCE [ / RECOVER ... ] / END SEQUENCE + statement. + ; xHarbour reinitialize all or properties instance variables to + default state inside :LoadFromText() and :LoadFromFile() methods. + The 3-rd parameter in above method allows to + chose which install variables should be reinitialized: + all (default) or properties only. + Harbour does not have such functionality. + If programmer needs it then he should reinitialize them himself. + It can be easy done be simple function. + Alternatively we can implement this functionality but in such + case I'd suggest to define three actions for such switch: + none (default), all, properties only. + ; Harbour does not support 2-nd parameter which + exist in xHarbour versions of HBPersistent:LoadFromText() and + HBPersistent:LoadFromFile(): + If necessary we can implement it though it's usable only if we + want to ignore some wrong lines and process others. + ; Warning: Neither Harbour nor xHarbour supports arrays and objects + with cyclic references in HBPersistent code - infinite + loop appears in such case. + ; I've never used HBPersistent and the state of the previous + HBPersistent code in Harbour suggests that no one used it for + some serious jobs so I'm open for any opinions and suggestions + about it from xHarbour users. + + * harbour/src/compiler/harbour.y + * generate line numbers before extended codeblocks - it gives + more debugger friendly code. + + * harbour/src/compiler/harbour.yyh + * harbour/src/compiler/harbour.yyc + * regenerated (with bison 2.4.1) + 2012-05-16 18:38 UTC+0200 Viktor Szakats (harbour syenar.net) * src/rtl/hbgtcore.c * src/rtl/rat.c diff --git a/harbour/src/compiler/harbour.y b/harbour/src/compiler/harbour.y index 1073078ee9..0f7fecc495 100644 --- a/harbour/src/compiler/harbour.y +++ b/harbour/src/compiler/harbour.y @@ -431,7 +431,7 @@ Statement : ExecFlow CrlfStmnt } HB_COMP_PARAM->functions.pLast->funFlags |= FUN_WITH_RETURN | FUN_BREAK_CODE; } - | PUBLIC { hb_compLinePushIfInside( HB_COMP_PARAM ); HB_COMP_PARAM->iVarScope = VS_PUBLIC; } + | PUBLIC { hb_compLinePushIfInside( HB_COMP_PARAM ); HB_COMP_PARAM->iVarScope = VS_PUBLIC; } ExtVarList { hb_compRTVariableGen( HB_COMP_PARAM, "__MVPUBLIC" ); HB_COMP_PARAM->iVarScope = VS_NONE; @@ -1037,6 +1037,7 @@ CodeBlock : BlockHead { /* 3 */ HB_CBVAR_PTR pVar; $$ = HB_COMP_PARAM->functions.pLast->nPCodePos; + $2 = HB_COMP_PARAM->lastLine; hb_compCodeBlockStart( HB_COMP_PARAM, HB_TRUE ); HB_COMP_PARAM->functions.pLast->funFlags |= FUN_EXTBLOCK; HB_COMP_PARAM->functions.pLast->fVParams = @@ -1065,6 +1066,7 @@ CodeBlock : BlockHead HB_COMP_PARAM->functions.pLast->pCode + $3, HB_COMP_PARAM->functions.pLast->nPCodePos - $3 ); HB_COMP_PARAM->functions.pLast->nPCodePos = $3; + HB_COMP_PARAM->lastLine = $2; } ; diff --git a/harbour/src/compiler/harbour.yyc b/harbour/src/compiler/harbour.yyc index 2046c5cfc9..9b68ef86be 100644 --- a/harbour/src/compiler/harbour.yyc +++ b/harbour/src/compiler/harbour.yyc @@ -1,14 +1,15 @@ -/* A Bison parser, made by GNU Bison 2.3. */ + +/* A Bison parser, made by GNU Bison 2.4.1. */ /* Skeleton implementation for Bison's Yacc-like parsers in C Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. - This program is free software; you can redistribute it and/or modify + This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,9 +17,7 @@ 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., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work @@ -47,7 +46,7 @@ #define YYBISON 1 /* Bison version. */ -#define YYBISON_VERSION "2.3" +#define YYBISON_VERSION "2.4.1" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" @@ -55,17 +54,160 @@ /* Pure parsers. */ #define YYPURE 1 +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + /* Using locations. */ #define YYLSP_NEEDED 0 /* Substitute the variable and function names. */ -#define yyparse hb_comp_yyparse -#define yylex hb_comp_yylex -#define yyerror hb_comp_yyerror -#define yylval hb_comp_yylval -#define yychar hb_comp_yychar -#define yydebug hb_comp_yydebug -#define yynerrs hb_comp_yynerrs +#define yyparse hb_comp_yyparse +#define yylex hb_comp_yylex +#define yyerror hb_comp_yyerror +#define yylval hb_comp_yylval +#define yychar hb_comp_yychar +#define yydebug hb_comp_yydebug +#define yynerrs hb_comp_yynerrs + + +/* Copy the first part of user declarations. */ + +/* Line 189 of yacc.c */ +#line 5 "harbour.y" + +/* + * $Id$ + */ + +/* + * Harbour Project source code: + * Compiler YACC rules and actions + * + * Copyright 1999 Antonio Linares + * www - http://harbour-project.org + * + * This program is free software; you can redistribute it and/or modify + * it under 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. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 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., 675 Mass Ave, Cambridge, MA 02139, USA (or visit + * their web site at http://www.gnu.org/). + * + */ + +/* TODO list + * 1) Change the pcode generated by ::cVar from Self:cVar to QSELF():cVar + * The major problem to solve is how to support QSELF() inside a codeblock. + */ + + +#include "hbcomp.h" + +/* Compile using: bison -d -v harbour.y */ + +/* to pacify some warnings in BCC */ +#if defined( __BORLANDC__ ) && !defined( __STDC__ ) +# define __STDC__ +#endif + +#undef alloca +#define alloca hb_xgrab +#undef malloc +#define malloc hb_xgrab +#undef realloc +#define realloc hb_xrealloc +#undef free +#define free hb_xfree + +/* NOTE: these symbols are used internally in bison.simple + */ +#undef YYFREE +#define YYFREE hb_xfree +#undef YYMALLOC +#define YYMALLOC hb_xgrab + +#define NO_YYERROR + +/* NOTE: these symbols are defined explicitly to pacify warnings */ +#define YYENABLE_NLS 0 +#define YYLTYPE_IS_TRIVIAL 0 + +/* NOTE: increase the maximum size of bison stack size */ +#define YYMAXDEPTH 100000 + +static void hb_compLoopStart( HB_COMP_DECL, HB_BOOL ); +static void hb_compLoopEnd( HB_COMP_DECL ); +static void hb_compLoopLoop( HB_COMP_DECL ); +static void hb_compLoopExit( HB_COMP_DECL ); +static void hb_compLoopHere( HB_COMP_DECL ); +static long hb_compLoopCount( HB_COMP_DECL ); + +static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirstElseIf, HB_SIZE nOffset ); /* generates a support structure for elseifs pcode fixups */ +static void hb_compElseIfFix( HB_COMP_DECL, void * pIfElseIfs ); /* implements the ElseIfs pcode fixups */ + +static void hb_compRTVariableAdd( HB_COMP_DECL, HB_EXPR_PTR, HB_BOOL ); +static void hb_compRTVariableGen( HB_COMP_DECL, const char * ); + +static HB_EXPR_PTR hb_compArrayDimPush( HB_EXPR_PTR pInitValue, HB_COMP_DECL ); +static void hb_compVariableDim( const char *, HB_EXPR_PTR, HB_COMP_DECL ); + +static void hb_compForStart( HB_COMP_DECL, const char *szVarName, HB_BOOL bForEach ); +static void hb_compForEnd( HB_COMP_DECL, const char *szVarName ); +static void hb_compEnumStart( HB_COMP_DECL, HB_EXPR_PTR pVars, HB_EXPR_PTR pExprs, int descend ); +static void hb_compEnumNext( HB_COMP_DECL, HB_EXPR_PTR pExpr, int descend ); +static void hb_compEnumEnd( HB_COMP_DECL, HB_EXPR_PTR pExpr ); + +static void hb_compSwitchStart( HB_COMP_DECL, HB_EXPR_PTR ); +static void hb_compSwitchAdd( HB_COMP_DECL, HB_EXPR_PTR ); +static void hb_compSwitchEnd( HB_COMP_DECL ); + +static HB_EXPR_PTR hb_compCheckMethod( HB_COMP_DECL, HB_EXPR_PTR pExpr ); +static HB_EXPR_PTR hb_compCheckPassByRef( HB_COMP_DECL, HB_EXPR_PTR pExpr ); + +#ifdef HB_YYDEBUG + #define YYDEBUG 1 /* Parser debug information support */ +#endif + +/* Controls if passing by reference '@' is allowed */ +#define HB_PASSBYREF_OFF 0 +#define HB_PASSBYREF_FUNCALL 1 +#define HB_PASSBYREF_ARRAY 2 + +static void hb_compDebugStart( void ) { } + + + +/* Line 189 of yacc.c */ +#line 193 "harboury.c" + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +/* Enabling the token table. */ +#ifndef YYTOKEN_TABLE +# define YYTOKEN_TABLE 0 +#endif /* Tokens. */ @@ -185,255 +327,16 @@ PRE = 366 }; #endif -/* Tokens. */ -#define FUNCTION 258 -#define PROCEDURE 259 -#define IDENTIFIER 260 -#define RETURN 261 -#define NIL 262 -#define NUM_DOUBLE 263 -#define INASSIGN 264 -#define NUM_LONG 265 -#define LOCAL 266 -#define STATIC 267 -#define IIF 268 -#define IF 269 -#define ELSE 270 -#define ELSEIF 271 -#define END 272 -#define ENDIF 273 -#define LITERAL 274 -#define TRUEVALUE 275 -#define FALSEVALUE 276 -#define ANNOUNCE 277 -#define EXTERN 278 -#define DYNAMIC 279 -#define INIT 280 -#define EXIT 281 -#define AND 282 -#define OR 283 -#define NOT 284 -#define PUBLIC 285 -#define EQ 286 -#define NE1 287 -#define NE2 288 -#define INC 289 -#define DEC 290 -#define ALIASOP 291 -#define DOCASE 292 -#define CASE 293 -#define OTHERWISE 294 -#define ENDCASE 295 -#define ENDDO 296 -#define MEMVAR 297 -#define WHILE 298 -#define LOOP 299 -#define FOR 300 -#define NEXT 301 -#define TO 302 -#define STEP 303 -#define LE 304 -#define GE 305 -#define FIELD 306 -#define IN 307 -#define PARAMETERS 308 -#define PLUSEQ 309 -#define MINUSEQ 310 -#define MULTEQ 311 -#define DIVEQ 312 -#define POWER 313 -#define EXPEQ 314 -#define MODEQ 315 -#define PRIVATE 316 -#define BEGINSEQ 317 -#define BREAK 318 -#define RECOVER 319 -#define RECOVERUSING 320 -#define ALWAYS 321 -#define ENDSEQ 322 -#define DO 323 -#define WITH 324 -#define SELF 325 -#define LINE 326 -#define MACROVAR 327 -#define MACROTEXT 328 -#define AS_ARRAY 329 -#define AS_BLOCK 330 -#define AS_CHARACTER 331 -#define AS_CLASS 332 -#define AS_DATE 333 -#define AS_LOGICAL 334 -#define AS_NUMERIC 335 -#define AS_OBJECT 336 -#define AS_VARIANT 337 -#define DECLARE 338 -#define OPTIONAL 339 -#define DECLARE_CLASS 340 -#define DECLARE_MEMBER 341 -#define AS_ARRAY_ARRAY 342 -#define AS_BLOCK_ARRAY 343 -#define AS_CHARACTER_ARRAY 344 -#define AS_CLASS_ARRAY 345 -#define AS_DATE_ARRAY 346 -#define AS_LOGICAL_ARRAY 347 -#define AS_NUMERIC_ARRAY 348 -#define AS_OBJECT_ARRAY 349 -#define PROCREQ 350 -#define CBSTART 351 -#define DOIDENT 352 -#define FOREACH 353 -#define DESCEND 354 -#define DOSWITCH 355 -#define ENDSWITCH 356 -#define WITHOBJECT 357 -#define ENDWITH 358 -#define NUM_DATE 359 -#define TIMESTAMP 360 -#define EPSILON 361 -#define HASHOP 362 -#define THREAD 363 -#define POST 364 -#define UNARY 365 -#define PRE 366 - -/* Copy the first part of user declarations. */ -#line 5 "harbour.y" - -/* - * $Id$ - */ - -/* - * Harbour Project source code: - * Compiler YACC rules and actions - * - * Copyright 1999 Antonio Linares - * www - http://harbour-project.org - * - * This program is free software; you can redistribute it and/or modify - * it under 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. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 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., 675 Mass Ave, Cambridge, MA 02139, USA (or visit - * their web site at http://www.gnu.org/). - * - */ - -/* TODO list - * 1) Change the pcode generated by ::cVar from Self:cVar to QSELF():cVar - * The major problem to solve is how to support QSELF() inside a codeblock. - */ - - -#include "hbcomp.h" - -/* Compile using: bison -d -v harbour.y */ - -/* to pacify some warnings in BCC */ -#if defined( __BORLANDC__ ) && !defined( __STDC__ ) -# define __STDC__ -#endif - -#undef alloca -#define alloca hb_xgrab -#undef malloc -#define malloc hb_xgrab -#undef realloc -#define realloc hb_xrealloc -#undef free -#define free hb_xfree - -/* NOTE: these symbols are used internally in bison.simple - */ -#undef YYFREE -#define YYFREE hb_xfree -#undef YYMALLOC -#define YYMALLOC hb_xgrab - -#define NO_YYERROR - -/* NOTE: these symbols are defined explicitly to pacify warnings */ -#define YYENABLE_NLS 0 -#define YYLTYPE_IS_TRIVIAL 0 - -/* NOTE: increase the maximum size of bison stack size */ -#define YYMAXDEPTH 100000 - -static void hb_compLoopStart( HB_COMP_DECL, HB_BOOL ); -static void hb_compLoopEnd( HB_COMP_DECL ); -static void hb_compLoopLoop( HB_COMP_DECL ); -static void hb_compLoopExit( HB_COMP_DECL ); -static void hb_compLoopHere( HB_COMP_DECL ); -static long hb_compLoopCount( HB_COMP_DECL ); - -static void * hb_compElseIfGen( HB_COMP_DECL, void * pFirstElseIf, HB_SIZE nOffset ); /* generates a support structure for elseifs pcode fixups */ -static void hb_compElseIfFix( HB_COMP_DECL, void * pIfElseIfs ); /* implements the ElseIfs pcode fixups */ - -static void hb_compRTVariableAdd( HB_COMP_DECL, HB_EXPR_PTR, HB_BOOL ); -static void hb_compRTVariableGen( HB_COMP_DECL, const char * ); - -static HB_EXPR_PTR hb_compArrayDimPush( HB_EXPR_PTR pInitValue, HB_COMP_DECL ); -static void hb_compVariableDim( const char *, HB_EXPR_PTR, HB_COMP_DECL ); - -static void hb_compForStart( HB_COMP_DECL, const char *szVarName, HB_BOOL bForEach ); -static void hb_compForEnd( HB_COMP_DECL, const char *szVarName ); -static void hb_compEnumStart( HB_COMP_DECL, HB_EXPR_PTR pVars, HB_EXPR_PTR pExprs, int descend ); -static void hb_compEnumNext( HB_COMP_DECL, HB_EXPR_PTR pExpr, int descend ); -static void hb_compEnumEnd( HB_COMP_DECL, HB_EXPR_PTR pExpr ); - -static void hb_compSwitchStart( HB_COMP_DECL, HB_EXPR_PTR ); -static void hb_compSwitchAdd( HB_COMP_DECL, HB_EXPR_PTR ); -static void hb_compSwitchEnd( HB_COMP_DECL ); - -static HB_EXPR_PTR hb_compCheckMethod( HB_COMP_DECL, HB_EXPR_PTR pExpr ); -static HB_EXPR_PTR hb_compCheckPassByRef( HB_COMP_DECL, HB_EXPR_PTR pExpr ); - -#ifdef HB_YYDEBUG - #define YYDEBUG 1 /* Parser debug information support */ -#endif - -/* Controls if passing by reference '@' is allowed */ -#define HB_PASSBYREF_OFF 0 -#define HB_PASSBYREF_FUNCALL 1 -#define HB_PASSBYREF_ARRAY 2 - -static void hb_compDebugStart( void ) { } - - - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE 0 -#endif - -/* Enabling the token table. */ -#ifndef YYTOKEN_TABLE -# define YYTOKEN_TABLE 0 -#endif - #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE -#line 117 "harbour.y" { + +/* Line 214 of yacc.c */ +#line 117 "harbour.y" + const char * string; /* to hold a string returned by lex */ int iNumber; /* to hold a temporary integer number */ HB_SIZE sNumber; /* to hold a temporary HB_SIZE values */ @@ -470,18 +373,21 @@ typedef union YYSTYPE int flags; /* Flag for early {|| ¯o} (1) or late {|| &(macro)} (2) binding */ } asCodeblock; PHB_VARTYPE asVarType; -} -/* Line 187 of yacc.c. */ -#line 476 "harboury.c" - YYSTYPE; + + + +/* Line 214 of yacc.c */ +#line 381 "harboury.c" +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 #endif - /* Copy the second part of user declarations. */ + +/* Line 264 of yacc.c */ #line 156 "harbour.y" /* This must be placed after the above union - the union is @@ -491,8 +397,8 @@ extern int yylex( YYSTYPE *, HB_COMP_DECL ); /* main lex token function, cal extern void yyerror( HB_COMP_DECL, const char * ); /* parsing error management function */ -/* Line 216 of yacc.c. */ -#line 496 "harboury.c" +/* Line 264 of yacc.c */ +#line 402 "harboury.c" #ifdef short # undef short @@ -567,14 +473,14 @@ typedef short int yytype_int16; #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static int -YYID (int i) +YYID (int yyi) #else static int -YYID (i) - int i; +YYID (yyi) + int yyi; #endif { - return i; + return yyi; } #endif @@ -655,9 +561,9 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */ /* A type that is properly aligned for any stack member. */ union yyalloc { - yytype_int16 yyss; - YYSTYPE yyvs; - }; + yytype_int16 yyss_alloc; + YYSTYPE yyvs_alloc; +}; /* The size of the maximum gap between one aligned stack and the next. */ # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) @@ -691,12 +597,12 @@ union yyalloc elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ -# define YYSTACK_RELOCATE(Stack) \ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ do \ { \ YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ @@ -1061,29 +967,29 @@ static const yytype_uint16 yyrline[] = 981, 984, 985, 986, 987, 988, 989, 990, 991, 992, 995, 1001, 1002, 1003, 1006, 1007, 1010, 1010, 1016, 1017, 1018, 1019, 1022, 1023, 1026, 1027, 1031, 1034, 1030, 1037, - 1036, 1072, 1073, 1075, 1078, 1087, 1091, 1094, 1094, 1096, - 1096, 1098, 1098, 1100, 1100, 1110, 1111, 1114, 1115, 1123, - 1124, 1126, 1130, 1137, 1155, 1155, 1184, 1190, 1193, 1194, - 1195, 1198, 1198, 1205, 1206, 1209, 1210, 1213, 1213, 1216, - 1217, 1220, 1220, 1239, 1239, 1240, 1241, 1242, 1243, 1243, - 1246, 1247, 1250, 1251, 1252, 1253, 1256, 1256, 1275, 1275, - 1330, 1331, 1332, 1333, 1336, 1337, 1338, 1339, 1340, 1341, - 1342, 1345, 1346, 1349, 1352, 1353, 1354, 1355, 1356, 1357, - 1360, 1361, 1362, 1363, 1364, 1365, 1368, 1369, 1370, 1371, - 1372, 1373, 1374, 1375, 1378, 1379, 1380, 1381, 1385, 1387, - 1384, 1392, 1392, 1396, 1398, 1396, 1406, 1408, 1406, 1417, - 1425, 1426, 1429, 1433, 1437, 1440, 1446, 1453, 1454, 1457, - 1457, 1460, 1461, 1469, 1470, 1469, 1481, 1482, 1481, 1494, - 1494, 1494, 1496, 1496, 1501, 1506, 1500, 1520, 1529, 1533, - 1534, 1538, 1551, 1556, 1537, 1604, 1605, 1608, 1609, 1612, - 1620, 1621, 1622, 1623, 1626, 1627, 1630, 1631, 1634, 1635, - 1638, 1639, 1644, 1650, 1660, 1643, 1679, 1680, 1684, 1683, - 1696, 1704, 1712, 1713, 1717, 1716, 1727, 1728, 1737, 1737, - 1740, 1740, 1743, 1745, 1748, 1748, 1748, 1753, 1761, 1772, - 1782, 1752, 1813, 1814, 1817, 1818, 1826, 1827, 1830, 1839, - 1840, 1841, 1844, 1855, 1873, 1877, 1885, 1886, 1889, 1890, - 1891, 1892, 1893, 1896, 1897, 1898, 1899, 1900, 1904, 1903, - 1926, 1927, 1930, 1931 + 1036, 1073, 1074, 1076, 1079, 1088, 1092, 1095, 1095, 1097, + 1097, 1099, 1099, 1101, 1101, 1111, 1112, 1115, 1116, 1124, + 1125, 1127, 1131, 1138, 1156, 1156, 1185, 1191, 1194, 1195, + 1196, 1199, 1199, 1206, 1207, 1210, 1211, 1214, 1214, 1217, + 1218, 1221, 1221, 1240, 1240, 1241, 1242, 1243, 1244, 1244, + 1247, 1248, 1251, 1252, 1253, 1254, 1257, 1257, 1276, 1276, + 1331, 1332, 1333, 1334, 1337, 1338, 1339, 1340, 1341, 1342, + 1343, 1346, 1347, 1350, 1353, 1354, 1355, 1356, 1357, 1358, + 1361, 1362, 1363, 1364, 1365, 1366, 1369, 1370, 1371, 1372, + 1373, 1374, 1375, 1376, 1379, 1380, 1381, 1382, 1386, 1388, + 1385, 1393, 1393, 1397, 1399, 1397, 1407, 1409, 1407, 1418, + 1426, 1427, 1430, 1434, 1438, 1441, 1447, 1454, 1455, 1458, + 1458, 1461, 1462, 1470, 1471, 1470, 1482, 1483, 1482, 1495, + 1495, 1495, 1497, 1497, 1502, 1507, 1501, 1521, 1530, 1534, + 1535, 1539, 1552, 1557, 1538, 1605, 1606, 1609, 1610, 1613, + 1621, 1622, 1623, 1624, 1627, 1628, 1631, 1632, 1635, 1636, + 1639, 1640, 1645, 1651, 1661, 1644, 1680, 1681, 1685, 1684, + 1697, 1705, 1713, 1714, 1718, 1717, 1728, 1729, 1738, 1738, + 1741, 1741, 1744, 1746, 1749, 1749, 1749, 1754, 1762, 1773, + 1783, 1753, 1814, 1815, 1818, 1819, 1827, 1828, 1831, 1840, + 1841, 1842, 1845, 1856, 1874, 1878, 1886, 1887, 1890, 1891, + 1892, 1893, 1894, 1897, 1898, 1899, 1900, 1901, 1905, 1904, + 1927, 1928, 1931, 1932 }; #endif @@ -1113,47 +1019,47 @@ static const char *const yytname[] = "'<'", "'>'", "'$'", "'+'", "'-'", "'*'", "'/'", "'%'", "UNARY", "PRE", "'&'", "'@'", "'\\n'", "';'", "','", "'('", "')'", "'{'", "'}'", "':'", "']'", "'['", "'|'", "$accept", "Main", "Source", "Line", "Function", - "@1", "@2", "@3", "@4", "FunScope", "Params", "AsType", "AsArrayType", - "StrongType", "AsArray", "ParamList", "Statement", "@5", "@6", "@7", - "@8", "@9", "@10", "@11", "CompTimeStr", "CrlfStmnt", "@12", "LineStat", - "ControlError", "FunScopeId", "Statements", "EmptyStats", "ExtList", - "DynList", "IdentName", "NumValue", "DateValue", "TimeStampValue", - "NumAlias", "NilValue", "NilAlias", "LiteralValue", "LiteralAlias", - "CodeBlockAlias", "Logical", "LogicalAlias", "SelfValue", "SelfAlias", - "Array", "ArrayAlias", "ArrayAt", "ArrayAtAlias", "Hash", "HashAlias", - "HashList", "Variable", "VarAlias", "MacroVar", "MacroVarAlias", - "MacroExpr", "MacroExprAlias", "MacroAny", "FieldAlias", "FieldVarAlias", - "AliasId", "AliasVar", "AliasExpr", "VariableAt", "VariableAtAlias", - "FunIdentCall", "FunCall", "FunRef", "FunCallAlias", "ArgList", - "Argument", "RefArgument", "ExtArgument", "ObjectData", "SendId", - "ObjectRef", "ObjectDataAlias", "ObjectMethod", "ObjectMethodAlias", - "SimpleExpression", "Expression", "ExtExpression", "EmptyExpression", - "LValue", "LeftExpression", "PostOp", "ExprPostOp", "ExprPreOp", - "ExprUnary", "ExprEqual", "ExprAssign", "ExprPlusEq", "ExprMinusEq", - "ExprMultEq", "ExprDivEq", "ExprModEq", "ExprExpEq", "ExprOperEq", - "ExprMath", "ExprBool", "ExprRelation", "ArrayIndex", "IndexList", - "ElemList", "BlockHead", "@13", "BlockVars", "BlockVarList", - "BlockExpList", "CodeBlock", "@14", "@15", "@16", "ExpList", + "$@1", "$@2", "$@3", "$@4", "FunScope", "Params", "AsType", + "AsArrayType", "StrongType", "AsArray", "ParamList", "Statement", "$@5", + "$@6", "$@7", "$@8", "$@9", "$@10", "$@11", "CompTimeStr", "CrlfStmnt", + "$@12", "LineStat", "ControlError", "FunScopeId", "Statements", + "EmptyStats", "ExtList", "DynList", "IdentName", "NumValue", "DateValue", + "TimeStampValue", "NumAlias", "NilValue", "NilAlias", "LiteralValue", + "LiteralAlias", "CodeBlockAlias", "Logical", "LogicalAlias", "SelfValue", + "SelfAlias", "Array", "ArrayAlias", "ArrayAt", "ArrayAtAlias", "Hash", + "HashAlias", "HashList", "Variable", "VarAlias", "MacroVar", + "MacroVarAlias", "MacroExpr", "MacroExprAlias", "MacroAny", "FieldAlias", + "FieldVarAlias", "AliasId", "AliasVar", "AliasExpr", "VariableAt", + "VariableAtAlias", "FunIdentCall", "FunCall", "FunRef", "FunCallAlias", + "ArgList", "Argument", "RefArgument", "ExtArgument", "ObjectData", + "SendId", "ObjectRef", "ObjectDataAlias", "ObjectMethod", + "ObjectMethodAlias", "SimpleExpression", "Expression", "ExtExpression", + "EmptyExpression", "LValue", "LeftExpression", "PostOp", "ExprPostOp", + "ExprPreOp", "ExprUnary", "ExprEqual", "ExprAssign", "ExprPlusEq", + "ExprMinusEq", "ExprMultEq", "ExprDivEq", "ExprModEq", "ExprExpEq", + "ExprOperEq", "ExprMath", "ExprBool", "ExprRelation", "ArrayIndex", + "IndexList", "ElemList", "BlockHead", "@13", "BlockVars", "BlockVarList", + "BlockExpList", "CodeBlock", "@14", "$@15", "@16", "ExpList", "PareExpList", "PareExpListAlias", "IfInline", "IfInlineAlias", - "VarDefs", "@17", "@18", "@19", "@20", "VarList", "ExtVarList", - "ExtVarDef", "VarDef", "@21", "DimList", "DimIndex", "FieldsDef", "@22", - "FieldList", "InAlias", "MemvarDef", "@23", "MemvarList", "Declaration", - "@24", "@25", "@26", "DecDataList", "ClassInfo", "DecMethod", "@27", - "DecData", "@28", "DecList", "DecListExt", "DummyArgList", + "VarDefs", "$@17", "$@18", "$@19", "$@20", "VarList", "ExtVarList", + "ExtVarDef", "VarDef", "@21", "DimList", "DimIndex", "FieldsDef", "$@22", + "FieldList", "InAlias", "MemvarDef", "$@23", "MemvarList", "Declaration", + "$@24", "$@25", "$@26", "DecDataList", "ClassInfo", "DecMethod", "$@27", + "DecData", "$@28", "DecList", "DecListExt", "DummyArgList", "DummyArgument", "FormalList", "OptList", "ExecFlow", "IfEndif", - "IfBegin", "@29", "@30", "IfElse", "@31", "IfElseIf", "@32", "@33", - "@34", "@35", "EndIf", "EndIfID", "DoCase", "EndCase", "EndCaseID", - "DoCaseStart", "@36", "DoCaseBegin", "Cases", "@37", "@38", "@39", "@40", - "Otherwise", "@41", "@42", "@43", "DoWhile", "@44", "@45", "WhileBegin", - "EndWhile", "EndWhileID", "ForNext", "@46", "@47", "@48", "ForAssign", - "StepExpr", "ForStatements", "EndForID", "ForVar", "ForList", "ForExpr", - "ForArgs", "ForEach", "@49", "@50", "@51", "Descend", "DoSwitch", "@52", - "EndSwitch", "EndSwitchID", "SwitchStart", "@53", "SwitchBegin", - "SwitchCases", "@54", "@55", "SwitchDefault", "@56", "@57", "BeginSeq", - "@58", "@59", "@60", "@61", "EndSeqID", "BlockSeq", "AlwaysSeq", - "Always", "RecoverSeq", "RecoverEmpty", "RecoverUsing", "DoProc", - "DoArgs", "DoArgList", "DoArgument", "WithObject", "@62", "EndWithID", - "Crlf", 0 + "IfBegin", "$@29", "@30", "IfElse", "$@31", "IfElseIf", "$@32", "@33", + "$@34", "@35", "EndIf", "EndIfID", "DoCase", "EndCase", "EndCaseID", + "DoCaseStart", "$@36", "DoCaseBegin", "Cases", "$@37", "@38", "$@39", + "@40", "Otherwise", "$@41", "$@42", "$@43", "DoWhile", "@44", "$@45", + "WhileBegin", "EndWhile", "EndWhileID", "ForNext", "@46", "@47", "@48", + "ForAssign", "StepExpr", "ForStatements", "EndForID", "ForVar", + "ForList", "ForExpr", "ForArgs", "ForEach", "$@49", "@50", "@51", + "Descend", "DoSwitch", "$@52", "EndSwitch", "EndSwitchID", "SwitchStart", + "$@53", "SwitchBegin", "SwitchCases", "$@54", "$@55", "SwitchDefault", + "$@56", "$@57", "BeginSeq", "@58", "@59", "$@60", "$@61", "EndSeqID", + "BlockSeq", "AlwaysSeq", "Always", "RecoverSeq", "RecoverEmpty", + "RecoverUsing", "DoProc", "DoArgs", "DoArgList", "DoArgument", + "WithObject", "@62", "EndWithID", "Crlf", 0 }; #endif @@ -3661,17 +3567,20 @@ yy_symbol_print (yyoutput, yytype, yyvaluep, pComp) #if (defined __STDC__ || defined __C99__FUNC__ \ || defined __cplusplus || defined _MSC_VER) static void -yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) +yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) #else static void -yy_stack_print (bottom, top) - yytype_int16 *bottom; - yytype_int16 *top; +yy_stack_print (yybottom, yytop) + yytype_int16 *yybottom; + yytype_int16 *yytop; #endif { YYFPRINTF (stderr, "Stack now"); - for (; bottom <= top; ++bottom) - YYFPRINTF (stderr, " %d", *bottom); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } YYFPRINTF (stderr, "\n"); } @@ -3706,11 +3615,11 @@ yy_reduce_print (yyvsp, yyrule, pComp) /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { - fprintf (stderr, " $%d = ", yyi + 1); + YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], &(yyvsp[(yyi + 1) - (yynrhs)]) , pComp); - fprintf (stderr, "\n"); + YYFPRINTF (stderr, "\n"); } } @@ -3983,30 +3892,35 @@ yydestruct (yymsg, yytype, yyvaluep, pComp) if (!yymsg) yymsg = "Deleting"; - YYUSE (yymsg); YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); switch (yytype) { case 19: /* "LITERAL" */ + +/* Line 1000 of yacc.c */ #line 279 "harbour.y" { if( (yyvaluep->valChar).dealloc ) hb_xfree( (yyvaluep->valChar).string ); }; -#line 3995 "harboury.c" + +/* Line 1000 of yacc.c */ +#line 3907 "harboury.c" break; case 96: /* "CBSTART" */ + +/* Line 1000 of yacc.c */ #line 278 "harbour.y" { if( (yyvaluep->asCodeblock).string ) hb_xfree( (yyvaluep->asCodeblock).string ); }; -#line 4000 "harboury.c" + +/* Line 1000 of yacc.c */ +#line 3916 "harboury.c" break; default: break; } } - /* Prevent warnings from -Wmissing-prototypes. */ - #ifdef YYPARSE_PARAM #if defined __STDC__ || defined __cplusplus int yyparse (void *YYPARSE_PARAM); @@ -4025,10 +3939,9 @@ int yyparse (); - -/*----------. -| yyparse. | -`----------*/ +/*-------------------------. +| yyparse or yypush_parse. | +`-------------------------*/ #ifdef YYPARSE_PARAM #if (defined __STDC__ || defined __C99__FUNC__ \ @@ -4052,22 +3965,46 @@ yyparse (pComp) #endif #endif { - /* The look-ahead symbol. */ +/* The lookahead symbol. */ int yychar; -/* The semantic value of the look-ahead symbol. */ +/* The semantic value of the lookahead symbol. */ YYSTYPE yylval; -/* Number of syntax errors so far. */ -int yynerrs; + /* Number of syntax errors so far. */ + int yynerrs; + + int yystate; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + + /* The stacks and their tools: + `yyss': related to states. + `yyvs': related to semantic values. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + yytype_int16 yyssa[YYINITDEPTH]; + yytype_int16 *yyss; + yytype_int16 *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs; + YYSTYPE *yyvsp; + + YYSIZE_T yystacksize; - int yystate; int yyn; int yyresult; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; - /* Look-ahead token as an internal (translated) token number. */ - int yytoken = 0; + /* Lookahead token as an internal (translated) token number. */ + int yytoken; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + #if YYERROR_VERBOSE /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; @@ -4075,52 +4012,28 @@ int yynerrs; YYSIZE_T yymsg_alloc = sizeof yymsgbuf; #endif - /* Three stacks and their tools: - `yyss': related to states, - `yyvs': related to semantic values, - `yyls': related to locations. - - Refer to the stacks thru separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* The state stack. */ - yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16 *yyss = yyssa; - yytype_int16 *yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs = yyvsa; - YYSTYPE *yyvsp; - - - #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) - YYSIZE_T yystacksize = YYINITDEPTH; - - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; - - /* The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped. */ int yylen = 0; + yytoken = 0; + yyss = yyssa; + yyvs = yyvsa; + yystacksize = YYINITDEPTH; + YYDPRINTF ((stderr, "Starting parse\n")); - memset(&yylval, 0, sizeof (yylval)); yystate = 0; yyerrstatus = 0; yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ + yychar = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack so that they stay on the same level as the state stack. The wasted elements are never initialized. */ - yyssp = yyss; yyvsp = yyvs; @@ -4150,7 +4063,6 @@ int yynerrs; YYSTYPE *yyvs1 = yyvs; yytype_int16 *yyss1 = yyss; - /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. This used to be a conditional around just the two extra args, but that might @@ -4158,7 +4070,6 @@ int yynerrs; yyoverflow (YY_("memory exhausted"), &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), - &yystacksize); yyss = yyss1; @@ -4181,10 +4092,8 @@ int yynerrs; (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyexhaustedlab; - YYSTACK_RELOCATE (yyss); - YYSTACK_RELOCATE (yyvs); - YYUSE (yyptr); - + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); # undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); @@ -4195,7 +4104,6 @@ int yynerrs; yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; - YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); @@ -4205,6 +4113,9 @@ int yynerrs; YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + if (yystate == YYFINAL) + YYACCEPT; + goto yybackup; /*-----------. @@ -4213,16 +4124,16 @@ int yynerrs; yybackup: /* Do appropriate processing given the current state. Read a - look-ahead token if we need one and don't already have one. */ + lookahead token if we need one and don't already have one. */ - /* First try to decide what to do without reference to look-ahead token. */ + /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; if (yyn == YYPACT_NINF) goto yydefault; - /* Not known => get a look-ahead token if don't already have one. */ + /* Not known => get a lookahead token if don't already have one. */ - /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); @@ -4254,20 +4165,16 @@ yybackup: goto yyreduce; } - if (yyn == YYFINAL) - YYACCEPT; - /* Count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; - /* Shift the look-ahead token. */ + /* Shift the lookahead token. */ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); - /* Discard the shifted token unless it is eof. */ - if (yychar != YYEOF) - yychar = YYEMPTY; + /* Discard the shifted token. */ + yychar = YYEMPTY; yystate = yyn; *++yyvsp = yylval; @@ -4307,22 +4214,30 @@ yyreduce: switch (yyn) { case 9: + +/* Line 1455 of yacc.c */ #line 292 "harbour.y" { yyclearin; yyerrok; ;} break; case 15: + +/* Line 1455 of yacc.c */ #line 298 "harbour.y" { yyclearin; yyerrok; ;} break; case 16: + +/* Line 1455 of yacc.c */ #line 302 "harbour.y" { HB_COMP_PARAM->currLine = ( int ) (yyvsp[(2) - (3)].valLong).lNumber; HB_COMP_PARAM->pLex->fEol = HB_FALSE; ;} break; case 17: + +/* Line 1455 of yacc.c */ #line 305 "harbour.y" { HB_COMP_PARAM->currModule = hb_compIdentifierNew( HB_COMP_PARAM, (yyvsp[(3) - (4)].valChar).string, (yyvsp[(3) - (4)].valChar).dealloc ? HB_IDENT_FREE : HB_IDENT_STATIC ); HB_COMP_PARAM->currLine = ( int ) (yyvsp[(2) - (4)].valLong).lNumber; @@ -4331,6 +4246,8 @@ yyreduce: break; case 18: + +/* Line 1455 of yacc.c */ #line 310 "harbour.y" { HB_COMP_PARAM->currModule = hb_compIdentifierNew( HB_COMP_PARAM, (yyvsp[(5) - (6)].valChar).string, (yyvsp[(5) - (6)].valChar).dealloc ? HB_IDENT_FREE : HB_IDENT_STATIC ); HB_COMP_PARAM->currLine = ( int ) (yyvsp[(2) - (6)].valLong).lNumber; @@ -4340,186 +4257,260 @@ yyreduce: break; case 19: + +/* Line 1455 of yacc.c */ #line 317 "harbour.y" { hb_compFunctionAdd( HB_COMP_PARAM, (yyvsp[(3) - (3)].string), ( HB_SYMBOLSCOPE ) (yyvsp[(1) - (3)].iNumber), 0 ); ;} break; case 21: + +/* Line 1455 of yacc.c */ #line 318 "harbour.y" { hb_compFunctionAdd( HB_COMP_PARAM, (yyvsp[(3) - (3)].string), ( HB_SYMBOLSCOPE ) (yyvsp[(1) - (3)].iNumber), FUN_PROCEDURE ); ;} break; case 23: + +/* Line 1455 of yacc.c */ #line 319 "harbour.y" { hb_compFunctionAdd( HB_COMP_PARAM, (yyvsp[(3) - (3)].string), ( HB_SYMBOLSCOPE ) (yyvsp[(1) - (3)].iNumber), 0 ); HB_COMP_PARAM->iVarScope = VS_PARAMETER; ;} break; case 25: + +/* Line 1455 of yacc.c */ #line 320 "harbour.y" { hb_compFunctionAdd( HB_COMP_PARAM, (yyvsp[(3) - (3)].string), ( HB_SYMBOLSCOPE ) (yyvsp[(1) - (3)].iNumber), FUN_PROCEDURE ); HB_COMP_PARAM->iVarScope = VS_PARAMETER;;} break; case 27: + +/* Line 1455 of yacc.c */ #line 323 "harbour.y" { (yyval.iNumber) = HB_FS_PUBLIC; ;} break; case 28: + +/* Line 1455 of yacc.c */ #line 324 "harbour.y" { (yyval.iNumber) = HB_FS_STATIC; ;} break; case 29: + +/* Line 1455 of yacc.c */ #line 325 "harbour.y" { (yyval.iNumber) = HB_FS_INIT; ;} break; case 30: + +/* Line 1455 of yacc.c */ #line 326 "harbour.y" { (yyval.iNumber) = HB_FS_EXIT; ;} break; case 31: + +/* Line 1455 of yacc.c */ #line 329 "harbour.y" { (yyval.iNumber) = 0; ;} break; case 32: + +/* Line 1455 of yacc.c */ #line 330 "harbour.y" { HB_COMP_PARAM->functions.pLast->fVParams = HB_TRUE; (yyval.iNumber) = 0; ;} break; case 34: + +/* Line 1455 of yacc.c */ #line 332 "harbour.y" { HB_COMP_PARAM->functions.pLast->fVParams = HB_TRUE; (yyval.iNumber) = (yyvsp[(1) - (3)].iNumber); ;} break; case 35: + +/* Line 1455 of yacc.c */ #line 335 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, ' ', NULL ); ;} break; case 37: + +/* Line 1455 of yacc.c */ #line 339 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, ' ', NULL ); ;} break; case 39: + +/* Line 1455 of yacc.c */ #line 343 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'N', NULL ); ;} break; case 40: + +/* Line 1455 of yacc.c */ #line 344 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'C', NULL ); ;} break; case 41: + +/* Line 1455 of yacc.c */ #line 345 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'D', NULL ); ;} break; case 42: + +/* Line 1455 of yacc.c */ #line 346 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'L', NULL ); ;} break; case 43: + +/* Line 1455 of yacc.c */ #line 347 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'B', NULL ); ;} break; case 44: + +/* Line 1455 of yacc.c */ #line 348 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'O', NULL ); ;} break; case 45: + +/* Line 1455 of yacc.c */ #line 349 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'S', (yyvsp[(2) - (2)].string) ); ;} break; case 46: + +/* Line 1455 of yacc.c */ #line 350 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, ' ', NULL ); ;} break; case 48: + +/* Line 1455 of yacc.c */ #line 354 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'A', NULL ); ;} break; case 49: + +/* Line 1455 of yacc.c */ #line 355 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'n', NULL ); ;} break; case 50: + +/* Line 1455 of yacc.c */ #line 356 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'c', NULL ); ;} break; case 51: + +/* Line 1455 of yacc.c */ #line 357 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'd', NULL ); ;} break; case 52: + +/* Line 1455 of yacc.c */ #line 358 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'l', NULL ); ;} break; case 53: + +/* Line 1455 of yacc.c */ #line 359 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'a', NULL ); ;} break; case 54: + +/* Line 1455 of yacc.c */ #line 360 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'b', NULL ); ;} break; case 55: + +/* Line 1455 of yacc.c */ #line 361 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 'o', NULL ); ;} break; case 56: + +/* Line 1455 of yacc.c */ #line 362 "harbour.y" { (yyval.asVarType) = hb_compVarTypeNew( HB_COMP_PARAM, 's', (yyvsp[(2) - (2)].string) ); ;} break; case 57: + +/* Line 1455 of yacc.c */ #line 365 "harbour.y" { hb_compVariableAdd( HB_COMP_PARAM, (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].asVarType) ); (yyval.iNumber) = 1; ;} break; case 58: + +/* Line 1455 of yacc.c */ #line 366 "harbour.y" { hb_compVariableAdd( HB_COMP_PARAM, (yyvsp[(3) - (4)].string), (yyvsp[(4) - (4)].asVarType) ); (yyval.iNumber)++; ;} break; case 60: + +/* Line 1455 of yacc.c */ #line 375 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 61: + +/* Line 1455 of yacc.c */ #line 376 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 62: + +/* Line 1455 of yacc.c */ #line 377 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 63: + +/* Line 1455 of yacc.c */ #line 378 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 64: + +/* Line 1455 of yacc.c */ #line 379 "harbour.y" { if( HB_COMP_ISSUPPORTED( HB_COMPFLAG_XBASE ) ) HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); @@ -4530,52 +4521,72 @@ yyreduce: break; case 65: + +/* Line 1455 of yacc.c */ #line 385 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 66: + +/* Line 1455 of yacc.c */ #line 386 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 67: + +/* Line 1455 of yacc.c */ #line 387 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 68: + +/* Line 1455 of yacc.c */ #line 388 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 69: + +/* Line 1455 of yacc.c */ #line 389 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 70: + +/* Line 1455 of yacc.c */ #line 390 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 71: + +/* Line 1455 of yacc.c */ #line 391 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenStatement( (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ) ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_WITH_RETURN; ;} break; case 72: + +/* Line 1455 of yacc.c */ #line 392 "harbour.y" { hb_compGenBreak( HB_COMP_PARAM ); hb_compGenPCode2( HB_P_DOSHORT, 0, HB_COMP_PARAM ); HB_COMP_PARAM->functions.pLast->funFlags |= FUN_BREAK_CODE; ;} break; case 73: + +/* Line 1455 of yacc.c */ #line 394 "harbour.y" { hb_compLinePushIfInside( HB_COMP_PARAM ); ;} break; case 74: + +/* Line 1455 of yacc.c */ #line 395 "harbour.y" { hb_compGenBreak( HB_COMP_PARAM ); HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(3) - (4)].asExpr), HB_COMP_PARAM ) ); @@ -4585,16 +4596,22 @@ yyreduce: break; case 75: + +/* Line 1455 of yacc.c */ #line 400 "harbour.y" { hb_compLoopExit( HB_COMP_PARAM ); HB_COMP_PARAM->functions.pLast->funFlags |= FUN_BREAK_CODE; ;} break; case 76: + +/* Line 1455 of yacc.c */ #line 401 "harbour.y" { hb_compLoopLoop( HB_COMP_PARAM ); HB_COMP_PARAM->functions.pLast->funFlags |= FUN_BREAK_CODE; ;} break; case 77: + +/* Line 1455 of yacc.c */ #line 402 "harbour.y" { if( HB_COMP_PARAM->functions.pLast->wSeqCounter ) @@ -4611,11 +4628,15 @@ yyreduce: break; case 78: + +/* Line 1455 of yacc.c */ #line 414 "harbour.y" { hb_compLinePushIfInside( HB_COMP_PARAM ); ;} break; case 79: + +/* Line 1455 of yacc.c */ #line 416 "harbour.y" { if( HB_COMP_PARAM->functions.pLast->wSeqCounter ) @@ -4638,11 +4659,15 @@ yyreduce: break; case 80: + +/* Line 1455 of yacc.c */ #line 434 "harbour.y" - { hb_compLinePushIfInside( HB_COMP_PARAM ); HB_COMP_PARAM->iVarScope = VS_PUBLIC; ;} + { hb_compLinePushIfInside( HB_COMP_PARAM ); HB_COMP_PARAM->iVarScope = VS_PUBLIC; ;} break; case 81: + +/* Line 1455 of yacc.c */ #line 436 "harbour.y" { hb_compRTVariableGen( HB_COMP_PARAM, "__MVPUBLIC" ); HB_COMP_PARAM->iVarScope = VS_NONE; @@ -4651,11 +4676,15 @@ yyreduce: break; case 83: + +/* Line 1455 of yacc.c */ #line 440 "harbour.y" { hb_compLinePushIfInside( HB_COMP_PARAM ); HB_COMP_PARAM->iVarScope = VS_PRIVATE; ;} break; case 84: + +/* Line 1455 of yacc.c */ #line 442 "harbour.y" { hb_compRTVariableGen( HB_COMP_PARAM, "__MVPRIVATE" ); HB_COMP_PARAM->iVarScope = VS_NONE; @@ -4664,6 +4693,8 @@ yyreduce: break; case 91: + +/* Line 1455 of yacc.c */ #line 451 "harbour.y" { if( HB_COMP_PARAM->szAnnounce == NULL ) @@ -4674,6 +4705,8 @@ yyreduce: break; case 94: + +/* Line 1455 of yacc.c */ #line 460 "harbour.y" { if( (yyvsp[(1) - (1)].valChar).dealloc ) @@ -4686,6 +4719,8 @@ yyreduce: break; case 95: + +/* Line 1455 of yacc.c */ #line 468 "harbour.y" { { @@ -4707,36 +4742,50 @@ yyreduce: break; case 96: + +/* Line 1455 of yacc.c */ #line 487 "harbour.y" { hb_compLinePushIfInside( HB_COMP_PARAM ); ;} break; case 98: + +/* Line 1455 of yacc.c */ #line 490 "harbour.y" { (yyval.lNumber) = 0; ;} break; case 99: + +/* Line 1455 of yacc.c */ #line 491 "harbour.y" { (yyval.lNumber) = 1; ;} break; case 100: + +/* Line 1455 of yacc.c */ #line 492 "harbour.y" { (yyval.lNumber) = 1; ;} break; case 101: + +/* Line 1455 of yacc.c */ #line 493 "harbour.y" { (yyval.lNumber) = 0; ;} break; case 102: + +/* Line 1455 of yacc.c */ #line 494 "harbour.y" { (yyval.lNumber) = 0; hb_compCheckUnclosedStru( HB_COMP_PARAM, HB_COMP_PARAM->functions.pLast ); ;} break; case 103: + +/* Line 1455 of yacc.c */ #line 495 "harbour.y" { if( HB_COMP_PARAM->ilastLineErr && HB_COMP_PARAM->ilastLineErr == HB_COMP_PARAM->currLine ) { @@ -4752,161 +4801,225 @@ yyreduce: break; case 113: + +/* Line 1455 of yacc.c */ #line 521 "harbour.y" { (yyval.lNumber) += (yyvsp[(2) - (2)].lNumber); ;} break; case 114: + +/* Line 1455 of yacc.c */ #line 524 "harbour.y" { (yyval.lNumber) = 0; ;} break; case 116: + +/* Line 1455 of yacc.c */ #line 528 "harbour.y" { hb_compExternAdd( HB_COMP_PARAM, (yyvsp[(1) - (1)].string), 0 ); ;} break; case 117: + +/* Line 1455 of yacc.c */ #line 529 "harbour.y" { hb_compExternAdd( HB_COMP_PARAM, (yyvsp[(3) - (3)].string), 0 ); ;} break; case 118: + +/* Line 1455 of yacc.c */ #line 532 "harbour.y" { hb_compExternAdd( HB_COMP_PARAM, (yyvsp[(1) - (1)].string), HB_FS_DEFERRED ); ;} break; case 119: + +/* Line 1455 of yacc.c */ #line 533 "harbour.y" { hb_compExternAdd( HB_COMP_PARAM, (yyvsp[(3) - (3)].string), HB_FS_DEFERRED ); ;} break; case 121: + +/* Line 1455 of yacc.c */ #line 537 "harbour.y" { (yyval.string) = "STEP"; ;} break; case 122: + +/* Line 1455 of yacc.c */ #line 538 "harbour.y" { (yyval.string) = "TO"; ;} break; case 123: + +/* Line 1455 of yacc.c */ #line 539 "harbour.y" { (yyval.string) = "LOOP"; ;} break; case 124: + +/* Line 1455 of yacc.c */ #line 540 "harbour.y" { (yyval.string) = "EXIT"; ;} break; case 125: + +/* Line 1455 of yacc.c */ #line 541 "harbour.y" { (yyval.string) = "IN"; ;} break; case 126: + +/* Line 1455 of yacc.c */ #line 542 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 127: + +/* Line 1455 of yacc.c */ #line 543 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 128: + +/* Line 1455 of yacc.c */ #line 544 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 129: + +/* Line 1455 of yacc.c */ #line 545 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 130: + +/* Line 1455 of yacc.c */ #line 546 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 131: + +/* Line 1455 of yacc.c */ #line 547 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 132: + +/* Line 1455 of yacc.c */ #line 548 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 133: + +/* Line 1455 of yacc.c */ #line 549 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 134: + +/* Line 1455 of yacc.c */ #line 550 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 135: + +/* Line 1455 of yacc.c */ #line 551 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 136: + +/* Line 1455 of yacc.c */ #line 552 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 137: + +/* Line 1455 of yacc.c */ #line 553 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 138: + +/* Line 1455 of yacc.c */ #line 554 "harbour.y" { (yyval.string) = (yyvsp[(1) - (1)].string); ;} break; case 139: + +/* Line 1455 of yacc.c */ #line 559 "harbour.y" { (yyval.asExpr) = hb_compExprNewDouble( (yyvsp[(1) - (1)].valDouble).dNumber, (yyvsp[(1) - (1)].valDouble).bWidth, (yyvsp[(1) - (1)].valDouble).bDec, HB_COMP_PARAM ); ;} break; case 140: + +/* Line 1455 of yacc.c */ #line 560 "harbour.y" { (yyval.asExpr) = hb_compExprNewLong( (yyvsp[(1) - (1)].valLong).lNumber, HB_COMP_PARAM ); ;} break; case 141: + +/* Line 1455 of yacc.c */ #line 563 "harbour.y" { (yyval.asExpr) = hb_compExprNewDate( ( long ) (yyvsp[(1) - (1)].valLong).lNumber, HB_COMP_PARAM ); ;} break; case 142: + +/* Line 1455 of yacc.c */ #line 566 "harbour.y" { (yyval.asExpr) = hb_compExprNewTimeStamp( (yyvsp[(1) - (1)].valTimeStamp).date, (yyvsp[(1) - (1)].valTimeStamp).time, HB_COMP_PARAM ); ;} break; case 143: + +/* Line 1455 of yacc.c */ #line 569 "harbour.y" { (yyval.asExpr) = hb_compExprNewLong( (yyvsp[(1) - (2)].valLong).lNumber, HB_COMP_PARAM ); ;} break; case 144: + +/* Line 1455 of yacc.c */ #line 570 "harbour.y" { (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, hb_compExprNewDouble( (yyvsp[(1) - (2)].valDouble).dNumber, (yyvsp[(1) - (2)].valDouble).bWidth, (yyvsp[(1) - (2)].valDouble).bDec, HB_COMP_PARAM ) ); ;} break; case 145: + +/* Line 1455 of yacc.c */ #line 575 "harbour.y" { (yyval.asExpr) = hb_compExprNewNil( HB_COMP_PARAM ); ;} break; case 147: + +/* Line 1455 of yacc.c */ #line 583 "harbour.y" { (yyval.asExpr) = hb_compExprNewString( (yyvsp[(1) - (1)].valChar).string, (yyvsp[(1) - (1)].valChar).length, (yyvsp[(1) - (1)].valChar).dealloc, HB_COMP_PARAM ); @@ -4915,446 +5028,624 @@ yyreduce: break; case 150: + +/* Line 1455 of yacc.c */ #line 599 "harbour.y" { (yyval.asExpr) = hb_compExprNewLogical( HB_TRUE, HB_COMP_PARAM ); ;} break; case 151: + +/* Line 1455 of yacc.c */ #line 600 "harbour.y" { (yyval.asExpr) = hb_compExprNewLogical( HB_FALSE, HB_COMP_PARAM ); ;} break; case 153: + +/* Line 1455 of yacc.c */ #line 608 "harbour.y" { (yyval.asExpr) = hb_compExprNewSelf( HB_COMP_PARAM ); ;} break; case 155: + +/* Line 1455 of yacc.c */ #line 622 "harbour.y" { (yyval.asExpr) = hb_compExprNewArray( (yyvsp[(2) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 157: + +/* Line 1455 of yacc.c */ #line 630 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 159: + +/* Line 1455 of yacc.c */ #line 636 "harbour.y" { (yyval.asExpr) = hb_compExprNewHash( NULL, HB_COMP_PARAM ); ;} break; case 160: + +/* Line 1455 of yacc.c */ #line 637 "harbour.y" { (yyval.asExpr) = hb_compExprNewHash( (yyvsp[(2) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 162: + +/* Line 1455 of yacc.c */ #line 643 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( hb_compExprNewList( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr) ); ;} break; case 163: + +/* Line 1455 of yacc.c */ #line 644 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( hb_compExprAddListExpr( (yyvsp[(1) - (5)].asExpr), (yyvsp[(3) - (5)].asExpr) ), (yyvsp[(5) - (5)].asExpr) ); ;} break; case 164: + +/* Line 1455 of yacc.c */ #line 649 "harbour.y" { (yyval.asExpr) = hb_compExprNewVar( (yyvsp[(1) - (1)].string), HB_COMP_PARAM ); ;} break; case 165: + +/* Line 1455 of yacc.c */ #line 652 "harbour.y" { (yyval.asExpr) = hb_compExprNewAlias( (yyvsp[(1) - (2)].string), HB_COMP_PARAM ); ;} break; case 166: + +/* Line 1455 of yacc.c */ #line 657 "harbour.y" { (yyval.asExpr) = hb_compExprNewMacro( NULL, '&', (yyvsp[(1) - (1)].string), HB_COMP_PARAM ); ;} break; case 167: + +/* Line 1455 of yacc.c */ #line 658 "harbour.y" { (yyval.asExpr) = hb_compExprNewMacro( NULL, 0, (yyvsp[(1) - (1)].string), HB_COMP_PARAM ); ;} break; case 169: + +/* Line 1455 of yacc.c */ #line 666 "harbour.y" { (yyval.asExpr) = hb_compExprNewMacro( (yyvsp[(2) - (2)].asExpr), 0, NULL, HB_COMP_PARAM ); ;} break; case 173: + +/* Line 1455 of yacc.c */ #line 680 "harbour.y" { (yyval.asExpr) = hb_compExprNewAlias( "FIELD", HB_COMP_PARAM ); ;} break; case 174: + +/* Line 1455 of yacc.c */ #line 681 "harbour.y" { (yyval.asExpr) = (yyvsp[(3) - (3)].asExpr); ;} break; case 175: + +/* Line 1455 of yacc.c */ #line 686 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 176: + +/* Line 1455 of yacc.c */ #line 687 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 177: + +/* Line 1455 of yacc.c */ #line 688 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 178: + +/* Line 1455 of yacc.c */ #line 689 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 179: + +/* Line 1455 of yacc.c */ #line 690 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 180: + +/* Line 1455 of yacc.c */ #line 691 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 181: + +/* Line 1455 of yacc.c */ #line 692 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 182: + +/* Line 1455 of yacc.c */ #line 693 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 183: + +/* Line 1455 of yacc.c */ #line 694 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 184: + +/* Line 1455 of yacc.c */ #line 695 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 185: + +/* Line 1455 of yacc.c */ #line 696 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 186: + +/* Line 1455 of yacc.c */ #line 697 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 187: + +/* Line 1455 of yacc.c */ #line 698 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 188: + +/* Line 1455 of yacc.c */ #line 699 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 189: + +/* Line 1455 of yacc.c */ #line 702 "harbour.y" { (yyval.asExpr) = hb_compExprNewVar( (yyvsp[(1) - (1)].string), HB_COMP_PARAM ); ;} break; case 191: + +/* Line 1455 of yacc.c */ #line 706 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasVar( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 192: + +/* Line 1455 of yacc.c */ #line 707 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasVar( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 193: + +/* Line 1455 of yacc.c */ #line 708 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasVar( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 194: + +/* Line 1455 of yacc.c */ #line 709 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasVar( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 195: + +/* Line 1455 of yacc.c */ #line 710 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 196: + +/* Line 1455 of yacc.c */ #line 711 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 197: + +/* Line 1455 of yacc.c */ #line 712 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 198: + +/* Line 1455 of yacc.c */ #line 713 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 199: + +/* Line 1455 of yacc.c */ #line 714 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 200: + +/* Line 1455 of yacc.c */ #line 715 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 201: + +/* Line 1455 of yacc.c */ #line 716 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 202: + +/* Line 1455 of yacc.c */ #line 717 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 203: + +/* Line 1455 of yacc.c */ #line 718 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 204: + +/* Line 1455 of yacc.c */ #line 719 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 205: + +/* Line 1455 of yacc.c */ #line 720 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 206: + +/* Line 1455 of yacc.c */ #line 721 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 207: + +/* Line 1455 of yacc.c */ #line 722 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(1) - (2)].asExpr) ); ;} break; case 208: + +/* Line 1455 of yacc.c */ #line 723 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasVar( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 209: + +/* Line 1455 of yacc.c */ #line 724 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasVar( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 210: + +/* Line 1455 of yacc.c */ #line 725 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasVar( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 211: + +/* Line 1455 of yacc.c */ #line 734 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasExpr( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 212: + +/* Line 1455 of yacc.c */ #line 735 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasExpr( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 213: + +/* Line 1455 of yacc.c */ #line 736 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasExpr( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 214: + +/* Line 1455 of yacc.c */ #line 737 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasExpr( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 215: + +/* Line 1455 of yacc.c */ #line 738 "harbour.y" { (yyval.asExpr) = hb_compExprNewAliasExpr( (yyvsp[(1) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 216: + +/* Line 1455 of yacc.c */ #line 739 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); (yyval.asExpr) = hb_compErrorAlias( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 217: + +/* Line 1455 of yacc.c */ #line 744 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 218: + +/* Line 1455 of yacc.c */ #line 745 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 219: + +/* Line 1455 of yacc.c */ #line 746 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 220: + +/* Line 1455 of yacc.c */ #line 747 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 221: + +/* Line 1455 of yacc.c */ #line 748 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 222: + +/* Line 1455 of yacc.c */ #line 749 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 223: + +/* Line 1455 of yacc.c */ #line 750 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 224: + +/* Line 1455 of yacc.c */ #line 751 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 225: + +/* Line 1455 of yacc.c */ #line 752 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 226: + +/* Line 1455 of yacc.c */ #line 753 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 227: + +/* Line 1455 of yacc.c */ #line 754 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 228: + +/* Line 1455 of yacc.c */ #line 755 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 229: + +/* Line 1455 of yacc.c */ #line 756 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 230: + +/* Line 1455 of yacc.c */ #line 757 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 231: + +/* Line 1455 of yacc.c */ #line 758 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 232: + +/* Line 1455 of yacc.c */ #line 759 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 233: + +/* Line 1455 of yacc.c */ #line 760 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 234: + +/* Line 1455 of yacc.c */ #line 761 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 236: + +/* Line 1455 of yacc.c */ #line 768 "harbour.y" { (yyval.asExpr) = hb_compExprNewFunCall( hb_compExprNewFunName( (yyvsp[(1) - (4)].string), HB_COMP_PARAM ), (yyvsp[(3) - (4)].asExpr), HB_COMP_PARAM ); ;} break; case 238: + +/* Line 1455 of yacc.c */ #line 772 "harbour.y" { (yyval.asExpr) = hb_compExprNewFunCall( (yyvsp[(1) - (4)].asExpr), (yyvsp[(3) - (4)].asExpr), HB_COMP_PARAM ); ;} break; case 239: + +/* Line 1455 of yacc.c */ #line 776 "harbour.y" { (yyval.asExpr) = hb_compCheckPassByRef( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); ;} break; case 241: + +/* Line 1455 of yacc.c */ #line 782 "harbour.y" { (yyval.asExpr) = hb_compExprNewArgList( (yyvsp[(1) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 242: + +/* Line 1455 of yacc.c */ #line 783 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( (yyvsp[(1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr) ); ;} break; case 245: + +/* Line 1455 of yacc.c */ #line 790 "harbour.y" { (yyval.asExpr) = hb_compCheckPassByRef( HB_COMP_PARAM, hb_compExprNewVarRef( (yyvsp[(2) - (2)].string), HB_COMP_PARAM ) ); ;} break; case 246: + +/* Line 1455 of yacc.c */ #line 791 "harbour.y" { (yyval.asExpr) = hb_compCheckPassByRef( HB_COMP_PARAM, hb_compExprNewRef( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ) ); ;} break; case 247: + +/* Line 1455 of yacc.c */ #line 792 "harbour.y" { (yyval.asExpr) = hb_compCheckPassByRef( HB_COMP_PARAM, hb_compExprNewRef( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ) ); ;} break; case 248: + +/* Line 1455 of yacc.c */ #line 793 "harbour.y" { (yyval.asExpr) = hb_compCheckPassByRef( HB_COMP_PARAM, hb_compExprNewRef( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ) ); ;} break; case 249: + +/* Line 1455 of yacc.c */ #line 794 "harbour.y" { (yyval.asExpr) = hb_compCheckPassByRef( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); (yyval.asExpr)->value.asList.reference = HB_TRUE; ;} break; case 250: + +/* Line 1455 of yacc.c */ #line 797 "harbour.y" { (yyval.asExpr) = hb_compExprNewArgRef( HB_COMP_PARAM ); ;} break; case 252: + +/* Line 1455 of yacc.c */ #line 803 "harbour.y" { (yyval.asExpr) = hb_compCheckMethod( HB_COMP_PARAM, hb_compExprNewMethodObject( (yyvsp[(3) - (3)].asExpr), (yyvsp[(1) - (3)].asExpr) ) ); ;} break; case 253: + +/* Line 1455 of yacc.c */ #line 804 "harbour.y" { (yyval.asExpr) = hb_compExprNewMethodObject( (yyvsp[(3) - (3)].asExpr), (yyvsp[(1) - (3)].asExpr) ); ;} break; case 254: + +/* Line 1455 of yacc.c */ #line 805 "harbour.y" { if( HB_COMP_PARAM->functions.pLast->wWithObjectCnt == 0 ) hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'E', HB_COMP_ERR_WITHOBJECT, NULL, NULL ); @@ -5363,331 +5654,462 @@ yyreduce: break; case 255: + +/* Line 1455 of yacc.c */ #line 811 "harbour.y" { (yyval.asExpr) = hb_compExprNewSend( (yyvsp[(1) - (1)].string), HB_COMP_PARAM ); ;} break; case 256: + +/* Line 1455 of yacc.c */ #line 812 "harbour.y" { (yyval.asExpr) = hb_compExprNewMacroSend( (yyvsp[(1) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 257: + +/* Line 1455 of yacc.c */ #line 815 "harbour.y" { (yyval.asExpr) = hb_compExprNewVarRef( (yyvsp[(3) - (4)].string), HB_COMP_PARAM ); ;} break; case 259: + +/* Line 1455 of yacc.c */ #line 823 "harbour.y" { (yyval.asExpr) = hb_compExprNewMethodCall( (yyvsp[(1) - (4)].asExpr), (yyvsp[(3) - (4)].asExpr) ); ;} break; case 269: + +/* Line 1455 of yacc.c */ #line 843 "harbour.y" { (yyval.asExpr) = (yyvsp[(1) - (2)].asExpr); ;} break; case 279: + +/* Line 1455 of yacc.c */ #line 853 "harbour.y" { (yyval.asExpr) = (yyvsp[(1) - (2)].asExpr); ;} break; case 282: + +/* Line 1455 of yacc.c */ #line 856 "harbour.y" { (yyval.asExpr) = (yyvsp[(1) - (2)].asExpr); ;} break; case 284: + +/* Line 1455 of yacc.c */ #line 858 "harbour.y" { (yyval.asExpr) = (yyvsp[(1) - (2)].asExpr); ;} break; case 296: + +/* Line 1455 of yacc.c */ #line 872 "harbour.y" { (yyval.asExpr) = (yyvsp[(1) - (2)].asExpr); ;} break; case 297: + +/* Line 1455 of yacc.c */ #line 873 "harbour.y" { (yyval.asExpr) = (yyvsp[(1) - (2)].asExpr); ;} break; case 299: + +/* Line 1455 of yacc.c */ #line 877 "harbour.y" { (yyval.asExpr) = hb_compExprNewArgRef( HB_COMP_PARAM ); ;} break; case 301: + +/* Line 1455 of yacc.c */ #line 881 "harbour.y" { (yyval.asExpr) = hb_compExprNewEmpty( HB_COMP_PARAM ); ;} break; case 303: + +/* Line 1455 of yacc.c */ #line 885 "harbour.y" { (yyval.asExpr) = hb_compExprNewVar( (yyvsp[(1) - (1)].string), HB_COMP_PARAM ); ;} break; case 309: + +/* Line 1455 of yacc.c */ #line 891 "harbour.y" { (yyval.asExpr) = hb_compExprListStrip( (yyvsp[(1) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 331: + +/* Line 1455 of yacc.c */ #line 924 "harbour.y" { (yyval.asExpr) = hb_compExprNewPostInc( (yyvsp[(0) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 332: + +/* Line 1455 of yacc.c */ #line 925 "harbour.y" { (yyval.asExpr) = hb_compExprNewPostDec( (yyvsp[(0) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 333: + +/* Line 1455 of yacc.c */ #line 928 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 334: + +/* Line 1455 of yacc.c */ #line 931 "harbour.y" { (yyval.asExpr) = hb_compExprNewPreInc( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 335: + +/* Line 1455 of yacc.c */ #line 932 "harbour.y" { (yyval.asExpr) = hb_compExprNewPreDec( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 336: + +/* Line 1455 of yacc.c */ #line 935 "harbour.y" { (yyval.asExpr) = hb_compExprNewNot( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 337: + +/* Line 1455 of yacc.c */ #line 936 "harbour.y" { (yyval.asExpr) = hb_compExprNewNegate( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 338: + +/* Line 1455 of yacc.c */ #line 937 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 339: + +/* Line 1455 of yacc.c */ #line 940 "harbour.y" { (yyval.asExpr) = hb_compExprAssign( (yyvsp[(1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 340: + +/* Line 1455 of yacc.c */ #line 943 "harbour.y" { (yyval.asExpr) = hb_compExprAssign( (yyvsp[(1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 341: + +/* Line 1455 of yacc.c */ #line 946 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewPlusEq( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 342: + +/* Line 1455 of yacc.c */ #line 949 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewMinusEq( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 343: + +/* Line 1455 of yacc.c */ #line 952 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewMultEq( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 344: + +/* Line 1455 of yacc.c */ #line 955 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewDivEq( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 345: + +/* Line 1455 of yacc.c */ #line 958 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewModEq( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 346: + +/* Line 1455 of yacc.c */ #line 961 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewExpEq( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 353: + +/* Line 1455 of yacc.c */ #line 972 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewPlus( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 354: + +/* Line 1455 of yacc.c */ #line 973 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewMinus( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 355: + +/* Line 1455 of yacc.c */ #line 974 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewMult( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 356: + +/* Line 1455 of yacc.c */ #line 975 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewDiv( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 357: + +/* Line 1455 of yacc.c */ #line 976 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewMod( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 358: + +/* Line 1455 of yacc.c */ #line 977 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewPower( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 359: + +/* Line 1455 of yacc.c */ #line 980 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewAnd( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 360: + +/* Line 1455 of yacc.c */ #line 981 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewOr( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 361: + +/* Line 1455 of yacc.c */ #line 984 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewEQ( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 362: + +/* Line 1455 of yacc.c */ #line 985 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewLT( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 363: + +/* Line 1455 of yacc.c */ #line 986 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewGT( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 364: + +/* Line 1455 of yacc.c */ #line 987 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewLE( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 365: + +/* Line 1455 of yacc.c */ #line 988 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewGE( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 366: + +/* Line 1455 of yacc.c */ #line 989 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewNE( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 367: + +/* Line 1455 of yacc.c */ #line 990 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewNE( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 368: + +/* Line 1455 of yacc.c */ #line 991 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewIN( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 369: + +/* Line 1455 of yacc.c */ #line 992 "harbour.y" { (yyval.asExpr) = hb_compExprSetOperand( hb_compExprNewEqual( (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 371: + +/* Line 1455 of yacc.c */ #line 1001 "harbour.y" { (yyval.asExpr) = hb_compExprNewArrayAt( (yyvsp[(0) - (2)].asExpr), (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 372: + +/* Line 1455 of yacc.c */ #line 1002 "harbour.y" { (yyval.asExpr) = hb_compExprNewArrayAt( (yyvsp[(1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 373: + +/* Line 1455 of yacc.c */ #line 1003 "harbour.y" { (yyval.asExpr) = hb_compExprNewArrayAt( (yyvsp[(1) - (4)].asExpr), (yyvsp[(4) - (4)].asExpr), HB_COMP_PARAM ); ;} break; case 374: + +/* Line 1455 of yacc.c */ #line 1006 "harbour.y" { (yyval.asExpr) = hb_compExprNewList( (yyvsp[(1) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 375: + +/* Line 1455 of yacc.c */ #line 1007 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( (yyvsp[(1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr) ); ;} break; case 376: + +/* Line 1455 of yacc.c */ #line 1010 "harbour.y" { (yyval.asExpr) = hb_compExprNewCodeBlock( (yyvsp[(1) - (1)].asCodeblock).string, (yyvsp[(1) - (1)].asCodeblock).length, (yyvsp[(1) - (1)].asCodeblock).flags, HB_COMP_PARAM ); (yyvsp[(1) - (1)].asCodeblock).string = NULL; ;} break; case 377: + +/* Line 1455 of yacc.c */ #line 1011 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (4)].asExpr); ;} break; case 378: + +/* Line 1455 of yacc.c */ #line 1016 "harbour.y" { (yyval.asExpr) = NULL; ;} break; case 379: + +/* Line 1455 of yacc.c */ #line 1017 "harbour.y" { (yyval.asExpr) = NULL; (yyvsp[(0) - (1)].asExpr)->value.asCodeblock.flags |= HB_BLOCK_VPARAMS; ;} break; case 380: + +/* Line 1455 of yacc.c */ #line 1018 "harbour.y" { (yyval.asExpr) = (yyvsp[(1) - (1)].asExpr); ;} break; case 381: + +/* Line 1455 of yacc.c */ #line 1019 "harbour.y" { (yyval.asExpr) = (yyvsp[(1) - (3)].asExpr); (yyvsp[(0) - (3)].asExpr)->value.asCodeblock.flags |= HB_BLOCK_VPARAMS; ;} break; case 382: + +/* Line 1455 of yacc.c */ #line 1022 "harbour.y" { HB_COMP_PARAM->iVarScope = VS_LOCAL; (yyval.asExpr) = hb_compExprCBVarAdd( (yyvsp[(0) - (2)].asExpr), (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].asVarType)->cVarType, HB_COMP_PARAM ); ;} break; case 383: + +/* Line 1455 of yacc.c */ #line 1023 "harbour.y" { HB_COMP_PARAM->iVarScope = VS_LOCAL; (yyval.asExpr) = hb_compExprCBVarAdd( (yyvsp[(0) - (4)].asExpr), (yyvsp[(3) - (4)].string), (yyvsp[(4) - (4)].asVarType)->cVarType, HB_COMP_PARAM ); ;} break; case 384: + +/* Line 1455 of yacc.c */ #line 1026 "harbour.y" { (yyval.asExpr) = hb_compExprAddCodeblockExpr( (yyvsp[(-1) - (1)].asExpr), (yyvsp[(1) - (1)].asExpr) ); ;} break; case 385: + +/* Line 1455 of yacc.c */ #line 1027 "harbour.y" { (yyval.asExpr) = hb_compExprAddCodeblockExpr( (yyvsp[(-1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr) ); ;} break; case 386: + +/* Line 1455 of yacc.c */ #line 1031 "harbour.y" { (yyval.bTrue) = HB_COMP_PARAM->functions.pLast->bBlock; HB_COMP_PARAM->functions.pLast->bBlock = HB_TRUE; ;} break; case 387: + +/* Line 1455 of yacc.c */ #line 1034 "harbour.y" { HB_COMP_PARAM->functions.pLast->bBlock = (yyvsp[(2) - (3)].bTrue); ;} break; case 389: + +/* Line 1455 of yacc.c */ #line 1037 "harbour.y" { /* 3 */ HB_CBVAR_PTR pVar; (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; + (yyvsp[(2) - (2)].sNumber) = HB_COMP_PARAM->lastLine; hb_compCodeBlockStart( HB_COMP_PARAM, HB_TRUE ); HB_COMP_PARAM->functions.pLast->funFlags |= FUN_EXTBLOCK; HB_COMP_PARAM->functions.pLast->fVParams = @@ -5712,53 +6134,72 @@ yyreduce: break; case 390: -#line 1062 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1063 "harbour.y" { /* 6 */ hb_compCodeBlockEnd( HB_COMP_PARAM ); (yyval.asExpr) = hb_compExprSetCodeblockBody( (yyvsp[(1) - (5)].asExpr), HB_COMP_PARAM->functions.pLast->pCode + (yyvsp[(3) - (5)].sNumber), HB_COMP_PARAM->functions.pLast->nPCodePos - (yyvsp[(3) - (5)].sNumber) ); HB_COMP_PARAM->functions.pLast->nPCodePos = (yyvsp[(3) - (5)].sNumber); + HB_COMP_PARAM->lastLine = (yyvsp[(2) - (5)].sNumber); ;} break; case 391: -#line 1072 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1073 "harbour.y" { (yyval.asExpr) = hb_compExprNewList( (yyvsp[(1) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 392: -#line 1073 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1074 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( (yyvsp[(1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr) ); ;} break; case 393: -#line 1075 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1076 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (3)].asExpr) ;} break; case 395: -#line 1088 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1089 "harbour.y" { (yyval.asExpr) = hb_compExprNewIIF( hb_compExprAddListExpr( hb_compExprAddListExpr( hb_compExprNewList( (yyvsp[(3) - (8)].asExpr), HB_COMP_PARAM ), (yyvsp[(5) - (8)].asExpr) ), (yyvsp[(7) - (8)].asExpr) ) ); ;} break; case 397: -#line 1094 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1095 "harbour.y" { HB_COMP_PARAM->iVarScope = VS_LOCAL; hb_compLinePush( HB_COMP_PARAM ); ;} break; case 399: -#line 1096 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1097 "harbour.y" { HB_COMP_PARAM->iVarScope = VS_STATIC; hb_compLinePush( HB_COMP_PARAM ); ;} break; case 401: -#line 1098 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1099 "harbour.y" { HB_COMP_PARAM->iVarScope = VS_TH_STATIC; hb_compLinePush( HB_COMP_PARAM ); ;} break; case 403: -#line 1100 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1101 "harbour.y" { if( HB_COMP_PARAM->functions.pLast->funFlags & FUN_USES_LOCAL_PARAMS ) hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'E', HB_COMP_ERR_PARAMETERS_NOT_ALLOWED, NULL, NULL ); else @@ -5770,44 +6211,60 @@ yyreduce: break; case 404: -#line 1107 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1108 "harbour.y" { HB_COMP_PARAM->iVarScope = VS_NONE; ;} break; case 405: -#line 1110 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1111 "harbour.y" { (yyval.iNumber) = 1; ;} break; case 406: -#line 1111 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1112 "harbour.y" { (yyval.iNumber)++; ;} break; case 407: -#line 1114 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1115 "harbour.y" { (yyval.iNumber) = 1; ;} break; case 408: -#line 1115 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1116 "harbour.y" { (yyval.iNumber)++; ;} break; case 410: -#line 1125 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1126 "harbour.y" { hb_compRTVariableAdd( HB_COMP_PARAM, hb_compExprNewRTVar( NULL, (yyvsp[(1) - (2)].asExpr), HB_COMP_PARAM ), HB_FALSE ); ;} break; case 411: -#line 1127 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1128 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(4) - (4)].asExpr), HB_COMP_PARAM ) ); hb_compRTVariableAdd( HB_COMP_PARAM, hb_compExprNewRTVar( NULL, (yyvsp[(1) - (4)].asExpr), HB_COMP_PARAM ), HB_TRUE ); ;} break; case 412: -#line 1131 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1132 "harbour.y" { HB_COMP_EXPR_FREE( hb_compArrayDimPush( (yyvsp[(2) - (3)].asExpr), HB_COMP_PARAM ) ); hb_compRTVariableAdd( HB_COMP_PARAM, hb_compExprNewRTVar( NULL, (yyvsp[(1) - (3)].asExpr), HB_COMP_PARAM ), HB_TRUE ); @@ -5815,7 +6272,9 @@ yyreduce: break; case 413: -#line 1138 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1139 "harbour.y" { hb_compVariableAdd( HB_COMP_PARAM, (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].asVarType) ); if( HB_COMP_PARAM->iVarScope & VS_STATIC ) @@ -5836,14 +6295,18 @@ yyreduce: break; case 414: -#line 1155 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1156 "harbour.y" { (yyval.iNumber) = HB_COMP_PARAM->iVarScope; hb_compVariableAdd( HB_COMP_PARAM, (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].asVarType) ); ;} break; case 415: -#line 1159 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1160 "harbour.y" { HB_COMP_PARAM->iVarScope = (yyvsp[(3) - (5)].iNumber); if( HB_COMP_PARAM->iVarScope & VS_STATIC ) @@ -5871,79 +6334,109 @@ yyreduce: break; case 416: -#line 1184 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1185 "harbour.y" { hb_compVariableDim( (yyvsp[(1) - (3)].string), (yyvsp[(2) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 418: -#line 1193 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1194 "harbour.y" { (yyval.asExpr) = hb_compExprNewArgList( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 419: -#line 1194 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1195 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( (yyvsp[(1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr) ); ;} break; case 420: -#line 1195 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1196 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( (yyvsp[(1) - (4)].asExpr), (yyvsp[(4) - (4)].asExpr) ); ;} break; case 421: -#line 1198 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1199 "harbour.y" { HB_COMP_PARAM->iVarScope = VS_FIELD; ;} break; case 422: -#line 1200 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1201 "harbour.y" { if( (yyvsp[(4) - (5)].string) ) hb_compFieldSetAlias( HB_COMP_PARAM, (yyvsp[(4) - (5)].string), (yyvsp[(3) - (5)].iNumber) ); ;} break; case 423: -#line 1205 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1206 "harbour.y" { (yyval.iNumber) = hb_compFieldsCount( HB_COMP_PARAM ); hb_compVariableAdd( HB_COMP_PARAM, (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].asVarType) ); ;} break; case 424: -#line 1206 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1207 "harbour.y" { hb_compVariableAdd( HB_COMP_PARAM, (yyvsp[(3) - (4)].string), (yyvsp[(4) - (4)].asVarType) ); ;} break; case 425: -#line 1209 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1210 "harbour.y" { (yyval.string) = NULL; ;} break; case 426: -#line 1210 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1211 "harbour.y" { (yyval.string) = (yyvsp[(2) - (2)].string); ;} break; case 427: -#line 1213 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1214 "harbour.y" { HB_COMP_PARAM->iVarScope = VS_MEMVAR; ;} break; case 429: -#line 1216 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1217 "harbour.y" { hb_compVariableAdd( HB_COMP_PARAM, (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].asVarType) ); ;} break; case 430: -#line 1217 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1218 "harbour.y" { hb_compVariableAdd( HB_COMP_PARAM, (yyvsp[(3) - (4)].string), (yyvsp[(4) - (4)].asVarType) ); ;} break; case 431: -#line 1220 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1221 "harbour.y" { hb_compDeclaredAdd( HB_COMP_PARAM, (yyvsp[(2) - (3)].string) ); HB_COMP_PARAM->szDeclaredFun = (yyvsp[(2) - (3)].string); ;} break; case 432: -#line 1221 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1222 "harbour.y" { if( HB_COMP_PARAM->pLastDeclared ) { @@ -5965,47 +6458,65 @@ yyreduce: break; case 433: -#line 1239 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1240 "harbour.y" { HB_COMP_PARAM->pLastClass = hb_compClassAdd( HB_COMP_PARAM, (yyvsp[(2) - (2)].string), NULL ); ;} break; case 434: -#line 1239 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1240 "harbour.y" { HB_COMP_PARAM->iVarScope = VS_NONE; ;} break; case 435: -#line 1240 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1241 "harbour.y" { HB_COMP_PARAM->pLastClass = hb_compClassAdd( HB_COMP_PARAM, (yyvsp[(2) - (3)].string), NULL ); HB_COMP_PARAM->iVarScope = VS_NONE; ;} break; case 436: -#line 1241 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1242 "harbour.y" { HB_COMP_PARAM->pLastClass = hb_compClassAdd( HB_COMP_PARAM, (yyvsp[(2) - (4)].string), (yyvsp[(3) - (4)].string) ); HB_COMP_PARAM->iVarScope = VS_NONE; ;} break; case 437: -#line 1242 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1243 "harbour.y" { HB_COMP_PARAM->iVarScope = VS_NONE; ;} break; case 438: -#line 1243 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1244 "harbour.y" { HB_COMP_PARAM->cDataListType = (yyvsp[(3) - (3)].asVarType)->cVarType; ;} break; case 439: -#line 1243 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1244 "harbour.y" { HB_COMP_PARAM->cDataListType = 0; HB_COMP_PARAM->iVarScope = VS_NONE; ;} break; case 446: -#line 1256 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1257 "harbour.y" { HB_COMP_PARAM->pLastMethod = hb_compMethodAdd( HB_COMP_PARAM, HB_COMP_PARAM->pLastClass, (yyvsp[(1) - (2)].string) ); ;} break; case 447: -#line 1257 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1258 "harbour.y" { if( HB_COMP_PARAM->pLastMethod ) { @@ -6025,12 +6536,16 @@ yyreduce: break; case 448: -#line 1275 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1276 "harbour.y" { HB_COMP_PARAM->pLastMethod = hb_compMethodAdd( HB_COMP_PARAM, HB_COMP_PARAM->pLastClass, (yyvsp[(1) - (1)].string) ); ;} break; case 449: -#line 1276 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1277 "harbour.y" { if( HB_COMP_PARAM->pLastMethod ) { @@ -6086,150 +6601,206 @@ yyreduce: break; case 463: -#line 1349 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1350 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (1)].asExpr) ); ;} break; case 464: -#line 1352 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1353 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].asVarType) ); ;} break; case 465: -#line 1353 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1354 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(2) - (3)].string), hb_compVarTypeNew( HB_COMP_PARAM, (yyvsp[(3) - (3)].asVarType)->cVarType + VT_OFFSET_BYREF, NULL ) ); ;} break; case 466: -#line 1354 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1355 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(2) - (5)].string), hb_compVarTypeNew( HB_COMP_PARAM, 'F', NULL ) ); ;} break; case 467: -#line 1355 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1356 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(3) - (4)].string), (yyvsp[(4) - (4)].asVarType) ); ;} break; case 468: -#line 1356 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1357 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(4) - (5)].string), hb_compVarTypeNew( HB_COMP_PARAM, (yyvsp[(5) - (5)].asVarType)->cVarType + VT_OFFSET_BYREF, NULL ) ); ;} break; case 469: -#line 1357 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1358 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(4) - (7)].string), hb_compVarTypeNew( HB_COMP_PARAM, 'F', NULL ) ); ;} break; case 470: -#line 1360 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1361 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(2) - (3)].string), hb_compVarTypeNew( HB_COMP_PARAM, (yyvsp[(3) - (3)].asVarType)->cVarType + VT_OFFSET_OPTIONAL, NULL ) ); ;} break; case 471: -#line 1361 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1362 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(3) - (4)].string), hb_compVarTypeNew( HB_COMP_PARAM, (yyvsp[(4) - (4)].asVarType)->cVarType + VT_OFFSET_OPTIONAL + VT_OFFSET_BYREF, NULL ) ); ;} break; case 472: -#line 1362 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1363 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(3) - (6)].string), hb_compVarTypeNew( HB_COMP_PARAM, 'F' + VT_OFFSET_OPTIONAL + VT_OFFSET_BYREF, NULL ) ); ;} break; case 473: -#line 1363 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1364 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(4) - (5)].string), hb_compVarTypeNew( HB_COMP_PARAM, (yyvsp[(5) - (5)].asVarType)->cVarType + VT_OFFSET_OPTIONAL, NULL ) ); ;} break; case 474: -#line 1364 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1365 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(5) - (6)].string), hb_compVarTypeNew( HB_COMP_PARAM, (yyvsp[(6) - (6)].asVarType)->cVarType + VT_OFFSET_OPTIONAL + VT_OFFSET_BYREF, NULL ) ); ;} break; case 475: -#line 1365 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1366 "harbour.y" { hb_compDeclaredParameterAdd( HB_COMP_PARAM, (yyvsp[(5) - (8)].string), hb_compVarTypeNew( HB_COMP_PARAM, 'F' + VT_OFFSET_OPTIONAL + VT_OFFSET_BYREF, NULL ) ); ;} break; case 484: -#line 1378 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1379 "harbour.y" { hb_compGenJumpHere( (yyvsp[(1) - (2)].sNumber), HB_COMP_PARAM ); ;} break; case 485: -#line 1379 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1380 "harbour.y" { hb_compGenJumpHere( (yyvsp[(1) - (3)].sNumber), HB_COMP_PARAM ); ;} break; case 486: -#line 1380 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1381 "harbour.y" { hb_compGenJumpHere( (yyvsp[(1) - (3)].sNumber), HB_COMP_PARAM ); hb_compElseIfFix( HB_COMP_PARAM, (yyvsp[(2) - (3)].pVoid) ); ;} break; case 487: -#line 1381 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1382 "harbour.y" { hb_compGenJumpHere( (yyvsp[(1) - (4)].sNumber), HB_COMP_PARAM ); hb_compElseIfFix( HB_COMP_PARAM, (yyvsp[(2) - (4)].pVoid) ); ;} break; case 488: -#line 1385 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1386 "harbour.y" { ++HB_COMP_PARAM->functions.pLast->wIfCounter; hb_compLinePushIfInside( HB_COMP_PARAM ); ;} break; case 489: -#line 1387 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1388 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(2) - (4)].asExpr), HB_COMP_PARAM ) ); (yyval.sNumber) = hb_compGenJumpFalse( 0, HB_COMP_PARAM ); ;} break; case 490: -#line 1389 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1390 "harbour.y" { (yyval.sNumber) = hb_compGenJump( 0, HB_COMP_PARAM ); hb_compGenJumpHere( (yyvsp[(5) - (6)].sNumber), HB_COMP_PARAM ); ;} break; case 491: -#line 1392 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1393 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; ;} break; case 493: -#line 1396 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1397 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; hb_compLinePush( HB_COMP_PARAM ); ;} break; case 494: -#line 1398 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1399 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(3) - (4)].asExpr), HB_COMP_PARAM ) ); (yyval.sNumber) = hb_compGenJumpFalse( 0, HB_COMP_PARAM ); ;} break; case 495: -#line 1402 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1403 "harbour.y" { (yyval.pVoid) = hb_compElseIfGen( HB_COMP_PARAM, NULL, hb_compGenJump( 0, HB_COMP_PARAM ) ); hb_compGenJumpHere( (yyvsp[(5) - (6)].sNumber), HB_COMP_PARAM ); ;} break; case 496: -#line 1406 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1407 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; hb_compLinePush( HB_COMP_PARAM ); ;} break; case 497: -#line 1408 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1409 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(4) - (5)].asExpr), HB_COMP_PARAM ) ); (yyval.sNumber) = hb_compGenJumpFalse( 0, HB_COMP_PARAM ); ;} break; case 498: -#line 1412 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1413 "harbour.y" { (yyval.pVoid) = hb_compElseIfGen( HB_COMP_PARAM, (yyvsp[(1) - (7)].pVoid), hb_compGenJump( 0, HB_COMP_PARAM ) ); hb_compGenJumpHere( (yyvsp[(6) - (7)].sNumber), HB_COMP_PARAM ); ;} break; case 499: -#line 1418 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1419 "harbour.y" { if( HB_COMP_PARAM->functions.pLast->wIfCounter ) --HB_COMP_PARAM->functions.pLast->wIfCounter; @@ -6238,17 +6809,23 @@ yyreduce: break; case 502: -#line 1431 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1432 "harbour.y" { hb_compElseIfFix( HB_COMP_PARAM, (yyvsp[(2) - (3)].pVoid) ); ;} break; case 505: -#line 1443 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1444 "harbour.y" { hb_compElseIfFix( HB_COMP_PARAM, (yyvsp[(2) - (4)].pVoid) ); ;} break; case 506: -#line 1447 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1448 "harbour.y" { if( HB_COMP_PARAM->functions.pLast->wCaseCounter ) --HB_COMP_PARAM->functions.pLast->wCaseCounter; HB_COMP_PARAM->functions.pLast->funFlags &= ~ ( FUN_WITH_RETURN | FUN_BREAK_CODE ); @@ -6256,12 +6833,16 @@ yyreduce: break; case 509: -#line 1457 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1458 "harbour.y" { ++HB_COMP_PARAM->functions.pLast->wCaseCounter; hb_compLinePushIfDebugger( HB_COMP_PARAM );;} break; case 512: -#line 1461 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1462 "harbour.y" { if( (yyvsp[(2) - (2)].lNumber) > 0 ) { @@ -6271,12 +6852,16 @@ yyreduce: break; case 513: -#line 1469 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1470 "harbour.y" { hb_compLinePushIfInside( HB_COMP_PARAM ); ;} break; case 514: -#line 1470 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1471 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(3) - (4)].asExpr), HB_COMP_PARAM ) ); (yyval.sNumber) = hb_compGenJumpFalse( 0, HB_COMP_PARAM ); @@ -6284,7 +6869,9 @@ yyreduce: break; case 515: -#line 1475 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1476 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; (yyval.pVoid) = hb_compElseIfGen( HB_COMP_PARAM, NULL, hb_compGenJump( 0, HB_COMP_PARAM ) ); @@ -6293,12 +6880,16 @@ yyreduce: break; case 516: -#line 1481 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1482 "harbour.y" { hb_compLinePushIfInside( HB_COMP_PARAM ); ;} break; case 517: -#line 1482 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1483 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(4) - (5)].asExpr), HB_COMP_PARAM ) ); (yyval.sNumber) = hb_compGenJumpFalse( 0, HB_COMP_PARAM ); @@ -6306,7 +6897,9 @@ yyreduce: break; case 518: -#line 1487 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1488 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; (yyval.pVoid) = hb_compElseIfGen( HB_COMP_PARAM, (yyvsp[(1) - (7)].pVoid), hb_compGenJump( 0, HB_COMP_PARAM ) ); @@ -6315,22 +6908,30 @@ yyreduce: break; case 519: -#line 1494 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1495 "harbour.y" {hb_compLinePushIfDebugger( HB_COMP_PARAM ); ;} break; case 520: -#line 1494 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1495 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; ;} break; case 522: -#line 1496 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1497 "harbour.y" { hb_compGenError( HB_COMP_PARAM, hb_comp_szErrors, 'E', HB_COMP_ERR_MAYHEM_IN_CASE, NULL, NULL ); ;} break; case 524: -#line 1501 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1502 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(2) - (3)].asExpr), HB_COMP_PARAM ) ); (yyval.sNumber) = hb_compGenJumpFalse( 0, HB_COMP_PARAM ); @@ -6338,7 +6939,9 @@ yyreduce: break; case 525: -#line 1506 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1507 "harbour.y" { hb_compLoopHere( HB_COMP_PARAM ); hb_compGenJump( (yyvsp[(1) - (5)].sNumber) - HB_COMP_PARAM->functions.pLast->nPCodePos, HB_COMP_PARAM ); @@ -6346,7 +6949,9 @@ yyreduce: break; case 526: -#line 1511 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1512 "harbour.y" { hb_compGenJumpHere( (yyvsp[(4) - (7)].sNumber), HB_COMP_PARAM ); if( HB_COMP_PARAM->functions.pLast->wWhileCounter ) @@ -6357,7 +6962,9 @@ yyreduce: break; case 527: -#line 1521 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1522 "harbour.y" { (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; hb_compLinePushIfInside( HB_COMP_PARAM ); @@ -6367,12 +6974,16 @@ yyreduce: break; case 528: -#line 1530 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1531 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; ;} break; case 531: -#line 1538 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1539 "harbour.y" { /* 5 */ hb_compLinePushIfInside( HB_COMP_PARAM ); (yyvsp[(1) - (4)].iNumber) = HB_COMP_PARAM->currLine; @@ -6388,7 +6999,9 @@ yyreduce: break; case 532: -#line 1551 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1552 "harbour.y" { /* 9 */ hb_compLoopStart( HB_COMP_PARAM, HB_TRUE ); (yyval.sNumber) = hb_compGenJump( 0, HB_COMP_PARAM ); @@ -6396,14 +7009,18 @@ yyreduce: break; case 533: -#line 1556 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1557 "harbour.y" { /* 11 */ (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; ;} break; case 534: -#line 1560 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1561 "harbour.y" { int iSign, iLine; @@ -6449,17 +7066,23 @@ yyreduce: break; case 537: -#line 1608 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1609 "harbour.y" { (yyval.asExpr) = NULL; ;} break; case 538: -#line 1609 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1610 "harbour.y" { (yyval.asExpr) = hb_compExprReduce( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ); ;} break; case 539: -#line 1613 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1614 "harbour.y" { hb_compLinePush( HB_COMP_PARAM ); if( HB_COMP_PARAM->functions.pLast->wForCounter ) @@ -6468,42 +7091,58 @@ yyreduce: break; case 544: -#line 1626 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1627 "harbour.y" { (yyval.asExpr) = hb_compExprNewVarRef( (yyvsp[(1) - (1)].string), HB_COMP_PARAM ); ;} break; case 545: -#line 1627 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1628 "harbour.y" { (yyval.asExpr) = hb_compExprNewRef( (yyvsp[(1) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 546: -#line 1630 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1631 "harbour.y" { (yyval.asExpr) = hb_compExprNewArgList( (yyvsp[(1) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 547: -#line 1631 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1632 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( (yyvsp[(1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr) ); ;} break; case 548: -#line 1634 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1635 "harbour.y" { (yyval.asExpr) = hb_compExprNewVarRef( (yyvsp[(2) - (2)].string), HB_COMP_PARAM ); ;} break; case 550: -#line 1638 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1639 "harbour.y" { (yyval.asExpr) = hb_compExprNewArgList( (yyvsp[(1) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 551: -#line 1639 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1640 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( (yyvsp[(1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr) ); ;} break; case 552: -#line 1644 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1645 "harbour.y" { ++HB_COMP_PARAM->functions.pLast->wForCounter; /* 5 */ hb_compLinePushIfInside( HB_COMP_PARAM ); @@ -6512,7 +7151,9 @@ yyreduce: break; case 553: -#line 1650 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1651 "harbour.y" { /* 7 */ (yyvsp[(2) - (6)].asExpr) = hb_compExprReduce( (yyvsp[(2) - (6)].asExpr), HB_COMP_PARAM ); @@ -6525,7 +7166,9 @@ yyreduce: break; case 554: -#line 1660 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1661 "harbour.y" { /* 9 */ (yyval.sNumber) = hb_compGenJumpFalse( 0, HB_COMP_PARAM ); @@ -6533,7 +7176,9 @@ yyreduce: break; case 555: -#line 1665 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1666 "harbour.y" { hb_compLoopHere( HB_COMP_PARAM ); hb_compEnumNext( HB_COMP_PARAM, (yyvsp[(2) - (10)].asExpr), (yyvsp[(6) - (10)].iNumber) ); @@ -6549,17 +7194,23 @@ yyreduce: break; case 556: -#line 1679 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1680 "harbour.y" { (yyval.iNumber) = 1; ;} break; case 557: -#line 1680 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1681 "harbour.y" { (yyval.iNumber) = -1; ;} break; case 558: -#line 1684 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1685 "harbour.y" { hb_compLoopStart( HB_COMP_PARAM, HB_FALSE ); hb_compSwitchStart( HB_COMP_PARAM, (yyvsp[(1) - (1)].asExpr) ); @@ -6568,7 +7219,9 @@ yyreduce: break; case 559: -#line 1691 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1692 "harbour.y" { hb_compSwitchEnd( HB_COMP_PARAM ); hb_compLoopEnd( HB_COMP_PARAM ); @@ -6576,7 +7229,9 @@ yyreduce: break; case 560: -#line 1698 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1699 "harbour.y" { HB_COMP_EXPR_FREE( (yyvsp[(1) - (2)].asExpr) ); hb_compGenPCode1( HB_P_POP, HB_COMP_PARAM ); @@ -6584,7 +7239,9 @@ yyreduce: break; case 561: -#line 1705 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1706 "harbour.y" { if( HB_COMP_PARAM->functions.pLast->wSwitchCounter ) --HB_COMP_PARAM->functions.pLast->wSwitchCounter; @@ -6593,7 +7250,9 @@ yyreduce: break; case 564: -#line 1717 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1718 "harbour.y" { ++HB_COMP_PARAM->functions.pLast->wSwitchCounter; hb_compLinePushIfInside( HB_COMP_PARAM ); @@ -6601,14 +7260,18 @@ yyreduce: break; case 565: -#line 1722 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1723 "harbour.y" { (yyval.asExpr) = hb_compExprReduce( (yyvsp[(3) - (4)].asExpr), HB_COMP_PARAM ); ;} break; case 567: -#line 1729 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1730 "harbour.y" { if( (yyvsp[(2) - (2)].lNumber) > 0 ) { @@ -6618,27 +7281,37 @@ yyreduce: break; case 568: -#line 1737 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1738 "harbour.y" { hb_compSwitchAdd( HB_COMP_PARAM, (yyvsp[(2) - (2)].asExpr) ); hb_compLinePush( HB_COMP_PARAM ); ;} break; case 570: -#line 1740 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1741 "harbour.y" { hb_compSwitchAdd( HB_COMP_PARAM, (yyvsp[(3) - (3)].asExpr) ); hb_compLinePush( HB_COMP_PARAM ); ;} break; case 574: -#line 1748 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1749 "harbour.y" { hb_compSwitchAdd( HB_COMP_PARAM, NULL ); hb_compLinePush( HB_COMP_PARAM ); ;} break; case 575: -#line 1748 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1749 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; ;} break; case 577: -#line 1753 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1754 "harbour.y" { /* 2 */ hb_compLinePushIfInside( HB_COMP_PARAM ); ++HB_COMP_PARAM->functions.pLast->wSeqCounter; @@ -6647,7 +7320,9 @@ yyreduce: break; case 578: -#line 1761 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1762 "harbour.y" { /* 6 */ /* Set jump address for HB_P_SEQBEGIN opcode - this address * will be used in BREAK code if there is no RECOVER clause @@ -6661,7 +7336,9 @@ yyreduce: break; case 579: -#line 1772 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1773 "harbour.y" { /* 8 */ /* Replace END address with RECOVER address in * HB_P_SEQBEGIN opcode if there is RECOVER clause @@ -6674,7 +7351,9 @@ yyreduce: break; case 580: -#line 1782 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1783 "harbour.y" { /* 10 */ long lLoopCount = hb_compLoopCount( HB_COMP_PARAM ); HB_COMP_PARAM->functions.pLast->funFlags &= ~ ( FUN_WITH_RETURN | FUN_BREAK_CODE ); @@ -6706,12 +7385,16 @@ yyreduce: break; case 584: -#line 1817 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1818 "harbour.y" { (yyval.sNumber) = 0; ;} break; case 585: -#line 1819 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1820 "harbour.y" { HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(2) - (2)].asExpr), HB_COMP_PARAM ) ); hb_compGenPCode1( HB_P_SEQBLOCK, HB_COMP_PARAM ); @@ -6720,12 +7403,16 @@ yyreduce: break; case 586: -#line 1826 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1827 "harbour.y" { (yyval.sNumber) = 0; ;} break; case 588: -#line 1831 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1832 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ ( FUN_WITH_RETURN | FUN_BREAK_CODE ); (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; @@ -6735,12 +7422,16 @@ yyreduce: break; case 589: -#line 1839 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1840 "harbour.y" { (yyval.sNumber) = 0; HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; ;} break; case 592: -#line 1845 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1846 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; @@ -6752,7 +7443,9 @@ yyreduce: break; case 593: -#line 1856 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1857 "harbour.y" { HB_COMP_PARAM->functions.pLast->funFlags &= ~ FUN_BREAK_CODE; (yyval.sNumber) = HB_COMP_PARAM->functions.pLast->nPCodePos; @@ -6765,14 +7458,18 @@ yyreduce: break; case 594: -#line 1874 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1875 "harbour.y" { (yyval.asExpr) = hb_compExprNewFunCall( (yyvsp[(2) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr), HB_COMP_PARAM ); ;} break; case 595: -#line 1878 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1879 "harbour.y" { hb_compModuleAdd( HB_COMP_PARAM, (yyvsp[(1) - (2)].string), HB_FALSE ); /* DOIDENT is the only one identifier which can be returned in lower letters */ @@ -6781,47 +7478,65 @@ yyreduce: break; case 596: -#line 1885 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1886 "harbour.y" { (yyval.asExpr) = NULL; ;} break; case 597: -#line 1886 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1887 "harbour.y" { (yyval.asExpr) = (yyvsp[(2) - (2)].asExpr); ;} break; case 598: -#line 1889 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1890 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( hb_compExprNewArgList( hb_compExprNewNil( HB_COMP_PARAM ), HB_COMP_PARAM ), hb_compExprNewNil( HB_COMP_PARAM ) ); ;} break; case 599: -#line 1890 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1891 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( hb_compExprNewArgList( hb_compExprNewNil( HB_COMP_PARAM ), HB_COMP_PARAM ), (yyvsp[(2) - (2)].asExpr) ); ;} break; case 600: -#line 1891 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1892 "harbour.y" { (yyval.asExpr) = hb_compExprNewArgList( (yyvsp[(1) - (1)].asExpr), HB_COMP_PARAM ); ;} break; case 601: -#line 1892 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1893 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( (yyvsp[(1) - (2)].asExpr), hb_compExprNewNil( HB_COMP_PARAM ) ); ;} break; case 602: -#line 1893 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1894 "harbour.y" { (yyval.asExpr) = hb_compExprAddListExpr( (yyvsp[(1) - (3)].asExpr), (yyvsp[(3) - (3)].asExpr) ); ;} break; case 603: -#line 1896 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1897 "harbour.y" { (yyval.asExpr) = hb_compExprNewVarRef( (yyvsp[(1) - (1)].string), HB_COMP_PARAM ); ;} break; case 608: -#line 1904 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1905 "harbour.y" { hb_compLinePushIfInside( HB_COMP_PARAM ); HB_COMP_EXPR_FREE( hb_compExprGenPush( (yyvsp[(2) - (3)].asExpr), HB_COMP_PARAM ) ); @@ -6832,7 +7547,9 @@ yyreduce: break; case 609: -#line 1913 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1914 "harbour.y" { if( HB_COMP_PARAM->functions.pLast->wWithObjectCnt ) --HB_COMP_PARAM->functions.pLast->wWithObjectCnt; if( (yyvsp[(5) - (6)].lNumber) ) @@ -6847,13 +7564,16 @@ yyreduce: break; case 612: -#line 1930 "harbour.y" + +/* Line 1455 of yacc.c */ +#line 1931 "harbour.y" { HB_COMP_PARAM->fError = HB_FALSE; ;} break; -/* Line 1269 of yacc.c. */ -#line 6858 "harboury.c" + +/* Line 1455 of yacc.c */ +#line 7577 "harboury.c" default: break; } YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); @@ -6864,7 +7584,6 @@ yyreduce: *++yyvsp = yyval; - /* Now `shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ @@ -6888,7 +7607,6 @@ yyerrlab: if (!yyerrstatus) { ++yynerrs; - YYUSE (yynerrs); #if ! YYERROR_VERBOSE yyerror (pComp, YY_("syntax error")); #else @@ -6930,7 +7648,7 @@ yyerrlab: if (yyerrstatus == 3) { - /* If just tried and failed to reuse look-ahead token after an + /* If just tried and failed to reuse lookahead token after an error, discard it. */ if (yychar <= YYEOF) @@ -6947,7 +7665,7 @@ yyerrlab: } } - /* Else will try to reuse look-ahead token after shifting the error + /* Else will try to reuse lookahead token after shifting the error token. */ goto yyerrlab1; @@ -6961,10 +7679,8 @@ yyerrorlab: /* Pacify compilers like GCC when the user code never invokes YYERROR and the label yyerrorlab therefore never appears in user code. */ -#if ! defined( __BORLANDC__ ) && ! defined( __WATCOMC__ ) if (/*CONSTCOND*/ 0) goto yyerrorlab; -#endif /* Do not reclaim the symbols of the rule which action triggered this YYERROR. */ @@ -7008,9 +7724,6 @@ yyerrlab1: YY_STACK_PRINT (yyss, yyssp); } - if (yyn == YYFINAL) - YYACCEPT; - *++yyvsp = yylval; @@ -7035,7 +7748,7 @@ yyabortlab: yyresult = 1; goto yyreturn; -#ifndef yyoverflow +#if !defined(yyoverflow) || YYERROR_VERBOSE /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | `-------------------------------------------------*/ @@ -7046,7 +7759,7 @@ yyexhaustedlab: #endif yyreturn: - if (yychar != YYEOF && yychar != YYEMPTY) + if (yychar != YYEMPTY) yydestruct ("Cleanup: discarding lookahead", yytoken, &yylval, pComp); /* Do not reclaim the symbols of the rule which action triggered @@ -7072,7 +7785,9 @@ yyreturn: } -#line 1934 "harbour.y" + +/* Line 1675 of yacc.c */ +#line 1935 "harbour.y" /* diff --git a/harbour/src/compiler/harbour.yyh b/harbour/src/compiler/harbour.yyh index 111e142d21..23e4d9354b 100644 --- a/harbour/src/compiler/harbour.yyh +++ b/harbour/src/compiler/harbour.yyh @@ -1,14 +1,15 @@ -/* A Bison parser, made by GNU Bison 2.3. */ + +/* A Bison parser, made by GNU Bison 2.4.1. */ /* Skeleton interface for Bison's Yacc-like parsers in C Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. - This program is free software; you can redistribute it and/or modify + This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -16,9 +17,7 @@ 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., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work @@ -33,6 +32,7 @@ This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ + /* Tokens. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE @@ -150,124 +150,16 @@ PRE = 366 }; #endif -/* Tokens. */ -#define FUNCTION 258 -#define PROCEDURE 259 -#define IDENTIFIER 260 -#define RETURN 261 -#define NIL 262 -#define NUM_DOUBLE 263 -#define INASSIGN 264 -#define NUM_LONG 265 -#define LOCAL 266 -#define STATIC 267 -#define IIF 268 -#define IF 269 -#define ELSE 270 -#define ELSEIF 271 -#define END 272 -#define ENDIF 273 -#define LITERAL 274 -#define TRUEVALUE 275 -#define FALSEVALUE 276 -#define ANNOUNCE 277 -#define EXTERN 278 -#define DYNAMIC 279 -#define INIT 280 -#define EXIT 281 -#define AND 282 -#define OR 283 -#define NOT 284 -#define PUBLIC 285 -#define EQ 286 -#define NE1 287 -#define NE2 288 -#define INC 289 -#define DEC 290 -#define ALIASOP 291 -#define DOCASE 292 -#define CASE 293 -#define OTHERWISE 294 -#define ENDCASE 295 -#define ENDDO 296 -#define MEMVAR 297 -#define WHILE 298 -#define LOOP 299 -#define FOR 300 -#define NEXT 301 -#define TO 302 -#define STEP 303 -#define LE 304 -#define GE 305 -#define FIELD 306 -#define IN 307 -#define PARAMETERS 308 -#define PLUSEQ 309 -#define MINUSEQ 310 -#define MULTEQ 311 -#define DIVEQ 312 -#define POWER 313 -#define EXPEQ 314 -#define MODEQ 315 -#define PRIVATE 316 -#define BEGINSEQ 317 -#define BREAK 318 -#define RECOVER 319 -#define RECOVERUSING 320 -#define ALWAYS 321 -#define ENDSEQ 322 -#define DO 323 -#define WITH 324 -#define SELF 325 -#define LINE 326 -#define MACROVAR 327 -#define MACROTEXT 328 -#define AS_ARRAY 329 -#define AS_BLOCK 330 -#define AS_CHARACTER 331 -#define AS_CLASS 332 -#define AS_DATE 333 -#define AS_LOGICAL 334 -#define AS_NUMERIC 335 -#define AS_OBJECT 336 -#define AS_VARIANT 337 -#define DECLARE 338 -#define OPTIONAL 339 -#define DECLARE_CLASS 340 -#define DECLARE_MEMBER 341 -#define AS_ARRAY_ARRAY 342 -#define AS_BLOCK_ARRAY 343 -#define AS_CHARACTER_ARRAY 344 -#define AS_CLASS_ARRAY 345 -#define AS_DATE_ARRAY 346 -#define AS_LOGICAL_ARRAY 347 -#define AS_NUMERIC_ARRAY 348 -#define AS_OBJECT_ARRAY 349 -#define PROCREQ 350 -#define CBSTART 351 -#define DOIDENT 352 -#define FOREACH 353 -#define DESCEND 354 -#define DOSWITCH 355 -#define ENDSWITCH 356 -#define WITHOBJECT 357 -#define ENDWITH 358 -#define NUM_DATE 359 -#define TIMESTAMP 360 -#define EPSILON 361 -#define HASHOP 362 -#define THREAD 363 -#define POST 364 -#define UNARY 365 -#define PRE 366 - #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED typedef union YYSTYPE -#line 117 "harbour.y" { + +/* Line 1676 of yacc.c */ +#line 117 "harbour.y" + const char * string; /* to hold a string returned by lex */ int iNumber; /* to hold a temporary integer number */ HB_SIZE sNumber; /* to hold a temporary HB_SIZE values */ @@ -304,14 +196,17 @@ typedef union YYSTYPE int flags; /* Flag for early {|| ¯o} (1) or late {|| &(macro)} (2) binding */ } asCodeblock; PHB_VARTYPE asVarType; -} -/* Line 1496 of yacc.c. */ -#line 310 "harboury.h" - YYSTYPE; + + + +/* Line 1676 of yacc.c */ +#line 204 "harboury.h" +} YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 #endif + diff --git a/harbour/src/rtl/tpersist.prg b/harbour/src/rtl/tpersist.prg index bad185e056..2281beb940 100644 --- a/harbour/src/rtl/tpersist.prg +++ b/harbour/src/rtl/tpersist.prg @@ -53,6 +53,8 @@ #include "hbclass.ch" #include "common.ch" +REQUEST ARRAY + CREATE CLASS HBPersistent METHOD CreateNew() INLINE Self @@ -66,8 +68,10 @@ ENDCLASS METHOD LoadFromText( cObjectText ) CLASS HBPersistent LOCAL nFrom := 1 + LOCAL nPos LOCAL cLine LOCAL lStart := .t. + LOCAL aObjects := { Self } PRIVATE oSelf @@ -75,31 +79,47 @@ METHOD LoadFromText( cObjectText ) CLASS HBPersistent RETURN .F. ENDIF - /* We skip the first empty lines */ - DO WHILE Empty( ExtractLine( cObjectText, @nFrom ) ) - ENDDO - DO WHILE nFrom <= Len( cObjectText ) - cLine := ExtractLine( cObjectText, @nFrom ) + cLine := AllTrim( ExtractLine( cObjectText, @nFrom ) ) DO CASE + CASE Empty( cLine ) .OR. Left( cLine, 2 ) == "//" + /* ignore comments and empty lines */ + CASE hb_asciiUpper( LTrim( hb_TokenGet( cLine, 1 ) ) ) == "OBJECT" IF lStart lStart := .F. + ELSE + cLine := SubStr( cLine, At( "::", cLine ) ) + MEMVAR->oSelf := ATail( aObjects ) + cLine := StrTran( cLine, "::", "oSelf:",, 1 ) + cLine := StrTran( cLine, " AS ", " := " ) + "():CreateNew()" + AAdd( aObjects, &( cLine ) ) + ENDIF + + CASE hb_asciiUpper( LTrim( hb_TokenGet( cLine, 1 ) ) ) == "ENDOBJECT" + ASize( aObjects, Len( aObjects ) - 1 ) + IF Empty( aObjects ) + EXIT ENDIF CASE hb_asciiUpper( LTrim( hb_TokenGet( cLine, 1 ) ) ) == "ARRAY" cLine := SubStr( cLine, At( "::", cLine ) ) - MEMVAR->oSelf := Self - cLine := StrTran( cLine, "::", "oSelf:" ) - cLine := StrTran( cLine, " LEN ", " = Array( " ) - cLine := RTrim( StrTran( cLine, "=", ":=", , 1 ) ) + " )" + MEMVAR->oSelf := ATail( aObjects ) + cLine := StrTran( cLine, "::", "oSelf:",, 1 ) + cLine := StrTran( cLine, " LEN ", " := Array( " ) + " )" &( cLine ) - CASE Left( LTrim( hb_TokenGet( cLine, 1, "=" ) ), 2 ) == "::" - MEMVAR->oSelf := Self - cLine := StrTran( cLine, "::", "oSelf:" ) - cLine := StrTran( cLine, "=", ":=", , 1 ) + CASE Left( cLine, 2 ) == "::" + /* fix for older versions */ + nPos := At( "=", cLine ) + IF nPos > 0 + IF !( SubStr( cLine, nPos - 1, 1 ) == ":" ) + cLine := Stuff( cLine, nPos, 0, ":" ) + ENDIF + ENDIF + MEMVAR->oSelf := ATail( aObjects ) + cLine := StrTran( cLine, "::", "oSelf:",, 1 ) &( cLine ) ENDCASE @@ -141,31 +161,38 @@ METHOD SaveToText( cObjectName, nIndent ) CLASS HBPersistent IF !( cType == ValType( uNewValue ) ) .OR. !( uValue == uNewValue ) - DO CASE - CASE cType == "A" + SWITCH cType + CASE "A" nIndent += 3 cObject += ArrayToText( uValue, aProperties[ n ], nIndent ) nIndent -= 3 IF n < Len( aProperties ) cObject += hb_eol() ENDIF + EXIT - CASE cType == "O" + CASE "O" IF __objDerivedFrom( uValue, "HBPERSISTENT" ) cObject += uValue:SaveToText( aProperties[ n ], nIndent ) ENDIF IF n < Len( aProperties ) cObject += hb_eol() ENDIF + EXIT + + CASE "B" + CASE "P" + /* ignore codeblock and pointer items */ + EXIT OTHERWISE IF n == 1 cObject += hb_eol() ENDIF cObject += Space( nIndent ) + " ::" + ; - aProperties[ n ] + " = " + ValToText( uValue ) + ; + aProperties[ n ] + " := " + hb_ValToExp( uValue ) + ; hb_eol() - ENDCASE + ENDSWITCH ENDIF @@ -200,13 +227,18 @@ STATIC FUNCTION ArrayToText( aArray, cName, nIndent ) ENDIF EXIT + CASE "B" + CASE "P" + /* ignore codeblock and pointer items */ + EXIT + OTHERWISE IF n == 1 cArray += hb_eol() ENDIF cArray += Space( nIndent ) + " ::" + cName + ; - + "[ " + hb_NToS( n ) + " ]" + " = " + ; - ValToText( uValue ) + hb_eol() + + "[ " + hb_NToS( n ) + " ]" + " := " + ; + hb_ValToExp( uValue ) + hb_eol() ENDSWITCH NEXT @@ -214,21 +246,6 @@ STATIC FUNCTION ArrayToText( aArray, cName, nIndent ) RETURN cArray -STATIC FUNCTION ValToText( uValue ) - - SWITCH ValType( uValue ) - CASE "C" - RETURN hb_StrToExp( uValue ) - CASE "N" - RETURN hb_NToS( uValue ) - CASE "D" - RETURN "0d" + iif( Empty( DToS( uValue ) ), "00000000", DToS( uValue ) ) - CASE "T" - RETURN 't"' + hb_TSToStr( uValue, .T. ) + '"' - ENDSWITCH - - RETURN hb_ValToStr( uValue ) - /* Notice: nFrom must be supplied by reference */ STATIC FUNCTION ExtractLine( cText, nFrom ) diff --git a/harbour/src/vm/classes.c b/harbour/src/vm/classes.c index d746c89fab..aad6403dc0 100644 --- a/harbour/src/vm/classes.c +++ b/harbour/src/vm/classes.c @@ -4960,8 +4960,9 @@ HB_FUNC( __CLSGETPROPERTIES ) ++nCount; else if( pMethod->pMessage->pSymbol->szName[ 0 ] == '_' ) { - PHB_DYNS pMsg = hb_dynsymFind( pMethod->pMessage->pSymbol->szName + 1 ); - if( pMsg && hb_clsFindMsg( pClass, pMsg ) ) + if( !pMethod->pAccMsg ) + pMethod->pAccMsg = hb_dynsymGetCase( pMethod->pMessage->pSymbol->szName + 1 ); + if( hb_clsFindMsg( pClass, pMethod->pAccMsg ) ) ++nCount; } } @@ -4980,10 +4981,10 @@ HB_FUNC( __CLSGETPROPERTIES ) { if( ( pMethod->uiScope & HB_OO_CLSTP_PERSIST ) != 0 ) hb_arraySetC( pReturn, ++nCount, pMethod->pMessage->pSymbol->szName ); - else if( pMethod->pMessage->pSymbol->szName[ 0 ] == '_' ) + else if( pMethod->pMessage->pSymbol->szName[ 0 ] == '_' && + pMethod->pAccMsg ) { - PHB_DYNS pMsg = hb_dynsymFind( pMethod->pMessage->pSymbol->szName + 1 ); - if( pMsg && hb_clsFindMsg( pClass, pMsg ) ) + if( hb_clsFindMsg( pClass, pMethod->pAccMsg ) ) hb_arraySetC( pReturn, ++nCount, pMethod->pMessage->pSymbol->szName + 1 ); } }