OpenXM/src/kan96xx/plugin/cmo.c - diff

Return to cmo.c CVS log

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

Diff for /OpenXM/src/kan96xx/plugin/cmo.c between version 1.3 and 1.11

version 1.3, 1999/11/18 23:57:19

version 1.11, 2004/03/08 08:24:42

Line 1

/*$OpenXM$*/

/*$OpenXM: OpenXM/src/kan96xx/plugin/cmo.c,v 1.10 2003/12/06 02:35:54 takayama Exp $*/

#include <stdio.h>

#include <string.h>

/* #include <netinet/in.h> */

Line 16

#include "cmo.h"

#include "cmotag.htmp" /* static char *cmotagToName(int tag) is defined

here. */

extern int OxVersion;

int CmoClientMode = 1; /* This flag is used to translate names for

indeterminates.

It does not work well if ox_sm1 have a server, i.e.,

sm1 --> ox_sm1 --> ox_sm1

/* void *malloc(int s);

#define GC_malloc(x) malloc(x) */

Line 37 int CmoClientMode = 1; /* This flag is used to transl

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

/* If you change the format of mathcap, do the follows.

Mofify cmoCheckMathCap in oxmisc2.c,

oxReq, SM_setMathCap:, and

oxSendMathCap in oxmisc.c,

newMathCap in cmo.c,

oxReq, SM_setMathCap: in oxmisc2.c, and

grep mathCap and make all modifications.

Line 87 struct cmoBuffer *cmoOutputToBuf(cmoAction a,void *dat

Line 89 struct cmoBuffer *cmoOutputToBuf(cmoAction a,void *dat

break;

case CMOPUT:

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

fp2fputc((int) ((char *)data)[i], b.fp);

}

break;

case CMOFLUSH:

if (fp2fflush(b.fp)<0) {

errorCmo("cmoOutputToBuf: CMOFLUSH failed in stream mode.");

}

cb = (struct cmoBuffer *)sGC_malloc(sizeof(struct cmoBuffer));

cb->isStream = b.isStream;

Line 126 struct cmoBuffer *cmoOutputToBuf(cmoAction a,void *dat

Line 128 struct cmoBuffer *cmoOutputToBuf(cmoAction a,void *dat

break;

case CMOPUT:

if (b.pos + size >= b.size) {

tmp = sGC_malloc((b.size)*2+size);

memcpy(tmp,b.buf,b.pos);

b.buf = tmp;

b.size = (b.size)*2+size;

}

memcpy((void *) &(((char *)(b.buf))[b.pos]),data,size);

b.pos += size;

Line 375 int cmoOutRingDefinition(struct ring *rp,int option)

Line 377 int cmoOutRingDefinition(struct ring *rp,int option)

cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint)*3);

cmoOutInt32((rp->n)*2); /* number of variables */

cmoOutInt32(rp->p); /* coefficient field.

CMO_INT32 or CMO_DMS_OF_N_VARIABLES */

/* Optional arguments are name of variables, weight_vector, output_order */

break;

default: /* including 0. */

Line 401 int cmoOutRingDefinition2(struct ring *rp,int option)

Line 403 int cmoOutRingDefinition2(struct ring *rp,int option)

cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint)*3);

cmoOutInt32((rp->n)*2); /* number of variables */

cmoOutInt32(rp->p); /* coefficient field.

CMO_INT32 or CMO_DMS_OF_N_VARIABLES */

/* Optional arguments are list of indeterminates (name of variables),

weight_vector by list , output_order by list. */

break;

Line 423 int cmoGetIntFromBuf(cmoAction a,struct cmoBuffer *cb)

Line 425 int cmoGetIntFromBuf(cmoAction a,struct cmoBuffer *cb)

switch(a) {

case CMOGET:

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

cc = fp2fgetc(cb->fp);

if (cc < 0) {

return(-1);

errorCmo("cmoGetIntFromBuf CMOGET: unexpected EOF.\n");

}

data[i] = cc;

}

return( (int) ntohl( *((cmoint *) data) ));

break;

case CMOGETBYTE:

cc = fp2fgetc(cb->fp);

if (cc < 0) {

return(-1);

errorCmo("cmoGetIntFromBuf CMOGETBYTE: unexpected EOF.\n");

}

return(cc);

break;

Line 460 int cmoGetIntFromBuf(cmoAction a,struct cmoBuffer *cb)

Line 462 int cmoGetIntFromBuf(cmoAction a,struct cmoBuffer *cb)

switch(a) {

case CMOGET:

if (cb->rpos + sizeof(cmoint) > cb->pos) {

fprintf(stderr,"No more data in the buffer. Returns -1.\n");

return(-1);

}

memcpy(tmp,(void *) &(((char *)(cb->buf))[cb->rpos]),

sizeof(cmoint));

cb->rpos += sizeof(cmoint);

return( (int) ntohl(tmp[0]));

break;

case CMOGETBYTE:

if (cb->rpos + 1 > cb->pos) {

fprintf(stderr,"No more data in the buffer. Returns -1.\n");

return(-1);

}

tmp[0] = ((unsigned char *)(cb->buf))[cb->rpos];

cb->rpos += 1;

Line 542 POLY cmoGetMonomial32(struct cmoBuffer *cb)

Line 544 POLY cmoGetMonomial32(struct cmoBuffer *cb)

warningCmo("cmoGetMonomials32(): Changed the current ring, because your peer sent a DMS that does not fit to the current ring.");

/* original code.

skip = nn - (CurrentRingp->n)*2;

nn1 = nn0 = CurrentRingp->n;

if (! (cb->errorno) ) {

warningCmo("cmoGetMonomial32(): serialized polynomial \\not\\in CurrentRing.");

}

cmoGetIntFromBuf(CMOERROR,cb);

}

if (nn == (CurrentRingp->n)*2 ) {

Line 658 void cmoObjectToCmo00(struct object ob)

Line 660 void cmoObjectToCmo00(struct object ob)

case SuniversalNumber:

cmoOutGMPCoeff(ob.lc.universalNumber->val.bigp);

break;

case SrationalFunction:

tmp[0] = htonl(CMO_RATIONAL);

cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));

cmoObjectToCmo00(*(Knumerator(ob)));

cmoObjectToCmo00(*(Kdenominator(ob)));

break;

case Sdouble:

if (sizeof(double) != 8) errorCmo("double is assumed to be 8 bytes.");

cmoOutRawInt(CMO_64BIT_MACHINE_DOUBLE);

Line 669 void cmoObjectToCmo00(struct object ob)

Line 677 void cmoObjectToCmo00(struct object ob)

case CLASSNAME_ERROR_PACKET:

/* fprintf(stderr,"ectag=%d\n",ectag(*KopErrorPacket(ob))); **kxx:CMO_ERROR*/

if (ectag(*KopErrorPacket(ob)) == CLASSNAME_ERROR_PACKET) {

tmp[0] = htonl(CMO_ERROR);

cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));

}else{

tmp[0] = htonl(CMO_ERROR2);

cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));

/* Send without OX_DATA header !! */

cmoObjectToCmo00(*(KopErrorPacket(ob)));

}

break;

case CLASSNAME_mathcap:

Line 690 void cmoObjectToCmo00(struct object ob)

Line 698 void cmoObjectToCmo00(struct object ob)

/* cmoObjectToCmo00(KopIndeterminate(ob)); Old code. */

/* If you need to translate the name, do it here. */

if (CmoClientMode) {

ob = KopIndeterminate(ob);

}else{

ob = cmoTranslateVariable_outGoing(KopIndeterminate(ob));

}

cmoObjectToCmo00(ob);

break;

case CLASSNAME_recursivePolynomial:

/* We assume that the format of the recursive polynomial

is OK. */

tmp[0] = htonl(CMO_RECURSIVE_POLYNOMIAL);

cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));

ob = KopRecursivePolynomial(ob);

vlist = getoa(ob,0);

vlist0 = newObjectArray(getoaSize(vlist));

for (i=0; i<getoaSize(vlist); i++) {

if (CmoClientMode) {

if (getoa(vlist,i).tag == Sdollar) {

putoa(vlist0,i,

if (CmoClientMode) {

KpoIndeterminate(getoa(vlist,i)));

putoa(vlist0,i,

}else{

KpoIndeterminate(getoa(vlist,i)));

putoa(vlist0,i,

}else{

KpoIndeterminate(cmoTranslateVariable_outGoing(getoa(vlist,i))));

putoa(vlist0,i,

}

KpoIndeterminate(cmoTranslateVariable_outGoing(getoa(vlist,i))));

}

}else{

putoa(vlist0,i,getoa(vlist,i));

}

cmoObjectToCmo00(vlist0); /* output the list of variables. */

cmoObjectToCmo00(getoa(ob,1)); /* output the body of the recursive poly

polynomial in one variable or any object*/

break;

case CLASSNAME_polynomialInOneVariable:

tmp[0] = htonl(CMO_POLYNOMIAL_IN_ONE_VARIABLE);

cmoOutputToBuf(CMOPUT,tmp,sizeof(cmoint));

ob = KopPolynomialInOneVariable(ob);

if (ob.tag != Sarray) {

cmoObjectToCmo00(ob);

}else{

/* We do not check the format. */

m = (getoaSize(ob)-1)/2; /* the number of monomials */

cmoOutRawInt(m);

ob2 = getoa(ob,0); /* the variable name by integer. */

if (ob2.tag != Sinteger) {

warningCmo("cmoObjectToCmo00(): polynomial in one variable: this field should be integer. Output 0");

/* cmoOutInt32(0); */

cmoOutRawInt(0);

}else{

/* cmoObjectToCmo00(ob2); */

cmoOutRawInt(KopInteger(ob2));

}

for (i=1; i<getoaSize(ob); i = i+2) {

cmoOutRawInt(KopInteger(getoa(ob,i))); /* exponent */

cmoObjectToCmo00(getoa(ob,i+1)); /* coefficient */

}

break;

case CLASSNAME_tree:

Line 855 struct object cmoCmoToObject00(struct cmoBuffer *cb)

Line 867 struct object cmoCmoToObject00(struct cmoBuffer *cb)

putoa(rob,i,cmoCmoToObject00(cb));

/* printObject(getoa(rob,i),0,stdout); */

if (i==0) {

ob1 = getoa(rob,0);

if (ob1.tag == CMO+CMO_DMS) {

goto dmscase ;

}

break;

Line 877 struct object cmoCmoToObject00(struct cmoBuffer *cb)

Line 889 struct object cmoCmoToObject00(struct cmoBuffer *cb)

/* Change the CurrentRingp by looking up the name. */

ob1 = KfindUserDictionary(KopString(ob1));

if (ob1.tag != Sring) {

errorCmo("cmoCmoToObject00(): your ring is not defined in the name space.");

}

CurrentRingp = KopRingp(ob1);

}

Line 954 struct object cmoCmoToObject00(struct cmoBuffer *cb)

Line 966 struct object cmoCmoToObject00(struct cmoBuffer *cb)

for (i=0; i<getoaSize(vlist0); i++) {

ob1 = getoa(vlist0,i);

if (ectag(ob1) == CLASSNAME_indeterminate) {

ob1 = KopIndeterminate(ob1);

}else if (ectag(ob1) == CLASSNAME_tree) {

/* do nothing. */

}

putoa(vlist,i,ob1);

}

Line 1003 struct object cmoCmoToObject00(struct cmoBuffer *cb)

Line 1017 struct object cmoCmoToObject00(struct cmoBuffer *cb)

}else{

ob1 = getoa(rob,0);

if (ob1.tag != Sdollar) warningCmo("CMO_TREE : the first arg must be the node name by a string.");

ob2 = getoa(rob,1); /* content dictionary name. */

ob2 = getoa(rob,1); /* Attribute List */

if (ob2.tag != Sdollar) warningCmo("CMO_TREE : the second arg must be the node name by a string.");

if (ob2.tag != Sarray) warningCmo("CMO_TREE : the second arg must be a list of attributes.");

rob = KpoTree(rob);

}

break;

Line 1083 struct object cmoListToPoly(struct object ob) {

Line 1097 struct object cmoListToPoly(struct object ob) {

if (n >= 1) {

ob0 = getoa(ob,0);

if (ob0.tag == CMO+CMO_DMS) {

rob = KpoPOLY(cmoListToPOLY(ob)); /* not ToPoly, ToPOLY */

}else{

rob = newObjectArray(n);

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

putoa(rob,i,cmoListToPoly(getoa(ob,i)));

}

}else{

rob = ob;

Line 1105 struct object cmoListToPoly2(struct object ob)

Line 1119 struct object cmoListToPoly2(struct object ob)

struct object ob0,ob1;

POLY f;

printf("<<");printObject(ob,0,stdout); printf(">>\n"); fflush(stdout);

if (ob.tag != Sarray) {

errorCmo("cmoListToPoly2(): the argument must be array.");

}

Line 1146 POLY cmoListToPOLY(struct object ob)

Line 1160 POLY cmoListToPOLY(struct object ob)

struct object ob0,ob1;

POLY f;

printf("<<");printObject(ob,0,stdout); printf(">>\n"); fflush(stdout);

if (ob.tag != Sarray) {

errorCmo("cmoListToPOLY(): the argument must be array.");

}

Line 1165 POLY cmoListToPOLY(struct object ob)

Line 1179 POLY cmoListToPOLY(struct object ob)

for (i=size-1; i>=2; i--) {

ob1 = getoa(ob,i);

if (ob1.tag == Spoly) {

f = ppAdd(f,KopPOLY(ob1));

}else{

f = ppAdd(f,cmoListToPOLY(ob1));

}

return(f);

Line 1318 struct object newMathCap(struct mathCap *mathcap){

Line 1332 struct object newMathCap(struct mathCap *mathcap){

struct object ob3;

struct object obOx;

struct object obSm;

struct object ob3tmp;

struct object *obp;

int i;

int i,j;

struct object mathinfo;

rob = newObjectArray(3);

Line 1329 struct object newMathCap(struct mathCap *mathcap){

Line 1344 struct object newMathCap(struct mathCap *mathcap){

for (i=0; i<getoaSize(mathinfo); i++) {

putoa(ob1,i,getoa(mathinfo,i));

}

ob2 = newObjectArray(mathcap->n);

ob3 = newObjectArray(mathcap->oxSize);

for (i=0; i<mathcap->n; i++) {

putoa(ob2,i,KpoInteger((mathcap->cmo)[i]));

}

obOx = newObjectArray(mathcap->oxSize);

for (i=0; i<mathcap->oxSize; i++) {

putoa(obOx,i,KpoInteger((mathcap->ox)[i]));

ob3tmp = newObjectArray(2);

putoa(ob3tmp,0,KpoInteger((mathcap->ox)[i]));

ob2 = newObjectArray(mathcap->n);

for (j=0; j<mathcap->n; j++) {

putoa(ob2,j,KpoInteger((mathcap->cmo)[j]));

}

putoa(ob3tmp,1,ob2);

putoa(ob3,i,ob3tmp);

}

ob3 = newObjectArray(2);

putoa(ob3,0,obOx);

putoa(ob3,1,ob2);

obSm = newObjectArray(mathcap->smSize);

for (i=0; i<mathcap->smSize; i++) {

Line 1361 struct object KSmathCap(void)

Line 1376 struct object KSmathCap(void)

}

void *KSmathCapByStruct(void)

/* Return the math cap of kan/sm1 with cmo.c as a mathcap classObject*/

{

struct mathCap *mathcap;

struct object ob;

Line 1386 void *KSmathCapByStruct(void)

Line 1401 void *KSmathCapByStruct(void)

putoa(ob,1,KpoString(sys));

putoa(ob,2,KpoString(sysVersion));

s1 = getenv("HOSTTYPE");

if (s1 == NULL) s1="unknown";

s2 = (char *)sGC_malloc(strlen(s1)+2+strlen("HOSTTYPE="));

strcpy(s2,"HOSTTYPE=");

strcat(s2,s1);

Line 1422 void *KSmathCapByStruct(void)

Line 1438 void *KSmathCapByStruct(void)

mathcap->cmo[21]= CMO_RATIONAL;

mathcap->n = 22 ; /* This is the number of cmo object. You can use

cmo upto 1023. see mathcap.h */

mathcap->ox[0] = OX_DATA;

mathcap->oxSize = 1 ; /* This is the number of OX object. You can use

OX upto 1023. see mathcap.h */

mathcap->sm[0] = SM_popCMO;

mathcap->sm[1] = SM_popString;

Line 1439 void *KSmathCapByStruct(void)

Line 1455 void *KSmathCapByStruct(void)

mathcap->sm[8] = SM_setMathCap;

mathcap->sm[9] = SM_getsp;

mathcap->sm[10] = SM_dupErrors;

mathcap->smSize = 11;

mathcap->sm[11] = SM_pushCMOtag;

mathcap->sm[12] = SM_executeFunctionWithOptionalArgument;

mathcap->smSize = 13;

return((void *)mathcap);

}

Line 1467 errorCmo(char *s) {

Line 1485 errorCmo(char *s) {

int outfp2(FILE2 *fp2) {

int i;

printf("--------- outfp2 ---------\n"); fflush(stdout);

/* if (checkfp2(fp2," f2pdumpBuf ") == -1) {

return(-1);

}*/

printf("fd=%d\n",fp2->fd);

printf("initialied=%d\n",fp2->initialized);

printf("readpos=%d\n",fp2->readpos);

Line 1502 static char *translateReservedName(char *s) {

Line 1520 static char *translateReservedName(char *s) {

return(NULL);

}

struct object cmoTranslateVariable_inComming(struct object ob) {

/* ob must be Sdollar, return value must be Sdollar. */

/* Read a variable name from an other system,

Line 1530 struct object cmoTranslateVariable_inComming(struct ob

Line 1548 struct object cmoTranslateVariable_inComming(struct ob

if (t == NULL) errorCmo("No more memory.");

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

if (s[i] <= ' ' || s[i] == '#') {

t[count++] = '#';

t[count++] = (s[i]/16 < 10? s[i]/16+'0': (s[i]/16-10)+'A');

t[count++] = (s[i]%16 < 10? s[i]%16+'0': (s[i]%16-10)+'A');

}else{

t[count++] = s[i];

}

t[count] = '\0';

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