[BACK]Return to tree.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / Kan / Kclass

Annotation of OpenXM/src/kan96xx/Kan/Kclass/tree.c, Revision 1.6

1.6     ! takayama    1: /* $OpenXM: OpenXM/src/kan96xx/Kan/Kclass/tree.c,v 1.5 2003/12/05 13:51:32 takayama Exp $ */
1.1       takayama    2: #include <stdio.h>
                      3: #include "../datatype.h"
                      4: #include "../stackm.h"
                      5: #include "../extern.h"
                      6: #include "../gradedset.h"
                      7: #include "../extern2.h"
                      8: #include "../kclass.h"
                      9:
                     10:
                     11:
                     12: /* Data conversion function : see KclassDataConversion*/
                     13: struct object KpoTree(struct object ob) {
                     14:   struct object rob;
                     15:   struct object ob1,ob2,ob3;
                     16:   struct object *newobp;
                     17:   rob.tag = Sclass;
                     18:   rob.lc.ival = CLASSNAME_tree;
                     19:   newobp = (struct object *) sGC_malloc(sizeof(struct object));
                     20:   if (newobp == NULL) errorKan1("%s\n","Kclass/indeterminate.c, no more memory.");
                     21:   if (ob.tag != Sarray) {
1.2       takayama   22:     errorKan1("%s\n","Kclass/indeterminate.c, only properly formatted list object can be transformed into tree. [name, attr-list, arglist].");
1.1       takayama   23:   }
                     24:   if (getoaSize(ob) < 3) {
1.2       takayama   25:     errorKan1("%s\n","Kclass/indeterminate.c, the length must 3 or more than 3. [name, attr-list, arglist].");
1.1       takayama   26:   }
                     27:   ob1 = getoa(ob,0); ob2 = getoa(ob,1); ob3 = getoa(ob,2);
                     28:   if (ob1.tag != Sdollar || ob2.tag != Sarray || ob3.tag != Sarray) {
                     29:     errorKan1("%s\n","Kclass/indeterminate.c, [string name, list attributes, list arglist].");
                     30:   }
1.2       takayama   31:   *newobp = ob;   /* Add class-tag to the array */
1.1       takayama   32:   rob.rc.voidp = newobp;
                     33:   return(rob);
                     34: }
                     35:
                     36:
                     37: /* Printing function : see fprintClass */
                     38: void fprintTree(FILE *fp,struct object op)
                     39: {
                     40:   printObject(KopTree(op),0,fp);
                     41: }
                     42:
                     43: int isTreeAdd(struct object ob) {
                     44:   struct object name;
                     45:   if (ob.tag != Sclass) {
                     46:     return(0);
                     47:   }
                     48:   if (ectag(ob) != CLASSNAME_tree) {
                     49:     return(0);
                     50:   }
                     51:   ob = KopTree(ob);
                     52:   if (ob.tag != Sarray) {
                     53:     errorKan1("%s\n","CLASSNAME_tree is broken. Should be array.");
                     54:   }
                     55:   name = getoa(ob,0);
                     56:   if (name.tag != Sdollar) {
                     57:     errorKan1("%s\n","CLASSNAME_tree is broken. Should be string.");
                     58:   }
1.6     ! takayama   59:   if (strcmp(KopString(name),"plus") == 0) {
1.1       takayama   60:     return(1);
                     61:   }else{
                     62:     return(0);
                     63:   }
                     64: }
                     65:
                     66: struct object addTree(struct object ob1, struct object ob2)
                     67: {
                     68:   struct object rob,aob;
                     69:   struct object ob3,ob4;
1.5       takayama   70:   struct object attr;
                     71:   struct object keyValue;
1.6     ! takayama   72:   struct object to;
1.1       takayama   73:   int i;
1.6     ! takayama   74:   to = ob2; ob2=ob1; ob1=to; /* Exchange ob1 and ob2 */
1.1       takayama   75:   if (isTreeAdd(ob1) && !isTreeAdd(ob2)) {
                     76:     ob1 = KopTree(ob1);
                     77:     ob3 = getoa(ob1,2);
                     78:     aob = newObjectArray(getoaSize(ob3)+1);
                     79:     for (i=0; i<getoaSize(ob3); i++) {
                     80:       putoa(aob,i,getoa(ob3,i));
                     81:     }
                     82:     putoa(aob,getoaSize(ob3),ob2);
                     83:   }else if (!isTreeAdd(ob1) && isTreeAdd(ob2)) {
                     84:     ob2 = KopTree(ob2);
                     85:     ob3 = getoa(ob2,2);
                     86:     aob = newObjectArray(getoaSize(ob3)+1);
                     87:     putoa(aob,0,ob1);
                     88:     for (i=0; i<getoaSize(ob3); i++) {
                     89:       putoa(aob,1+i,getoa(ob3,i));
                     90:     }
                     91:   }else if (isTreeAdd(ob1) && isTreeAdd(ob2)) {
                     92:     ob1 = KopTree(ob1);
                     93:     ob2 = KopTree(ob2);
                     94:     ob3 = getoa(ob1,2);
                     95:     ob4 = getoa(ob2,2);
                     96:     aob = newObjectArray(getoaSize(ob3)+getoaSize(ob4));
                     97:     for (i=0; i<getoaSize(ob3); i++) {
                     98:       putoa(aob,i,getoa(ob3,i));
                     99:     }
                    100:     for (i=0; i<getoaSize(ob4); i++) {
                    101:       putoa(aob,getoaSize(ob3)+i,getoa(ob4,i));
                    102:     }
                    103:   }else{
                    104:     aob = newObjectArray(2);
                    105:     putoa(aob,0,ob1);
                    106:     putoa(aob,1,ob2);
                    107:   }
1.5       takayama  108:   attr = newObjectArray(1);
                    109:   keyValue = newObjectArray(2);
1.6     ! takayama  110:   putoa(keyValue,0,KpoString("cd"));
        !           111:   putoa(keyValue,1,KpoString("arith1"));
1.5       takayama  112:   putoa(attr,0,keyValue);
1.1       takayama  113:   rob = newObjectArray(3);
1.6     ! takayama  114:   putoa(rob,0,KpoString("plus"));
1.5       takayama  115:   putoa(rob,1,attr);
1.1       takayama  116:   putoa(rob,2,aob);
                    117:   return(KpoTree(rob));
                    118: }
                    119:
1.2       takayama  120: /* XML DOM-like interfaces */
                    121: struct object KtreeGetDocumentElement(struct object to) {
                    122:   struct object rob;
                    123:   struct object ob;
1.3       takayama  124:   if (to.tag != Sclass) errorKan1("%s\n","KtreeGetDocumentElement");
                    125:   if (ectag(to) != CLASSNAME_tree) errorKan1("%s\n","KtreeGetDocumentElement");
1.2       takayama  126:   ob = KopTree(to);
1.4       takayama  127:   if (ob.tag != Sarray) errorKan1("%s\n","KtreeGetDocumentElement: not an array.");
                    128:   if (getoaSize(ob) != 3) errorKan1("%s\n","KtreeGetDocumentElement: array is broken.");
                    129:   ob=getoa(ob,0);
                    130:   if (ob.tag != Sdollar) errorKan1("%s\n","KtreeGetDocumentElement: element must be a string");
                    131:   return ob;
1.2       takayama  132: }
                    133:
                    134: struct object KtreeGetAttributes(struct object to) {
                    135:   struct object rob;
                    136:   struct object ob;
1.3       takayama  137:   if (to.tag != Sclass) errorKan1("%s\n","KtreeGetAttributes:");
                    138:   if (ectag(to) != CLASSNAME_tree) errorKan1("%s\n","KtreeGetAttributes:");
1.2       takayama  139:   ob = KopTree(to);
1.3       takayama  140:   if (ob.tag != Sarray) errorKan1("%s\n","KtreeGetAttributes: not an array.");
1.4       takayama  141:   if (getoaSize(ob) != 3) errorKan1("%s\n","KtreeGetAttributes: array is broken.");
1.2       takayama  142:   return getoa(ob,1);
                    143: }
                    144:
                    145: struct object KtreeGetChildNodes(struct object to) {
                    146:   struct object rob;
                    147:   struct object ob;
1.3       takayama  148:   if (to.tag != Sclass) errorKan1("%s\n","KtreeGetChildNodes:");
                    149:   if (ectag(to) != CLASSNAME_tree) errorKan1("%s\n","KtreeGetChildNodes:");
1.2       takayama  150:   ob = KopTree(to);
1.3       takayama  151:   if (ob.tag != Sarray) errorKan1("%s\n","KtreeGetChildNodes: not an array.");
1.4       takayama  152:   if (getoaSize(ob) != 3) errorKan1("%s\n","KtreeGetChildNodes: array is broken.");
1.2       takayama  153:   return getoa(ob,2);
                    154: }
                    155:
                    156: struct object KtreeCreateElement(struct object ostr) {
                    157:   struct object ob;
1.3       takayama  158:   if (ostr.tag != Sdollar) errorKan1("%s\n","KtreeCreateElement: not a string.");
1.2       takayama  159:   ob = newObjectArray(3);
                    160:   getoa(ob,0)=ostr;
                    161:   getoa(ob,1) = newObjectArray(0);
                    162:   getoa(ob,2) = newObjectArray(0);
                    163:   return KpoTree(ob);
                    164: }
1.1       takayama  165:

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