author  Ryan C. Gordon <icculus@icculus.org> 
Tue, 09 Feb 2010 00:08:12 0500  
branch  calculatorexperiment 
changeset 824  f4b3ba2b435d 
parent 823  48757134a880 
child 826  59a6a8aa7d87 
permissions  rwrr 
811
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

1 
/** 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

2 
* MojoShader; generate shader programs from bytecode of compiled 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

3 
* Direct3D shaders. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

4 
* 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

5 
* Please see the file LICENSE.txt in the source's root directory. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

6 
* 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

7 
* This file written by Ryan C. Gordon. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

8 
*/ 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

9 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

10 
// This is a Lemon Parser grammar for HLSL. It is based on an ANSI C YACC 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

11 
// grammar by Jeff Lee: http://www.lysator.liu.se/c/ANSICgrammary.html 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

12 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

13 
// Lemon is here: http://www.hwaci.com/sw/lemon/ ... the source is included 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

14 
// with MojoShader, and built with the library, so you don't have to track 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

15 
// down the dependency. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

16 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

17 
%name ParseCalculator 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

18 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

19 
// Some shiftreduce conflicts are basically unavoidable, but if the final 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

20 
// conflict count matches this value, we consider it known and acceptable. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

21 
%expect 0 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

22 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

23 
%start_symbol calculator 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

24 
%token_prefix TOKEN_CALC_ 
816
dd3e3e03b7ce
Fixed literal data getting through the parser in one piece.
Ryan C. Gordon <icculus@icculus.org>
parents:
815
diff
changeset

25 
%token_type { TokenData } 
811
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

26 
%extra_argument { Context *ctx } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

27 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

28 
%include { 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

29 
#ifndef __MOJOSHADER_CALC_COMPILER__ 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

30 
#error Do not compile this file directly. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

31 
#endif 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

32 
} 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

33 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

34 
%syntax_error { 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

35 
fprintf(stderr,"Syntax error\n"); 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

36 
} 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

37 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

38 
%parse_failure { 
820
fd001ff71c65
Stop parsing if the parser panics.
Ryan C. Gordon <icculus@icculus.org>
parents:
816
diff
changeset

39 
ctx>isfail = 1; 
fd001ff71c65
Stop parsing if the parser panics.
Ryan C. Gordon <icculus@icculus.org>
parents:
816
diff
changeset

40 
fprintf(stderr, "Giving up. Parser is hopelessly lost...\n"); 
fd001ff71c65
Stop parsing if the parser panics.
Ryan C. Gordon <icculus@icculus.org>
parents:
816
diff
changeset

41 

811
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

42 
} 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

43 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

44 
%stack_overflow { 
820
fd001ff71c65
Stop parsing if the parser panics.
Ryan C. Gordon <icculus@icculus.org>
parents:
816
diff
changeset

45 
ctx>isfail = 1; 
fd001ff71c65
Stop parsing if the parser panics.
Ryan C. Gordon <icculus@icculus.org>
parents:
816
diff
changeset

46 
fprintf(stderr, "Giving up. Parser stack overflow\n"); 
811
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

47 
} 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

48 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

49 
// operator precedence (matches C spec)... 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

50 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

51 
%left COMMA. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

52 
%right ASSIGN ADDASSIGN SUBASSIGN MULASSIGN DIVASSIGN MODASSIGN LSHIFTASSIGN 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

53 
RSHIFTASSIGN ANDASSIGN ORASSIGN XORASSIGN. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

54 
%right QUESTION. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

55 
%left OROR. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

56 
%left ANDAND. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

57 
%left OR. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

58 
%left XOR. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

59 
%left AND. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

60 
%left EQL NEQ. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

61 
%left LT LEQ GT GEQ. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

62 
%left LSHIFT RSHIFT. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

63 
%left PLUS MINUS. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

64 
%left STAR SLASH PERCENT. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

65 
%right TYPECAST EXCLAMATION COMPLEMENT MINUSMINUS PLUSPLUS. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

66 
%left DOT LBRACKET RBRACKET LPAREN RPAREN. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

67 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

68 
// bump up the precedence of ELSE, to avoid shift/reduce conflict on the 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

69 
// usual "dangling else ambiguity" ... 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

70 
%right ELSE. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

71 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

72 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

73 
// The rules... 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

74 

824
f4b3ba2b435d
"identifier" shouldn't be a nonterminal.
Ryan C. Gordon <icculus@icculus.org>
parents:
823
diff
changeset

75 
%type calculator { int } // !!! FIXME: remove this later. 
f4b3ba2b435d
"identifier" shouldn't be a nonterminal.
Ryan C. Gordon <icculus@icculus.org>
parents:
823
diff
changeset

76 
%destructor calculator { (void) ctx; } // !!! FIXME: remove this later. 
822
fa78ed1fe469
Free the parse tree once we're done with it.
Ryan C. Gordon <icculus@icculus.org>
parents:
820
diff
changeset

77 
calculator ::= expression(B). { parse_complete(ctx, B); } 
811
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

78 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

79 
// the expression stuff is based on Jeff Lee's ANSI C grammar. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

80 
%type primary_expr { Expression * } 
824
f4b3ba2b435d
"identifier" shouldn't be a nonterminal.
Ryan C. Gordon <icculus@icculus.org>
parents:
823
diff
changeset

81 
primary_expr(A) ::= IDENTIFIER(B). { A = new_identifier_expr(ctx, &B); } 
816
dd3e3e03b7ce
Fixed literal data getting through the parser in one piece.
Ryan C. Gordon <icculus@icculus.org>
parents:
815
diff
changeset

82 
primary_expr(A) ::= INT_CONSTANT(B). { A = new_literal_int_expr(ctx, &B); } 
dd3e3e03b7ce
Fixed literal data getting through the parser in one piece.
Ryan C. Gordon <icculus@icculus.org>
parents:
815
diff
changeset

83 
primary_expr(A) ::= FLOAT_CONSTANT(B). { A = new_literal_float_expr(ctx, &B); } 
dd3e3e03b7ce
Fixed literal data getting through the parser in one piece.
Ryan C. Gordon <icculus@icculus.org>
parents:
815
diff
changeset

84 
primary_expr(A) ::= STRING_LITERAL(B). { A = new_literal_string_expr(ctx, &B); } 
811
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

85 
primary_expr(A) ::= LPAREN expression(B) RPAREN. { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

86 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

87 
%type postfix_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

88 
postfix_expr(A) ::= primary_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

89 
postfix_expr(A) ::= postfix_expr(B) LBRACKET expression(C) RBRACKET. { A = new_binary_expr(ctx, OP_DEREF_ARRAY, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

90 
postfix_expr(A) ::= postfix_expr(B) LPAREN RPAREN. { A = new_binary_expr(ctx, OP_CALLFUNC, B, NULL); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

91 
postfix_expr(A) ::= postfix_expr(B) LPAREN argument_expr_list(C) RPAREN. { A = new_binary_expr(ctx, OP_CALLFUNC, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

92 
//postfix_expr(A) ::= datatype(B) LPAREN argument_expr_list(C) RPAREN. { A = new_constructor_expr(ctx, B, C); } // HLSL constructor 
824
f4b3ba2b435d
"identifier" shouldn't be a nonterminal.
Ryan C. Gordon <icculus@icculus.org>
parents:
823
diff
changeset

93 
postfix_expr(A) ::= postfix_expr(B) DOT IDENTIFIER(C). { A = new_binary_expr(ctx, OP_DEREF_STRUCT, B, new_identifier_expr(ctx, &C)); } 
811
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

94 
postfix_expr(A) ::= postfix_expr(B) PLUSPLUS. { A = new_unary_expr(ctx, OP_POSTINCREMENT, B); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

95 
postfix_expr(A) ::= postfix_expr(B) MINUSMINUS. { A = new_unary_expr(ctx, OP_POSTDECREMENT, B); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

96 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

97 
%type argument_expr_list { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

98 
argument_expr_list(A) ::= assignment_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

99 
argument_expr_list(A) ::= argument_expr_list(B) COMMA assignment_expr(C). { A = new_binary_expr(ctx, OP_COMMA, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

100 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

101 
%type unary_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

102 
unary_expr(A) ::= postfix_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

103 
unary_expr(A) ::= PLUSPLUS unary_expr(B). { A = new_unary_expr(ctx, OP_PREINCREMENT, B); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

104 
unary_expr(A) ::= MINUSMINUS unary_expr(B). { A = new_unary_expr(ctx, OP_PREDECREMENT, B); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

105 
unary_expr(A) ::= PLUS cast_expr(B). { A = B; } // unary "+x" is always a noop, so throw it away here. 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

106 
unary_expr(A) ::= MINUS cast_expr(B). { A = new_unary_expr(ctx, OP_NEGATE, B); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

107 
unary_expr(A) ::= COMPLEMENT cast_expr(B). { A = new_unary_expr(ctx, OP_COMPLEMENT, B); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

108 
unary_expr(A) ::= EXCLAMATION cast_expr(B). { A = new_unary_expr(ctx, OP_NOT, B); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

109 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

110 
%type cast_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

111 
cast_expr(A) ::= unary_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

112 
//cast_expr(A) ::= LPAREN datatype(B) RPAREN cast_expr(C). { A = new_cast_expr(ctx, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

113 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

114 
%type multiplicative_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

115 
multiplicative_expr(A) ::= cast_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

116 
multiplicative_expr(A) ::= multiplicative_expr(B) STAR cast_expr(C). { A = new_binary_expr(ctx, OP_MULTIPLY, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

117 
multiplicative_expr(A) ::= multiplicative_expr(B) SLASH cast_expr(C). { A = new_binary_expr(ctx, OP_DIVIDE, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

118 
multiplicative_expr(A) ::= multiplicative_expr(B) PERCENT cast_expr(C). { A = new_binary_expr(ctx, OP_MODULO, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

119 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

120 
%type additive_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

121 
additive_expr(A) ::= multiplicative_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

122 
additive_expr(A) ::= additive_expr(B) PLUS multiplicative_expr(C). { A = new_binary_expr(ctx, OP_ADD, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

123 
additive_expr(A) ::= additive_expr(B) MINUS multiplicative_expr(C). { A = new_binary_expr(ctx, OP_SUBTRACT, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

124 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

125 
%type shift_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

126 
shift_expr(A) ::= additive_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

127 
shift_expr(A) ::= shift_expr(B) LSHIFT additive_expr(C). { A = new_binary_expr(ctx, OP_LSHIFT, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

128 
shift_expr(A) ::= shift_expr(B) RSHIFT additive_expr(C). { A = new_binary_expr(ctx, OP_RSHIFT, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

129 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

130 
%type relational_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

131 
relational_expr(A) ::= shift_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

132 
relational_expr(A) ::= relational_expr(B) LT shift_expr(C). { A = new_binary_expr(ctx, OP_LESSTHAN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

133 
relational_expr(A) ::= relational_expr(B) GT shift_expr(C). { A = new_binary_expr(ctx, OP_GREATERTHAN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

134 
relational_expr(A) ::= relational_expr(B) LEQ shift_expr(C). { A = new_binary_expr(ctx, OP_LESSTHANOREQUAL, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

135 
relational_expr(A) ::= relational_expr(B) GEQ shift_expr(C). { A = new_binary_expr(ctx, OP_GREATERTHANOREQUAL, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

136 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

137 
%type equality_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

138 
equality_expr(A) ::= relational_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

139 
equality_expr(A) ::= equality_expr(B) EQL relational_expr(C). { A = new_binary_expr(ctx, OP_EQUAL, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

140 
equality_expr(A) ::= equality_expr(B) NEQ relational_expr(C). { A = new_binary_expr(ctx, OP_NOTEQUAL, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

141 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

142 
%type and_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

143 
and_expr(A) ::= equality_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

144 
and_expr(A) ::= and_expr(B) AND equality_expr(C). { A = new_binary_expr(ctx, OP_BINARYAND, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

145 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

146 
%type exclusive_or_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

147 
exclusive_or_expr(A) ::= and_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

148 
exclusive_or_expr(A) ::= exclusive_or_expr(B) XOR and_expr(C). { A = new_binary_expr(ctx, OP_BINARYXOR, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

149 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

150 
%type inclusive_or_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

151 
inclusive_or_expr(A) ::= exclusive_or_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

152 
inclusive_or_expr(A) ::= inclusive_or_expr(B) OR exclusive_or_expr(C). { A = new_binary_expr(ctx, OP_BINARYOR, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

153 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

154 
%type logical_and_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

155 
logical_and_expr(A) ::= inclusive_or_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

156 
logical_and_expr(A) ::= logical_and_expr(B) ANDAND inclusive_or_expr(C). { A = new_binary_expr(ctx, OP_LOGICALAND, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

157 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

158 
%type logical_or_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

159 
logical_or_expr(A) ::= logical_and_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

160 
logical_or_expr(A) ::= logical_or_expr(B) OROR logical_and_expr(C). { A = new_binary_expr(ctx, OP_LOGICALOR, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

161 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

162 
%type conditional_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

163 
conditional_expr(A) ::= logical_or_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

164 
conditional_expr(A) ::= logical_or_expr(B) QUESTION logical_or_expr(C) COLON conditional_expr(D). { A = new_ternary_expr(ctx, OP_CONDITIONAL, B, C, D); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

165 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

166 
%type assignment_expr { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

167 
assignment_expr(A) ::= conditional_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

168 
assignment_expr(A) ::= unary_expr(B) ASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_ASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

169 
assignment_expr(A) ::= unary_expr(B) MULASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_MULASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

170 
assignment_expr(A) ::= unary_expr(B) DIVASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_DIVASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

171 
assignment_expr(A) ::= unary_expr(B) MODASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_MODASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

172 
assignment_expr(A) ::= unary_expr(B) ADDASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_ADDASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

173 
assignment_expr(A) ::= unary_expr(B) SUBASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_SUBASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

174 
assignment_expr(A) ::= unary_expr(B) LSHIFTASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_LSHIFTASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

175 
assignment_expr(A) ::= unary_expr(B) RSHIFTASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_RSHIFTASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

176 
assignment_expr(A) ::= unary_expr(B) ANDASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_ANDASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

177 
assignment_expr(A) ::= unary_expr(B) XORASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_XORASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

178 
assignment_expr(A) ::= unary_expr(B) ORASSIGN assignment_expr(C). { A = new_binary_expr(ctx, OP_ORASSIGN, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

179 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

180 
%type expression { Expression * } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

181 
expression(A) ::= assignment_expr(B). { A = B; } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

182 
expression(A) ::= expression(B) COMMA assignment_expr(C). { A = new_binary_expr(ctx, OP_COMMA, B, C); } 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

183 

307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

184 
// end of calculator.lemon ... 
307e3ab506fa
Start of experiment with a basic calculator.
Ryan C. Gordon <icculus@icculus.org>
parents:
diff
changeset

185 