wsgram.y

The Kannel Open Source WAP and SMS gateway works as both an SMS gateway, for implementing keyword b

		        ws_list_append(pctx, $1, parm);
		}
	;

/* Statements. */

Statement:
	  Block
		{
		    if ($1)
		        $$ = ws_stmt_block(pctx, $1->first_line, $1->last_line,
				           $1);
		    else
		        $$ = NULL;
		}
	| VariableStatement
	| ';'			/* EmptyStatement */
		{ $$ = ws_stmt_empty(pctx, @1.first_line); }
	| Expression ';'	/* ExpressionStatement */
		{ $$ = ws_stmt_expr(pctx, $1->line, $1); }
	| IfStatement
	| IterationStatement
	| tCONTINUE ';'		/* ContinueStatement */
		{ $$ = ws_stmt_continue(pctx, @1.first_line); }
	| tBREAK ';'		/* BreakStatement */
		{ $$ = ws_stmt_break(pctx, @1.first_line); }
	| ReturnStatement
	;

Block:	'{' StatementListOpt '}'
		{
		    $$ = $2;
		    if ($$) {
		        $$->first_line = @1.first_line;
		        $$->last_line = @3.first_line;
		    }
		}
	| error
		{
		    ws_error_syntax(pctx, @1.first_line);
		    $$ = NULL;
		}
	;

StatementListOpt:
	  /* empty */
		{ $$ = ws_list_new(pctx); }
	| StatementList
	;

StatementList:
	  Statement
		{
		    $$ = ws_list_new(pctx);
		    ws_list_append(pctx, $$, $1);
		}
	| StatementList Statement
		{ ws_list_append(pctx, $1, $2); }
	;

VariableStatement:
	  tVAR VariableDeclarationList ';'
		{ $$ = ws_stmt_variable(pctx, @1.first_line, $2); }
	| tVAR error
		{ ws_error_syntax(pctx, @2.first_line); }
	;

VariableDeclarationList:
	  VariableDeclaration
		{
		    $$ = ws_list_new(pctx);
		    ws_list_append(pctx, $$, $1);
		}
	| VariableDeclarationList ',' VariableDeclaration
		{ ws_list_append(pctx, $1, $3); }
	;

VariableDeclaration:
	  tIDENTIFIER VariableInitializedOpt
		{
		    char *id = ws_f_strdup(((WsCompiler *) pctx)->pool_stree,
					   $1);

		    ws_lexer_free_block(pctx, $1);
		    if (id == NULL) {
		        ws_error_memory(pctx);
		        $$ = NULL;
		    } else
		        $$ = ws_variable_declaration(pctx, id, $2);
		}
	;

VariableInitializedOpt:
	  /* empty */
		{ $$ = NULL; }
	| '=' ConditionalExpression
		{ $$ = $2; }
	;

IfStatement:
	  tIF '(' Expression ')' Statement tELSE Statement
		{ $$ = ws_stmt_if(pctx, @1.first_line, $3, $5, $7); }
	| tIF '(' Expression ')' Statement
		{ $$ = ws_stmt_if(pctx, @1.first_line, $3, $5, NULL); }
	;

IterationStatement:
	  tWHILE '(' Expression ')' Statement
		{ $$ = ws_stmt_while(pctx, @1.first_line, $3, $5); }
	| ForStatement
	;

ForStatement:
	  tFOR '(' ExpressionOpt ';' ExpressionOpt ';' ExpressionOpt ')'
			Statement
	  	{ $$ = ws_stmt_for(pctx, @1.first_line, NULL, $3, $5, $7, $9); }
	| tFOR '(' tVAR VariableDeclarationList ';' ExpressionOpt ';'
	       		ExpressionOpt ')' Statement
	  	{ $$ = ws_stmt_for(pctx, @1.first_line, $4, NULL, $6, $8, $10); }
	;

ReturnStatement:
	  tRETURN ExpressionOpt ';'
		{ $$ = ws_stmt_return(pctx, @1.first_line, $2); }
	;

/* Expressions. */

ExpressionOpt:
	  /* empty */	{ $$ = NULL; }
	| Expression
	;


Expression:
	  AssignmentExpression
	| Expression ',' AssignmentExpression
		{ $$ = ws_expr_comma(pctx, @2.first_line, $1, $3); }
	;

AssignmentExpression:
	  ConditionalExpression
	| tIDENTIFIER	'='		AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, '=', $3); }
	| tIDENTIFIER	tMULA		AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tMULA, $3); }
	| tIDENTIFIER	tDIVA		AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tDIVA, $3); }
	| tIDENTIFIER	tREMA		AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tREMA, $3); }
	| tIDENTIFIER	tADDA		AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tADDA, $3); }
	| tIDENTIFIER	tSUBA		AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tSUBA, $3); }
	| tIDENTIFIER	tLSHIFTA	AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tLSHIFTA, $3); }
	| tIDENTIFIER	tRSSHIFTA	AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tRSSHIFTA, $3); }
	| tIDENTIFIER	tRSZSHIFTA	AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tRSZSHIFTA, $3); }
	| tIDENTIFIER	tANDA		AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tANDA, $3); }
	| tIDENTIFIER	tXORA		AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tXORA, $3); }
	| tIDENTIFIER	tORA		AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tORA, $3); }
	| tIDENTIFIER	tIDIVA		AssignmentExpression
		{ $$ = ws_expr_assign(pctx, @1.first_line, $1, tIDIVA, $3); }
	;

ConditionalExpression:
	  LogicalORExpression
	| LogicalORExpression '?' AssignmentExpression ':' AssignmentExpression
		{ $$ = ws_expr_conditional(pctx, @2.first_line, $1, $3, $5); }
	;

LogicalORExpression:
	  LogicalANDExpression
	| LogicalORExpression tOR LogicalANDExpression
		{ $$ = ws_expr_logical(pctx, @2.first_line, WS_ASM_SCOR, $1, $3); }
	;

LogicalANDExpression:
	  BitwiseORExpression
	| LogicalANDExpression tAND BitwiseORExpression
		{ $$ = ws_expr_logical(pctx, @2.first_line, WS_ASM_SCAND, $1, $3); }
	;

BitwiseORExpression:
	  BitwiseXORExpression
	| BitwiseORExpression '|' BitwiseXORExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_OR, $1, $3); }
	;

BitwiseXORExpression:
	  BitwiseANDExpression
	| BitwiseXORExpression '^' BitwiseANDExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_XOR, $1, $3); }
	;

BitwiseANDExpression:
	  EqualityExpression
	| BitwiseANDExpression '&' EqualityExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_AND, $1, $3); }
	;

EqualityExpression:
	  RelationalExpression
	| EqualityExpression tEQ RelationalExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_EQ, $1, $3); }
	| EqualityExpression tNE RelationalExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_NE, $1, $3); }
	;

RelationalExpression:
	  ShiftExpression
	| RelationalExpression '<' ShiftExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_LT, $1, $3); }
	| RelationalExpression '>' ShiftExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_GT, $1, $3); }
	| RelationalExpression tLE ShiftExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_LE, $1, $3); }
	| RelationalExpression tGE ShiftExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_GE, $1, $3); }
	;

ShiftExpression:
	  AdditiveExpression
	| ShiftExpression tLSHIFT AdditiveExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_LSHIFT, $1, $3); }
	| ShiftExpression tRSSHIFT AdditiveExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_RSSHIFT, $1, $3); }
	| ShiftExpression tRSZSHIFT AdditiveExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_RSZSHIFT, $1, $3); }
	;

AdditiveExpression:
	  MultiplicativeExpression
	| AdditiveExpression '+' MultiplicativeExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_ADD, $1, $3); }
	| AdditiveExpression '-' MultiplicativeExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_SUB, $1, $3); }
	;

MultiplicativeExpression:
	  UnaryExpression
	| MultiplicativeExpression '*' UnaryExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_MUL, $1, $3); }
	| MultiplicativeExpression '/' UnaryExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_DIV, $1, $3); }
	| MultiplicativeExpression tIDIV UnaryExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_IDIV, $1, $3); }
	| MultiplicativeExpression '%' UnaryExpression
		{ $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_REM, $1, $3); }
	;

UnaryExpression:
	  PostfixExpression
	| tTYPEOF UnaryExpression
		{ $$ = ws_expr_unary(pctx, @1.first_line, WS_ASM_TYPEOF, $2); }
	| tISVALID UnaryExpression
		{ $$ = ws_expr_unary(pctx, @1.first_line, WS_ASM_ISVALID, $2); }
	| tPLUSPLUS tIDENTIFIER
		{ $$ = ws_expr_unary_var(pctx, @1.first_line, WS_TRUE, $2); }
	| tMINUSMINUS tIDENTIFIER
		{ $$ = ws_expr_unary_var(pctx, @1.first_line, WS_FALSE, $2); }
	| '+' UnaryExpression
		{
                    /* There is no direct way to compile unary `+'.
                     * It doesn't do anything except require type conversion
		     * (section 7.2, 7.3.2), and we do that by converting
		     * it to a binary expression: `UnaryExpression - 0'.
                     * Using `--UnaryExpression' would not be correct because
                     * it might overflow if UnaryExpression is the smallest
                     * possible integer value (see 6.2.7.1).
                     * Using `UnaryExpression + 0' would not be correct
                     * because binary `+' accepts strings, which makes the
		     * type conversion different.
                     */
                    $$ = ws_expr_binary(pctx, @1.first_line, WS_ASM_SUB, $2,
                              ws_expr_const_integer(pctx, @1.first_line, 0));
		}
	| '-' UnaryExpression
		{ $$ = ws_expr_unary(pctx, @1.first_line, WS_ASM_UMINUS, $2); }
	| '~' UnaryExpression
		{ $$ = ws_expr_unary(pctx, @1.first_line, WS_ASM_B_NOT, $2); }
	| '!' UnaryExpression
		{ $$ = ws_expr_unary(pctx, @1.first_line, WS_ASM_NOT, $2); }
	;

PostfixExpression:
	  CallExpression
	| tIDENTIFIER tPLUSPLUS
		{ $$ = ws_expr_postfix_var(pctx, @1.first_line, WS_TRUE, $1); }
	| tIDENTIFIER tMINUSMINUS
		{ $$ = ws_expr_postfix_var(pctx, @1.first_line, WS_FALSE, $1); }
	;

CallExpression:
	  PrimaryExpression
	| tIDENTIFIER Arguments                 /* LocalScriptFunctionCall */
		{
		    WsFunctionHash *f = ws_function_hash(pctx, $1);

		    /* Add an usage count for the local script function. */
		    if (f)
		      f->usage_count++;

		    $$ = ws_expr_call(pctx, @1.first_line, ' ', NULL, $1, $2);
		}
	| tIDENTIFIER '#' tIDENTIFIER Arguments /* ExternalScriptFunctionCall*/
		{ $$ = ws_expr_call(pctx, @3.first_line, '#', $1, $3, $4); }
	| tIDENTIFIER '.' tIDENTIFIER Arguments /* LibraryFunctionCall */
		{ $$ = ws_expr_call(pctx, @3.first_line, '.', $1, $3, $4); }
	;

PrimaryExpression:
	  tIDENTIFIER
		{ $$ = ws_expr_symbol(pctx, @1.first_line, $1); }
	| tINVALID
		{ $$ = ws_expr_const_invalid(pctx, @1.first_line); }
	| tTRUE
		{ $$ = ws_expr_const_true(pctx, @1.first_line); }
	| tFALSE
		{ $$ = ws_expr_const_false(pctx, @1.first_line); }
	| tINTEGER
		{ $$ = ws_expr_const_integer(pctx, @1.first_line, $1); }
	| tFLOAT
		{ $$ = ws_expr_const_float(pctx, @1.first_line, $1); }
	| tSTRING
		{ $$ = ws_expr_const_string(pctx, @1.first_line, $1); }
	| '(' Expression ')'
		{ $$ = $2; }
	;

Arguments:
	  '(' ')'
		{ $$ = ws_list_new(pctx); }
	| '(' ArgumentList ')'
		{ $$ = $2; }
	;

ArgumentList:
	  AssignmentExpression
		{
		    $$ = ws_list_new(pctx);
		    ws_list_append(pctx, $$, $1);
		}
	| ArgumentList ',' AssignmentExpression
		{ ws_list_append(pctx, $1, $3); }
	;

%%

void
yyerror(char *msg)
{
#if WS_DEBUG
  fprintf(stderr, "*** %s:%d: wsc: %s - this msg will be removed ***\n",
	  global_compiler->input_name, global_compiler->linenum, msg);
#endif /* WS_DEBUG */
}