730 lines
17 KiB
C
730 lines
17 KiB
C
/*
|
|
* eDiv Compiler
|
|
* Copyleft (C) 2000-2002 Sion Entertainment
|
|
* http://www.sion-e.com
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program 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, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
/*
|
|
* Este fichero contien el codigo del interprete del eDiv
|
|
* by Riseven
|
|
*
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <SDL/SDL.h>
|
|
|
|
#include "extern.h"
|
|
#include "edivfont.h"
|
|
//#include "kernel.h"
|
|
#include "inte.h"
|
|
#include "main.h"
|
|
#include "dll.h"
|
|
#include "varindex.h"
|
|
|
|
|
|
int first_loaded ;
|
|
|
|
int ini_interprete()
|
|
{
|
|
int i ;
|
|
first_loaded = 1 ;
|
|
|
|
pila_max = 1024 ;
|
|
if ((pila=(int*)malloc(4*pila_max))==NULL)
|
|
critical_error(4); // no se pudo reservar memoria para la pila
|
|
|
|
sp = 0 ; //por si acaso
|
|
|
|
|
|
// Posicion de inicio del code
|
|
iloc=mem[2]; // Inicio de la imagen de las variables locales
|
|
iloc_len=mem[6]+mem[5]; // Longitud de las locales (p£blicas y privadas)
|
|
iloc_pub_len=mem[6]; // Longitud de las variables locales p£blicas
|
|
inicio_privadas=iloc_pub_len;
|
|
imem=mem[1]; // Principio del codigo
|
|
/*
|
|
for ( i = 0 ; i < 10 ; i++ )
|
|
printf( " : %i \n" , mem[i] ) ;
|
|
*/
|
|
|
|
|
|
procs_s[1].imem = imem ;
|
|
procs_s[1].tipo = 0 ;
|
|
lista_mete( 1 ) ;
|
|
|
|
// Preparamos la estructura de parametros
|
|
fp.Call_Entrypoint = Call_Entrypoint ;
|
|
fp.mem = mem ;
|
|
fp.pila = pila ;
|
|
fp.procs_s = &procs_s ;
|
|
fp.sp = &sp ;
|
|
fp.varindex = varindex ;
|
|
fp.num_procs = &num_proc_orden ;
|
|
fp.proc_orden = proc_orden ;
|
|
fp.proceso_actual = &proceso_actual ;
|
|
fp.nombre_program=nombre_program;
|
|
fp.existe.regions = 0 ;
|
|
fp.existe.dibuja = 0 ;
|
|
fp.Runtime_Error=error;
|
|
fp.Critical_Error=critical_error;
|
|
fp.GetVarOffset=GetVarOffset;
|
|
fp.Stub_Quit=stub_quit;
|
|
fp.imem_max=imem_max;
|
|
|
|
#ifdef DBG
|
|
last_lin=0;
|
|
#endif /* DBG */
|
|
|
|
|
|
return 1 ;
|
|
}
|
|
|
|
int busca_proc_libre()
|
|
{
|
|
int i ;
|
|
for ( i = 1 ; i < 4096 ; i++ )
|
|
{
|
|
if ( procs_s[i].tipo == 0 )
|
|
return i ;
|
|
}
|
|
|
|
return -1 ;
|
|
}
|
|
|
|
int lista_mete( int num )
|
|
{
|
|
// Esto esta mal, habra que buscar su posicion segun priority
|
|
procs_s[num].orden = num_proc_orden ;
|
|
proc_orden[ num_proc_orden++ ] = num ;
|
|
|
|
|
|
return num_proc_orden-1 ;
|
|
}
|
|
|
|
|
|
int lista_quita( int num )
|
|
{
|
|
int i ;
|
|
|
|
procs_s[proc_orden[num]].tipo=0;
|
|
|
|
for ( i = num+1 ; i < num_proc_orden ; i++ )
|
|
{
|
|
procs_s[ proc_orden[ i ] ].orden-- ;
|
|
proc_orden[ i - 1 ] = proc_orden[ i ] ;
|
|
}
|
|
num_proc_orden-- ;
|
|
|
|
return 1 ;
|
|
|
|
}
|
|
|
|
|
|
|
|
int interprete()
|
|
{
|
|
|
|
int _status=reservedptr("status");
|
|
|
|
// PROVISIONAL. Se tendra que cambiar para k soporte frame(int) y prioritys
|
|
if ( num_proc_orden > 0 )
|
|
{
|
|
for ( proceso_actual = 0 ; proceso_actual < num_proc_orden ; proceso_actual++ )
|
|
{
|
|
if(procs_s[proc_orden[proceso_actual]].tipo==0 || mem[procs_s[proc_orden[proceso_actual]].id+_status]==2)
|
|
proceso( proc_orden[ proceso_actual ], -1 ) ;
|
|
}
|
|
Call_Entrypoint(EDIV_frame);
|
|
|
|
for ( proceso_actual = 0 ; proceso_actual < num_proc_orden ; proceso_actual++ )
|
|
{
|
|
//printf("Proceso %d - Estado: %d\n",procs_s[proc_orden[proceso_actual]].id,mem[procs_s[proc_orden[proceso_actual]].id+_status]);
|
|
if(mem[procs_s[proc_orden[proceso_actual]].id+_status]==1) {
|
|
mem[procs_s[proc_orden[proceso_actual]].id+_status]=0;
|
|
//assert(0);
|
|
lista_quita(proceso_actual);
|
|
proceso_actual--;
|
|
}
|
|
}
|
|
|
|
}
|
|
else {
|
|
stub_quit(0) ;
|
|
}
|
|
|
|
|
|
return 1 ;
|
|
}
|
|
|
|
|
|
int proceso( int num, int padre )
|
|
{
|
|
int v1 ;
|
|
int retcode = 0;
|
|
int no_devuelve = 0 ;
|
|
int (*externa)(struct _fun_params*);
|
|
int temp ;
|
|
int cpas=0;
|
|
#ifdef DBG
|
|
int actual_lin;
|
|
#endif
|
|
int _status=reservedptr("status");
|
|
int _param_offset;
|
|
|
|
num_proc = num ;
|
|
imem = procs_s[num_proc].imem ;
|
|
|
|
//printf("num_proc: %d\n",num);
|
|
|
|
|
|
//if(num==972) assert(0);
|
|
|
|
while( retcode == 0 )
|
|
{
|
|
|
|
//printf("imem: %i\tnum_proc: %i\tsp: %i\tpila[sp]: %i \n" , imem , num_proc , sp , pila[sp]) ;
|
|
|
|
switch ( mem[ imem++ ] )
|
|
{
|
|
case lnop://0
|
|
break;
|
|
case lcar://1
|
|
pila[++sp]=mem[imem++] ;
|
|
break;
|
|
case lasi://2
|
|
mem[ pila[sp-1] ] = pila[sp--] ;
|
|
//printf("Cargado %i en %i\n" , pila[sp+1], pila[sp] ) ;
|
|
break ;
|
|
case lori://3
|
|
pila[sp-1]|=pila[sp];
|
|
sp--;
|
|
break;
|
|
case lxor://4
|
|
pila[sp-1]^=pila[sp];
|
|
sp--;
|
|
break;
|
|
case land://5
|
|
pila[sp-1]&=pila[sp];
|
|
sp--;
|
|
break;
|
|
case ligu://6
|
|
pila[sp-1] = ( pila[sp-1] == pila[sp] ) ;
|
|
sp--;
|
|
break;
|
|
case ldis://7
|
|
pila[sp-1] = ( pila[sp-1] != pila[sp] ) ;
|
|
sp--;
|
|
break;
|
|
case lmay://8
|
|
pila[sp-1] = ( pila[sp-1] > pila[sp] ) ;
|
|
sp--;
|
|
break;
|
|
case lmen://9
|
|
pila[sp-1] = ( pila[sp-1] < pila[sp] ) ;
|
|
sp--;
|
|
break;
|
|
case lmei://10
|
|
pila[sp-1] = ( pila[sp-1] <= pila[sp] ) ;
|
|
sp--;
|
|
break;
|
|
case lmai://11
|
|
pila[sp-1] = ( pila[sp-1] >= pila[sp] ) ;
|
|
sp--;
|
|
break;
|
|
case ladd://12
|
|
pila[sp-1] += pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lsub://13
|
|
pila[sp-1] -= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lmul://14
|
|
pila[sp-1] *= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case ldiv://15
|
|
if(pila[sp]==0) error(145); // división entre cero
|
|
pila[sp-1] /= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lmod://16
|
|
if(pila[sp]==0) error(145); // división entre cero
|
|
pila[sp-1] %= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lneg://17
|
|
pila[sp] = -pila[sp] ;
|
|
break ;
|
|
case lptr://18
|
|
pila[sp] = mem[ pila[sp] ] ;
|
|
break ;
|
|
case lnot://19
|
|
pila[sp]^=-1;
|
|
break ;
|
|
case laid://20
|
|
pila[sp]+= procs_s[num_proc].id ;
|
|
break ;
|
|
case lcid://21
|
|
pila[++sp] = procs_s[num_proc].id ;
|
|
break ;
|
|
case lrng://22 POR HACER (debug)
|
|
imem++;
|
|
break ;
|
|
case ljmp://23
|
|
imem = mem[ imem ] ;
|
|
//printf("Nueva posicion: %i\n", imem ) ;
|
|
break ;
|
|
case ljpf://24
|
|
if (!(pila[sp]&1))
|
|
imem = mem[ imem ] ;
|
|
else
|
|
imem++;
|
|
sp--;
|
|
break ;
|
|
case lfun://25 NO USADO
|
|
break ;
|
|
case lcal://26
|
|
//assert(num_proc_orden<153);
|
|
devolver++ ;
|
|
v1 = busca_proc_libre() ;
|
|
procs_s[v1].imem = mem[imem++] ;
|
|
temp = proceso_actual ;
|
|
proceso_actual = lista_mete(v1) ;
|
|
procs_s[num_proc].imem = imem ;
|
|
proceso(v1,num_proc) ;
|
|
proceso_actual = temp ;
|
|
num_proc = num ;
|
|
imem = procs_s[num_proc].imem ;
|
|
break ;
|
|
case lret://27
|
|
lista_quita(num_proc) ;
|
|
//printf("Ret: %i\n" , num_proc) ;
|
|
retcode = 1 ;
|
|
break ;
|
|
case lasp://28
|
|
sp--;
|
|
break;
|
|
case lfrm://29
|
|
procs_s[num_proc].imem = imem ;
|
|
reserved("type_scan",procs_s[num_proc].id)=0; /* resetea get_id() */
|
|
reserved("id_scan",procs_s[num_proc].id)=0;
|
|
if ( first_loaded )
|
|
{
|
|
Call_Entrypoint(EDIV_first_load);
|
|
first_loaded = 0 ;
|
|
}
|
|
//printf("Frame en: %i\n" , imem ) ;
|
|
retcode = 1 ;
|
|
break ;
|
|
case lcbp://30
|
|
reserved("parameters",procs_s[num_proc].id)=mem[imem++];
|
|
reserved("param_offset",procs_s[num_proc].id)=sp-reserved("parameters",procs_s[num_proc].id)+1;
|
|
/**/procs_s[num_proc].num_params = mem[ imem-1 ] ;
|
|
break;
|
|
case lcpa://31
|
|
mem[pila[sp]]=pila[reserved("param_offset",procs_s[num_proc].id)++];
|
|
sp--;
|
|
cpas++;
|
|
if(cpas==reserved("parameters",procs_s[num_proc].id))
|
|
sp-=cpas;
|
|
break;
|
|
case ltyp://32
|
|
if ( procs_s[num_proc].tipo != 0 )
|
|
critical_error(3); // redefinición del tipo de proceso
|
|
procs_s[num_proc].id = (mem[2] + ( num_proc * iloc_len ))|1;
|
|
if(procs_s[num_proc].id>imem_max-iloc_len) critical_error(8); // demasiados procesos en ejecución
|
|
memcpy(&mem[procs_s[num_proc].id],&mem[iloc],iloc_pub_len<<2);
|
|
reserved("process_id",procs_s[num_proc].id)=procs_s[num_proc].id;
|
|
if(padre!=-1) {
|
|
int bigbro;
|
|
if(bigbro=local("son",procs_s[padre].id)) {
|
|
local("smallbro",bigbro)=procs_s[num_proc].id;
|
|
local("bigbro",procs_s[num_proc].id)=bigbro;
|
|
}
|
|
local("son",procs_s[padre].id)=procs_s[num_proc].id;
|
|
local("father",procs_s[num_proc].id)=procs_s[padre].id;
|
|
}
|
|
else {
|
|
local("father",procs_s[num_proc].id)=0;
|
|
}
|
|
procs_s[num_proc].tipo = mem[ imem++ ] ;
|
|
reserved("process_type",procs_s[num_proc].id) = procs_s[num_proc].tipo ;
|
|
mem[procs_s[num_proc].id+_status] = 2;
|
|
inicio_privadas=mem[6];
|
|
break ;
|
|
case lpri://33 POR HACER?
|
|
memcpy(&mem[procs_s[num_proc].id+inicio_privadas],&mem[imem+1],(mem[imem]-imem-1)<<2);
|
|
inicio_privadas+=(mem[imem]-imem-1); imem=mem[imem];
|
|
break ;
|
|
case lcse://34
|
|
if ( pila[sp-1] == pila[sp] )
|
|
imem++;
|
|
else
|
|
imem=mem[imem];
|
|
sp--;
|
|
break ;
|
|
case lcsr://35
|
|
if ( pila[sp-2] >= pila[sp-1] && pila[sp-2] <= pila[sp] )
|
|
imem++ ;
|
|
else
|
|
imem = mem[imem];
|
|
sp-=2;
|
|
break ;
|
|
case lshr://36
|
|
pila[sp-1] >>= pila[sp] ;
|
|
sp-- ;
|
|
break ;
|
|
case lshl://37
|
|
pila[sp-1] <<= pila[sp] ;
|
|
sp-- ;
|
|
break ;
|
|
case lipt://38
|
|
pila[sp] = ++mem[ pila[sp] ] ;
|
|
break ;
|
|
case lpti://39 COMPORTAMIENTO EXTRAÑO SI SE PONE EN UNA LINEA
|
|
mem[ pila[sp] ]++;
|
|
pila[sp] = mem[ pila[sp] ]-1 ;
|
|
break ;
|
|
case ldpt://40
|
|
pila[sp] = --mem[ pila[sp] ] ;
|
|
break ;
|
|
case lptd://41 COMPORTAMIENTO EXTRAÑO SI SE PONE EN UNA LINEA
|
|
mem[ pila[sp] ]--;
|
|
pila[sp] = mem[ pila[sp] ]+1 ;
|
|
break ;
|
|
case lada://42
|
|
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] += pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lsua://43
|
|
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] -= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lmua://44
|
|
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] *= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case ldia://45
|
|
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] /= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lmoa://46
|
|
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] %= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lana://47
|
|
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] &= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lora://48
|
|
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] |= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lxoa://49
|
|
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] ^= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lsra://50
|
|
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] >>= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lsla://51
|
|
pila[ sp-1 ] = mem[ pila[ sp-1 ] ] <<= pila[sp] ;
|
|
sp--;
|
|
break;
|
|
case lpar://52 POR HACER?
|
|
//imem++;
|
|
inicio_privadas+=mem[imem++];
|
|
break;
|
|
case lrtf://53
|
|
lista_quita(num_proc) ;
|
|
no_devuelve = 1 ;
|
|
//printf("Return: %i\n" , num_proc) ;
|
|
retcode = 1 ;
|
|
break ;
|
|
case lclo://54 POR HACER
|
|
break ;
|
|
case lfrf://55 POR HACER
|
|
sp--;
|
|
break ;
|
|
case limp://56
|
|
carga_dll((char*)&mem[mem[imem++]]);
|
|
break ;
|
|
case lext://57
|
|
//assert(0);
|
|
externa=extfuncs[mem[imem]];
|
|
// corresponder con FUNCTION_PARAMS
|
|
//temp = externa(pila,&sp,mem,varindex,&procs_s,Call_Entrypoint);
|
|
fp.num_params=extparms[mem[imem++]];
|
|
temp = externa(&fp) ;
|
|
pila[++sp]= temp ;
|
|
break ;
|
|
case ldbg://58
|
|
#ifdef DBG
|
|
Call_Entrypoint(EDIV_debug,imem,nombre_program,lin,0);
|
|
#endif
|
|
break ;
|
|
|
|
/* OPCODES OPTIMIZADOS */
|
|
|
|
case lcar2://60
|
|
pila[++sp]=mem[imem++];
|
|
pila[++sp]=mem[imem++];
|
|
break;
|
|
case lcar3://61
|
|
pila[++sp]=mem[imem++];
|
|
pila[++sp]=mem[imem++];
|
|
pila[++sp]=mem[imem++];
|
|
break;
|
|
case lcar4://62
|
|
pila[++sp]=mem[imem++];
|
|
pila[++sp]=mem[imem++];
|
|
pila[++sp]=mem[imem++];
|
|
pila[++sp]=mem[imem++];
|
|
break;
|
|
case lasiasp://63
|
|
mem[pila[sp-1]]=pila[sp];
|
|
sp-=2;
|
|
break;
|
|
case lcaraid://64
|
|
pila[++sp]=mem[imem++]+procs_s[num_proc].id;
|
|
break;
|
|
case lcarptr://65
|
|
pila[++sp]=mem[mem[imem++]];
|
|
break;
|
|
case laidptr://66
|
|
pila[sp]=mem[pila[sp]+procs_s[num_proc].id];
|
|
break;
|
|
case lcaraidptr://67
|
|
pila[++sp]=mem[mem[imem++]+procs_s[num_proc].id];
|
|
break;
|
|
case lcaraidcpa://68
|
|
mem[mem[imem++]+procs_s[num_proc].id]=pila[reserved("param_offset",procs_s[num_proc].id)++];
|
|
sp--;
|
|
break;
|
|
case laddptr://69
|
|
pila[sp-1]=mem[pila[sp-1]+pila[sp]];
|
|
sp--;
|
|
break;
|
|
case lfunasp://70 NO USADO
|
|
break;
|
|
case lcaradd://71
|
|
pila[sp]+=mem[imem++];
|
|
break;
|
|
case lcaraddptr://72
|
|
pila[sp]=mem[pila[sp]+mem[imem++]];
|
|
break;
|
|
case lcarmul://73
|
|
pila[sp]*=mem[imem++];
|
|
break;
|
|
case lcarmuladd://74
|
|
pila[sp-1]+=pila[sp]*mem[imem++];
|
|
sp--;
|
|
break;
|
|
case lcarasiasp://75
|
|
mem[pila[sp]]=mem[imem++];
|
|
sp--;
|
|
break;
|
|
case lcarsub://76
|
|
pila[sp]-=mem[imem++];
|
|
break;
|
|
case lcardiv://77 no hay nunca "cardiv 0"
|
|
pila[sp]/=mem[imem++];
|
|
break;
|
|
|
|
/* OPERACIONES CON DATOS DE TIPO BYTE */
|
|
|
|
case lptrchr:
|
|
pila[sp-1]=(unsigned int)memb[pila[sp-1]*4+pila[sp]];
|
|
sp--;
|
|
break;
|
|
case lasichr:
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case liptchr:
|
|
pila[sp-1]=(unsigned int)++memb[pila[sp-1]*4+pila[sp]];
|
|
sp--;
|
|
break;
|
|
case lptichr:
|
|
pila[sp-1]=(unsigned int)memb[pila[sp-1]*4+pila[sp]]++;
|
|
sp--;
|
|
break;
|
|
case ldptchr:
|
|
pila[sp-1]=(unsigned int)--memb[pila[sp-1]*4+pila[sp]];
|
|
sp--;
|
|
break;
|
|
case lptdchr:
|
|
pila[sp-1]=(unsigned int)memb[pila[sp-1]*4+pila[sp]]--;
|
|
sp--;
|
|
break;
|
|
case ladachr:
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]+=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case lsuachr:
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]-=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case lmuachr:
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]*=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case ldiachr:
|
|
/*#ifdef DBG
|
|
if (pila[sp]==0) {
|
|
memb[pila[sp-2]*4+pila[sp-1]]=0;
|
|
sp-=2; pila[sp]=0;
|
|
v_function=-2; e(145);
|
|
if (call_to_debug) { process_stoped=id; return; }
|
|
break;
|
|
}
|
|
#endif*/
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]/=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case lmoachr:
|
|
/*#ifdef DBG
|
|
if (pila[sp]==0) {
|
|
memb[pila[sp-2]*4+pila[sp-1]]=0;
|
|
sp-=2; pila[sp]=0;
|
|
v_function=-2; e(145);
|
|
if (call_to_debug) { process_stoped=id; return; }
|
|
break;
|
|
}
|
|
#endif*/
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]%=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case lanachr:
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]&=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case lorachr:
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]|=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case lxoachr:
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]^=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case lsrachr:
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]>>=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case lslachr:
|
|
pila[sp-2]=(unsigned int)(memb[pila[sp-2]*4+pila[sp-1]]<<=(byte)pila[sp]);
|
|
sp-=2;
|
|
break;
|
|
case lcpachr:
|
|
_param_offset=reservedptr("param_offset");
|
|
if ((unsigned int)pila[mem[procs_s[num_proc].id+_param_offset]]<256) {
|
|
memb[pila[sp-1]*4+pila[sp]]=(byte)pila[mem[procs_s[num_proc].id+_param_offset]];
|
|
}
|
|
else {
|
|
if (pila[mem[procs_s[num_proc].id+_param_offset]]<imem_max+258*4)
|
|
memb[pila[sp-1]*4+pila[sp]]=memb[pila[mem[procs_s[num_proc].id+_param_offset]]*4];
|
|
else
|
|
memb[pila[sp-1]*4+pila[sp]]=(byte)pila[mem[procs_s[num_proc].id+_param_offset]];
|
|
}
|
|
sp-=2;
|
|
mem[procs_s[num_proc].id+_param_offset]++;
|
|
break;
|
|
}
|
|
|
|
#ifdef DBG
|
|
Call_Entrypoint(EDIV_trace,imem,nombre_program,lin,0);
|
|
#ifdef _DEBUG
|
|
actual_lin=localiza_lin(imem);
|
|
if(actual_lin!=last_lin) {
|
|
unsigned char* p=&prog[lin[actual_lin*4+3]];
|
|
// printf("[%d|%d-%d] ",imem,lin[actual_lin*4+3],lin[actual_lin*4+4]);
|
|
printf("[%d] ",imem);
|
|
while(p<=&prog[lin[actual_lin*4+4]]) {
|
|
putc(*p,stdout);
|
|
p++;
|
|
}
|
|
printf("\n");
|
|
last_lin=actual_lin;
|
|
}
|
|
#endif /* _DEBUG */
|
|
#endif /* DBG */
|
|
}
|
|
|
|
if ( devolver > 0 && no_devuelve == 0 )
|
|
{
|
|
//pila[++sp] = 0 ;// AQUI SE DEBERA DEVOLVER EL ID
|
|
pila[++sp]=procs_s[num_proc].id;
|
|
devolver-- ;
|
|
}
|
|
|
|
Call_Entrypoint(EDIV_post_process);
|
|
|
|
return 1 ;
|
|
}
|
|
|
|
#ifdef DBG
|
|
|
|
/*
|
|
* int localiza_lin (int ip)
|
|
* Localiza el imem actual (ip) en la tabla LIN (es decir, localiza en qué línea y
|
|
* columna del PRG nos encontramos).
|
|
*
|
|
* Retorna:
|
|
* ((El índice en lin[])-1)/4 <- sentiende no?
|
|
*/
|
|
|
|
int localiza_lin(int ip)
|
|
{
|
|
lin_item* last;
|
|
int i;
|
|
/* Primero, para ahorrar tiempo, comprueba si aún seguimos dentro de la misma
|
|
sentencia, aunque sea distinto opcode */
|
|
last=(lin_item*)(&lin[last_lin*4]);
|
|
if(last->inicio<=ip && last->fin>=ip) {
|
|
//printf("(%d) last_lin\n",ip);
|
|
return last_lin;
|
|
}
|
|
|
|
/* Si no, recorre la tabla LIN a partir de donde estábamos, no desde el principio,
|
|
ya que es más probable que hayamos saltado a una sentencia posterior que a una
|
|
anterior */
|
|
for(i=last_lin;i<lin[0];i++) {
|
|
if(lin[i*4+1]<=ip && lin[i*4+2]>=ip)
|
|
return i;
|
|
}
|
|
|
|
/* No lo hemos encontrado, entonces buscaremos desde el principio hasta last_lin */
|
|
for(i=0;i<last_lin;i++) {
|
|
if(lin[i*4+1]<=ip && lin[i*4+2]>=ip)
|
|
return i;
|
|
}
|
|
|
|
/* Si aún no lo hemos encontrado, mal rollito.. bug seguro, avisemos al programador */
|
|
#ifdef _DEBUG
|
|
printf("PANIC! No se en que parte del PRG estoy! imem=%d, last_lin=%d\n",ip,last_lin);
|
|
#endif
|
|
|
|
return last_lin;
|
|
}
|
|
|
|
#endif /* DBG */
|