--- parser3/src/main/compile.y	2001/09/17 14:26:56	1.165.4.2
+++ parser3/src/main/compile.y	2002/04/15 06:45:58	1.183
@@ -1,12 +1,12 @@
+%{
 /** @file
 	Parser: compiler(lexical parser and grammar).
 
 	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
-
 	Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
+
+	$Id: compile.y,v 1.183 2002/04/15 06:45:58 paf Exp $
 */
-%{
-static char *RCSId="$Id: compile.y,v 1.165.4.2 2001/09/17 14:26:56 parser Exp $"; 
 
 /**
 	@todo parser4: 
@@ -59,6 +59,7 @@ static int yylex(YYSTYPE *lvalp, void *p
 
 %token BAD_STRING_COMPARISON_OPERATOR
 %token BAD_HEX_LITERAL
+%token BAD_METHOD_DECL_START
 
 %token LAND "&&"
 %token LOR "||"
@@ -99,7 +100,7 @@ static int yylex(YYSTYPE *lvalp, void *p
 
 /* numerical */
 %left '-' '+'
-%left '*' '/' '%'
+%left '*' '/' '%' '\\'
 %left NEG     /* negation: unary - */
 
 %%
@@ -251,13 +252,20 @@ name_without_curly_rdive_read: name_with
 	$$=N(POOL); 
 	Array *diving_code=$1;
 	const String *first_name=LA2S(diving_code);
+	// self.xxx... -> xxx...
+	// OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
 	if(first_name && *first_name==SELF_ELEMENT_NAME) {
 		O($$, OP_WITH_SELF); /* stack: starting context */
 		P($$, diving_code, 
 			/* skip over... */
-			diving_code->size()>2?3/*OP_+string+get_element*/:2/*OP_+string*/);
+			diving_code->size()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);
 	} else {
 		O($$, OP_WITH_READ); /* stack: starting context */
+
+		// ^if ELEMENT -> ^if ELEMENT_OR_OPERATOR
+		// OP_VALUE+string+OP_GET_ELEMENT. -> OP_VALUE+string+OP_GET_ELEMENT_OR_OPERATOR.
+		if(PC.in_call_value && diving_code->size()==3)
+			diving_code->put_int(2, OP_GET_ELEMENT_OR_OPERATOR);
 		P($$, diving_code);
 	}
 	/* diving code; stack: current context */
@@ -279,11 +287,13 @@ name_expr_wdive_root: name_expr_dive_cod
 	$$=N(POOL);
 	Array *diving_code=$1;
 	const String *first_name=LA2S(diving_code);
+	// $self.xxx... -> $xxx...
+	// OP_VALUE+string+OP_GET_ELEMENT+... -> OP_WITH_SELF+...
 	if(first_name && *first_name==SELF_ELEMENT_NAME) {
 		O($$, OP_WITH_SELF); /* stack: starting context */
 		P($$, diving_code, 
 			/* skip over... */
-			diving_code->size()>2?3/*OP_+string+get_element*/:2/*OP_+string*/);
+			diving_code->size()>=3?3/*OP_VALUE+string+OP_GET_ELEMENTx*/:2/*OP_+string*/);
 	} else {
 		O($$, OP_WITH_ROOT); /* stack: starting context */
 		P($$, diving_code);
@@ -309,8 +319,10 @@ construct_square: '[' any_constructor_co
 }
 ;
 construct_round: '(' expr_value ')' { 
+	$$=N(POOL); 
+	O($$, OP_PREPARE_TO_EXPRESSION);
 	// stack: context, name
-	$$=$2; // stack: context, name, value
+	P($$, $2); // stack: context, name, value
 	O($$, OP_CONSTRUCT_EXPR); /* value=pop->as_expr_result; name=pop; context=pop; construct(context,name,value) */
 }
 ;
@@ -327,9 +339,9 @@ any_constructor_code_value:
 ;
 constructor_code_value: constructor_code {
 	$$=N(POOL); 
-	O($$, OP_CREATE_EWPOOL); /* stack: empty write context */
-	P($$, $1); /* some code that writes to that context */
-	O($$, OP_REDUCE_EWPOOL); /* context=pop; stack: context.value() */
+	PJP($$, $1); /* stack: empty write context */
+	/* some code that writes to that context */
+	/* context=pop; stack: context.value() */
 };
 constructor_code: codes__excluding_sole_str_literal;
 codes__excluding_sole_str_literal: action | code codes { $$=$1; P($$, $2) };
@@ -340,8 +352,12 @@ call: call_value {
 	$$=$1; /* stack: value */
 	O($$, OP_WRITE_VALUE); /* value=pop; wcontext.write(value) */
 };
-call_value: '^' { PC.object_constructor_allowed=true } 
-			call_name { PC.object_constructor_allowed=false } 
+call_value: '^' { 
+					PC.in_call_value=true; 
+			}
+			call_name {
+				PC.in_call_value=false;
+			} 
 			store_params EON { /* ^field.$method{vasya} */
 	$$=$3; /* with_xxx,diving code; stack: context,method_junction */
 	O($$, OP_GET_METHOD_FRAME); /* stack: context,method_frame */
@@ -397,7 +413,9 @@ code_param_value:
 |	constructor_code_value /* [something complex] */
 ;
 write_expr_value: expr_value {
-	$$=$1;
+	$$=N(POOL); 
+	O($$, OP_PREPARE_TO_EXPRESSION);
+	P($$, $1);
 	O($$, OP_WRITE_EXPR_RESULT);
 };
 
@@ -408,6 +426,9 @@ name_expr_dive_code: name_expr_value | n
 name_path: name_step | name_path name_step { $$=$1; P($$, $2) };
 name_step: name_advance1 '.';
 name_advance1: name_expr_value {
+	// we know that name_advance1 not called from ^xxx context
+	// so we'll not check for operator call possibility as we do in name_advance2
+
 	/* stack: context */
 	$$=$1; /* stack: context,name */
 	O($$, OP_GET_ELEMENT); /* name=pop; context=pop; stack: context.get_element(name) */
@@ -430,18 +451,19 @@ name_expr_subvar_value: '$' subvar_ref_n
 	O($$, OP_GET_ELEMENT);
 };
 name_expr_with_subvar_value: STRING subvar_get_writes {
+	Array *code;
+	{
+		change_string_literal_to_write_string_literal(code=$1);
+		P(code, $2);
+	}
 	$$=N(POOL); 
-	O($$, OP_CREATE_EWPOOL);
-	P($$, $1);
-	O($$, OP_WRITE_VALUE);
-	P($$, $2);
-	O($$, OP_REDUCE_EWPOOL);
+	PSP($$, code);
 };
 name_square_code_value: '[' codes ']' {
 	$$=N(POOL); 
-	O($$, OP_CREATE_EWPOOL);
-	P($$, $2);
-	O($$, OP_REDUCE_EWPOOL);
+	PJP($$, $2); /* stack: empty write context */
+	/* some code that writes to that context */
+	/* context=pop; stack: context.value() */
 };
 subvar_ref_name_rdive: STRING {
 	$$=N(POOL); 
@@ -464,7 +486,7 @@ class_static_prefix: STRING ':' {
 };
 class_constructor_prefix: class_static_prefix ':' {
 	$$=$1;
-	if(!PC.object_constructor_allowed) {
+	if(!PC.in_call_value) {
 		strcpy(PC.error, ":: not allowed here");
 		YYERROR;
 	}
@@ -475,6 +497,7 @@ class_constructor_prefix: class_static_p
 /* expr */
 
 expr_value: expr {
+	// see OP_PREPARE_TO_EXPRESSION!!
 	if(($$=$1)->size()==2) // only one string literal in there?
 		change_string_literal_to_double_literal($$); // make that string literal Double
 };
@@ -500,11 +523,12 @@ expr:
 |	expr '*' expr { $$=$1;  P($$, $3);  O($$, OP_MUL) }
 |	expr '/' expr { $$=$1;  P($$, $3);  O($$, OP_DIV) }
 |	expr '%' expr { $$=$1;  P($$, $3);  O($$, OP_MOD) }
+|	expr '\\' expr { $$=$1;  P($$, $3);  O($$, OP_INTDIV) }
 |	expr '&' expr { $$=$1; 	P($$, $3);  O($$, OP_BIN_AND) }
 |	expr '|' expr { $$=$1;  P($$, $3);  O($$, OP_BIN_OR) }
 |	expr '#' expr { $$=$1;  P($$, $3);  O($$, OP_BIN_XOR) }
-|	expr "&&" expr { $$=$1;  P($$, $3);  O($$, OP_LOG_AND) }
-|	expr "||" expr { $$=$1;  P($$, $3);  O($$, OP_LOG_OR) }
+|	expr "&&" expr { $$=$1;  PNC($$, $3);  O($$, OP_LOG_AND) }
+|	expr "||" expr { $$=$1;  PNC($$, $3);  O($$, OP_LOG_OR) }
 |	expr "##" expr { $$=$1;  P($$, $3);  O($$, OP_LOG_XOR) }
 |	expr '<' expr { $$=$1;  P($$, $3);  O($$, OP_NUM_LT) }
 |	expr '>' expr { $$=$1;  P($$, $3);  O($$, OP_NUM_GT) }
@@ -523,9 +547,9 @@ expr:
 
 string_inside_quotes_value: maybe_codes {
 	$$=N(POOL);
-	O($$, OP_CREATE_SWPOOL); /* stack: empty write context */
-	P($$, $1); /* some code that writes to that context */
-	O($$, OP_REDUCE_SWPOOL); /* context=pop; stack: context.get_string() */
+	PSP($$, $1); /* stack: empty write context */
+	/* some code that writes to that context */
+	/* context=pop; stack: context.get_string() */
 };
 
 /* basics */
@@ -558,7 +582,7 @@ empty: /* empty */ { $$=N(POOL) };
 */
 
 static int yylex(YYSTYPE *lvalp, void *pc) {
-	#define lexical_brackets_nestage PC.brackets_nestages[PC.sp]
+	#define lexical_brackets_nestage PC.brackets_nestages[PC.ls_sp]
 	#define RC {result=c; goto break2; }
 
     register int c;
@@ -584,14 +608,39 @@ static int yylex(YYSTYPE *lvalp, void *p
 		} else
 			PC.col++;
 
-		if(c=='^' && PC.ls!=LS_COMMENT && PC.ls!=LS_DEF_COMMENT) 
+		if(c=='@' && PC.col==0+1) {
+			if(PC.ls==LS_DEF_SPECIAL_BODY) {
+				// @SPECIAL
+				// ...
+				// @<here = 
+				pop_LS(PC); // exiting from LS_DEF_SPECIAL_BODY state
+			} // continuing checks
+			if(PC.ls==LS_USER) {
+				push_LS(PC, LS_DEF_NAME);
+				RC;
+			} else // @ in first column inside some code [when could that be?]
+				result=BAD_METHOD_DECL_START;
+			goto break2;
+		} else if(c=='^')
+			switch(PC.ls) {
+case LS_EXPRESSION_VAR_NAME_WITH_COLON:
+case LS_EXPRESSION_VAR_NAME_WITHOUT_COLON:
+case LS_VAR_NAME_SIMPLE_WITH_COLON:
+case LS_VAR_NAME_SIMPLE_WITHOUT_COLON:
+case LS_VAR_NAME_CURLY:
+case LS_METHOD_NAME:
+case LS_COMMENT:
+case LS_DEF_COMMENT:
+	// no literals in names, please
+	break;
+default:
 			switch(*PC.source) {
 			// ^escaping some punctuators
 			case '^': case '$': case ';':
 			case '(': case ')':
 			case '[': case ']':
 			case '{': case '}':
-			case '"': 
+			case '"':  case ':':
 				if(end!=begin) {
 					// append piece till ^
 					PC.string->APPEND_CLEAN(begin, end-begin, PC.file, begin_line);
@@ -639,6 +688,8 @@ static int yylex(YYSTYPE *lvalp, void *p
 				}
 				break;
 			}
+			break;
+		}
 		// #comment  start skipping
 		if(c=='#' && PC.col==1) {
 			if(end!=begin) {
@@ -647,6 +698,7 @@ static int yylex(YYSTYPE *lvalp, void *p
 			}
 			// fall into COMMENT lexical state [wait for \n]
 			push_LS(PC, LS_COMMENT);
+			continue;
 		}
 		switch(PC.ls) {
 
@@ -669,12 +721,6 @@ static int yylex(YYSTYPE *lvalp, void *p
 			case '^':
 				push_LS(PC, LS_METHOD_NAME);
 				RC;
-			case '@':
-				if(PC.col==0+1) {
-					push_LS(PC, LS_DEF_NAME);
-					RC;
-				}
-				break;
 			case ']':
 				if(PC.ls==LS_NAME_SQUARE_PART)
 					if(--lexical_brackets_nestage==0) {// $name.[co<]?>de<]?>
@@ -770,19 +816,8 @@ static int yylex(YYSTYPE *lvalp, void *p
 			break;
 
 		case LS_DEF_SPECIAL_BODY:
-			//                          @todo in case
-			// ################
-			// @next-method
-			// we are here with c=='@'
-			// which is wrong, and need action
-			if(c=='\n') {
-				switch(*PC.source) {
-				case '@': case 0: // end of special_code
-					pop_LS(PC);
-					break;
-				}
+			if(c=='\n')
 				RC;
-			}
 			break;
 
 		// (EXPRESSION)
@@ -820,7 +855,7 @@ static int yylex(YYSTYPE *lvalp, void *p
 					goto break2;
 				}
 				goto break2;
-			case '+': case '*': case '/': case '%': 
+			case '+': case '*': case '/': case '%': case '\\':
 			case '~':
 			case ';':
 				RC;
@@ -914,9 +949,12 @@ static int yylex(YYSTYPE *lvalp, void *p
 			if(
 				PC.ls==LS_EXPRESSION_VAR_NAME_WITH_COLON ||
 				PC.ls==LS_EXPRESSION_VAR_NAME_WITHOUT_COLON) {
-				// name in expr ends also before binary operators 
+				// name in expr ends also before 
 				switch(c) {
+				// expression minus
 				case '-': 
+				// expression integer division
+				case '\\':
 					pop_LS(PC);
 					PC.source--;  if(--PC.col<0) { PC.line--;  PC.col=-1; }
 					result=EON;
@@ -1080,6 +1118,8 @@ static int yylex(YYSTYPE *lvalp, void *p
 			case '.': // name part delim 
 			case '$': // name part subvar
 			case ':': // ':name' or 'class:name'
+			case '^': // ^abc^xxx wrong. bailing out
+			case ']': case '}': case ')': // ^abc]}) wrong. bailing out
 				RC;
 			}
 			break;