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

Subversion Repositories thor

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

Details | Compare with Previous | View Log


// ============================================================================
//        __
//   \\__/ o\    (C) 2014  Robert Finch, Stratford
//    \  __ /    All rights reserved.
//     \/_//     robfinch<remove>@finitron.ca
//       ||
//
// A64 - Assembler
//  - 64 bit CPU
//
// This source file is free software: you can redistribute it and/or modify 
// it under the terms of the GNU Lesser General Public License as published 
// by the Free Software Foundation, either version 3 of the License, or     
// (at your option) any later version.                                      
//                                                                          
// This source file is distributed in the hope that it will be useful,      
// but WITHOUT ANY WARRANTY; without even the implied warranty of           
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            
// GNU General Public License for more details.                             
//                                                                          
// You should have received a copy of the GNU General Public License        
// along with this program.  If not, see <http://www.gnu.org/licenses/>.    
//                                                                          
// ============================================================================
//
#include "stdafx.h"
 
Int128 expr128();
extern int nsym;
 
// id
// const
// (expr)
// >expr
static Int128 primary()
{
    Int128 val;
    SYM *sym;
    static char buf[500];
 
    switch(token) {
    case tk_id:
         if (lastid[0]=='.')  // local label
            sprintf(buf, "%s%s", current_label, lastid);
         else
             strcpy(buf, lastid);
         sym = find_symbol(buf);
         if (!sym)
             sym = new_symbol(buf);
         val = sym->value;
         if (sym->segment < 5)
             nsym++;
         lastsym = sym;
         NextToken();
         if (token==tk_eol)
            prevToken();
         break;
    case tk_icon:
         val = ival;
         NextToken();
         if (token==tk_eol)
            prevToken();
         break;
    case '\'':
         inptr++;
                 if (*inptr=='\\') {
                         inptr++;
                         switch(*inptr) {
                         case '\r':     val.low = '\r'; val.high = 0; NextToken(); expect('\''); return (val);
                         case '\n':     val.low = '\n'; val.high = 0; NextToken(); expect('\''); return (val);
                         case '\t':     val.low = '\t'; val.high = 0; NextToken(); expect('\''); return (val);
                         case '\f':     val.low = '\f'; val.high = 0; NextToken(); expect('\''); return (val);
                         case '\b':     val.low = '\b'; val.high = 0; NextToken(); expect('\''); return (val);
                         }
                 }
         val.low = *inptr;
                 val.high = 0;
         NextToken();
         expect('\'');
         break;
    case '(':
         NextToken();
         val = expr128();
         expect(')');
         break;
    default:
       //printf("Syntax error.\r\n");
       val.low = val.high = 0;
       if (token != tk_eol)
           NextToken();
      break;
    }
    return (val);
}
 
// !unary
// -unary
// +unary
// ~unary
//  primary
 
static Int128 unary()
{
    Int128 val;
 
    switch(token) {
    case '!':
                NextToken();
                val = unary();
                if (Int128::IsEqual(&val,Int128::Zero()))
                        Int128::Assign(&val,Int128::One());
                else
                        Int128::Assign(&val,Int128::Zero());
                return (val);
    case '-':
                NextToken();
                val = unary();
                Int128::Sub(&val,Int128::Zero(),&val);
                return (val);
    case '+':
                NextToken();
                val = unary();
                return (val);
    case '~':
                NextToken();
                val = unary();
                val.low = ~val.low;
                val.high = ~val.high;
                return (val);
    default:
        return (primary());
    }
}
 
// unary
// unary [*/%] unary
 
static Int128 mult_expr()
{
    Int128 val, a, rem;
 
    val = unary();
    while(1) {
        switch(token) {
        case '*':
                        NextToken();
                        a = unary();
                        Int128::Mul(&val, &val, &a);
                        break;
        case '/':
                        NextToken();
                        a = unary();
                        Int128::Div(&val, &rem, &val, &a);
                        break;
        case '%':
                        NextToken();
                        a = unary();
                        Int128::Div(&rem, &val, &val, &a);
                        break;
        default: goto j1;
        }
    }
j1:
    return (val);
}
 
// mult_expr
// mult_expr [+-] add_expr_list
//
static Int128 add_expr()
{
    Int128 val, a;
 
    val = mult_expr();
    while (1) {
        switch(token) {
        case '+':
                        NextToken();
                        a = mult_expr();
                        Int128::Add(&val, &val, &a);
                        break;
        case '-':
                        NextToken();
                        a = mult_expr();
                        Int128::Sub(&val, &val, &a);
                        break;
        default: goto j1;
        }
    }
j1:
    return (val);
}
 
static Int128 shift_expr()
{
    Int128 val, amt;
    int nn;
 
    val = add_expr();
    while(1) {
        switch(token) {
        case tk_lshift:
                        NextToken();
                        amt = add_expr();
                        for (nn = 0; nn < 128 && nn < amt.low; nn++)
                                Int128::Shl(&val, &val);
                        break;
        case tk_rshift:
                        NextToken();
                        amt = add_expr();
                        for (nn = 0; nn < 128 && nn < amt.low; nn++)
                                Int128::Shr(&val, &val);
                        break;
        default: goto j1;
        }
    }
j1:
    return (val);
}
 
static Int128 relational_expr()
{
    Int128 val, a;
 
    val = shift_expr();
    while (1) {
        switch(token) {
        case tk_lt:
                        NextToken();
                        a = shift_expr();
                        if (Int128::IsLessThan(&val, &a))
                                Int128::Assign(&val, Int128::One());
                        else
                                Int128::Assign(&val, Int128::Zero());
                        break;
        case tk_le:
                        NextToken();
                        a = shift_expr();
                        if (Int128::IsLessThan(&val, &a) || Int128::IsEqual(&val, &a))
                                Int128::Assign(&val, Int128::One());
                        else
                                Int128::Assign(&val, Int128::Zero());
                        break;
        case tk_gt:
                        NextToken();
                        a = shift_expr();
                        if (!Int128::IsLessThan(&val, &a) && !Int128::IsEqual(&val, &a))
                                Int128::Assign(&val, Int128::One());
                        else
                                Int128::Assign(&val, Int128::Zero());
                        break;
        case tk_ge:
                        NextToken();
                        a = shift_expr();
                        if (!Int128::IsLessThan(&val, &a) || Int128::IsEqual(&val, &a))
                                Int128::Assign(&val, Int128::One());
                        else
                                Int128::Assign(&val, Int128::Zero());
                        break;
        default: goto j1;
        }
    }
j1:
    return (val);
}
 
// relational_expr
// relational_expr & equals_expr_list
//
static Int128 equals_expr()
{
    Int128 val, a;
 
    val = relational_expr();
    while (1) {
        switch(token) {
                case tk_eq:
                        NextToken();
                        a = relational_expr();
                        if (Int128::IsEqual(&val, &a))
                                Int128::Assign(&val, Int128::One());
                        else
                                Int128::Assign(&val, Int128::Zero());
                        break;
        case tk_ne:
                        NextToken();
                        a = relational_expr();
                        if (!Int128::IsEqual(&val, &a))
                                Int128::Assign(&val, Int128::One());
                        else
                                Int128::Assign(&val, Int128::Zero());
                        break;
        default: goto j1;
        }
    }
j1:
    return (val);
}
 
// equals_expr
// equals_expr & bitwise_expr_list
//
static Int128 bitwise_expr()
{
    Int128 val, a;
 
    val = equals_expr();
    while (1) {
        switch(token) {
        case '&':
                        NextToken();
                        a = equals_expr();
                        val.low = val.low & a.low;
                        val.high = val.high & a.high;
                        break;
        case '^':
                        NextToken();
                        a = equals_expr();
                        val.low = val.low ^ a.low;
                        val.high = val.high ^ a.high;
                        break;
        case '|':
                        NextToken();
                        a = equals_expr();
                        val.low = val.low | a.low;
                        val.high = val.high | a.high;
                        break;
        default: goto j1;
        }
    }
j1:
    return (val);
}
 
// bitwise_expr
// bitwise_expr && and_expr_list
//        
static Int128 and_expr()
{
    Int128 val, a;
 
    val = bitwise_expr();
    while(token==tk_land) {
        NextToken();
                a = bitwise_expr();
                if (Int128::IsEqual(&a,Int128::Zero()) || Int128::IsEqual(&val,Int128::Zero()))
                        Int128::Assign(&val,Int128::Zero());
                else
                        Int128::Assign(&val,Int128::One());
    }
    return (val);
}
 
// and_expr
// and_expr || or_expr_list
//
static Int128 or_expr()
{
    Int128 val, a;
 
    val = and_expr();
    while(token==tk_lor) {
        NextToken();
                a = and_expr();
                if (!Int128::IsEqual(&a,Int128::Zero()) || !Int128::IsEqual(&val,Int128::Zero()))
                        Int128::Assign(&val,Int128::One());
                else
                        Int128::Assign(&val,Int128::Zero());
    }
    return (val);
}
 
Int128 expr128()
{
    Int128 val;
 
    nsym = 0;
    lastsym = (SYM*)NULL;
    if (token=='#')
       NextToken();
    val = or_expr();
    // We only care about the symbol if relocatable output is being generated.
    // Setting the symbol to NULL will result in no rel records being output.
    if (nsym > 1 || !rel_out)
        lastsym = (SYM *)NULL;
    return val;
}
 

Browse

Tools

Subversion Repositories thor

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

Line No.	Rev	Author	Line
1	48	robfinch	`// ============================================================================`
2			`// __`
3			`// \\__/ o\ (C) 2014 Robert Finch, Stratford`
4			`// \ __ / All rights reserved.`
5			`// \/_// robfinch<remove>@finitron.ca`
6			`// \|\|`
7			`//`
8			`// A64 - 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			`Int128 expr128();`
29			`extern int nsym;`
30
31			`// id`
32			`// const`
33			`// (expr)`
34			`// >expr`
35			`static Int128 primary()`
36			`{`
37			`Int128 val;`
38			`SYM *sym;`
39			`static char buf[500];`
40
41			`switch(token) {`
42			`case tk_id:`
43			`if (lastid[0]=='.') // local label`
44			`sprintf(buf, "%s%s", current_label, lastid);`
45			`else`
46			`strcpy(buf, lastid);`
47			`sym = find_symbol(buf);`
48			`if (!sym)`
49			`sym = new_symbol(buf);`
50			`val = sym->value;`
51			`if (sym->segment < 5)`
52			`nsym++;`
53			`lastsym = sym;`
54			`NextToken();`
55			`if (token==tk_eol)`
56			`prevToken();`
57			`break;`
58			`case tk_icon:`
59			`val = ival;`
60			`NextToken();`
61			`if (token==tk_eol)`
62			`prevToken();`
63			`break;`
64			`case '\'':`
65			`inptr++;`
66			`if (*inptr=='\\') {`
67			`inptr++;`
68			`switch(*inptr) {`
69			`case '\r': val.low = '\r'; val.high = 0; NextToken(); expect('\''); return (val);`
70			`case '\n': val.low = '\n'; val.high = 0; NextToken(); expect('\''); return (val);`
71			`case '\t': val.low = '\t'; val.high = 0; NextToken(); expect('\''); return (val);`
72			`case '\f': val.low = '\f'; val.high = 0; NextToken(); expect('\''); return (val);`
73			`case '\b': val.low = '\b'; val.high = 0; NextToken(); expect('\''); return (val);`
74			`}`
75			`}`
76			`val.low = *inptr;`
77			`val.high = 0;`
78			`NextToken();`
79			`expect('\'');`
80			`break;`
81			`case '(':`
82			`NextToken();`
83			`val = expr128();`
84			`expect(')');`
85			`break;`
86			`default:`
87			`//printf("Syntax error.\r\n");`
88			`val.low = val.high = 0;`
89			`if (token != tk_eol)`
90			`NextToken();`
91			`break;`
92			`}`
93			`return (val);`
94			`}`
95
96			`// !unary`
97			`// -unary`
98			`// +unary`
99			`// ~unary`
100			`// primary`
101
102			`static Int128 unary()`
103			`{`
104			`Int128 val;`
105
106			`switch(token) {`
107			`case '!':`
108			`NextToken();`
109			`val = unary();`
110			`if (Int128::IsEqual(&val,Int128::Zero()))`
111			`Int128::Assign(&val,Int128::One());`
112			`else`
113			`Int128::Assign(&val,Int128::Zero());`
114			`return (val);`
115			`case '-':`
116			`NextToken();`
117			`val = unary();`
118			`Int128::Sub(&val,Int128::Zero(),&val);`
119			`return (val);`
120			`case '+':`
121			`NextToken();`
122			`val = unary();`
123			`return (val);`
124			`case '~':`
125			`NextToken();`
126			`val = unary();`
127			`val.low = ~val.low;`
128			`val.high = ~val.high;`
129			`return (val);`
130			`default:`
131			`return (primary());`
132			`}`
133			`}`
134
135			`// unary`
136			`// unary [*/%] unary`
137
138			`static Int128 mult_expr()`
139			`{`
140			`Int128 val, a, rem;`
141
142			`val = unary();`
143			`while(1) {`
144			`switch(token) {`
145			`case '*':`
146			`NextToken();`
147			`a = unary();`
148			`Int128::Mul(&val, &val, &a);`
149			`break;`
150			`case '/':`
151			`NextToken();`
152			`a = unary();`
153			`Int128::Div(&val, &rem, &val, &a);`
154			`break;`
155			`case '%':`
156			`NextToken();`
157			`a = unary();`
158			`Int128::Div(&rem, &val, &val, &a);`
159			`break;`
160			`default: goto j1;`
161			`}`
162			`}`
163			`j1:`
164			`return (val);`
165			`}`
166
167			`// mult_expr`
168			`// mult_expr [+-] add_expr_list`
169			`//`
170			`static Int128 add_expr()`
171			`{`
172			`Int128 val, a;`
173
174			`val = mult_expr();`
175			`while (1) {`
176			`switch(token) {`
177			`case '+':`
178			`NextToken();`
179			`a = mult_expr();`
180			`Int128::Add(&val, &val, &a);`
181			`break;`
182			`case '-':`
183			`NextToken();`
184			`a = mult_expr();`
185			`Int128::Sub(&val, &val, &a);`
186			`break;`
187			`default: goto j1;`
188			`}`
189			`}`
190			`j1:`
191			`return (val);`
192			`}`
193
194			`static Int128 shift_expr()`
195			`{`
196			`Int128 val, amt;`
197			`int nn;`
198
199			`val = add_expr();`
200			`while(1) {`
201			`switch(token) {`
202			`case tk_lshift:`
203			`NextToken();`
204			`amt = add_expr();`
205			`for (nn = 0; nn < 128 && nn < amt.low; nn++)`
206			`Int128::Shl(&val, &val);`
207			`break;`
208			`case tk_rshift:`
209			`NextToken();`
210			`amt = add_expr();`
211			`for (nn = 0; nn < 128 && nn < amt.low; nn++)`
212			`Int128::Shr(&val, &val);`
213			`break;`
214			`default: goto j1;`
215			`}`
216			`}`
217			`j1:`
218			`return (val);`
219			`}`
220
221			`static Int128 relational_expr()`
222			`{`
223			`Int128 val, a;`
224
225			`val = shift_expr();`
226			`while (1) {`
227			`switch(token) {`
228			`case tk_lt:`
229			`NextToken();`
230			`a = shift_expr();`
231			`if (Int128::IsLessThan(&val, &a))`
232			`Int128::Assign(&val, Int128::One());`
233			`else`
234			`Int128::Assign(&val, Int128::Zero());`
235			`break;`
236			`case tk_le:`
237			`NextToken();`
238			`a = shift_expr();`
239			`if (Int128::IsLessThan(&val, &a) \|\| Int128::IsEqual(&val, &a))`
240			`Int128::Assign(&val, Int128::One());`
241			`else`
242			`Int128::Assign(&val, Int128::Zero());`
243			`break;`
244			`case tk_gt:`
245			`NextToken();`
246			`a = shift_expr();`
247			`if (!Int128::IsLessThan(&val, &a) && !Int128::IsEqual(&val, &a))`
248			`Int128::Assign(&val, Int128::One());`
249			`else`
250			`Int128::Assign(&val, Int128::Zero());`
251			`break;`
252			`case tk_ge:`
253			`NextToken();`
254			`a = shift_expr();`
255			`if (!Int128::IsLessThan(&val, &a) \|\| Int128::IsEqual(&val, &a))`
256			`Int128::Assign(&val, Int128::One());`
257			`else`
258			`Int128::Assign(&val, Int128::Zero());`
259			`break;`
260			`default: goto j1;`
261			`}`
262			`}`
263			`j1:`
264			`return (val);`
265			`}`
266
267			`// relational_expr`
268			`// relational_expr & equals_expr_list`
269			`//`
270			`static Int128 equals_expr()`
271			`{`
272			`Int128 val, a;`
273
274			`val = relational_expr();`
275			`while (1) {`
276			`switch(token) {`
277			`case tk_eq:`
278			`NextToken();`
279			`a = relational_expr();`
280			`if (Int128::IsEqual(&val, &a))`
281			`Int128::Assign(&val, Int128::One());`
282			`else`
283			`Int128::Assign(&val, Int128::Zero());`
284			`break;`
285			`case tk_ne:`
286			`NextToken();`
287			`a = relational_expr();`
288			`if (!Int128::IsEqual(&val, &a))`
289			`Int128::Assign(&val, Int128::One());`
290			`else`
291			`Int128::Assign(&val, Int128::Zero());`
292			`break;`
293			`default: goto j1;`
294			`}`
295			`}`
296			`j1:`
297			`return (val);`
298			`}`
299
300			`// equals_expr`
301			`// equals_expr & bitwise_expr_list`
302			`//`
303			`static Int128 bitwise_expr()`
304			`{`
305			`Int128 val, a;`
306
307			`val = equals_expr();`
308			`while (1) {`
309			`switch(token) {`
310			`case '&':`
311			`NextToken();`
312			`a = equals_expr();`
313			`val.low = val.low & a.low;`
314			`val.high = val.high & a.high;`
315			`break;`
316			`case '^':`
317			`NextToken();`
318			`a = equals_expr();`
319			`val.low = val.low ^ a.low;`
320			`val.high = val.high ^ a.high;`
321			`break;`
322			`case '\|':`
323			`NextToken();`
324			`a = equals_expr();`
325			`val.low = val.low \| a.low;`
326			`val.high = val.high \| a.high;`
327			`break;`
328			`default: goto j1;`
329			`}`
330			`}`
331			`j1:`
332			`return (val);`
333			`}`
334
335			`// bitwise_expr`
336			`// bitwise_expr && and_expr_list`
337			`//`
338			`static Int128 and_expr()`
339			`{`
340			`Int128 val, a;`
341
342			`val = bitwise_expr();`
343			`while(token==tk_land) {`
344			`NextToken();`
345			`a = bitwise_expr();`
346			`if (Int128::IsEqual(&a,Int128::Zero()) \|\| Int128::IsEqual(&val,Int128::Zero()))`
347			`Int128::Assign(&val,Int128::Zero());`
348			`else`
349			`Int128::Assign(&val,Int128::One());`
350			`}`
351			`return (val);`
352			`}`
353
354			`// and_expr`
355			`// and_expr \|\| or_expr_list`
356			`//`
357			`static Int128 or_expr()`
358			`{`
359			`Int128 val, a;`
360
361			`val = and_expr();`
362			`while(token==tk_lor) {`
363			`NextToken();`
364			`a = and_expr();`
365			`if (!Int128::IsEqual(&a,Int128::Zero()) \|\| !Int128::IsEqual(&val,Int128::Zero()))`
366			`Int128::Assign(&val,Int128::One());`
367			`else`
368			`Int128::Assign(&val,Int128::Zero());`
369			`}`
370			`return (val);`
371			`}`
372
373			`Int128 expr128()`
374			`{`
375			`Int128 val;`
376
377			`nsym = 0;`
378			`lastsym = (SYM*)NULL;`
379			`if (token=='#')`
380			`NextToken();`
381			`val = or_expr();`
382			`// We only care about the symbol if relocatable output is being generated.`
383			`// Setting the symbol to NULL will result in no rel records being output.`
384			`if (nsym > 1 \|\| !rel_out)`
385			`lastsym = (SYM *)NULL;`
386			`return val;`
387			`}`
388