static void dumpFic(char *L)
{
int fd;
struct DumpEnt E;
char * F;
dropTrSuite();
F = DumpRest_ext(L);
if ((fd = open(F,O_CREAT|O_WRONLY,0600)) == -1) {
perror(F);
messErr(58);
} else {
strncpy(E.L,"Nblf010", 7);
E.V=atof(VERSION);
E.Scs=(long)getScs();
if ((write(fd,(void*)&E, LENT)) == LENT) {
dump_marque(fd, 'N');
dump_stackN(fd);
dump_marque(fd, 'C');
dump_stackC(fd);
dump_marque(fd, 'L');
dump_stackL(fd);
dump_marque(fd, 'V');
dump_stackV(fd);
dump_marque(fd, 'F');
dump_stackF(fd);
dump_marque(fd, 'X');
close(fd);
} else messErr(58);
}
free((void*)F);
}
struct Fct *putCodeFct(void* C)
{
struct Fct *Elt;
if (stackF != VIDE) {
Elt = (struct Fct *)stackF;
if (Elt->c == VIDE) Elt->c = C;
else messErr(8);
}
else messErr(7);
return Elt;
}
void IF_finFct(void)
{
void * M;
struct Fct * F;
int i,l, *ea, *Ea;
if ((M = malloc((3*sizeof(int))+i_cod)) == NULL)
stopErr("IF_finFct","malloc");
ea = (int*)M;
*ea++ = i_cod;
*ea=0;
Ea=ea+1;
*Ea=0;
/* on remplace tous les MYSELF */
l = sizeof(M);
for (i=0; i<i_cod; i+=(l+1)) {
if (cod[i]==T_MYSF) {
cod[i] = T_FCT;
bcopy((void*)&M,(void*)&cod[i+1],l);
} else {
if (cod[i]==T_ONER) {
if (*ea==0) *ea = i;
else {
messErr(46);
return;
}
} else {
if (cod[i]==T_END) {
if (*Ea==0) *Ea = i;
else {
messErr(47);
return;
}
}
}
}
}
bcopy((void*)cod,(void*)((char*)M+(3*sizeof(int))),i_cod);
F=putCodeFct(M);
if (F->typ) {
F->typ=2;
addFonU(F->l,M);
}
/* printf("Total Fct : %d + %d !\n",i_cod,(3*sizeof(int))); */
_MODIF_fctEnCours_(0);
}
static void lectFic(char *L)
{
int fd;
dropTrSuite();
if ((fd = open(L,O_RDONLY)) == -1) {
perror(L);
messErr(16);
} else addFD(fd,L);
}
void IF_typeC(void)
{
int i;
i = i_StackC;
if (i) {
printf("%s",stackC[i-1]);
IF_dropC();
}
else messErr(6);
}
void IF_old_stackC(void)
{
if (G_i_TStackC == 0) {
messErr(61); return;
}
G_TiStackC[G_i_TStackC] = i_StackC;
G_TStackC[G_i_TStackC--] = stackC;
stackC = G_TStackC[G_i_TStackC];
i_StackC = G_TiStackC[G_i_TStackC];
}
void rmLastFct(void)
{
struct Fct *Elt;
if (stackF != VIDE) {
Elt = (struct Fct *)stackF;
if (Elt->typ==2) return;
stackF = Elt->n;
eraseFct(Elt);
} else messErr(7);
}
static void IF_dupC_i(int i)
{
char * S;
int I;
I = i_StackC;
if (I>=i) {
S = stackC[I-i];
putString(S);
}
else messErr(19);
}
void IF_execCSv(void)
{
char * f;
f = getString();
if (f != NULL) {
if (!IF_execVar(f)) {
printf("%s - ",f); messErr(24);
}
free((void*)f);
}
}
void IF_NewTask (void)
{
int i;
for (i=0;i<MAX_TASK;i++) if (TASKp[i]==0) break;
if (i<MAX_TASK) {
FctInTask = i+1;
} else {
FctInTask = -1;
messErr(26);
}
}
char * getString(void) /* NOT free() !!! */
{
int i;
i = i_StackC;
if (i) {
i--;
_MODIF_i_StackC_(i);
return(stackC[i]);
}
messErr(6);
return NULL;
}
void suiteBackC1(char *S)
{
void * M;
dropTrSuite();
if (strlen(S) > LDFLT) {
messErr(9);
return;
}
if (S[strlen(S)-1] != '`') {
messErr(44);
return;
}
S[strlen(S)-1] = '\0';
if ((M = malloc(strlen(S)+1)) == NULL) stopErr("suiteBackC1","malloc");
#ifdef DEBUG_M
printf("New String address : %lu \n",(unsigned long)M);
#endif
strcpy((char*)M,S);
if (fctEnCours) makeFct(T_BKC1,M);
else messErr(13);
}
void IF_swapC(void)
{
char * S;
int I;
I = i_StackC;
if (I>1) {
S = stackC[I-1];
stackC[I-1] = stackC[I-2];
stackC[I-2] = S;
}
else messErr(19);
}
static void restoreFic(char *L)
{
int fd;
struct DumpEnt E;
char * F;
dropTrSuite();
F = DumpRest_ext(L);
if ((fd = open(F,O_RDONLY)) == -1) {
perror(F);
messErr(43);
} else {
if (read(fd,(void*)&E, LENT) != LENT) {
printf("File too small !\n");
messErr(59);
} else {
if (strncmp(E.L,"Nblf010", 7) == 0) {
if (E.Scs == (long)getScs()) {
if (E.V == atof(VERSION)) {
restore_marque(fd, 'N');
restore_stackN(fd);
restore_marque(fd, 'C');
restore_stackC(fd);
restore_marque(fd, 'L');
restore_stackL(fd);
restore_marque(fd, 'V');
restore_stackV(fd);
restore_links_stackN();
restore_marque(fd, 'F');
restore_stackF(fd);
restore_marque(fd, 'X');
restore_links_stackV();
} else printf("This file is just available for Nife v %g !\n",E.V);
} else printf("This file have another SCS !\n");
} else printf("Not a NBLF File !\n");
close(fd);
}
}
free((void*)F);
}
void * makeFunction(char * f)
{
void *M;
if ((M = malloc(strlen(f)+8)) == NULL) stopErr("makeFunction","malloc");
sprintf((char*)M,": _f %s ;",f);
traiteLigne((char*)M,3);
free(M);
if (noErr() == 0) {
M = fctByName("_f");
return M;
}
messErr(48);
return VIDE;
}
void IF_new_stackC(void)
{
if (G_i_TStackC == LSTACKS) {
messErr(60); return;
}
G_TiStackC[G_i_TStackC] = i_StackC;
G_TStackC[G_i_TStackC++] = stackC;
stackC = G_TStackC[G_i_TStackC];
i_StackC = G_TiStackC[G_i_TStackC];
if (stackC == (char **)0) {
if ((stackC = (char**)malloc(sizeof(char**)*LSTACKC)) == NULL)
stopErr("IF_new_stackC","malloc");
i_StackC=0;
}
}
void IF_delTask(void)
{
long V;
int i;
if (getParLong(&V)) {
i = V -1;
if (TASKp[i] != 0) {
if (kill(TASKp[i],SIGUSR1)==0) {
messErr(27);
return;
}
}
TASKp[i] = 0;
}
}
void IF_showCons(void)
{
long V;
int i;
char * NF, comm[30];
if (getParLong(&V)) {
i = V -1;
if (TASKp[i] != 0) {
NF = FicCons((int)V);
sprintf(comm,"more %s",NF);
runCommand(comm);
}
else messErr(28);
}
}
static void delVar(char * L)
{
void ** PNext;
struct Var * N;
dropTrSuite();
PNext = &stackV;
while (*PNext != VIDE) {
N = (struct Var*) *PNext;
if (strcmp(N->l,L)==0) {
rmVar(PNext, N);
return;
}
PNext = &N->n;
}
messErr(24);
}
static void scanFonc(char * Lib)
{
void ** PNext;
struct Fct * N;
dropTrSuite();
PNext = &stackF;
while (*PNext != VIDE) {
N = (struct Fct*) *PNext;
if (strcmp(N->l,Lib)==0) break;
PNext = &N->n;
}
if (strcmp(N->l,Lib)!=0) {
messErr(21);
return;
}
scanFoncI((void*)N ,0);
}
static void rmFct(char * L)
{
void ** PNext;
struct Fct * N;
dropTrSuite();
PNext = &stackF;
while (*PNext != VIDE) {
N = (struct Fct*) *PNext;
if (N->typ==0)
if (strcmp(N->l,L)==0) {
*PNext = N->n;
eraseFct(N);
return;
}
PNext = &N->n;
}
messErr(21);
}
void addFD(int fd, char*S)
{
void *M;
iFD++;
/* printf("addFD iFD=%d\n",iFD); */
if (iFD == FDMAX) {
iFD--;
messErr(45);
return;
}
_MODIF_FD_IN_(fd);
FD_T[iFD]=fd;
FD_L[iFD]=0;
if ((M = malloc(strlen(S)+1)) == NULL) stopErr("addFD","malloc");
#ifdef DEBUG_M
printf("New String address : %lu \n",(unsigned long)M);
#endif
strcpy((char*)M,S);
FD_N[iFD]=M;
}
void suiteString(char *S)
{
int end=0;
if ((strlen(bufC)+strlen(S)+1) > MAXSTRING) {
dropTrSuite();
_MODIF_stringEnCours_(0);
messErr(9);
return;
}
if (S[strlen(S)-1] == '"') {
S[strlen(S)-1] = '\0';
end=1;
}
strcat(bufC,S);
if (end) {
dropTrSuite();
_MODIF_stringEnCours_(0);
putString(bufC);
}
}
static void IF_catC_i(int i)
{
char * S1, * S2, *S;
int l, I;
I = i_StackC;
if (I>1) {
S1 = stackC[I-2];
S2 = stackC[I-1];
l = strlen(S1) + strlen(S2) + i + 1;
if ((S = (char*)malloc(l+1)) == NULL) stopErr("IF_catC_i","malloc");
strcpy(S,S1);
if (i) strcat(S, " ");
strcat(S,S2);
IF_dropC();
IF_dropC();
I = i_StackC;
stackC[I++]=S;
_MODIF_i_StackC_(I);
}
else messErr(19);
}
static void rmOFct(char * L)
{
void ** PNext, ** FP;
struct Fct * N, * F;
dropTrSuite();
F = VIDE;
PNext = &stackF;
while (*PNext != VIDE) {
N = (struct Fct*) *PNext;
if (N->typ==0)
if (strcmp(N->l,L)==0) {
FP = PNext;
F = N;
}
PNext = &N->n;
}
if (F != VIDE) {
*FP = F->n;
eraseFct(F);
}
else messErr(21);
}
int execLib(char *C)
{
int i;
void * A;
short T=0;
InExec = C;
/* D_Trace(C); pas pour le moment */
if (sigsetjmp(ENV_INT,1)) {
interInfos("execLib",C);
return 1;
}
if (InstallOn) {
switch (InstallOn) {
case 1 : /* lib first */
A=libByName(C);
if (A==VIDE) {
A=fctByName(C);
if (A!=VIDE) T=2;
} else T=1;
break;
case 2 : /* user functions first */
A=fctByName(C);
if (A==VIDE) {
A=libByName(C);
if (A!=VIDE) T=1;
} else T=2;
break;
case 3 : /* variables only */
A=varByName(C);
if (A!=VIDE) T=3;
break;
case 8 : /* df_init */
A=fctByName(C);
updDynFct(A,0);
break;
case 9 : /* df_start */
A=fctByName(C);
updDynFct(A,1);
break;
case 10 : /* df_stop */
A=fctByName(C);
updDynFct(A,2);
break;
default :
break;
}
_MODIF_FCT_INST_(A);
_MODIF_FCT_TYP_(T);
InstallOn=0;
return 1;
}
if ((VARS==2) && (IF_execVar(C))) return 1; /* VARS UP */
if (IF_execFct(C)) return 1;
for (i=0;i<NBFonc;i++) {
/* printf("execLib : teste %s !\n", Fonctions[i].nam); */
if (strcmp(C,Fonctions[i].nam) == 0) {
switch (Fonctions[i].typ) {
case 1:
if (fctEnCours) Fonctions[i].fct();
else messErr(13);
break;
case 2:
if (fctEnCours) messErr(25);
else Fonctions[i].fct();
break;
case 3: /* usr fct */
break;
default: /* typ = 0 */
if (fctEnCours) {
if (strcmp(C,":") == 0) messErr(15);
else {
if (strcmp(C,"\"") == 0) Fonctions[i].fct();
else makeFct(T_LIB,(void*)Fonctions[i].fct);
}
} else Fonctions[i].fct();
break;
}
return 1;
}
}
if ((VARS==1) && (IF_execVar(C))) return 1; /* VARS DOWN */
/* printf("execLib : appel putVal(%s)\n",C); */
return(putVal(C));
}
static void IF_instruct(Code C)
{
if (fctEnCours) makeFct(C,NULL);
else messErr(13);
}
void makeFct(Code c,void *A)
{
int d,i;
long L, L2, LE;
d = sizeof(A);
/* printf("makeFct Entree : code %d + %d\n",(int)c,i_cod); */
switch(c) {
case T_RET :
case T_NUM :
case T_CHA :
case T_LIB :
case T_FCT :
case T_MYSF :
case T_DO_I :
case T_DO_J :
case T_DO_K :
case T_VAR :
case T_BKC :
case T_BKC1 :
case T_ONER :
case T_END :
case T_JEND :
case T_EXEK :
cod[i_cod++] = c;
bcopy((void*)&A,(void*)&cod[i_cod],d);
i_cod+=d;
break;
case T_IF :
cod[i_cod++] = c;
adr[i_adr]=(void*)&cod[i_cod];
i_cod+=d;
tad[i_adr++]=c;
break;
case T_ELSE :
if (tad[i_adr-1] == T_IF) {
cod[i_cod++] = T_JMP;
adr[i_adr]=(void*)&cod[i_cod];
L = (void*)&(cod[i_cod]) - adr[i_adr-1];
i_cod+=d;
bcopy((void*)&L,adr[i_adr-1],d);
tad[i_adr++]=c;
} else messErr(14);
break;
case T_THEN :
if ((tad[i_adr-1] == T_IF) || (tad[i_adr-1] == T_ELSE)) {
L = (void*)&cod[i_cod+1] - adr[i_adr-1] - (sizeof(void*)+1);/*AV5*/
bcopy((void*)&L,adr[i_adr-1],d);
tad[i_adr]='\0';
while (tad[i_adr] != T_IF) i_adr--; /* depile adr */
} else messErr(14);
break;
case T_BEGI :
adB[i_adB]=i_cod;
tcB[i_adB++]=c;
break;
case T_DO :
cod[i_cod++] = c;
i_cod+=d;
adD[i_adD]=i_cod;
tcD[i_adD++]=c;
cod[i_cod++] = T_IFD;
L = d+1;
bcopy((void*)&L,(void*)&cod[i_cod],d);
i_cod+=d;
cod[i_cod++] = T_GOTO;
L = -1;
bcopy((void*)&L,(void*)&cod[i_cod],d);
i_cod+=d;
break;
case T_PLOO :
case T_LOOP :
if (tcD[i_adD-1] == T_DO) {
i_adD--; /* on depile */
cod[i_cod++] = c;
i_cod+=d;
cod[i_cod++] = T_GOTO;
L = adD[i_adD];
bcopy((void*)&L,(void*)&cod[i_cod],d);
i_cod+=d;
/* maj des breaks GOTO -1 */
LE = i_cod;
for(i=L;i<i_cod-(d+1);i+=(d+1)) {
if (cod[i] == T_GOTO) {
bcopy((void*)&cod[i+1],(void*)&L2,d);
if (L2==-1) bcopy((void*)&LE,(void*)&cod[i+1],d);
}
}
} else messErr(39);
break;
case T_AGAI :
case T_REPE :
if (tcB[i_adB-1] == T_BEGI) {
i_adB--; /* on depile */
cod[i_cod++] = T_GOTO;
L = adB[i_adB];
bcopy((void*)&L,(void*)&cod[i_cod],d);
i_cod+=d;
/* maj des breaks GOTO -1 */
LE = i_cod;
for(i=L;i<i_cod-(d+1);i+=(d+1)) {
if (cod[i] == T_GOTO) {
bcopy((void*)&cod[i+1],(void*)&L2,d);
if (L2==-1) bcopy((void*)&LE,(void*)&cod[i+1],d);
}
}
} else messErr(22);
break;
case T_UNTI :
case T_WHIL :
if (tcB[i_adB-1] == T_BEGI) {
cod[i_cod++] = T_IFN;
/* if (c==T_UNTI) cod[i_cod++] = T_IFN;
else cod[i_cod++] = T_IF;
*/
L = d+1;
bcopy((void*)&L,(void*)&cod[i_cod],d);
i_cod+=d;
cod[i_cod++] = T_GOTO;
if (c==T_UNTI) L = adB[i_adB-1];
else L = -1;
bcopy((void*)&L,(void*)&cod[i_cod],d);
i_cod+=d;
if (c==T_UNTI) {
i_adB--; /* depile adB */
/* maj des breaks GOTO -1 */
LE = i_cod;
for(i=L;i<i_cod-(d+1);i+=(d+1)) {
if (cod[i] == T_GOTO) {
bcopy((void*)&cod[i+1],(void*)&L2,d);
if (L2==-1) bcopy((void*)&LE,(void*)&cod[i+1],d);
}
}
}
} else messErr(22);
break;
case T_BREA :
cod[i_cod++] = T_GOTO;
L = -1; /* special value for BREAK */
bcopy((void*)&L,(void*)&cod[i_cod],d);
i_cod+=d;
break;
default :
messErr(11);
}
}
void execCod(void *A)
{
int i,n, ea, Ea, *ai, InDo=0, OnErr=0, mFCTP;
long L, P;
char * C, *D, *F, *W, *S, *ADo_Next, *ADo_Leave;
void * T, *T2;
void (*f)(void);
struct Fct * FR;
/* printf("pid = %d ITASK=%d FctInTask=%d\n",getpid(),ITASK,FctInTask);*/
if (FctInTask) {
if (ITASK==0) {
if (FctInTask==-1) {
FctInTask=0; return;
}
if (MakeTask(A)) return;
}
if (ITASK!=FctInTask) return;
}
D_Cod++;
ai = (int*)A;
i = *ai++;
ea = *ai++;
Ea = *ai;
if (ea) tellOnErr(A);
C = (char*)A+(3*sizeof(int));
D = C;
F = C+i;
n = sizeof(T);
while (C <= F) {
/* printf("execCod : %s %d - %x : %ld\n",
codByAddr(A),(int)(C-D),*C,(long)*(C+1));
*/
if (noErr() && ((C==F) || ((Code)*C != T_ONER)) ) { /* to find onerr: */
if (ea && (OnErr==0)) {
C = D+ea;
} else {
printf("Called in %s err=%d i=%d/%d cod=<%x>\n",
codByAddr(A),noErr(),(int)(C-D),i,*C);
break; /* end of while */
}
}
if (C==F) break; /* end of code */
switch((Code)*C) {
case T_ONER :
if (noErr()==0) { /* jmp end: */
if (Ea) C = D+Ea;
else C = F; /* to break */
} else {
if (OnErr==0) {
OnErr=1;
majLastErr(A);
razErr();
} else C = F;
}
break;
case T_RET :
C = F; /* to break */
break;
case T_END :
break; /* nothing */
case T_JEND :
if (Ea) C = D+Ea;
else C = F; /* to break */
break;
case T_NUM :
bcopy((void*)(C+1),(void*)&T,n);
insertVal(T);
break;
case T_CHA :
bcopy((void*)(C+1),(void*)&W,n);
putString(W);
break;
case T_LIB :
if (InstallOn) {
if (InstallOn < 3) {
bcopy((void*)(C+1),(void*)&T,n);
_MODIF_FCT_INST_(T);
_MODIF_FCT_TYP_(1);
} else {
_MODIF_FCT_INST_(VIDE);
_MODIF_FCT_TYP_(0);
}
InstallOn=0;
} else {
bcopy((void*)(C+1),(void*)&f,n);
f();
/* free context loops */
if (Do_Evts) { /* quit or cut */
/*printf("execCod T_LIB : Evts %d\n",Do_Evts);*/
if (InDo) {
if (Do_Evts>0) {
C=ADo_Leave;
I_DO--;
InDo = 0;
Do_Evts--;
} else {
C=ADo_Next;
Do_Evts=0;
}
} else { /* quit */
C = F;
}
}
}
break;
case T_FCT :
if (InstallOn) {
if (InstallOn < 3) {
bcopy((void*)(C+1),(void*)&T,n);
T2=fctByCode(T);
_MODIF_FCT_INST_(T2);
_MODIF_FCT_TYP_(2);
} else {
_MODIF_FCT_INST_(VIDE);
_MODIF_FCT_TYP_(0);
}
InstallOn=0;
} else {
bcopy((void*)(C+1),(void*)&T,n);
execCod(T);
/* free context loops */
if (Do_Evts) { /* quit or cut */
/*printf("execCod T_FCT : Evts %d\n",Do_Evts);*/
if (InDo) {
if (Do_Evts>0) {
C=ADo_Leave;
I_DO--;
InDo = 0;
Do_Evts--;
} else {
C=ADo_Next;
Do_Evts=0;
}
} else { /* quit */
C = F;
}
}
}
break;
case T_FCTDS :
case T_EXEKS :
if ((S = getString()) != NULL)
free((void*)S); /* remove the string */
break;
case T_FCTD :
if ((S = getString()) != NULL)
free((void*)S); /* remove the string */
if (noErr()) break;
case T_FCTDW :
case T_FCTP :
bcopy((void*)(C+1),(void*)&T,n);
FR = (struct Fct *)T;
execCod(FR->c);
/* free context loops */
if (Do_Evts) { /* quit or cut */
/*printf("execCod T_FCTD : Evts %d\n",Do_Evts);*/
if (InDo) {
if (Do_Evts>0) {
C=ADo_Leave;
I_DO--;
InDo = 0;
Do_Evts--;
} else {
C=ADo_Next;
Do_Evts=0;
}
} else { /* quit */
C = F;
}
}
if (*C == T_FCTP) {
if (mFCTP) *C = T_FCTDW;
else *C = T_FCTD;
}
break;
case T_EXEK :
if ((S = getString()) != NULL) {
if (strlen(S)>0) { /* to do with T_FCTD */
mFCTP=0;
T = makeFunction(S);
if (T != VIDE) {
bcopy((void*)&T, (void*)(C+1),n);
*C = T_FCTP;
C -= (n+1);
unlinkLastFct();
/* upgrading precedent code ? not always ! */
if (C >= D) {
if (*C == T_CHA) { /* case of a string */
*C = T_CHAS;
mFCTP=1;
}
if (*C == T_VAR) { /* case of a variable string */
bcopy((void*)(C+1),(void*)&W,n);
if (isVarChar(W)) {
*C = T_VARS;
mFCTP=1;
}
}
}
} else /* error in compilation */
*C = T_EXEKS;
}
free((void*)S);
}
break;
case T_IF :
if (!getBool()) {
bcopy((void*)(C+1),(void*)&L,n);
C += L;
}
break;
case T_IFN :
if (getBool()) {
bcopy((void*)(C+1),(void*)&L,n);
C += L;
}
break;
case T_DO :
I_DO++;
InDo=1;
/* maj do_adresses */
W = C + (2*(n+1));
bcopy((void*)(W+1),(void*)&L,n);
ADo_Leave=D+L-n-1;
ADo_Next=ADo_Leave-(2*(n+1));
/* printf("execCod T_DO : AL= %d AN=%d\n",
(int)(ADo_Leave-D), (int)(ADo_Next-D));*/
getParLong(&P);
D_DO[I_DO] = P;
getParLong(&P);
L_DO[I_DO] = P;
if (P > D_DO[I_DO]) S_DO[I_DO]=0;
else S_DO[I_DO]=1;
break;
case T_DO_I :
IF_getIndDo(0);
break;
case T_DO_J :
IF_getIndDo(1);
break;
case T_DO_K :
IF_getIndDo(2);
break;
case T_IFD :
if (S_DO[I_DO]) {
if (D_DO[I_DO] > L_DO[I_DO]) {
bcopy((void*)(C+1),(void*)&L,n);
C += L;
} else {
I_DO--;
InDo=0;
}
} else {
if (D_DO[I_DO] < L_DO[I_DO]) {
bcopy((void*)(C+1),(void*)&L,n);
C += L;
} else {
I_DO--;
InDo=0;
}
}
break;
case T_LOOP :
if (S_DO[I_DO]) D_DO[I_DO]--;
else D_DO[I_DO]++;
break;
case T_PLOO :
getParLong(&P);
D_DO[I_DO]+=P;
break;
case T_JMP :
bcopy((void*)(C+1),(void*)&L,n);
C += L;
break;
case T_GOTO :
bcopy((void*)(C+1),(void*)&L,n);
C = D + L - n-1;
break;
case T_VAR :
if (InstallOn) {
if (InstallOn == 3) {
bcopy((void*)(C+1),(void*)&T,n);
_MODIF_FCT_INST_(T);
_MODIF_FCT_TYP_(3);
} else {
_MODIF_FCT_INST_(VIDE);
_MODIF_FCT_TYP_(0);
}
InstallOn=0;
} else {
bcopy((void*)(C+1),(void*)&W,n);
executeVar(W);
/* free context loops */
if (Do_Evts) { /* quit or cut */
/*printf("execCod T_VAR : Evts %d\n",Do_Evts);*/
if (InDo) {
if (Do_Evts>0) {
C=ADo_Leave;
I_DO--;
InDo = 0;
Do_Evts--;
} else {
C=ADo_Next;
Do_Evts=0;
}
} else { /* quit */
C = F;
}
}
}
break;
case T_BKC :
bcopy((void*)(C+1),(void*)&W,n);
execLib(W);
break;
case T_BKC1 : /* like makeFct */
bcopy((void*)(C+1),(void*)&W,n);
/* try to modify the code */
if (VARS==2) { /* VARS UP */
if ((T = varByName(W)) != VIDE) {
*C = T_VAR;
} else {
if ((T = fctByName(W)) != VIDE) {
*C = T_FCT;
FR = (struct Fct *)T;
T = FR->c;
}
}
} else {
if ((T = fctByName(W)) != VIDE) {
*C = T_FCT;
FR = (struct Fct *)T;
T = FR->c;
} else {
if ((VARS==1) && ((T = varByName(W)) != VIDE)) {
*C = T_VAR;
}
}
}
if ((Code)*C != T_BKC1) { /* code is updated */
bcopy((void*)&T, (void*)(C+1),n);
C-=(n+1); /* it must be executed */
}
break;
case T_NOP :
case T_CHAS :
case T_VARS :
case T_FCTDWS :
break;
default :
messErr(11);
}
C+= n+1;
}
D_Cod--;
if (ea) tellOnErr(VIDE);
}
void rmLastVar(void)
{
if (stackV != VIDE) rmVar(&stackV, (struct Var *)stackV);
else messErr(23);
}
