Annotation of OpenXM/src/kan96xx/plugin/cmo.c, Revision 1.1.1.1
1.1 maekawa 1: #include <stdio.h>
2: #include <string.h>
3: #include <netinet/in.h>
4: #include <stdlib.h>
5: #include "datatype.h"
6: #include "stackm.h"
7: #include "extern.h"
8: #include "extern2.h"
9: #include "mathcap.h"
10: #include "kclass.h"
11: #include "oxMessageTag.h"
12: #include "oxFunctionId.h"
13:
14: #include "file2.h"
15: #include "cmo.h"
16:
17: #include "cmotag.htmp" /* static char *cmotagToName(int tag) is defined
18: here. */
19:
20: extern int OxVersion;
21:
22: int CmoClientMode = 1; /* This flag is used to translate names for
23: indeterminates.
24: It does not work well if ox_sm1 have a server, i.e.,
25: sm1 --> ox_sm1 --> ox_sm1
26: */
27:
28: /* void *malloc(int s);
29: #define GC_malloc(x) malloc(x) */
30: /********************** What you have to do when you add new CMO_ **********
31: * Add your new object to cmoObjectToCmo00 ( for sending )
32: * Add your new object to cmoCmoToObject00 ( for receiving )
33: * Edit KSmathCapByStruct();
34: * Edit typeTrans in cmoCheck00 in oxmisc2.c , e.g.,
35: * typeTrans[CLASSNAME_mathcap] = CMO_MATHCAP;
36: **************************************************************************/
37: /* If you change the format of mathcap, do the follows.
38: Mofify cmoCheckMathCap in oxmisc2.c,
39: oxReq, SM_setMathCap:, and
40: grep mathCap and make all modifications.
41: */
42:
43: extern struct ring *CurrentRingp;
44: extern struct ring *SmallRingp;
45: extern int CmoDMSOutputOption;
46:
47: struct object NullObjectInCmo;
48:
49: extern int SerialCurrent;
50: extern int DebugCMO;
51:
52: #define BUFFERSIZE 1024
53: struct cmoBuffer *cmoOutputToBuf(cmoAction a,void *data, int size)
54: {
55: static struct cmoBuffer b;
56: static int bufferIsInitialized = 0;
57: void *tmp;
58: struct cmoBuffer *cb;
59: int i;
60: if (!bufferIsInitialized) {
61: NullObjectInCmo.tag = Snull;
62: bufferIsInitialized = 1;
63: b.size = BUFFERSIZE;
64: b.pos = 0;
65: b.rpos = 0;
66: b.isStream = 0;
67: b.fp = (FILE2 *)NULL;
68: b.buf = sGC_malloc(BUFFERSIZE);
69: if (b.buf == NULL) errorCmo("cmoOutputToBuf: no memory.");
70: }
71: if (b.isStream) {
72: switch(a) {
73: case CMOINIT:
74: b.pos = 0;
75: b.rpos = 0; /* added, 1997, 12/5 */
76: b.isStream = 0;
77: b.fp = (FILE2 *)data ;
78: b.errorno = 0;
79: break;
80: case CMOINITSTREAM:
81: b.pos = 0;
82: b.isStream = 1;
83: b.rpos = 0; /* added, 1997, 12/5 */
84: b.fp = (FILE2 *)data;
85: b.errorno = 0;
86: break;
87: case CMOPUT:
88: for (i=0; i<size; i++) {
89: fp2fputc(((char *)data)[i], b.fp);
90: }
91: break;
92: case CMOFLUSH:
93: if (fp2fflush(b.fp)<0) {
94: errorCmo("cmoOutputToBuf: CMOFLUSH failed in stream mode.");
95: }
96: cb = (struct cmoBuffer *)sGC_malloc(sizeof(struct cmoBuffer));
97: cb->isStream = b.isStream;
98: cb->size = b.pos;
99: cb->pos = b.pos;
100: cb->buf = NULL;
101: return(cb);
102: break;
103: case CMOERROR:
104: b.errorno = size;
105: break;
106: default:
107: errorCmo("Unknown action.");
108: break;
109: }
110: return(NULL);
111: }else{
112: switch(a) {
113: case CMOINIT:
114: b.pos = 0;
115: b.rpos = 0; /* added, 1997, 12/5 */
116: b.isStream = 0;
117: b.errorno = 0;
118: break;
119: case CMOINITSTREAM:
120: b.pos = 0;
121: b.isStream = 1;
122: b.rpos = 0; /* added, 1997, 12/5 */
123: b.fp = (FILE2 *)data;
124: b.errorno = 0;
125: break;
126: case CMOPUT:
127: if (b.pos + size >= b.size) {
128: tmp = sGC_malloc((b.size)*2+size);
129: memcpy(tmp,b.buf,b.pos);
130: b.buf = tmp;
131: b.size = (b.size)*2+size;
132: }
133: memcpy((void *) &(((char *)(b.buf))[b.pos]),data,size);
134: b.pos += size;
135: break;
136: case CMOFLUSH:
137: cb = (struct cmoBuffer *)sGC_malloc(sizeof(struct cmoBuffer));
138: cb->isStream = b.isStream;
139: cb->size = b.pos;
140: cb->pos = b.pos;
141: cb->buf = sGC_malloc((b.pos<=0?1:b.pos));
142: memcpy(cb->buf,b.buf,b.pos);
143: return(cb);
144: break;
145: case CMOERROR:
146: b.errorno = size;
147: break;
148: default:
149: errorCmo("Unknown action.");
150: break;
151: }
152: return(NULL);
153: }
154: }
155:
156: dumpCmoBuf(struct cmoBuffer *cb)
157: {
158: int i,size, tag;
159: char *s;
160: if (cb->isStream) {
161: printf("cmoBuffer is directed to a stream.\n");
162: return;
163: }
164: size = cb->pos;
165: s = (char *)(cb->buf);
166: tag = htonl(*((int *) s));
167: printf("CMO StandardEncoding: size = %d, size/sizeof(int) = %d, tag=%s \n",size,size/sizeof(int),cmotagToName(tag));
168: for (i=0; i<size; i++) {
169: if (i % 20 == 0) putchar('\n');
170: printf("%3x",(int)(unsigned char)s[i]);
171: }
172: putchar('\n');
173: }
174:
175: /* This obsolete function is used to write data
176: in cmoBuffer (cmo object in kan)
177: to a stream */
178: cmoToStream(struct object cmoObj,struct object of)
179: {
180: int i,size;
181: struct cmoBuffer *cb;
182: char *s;
183: int file2=0;
184: if (!(cmoObj.tag == Sclass && cmoObj.lc.ival == CMO)) {
185: errorCmo("cmoToStream: the first argument is not cmoObject.");
186: }
187: if (of.tag != Sfile) {
188: errorCmo("cmoToStream: the second argument is not file object.");
189: }
190: if (strcmp(of.lc.str,MAGIC2) == 0) {
191: file2 = 1;
192: }
193: cb = cmoObj.rc.voidp;
194: size = cb->pos;
195: s = (char *)(cb->buf);
196: for (i=0; i<size; i++) {
197: if (file2) {
198: fp2fputc(s[i],(FILE2 *)(of.rc.voidp));
199: }else{
200: fputc(s[i],of.rc.file);
201: }
202: }
203: }
204: /* This obsolete function is used to store data from the stream
205: to cmoBuffer in the raw form. (cmo object in kan).
206: cf. cmoObjectFromStream, cmoObjectToStream: these function
207: directly transmit objects of kan to a stream in CMO format.
208: */
209: struct object streamToCmo(struct object of)
210: {
211: int c;
212: unsigned char s[1];
213: struct object ob;
214: int file2 = 0;
215: if (of.tag == Sfile) {
216:
217: }else{
218: errorCmo("streamToCmo: no file is opened.");
219: }
220: if (strcmp(of.lc.str,MAGIC2) == 0) {
221: file2 = 1;
222: }
223: cmoOutputToBuf(CMOINIT,NULL,0);
224: /* Raw reading to the buffer from file. No cmoOutHeader(). */
225: if (file2) {
226: while ((c=fp2fgetc((FILE2 *)of.rc.voidp)) != EOF) {
227: s[0] = c;
228: cmoOutputToBuf(CMOPUT,s,1);
229: }
230: }else{
231: while ((c=fgetc(of.rc.file)) != EOF) {
232: s[0] = c;
233: cmoOutputToBuf(CMOPUT,s,1);
234: }
235: }
236: /* Raw reading to the buffer from file. No cmoOutTail(). */
237: ob.tag = Sclass;
238: ob.lc.ival = CMO;
239: ob.rc.voidp = cmoOutputToBuf(CMOFLUSH,NULL,0);
240: return(ob);
241: }
242:
243:
244: cmoOutCmoNull() {
245: cmoint tmp[1];
246: tmp[0] = htonl((cmoint) CMO_NULL);
247: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));
248: }
249:
250:
251:
252:
253: /* unsigned short int must be 32 bits */
254: cmoOutInt32(int k)
255: {
256: cmoint tmp[2];
257: tmp[0] = htonl((cmoint) CMO_INT32);
258: tmp[1] = htonl((cmoint ) k);
259: cmoOutputToBuf(CMOPUT,tmp,2*sizeof(cmoint));
260: }
261:
262: cmoOutString(char *d,int size) {
263: cmoint tmp[2];
264: tmp[0] = htonl((cmoint) CMO_STRING);
265: tmp[1] = htonl((cmoint ) size);
266: cmoOutputToBuf(CMOPUT,tmp,2*sizeof(cmoint));
267: cmoOutputToBuf(CMOPUT,d,size);
268: }
269:
270:
271: int cmoOutMonomial32(POLY cell)
272: {
273: cmoint tmp[3+N0*2];
274: extern int ReverseOutputOrder;
275: int i,nn,tt;
276: if (cell == POLYNULL) {
277: tmp[0] = htonl(CMO_ZERO);
278: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));
279: return(0);
280: }
281: tmp[0] = htonl(CMO_MONOMIAL32);
282: nn = cell->m->ringp->n;
283: tmp[1] = htonl(nn*2);
284: if (ReverseOutputOrder) {
285: for (i=0; i<nn; i++) {
286: tmp[2+i] = htonl(cell->m->e[nn-i-1].x);
287: tmp[2+nn+i] = htonl(cell->m->e[nn-i-1].D);
288: }
289: }else{
290: for (i=0; i<nn; i++) {
291: tmp[2+i] = htonl(cell->m->e[i].x);
292: tmp[2+nn+i] = htonl(cell->m->e[i].D);
293: }
294: }
295: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint)*(2+2*nn));
296: switch(cell->coeffp->tag) {
297: case INTEGER:
298: cmoOutInt32(cell->coeffp->val.i);
299: return(0);
300: break;
301: case MP_INTEGER:
302: /* errorCmo("Not implemented."); */
303: cmoOutGMPCoeff(cell->coeffp->val.bigp);
304: return(0);
305: break;
306: default:
307: cmoOutputToBuf(CMOERROR,NULL,-1); /* fatal, need reset_connection */
308: errorCmo("cmoOutMonomial32(): unknown coefficient tag.");
309: return(-1);
310: break;
311: }
312: }
313:
314: int cmoOutDMS()
315: {
316: cmoint tmp[1];
317: tmp[0] = htonl(CMO_DMS);
318: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));
319: return(0);
320: }
321:
322: int cmoOutPolynomial(POLY f)
323: {
324: int size;
325: cmoint tmp[2];
326: if (f == POLYNULL) {
327: return(cmoOutMonomial32(f));
328: }
329: size = pLength(f);
330: tmp[0] = htonl(CMO_LIST);
331: tmp[1] = htonl(size+2);
332: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint)*2);
333: cmoOutDMS();
334: cmoOutRingDefinition(f->m->ringp,CmoDMSOutputOption);
335: while (f != POLYNULL) {
336: cmoOutMonomial32(f);
337: f = f->next;
338: }
339: return(0);
340: }
341:
342: int cmoOutPolynomial2(POLY f)
343: {
344: int size;
345: cmoint tmp[2];
346: if (f == POLYNULL) {
347: return(cmoOutMonomial32(f));
348: }
349: size = pLength(f);
350: tmp[0] = htonl(CMO_DISTRIBUTED_POLYNOMIAL);
351: tmp[1] = htonl(size);
352: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint)*2);
353: cmoOutRingDefinition2(f->m->ringp,CmoDMSOutputOption);
354: while (f != POLYNULL) {
355: cmoOutMonomial32(f);
356: f = f->next;
357: }
358: return(0);
359: }
360:
361: int cmoOutRingDefinition(struct ring *rp,int option)
362: {
363: cmoint tmp[3];
364: /* minimal information */
365: switch(option) {
366: case 1: /* RING_BY_NAME */
367: cmoOutRawInt(CMO_RING_BY_NAME);
368: cmoOutString(rp->name,strlen(rp->name));
369: break;
370: case 2:
371: tmp[0] = htonl(CMO_DMS_OF_N_VARIABLES);
372: tmp[1] = htonl(CMO_LIST);
373: tmp[2] = htonl(2);
374: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint)*3);
375: cmoOutInt32((rp->n)*2); /* number of variables */
376: cmoOutInt32(rp->p); /* coefficient field.
377: CMO_INT32 or CMO_DMS_OF_N_VARIABLES */
378: /* Optional arguments are name of variables, weight_vector, output_order */
379: break;
380: default: /* including 0. */
381: cmoOutInt32(CMO_DMS_GENERIC);
382: break;
383: }
384:
385: }
386:
387: int cmoOutRingDefinition2(struct ring *rp,int option)
388: {
389: cmoint tmp[3];
390: /* minimal information */
391: switch(option) {
392: case 1: /* RING_BY_NAME */
393: cmoOutRawInt(CMO_RING_BY_NAME);
394: cmoOutString(rp->name,strlen(rp->name));
395: break;
396: case 2:
397: tmp[0] = htonl(CMO_DMS_OF_N_VARIABLES);
398: tmp[1] = htonl(CMO_LIST);
399: tmp[2] = htonl(2);
400: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint)*3);
401: cmoOutInt32((rp->n)*2); /* number of variables */
402: cmoOutInt32(rp->p); /* coefficient field.
403: CMO_INT32 or CMO_DMS_OF_N_VARIABLES */
404: /* Optional arguments are list of indeterminates (name of variables),
405: weight_vector by list , output_order by list. */
406: break;
407: default: /* including 0. */
408: cmoOutRawInt(CMO_DMS_GENERIC);
409: break;
410: }
411:
412: }
413:
414: /* ------------------------------ */
415: int cmoGetIntFromBuf(cmoAction a,struct cmoBuffer *cb)
416: {
417: cmoint tmp[1];
418: char data[4];
419: int i;
420: int cc;
421: if (cb->isStream) {
422: switch(a) {
423: case CMOGET:
424: for (i=0; i<4; i++) {
425: cc = fp2fgetc(cb->fp);
426: if (cc < 0) {
427: return(-1);
428: errorCmo("cmoGetIntFromBuf CMOGET: unexpected EOF.\n");
429: }
430: data[i] = cc;
431: }
432: return( (int) ntohl( *((cmoint *) data) ));
433: break;
434: case CMOGETBYTE:
435: cc = fp2fgetc(cb->fp);
436: if (cc < 0) {
437: return(-1);
438: errorCmo("cmoGetIntFromBuf CMOGETBYTE: unexpected EOF.\n");
439: }
440: return(cc);
441: break;
442: case CMOINIT:
443: fprintf(stderr,"Invalid action CMOINIT for cmoBuffer in the stream mode.\n");
444: cb->rpos = 0;
445: cb->errorno = 0;
446: break;
447: case CMOINITSTREAM:
448: cb->errorno = 0;
449: break;
450: case CMOERROR:
451: cb->errorno = 1;
452: break;
453: case CMOERROR2:
454: cb->errorno = -1;
455: break;
456: }
457: return(0);
458: }else{
459: switch(a) {
460: case CMOGET:
461: if (cb->rpos + sizeof(cmoint) > cb->pos) {
462: fprintf(stderr,"No more data in the buffer. Returns -1.\n");
463: return(-1);
464: }
465: memcpy(tmp,(void *) &(((char *)(cb->buf))[cb->rpos]),
466: sizeof(cmoint));
467: cb->rpos += sizeof(cmoint);
468: return( (int) ntohl(tmp[0]));
469: break;
470: case CMOGETBYTE:
471: if (cb->rpos + 1 > cb->pos) {
472: fprintf(stderr,"No more data in the buffer. Returns -1.\n");
473: return(-1);
474: }
475: tmp[0] = ((unsigned char *)(cb->buf))[cb->rpos];
476: cb->rpos += 1;
477: return( (int) tmp[0]);
478: break;
479: case CMOINIT:
480: cb->rpos = 0;
481: cb->errorno = 0;
482: break;
483: case CMOINITSTREAM:
484: cb->errorno = 0;
485: break;
486: case CMOERROR:
487: cb->errorno = 1;
488: break;
489: case CMOERROR2:
490: cb->errorno = -1;
491: break;
492: }
493: return(0);
494: }
495: }
496:
497:
498: /* ------------------------------------- */
499: /* This function is called after reading the tag CMO_INT32COEFF */
500: struct coeff * cmoGetInt32Coeff(struct cmoBuffer *cb)
501: {
502: struct coeff *c;
503: c = intToCoeff(cmoGetIntFromBuf(CMOGET,cb),CurrentRingp);
504: return(c);
505: }
506: void *cmoGetString(struct cmoBuffer *cb, int size)
507: {
508: char *d;
509: int i;
510: if (size > 0) {
511: d = (char *)sGC_malloc(size);
512: if (d == NULL) {
513: errorCmo("No more memory in cmoGetString().\n");
514: }
515: }else{
516: d = (char *)sGC_malloc(1); d[0] = '\0';
517: if (d == NULL) {
518: errorCmo("No more memory in cmoGetString().\n");
519: }
520: }
521: for (i=0; i<size; i++) {
522: d[i] = cmoGetIntFromBuf(CMOGETBYTE, cb);
523: }
524: return(d);
525: }
526:
527: POLY cmoGetMonomial32(struct cmoBuffer *cb)
528: {
529: int nn,i,tt;
530: struct coeff *c;
531: struct monomial *m;
532: MP_INT *mi;
533: MP_INT *mi2;
534: int skip;
535: int nn0,nn1;
536: extern int ReverseOutputOrder;
537: skip = 0;
538: nn = cmoGetIntFromBuf(CMOGET,cb);
539: if (nn > (CurrentRingp->n)*2 ) {
540: CurrentRingp = KopRingp(KdefaultPolyRing(KpoInteger(nn/2+(nn%2))));
541: warningCmo("cmoGetMonomials32(): Changed the current ring, because your peer sent a DMS that does not fit to the current ring.");
542:
543: /* original code.
544: skip = nn - (CurrentRingp->n)*2;
545: nn1 = nn0 = CurrentRingp->n;
546: if (! (cb->errorno) ) {
547: warningCmo("cmoGetMonomial32(): serialized polynomial \\not\\in CurrentRing.");
548: }
549: cmoGetIntFromBuf(CMOERROR,cb);
550: */
551: }
552: if (nn == (CurrentRingp->n)*2 ) {
553: nn1 = nn0 = CurrentRingp->n;
554: skip = 0;
555: }else {
556: nn0 = nn/2;
557: nn1 = nn - nn0;
558: skip = 0;
559: }
560:
561: m = newMonomial(CurrentRingp);
562: if (ReverseOutputOrder) {
563: for (i=0; i<nn0; i++) {
564: m->e[nn0-i-1].x = cmoGetIntFromBuf(CMOGET,cb);
565: }
566: for (i=0; i<nn1; i++) {
567: m->e[nn1-i-1].D = cmoGetIntFromBuf(CMOGET,cb);
568: }
569: }else{
570: for (i=0; i<nn0; i++) {
571: m->e[i].x = cmoGetIntFromBuf(CMOGET,cb);
572: }
573: for (i=0; i<nn1; i++) {
574: m->e[i].D = cmoGetIntFromBuf(CMOGET,cb);
575: }
576: }
577:
578: /* Throw a way extra data. */
579: for (i=0; i<skip; i++) {
580: cmoGetIntFromBuf(CMOGET,cb);
581: }
582:
583: tt = cmoGetIntFromBuf(CMOGET,cb);
584: switch(tt) {
585: case CMO_INT32:
586: c = cmoGetInt32Coeff(cb);
587: break;
588: case CMO_ZZ_OLD:
589: case CMO_ZZ:
590: if (OxVersion >= 199907170 && tt == CMO_ZZ_OLD) {
591: errorCmo("CMO_ZZ_OLD is not implemented.");
592: }else if (OxVersion < 199907170 && tt == CMO_ZZ) {
593: errorCmo("CMO_ZZ is not implemented.");
594: }
595: mi = newMP_INT();
596: cmoGetGMPCoeff(mi, cb);
597: c = mpintToCoeff(mi,CurrentRingp);
598: /* errorCmo("Not implemented."); */
599: break;
600: case CMO_QQ:
601: if (! (cb->errorno) ) {
602: warningCmo("cmoGetMonomial32(): coefficient CMO_QQ is not supported. Denominators are ignored.");
603: }
604: cmoGetIntFromBuf(CMOERROR,cb);
605: mi = newMP_INT();
606: cmoGetGMPCoeff(mi,cb);
607: c = mpintToCoeff(mi,CurrentRingp); /* we take only numerator */
608: /* Throw a way denominators. */
609: mi2 = newMP_INT();
610: cmoGetGMPCoeff(mi2,cb);
611: break;
612: default:
613: cmoGetIntFromBuf(CMOERROR2,cb);
614: errorCmo("cmoGetMonomial32(): coeff type that is not implemented.");
615: break;
616: }
617: return(newCell(c,m));
618: }
619:
620:
621:
622: /* ------------------------------------- */
623: void cmoObjectToCmo00(struct object ob)
624: {
625: struct object rob;
626: cmoint tmp[16];
627: char tmpc[16];
628: int i,size;
629: struct object vlist, vlist0;
630: int m;
631: struct object ob2;
632:
633: /* NO initialization */
634: switch(ob.tag) {
635: case Snull:
636: cmoOutCmoNull();
637: break;
638: case Sinteger:
639: /* fprintf(stderr,"For test.\n"); */
640: cmoOutInt32(ob.lc.ival);
641: break;
642: case Sdollar:
643: cmoOutString(ob.lc.str,strlen(ob.lc.str));
644: break;
645: case Spoly:
646: /* cmoOutPolynomial(KopPOLY(ob)); */
647: cmoOutPolynomial2(KopPOLY(ob));
648: break;
649: case Sarray:
650: tmp[0] = htonl(CMO_LIST);
651: tmp[1] = htonl(size=getoaSize(ob));
652: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint)*2);
653: for (i=0; i<size; i++) {
654: cmoObjectToCmo00(getoa(ob,i));
655: }
656: break;
657: case SuniversalNumber:
658: cmoOutGMPCoeff(ob.lc.universalNumber->val.bigp);
659: break;
660: case Sdouble:
661: if (sizeof(double) != 8) errorCmo("double is assumed to be 8 bytes.");
662: cmoOutRawInt(CMO_64BIT_MACHINE_DOUBLE);
663: *((double *) tmpc) = (double) *(ob.lc.dbl);
664: cmoOutputToBuf(CMOPUT,tmpc,8);
665: break;
666: case Sclass:
667: switch(ectag(ob)) {
668: case CLASSNAME_ERROR_PACKET:
669: /* fprintf(stderr,"ectag=%d\n",ectag(*KopErrorPacket(ob))); **kxx:CMO_ERROR*/
670: if (ectag(*KopErrorPacket(ob)) == CLASSNAME_ERROR_PACKET) {
671: tmp[0] = htonl(CMO_ERROR);
672: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));
673: }else{
674: tmp[0] = htonl(CMO_ERROR2);
675: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));
676: /* Send without OX_DATA header !! */
677: cmoObjectToCmo00(*(KopErrorPacket(ob)));
678: }
679: break;
680: case CLASSNAME_mathcap:
681: tmp[0] = htonl(CMO_MATHCAP);
682: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));
683: /* Send without OX_DATA header !! */
684: cmoObjectToCmo00(*(KopMathCap(ob)));
685: break;
686: case CLASSNAME_indeterminate:
687: tmp[0] = htonl(CMO_INDETERMINATE);
688: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));
689: /* cmoObjectToCmo00(KopIndeterminate(ob)); Old code. */
690: /* If you need to translate the name, do it here. */
691: if (CmoClientMode) {
692: ob = KopIndeterminate(ob);
693: }else{
694: ob = cmoTranslateVariable_outGoing(KopIndeterminate(ob));
695: }
696: cmoObjectToCmo00(ob);
697: break;
698: case CLASSNAME_recursivePolynomial:
699: /* We assume that the format of the recursive polynomial
700: is OK. */
701: tmp[0] = htonl(CMO_RECURSIVE_POLYNOMIAL);
702: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));
703: ob = KopRecursivePolynomial(ob);
704: vlist = getoa(ob,0);
705: vlist0 = newObjectArray(getoaSize(vlist));
706: for (i=0; i<getoaSize(vlist); i++) {
707: if (CmoClientMode) {
708: putoa(vlist0,i,
709: KpoIndeterminate(getoa(vlist,i)));
710: }else{
711: putoa(vlist0,i,
712: KpoIndeterminate(cmoTranslateVariable_outGoing(getoa(vlist,i))));
713: }
714: }
715: cmoObjectToCmo00(vlist0); /* output the list of variables. */
716: cmoObjectToCmo00(getoa(ob,1)); /* output the body of the recursive poly
717: polynomial in one variable or any object*/
718: break;
719: case CLASSNAME_polynomialInOneVariable:
720: tmp[0] = htonl(CMO_POLYNOMIAL_IN_ONE_VARIABLE);
721: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));
722: ob = KopPolynomialInOneVariable(ob);
723: if (ob.tag != Sarray) {
724: cmoObjectToCmo00(ob);
725: }else{
726: /* We do not check the format. */
727: m = (getoaSize(ob)-1)/2; /* the number of monomials */
728: cmoOutRawInt(m);
729: ob2 = getoa(ob,0); /* the variable name by integer. */
730: if (ob2.tag != Sinteger) {
731: warningCmo("cmoObjectToCmo00(): polynomial in one variable: this field should be integer. Output 0");
732: /* cmoOutInt32(0); */
733: cmoOutRawInt(0);
734: }else{
735: /* cmoObjectToCmo00(ob2); */
736: cmoOutRawInt(KopInteger(ob2));
737: }
738: for (i=1; i<getoaSize(ob); i = i+2) {
739: cmoOutRawInt(KopInteger(getoa(ob,i))); /* exponent */
740: cmoObjectToCmo00(getoa(ob,i+1)); /* coefficient */
741: }
742: }
743: break;
744: case CLASSNAME_tree:
745: cmoOutRawInt(CMO_TREE);
746: ob = KopTree(ob);
747: cmoObjectToCmo00(getoa(ob,0));
748: cmoObjectToCmo00(getoa(ob,1));
749: cmoObjectToCmo00(getoa(ob,2));
750: break;
751: default:
752: warningCmo("cmoObjectToCmo(): unknown etag for Sclass. Output CMO_NULL");
753: cmoOutCmoNull(); /* otherwise core dump. */
754: break;
755: }
756: break;
757: default:
758: warningCmo("cmoObjectToCmo(): unknown tag. Output CMO_NULL");
759: cmoOutCmoNull(); /* otherwise core dump. */
760: break;
761: }
762: /* no flush */
763: }
764:
765: struct object cmoObjectToCmo(struct object ob)
766: {
767: struct object rob;
768: if (DebugCMO) {
769: fprintf(stderr,"cmoObjectToCmo: ");
770: printObject(ob,1,stderr);
771: }
772: cmoOutputToBuf(CMOINIT,NULL,0);
773: cmoObjectToCmo00(ob);
774: rob.tag = Sclass;
775: rob.lc.ival = CMO;
776: rob.rc.voidp = cmoOutputToBuf(CMOFLUSH,NULL,0);
777: return(rob);
778: }
779: void cmoDumpCmo(struct object ob)
780: {
781: if (ob.tag == Sclass && ob.lc.ival == CMO) {
782: dumpCmoBuf((struct cmoBuffer *) ob.rc.voidp);
783: }else {
784: errorCmo("cmoDumpCmo(): Object is not CMO.");
785: }
786: }
787:
788: int Lisplike = 0;
789: /* It is for debugging. Internal use only. */
790: /* [(cmoLispLike) 1] extension can be used to turn this option on. */
791: /* debug/cmotest.sm1 test11, test12 */
792:
793: struct object cmoCmoToObject00(struct cmoBuffer *cb)
794: {
795: struct object rob;
796: struct object ob1;
797: struct object ob2;
798: int tt,ival;
799: int i,size;
800: MP_INT *mi;
801: MP_INT *mi2;
802: struct ring *oldringp;
803: char tmpc[16];
804: struct object vlist, vlist0;
805: int k;
806: int m;
807: struct object ob;
808:
809:
810: tt = cmoGetIntFromBuf(CMOGET,cb); /* read the tag */
811: /* fprintf(stderr,"CmoToObject00: tag=%d\n",tt); */
812: if (Lisplike) {
813: printf("(%s[%x],", cmotagToName(tt),tt);
814: }
815: switch (tt) {
816: case CMO_ERROR2:
817: rob = KnewErrorPacketObj(cmoCmoToObject00(cb));
818: if (Lisplike) { printObject(rob,0,stdout); }
819: break;
820: case CMO_ERROR:
821: rob = KnewErrorPacketObj(KnewErrorPacket(SerialCurrent,-1,"CMO_ERROR"));
822: break;
823: case CMO_NULL:
824: rob.tag = Snull;
825: break;
826: case CMO_INT32:
827: /* For test. */
828: ival = cmoGetIntFromBuf(CMOGET,cb);
829: rob = KpoInteger(ival);
830: if (Lisplike) { printObject(rob,0,stdout); }
831: break;
832: case CMO_STRING:
833: size = cmoGetIntFromBuf(CMOGET,cb);
834: if (Lisplike) { printf("[size=%d],",size); }
835: rob = KpoString((char *)cmoGetString(cb,size));
836: if (Lisplike) { printObject(rob,0,stdout); }
837: break;
838: case CMO_MATHCAP:
839: rob = newObjectArray(2);
840: putoa(rob,0,KpoString("mathcap-object"));
841: /* We should create Class.mathcap in a future by KpoMathCap */
842: ob1= cmoCmoToObject00(cb);
843: putoa(rob,1,ob1);
844: if (Lisplike) { printObject(rob,0,stdout); }
845: break;
846: case CMO_LIST:
847: case CMO_ARRAY:
848: size = cmoGetIntFromBuf(CMOGET,cb);
849: if (size < 0) errorCmo("cmoCmoToObject00(): size of array is negative.");
850: rob = newObjectArray(size);
851: if (Lisplike) { printf("[size=%d],",size); }
852: /* printf("size=%d\n",size); */
853: for (i=0; i<size; i++) {
854: putoa(rob,i,cmoCmoToObject00(cb));
855: /* printObject(getoa(rob,i),0,stdout); */
856: if (i==0) {
857: ob1 = getoa(rob,0);
858: if (ob1.tag == CMO+CMO_DMS) {
859: goto dmscase ;
860: }
861: }
862: }
863: break;
864: case CMO_DMS:
865: rob.tag = CMO+CMO_DMS; /* OK?? */
866: break;
867: case CMO_DISTRIBUTED_POLYNOMIAL:
868: size = cmoGetIntFromBuf(CMOGET,cb);
869: if (Lisplike) { printf("[size=]%d,",size); }
870: if (size < 0) errorCmo("cmoCmoToObject00(): CMO_DISTRIBUTED_POLYNOMIAL : negative size field.");
871: rob = newObjectArray(size);
872: /* Case for DMS. */
873: oldringp = CurrentRingp;
874: ob1 = cmoCmoToObject00(cb);
875: if (ob1.tag == Sdollar) {
876: /* Change the CurrentRingp by looking up the name. */
877: ob1 = KfindUserDictionary(KopString(ob1));
878: if (ob1.tag != Sring) {
879: errorCmo("cmoCmoToObject00(): your ring is not defined in the name space.");
880: }
881: CurrentRingp = KopRingp(ob1);
882: }
883: i = 0;
884: while (i<size) {
885: putoa(rob,i,cmoCmoToObject00(cb));
886: i++;
887: }
888: CurrentRingp = oldringp;
889: rob = cmoListToPoly2(rob);
890: break;
891:
892: case CMO_DMS_GENERIC:
893: rob.tag = Snull;
894: break;
895: case CMO_DMS_OF_N_VARIABLES:
896: rob = cmoCmoToObject00(cb); /* list structure will come. */
897: break;
898: case CMO_RING_BY_NAME:
899: rob = cmoCmoToObject00(cb); /* read the string. */
900: break;
901: case CMO_MONOMIAL32:
902: rob = KpoPOLY(cmoGetMonomial32(cb));
903: if (Lisplike) { printObject(rob,0,stdout); }
904: break;
905: case CMO_ZERO:
906: rob = KpoPOLY(POLYNULL);
907: break;
908: case CMO_ZZ_OLD:
909: case CMO_ZZ:
910: if (OxVersion >= 199907170 && tt == CMO_ZZ_OLD) {
911: errorCmo("CMO_ZZ_OLD is not implemented.");
912: }else if (OxVersion < 199907170 && tt == CMO_ZZ) {
913: errorCmo("CMO_ZZ is not implemented.");
914: }
915: mi = newMP_INT();
916: cmoGetGMPCoeff(mi, cb);
917: rob.tag = SuniversalNumber;
918: rob.lc.universalNumber = mpintToCoeff(mi,SmallRingp);
919: if (Lisplike) { printObject(rob,0,stdout); }
920: break;
921: case CMO_QQ:
922: mi = newMP_INT();
923: cmoGetGMPCoeff(mi, cb);
924: mi2 = newMP_INT();
925: cmoGetGMPCoeff(mi2, cb);
926: ob1.tag = SuniversalNumber;
927: ob1.lc.universalNumber = mpintToCoeff(mi,SmallRingp);
928: ob2.tag = SuniversalNumber;
929: ob2.lc.universalNumber = mpintToCoeff(mi2,SmallRingp);
930: rob = KooDiv2(ob1,ob2);
931: if (Lisplike) { printObject(rob,0,stdout); }
932: break;
933: case CMO_64BIT_MACHINE_DOUBLE:
934: for (i=0; i<8; i++) {
935: tmpc[i] = cmoGetIntFromBuf(CMOGETBYTE, cb);
936: }
937: rob = KpoDouble(*((double *)tmpc));
938: if (Lisplike) { printObject(rob,0,stdout); }
939: break;
940: case CMO_INDETERMINATE:
941: /* Old code. rob = KpoIndeterminate(cmoCmoToObject00(cb)); */
942: /* If you need to change the names of indeterminates,
943: do it here. */
944: if (CmoClientMode) {
945: rob = KpoIndeterminate(cmoCmoToObject00(cb));
946: }else{
947: rob = KpoIndeterminate(cmoTranslateVariable_inComming(cmoCmoToObject00(cb)));
948: }
949: break;
950: case CMO_RECURSIVE_POLYNOMIAL:
951: vlist0 = cmoCmoToObject00(cb); /* list of variables by indeterminates. */
952: vlist = newObjectArray(getoaSize(vlist0));
953: for (i=0; i<getoaSize(vlist0); i++) {
954: ob1 = getoa(vlist0,i);
955: if (ectag(ob1) == CLASSNAME_indeterminate) {
956: ob1 = KopIndeterminate(ob1);
957: }
958: putoa(vlist,i,ob1);
959: }
960: /* vlist is a list of variables by strings. */
961:
962: rob = newObjectArray(2);
963: putoa(rob,0,vlist);
964: putoa(rob,1,cmoCmoToObject00(cb));
965: rob = KpoRecursivePolynomial(rob);
966: if (!isRecursivePolynomial2(rob)) {
967: errorCmo("cmoCmoToObject00(): invalid format of recursive polynomial. Return null.");
968: rob.tag = Snull;
969: }
970: break;
971: case CMO_POLYNOMIAL_IN_ONE_VARIABLE:
972: m = cmoGetIntFromBuf(CMOGET,cb);
973: if (Lisplike) { printf("[numberOfMonomials=%d],",m); }
974: if (m < 0) {
975: errorCmo("cmoCmoToObject00(): invalid size of polynomial in one variable.");
976: rob.tag = Snull;
977: break;
978: }
979: rob = newObjectArray(2*m+1);
980: /* ob1 = cmoCmoToObject00(cb);
981: putoa(rob,0,ob1); name of the variable */
982: i = cmoGetIntFromBuf(CMOGET,cb);
983: putoa(rob,0,KpoInteger(i));
984: if (Lisplike) { printf("[the main variable=]%d,",i); }
985: for (i=1; i< 2*m+1; i = i+2) {
986: k = cmoGetIntFromBuf(CMOGET,cb); /* exponent */
987: if (Lisplike) { printf("[exponent=]%d,",k); }
988: putoa(rob,i,KpoInteger(k));
989: ob2 = cmoCmoToObject00(cb); putoa(rob,i+1,ob2);
990: }
991: rob = KpoPolynomialInOneVariable(rob);
992: break;
993: case CMO_TREE:
994: ob1 = cmoCmoToObject00(cb);
995: ob2 = cmoCmoToObject00(cb);
996: rob = newObjectArray(3);
997: putoa(rob,0,ob1);
998: putoa(rob,1,ob2);
999: putoa(rob,2,cmoCmoToObject00(cb));
1000: if (getoaSize(rob) != 3) {
1001: warningCmo("CMO_TREE : the object is not an array of the length 3.");
1002: }else{
1003: ob1 = getoa(rob,0);
1004: if (ob1.tag != Sdollar) warningCmo("CMO_TREE : the first arg must be the node name by a string.");
1005: ob2 = getoa(rob,1); /* content dictionary name. */
1006: if (ob2.tag != Sdollar) warningCmo("CMO_TREE : the second arg must be the node name by a string.");
1007: rob = KpoTree(rob);
1008: }
1009: break;
1010: case CMO_RATIONAL:
1011: ob1 = cmoCmoToObject00(cb);
1012: ob2 = cmoCmoToObject00(cb);
1013: rob = KooDiv2(ob1,ob2);
1014: if (Lisplike) { printObject(rob,0,stdout); }
1015: break;
1016: defaut:
1017: fprintf(stderr,"tag=%d (%x) ",tt,tt);
1018: errorCmo("cmoCmoToObject00(): unknown CMO tag. returns null object.");
1019: rob.tag = Snull;
1020: break;
1021: }
1022: if (Lisplike) { printf("),"); fflush(stdout); }
1023: return(rob);
1024:
1025: dmscase: ;
1026: /* Case for DMS. */
1027: oldringp = CurrentRingp;
1028: i = 1;
1029: if (i >= size) errorCmo("cmoCmoToObject00(): DMS, ring-def, ...");
1030: putoa(rob,i,cmoCmoToObject00(cb));
1031: ob1 = getoa(rob,1);
1032: if (ob1.tag == Sdollar) {
1033: /* Change the CurrentRingp by looking up the name. */
1034: ob1 = KfindUserDictionary(KopString(ob1));
1035: if (ob1.tag != Sring) {
1036: errorCmo("cmoCmoToObject00(): your ring is not defined in the name space.");
1037: }
1038: CurrentRingp = KopRingp(ob1);
1039: }
1040: i = 2;
1041: while (i<size) {
1042: putoa(rob,i,cmoCmoToObject00(cb));
1043: i++;
1044: }
1045: CurrentRingp = oldringp;
1046: if (Lisplike) { printf("),"); fflush(stdout); }
1047: return(rob);
1048: }
1049:
1050: struct object cmoCmoToObject(struct object ob)
1051: {
1052: struct object rob;
1053: struct object ob0;
1054: struct cmoBuffer *cb;
1055: if (!(ob.tag == Sclass && ob.lc.ival == CMO)) {
1056: rob.tag = Snull;
1057: errorCmo("cmoCmoToObject(): the argument is not CMO.");
1058: return(rob);
1059: }
1060: cb = (struct cmoBuffer *) ob.rc.voidp;
1061: cmoGetIntFromBuf(CMOINIT,cb);
1062: if (cb->pos == 0) {
1063: /* null */
1064: rob.tag = Snull;
1065: return(rob);
1066: }
1067: rob = cmoCmoToObject00(cb);
1068: rob = cmoListToPoly(rob);
1069: if (DebugCMO) {
1070: fprintf(stderr,"cmoCmoToObject: ");
1071: printObject(rob,1,stderr);
1072: }
1073: return(rob);
1074: }
1075:
1076: struct object cmoListToPoly(struct object ob) {
1077: struct object ob0;
1078: struct object rob;
1079: int i,n;
1080: if (ob.tag == Sarray) {
1081: n = getoaSize(ob);
1082: if (n >= 1) {
1083: ob0 = getoa(ob,0);
1084: if (ob0.tag == CMO+CMO_DMS) {
1085: rob = KpoPOLY(cmoListToPOLY(ob)); /* not ToPoly, ToPOLY */
1086: }else{
1087: rob = newObjectArray(n);
1088: for (i=0; i<n; i++) {
1089: putoa(rob,i,cmoListToPoly(getoa(ob,i)));
1090: }
1091: }
1092: }else{
1093: rob = ob;
1094: }
1095: }else{
1096: rob = ob;
1097: }
1098: return(rob);
1099: }
1100:
1101: struct object cmoListToPoly2(struct object ob)
1102: {
1103: int size,i;
1104: struct object ob0,ob1;
1105: POLY f;
1106: /*
1107: printf("<<");printObject(ob,0,stdout); printf(">>\n"); fflush(stdout);
1108: */
1109: if (ob.tag != Sarray) {
1110: errorCmo("cmoListToPoly2(): the argument must be array.");
1111: }
1112: size = getoaSize(ob);
1113: f = POLYNULL;
1114: for (i=size-1; i>=0; i--) {
1115: ob1 = getoa(ob,i);
1116: if (ob1.tag == Spoly) {
1117: f = ppAdd(f,KopPOLY(ob1));
1118: }else{
1119: errorCmo("cmoListToPoly2(): format error.");
1120: }
1121: }
1122: return(KpoPOLY(f));
1123: }
1124:
1125: /*
1126: main() {
1127: int i;
1128: struct cmoBuffer *cb;
1129: printf("%d\n",sizeof(long int));
1130: for (i=0; i<300; i++) {
1131: cmoOutInt32(i);
1132: }
1133: dumpCmoBuf(cb=cmoOutputToBuf(CMOFLUSH,NULL,0));
1134: cmoGetIntFromBuf(CMOINIT,cb);
1135: for (i=0; i<300; i++) {
1136: printf("%5d",cmoGetIntFromBuf(CMOGET,cb));
1137: }
1138: putchar('\n');
1139: }
1140: */
1141:
1142: POLY cmoListToPOLY(struct object ob)
1143: {
1144: int size,i;
1145: struct object ob0,ob1;
1146: POLY f;
1147: /*
1148: printf("<<");printObject(ob,0,stdout); printf(">>\n"); fflush(stdout);
1149: */
1150: if (ob.tag != Sarray) {
1151: errorCmo("cmoListToPOLY(): the argument must be array.");
1152: }
1153: size = getoaSize(ob);
1154: if (size < 2) {
1155: errorCmo("cmoListToPOLY(): the first element of the array must be CMO-tag.");
1156: errorCmo("cmoListToPOLY(): the second element must be the ring definition.");
1157: }
1158: ob0 = getoa(ob,0);
1159: ob1 = getoa(ob,1); /* ring defintion. It is not used for now. */
1160: /* printObject(ob1,0,stdout); */
1161: switch(ob0.tag) {
1162: case (CMO+CMO_DMS):
1163: f = POLYNULL;
1164: for (i=size-1; i>=2; i--) {
1165: ob1 = getoa(ob,i);
1166: if (ob1.tag == Spoly) {
1167: f = ppAdd(f,KopPOLY(ob1));
1168: }else{
1169: f = ppAdd(f,cmoListToPOLY(ob1));
1170: }
1171: }
1172: return(f);
1173: break;
1174: default:
1175: errorCmo("cmoListToPoly(): unknown tag.");
1176: break;
1177: }
1178: }
1179:
1180:
1181: int Kan_PushBinary(int size,void *data)
1182: {
1183: struct cmoBuffer cb;
1184: struct object ob;
1185: cb.pos = size;
1186: cb.rpos = 0;
1187: cb.buf = data;
1188: cb.size = size;
1189: ob.tag = Sclass; ob.lc.ival = CMO;
1190: ob.rc.voidp = &cb;
1191: KSpush(cmoCmoToObject(ob));
1192: return(0);
1193: }
1194:
1195: void *Kan_PopBinary(int *sizep)
1196: {
1197: struct object ob;
1198: struct cmoBuffer *cb;
1199: ob = KSpop();
1200: ob = cmoObjectToCmo(ob);
1201: if (ob.tag == Sclass && ob.lc.ival == CMO) {
1202: cb = (struct cmoBuffer *) (ob.rc.voidp);
1203: *sizep = cb->pos;
1204: return(cb->buf);
1205: }
1206: return(NULL);
1207: }
1208:
1209:
1210:
1211:
1212:
1213: struct object cmoObjectFromStream(struct object obStream)
1214: {
1215: struct cmoBuffer cb;
1216: struct object rob;
1217: extern DebugCMO;
1218: if (obStream.tag != Sfile) {
1219: errorCmo("cmoObjectFromStream: Argument must be of type file.");
1220: }
1221: if (strcmp(obStream.lc.str,MAGIC2) != 0) {
1222: errorCmo("cmoObjectFromStream: Argument must be of type plugin/file2 buffered IO.");
1223: }
1224: rob = cmoObjectFromStream2((FILE2 *)obStream.rc.voidp);
1225: if (DebugCMO >= 2) {
1226: fprintf(stderr,"cmoObjectFromStream: ");
1227: printObject(rob,1,stderr);
1228: }
1229: return(rob);
1230: }
1231: struct object cmoObjectFromStream2(FILE2 *fp2)
1232: {
1233: struct cmoBuffer cb;
1234: struct object rob;
1235: cb.isStream=1; cb.fp = fp2;
1236: cmoGetIntFromBuf(CMOINITSTREAM,&cb);
1237: rob = cmoCmoToObject00(&cb);
1238: rob = cmoListToPoly(rob);
1239: if (cb.errorno) errorCmo("at cmoObjectFromStream2");
1240: if (DebugCMO) {
1241: fprintf(stderr,"cmoObjectFromStream2: ");
1242: printObject(rob,1,stderr);
1243: }
1244: return(rob);
1245: }
1246:
1247: struct object cmoObjectToStream(struct object ob, struct object obStream)
1248: {
1249: struct object rob;
1250: extern int DebugCMO;
1251: if (obStream.tag != Sfile) {
1252: errorCmo("cmoObjectToStream: Argument must be of type file.");
1253: }
1254: if (strcmp(obStream.lc.str,MAGIC2) != 0) {
1255: errorCmo("cmoObjectToStream: Argument must be of type plugin/file2 buffered IO.");
1256: }
1257: if (DebugCMO >= 2) {
1258: fprintf(stderr,"cmoObjectToStream: ");
1259: printObject(ob,1,stderr);
1260: }
1261: return(cmoObjectToStream2(ob,(FILE2 *)obStream.rc.voidp));
1262: }
1263:
1264: struct object cmoObjectToStream2(struct object ob, FILE2 *fp2)
1265: {
1266: struct object rob;
1267: cmoOutputToBuf(CMOINITSTREAM,(void *)fp2,0);
1268: if (DebugCMO) {
1269: fprintf(stderr,"cmoObjectToStream2: ");
1270: printObject(ob,1,stderr);
1271: }
1272: cmoObjectToCmo00(ob);
1273: fp2fflush(fp2);
1274: rob = KpoInteger(0);
1275: return(rob);
1276: }
1277:
1278: int Kan_pushCMOFromStream(FILE2 *fp)
1279: {
1280: struct object ob;
1281: struct object rob;
1282: ob.tag = Sfile; ob.rc.voidp = (void *)fp; ob.lc.str = MAGIC2;
1283: rob = cmoObjectFromStream(ob);
1284: KSpush(rob);
1285: return(0);
1286: }
1287:
1288: int Kan_popCMOToStream(FILE2 *fp,int serial)
1289: {
1290: struct object ob;
1291: struct object sob;
1292: sob.tag = Sfile; sob.rc.file = (void *)fp; sob.lc.str = MAGIC2;
1293: ob = Kpop();
1294: /*outfp2(fp);*/ /* outfp2 is for debugging. see develop/97feb.. 1999, 1/19*/
1295: if (!cmoCheckMathCap(ob, (struct object *)(fp->mathcapList))) {
1296: fprintf(stderr,"%s\n","Protection by mathcap. You cannot send this object to your peer.");
1297: ob = KnewErrorPacket(serial,-1,"cmoObjectToStream: protection by mathcap");
1298: cmoObjectToStream(ob,sob);
1299: return(-1);
1300: }
1301: cmoObjectToStream(ob,sob);
1302: return(0);
1303: }
1304:
1305: int Kan_setMathCapToStream(FILE2 *fp,struct object ob) {
1306: struct object *obp;
1307: obp = (struct object *)sGC_malloc(sizeof(struct object));
1308: *obp = ob;
1309: fp->mathcapList = (void *)obp;
1310: }
1311:
1312: /* It is declared in oxmisc2.h, too. */
1313: struct object newMathCap(struct mathCap *mathcap){
1314: struct object rob;
1315: struct object ob1;
1316: struct object ob2;
1317: struct object ob3;
1318: struct object obOx;
1319: struct object obSm;
1320: struct object *obp;
1321: int i;
1322: struct object mathinfo;
1323:
1324: rob = newObjectArray(3);
1325:
1326: mathinfo = *((struct object *) (mathcap->infop));
1327: ob1 = newObjectArray(getoaSize(mathinfo));
1328: for (i=0; i<getoaSize(mathinfo); i++) {
1329: putoa(ob1,i,getoa(mathinfo,i));
1330: }
1331: ob2 = newObjectArray(mathcap->n);
1332: for (i=0; i<mathcap->n; i++) {
1333: putoa(ob2,i,KpoInteger((mathcap->cmo)[i]));
1334: }
1335: obOx = newObjectArray(mathcap->oxSize);
1336: for (i=0; i<mathcap->oxSize; i++) {
1337: putoa(obOx,i,KpoInteger((mathcap->ox)[i]));
1338: }
1339: ob3 = newObjectArray(2);
1340: putoa(ob3,0,obOx);
1341: putoa(ob3,1,ob2);
1342:
1343: obSm = newObjectArray(mathcap->smSize);
1344: for (i=0; i<mathcap->smSize; i++) {
1345: putoa(obSm,i,KpoInteger((mathcap->sm)[i]));
1346: }
1347: putoa(rob,0,ob1); /* Version , name etc */
1348: putoa(rob,1,obSm); /* SM tags */
1349: putoa(rob,2,ob3); /* OX_DATA format, cmo types. */
1350: obp = (struct object *)sGC_malloc(sizeof(struct object));
1351: *obp = rob;
1352: return( KpoMathCap(obp) );
1353: }
1354:
1355: struct object KSmathCap(void)
1356: {
1357: struct mathCap *mathcap;
1358: mathcap = KSmathCapByStruct();
1359: return(newMathCap(mathcap));
1360: }
1361:
1362: void *KSmathCapByStruct(void)
1363: /* Return the math cap of kan/sm1 with cmo.c as a mathcap classObject*/
1364: {
1365: struct mathCap *mathcap;
1366: struct object ob;
1367: char *s1,*s2;
1368: struct object *mathinfo;
1369: char *sys;
1370: char *sysVersion;
1371: extern char *OxSystem; /* Example : ox_sm1.plain */
1372: extern char *OxSystemVersion; /* Example : 0.1 */
1373: mathcap = (struct mathCap *)sGC_malloc(sizeof(struct mathCap));
1374: mathinfo = sGC_malloc(sizeof(struct object));
1375:
1376: sys = (char *) sGC_malloc(sizeof(char)*(strlen(OxSystem)+strlen("Ox_system=")+2));
1377: strcpy(sys,"Ox_system="); strcat(sys,OxSystem);
1378: sysVersion =
1379: (char *) sGC_malloc(sizeof(char)*(strlen(OxSystemVersion)+strlen("Version=")+2));
1380: strcpy(sysVersion,"Version="); strcat(sysVersion,OxSystemVersion);
1381:
1382: ob = newObjectArray(4);
1383: putoa(ob,0,KpoInteger(OxVersion)); /* Open XM protocol Version */
1384: /* The rest entries must be strings. See oxmisc2.c oxSendMathcap */
1385: putoa(ob,1,KpoString(sys));
1386: putoa(ob,2,KpoString(sysVersion));
1387: s1 = getenv("HOSTTYPE");
1388: s2 = (char *)sGC_malloc(strlen(s1)+2+strlen("HOSTTYPE="));
1389: strcpy(s2,"HOSTTYPE=");
1390: strcat(s2,s1);
1391: putoa(ob,3,KpoString(s2));
1392:
1393: *mathinfo = ob;
1394: mathcap->infop = (void *) mathinfo;
1395:
1396: mathcap->cmo[0] = CMO_ERROR2;
1397: mathcap->cmo[1] = CMO_NULL;
1398: mathcap->cmo[2] = CMO_INT32;
1399: mathcap->cmo[3] = CMO_STRING;
1400: mathcap->cmo[4] = CMO_MATHCAP;
1401: mathcap->cmo[5] = CMO_LIST;
1402: mathcap->cmo[6] = CMO_MONOMIAL32;
1403: if (OxVersion >= 199907170) {
1404: mathcap->cmo[7] = CMO_ZZ;
1405: }else{
1406: mathcap->cmo[7] = CMO_ZZ_OLD;
1407: }
1408: mathcap->cmo[8] = CMO_ZERO;
1409: mathcap->cmo[9] = CMO_DMS;
1410: mathcap->cmo[10] = CMO_DMS_GENERIC;
1411: mathcap->cmo[11]= CMO_DMS_OF_N_VARIABLES;
1412: mathcap->cmo[12]= CMO_RING_BY_NAME;
1413: mathcap->cmo[13]= CMO_INT32COEFF;
1414: mathcap->cmo[14]= CMO_DISTRIBUTED_POLYNOMIAL;
1415: mathcap->cmo[15]= CMO_INDETERMINATE;
1416: mathcap->cmo[16]= CMO_TREE;
1417: mathcap->cmo[17]= CMO_RECURSIVE_POLYNOMIAL;
1418: mathcap->cmo[18]= CMO_POLYNOMIAL_IN_ONE_VARIABLE;
1419: mathcap->cmo[19]= CMO_64BIT_MACHINE_DOUBLE;
1420: mathcap->cmo[20]= CMO_ARRAY;
1421: mathcap->cmo[21]= CMO_RATIONAL;
1422:
1423: mathcap->n = 22 ; /* This is the number of cmo object. You can use
1424: cmo upto 1023. see mathcap.h */
1425:
1426: mathcap->ox[0] = OX_DATA;
1427: mathcap->oxSize = 1 ; /* This is the number of OX object. You can use
1428: OX upto 1023. see mathcap.h */
1429:
1430: mathcap->sm[0] = SM_popCMO;
1431: mathcap->sm[1] = SM_popString;
1432: mathcap->sm[2] = SM_mathcap;
1433: mathcap->sm[3] = SM_pops;
1434: mathcap->sm[4] = SM_setName;
1435: mathcap->sm[5] = SM_executeStringByLocalParser;
1436: mathcap->sm[6] = SM_executeFunction;
1437: mathcap->sm[7] = SM_shutdown;
1438: mathcap->sm[8] = SM_setMathCap;
1439: mathcap->sm[9] = SM_getsp;
1440: mathcap->sm[10] = SM_dupErrors;
1441: mathcap->smSize = 11;
1442:
1443: return((void *)mathcap);
1444: }
1445:
1446: int cmoOutRawInt(int k)
1447: {
1448: cmoint tmp[1];
1449: tmp[0] = htonl((cmoint ) k);
1450: cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));
1451: }
1452:
1453: warningCmo(char *s) {
1454: fprintf(stderr,"Warning: plugin/cmo.c : %s\n",s);
1455: }
1456:
1457: errorCmo(char *s) {
1458: fprintf(stderr,"plugin/cmo.c : %s\n",s);
1459: errorKan1("%s\n","cmo fatal error. ox servers need SM_control_reset_connection.");
1460: /* ErrorPacket is automatically push on the ErrorStack.
1461: cf. var.sm1, [(ErrorStack)] system_variable */
1462: /* KSexecuteString(" error "); */
1463: }
1464:
1465: /* for dubugging. Should be comment out later. */
1466: int outfp2(FILE2 *fp2) {
1467: int i;
1468: printf("--------- outfp2 ---------\n"); fflush(stdout);
1469: /* if (checkfp2(fp2," f2pdumpBuf ") == -1) {
1470: return(-1);
1471: }*/
1472: printf("fd=%d\n",fp2->fd);
1473: printf("initialied=%d\n",fp2->initialized);
1474: printf("readpos=%d\n",fp2->readpos);
1475: printf("readsize=%d\n",fp2->readsize);
1476: printf("writepos=%d\n",fp2->writepos);
1477: printf("limit=%d\n",fp2->limit);
1478: for (i=0; i<fp2->readsize; i++) {
1479: printf("readBuf[%d]=%2x ",i,fp2->readBuf[i]);
1480: }
1481: for (i=0; i<fp2->writepos; i++) {
1482: printf("writeBuf[%d]=%2x ",i,fp2->writeBuf[i]);
1483: }
1484: printf("\n");
1485: printObject(*( (struct object *)fp2->mathcapList),0,stdout);
1486: printf("\n");
1487: return(0);
1488: }
1489:
1490: static char *translateReservedName(char *s) {
1491: /* We do not translate h and q */
1492: if (strcmp(s,"e_") == 0) { /* Should read the @@@E.symbol value */
1493: return("#65_");
1494: }else if (strcmp(s,"E") == 0) {
1495: return("#45");
1496: }else if (strcmp(s,"H") == 0) {
1497: return("#48");
1498: }else if (strcmp(s,"PAD")==0) {
1499: return("#4FAD");
1500: }else {
1501: return(NULL);
1502: }
1503: }
1504:
1505: struct object cmoTranslateVariable_inComming(struct object ob) {
1506: /* ob must be Sdollar, return value must be Sdollar. */
1507: /* Read a variable name from an other system,
1508: and translate the variable name into
1509: a suitable sm1 variable name. */
1510: char *s;
1511: char *t;
1512: int n, i, count;
1513: if (ob.tag != Sdollar) errorCmo("cmoTranslateVariable_inComming: the argument must be a string.");
1514: s = KopString(ob);
1515: t = translateReservedName(s);
1516: if (t != NULL) {
1517: if (Lisplike) printf("[%s==>%s]",s,t);
1518: return(KpoString(t));
1519: }
1520:
1521: n = strlen(s);
1522: for (i=count=0; i<n; i++,count++) {
1523: if (s[i] <= ' ' || s[i] == '#') {
1524: count += 2;
1525: }
1526: }
1527: if (n != count) {
1528: t = (char *) sGC_malloc(sizeof(char)*(count+2));
1529: if (t == NULL) errorCmo("No more memory.");
1530: for (i=count=0; i<n; i++) {
1531: if (s[i] <= ' ' || s[i] == '#') {
1532: t[count++] = '#';
1533: t[count++] = (s[i]/16 < 10? s[i]/16+'0': (s[i]/16-10)+'A');
1534: t[count++] = (s[i]%16 < 10? s[i]%16+'0': (s[i]%16-10)+'A');
1535: }else{
1536: t[count++] = s[i];
1537: }
1538: }
1539: t[count] = '\0';
1540: }else{
1541: t = s;
1542: }
1543: if (Lisplike) {
1544: printf("[%s==>%s]",s,t);
1545: }
1546: return(KpoString(t));
1547: }
1548:
1549: #define isHex_cmo(a) ((a >= '0' && a <='9') || (a>='A' && a <='F')?1:0)
1550: #define hexnum_cmo(a) (a>='A' && a <='F'? a-'A'+10 : a-'0')
1551: struct object cmoTranslateVariable_outGoing(struct object ob) {
1552: /* ob must be Sdollar, return value must be Sdollar. */
1553: char *s, *t;
1554: int i,j,n;
1555: int p;
1556: if (ob.tag != Sdollar) errorCmo("cmoTranslateVariable_inComming: the argument must be a string.");
1557: s = KopString(ob);
1558: n = strlen(s);
1559: for (i=0; i<n; i++) {
1560: if (i < n-2 && s[i] == '#' && isHex_cmo(s[i+1]) && isHex_cmo(s[i+2])) {
1561: t = (char *) sGC_malloc(sizeof(char)*(n+2));
1562: if (t == NULL) errorCmo("No more memory.");
1563: break;
1564: }
1565: if (i== n-1) {
1566: return(KpoString(s));
1567: }
1568: }
1569: for (i=j=0; i<n; i++) {
1570: if (i < n-2 && s[i] == '#' && isHex_cmo(s[i+1]) && isHex_cmo(s[i+2])) {
1571: p = (hexnum_cmo(s[i+1]))*16+hexnum_cmo(s[i+2]);
1572: t[j++] = p; i += 2;
1573: }else{
1574: t[j++] = s[i];
1575: }
1576: }
1577: t[j] = '\0';
1578: if (Lisplike) {
1579: printf("[%s-->%s]",s,t);
1580: }
1581: return(KpoString(t));
1582: }
1583:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cmo.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / plugin