earlybrowserreborn - Diff between revs 1 and 4

Subversion Repositories:
Rev:
Only display areas with differences - Ignore whitespace
Rev 1 Rev 4
1 /* 1 /*
2  * Copyright 1990 1991 Pei-Yuan Wei.  All rights reserved. 2  * Copyright 1990 1991 Pei-Yuan Wei.  All rights reserved.
3  * 3  *
4  * Permission to use, copy, and/or distribute for any purpose and 4  * Permission to use, copy, and/or distribute for any purpose and
5  * without fee is hereby granted, provided that both the above copyright 5  * without fee is hereby granted, provided that both the above copyright
6  * notice and this permission notice appear in all copies and derived works. 6  * notice and this permission notice appear in all copies and derived works.
7  * Fees for distribution or use of this software or derived works may only 7  * Fees for distribution or use of this software or derived works may only
8  * be charged with express written permission of the copyright holder. 8  * be charged with express written permission of the copyright holder.
9  * This software is provided ``as is'' without express or implied warranty. 9  * This software is provided ``as is'' without express or implied warranty.
10  */ 10  */
11 /* 11 /*
12  * class        : cosmic 12  * class        : cosmic
13  * superClass   : NULL 13  * superClass   : NULL
14  */ 14  */
15 #include "utils.h" 15 #include "utils.h"
16 #include <sys/file.h> 16 #include <sys/file.h>
17 #include "mystrings.h" 17 #include "mystrings.h"
18 #include "sys.h" 18 #include "sys.h"
19 #include "error.h" 19 #include "error.h"
20 #include "hash.h" 20 #include "hash.h"
21 #include "ident.h" 21 #include "ident.h"
22 #include "scanutils.h" 22 #include "scanutils.h"
23 #include "obj.h" 23 #include "obj.h"
24 #include "vlist.h" 24 #include "vlist.h"
25 #include "attr.h" 25 #include "attr.h"
26 #include "packet.h" 26 #include "packet.h"
27 #include "membership.h" 27 #include "membership.h"
28 #include "class.h" 28 #include "class.h"
29 #include "classlist.h" 29 #include "classlist.h"
30 #include "cl_cosmic.h" 30 #include "cl_cosmic.h"
31 #include "slotaccess.h" 31 #include "slotaccess.h"
32 #include "cexec.h" 32 #include "cexec.h"
33 #include "misc.h" 33 #include "misc.h"
34 #include "../libWWW/Library/Implementation/HTParse.h" 34 #include "../libWWW/Library/Implementation/HTParse.h"
35 35
36 /* for test1() */ 36 /* for test1() */
37 #include "glib.h" 37 #include "glib.h"
38 #include "slib.h" 38 #include "slib.h"
39 #include "misc.h" 39 #include "misc.h"
40 #include "event.h" 40 #include "event.h"
41 #include "tfed.h" 41 #include "tfed.h"
42 42
43 /* test4, for math */ 43 /* test4, for math */
44 #include "htmath.h" 44 #include "htmath.h"
45 45
46 #include "ast.h" 46 #include "ast.h"
47 #include "cgen.h" 47 #include "cgen.h"
48 48
49 int notSecure(self) 49 int notSecure(self)
50      VObj *self; 50      VObj *self;
51 { 51 {
52         if (GET_security(self) > 0) { 52         if (GET_security(self) > 0) {
53                 fprintf(stderr, 53                 fprintf(stderr,
54                 "loadFile(): execution denied to object '%s' (security=%d)\n", 54                 "loadFile(): execution denied to object '%s' (security=%d)\n",
55                 GET_name(self), GET_security(self)); 55                 GET_name(self), GET_security(self));
56                 return 1; 56                 return 1;
57         } 57         }
58         return 0; 58         return 0;
59 } 59 }
60         60        
61 61
62 62
63 SlotInfo cl_cosmic_NCSlots[] = { 63 SlotInfo cl_cosmic_NCSlots[] = {
64 { 64 {
65         STR_class, 65         STR_class,
66         PTRS | SLOT_RW, 66         PTRS | SLOT_RW,
67         (long)"cosmic" 67         (long)"cosmic"
68 },{ 68 },{
69         STR_classScript, 69         STR_classScript,
70         PTRS, 70         PTRS,
71         (long)"\n\ 71         (long)"\n\
72                 switch (arg[0]) {\n\ 72                 switch (arg[0]) {\n\
73                 case \"config\":\n\ 73                 case \"config\":\n\
74                         config(arg[1], arg[2], arg[3], arg[4]);\n\ 74                         config(arg[1], arg[2], arg[3], arg[4]);\n\
75                 break;\n\ 75                 break;\n\
76                 case \"expose\":\n\ 76                 case \"expose\":\n\
77                 case \"render\":\n\ 77                 case \"render\":\n\
78                         expose(arg[1], arg[2], arg[3], arg[4]);\n\ 78                         expose(arg[1], arg[2], arg[3], arg[4]);\n\
79                         render();\n\ 79                         render();\n\
80                 break;\n\ 80                 break;\n\
81                 case \"init\":\n\ 81                 case \"init\":\n\
82                         initialize();\n\ 82                         initialize();\n\
83                 break;\n\ 83                 break;\n\
84                 case \"freeSelf\":\n\ 84                 case \"freeSelf\":\n\
85                         freeSelf();\n\ 85                         freeSelf();\n\
86                 break;\n\ 86                 break;\n\
87                 default:\n\ 87                 default:\n\
88                         print(\"unknown message, clsss = cosmic: args: \");\n\ 88                         print(\"unknown message, clsss = cosmic: args: \");\n\
89                         for (i =0; i < arg[]; i++) print(arg[i], \", \");\n\ 89                         for (i =0; i < arg[]; i++) print(arg[i], \", \");\n\
90                         print(\"\\n\");\n\ 90                         print(\"\\n\");\n\
91                         break;\n\ 91                         break;\n\
92                 }\n\ 92                 }\n\
93         ", 93         ",
94 },{ 94 },{
95         STR__classScript, 95         STR__classScript,
96         PCOD, 96         PCOD,
97         NULL, 97         NULL,
98 },{ 98 },{
99         NULL 99         NULL
100 } 100 }
101 }; 101 };
102 SlotInfo cl_cosmic_NPSlots[] = { 102 SlotInfo cl_cosmic_NPSlots[] = {
103 { 103 {
104         STR__classInfo, 104         STR__classInfo,
105         CLSI, 105         CLSI,
106         (long)&class_cosmic 106         (long)&class_cosmic
107 },{ 107 },{
108         STR__memoryGroup, 108         STR__memoryGroup,
109         PTRV, 109         PTRV,
110         NULL, 110         NULL,
111 },{ 111 },{
112         NULL 112         NULL
113 } 113 }
114 }; 114 };
115 SlotInfo cl_cosmic_CSlots[] = { 115 SlotInfo cl_cosmic_CSlots[] = {
116         NULL 116         NULL
117 }; 117 };
118 SlotInfo cl_cosmic_PSlots[] = { 118 SlotInfo cl_cosmic_PSlots[] = {
119         NULL 119         NULL
120 }; 120 };
121 121
122 SlotInfo *slots_cosmic[] = { 122 SlotInfo *slots_cosmic[] = {
123         (SlotInfo*)cl_cosmic_NCSlots, 123         (SlotInfo*)cl_cosmic_NCSlots,
124         (SlotInfo*)cl_cosmic_NPSlots, 124         (SlotInfo*)cl_cosmic_NPSlots,
125         (SlotInfo*)cl_cosmic_CSlots, 125         (SlotInfo*)cl_cosmic_CSlots,
126         (SlotInfo*)cl_cosmic_PSlots 126         (SlotInfo*)cl_cosmic_PSlots
127 }; 127 };
128 128
129 MethodInfo meths_cosmic[] = { 129 MethodInfo meths_cosmic[] = {
130 { 130 {
131         STR_clone, 131         STR_clone,
132         meth_cosmic_clone 132         meth_cosmic_clone
133 },{ 133 },{
134         STR_clone2, 134         STR_clone2,
135         meth_cosmic_clone2 135         meth_cosmic_clone2
136 },{ 136 },{
137         STR_cloneID, 137         STR_cloneID,
138         meth_cosmic_cloneID 138         meth_cosmic_cloneID
139 },{ 139 },{
140         STR_create, 140         STR_create,
141         meth_cosmic_create 141         meth_cosmic_create
142 },{ 142 },{
143         STR_debug, 143         STR_debug,
144         meth_cosmic_debug 144         meth_cosmic_debug
145 },{ 145 },{
146         STR_detach, 146         STR_detach,
147         meth_cosmic_detach 147         meth_cosmic_detach
148 },{ 148 },{
149         STR_destroy, 149         STR_destroy,
150         meth_cosmic_destroy 150         meth_cosmic_destroy
151 },{ 151 },{
152         STR_exit, 152         STR_exit,
153         meth_cosmic_exit 153         meth_cosmic_exit
154 },{ 154 },{
155         STR_exist, 155         STR_exist,
156         meth_cosmic_exist 156         meth_cosmic_exist
157 },{ 157 },{
158         STR_freeSelf, 158         STR_freeSelf,
159         meth_cosmic_freeSelf 159         meth_cosmic_freeSelf
160 },{ 160 },{
161         STR_info, 161         STR_info,
162         meth_cosmic_info 162         meth_cosmic_info
163 },{ 163 },{
164         STR_interpret, 164         STR_interpret,
165         meth_cosmic_interpret 165         meth_cosmic_interpret
166 },{ 166 },{
167         STR_loadObjFile, 167         STR_loadObjFile,
168         meth_cosmic_loadObjFile 168         meth_cosmic_loadObjFile
169 },{ 169 },{
170         STR_modalExit, 170         STR_modalExit,
171         meth_cosmic_modalExit 171         meth_cosmic_modalExit
172 },{ 172 },{
173         STR_object, 173         STR_object,
174         meth_cosmic_object 174         meth_cosmic_object
175 },{ 175 },{
176         STR_pop, 176         STR_pop,
177         meth_cosmic_pop 177         meth_cosmic_pop
178 },{ 178 },{
179         STR_push, 179         STR_push,
180         meth_cosmic_push 180         meth_cosmic_push
181 },{ 181 },{
182         STR_quit, 182         STR_quit,
183         meth_cosmic_quit 183         meth_cosmic_quit
184 },{ 184 },{
185         STR_save, 185         STR_save,
186         meth_cosmic_save 186         meth_cosmic_save
187 },{ 187 },{
188         STR_saveAs, 188         STR_saveAs,
189         meth_cosmic_saveAs 189         meth_cosmic_saveAs
190 },{ 190 },{
191         STR_send, 191         STR_send,
192         meth_cosmic_send 192         meth_cosmic_send
193 },{ 193 },{
194         STR_test1, 194         STR_test1,
195         meth_cosmic_test1 195         meth_cosmic_test1
196 },{ 196 },{
197         STR_test2, 197         STR_test2,
198         meth_cosmic_test2 198         meth_cosmic_test2
199 },{ 199 },{
200         STR_test3, 200         STR_test3,
201         meth_cosmic_test3 201         meth_cosmic_test3
202 },{ 202 },{
203         STR_test4, 203         STR_test4,
204         meth_cosmic_test4 204         meth_cosmic_test4
205 },{ 205 },{
206         STR_tweak, 206         STR_tweak,
207         meth_cosmic_tweak 207         meth_cosmic_tweak
208 },{ 208 },{
209         STR_usual, 209         STR_usual,
210         meth_cosmic_usual 210         meth_cosmic_usual
211 },{ 211 },{
212         NULL 212         NULL
213 } 213 }
214 }; 214 };
215 215
216 ClassInfo class_cosmic = { 216 ClassInfo class_cosmic = {
217         helper_cosmic_get, 217         helper_cosmic_get,
218         helper_cosmic_set, 218         helper_cosmic_set,
219         slots_cosmic,           /* class slot information       */ 219         slots_cosmic,           /* class slot information       */
220         meths_cosmic,           /* class methods                */ 220         meths_cosmic,           /* class methods                */
221         STR_cosmic,             /* class identifier number      */ 221         STR_cosmic,             /* class identifier number      */
222         NULL,                   /* super class                  */ 222         NULL,                   /* super class                  */
223 }; 223 };
224 224
225 int global_cloneID = 0; 225 int global_cloneID = 0;
226 226
227 void sendInitToChildren(self) 227 void sendInitToChildren(self)
228         VObj *self; 228         VObj *self;
229 { 229 {
230         Packet *result = borrowPacket(); 230         Packet *result = borrowPacket();
231         VObjList *olist; 231         VObjList *olist;
232 232
233         if (!callMeth(self, result, 0, NULL, STR_initialize)) { 233         if (!callMeth(self, result, 0, NULL, STR_initialize)) {
234                 fprintf(stderr, "clone ``%s''not properly initialized\n", 234                 fprintf(stderr, "clone ``%s''not properly initialized\n",
235                         GET_name(self)); 235                         GET_name(self));
236                 /* error */ 236                 /* error */
237         } 237         }
238         for (olist = GET__children(self); olist; olist = olist->next) 238         for (olist = GET__children(self); olist; olist = olist->next)
239                 if (olist->o) sendInitToChildren(olist->o); 239                 if (olist->o) sendInitToChildren(olist->o);
240 240
241         returnPacket(); 241         returnPacket();
242 } 242 }
243 243
244 int helper_cosmic_get(self, result, argc, argv, labelID) 244 int helper_cosmic_get(self, result, argc, argv, labelID)
245         VObj *self; 245         VObj *self;
246         Packet *result; 246         Packet *result;
247         int argc; 247         int argc;
248         Packet argv[]; 248         Packet argv[];
249         int labelID; 249         int labelID;
250 { 250 {
251         return 0; 251         return 0;
252 }       252 }      
253 253
254 int helper_cosmic_set(self, result, argc, argv, labelID) 254 int helper_cosmic_set(self, result, argc, argv, labelID)
255         VObj *self; 255         VObj *self;
256         Packet *result; 256         Packet *result;
257         int argc; 257         int argc;
258         Packet argv[]; 258         Packet argv[];
259         int labelID; 259         int labelID;
260 { 260 {
261         return 0; 261         return 0;
262 }       262 }      
263 263
264 /* 264 /*
265  * clone(clone name suffix) 265  * clone(clone name suffix)
266  * 266  *
267  * Make a clone self 267  * Make a clone self
268  * 268  *
269  * Result: clone object, and optinally name it 269  * Result: clone object, and optinally name it
270  * Return: 1 if successful, 0 if error occured 270  * Return: 1 if successful, 0 if error occured
271  */ 271  */
272 int meth_cosmic_clone(self, result, argc, argv) 272 int meth_cosmic_clone(self, result, argc, argv)
273         VObj *self; 273         VObj *self;
274         Packet *result; 274         Packet *result;
275         int argc; 275         int argc;
276         Packet argv[]; 276         Packet argv[];
277 { 277 {
278         VObj *cloneObj; 278         VObj *cloneObj;
279 279
280         if (!meth_cosmic_clone2(self, result, argc, argv)) return 0; 280         if (!meth_cosmic_clone2(self, result, argc, argv)) return 0;
281         cloneObj = result->info.o; 281         cloneObj = result->info.o;
282         if (cloneObj) { 282         if (cloneObj) {
283                 sendInitToChildren(cloneObj); 283                 sendInitToChildren(cloneObj);
284                 result->type = PKT_OBJ; 284                 result->type = PKT_OBJ;
285                 result->info.o = cloneObj; 285                 result->info.o = cloneObj;
286                 result->canFree = 0; 286                 result->canFree = 0;
287                 return 1; 287                 return 1;
288         } 288         }
289         result->type = PKT_OBJ; 289         result->type = PKT_OBJ;
290         result->info.o = NULL; 290         result->info.o = NULL;
291         result->canFree = 0; 291         result->canFree = 0;
292         return 0; 292         return 0;
293 } 293 }
294 294
295 int meth_cosmic_clone2(self, result, argc, argv) 295 int meth_cosmic_clone2(self, result, argc, argv)
296         VObj *self; 296         VObj *self;
297         Packet *result; 297         Packet *result;
298         int argc; 298         int argc;
299         Packet argv[]; 299         Packet argv[];
300 { 300 {
301         char *suffix; 301         char *suffix;
302         VObj *cloneObj; 302         VObj *cloneObj;
303         char *sp1, *sp2, newName[255]; 303         char *sp1, *sp2, newName[255];
304 304
305         cloneObj = clone(self); 305         cloneObj = clone(self);
306 306
307         suffix = PkInfo2Str(&argv[0]); 307         suffix = PkInfo2Str(&argv[0]);
308         if (!cloneObj || !suffix) { 308         if (!cloneObj || !suffix) {
309                 result->type = PKT_OBJ; 309                 result->type = PKT_OBJ;
310                 result->info.o = NULL; 310                 result->info.o = NULL;
311                 result->canFree = 0; 311                 result->canFree = 0;
312                 return 0; 312                 return 0;
313         } 313         }
314 314
315         /*XXX later, put class mg size in class public space */ 315         /*XXX later, put class mg size in class public space */
316 /*      SET__memoryGroup(cloneObj, newMemoryGroup(512)); 316 /*      SET__memoryGroup(cloneObj, newMemoryGroup(512));
317 */ 317 */
318         /*sprintf(newName, "%s%s", GET_name(cloneObj), suffix); 318         /*sprintf(newName, "%s%s", GET_name(cloneObj), suffix);
319          */ 319          */
320         for (sp1 = newName, sp2 = GET_name(cloneObj); *sp2;) *sp1++ = *sp2++; 320         for (sp1 = newName, sp2 = GET_name(cloneObj); *sp2;) *sp1++ = *sp2++;
321         for (sp2 = suffix; *sp2;) *sp1++ = *sp2++; 321         for (sp2 = suffix; *sp2;) *sp1++ = *sp2++;
322         *sp1++ = '\0'; 322         *sp1++ = '\0';
323         323        
324         SET_name(cloneObj, saveStringN(newName, sp1 - newName)); 324         SET_name(cloneObj, saveStringN(newName, sp1 - newName));
325 325
326         objID2Obj->put_replace(objID2Obj, 326         objID2Obj->put_replace(objID2Obj,
327                              storeIdent(saveString(GET_name(cloneObj))), 327                              storeIdent(saveString(GET_name(cloneObj))),
328                              (int)cloneObj); 328                              (int)cloneObj);
329 329
330         objObj2ExistP->put_replace(objObj2ExistP, cloneObj, (int)1); 330         objObj2ExistP->put_replace(objObj2ExistP, cloneObj, (int)1);
331 331
332         result->type = PKT_OBJ; 332         result->type = PKT_OBJ;
333         result->info.o = cloneObj; 333         result->info.o = cloneObj;
334         result->canFree = 0; 334         result->canFree = 0;
335         return 1; 335         return 1;
336 } 336 }
337 337
338 int meth_cosmic_cloneID(self, result, argc, argv) 338 int meth_cosmic_cloneID(self, result, argc, argv)
339         VObj *self; 339         VObj *self;
340         Packet *result; 340         Packet *result;
341         int argc; 341         int argc;
342         Packet argv[]; 342         Packet argv[];
343 { 343 {
344         result->info.i = global_cloneID++; 344         result->info.i = global_cloneID++;
345         result->type = PKT_INT; 345         result->type = PKT_INT;
346         result->canFree = 0; 346         result->canFree = 0;
347         return 1; 347         return 1;
348 } 348 }
349 349
350 /* 350 /*
351  * create(<attributes list>) 351  * create(<attributes list>)
352  * 352  *
353  * Result: created object 353  * Result: created object
354  * Return: 1 if successful, 0 if error occured 354  * Return: 1 if successful, 0 if error occured
355  */ 355  */
356 int meth_cosmic_create(self, result, argc, argv) 356 int meth_cosmic_create(self, result, argc, argv)
357         VObj *self; 357         VObj *self;
358         Packet *result; 358         Packet *result;
359         int argc; 359         int argc;
360         Packet argv[]; 360         Packet argv[];
361 { 361 {
362         int slotv[100][2], slotc = 0, i; 362         int slotv[100][2], slotc = 0, i;
363         char *cp; 363         char *cp;
364         HashEntry *entry; 364         HashEntry *entry;
365         VObj *obj; 365         VObj *obj;
366 366
367         result->type = PKT_OBJ; 367         result->type = PKT_OBJ;
368         result->info.o = NULL; 368         result->info.o = NULL;
369 369
370         for (slotc = 0, i = 0; i < argc; slotc++, i += 2) { 370         for (slotc = 0, i = 0; i < argc; slotc++, i += 2) {
371                 cp = PkInfo2Str(&argv[i]); 371                 cp = PkInfo2Str(&argv[i]);
372                 if (!cp) { 372                 if (!cp) {
373                         printf("create(): unknown attribute:"); 373                         printf("create(): unknown attribute:");
374                         dumpPacket(&argv[i]); 374                         dumpPacket(&argv[i]);
375                         printf("\n"); 375                         printf("\n");
376                         return 0; 376                         return 0;
377                 } 377                 }
378                 entry = symStr2ID->get(symStr2ID, (int)cp); 378                 entry = symStr2ID->get(symStr2ID, (int)cp);
379                 if (!entry) { 379                 if (!entry) {
380                         printf("create(): unknown attribute: \"%s\"\n", cp); 380                         printf("create(): unknown attribute: \"%s\"\n", cp);
381                         return 0; 381                         return 0;
382                 } 382                 }
383                 slotv[slotc][0] = (int)(entry->val); 383                 slotv[slotc][0] = (int)(entry->val);
384                 slotv[slotc][1] = (int)saveString(PkInfo2Str(&argv[i + 1])); 384                 slotv[slotc][1] = (int)saveString(PkInfo2Str(&argv[i + 1]));
385         } 385         }
386         if (slotc <= 0) return 0; 386         if (slotc <= 0) return 0;
387 387
388         if (obj = instantiateObj(slotv, &slotc)) { 388         if (obj = instantiateObj(slotv, &slotc)) {
389                 objID2Obj->put_replace(objID2Obj, 389                 objID2Obj->put_replace(objID2Obj,
390                                      storeIdent(saveString(GET_name(obj))), 390                                      storeIdent(saveString(GET_name(obj))),
391                                      (int)obj); 391                                      (int)obj);
392                 objObj2ExistP->put_replace(objObj2ExistP, obj, 1); 392                 objObj2ExistP->put_replace(objObj2ExistP, obj, 1);
393 /*              SET__memoryGroup(obj, newMemoryGroup(1024)); 393 /*              SET__memoryGroup(obj, newMemoryGroup(1024));
394 */ 394 */
395                 sendMessage1(obj, "init"); 395                 sendMessage1(obj, "init");
396                 freePossibleDangler(result); 396                 freePossibleDangler(result);
397                 result->type = PKT_OBJ; 397                 result->type = PKT_OBJ;
398                 result->info.o = obj; 398                 result->info.o = obj;
399                 result->canFree = 0; 399                 result->canFree = 0;
400                 return 1; 400                 return 1;
401         } else { 401         } else {
402                 fprintf(stderr, "create(): failed to create object.\n"); 402                 fprintf(stderr, "create(): failed to create object.\n");
403                 return 0; 403                 return 0;
404         } 404         }
405 } 405 }
406 406
407 /* 407 /*
408  * detach() 408  * detach()
409  * 409  *
410  * 410  *
411  * Result: 411  * Result:
412  * Return: 412  * Return:
413  */ 413  */
414 int meth_cosmic_detach(self, result, argc, argv) 414 int meth_cosmic_detach(self, result, argc, argv)
415         VObj *self; 415         VObj *self;
416         Packet *result; 416         Packet *result;
417         int argc; 417         int argc;
418         Packet argv[]; 418         Packet argv[];
419 { 419 {
420         clearPacket(result); 420         clearPacket(result);
421         return 0; 421         return 0;
422 } 422 }
423 423
424 /* 424 /*
425  * debug() 425  * debug()
426  * 426  *
427  * Used to turn on/off various debugging flags. 427  * Used to turn on/off various debugging flags.
428  * 428  *
429  * Result: 429  * Result:
430  * Return: 430  * Return:
431  */ 431  */
432 int meth_cosmic_debug(self, result, argc, argv) 432 int meth_cosmic_debug(self, result, argc, argv)
433         VObj *self; 433         VObj *self;
434         Packet *result; 434         Packet *result;
435         int argc; 435         int argc;
436         Packet argv[]; 436         Packet argv[];
437 { 437 {
438         clearPacket(result); 438         clearPacket(result);
439         if (!STRCMP(PkInfo2Str(&argv[0]), "pa")) { 439         if (!STRCMP(PkInfo2Str(&argv[0]), "pa")) {
440                 extern int flag_printAST; 440                 extern int flag_printAST;
441                 flag_printAST = PkInfo2Int(&argv[1]); 441                 flag_printAST = PkInfo2Int(&argv[1]);
442         } else if (!STRCMP(PkInfo2Str(&argv[0]), "pc")) { 442         } else if (!STRCMP(PkInfo2Str(&argv[0]), "pc")) {
443                 extern int flag_printPCode; 443                 extern int flag_printPCode;
444                 flag_printPCode = PkInfo2Int(&argv[1]); 444                 flag_printPCode = PkInfo2Int(&argv[1]);
445         } else if (!STRCMP(PkInfo2Str(&argv[0]), "pe")) { 445         } else if (!STRCMP(PkInfo2Str(&argv[0]), "pe")) {
446                 extern int flag_printExec; 446                 extern int flag_printExec;
447                 flag_printExec = PkInfo2Int(&argv[1]); 447                 flag_printExec = PkInfo2Int(&argv[1]);
448         } else if (!STRCMP(PkInfo2Str(&argv[0]), "dumpPCode")) { 448         } else if (!STRCMP(PkInfo2Str(&argv[0]), "dumpPCode")) {
449                 int pc = 0; 449                 int pc = 0;
450                 union PCode *pcode = GET__script(self); 450                 union PCode *pcode = GET__script(self);
451 451
452                 printPCode(&pcode[PCODE_IDX_INSTR], 452                 printPCode(&pcode[PCODE_IDX_INSTR],
453                            &pc, 453                            &pc,
454                            pcode[PCODE_IDX_SIZE].i); 454                            pcode[PCODE_IDX_SIZE].i);
455         } 455         }
456         return 1; 456         return 1;
457 } 457 }
458 458
459 /* 459 /*
460  * destroy() 460  * destroy()
461  * 461  *
462  * 462  *
463  * Result: 463  * Result:
464  * Return: 464  * Return:
465  */ 465  */
466 int meth_cosmic_destroy(self, result, argc, argv) 466 int meth_cosmic_destroy(self, result, argc, argv)
467         VObj *self; 467         VObj *self;
468         Packet *result; 468         Packet *result;
469         int argc; 469         int argc;
470         Packet argv[]; 470         Packet argv[];
471 { 471 {
472         if (notSecure(self)) return 0; 472         if (notSecure(self)) return 0;
473         clearPacket(result); 473         clearPacket(result);
474         free(self); 474         free(self);
475         /* and remove from object list...*/ 475         /* and remove from object list...*/
476         return 1; 476         return 1;
477 } 477 }
478 478
479 /* 479 /*
480  * exit(value) 480  * exit(value)
481  * 481  *
482  * Exit viola with specified value. 482  * Exit viola with specified value.
483  * 483  *
484  * Result: n/a 484  * Result: n/a
485  * Return: n/a 485  * Return: n/a
486  */ 486  */
487 int meth_cosmic_exit(self, result, argc, argv) 487 int meth_cosmic_exit(self, result, argc, argv)
488         VObj *self; 488         VObj *self;
489         Packet *result; 489         Packet *result;
490         int argc; 490         int argc;
491         Packet argv[]; 491         Packet argv[];
492 { 492 {
493         if (notSecure(self)) return 0; 493         if (notSecure(self)) return 0;
494 494
495         exit(PkInfo2Int(&argv[0])); 495         exit(PkInfo2Int(&argv[0]));
496 } 496 }
497 497
498 /* 498 /*
499  * exist(<obj name>) 499  * exist(<obj name>)
500  * 500  *
501  * Determines whether if an object is currently loaded. 501  * Determines whether if an object is currently loaded.
502  * 502  *
503  * Result: 503  * Result:
504  * Return: 504  * Return:
505  */ 505  */
506 int meth_cosmic_exist(self, result, argc, argv) 506 int meth_cosmic_exist(self, result, argc, argv)
507         VObj *self; 507         VObj *self;
508         Packet *result; 508         Packet *result;
509         int argc; 509         int argc;
510         Packet argv[]; 510         Packet argv[];
511 { 511 {
512         HashEntry *entry; 512         HashEntry *entry;
513         VObj *obj = PkInfo2Obj(&argv[0]); 513         VObj *obj = PkInfo2Obj(&argv[0]);
514 514
515         result->type = PKT_INT; 515         result->type = PKT_INT;
516         result->canFree = 0; 516         result->canFree = 0;
517 517
518         if (obj) { 518         if (obj) {
519                 if (entry = objObj2ExistP->get(objObj2ExistP, (int)obj)) { 519                 if (entry = objObj2ExistP->get(objObj2ExistP, (int)obj)) {
520                         result->info.i = 1; 520                         result->info.i = 1;
521                         return 1; 521                         return 1;
522                 } 522                 }
523         } 523         }
524 /* 524 /*
525         char *objName; 525         char *objName;
526         if (entry = objID2Obj->get(objID2Obj, (int)getIdent(objName))) { 526         if (entry = objID2Obj->get(objID2Obj, (int)getIdent(objName))) {
527                 if (entry = symStr2ID->get(symStr2ID, (int)objName)) { 527                 if (entry = symStr2ID->get(symStr2ID, (int)objName)) {
528                         if (findObject(entry->val)) { 528                         if (findObject(entry->val)) {
529                                 result->info.i = 1; 529                                 result->info.i = 1;
530                                 return 1; 530                                 return 1;
531                         } 531                         }
532                 } 532                 }
533         } 533         }
534 */ 534 */
535         result->info.i = 0; 535         result->info.i = 0;
536         return 1; 536         return 1;
537 } 537 }
538 538
539 /* 539 /*
540  * freeSelf() 540  * freeSelf()
541  * 541  *
542  * 542  *
543  * Result: 543  * Result:
544  * Return: 544  * Return:
545  */ 545  */
546 int meth_cosmic_freeSelf(self, result, argc, argv) 546 int meth_cosmic_freeSelf(self, result, argc, argv)
547         VObj *self; 547         VObj *self;
548         Packet *result; 548         Packet *result;
549         int argc; 549         int argc;
550         Packet argv[]; 550         Packet argv[];
551 { 551 {
552         int i; 552         int i;
553 553
554         for (i = 0; i < callObjStackIdx; i++) { 554         for (i = 0; i < callObjStackIdx; i++) {
555                 if (callObjStack[i].obj == self) 555                 if (callObjStack[i].obj == self)
556                         callObjStack[i].destroyed = 1; 556                         callObjStack[i].destroyed = 1;
557         } 557         }
558         if (!exitingViola) { 558         if (!exitingViola) {
559                 cancelEventByObject(self); /* in case an event is coming */ 559                 cancelEventByObject(self); /* in case an event is coming */
560 560
561                 /* quite vain */ 561                 /* quite vain */
562                 SET__classInfo(self, NULL); 562                 SET__classInfo(self, NULL);
563 563
564                 free(self); 564                 free(self);
565                 /* and remove from object list...*/ 565                 /* and remove from object list...*/
566         } 566         }
567         clearPacket(result); 567         clearPacket(result);
568         return 1; 568         return 1;
569 } 569 }
570 570
571 /* 571 /*
572  * info(<info flag>) 572  * info(<info flag>)
573  * 573  *
574  * Info flags: 574  * Info flags:
575  *      <none> 575  *      <none>
576  *              Print to stdout slot values for the calling object. 576  *              Print to stdout slot values for the calling object.
577  *      "listAllMethods" 577  *      "listAllMethods"
578  *              Print to stdout name of methods in all classes. 578  *              Print to stdout name of methods in all classes.
579  *      "listMethods" 579  *      "listMethods"
580  *              Print to stdout name of methods in calling obj's class. 580  *              Print to stdout name of methods in calling obj's class.
581  *      "listSlotsRW" 581  *      "listSlotsRW"
582  *      "listSlotsR" 582  *      "listSlotsR"
583  *      "listSlotsW" 583  *      "listSlotsW"
584  *              Print to stdout slot values for the calling object, 584  *              Print to stdout slot values for the calling object,
585  *              filterd by SLOT_R/W flags. 585  *              filterd by SLOT_R/W flags.
586  *      "listAllObjects" 586  *      "listAllObjects"
587  *              List to stdout name of all loaded objects. 587  *              List to stdout name of all loaded objects.
588  * 588  *
589  * Result: 589  * Result:
590  * Return: 590  * Return:
591  */ 591  */
592 int meth_cosmic_info(self, result, argc, argv) 592 int meth_cosmic_info(self, result, argc, argv)
593         VObj *self; 593         VObj *self;
594         Packet *result; 594         Packet *result;
595         int argc; 595         int argc;
596         Packet argv[]; 596         Packet argv[];
597 { 597 {
598         char *cp; 598         char *cp;
599         extern int fprintf(); -  
-   599 //      extern int fprintf();
600 600
601         clearPacket(result); 601         clearPacket(result);
602         if (argc == 0) { 602         if (argc == 0) {
603                 return dumpObj(self, fprintf, stdout, 0, 0); 603                 return dumpObj(self, fprintf, stdout, 0, 0);
604         } 604         }
605         cp = PkInfo2Str(&argv[0]); 605         cp = PkInfo2Str(&argv[0]);
606         if (!STRCMP(cp, "listMethods")) { 606         if (!STRCMP(cp, "listMethods")) {
607                 ClassInfo *cip; 607                 ClassInfo *cip;
608                 MethodInfo *mip; 608                 MethodInfo *mip;
609                 FILE *fp; 609                 FILE *fp;
610 610
611                 if (argc >= 2) { 611                 if (argc >= 2) {
612                         cip = getClassInfoByName(PkInfo2Str(&argv[1])); 612                         cip = getClassInfoByName(PkInfo2Str(&argv[1]));
613                 } else { 613                 } else {
614                         cip = (ClassInfo*)GET_class(self); 614                         cip = (ClassInfo*)GET_class(self);
615                 } 615                 }
616                 if (argc == 3) { 616                 if (argc == 3) {
617                         fp = fopen(PkInfo2Str(&argv[2]), "w"); 617                         fp = fopen(PkInfo2Str(&argv[2]), "w");
618                         if (!fp) return 0; 618                         if (!fp) return 0;
619                         for (mip = cip->methods; mip->id; mip++) 619                         for (mip = cip->methods; mip->id; mip++)
620                                 fprintf(fp, "%s\n", 620                                 fprintf(fp, "%s\n",
621                                         (char*)(symID2Str->get(symID2Str, 621                                         (char*)(symID2Str->get(symID2Str,
622                                                         mip->id)->val)); 622                                                         mip->id)->val));
623                         fclose(fp); 623                         fclose(fp);
624                 } else { 624                 } else {
625                         char sbuff[255]; 625                         char sbuff[255];
626 626
627                         buff[0] ='\0'; 627                         buff[0] ='\0';
628                         for (mip = cip->methods; mip->id; mip++) { 628                         for (mip = cip->methods; mip->id; mip++) {
629                                 sprintf(sbuff, "%s\n", 629                                 sprintf(sbuff, "%s\n",
630                                         (char*)(symID2Str->get)(symID2Str, 630                                         (char*)(symID2Str->get)(symID2Str,
631                                                         mip->id)->val); 631                                                         mip->id)->val);
632                                 strcat(buff, " "); 632                                 strcat(buff, " ");
633                                 strcat(buff, sbuff); 633                                 strcat(buff, sbuff);
634                         } 634                         }
635                         result->info.s = saveString(buff); 635                         result->info.s = saveString(buff);
636                         result->type = PKT_STR; 636                         result->type = PKT_STR;
637                         result->canFree = PK_CANFREE_STR; 637                         result->canFree = PK_CANFREE_STR;
638                 } 638                 }
639 639
640         } else if (!STRCMP(cp, "listNPSlots")) { 640         } else if (!STRCMP(cp, "listNPSlots")) {
641                 ClassInfo *cip; 641                 ClassInfo *cip;
642                 SlotInfo *sip; 642                 SlotInfo *sip;
643                 int i; 643                 int i;
644 644
645                 if (argc >= 2) { 645                 if (argc >= 2) {
646                         cip = getClassInfoByName(PkInfo2Str(&argv[1])); 646                         cip = getClassInfoByName(PkInfo2Str(&argv[1]));
647                 } else { 647                 } else {
648                         cip = (ClassInfo*)GET_class(self); 648                         cip = (ClassInfo*)GET_class(self);
649                 } 649                 }
650                 buff[0] = '\0'; 650                 buff[0] = '\0';
651                 sip = cip->slots[1]; /* section 1 is NPSlots */ 651                 sip = cip->slots[1]; /* section 1 is NPSlots */
652                 for (i = 0; sip[i].id; i++) { 652                 for (i = 0; sip[i].id; i++) {
653                         if (!(sip[i].flags & SLOT_RW)) continue; 653                         if (!(sip[i].flags & SLOT_RW)) continue;
654                         strcat(buff, 654                         strcat(buff,
655                                 (char*)symID2Str->get(symID2Str, 655                                 (char*)symID2Str->get(symID2Str,
656                                         sip[i].id)->val); 656                                         sip[i].id)->val);
657                         strcat(buff, "\n"); 657                         strcat(buff, "\n");
658                 }       658                 }      
659                 result->info.s = saveString(buff); 659                 result->info.s = saveString(buff);
660                 result->type = PKT_STR; 660                 result->type = PKT_STR;
661                 result->canFree = PK_CANFREE_STR; 661                 result->canFree = PK_CANFREE_STR;
662 662
663         } else if (!STRCMP(cp, "listNCSlots")) { 663         } else if (!STRCMP(cp, "listNCSlots")) {
664                 ClassInfo *cip; 664                 ClassInfo *cip;
665                 SlotInfo *sip; 665                 SlotInfo *sip;
666                 int i; 666                 int i;
667 667
668                 if (argc >= 2) { 668                 if (argc >= 2) {
669                         cip = getClassInfoByName(PkInfo2Str(&argv[1])); 669                         cip = getClassInfoByName(PkInfo2Str(&argv[1]));
670                 } else { 670                 } else {
671                         cip = (ClassInfo*)GET_class(self); 671                         cip = (ClassInfo*)GET_class(self);
672                 } 672                 }
673                 buff[0] = '\0'; 673                 buff[0] = '\0';
674                 sip = cip->slots[0]; /* section 0 is NCSlots */ 674                 sip = cip->slots[0]; /* section 0 is NCSlots */
675                 for (i = 0; sip[i].id; i++) { 675                 for (i = 0; sip[i].id; i++) {
676                         strcat(buff, 676                         strcat(buff,
677                                 (char*)symID2Str->get(symID2Str, 677                                 (char*)symID2Str->get(symID2Str,
678                                         sip[i].id)->val); 678                                         sip[i].id)->val);
679                         strcat(buff, "\n"); 679                         strcat(buff, "\n");
680                 }       680                 }      
681                 result->info.s = saveString(buff); 681                 result->info.s = saveString(buff);
682                 result->type = PKT_STR; 682                 result->type = PKT_STR;
683                 result->canFree = PK_CANFREE_STR; 683                 result->canFree = PK_CANFREE_STR;
684 684
685         } else if (!STRCMP(cp, "listSlotsRW")) { 685         } else if (!STRCMP(cp, "listSlotsRW")) {
686                 return dumpObj(self, fprintf, stdout, SLOT_RW, 0); 686                 return dumpObj(self, fprintf, stdout, SLOT_RW, 0);
687         } else if (!STRCMP(cp, "listSlotsR")) { 687         } else if (!STRCMP(cp, "listSlotsR")) {
688                 return dumpObj(self, fprintf, stdout, SLOT_R, 0); 688                 return dumpObj(self, fprintf, stdout, SLOT_R, 0);
689         } else if (!STRCMP(cp, "listSlotsW")) { 689         } else if (!STRCMP(cp, "listSlotsW")) {
690                 return dumpObj(self, fprintf, stdout, SLOT_W, 0); 690                 return dumpObj(self, fprintf, stdout, SLOT_W, 0);
691         } else if (!STRCMP(cp, "listAllObjects")) { 691         } else if (!STRCMP(cp, "listAllObjects")) {
692 692
693         } else if (!STRCMP(cp, "listAllMethods")) { 693         } else if (!STRCMP(cp, "listAllMethods")) {
694                 extern HashTable *symStr2ID, *symID2Str; 694                 extern HashTable *symStr2ID, *symID2Str;
695                 ClassInfo *cip, *cip2; 695                 ClassInfo *cip, *cip2;
696                 MethodInfo *mip; 696                 MethodInfo *mip;
697                 int i; 697                 int i;
698 698
699                 for (i = 0; cip = classList[i]; i++) { 699                 for (i = 0; cip = classList[i]; i++) {
700                         printf("\n%s :\n", 700                         printf("\n%s :\n",
701                                 (char*)symID2Str->get(symID2Str,cip->id)->val); 701                                 (char*)symID2Str->get(symID2Str,cip->id)->val);
702                         for (cip2 = cip; cip2; cip2 = cip2->superClass) { 702                         for (cip2 = cip; cip2; cip2 = cip2->superClass) {
703                                 for (mip = cip2->methods; mip->id; mip++) { 703                                 for (mip = cip2->methods; mip->id; mip++) {
704                                         printf("%s\n", 704                                         printf("%s\n",
705                                           (char*)symID2Str->get(symID2Str, 705                                           (char*)symID2Str->get(symID2Str,
706                                                         mip->id)->val); 706                                                         mip->id)->val);
707                                 } 707                                 }
708                         } 708                         }
709                         printf("\n"); 709                         printf("\n");
710                 } 710                 }
711         } 711         }
712         return 1; 712         return 1;
713 } 713 }
714 714
715 /* 715 /*
716  * interpret(<script> [, ...]) 716  * interpret(<script> [, ...])
717  * 717  *
718  * Evaluate the arguments as scripts. 718  * Evaluate the arguments as scripts.
719  * 719  *
720  * Result: as effected by script 720  * Result: as effected by script
721  * Return: 1 if successful, 0 if error occured 721  * Return: 1 if successful, 0 if error occured
722  */ 722  */
723 int meth_cosmic_interpret(self, result, argc, argv) 723 int meth_cosmic_interpret(self, result, argc, argv)
724         VObj *self; 724         VObj *self;
725         Packet *result; 725         Packet *result;
726         int argc; 726         int argc;
727         Packet argv[]; 727         Packet argv[];
728 { 728 {
729         int i; 729         int i;
730         char *cp; 730         char *cp;
731 731
732         clearPacket(result); 732         clearPacket(result);
733 733
734         if (notSecure(self)) return 0; 734         if (notSecure(self)) return 0;
735 735
736         for (i = 0; i < argc; i++) { 736         for (i = 0; i < argc; i++) {
737                 cp = SaveString(PkInfo2Str(&argv[i])); 737                 cp = SaveString(PkInfo2Str(&argv[i]));
738                 if (cp) execScript(self, result, cp); 738                 if (cp) execScript(self, result, cp);
739                 else { 739                 else {
740                         printf("error: interpret(): argument %d is empty.\n", 740                         printf("error: interpret(): argument %d is empty.\n",
741                                 i); 741                                 i);
742                 } 742                 }
743                 free(cp); 743                 free(cp);
744         } 744         }
745 745
746         return 1; 746         return 1;
747 } 747 }
748 748
749 /* return new object count 749 /* return new object count
750  */ 750  */
751 int meth_cosmic_loadObjFile(self, result, argc, argv) 751 int meth_cosmic_loadObjFile(self, result, argc, argv)
752         VObj *self; 752         VObj *self;
753         Packet *result; 753         Packet *result;
754         int argc; 754         int argc;
755         Packet argv[]; 755         Packet argv[];
756 { 756 {
757         char *path; 757         char *path;
758         char *fname = NULL; 758         char *fname = NULL;
759 759
760         if (argc > 0) { 760         if (argc > 0) {
761                 path = PkInfo2Str(&argv[0]); 761                 path = PkInfo2Str(&argv[0]);
762                 if (argc > 1) fname = PkInfo2Str(&argv[1]); 762                 if (argc > 1) fname = PkInfo2Str(&argv[1]);
763 763
764                 if (path && fname) result->info.i = load_object(fname, path); 764                 if (path && fname) result->info.i = load_object(fname, path);
765                 else result->info.i = 0; 765                 else result->info.i = 0;
766         } else { 766         } else {
767                 result->info.i = 0; 767                 result->info.i = 0;
768         } 768         }
769         result->type = PKT_INT; 769         result->type = PKT_INT;
770         result->canFree = 0; 770         result->canFree = 0;
771 771
772         return ((result->info.i == -1) ? 0 : 1); 772         return ((result->info.i == -1) ? 0 : 1);
773 } 773 }
774 774
775 int meth_cosmic_modalExit(self, result, argc, argv) 775 int meth_cosmic_modalExit(self, result, argc, argv)
776         VObj *self; 776         VObj *self;
777         Packet *result; 777         Packet *result;
778         int argc; 778         int argc;
779         Packet argv[]; 779         Packet argv[];
780 { 780 {
781         if (notSecure(self)) return 0; 781         if (notSecure(self)) return 0;
782         modalState = 0; 782         modalState = 0;
783         copyPacket(modalResult, &argv[0]); 783         copyPacket(modalResult, &argv[0]);
784         return 1; 784         return 1;
785 } 785 }
786 786
787 /* 787 /*
788  * object(<object name>) 788  * object(<object name>)
789  * 789  *
790  * 790  *
791  * 791  *
792  * Result: 792  * Result:
793  * Return: 793  * Return:
794  */ 794  */
795 int meth_cosmic_object(self, result, argc, argv) 795 int meth_cosmic_object(self, result, argc, argv)
796         VObj *self; 796         VObj *self;
797         Packet *result; 797         Packet *result;
798         int argc; 798         int argc;
799         Packet argv[]; 799         Packet argv[];
800 { 800 {
801         result->info.o = PkInfo2Obj(&argv[0]); 801         result->info.o = PkInfo2Obj(&argv[0]);
802         result->type = PKT_OBJ; 802         result->type = PKT_OBJ;
803         result->canFree = 0; 803         result->canFree = 0;
804         return 1; 804         return 1;
805 } 805 }
806 806
807 /* 807 /*
808  * pop() 808  * pop()
809  * 809  *
810  * 810  *
811  * Result: 811  * Result:
812  * Return: 812  * Return:
813  */ 813  */
814 int meth_cosmic_pop(self, result, argc, argv) 814 int meth_cosmic_pop(self, result, argc, argv)
815         VObj *self; 815         VObj *self;
816         Packet *result; 816         Packet *result;
817         int argc; 817         int argc;
818         Packet argv[]; 818         Packet argv[];
819 { 819 {
820         clearPacket(result); 820         clearPacket(result);
821         return 0; 821         return 0;
822 } 822 }
823 823
824 /* 824 /*
825  * () 825  * ()
826  * 826  *
827  * 827  *
828  * Result: 828  * Result:
829  * Return: 829  * Return:
830  */ 830  */
831 int meth_cosmic_push(self, result, argc, argv) 831 int meth_cosmic_push(self, result, argc, argv)
832         VObj *self; 832         VObj *self;
833         Packet *result; 833         Packet *result;
834         int argc; 834         int argc;
835         Packet argv[]; 835         Packet argv[];
836 { 836 {
837         clearPacket(result); 837         clearPacket(result);
838         return 0; 838         return 0;
839 } 839 }
840 840
841 /* 841 /*
842  * quit(); 842  * quit();
843  * 843  *
844  * Save stack and exit. 844  * Save stack and exit.
845  * 845  *
846  * Result: unaffected 846  * Result: unaffected
847  * Return: 1 if successful, 0 if error occured 847  * Return: 1 if successful, 0 if error occured
848  */ 848  */
849 int meth_cosmic_quit(self, result, argc, argv) 849 int meth_cosmic_quit(self, result, argc, argv)
850         VObj *self; 850         VObj *self;
851         Packet *result; 851         Packet *result;
852         int argc; 852         int argc;
853         Packet argv[]; 853         Packet argv[];
854 { 854 {
855         if (notSecure(self)) return 0; 855         if (notSecure(self)) return 0;
856 /*      methodMembershipProfile();*/ 856 /*      methodMembershipProfile();*/
857         exitingViola = 1; 857         exitingViola = 1;
858         freeViolaResources(); 858         freeViolaResources();
859         exit(0); 859         exit(0);
860 } 860 }
861 861
862 /* 862 /*
863  * save(); 863  * save();
864  * 864  *
865  * Save the calling object's cluster in the top object's name with ".v" 865  * Save the calling object's cluster in the top object's name with ".v"
866  * appended. 866  * appended.
867  * 867  *
868  * Result: file name under which the objects were saved in 868  * Result: file name under which the objects were saved in
869  * Return: 869  * Return:
870  */ 870  */
871 int meth_cosmic_save(self, result, argc, argv) 871 int meth_cosmic_save(self, result, argc, argv)
872         VObj *self; 872         VObj *self;
873         Packet *result; 873         Packet *result;
874         int argc; 874         int argc;
875         Packet argv[]; 875         Packet argv[];
876 { 876 {
877         VObj *parent, *obj = self; 877         VObj *parent, *obj = self;
878         char fileName[100]; 878         char fileName[100];
879         FILE *fp; 879         FILE *fp;
880         int stat; 880         int stat;
881 881
882         if (notSecure(self)) return 0; 882         if (notSecure(self)) return 0;
883 883
884         while (parent = GET__parent(obj)) obj = parent; 884         while (parent = GET__parent(obj)) obj = parent;
885 885
886         strcpy(fileName, GET_name(obj)); 886         strcpy(fileName, GET_name(obj));
887         strcat(fileName, ".v"); 887         strcat(fileName, ".v");
888 888
889         fp = fopen(fileName, "w"); 889         fp = fopen(fileName, "w");
890         if (fp) { 890         if (fp) {
891                 stat = saveSelfAndChildren(obj, fp); 891                 stat = saveSelfAndChildren(obj, fp);
892                 fclose(fp); 892                 fclose(fp);
893                 if (stat) { 893                 if (stat) {
894                         result->type = PKT_STR; 894                         result->type = PKT_STR;
895                         result->info.s = saveString(fileName); 895                         result->info.s = saveString(fileName);
896                         result->canFree = PK_CANFREE_STR; 896                         result->canFree = PK_CANFREE_STR;
897                         return 1; 897                         return 1;
898                 } 898                 }
899         } 899         }
900         clearPacket(result); 900         clearPacket(result);
901         return 0; 901         return 0;
902 } 902 }
903 903
904 /* 904 /*
905  * saveAs(filePath); 905  * saveAs(filePath);
906  * 906  *
907  * Save the calling object's cluster in the specified file path. 907  * Save the calling object's cluster in the specified file path.
908  * 908  *
909  * Result: 909  * Result:
910  * Return: 910  * Return:
911  */ 911  */
912 int meth_cosmic_saveAs(self, result, argc, argv) 912 int meth_cosmic_saveAs(self, result, argc, argv)
913         VObj *self; 913         VObj *self;
914         Packet *result; 914         Packet *result;
915         int argc; 915         int argc;
916         Packet argv[]; 916         Packet argv[];
917 { 917 {
918         VObj *parent, *obj = self; 918         VObj *parent, *obj = self;
919         char *cp, fileName[100]; 919         char *cp, fileName[100];
920         FILE *fp; 920         FILE *fp;
921         int stat; 921         int stat;
922 922
923         if (notSecure(self)) return 0; 923         if (notSecure(self)) return 0;
924 924
925         if (argc != 1) return 0; 925         if (argc != 1) return 0;
926 926
927         while (parent = GET__parent(obj)) obj = parent; 927         while (parent = GET__parent(obj)) obj = parent;
928 928
929         cp = PkInfo2Str(&argv[0]); 929         cp = PkInfo2Str(&argv[0]);
930         if (!cp) return 0; 930         if (!cp) return 0;
931 931
932         strcpy(fileName, cp); 932         strcpy(fileName, cp);
933 933
934         fp = fopen(cp, "w"); 934         fp = fopen(cp, "w");
935         if (fp) { 935         if (fp) {
936                 stat = saveSelfAndChildren(obj, fp); 936                 stat = saveSelfAndChildren(obj, fp);
937                 fclose(fp); 937                 fclose(fp);
938                 if (stat) { 938                 if (stat) {
939                         result->type = PKT_STR; 939                         result->type = PKT_STR;
940                         result->info.s = saveString(fileName); 940                         result->info.s = saveString(fileName);
941                         result->canFree = PK_CANFREE_STR; 941                         result->canFree = PK_CANFREE_STR;
942                         return 1; 942                         return 1;
943                 } 943                 }
944         } 944         }
945         clearPacket(result); 945         clearPacket(result);
946         return stat; 946         return stat;
947 } 947 }
948 948
949 /* 949 /*
950  * send(<object name>, <message list ...>) 950  * send(<object name>, <message list ...>)
951  * 951  *
952  * Send a message for the target object's script to handle. 952  * Send a message for the target object's script to handle.
953  * 953  *
954  * Result: 954  * Result:
955  * Return: 955  * Return:
956  */ 956  */
957 int meth_cosmic_send(self, result, argc, argv) 957 int meth_cosmic_send(self, result, argc, argv)
958         VObj *self; 958         VObj *self;
959         Packet *result; 959         Packet *result;
960         int argc; 960         int argc;
961         Packet argv[]; 961         Packet argv[];
962 { 962 {
963         VObj *obj = PkInfo2Obj(&argv[0]); 963         VObj *obj = PkInfo2Obj(&argv[0]);
964 964
965         if (obj) 965         if (obj)
966             if (validObjectP(obj)) { 966             if (validObjectP(obj)) {
967                 if (sendMessagePackets_result(obj, &argv[1], argc - 1, 967                 if (sendMessagePackets_result(obj, &argv[1], argc - 1,
968                                               result)) { 968                                               result)) {
969                         return 1; 969                         return 1;
970                 } 970                 }
971             } 971             }
972         clearPacket(result); 972         clearPacket(result);
973         return 0; 973         return 0;
974 } 974 }
975 975
976 /* 976 /*
977  */ 977  */
978 int meth_cosmic_test1(self, result, argc, argv) 978 int meth_cosmic_test1(self, result, argc, argv)
979         VObj *self; 979         VObj *self;
980         Packet *result; 980         Packet *result;
981         int argc; 981         int argc;
982         Packet argv[]; 982         Packet argv[];
983 { 983 {
984 /*      clearPacket(result); 984 /*      clearPacket(result);
985         result->info.i = user_message_confirm(PkInfo2Str(&argv[0])); 985         result->info.i = user_message_confirm(PkInfo2Str(&argv[0]));
986         result->type = PKT_INT; 986         result->type = PKT_INT;
987 */ 987 */
988         return 1; 988         return 1;
989 } 989 }
990 990
991 /* 991 /*
992  */ 992  */
993 int meth_cosmic_test2(self, result, argc, argv) 993 int meth_cosmic_test2(self, result, argc, argv)
994         VObj *self; 994         VObj *self;
995         Packet *result; 995         Packet *result;
996         int argc; 996         int argc;
997         Packet argv[]; 997         Packet argv[];
998 { 998 {
999         clearPacket(result); 999         clearPacket(result);
1000         result->info.s = user_prompt_default(PkInfo2Str(&argv[0]), 1000         result->info.s = user_prompt_default(PkInfo2Str(&argv[0]),
1001                                                 PkInfo2Str(&argv[1])); 1001                                                 PkInfo2Str(&argv[1]));
1002         result->type = PKT_STR; 1002         result->type = PKT_STR;
1003         return 1; 1003         return 1;
1004 } 1004 }
1005 1005
1006 /* 1006 /*
1007  */ 1007  */
1008 int meth_cosmic_test3(self, result, argc, argv) 1008 int meth_cosmic_test3(self, result, argc, argv)
1009         VObj *self; 1009         VObj *self;
1010         Packet *result; 1010         Packet *result;
1011         int argc; 1011         int argc;
1012         Packet argv[]; 1012         Packet argv[];
1013 { 1013 {
1014         /* cuts off the dataBuff at the caller's string's beginning 1014         /* cuts off the dataBuff at the caller's string's beginning
1015          * this is useful if the caller wants to get the parent to 1015          * this is useful if the caller wants to get the parent to
1016          * do something with its (parent's) data before the caller 1016          * do something with its (parent's) data before the caller
1017          * itself exist. 1017          * itself exist.
1018          * example: <SUP> telling <MATH> to collect tokens... 1018          * example: <SUP> telling <MATH> to collect tokens...
1019          */ 1019          */
1020         nullifyCallerDataBuff(); 1020         nullifyCallerDataBuff();
1021         return 0; 1021         return 0;
1022 } 1022 }
1023 1023
1024 int meth_cosmic_test4(self, result, argc, argv) 1024 int meth_cosmic_test4(self, result, argc, argv)
1025         VObj *self; 1025         VObj *self;
1026         Packet *result; 1026         Packet *result;
1027         int argc; 1027         int argc;
1028         Packet argv[]; 1028         Packet argv[];
1029 { 1029 {
1030         HTMLMathDraw(self, GET__content2(self)); 1030         HTMLMathDraw(self, GET__content2(self));
1031         return 0; 1031         return 0;
1032 } 1032 }
1033 1033
1034 /* 1034 /*
1035  * tweak(object name, command string) 1035  * tweak(object name, command string)
1036  * 1036  *
1037  * Execute command string in context of the target object, bypassing 1037  * Execute command string in context of the target object, bypassing
1038  * the target object's script. 1038  * the target object's script.
1039  * 1039  *
1040  * Result: 1040  * Result:
1041  * Return: 1041  * Return:
1042  */ 1042  */
1043 int meth_cosmic_tweak(self, result, argc, argv) 1043 int meth_cosmic_tweak(self, result, argc, argv)
1044         VObj *self; 1044         VObj *self;
1045         Packet *result; 1045         Packet *result;
1046         int argc; 1046         int argc;
1047         Packet argv[]; 1047         Packet argv[];
1048 { 1048 {
1049         VObj *obj; 1049         VObj *obj;
1050         int i, len; 1050         int i, len;
1051         char *cp, *script; 1051         char *cp, *script;
1052 1052
1053         if (notSecure(self)) return 0; 1053         if (notSecure(self)) return 0;
1054 1054
1055         obj = PkInfo2Obj(&argv[0]); 1055         obj = PkInfo2Obj(&argv[0]);
1056         if (obj) { 1056         if (obj) {
1057                 for (i = 1; i < argc; i++) { 1057                 for (i = 1; i < argc; i++) {
1058                         script = PkInfo2Str(&argv[i]); 1058                         script = PkInfo2Str(&argv[i]);
1059                         if (script) { 1059                         if (script) {
1060                                 len = strlen(script); 1060                                 len = strlen(script);
1061                                 /* extra space to let yylook safely 1061                                 /* extra space to let yylook safely
1062                                  * overwriting array boundary */ 1062                                  * overwriting array boundary */
1063                                 cp = (char*)malloc(sizeof(char) * (len + 2)); 1063                                 cp = (char*)malloc(sizeof(char) * (len + 2));
1064                                 if (cp) { 1064                                 if (cp) {
1065                                         strcpy(cp, script); 1065                                         strcpy(cp, script);
1066                                         execScript(obj, result, cp); 1066                                         execScript(obj, result, cp);
1067                                         free(cp); 1067                                         free(cp);
1068                                 } 1068                                 }
1069                         } 1069                         }
1070                 } 1070                 }
1071                 return 1; 1071                 return 1;
1072         } 1072         }
1073         clearPacket(result); 1073         clearPacket(result);
1074         return 0; 1074         return 0;
1075 } 1075 }
1076 1076
1077 /* 1077 /*
1078  * usual() 1078  * usual()
1079  * 1079  *
1080  * Execute the default class script for the class of the calling object. 1080  * Execute the default class script for the class of the calling object.
1081  * 1081  *
1082  * Result: result of the class script 1082  * Result: result of the class script
1083  * Return: 1083  * Return:
1084  */ 1084  */
1085 int meth_cosmic_usual(self, result, argc, argv) 1085 int meth_cosmic_usual(self, result, argc, argv)
1086         VObj *self; 1086         VObj *self;
1087         Packet *result; 1087         Packet *result;
1088         int argc; 1088         int argc;
1089         Packet argv[]; 1089         Packet argv[];
1090 { 1090 {
1091         extern int stackExecIdx; 1091         extern int stackExecIdx;
1092         extern int stackBaseIdx; 1092         extern int stackBaseIdx;
1093         int save_stackExecIdx; 1093         int save_stackExecIdx;
1094         int save_stackBaseIdx; 1094         int save_stackBaseIdx;
1095 1095
1096         save_stackExecIdx = stackExecIdx; 1096         save_stackExecIdx = stackExecIdx;
1097         save_stackBaseIdx = stackBaseIdx; 1097         save_stackBaseIdx = stackBaseIdx;
1098 1098
1099         stackBaseIdx = stackExecIdx; 1099         stackBaseIdx = stackExecIdx;
1100         execObjClassScript(self, result); 1100         execObjClassScript(self, result);
1101 1101
1102         stackExecIdx = save_stackExecIdx; 1102         stackExecIdx = save_stackExecIdx;
1103         stackBaseIdx = save_stackBaseIdx; 1103         stackBaseIdx = save_stackBaseIdx;
1104 1104
1105         return 1; 1105         return 1;
1106 } 1106 }
1107 1107
1108 1108
1109 1109
1110 1110
1111   1111