Annotation of OpenXM/src/kan96xx/plugin/oxmisc2.c, Revision 1.1
1.1 ! maekawa 1: #include <stdio.h>
! 2: #include "ox_kan.h"
! 3: #include "oxmisc2.h" /* This file requires sm1 object description. */
! 4: #include "cmo.h"
! 5: extern FILE *MyErrorOut;
! 6: extern int SerialOX; /* defined in SerialOX */
! 7:
! 8: extern int OxVersion;
! 9:
! 10: int DebugMathCap = 1;
! 11:
! 12:
! 13:
! 14: int oxGet(oxclientp client, struct object *op,int *isObj)
! 15: /* This method should be synchronized. */
! 16: /* oxGet is a function for client. */
! 17: {
! 18: int ans;
! 19: ox_stream os;
! 20: int m;
! 21: struct object rob;
! 22: int sss; /* Serial number of the recieved packet. */
! 23: *isObj = 0;
! 24: op->tag = Snull;
! 25: os = client->datafp2;
! 26: switch(client->dstate) {
! 27: case DSTATE_ANY:
! 28: m = oxGetOXheader(os,&sss);
! 29: switch(m) {
! 30: case OX_DATA:
! 31: client->dstate = DSTATE_WAIT_OX_DATA;
! 32: return(oxGet(client,op,isObj));
! 33: case OX_SYNC_BALL:
! 34: client->dstate = DSTATE_ANY;
! 35: return(OX_SYNC_BALL);
! 36: default:
! 37: errorOxmisc2("oxGet: cannot handle this tag.\n");
! 38: client->dstate = DSTATE_ERROR;
! 39: return(-1);
! 40: }
! 41: break;
! 42: case DSTATE_FIRST_SYNC: /* waiting the first sync ball */
! 43: /* I need to clear the buffer?? */
! 44: oxWaitSyncBall(os);
! 45: client->dstate = DSTATE_ANY;
! 46: oxSendSyncBall(os);
! 47: return(OX_SYNC_BALL);
! 48: break;
! 49: case DSTATE_WAIT_OX_DATA: /* waiting a cmo data. */
! 50: *op = cmoObjectFromStream2(client->datafp2);
! 51: client->dstate = DSTATE_ANY;
! 52: *isObj = 1;
! 53: return(0);
! 54: break;
! 55: case DSTATE_ERROR:
! 56: client->dstate = DSTATE_ERROR;
! 57: errorOxmisc2("oxGet: dstate == DSTATE_ERROR (error state)\n");
! 58: return(-1);
! 59: default:
! 60: client->dstate = DSTATE_ERROR;
! 61: errorOxmisc2("oxGet: Unknown state number.");
! 62: }
! 63:
! 64: return(-1);
! 65: }
! 66:
! 67: int oxGetFromControl(oxclientp client)
! 68: {
! 69: int ans = -1;
! 70: if (client->cstate != -1) {
! 71: ans = oxGetResultOfControlInt32(client->controlfd);
! 72: if (ans != -1) { client->cstate = 0; }
! 73: else {client->cstate = -1; }
! 74: }
! 75: return(ans);
! 76: }
! 77:
! 78: int oxReq(oxclientp client,int func,struct object ob)
! 79: {
! 80: struct object *ob1p;
! 81: /* request to the control channel */
! 82: if (func == SM_control_reset_connection ||
! 83: func == SM_control_kill) {
! 84: switch(func) {
! 85: case SM_control_reset_connection:
! 86: oxReqControlResetConnection(client->controlfd);
! 87: client->cstate = 1;
! 88: client->dstate = DSTATE_FIRST_SYNC;
! 89: break;
! 90: case SM_control_kill:
! 91: oxReqControlKill(client->controlfd);
! 92: client->cstate = 0;
! 93: client->dstate = DSTATE_ANY;
! 94: break;
! 95: }
! 96: fflush(NULL);
! 97: return(0);
! 98: }
! 99:
! 100: /* request to the data channel */
! 101: if (client->dstate != DSTATE_ANY) {
! 102: errorOxmisc2("oxReq: client->dstate != DSTATE_ANY, data channel is not ready to send data.\n");
! 103: return(-1);
! 104: }
! 105: switch(func) {
! 106: case SM_DUMMY_sendcmo:
! 107: if (!cmoCheckMathCap(ob,(struct object *)client->mathcapObjp)) {
! 108: errorOxmisc2("oxReq: your peer does not understand this cmo.\n");
! 109: return(-1);
! 110: }
! 111: oxSendOXheader(client->datafp2,OX_DATA,SerialOX++);
! 112: cmoObjectToStream2(ob,client->datafp2);
! 113: client->dstate = DSTATE_ANY;
! 114: break;
! 115: case SM_sync_ball:
! 116: oxSendSyncBall(client->datafp2);
! 117: client->dstate = DSTATE_ANY; /* We do not expect the sync ball.*/
! 118: client->cstate = 0; /* clear the cstate */
! 119: break;
! 120: case SM_popCMO:
! 121: oxReqPopCMO(client->datafp2);
! 122: client->dstate = DSTATE_ANY;
! 123: break;
! 124: case SM_mathcap:
! 125: oxReqMathCap(client->datafp2);
! 126: client->dstate = DSTATE_ANY;
! 127: break;
! 128: case SM_setMathCap:
! 129: /* ob = [(mathcap-obj) [[version num, system name] [sm tags]
! 130: ob1 smtags
! 131: [[ox numbers] [cmo numbers]]]
! 132: ob3 ob2 */
! 133: {
! 134: struct object ob1;
! 135: struct object ob2;
! 136: struct object ob3;
! 137: struct object smtags;
! 138: int n,i;
! 139: struct mathCap mathcap;
! 140:
! 141: if (strcmp(KopString(getoa(ob,0)),"mathcap-object") != 0) {
! 142: errorOxmisc2("data format error in oxReqSetMathCap");
! 143: client->dstate = DSTATE_ANY;
! 144: break;
! 145: }
! 146: ob1 = getoa(getoa(ob,1),0);
! 147: smtags = getoa(getoa(ob,1),1);
! 148: ob2 = getoa(getoa(getoa(ob,1),2),1);
! 149: ob3 = getoa(getoa(getoa(ob,1),2),0);
! 150:
! 151: ob1p = (struct object *) sGC_malloc(sizeof(struct object));
! 152: *ob1p = ob1;
! 153: mathcap.infop = ob1p;
! 154: n = getoaSize(ob2);
! 155: mathcap.n = n;
! 156: if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer.");
! 157: for (i=0; i<n; i++) {
! 158: mathcap.cmo[i] = KopInteger(getoa(ob2,i));
! 159: }
! 160: n = getoaSize(ob3);
! 161: if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer.");
! 162: mathcap.oxSize = n;
! 163: for (i=0; i<n; i++) {
! 164: mathcap.ox[i] = KopInteger(getoa(ob3,i));
! 165: }
! 166:
! 167: n = getoaSize(smtags);
! 168: if (n >= MATHCAP_SIZE) errorOxmisc2("Too big mathcap of your peer.");
! 169: mathcap.smSize = n;
! 170: for (i=0; i<n; i++) {
! 171: mathcap.sm[i] = KopInteger(getoa(smtags,i));
! 172: }
! 173:
! 174: oxReqSetMathCap(client->datafp2,&mathcap);
! 175: client->dstate = DSTATE_ANY;
! 176: }
! 177: break;
! 178: case SM_pops:
! 179: if (ob.tag != Sinteger) {
! 180: errorOxmisc2("SM_pops : the argument must be an integer.");
! 181: return(-1);
! 182: }
! 183: oxReqPops(client->datafp2, KopInteger(ob));
! 184: client->dstate = DSTATE_ANY;
! 185: break;
! 186: case SM_executeStringByLocalParser:
! 187: if (ob.tag != Sdollar) {
! 188: errorOxmisc2("SM_executeStringByLocalParser : the argument must be a string.");
! 189: return(-1);
! 190: }
! 191: oxReqExecuteStringByLocalParser(client->datafp2,KopString(ob));
! 192: client->dstate = DSTATE_ANY;
! 193: break;
! 194: case SM_executeFunction:
! 195: if (ob.tag != Sdollar) {
! 196: errorOxmisc2("SM_executeFunction : the argument must be a string.");
! 197: return(-1);
! 198: }
! 199: oxReqExecuteFunction(client->datafp2,KopString(ob));
! 200: client->dstate = DSTATE_ANY;
! 201: break;
! 202: case SM_popString:
! 203: oxReqPopString(client->datafp2);
! 204: client->dstate = DSTATE_ANY;
! 205: break;
! 206: case SM_evalName:
! 207: if (ob.tag != Sdollar) {
! 208: errorOxmisc2("SM_evalName : the argument must be a string.");
! 209: return(-1);
! 210: }
! 211: oxReqEvalName(client->datafp2,KopString(ob));
! 212: client->dstate = DSTATE_ANY;
! 213: break;
! 214: case SM_setName:
! 215: if (ob.tag != Sdollar) {
! 216: errorOxmisc2("SM_setName : the argument must be a string.");
! 217: return(-1);
! 218: }
! 219: oxReqSetName(client->datafp2,KopString(ob));
! 220: client->dstate = DSTATE_ANY;
! 221: break;
! 222: case SM_getsp:
! 223: oxReqSingleOperand(client->datafp2,SM_getsp);
! 224: client->dstate = DSTATE_ANY;
! 225: break;
! 226: case SM_dupErrors:
! 227: oxReqSingleOperand(client->datafp2,SM_dupErrors);
! 228: client->dstate = DSTATE_ANY;
! 229: break;
! 230: default:
! 231: fprintf(MyErrorOut,"func=%d ",func);
! 232: errorOxmisc2("This function is not implemented.");
! 233: break;
! 234: }
! 235: fp2fflush(client->datafp2);
! 236: return(0);
! 237: }
! 238:
! 239: struct object KoxCreateClient(struct object ip,
! 240: struct object portStream,
! 241: struct object portControl)
! 242: {
! 243: struct object rob;
! 244: oxclientp client;
! 245: rob.tag = Snull;
! 246: if (ip.tag != Sdollar) {
! 247: errorOxmisc2("KoxCreateClient(): The first argument must be a hostname given by a string.");
! 248: return(rob);
! 249: }
! 250: if (portStream.tag == Sdollar) {
! 251: client = oxCreateClientFile(KopString(ip),KopString(portStream),
! 252: "/dev/null","w");
! 253: if (client == NULL) {
! 254: errorOxmisc2("KoxCreateClient(): Open error.");
! 255: return(rob);
! 256: }
! 257: rob = newObjectArray(N_OF_CLIENT_FIELDS);
! 258: oxClientToObject(client,rob);
! 259: return(rob);
! 260: }
! 261:
! 262: if (portStream.tag != Sinteger) {
! 263: errorOxmisc2("KoxCreateClient(): The second argument must be a port number given in an integer.");
! 264: return(rob);
! 265: }
! 266: if (portControl.tag != Sinteger) {
! 267: errorOxmisc2("KoxCreateClient(): The third argument must be a port number given in an integer.");
! 268: return(rob);
! 269: }
! 270: client = oxCreateClient(KopString(ip),KopInteger(portStream),KopInteger(portControl));
! 271: if (client == NULL) {
! 272: errorOxmisc2("KoxCreateClient(): Open error.");
! 273: return(rob);
! 274: }
! 275: rob = newObjectArray(N_OF_CLIENT_FIELDS);
! 276: oxClientToObject(client,rob);
! 277: return(rob);
! 278: }
! 279:
! 280: static int isItClientObject(struct object ob)
! 281: {
! 282: int size,i;
! 283: struct object ee[N_OF_CLIENT_FIELDS];
! 284: if (ob.tag != Sarray) {
! 285: return(0);
! 286: }
! 287: size = getoaSize(ob);
! 288: if (size != N_OF_CLIENT_FIELDS) return(0);
! 289: for (i=0; i<N_OF_CLIENT_FIELDS; i++) {
! 290: ee[i] = getoa(ob,i);
! 291: }
! 292:
! 293: if (ee[0].tag != Sdollar) return(0);
! 294: if (strcmp(KopString(ee[0]),"client")!=0) return(0);
! 295:
! 296: if (ee[1].tag != Sfile) return(0);
! 297: if (strcmp((ee[1]).lc.str,MAGIC2) != 0) return(0);
! 298:
! 299: for (i=2; i<=9; i++) {
! 300: if (ee[i].tag != Sinteger) return(0);
! 301: }
! 302: return(1);
! 303: }
! 304:
! 305:
! 306: struct object KoxIsThereErrorClient(struct object ob)
! 307: {
! 308: struct object rob;
! 309: int ans;
! 310: int size;
! 311: oxclient cc;
! 312: rob.tag = Snull;
! 313: if (!isItClientObject(ob)) {
! 314: errorOxmisc2("KoxIsThereErrorClient(): the argument must be an array for client object.");
! 315: return(rob);
! 316: }
! 317: if (oxObjectToClient(ob,&cc) == -1) return(KpoInteger(-1));
! 318: ans = oxIsThereErrorClient(&cc);
! 319: return(KpoInteger(ans));
! 320: }
! 321:
! 322: int oxClientToObject(oxclientp client,struct object rob)
! 323: {
! 324: struct object ob;
! 325: if (client == NULL) return;
! 326: /* rob = newObjectArray(N_OF_CLIENT_FIELDS); */
! 327: if (rob.tag != Sarray) {
! 328: errorOxmisc2("oxClientToObject(): the second argument must be an array.");
! 329: return(-1);
! 330: }
! 331: if (getoaSize(rob) != N_OF_CLIENT_FIELDS) {
! 332: errorOxmisc2("oxClientToObject(): the second argument must be an array of size N_OF_CLIENT_FIELDS.");
! 333: return(-1);
! 334: }
! 335:
! 336: ob = KpoString("client");
! 337: putoa(rob,0,ob);
! 338:
! 339: ob.tag = Sfile; ob.lc.str = MAGIC2; ob.rc.voidp = (void *)(client->datafp2);
! 340: putoa(rob,1,ob);
! 341:
! 342: putoa(rob,2,KpoInteger(client->dataport));
! 343: putoa(rob,3,KpoInteger(client->controlfd));
! 344: putoa(rob,4,KpoInteger(client->controlport));
! 345: putoa(rob,5,KpoInteger(client->dstate));
! 346: putoa(rob,6,KpoInteger(client->cstate));
! 347: putoa(rob,7,KpoInteger(client->humanio));
! 348: putoa(rob,8,KpoInteger(client->id));
! 349: putoa(rob,9,KpoInteger(client->type));
! 350: if (client->mathcapObjp == NULL) {
! 351: putoa(rob,10,NullObject);
! 352: }else{
! 353: putoa(rob,10,*((struct object *)(client->mathcapObjp)));
! 354: }
! 355: putoa(rob,11,KpoInteger(client->engineByteOrder));
! 356: putoa(rob,12,KpoInteger(client->controlByteOrder));
! 357: return(0);
! 358: }
! 359:
! 360: int oxObjectToClient(struct object ob,oxclientp cp)
! 361: {
! 362: struct object ob1;
! 363: struct object *obp;
! 364: if (cp == NULL) {
! 365: errorOxmisc2("oxObjectToClient(): the second argument is NULL");
! 366: return(-1);
! 367: }
! 368: if (!isItClientObject(ob)) {
! 369: errorOxmisc2("oxObjectToClient(): the first argument is not client object.");
! 370: oxInitClient(cp);
! 371: return(-1);
! 372: }
! 373:
! 374: ob1 = getoa(ob,1);
! 375: cp->datafp2 = (FILE2 *) (ob1.rc.voidp);
! 376:
! 377: ob1 = getoa(ob,2);
! 378: cp->dataport = KopInteger(ob1);
! 379:
! 380: ob1 = getoa(ob,3);
! 381: cp->controlfd = KopInteger(ob1);
! 382:
! 383: ob1 = getoa(ob,4);
! 384: cp->controlport = KopInteger(ob1);
! 385:
! 386: ob1 = getoa(ob,5);
! 387: cp->dstate = KopInteger(ob1);
! 388:
! 389: ob1 = getoa(ob,6);
! 390: cp->cstate = KopInteger(ob1);
! 391:
! 392: ob1 = getoa(ob,7);
! 393: cp->humanio = KopInteger(ob1);
! 394:
! 395: ob1 = getoa(ob,8);
! 396: cp->id = KopInteger(ob1);
! 397:
! 398: ob1 = getoa(ob,9);
! 399: cp->type = KopInteger(ob1);
! 400:
! 401: ob1 = getoa(ob,10);
! 402: if (ob1.tag == Snull) {
! 403: cp->mathcapObjp = NULL;
! 404: }else{
! 405: obp = (struct object *) sGC_malloc(sizeof(struct object));
! 406: *obp = ob1;
! 407: cp->mathcapObjp = (void *)obp;
! 408: }
! 409: ob1 = getoa(ob,11);
! 410: cp->engineByteOrder = KopInteger(ob1);
! 411: ob1 = getoa(ob,12);
! 412: cp->controlByteOrder = KopInteger(ob1);
! 413:
! 414:
! 415: return(0);
! 416: }
! 417:
! 418: struct object KoxReq(struct object client,
! 419: struct object func,
! 420: struct object ob1)
! 421: {
! 422: int ans;
! 423: static oxclientp cc1 = NULL;
! 424: struct object rob;
! 425: rob.tag = Snull;
! 426: if (cc1 == NULL) {
! 427: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
! 428: if (cc1 == NULL) {
! 429: errorOxmisc2("KoxReq(): no more memory.");
! 430: return(rob);
! 431: }
! 432: oxInitClient(cc1);
! 433: }
! 434:
! 435: if (oxObjectToClient(client,cc1) == -1) return(rob);
! 436: if (cc1 == NULL) {
! 437: errorOxmisc2("KoxReq(): the first argument must be a client object.");
! 438: return(rob);
! 439: }
! 440: if (func.tag != Sinteger) {
! 441: errorOxmisc2("KoxReq(): the second argument must be an integer.");
! 442: return(rob);
! 443: }
! 444: ans = oxReq(cc1,KopInteger(func),ob1);
! 445: /* synchronize cc1 and client. */
! 446: oxClientToObject(cc1,client);
! 447:
! 448: return(KpoInteger(ans));
! 449: }
! 450:
! 451: struct object KoxGet(struct object client)
! 452: {
! 453: int ans,k;
! 454: static oxclientp cc1 = NULL;
! 455: struct object rob;
! 456: rob.tag = Snull;
! 457: if (cc1 == NULL) {
! 458: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
! 459: if (cc1 == NULL) {
! 460: errorOxmisc2("KoxGet(): no more memory.");
! 461: return(rob);
! 462: }
! 463: oxInitClient(cc1);
! 464: }
! 465:
! 466: if (oxObjectToClient(client,cc1) == -1) return(rob);
! 467: if (cc1 == NULL) {
! 468: errorOxmisc2("KoxGet(): the first argument must be a client object.");
! 469: return(rob);
! 470: }
! 471:
! 472: ans = oxGet(cc1,&rob,&k);
! 473: /* synchronize cc1 and client. */
! 474: oxClientToObject(cc1,client);
! 475:
! 476: if (k) return(rob);
! 477: else {
! 478: return(KpoInteger(ans));
! 479: }
! 480: }
! 481:
! 482: struct object KoxGetFromControl(struct object client)
! 483: {
! 484: int ans;
! 485: static oxclientp cc1 = NULL;
! 486: struct object rob;
! 487: rob.tag = Snull;
! 488: if (cc1 == NULL) {
! 489: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
! 490: if (cc1 == NULL) {
! 491: errorOxmisc2("KoxGetFromControl(): no more memory.");
! 492: return(rob);
! 493: }
! 494: oxInitClient(cc1);
! 495: }
! 496:
! 497: if (oxObjectToClient(client,cc1) == -1) return(rob);
! 498: if (cc1 == NULL) {
! 499: errorOxmisc2("KoxGetFromControl(): the first argument must be a client object.");
! 500: return(rob);
! 501: }
! 502:
! 503: ans = oxGetFromControl(cc1);
! 504: /* synchronize cc1 and client. */
! 505: oxClientToObject(cc1,client);
! 506:
! 507: return(KpoInteger(ans));
! 508: }
! 509:
! 510: struct object KoxMultiSelect(struct object oclients,struct object t)
! 511: {
! 512: static int first = 1;
! 513: static int csize = 0;
! 514: static oxclientp *clients = NULL;
! 515: oxclientp cc1;
! 516: struct object rob;
! 517: int i;
! 518: int tt;
! 519: struct object ob1;
! 520: struct object ob2;
! 521: struct object ob0;
! 522: int size;
! 523: int ans;
! 524: int dataready[1024];
! 525: int controlready[1024];
! 526:
! 527: rob.tag = Snull;
! 528: if (oclients.tag != Sarray) {
! 529: errorOxmisc2("KoxMultiSelect(): the first argument must be an array.");
! 530: return(rob);
! 531: }
! 532: size = getoaSize(oclients);
! 533: if (first) {
! 534: first = 0; csize = size;
! 535: clients = (oxclientp *)mymalloc(sizeof(oxclientp)*(size+1));
! 536: if (clients == NULL) {
! 537: errorOxmisc2("KoxMultiSelect(): no more memory.");
! 538: return(rob);
! 539: }
! 540: for (i=0; i<size; i++) {
! 541: clients[i] = (oxclientp) mymalloc(sizeof(oxclient));
! 542: if (clients[i] == NULL) {
! 543: errorOxmisc2("KoxMultiSelect(): no more memory.");
! 544: return(rob);
! 545: }
! 546: oxInitClient(clients[i]);
! 547: }
! 548: }
! 549: if (csize < size) {
! 550: first = 1;
! 551: return(KoxMultiSelect(oclients,t));
! 552: }
! 553: for (i=0; i<size; i++) {
! 554: ob0 = getoa(oclients,i);
! 555: if (oxObjectToClient(ob0,clients[i]) == -1) return(rob);
! 556: }
! 557: if (t.tag != Sinteger) {
! 558: errorOxmisc2("KoxMultiSelect(): the second argument must be an integer.");
! 559: }
! 560: tt = KopInteger(t);
! 561: ans = oxclientMultiSelect(clients,dataready,controlready,size,tt);
! 562: /* synchronize oclients and clients. */
! 563: for (i=0; i<size; i++) {
! 564: ob0 = getoa(oclients,i);
! 565: oxClientToObject(clients[i],ob0);
! 566: putoa(oclients,i,ob0);
! 567: }
! 568: rob = newObjectArray(3);
! 569: putoa(rob,0,KpoInteger(ans));
! 570: ob1 = newObjectArray(size);
! 571: ob2 = newObjectArray(size);
! 572: for (i=0; i<size; i++) {
! 573: putoa(ob1,i,KpoInteger(dataready[i]));
! 574: putoa(ob2,i,KpoInteger(controlready[i]));
! 575: }
! 576: putoa(rob,1,ob1);
! 577: putoa(rob,2,ob2);
! 578: return(rob);
! 579: }
! 580:
! 581: struct object KoxWatch(struct object client,struct object f)
! 582: /* f is not used for now. It should be log file. */
! 583: {
! 584: int ans,k;
! 585: static oxclientp cc1 = NULL;
! 586: struct object rob;
! 587: rob.tag = Snull;
! 588: if (cc1 == NULL) {
! 589: cc1 = (oxclientp) mymalloc(sizeof(oxclient));
! 590: if (cc1 == NULL) {
! 591: errorOxmisc2("KoxWatch(): no more memory.");
! 592: return(rob);
! 593: }
! 594: oxInitClient(cc1);
! 595: }
! 596:
! 597: if (oxObjectToClient(client,cc1) == -1) return(rob);
! 598: if (cc1 == NULL) {
! 599: errorOxmisc2("KoxWatch(): the first argument must be a client object.");
! 600: return(rob);
! 601: }
! 602:
! 603: k = fp2watch(cc1->datafp2,stdout);
! 604: /* synchronize cc1 and client. */
! 605: oxClientToObject(cc1,client);
! 606:
! 607: return(KpoInteger(ans));
! 608: }
! 609:
! 610:
! 611: struct object KoxCloseClient(struct object client) {
! 612: oxclientp cc1 = NULL;
! 613: oxclient cc;
! 614: struct object rob;
! 615: rob.tag = Snull;
! 616: cc1 = &cc;
! 617: if (oxObjectToClient(client,cc1) == -1) return(rob);
! 618: if (cc1 == NULL) {
! 619: errorOxmisc2("KoxCloseClient(): the first argument must be a client object.");
! 620: return(rob);
! 621: }
! 622:
! 623: fp2fflush(cc1->datafp2);
! 624: if (cc1->humanio) {
! 625: /* Do not close the file. */
! 626: return(KpoInteger(0));
! 627: }
! 628: switch (cc1->type) {
! 629: case CLIENT_SOCKET:
! 630: fp2fclose(cc1->datafp2);
! 631: close(cc1->controlfd);
! 632: break;
! 633: case CLIENT_FILE:
! 634: fp2fclose(cc1->datafp2);
! 635: close(cc1->controlfd);
! 636: break;
! 637: default:
! 638: errorOxmisc2("Unknown client->type\n");
! 639: break;
! 640: }
! 641: return(KpoInteger(0));
! 642:
! 643: }
! 644:
! 645: static int cmoCheck00(struct object obj,int cmo[], int n) {
! 646: int i,j,m;
! 647: int ttt;
! 648: #define CHECK00_N 4098 /* look up stackm.h and kclass.h */
! 649: static int typeTrans[CHECK00_N];
! 650: static int init = 0;
! 651: if (n == 0) return(1); /* For null cmolist, OK. */
! 652: if (!init) {
! 653: for (i=0; i<CHECK00_N; i++) {
! 654: typeTrans[i] = 0; /* unknown cmo number */
! 655: }
! 656: typeTrans[Snull] = CMO_NULL;
! 657: typeTrans[Sinteger] = CMO_INT32;
! 658: typeTrans[Sdollar] = CMO_STRING;
! 659: if (OxVersion >= 199907170) {
! 660: typeTrans[SuniversalNumber] = CMO_ZZ;
! 661: }else{
! 662: typeTrans[SuniversalNumber] = CMO_ZZ_OLD;
! 663: }
! 664: typeTrans[Sarray] = CMO_LIST;
! 665: /* typeTrans[Spoly] = CMO_DMS; */
! 666: typeTrans[Spoly] = CMO_DISTRIBUTED_POLYNOMIAL;
! 667: typeTrans[Sdouble] = CMO_64BIT_MACHINE_DOUBLE;
! 668: typeTrans[CLASSNAME_ERROR_PACKET] = CMO_ERROR2;
! 669: typeTrans[CLASSNAME_mathcap] = CMO_MATHCAP;
! 670: typeTrans[CLASSNAME_indeterminate] = CMO_INDETERMINATE;
! 671: typeTrans[CLASSNAME_tree] = CMO_TREE;
! 672: typeTrans[CLASSNAME_recursivePolynomial] = CMO_RECURSIVE_POLYNOMIAL;
! 673: typeTrans[CLASSNAME_polynomialInOneVariable] = CMO_POLYNOMIAL_IN_ONE_VARIABLE;
! 674: init = 1;
! 675: }
! 676: ttt = typeTrans[obj.tag];
! 677: if (obj.tag == Sclass) {
! 678: ttt = typeTrans[ectag(obj)];
! 679: }
! 680:
! 681: for (i=0; i<n; i++) {
! 682: if (ttt == cmo[i]) {
! 683: if (ttt != CMO_LIST) return(1);
! 684: else {
! 685: m = getoaSize(obj);
! 686: for (j=0; j<m; j++) {
! 687: if (!cmoCheck00(getoa(obj,j),cmo,n)) return(0);
! 688: }
! 689: return(1);
! 690: }
! 691: }
! 692: }
! 693: if (DebugMathCap) {
! 694: if (DebugMathCap && 1) {
! 695: fprintf(stderr,"Type translation table (internal object tag --> CMO tag)\n");
! 696: for (i=0; i<20; i++) {
! 697: printf("%d ", typeTrans[i]);
! 698: }
! 699: printf("\n");
! 700: }
! 701: fprintf(stderr,"The type of the argument object in sm1 is %d.\n",obj.tag);
! 702: fprintf(stderr,"The type of the argument object in CMO is %d.\n",ttt);
! 703: fprintf(stderr,"Available CMO tags in mathcap= %d elements : [ ",n);
! 704: for (i=0; i<n; i++) {
! 705: fprintf(stderr," %d ",cmo[i]);
! 706: }
! 707: fprintf(stderr," ] \n");
! 708: }
! 709: return(0);
! 710: }
! 711:
! 712: int cmoCheckMathCap(struct object obj, struct object *obp)
! 713: {
! 714: struct object mathcap;
! 715: struct object cmolist;
! 716: int n;
! 717: int i;
! 718: #define CMO_CHECK_MATH_CAP_LIST_SIZE 1024
! 719: int cmo[CMO_CHECK_MATH_CAP_LIST_SIZE];
! 720: if (obp == NULL) return(1);
! 721: if (obp->tag != Sarray) {
! 722: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
! 723: printObject(*obp,0,stderr);
! 724: fprintf(stderr,"\n");
! 725: errorOxmisc2("cmoCheckMathCap: format error in the client->mathcapObjp field.\n");
! 726: }
! 727: mathcap = *obp;
! 728: n = getoaSize(mathcap);
! 729: if (n < 2) {
! 730: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
! 731: printObject(*obp,0,stderr);
! 732: fprintf(stderr,"\n");
! 733: errorOxmisc2("cmoCheckMathCap: length of mathcap is wrong in the client->mathcapObjp field.\n");
! 734: }
! 735: /* I should check
! 736: getoa(getoa(mathcap,2),0)
! 737: contains OX_DATA.
! 738: It has not yet implemented.
! 739: */
! 740: mathcap = getoa(getoa(mathcap,1),2);
! 741: n = getoaSize(mathcap);
! 742: if (n < 2) {
! 743: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
! 744: printObject(*obp,0,stderr);
! 745: fprintf(stderr,"\n");
! 746: errorOxmisc2("cmoCheckMathCap: length of mathcap is wrong in the client->mathcapObjp field.\n");
! 747: }
! 748: cmolist = getoa(mathcap,1);
! 749: if (cmolist.tag != Sarray) {
! 750: fprintf(stderr,"cmoCheckMathCap: the mathcap obj is \n");
! 751: printObject(*obp,0,stderr);
! 752: fprintf(stderr,"\n");
! 753: errorOxmisc2("cmoCheckMathCap: mathcap[1] must be an array of integers.\n");
! 754: }
! 755: n = getoaSize(cmolist);
! 756: if (n > CMO_CHECK_MATH_CAP_LIST_SIZE) {
! 757: errorOxmisc2("cmoCheckMathCap: Too big cmo list.\n");
! 758: }
! 759: for (i=0; i<n; i++) {
! 760: cmo[i] = KopInteger(getoa(cmolist,i));
! 761: }
! 762: return(cmoCheck00(obj,cmo,n));
! 763: }
! 764:
! 765:
! 766: struct object KoxGenPortFile(void) {
! 767: struct object ob;
! 768: ob = KpoString(oxGenPortFile());
! 769: return(ob);
! 770: }
! 771: void KoxRemovePortFile(void) {
! 772: oxRemovePortFile();
! 773: }
! 774:
! 775: void oxPushMathCap(struct mathCap *mathcap)
! 776: {
! 777: struct object rob;
! 778: rob = newMathCap(mathcap);
! 779: Kpush(rob);
! 780: }
! 781:
! 782: struct object KoxGenPass(void) {
! 783: struct object rob;
! 784: rob = KpoString(oxGenPass());
! 785: return(rob);
! 786: }
! 787:
! 788: struct object KoxGetPort(struct object host)
! 789: {
! 790: struct object rob;
! 791: int fdStream, fdControl;
! 792: int portStream, portControl;
! 793: extern int OpenedSocket;
! 794: char *sname;
! 795: rob = NullObject;
! 796: if (host.tag != Sdollar) {
! 797: errorOxmisc2("KoxGetPort: argument is not a string.");
! 798: return(rob);
! 799: }
! 800: sname = KopString(host);
! 801: fdControl = socketOpen(sname,0);
! 802: portControl = OpenedSocket;
! 803: fdStream = socketOpen(sname,0);
! 804: portStream = OpenedSocket;
! 805: rob = newObjectArray(4);
! 806: putoa(rob,0,KpoInteger(fdStream));
! 807: putoa(rob,1,KpoInteger(portStream));
! 808: putoa(rob,2,KpoInteger(fdControl));
! 809: putoa(rob,3,KpoInteger(portControl));
! 810: return(rob);
! 811: }
! 812:
! 813: struct object KoxCreateClient2(struct object peer,
! 814: struct object ipmask,
! 815: struct object pass)
! 816: {
! 817: struct object rob;
! 818: oxclientp client;
! 819: int fdStream, portStream, fdControl, portControl;
! 820: int i;
! 821: struct object ob1;
! 822: rob.tag = Snull;
! 823: if (peer.tag != Sarray) {
! 824: errorOxmisc2("KoxCreateClient2(): The first argument must be an array [fdStream, portStream, fdControl, portControl]");
! 825: return(rob);
! 826: }
! 827: if (getoaSize(peer) != 4) {
! 828: errorOxmisc2("KoxCreateClient2(): The first argument must be an array [fdStream, portStream, fdControl, portControl] of size 4.");
! 829: return(rob);
! 830: }
! 831: for (i=0; i<4; i++) {
! 832: ob1 = getoa(peer,i);
! 833: if (ob1.tag != Sinteger) {
! 834: errorOxmisc2("KoxCreateClient2(): The element of the first argument must be an integer.");
! 835: }
! 836: }
! 837: fdStream = KopInteger(getoa(peer,0));
! 838: portStream = KopInteger(getoa(peer,1));
! 839: fdControl = KopInteger(getoa(peer,2));
! 840: portControl = KopInteger(getoa(peer,3));
! 841:
! 842: if (ipmask.tag != Sinteger) {
! 843: errorOxmisc2("KoxCreateClient2(): ipmask must be an integer.");
! 844: }
! 845: if (pass.tag != Sdollar) {
! 846: errorOxmisc2("KoxCreateClient2(): pass must be a string.");
! 847: }
! 848:
! 849: client = oxCreateClient2(fdStream, portStream, fdControl, portControl,
! 850: KopInteger(ipmask), KopString(pass));
! 851: if (client == NULL) {
! 852: errorOxmisc2("KoxCreateClient2(): Open error.");
! 853: return(rob);
! 854: }
! 855: rob = newObjectArray(N_OF_CLIENT_FIELDS);
! 856: oxClientToObject(client,rob);
! 857: return(rob);
! 858: }
! 859:
! 860: errorOxmisc2(char *s) {
! 861: fprintf(MyErrorOut,"error in oxmisc2.c: %s\n",s);
! 862: errorKan1("%s\n"," ");
! 863: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to oxmisc2.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / plugin