OpenCores
URL https://opencores.org/ocsvn/thor/thor/trunk

Subversion Repositories thor

[/] [thor/] [trunk/] [FT64v5/] [software/] [AS64/] [source/] [expr.cpp] - Blame information for rev 48

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 48 robfinch 
// ============================================================================
2 
//        __
3 
//   \\__/ o\    (C) 2014-2018  Robert Finch, Waterloo
4 
//    \  __ /    All rights reserved.
5 
//     \/_//     robfinch<remove>@finitron.ca
6 
//       ||
7 
//
8 
// AS64 - Assembler
9 
//  - 64 bit CPU
10 
//
11 
// This source file is free software: you can redistribute it and/or modify
12 
// it under the terms of the GNU Lesser General Public License as published
13 
// by the Free Software Foundation, either version 3 of the License, or
14 
// (at your option) any later version.
15 
//
16 
// This source file is distributed in the hope that it will be useful,
17 
// but WITHOUT ANY WARRANTY; without even the implied warranty of
18 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 
// GNU General Public License for more details.
20 
//
21 
// You should have received a copy of the GNU General Public License
22 
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
23 
//
24 
// ============================================================================
25 
//
26 
#include "stdafx.h"
27 
 
28 
int64_t expr();
29 
int nsym;
30 
 
31 
// id
32 
// const
33 
// (expr)
34 
// >expr
35 
int64_t primary()
36 
{
37 
    int64_t val;
38 
    SYM *sym;
39 
    static char buf[500];
40 
 
41 
        ZeroMemory(buf,sizeof(buf));
42 
    switch(token) {
43 
    case tk_id:
44 
         if (lastid[0]=='.')  // local label
45 
            sprintf(buf, "%s%s", current_label, lastid);
46 
         else
47 
             strcpy(buf, lastid);
48 
         sym = find_symbol(buf);
49 
         if (!sym)
50 
             sym = new_symbol(buf);
51 
         val = sym->value.low;
52 
         if (sym->segment < 5)
53 
             nsym++;
54 
         lastsym = sym;
55 
         NextToken();
56 
         if (token==tk_eol)
57 
            prevToken();
58 
         break;
59 
    case tk_icon:
60 
         val = ival.low;
61 
         NextToken();
62 
         if (token==tk_eol)
63 
            prevToken();
64 
         break;
65 
    case '\'':
66 
         inptr++;
67 
                 if (*inptr=='\\') {
68 
                         inptr++;
69 
                         switch(*inptr) {
70 
                         case '\r':     val = '\r'; NextToken(); expect('\''); return (val);
71 
                         case '\n':     val = '\n'; NextToken(); expect('\''); return (val);
72 
                         case '\t':     val = '\t'; NextToken(); expect('\''); return (val);
73 
                         case '\f':     val = '\f'; NextToken(); expect('\''); return (val);
74 
                         case '\b':     val = '\b'; NextToken(); expect('\''); return (val);
75 
                         }
76 
                 }
77 
         val = *inptr;
78 
         NextToken();
79 
         expect('\'');
80 
         break;
81 
    case '(':
82 
         NextToken();
83 
         val = expr();
84 
         expect(')');
85 
         break;
86 
    default:
87 
      if (token=='>' && gCpu==5) {
88 
        val = expr();
89 
        val >>= 12;
90 
      }
91 
      else if (token=='<' && gCpu==5) {
92 
        val = expr();
93 
        val &= 0xFFF;
94 
      }
95 
      else {
96 
       //printf("Syntax error.\r\n");
97 
       val = 0;
98 
       if (token != tk_eol)
99 
           NextToken();
100 
      }
101 
      break;
102 
    }
103 
    return val;
104 
}
105 
 
106 
// !unary
107 
// -unary
108 
// +unary
109 
// ~unary
110 
//  primary
111 
 
112 
int64_t unary()
113 
{
114 
    int64_t val;
115 
 
116 
    switch(token) {
117 
    case '!': NextToken(); return !unary();
118 
    case '-': NextToken(); return -unary();
119 
    case '+': NextToken(); return +unary();
120 
    case '~': NextToken(); return ~unary();
121 
    default:
122 
        return primary();
123 
    }
124 
}
125 
 
126 
// unary
127 
// unary [*/%] unary
128 
 
129 
int64_t mult_expr()
130 
{
131 
    int64_t val;
132 
 
133 
    val = unary();
134 
    while(1) {
135 
        switch(token) {
136 
        case '*': NextToken(); val = val * unary(); break;
137 
        case '/': NextToken(); val = val / unary(); break;
138 
        case '%': NextToken(); val = val % unary(); break;
139 
        default: goto j1;
140 
        }
141 
    }
142 
j1:
143 
    return val;
144 
}
145 
 
146 
// mult_expr
147 
// mult_expr [+-] add_expr_list
148 
//
149 
int64_t add_expr()
150 
{
151 
    int64_t val;
152 
 
153 
    val = mult_expr();
154 
    while (1) {
155 
        switch(token) {
156 
        case '+': NextToken(); val = val + mult_expr(); break;
157 
        case '-': NextToken(); val = val - mult_expr(); break;
158 
        default: goto j1;
159 
        }
160 
    }
161 
j1:
162 
    return val;
163 
}
164 
 
165 
int64_t shift_expr()
166 
{
167 
    int64_t val;
168 
 
169 
    val = add_expr();
170 
    while(1) {
171 
        switch(token) {
172 
        case tk_lshift: NextToken(); val = val << add_expr(); break;
173 
        case tk_rshift: NextToken(); val = val >> add_expr(); break;
174 
        default: goto j1;
175 
        }
176 
    }
177 
j1:
178 
    return val;
179 
}
180 
 
181 
int64_t relational_expr()
182 
{
183 
    int64_t val;
184 
 
185 
    val = shift_expr();
186 
    while (1) {
187 
        switch(token) {
188 
        case tk_lt: NextToken(); val = val <shift_expr(); break;
189 
        case tk_le: NextToken(); val = val<=shift_expr(); break;
190 
        case tk_gt: NextToken(); val = val >shift_expr(); break;
191 
        case tk_ge: NextToken(); val = val>=shift_expr(); break;
192 
        default: goto j1;
193 
        }
194 
    }
195 
j1:
196 
    return val;
197 
}
198 
 
199 
// relational_expr
200 
// relational_expr & equals_expr_list
201 
//
202 
int64_t equals_expr()
203 
{
204 
    int64_t val;
205 
 
206 
    val = relational_expr();
207 
    while (1) {
208 
        switch(token) {
209 
        case tk_eq: NextToken(); val = val == relational_expr(); break;
210 
        case tk_ne: NextToken(); val = val != relational_expr(); break;
211 
        default: goto j1;
212 
        }
213 
    }
214 
j1:
215 
    return val;
216 
}
217 
 
218 
// equals_expr
219 
// equals_expr & bitwise_expr_list
220 
//
221 
int64_t bitwise_expr()
222 
{
223 
    int64_t val;
224 
 
225 
    val = equals_expr();
226 
    while (1) {
227 
        switch(token) {
228 
        case '&': NextToken(); val = val & equals_expr(); break;
229 
        case '^': NextToken(); val = val ^ equals_expr(); break;
230 
        case '|': NextToken(); val = val | equals_expr(); break;
231 
        default: goto j1;
232 
        }
233 
    }
234 
j1:
235 
    return val;
236 
}
237 
 
238 
// bitwise_expr
239 
// bitwise_expr && and_expr_list
240 
//
241 
int64_t and_expr()
242 
{
243 
    int64_t val;
244 
 
245 
    val = bitwise_expr();
246 
    while(token==tk_land) {
247 
        NextToken();
248 
        val = val && bitwise_expr();
249 
    }
250 
    return val;
251 
}
252 
 
253 
// and_expr
254 
// and_expr || or_expr_list
255 
//
256 
int64_t or_expr()
257 
{
258 
    int64_t val;
259 
 
260 
    val = and_expr();
261 
    while(token==tk_lor) {
262 
        NextToken();
263 
        val = val || and_expr();
264 
    }
265 
    return val;
266 
}
267 
 
268 
int64_t expr()
269 
{
270 
    int64_t val;
271 
 
272 
    nsym = 0;
273 
    lastsym = (SYM*)NULL;
274 
    if (token=='#')
275 
       NextToken();
276 
    val = or_expr();
277 
    // We only care about the symbol if relocatable output is being generated.
278 
    // Setting the symbol to NULL will result in no rel records being output.
279 
    if (nsym > 1 || !rel_out)
280 
        lastsym = (SYM *)NULL;
281 
    return val;
282 
}
283 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.