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