/[smarc]/smarc/src/spasm/spasm.y
ViewVC logotype

Diff of /smarc/src/spasm/spasm.y

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1 by batonik, Thu Dec 19 20:45:37 2002 UTC revision 1.2 by batonik, Sat Dec 28 21:29:26 2002 UTC
# Line 1  Line 1 
1    
2  %union {  %union {
3          int     lcalk;          unsigned long   lcalk;
4          char *  string;          char *  string;
5  }  }
6    
7  %type <string> tekst_ascii  %type <string> tekst_ascii
8    %type <lcalk> dane_bajty
9    %type <lcalk> zero_arg
10    %type <lcalk> jeden_arg
11    %type <lcalk> dwa_arg
12    %type <lcalk> trzy_arg
13    %type <lcalk> rejestr
14    
15  %token <lcalk> LICZBA  %token <lcalk> LICZBA
16    
# Line 13  Line 19 
19  %token ALIGN  %token ALIGN
20  %token DATA  %token DATA
21  %token SKIP  %token SKIP
22    %token BYTE
23    %token HALF
24    %token WORD
25    
26  %token CUDZYSLOW  %token CUDZYSLOW
27  %token <string> TEKSTCIAGU  %token <string> TEKSTCIAGU
28    %token PRZECINEK
29    
30  %token <string> ETYKIETA  %token <string> ETYKIETA
31  %token NLINIA  %token NLINIA
32  %token PSEUDO_R  
33    %token <string> CIAG_ALNUM
34    %token ZNAK_ROWN
35    %token HI
36    %token LO
37    %token <lcalk> REJESTR
38    %token NAWIASL
39    %token NAWIASP
40    
41    
42    /* rozkazy skoków (branch) */
43    
44    %token B_BN
45    %token B_BE
46    %token B_BLE
47    %token B_BL
48    %token B_BLEU
49    %token B_BCS
50    %token B_BNEG
51    %token B_BVS
52    %token B_BA
53    %token B_BNE
54    %token B_BG
55    %token B_BGE
56    %token B_BGU
57    %token B_BCC
58    %token B_BPOS
59    %token B_BVC
60    
61    
62    /* rozkazy arytmetyczno-logiczne, dostępu do pamięci */
63    
64    %token R_ADD
65    %token R_AND
66    %token R_OR
67    %token R_XOR
68    %token R_SUB
69    %token R_ANDN
70    %token R_ORN
71    %token R_XNOR
72    %token R_ADDX
73    %token R_SUBX
74    %token R_ADDCC
75    %token R_ANDCC
76    %token R_ORCC
77    %token R_XORCC
78    %token R_SUBCC
79    %token R_ANDNCC
80    %token R_ORNCC
81    %token R_XNORCC
82    %token R_ADDXCC
83    %token R_SUBXCC
84    %token R_SLL
85    %token R_SRL
86    %token R_SRA
87    %token R_JMPL
88    %token R_SAVE
89    %token R_RESTORE
90    %token R_SETHI
91    %token R_CALL
92    %token R_LD
93    %token R_LDUB
94    %token R_LDUH
95    %token R_ST
96    %token R_STB
97    %token R_STH
98    %token R_LDSB
99    %token R_LDSH
100    %token R_LDSTUB
101    %token R_SWAP
102    
103    
104    /* pseudorozkazy */
105    
106    %token PR_MOV
107    %token PR_CMP
108    %token PR_TST
109    %token PR_NOT
110    %token PR_NEG
111    %token PR_INC
112    %token PR_DEC
113    %token PR_CLR
114    %token PR_RET
115    %token PR_JMP
116    %token PR_SKIPZ
117    %token PR_SKIPNZ
118    %token PR_SET
119    %token PR_NOP
120    
121    
122  %start program  %start program
123    
# Line 29  Line 127 
127  #include "zmienne.h"  #include "zmienne.h"
128  #include "stale.h"  #include "stale.h"
129  #include "funkcje.h"  #include "funkcje.h"
130    #include "rozkazy.h"
131    
132  %}  %}
133    
# Line 40  program:       /* pustka */ Line 139  program:       /* pustka */
139    
140  linia:          wyrazenie  linia:          wyrazenie
141                  | NLINIA                  | NLINIA
142                  |               { yyerror("troszku nie rozumiem!"); YYABORT; }                  |               {
143                                            yyerror("a tu co artysta miał na myśli??");
144                                            YYABORT;
145                                    }
146  ;  ;
147    
148  wyrazenie:      ETYKIETA        { printf("--> etykieta '%s'\n", yytext); }  wyrazenie:      ETYKIETA        {
149                                            printf("--> etykieta '%s'\n", yytext);
150                                    }
151                    | CIAG_ALNUM ZNAK_ROWN LICZBA
152                                    {
153                                            printf ("--> stała w linii %d\n", numerLinii);
154                                    }
155                  | wyr2                  | wyr2
156                  | wyrazenie wyr2                  | wyrazenie wyr2
157  ;  ;
# Line 53  wyr2:          dyrektywa Line 161  wyr2:          dyrektywa
161  ;  ;
162    
163  dyrektywa:      ASCII ascii  dyrektywa:      ASCII ascii
164                  | TEXT          { printf("--> sekcja kodu...\n"); }                  | TEXT          {
165                  | DATA          { /* sekcja danych */ }                                          aktualnaSekcja = KOD;
166                  | ALIGN align   /* align musi mieć parametr */                                  }
167                  | SKIP skip     /* skip też */                  | DATA          {
168                                            //właściwie na cholerę to komu...
169                                            aktualnaSekcja = DANE;
170                                    }
171                    | ALIGN align           /* align musi mieć parametr */
172                    | SKIP skip             /* skip też */
173                    | BYTE dane_bajty       /* ziew */
174                    | WORD dane_slowa       /* ziew2 */
175                    | HALF dane_polslowa    /* ziew3 */
176  ;  ;
177    
178  ascii:          CUDZYSLOW  ascii:          CUDZYSLOW
179                   tekst_ascii                   tekst_ascii
180                  CUDZYSLOW       {                  CUDZYSLOW       {
181                                            int ile = strlen($2);
182    
183                                            if (zapiszASCIIZ)
184                                                    ++ile;
185                                          printf("--> łańcuch `%s'\n", $2);                                          printf("--> łańcuch `%s'\n", $2);
186                                            fwrite($2, ile, 1, plikWynikowyDanych);
187                                            daneOffset += ile;
188                                    }
189                    |               {
190                                            yywarn("brak ciągu");
191                                  }                                  }
                 |               { yyerror("brak ciągu"); YYABORT; }  
192  ;  ;
193    
194  tekst_ascii:    TEKSTCIAGU      {  tekst_ascii:    TEKSTCIAGU      {
# Line 75  tekst_ascii:   TEKSTCIAGU      { Line 199  tekst_ascii:   TEKSTCIAGU      {
199  align:          LICZBA          {  align:          LICZBA          {
200                                          int _al = $1;                                          int _al = $1;
201                                          if (_al != 2 && _al != 4)                                          if (_al != 2 && _al != 4)
202                                                  yyerror("dozwolone wartości to 2 lub 4");                                                  yywarn("dozwolone wartości to 2 lub 4, pomijam");
203                                            else
204                                                    wyrownanieAdresow = $1;
205                                  }                                  }
206                  |               {                  |               {
207                                          yyerror("brak wartości dla ALIGN");                                          yywarn("brak wartości dla ALIGN");
                                         YYABORT;  
208                                  }                                  }
209  ;  ;
210    
211  skip:           LICZBA          {  skip:           LICZBA          {
212                                            unsigned int i;
213                                            char zero = 0;
214    
215                                            for (i = 0; i < $1; i++)
216                                                    fwrite(&zero,1,1,plikWynikowyDanych);
217                                            daneOffset += $1;
218                                  }                                  }
219                  |               {                  |               {
220                                          yyerror("brak wartości dla SKIP");                                          //tylko ostrzeżenie
221                                          YYABORT;                                          yywarn("brak wartości dla SKIP");
222                                    }
223    ;
224    
225    dane_bajty:     LICZBA          {
226                                            if ($1 > 255 || $1 < 0)
227                                            {
228                                                    yyerror("troszkę zakres przekroczyłeś");
229                                                    YYABORT;
230                                            }
231    
232                                            fprintf(plikWynikowyDanych, "%c", (char) $1);
233                                            daneOffset += 1;
234    
235                                            printf ("--> dane: bajt: %lu\n", $1);
236                                    }
237                    | dane_bajty PRZECINEK dane_bajty
238                    |               {
239                                            yywarn("a gdzie dane??");
240                                  }                                  }
241  ;  ;
242    
243  instrukcja:     pseudorozkaz  dane_slowa:     LICZBA          {
244                                            fprintf(plikWynikowyDanych, "%c%c%c%c",
245                                                    (char) ($1 >> 24),
246                                                    (char) ($1 >> 16),
247                                                    (char) ($1 >> 8),
248                                                    (char) $1 & 0xFF);
249                                            daneOffset += 4;
250    
251                                            printf ("--> dane: slowo: %lu\n", $1);
252                                    }
253                    | dane_slowa PRZECINEK dane_slowa
254                    |               {
255                                            yywarn("a gdzie dane??");
256                                    }
257  ;  ;
258    
259  pseudorozkaz:   PSEUDO_R        { printf("--> pseudorozkaz: %s\n", yytext); }  dane_polslowa:  LICZBA          {
260                                            if ($1 > 65535 || $1 < 0)
261                                            {
262                                                    yyerror("troszkę zakres przekroczyłeś");
263                                                    YYABORT;
264                                            }
265    
266                                            fprintf(plikWynikowyDanych, "%c%c%c%c",
267                                                    (char) 0, (char) 0,
268                                                    (char) ($1 >> 8),
269                                                    (char) $1 & 0xFF );
270                                            daneOffset += 4;
271    
272                                            printf ("--> dane: polslowo: %lu\n", $1);
273                                    }
274                    | dane_polslowa PRZECINEK dane_polslowa
275                    |               {
276                                            yywarn("a gdzie dane??");
277                                    }
278  ;  ;
279    
280    instrukcja:     dwa_arg         {
281                                            WyswietlBin($1);
282                                            printf("\n");
283                                    }
284                    | jeden_arg     {
285                                            WyswietlBin($1);
286                                            printf("\n");
287                                    }
288                    | zero_arg      {
289                                            WyswietlBin($1);
290                                            printf("\n");
291                                    }
292    ;
293    
294    zero_arg:       PR_NOP  
295                            {
296                                    $$ = ZrobSetHi(0,0);
297                            }
298                    | PR_RET
299                            {
300                                    $$ = ZrobRozkaz(TYP_REGIMM, F_ALU, 0, OPC_JMPL,
301                                            7, 0, /* imm13 */ 2);
302                            }
303                    | PR_SKIPZ
304                            {
305                                    $$ = ZrobBranch(CND_BNZ, /* dsp22 */ 2);
306                            }
307                    | PR_SKIPNZ
308                            {
309                                    $$ = ZrobBranch(CND_BZ, /* dsp22 */ 2);
310                            }
311    ;
312    
313    rejestr:        REJESTR {
314                                    if ($1 > 31)
315                                    {
316                                            yyerror("nie ma takiego rejestru!");
317                                            YYABORT;
318                                    }
319                                    else
320                                            $$ = $1;
321                            }
322                    |       {
323                                    yyerror("brak argumentu (rejestru)");
324                                    YYABORT;
325                            }
326    ;
327    
328    jeden_arg:      PR_TST rejestr
329                            {
330                                    $$ = ZrobRozkaz(TYP_REGREG, F_ALU, 0, OPC_ORCC,
331                                            0, $2, 0);
332                            }
333                    | PR_NOT rejestr
334                            {
335                                    $$ = ZrobRozkaz(TYP_REGREG, F_ALU, $2, OPC_XNOR,
336                                            0, $2, 0);
337                            }
338                    | PR_NEG rejestr
339                            {
340                                    $$ = ZrobRozkaz(TYP_REGREG, F_ALU, $2, OPC_SUB,
341                                            0, $2, 0);
342                            }
343                    | PR_INC rejestr
344                            {
345    // !!!!! jak wstawić do rozkazu stałą?!?! (1) IMM13 ???
346                                    $$ = ZrobRozkaz(TYP_REGIMM, F_ALU, $2, OPC_ADD,
347                                            $2, 0, 1);
348                            }
349                    | PR_DEC rejestr
350                            {
351                                    $$ = ZrobRozkaz(TYP_REGIMM, F_ALU, $2, OPC_SUB,
352                                            $2, 0, 1);
353                            }
354                    | PR_CLR rejestr
355                            {
356                                    $$ = ZrobRozkaz(TYP_REGREG, F_ALU, $2, OPC_OR,
357                                            0, 0, 0);
358                            }
359    ;
360    
361    dwa_arg:        PR_MOV rejestr PRZECINEK rejestr
362                            {
363                                    $$ = ZrobRozkaz(TYP_REGREG, F_ALU, $4, OPC_OR,
364                                            0, $2, 0);
365                            }
366                    | PR_CMP rejestr PRZECINEK rejestr
367                            {
368                                    $$ = ZrobRozkaz(TYP_REGREG, F_ALU, 0, OPC_SUBCC,
369                                            $4, $2, 0);
370                            }
371    
372    ;
373    
374    trzy_arg:       R_ADD   {}
375    ;

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26