1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
%name cl_ucsim_parser
%{
#include "cmdlexcl.h"
#include "memcl.h"
#include "globals.h"
#include "stypes.h"
%}
%pure_parser
%define INHERIT : public cl_base
%define MEMBERS class cl_ucsim_lexer *lexer_object;\
virtual ~YY_cl_ucsim_parser_CLASS(void) { delete lexer_object; }
%define CONSTRUCTOR_PARAM \
class cl_ucsim_lexer *the_lexer
%define CONSTRUCTOR_CODE \
lexer_object= the_lexer;
%token PTOK_PLUS PTOK_MINUS PTOK_ASTERIX PTOK_SLASH PTOK_EQUAL
%token PTOK_LEFT_PAREN PTOK_RIGHT_PAREN
%token PTOK_LEFT_BRACKET PTOK_RIGHT_BRACKET
%token PTOK_DOT PTOK_AMPERSAND
%token <memory_object> PTOK_MEMORY_OBJECT
%token <memory> PTOK_MEMORY
%token <number> PTOK_NUMBER
%token <bit> PTOK_BIT
%right PTOK_EQUAL
%left PTOK_MINUS PTOK_PLUS
%left PTOK_ASTERIX PTOK_SLASH
%nonassoc UNARYMINUS PTOK_AMPERSAND
%nonassoc PTOK_LEFT_PAREN PTOK_RIGHT_PAREN
%type <number> ucsim_grammar assignment expression address_of_expression
%type <memory> memory
%type <bit> bit
%union {
long number;
class cl_memory *memory_object;
struct {
class cl_memory *memory;
long address;
} memory;
struct {
class cl_memory *memory;
long mem_address, bit_address;
long mask;
} bit;
}
%%
ucsim_grammar:
expression { application->dd_printf("%d\n", $1); }
;
assignment:
memory PTOK_EQUAL expression
{
$1.memory->write($1.address, $3);
$$= $3;
}
| bit PTOK_EQUAL expression
{
if ($3)
{
$1.memory->write($1.mem_address,
$1.memory->read($1.mem_address) | $1.mask);
$$= 1;
}
else
{
$1.memory->write($1.mem_address,
$1.memory->read($1.mem_address) & ~($1.mask));
$$= 0;
}
}
;
expression:
assignment { $$= $1; }
| expression PTOK_PLUS expression { $$= $1 + $3; }
| expression PTOK_MINUS expression { $$= $1 - $3; }
| expression PTOK_ASTERIX expression { $$= $1 * $3; }
| expression PTOK_SLASH expression
{
if ($3 == 0)
yyerror((char *)"Divide by zero");
else
$$= $1 / $3;
}
| PTOK_MINUS expression %prec UNARYMINUS { $$= -$2; }
| address_of_expression { $$= $1; }
| PTOK_LEFT_PAREN expression PTOK_RIGHT_PAREN { $$= $2; }
| PTOK_NUMBER { $$= $1; }
| memory { $$= $1.memory->read($1.address); }
| bit { $$= ($1.memory->read($1.mem_address) & $1.mask)?1:0; }
;
address_of_expression:
PTOK_AMPERSAND memory { $$= $2.address; }
| PTOK_AMPERSAND bit
{
$$= $2.bit_address;
if ($$ < 0)
{
yyerror((char *)"Bit has no address.");
$$= 0;
}
}
;
memory:
PTOK_MEMORY
| PTOK_MEMORY_OBJECT PTOK_LEFT_BRACKET expression PTOK_RIGHT_BRACKET
{
$$.memory= $1;
$$.address= $3;
}
bit:
PTOK_BIT
| memory PTOK_DOT expression
{
$$.memory= $1.memory;
$$.mem_address= $1.address;
$$.mask= 1 << $3;
$$.bit_address= -1;
class cl_uc *uc= application->get_uc();
if (uc)
$$.bit_address= uc->bit_address($1.memory, $1.address, $3);
}
;
%%
int
YY_cl_ucsim_parser_CLASS::yylex(YY_cl_ucsim_parser_STYPE *yylval)
{
lexer_object->activate_lexer_to_parse_into(yylval);
return(lexer_object->yylex());
}
void
YY_cl_ucsim_parser_CLASS::yyerror(char *msg)
{
application->dd_printf("Parser error: %s\n", msg);
}
|
