earlybrowserreborn - Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 roytam 1 #include "utils.h"
2 #include <ctype.h>
3 #include <math.h>
4 #include "error.h"
5 #include "mystrings.h"
6 #include "hash.h"
7 #include "ident.h"
8 #include "scanutils.h"
9 #include "obj.h"
10 #include "packet.h"
11 #include "slotaccess.h"
12 #include "misc.h"
13  
14 int cmd_history = 0;
15 int verbose = 0;
16  
17 char strBuff[32];
18  
19 /*
20  * parse the string and set the numbers onto the array.
21  *
22  * RETURN: number of transfered.
23  */
24 int transferNumList2Array(numStr, array, n)
25         char *numStr;
26         int *array;
27         int n;
28 {
29         int count = 0, stri = 0, ai = 0;
30  
31         /* make sure to start out with number */
32         while (*numStr) if (isdigit(*numStr)) break;
33  
34         for (;;) {
35                 if (isdigit(*numStr)) {
36                         strBuff[stri++] = *numStr;
37                 } else {
38                         if (stri > 0) {
39                                 strBuff[stri] = '\0';
40                                 stri = 0;
41                                 array[ai++] = atoi(strBuff);
42                                 if (++count >= n) return count;
43                         }
44                 }
45                 if (*numStr == '\0') break;
46                 ++numStr;
47         }
48         return count;
49 }
50  
51 int argNumsToInt(argv, n, intBuff)
52         Packet argv[];
53         int n;
54         int intBuff[];
55 {
56         int i;
57         for (i = 0; i < n; i++) {
58                 switch (argv[i].type) {
59                 case PKT_FLT:
60                         intBuff[i] = (int)(argv[i].info.f);
61                 break;
62                 case PKT_STR:
63                         intBuff[i] = atoi(argv[i].info.s);
64                 break;
65                 case PKT_CHR:
66                         intBuff[i] = (int)(argv[i].info.c);
67                 break;
68                 case PKT_INT:
69                 default:
70                         intBuff[i] = argv[i].info.i;
71                 break;
72                 }
73         }
74         return i;
75 }
76  
77 VObjList *strOListToOList(str)
78         char *str;
79 {
80         char name[100];
81         int i = 0;
82         VObj *obj;
83         VObjList *objl = NULL;
84  
85         for (;;) {
86                 while (ISSPACE(str[i])) i++;
87                 i = NextWord(str, i, name);
88                 if (AllBlank(name)) break;
89                 obj = findObject(getIdent(name));
90                 if (obj) objl = appendObjToList(objl, obj);
91         }
92         return objl;
93 }
94  
95 /* XXX Sins: uses global buff, 2xstrcat()...
96  */
97 char *OListToStr(olist)
98         VObjList *olist;
99 {
100         buff[0] = '\0';
101  
102         for (; olist; olist = olist->next) {
103                 strcat(buff, GET_name(olist->o));
104                 strcat(buff, " ");
105         }
106         return buff;
107 }
108  
109 /* XXX Sins: uses global buff, 2xstrcat()...
110  */
111 char *OListToStrPlusSuffix(olist, suffix)
112         VObjList *olist;
113         char *suffix;
114 {
115         buff[0] = '\0';
116  
117         for (; olist; olist = olist->next) {
118                 if (olist->o) {
119                         strcat(buff, GET_name(olist->o));
120                         strcat(buff, suffix);
121                         strcat(buff, " ");
122                 }
123         }
124         return buff;
125 }
126  
127 /*
128 void setDepentShownInfo(self, attrStrID, position, size)
129         VObj *self;
130         int attrStrID;
131         int position;
132         int size;
133 {
134         VObjList *objl;
135  
136         for (objl = GET__shownDepend(self); objl; objl = objl->next)
137                 if (objl->o)
138                         sendMessage1N2int(objl->o, attrStrID, position, size);
139 }
140  
141 void setNotifyShownInfo(self, attrStrID, position, size)
142         VObj *self;
143         int attrStrID;
144         int position;
145         int size;
146 {
147         VObjList *objl;
148  
149         for (objl = GET__shownNotify(self); objl; objl = objl->next)
150                 if (objl->o)
151                         sendMessage1N2int(objl->o, attrStrID, position, size);
152 }
153  
154 */
155  
156 int makeArgv(argv, argline)
157         char *argv[];
158         char *argline;
159 {
160         int argc = 0, i = 0, j = 0;
161  
162         do {
163                 j = i;
164                 i = NextWord(argline, i, buff);
165                 if (*buff) argv[argc++] = SaveString(buff);
166         } while (i != j);
167         return argc;
168 }
169  
170 /*
171  * NOTE: the returned string is stored in shared buffer space.
172  */
173 char *PkInfos2Str(argc, argv)
174         int argc;
175         Packet argv[];
176 {
177         int i;
178         char sbuff[64000]; /*XXX*/
179  
180         buff[0] = '\0';
181  
182         for (i = 0; i < argc; i++) {
183                 switch (argv[i].type) {
184                 case PKT_STR:
185                         sprintf(sbuff, "%s", argv[i].info.s);
186                 break;
187                 case PKT_CHR:
188                         sprintf(sbuff, "%c", argv[i].info.c);
189                 break;
190                 case PKT_INT:
191                         sprintf(sbuff, "%d", argv[i].info.i);
192                 break;
193                 case PKT_FLT:
194                         sprintf(sbuff, "%f", argv[i].info.f);
195                 break;
196                 case PKT_OBJ:
197                         if (argv[i].info.o)
198                                 sprintf(sbuff, "%s", GET_name(argv[i].info.o));
199                         else
200                                 sprintf(sbuff, "(NULL)");
201                 break;
202                 case PKT_ARY:
203                         if (argv[i].info.y) {
204                                 int n;
205                                 Array *array = argv[i].info.y;
206                                 for (n = 0; n < array->size; n++)
207                                         sprintf(sbuff, "%d ", array->info[n]);
208                         }
209                 break;
210 /*              case PKT_STRI:
211                         if (argv[i].info.si) {
212                                 if (argv[i].info.si.s)
213                                         sprintf("%s", argv[i].info.si.s);
214                                 else
215                                         *sbuff = '\0';
216                         } else {
217                                 *sbuff = '\0';
218                         }
219                 break;
220 */
221                 default:
222                         sprintf(sbuff, "?");
223                 break;
224                 }
225 /*printf("argc=%d i=%d sbuff=``%s''\n", argc, i, sbuff);*/
226                 strcat(buff, sbuff);
227         }
228         return buff;
229 }
230  
231 /*
232  * NOTE: the returned string is stored in shared buffer space.
233  */
234 char *PkInfo2Str(pk)
235         Packet *pk;
236 {
237         switch (pk->type) {
238         case PKT_STR:
239                 return pk->info.s;
240         case PKT_CHR:
241                 sprintf(buff, "%c", pk->info.c);
242         break;
243         case PKT_INT:
244                 sprintf(buff, "%d", pk->info.i);
245         break;
246         case PKT_FLT:
247                 sprintf(buff, "%f", pk->info.f);
248         break;
249         case PKT_OBJ:
250                 if (pk->info.o)
251                         sprintf(buff, "%s", GET_name(pk->info.o));
252                 else
253                         sprintf(buff, "");
254         break;
255         case PKT_ARY:
256                 if (pk->info.y) {
257                         int n;
258                         Array *array = pk->info.y;
259                         for (n = 0; n < array->size; n++)
260                                 sprintf(buff, "%d ", array->info[n]);
261                 }
262         break;
263 /*      case PKT_STRI:
264                 printf(stderr,"PKT_STRI: NOT IMPLEMENTED XXX\n");
265         break;
266 */
267         default:
268                 buff[0] = '\0';
269         break;
270         }
271         return buff;
272 }
273  
274 float PkInfo2Flt(pk)
275         Packet *pk;
276 {
277         switch (pk->type) {
278         case PKT_FLT:
279                 return pk->info.f;
280         case PKT_INT:
281                 return (float)(pk->info.i);
282         case PKT_STR:
283                 return (float)atof(pk->info.s);
284         case PKT_CHR:
285                 return (float)(pk->info.c);
286         default:
287                 return (float)(pk->info.f);
288         }
289 }
290  
291 char PkInfo2Char(pk)
292         Packet *pk;
293 {
294         switch (pk->type) {
295         case PKT_CHR:
296                 return pk->info.c;
297         case PKT_STR:
298                 return pk->info.s[0];
299         case PKT_INT:
300                 return (char)(pk->info.i);      /* ?? */
301         case PKT_FLT:
302                 return (char)(pk->info.f);
303         default:
304                 return (char)pk->info.c;
305         }
306 }
307  
308 int PkInfo2Int(pk)
309         Packet *pk;
310 {
311         switch (pk->type) {
312         case PKT_INT:
313                 return pk->info.i;
314         case PKT_STR:
315                 if (pk->info.s) {
316                         return atoi(pk->info.s);
317                 } else {
318                         fprintf(stderr,
319                                 "warning: PkInfo2Int() pk->info.s == NULL\n");
320                         return 0;
321                 }
322         case PKT_FLT:
323                 return (int)(pk->info.f);
324         case PKT_CHR:
325                 return (int)(pk->info.c);       /* ?? */
326         }
327         return (int)(pk->info.i);
328 }
329  
330 /* load if necessary
331  */
332 VObj *getObject(objName)
333         char *objName;
334 {
335         int symID;
336         VObj *obj = NULL;
337  
338         symID = getIdent(trimEdgeSpaces(objName));
339         if (symID) obj = findObject(symID);
340         if (obj) {
341                 return obj;
342         } else {
343                 char *fname, *objname;
344                 int length;
345                 HashEntry *entry;
346  
347                 length = sizeof(char) * (strlen(objName) + 3);
348                 fname = (char*)malloc(length);
349                 objname = (char*)malloc(length);
350                 strcpy(fname, objName);
351                 strcpy(objname, objName);
352                 length = strlen(fname);
353                 if (length >= 2) {
354                         if (fname[length-2] != '.' ||
355                             fname[length-1] != 'v')
356                                 strcat(fname, ".v");
357                 }
358                 load_object(fname, NULL);
359                 entry = objID2Obj->get(objID2Obj, storeIdent(objname));
360                 free(fname);
361                 if (entry) return (VObj*)entry->val;
362         }
363         return NULL;
364 }
365  
366 VObj *PkInfo2Obj(pk)
367         Packet *pk;
368 {
369         VObj *obj = NULL;
370  
371         if (pk->type == PKT_OBJ) {
372                 return pk->info.o;
373         } else if (pk->type == PKT_STR) {
374                 if (pk->info.s) return getObject(pk->info.s);
375         }
376         return NULL;
377 }
378  
379