1 #include "types.h"
2
3 extern int fd[2];
4 extern Window ref;
5
6 void (*TabCom[30]) (int NbArg, long *TabArg);
7 char *(*TabFunc[20]) (int *NbArg, long *TabArg);
8 int (*TabComp[15]) (char *arg1, char *arg2);
9
10 extern X11base *x11base;
11 extern int grab_serve;
12 extern struct XObj *tabxobj[100];
13 extern void LoadIcon (struct XObj *xobj);
14
15 extern int nbobj;
16 extern char **TabVVar;
17 extern int TabIdObj[101];
18 extern char *ScriptName;
19 extern char *MyName;
20 extern TypeBuffSend BuffSend;
21 extern Atom propriete;
22
23 char *BufCom;
24 char Command[255] = "None";
25 time_t TimeCom = 0;
26
27 /*************************************************************/
28 /* Ensemble de fonction de comparaison de deux entiers */
29 /*************************************************************/
30 int
Inf(char * arg1,char * arg2)31 Inf (char *arg1, char *arg2)
32 {
33 int an1, an2;
34 an1 = atoi (arg1);
35 an2 = atoi (arg2);
36 return (an1 < an2);
37 }
38
39 int
InfEq(char * arg1,char * arg2)40 InfEq (char *arg1, char *arg2)
41 {
42 int an1, an2;
43 an1 = atoi (arg1);
44 an2 = atoi (arg2);
45 return (an1 <= an2);
46 }
47
48 int
Equal(char * arg1,char * arg2)49 Equal (char *arg1, char *arg2)
50 {
51 int an1, an2;
52 an1 = atoi (arg1);
53 an2 = atoi (arg2);
54 return (strcmp (arg1, arg2) == 0);
55 }
56
57 int
SupEq(char * arg1,char * arg2)58 SupEq (char *arg1, char *arg2)
59 {
60 int an1, an2;
61 an1 = atoi (arg1);
62 an2 = atoi (arg2);
63 return (an1 >= an2);
64 }
65
66 int
Sup(char * arg1,char * arg2)67 Sup (char *arg1, char *arg2)
68 {
69 int an1, an2;
70 an1 = atoi (arg1);
71 an2 = atoi (arg2);
72 return (an1 > an2);
73 }
74
75 int
Diff(char * arg1,char * arg2)76 Diff (char *arg1, char *arg2)
77 {
78 int an1, an2;
79 an1 = atoi (arg1);
80 an2 = atoi (arg2);
81 return (strcmp (arg1, arg2) != 0);
82 }
83
84 /*****************************************************/
85 /* Fonction qui retourne la valeur d'un argument */
86 /*****************************************************/
87 char *
CalcArg(long * TabArg,int * Ix)88 CalcArg (long *TabArg, int *Ix)
89 {
90 char *TmpStr;
91 int i;
92
93 if (TabArg[*Ix] > 100000)
94 { /* Cas du codage d'un nombre */
95 i = (int) TabArg[*Ix] - 200000;
96 TmpStr = (char *) calloc (1, sizeof (char) * 10);
97 sprintf (TmpStr, "%d", i);
98 }
99 else if (TabArg[*Ix] < -200000)
100 { /* Cas d'un id de fonction de comparaison */
101 i = TabArg[*Ix] + 250000;
102 TmpStr = (char *) calloc (1, sizeof (char) * 10);
103 sprintf (TmpStr, "%d", i);
104 }
105 else if (TabArg[*Ix] < -100000)
106 { /* Cas d'un id de fonction */
107 TmpStr = TabFunc[TabArg[*Ix] + 150000] (Ix, TabArg);
108 }
109 else
110 { /* Cas d'une variable */
111 TmpStr = strdup (TabVVar[TabArg[*Ix]]);
112 }
113 return (TmpStr);
114 }
115
116 /*************************************************************/
117 /* Ensemble des fonctions pour recuperer les prop d'un objet */
118 /*************************************************************/
119 char *
FuncGetValue(int * NbArg,long * TabArg)120 FuncGetValue (int *NbArg, long *TabArg)
121 {
122 char *tmp;
123 long Id;
124
125 (*NbArg)++; /* La fonction GetValue n'a qu'un seul argument */
126 tmp = CalcArg (TabArg, NbArg);
127 Id = atoi (tmp);
128 free (tmp);
129 tmp = (char *) calloc (1, sizeof (char) * 10);
130 sprintf (tmp, "%d", tabxobj[TabIdObj[Id]]->value);
131 return tmp;
132 }
133
134 /* Fonction qui retourne le titre d'un objet */
135 char *
FuncGetTitle(int * NbArg,long * TabArg)136 FuncGetTitle (int *NbArg, long *TabArg)
137 {
138 char *tmp;
139 long Id;
140
141 (*NbArg)++;
142 tmp = CalcArg (TabArg, NbArg);
143 Id = atoi (tmp);
144 free (tmp);
145 if (TabIdObj[Id] != -1)
146 tmp = strdup (tabxobj[TabIdObj[Id]]->title);
147 else
148 {
149 fprintf (stderr, "Widget %d doesn't exist\n", (int) Id);
150 tmp = (char *) calloc (1, sizeof (char));
151 tmp[0] = '\0';
152 }
153 return tmp;
154 }
155
156 /* Read an option value in an afterstep file */
157 char *
FuncGetASoption(int * NbArg,long * TabArg)158 FuncGetASoption (int *NbArg, long *TabArg)
159 {
160 int index, i = 2, k = 0, NewWord;
161 int maxsize = MAXLINELENGTH * (MAXLINELENGTH / 2);
162 int found = 0, size;
163 char *cmndbuf, *wordtofind, *str;
164 FILE *f;
165
166 (*NbArg)++;
167 cmndbuf = CalcArg (TabArg, NbArg);
168 (*NbArg)++;
169 wordtofind = CalcArg (TabArg, NbArg);
170 (*NbArg)++;
171 str = CalcArg (TabArg, NbArg);
172 index = atoi (str);
173 free (str);
174
175 printf ("\n �� command: %s\n", cmndbuf);
176 printf ("\n �� word to find: %s\n", wordtofind);
177 printf ("\n �� #argument to read: %d\n", index);
178
179 /* Read command output */
180 if ((strcmp (Command, cmndbuf)) || ((time (NULL) - TimeCom) > 1) || (TimeCom == 0))
181 {
182 if ((f = popen (cmndbuf, "r")) == NULL)
183 {
184 fprintf (stderr, "%s: can't run %s\n", ScriptName, cmndbuf);
185 str = (char *) calloc (sizeof (char), 10);
186 free (cmndbuf);
187 return str;
188 }
189 else
190 {
191 if (strcmp (Command, "None"))
192 free (BufCom);
193 BufCom = (char *) calloc (sizeof (char), maxsize);
194 size = fread (BufCom, 1, maxsize, f);
195 pclose (f);
196 strcpy (Command, cmndbuf);
197 TimeCom = time (NULL);
198 }
199 }
200 /* Function differs, depending on whether index >= 0 or index < 0 */
201
202 if (index < 0)
203 {
204 /* should return the whole abs(index) line */
205 index = abs (index);
206 }
207 /* Now seek for wordtofind in &BufCom[int] */
208 while ((&BufCom[k] != (char *) 0) && (BufCom[k] != '\0') && (found == 0))
209 {
210 while (isspace (*&BufCom[k]))
211 BufCom[k]++;
212
213 if (mystrncasecmp (&BufCom[k], wordtofind, strlen (wordtofind)) == 0)
214 found = k;
215 else
216 k++;
217 }
218
219 printf ("\n �� good line: %d", found);
220
221 /* Return the #(index) argument, if 0, whole line */
222 if (index != 0)
223 {
224 i = 1;
225 NewWord = 0;
226 while ((i < index) && (BufCom[found] != '\n') && (BufCom[found] != '\0'))
227 {
228 if (BufCom[found++] == ' ')
229 {
230 if (NewWord)
231 {
232 i++;
233 NewWord = 0;
234 }
235 }
236 else if (!NewWord)
237 NewWord = 1;
238 }
239 str = (char *) calloc (sizeof (char), 255);
240 sscanf (&BufCom[found], "%s", str);
241 }
242 else
243 {
244 if (i != 2)
245 found++;
246 k = found;
247 while ((BufCom[k] != '\n') && (BufCom[k] != '\0'))
248 k++;
249 str = (char *) calloc (sizeof (char), k - found + 1);
250 memmove (str, &BufCom[found], k - found);
251 str[k - found] = '\0';
252 }
253 free (cmndbuf);
254 return str;
255 }
256
257 /* Read an option value in an afterstep file */
258 char *
FuncSetASoption(int * NbArg,long * TabArg)259 FuncSetASoption (int *NbArg, long *TabArg)
260 {
261 #if 0
262 TO
263 BE
264 DONE
265 #endif
266 return NULL;
267 }
268
269 /* Fonction qui retourne la sortie d'une commande */
270 char *
FuncGetOutput(int * NbArg,long * TabArg)271 FuncGetOutput (int *NbArg, long *TabArg)
272 {
273 char *cmndbuf;
274 char *str;
275 int line, index, i = 2, j = 0, k, NewWord;
276 FILE *f;
277 int maxsize = 32000;
278 int size;
279
280 (*NbArg)++;
281 cmndbuf = CalcArg (TabArg, NbArg);
282 (*NbArg)++;
283 str = CalcArg (TabArg, NbArg);
284 line = atoi (str);
285 free (str);
286 (*NbArg)++;
287 str = CalcArg (TabArg, NbArg);
288 index = atoi (str);
289 free (str);
290
291 if ((strcmp (Command, cmndbuf)) || ((time (NULL) - TimeCom) > 1) || (TimeCom
292 == 0))
293 {
294 if ((f = popen (cmndbuf, "r")) == NULL)
295 {
296 fprintf (stderr, "%s: can't run %s\n", ScriptName, cmndbuf);
297 str = (char *) calloc (sizeof (char), 10);
298 free (cmndbuf);
299 return str;
300 }
301 else
302 {
303 if (strcmp (Command, "None"))
304 free (BufCom);
305 BufCom = (char *) calloc (sizeof (char), maxsize);
306 size = fread (BufCom, 1, maxsize, f);
307 pclose (f);
308 strcpy (Command, cmndbuf);
309 TimeCom = time (NULL);
310 }
311 }
312 /* Recherche de la ligne */
313 while ((i <= line) && (BufCom[j] != '\0'))
314 {
315 j++;
316 if (BufCom[j] == '\n')
317 i++;
318 }
319
320 /* Recherche du mot */
321 if (index != -1)
322 {
323 if (i != 2)
324 j++;
325 i = 1;
326 NewWord = 0;
327 while ((i < index) && (BufCom[j] != '\n') && (BufCom[j] != '\0'))
328 {
329 j++;
330 if (BufCom[j] == ' ')
331 {
332 if (NewWord)
333 {
334 i++;
335 NewWord = 0;
336 }
337 }
338 else if (!NewWord)
339 NewWord = 1;
340 }
341 str = (char *) calloc (sizeof (char), 255);
342 sscanf (&BufCom[j], "%s", str);
343 }
344 else
345 { /* Lecture de la ligne complete */
346 if (i != 2)
347 j++;
348 k = j;
349 while ((BufCom[k] != '\n') && (BufCom[k] != '\0'))
350 k++;
351 str = (char *) calloc (sizeof (char), k - j + 1);
352 memmove (str, &BufCom[j], k - j);
353 str[k - j] = '\0';
354 }
355
356 free (cmndbuf);
357 return str;
358 }
359
360 /* Convertion decimal vers hexadecimal */
361 char *
FuncNumToHex(int * NbArg,long * TabArg)362 FuncNumToHex (int *NbArg, long *TabArg)
363 {
364 char *str;
365 int value, nbchar;
366 int i, j;
367
368 (*NbArg)++;
369 str = CalcArg (TabArg, NbArg);
370 value = atoi (str);
371 free (str);
372 (*NbArg)++;
373 str = CalcArg (TabArg, NbArg);
374 nbchar = atoi (str);
375 free (str);
376
377 str = (char *) calloc (1, nbchar + 10);
378 sprintf (str, "%X", value);
379 j = strlen (str);
380 if (j < nbchar)
381 {
382 memmove (&str[nbchar - j], str, j);
383 for (i = 0; i < (nbchar - j); i++)
384 str[i] = '0';
385 }
386 return str;
387 }
388
389 /* Convertion hexadecimal vers decimal */
390 char *
FuncHexToNum(int * NbArg,long * TabArg)391 FuncHexToNum (int *NbArg, long *TabArg)
392 {
393 char *str, *str2;
394 int k;
395
396 (*NbArg)++;
397 str = CalcArg (TabArg, NbArg);
398 if (str[0] == '#')
399 memmove (str, &str[1], strlen (str));
400 k = (int) strtol (str, NULL, 16);
401 free (str);
402
403 str2 = (char *) calloc (1, 20);
404 sprintf (str2, "%d", k);
405 return str2;
406 }
407 char *
FuncAdd(int * NbArg,long * TabArg)408 FuncAdd (int *NbArg, long *TabArg)
409 {
410 char *str;
411 int val1, val2;
412
413 (*NbArg)++;
414 str = CalcArg (TabArg, NbArg);
415 val1 = atoi (str);
416 free (str);
417 (*NbArg)++;
418 str = CalcArg (TabArg, NbArg);
419 val2 = atoi (str);
420 free (str);
421 str = (char *) calloc (1, 20);
422 sprintf (str, "%d", val1 + val2);
423 return str;
424 }
425 char *
FuncMult(int * NbArg,long * TabArg)426 FuncMult (int *NbArg, long *TabArg)
427 {
428 char *str;
429 int val1, val2;
430
431 (*NbArg)++;
432 str = CalcArg (TabArg, NbArg);
433 val1 = atoi (str);
434 free (str);
435 (*NbArg)++;
436 str = CalcArg (TabArg, NbArg);
437 val2 = atoi (str);
438 free (str);
439 str = (char *) calloc (1, 20);
440 sprintf (str, "%d", val1 * val2);
441 return str;
442 }
443 char *
FuncDiv(int * NbArg,long * TabArg)444 FuncDiv (int *NbArg, long *TabArg)
445 {
446 char *str;
447 int val1, val2;
448
449 (*NbArg)++;
450 str = CalcArg (TabArg, NbArg);
451 val1 = atoi (str);
452 free (str);
453 (*NbArg)++;
454 str = CalcArg (TabArg, NbArg);
455 val2 = atoi (str);
456 free (str);
457 str = (char *) calloc (1, 20);
458 sprintf (str, "%d", val1 / val2);
459 return str;
460 }
461 char *
RemainderOfDiv(int * NbArg,long * TabArg)462 RemainderOfDiv (int *NbArg, long *TabArg)
463 {
464 char *str;
465 int val1, val2;
466 div_t res;
467
468 (*NbArg)++;
469 str = CalcArg (TabArg, NbArg);
470 val1 = atoi (str);
471 free (str);
472 (*NbArg)++;
473 str = CalcArg (TabArg, NbArg);
474 val2 = atoi (str);
475 free (str);
476 str = (char *) calloc (1, 20);
477 res = div (val1, val2);
478 sprintf (str, "%d", res.rem);
479 return str;
480 }
481 char *
FuncStrCopy(int * NbArg,long * TabArg)482 FuncStrCopy (int *NbArg, long *TabArg)
483 {
484 char *str, *strsrc;
485 int i1, i2;
486
487 (*NbArg)++;
488 strsrc = CalcArg (TabArg, NbArg);
489 (*NbArg)++;
490 str = CalcArg (TabArg, NbArg);
491 i1 = atoi (str);
492 if (i1 < 1)
493 i1 = 1;
494 free (str);
495 (*NbArg)++;
496 str = CalcArg (TabArg, NbArg);
497 i2 = atoi (str);
498 if (i2 < 1)
499 i2 = 1;
500 free (str);
501
502 if ((i1 <= i2) && (i1 <= strlen (strsrc)))
503 {
504 if (i2 > strlen (strsrc))
505 i2 = strlen (strsrc);
506 str = (char *) calloc (1, i2 - i1 + 2);
507 memmove (str, &strsrc[i1 - 1], i2 - i1 + 1);
508 }
509 else
510 {
511 str = (char *) calloc (1, 1);
512 }
513
514 free (strsrc);
515 return str;
516 }
517
518 /* Lancement d'un script avec pipe */
519 char *
LaunchScript(int * NbArg,long * TabArg)520 LaunchScript (int *NbArg, long *TabArg)
521 {
522 char *arg, *execstr, *str, *scriptarg, *scriptname;
523 int leng, i;
524 Atom MyAtom;
525
526 /* Lecture des arguments */
527 (*NbArg)++;
528 arg = CalcArg (TabArg, NbArg);
529
530 str = (char *) calloc (100, sizeof (char));
531
532 /* Calcul du nom du script fils */
533 x11base->TabScriptId[x11base->NbChild + 2] = (char *) calloc (strlen (x11base->TabScriptId[1]) + 4, sizeof (char));
534
535 if (x11base->NbChild < 98)
536 {
537 i = 16;
538 do
539 {
540 sprintf (x11base->TabScriptId[x11base->NbChild + 2], "%s%x", x11base->TabScriptId[1], i);
541 MyAtom = XInternAtom (x11base->display, x11base->TabScriptId[x11base->NbChild + 2], False);
542 i++;
543 }
544 while (XGetSelectionOwner (x11base->display, MyAtom) != None);
545 }
546 else
547 {
548 fprintf (stderr, "Too many launched script\n");
549 sprintf (str, "-1");
550 return str;
551 }
552
553 /* Construction de la commande */
554 execstr = (char *) calloc (strlen (MyName) + strlen (arg) +
555 strlen (x11base->TabScriptId[x11base->NbChild + 2]) + 5, sizeof (char));
556 scriptname = (char *) calloc (sizeof (char), 100);
557 sscanf (arg, "%s", scriptname);
558 scriptarg = (char *) calloc (sizeof (char), strlen (arg));
559 scriptarg = (char *) strncpy (scriptarg, &arg[strlen (scriptname)], strlen (arg) - strlen (scriptname));
560 sprintf (execstr, "%s %s %s %s", MyName, scriptname,
561 x11base->TabScriptId[x11base->NbChild + 2], scriptarg);
562 free (scriptname);
563 free (scriptarg);
564 free (arg);
565
566 /* Envoi de la commande */
567 write (fd[0], &ref, sizeof (Window));
568 leng = strlen (execstr);
569 write (fd[0], &leng, sizeof (int));
570 write (fd[0], execstr, leng);
571 leng = 1;
572 write (fd[0], &leng, sizeof (int));
573 free (execstr);
574
575 /* Retourne l'id du fils */
576 sprintf (str, "%d", x11base->NbChild + 2);
577 x11base->NbChild++;
578 return str;
579 }
580
581 char *
GetScriptFather(int * NbArg,long * TabArg)582 GetScriptFather (int *NbArg, long *TabArg)
583 {
584 char *str;
585
586 str = (char *) calloc (10, sizeof (char));
587 sprintf (str, "0");
588 return str;
589 }
590 char *
GetTime(int * NbArg,long * TabArg)591 GetTime (int *NbArg, long *TabArg)
592 {
593 char *str;
594 time_t t;
595
596 str = (char *) calloc (20, sizeof (char));
597 t = time (NULL);
598 sprintf (str, "%ld", (long) t - x11base->BeginTime);
599 return str;
600 }
601 char *
GetScriptArg(int * NbArg,long * TabArg)602 GetScriptArg (int *NbArg, long *TabArg)
603 {
604 char *str;
605 int val1;
606
607 (*NbArg)++;
608 str = CalcArg (TabArg, NbArg);
609 val1 = atoi (str);
610 free (str);
611
612 str = (char *) calloc (strlen (x11base->TabArg[val1]) + 1, sizeof (char));
613 str = strcpy (str, x11base->TabArg[val1]);
614
615 return str;
616 }
617 char *
ReceivFromScript(int * NbArg,long * TabArg)618 ReceivFromScript (int *NbArg, long *TabArg)
619 {
620 char *arg, *msg;
621 int send;
622 Atom AReceiv, ASend, type;
623 static XEvent event;
624 unsigned long longueur, octets_restant;
625 unsigned char *donnees = "";
626 int format;
627 int NbEssai = 0;
628
629 (*NbArg)++;
630 arg = CalcArg (TabArg, NbArg);
631 send = (int) atoi (arg);
632 free (arg);
633
634 msg = (char *) calloc (256, sizeof (char));
635 sprintf (msg, "No message");
636
637 /* Recuperation des atomes */
638 AReceiv = XInternAtom (x11base->display, x11base->TabScriptId[1], True);
639 if (AReceiv == None)
640 {
641 fprintf (stderr, "Error with atome\n");
642 return msg;
643 }
644 if ((send >= 0) && (send < 99))
645 if (x11base->TabScriptId[send] != NULL)
646 {
647 ASend = XInternAtom (x11base->display, x11base->TabScriptId[send], True);
648 if (ASend == None)
649 fprintf (stderr, "Error with atome\n");
650 }
651 else
652 return msg;
653 else
654 return msg;
655
656 /* Recuperation du message */
657 XConvertSelection (x11base->display, ASend, AReceiv, propriete, x11base->win, CurrentTime);
658 while ((!XCheckTypedEvent (x11base->display, SelectionNotify, &event)) && (NbEssai < 25000))
659 NbEssai++;
660 if (event.xselection.property != None)
661 if (event.xselection.selection == ASend)
662 {
663 XGetWindowProperty (x11base->display, event.xselection.requestor, event.xselection.property, 0,
664 8192, False, event.xselection.target, &type, &format, &longueur, &octets_restant,
665 &donnees);
666 if (longueur > 0)
667 {
668 msg = (char *) realloc ((void *) msg, (longueur + 1) * sizeof (char));
669 msg = strcpy (msg, donnees);
670 XDeleteProperty (x11base->display, event.xselection.requestor, event.xselection.property);
671 XFree (donnees);
672 }
673 }
674 return msg;
675 }
676
677
678 /***********************************************/
679 /* Ensemble des commandes possible pour un obj */
680 /***********************************************/
681
682 void
Exec(int NbArg,long * TabArg)683 Exec (int NbArg, long *TabArg)
684 {
685 int leng;
686 char *execstr;
687 char *tempstr;
688 int i;
689
690 execstr = (char *) calloc (1, 256);
691 for (i = 0; i < NbArg; i++)
692 {
693 tempstr = CalcArg (TabArg, &i);
694 execstr = strcat (execstr, tempstr);
695 free (tempstr);
696 }
697 write (fd[0], &ref, sizeof (Window));
698 leng = strlen (execstr);
699 write (fd[0], &leng, sizeof (int));
700 write (fd[0], execstr, leng);
701 leng = 1;
702 write (fd[0], &leng, sizeof (int));
703
704
705 free (execstr);
706 }
707
708 void
HideObj(int NbArg,long * TabArg)709 HideObj (int NbArg, long *TabArg)
710 {
711 char *arg[1];
712 int IdItem;
713 int i = 0;
714
715 arg[0] = CalcArg (TabArg, &i);
716 IdItem = TabIdObj[atoi (arg[0])];
717
718 tabxobj[IdItem]->flags[0] = True;
719 /* On cache la fentre pour la faire disparaitre */
720 XUnmapWindow (x11base->display, tabxobj[IdItem]->win);
721 free (arg[0]);
722 }
723 void
ShowObj(int NbArg,long * TabArg)724 ShowObj (int NbArg, long *TabArg)
725 {
726 char *arg[1];
727 int IdItem;
728 int i = 0;
729
730 arg[0] = CalcArg (TabArg, &i);
731 IdItem = TabIdObj[atoi (arg[0])];
732
733 tabxobj[IdItem]->flags[0] = False;
734 XMapWindow (x11base->display, tabxobj[IdItem]->win);
735 tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
736 free (arg[0]);
737 }
738 void
ChangeValue(int NbArg,long * TabArg)739 ChangeValue (int NbArg, long *TabArg)
740 {
741 int i = 0;
742 char *arg[2];
743
744 arg[0] = CalcArg (TabArg, &i);
745 i++;
746 arg[1] = CalcArg (TabArg, &i);
747
748 tabxobj[TabIdObj[atoi (arg[0])]]->value = atoi (arg[1]);
749 /* On redessine l'objet pour le mettre a jour */
750 tabxobj[TabIdObj[atoi (arg[0])]]->DrawObj (tabxobj[TabIdObj[atoi (arg[0])]]);
751 free (arg[0]);
752 free (arg[1]);
753 }
754 void
ChangeValueMax(int NbArg,long * TabArg)755 ChangeValueMax (int NbArg, long *TabArg)
756 {
757 int i = 0;
758 char *arg[2];
759 int j;
760
761 arg[0] = CalcArg (TabArg, &i);
762 j = atoi (arg[0]);
763 i++;
764 arg[1] = CalcArg (TabArg, &i);
765
766 tabxobj[TabIdObj[j]]->value3 = atoi (arg[1]);
767 /* On redessine l'objet pour le mettre a jour */
768 if (tabxobj[TabIdObj[j]]->value > tabxobj[TabIdObj[j]]->value3)
769 {
770 tabxobj[TabIdObj[j]]->value = atoi (arg[1]);
771 tabxobj[TabIdObj[j]]->DrawObj (tabxobj[TabIdObj[j]]);
772 }
773 free (arg[0]);
774 free (arg[1]);
775 }
776
777 void
ChangeValueMin(int NbArg,long * TabArg)778 ChangeValueMin (int NbArg, long *TabArg)
779 {
780 int i = 0;
781 char *arg[2];
782 int j;
783
784 arg[0] = CalcArg (TabArg, &i);
785 i++;
786 arg[1] = CalcArg (TabArg, &i);
787 j = atoi (arg[0]);
788
789 tabxobj[TabIdObj[j]]->value2 = atoi (arg[1]);
790 /* On redessine l'objet pour le mettre a jour */
791 if (tabxobj[TabIdObj[j]]->value < tabxobj[TabIdObj[j]]->value2)
792 {
793 tabxobj[TabIdObj[j]]->value = atoi (arg[1]);
794 tabxobj[TabIdObj[j]]->DrawObj (tabxobj[TabIdObj[j]]);
795 }
796 free (arg[0]);
797 free (arg[1]);
798 }
799
800 void
ChangePos(int NbArg,long * TabArg)801 ChangePos (int NbArg, long *TabArg)
802 {
803 int i = 0;
804 char *arg[3];
805 int an[3];
806 int IdItem;
807
808 arg[0] = CalcArg (TabArg, &i);
809 i++;
810 arg[1] = CalcArg (TabArg, &i);
811 i++;
812 arg[2] = CalcArg (TabArg, &i);
813
814 IdItem = TabIdObj[atoi (arg[0])];
815 for (i = 1; i < 3; i++)
816 an[i] = atoi (arg[i]);
817 tabxobj[IdItem]->x = an[1];
818 tabxobj[IdItem]->y = an[2];
819 XMoveWindow (x11base->display, tabxobj[IdItem]->win, an[1], an[2]);
820
821 free (arg[0]);
822 free (arg[1]);
823 free (arg[2]);
824
825 }
826 void
ChangeFont(int NbArg,long * TabArg)827 ChangeFont (int NbArg, long *TabArg)
828 {
829 int i = 0;
830 char *arg[2];
831 int IdItem;
832 MyFont xfont;
833
834 arg[0] = CalcArg (TabArg, &i);
835 i++;
836 arg[1] = CalcArg (TabArg, &i);
837 IdItem = TabIdObj[atoi (arg[0])];
838
839 tabxobj[IdItem]->font = strdup (arg[1]);
840 if (!load_font (tabxobj[IdItem]->font, &xfont))
841 {
842 fprintf (stderr, "Can't load font %s\n", tabxobj[IdItem]->font);
843 }
844 else
845 {
846 unload_font (&tabxobj[IdItem]->xfont);
847 tabxobj[IdItem]->xfont = xfont;
848 XSetFont (tabxobj[IdItem]->display, tabxobj[IdItem]->gc, tabxobj[IdItem]->xfont.font->fid);
849 }
850 tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
851 free (arg[0]);
852 free (arg[1]);
853 }
854
855 void
ChangeSize(int NbArg,long * TabArg)856 ChangeSize (int NbArg, long *TabArg)
857 {
858 int i = 0;
859 char *arg[3];
860 int an[3];
861 int IdItem;
862
863 arg[0] = CalcArg (TabArg, &i);
864 i++;
865 arg[1] = CalcArg (TabArg, &i);
866 i++;
867 arg[2] = CalcArg (TabArg, &i);
868
869 IdItem = TabIdObj[atoi (arg[0])];
870 for (i = 1; i < 3; i++)
871 an[i] = atoi (arg[i]);
872 tabxobj[IdItem]->width = an[1];
873 tabxobj[IdItem]->height = an[2];
874 XResizeWindow (x11base->display, tabxobj[IdItem]->win, an[1], an[2]);
875 tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
876 free (arg[0]);
877 free (arg[1]);
878 free (arg[2]);
879 }
880 void
ChangeTitle(int NbArg,long * TabArg)881 ChangeTitle (int NbArg, long *TabArg)
882 {
883 int i = 0;
884 char *arg[2];
885 int IdItem;
886
887 arg[0] = CalcArg (TabArg, &i);
888 i++;
889 arg[1] = CalcArg (TabArg, &i);
890 IdItem = TabIdObj[atoi (arg[0])];
891
892 tabxobj[IdItem]->title = strdup (arg[1]);
893 tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
894 free (arg[0]);
895 free (arg[1]);
896 }
897 void
ChangeIcon(int NbArg,long * TabArg)898 ChangeIcon (int NbArg, long *TabArg)
899 {
900 int i = 0;
901 char *arg[2];
902 int IdItem;
903
904 arg[0] = CalcArg (TabArg, &i);
905 i++;
906 arg[1] = CalcArg (TabArg, &i);
907 IdItem = TabIdObj[atoi (arg[0])];
908
909 /* if (tabxobj[IdItem]->icon!=NULL)
910 {
911 free(tabxobj[IdItem]->icon);
912 if (tabxobj[IdItem]->iconPixmap!=None)
913 XFreePixmap(tabxobj[IdItem]->display,tabxobj[IdItem]->iconPixmap);
914 if (tabxobj[IdItem]->icon_maskPixmap!=None)
915 XFreePixmap(tabxobj[IdItem]->display,tabxobj[IdItem]->icon_maskPixmap);
916 }
917 */
918 tabxobj[IdItem]->icon = strdup (arg[1]);
919 LoadIcon (tabxobj[IdItem]);
920 tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
921 free (arg[0]);
922 free (arg[1]);
923 }
924 void
ChangeForeColor(int NbArg,long * TabArg)925 ChangeForeColor (int NbArg, long *TabArg)
926 {
927 int i = 0;
928 char *arg[2];
929 int IdItem;
930
931 arg[0] = CalcArg (TabArg, &i);
932 i++;
933 arg[1] = CalcArg (TabArg, &i);
934 IdItem = TabIdObj[atoi (arg[0])];
935
936 /* Liberation de la couleur */
937 XFreeColors (tabxobj[IdItem]->display, *(tabxobj[IdItem])->colormap,
938 (void *) (&(tabxobj[IdItem])->TabColor[fore]), 1, 0);
939
940 tabxobj[IdItem]->forecolor = (char *) calloc (100, sizeof (char));
941 sprintf (tabxobj[IdItem]->forecolor, "%s", arg[1]);
942
943 MyAllocNamedColor (tabxobj[IdItem]->forecolor, &(tabxobj[IdItem])->TabColor[fore]);
944
945 tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
946
947 free (arg[0]);
948 free (arg[1]);
949
950 }
951 void
ChangeBackColor(int NbArg,long * TabArg)952 ChangeBackColor (int NbArg, long *TabArg)
953 {
954 int i = 0;
955 char *arg[2];
956 int IdItem;
957
958 arg[0] = CalcArg (TabArg, &i);
959 i++;
960 arg[1] = CalcArg (TabArg, &i);
961 IdItem = TabIdObj[atoi (arg[0])];
962
963 /* Liberation de la couleur */
964 XFreeColors (tabxobj[IdItem]->display, *(tabxobj[IdItem])->colormap,
965 (void *) (&(tabxobj[IdItem])->TabColor[back]), 1, 0);
966
967 tabxobj[IdItem]->backcolor = (char *) calloc (100, sizeof (char));
968 sprintf (tabxobj[IdItem]->backcolor, "%s", arg[1]);
969
970 MyAllocNamedColor (tabxobj[IdItem]->backcolor, &(tabxobj[IdItem])->TabColor[back]);
971
972 tabxobj[IdItem]->DrawObj (tabxobj[IdItem]);
973
974 free (arg[0]);
975 free (arg[1]);
976 }
977 void
SetVar(int NbArg,long * TabArg)978 SetVar (int NbArg, long *TabArg)
979 {
980 int i;
981 char *str, *tempstr;
982
983 str = (char *) calloc (sizeof (char), 1);
984 for (i = 1; i < NbArg; i++)
985 {
986 tempstr = CalcArg (TabArg, &i);
987 str = (char *) realloc ((void *) str, sizeof (char) * (1 + strlen (str) + strlen (tempstr)));
988 str = strcat (str, tempstr);
989 free (tempstr);
990 }
991 free (TabVVar[TabArg[0]]);
992 TabVVar[TabArg[0]] = str;
993 }
994
995 void
SendSign(int NbArg,long * TabArg)996 SendSign (int NbArg, long *TabArg)
997 {
998 int i = 0;
999 char *arg[2];
1000 int IdItem;
1001 int TypeMsg;
1002
1003 arg[0] = CalcArg (TabArg, &i);
1004 i++;
1005 arg[1] = CalcArg (TabArg, &i);
1006 IdItem = TabIdObj[atoi (arg[0])];
1007 TypeMsg = atoi (arg[1]);
1008 SendMsg (tabxobj[IdItem], TypeMsg);
1009 free (arg[0]);
1010 free (arg[1]);
1011 }
1012 void
WarpPointer(int NbArg,long * TabArg)1013 WarpPointer (int NbArg, long *TabArg)
1014 {
1015 int i = 0;
1016 char *arg;
1017 int IdItem;
1018
1019 arg = CalcArg (TabArg, &i);
1020 IdItem = TabIdObj[atoi (arg)];
1021 /* Deplacement du pointeur sur l'objet */
1022 XWarpPointer (x11base->display, None, tabxobj[IdItem]->win, 0, 0, 0, 0,
1023 tabxobj[IdItem]->width / 2, tabxobj[IdItem]->height + 10);
1024 free (arg);
1025 }
1026 void
Quit(int NbArg,long * TabArg)1027 Quit (int NbArg, long *TabArg)
1028 {
1029 int i;
1030 static XEvent event;
1031 fd_set in_fdset;
1032 extern int x_fd;
1033 Atom MyAtom;
1034 int NbEssai = 0;
1035 struct timeval tv;
1036
1037 #ifdef DEBUG /* For debugging */
1038 XSync (x11base->display, 0);
1039 #endif
1040
1041 /* On cache la fenetre */
1042 XUnmapWindow (x11base->display, x11base->win);
1043 XFlush (x11base->display);
1044
1045 /* Le script ne possede plus la propriete */
1046 MyAtom = XInternAtom (x11base->display, x11base->TabScriptId[1], False);
1047 XSetSelectionOwner (x11base->display, MyAtom, x11base->root, CurrentTime);
1048
1049 /* On verifie si tous les messages ont ete envoyes */
1050 while ((BuffSend.NbMsg > 0) && (NbEssai < 10000))
1051 {
1052 tv.tv_sec = 1;
1053 tv.tv_usec = 0;
1054 FD_ZERO (&in_fdset);
1055 FD_SET (x_fd, &in_fdset);
1056 select (32, &in_fdset, NULL, NULL, &tv);
1057 if (FD_ISSET (x_fd, &in_fdset))
1058 {
1059 if (XCheckTypedEvent (x11base->display, SelectionRequest, &event))
1060 SendMsgToScript (event);
1061 else
1062 NbEssai++;
1063 }
1064 }
1065 XFlush (x11base->display);
1066
1067 /* Attente de deux secondes afin d'etre sur que tous */
1068 /* les messages soient arrives a destination */
1069 /* On quitte proprement le serveur X */
1070 for (i = 0; i < nbobj; i++)
1071 tabxobj[i]->DestroyObj (tabxobj[i]);
1072 XFlush (x11base->display);
1073 /* XSync(x11base->display,True); */
1074 sleep (2);
1075 XFreeGC (x11base->display, x11base->gc);
1076 XFreeColormap (x11base->display, x11base->colormap);
1077 XDestroyWindow (x11base->display, x11base->win);
1078 XCloseDisplay (x11base->display);
1079 exit (0);
1080 }
1081
1082 void
IfThen(int NbArg,long * TabArg)1083 IfThen (int NbArg, long *TabArg)
1084 {
1085 char *arg[10];
1086 int i, j;
1087 int CurrArg = 0;
1088 int IdFuncComp = 0;
1089
1090 /* Verification de la condition */
1091 for (j = 0; j < NbArg - 2; j++)
1092 {
1093 if (TabArg[j] > 100000)
1094 { /* Cas du codage d'un nombre */
1095 i = (int) TabArg[j] - 200000;
1096 arg[CurrArg] = (char *) calloc (1, sizeof (char) * 10);
1097 sprintf (arg[CurrArg], "%d", i);
1098 CurrArg++;
1099 }
1100 else if (TabArg[j] < -200000)
1101 { /* Cas d'un id de fonction de comparaison */
1102 IdFuncComp = TabArg[j] + 250000;
1103 }
1104 else if (TabArg[j] < -100000)
1105 { /* Cas d'un id de fonction */
1106 arg[CurrArg] = TabFunc[TabArg[j] + 150000] (&j, TabArg);
1107 CurrArg++;
1108 }
1109 else
1110 { /* Cas d'une variable */
1111 arg[CurrArg] = strdup (TabVVar[TabArg[j]]);
1112 CurrArg++;
1113 }
1114 }
1115
1116 /* Comparaison des arguments */
1117 if (TabComp[IdFuncComp] (arg[0], arg[1]))
1118 ExecBloc ((Bloc *) TabArg[NbArg - 2]);
1119 else if (TabArg[NbArg - 1] != 0)
1120 ExecBloc ((Bloc *) TabArg[NbArg - 1]);
1121
1122 free (arg[0]);
1123 free (arg[1]);
1124 }
1125
1126 /* Instruction boucle */
1127 void
Loop(int NbArg,long * TabArg)1128 Loop (int NbArg, long *TabArg)
1129 {
1130 int IdVar;
1131 char *arg[2];
1132 int limit[2];
1133 int i;
1134 int CurrArg = 0;
1135
1136 /* le premier argument est une variable */
1137 IdVar = TabArg[0];
1138 /*On ajuste la taille de la var pour contenir un nombre */
1139 TabVVar[TabArg[0]] = (char *) realloc (TabVVar[TabArg[0]], sizeof (char) * 10);
1140 /* Calcul des 2 autres arguments */
1141 for (i = 1; i < NbArg - 1; i++)
1142 {
1143 if (TabArg[i] > 100000)
1144 { /* Cas du codage d'un nombre */
1145 i = (int) TabArg[i] - 200000;
1146 arg[CurrArg] = (char *) calloc (1, sizeof (char) * 10);
1147 sprintf (arg[CurrArg], "%d", i);
1148 }
1149 else if (TabArg[i] < -100000)
1150 { /* Cas d'un id de fonction */
1151 arg[CurrArg] = TabFunc[TabArg[i] + 150000] (&i, TabArg);
1152 }
1153 else /* Cas d'une variable */
1154 arg[CurrArg] = strdup (TabVVar[TabArg[i]]);
1155 CurrArg++;
1156 }
1157 limit[0] = atoi (arg[0]);
1158 limit[1] = atoi (arg[1]);
1159 if (limit[0] < limit[1])
1160 for (i = limit[0]; i <= limit[1]; i++)
1161 {
1162 /* On met a jour la variable */
1163 sprintf (TabVVar[TabArg[0]], "%d", i);
1164 ExecBloc ((Bloc *) TabArg[NbArg - 1]);
1165 }
1166 else
1167 for (i = limit[0]; i <= limit[1]; i++)
1168 {
1169 sprintf (TabVVar[TabArg[0]], "%d", i);
1170 ExecBloc ((Bloc *) TabArg[NbArg - 1]);
1171 }
1172
1173 free (arg[0]);
1174 free (arg[1]);
1175 }
1176
1177 /* Instruction While */
1178 void
While(int NbArg,long * TabArg)1179 While (int NbArg, long *TabArg)
1180 {
1181 char *arg[3], *str;
1182 int i;
1183 int Loop = 1;
1184 int IdFuncComp;
1185
1186 while (Loop)
1187 {
1188 i = 0;
1189 arg[0] = CalcArg (TabArg, &i);
1190 i++;
1191 str = CalcArg (TabArg, &i);
1192 IdFuncComp = atoi (str);
1193 free (str);
1194 i++;
1195 arg[1] = CalcArg (TabArg, &i);
1196
1197 Loop = TabComp[IdFuncComp] (arg[0], arg[1]);
1198 if (Loop)
1199 ExecBloc ((Bloc *) TabArg[NbArg - 1]);
1200 free (arg[0]);
1201 free (arg[1]);
1202 }
1203 }
1204 void
WriteToFile(int NbArg,long * TabArg)1205 WriteToFile (int NbArg, long *TabArg)
1206 {
1207 int i = 0;
1208 char *arg[2], str[50], *tempstr, *home, *file;
1209 FILE *f;
1210 char StrBegin[100];
1211 char StrEnd[10];
1212 size_t size;
1213 char *buf;
1214 int maxsize = 32000;
1215 int CurrPos = 0, CurrPos2;
1216 int OldPID;
1217
1218 arg[0] = CalcArg (TabArg, &i);
1219 arg[1] = (char *) calloc (1, 256);
1220 for (i = 1; i < NbArg; i++)
1221 {
1222 tempstr = CalcArg (TabArg, &i);
1223 arg[1] = strcat (arg[1], tempstr);
1224 free (tempstr);
1225 }
1226 if (arg[1][strlen (arg[1]) - 1] != '\n')
1227 {
1228 i = strlen (arg[1]);
1229 arg[1] = (char *) realloc (arg[1], strlen (arg[1]) + 2);
1230 arg[1][i] = '\n';
1231 arg[1][i + 1] = '\0';
1232 }
1233 sprintf (StrEnd, "#end\n");
1234 sprintf (StrBegin, "#%s,", ScriptName);
1235
1236 buf = (char *) calloc (1, maxsize);
1237
1238 if (arg[0][0] != '/')
1239 {
1240 file = strdup (arg[0]);
1241 home = getenv ("HOME");
1242 arg[0] = (char *) realloc (arg[0], sizeof (char) * (strlen (arg[0]) + 4 + strlen (home)));
1243 sprintf (arg[0], "%s/%s", home, file);
1244 /* free(home); BUG */
1245 free (file);
1246 }
1247 f = fopen (arg[0], "a+");
1248 fseek (f, 0, SEEK_SET);
1249 size = fread (buf, 1, maxsize, f);
1250 while (((strncmp (StrBegin, &buf[CurrPos], strlen (StrBegin))) != 0) && (CurrPos < size))
1251 CurrPos++;
1252 if (CurrPos == size)
1253 {
1254 sprintf (buf, "%s\n%s%d\n", buf, StrBegin, getpid ());
1255 sprintf (buf, "%s%s", buf, arg[1]);
1256 sprintf (buf, "%s%s\n", buf, StrEnd);
1257 }
1258 else
1259 {
1260 sscanf (&buf[CurrPos + strlen (StrBegin)], "%d", &OldPID);
1261 if (OldPID == getpid ())
1262 {
1263 sprintf (str, "%d\n", OldPID);
1264 while (((strncmp (StrEnd, &buf[CurrPos], strlen (StrEnd))) != 0) && (CurrPos < size))
1265 CurrPos++;
1266 memmove (&buf[CurrPos + strlen (arg[1])], &buf[CurrPos], strlen (buf) - CurrPos);
1267 memmove (&buf[CurrPos], arg[1], strlen (arg[1]));
1268 }
1269 else
1270 { /* Remplacement des anciennes commandes */
1271 CurrPos = CurrPos + strlen (StrBegin);
1272 CurrPos2 = CurrPos;
1273 while (((strncmp (StrEnd, &buf[CurrPos2], strlen (StrEnd))) != 0) && (CurrPos2 < size))
1274 CurrPos2++;
1275 sprintf (str, "%d\n%s", getpid (), arg[1]);
1276 memmove (&buf[CurrPos + strlen (str)], &buf[CurrPos2], strlen (buf) - CurrPos2);
1277 buf[strlen (buf) - ((CurrPos2 - CurrPos) - strlen (str))] = '\0';
1278 memmove (&buf[CurrPos], str, strlen (str));
1279 }
1280 }
1281
1282 fclose (f);
1283 f = fopen (arg[0], "w");
1284 if (f == NULL)
1285 {
1286 fprintf (stderr, "Enable to open file %s\n", arg[0]);
1287 return;
1288 }
1289 fwrite (buf, 1, strlen (buf), f);
1290 fclose (f);
1291
1292 free (arg[0]);
1293 free (arg[1]);
1294 }
1295
1296 void
SendToScript(int NbArg,long * TabArg)1297 SendToScript (int NbArg, long *TabArg)
1298 {
1299 char *tempstr, *Msg, *R;
1300 int dest;
1301 int j = 0;
1302 Atom myatom;
1303
1304 /* Calcul destinataire */
1305 tempstr = CalcArg (TabArg, &j);
1306 dest = (int) atoi (tempstr);
1307 free (tempstr);
1308
1309 /* Calcul contenu */
1310 Msg = (char *) calloc (256, sizeof (char));
1311 for (j = 1; j < NbArg; j++)
1312 {
1313 tempstr = CalcArg (TabArg, &j);
1314 Msg = (char *) realloc ((void *) Msg, strlen (Msg) + strlen (tempstr) + 1);
1315 Msg = strcat (Msg, tempstr);
1316 free (tempstr);
1317 } /* Calcul recepteur */
1318 R = (char *) calloc (strlen (x11base->TabScriptId[dest]) + 1, sizeof (char));
1319 sprintf (R, "%s", x11base->TabScriptId[dest]);
1320 myatom = XInternAtom (x11base->display, R, True);
1321
1322 if ((BuffSend.NbMsg < 40) && (XGetSelectionOwner (x11base->display, myatom) != None))
1323 {
1324 /* Enregistrement dans le buffer du message */
1325 BuffSend.TabMsg[BuffSend.NbMsg].Msg = Msg;
1326 /* Enregistrement dans le buffer du destinataire */
1327 BuffSend.TabMsg[BuffSend.NbMsg].R = R;
1328 /* Enregistrement du message */
1329 BuffSend.NbMsg++;
1330
1331 /* Reveil du destinataire */
1332 XConvertSelection (x11base->display, XInternAtom (x11base->display, x11base->TabScriptId[dest], True)
1333 ,propriete, propriete, x11base->win, CurrentTime);
1334 }
1335 else
1336 {
1337 fprintf (stderr, "Too many messages sended\n");
1338 free (Msg);
1339 }
1340 }
1341
1342 /****************************************************/
1343 /* Fonction d'initialisation de TabCom et TabFunc */
1344 /****************************************************/
1345 void
InitCom()1346 InitCom ()
1347 {
1348 /* commande */
1349 TabCom[1] = Exec;
1350 TabCom[2] = HideObj;
1351 TabCom[3] = ShowObj;
1352 TabCom[4] = ChangeValue;
1353 TabCom[5] = ChangePos;
1354 TabCom[6] = ChangeSize;
1355 TabCom[7] = ChangeIcon;
1356 TabCom[8] = ChangeTitle;
1357 TabCom[9] = ChangeFont;
1358 TabCom[10] = ChangeForeColor;
1359 TabCom[11] = SetVar;
1360 TabCom[12] = SendSign;
1361 TabCom[13] = Quit;
1362 TabCom[14] = IfThen;
1363 TabCom[15] = Loop;
1364 TabCom[16] = While;
1365 TabCom[17] = WarpPointer;
1366 TabCom[18] = WriteToFile;
1367 TabCom[19] = ChangeBackColor;
1368 TabCom[21] = ChangeValueMax;
1369 TabCom[22] = ChangeValueMin;
1370 TabCom[23] = SendToScript;
1371
1372 /* Fonction */
1373 TabFunc[1] = FuncGetValue;
1374 TabFunc[2] = FuncGetTitle;
1375 TabFunc[3] = FuncGetOutput;
1376 TabFunc[4] = FuncGetASoption;
1377 TabFunc[5] = FuncSetASoption;
1378 TabFunc[6] = FuncNumToHex;
1379 TabFunc[7] = FuncHexToNum;
1380 TabFunc[8] = FuncAdd;
1381 TabFunc[9] = FuncMult;
1382 TabFunc[10] = FuncDiv;
1383 TabFunc[11] = FuncStrCopy;
1384 TabFunc[12] = LaunchScript;
1385 TabFunc[13] = GetScriptFather;
1386 TabFunc[14] = ReceivFromScript;
1387 TabFunc[15] = RemainderOfDiv;
1388 TabFunc[16] = GetTime;
1389 TabFunc[17] = GetScriptArg;
1390
1391 /* Fonction de comparaison */
1392 TabComp[1] = Inf;
1393 TabComp[2] = InfEq;
1394 TabComp[3] = Equal;
1395 TabComp[4] = SupEq;
1396 TabComp[5] = Sup;
1397 TabComp[6] = Diff;
1398
1399 }
1400