开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
wsgram.y
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：19k
源码类别：

手机WAP编程

开发平台：

WINDOWS

wsgram.y：源码内容
  1. %{
  2. /*
  3.  *
  4.  * wsgram.y
  5.  *
  6.  * Author: Markku Rossi <mtr@iki.fi>
  7.  *
  8.  * Copyright (c) 1999-2000 WAPIT OY LTD.
  9.  *  All rights reserved.
  10.  *
  11.  * Bison grammar for the WMLScript compiler.
  12.  *
  13.  */
  15. #include "wmlscript/wsint.h"
  17. #define YYPARSE_PARAM pctx
  18. #define YYLEX_PARAM pctx
  20. /* The required yyerror() function.  This is actually not used but to
  21.    report the internal parser errors.  All other errors are reported
  22.    by using the `wserror.h' functions. */
  23. extern void yyerror(char *msg);
  25. #if WS_DEBUG
  26. /* Just for debugging purposes. */
  27. WsCompilerPtr global_compiler = NULL;
  28. #endif /* WS_DEBUG */
  30. %}
  32. /* The possible semantic values. */
  33. %union
  34. {
  35.     WsUInt32 integer;
  36.     WsFloat vfloat;
  37.     char *identifier;
  38.     WsUtf8String *string;
  40.     WsBool boolean;
  41.     WsList *list;
  42.     WsFormalParm *parm;
  43.     WsVarDec *vardec;
  45.     WsPragmaMetaBody *meta_body;
  47.     WsStatement *stmt;
  48.     WsExpression *expr;
  49. }
  51. /* Tokens. */
  53. /* Language literals. */
  54. %token tINVALID tTRUE tFALSE tINTEGER tFLOAT tSTRING
  56. /* Identifier. */
  57. %token tIDENTIFIER
  59. /* Keywords. */
  60. %token tACCESS tAGENT tBREAK tCONTINUE tIDIV tIDIVA tDOMAIN tELSE tEQUIV
  61. %token tEXTERN tFOR tFUNCTION tHEADER tHTTP tIF tISVALID tMETA tNAME tPATH
  62. %token tRETURN tTYPEOF tUSE tUSER tVAR tWHILE tURL
  64. /* Keywords not used by WMLScript */
  65. %token tDELETE tIN tLIB tNEW tNULL tTHIS tVOID tWITH
  67. /* Future reserved keywords. */
  68. %token tCASE tCATCH tCLASS tCONST tDEBUGGER tDEFAULT tDO tENUM tEXPORT
  69. %token tEXTENDS tFINALLY tIMPORT tPRIVATE tPUBLIC tSIZEOF tSTRUCT tSUPER
  70. %token tSWITCH tTHROW tTRY
  72. /* Punctuation. */
  73. %token tEQ tLE tGE tNE tAND tOR tPLUSPLUS tMINUSMINUS
  74. %token tLSHIFT tRSSHIFT tRSZSHIFT tADDA tSUBA tMULA tDIVA tANDA tORA tXORA
  75. %token tREMA tLSHIFTA tRSSHIFTA tRSZSHIFTA
  77. /* Assign semantic values to tokens and non-terminals. */
  79. %type <integer> tINTEGER
  80. %type <vfloat> tFLOAT
  81. %type <string> tSTRING
  82. %type <identifier> tIDENTIFIER
  84. %type <string> MetaPropertyName MetaContent MetaScheme
  86. %type <meta_body> MetaBody
  88. %type <boolean> ExternOpt
  90. %type <list> FormalParameterListOpt FormalParameterList
  91. %type <list> StatementListOpt StatementList
  92. %type <list> Block Arguments ArgumentList VariableDeclarationList
  94. %type <vardec> VariableDeclaration
  96. %type <stmt> Statement ReturnStatement VariableStatement IfStatement
  97. %type <stmt> IterationStatement ForStatement
  99. %type <expr> ExpressionOpt Expression AssignmentExpression
  100. %type <expr> ConditionalExpression LogicalORExpression
  101. %type <expr> LogicalANDExpression BitwiseORExpression
  102. %type <expr> BitwiseXORExpression BitwiseANDExpression
  103. %type <expr> EqualityExpression RelationalExpression ShiftExpression
  104. %type <expr> AdditiveExpression MultiplicativeExpression UnaryExpression
  105. %type <expr> PostfixExpression CallExpression PrimaryExpression
  106. %type <expr> VariableInitializedOpt
  108. /* Options for bison. */
  110. /* Generate reentrant parser. */
  111. %pure_parser
  113. /* This grammar has one shift-reduce conflict.  It comes from the
  114.    if-else statement. */
  115. %expect 1
  117. %%
  119. /* A compilation unit. */
  121. CompilationUnit:
  122.   Pragmas FunctionDeclarations
  123. | FunctionDeclarations
  124. | error
  125. { ws_error_syntax(pctx, @1.first_line); }
  126. ;
  128. /* Pragmas. */
  130. Pragmas:
  131.   Pragma
  132. | Pragmas Pragma
  133. ;
  135. Pragma:
  136.   tUSE PragmaDeclaration ';'
  137. | error
  138. { ws_error_syntax(pctx, @2.first_line); }
  139. ;
  141. PragmaDeclaration:
  142.   ExternalCompilationUnitPragma
  143. | AccessControlPragma
  144. | MetaPragma
  145. ;
  147. ExternalCompilationUnitPragma:
  148.   tURL tIDENTIFIER tSTRING
  149.    { ws_pragma_use(pctx, @2.first_line, $2, $3); }
  150. ;
  152. AccessControlPragma:
  153.   tACCESS AccessControlSpecifier
  154. ;
  156. AccessControlSpecifier:
  157.   tDOMAIN tSTRING
  158.    {
  159.     WsCompiler *compiler = (WsCompiler *) pctx;
  161.     /* Pass this to the byte-code */
  162.     if (!ws_bc_add_pragma_access_domain(compiler->bc, $2->data,
  163.         $2->len))
  164.         ws_error_memory(pctx);
  165.     ws_lexer_free_utf8(compiler, $2);
  166. }
  167. | tPATH tSTRING
  168.    {
  169.     WsCompiler *compiler = (WsCompiler *) pctx;
  171.     /* Pass this to the byte-code */
  172.     if (!ws_bc_add_pragma_access_path(compiler->bc, $2->data,
  173.       $2->len))
  174.         ws_error_memory(pctx);
  176.     ws_lexer_free_utf8(compiler, $2);
  177. }
  178. | tDOMAIN tSTRING tPATH tSTRING
  179.    {
  180.     WsCompiler *compiler = (WsCompiler *) pctx;
  181.     WsBool success = WS_TRUE;
  183.     /* Pass these to the byte-code */
  184.     if (!ws_bc_add_pragma_access_domain(compiler->bc, $2->data,
  185.         $2->len))
  186.         success = WS_FALSE;
  188.     if (!ws_bc_add_pragma_access_path(compiler->bc, $4->data,
  189.       $4->len))
  190.         success = WS_FALSE;
  192.     if (!success)
  193.         ws_error_memory(pctx);
  195.     ws_lexer_free_utf8(compiler, $2);
  196.     ws_lexer_free_utf8(compiler, $4);
  197. }
  198. ;
  200. MetaPragma:
  201.   tMETA MetaSpecifier
  202. ;
  204. MetaSpecifier:
  205.   MetaName
  206. | MetaHttpEquiv
  207. | MetaUserAgent
  208. ;
  210. MetaName:
  211.   tNAME MetaBody
  212. {
  213.     WsCompiler *compiler = (WsCompiler *) pctx;
  215.     /* Meta information for the origin servers.  Show it
  216.                      * to the user if requested. */
  217.     if (compiler->params.meta_name_cb)
  218.         (*compiler->params.meta_name_cb)(
  219. $2->property_name, $2->content,
  220. $2->scheme,
  221. compiler->params.meta_name_cb_context);
  223.     /* We do not need the MetaBody anymore. */
  224.     ws_pragma_meta_body_free(compiler, $2);
  225. }
  226. ;
  228. MetaHttpEquiv:
  229.   tHTTP tEQUIV MetaBody
  230.    {
  231.     WsCompiler *compiler = (WsCompiler *) pctx;
  233.     /* Meta information HTTP header that should be
  234.                      * included to an HTTP response header.  Show it to
  235.                      * the user if requested. */
  236.     if (compiler->params.meta_http_equiv_cb)
  237.         (*compiler->params.meta_http_equiv_cb)(
  238. $3->property_name,
  239. $3->content,
  240. $3->scheme,
  241. compiler->params.meta_http_equiv_cb_context);
  243.     /* We do not need the MetaBody anymore. */
  244.     ws_pragma_meta_body_free(compiler, $3);
  245. }
  246. ;
  248. MetaUserAgent:
  249.   tUSER tAGENT MetaBody
  250. {
  251.     WsBool success;
  252.     WsCompiler *compiler = (WsCompiler *) pctx;
  254.     /* Pass this pragma to the byte-code */
  255.     if ($3) {
  256.         if ($3->scheme)
  257.        success
  258.   = ws_bc_add_pragma_user_agent_property_and_scheme(
  259. compiler->bc,
  260. $3->property_name->data,
  261. $3->property_name->len,
  262. $3->content->data,
  263. $3->content->len,
  264. $3->scheme->data,
  265. $3->scheme->len);
  266.         else
  267.        success = ws_bc_add_pragma_user_agent_property(
  268. compiler->bc,
  269. $3->property_name->data,
  270. $3->property_name->len,
  271. $3->content->data,
  272. $3->content->len);
  274.         /* Free the MetaBody. */
  275.         ws_pragma_meta_body_free(compiler, $3);
  277.         if (!success)
  278.        ws_error_memory(pctx);
  279.     }
  280. }
  281. ;
  283. MetaBody:
  284.   MetaPropertyName MetaContent
  285. { $$ = ws_pragma_meta_body(pctx, $1, $2, NULL); }
  286. | MetaPropertyName MetaContent MetaScheme
  287. { $$ = ws_pragma_meta_body(pctx, $1, $2, $3); }
  288. ;
  290. MetaPropertyName: tSTRING;
  291. MetaContent: tSTRING;
  292. MetaScheme: tSTRING;
  294. /* Function declarations. */
  296. FunctionDeclarations:
  297.   FunctionDeclaration
  298. | FunctionDeclarations FunctionDeclaration
  299. ;
  301. FunctionDeclaration:
  302.   ExternOpt tFUNCTION tIDENTIFIER '(' FormalParameterListOpt ')' Block
  303.   SemicolonOpt
  304. {
  305.     char *name = ws_strdup($3);
  307.     ws_lexer_free_block(pctx, $3);
  309.     if (name)
  310.         ws_function(pctx, $1, name, @3.first_line, $5, $7);
  311.     else
  312.         ws_error_memory(pctx);
  313. }
  314. ;
  316. ExternOpt:
  317.   /* empty */ { $$ = WS_FALSE; }
  318. | tEXTERN { $$ = WS_TRUE;  }
  319. ;
  321. FormalParameterListOpt:
  322.   /* empty */
  323. { $$ = ws_list_new(pctx); }
  324. | FormalParameterList
  325. ;
  327. SemicolonOpt:
  328.   /* empty */
  329. | ';'
  330. ;
  332. FormalParameterList:
  333.   tIDENTIFIER
  334. {
  335.                     char *id;
  336.                     WsFormalParm *parm;
  338.     id = ws_f_strdup(((WsCompiler *) pctx)->pool_stree, $1);
  339.                     parm = ws_formal_parameter(pctx, @1.first_line, id);
  341.     ws_lexer_free_block(pctx, $1);
  343.     if (id == NULL || parm == NULL) {
  344.         ws_error_memory(pctx);
  345.         $$ = NULL;
  346.     } else {
  347.         $$ = ws_list_new(pctx);
  348.         ws_list_append(pctx, $$, parm);
  349.     }
  350. }
  351. | FormalParameterList ',' tIDENTIFIER
  352. {
  353.                     char *id;
  354.                     WsFormalParm *parm;
  356.     id = ws_f_strdup(((WsCompiler *) pctx)->pool_stree, $3);
  357.                     parm = ws_formal_parameter(pctx, @1.first_line, id);
  359.     ws_lexer_free_block(pctx, $3);
  361.     if (id == NULL || parm == NULL) {
  362.         ws_error_memory(pctx);
  363.         $$ = NULL;
  364.     } else
  365.         ws_list_append(pctx, $1, parm);
  366. }
  367. ;
  369. /* Statements. */
  371. Statement:
  372.   Block
  373. {
  374.     if ($1)
  375.         $$ = ws_stmt_block(pctx, $1->first_line, $1->last_line,
  376.            $1);
  377.     else
  378.         $$ = NULL;
  379. }
  380. | VariableStatement
  381. | ';' /* EmptyStatement */
  382. { $$ = ws_stmt_empty(pctx, @1.first_line); }
  383. | Expression ';' /* ExpressionStatement */
  384. { $$ = ws_stmt_expr(pctx, $1->line, $1); }
  385. | IfStatement
  386. | IterationStatement
  387. | tCONTINUE ';' /* ContinueStatement */
  388. { $$ = ws_stmt_continue(pctx, @1.first_line); }
  389. | tBREAK ';' /* BreakStatement */
  390. { $$ = ws_stmt_break(pctx, @1.first_line); }
  391. | ReturnStatement
  392. ;
  394. Block: '{' StatementListOpt '}'
  395. {
  396.     $$ = $2;
  397.     if ($$) {
  398.         $$->first_line = @1.first_line;
  399.         $$->last_line = @3.first_line;
  400.     }
  401. }
  402. | error
  403. {
  404.     ws_error_syntax(pctx, @2.first_line);
  405.     $$ = NULL;
  406. }
  407. ;
  409. StatementListOpt:
  410.   /* empty */
  411. { $$ = ws_list_new(pctx); }
  412. | StatementList
  413. ;
  415. StatementList:
  416.   Statement
  417. {
  418.     $$ = ws_list_new(pctx);
  419.     ws_list_append(pctx, $$, $1);
  420. }
  421. | StatementList Statement
  422. { ws_list_append(pctx, $1, $2); }
  423. ;
  425. VariableStatement:
  426.   tVAR VariableDeclarationList ';'
  427. { $$ = ws_stmt_variable(pctx, @1.first_line, $2); }
  428. | tVAR error
  429. { ws_error_syntax(pctx, @2.first_line); }
  430. ;
  432. VariableDeclarationList:
  433.   VariableDeclaration
  434. {
  435.     $$ = ws_list_new(pctx);
  436.     ws_list_append(pctx, $$, $1);
  437. }
  438. | VariableDeclarationList ',' VariableDeclaration
  439. { ws_list_append(pctx, $1, $3); }
  440. ;
  442. VariableDeclaration:
  443.   tIDENTIFIER VariableInitializedOpt
  444. {
  445.     char *id = ws_f_strdup(((WsCompiler *) pctx)->pool_stree,
  446.    $1);
  448.     ws_lexer_free_block(pctx, $1);
  449.     if (id == NULL) {
  450.         ws_error_memory(pctx);
  451.         $$ = NULL;
  452.     } else
  453.         $$ = ws_variable_declaration(pctx, id, $2);
  454. }
  455. ;
  457. VariableInitializedOpt:
  458.   /* empty */
  459. { $$ = NULL; }
  460. | '=' ConditionalExpression
  461. { $$ = $2; }
  462. ;
  464. IfStatement:
  465.   tIF '(' Expression ')' Statement tELSE Statement
  466. { $$ = ws_stmt_if(pctx, @1.first_line, $3, $5, $7); }
  467. | tIF '(' Expression ')' Statement
  468. { $$ = ws_stmt_if(pctx, @1.first_line, $3, $5, NULL); }
  469. ;
  471. IterationStatement:
  472.   tWHILE '(' Expression ')' Statement
  473. { $$ = ws_stmt_while(pctx, @1.first_line, $3, $5); }
  474. | ForStatement
  475. ;
  477. ForStatement:
  478.   tFOR '(' ExpressionOpt ';' ExpressionOpt ';' ExpressionOpt ')'
  479. Statement
  480.    { $$ = ws_stmt_for(pctx, @1.first_line, NULL, $3, $5, $7, $9); }
  481. | tFOR '(' tVAR VariableDeclarationList ';' ExpressionOpt ';'
  482.         ExpressionOpt ')' Statement
  483.    { $$ = ws_stmt_for(pctx, @1.first_line, $4, NULL, $6, $8, $10); }
  484. ;
  486. ReturnStatement:
  487.   tRETURN ExpressionOpt ';'
  488. { $$ = ws_stmt_return(pctx, @1.first_line, $2); }
  489. ;
  491. /* Expressions. */
  493. ExpressionOpt:
  494.   /* empty */ { $$ = NULL; }
  495. | Expression
  496. ;
  499. Expression:
  500.   AssignmentExpression
  501. | Expression ',' AssignmentExpression
  502. { $$ = ws_expr_comma(pctx, @2.first_line, $1, $3); }
  503. ;
  505. AssignmentExpression:
  506.   ConditionalExpression
  507. | tIDENTIFIER '=' AssignmentExpression
  508. { $$ = ws_expr_assign(pctx, @1.first_line, $1, '=', $3); }
  509. | tIDENTIFIER tMULA AssignmentExpression
  510. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tMULA, $3); }
  511. | tIDENTIFIER tDIVA AssignmentExpression
  512. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tDIVA, $3); }
  513. | tIDENTIFIER tREMA AssignmentExpression
  514. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tREMA, $3); }
  515. | tIDENTIFIER tADDA AssignmentExpression
  516. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tADDA, $3); }
  517. | tIDENTIFIER tSUBA AssignmentExpression
  518. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tSUBA, $3); }
  519. | tIDENTIFIER tLSHIFTA AssignmentExpression
  520. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tLSHIFTA, $3); }
  521. | tIDENTIFIER tRSSHIFTA AssignmentExpression
  522. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tRSSHIFTA, $3); }
  523. | tIDENTIFIER tRSZSHIFTA AssignmentExpression
  524. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tRSZSHIFTA, $3); }
  525. | tIDENTIFIER tANDA AssignmentExpression
  526. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tANDA, $3); }
  527. | tIDENTIFIER tXORA AssignmentExpression
  528. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tXORA, $3); }
  529. | tIDENTIFIER tORA AssignmentExpression
  530. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tORA, $3); }
  531. | tIDENTIFIER tIDIVA AssignmentExpression
  532. { $$ = ws_expr_assign(pctx, @1.first_line, $1, tIDIVA, $3); }
  533. ;
  535. ConditionalExpression:
  536.   LogicalORExpression
  537. | LogicalORExpression '?' AssignmentExpression ':' AssignmentExpression
  538. { $$ = ws_expr_conditional(pctx, @2.first_line, $1, $3, $5); }
  539. ;
  541. LogicalORExpression:
  542.   LogicalANDExpression
  543. | LogicalORExpression tOR LogicalANDExpression
  544. { $$ = ws_expr_logical(pctx, @2.first_line, WS_ASM_SCOR, $1, $3); }
  545. ;
  547. LogicalANDExpression:
  548.   BitwiseORExpression
  549. | LogicalANDExpression tAND BitwiseORExpression
  550. { $$ = ws_expr_logical(pctx, @2.first_line, WS_ASM_SCAND, $1, $3); }
  551. ;
  553. BitwiseORExpression:
  554.   BitwiseXORExpression
  555. | BitwiseORExpression '|' BitwiseXORExpression
  556. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_OR, $1, $3); }
  557. ;
  559. BitwiseXORExpression:
  560.   BitwiseANDExpression
  561. | BitwiseXORExpression '^' BitwiseANDExpression
  562. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_XOR, $1, $3); }
  563. ;
  565. BitwiseANDExpression:
  566.   EqualityExpression
  567. | BitwiseANDExpression '&' EqualityExpression
  568. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_AND, $1, $3); }
  569. ;
  571. EqualityExpression:
  572.   RelationalExpression
  573. | EqualityExpression tEQ RelationalExpression
  574. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_EQ, $1, $3); }
  575. | EqualityExpression tNE RelationalExpression
  576. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_NE, $1, $3); }
  577. ;
  579. RelationalExpression:
  580.   ShiftExpression
  581. | RelationalExpression '<' ShiftExpression
  582. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_LT, $1, $3); }
  583. | RelationalExpression '>' ShiftExpression
  584. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_GT, $1, $3); }
  585. | RelationalExpression tLE ShiftExpression
  586. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_LE, $1, $3); }
  587. | RelationalExpression tGE ShiftExpression
  588. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_GE, $1, $3); }
  589. ;
  591. ShiftExpression:
  592.   AdditiveExpression
  593. | ShiftExpression tLSHIFT AdditiveExpression
  594. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_LSHIFT, $1, $3); }
  595. | ShiftExpression tRSSHIFT AdditiveExpression
  596. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_RSSHIFT, $1, $3); }
  597. | ShiftExpression tRSZSHIFT AdditiveExpression
  598. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_B_RSZSHIFT, $1, $3); }
  599. ;
  601. AdditiveExpression:
  602.   MultiplicativeExpression
  603. | AdditiveExpression '+' MultiplicativeExpression
  604. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_ADD, $1, $3); }
  605. | AdditiveExpression '-' MultiplicativeExpression
  606. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_SUB, $1, $3); }
  607. ;
  609. MultiplicativeExpression:
  610.   UnaryExpression
  611. | MultiplicativeExpression '*' UnaryExpression
  612. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_MUL, $1, $3); }
  613. | MultiplicativeExpression '/' UnaryExpression
  614. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_DIV, $1, $3); }
  615. | MultiplicativeExpression tIDIV UnaryExpression
  616. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_IDIV, $1, $3); }
  617. | MultiplicativeExpression '%' UnaryExpression
  618. { $$ = ws_expr_binary(pctx, @2.first_line, WS_ASM_REM, $1, $3); }
  619. ;
  621. UnaryExpression:
  622.   PostfixExpression
  623. | tTYPEOF UnaryExpression
  624. { $$ = ws_expr_unary(pctx, @1.first_line, WS_ASM_TYPEOF, $2); }
  625. | tISVALID UnaryExpression
  626. { $$ = ws_expr_unary(pctx, @1.first_line, WS_ASM_ISVALID, $2); }
  627. | tPLUSPLUS tIDENTIFIER
  628. { $$ = ws_expr_unary_var(pctx, @1.first_line, WS_TRUE, $2); }
  629. | tMINUSMINUS tIDENTIFIER
  630. { $$ = ws_expr_unary_var(pctx, @1.first_line, WS_FALSE, $2); }
  631. | '+' UnaryExpression
  632. {
  633.                     /* There is no direct way to compile unary `+'.
  634.                      * It doesn't do anything except require type conversion
  635.      * (section 7.2, 7.3.2), and we do that by converting
  636.      * it to a binary expression: `UnaryExpression - 0'.
  637.                      * Using `--UnaryExpression' would not be correct because
  638.                      * it might overflow if UnaryExpression is the smallest
  639.                      * possible integer value (see 6.2.7.1).
  640.                      * Using `UnaryExpression + 0' would not be correct
  641.                      * because binary `+' accepts strings, which makes the
  642.      * type conversion different.
  643.                      */
  644.                     $$ = ws_expr_binary(pctx, @1.first_line, WS_ASM_SUB, $2,
  645.                               ws_expr_const_integer(pctx, @1.first_line, 0));
  646. }
  647. | '-' UnaryExpression
  648. { $$ = ws_expr_unary(pctx, @1.first_line, WS_ASM_UMINUS, $2); }
  649. | '~' UnaryExpression
  650. { $$ = ws_expr_unary(pctx, @1.first_line, WS_ASM_B_NOT, $2); }
  651. | '!' UnaryExpression
  652. { $$ = ws_expr_unary(pctx, @1.first_line, WS_ASM_NOT, $2); }
  653. ;
  655. PostfixExpression:
  656.   CallExpression
  657. | tIDENTIFIER tPLUSPLUS
  658. { $$ = ws_expr_postfix_var(pctx, @1.first_line, WS_TRUE, $1); }
  659. | tIDENTIFIER tMINUSMINUS
  660. { $$ = ws_expr_postfix_var(pctx, @1.first_line, WS_FALSE, $1); }
  661. ;
  663. CallExpression:
  664.   PrimaryExpression
  665. | tIDENTIFIER Arguments                 /* LocalScriptFunctionCall */
  666. {
  667.     WsFunctionHash *f = ws_function_hash(pctx, $1);
  669.     /* Add an usage count for the local script function. */
  670.     if (f)
  671.       f->usage_count++;
  673.     $$ = ws_expr_call(pctx, @1.first_line, ' ', NULL, $1, $2);
  674. }
  675. | tIDENTIFIER '#' tIDENTIFIER Arguments /* ExternalScriptFunctionCall*/
  676. { $$ = ws_expr_call(pctx, @3.first_line, '#', $1, $3, $4); }
  677. | tIDENTIFIER '.' tIDENTIFIER Arguments /* LibraryFunctionCall */
  678. { $$ = ws_expr_call(pctx, @3.first_line, '.', $1, $3, $4); }
  679. ;
  681. PrimaryExpression:
  682.   tIDENTIFIER
  683. { $$ = ws_expr_symbol(pctx, @1.first_line, $1); }
  684. | tINVALID
  685. { $$ = ws_expr_const_invalid(pctx, @1.first_line); }
  686. | tTRUE
  687. { $$ = ws_expr_const_true(pctx, @1.first_line); }
  688. | tFALSE
  689. { $$ = ws_expr_const_false(pctx, @1.first_line); }
  690. | tINTEGER
  691. { $$ = ws_expr_const_integer(pctx, @1.first_line, $1); }
  692. | tFLOAT
  693. { $$ = ws_expr_const_float(pctx, @1.first_line, $1); }
  694. | tSTRING
  695. { $$ = ws_expr_const_string(pctx, @1.first_line, $1); }
  696. | '(' Expression ')'
  697. { $$ = $2; }
  698. ;
  700. Arguments:
  701.   '(' ')'
  702. { $$ = ws_list_new(pctx); }
  703. | '(' ArgumentList ')'
  704. { $$ = $2; }
  705. ;
  707. ArgumentList:
  708.   AssignmentExpression
  709. {
  710.     $$ = ws_list_new(pctx);
  711.     ws_list_append(pctx, $$, $1);
  712. }
  713. | ArgumentList ',' AssignmentExpression
  714. { ws_list_append(pctx, $1, $3); }
  715. ;
  717. %%
  719. void
  720. yyerror(char *msg)
  721. {
  722. #if WS_DEBUG
  723.   fprintf(stderr, "*** %s:%d: wsc: %s - this msg will be removed ***n",
  724.   global_compiler->input_name, global_compiler->linenum, msg);
  725. #endif /* WS_DEBUG */
  726. }