Context Navigation

framscript.y @ 605

Last change on this file since 605 was 538, checked in by Maciej Komosinski, 8 years ago
Value of the assignment statement is now consistently the assigned value. Previously it was the value returned from set() (in cases where set() is used and the assigned expression is not a constant). Interestingly, Dictionary.set() returns the "before" value for the given key, and this created the delayed "assignment propagation" effect.
Property svn:eol-style set to `native`
File size: 51.3 KB

Rev	Line
[286]	1	// This file is a part of Framsticks SDK. http://www.framsticks.com/
	2	// Copyright (C) 1999-2015 Maciej Komosinski and Szymon Ulatowski.
	3	// See LICENSE.txt for details.
[163]	4
	5	%{
	6	#include "framscript-defs.h"
[375]	7	#include "common/log.h"
[163]	8	#include <math.h>
	9	#include <ctype.h>
	10	#include <stdio.h>
	11
	12	#define YYERROR_VERBOSE
	13	#define YYPRINT(file,type,value) yyprint (file,type,value)
	14
[477]	15	enum NameKind { NameNotFound, VariableName, GlobalName, ConstName };
	16	static const char* name_kind_names[]={"","var","global","const"};
	17
[163]	18	static void yyprint (FILE *file,int type,YYSTYPE value);
	19	void handleTwoArg(YYSTYPE& result,const YYSTYPE& arg1,const YYSTYPE& arg2,
[332]	20	int optoken,const char* opname, bool negarg2, bool uniq);
	21	bool handleCompare(YYSTYPE& result,const YYSTYPE& arg1,const YYSTYPE& arg2,
	22	ExtValue::CmpOperator,const char* opname);
[163]	23	bool handleAssignOp(YYSTYPE& result,const YYSTYPE& var,const YYSTYPE& arg,const char* opname);
	24	bool handleAssignOp2(YYSTYPE& result,const char var,const YYSTYPE& arg,const char opname,int stackpos,bool push);
[477]	25	bool canAddName(const SString &name,NameKind kind);
[163]	26	bool variableOk(TokenValue &tok, const TokenValue& var,int &loc);
[477]	27	int variableNameOk(const SString &name);
[163]	28	bool globalOk(const TokenValue& var);
[477]	29	bool globalNameOk(const SString& name);
[163]	30	void badVariable(TokenValue &tok, const TokenValue &var);
	31	bool evalVariable(TokenValue &tok, const TokenValue &var);
	32	bool doBreak(int level);
	33	bool doContinue(int level);
	34	void warnTruthValue(const TokenValue& t);
	35	void outFunName(const TokenValue& t);
[333]	36	static bool resultIsRelaxedEqual(ExtValue::CompareResult res);
[163]	37
	38	static const char* assign_op_names[]={"add","sub","mul","div","mod"};
	39
	40	%}
	41
	42	%token_table
	43
	44	%token CONSTANT
[468]	45	%token INVALID_NUMBER
[163]	46
	47	%nonassoc ASSIGN_ADD ASSIGN_SUB ASSIGN_MUL ASSIGN_DIV ASSIGN_MOD
	48	%nonassoc PLUSPLUS MINUSMINUS
	49	%left LOGIC_AND LOGIC_OR '!'
	50	%left EQUAL NOT_EQUAL GEQUAL LEQUAL '>' '<'
	51	%left '\|' '&' '^'
	52	%left '-' '+'
	53	%left '*' '/' '%'
	54	%left NEG /* negation--unary minus */
	55	%left TYPEOF
[333]	56	%left INT_TYPE
	57	%left FLOAT_TYPE
	58	%left STRING_TYPE
[163]	59
	60	%token IDENT
	61	%token OBJNAME
	62
	63	%token IF "if"
	64	%token ELSE "else"
	65	%token FOR "for"
	66	%token INNN "in"
	67	%token WHILE "while"
	68	%token DO "do"
	69	%token GOTO "goto"
	70	%token RETURN "return"
	71	%token BREAK "break"
	72	%token CONTINUE "continue"
	73	%token SWITCH "switch"
	74	%token CASE "case"
	75	%token DEFAULT "default"
	76
[333]	77	%token TYPEOF "typeof"
	78	%token INT_TYPE "int"
	79	%token FLOAT_TYPE "float"
	80	%token STRING_TYPE "string"
[163]	81
	82	%token ASM
	83	%token ASMLINE
	84
	85	%token VAR "var"
[477]	86	%token CONSTDEF "const"
[163]	87	%token GLOBAL "global"
	88	%token FUNCTION "function"
	89
	90	%token CALL "call"
	91
[477]	92	%token ARROW
	93
[163]	94	%token ASSIGN
	95	%token ASSIGN_ADD
	96	%token ASSIGN_SUB
	97	%token ASSIGN_MUL
	98	%token ASSIGN_DIV
	99
	100	%token EQUAL
	101	%token NOT_EQUAL
	102	%token GEQUAL
	103	%token LEQUAL
	104
	105	%token LOGIC_AND
	106	%token LOGIC_OR
	107
	108	%token PLUSPLUS
	109	%token MINUSMINUS
	110
	111	%token LSHIFT
	112	%token RSHIFT
	113
	114	%%
	115	code: {$$.setInt(trstack.currentPos());} recurcode
	116	{
	117	int pos=$1.getInt();
	118	if (pos!=trstack.currentPos()) trctx.out->printf("add %d,m0\n",pos-trstack.currentPos());
	119	}
	120	;
	121
	122	recurcode: /* empty string */
	123	\| recurcode statement
	124	;
	125
	126	statement: ';'
	127	\| VAR vardeflist ';'
[477]	128	\| CONSTDEF constdeflist ';'
[163]	129	\| GLOBAL globaldeflist ';'
	130	\| IDENT ':' {trctx.out->printf(":%s\n",str($1));}
[332]	131	\| expr ';' {if (!$1.constant) { trctx.out->printf("inc m0\n"); trstack.adjust(+1); } trctx.emitLine(); }
[163]	132	\| functiondef
	133	\| blok
	134	\| if_statement
	135	\| goto_statement
	136	\| return_statement
	137	\| for_statement
	138	\| while_statement
	139	\| dowhile_statement
	140	\| break_statement
	141	\| continue_statement
	142	\| switch_statement
	143	// \| error ';'
	144	\| asmblock
	145	;
	146
	147	asmblock: ASM asmlines '}'
	148	;
	149
	150	asmlines: /* empty */
[523]	151	\| ASMLINE {trctx.out->Vputs(str($1));trctx.out->Vputc('\n');}
	152	\| asmlines ASMLINE {trctx.out->Vputs(str($2));trctx.out->Vputc('\n');}
[163]	153	;
	154
	155	goto_statement: GOTO IDENT ';'
	156	{
	157	#ifdef FRAMSCRIPT_GOTO
[375]	158	trctx.out->printf("jump :%s\n",str($2)); logPrintf("FramScriptCompiler","translate",LOG_WARN,"goto is not recommended"); trctx.emitLine();
[163]	159	#else
[245]	160	trctx.err->printf("goto is not supported\n");return 1;
[163]	161	#endif
	162	}
	163	;
	164
	165	return_statement: RETURN expr ';'
	166	{
	167	int offset;
[466]	168	if (trctx.functionstackpos==TranslatorContext::NOT_IN_FUNCTION)
[163]	169	offset=-trstack.currentPos();
	170	else
	171	offset=trctx.functionstackpos-trstack.currentPos();
	172	if (!offset)
	173	{
	174	if ($2.constant)
	175	trctx.out->printf("move %s,s0\nreturn\n",litstr($2));
	176	else
	177	{
	178	trctx.out->printf("move m[m0++],s0\nreturn\n");
	179	trstack.adjust(+1);
	180	}
	181	}
	182	else
	183	{
	184	if ($2.constant)
	185	{
	186	trctx.out->printf("add %d,m0\nmove %s,s0\nreturn\n",offset,litstr($2));
	187	trstack.adjust(offset);
	188	}
	189	else
	190	{
	191	trctx.out->printf("move s0,s%d\nadd %d,m0\nreturn\n",offset,offset);
	192	trstack.adjust(offset);
	193	}
	194	}
	195	}
	196	\| RETURN ';'
	197	{
	198	int offset;
[466]	199	if (trctx.functionstackpos==TranslatorContext::NOT_IN_FUNCTION)
[163]	200	offset=-trstack.currentPos();
	201	else
	202	offset=trctx.functionstackpos-trstack.currentPos();
[332]	203	trctx.emitLine();
[163]	204	if (!offset)
	205	trctx.out->printf("move invalid,s0\nreturn\n");
	206	else
	207	trctx.out->printf("add %d,m0\nmove invalid,s0\nreturn\n",offset);
	208	}
	209	;
	210
	211	vardeflist: vardef
	212	\| vardeflist ',' vardef
	213	;
	214
[477]	215	vardef: IDENT { trctx.emitLine(); if (!canAddName($1.getString(),VariableName)) return 1; trstack.addVariable($1.getString()); trctx.out->printf("push invalid\n"); }
	216	\| IDENT '=' stackexpr { trctx.emitLine(); if (!canAddName($1.getString(),VariableName)) return 1; trstack.adjust(1); trstack.addVariable($1.getString());}
[163]	217	;
	218
[477]	219	constdeflist: constdef
	220	\| constdeflist ',' constdef
	221	;
	222
	223	constdef: IDENT '=' expr { trctx.emitLine(); if (!canAddName($1.getString(),ConstName)) return 1; if (!$3.constant) {trctx.err->printf("const expression must be constant");return 1;} trstack.addConstant($1.getString(),$3); }
	224	;
	225
[163]	226	globaldeflist: globaldef
	227	\| globaldeflist ',' globaldef
	228	;
	229
[477]	230	globaldef: IDENT { if (!canAddName($1.getString(),GlobalName)) return 1; trstack.globals.add($1.getString(),0); trctx.out->printf("global %s\n",str($1));}
[163]	231	;
	232
	233	funparam: IDENT { trstack.addVariable($1.getString()); };
	234
	235	paramlist: /* empty */ {$$.setInt(0); }
	236	\| funparam {$$.setInt(1); }
	237	\| paramlist ',' funparam {$$.setInt($1.getInt()+1);}
	238	;
	239
	240	funnamelist:
	241	IDENT {outFunName($1);}
	242	\| funnamelist ',' IDENT {outFunName($3);}
	243	;
	244
	245	functiondef: FUNCTION funnamelist
	246	{
[332]	247	trctx.emitLine();
[163]	248	int pos=trstack.currentPos();
	249	$$.setInt(pos);
[466]	250	if (trctx.functionstackpos!=TranslatorContext::NOT_IN_FUNCTION)
[245]	251	{trctx.err->printf("functions cannot be nested\n");return 1;}
[466]	252	trctx.beforefunctionstackpos=trstack.currentPos();
[163]	253	}
	254	'(' paramlist ')'
	255	{
	256	trctx.functionstackpos=trstack.currentPos();
	257	}
	258	blok
	259	{trctx.out->printf("move invalid,s0\nreturn\n");
	260	int pos=$3.getInt();
	261	trstack.dropToPos(pos);
[466]	262	trctx.functionstackpos=TranslatorContext::NOT_IN_FUNCTION;
	263	trctx.beforefunctionstackpos=TranslatorContext::NOT_IN_FUNCTION;
[163]	264	trctx.out->printf(":_skipfun_%d\n",trctx.functiontmplabel);
	265	trctx.functiontmplabel=-1;
[332]	266	trctx.emitLine();
[163]	267	};
	268
	269	break_statement: BREAK ';' {if (!doBreak(1)) return 1;}
	270	\| BREAK expr ';'
	271	{
[332]	272	trctx.emitLine();
[163]	273	if (!$2.constant)
[245]	274	{trctx.err->printf("break level must be a constant expression\n");return 1;}
[163]	275	int level=$2.getInt();
	276	if (level<1)
[245]	277	{trctx.err->printf("break level must be a positive integer\n");return 1;}
[163]	278	if (!doBreak(level)) return 1;
[332]	279	trctx.emitLine();
[163]	280	};
	281
	282	continue_statement: CONTINUE ';' {if (!doContinue(1)) return 1;}
	283	\| CONTINUE expr ';'
	284	{
	285	if (!$2.constant)
[245]	286	{trctx.err->printf("continue level must be a constant expression\n");return 1;}
[163]	287	int level=$2.getInt();
	288	if (level<1)
[245]	289	{trctx.err->printf("continue level must be a positive integer\n");return 1;}
[163]	290	if (!doContinue(level)) return 1;
[332]	291	trctx.emitLine();
[163]	292	};
	293
	294	while_statement: WHILE '('
[332]	295	{
	296	int c=trctx.labelcounter++; $$.setInt(c);
[163]	297	$$.stack=trstack.currentPos();
	298	trstack.loops.addLoop(c,$$.stack);
	299	trctx.out->printf(":_loop_%d\n",c);}
	300	expr ')'
	301	{
	302	int c=$3.getInt();
	303	warnTruthValue($4);
	304	if ($4.constant)
	305	{if (!$4.getInt()) trctx.out->printf("jump :_loop_end_%d\n",c);}
	306	else
	307	{
[332]	308	trctx.out->printf("if ~=,m[m0++],:_loop_end_%d\n",c,c);
[163]	309	trstack.adjust(+1);
	310	}
	311	}
	312	pseudoblok_statement
[332]	313	{
	314	trctx.out->printf("jump :_loop_%d\n:_loop_end_%d\n",$3.getInt(),$3.getInt());
[163]	315	trstack.adjust($3.stack-trstack.currentPos());
	316	trstack.loops.drop();
	317	}
	318	;
	319
	320	dowhile_statement: DO
[332]	321	{
	322	trctx.emitLine();
	323	int c=trctx.labelcounter++; $$.setInt(c);
[163]	324	$$.stack=trstack.currentPos();
	325	trstack.loops.addLoop(c,$$.stack);
	326	trctx.out->printf(":_loop_%d\n",c);} //2
	327
	328	pseudoblok_statement WHILE '(' expr ')'
	329
	330	{//8
	331	int c=$2.getInt();
	332	warnTruthValue($6);
	333	if ($6.constant)
	334	{if ($6.getInt()) trctx.out->printf("jump :_loop_%d\n",c);}
	335	else
	336	{
[332]	337	trctx.out->printf("if !~,m[m0++],:_loop_%d\n",c);
[163]	338	trstack.adjust(+1);
	339	}
	340	trctx.out->printf(":_loop_end_%d\n",c);
	341	trstack.adjust($2.stack-trstack.currentPos());
	342	trstack.loops.drop();
[332]	343	trctx.emitLine();
[163]	344	}
	345	;
	346
	347	switch_statement: SWITCH '('
[332]	348	{
	349	int c=trctx.labelcounter++; $1.setInt(c);
[163]	350	trstack.loops.addLoop(c,trstack.currentPos());}
	351	stackexpr ')'
[332]	352	{trctx.emitLine(); trctx.out->printf("dec m0\n"); trstack.adjust(-1);}
[163]	353	'{' inside_switch '}'
[332]	354	{
	355	trctx.emitLine();
	356	LoopInfo *li=trstack.loops.getLoop(0);
	357	trctx.out->printf(":_case_after_%d_%d\n"
	358	"add 2,m0\n"
	359	":_loop_end_%d\n",
	360	li->id,li->casecounter,
	361	li->id);
	362	trstack.adjust(+2);
	363	trstack.loops.drop();
	364	}
[163]	365	;
	366
	367	inside_switch: /* empty */
	368	\| case_label
	369	\| inside_switch case_label
	370	;
	371
	372	case_label: CASE expr ':'
[332]	373	{
	374	LoopInfo *li=trstack.loops.getLoop(0);
	375	if ($2.constant)
	376	trctx.out->printf("if s1,!=,%s,:_case_before_%d_%d\n",
	377	litstr($2),
	378	li->id,li->casecounter+1);
	379	else
	380	{
	381	trctx.out->printf("if s2,!=,m[m0++],:_case_before_%d_%d\n",
	382	li->id,li->casecounter+1);
	383	trstack.adjust(+1);
	384	}
	385	trctx.out->printf(":_case_after_%d_%d\n",
	386	li->id,li->casecounter);
[163]	387	int pos=trstack.currentPos(); $$.setInt(pos);
	388	}
	389	recurcode
	390	{
[332]	391	trctx.emitLine();
	392	LoopInfo *li=trstack.loops.getLoop(0);
[163]	393	int pos=$4.getInt();
	394	if (pos!=trstack.currentPos()) trctx.out->printf("add %d,m0\n",pos-trstack.currentPos());
	395	trstack.dropToPos(pos);
[332]	396	li->casecounter++;
	397	trctx.out->printf("jump :_case_after_%d_%d\n"
	398	":_case_before_%d_%d\n",
	399	li->id,li->casecounter,
	400	li->id,li->casecounter);
[163]	401	}
[332]	402	\| DEFAULT ':'
	403	{
	404	LoopInfo *li=trstack.loops.getLoop(0);
	405	trctx.out->printf(":_case_after_%d_%d\n",li->id,li->casecounter);
	406	}
	407	recurcode
	408	{
	409	LoopInfo *li=trstack.loops.getLoop(0);
	410	li->casecounter++;
	411	}
[163]	412	;
	413
	414	newvar_or_expr:
	415	VAR IDENT { $$.setInt(trstack.addVariable($2.getString())); trctx.out->printf("push invalid\n"); $$.ident=true; $$.var=true; }
	416
	417	\|
	418	VAR IDENT '=' stackexpr
	419	{
	420	//trctx.out->printf("# VAR IDENT '=' stackexpr pos=%d\n",trstack.currentPos());
	421	trstack.adjust(+1);
	422	$$.setInt(trstack.addVariable($2.getString()));
	423	$$.ident=true; $$.var=true;
	424	}
	425
	426	\|
	427	expr_special_ident
	428	{
	429	$$=$1;
	430	}
	431
	432	\| //nic
	433	{
	434	$$.setInt(1); $$.assign=false; $$.ident=false; $$.var=false; $$.constant=true;
	435	}
	436	;
	437
	438	expr_or_objname:
	439	expr { $$=$1; $$.objname=false; }
	440	\|
	441	OBJNAME { $$.setString($1.getString()); $$.objname=true; }
	442	;
	443
	444	for_statement_begin: FOR '('
	445	{
	446	int c=trctx.labelcounter++; $$.counter=c; $$.stack=trstack.currentPos();
	447	}
	448	newvar_or_expr
	449	{
	450	$$=$4; $$.counter=$3.counter; $$.stack=$3.stack;
	451	};
	452
	453	for_statement:
	454
	455	/////////// for(in) ... ////////////
	456	for_statement_begin INNN
	457	{//3
	458	if (!$1.ident)
	459	{
	460	trctx.err->printf("for(... in ...) requires an variable\n");
	461	return 1;
	462	}
	463	int loc;
	464	if ($1.var) // for(var x[=expr] in
	465	$$.setInt($1.getInt());
	466	else
	467	{ // for(x in
	468	if (variableOk($$,$1,loc))
	469	$$.setInt(loc);
	470	else if (globalOk($1))
	471	{
	472	trctx.err->printf("global '%s' can't be iterating variable in for\n",str($1));
	473	return 1;
	474	}
	475	else
	476	{
	477	badVariable($$,$1);
	478	return 1;
	479	}
	480	}
	481	}
	482	expr_or_objname ')'
	483	{//6
[332]	484	trctx.emitLine();
[163]	485	if ($4.constant)
[477]	486	{
	487	logPrintf("", "", LOG_WARN, "%s can't be iterated",str($4));
	488	trctx.out->printf("jump :_loop_end_%d\n",$1.counter);
	489	}
	490	trstack.adjust(-1);
	491	trstack.loops.addLoop($1.counter,trstack.currentPos());
[163]	492	if ($4.objname)
[477]	493	trctx.out->printf("dec m0\nmove %s.iterator,m[m0]\n",$4.getString().c_str());
[163]	494	else
[489]	495	trctx.out->printf("move s%d,m1\ndec m0\nif ~=,m1,:_loop_end_%d\nmove [m1].\"iterator\",m[m0]\n",0,$1.counter);
[163]	496	// s0=iterator s1=obj (=obj.iterator)
	497	trctx.out->printf(":_loop1_%d\n",$1.counter);
	498	trctx.out->printf(":_loop_%d\n",$1.counter);
	499	trctx.out->printf("move s0,m1\nmove [m1].\"next\",m2\n");
[489]	500	trctx.out->printf("if ~=,m2,:_loop_end_%d\n",$1.counter);
[163]	501	trctx.out->printf("move [m1].\"value\",s%d\n",$3.getInt()-trstack.currentPos());
	502	}
	503	pseudoblok_statement
	504	{
	505	trctx.out->printf("jump :_loop1_%d\n",$1.counter);
	506	trctx.out->printf(":_loop_end_%d\n",$1.counter);
	507	trstack.loops.drop();
	508	if ($1.stack != trstack.currentPos())
	509	trctx.out->printf("add %d,m0\n",$1.stack-trstack.currentPos());
	510	trstack.adjust($1.stack-trstack.currentPos());
	511	}
	512
	513	\|
	514
	515	/////////// for(;;) ... ////////////
	516	for_statement_begin ';'
	517	{ //3
[332]	518	trctx.emitLine();
[163]	519	//trctx.out->printf("# for_statement_begin pos=%d ident=%d var=%d\n",trstack.currentPos(),$1.ident,$1.var);
	520	if ((!$1.var) && ($1.ident))
	521	{ // for(x;
	522	int loc;
	523	if ((!variableOk($$,$1,loc)) \|\| (globalOk($1)))
	524	{
	525	badVariable($$,$1);
	526	return 1;
	527	}
	528	}
	529	if (!$1.constant && !$1.ident)
	530	{
	531	trctx.out->printf("inc m0\n");
	532	trstack.adjust(+1);
	533	}
	534	trstack.loops.addLoop($1.counter,trstack.currentPos());
	535	trctx.out->printf(":_loop1_%d\n",$1.counter);
	536	//trctx.out->printf("# expr#2\n");
	537	}
	538	expr_or_empty ';'
	539	{ //6
[332]	540	trctx.emitLine();
[163]	541	int c=$1.counter;
	542	warnTruthValue($4);
	543	if ($4.constant)
	544	{if (!$4.getInt()) trctx.out->printf("jump :_loop_end_%d\n",c);}
	545	else
	546	{
	547	trctx.out->printf("if m[m0++],==,0,:_loop_end_%d\n",c,c);
	548	trstack.adjust(+1);
	549	}
[382]	550	trctx.tmp="";
[163]	551	trctx.divertOut();
	552	//trctx.out->printf("# expr#3\n");
	553	}
	554	expr_or_empty ')'
	555	{ //9
[332]	556	trctx.emitLine();
[163]	557	if (!$7.constant) { trctx.out->printf("inc m0\n"); trstack.adjust(+1); }
	558	trctx.restoreOut();
[382]	559	$$.setString(trctx.tmp.c_str());
[163]	560	//trctx.out->printf("# pseudoblok_statement pos=%d\n",trstack.currentPos());
	561	}
	562	pseudoblok_statement
	563	{//11
	564	trctx.out->printf(":_loop_%d\n",$1.counter);
	565	LoopInfo* li=trstack.loops.getLoop(0);
	566	if (li->location != trstack.currentPos())
	567	trctx.out->printf("add %d,m0\n",li->location-trstack.currentPos());
	568	trctx.out->printf(str($9));
	569	if (li->location != trstack.currentPos())
	570	trctx.out->printf("sub %d,m0\n",li->location-trstack.currentPos());
	571	trctx.out->printf("jump :_loop1_%d\n:_loop_end_%d\n",$1.counter,$1.counter);
	572	if ($1.stack != trstack.currentPos())
	573	trctx.out->printf("add %d,m0\n",$1.stack-trstack.currentPos());
	574	trstack.adjust($1.stack-trstack.currentPos());
	575	trstack.loops.drop();
	576	}
	577	;
	578
	579	pseudoblok_statement:
[332]	580	{trctx.emitLine(); int pos=trstack.currentPos(); $$.setInt(pos);}
[163]	581	statement
	582	{
	583	int pos=$1.getInt();
	584	if (pos!=trstack.currentPos()) trctx.out->printf("add %d,m0\n",pos-trstack.currentPos());
	585	trstack.dropToPos(pos);
[332]	586	trctx.emitLine();
[163]	587	};
	588
	589	if_statement:
	590	if_condition pseudoblok_statement
	591	{
	592	if ($1.stack!=trstack.currentPos())
	593	trctx.out->printf("add %d,m0\n",$1.stack-trstack.currentPos());
	594	trstack.adjust(trstack.currentPos()-$1.stack);
	595	trctx.out->printf("jump :_if_end_%d\n:_if_else_%d\n",$1.getInt(),$1.getInt());
	596	}
	597	ELSE
	598	{trstack.adjust($1.stack-trstack.currentPos());}
	599	pseudoblok_statement
	600	{
	601	if ($1.stack!=trstack.currentPos())
	602	trctx.out->printf("add %d,m0\n",$1.stack-trstack.currentPos());
	603	trstack.adjust(trstack.currentPos()-$1.stack);
	604	trctx.out->printf(":_if_end_%d\n",$1.getInt());
	605	}
	606	\|
	607	if_condition pseudoblok_statement
	608	{
	609	if ($1.stack!=trstack.currentPos())
	610	trctx.out->printf("add %d,m0\n",$1.stack-trstack.currentPos());
	611	trstack.dropToPos($1.stack);
	612	trctx.out->printf(":_if_else_%d\n",$1.getInt());
	613	}
	614	;
	615
	616	if_condition: IF
[332]	617	{$$.stack=trstack.currentPos();trctx.emitLine();}
[163]	618
	619	'(' expr ')'
	620	{
[332]	621	trctx.emitLine();
[163]	622	int c=trctx.labelcounter++;
	623	$$.setInt(c);
	624	warnTruthValue($4);
	625	if ($4.constant)
	626	{
	627	if (!$4.getInt()) trctx.out->printf("jump :_if_else_%d\n",c);
	628	}
	629	else
	630	{
[332]	631	trctx.out->printf("if ~=,m[m0++],:_if_else_%d\n",c);
[163]	632	trstack.adjust(+1);
	633	}
	634	$$.stack=$2.stack;
	635	};
	636
	637	blok: '{'
	638	{ int pos=trstack.currentPos();
	639	$$.setInt(pos);
	640	}
	641	recurcode '}'
	642	{
	643	int pos=$2.getInt();
	644	if (pos!=trstack.currentPos()) trctx.out->printf("add %d,m0\n",pos-trstack.currentPos());
	645	trstack.dropToPos(pos);
	646	}
	647
	648	assign_op: ASSIGN_ADD {$$.setInt(0);}
	649	\| ASSIGN_SUB {$$.setInt(1);}
	650	\| ASSIGN_MUL {$$.setInt(2);}
	651	\| ASSIGN_DIV {$$.setInt(3);}
	652	\| ASSIGN_MOD {$$.setInt(4);}
	653
	654	plusminus: PLUSPLUS {$$.setInt(1);} \| MINUSMINUS {$$.setInt(0);}
	655
	656	expr: expr_special_ident
	657	{
	658	//trctx.out->printf("# expr: ident=%d str=%s\n",$1.ident,(const char*)$1.getString());
	659	if ($1.ident)
	660	{
	661	if (evalVariable($$,$1))
	662	$$.constant=false;
	663	else
	664	return 1;
	665	}
	666	else
	667	{$$=$1; $$.ident=false;}
[332]	668	trctx.emitLine();
[163]	669	}
	670	;
	671
[345]	672	stackexpr: expr {if ($1.constant) {trctx.out->printf("push %s\n",litstr($1)); trstack.adjust(-1); $$.constant=0;} }
	673
[163]	674	expr_or_empty:
	675	expr {$$=$1;}
	676
	677	\| //nic
	678	{ $$.setInt(1); $$.assign=false; $$.constant=true; $$.ident=false; $$.ident=false; }
	679	;
	680
	681	expr_special_ident: CONSTANT { $$=$1; $$.constant=1; $$.ident=0; }
	682
[477]	683	\| IDENT {
	684	ExtValue c;
	685	if (trstack.getConstant($1.getString(),c))
	686	{ $$=c; $$.constant=1; $$.ident=0; }
	687	else
	688	{ $$.ident=true; $$.setString($1.getString()); }
	689	}
[163]	690
	691	\| OBJNAME ':' IDENT {$$.constant=0; $$.ident=0;
[348]	692	trctx.out->printf("push %s:%s\n",$1.getString().c_str(),
	693	$3.getString().c_str());
[163]	694	trstack.adjust(-1);
	695	}
	696	\| plusminus IDENT
	697	{
[332]	698	trctx.emitLine();
[163]	699	$$.ident=0;
	700	int loc; if (variableOk($$,$2,loc))
	701	{ loc-=trstack.currentPos();
	702	trctx.out->printf("%s s%d\npush s%d\n",$1.getInt()?"inc":"dec",loc,loc);
	703	trstack.adjust(-1);}
	704	else if (globalOk($2))
	705	{ trctx.out->printf("%s @%s\npush @%s\n",$1.getInt()?"inc":"dec",str($2),str($2));
	706	trstack.adjust(-1);}
	707	else {badVariable($$,$2); return 1;}
	708	}
	709
	710	\| IDENT plusminus
	711	{
[332]	712	trctx.emitLine();
[163]	713	$$.ident=0;
	714	int loc; if (variableOk($$,$1,loc))
	715	{loc-=trstack.currentPos(); trctx.out->printf("push s%d\n%s s%d\n",loc,$2.getInt()?"inc":"dec",loc+1);
	716	trstack.adjust(-1);}
	717	else if (globalOk($1))
[348]	718	{ trctx.out->printf("push @%s\n%s @%s\n",$1.getString().c_str(),
	719	$2.getInt()?"inc":"dec",$1.getString().c_str());
[163]	720	trstack.adjust(-1);}
	721	else {badVariable($$,$1); return 1;}
	722	}
	723
[332]	724	\| IDENT assign_op expr { trctx.emitLine(); $$.ident=0;
[163]	725	if (!handleAssignOp($$,$1,$3,assign_op_names[$2.getInt()]))
	726	if (globalOk($1)) {SString t="@"; t+=$1.getString();
[348]	727	handleAssignOp2($$,t.c_str(),$3,assign_op_names[$2.getInt()],0,1);}
[163]	728	else { badVariable($$,$1); return 1; }
	729	}
	730
[332]	731	\| TYPEOF '(' expr ')' { trctx.emitLine(); $$.ident=0;
	732	if ($3.constant)
	733	{$$.constant=1; $$=$3.getExtType();}
[163]	734	else
	735	{trctx.out->printf("type s0,s0\n");}
	736	}
[333]	737	\| INT_TYPE '(' expr ')' { trctx.emitLine(); $$.ident=0;
[332]	738	if ($3.constant)
	739	{$$.constant=1; $$=ExtValue($3.getInt());}
	740	else
	741	{trctx.out->printf("conv 1,s0\n");}
	742	}
[333]	743	\| FLOAT_TYPE '(' expr ')' { trctx.emitLine(); $$.ident=0;
[332]	744	if ($3.constant)
	745	{$$.constant=1; $$=ExtValue($3.getDouble());}
	746	else
	747	{trctx.out->printf("conv 2,s0\n");}
	748	}
[333]	749	\| STRING_TYPE '(' expr ')' { trctx.emitLine(); $$.ident=0;
[332]	750	if ($3.constant)
	751	{$$.constant=1; $$=ExtValue($3.getString());}
	752	else
	753	{trctx.out->printf("conv 3,s0\n");}
	754	}
[163]	755
[332]	756	\| expr '+' expr { handleTwoArg($$,$1,$3,'+',"add",0,1); }
	757	\| expr '-' expr { handleTwoArg($$,$1,$3,'-',"sub",0,0); }
	758	\| expr '' expr { handleTwoArg($$,$1,$3,'',"mul",0,1); }
	759	\| expr '/' expr { handleTwoArg($$,$1,$3,'/',"div",0,0); }
	760	\| expr '&' expr { handleTwoArg($$,$1,$3,'&',"and",0,0); }
	761	\| expr '\|' expr { handleTwoArg($$,$1,$3,'\|',"or",0,0); }
	762	\| expr '%' expr { handleTwoArg($$,$1,$3,'%',"mod",0,0); }
[163]	763
[332]	764	\| expr LOGIC_AND
	765	{
	766	// a && b:
	767	// push a
	768	// if (a)
	769	// pop; goto and_b
	770	// else
	771	// pop; push 0; goto and_end
	772	// and_b:
	773	// push b
	774	// and_end:
	775	trctx.emitLine();
	776	// trctx.out->printf("\n####### logic AND\n");
	777	int c=trctx.labelcounter++;
	778	$$.setInt(c);
	779	if ($1.constant)
	780	{
[333]	781	ExtValue::CompareResult cond=$1.compare(ExtValue::zero());
	782	if (resultIsRelaxedEqual(cond))
[332]	783	{
	784	$1.counter=0;
	785	// no stack adjust - next tokens are processed in a different context
	786	trctx.out->printf("push 0\njump :_and_end_%d\n",c);
	787	}
	788	else
	789	$1.counter=1;
	790	}
	791	else
	792	{
	793	trstack.adjust(+1); // stack as if (a==true), b expr is processed
	794	trctx.out->printf("if !~,m[m0++],:_and_b_%d\n"
	795	"push 0\n"
	796	"jump :_and_end_%d\n"
	797	":_and_b_%d\n"
	798	,c,c,c);
	799	}
	800	}
	801	expr
	802	{
	803	$$.ident=false;
	804	$$.constant=0;
	805	if ($4.constant)
	806	{
	807	if (!($1.constant && $1.counter==0))
	808	{
[333]	809	ExtValue::CompareResult cond=$4.compare(ExtValue::zero());
	810	bool value=!resultIsRelaxedEqual(cond);
[332]	811	trstack.adjust(-1);
	812	trctx.out->printf("push %d\n",value);
	813	}
	814	}
	815	trctx.out->printf(":_and_end_%d\n",$3.getInt());
	816	// trctx.out->printf("#################\n\n");
	817	}
	818
	819	\| expr LOGIC_OR
	820	{
	821	// a \|\| b:
	822	// push a
	823	// if (!a)
	824	// pop; goto and_b
	825	// else
	826	// pop; push 1; goto and_end
	827	// and_b:
	828	// push b
	829	// and_end:
	830	trctx.emitLine();
	831	// trctx.out->printf("\n####### logic AND\n");
	832	int c=trctx.labelcounter++;
	833	$$.setInt(c);
	834	if ($1.constant)
	835	{
[333]	836	ExtValue::CompareResult cond=$1.compare(ExtValue::zero());
	837	if (!resultIsRelaxedEqual(cond))
[332]	838	{
	839	$1.counter=1;
	840	// no stack adjust - next tokens are processed in a different context
	841	trctx.out->printf("push 1\njump :_or_end_%d\n",c);
	842	}
	843	else
	844	$1.counter=0;
	845	}
	846	else
	847	{
	848	trstack.adjust(+1); // stack for (a==false)
	849	trctx.out->printf("if ~=,m[m0++],:_or_b_%d\n"
	850	"push 1\n"
	851	"jump :_or_end_%d\n"
	852	":_or_b_%d\n"
	853	,c,c,c);
	854	}
	855	}
	856	expr
	857	{
	858	$$.ident=false;
	859	$$.constant=0;
	860	if ($4.constant)
	861	{
	862	if (!($1.constant && $1.counter==1))
	863	{
[333]	864	ExtValue::CompareResult cond=$4.compare(ExtValue::zero());
	865	bool value=!resultIsRelaxedEqual(cond);
[332]	866	trstack.adjust(-1);
	867	trctx.out->printf("push %d\n",value);
	868	}
	869	}
	870	trctx.out->printf(":_or_end_%d\n",$3.getInt());
	871	// trctx.out->printf("#################\n\n");
	872	}
	873
	874
	875	\| expr LSHIFT expr { handleTwoArg($$,$1,$3,LSHIFT,"shift",0,0); }
	876	\| expr RSHIFT expr { handleTwoArg($$,$1,$3,RSHIFT,"shift",1,0); }
	877	\| expr EQUAL expr { if (!handleCompare($$,$1,$3,ExtValue::CmpEQ,"==")) return 1; }
	878	\| expr NOT_EQUAL expr { if (!handleCompare($$,$1,$3,ExtValue::CmpNE,"!=")) return 1; }
	879	\| expr GEQUAL expr { if (!handleCompare($$,$1,$3,ExtValue::CmpGE,">=")) return 1; }
	880	\| expr LEQUAL expr { if (!handleCompare($$,$1,$3,ExtValue::CmpLE,"<=")) return 1; }
	881	\| expr '>' expr { if (!handleCompare($$,$1,$3,ExtValue::CmpGT,">")) return 1; }
	882	\| expr '<' expr { if (!handleCompare($$,$1,$3,ExtValue::CmpLT,"<")) return 1; }
	883
[163]	884	\| '!' expr {
[332]	885	trctx.emitLine(); $$.assign=$2.assign; $$.parens=0; $$.ident=0;
[163]	886	if ($2.constant)
[333]	887	{$$.constant=1; ExtValue::CompareResult res=$2.compare(ExtValue((paInt)0)); $$.setInt(resultIsRelaxedEqual(res));}
[163]	888	else
[332]	889	{trctx.out->printf("setif ~=,s0,s0\n");}
[163]	890	}
	891
	892	\| '-' expr %prec NEG {
[332]	893	trctx.emitLine(); $$.assign=$2.assign; $$.parens=0; $$.ident=0;
[163]	894	if ($2.constant)
	895	{ $$.constant=$2.constant;
	896	if ($2.type==TInt) $$.setInt(-$2.getInt());
	897	else if ($2.type==TDouble) $$.setDouble(-$2.getDouble());
	898	else $$=$2;
	899	}
	900	else
	901	{
	902	$$.constant=0; SString t="-"; t+=$2.getString(); $$.setString(t);
	903	trctx.out->printf("mul -1,s0\n");
	904	}
	905	}
	906
[332]	907	\| '(' expr ')' { trctx.emitLine(); $$ = $2; $$.assign=$2.assign?(!$2.parens):0; $$.parens=1; $$.ident=0; }
[163]	908
	909	\| OBJNAME '.' member {
[332]	910	trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+="."; t+=$3.getString(); $$.setString(t);
[163]	911	if ($3.constant)
	912	{
	913	trctx.out->printf("push %s.%s\n",str($1),str($3)); trstack.adjust(-1);
	914	}
	915	else
	916	{
	917	trctx.out->printf("move s0,m1\nmove %s.[m1],s0\n",str($1));
	918	}
	919	}
	920
	921	\| OBJNAME '.' member assign_op expr
[332]	922	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+="."; t+=$3.getString(); $$.setString(t);
[163]	923	if ($3.constant)
	924	{
[348]	925	handleAssignOp2($$,t.c_str(),$5,assign_op_names[$4.getInt()],0,1);
[163]	926	}
	927	else
	928	{
	929	int sp=($5.constant)?0:1;
	930	t=$1.getString();t+=".[m1]";
	931	trctx.out->printf("move s0,m1\n",str($1));
[348]	932	handleAssignOp2($$,t.c_str(),$5,assign_op_names[$4.getInt()],sp,0);
[163]	933	if (sp) {trctx.out->printf("inc m0\n"); trstack.adjust(1);}
	934	}
	935	}
	936
	937	\| plusminus OBJNAME '.' member {
[332]	938	trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$2.getString(); t+="."; t+=$4.getString(); $$.setString(t);
[163]	939	if ($4.constant)
	940	{
	941	trctx.out->printf("%s %s.%s\npush %s.%s\n",$1.getInt()?"inc":"dec",
	942	str($2),str($4),str($2),str($4));
	943	trstack.adjust(-1);
	944	}
	945	else
	946	{
	947	trctx.out->printf("move s0,m1\n%s %s.[m1]\nmove %s.[m1],s0\n",
	948	$1.getInt()?"inc":"dec",str($2),str($2));
	949	}
	950	}
	951
	952	\| OBJNAME '.' member plusminus {
[332]	953	trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+="."; t+=$3.getString(); $$.setString(t);
[163]	954	if ($3.constant)
	955	{
	956	trctx.out->printf("push %s.%s\n%s %s.%s\n",
	957	str($1),str($3),$4.getInt()?"inc":"dec",str($1),str($3));
	958	trstack.adjust(-1);
	959	}
	960	else
	961	{
	962	trctx.out->printf("move s0,m1\nmove %s.[m1],s0\n%s %s.[m1]\n",
	963	str($1),$4.getInt()?"inc":"dec",str($1));
	964	}
	965	}
	966
	967	\| OBJNAME '.' '*' {
[332]	968	trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+=".*"; $$.setString(t);
[163]	969	trctx.out->printf("push %s.*\n",str($1)); trstack.adjust(-1);
	970	}
	971
	972
	973	\| OBJNAME '.' member '=' expr {
[332]	974	trctx.emitLine(); $$=$5; $$.assign=1; $$.parens=0; $$.ident=0;
[163]	975	if ($3.constant)
	976	{
	977	if ($$.constant)
	978	trctx.out->printf("move %s,%s.%s\n",litstr($5),str($1),str($3));
	979	else
	980	trctx.out->printf("move s0,%s.%s\n",str($1),str($3));
	981	}
	982	else
	983	{
	984	if ($$.constant)
	985	{
	986	trctx.out->printf("move m[m0++],m1\nmove %s,%s.[m1]\n",
	987	litstr($5),str($1));
	988	trstack.adjust(1);
	989	}
	990	else
	991	{
	992	trctx.out->printf("move s1,m1\nmove m[m0++],s0\nmove s0,%s.[m1]\n",
	993	str($1));
	994	trstack.adjust(1);
	995	}
	996	}
	997	}
	998
	999	\| OBJNAME '.' member '(' arguments ')'
	1000	{
[332]	1001	trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+="."; t+=$3.getString(); $$.setString(t);
[163]	1002	int adj=0,adj2=0;
	1003	if ($5.getInt()==0)
	1004	{trctx.out->printf("dec m0\n");trstack.adjust(-1);adj=1;}
	1005	if ($3.constant)
	1006	trctx.out->printf("call %s.%s\n",str($1),str($3));
	1007	else
	1008	{
	1009	trctx.out->printf("move s%d,m1\ncall %s.[m1]\n",$5.getInt()+adj,str($1));
	1010	adj2=1;
	1011	}
	1012	adj2+=$5.getInt()-1+adj;
	1013	if (adj2>0)
	1014	{
	1015	trctx.out->printf("add %d,m0\nxmove s%d,s0\n",adj2,-adj2);
	1016	trstack.adjust(adj2);
	1017	}
	1018	}
	1019
	1020	\| CALL expr '(' arguments ')'
[332]	1021	{ trctx.emitLine(); $$.constant=0; $$.ident=0; $$.setString($2.getString());
[163]	1022	short adj=0;
	1023	if ($4.getInt()==0)
	1024	{trctx.out->printf("dec m0\n");trstack.adjust(-1);adj=1;}
	1025	if ($2.constant)
	1026	trctx.out->printf("call %s\n",litstr($2));
	1027	else
	1028	trctx.out->printf("call s%d\n",$4.getInt()+adj);
	1029	if (($4.getInt()+adj) > 0)
	1030	{
	1031	trctx.out->printf("add %d,m0\nxmove s%d,s0\n",$4.getInt()+adj,-($4.getInt()+adj));
	1032	trstack.adjust($4.getInt()+adj);
	1033	}
	1034	}
	1035
	1036	\| FUNCTION IDENT
[332]	1037	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=":"; t+=$1.getString(); $$.setString(t);
[348]	1038	trctx.out->printf("push :%s\n",$2.getString().c_str());
[163]	1039	trstack.adjust(-1);
	1040	}
	1041
[341]	1042	\| stackexpr '.' member
[332]	1043	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+="."; t+=$3.getString(); $$.setString(t);
[163]	1044	if ($3.constant)
	1045	trctx.out->printf("move s0,m1\nmove [m1].%s,s0\n",str($3));
	1046	else
	1047	// trctx.out->printf("move s1,m1\nmove m[m0++],m2\nmove [m1].[m2],s0\n");
	1048	{trctx.out->printf("move s1,m1\nmove m[m0++],m2\nmove [m1].[m2],s0\n");trstack.adjust(1);}
	1049	}
	1050
[477]	1051	\| stackexpr ARROW IDENT /* shortcut: expr.get("ident") */
	1052	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+="->"; t+=$3.getString(); $$.setString(t);
	1053	trctx.out->printf("move s0,m1\ncall [m1].\"get\",%s\n",litstr($3));
	1054	}
	1055
	1056	\| OBJNAME ARROW IDENT /* shortcut: StaticObject.get("ident") */
	1057	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+="->"; t+=$3.getString(); $$.setString(t);
	1058	trctx.out->printf("dec m0\ncall %s.\"get\",%s\n",$1.getString().c_str(),litstr($3)); trstack.adjust(-1);
	1059	}
	1060
	1061	\| plusminus stackexpr ARROW IDENT /* shortcut: expr.set("ident",expr.get("ident")+/-1) */
	1062	{ trctx.emitLine(); $$.constant=0; $$.ident=0; $$.setString("");
	1063	trctx.out->printf("move s0,m1\ncall [m1].\"get\",%s\n"
	1064	"move s0,m2\n%s m2\n"
	1065	"call [m1].\"set\",%s,m2\nmove m2,s0\n",
	1066	litstr($4),$1.getInt()?"inc":"dec",litstr($4));
	1067	}
	1068
	1069	\| stackexpr ARROW IDENT plusminus /* shortcut: expr.set("ident",expr.get("ident")+/-1) */
	1070	{ trctx.emitLine(); $$.constant=0; $$.ident=0; $$.setString("");
	1071	trctx.out->printf("move s0,m1\ncall [m1].\"get\",%s\n"
	1072	"move s0,m2\n%s s0\n"
	1073	"call [m1].\"set\",%s,s0\nmove m2,s0\n",
	1074	litstr($3),$4.getInt()?"inc":"dec",litstr($3));
	1075	}
	1076
	1077	\| stackexpr ARROW IDENT assign_op expr /* shortcut: expr1.set("ident",expr1.get("ident") +-/ expr2) /
	1078	{ trctx.emitLine(); $$.constant=0; $$.ident=0; $$.setString("");
	1079	if ($5.constant)
	1080	trctx.out->printf("move s0,m1\ncall [m1].\"get\",%s\n"
	1081	"move s0,m2\n%s %s,m2\n"
	1082	"call [m1].\"set\",%s,m2\nmove m2,s0\n",
	1083	litstr($3),assign_op_names[$4.getInt()],litstr($5),litstr($3));
	1084	else
	1085	{
	1086	trctx.out->printf("move s0,m3\nmove s1,m1\ncall [m1].\"get\",%s\n"
	1087	"move s0,m2\n%s m3,m2\n"
	1088	"call [m1].\"set\",%s,m2\ninc m0\nmove m2,s0\n",
	1089	litstr($3),assign_op_names[$4.getInt()],litstr($3));
	1090	trstack.adjust(1);
	1091	}
	1092	}
	1093
[341]	1094	\| plusminus stackexpr '.' member
[332]	1095	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$2.getString(); t+="."; t+=$4.getString(); $$.setString(t);
[163]	1096	if ($4.constant)
	1097	trctx.out->printf("move s0,m1\n%s [m1].%s\nmove [m1].%s,s0\n",
	1098	$1.getInt()?"inc":"dec",str($4),str($4));
	1099	else
	1100	// trctx.out->printf("move s1,m1\nmove m[m0++],m2\nmove [m1].[m2],s0\n");
	1101	{trctx.out->printf("move s1,m1\nmove m[m0++],m2\n%s [m1].[m2]\nmove [m1].[m2],s0\n",
	1102	$1.getInt()?"inc":"dec");trstack.adjust(1);}
	1103	}
	1104
[341]	1105	\| stackexpr '.' member plusminus
[332]	1106	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+="."; t+=$3.getString(); $$.setString(t);
[163]	1107	if ($3.constant)
	1108	trctx.out->printf("move s0,m1\nmove [m1].%s,s0\n%s [m1].%s\n",
	1109	str($3),$4.getInt()?"inc":"dec",str($3));
	1110	else
	1111	// trctx.out->printf("move s1,m1\nmove m[m0++],m2\nmove [m1].[m2],s0\n");
	1112	{trctx.out->printf("move s1,m1\nmove m[m0++],m2\nmove [m1].[m2],s0\n%s [m1].[m2]\n",
	1113	$4.getInt()?"inc":"dec");trstack.adjust(1);}
	1114	}
	1115
[341]	1116	\| stackexpr '.' member assign_op expr
[332]	1117	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+="."; t+=$3.getString(); $$.setString(t);
[163]	1118	if ($3.constant)
	1119	{
	1120	int sp;
	1121	if ($5.constant)
	1122	{sp=0; trctx.out->printf("move s0,m1\n");}
	1123	else
	1124	{sp=1; trctx.out->printf("move s1,m1\n");}
	1125	t="[m1]."; t+=str($3);
[348]	1126	handleAssignOp2($$,t.c_str(),$5,assign_op_names[$4.getInt()],sp,0);
[163]	1127	if (sp) {trctx.out->printf("inc m0\n");trstack.adjust(1);}
	1128	}
	1129	else
	1130	{
	1131	int sp;
	1132	char *t;
	1133	if ($5.constant)
	1134	{sp=1; t="move s1,m1\nmove s0,m2\n";}
	1135	else
	1136	{sp=2; t="move s2,m1\nmove s1,m2\n";}
	1137	trctx.out->printf(t);
	1138	handleAssignOp2($$,"[m1].[m2]",$5,assign_op_names[$4.getInt()],sp,0);
	1139	trctx.out->printf("add %d,m0\n",sp);
	1140	trstack.adjust(sp);
	1141	}
	1142	}
	1143
[341]	1144	\| stackexpr '.' member '=' stackexpr
[332]	1145	{ trctx.emitLine(); $$=$5; $$.assign=1; $$.parens=0; $$.ident=0;
[163]	1146	if ($3.constant)
	1147	{
	1148	trctx.out->printf("move s1,m1\nmove m[m0++],s0\nmove s0,[m1].%s\n",str($3));
	1149	trstack.adjust(1);
	1150	}
	1151	else
	1152	{
	1153	trctx.out->printf("move s2,m1\nmove s1,m2\nmove s0,[m1].[m2]\nadd 2,m0\nmove s-2,s0\n");
	1154	trstack.adjust(2);
	1155	}
	1156	}
	1157
[341]	1158	\| stackexpr '.' member '(' arguments ')'
[332]	1159	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+="."; t+=$3.getString(); $$.setString(t);
[163]	1160	int adj=0;
	1161	if ($5.getInt()==0)
	1162	{trctx.out->printf("dec m0\n");trstack.adjust(-1);adj=1;}
	1163	if ($3.constant)
	1164	{
	1165	trctx.out->printf("move s%d,m1\ncall [m1].%s\n",$5.getInt()+adj,str($3));
	1166	adj+=1;
	1167	}
	1168	else
	1169	{
	1170	trctx.out->printf("move s%d,m2\nmove s%d,m1\ncall [m2].[m1]\n",
	1171	$5.getInt()+adj+1,$5.getInt()+adj);
	1172	adj+=2;
	1173	}
	1174	if (($5.getInt()+adj) > 1)
	1175	{
	1176	trctx.out->printf("add %d,m0\nxmove s%d,s0\n",$5.getInt()-1+adj,-($5.getInt()-1+adj));
	1177	trstack.adjust($5.getInt()-1+adj);
	1178	}
	1179	}
	1180
[341]	1181	\| stackexpr '[' expr ']' '=' expr // shortcut: expr.set(expr,expr)
[332]	1182	{ trctx.emitLine(); $$=$6; $$.assign=1; $$.parens=0; $$.ident=0;
[163]	1183	if ($3.constant)
	1184	{
	1185	if ($6.constant)
[538]	1186	{trctx.out->printf("move s0,m1\ncall [m1].\"set\",%s,%s\ninc m0\n",litstr($3),litstr($6));trstack.adjust(+1);}
[163]	1187	else
[538]	1188	{trctx.out->printf("move s1,m1\npush s0\npush s0\nmove %s,s1\ncall [m1].\"set\"\nadd 3,m0\nmove s-1,s0\n",litstr($3));trstack.adjust(+1);}
[163]	1189	}
	1190	else
	1191	{
	1192	if ($6.constant)
	1193	{trctx.out->printf("move s1,m1\npush %s\ncall [m1].\"set\"\nadd 3,m0\n",litstr($6)); trstack.adjust(+2);}
	1194	else
[538]	1195	{trctx.out->printf("move s2,m1\npush s1\npush s1\ncall [m1].\"set\"\nadd 4,m0\nmove s-2,s0\n"); trstack.adjust(+2);}
[163]	1196	}
	1197	}
	1198
[477]	1199	\| plusminus stackexpr '[' expr ']' /* shortcut: o.set(index,o.get(index)+/-1) */
	1200	{ trctx.emitLine(); $$.constant=0; $$.ident=0; $$.setString("");
	1201	if ($4.constant)
	1202	trctx.out->printf("move s0,m1\ncall [m1].\"get\",%s\n"
	1203	"move s0,m2\n%s m2\n"
	1204	"call [m1].\"set\",%s,m2\nmove m2,s0\n",
	1205	litstr($4),$1.getInt()?"inc":"dec",litstr($4));
	1206	else
	1207	{
	1208	trctx.out->printf("move s0,m3\nmove s1,m1\ncall [m1].\"get\",m3\n"
	1209	"move s0,m2\n%s m2\n"
	1210	"call [m1].\"set\",m3,m2\ninc m0\nmove m2,s0\n",
	1211	$1.getInt()?"inc":"dec");
	1212	trstack.adjust(1);
	1213	}
	1214	}
	1215
	1216	\| stackexpr '[' expr ']' plusminus /* shortcut: o.set(index,o.get(index)+/-1) */
	1217	{ trctx.emitLine(); $$.constant=0; $$.ident=0; $$.setString("");
	1218	if ($3.constant)
	1219	trctx.out->printf("move s0,m1\ncall [m1].\"get\",%s\n"
	1220	"move s0,m2\n%s s0\n"
	1221	"call [m1].\"set\",%s,s0\nmove m2,s0\n",
	1222	litstr($3),$5.getInt()?"inc":"dec",litstr($3));
	1223	else
	1224	{
	1225	trctx.out->printf("move s0,m3\nmove s1,m1\ncall [m1].\"get\",m3\n"
	1226	"move s0,m2\n%s s0\n"
	1227	"call [m1].\"set\",m3,s0\ninc m0\nmove m2,s0\n",
	1228	$5.getInt()?"inc":"dec");
	1229	trstack.adjust(1);
	1230	}
	1231	}
	1232
	1233	\| stackexpr '[' expr ']' assign_op expr /* shortcut: o.set(index,o.get(index) +-/ expr) /
	1234	{ trctx.emitLine(); $$.constant=0; $$.ident=0; $$.setString("");
	1235	if ($6.constant)
	1236	{
	1237	if ($3.constant)
	1238	trctx.out->printf("move s0,m1\ncall [m1].\"get\",%s\n"
	1239	"move s0,m2\n%s %s,m2\n"
	1240	"call [m1].\"set\",%s,m2\nmove m2,s0\n",
	1241	litstr($3),assign_op_names[$5.getInt()],litstr($6),litstr($3));
	1242	else
	1243	{
	1244	trctx.out->printf("move s0,m3\nmove s1,m1\ncall [m1].\"get\",m3\n"
	1245	"move s0,m2\n%s %s,m2\n"
	1246	"call [m1].\"set\",m3,m2\ninc m0\nmove m2,s0\n",
	1247	assign_op_names[$5.getInt()],litstr($6));
	1248	trstack.adjust(1);
	1249	}
	1250	}
	1251	else
	1252	{
	1253	if ($3.constant)
	1254	{
	1255	trctx.out->printf("move s0,m3\nmove s1,m1\ncall [m1].\"get\",%s\n"
	1256	"move s0,m2\n%s m3,m2\n"
	1257	"call [m1].\"set\",%s,m2\ninc m0\nmove m2,s0\n",
	1258	litstr($3),assign_op_names[$5.getInt()],litstr($3));
	1259	trstack.adjust(1);
	1260	}
	1261	else
	1262	{
	1263	trctx.out->printf("move s0,m3\nmove s1,m4\nmove s2,m1\ncall [m1].\"get\",m4\n"
	1264	"move s0,m2\n%s m3,m2\n"
	1265	"call [m1].\"set\",m4,m2\nadd 2,m0\nmove m2,s0\n",
	1266	assign_op_names[$5.getInt()]);
	1267	trstack.adjust(2);
	1268	}
	1269	}
	1270	}
	1271
	1272
	1273	\| stackexpr ARROW IDENT '=' expr /* shortcut: expr.set("ident",expr) */
	1274	{ trctx.emitLine(); $$=$5; $$.assign=1; $$.ident=0; $$.parens=0;
	1275	if ($5.constant)
	1276	{trctx.out->printf("move s0,m1\ncall [m1].\"set\",%s,%s\ninc m0\n",litstr($3),litstr($5));$$=$5;trstack.adjust(+1);}
	1277	else
[538]	1278	{trctx.out->printf("move s1,m1\npush s0\npush s0\nmove %s,s1\ncall [m1].\"set\"\nadd 3,m0\nmove s-1,s0\n",litstr($3));trstack.adjust(+1);}
[477]	1279	}
	1280
[341]	1281	\| stackexpr '[' expr ']' /* shortcut: expr.get(expr) */
[332]	1282	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+=".get"; $$.setString(t);
[163]	1283	if ($3.constant)
	1284	{
	1285	trctx.out->printf("move s0,m1\ncall [m1].\"get\",%s\n",litstr($3));
	1286	}
	1287	else
	1288	{
	1289	trctx.out->printf("move s1,m1\ncall [m1].\"get\"\ninc m0\nmove s-1,s0\n");
	1290	trstack.adjust(+1);
	1291	}
	1292	}
	1293
[332]	1294	\| IDENT '=' expr { trctx.emitLine(); $$=$3; $$.assign=1; $$.ident=0;
[163]	1295	int loc=trstack.getVariableLocation($1.getString());
	1296	if (loc!=TranslatorStack::NOTFOUND)
	1297	{
	1298	if ($3.constant)
	1299	trctx.out->printf("move %s,s%d\n",litstr($3),loc-trstack.currentPos());
	1300	else
	1301	trctx.out->printf("move s0,s%d\n",loc-trstack.currentPos());
	1302	}
	1303	else if (globalOk($1)) { $$=$3; $$.ident=0; $$.assign=1;
	1304	if ($3.constant) trctx.out->printf("move %s,@%s\n",litstr($3),str($1));
	1305	else trctx.out->printf("move s0,@%s\n",str($1));}
[245]	1306	else {trctx.err->printf("undefined variable: '%s'\n",str($1)); return 1;}
[163]	1307	}
	1308
	1309	\| OBJNAME '[' expr ']' /* shortcut: OBJNAME.get(expr) */
[332]	1310	{ trctx.emitLine(); $$.constant=0; $$.ident=0; SString t=$1.getString(); t+=".get"; $$.setString(t);
[163]	1311	if ($3.constant)
	1312	{
	1313	trctx.out->printf("dec m0\ncall %s.get,%s\n",str($1),litstr($3));
	1314	trstack.adjust(-1);
	1315	}
	1316	else
	1317	{
	1318	trctx.out->printf("call %s.get\n",str($1));
	1319	}
	1320	}
	1321
	1322	\| IDENT '(' arguments ')'
	1323	{
[332]	1324	trctx.emitLine(); $$.constant=0; $$.ident=0; $$.setString("function call");
[163]	1325	if ($3.getInt()==0)
	1326	{trctx.out->printf("dec m0\n");trstack.adjust(-1);}
	1327	trctx.out->printf("call :%s\n",str($1));
	1328	if ($3.getInt()>1)
	1329	{
	1330	trctx.out->printf("add %d,m0\nxmove s%d,s0\n",$3.getInt()-1,-($3.getInt()-1));
	1331	trstack.adjust($3.getInt()-1);
	1332	}
	1333	}
	1334
[332]	1335	\| '[' {trctx.emitLine(); $$.ident=0; trctx.out->printf("add -2,m0\ncall Vector.new\nmove s0,s1\n");trstack.adjust(-2);} // s1=vector, s0=nieuzywane ale zarezerwowane zeby nie przesuwac stosu przy kazdym elemencie (trafia tu wartosc zwracana przez add/set)
[163]	1336	v_elements ']'
	1337	{$$.constant=0; trctx.out->printf("inc m0\n");trstack.adjust(1);}
	1338
[332]	1339	\| '{' {trctx.emitLine(); $$.ident=0; trctx.out->printf("add -2,m0\ncall Dictionary.new\nmove s0,s1\n");trstack.adjust(-2);} // s1=dict, s0=nieuzywane ale zarezerwowane zeby nie przesuwac stosu przy kazdym elemencie (trafia tu wartosc zwracana przez add/set)
[163]	1340	d_elements '}'
	1341	{$$.constant=0; trctx.out->printf("inc m0\n"); trstack.adjust(1);}
	1342
	1343	// \| '&' stackexpr {trctx.out->printf("call Ref.new\n");}
	1344
	1345	\| '&' IDENT {
[332]	1346	trctx.emitLine(); $$.ident=0;
[163]	1347	int loc=trstack.getVariableLocation($2.getString());
	1348	if (loc!=TranslatorStack::NOTFOUND)
	1349	{
[247]	1350	trctx.out->printf("push &%d\n",loc-trstack.currentPos());trstack.adjust(-1);
[163]	1351	}
	1352	else if (globalOk($2))
	1353	{
	1354	trctx.out->printf("gpush &@%s\ncall Ref.newO\ninc m0\nmove s-1,s0\n",str($2));
	1355	trstack.adjust(-1);
	1356	}
[245]	1357	else {trctx.err->printf("undefined variable: '%s'\n",str($1)); return 1;}
[163]	1358	}
	1359
	1360	\| '&' OBJNAME '.' member {
[332]	1361	trctx.emitLine(); $$.ident=0;
[163]	1362	if ($4.constant)
	1363	{
	1364	trctx.out->printf("dec m0\ncall Ref.newO,%s.*,%s:%s\n",str($2),str($2),str($4));
	1365	trstack.adjust(-1);
	1366	}
	1367	else
	1368	{
	1369	trctx.out->printf("call Ref.newO,%s.*,s0\n",str($2));
	1370	}
	1371	}
	1372
	1373	\| '&' '(' stackexpr ')' '.' member {
[332]	1374	trctx.emitLine(); $$.ident=0;
[163]	1375	if ($6.constant)
	1376	{
	1377	trctx.out->printf("call Ref.newO,s0,%s\n",litstr($6));
	1378	}
	1379	else
	1380	{
	1381	trctx.out->printf("call Ref.newO,s1,s0\ninc m0\nmove s-1,s0\n");
	1382	trstack.adjust(1);
	1383	}
	1384	}
	1385
	1386	\| '(' stackexpr ',' stackexpr ',' stackexpr ')' {
[332]	1387	trctx.emitLine(); $$.ident=0;
[163]	1388	trctx.out->printf("call XYZ.new\nadd 2,m0\nmove s-2,s0\n");trstack.adjust(2);}
	1389	;
	1390
	1391	v_elements: /* empty */
	1392	\| v_element
	1393	\| v_elements ',' v_element
	1394	;
	1395
	1396	d_elements: /* empty */
	1397	\| d_element
	1398	\| d_elements ',' d_element
	1399	;
	1400
	1401	v_element: expr
	1402	{
	1403	if ($1.constant)
	1404	trctx.out->printf("move s1,m1\ncall [m1].Vector:add,%s\n",litstr($1));
	1405	else
	1406	{trctx.out->printf("move s2,m1\ncall [m1].Vector:add\ninc m0\n");trstack.adjust(1);}
	1407	}
	1408	;
	1409
	1410	d_element: expr ':' expr
	1411	{
	1412	if ($1.constant)
	1413	{
	1414	if ($3.constant)
	1415	trctx.out->printf("move s1,m1\ncall [m1].Dictionary:set,%s,%s\n",litstr($1),litstr($3));
	1416	else
	1417	{trctx.out->printf("move s2,m1\nmove %s,s1\ncall [m1].Dictionary:set\ninc m0\n",litstr($1));trstack.adjust(1);}
	1418	}
	1419	else
	1420	{
	1421	if ($3.constant)
	1422	{trctx.out->printf("move s2,m1\nmove s0,s1\nmove %s,s0\ncall [m1].Dictionary:set\ninc m0\n",litstr($3));trstack.adjust(1);}
	1423	else
	1424	{trctx.out->printf("move s3,m1\ncall [m1].Dictionary:set\nadd 2,m0\n");trstack.adjust(2);}
	1425	}
	1426	}
	1427	;
	1428
	1429	member: IDENT { $$=$1; $$.constant=1;}
	1430	\| OBJNAME ':' IDENT { SString t=$1.getString();t+=":";t+=$3.getString();
	1431	$$.setString(t);$$.constant=1;}
	1432	\| '[' stackexpr ']' { SString t="["; t+=$2.getString(); t+="]";
	1433	$$.setString(t); $$.constant=0;}
	1434
	1435	arguments: /* empty */ { $$.setInt(0); }
	1436	\| stackexpr { $$.setInt(1); }
	1437	\| arguments ',' stackexpr {$$.setInt($1.getInt()+1);}
	1438	;
	1439
	1440	%%
	1441
	1442	SString makeLitString(const ExtValue& val)
	1443	{
	1444	if (val.type!=TString)
	1445	return val.getString();
	1446	SString s=val.getString();
	1447	int len=s.len();
	1448	SString ret((len*11)/10+10);
	1449	ret+='\"';
[348]	1450	const char*t=s.c_str();
[163]	1451	while(len>0)
	1452	{
	1453	switch(*t)
	1454	{
	1455	case '\n': ret+="\\n"; break;
	1456	case '\r': ret+="\\r"; break;
	1457	case '\t': ret+="\\t"; break;
	1458	default: ret+=*t;
	1459	}
	1460	t++; len--;
	1461	}
	1462	ret+='\"';
	1463	return ret;
	1464	}
	1465
	1466	static void yyprint (FILE *file,int type,YYSTYPE value)
	1467	{
	1468	fprintf(file,"(%s)%s",str(value),value.constant?"c":"");
	1469	}
	1470
	1471	int yyerror (const char s) / Called by yyparse on error */
	1472	{
	1473	trctx.err->printf ("%s\n",s);
	1474	return 0; // w przykladach do bisona tez nie dali returna...
	1475	}
	1476
	1477	void handleTwoArg(YYSTYPE& result,const YYSTYPE& arg1,const YYSTYPE& arg2,
[332]	1478	int optoken,const char* opname,bool negarg2,bool uniq)
[163]	1479	{
[332]	1480	trctx.emitLine();
[163]	1481	result.ident=false;
	1482	if (arg1.constant && arg2.constant)
	1483	{
	1484	result=arg1;
	1485	switch(optoken)
	1486	{
	1487	case '+': result+=arg2; break;
	1488	case '-': result-=arg2; break;
	1489	case '': result=arg2; break;
	1490	case '/': result/=arg2; break;
	1491	case '%': result%=arg2; break;
	1492	case '&': result.setInt(arg1.getInt() & arg2.getInt()); break;
	1493	case '\|': result.setInt(arg1.getInt() \| arg2.getInt()); break;
	1494	case LSHIFT: result.setInt(arg1.getInt() << arg2.getInt()); break;
	1495	case RSHIFT: result.setInt(arg1.getInt() >> arg2.getInt()); break;
	1496	}
	1497	}
	1498	else
	1499	{
	1500	//TODO: prawie kazde uzycie uniq jest niepotrzebne bo typem rzadko bedzie vector, ale w wiekszosci miejsc okreslenie typu wartosci
	1501	// byloby bardzo trudne lub niemozliwe. mozna byloby natomiast zapamietywac przy parsowaniu czy dana wartosc na stosie jest
	1502	// skopiowana ze zmiennej/pola czy jest wynikiem wczesniejszej operacji co pozwoliloby na likwidacje bardzo wielu uniq
	1503	result.constant=0;
	1504	result.assign=arg1.assign \|\| arg2.assign;
	1505	result.parens=0;
	1506	result.setString(opname);
	1507	if (arg1.constant)
[332]	1508	trctx.out->printf("move %s,m1\n%s%s s0,m1\nmove m1,s0\n",litstr(arg1),
[163]	1509	negarg2?"neg s0\n":"",
	1510	opname);
	1511	else if (arg2.constant)
	1512	{
[332]	1513	if (negarg2)
	1514	trctx.out->printf("%s %d,s0\n",opname,-arg2.getInt());
[163]	1515	else
[332]	1516	trctx.out->printf("%s%s %s,s0\n",(uniq?"uniq s0\n":""),opname,litstr(arg2));
[163]	1517	}
	1518	else
	1519	{
	1520	trctx.out->printf("%s%s%s s0,s1\ninc m0\n",
[332]	1521	uniq?"uniq s1\n":"",
[163]	1522	negarg2?"neg s0\n":"",
	1523	opname);
	1524	trstack.adjust(+1);
	1525	}
	1526	}
	1527	}
	1528
	1529	bool handleAssignOp(YYSTYPE& result,const YYSTYPE& var,const YYSTYPE& arg,const char* opname)
	1530	{
	1531	int loc; if (variableOk(result,var,loc))
	1532	{
	1533	loc-=trstack.currentPos();
	1534	if (arg.constant)
	1535	{
	1536	trctx.out->printf("%s %s,s%d\npush s%d\n",opname,litstr(arg),loc,loc);
	1537	trstack.adjust(-1);
	1538	}
	1539	else
	1540	trctx.out->printf("%s s0,s%d\nmove s%d,s0\n",opname,loc,loc);
	1541	return 1;
	1542	}
	1543	return 0;
	1544	}
	1545
	1546	bool handleAssignOp2(YYSTYPE& result,const char var,const YYSTYPE& arg,const char opname,int stackpos,bool push)
	1547	{
	1548	if (arg.constant)
	1549	{
	1550	trctx.out->printf("%s %s,%s\n",opname,litstr(arg),var);
	1551	if (!push)
	1552	trctx.out->printf("move %s,s%d\n",var,stackpos);
	1553	else
	1554	{
	1555	trctx.out->printf("push %s\n",var);
	1556	trstack.adjust(-1);
	1557	}
	1558	}
	1559	else
	1560	trctx.out->printf("%s s0,%s\nmove %s,s%d\n",opname,var,var,stackpos);
	1561	return 1;
	1562	}
	1563
[332]	1564	bool handleCompare(YYSTYPE& result,const YYSTYPE& arg1,const YYSTYPE& arg2,ExtValue::CmpOperator op,const char* opname)
	1565	{
	1566	trctx.emitLine();
[163]	1567	result.ident=0;
	1568	if (arg1.constant && arg2.constant)
	1569	{
	1570	result.constant=1;
[333]	1571	ExtValue::CompareResult cmp=arg1.compare(arg2);
[332]	1572	ExtValue::CmpContext context;
	1573	context.v1=&arg1;
	1574	context.v2=&arg2;
	1575	int ret=ExtValue::interpretCompare(op,cmp,&context);
	1576	if (ret<0)
	1577	result.setEmpty();//return false;
	1578	else
	1579	result.setInt(ret);
	1580	return true;
[163]	1581	}
	1582	else
	1583	{
	1584	result.constant=0;
	1585	result.assign=arg1.assign \|\| arg2.assign;
	1586	result.parens=0;
	1587	result.setString(opname);
	1588	if (arg1.constant)
	1589	trctx.out->printf("setif %s,%s,s0,s0\n",litstr(arg1),opname);
	1590	else if (arg2.constant)
	1591	trctx.out->printf("setif s0,%s,%s,s0\n",opname,litstr(arg2));
	1592	else
	1593	{
	1594	trctx.out->printf("setif s1,%s,s0,s1\ninc m0\n",opname);
	1595	trstack.adjust(+1);
	1596	}
[332]	1597	return true;
[163]	1598	}
	1599	}
	1600
[333]	1601	static bool resultIsRelaxedEqual(ExtValue::CompareResult res)
	1602	{
	1603	return (res==ExtValue::ResultEqual)\|\|(res==ExtValue::ResultEqualUnordered)\|\|(res==ExtValue::ResultUnequal_RelaxedEqual);
	1604	}
	1605
[477]	1606	bool canAddName(const SString &name,NameKind kind)
[163]	1607	{
[477]	1608	ExtValue dummy;
	1609	NameKind found=NameNotFound;
	1610	if (globalNameOk(name)) found=GlobalName;
	1611	else if (trstack.getConstant(name,dummy)) found=ConstName;
	1612	else if (kind!=VariableName) { if (variableNameOk(name)!=TranslatorStack::NOTFOUND) found=VariableName; }
	1613	if (found!=NameNotFound)
	1614	{ trctx.err->printf("Can't define '%s %s' (previously defined as %s)",name_kind_names[kind],name.c_str(),name_kind_names[found]); return false; }
	1615	return true;
	1616	}
	1617
	1618	int variableNameOk(const SString &name)
	1619	{
	1620	int loc=trstack.getVariableLocation(name);
[163]	1621	if (loc != TranslatorStack::NOTFOUND)
[466]	1622	{
	1623	if ((trctx.functionstackpos!=TranslatorContext::NOT_IN_FUNCTION)
	1624	&& (loc>=trctx.beforefunctionstackpos))
[477]	1625	return TranslatorStack::NOTFOUND;
	1626	return loc;
	1627	}
	1628	return TranslatorStack::NOTFOUND;
	1629	}
	1630
	1631	bool variableOk(TokenValue &tok, const TokenValue& var,int &loc)
	1632	{
	1633	loc=variableNameOk(var.getString());
	1634	if (loc != TranslatorStack::NOTFOUND)
	1635	{
[466]	1636	tok.setInt(loc); tok.constant=0;
[477]	1637	return true;
[466]	1638	}
[477]	1639	return false;
[163]	1640	}
	1641
	1642	bool globalOk(const TokenValue& var)
	1643	{
[477]	1644	return globalNameOk(var.getString());
	1645	}
	1646
	1647	bool globalNameOk(const SString& name)
	1648	{
	1649	SymTabEntry* found=trstack.globals.find(name);
[163]	1650	if (found) return true;
[477]	1651	return framscriptIsGlobalName(name.c_str());
[163]	1652	}
	1653
	1654	void badVariable(TokenValue &tok, const TokenValue& var)
	1655	{
	1656	tok=var; tok.constant=1;
	1657	trctx.err->printf("undefined variable '%s'\n",str(var));
	1658	}
	1659
	1660	bool doBreak(int level)
	1661	{
	1662	if (trstack.loops.size()<level)
[245]	1663	{trctx.err->printf("invalid 'break'\n"); return 0;}
[163]	1664	LoopInfo* li=trstack.loops.getLoop(level-1);
	1665	if (li->location != trstack.currentPos())
	1666	trctx.out->printf("add %d,m0\n",li->location-trstack.currentPos());
	1667	trctx.out->printf("jump :_loop_end_%d\n",li->id);
	1668	return 1;
	1669	}
	1670
	1671	bool doContinue(int level)
	1672	{
	1673	if (trstack.loops.size()<level)
[245]	1674	{trctx.err->printf("invalid 'continue'\n"); return 0;}
[163]	1675	LoopInfo* li=trstack.loops.getLoop(level-1);
	1676	if (li->location != trstack.currentPos())
	1677	trctx.out->printf("add %d,m0\n",li->location-trstack.currentPos());
	1678	trctx.out->printf("jump :_loop_%d\n",li->id);
	1679	return 1;
	1680	}
	1681
	1682	int lookupToken(char *s)
	1683	{
	1684	int len=strlen(s);
	1685	int i;
	1686	const char *t;
	1687	for (i = 0; i < YYNTOKENS; i++)
	1688	{
	1689	t=yytname[i];
	1690	if (t && (t[0]=='"')
	1691	&& (!strncmp(t+1,s,len))
	1692	&& (t[len+1]=='"')
	1693	&& (t[len+2] == 0))
	1694	return yytoknum[i];
	1695	}
	1696	return -1;
	1697	}
	1698
	1699	void warnTruthValue(const TokenValue& t)
	1700	{
	1701	if (t.assign && (!t.parens))
[375]	1702	logPrintf("FramScriptCompiler","translate",LOG_WARN,"Assignment used as truth value, use ((double parens)) if you really mean it");
[163]	1703	}
	1704
	1705	void outFunName(const TokenValue& t)
	1706	{
	1707	if (trctx.functiontmplabel<0)
	1708	{
	1709	trctx.functiontmplabel=trctx.labelcounter++;
	1710	trctx.out->printf("jump :_skipfun_%d\n",trctx.functiontmplabel);
	1711	}
	1712	trctx.out->printf(":%s\n",str(t));
	1713	}
	1714
	1715	bool evalVariable(TokenValue &tok,const TokenValue &var)
	1716	{
	1717	int loc;
	1718	if (variableOk(tok,var,loc))
	1719	{
	1720	trctx.out->printf("push s%d\n",loc-trstack.currentPos());
	1721	trstack.adjust(-1);
	1722	return true;
	1723	}
	1724	else if (globalOk(var))
	1725	{
[348]	1726	trctx.out->printf("push @%s\n",var.getString().c_str());
[163]	1727	trstack.adjust(-1);
	1728	return true;
	1729	}
	1730	else
	1731	{
	1732	badVariable(tok,var); return false;
	1733	}
	1734	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format