earlybrowserreborn - Blame information for rev 4

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