Annotation of OpenXM/src/kan96xx/Kan/kclass.c, Revision 1.3
1.3 ! takayama 1: /* $OpenXM: OpenXM/src/kan96xx/Kan/kclass.c,v 1.2 2000/01/16 07:55:39 takayama Exp $ */
1.1 maekawa 2: /* kclass.c, 1997, 3/1
3: This module handles class data base.
4: This is a top level and provides an interface for sm1 for Sclass objects.
5: Main processing is done in Kclass/*
6: See, Kclass/sample.h, Kclass/sample.c ;
7: grep the keyword CLASSNAME_sampleClass
8: */
9: #include <stdio.h>
10: #include "datatype.h"
11: #include "stackm.h"
12: #include "extern.h"
13: #include "gradedset.h"
14: #include "extern2.h"
15: #include "kclass.h"
16:
17: #define CLASSTABLE_SIZE 4096
18:
19:
20: struct object * ClassDictionaries[CLASSTABLE_SIZE];
21: char *ClassNames[CLASSTABLE_SIZE];
22: int ClassTypes[CLASSTABLE_SIZE];
23:
24: initClassDataBase() {
25: int i;
26: for (i=0; i<CLASSTABLE_SIZE; i++) {
27: ClassTypes[i] = CLASS_NOT_USED;
28: }
29: /* Initialize CLASS_INTERNAL */
30: ClassTypes[CLASSNAME_OPERANDSTACK] = CLASS_INTERNAL;
31: ClassNames[CLASSNAME_OPERANDSTACK] = "Class.OperandStack";
32: ClassDictionaries[CLASSNAME_OPERANDSTACK] = (struct object *)NULL;
33: /* We have to creat new dictionary in a future. */
34:
35: ClassTypes[CLASSNAME_ERROR_PACKET] = CLASS_OBJ;
36: ClassNames[CLASSNAME_ERROR_PACKET] = "Class.ErrorPacket";
37: ClassDictionaries[CLASSNAME_ERROR_PACKET] = (struct object *)NULL;
38: /* We have to creat new dictionary in a future. */
39:
40: ClassTypes[CLASSNAME_CONTEXT] = CLASS_INTERNAL;
41: ClassNames[CLASSNAME_CONTEXT] = "Class.Context";
42: ClassDictionaries[CLASSNAME_CONTEXT] = (struct object *)NULL;
43: /* We have to creat new dictionary in a future. */
44:
45: ClassTypes[CLASSNAME_GradedPolySet] = CLASS_INTERNAL;
46: ClassNames[CLASSNAME_GradedPolySet] = "Class.GradedPolySet";
47: ClassDictionaries[CLASSNAME_GradedPolySet] = (struct object *)NULL;
48: /* We have to creat new dictionary in a future. */
49:
50: ClassTypes[CLASSNAME_mathcap] = CLASS_OBJ;
51: ClassNames[CLASSNAME_mathcap] = "Class.mathcap";
52: ClassDictionaries[CLASSNAME_mathcap] = (struct object *)NULL;
53: /* We have to creat new dictionary in a future. */
54:
55: ClassTypes[CLASSNAME_CMO] = CLASS_OBJ;
56: ClassNames[CLASSNAME_CMO] = "Class.CMO";
57: ClassDictionaries[CLASSNAME_CMO] = (struct object *)NULL;
58: /* We have to creat new dictionary in a future. */
59:
60: ClassTypes[CLASSNAME_indeterminate] = CLASS_OBJ;
61: ClassNames[CLASSNAME_indeterminate] = "Class.indeterminate";
62: ClassDictionaries[CLASSNAME_indeterminate] = (struct object *)NULL;
63:
64: ClassTypes[CLASSNAME_tree] = CLASS_OBJ;
65: ClassNames[CLASSNAME_tree] = "Class.tree";
66: ClassDictionaries[CLASSNAME_tree] = (struct object *)NULL;
67:
68: ClassTypes[CLASSNAME_recursivePolynomial] = CLASS_OBJ;
69: ClassNames[CLASSNAME_recursivePolynomial] = "Class.recursivePolynomial";
70: ClassDictionaries[CLASSNAME_recursivePolynomial] = (struct object *)NULL;
71:
72: ClassTypes[CLASSNAME_polynomialInOneVariable] = CLASS_OBJ;
73: ClassNames[CLASSNAME_polynomialInOneVariable] = "Class.polynomialInOneVariable";
74: ClassDictionaries[CLASSNAME_polynomialInOneVariable] = (struct object *)NULL;
75:
76: ClassTypes[CLASSNAME_sampleClass] = CLASS_OBJ;
77: ClassNames[CLASSNAME_sampleClass] = "Class.sampleClass";
78: ClassDictionaries[CLASSNAME_sampleClass] = (struct object *)NULL;
79: /* We have to creat new dictionary in a future. */
80:
81: }
82:
83:
84: void fprintClass(FILE *fp,struct object obj) {
85: int tag;
86: tag = ectag(obj);
87: if (tag == -1) {
88: return ;
89: }
90: if (ClassTypes[tag] != CLASS_NOT_USED) {
91: fprintf(fp,"%s ",ClassNames[tag]);
92: }
93: switch(tag) {
94: case CLASSNAME_OPERANDSTACK:
95: break;
96: case CLASSNAME_ERROR_PACKET:
97: fprintErrorPacket(fp,KopErrorPacket(obj));
98: break;
99: case CLASSNAME_CONTEXT:
100: fprintContext(fp,KopContext(obj));
101: break;
102: case CLASSNAME_GradedPolySet:
103: outputGradedPolySet(KopGradedPolySet(obj),0);
104: break;
105: case CLASSNAME_mathcap:
106: fprintMathCap(fp,KopMathCap(obj));
107: break;
108: case CLASSNAME_CMO:
109: fprintCMOClass(fp,obj);
110: break;
111: case CLASSNAME_indeterminate:
112: fprintIndeterminate(fp,obj);
113: break;
114: case CLASSNAME_tree:
115: fprintTree(fp,obj);
116: break;
117: case CLASSNAME_recursivePolynomial:
118: fprintRecursivePolynomial(fp,obj);
119: break;
120: case CLASSNAME_polynomialInOneVariable:
121: fprintPolynomialInOneVariable(fp,obj);
122: break;
123: case CLASSNAME_sampleClass:
124: fprintSampleClass(fp,KopSampleClass(obj));
125: break;
126: default:
127: fprintf(fp,"Unknown class tag=%d.\n",tag);
128: break;
129: }
130: }
131:
132: int KclassEqualQ(struct object ob1,struct object ob2) {
133: if (ectag(ob1) != ectag(ob2)) return(0);
134: switch(ectag(ob1)) {
135: case CLASSNAME_OPERANDSTACK:
136: case CLASSNAME_CONTEXT:
137: if (ecbody(ob1) == ecbody(ob2)) return(1);
138: else return(0);
139: break;
140: case CLASSNAME_sampleClass:
141: return(eqSampleClass(KopSampleClass(ob1),KopSampleClass(ob2)));
142: break;
1.3 ! takayama 143: case CLASSNAME_indeterminate:
! 144: return(KooEqualQ(KopIndeterminate(ob1),KopIndeterminate(ob2)));
! 145: break;
1.1 maekawa 146: default:
147: errorKan1("%s\n","kclass.c (KclassEqualQ cannot compare these objects.)");
148: break;
149: }
150: }
151:
152: void fprintErrorPacket(FILE *fp,struct object *op)
153: {
154: printObject(*op,0,fp);
155: }
156:
157: void fprintMathCap(FILE *fp,struct object *op)
158: {
159: printObject(*op,0,fp);
160: }
161:
162: struct object KpoMathCap(struct object *obp) {
163: struct object rob;
164: struct object *newobp;
165:
166: newobp = (struct object *) sGC_malloc(sizeof(struct object));
167: /* Yes! You can call KpoMathCap(&localVar) */
168: if (newobp == NULL) errorKan1("%s\n","kclass.c, no more memory.");
169: *newobp = *obp;
170:
171: rob.tag = Sclass;
172: rob.lc.ival = CLASSNAME_mathcap;
173: rob.rc.voidp = newobp;
174: return(rob);
175: }
176:
177: /* try
178: [ 1 2 3] [(class) (sampleClass)] dc ::
179: */
180: struct object KclassDataConversion(struct object ob1,struct object ob2)
181: { /* It is called from primitive.c data_conversion. */
182: /* This function handles the following situnation.
183: (This is not yet documented.)
184: ob1 [(class) (class-name)] dc : method=1
185: ob1(with class tag) [(class) (class-name)] dc : method=2
186: ob1(with class tag) (usual flag) dc : method=3
187: It also create a new class object.
188: */
189: struct object rob = NullObject;
190: int method ;
191: struct object ff0;
192: struct object ff1;
193: struct object ob3; /* for work.*/
194: struct object ob4;
195: char *ccc;
196: char *key;
197:
198: if (ob1.tag == Sclass && ob2.tag == Sarray) {
199: method = 2;
200: }else if (ob1.tag == Sclass && ob2.tag == Sdollar) {
201: method = 3;
202: }else if (ob1.tag != Sclass && ob2.tag == Sarray) {
203: method = 1;
204: }else{
205: errorKan1("%s\n","kclass.c : KclassDataConversion() cannot make this data conversion.");
206: }
207: switch(method) {
208: case 1:
209: if (getoaSize(ob2) != 2) errorKan1("%s\n","kclass.c : KclassDataConversion() the second argument should be [(class) (class-name)]");
210: ff0 = getoa(ob2,0); ff1 = getoa(ob2,1);
211: if (ff0.tag != Sdollar || ff1.tag != Sdollar)
212: errorKan1("%s\n","kclass.c : KclassDataConversion() the second argument should be [(class) (class-name)]");
213: if (strcmp("class",KopString(ff0)) != 0)
214: errorKan1("%s\n","kclass.c : KclassDataConversion() the second argument should be [(class) (class-name)] (class)!!!");
215:
216: ccc = KopString(ff1); /* target data type */
217:
218: /* From primitive to Class object */
219:
220: if (strcmp(ccc,"sampleClass") == 0) {
221: rob = KpoSampleClass(&ob1);
222: }else if (strcmp(ccc,"errorPacket") == 0) {
223: if (ob1.tag != Sarray) errorKan1("%s\n","kclass.c : KclassDataConversion , !array --> errorPacket is not supported.");
224: if (getoaSize(ob1) != 3) errorKan1("%s\n","kclass.c : KclassDataConversion , only [integer, integer, string] --> errorPacket is supported.");
225: if (getoa(ob1,0).tag != Sinteger) errorKan1("%s\n","kclass.c : KclassDataConversion , only [integer, integer, string] --> errorPacket is supported.");
226: if (getoa(ob1,1).tag != Sinteger) errorKan1("%s\n","kclass.c : KclassDataConversion , only [integer, integer, string] --> errorPacket is supported.");
227: if (getoa(ob1,2).tag != Sdollar) errorKan1("%s\n","kclass.c : KclassDataConversion , only [integer, integer, string] --> errorPacket is supported.");
228: rob = KnewErrorPacketObj(ob1);
229: }else if (strcmp(ccc,"indeterminate") == 0) {
230: if (ob1.tag != Sdollar) errorKan1("%s\n","kclass.c : KclassDataConversion , !String --> indeterminate is not supported.");
231: rob = KpoIndeterminate(ob1);
232: }else if (strcmp(ccc,"mathcap") == 0) {
233: /* You should check ob1 contains mathcap data or not.
234: I've not yet written them.
235: */
236: rob = KpoMathCap(&ob1);
237: }else if (strcmp(ccc,"tree") == 0) {
1.3 ! takayama 238: if (ob1.tag != Sarray) errorKan1("%s\n","kclass.c : KclassDataConversion , !array --> tree is not supported.");
1.1 maekawa 239: rob = KpoTree(ob1);
240: }else if (strcmp(ccc,"recursivePolynomial") == 0) {
241: if (ob1.tag != Spoly) errorKan1("%s\n","kclass.c : KclassDataConversion , !poly --> recursivePoly is not supported.");
242: rob = polyToRecursivePoly(ob1);
243: }else{
244: errorKan1("%s\n","KclassDataConversion: this type of data conversion from primitive object to class object is not supported.");
245: }
246: break;
247: case 2:
248: if (getoaSize(ob2) != 2) errorKan1("%s\n","kclass.c : KclassDataConversion() the second argument should be [(class) (class-name)]");
249: ff0 = getoa(ob2,0); ff1 = getoa(ob2,1);
250: if (ff0.tag != Sdollar || ff1.tag != Sdollar)
251: errorKan1("%s\n","kclass.c : KclassDataConversion() the second argument should be [(class) (class-name)]");
252: if (strcmp("class",KopString(ff0)) != 0)
253: errorKan1("%s\n","kclass.c : KclassDataConversion() the second argument should be [(class) (class-name)] (class)!!!");
254:
255: ccc = KopString(ff1); /* target data type. */
256: switch(ectag(ob1)) {
257: case CLASSNAME_sampleClass:
258: if (strcmp(ccc,"sampleClass") == 0) {
259: rob = KpoSampleClass(&ob1);
260: }else{
261: errorKan1("%s\n","KclassDataCOnversion: this type of data conversion from class object to class object is not supported.");
262: }
263: break;
264: default:
265: errorKan1("%s\n","KclassDataConversion: this type of data conversion from class object to class object is not supported.");
266: }
267: break;
268: case 3:
269: key = KopString(ob2); /* target data type */
270: if (key[0] == 't' || key[0] =='e') {
271: if (strcmp(key,"type?")==0) {
272: rob = KpoInteger(ob1.tag);
273: return(rob);
274: }else if (strcmp(key,"type??")==0) {
275: if (ob1.tag != Sclass) {
276: rob = KpoInteger(ob1.tag);
277: }else {
278: rob = KpoInteger(ectag(ob1));
279: }
280: return(rob);
281: }else if (strcmp(key,"error")==0) {
282: rob = KnewErrorPacketObj(ob1);
283: return(rob);
284: }
285: }
286:
287: /* Class object to primtive Object */
288: switch(ectag(ob1)) {
289: case CLASSNAME_sampleClass:
290: if (strcmp(key,"array") == 0) {
291: rob = *(KopSampleClass(ob1));
292: }else{
293: errorKan1("%s\n","KclassDataCOnversion: this type of data conversion from class object to primitive object is not supported.");
294: }
295: break;
296: case CLASSNAME_mathcap:
297: if (strcmp(key,"array") == 0) {
298: rob = newObjectArray(2);
299: ob3 = KpoString("mathcap-object");
300: putoa(rob,0,ob3);
301: putoa(rob,1,*(KopMathCap(ob1)));
302: }else{
303: errorKan1("%s\n","KclassDataConversion: this type of data conversion from class object mathcap to primitive object is not supported.");
304: }
305: break;
306: case CLASSNAME_indeterminate:
307: if (strcmp(key,"string") == 0) {
308: rob = KopIndeterminate(ob1);
309: }else {
310: errorKan1("%s\n","KclassDataConversion: interminate-->?? is not supported..");
311: }
312: break;
313: case CLASSNAME_tree:
314: if (strcmp(key,"array") == 0) {
315: rob = KopTree(ob1);
316: }else {
317: errorKan1("%s\n","KclassDataConversion: tree-->?? is not supported..");
318: }
319: break;
320: case CLASSNAME_recursivePolynomial:
321: if (strcmp(key,"string") == 0) {
322: errorKan1("%s\n","Translation of recursive polynomial to a string should be implemented.");
323: }else if (strcmp(key,"poly") == 0) {
324: rob = recursivePolyToPoly(ob1);
325: }else if (strcmp(key,"array") == 0) {
326: rob = KopRecursivePolynomial(ob1);
327: }else {
328: errorKan1("%s\n","KclassDataConversion: recursivePoly-->?? is not supported..");
329: }
330: break;
331: default:
332: errorKan1("%s\n","KclassDataConversion: this type of data conversion from class object to primitive object is not supported.");
333: }
334: break;
335: }
336: return(rob);
337: }
338:
339: /* Arithmetic operations for class objects. */
340: struct object Kclass_ooAdd(struct object ob1, struct object ob2)
341: {
342: /* It is called from ooAdd(). */
343: /* ob1 or ob2 must have the class tag. */
344: struct object rob = NullObject;
345:
346: /* Default action */
347: rob = addTree(ob2,ob1);
348: return(rob);
349: }
350:
351:
352:
353:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to kclass.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM / src / kan96xx / Kan