OpenXM/src/kan96xx/Kan/primitive.c - diff

Return to primitive.c CVS log

Up to [local] / OpenXM / src / kan96xx / Kan

Diff for /OpenXM/src/kan96xx/Kan/primitive.c between version 1.1.1.1 and 1.17

version 1.1.1.1, 1999/10/08 02:12:02

version 1.17, 2004/09/16 02:22:03

Line 1

/* $OpenXM: OpenXM/src/kan96xx/Kan/primitive.c,v 1.16 2004/09/12 10:58:28 takayama Exp $ */

/* primitive.c */

/* The functions in this module were in stackmachine.c */

#include <stdio.h>

#include <signal.h>

#include "datatype.h"

#include "stackm.h"

#include "extern.h"

Line 12

Line 14

int PrintDollar = 1; /* flag for printObject() */

int PrintComma = 1; /* flag for printObject() */

int InSendmsg2 = 0;

#define OB_ARRAY_MAX (AGLIMIT+100)

extern int GotoP;

Line 22 extern int ClassTypes[]; /* kclass.c */

Line 25 extern int ClassTypes[]; /* kclass.c */

extern struct context *PrimitiveContextp;

extern struct context *CurrentContextp;

extern struct dictionary *SystemDictionary;

extern int QuoteMode;

static char *operatorType(int i);

static char *operatorType(type)

int type;

{ int i;

for (i=0; i<Sdp; i++) {

if (type == (SystemDictionary[i]).obj.lc.ival) {

return((SystemDictionary[i]).key);

}

return("Unknown operator");

}

#define evalEA(ob1) if (ob1.tag == SexecutableArray) {\

executeExecutableArray(ob1,(char *)NULL,0); ob1 = Kpop();}

/****** primitive functions *****************************************

the values must be greater than 1. 0 is used for special purposes.*/

#define Sadd 1

Line 119 int type;

Line 126 int type;

#define Ssupmsg2 98

#define Scclass 99

#define Scoeff2 100

#define Stlimit 101

#define Soxshell 102

/***********************************************/

void printObject(ob,nl,fp)

struct object ob;

int nl;

FILE *fp;

/* print the object on the top of the stack. */

{

int size;

Line 225 FILE *fp;

Line 234 FILE *fp;

for (i=0; i<size; i++) {

switch ((ta[i]).kind) {

case ID:

fprintf(fp,"<<ID>>%s ",(ta[i]).token);

break;

case EXECUTABLE_STRING:

fprintf(fp,"<<EXECUTABLE_STRING>>{%s} ",(ta[i]).token);

break;

case EXECUTABLE_ARRAY:

printObject((ta[i]).object,nl,fp);

break;

case DOLLAR:

fprintf(fp,"<<STRING(DOLLAR)>>%s ",(ta[i]).token);

break;

default:

fprintf(fp,"Unknown token type\n");

break;

}

fprintf(fp," }");

Line 293 FILE *fp;

Line 302 FILE *fp;

}

void printObjectArray(ob,nl,fp)

struct object ob;

int nl;

FILE *fp;

{

int size;

int i;

extern char *LeftBracket, *RightBracket;

size = ob.lc.ival;

fprintf(fp,"[ ");

fprintf(fp,"%s ",LeftBracket);

for (i=0; i<size; i++) {

if (PrintComma && (i != 0)) {

fprintf(fp," , ");

Line 309 FILE *fp;

Line 319 FILE *fp;

}

printObject((ob.rc.op)[i],0,fp);

}

fprintf(fp," ] ");

fprintf(fp," %s ",RightBracket);

if (nl) fprintf(fp,"\n");

}

Line 370 void KdefinePrimitiveFunctions() {

Line 380 void KdefinePrimitiveFunctions() {

putPrimitiveFunction("system",Ssystem);

putPrimitiveFunction("system_variable",Ssystem_variable);

putPrimitiveFunction("test",Stest);

putPrimitiveFunction("tlimit",Stlimit);

putPrimitiveFunction("oxshell",Soxshell);

putPrimitiveFunction("map",Smap);

putPrimitiveFunction("to_records",Sto_records);

putPrimitiveFunction("Usage",Susage);

Line 402 void KdefinePrimitiveFunctions() {

Line 414 void KdefinePrimitiveFunctions() {

}

int executePrimitive(ob)

struct object ob;

{

struct object ob1;

struct object ob2;

Line 415 struct object ob;

Line 427 struct object ob;

int size;

int i,j,k,n;

int status;

int infixOn;

struct tokens infixToken;

struct tokens *tokenArray;

struct tokens token;

FILE *fp;

Line 431 struct object ob;

Line 445 struct object ob;

extern int History;

extern struct ring *CurrentRingp;

extern TimerOn;

extern SecureMode;

infixOn = 0;

if (DebugStack >= 2) {

fprintf(Fstack,"In execute %d\n",ob.lc.ival); printOperandStack();

}

Line 468 struct object ob;

Line 485 struct object ob;

ob2 = peek(i+k);

switch(ob2.tag) {

case Sdollar: /* copy by value */

str = (char *)sGC_malloc(strlen(ob2.lc.str)+3);

if (str == (char *)NULL) errorStackmachine("No memory (copy)");

strcpy(str,ob2.lc.str);

Kpush(KpoString(str));

break;

case Spoly:

errorStackmachine("no pCopy (copy)");

break;

case Sarray:

n = ob2.lc.ival;

ob3 = newObjectArray(n);

for (j=0; j<n; j++) {

putoa(ob3,j,getoa(ob2,j));

}

Kpush(ob3);

break;

default:

Kpush(ob2);

break;

}

k++;

}

Line 508 struct object ob;

Line 525 struct object ob;

}

for (i=0; i<n; i++) {

if (i < OB_ARRAY_MAX) {

obArray[i] = Kpop();

}else{

errorStackmachine("exceeded OB_ARRAY_MAX (roll)\n");

}

for (i=0; i<n; i++) {

Line 526 struct object ob;

Line 543 struct object ob;

/* Postscript primitives :arithmetic */

case Sadd:

ob1 = Kpop();

ob2 = Kpop();

evalEA(ob1); evalEA(ob2);

rob = KooAdd(ob1,ob2);

Kpush(rob);

break;

case Ssub:

ob2 = Kpop();

ob1 = Kpop();

evalEA(ob1); evalEA(ob2);

rob = KooSub(ob1,ob2);

Kpush(rob);

break;

case Smult:

ob2 = Kpop();

ob1 = Kpop();

evalEA(ob1); evalEA(ob2);

rob = KooMult(ob1,ob2);

Kpush(rob);

break;

case Sidiv:

ob2 = Kpop(); ob1 = Kpop();

evalEA(ob1); evalEA(ob2);

rob = KooDiv(ob1,ob2);

Kpush(rob);

break;

case Sdiv:

ob2 = Kpop(); ob1 = Kpop();

evalEA(ob1); evalEA(ob2);

rob = KooDiv2(ob1,ob2);

Kpush(rob);

break;

Line 566 struct object ob;

Line 588 struct object ob;

ob1 = peek(size);

while (!(Osp-size-1 < 0)) { /* while the stack is not underflow */

if (ob1.tag == SleftBraceTag) {

rob = newObjectArray(size);

for (i=0; i<size; i++) {

(rob.rc.op)[i] = peek(size-1-i);

}

for (i=0; i<size+1; i++) {

Kpop();

}

break;

}

size++;

ob1 = peek(size);

Line 586 struct object ob;

Line 608 struct object ob;

/* ob2 ob1 get */

ob1 = Kpop();

ob2 = Kpop();

switch(ob2.tag) {

Kpush(Kget(ob2,ob1));

case Sarray: break;

default: errorStackmachine("Usage:get");

}

switch(ob1.tag) {

case Sinteger: break;

default: errorStackmachine("Usage:get");

}

i =ob1.lc.ival;

size = getoaSize(ob2);

if ((0 <= i) && (i<size)) {

Kpush(getoa(ob2,i));

}else{

errorStackmachine("Index is out of bound. (get)\n");

}

break;

case Sput:

Line 609 struct object ob;

Line 617 struct object ob;

/* Or; [[a_00 ....] [a_10 ....] ....] [1 0] any put. MultiIndex. */

ob1 = Kpop(); ob2 = Kpop(); ob3 = Kpop();

switch(ob2.tag) {

case SuniversalNumber:

ob2 = Kto_int32(ob2); /* do not break and go to Sinteger */

case Sinteger:

switch(ob3.tag) {

case Sarray:

i = ob2.lc.ival;

size = getoaSize(ob3);

if ((0 <= i) && (i<size)) {

getoa(ob3,i) = ob1;

}else{

errorStackmachine("Index is out of bound. (put)\n");

}

break;

case Sdollar:

i = ob2.lc.ival;

size = strlen(ob3.lc.str);

if ((0 <= i) && (i<size)) {

if (ob1.tag == Sdollar) {

(ob3.lc.str)[i] = (ob1.lc.str)[0];

}else{

(ob3.lc.str)[i] = ob1.lc.ival;

}

}else{

errorStackmachine("Index is out of bound. (put)\n");

}

break;

default: errorStackmachine("Usage:put");

}

break;

Line 640 struct object ob;

Line 650 struct object ob;

ob5 = ob3;

n = getoaSize(ob2);

for (i=0; i<n; i++) {

if (ob5.tag != Sarray)

errorStackmachine("Object pointed by the multi-index is not array (put)\n");

ob4 = getoa(ob2,i);

if (ob4.tag != Sinteger)

if (ob4.tag == SuniversalNumber) ob4 = Kto_int32(ob4);

errorStackmachine("Index has to be an integer. (put)\n");

if (ob4.tag != Sinteger)

k = ob4.lc.ival;

errorStackmachine("Index has to be an integer. (put)\n");

size = getoaSize(ob5);

k = ob4.lc.ival;

if ((0 <= k) && (k<size)) {

size = getoaSize(ob5);

if (i == n-1) {

if ((0 <= k) && (k<size)) {

getoa(ob5,k) = ob1;

if (i == n-1) {

}else{

getoa(ob5,k) = ob1;

ob5 = getoa(ob5,k);

}else{

}

ob5 = getoa(ob5,k);

}else{

}

errorStackmachine("Index is out of bound for the multi-index. (put)\n");

}else{

}

errorStackmachine("Index is out of bound for the multi-index. (put)\n");

}

break;

default: errorStackmachine("Usage:put");

Line 744 struct object ob;

Line 755 struct object ob;

errorStackmachine("Usage:loop");

break;

}

tokenArray = ob1.lc.tokenArray;

size = ob1.rc.ival;

i = 0;

while (1) {

token = tokenArray[i];

status = executeExecutableArray(ob1,(char *)NULL,1);

/***printf("[token %d]%s\n",i,token.token);*/

if ((status & STATUS_BREAK) || GotoP) break;

i++;

if (i >= size) {

i=0;

}

status = executeToken(token);

if (status || GotoP) break;

/* here, do not return 1. Do not propagate exit signal outside of the

loop. */

}

break;

Line 789 struct object ob;

Line 791 struct object ob;

inc = ob3.lc.ival;

if (inc > 0) {

if (lim < i) errorStackmachine("The initial value must not be greater than limit value (for).\n");

for ( ; i<=lim; i += inc) {

Kpush(KpoInteger(i));

tokenArray = ob1.lc.tokenArray;

status = executeExecutableArray(ob1,(char *)NULL,1);

size = ob1.rc.ival;

if ((status & STATUS_BREAK) || GotoP) goto xyz;

for (j=0; j<size; j++) {

}

status = executeToken(tokenArray[j]);

if (status || GotoP) goto xyz;

}

}else{

if (lim > i) errorStackmachine("The initial value must not be less than limit value (for).\n");

for ( ; i>=lim; i += inc) {

Kpush(KpoInteger(i));

tokenArray = ob1.lc.tokenArray;

status = executeExecutableArray(ob1,(char *)NULL,1);

size = ob1.rc.ival;

if ((status & STATUS_BREAK) || GotoP) goto xyz;

for (j=0; j<size; j++) {

}

status = executeToken(tokenArray[j]);

if (status || GotoP) goto xyz;

}

xyz: ;

}

break;

Line 833 struct object ob;

Line 827 struct object ob;

break;

}

{ int osize,size;

int i,j;

osize = getoaSize(ob1);

/*KSexecuteString("[");*/

rob.tag = SleftBraceTag;

Kpush(rob);

for (i=0; i<osize; i++) {

Kpush(getoa(ob1,i));

tokenArray = ob2.lc.tokenArray;

status = executeExecutableArray(ob2,(char *)NULL,0);

size = ob2.rc.ival;

if (status & STATUS_BREAK) goto foor;

for (j=0; j<size; j++) {

}

status = executeToken(tokenArray[j]);

if (status) goto foor;

}

foor: ;

/*KSexecuteString("]");*/

{

size = 0;

ob1 = peek(size);

while (!(Osp-size-1 < 0)) { /* while the stack is not underflow */

if (ob1.tag == SleftBraceTag) {

rob = newObjectArray(size);

for (i=0; i<size; i++) {

(rob.rc.op)[i] = peek(size-1-i);

}

for (i=0; i<size+1; i++) {

Kpop();

}

break;

}

size++;

ob1 = peek(size);

}

Kpush(rob);

}

Kpush(rob);

}

break;

Line 896 struct object ob;

Line 886 struct object ob;

ob1 = ob2;

}

/* execute ob1 */

tokenArray = ob1.lc.tokenArray;

status = executeExecutableArray(ob1,(char *)NULL,0);

size = ob1.rc.ival;

if (status & STATUS_BREAK) return(status);

for (i=0; i<size; i++) {

token = tokenArray[i];

status = executeToken(token);

if (status != 0) return(status);

}

break;

case Sexec:

Line 913 struct object ob;

Line 898 struct object ob;

case SexecutableArray: break;

default: errorStackmachine("Usage:exec");

}

tokenArray = ob1.lc.tokenArray;

status = executeExecutableArray(ob1,(char *)NULL,0);

size = ob1.rc.ival;

for (i=0; i<size; i++) {

token = tokenArray[i];

/***printf("[token %d]%s\n",i,token.token);*/

status = executeToken(token);

if (status != 0) break;

}

break;

/* Postscript primitives :dictionary */

case Sdef:

ob2 = Kpop();

ob1 = Kpop();

Line 935 struct object ob;

Line 913 struct object ob;

break;

}

k=putUserDictionary(ob1.lc.str,(ob1.rc.op->lc).ival,

(ob1.rc.op->rc).ival,ob2,

CurrentContextp->userDictionary);

if (k < 0) {

str = (char *)sGC_malloc(sizeof(char)*(strlen(ob1.lc.str) + 256));

if (str == (char *)NULL) {

errorStackmachine("No memory.\n");

}

if (k == -PROTECT) {

sprintf(str,"You rewrited the protected symbol %s.\n",ob1.lc.str);

/* cf. [(chattr) num sym] extension */

warningStackmachine(str);

} else if (k == -ABSOLUTE_PROTECT) {

sprintf(str,"You cannot rewrite the protected symbol %s.\n",ob1.lc.str);

errorStackmachine(str);

} else errorStackmachine("Unknown return value of putUserDictioanry\n");

}

break;

Line 960 struct object ob;

Line 938 struct object ob;

default: errorStackmachine("Usage:load");

}

ob1 = findUserDictionary(ob1.lc.str,

(ob1.rc.op->lc).ival,

(ob1.rc.op->rc).ival,

CurrentContextp);

if (ob1.tag == -1) Kpush(NullObject);

else Kpush(ob1);

Line 976 struct object ob;

Line 954 struct object ob;

default: errorStackmachine("Usage:set");

}

k= putUserDictionary(ob1.lc.str,(ob1.rc.op->lc).ival,

(ob1.rc.op->rc).ival,ob2,

CurrentContextp->userDictionary);

if (k < 0) {

str = (char *)sGC_malloc(sizeof(char)*(strlen(ob1.lc.str) + 256));

if (str == (char *)NULL) {

errorStackmachine("No memory.\n");

}

if (k == -PROTECT) {

sprintf(str,"You rewrited the protected symbol %s. \n",ob1.lc.str);

warningStackmachine(str);

} else if (k == -ABSOLUTE_PROTECT) {

sprintf(str,"You cannot rewrite the protected symbol %s.\n",ob1.lc.str);

errorStackmachine(str);

} else errorStackmachine("Unknown return value of putUserDictioanry\n");

}

break;

Line 1012 struct object ob;

Line 990 struct object ob;

switch(ob2.tag) {

case Sdollar:

if (ob1.tag != Sclass) {

rob = KdataConversion(ob1,ob2.lc.str);

}else{

rob = KclassDataConversion(ob1,ob2);

}

break;

case Sarray:

Line 1044 struct object ob;

Line 1022 struct object ob;

break;

case Sfileopen: /* filename mode file descripter */

/* ob2 ob1 */

ob1 = Kpop();

ob2 = Kpop();

if (SecureMode) errorStackmachine("Security violation: you cannot open a file.");

switch(ob1.tag) {

case Sdollar: break;

default: errorStackmachine("Usage:file");

Line 1059 struct object ob;

Line 1038 struct object ob;

rob = NullObject;

if (ob2.tag == Sdollar) {

if (strcmp(ob2.lc.str,"%stdin") == 0) {

rob.tag = Sfile; rob.lc.str="%stdin"; rob.rc.file = stdin;

}else if (strcmp(ob2.lc.str,"%stdout") == 0) {

rob.tag = Sfile; rob.lc.str="%stdout"; rob.rc.file = stdout;

}else if (strcmp(ob2.lc.str,"%stderr") == 0) {

rob.tag = Sfile; rob.lc.str="%stderr"; rob.rc.file = stderr;

}else if ( (rob.rc.file = fopen(ob2.lc.str,ob1.lc.str)) != (FILE *)NULL) {

rob.tag = Sfile; rob.lc.str = ob2.lc.str;

}else {

errorStackmachine("I cannot open the file.");

}

}else {

rob.rc.file = fdopen(ob2.lc.ival,ob1.lc.str);

if ( rob.rc.file != (FILE *)NULL) {

rob.tag = Sfile; rob.lc.ival = ob2.lc.ival;

}else{

errorStackmachine("I cannot fdopen the given fd.");

}

Line 1111 struct object ob;

Line 1090 struct object ob;

break;

case Spushfile: /* filename pushfile string */

/* ob2 */

ob2 = Kpop();

switch(ob2.tag) {

case Sdollar: break;

Line 1128 struct object ob;

Line 1107 struct object ob;

ob1.tag = Sfile; ob1.lc.str = ob2.lc.str;

}else {

if (ob1.rc.file == (FILE *)NULL) {

char fname2[1024];

strcpy(fname2,getLOAD_SM1_PATH());

strcat(fname2,ob2.lc.str);

ob1.rc.file = fopen(fname2,"r");

if (ob1.rc.file == (FILE *)NULL) {

strcpy(fname2,LOAD_SM1_PATH);

strcat(fname2,ob2.lc.str);

ob1.rc.file = fopen(fname2,"r");

if (ob1.rc.file == (FILE *)NULL) {

fprintf(stderr,"Warning: Cannot open the file <<%s>> for loading in the current directory nor the library directories %s and %s.\n",ob2.lc.str,getLOAD_SM1_PATH(),LOAD_SM1_PATH);

errorStackmachine("I cannot open the file.");

}

/* read the strings

n = 256; j=0;

rob.tag = Sdollar; rob.lc.str = (char *) sGC_malloc(sizeof(char)*n);

if (rob.lc.str == (char *)NULL) errorStackmachine("No more memory.");

while ((i = fgetc(ob1.rc.file)) != EOF) {

if (j >= n-1) {

n = 2*n;

if (n <= 0) errorStackmachine("Too large file to put on the stack.");

str = (char *)sGC_malloc(sizeof(char)*n);

if (str == (char *)NULL) errorStackmachine("No more memory.");

for (k=0; k< n/2; k++) str[k] = (rob.lc.str)[k];

rob.lc.str = str;

}

(rob.lc.str)[j] = i; (rob.lc.str)[j+1] = '\0';

j++;

Line 1179 struct object ob;

Line 1158 struct object ob;

case Sstring: break;

default: errorStackmachine("Usage:system");

}

if (SecureMode) errorStackmachine("Security violation.");

system( ob1.lc.str );

break;

Line 1194 struct object ob;

Line 1174 struct object ob;

ob2 = peek(i);

switch(ob2.tag) {

case Sdollar: break;

default: errorStackmachine("Usage:cat_n");

}

k += strlen(ob2.lc.str);

}

Line 1227 struct object ob;

Line 1207 struct object ob;

times(&after);

after_real = time(&after_real);

if (TimerOn) {

printf("User time: %f seconds, System time: %f seconds, Real time: %d s\n",

((double)(after.tms_utime - before.tms_utime)) /100.0,

((double)(after.tms_stime - before.tms_stime)) /100.0,

(int) (after_real-before_real));

/* In cases of Solaris and Linux, the unit of tms_utime seems to

be given 0.01 seconds. */

}

timerStart = 1; TimerOn = 0;

Line 1275 struct object ob;

Line 1255 struct object ob;

KsetOrderByObjArray(ob1);

break;

case Sset_up_ring:

KresetDegreeShift();

ob5 = Kpop(); ob4=Kpop(); ob3=Kpop(); ob2=Kpop(); ob1=Kpop();

KsetUpRing(ob1,ob2,ob3,ob4,ob5);

break;

Line 1352 struct object ob;

Line 1333 struct object ob;

if (ob2.tag != Sarray) {

Kpush(Khead(ob2));

}else{

ob1 = Kpop();

if (getoaSize(ob2) > 0) {

Kpush(oInitW(ob1,ob2));

if (getoa(ob2,getoaSize(ob2)-1).tag == Spoly) {

Kpush(oInitW(ob2,newObjectArray(0)));

}else{

ob1 = Kpop();

Kpush(oInitW(ob1,ob2));

}

}else{

ob1 = Kpop();

Kpush(oInitW(ob1,ob2));

}

break;

Line 1412 struct object ob;

Line 1402 struct object ob;

switch (ob1.tag) {

case Sclass:

if (ClassTypes[ob1.lc.ival] == CLASS_OBJ) {

Kpush(*(ob1.rc.op));

}else{

warningStackmachine("<<obj rc >> works only for a class object with CLASS_OBJ attribute.\n");

Kpush(ob1);

}

break;

default:

Line 1430 struct object ob;

Line 1420 struct object ob;

switch(ob1.tag) {

case Sclass:

if (ob2.tag == Sdollar) {

Kpush(KnewContext(ob1,KopString(ob2)));

}else errorStackmachine("Usage:newcontext");

break;

default:

Line 1475 struct object ob;

Line 1465 struct object ob;

ccflag = 0;

if (ob2.tag == Sarray ) {

if (getoaSize(ob2) >= 1) {

ob3 = getoa(ob2,0);

if (ectag(ob3) == CLASSNAME_CONTEXT) {

contextControl(CCPUSH); ccflag = 1; /* push the current context. */

CurrentContextp = (struct context *)ecbody(ob3);

}

if (!ccflag) {

Line 1488 struct object ob;

Line 1478 struct object ob;

}

/* normal exec. */

Kpush(ob2);

tokenArray = ob1.lc.tokenArray;

status = executeExecutableArray(ob1,(char *)NULL,0);

size = ob1.rc.ival;

for (i=0; i<size; i++) {

token = tokenArray[i];

status = executeToken(token);

if (status != 0) break;

}

if (ccflag) {

contextControl(CCPOP); ccflag = 0; /* recover the Current context. */

}

break;

case Ssendmsg2:

/* ob2 ob4 { .........} sendmsg2 */

Line 1513 struct object ob;

Line 1498 struct object ob;

ccflag = 0;

if (ob2.tag == Sarray ) {

if (getoaSize(ob2) >= 1) {

ob3 = getoa(ob2,0);

if (ectag(ob3) == CLASSNAME_CONTEXT) {

contextControl(CCPUSH); ccflag = 1; /* push the current context. */

CurrentContextp = (struct context *)ecbody(ob3);

}

if (!ccflag && ob4.tag == Sarray) {

if (getoaSize(ob4) >= 1) {

ob3 = getoa(ob4,0);

if (ectag(ob3) == CLASSNAME_CONTEXT) {

contextControl(CCPUSH); ccflag = 1; /* push the current context. */

CurrentContextp = (struct context *)ecbody(ob3);

}

if (!ccflag) {

Line 1535 struct object ob;

Line 1520 struct object ob;

}

/* normal exec. */

Kpush(ob2); Kpush(ob4);

/* We cannot use executeExecutableArray(ob1,(char *)NULL) because of

the quote mode. Think about it later. */

tokenArray = ob1.lc.tokenArray;

size = ob1.rc.ival;

for (i=0; i<size; i++) {

token = tokenArray[i];

InSendmsg2 = 1;

status = executeToken(token);

if (status != 0) break;

InSendmsg2 = 0;

if (status & STATUS_INFIX) {

if (status & DO_QUOTE) errorStackmachine("infix op with DO_QUOTE\n");

if (i == size-1) errorStackmachine("infix operator at the end(sendmsg2).\n");

infixOn = 1; infixToken = tokenArray[i];

infixToken.tflag |= NO_DELAY; continue;

}else if (infixOn) {

infixOn = 0; status = executeToken(infixToken);

if (status & STATUS_BREAK) break;

}

if (QuoteMode && (status & DO_QUOTE)) {

/* generate tree object, for kan/k0 */

struct object qob;

struct object qattr;

struct object qattr2;

if (i==0) { Kpop(); Kpop();}

qob = newObjectArray(3);

qattr = newObjectArray(1);

qattr2 = newObjectArray(2);

/* Set the node name of the tree. */

if (token.kind == ID) {

putoa(qob,0,KpoString(token.token));

}else{

putoa(qob,0,KpoString("unknown"));

}

/* Set the attibute list; class=className */

if (ob2.tag == Sdollar) {

putoa(qattr2,0,KpoString("cd"));

putoa(qattr2,1,ob2);

}else{

putoa(qattr2,0,KpoString("class"));

putoa(qattr2,1,KpoString(CurrentContextp->contextName));

}

putoa(qattr,0,qattr2);

putoa(qob,1,qattr);

putoa(qob,2,ob4); /* Argument */

qob = KpoTree(qob);

Kpush(qob);

} else if (status & STATUS_BREAK) break;

}

if (ccflag) {

contextControl(CCPOP); ccflag = 0;

Line 1560 struct object ob;

Line 1590 struct object ob;

contextControl(CCPUSH); ccflag = 1;

CurrentContextp = PrimitiveContextp;

/* normal exec. */

tokenArray = ob1.lc.tokenArray;

status = executeExecutableArray(ob1,(char *)NULL,0);

size = ob1.rc.ival;

for (i=0; i<size; i++) {

token = tokenArray[i];

status = executeToken(token);

if (status != 0) break;

}

contextControl(CCPOP); /* recover the Current context. */

break;

Line 1584 struct object ob;

Line 1607 struct object ob;

ccflag = 0;

if (ob2.tag == Sarray ) {

if (getoaSize(ob2) >= 1) {

ob3 = getoa(ob2,0);

if (ectag(ob3) == CLASSNAME_CONTEXT) {

if (((struct context *)ecbody(ob3))->super == NULL) {

errorStackmachine("supmsg2: SuperClass is NIL.");

}

contextControl(CCPUSH); ccflag = 1; /* push the current context. */

CurrentContextp = ((struct context *)ecbody(ob3))->super;

}

if (!ccflag && (ob4.tag == Sarray) ) {

if (getoaSize(ob4) >= 1) {

ob3 = getoa(ob4,0);

if (ectag(ob3) == CLASSNAME_CONTEXT) {

if (((struct context *)ecbody(ob3))->super == NULL) {

errorStackmachine("supmsg2: SuperClass is NIL.");

}

contextControl(CCPUSH); ccflag = 1; /* push the current context. */

CurrentContextp = ((struct context *)ecbody(ob3))->super;

}

if (!ccflag) {

Line 1612 struct object ob;

Line 1635 struct object ob;

}

/* normal exec. */

Kpush(ob2); Kpush(ob4);

tokenArray = ob1.lc.tokenArray;

status = executeExecutableArray(ob1,(char *)NULL,0);

size = ob1.rc.ival;

for (i=0; i<size; i++) {

token = tokenArray[i];

status = executeToken(token);

if (status != 0) break;

}

if (ccflag) {

contextControl(CCPOP); ccflag = 0; /* recover the Current context. */

}

Line 1631 struct object ob;

Line 1648 struct object ob;

/* compose error message */

ob = Kpop();

str = (char *) sGC_malloc(sizeof(char)*(strlen("error operator : ")+

strlen(KopString(ob1))+ 10));

if (str == NULL) errorStackmachine("No more memory.");

strcpy(str,"error operator : ");

strcat(str,KopString(ob1));

Line 1659 struct object ob;

Line 1676 struct object ob;

ob1 = Kpop();

Kpush(hilberto(ob1,ob2));

{

ob1 = Kpop();

Kpush(test(ob1));

}

break;

case Soxshell:

ob1 = Kpop();

Kpush(KoxShell(ob1));

break;

case Stlimit:

/* { } time tlimit */

ob2 = Kpop();

ob1 = Kpop();

switch(ob2.tag) {

case Sinteger: break;

default: errorStackmachine("Usage:tlimit"); break;

}

switch(ob1.tag) {

case SexecutableArray: break;

default:

errorStackmachine("Usage:tlimit");

break;

}

n = ob2.lc.ival;

if (n > 0) {

signal(SIGALRM,ctrlC); alarm((unsigned int) n);

status = executeExecutableArray(ob1,(char *)NULL,0);

cancelAlarm();

}else{

before_real = time(&before_real);

times(&before);

status = executeExecutableArray(ob1,(char *)NULL,0);

times(&after);

after_real = time(&after_real);

ob1 = newObjectArray(3);

putoa(ob1,0,KpoInteger((int) after.tms_utime - before.tms_utime));

putoa(ob1,1,KpoInteger((int) after.tms_stime - before.tms_stime));

putoa(ob1,2,KpoInteger((int) (after_real-before_real)));

Kpush(ob1);

}

break;

default:

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>