Annotation of OpenXM/src/kan96xx/Kan/stackmachine.c, Revision 1.1.1.1
1.1 maekawa 1: /* stackmachin.c */
2:
3: #include <stdio.h>
4: #include "datatype.h"
5: #include "stackm.h"
6: #include "extern.h"
7: #include "gradedset.h"
8: #include "kclass.h"
9: #include <signal.h>
10: #include <sys/types.h>
11:
12:
13: /* #define OPERAND_STACK_SIZE 2000 */
14: #define OPERAND_STACK_SIZE 30000
15: #define SYSTEM_DICTIONARY_SIZE 200
16: #define USER_DICTIONARY_SIZE 1223
17: /* The value of USER_DICTIONARY_SIZE must be prime number, because of hashing
18: method */
19: #define ARGV_WORK_MAX (AGLIMIT+100)
20: #define EMPTY (char *)NULL
21:
22:
23: /* global variables */
24: struct object StandardStackA[OPERAND_STACK_SIZE];
25: int StandardStackP = 0;
26: int StandardStackMax = OPERAND_STACK_SIZE;
27: struct operandStack StandardStack;
28: /* Initialization of operandStack will be done in initSystemDictionary(). */
29: #define ERROR_STACK_SIZE 100
30: struct object ErrorStackA[ERROR_STACK_SIZE];
31: int ErrorStackP = 0;
32: int ErrorStackMax = ERROR_STACK_SIZE;
33: struct operandStack ErrorStack;
34: /* Initialization of ErrorStack will be done in initSystemDictionary(). */
35:
36: struct operandStack *CurrentOperandStack = &StandardStack;
37: struct object *OperandStack = StandardStackA;
38: int Osp = 0; /* OperandStack pointer */
39: int OspMax = OPERAND_STACK_SIZE;
40:
41: struct dictionary SystemDictionary[SYSTEM_DICTIONARY_SIZE];
42: int Sdp = 0; /* SystemDictionary pointer */
43: struct dictionary UserDictionary[USER_DICTIONARY_SIZE];
44:
45: struct context StandardContext ;
46: /* Initialization of StructContext will be done in initSystemDictionary(). */
47: /* hashInitialize is done in global.c (initStackmachine()) */
48: struct context *StandardContextp = &StandardContext;
49: struct context *CurrentContextp = &StandardContext;
50: struct context *PrimitiveContextp = &StandardContext;
51:
52:
53: static struct object ObjTmp; /* for poor compiler */
54:
55: int StandardMacros = 1;
56: int StartAFile = 0;
57: char *StartFile;
58:
59: int StartAString = 0;
60: char *StartString;
61:
62: char *GotoLabel = (char *)NULL;
63: int GotoP = 0;
64:
65: static char *SMacros =
66: #include "smacro.h"
67:
68: static isInteger(char *);
69: static strToInteger(char *);
70: static power(int s,int i);
71: static void pstack(void);
72: static struct object executableStringToExecutableArray(char *str);
73:
74: extern int SerialCurrent;
75:
76: int SGClock = 0;
77: int UserCtrlC = 0;
78: int OXlock = 0;
79: int OXlockSaved = 0;
80:
81: struct object * newObject()
82: {
83: struct object *r;
84: r = (struct object *)sGC_malloc(sizeof(struct object));
85: if (r == (struct object *)NULL) errorStackmachine("No memory\n");
86: r->tag = 0;
87: (r->lc).ival = 0;
88: (r->rc).ival = 0;
89: return(r);
90: }
91:
92: struct object newObjectArray(size)
93: int size;
94: {
95: struct object rob;
96: struct object *op;
97: if (size < 0) return(NullObject);
98: if (size > 0) {
99: op = (struct object *)sGC_malloc(size*sizeof(struct object));
100: if (op == (struct object *)NULL) errorStackmachine("No memory\n");
101: }else{
102: op = (struct object *)NULL;
103: }
104: rob.tag = Sarray;
105: rob.lc.ival = size;
106: rob.rc.op = op;
107: return(rob);
108: }
109:
110: isNullObject(obj)
111: struct object obj;
112: {
113: if (obj.tag == 0) return(1);
114: else return(0);
115: }
116:
117: int putSystemDictionary(str,ob)
118: char *str; /* key */
119: struct object ob; /* value */
120: {
121: int i;
122: int j;
123: int flag = 0;
124:
125: for (i = Sdp-1; i>=0; i--) {
126: /*printf("Add %d %s\n",i,str);*/
127: if (strcmp(str,(SystemDictionary[i]).key) > 0) {
128: for (j=Sdp-1; j>=i+1; j--) {
129: (SystemDictionary[j+1]).key = (SystemDictionary[j]).key;
130: (SystemDictionary[j+1]).obj = (SystemDictionary[j]).obj;
131: }
132: (SystemDictionary[i+1]).key = str;
133: (SystemDictionary[i+1]).obj = ob;
134: flag = 1;
135: break;
136: }
137: }
138: if (!flag) { /* str is the minimum element */
139: for (j=Sdp-1; j>=0; j--) {
140: (SystemDictionary[j+1]).key = (SystemDictionary[j]).key;
141: (SystemDictionary[j+1]).obj = (SystemDictionary[j]).obj;
142: }
143: (SystemDictionary[0]).key = str;
144: (SystemDictionary[0]).obj = ob;
145: }
146: Sdp++;
147: if (Sdp >= SYSTEM_DICTIONARY_SIZE) {
148: warningStackmachine("No space for system dictionary area.\n");
149: Sdp--;
150: return(-1);
151: }
152: return(Sdp-1);
153: }
154:
155: int findSystemDictionary(str)
156: /* only used for primitive functions */
157: /* returns 0, if there is no item. */
158: /* This function assumes that the dictionary is sorted by strcmp() */
159: char *str; /* key */
160: {
161: int first,last,rr,middle;
162:
163: /* binary search */
164: first = 0; last = Sdp-1;
165: while (1) {
166: if (first > last) {
167: return(0);
168: } else if (first == last) {
169: if (strcmp(str,(SystemDictionary[first]).key) == 0) {
170: return((SystemDictionary[first]).obj.lc.ival);
171: }else {
172: return(0);
173: }
174: } else if (last - first == 1) { /* This case is necessary */
175: if (strcmp(str,(SystemDictionary[first]).key) == 0) {
176: return((SystemDictionary[first]).obj.lc.ival);
177: }else if (strcmp(str,(SystemDictionary[last]).key) == 0) {
178: return((SystemDictionary[last]).obj.lc.ival);
179: }else return(0);
180: }
181:
182: middle = (first + last)/2;
183: rr = strcmp(str,(SystemDictionary[middle]).key);
184: if (rr < 0) { /* str < middle */
185: last = middle;
186: }else if (rr == 0) {
187: return((SystemDictionary[middle]).obj.lc.ival);
188: }else { /* str > middle */
189: first = middle;
190: }
191: }
192: }
193:
194: int putUserDictionary(str,h0,h1,ob,dic)
195: char *str; /* key */
196: int h0,h1; /* Hash values of the key */
197: struct object ob; /* value */
198: struct dictionary *dic;
199: {
200: int x,r;
201: extern int Strict2;
202: x = h0;
203: if (str[0] == '\0') {
204: errorKan1("%s\n","putUserDictionary(): You are defining a value with the null key.");
205: }
206: while (1) {
207: if ((dic[x]).key == EMPTY) break;
208: if (strcmp((dic[x]).key,str) == 0) break;
209: x = (x+h1) % USER_DICTIONARY_SIZE;
210: if (x == h0) {
211: errorStackmachine("User dictionary is full. loop hashing.\n");
212: }
213: }
214: r = x;
215: if (Strict2) {
216: switch((dic[x]).attr) {
217: case PROTECT:
218: r = -PROTECT; /* Protected, but we rewrite it. */
219: break;
220: case ABSOLUTE_PROTECT:
221: r = -ABSOLUTE_PROTECT; /* Protected and we do not rewrite it. */
222: return(r);
223: default:
224: (dic[x]).attr = 0;
225: break;
226: }
227: }
228: (dic[x]).key = str;
229: (dic[x]).obj = ob;
230: (dic[x]).h0 = h0;
231: (dic[x]).h1 = h1;
232: return(r);
233: }
234:
235: struct object KputUserDictionary(char *str,struct object ob)
236: {
237: int r;
238: r = putUserDictionary(str,hash0(str),hash1(str),ob,CurrentContextp->userDictionary);
239: return(KpoInteger(r));
240: }
241:
242: struct object findUserDictionary(str,h0,h1,cp)
243: /* returns NoObject, if there is no item. */
244: char *str; /* key */
245: int h0,h1; /* The hashing values of the key. */
246: struct context *cp;
247: {
248: int x;
249: struct dictionary *dic;
250: dic = cp->userDictionary;
251: x = h0;
252: while (1) {
253: if ((dic[x]).key == EMPTY) { break; }
254: if (strcmp((dic[x]).key,str) == 0) {
255: return( (dic[x]).obj );
256: }
257: x = (x+h1) % USER_DICTIONARY_SIZE;
258: if (x == h0) {
259: errorStackmachine("User dictionary is full. loop hashing in findUserDictionary.\n");
260: }
261: }
262: if (cp->super == (struct context *)NULL) return(NoObject);
263: else return(findUserDictionary(str,h0,h1,cp->super));
264:
265: }
266:
267: struct object KfindUserDictionary(char *str) {
268: return(findUserDictionary(str,hash0(str),hash1(str),CurrentContextp));
269: }
270:
271: int putUserDictionary2(str,h0,h1,attr,dic)
272: char *str; /* key */
273: int h0,h1; /* Hash values of the key */
274: int attr; /* attribute field */
275: struct dictionary *dic;
276: {
277: int x;
278: int i;
279: if (SET_ATTR_FOR_ALL_WORDS & attr) {
280: for (i=0; i<USER_DICTIONARY_SIZE; i++) {
281: if ((dic[i]).key !=EMPTY) (dic[i]).attr = attr&(~SET_ATTR_FOR_ALL_WORDS);
282: }
283: return(0);
284: }
285: x = h0;
286: if (str[0] == '\0') {
287: errorKan1("%s\n","putUserDictionary2(): You are defining a value with the null key.");
288: }
289: while (1) {
290: if ((dic[x]).key == EMPTY) return(-1);
291: if (strcmp((dic[x]).key,str) == 0) break;
292: x = (x+h1) % USER_DICTIONARY_SIZE;
293: if (x == h0) {
294: errorStackmachine("User dictionary is full. loop hashing.\n");
295: }
296: }
297: (dic[x]).attr = attr;
298: return(x);
299: }
300:
301:
302: int putPrimitiveFunction(str,number)
303: char *str;
304: int number;
305: {
306: struct object ob;
307: ob.tag = Soperator;
308: ob.lc.ival = number;
309: return(putSystemDictionary(str,ob));
310: }
311:
312: struct tokens lookupTokens(t)
313: struct tokens t;
314: {
315: struct object *left;
316: struct object *right;
317: t.object.tag = Slist;
318: left = t.object.lc.op = newObject();
319: right = t.object.rc.op = newObject();
320: left->tag = Sinteger;
321: (left->lc).ival = hash0(t.token);
322: (left->rc).ival = hash1(t.token);
323: right->tag = Sinteger;
324: (right->lc).ival = findSystemDictionary(t.token);
325: return(t);
326: }
327:
328: struct object lookupLiteralString(s)
329: char *s; /* s must be a literal string */
330: {
331: struct object ob;
332: ob.tag = Slist;
333: ob.lc.op = newObject();
334: ob.rc.op = (struct object *)NULL;
335: ob.lc.op->tag = Sinteger;
336: (ob.lc.op->lc).ival = hash0(&(s[1]));
337: (ob.lc.op->rc).ival = hash1(&(s[1]));
338: return(ob);
339: }
340:
341:
342: int hash0(str)
343: char *str;
344: {
345: int h=0;
346: while (*str != '\0') {
347: h = ((h*128)+(*str)) % USER_DICTIONARY_SIZE;
348: str++;
349: }
350: return(h);
351: }
352:
353: int hash1(str)
354: char *str;
355: {
356: return(8-(str[0]%8));
357: }
358:
359: void hashInitialize(struct dictionary *dic)
360: {
361: int i;
362: for (i=0; i<USER_DICTIONARY_SIZE; i++) {
363: (dic[i]).key = EMPTY; (dic[i]).attr = 0;
364: }
365: }
366:
367: static isInteger(str)
368: char *str;
369: {
370: int i;
371: int n;
372: int start;
373:
374: n = strlen(str);
375: if ((str[0] == '+') || (str[0] == '-'))
376: start = 1;
377: else
378: start = 0;
379: if (start >= n) return(0);
380:
381: for (i=start; i<n; i++) {
382: if (('0' <= str[i]) && (str[i] <= '9')) ;
383: else return(0);
384: }
385: return(1);
386: }
387:
388: static strToInteger(str)
389: char *str;
390: {
391: int i;
392: int n;
393: int r;
394: int start;
395:
396: if ((str[0] == '+') || (str[0] == '-'))
397: start = 1;
398: else
399: start = 0;
400: n = strlen(str);
401: r = 0;
402: for (i=n-1; i>=start ; i--) {
403: r += (int)(str[i]-'0') *power(10,n-1-i);
404: }
405: if (str[0] == '-') r = -r;
406: return(r);
407: }
408:
409: static power(s,i)
410: int s;
411: int i;
412: {
413: if (i == 0) return 1;
414: else return( s*power(s,i-1) );
415: }
416:
417: int Kpush(ob)
418: struct object ob;
419: {
420: OperandStack[Osp++] = ob;
421: if (Osp >= OspMax) {
422: warningStackmachine("Operand stack overflow. \n");
423: Osp--;
424: return(-1);
425: }
426: return(0);
427: }
428:
429: struct object Kpop()
430: {
431: if (Osp <= 0) {
432: return( NullObject );
433: }else{
434: return( OperandStack[--Osp]);
435: }
436: }
437:
438: struct object peek(k)
439: int k;
440: {
441: if ((Osp-k-1) < 0) {
442: return( NullObject );
443: }else{
444: return( OperandStack[Osp-k-1]);
445: }
446: }
447:
448:
449: struct object newOperandStack(int size)
450: {
451: struct operandStack *os ;
452: struct object ob;
453: os = (struct operandStack *)sGC_malloc(sizeof(struct operandStack));
454: if (os == (void *)NULL) errorStackmachine("No more memory.");
455: if (size <= 0) errorStackmachine("Size of stack must be more than 1.");
456: os->size = size;
457: os->sp = 0;
458: os->ostack = (struct object *)sGC_malloc(sizeof(struct object)*(size+1));
459: if (os->ostack == (void *)NULL) errorStackmachine("No more memory.");
460: ob.tag = Sclass;
461: ob.lc.ival = CLASSNAME_OPERANDSTACK;
462: ob.rc.voidp = os;
463: return(ob);
464: }
465:
466: void setOperandStack(struct object ob) {
467: if (ob.tag != Sclass) errorStackmachine("The argument must be class.");
468: if (ob.lc.ival != CLASSNAME_OPERANDSTACK)
469: errorStackmachine("The argument must be class.OperandStack.");
470: CurrentOperandStack->ostack = OperandStack;
471: CurrentOperandStack->sp = Osp;
472: CurrentOperandStack->size = OspMax;
473: OperandStack = ((struct operandStack *)(ob.rc.voidp))->ostack;
474: Osp = ((struct operandStack *)(ob.rc.voidp))->sp;
475: OspMax = ((struct operandStack *)(ob.rc.voidp))->size;
476: CurrentOperandStack = ob.rc.voidp;
477: }
478:
479: void stdOperandStack(void) {
480: CurrentOperandStack->ostack = OperandStack;
481: CurrentOperandStack->sp = Osp;
482: CurrentOperandStack->size = OspMax;
483:
484: CurrentOperandStack = &StandardStack;
485: OperandStack = CurrentOperandStack->ostack;
486: Osp = CurrentOperandStack->sp;
487: OspMax = CurrentOperandStack->size;
488: }
489:
490: /* functions to handle contexts. */
491: void fprintContext(FILE *fp,struct context *cp) {
492: if (cp == (struct context *)NULL) {
493: fprintf(fp," Context=NIL \n");
494: return;
495: }
496: fprintf(fp," ContextName = %s, ",cp->contextName);
497: fprintf(fp,"Super = ");
498: if (cp->super == (struct context *)NULL) fprintf(fp,"NIL");
499: else {
500: fprintf(fp,"%s",cp->super->contextName);
501: }
502: fprintf(fp,"\n");
503: }
504:
505: struct context *newContext0(struct context *super,char *name) {
506: struct context *cp;
507: cp = sGC_malloc(sizeof(struct context));
508: if (cp == (struct context *)NULL) errorStackmachine("No memory (newContext0)");
509: cp->userDictionary=sGC_malloc(sizeof(struct dictionary)*USER_DICTIONARY_SIZE);
510: if (cp->userDictionary==(struct dictionary *)NULL)
511: errorStackmachine("No memory (newContext0)");
512: hashInitialize(cp->userDictionary);
513: cp->contextName = name;
514: cp->super = super;
515: return(cp);
516: }
517:
518: void KsetContext(struct object contextObj) {
519: if (contextObj.tag != Sclass) {
520: errorStackmachine("Usage:setcontext");
521: }
522: if (contextObj.lc.ival != CLASSNAME_CONTEXT) {
523: errorStackmachine("Usage:setcontext");
524: }
525: if (contextObj.rc.voidp == NULL) {
526: errorStackmachine("You cannot set NullContext to the CurrentContext.");
527: }
528: CurrentContextp = (struct context *)(contextObj.rc.voidp);
529: }
530:
531:
532: struct object getSuperContext(struct object contextObj) {
533: struct object rob;
534: struct context *cp;
535: if (contextObj.tag != Sclass) {
536: errorStackmachine("Usage:supercontext");
537: }
538: if (contextObj.lc.ival != CLASSNAME_CONTEXT) {
539: errorStackmachine("Usage:supercontext");
540: }
541: cp = (struct context *)(contextObj.rc.voidp);
542: if (cp->super == (struct context *)NULL) {
543: return(NullObject);
544: }else{
545: rob.tag = Sclass;
546: rob.lc.ival = CLASSNAME_CONTEXT;
547: rob.rc.voidp = cp->super;
548: }
549: return(rob);
550: }
551:
552: #define CSTACK_SIZE 1000
553: void contextControl(actionOfContextControl ctl) {
554: static struct context *cstack[CSTACK_SIZE];
555: static int cstackp = 0;
556: switch(ctl) {
557: case CCRESTORE:
558: if (cstackp == 0) return;
559: else {
560: CurrentContextp = cstack[0];
561: cstackp = 0;
562: }
563: break;
564: case CCPUSH:
565: if (cstackp < CSTACK_SIZE) {
566: cstack[cstackp] = CurrentContextp;
567: cstackp++;
568: }else{
569: contextControl(CCRESTORE);
570: errorStackmachine("Context stack (cstack) is overflow. CurrentContext is restored.\n");
571: }
572: break;
573: case CCPOP:
574: if (cstackp > 0) {
575: cstackp--;
576: CurrentContextp = cstack[cstackp];
577: }
578: break;
579: default:
580: break;
581: }
582: return;
583: }
584:
585:
586:
587: int isLiteral(str)
588: char *str;
589: {
590: if (strlen(str) <2) return(0);
591: else {
592: if ((str[0] == '/') && (str[1] != '/')) return(1);
593: else return(0);
594: }
595: }
596:
597: void printOperandStack() {
598: int i;
599: struct object ob;
600: int vs;
601: vs = VerboseStack; VerboseStack = 2;
602: for (i=Osp-1; i>=0; i--) {
603: fprintf(Fstack,"[%d] ",i);
604: ob = OperandStack[i];
605: printObject(ob,1,Fstack);
606: }
607: VerboseStack = vs;
608: }
609:
610:
611:
612: static initSystemDictionary()
613: {
614: StandardStack.ostack = StandardStackA;
615: StandardStack.sp = StandardStackP;
616: StandardStack.size = OPERAND_STACK_SIZE;
617:
618: ErrorStack.ostack = ErrorStackA;
619: ErrorStack.sp = ErrorStackP;
620: ErrorStack.size = ErrorStackMax;
621:
622: StandardContext.userDictionary = UserDictionary;
623: StandardContext.contextName = "StandardContext";
624: StandardContext.super = (struct context *)NULL;
625:
626: KdefinePrimitiveFunctions();
627:
628: }
629:
630: struct object showSystemDictionary(int f) {
631: int i;
632: int maxl;
633: char format[1000];
634: int nl;
635: struct object rob;
636: rob = NullObject;
637: if (f != 0) {
638: rob = newObjectArray(Sdp);
639: for (i=0; i<Sdp; i++) {
640: putoa(rob,i,KpoString((SystemDictionary[i]).key));
641: }
642: return(rob);
643: }
644: maxl = 1;
645: for (i=0; i<Sdp; i++) {
646: if (strlen((SystemDictionary[i]).key) >maxl)
647: maxl = strlen((SystemDictionary[i]).key);
648: }
649: maxl += 3;
650: nl = 80/maxl;
651: if (nl < 2) nl = 2;
652: sprintf(format,"%%-%ds",maxl);
653: for (i=0; i<Sdp; i++) {
654: fprintf(Fstack,format,(SystemDictionary[i]).key);
655: if (i % nl == nl-1) fprintf(Fstack,"\n");
656: }
657: fprintf(Fstack,"\n");
658: return(rob);
659: }
660:
661: int showUserDictionary()
662: {
663: int i,j;
664: int maxl;
665: char format[1000];
666: int nl;
667: struct dictionary *dic;
668: dic = CurrentContextp->userDictionary;
669: fprintf(Fstack,"DictionaryName=%s, super= ",CurrentContextp->contextName);
670: if (CurrentContextp->super == (struct context *)NULL) {
671: fprintf(Fstack,"NIL\n");
672: }else{
673: fprintf(Fstack,"%s\n",CurrentContextp->super->contextName);
674: }
675: maxl = 1;
676: for (i=0; i<USER_DICTIONARY_SIZE; i++) {
677: if ((dic[i]).key != EMPTY) {
678: if (strlen((dic[i]).key) >maxl)
679: maxl = strlen((dic[i]).key);
680: }
681: }
682: maxl += 3;
683: nl = 80/maxl;
684: if (nl < 2) nl = 2;
685: sprintf(format,"%%-%ds",maxl);
686: for (i=0,j=0; i<USER_DICTIONARY_SIZE; i++) {
687: if ((dic[i]).key != EMPTY) {
688: fprintf(Fstack,format,(dic[i]).key);
689: /*{ char *sss; int ii,h0,h1;
690: sss = dic[i].key;
691: h0 = dic[i].h0;
692: h1 = dic[i].h1;
693: for (ii=0; ii<strlen(sss); ii++) fprintf(Fstack,"%x ",sss[ii]);
694: fprintf(Fstack,": h0=%d, h1=%d, %d\n",h0,h1,i);
695: }*/
696: if (j % nl == nl-1) fprintf(Fstack,"\n");
697: j++;
698: }
699: }
700: fprintf(Fstack,"\n");
701: }
702:
703:
704: static struct object executableStringToExecutableArray(s)
705: char *s;
706: {
707: struct tokens *tokenArray;
708: struct object ob;
709: int i;
710: int size;
711: tokenArray = decomposeToTokens(s,&size);
712: ob.tag = SexecutableArray;
713: ob.lc.tokenArray = tokenArray;
714: ob.rc.ival = size;
715: for (i=0; i<size; i++) {
716: if ( ((ob.lc.tokenArray)[i]).kind == EXECUTABLE_STRING) {
717: ((ob.lc.tokenArray)[i]).kind = EXECUTABLE_ARRAY;
718: ((ob.lc.tokenArray)[i]).object =
719: executableStringToExecutableArray(((ob.lc.tokenArray)[i]).token);
720: }
721: }
722: return(ob);
723: }
724: /**************** stack machine **************************/
725: void scanner() {
726: struct tokens token;
727: struct object ob;
728: extern int Quiet;
729: extern void ctrlC();
730: int tmp;
731: char *tmp2;
732: extern int ErrorMessageMode;
733: int jval;
734: getokenSM(INIT);
735: initSystemDictionary();
736:
737: if (setjmp(EnvOfStackMachine)) {
738: /* do nothing in the case of error */
739: fprintf(stderr,"An error or interrupt in reading macros, files and command strings.\n");
740: exit(10);
741: } else { }
742: if (signal(SIGINT,SIG_IGN) != SIG_IGN) {
743: signal(SIGINT,ctrlC);
744: }
745:
746: /* setup quiet mode or not */
747: token.kind = EXECUTABLE_STRING;
748: if (Quiet) {
749: token.token = " /@@@.quiet 1 def ";
750: }else {
751: token.token = " /@@@.quiet 0 def ";
752: }
753: executeToken(token); /* execute startup commands */
754: token.kind = ID;
755: token.token = "exec";
756: token = lookupTokens(token); /* set hashing values */
757: tmp = findSystemDictionary(token.token);
758: ob.tag = Soperator;
759: ob.lc.ival = tmp;
760: executePrimitive(ob); /* exec */
761:
762:
763: KSdefineMacros();
764:
765: if (StartAFile) {
766: tmp2 = StartFile;
767: StartFile = (char *)sGC_malloc(sizeof(char)*(strlen(StartFile)+
768: 40));
769: sprintf(StartFile,"$%s$ run\n",tmp2);
770: token.kind = EXECUTABLE_STRING;
771: token.token = StartFile;
772: executeToken(token); /* execute startup commands */
773: token.kind = ID;
774: token.token = "exec";
775: token = lookupTokens(token); /* set hashing values */
776: tmp = findSystemDictionary(token.token);
777: ob.tag = Soperator;
778: ob.lc.ival = tmp;
779: executePrimitive(ob); /* exec */
780: }
781:
782: if (StartAString) {
783: token.kind = EXECUTABLE_STRING;
784: token.token = StartString;
785: executeToken(token); /* execute startup commands */
786: token.kind = ID;
787: token.token = "exec";
788: token = lookupTokens(token); /* set hashing values */
789: tmp = findSystemDictionary(token.token);
790: ob.tag = Soperator;
791: ob.lc.ival = tmp;
792: executePrimitive(ob); /* exec */
793: }
794:
795:
796: for (;;) {
797: if (jval=setjmp(EnvOfStackMachine)) {
798: /* *** The following does not work properly. ****
799: if (jval == 2) {
800: if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {
801: pushErrorStack(KnewErrorPacket(SerialCurrent,-1,"User interrupt by ctrl-C."));
802: }
803: }
804: **** */
805: if (DebugStack >= 1) {
806: fprintf(Fstack,"\nscanner> ");
807: }
808: KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */
809: } else { }
810: if (DebugStack >= 1) { printOperandStack(); }
811: token = getokenSM(GET);
812: if ((tmp=executeToken(token)) < 0) break;
813: /***if (tmp == 1) fprintf(stderr," --- exit --- \n");*/
814: }
815: }
816:
817:
818: void ctrlC(sig)
819: int sig;
820: {
821: extern void ctrlC();
822: extern int ErrorMessageMode;
823: extern int SGClock;
824: extern int UserCtrlC;
825: extern int OXlock;
826:
827: signal(sig,SIG_IGN);
828: /* see 133p */
829:
830: if (SGClock) {
831: UserCtrlC = 1;
832: fprintf(stderr,"ctrl-c is locked because of gc.\n");
833: signal(SIGINT,ctrlC);
834: return;
835: }
836: if (OXlock) {
837: if (UserCtrlC > 0) UserCtrlC++;
838: else UserCtrlC = 1;
839: if (UserCtrlC > 3) {
840: fprintf(stderr,"OK. You are eager to cancel the computation.\n");
841: fprintf(stderr,"You should close the ox communication cannel.\n");
842: signal(SIGINT,ctrlC);
843: unlockCtrlCForOx();
844: }
845: fprintf(stderr,"ctrl-c is locked because of ox lock %d.\n",UserCtrlC);
846: signal(SIGINT,ctrlC);
847: return;
848: }
849: if (ErrorMessageMode != 1) {
850: fprintf(Fstack,"User interruption by ctrl-C. We are in the top-level.\n");
851: fprintf(Fstack,"Type in quit in order to exit sm1.\n");
852: }
853: if (GotoP) {
854: fprintf(Fstack,"The interpreter was looking for the label <<%s>>. It is also aborted.\n",GotoLabel);
855: GotoP = 0;
856: }
857: stdOperandStack(); contextControl(CCRESTORE);
858: /*fprintf(Fstack,"Warning! The handler of ctrl-C has a bug, so you might have a core-dump.\n");*/
859: /*
860: $(x0+1)^50$ $x1 x0 + x1^20$ 2 groebner_n
861: ctrl-C
862: $(x0+1)^50$ $x1 x0 + x1^20$ 2 groebner_n
863: It SOMETIMES makes core dump.
864: */
865: getokenSM(INIT); /* It might fix the bug above. 1992/11/14 */
866: signal(SIGINT,ctrlC);
867: longjmp(EnvOfStackMachine,2); /* returns 2 for ctrl-C */
868: }
869:
870: int executeToken(token)
871: struct tokens token;
872: {
873: struct object ob;
874: int primitive;
875: int size;
876: int status;
877: struct tokens *tokenArray;
878: int i,h0,h1;
879: extern int WarningMessageMode;
880: extern int Strict;
881:
882: if (GotoP) { /* for goto */
883: if (token.kind == ID && isLiteral(token.token)) {
884: if (strcmp(&((token.token)[1]),GotoLabel) == 0) {
885: GotoP = 0;
886: return(0); /* normal exit */
887: }
888: }
889: return(0); /* normal exit */
890: }
891: if (token.kind == DOLLAR) {
892: ob.tag = Sdollar;
893: ob.lc.str = token.token;
894: Kpush(ob);
895: } else if (token.kind == ID) { /* ID */
896:
897: if (strcmp(token.token,"exit") == 0) return(1);
898: /* "exit" is not primitive here. */
899:
900: if (isLiteral(token.token)) {
901: /* literal object */
902: ob.tag = Sstring;
903: ob.lc.str = (char *)sGC_malloc((strlen(token.token)+1)*sizeof(char));
904: if (ob.lc.str == (char *)NULL) errorStackmachine("No space.");
905: strcpy(ob.lc.str, &((token.token)[1]));
906:
907: if (token.object.tag != Slist) {
908: fprintf(Fstack,"\n%%Warning: The hashing values for the <<%s>> are not set.\n",token.token);
909: token.object = lookupLiteralString(token.token);
910: }
911: ob.rc.op = token.object.lc.op;
912: Kpush(ob);
913: } else if (isInteger(token.token)) {
914: /* integer object */
915: ob.tag = Sinteger ;
916: ob.lc.ival = strToInteger(token.token);
917: Kpush(ob);
918: } else {
919: if (token.object.tag != Slist) {
920: fprintf(Fstack,"\n%%Warning: The hashing values for the <<%s>> are not set.\n",token.token);
921: token = lookupTokens(token);
922: }
923: h0 = ((token.object.lc.op)->lc).ival;
924: h1 = ((token.object.lc.op)->rc).ival;
925: ob=findUserDictionary(token.token,h0,h1,CurrentContextp);
926: primitive = ((token.object.rc.op)->lc).ival;
927: if (ob.tag >= 0) {
928: /* there is a definition in the user dictionary */
929: if (ob.tag == SexecutableArray) {
930: tokenArray = ob.lc.tokenArray;
931: size = ob.rc.ival;
932: for (i=0; i<size; i++) {
933: status = executeToken(tokenArray[i]);
934: if (status != 0) return(status);
935: }
936: }else {
937: Kpush(ob);
938: }
939: } else if (primitive) {
940: /* system operator */
941: ob.tag = Soperator;
942: ob.lc.ival = primitive;
943: return(executePrimitive(ob));
944: } else {
945: if (WarningMessageMode == 1 || WarningMessageMode == 2) {
946: char tmpc[1024];
947: if (strlen(token.token) < 900) {
948: sprintf(tmpc,"\n%%Warning: The identifier <<%s>> is not in the system dictionary\n%% nor in the user dictionaries. Push NullObject.\n",token.token);
949: }else {strcpy(tmpc,"Warning: identifier is not in the dictionaries.");}
950: pushErrorStack(KnewErrorPacket(SerialCurrent,-1,tmpc));
951: }
952: if (WarningMessageMode != 1) {
953: fprintf(Fstack,"\n%%Warning: The identifier <<%s>> is not in the system dictionary\n%% nor in the user dictionaries. Push NullObject.\n",token.token);
954: /*fprintf(Fstack,"(%d,%d)\n",h0,h1);*/
955: }
956: if (Strict) {
957: errorStackmachine("Warning: identifier is not in the dictionaries");
958: }
959: Kpush(NullObject);
960: }
961: }
962: } else if (token.kind == EXECUTABLE_STRING) {
963: Kpush(executableStringToExecutableArray(token.token));
964: } else if (token.kind == EXECUTABLE_ARRAY) {
965: Kpush(token.object);
966: } else if ((token.kind == -1) || (token.kind == -2)) { /* eof token */
967: return(-1);
968: } else {
969: /*fprintf(Fstack,"\n%%Error: Unknown token type\n");***/
970: fprintf(stderr,"\nUnknown token type = %d\n",token.kind);
971: fprintf(stderr,"\ntype in ctrl-\\ if you like to make core-dump.\n");
972: fprintf(stderr,"If you like to continue, type in RETURN key.\n");
973: fprintf(stderr,"Note that you cannot input null string.\n");
974: getchar();
975: errorStackmachine("Error: Unknown token type.\n");
976: /* return(-2); /* exit */
977: }
978: return(0); /* normal exit */
979: }
980:
981:
982:
983:
984: errorStackmachine(str)
985: char *str;
986: {
987: int i,j,k;
988: static char *u="Usage:";
989: char message0[1024];
990: char *message;
991: extern int ErrorMessageMode;
992: if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {
993: pushErrorStack(KnewErrorPacket(SerialCurrent,-1,str));
994: }
995: if (ErrorMessageMode != 1) {
996: message = message0;
997: i = 0;
998: while (i<6 && str[i]!='0') {
999: if (str[i] != u[i]) break;
1000: i++;
1001: }
1002: if (i==6) {
1003: fprintf(stderr,"ERROR(sm): \n");
1004: while (str[i] != '\0' && str[i] != ' ') {
1005: i++;
1006: }
1007: if (str[i] == ' ') {
1008: fprintf(stderr," %s\n",&(str[i+1]));
1009: k = 0;
1010: if (i-6 > 1022) message = (char *)sGC_malloc(sizeof(char)*i);
1011: for (j=6; j<i ; j++) {
1012: message[k] = str[j];
1013: message[k+1] = '\0';
1014: k++;
1015: }
1016: Kusage2(stderr,message);
1017: }else{
1018: Kusage2(stderr,&(str[6]));
1019: }
1020: }else {
1021: fprintf(stderr,"ERROR(sm): ");
1022: fprintf(stderr,str);
1023: }
1024: fprintf(stderr,"\n");
1025: }
1026: if (GotoP) {
1027: fprintf(Fstack,"The interpreter was looking for the label <<%s>>. It is also aborted.\n",GotoLabel);
1028: GotoP = 0;
1029: }
1030: stdOperandStack(); contextControl(CCRESTORE);
1031: getokenSM(INIT); /* It might fix the bug. 1996/3/10 */
1032: /* fprintf(stderr,"Now, Long jump!\n"); */
1033: longjmp(EnvOfStackMachine,1);
1034: }
1035:
1036: warningStackmachine(str)
1037: char *str;
1038: {
1039: extern int WarningMessageMode;
1040: extern int Strict;
1041: if (WarningMessageMode == 1 || WarningMessageMode == 2) {
1042: pushErrorStack(KnewErrorPacket(SerialCurrent,-1,str));
1043: }
1044: if (WarningMessageMode != 1) {
1045: fprintf(stderr,"WARNING(sm): ");
1046: fprintf(stderr,str);
1047: }
1048: if (Strict) errorStackmachine(" ");
1049: return(0);
1050: }
1051:
1052:
1053: /* exports */
1054: /* NOTE: If you call this function and an error occured,
1055: you have to reset the jump buffer by setjmp(EnvOfStackMachine).
1056: cf. kxx/memo1.txt, kxx/stdserver00.c 1998, 2/6 */
1057: KSexecuteString(s)
1058: char *s;
1059: {
1060: struct tokens token;
1061: struct object ob;
1062: int tmp;
1063: extern int CatchCtrlC;
1064: int jval;
1065: static int recursive = 0;
1066: extern int ErrorMessageMode;
1067: extern int KSPushEnvMode;
1068: jmp_buf saved_EnvOfStackMachine;
1069: void (*sigfunc)();
1070: int localCatchCtrlC ;
1071:
1072: localCatchCtrlC = CatchCtrlC;
1073: /* If CatchCtrlC is rewrited in this program,
1074: we crash. So, we use localCatchCtrlC. */
1075:
1076: if (localCatchCtrlC) {
1077: sigfunc = signal(SIGINT,SIG_IGN);
1078: signal(SIGINT,ctrlC);
1079: }
1080:
1081: if (KSPushEnvMode) {
1082: *saved_EnvOfStackMachine = *EnvOfStackMachine;
1083: if (jval = setjmp(EnvOfStackMachine)) {
1084: *EnvOfStackMachine = *saved_EnvOfStackMachine;
1085: if (jval == 2) {
1086: if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {
1087: pushErrorStack(KnewErrorPacket(SerialCurrent,-1,"User interrupt by ctrl-C."));
1088: }
1089: }
1090: recursive--;
1091: if (localCatchCtrlC) { signal(SIGINT, sigfunc); }
1092: return(-1);
1093: }else{ }
1094: }else{
1095: if (recursive == 0) {
1096: if (jval=setjmp(EnvOfStackMachine)) {
1097: if (jval == 2) {
1098: if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {
1099: pushErrorStack(KnewErrorPacket(SerialCurrent,-1,"User interrupt by ctrl-C."));
1100: }
1101: }
1102: recursive = 0;
1103: if (localCatchCtrlC) { signal(SIGINT, sigfunc); }
1104: return(-1);
1105: }else { }
1106: }
1107: }
1108:
1109: recursive++;
1110: token.token = s;
1111: token.kind = EXECUTABLE_STRING;
1112: executeToken(token);
1113: token.kind = ID;
1114: token.token = "exec";
1115: token = lookupTokens(token); /* no use */
1116: tmp = findSystemDictionary(token.token);
1117: ob.tag = Soperator;
1118: ob.lc.ival = tmp;
1119: executePrimitive(ob);
1120: recursive--;
1121: if (KSPushEnvMode) *EnvOfStackMachine = *saved_EnvOfStackMachine;
1122: if (localCatchCtrlC) { signal(SIGINT, sigfunc); }
1123: return(0);
1124: }
1125:
1126: KSdefineMacros() {
1127: struct tokens token;
1128: int tmp;
1129: struct object ob;
1130:
1131: if (StandardMacros && (strlen(SMacros))) {
1132: token.kind = EXECUTABLE_STRING;
1133: token.token = SMacros;
1134: executeToken(token); /* execute startup commands */
1135: token.kind = ID;
1136: token.token = "exec";
1137: token = lookupTokens(token); /* no use */
1138: tmp = findSystemDictionary(token.token);
1139: ob.tag = Soperator;
1140: ob.lc.ival = tmp;
1141: executePrimitive(ob); /* exec */
1142: }
1143: return(0);
1144:
1145: }
1146:
1147: void KSstart() {
1148: struct tokens token;
1149: int tmp;
1150: struct object ob;
1151: extern int Quiet;
1152:
1153: stackmachine_init(); KinitKan();
1154: getokenSM(INIT); initSystemDictionary();
1155:
1156: /* The following line may cause a core dump, if you do not setjmp properly
1157: after calling KSstart().*/
1158: /*
1159: if (setjmp(EnvOfStackMachine)) {
1160: fprintf(stderr,"KSstart(): An error or interrupt in reading macros, files and command strings.\n");
1161: exit(10);
1162: } else { } */
1163:
1164: /* setup quiet mode or not */
1165: token.kind = EXECUTABLE_STRING;
1166: if (Quiet) {
1167: token.token = " /@@@.quiet 1 def ";
1168: }else {
1169: token.token = " /@@@.quiet 0 def ";
1170: }
1171: executeToken(token); /* execute startup commands */
1172: token.kind = ID;
1173: token.token = "exec";
1174: token = lookupTokens(token); /* set hashing values */
1175: tmp = findSystemDictionary(token.token);
1176: ob.tag = Soperator;
1177: ob.lc.ival = tmp;
1178: executePrimitive(ob); /* exec */
1179:
1180: KSdefineMacros();
1181: }
1182:
1183: void KSstop() {
1184: Kclose(); stackmachine_close();
1185: }
1186:
1187:
1188: struct object KSpop() {
1189: return(Kpop());
1190: }
1191:
1192: void KSpush(ob)
1193: struct object ob;
1194: {
1195: Kpush(ob);
1196: }
1197:
1198: char *KSstringPop() {
1199: /* pop a string */
1200: struct object rob;
1201: rob = Kpop();
1202: if (rob.tag == Sdollar) {
1203: return(rob.lc.str);
1204: }else{
1205: return((char *)NULL);
1206: }
1207: }
1208:
1209: char *KSpopString() {
1210: return(KSstringPop());
1211: }
1212:
1213: int KSset(char *name) {
1214: char *tmp2;
1215: char tmp[1024];
1216: tmp2 = tmp;
1217: if (strlen(name) < 1000) {
1218: sprintf(tmp2," /%s set ",name);
1219: }else{
1220: tmp2 = sGC_malloc(sizeof(char)*(strlen(name)+20));
1221: if (tmp2 == (char *)NULL) errorStackmachine("Out of memory.");
1222: sprintf(tmp2," /%s set ",name);
1223: }
1224: return( KSexecuteString(tmp2) );
1225: }
1226:
1227: int KSpushBinary(int size,char *data) {
1228: /* struct object KbinaryToObject(int size, char *data); */
1229: errorStackmachine("KSpushBinary is not implemented.\n");
1230: return(-1);
1231: }
1232:
1233: char *KSpopBinary(int *size) {
1234: /* char *KobjectToBinary(struct object ob,int *size); */
1235: errorStackmachine("KSpopBinary is not implemented.\n");
1236: *size = 0;
1237: return((char *)NULL);
1238: }
1239:
1240: int pushErrorStack(struct object obj)
1241: {
1242: if (CurrentOperandStack == &ErrorStack) {
1243: fprintf(stderr,"You cannot call pushErrorStack when ErrorStack is the CurrentOperandStack. \n");
1244: return(-1);
1245: }
1246: (ErrorStack.ostack)[(ErrorStack.sp)++] = obj;
1247: /* printf("ErrorStack.sp = %d\n",ErrorStack.sp); */
1248: if ((ErrorStack.sp) >= (ErrorStack.size)) {
1249: ErrorStack.sp = 0;
1250: fprintf(stderr,"pushErrorStack():ErrorStack overflow. It is reset.\n");
1251: /* Note that it avoids recursive call.*/
1252: return(-1);
1253: }
1254: return(0);
1255: }
1256:
1257: struct object popErrorStack(void) {
1258: if (CurrentOperandStack == &ErrorStack) {
1259: fprintf(stderr,"You cannot call popErrorStack when ErrorStack is the CurrentOperandStack. \n");
1260: return(NullObject);
1261: }
1262: if ((ErrorStack.sp) <= 0) {
1263: return( NullObject );
1264: }else{
1265: return( (ErrorStack.ostack)[--(ErrorStack.sp)]);
1266: }
1267: }
1268:
1269: char *popErrorStackByString(void) {
1270: struct object obj;
1271: struct object eobj;
1272: eobj = popErrorStack();
1273: if (ectag(eobj) != CLASSNAME_ERROR_PACKET) {
1274: return(NULL);
1275: }else{
1276: obj = *(KopErrorPacket(eobj));
1277: }
1278: if (obj.tag != Sarray || getoaSize(obj) != 3) {
1279: fprintf(stderr,"errorPacket format error.\n");
1280: printObject(eobj,0,stderr); fflush(stderr);
1281: return("class errorPacket format error. Bug of sm1.");
1282: }
1283: obj = getoa(obj,2);
1284: if (obj.tag != Sdollar) {
1285: fprintf(stderr,"errorPacket format error at position 2..\n");
1286: printObject(eobj,0,stderr); fflush(stderr);
1287: return("class errorPacket format error at the position 2. Bug of sm1.");
1288: }
1289: return(KopString(obj));
1290: }
1291:
1292:
1293: int KScheckErrorStack(void)
1294: {
1295: return(ErrorStack.sp);
1296: }
1297:
1298: struct object KnewErrorPacket(int serial,int no,char *message)
1299: {
1300: struct object obj;
1301: struct object *myop;
1302: char *s;
1303: /* Set extended tag. */
1304: obj.tag = Sclass; obj.lc.ival = CLASSNAME_ERROR_PACKET ;
1305: myop = (struct object *)sGC_malloc(sizeof(struct object));
1306: if (myop == (struct object *)NULL) errorStackmachine("No memory\n");
1307: *myop = newObjectArray(3);
1308: /*fprintf(stderr,"newErrorPacket() in stackmachine.c: [%d, %d, %s] \n",serial,no,message); **kxx:CMO_ERROR */
1309: putoa((*myop),0,KpoInteger(serial));
1310: putoa((*myop),1,KpoInteger(no));
1311: s = (char *)sGC_malloc(sizeof(char)*(strlen(message)+2));
1312: if (s == (char *)NULL) errorStackmachine("No memory\n");
1313: strcpy(s,message);
1314: putoa((*myop),2,KpoString(s));
1315: obj.rc.op = myop;
1316: return(obj);
1317: }
1318:
1319:
1320: struct object KnewErrorPacketObj(struct object ob1)
1321: {
1322: struct object obj;
1323: struct object *myop;
1324: char *s;
1325: /* Set extended tag. */
1326: obj.tag = Sclass; obj.lc.ival = CLASSNAME_ERROR_PACKET ;
1327: myop = (struct object *)sGC_malloc(sizeof(struct object));
1328: if (myop == (struct object *)NULL) errorStackmachine("No memory\n");
1329: *myop = ob1;
1330: obj.rc.op = myop;
1331: return(obj);
1332: }
1333:
1334: void *sGC_malloc(size_t n) { /* synchronized function */
1335: void *c;
1336: int id;
1337: extern int SGClock, UserCtrlC;
1338:
1339: SGClock = 1;
1340: c = GC_malloc(n);
1341: SGClock = 0;
1342: if (UserCtrlC) {
1343: UserCtrlC = 0;
1344: id = getpid();
1345: kill(id,SIGINT);
1346: return(c);
1347: }else{
1348: return(c);
1349: }
1350: }
1351:
1352: void *sGC_realloc(void *p,size_t new) { /* synchronized function */
1353: void *c;
1354: int id;
1355: extern int SGClock, UserCtrlC;
1356:
1357: SGClock = 1;
1358: c = GC_realloc(p,new);
1359: SGClock = 0;
1360: if (UserCtrlC) {
1361: UserCtrlC = 0;
1362: id = getpid();
1363: kill(id,SIGINT);
1364: return(c);
1365: }else{
1366: return(c);
1367: }
1368: }
1369:
1370: void sGC_free(void *c) { /* synchronized function */
1371: int id;
1372: extern int SGClock, UserCtrlC;
1373:
1374: SGClock = 1;
1375: GC_free(c);
1376: SGClock = 0;
1377: if (UserCtrlC) {
1378: UserCtrlC = 0;
1379: id = getpid();
1380: kill(id,SIGINT);
1381: return;
1382: }else{
1383: return;
1384: }
1385: }
1386:
1387: void lockCtrlCForOx() {
1388: extern int OXlock;
1389: extern int OXlockSaved;
1390: OXlockSaved = OXlock;
1391: OXlock = 1;
1392: }
1393:
1394: void unlockCtrlCForOx() {
1395: int id;
1396: extern int OXlock, UserCtrlC;
1397: extern int OXlockSaved;
1398: OXlockSaved = OXlock;
1399: OXlock = 0;
1400: if (UserCtrlC) {
1401: UserCtrlC = 0;
1402: id = getpid();
1403: kill(id,SIGINT);
1404: return;
1405: }else{
1406: return;
1407: }
1408: }
1409:
1410: void restoreLockCtrlCForOx() {
1411: extern int OXlock;
1412: extern int OXlockSaved;
1413: OXlock = OXlockSaved;
1414: }
1415:
1416: int KSstackPointer() {
1417: return(Osp);
1418: }
1419:
1420: struct object KSdupErrors() {
1421: struct object rob;
1422: struct object ob;
1423: int i;
1424: int n;
1425: int m;
1426:
1427: n = KSstackPointer();
1428: m = 0;
1429: for (i=0; i<n; i++) {
1430: ob = peek(i);
1431: if (ob.tag == Sclass && ectag(ob) == CLASSNAME_ERROR_PACKET) {
1432: m++;
1433: }
1434: }
1435: rob = newObjectArray(m);
1436: m = 0;
1437: for (i=0; i<n; i++) {
1438: ob = peek(i);
1439: if (ob.tag == Sclass && ectag(ob) == CLASSNAME_ERROR_PACKET) {
1440: putoa(rob, m, ob);
1441: m++;
1442: }
1443: }
1444: return(rob);
1445: }
1446:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to stackmachine.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / Kan