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

Subversion Repositories 1664

[/] [1664/] [trunk/] [c/] [cpu_1664/] [cpu_1664_asm_n8_valua__cadena.c] - Blame information for rev 2

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 mrdmkg 
#include "cpu_1664.h"
2 
 
3 
SPR_t cpu_1664_asm_n8_valua__cadena(struct cpu_1664 *cpu, n1 *cadena, nN cuantia)
4 
{
5 
 const n1 sinia_no_braso[] = {cpu_1664_asm_table_sinia};
6 
 const n1 sinia_braso_clui[] = {cpu_1664_asm_table_clui};
7 
 SPR_t valua=0;
8 
 cpu_1664_asm_sinia_t sinia;
9 
 nN i;
10 
 n1 bool_negativa=0;
11 
 n1 loca=0;
12 
 SPR_t masca=-1;
13 
 struct lista *lista;
14 
 nN bitio_masca;
15 
 
16 
 if(*cadena=='-')
17 
 {
18 
  bool_negativa=1;
19 
  cadena++;
20 
  cuantia--;
21 
 }
22 
 
23 
 n1 *fini=cadena+cuantia;
24 
 nN cuantia_braso;
25 
 nN j,k;
26 
 struct lista *pila;
27 
 nN evalua_braso_cuantia;
28 
 SPR_t f,f0,f1;
29 
 SPR_t e0,e1;
30 
 n1 *cadena_;
31 
 while(cadena<fini)
32 
 {
33 
 
34 
 switch(*cadena)
35 
 {
36 
  case 0x09:
37 
  case ' ':
38 
   cadena++;
39 
   break;
40 
 
41 
  case '\"':
42 
   cuantia_braso=nN_cuantia_brasetida__cadena(cadena, *cadena, sinia_braso_clui[*cadena]);
43 
   cadena+=cuantia_braso;
44 
   break;
45 
 
46 
  case '{': //simboles polsce reversa
47 
   pila=lista_nova(sizeof(SPR_t)*8);
48 
   evalua_braso_cuantia=nN_cuantia_brasetida__cadena(cadena, *cadena, sinia_braso_clui[*cadena]);
49 
 
50 
   for(j=1;j<(evalua_braso_cuantia-1);j++)
51 
   {
52 
 
53 
    switch(cadena[j])
54 
    {
55 
     default:
56 
      cadena_=cadena+j;
57 
      while(sinia_no_braso[cadena[j]]!=0){ j++; }
58 
      f=cpu_1664_asm_n8_valua__cadena(cpu, cadena_,(cadena+j)-cadena_);
59 
      lista_ajunta__SPR_t(pila, f);
60 
      break;
61 
 
62 
     case 0x09:
63 
     case ' ':
64 
      break;
65 
 
66 
     case '{':
67 
      k=nN_cuantia_brasetida__cadena(cadena+j, cadena[j], sinia_braso_clui[*cadena]);
68 
      f=cpu_1664_asm_n8_valua__cadena(cpu, cadena+j, k);
69 
      lista_ajunta__SPR_t(pila, f);
70 
      j+=k;
71 
      break;
72 
 
73 
     case '.':
74 
 
75 
      switch(cadena[++j])
76 
      {
77 
       case '-': //negativa
78 
        if((pila->contador/sizeof(SPR_t))>=1)
79 
        {
80 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1]=-((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
81 
        }
82 
        j++;
83 
        break;
84 
 
85 
       case '+': //asoluta
86 
        if((pila->contador/sizeof(SPR_t))>=1)
87 
        {
88 
         f0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
89 
         if(f0<0.0) { ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1]=-f0; }
90 
        }
91 
        j++;
92 
        break;
93 
 
94 
       case '/': //invertida
95 
        if((pila->contador/sizeof(SPR_t))>=1)
96 
        {
97 
         f0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
98 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1]=1.0/f0;
99 
        }
100 
        j++;
101 
        break;
102 
 
103 
       case 'd': //dupli
104 
        if((pila->contador/sizeof(SPR_t))>=2)
105 
        {
106 
         f0=(((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1])+1;
107 
         if((pila->contador/sizeof(SPR_t))>=f0)
108 
         {
109 
          ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1]=((SPR_t *)(pila->datos))[f0];
110 
         }
111 
        }
112 
        j++;
113 
        break;
114 
 
115 
       case 'x': //intercambia
116 
        if((pila->contador/sizeof(SPR_t))>=2)
117 
        {
118 
         f1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
119 
         f0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
120 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=f0;
121 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1]=f1;
122 
        }
123 
        j++;
124 
        break;
125 
 
126 
       case '<': //cade
127 
        if((pila->contador/sizeof(SPR_t))>=2)
128 
        {
129 
         f0=(((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1])+1;
130 
         if((pila->contador/sizeof(SPR_t))>=f0)
131 
         {
132 
          pila->contador-=sizeof(SPR_t)*f0;
133 
         }
134 
        }
135 
        j++;
136 
        break;
137 
 
138 
       default:
139 
        //zero funsiona
140 
        break;
141 
      }
142 
      break;
143 
 
144 
     case '>':
145 
      switch(cadena[++j])
146 
      {
147 
       case '>': //loca
148 
        if((pila->contador/sizeof(SPR_t))>=2)
149 
        {
150 
         e1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
151 
         e0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
152 
         e1>>=e0;
153 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=e1;
154 
         pila->contador-=sizeof(SPR_t);
155 
        }
156 
        j++;
157 
        break;
158 
 
159 
       case '=': //lojica
160 
        if((pila->contador/sizeof(SPR_t))>=2)
161 
        {
162 
         f1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
163 
         f0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
164 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=f1>=f0;
165 
         pila->contador-=sizeof(SPR_t);
166 
        }
167 
        break;
168 
 
169 
       default: //lojica
170 
        if((pila->contador/sizeof(SPR_t))>=2)
171 
        {
172 
         f1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
173 
         f0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
174 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=f1>f0;
175 
         pila->contador-=sizeof(SPR_t);
176 
        }
177 
        break;
178 
      }
179 
      break;
180 
 
181 
     case '<':
182 
      switch(cadena[++j])
183 
      {
184 
       case '<': //loca
185 
        if((pila->contador/sizeof(SPR_t))>=2)
186 
        {
187 
         e1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
188 
         e0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
189 
         e1<<=e0;
190 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=e1;
191 
         pila->contador-=sizeof(SPR_t);
192 
        }
193 
        j++;
194 
        break;
195 
 
196 
       case '=': //lojica
197 
        if((pila->contador/sizeof(SPR_t))>=2)
198 
        {
199 
         f1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
200 
         f0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
201 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=f1<=f0;
202 
         pila->contador-=sizeof(SPR_t);
203 
        }
204 
        break;
205 
 
206 
       default: //lojica
207 
        if((pila->contador/sizeof(SPR_t))>=2)
208 
        {
209 
         f1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
210 
         f0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
211 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=f1<f0;
212 
         pila->contador-=sizeof(SPR_t);
213 
        }
214 
        break;
215 
      }
216 
      break;
217 
 
218 
     case '&':
219 
      switch(cadena[++j])
220 
      {
221 
       default: //bitio
222 
        if((pila->contador/sizeof(SPR_t))>=2)
223 
        {
224 
         e1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
225 
         e0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
226 
         e1&=e0;
227 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=e1;
228 
         pila->contador-=sizeof(SPR_t);
229 
        }
230 
        break;
231 
 
232 
       case '&': //lojica
233 
        if((pila->contador/sizeof(SPR_t))>=2)
234 
        {
235 
         e1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
236 
         e0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
237 
         e1=(SPR_t)e1&&(SPR_t)e0;
238 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=e1;
239 
         pila->contador-=sizeof(SPR_t);
240 
        }
241 
        j++;
242 
        break;
243 
      }
244 
      break;
245 
 
246 
     case '|':
247 
      switch(cadena[++j])
248 
      {
249 
       default: //bitio
250 
        if((pila->contador/sizeof(SPR_t))>=2)
251 
        {
252 
         e1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
253 
         e0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
254 
         e1|=e0;
255 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=e1;
256 
         pila->contador-=sizeof(SPR_t);
257 
        }
258 
        break;
259 
 
260 
       case '|': //lojica
261 
        if((pila->contador/sizeof(SPR_t))>=2)
262 
        {
263 
         e1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
264 
         e0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
265 
         e1=(SPR_t)e1||(SPR_t)e0;
266 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=e1;
267 
         pila->contador-=sizeof(SPR_t);
268 
        }
269 
        j++;
270 
        break;
271 
      }
272 
      break;
273 
 
274 
     case '!':
275 
      switch(cadena[++j])
276 
      {
277 
 
278 
       case '=': //lojica
279 
        if((pila->contador/sizeof(SPR_t))>=2)
280 
        {
281 
         f1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
282 
         f0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
283 
         ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=f1!=f0;
284 
         pila->contador-=sizeof(SPR_t);
285 
        }
286 
        break;
287 
 
288 
      }
289 
      break;
290 
 
291 
     case '=': //lojica
292 
      if((pila->contador/sizeof(SPR_t))>=2)
293 
      {
294 
       f1=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2];
295 
       f0=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
296 
       ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]=(f1==f0);
297 
       pila->contador-=sizeof(SPR_t);
298 
      }
299 
      break;
300 
 
301 
     case '+':
302 
      if((pila->contador/sizeof(SPR_t))>=2)
303 
      {
304 
       ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]+=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
305 
       pila->contador-=sizeof(SPR_t);
306 
      }
307 
      j++;
308 
      break;
309 
 
310 
     case '-':
311 
      if(sinia_no_braso[cadena[j+1]]==1)
312 
      {
313 
       cadena_=cadena+j;
314 
       while(sinia_no_braso[cadena[j]]==1) { j++; }
315 
       f=cpu_1664_asm_n8_valua__cadena(cpu, cadena_,(cadena+j)-cadena_);
316 
       lista_ajunta__SPR_t(pila, f);
317 
      }
318 
      else
319 
      {
320 
       if((pila->contador/sizeof(SPR_t))>=2)
321 
       {
322 
        ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]-=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
323 
        pila->contador-=sizeof(SPR_t);
324 
       }
325 
       j++;
326 
      }
327 
      break;
328 
 
329 
     case '*':
330 
      if((pila->contador/sizeof(SPR_t))>=2)
331 
      {
332 
       ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]*=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
333 
       pila->contador-=sizeof(SPR_t);
334 
      }
335 
      j++;
336 
      break;
337 
 
338 
     case '/':
339 
      if((pila->contador/sizeof(SPR_t))>=2)
340 
      {
341 
       ((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-2]/=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
342 
       pila->contador-=sizeof(SPR_t);
343 
      }
344 
      j++;
345 
      break;
346 
 
347 
    }
348 
   }
349 
   if(pila->contador!=0)
350 
   {
351 
    valua=((SPR_t *)(pila->datos))[(pila->contador/sizeof(SPR_t))-1];
352 
   }
353 
   cadena+=evalua_braso_cuantia;
354 
   lista_libri(pila);
355 
   break;
356 
 
357 
  case '(':
358 
   cuantia_braso=nN_cuantia_brasetida__cadena(cadena, *cadena, sinia_braso_clui[*cadena]);
359 
   valua=cpu_1664_asm_n8_valua__cadena(cpu, cadena+1, cuantia_braso-2);
360 
   cadena+=cuantia_braso;
361 
   break;
362 
 
363 
  case '}': // dev
364 
  case ']': // dev
365 
  case ')':
366 
   cadena++;
367 
   break;
368 
 
369 
  case '[':
370 
   cuantia_braso=nN_cuantia_brasetida__cadena(cadena, *cadena, sinia_braso_clui[*cadena]);
371 
   lista=cpu_1664_asm_lista_parametre__cadena(cadena+1);
372 
   bitio_masca=8;
373 
 
374 
   if((lista->contador/sizeof(P)>0)&&(lista->contador/sizeof(P)<3))
375 
   {
376 
    loca=cpu_1664_asm_n8_valua__cadena(cpu, ((struct lista **)(lista->datos))[0]->datos,((struct lista **)(lista->datos))[0]->contador);
377 
    if((lista->contador/sizeof(P)>1)) bitio_masca=cpu_1664_asm_n8_valua__cadena(cpu, ((struct lista **)(lista->datos))[1]->datos,((struct lista **)(lista->datos))[1]->contador);
378 
    masca=(1<<bitio_masca)-1;
379 
   }
380 
 
381 
   lista_2_libri(lista);
382 
 
383 
   cadena+=cuantia_braso;
384 
   break;
385 
 
386 
  case '0':
387 
 
388 
   if(*(cadena+1)=='x')
389 
   {
390 
    nN j;
391 
    cadena+=2;
392 
    for(j=0;(sinia_no_braso[cadena[j]]==1)&&((cadena+j)<fini);j++){}
393 
    valua=n8__exadesimal_cadena(cadena, j);
394 
    cadena+=j;
395 
    break;
396 
   }
397 
   else if (cuantia>1)
398 
   {
399 
    //octal
400 
   }
401 
  case '1' ... '9':
402 
   for(j=1;(sinia_no_braso[cadena[j]]==1)&&((cadena+j)<fini);j++){}
403 
   valua=n8__desimal_cadena(cadena, j);
404 
   cadena+=j;
405 
   break;
406 
 
407 
  default:
408 
   for(j=0;(sinia_no_braso[cadena[j]]==1)&&((cadena+j)<fini);j++){}
409 
   sinia=cpu_1664_asm_sinia_t_sinia__cadena(cadena, j);
410 
   cadena+=j;
411 
 
412 
   for(i=0;i<(cpu->lista_defina_sinia->contador/sizeof(cpu_1664_asm_sinia_t));i++)
413 
   {
414 
 
415 
    if(((cpu_1664_asm_sinia_t *)(cpu->lista_defina_sinia->datos))[i]==sinia)
416 
    {
417 
     valua=((cpu_1664_sinia_t *)(cpu->lista_defina_valua->datos))[i];
418 
     break;
419 
    }
420 
 
421 
   }
422 
 
423 
   if (i>=(cpu->lista_defina_sinia->contador/sizeof(cpu_1664_asm_sinia_t)))
424 
   {
425 
    cpu->avisa__no_definida=1;
426 
   }
427 
 
428 
   break;
429 
 }
430 
 }
431 
 
432 
 if(bool_negativa!=0)
433 
 {
434 
  valua=(-valua);
435 
 }
436 
 
437 
 valua=(valua>>loca)&masca;
438 
 return valua;
439 
}

powered by: WebSVN 2.1.0

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