Use gcore for creating core dump on segfault
[capablanca.git] / lasker-2.2.3 / src / variable.c
1 /*
2    Copyright (c) 1993 Richard V. Nash.
3    Copyright (c) 2000 Dan Papasian
4    Copyright (C) Andrew Tridgell 2002
5    
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "includes.h"
22
23 static int set_boolean_flag(int p, char *val, unsigned long flag)
24 {
25   int v = -1;
26
27   if (val == NULL) {
28     TogglePFlag(p, flag);
29     v = BoolCheckPFlag(p, flag);
30     return (v);
31   }
32   if (sscanf(val, "%d", &v) != 1) {
33     stolower(val);
34     if (!strcmp(val, "off") || !strcmp(val, "false"))
35       v = 0;
36     else if (!strcmp(val, "on") || !strcmp(val, "true"))
37       v = 1;
38   }
39   SetPFlag(p, flag, v);
40   return v;
41 }
42
43 static int set_availinfo(int p, char *var, char *val)
44 {
45   int v = set_boolean_flag(p, val, PFLAG_AVAIL);
46
47   if (v < 0)
48     return VAR_BADVAL;
49    pprintf(p, "availinfo set to %d.\n", BoolCheckPFlag(p, PFLAG_AVAIL));
50
51   if (v > 0)
52     pprintf(p, "You will receive info on who is available to play.\n");
53   else
54     pprintf(p, "You are no longer receiving info on who is available to play.\n");
55   return VAR_OK;
56 }
57
58 static int set_availmax(int p, char *var, char *val)
59 {
60   struct player *pp = &player_globals.parray[p];
61   int v = -1;
62
63   if (!val)
64     return VAR_BADVAL;
65   if (sscanf(val, "%d", &v) != 1)
66     return VAR_BADVAL;
67   if ((v < 0) || (v > 9999))
68     return VAR_BADVAL;
69
70   if (v < pp->availmin) {
71     pprintf(p, "You can't set availmax to less than availmin.\n");
72     return VAR_OK;
73   }
74
75   if ((pp->availmax = v)) {
76     pprintf(p, "You will be notified of availability with blitz ratings %d - %d.\n",pp->availmin,v); 
77   } else
78     pprintf(p, "You will be notified of all available players.\n");
79   return VAR_OK;
80 }
81
82 static int set_availmin(int p, char *var, char *val)
83 {
84   struct player *pp = &player_globals.parray[p];
85   int v = -1;
86
87   if (!val)
88     return VAR_BADVAL;
89   if (sscanf(val, "%d", &v) != 1)
90     return VAR_BADVAL;
91   if ((v < 0) || (v > 9999))
92     return VAR_BADVAL;
93
94   if (v > pp->availmax) {
95     pprintf(p, "You can't set availmin to more than availmax.\n");
96     return VAR_OK;
97   }
98
99   pp->availmin = v;
100   pprintf(p, "You will be notified of availability with blitz ratings %d - %d.\n",v,pp->availmax);
101   return VAR_OK;
102 }
103
104 static int set_open(int p, char *var, char *val)
105 {
106   struct player *pp = &player_globals.parray[p];
107   int v = set_boolean_flag(p, val, PFLAG_OPEN);
108
109   if (v < 0)
110     return VAR_BADVAL;
111   if (v > 0) {
112     pprintf(p, "You are now open to receive match requests.\n");
113     announce_avail (p);
114   } else {
115     decline_withdraw_offers(p, -1, PEND_MATCH,DO_DECLINE | DO_WITHDRAW);
116     pprintf(p, "You are no longer receiving match requests.\n");
117     if (pp->game < 0)
118       announce_notavail (p);
119   }
120   return VAR_OK;
121 }
122
123 static int set_tourney(int p, char *var, char *val)
124 {
125   struct player *pp = &player_globals.parray[p];
126   int v = set_boolean_flag(p, val, PFLAG_TOURNEY);
127
128   if (v < 0)
129     return VAR_BADVAL;
130   if (v > 0) {
131     decline_withdraw_offers(p, -1, PEND_MATCH,DO_DECLINE | DO_WITHDRAW);
132     pprintf(p, "Your tournament variable is now set.\n");
133     announce_notavail (p);
134   } else {
135     pprintf(p, "Your tournament variable is no longer set.\n");
136     if (pp->game < 0)
137       announce_avail (p);
138   }
139   return VAR_OK;
140 }
141
142 static int set_sopen(int p, char *var, char *val)
143 {
144   int v = set_boolean_flag(p, val, PFLAG_SIMOPEN);
145
146   if (v < 0)
147     return VAR_BADVAL;
148   pprintf(p, "sopen set to %d.\n", v);
149
150   if (v > 0)
151     pprintf(p, "You are now open to receive simul requests.\n");
152   else
153     pprintf(p, "You are no longer receiving simul requests.\n");
154   decline_withdraw_offers(p, -1, PEND_SIMUL,DO_DECLINE);
155   return VAR_OK;
156 }
157
158 static int set_ropen(int p, char *var, char *val)
159 {
160   if (set_boolean_flag(p, val, PFLAG_ROPEN) < 0)
161     return VAR_BADVAL;
162   pprintf(p, "ropen set to %d.\n", BoolCheckPFlag(p, PFLAG_ROPEN));
163   return VAR_OK;
164 }
165
166 static int set_rated(int p, char *var, char *val)
167 {
168   if (!CheckPFlag(p, PFLAG_REG)) {
169     pprintf(p, "You cannot change your rated status.\n");
170     return VAR_OK;
171   }
172   if (set_boolean_flag(p, val, PFLAG_RATED) < 0)
173     return VAR_BADVAL;
174   pprintf(p, "rated set to %d.\n", BoolCheckPFlag(p, PFLAG_RATED));
175   return VAR_OK;
176 }
177
178 static int set_shout(int p, char *var, char *val)
179 {
180   if (set_boolean_flag(p, val, PFLAG_SHOUT) < 0)
181     return VAR_BADVAL;
182   if (CheckPFlag(p, PFLAG_SHOUT))
183     pprintf(p, "You will now hear shouts.\n");
184   else
185     pprintf(p, "You will not hear shouts.\n");
186   return VAR_OK;
187 }
188
189 static int set_ads(int p, char *var, char *val)
190 {
191   if (set_boolean_flag(p, val, PFLAG_ADS) < 0)
192     return VAR_BADVAL;
193   if (CheckPFlag(p, PFLAG_ADS))
194     pprintf(p, "You will now hear ads.\n");
195   else
196     pprintf(p, "You will not hear ads.\n");
197   return VAR_OK;
198 }
199
200 static int set_cshout(int p, char *var, char *val)
201 {
202   if (set_boolean_flag(p, val, PFLAG_CSHOUT) < 0)
203     return VAR_BADVAL;
204   if (CheckPFlag(p, PFLAG_CSHOUT))
205     pprintf(p, "You will now hear cshouts.\n");
206   else
207     pprintf(p, "You will not hear cshouts.\n");
208   return VAR_OK;
209 }
210
211 static int set_kibitz(int p, char *var, char *val)
212 {
213   if (set_boolean_flag(p, val, PFLAG_KIBITZ) < 0)
214     return VAR_BADVAL;
215   if (CheckPFlag(p, PFLAG_KIBITZ))
216     pprintf(p, "You will now hear kibitzes.\n");
217   else
218     pprintf(p, "You will not hear kibitzes.\n");
219   return VAR_OK;
220 }
221 static int set_kiblevel(int p, char *var, char *val)
222 {
223   struct player *pp = &player_globals.parray[p];
224   int v = -1;
225
226   if (!val)
227     return VAR_BADVAL;
228   if (sscanf(val, "%d", &v) != 1)
229     return VAR_BADVAL;
230   if ((v < 0) || (v > 9999))
231     return VAR_BADVAL;
232   pp->kiblevel = v;
233   pprintf(p, "Kibitz level now set to: %d.\n", v);
234   return VAR_OK;
235 }
236
237 static int set_tell(int p, char *var, char *val)
238 {
239   if (set_boolean_flag(p, val, PFLAG_TELL) < 0)
240     return VAR_BADVAL;
241   if (CheckPFlag(p, PFLAG_TELL))
242     pprintf(p, "You will now hear tells from unregistered users.\n");
243   else
244     pprintf(p, "You will not hear tells from unregistered users.\n");
245   return VAR_OK;
246 }
247
248 static int set_notifiedby(int p, char *var, char *val)
249 {
250   if (set_boolean_flag(p, val, PFLAG_NOTIFYBY) < 0)
251     return VAR_BADVAL;
252   if (CheckPFlag(p, PFLAG_NOTIFYBY))
253     pprintf(p, "You will now hear if people notify you, but you don't notify them.\n");
254   else
255     pprintf(p, "You will not hear if people notify you, but you don't notify them.\n");
256   return VAR_OK;
257 }
258
259 static int set_pinform(int p, char *var, char *val)
260 {
261   if (set_boolean_flag(p, val, PFLAG_PIN) < 0)
262     return VAR_BADVAL;
263   if (CheckPFlag(p, PFLAG_PIN))
264     pprintf(p, "You will now hear logins/logouts.\n");
265   else
266     pprintf(p, "You will not hear logins/logouts.\n");
267   return VAR_OK;
268 }
269
270 static int set_ginform(int p, char *var, char *val)
271 {
272   if (set_boolean_flag(p, val, PFLAG_GIN) < 0)
273     return VAR_BADVAL;
274   if (CheckPFlag(p, PFLAG_GIN))
275     pprintf(p, "You will now hear game results.\n");
276   else
277     pprintf(p, "You will not hear game results.\n");
278   return VAR_OK;
279 }
280
281 static int set_private(int p, char *var, char *val)
282 {
283   if (set_boolean_flag(p, val, PFLAG_PRIVATE) < 0)
284     return VAR_BADVAL;
285   if (CheckPFlag(p, PFLAG_PRIVATE))
286     pprintf(p, "Your games will be private.\n");
287   else
288     pprintf(p, "Your games may not be private.\n");
289   return VAR_OK;
290 }
291
292 static int set_jprivate(int p, char *var, char *val)
293 {
294   if (!CheckPFlag(p, PFLAG_REG)) {
295     pprintf(p, "Unregistered players may not keep a journal.\n");
296     return VAR_OK;
297   }
298
299   if (set_boolean_flag(p, val, PFLAG_JPRIVATE) < 0)
300     return VAR_BADVAL;
301   if (CheckPFlag(p, PFLAG_JPRIVATE))
302     pprintf(p, "Your journal will be private.\n");
303   else
304     pprintf(p, "Your journal will not be private.\n");
305   return VAR_OK;
306 }
307
308 static int set_automail(int p, char *var, char *val)
309 {
310   if (set_boolean_flag(p, val, PFLAG_AUTOMAIL) < 0)
311     return VAR_BADVAL;
312   if (CheckPFlag(p, PFLAG_AUTOMAIL))
313     pprintf(p, "Your games will be mailed to you.\n");
314   else
315     pprintf(p, "Your games will not be mailed to you.\n");
316   return VAR_OK;
317 }
318
319 static int set_mailmess(int p, char *var, char *val)
320 {
321   if (!CheckPFlag(p, PFLAG_REG)) {
322     pprintf(p, "Unregistered players may not receive messages.\n");
323     return VAR_OK;
324   }
325   if (set_boolean_flag(p, val, PFLAG_MAILMESS) < 0)
326     return VAR_BADVAL;
327   if (CheckPFlag(p, PFLAG_MAILMESS))
328     pprintf(p, "Your messages will be mailed to you.\n");
329   else
330     pprintf(p, "Your messages will not be mailed to you.\n");
331   return VAR_OK;
332 }
333
334 static int set_pgn(int p, char *var, char *val)
335 {
336   if (set_boolean_flag(p, val, PFLAG_PGN) < 0)
337     return VAR_BADVAL;
338   if (CheckPFlag(p, PFLAG_PGN))
339     pprintf(p, "Games will now be mailed to you in PGN.\n");
340   else
341     pprintf(p, "Games will now be mailed to you in FICS format.\n");
342   return VAR_OK;
343 }
344
345 static int set_bell(int p, char *var, char *val)
346 {
347   if (set_boolean_flag(p, val, PFLAG_BELL) < 0)
348     return VAR_BADVAL;
349   if (CheckPFlag(p, PFLAG_BELL))
350     pprintf(p, "Bell on.\n");
351   else
352     pprintf(p, "Bell off.\n");
353   return VAR_OK;
354 }
355
356 static int set_highlight(int p, char *var, char *val)
357 {
358   struct player *pp = &player_globals.parray[p];
359   int v = -1;
360
361   if (!val)
362     return VAR_BADVAL;
363   if (sscanf(val, "%d", &v) != 1)
364     return VAR_BADVAL;
365   if ((v < 0) || (v > 15))
366     return VAR_BADVAL;
367
368   if ((pp->highlight = v)) {
369     pprintf(p, "Highlight is now style ");
370     pprintf_highlight(p, "%d", v);
371     pprintf(p, ".\n");
372   } else
373     pprintf(p, "Highlight is off.\n");
374   return VAR_OK;
375 }
376
377 static int set_style(int p, char *var, char *val)
378 {
379   struct player *pp = &player_globals.parray[p];
380   int v = -1;
381
382   if (!val)
383     return VAR_BADVAL;
384   if (sscanf(val, "%d", &v) != 1)
385     return VAR_BADVAL;
386   if ((v < 1) || (v > MAX_STYLES))
387     return VAR_BADVAL;
388   pp->style = v - 1;
389   pprintf(p, "Style %d set.\n", v);
390   return VAR_OK;
391 }
392
393 static int set_flip(int p, char *var, char *val)
394 {
395   if (set_boolean_flag(p, val, PFLAG_FLIP) < 0)
396     return VAR_BADVAL;
397   if (CheckPFlag(p, PFLAG_FLIP))
398     pprintf(p, "Flip on.\n");
399   else
400     pprintf(p, "Flip off.\n");
401   return VAR_OK;
402 }
403 /* Was pointless as this is what notes are for
404 static int set_uscf(int p, char *var, char *val)
405 {
406   int v = -1;
407
408   if (!val)
409     return VAR_BADVAL;
410   if (sscanf(val, "%d", &v) != 1)
411     return VAR_BADVAL;
412   if ((v < 0) || (v > 3000))
413     return VAR_BADVAL;
414   pp->uscfRating = v;
415   pprintf(p, "USCF Rating set to %d.\n", v);
416   return VAR_OK;
417 }
418 */
419 static int set_time(int p, char *var, char *val)
420 {
421   struct player *pp = &player_globals.parray[p];
422   int v = -1;
423
424   if (!val)
425     return VAR_BADVAL;
426   if (sscanf(val, "%d", &v) != 1)
427     return VAR_BADVAL;
428   if ((v < 0) || (v > 240))
429     return VAR_BADVAL;
430   pp->d_time = v;
431   pprintf(p, "Default time set to %d.\n", v);
432   return VAR_OK;
433 }
434
435 static int set_inc(int p, char *var, char *val)
436 {
437   struct player *pp = &player_globals.parray[p];
438   int v = -1;
439
440   if (!val)
441     return VAR_BADVAL;
442   if (sscanf(val, "%d", &v) != 1)
443     return VAR_BADVAL;
444   if ((v < 0) || (v > 300))
445     return VAR_BADVAL;
446   pp->d_inc = v;
447   pprintf(p, "Default increment set to %d.\n", v);
448   return VAR_OK;
449 }
450
451 static int set_height(int p, char *var, char *val)
452 {
453   struct player *pp = &player_globals.parray[p];
454   int v = -1;
455
456   if (!val)
457     return VAR_BADVAL;
458   if (sscanf(val, "%d", &v) != 1)
459     return VAR_BADVAL;
460   if ((v < 5) || (v > 240))
461     return VAR_BADVAL;
462   pp->d_height = v;
463   pprintf(p, "Height set to %d.\n", v);
464   return VAR_OK;
465 }
466
467 static int set_width(int p, char *var, char *val)
468 {
469         struct player *pp = &player_globals.parray[p];
470         int v = -1;
471
472         if (!val)
473                 return VAR_BADVAL;
474         if (sscanf(val, "%d", &v) != 1)
475                 return VAR_BADVAL;
476         if ((v < 32) || (v > 10000))
477                 return VAR_BADVAL;
478         pp->d_width = v;
479         pprintf(p, "Width set to %d.\n", v);
480         return VAR_OK;
481 }
482
483 const char *Language(int i)
484 {
485   static const char *Lang[NUM_LANGS] = {"English", "Spanish", "French", "Danish"};
486   return Lang[i];
487 }
488
489 static int set_language (int p, char *var, char *val)
490 {
491   struct player *pp = &player_globals.parray[p];
492   int i, len, gotIt = -1;
493
494   if (!val)
495     return VAR_BADVAL;
496   len = strlen(val);
497   for (i=0; i < NUM_LANGS; i++) {
498     if (strncasecmp(val, Language(i), len))
499       continue;
500     if (gotIt >= 0)
501       return VAR_BADVAL;
502     else gotIt = i;
503   }
504   if (gotIt < 0)
505     return VAR_BADVAL;
506   pp->language = gotIt;
507   pprintf(p, "Language set to %s.\n", Language(gotIt));
508   return VAR_OK;
509 }
510
511 static int set_promote(int p, char *var, char *val)
512 {
513   struct player *pp = &player_globals.parray[p];
514   if (!val)
515     return VAR_BADVAL;
516   stolower(val);
517   switch (val[0]) {
518   case 'q':
519     pp->promote = QUEEN;
520     pprintf(p, "Promotion piece set to QUEEN.\n");
521     break;
522   case 'r':
523     pp->promote = ROOK;
524     pprintf(p, "Promotion piece set to ROOK.\n");
525     break;
526   case 'b':
527     pp->promote = BISHOP;
528     pprintf(p, "Promotion piece set to BISHOP.\n");
529     break;
530   case 'n':
531   case 'k':
532     pp->promote = KNIGHT;
533     pprintf(p, "Promotion piece set to KNIGHT.\n");
534     break;
535   default:
536     return VAR_BADVAL;
537   }
538   return VAR_OK;
539 }
540
541
542 static int set_interface(int p, char *var, char *val)
543 {
544         struct player *pp = &player_globals.parray[p];
545         if (!val) {
546                 FREE(pp->interface);
547                 return VAR_OK;
548         }
549         if (!printablestring(val))
550                 return VAR_BADVAL;
551         FREE(pp->interface);
552         asprintf(&pp->interface, "%s", val);
553         return VAR_OK;
554 }
555
556 static int set_prompt(int p, char *var, char *val)
557 {
558         struct player *pp = &player_globals.parray[p];
559         char *prompt;
560         if (!val) {
561                 free(pp->prompt);
562                 pp->prompt = config_get("DEFAULT_PROMPT");
563                 return VAR_OK;
564         }
565         if (!printablestring(val))
566                 return VAR_BADVAL;
567         free(pp->prompt);
568         asprintf(&prompt, "%s", val);
569         pp->prompt = prompt;
570         return VAR_OK;
571 }
572
573 static int RePartner (int p, int new)
574 {
575   struct player *pp = &player_globals.parray[p];
576   int pOld;
577
578   if (p < 0)
579     return -1;
580   pOld = pp->partner;
581   if (pOld >= 0) {
582     if (player_globals.parray[pOld].partner == p) {
583       if (new >= 0)
584         pprintf_prompt (pOld, "Your partner has just chosen a new partner.\n");
585       else {
586         pprintf (pOld, "Your partner has unset his/her partner variable.\n");
587         pprintf_prompt (pOld, "You are no longer %s's partner.\n",pp->name);
588       }
589       decline_withdraw_offers (pOld, -1, PEND_BUGHOUSE,DO_DECLINE | DO_WITHDRAW);
590       player_globals.parray[pOld].partner = -1;
591     }
592   }
593   decline_withdraw_offers(p, -1, PEND_BUGHOUSE,DO_DECLINE | DO_WITHDRAW);
594   decline_withdraw_offers(p, -1, PEND_PARTNER,DO_DECLINE | DO_WITHDRAW);
595   pp->partner = new;
596   return new;
597 }
598
599 int com_partner(int p, param_list param)
600 {
601   struct player *pp = &player_globals.parray[p];
602   int pNew;
603   struct pending* pend;
604
605   if (param[0].type == TYPE_NULL) {
606     if (pp->partner >= 0)
607       pprintf (p, "You no longer have a bughouse partner.\n");
608     else pprintf (p, "You do not have a bughouse partner.\n");
609     RePartner(p, -1);
610     return COM_OK;
611   }
612   /* OK, we're trying to set a new partner. */
613   pNew = player_find_part_login(param[0].val.word);
614   if (pNew < 0 || player_globals.parray[pNew].status == PLAYER_PASSWORD
615       || player_globals.parray[pNew].status == PLAYER_LOGIN) {
616     pprintf(p, "No user named \"%s\" is logged in.\n", param[0].val.word);
617     return COM_OK;
618   }
619   if (pNew == p) {
620     pprintf(p, "You can't be your own bughouse partner.\n");
621     return COM_OK; 
622   }
623   /* Now we know a legit partner has been chosen.  Is an offer pending? */
624   if ((pend = find_pend(pNew, p, PEND_PARTNER)) != NULL) {
625     pprintf (p, "You agree to be %s's partner.\n", player_globals.parray[pNew].name);
626     Bell (pNew);
627     pprintf_prompt (pNew, "%s agrees to be your partner.\n", pp->name);
628
629     delete_pending (pend);
630
631     /* Make the switch. */
632     RePartner (p, pNew);
633     RePartner (pNew, p);
634     return COM_OK;
635   }
636   /* This is just an offer. Make sure a new partner is needed. */
637   if (player_globals.parray[pNew].partner >= 0) {
638     pprintf(p, "%s already has a partner.\n", player_globals.parray[pNew].name);
639     return COM_OK;
640   }
641   pprintf(pNew, "\n");
642   pprintf_highlight(pNew, "%s", pp->name);
643   Bell (pNew);
644   pprintf(pNew, " offers to be your bughouse partner; ");
645   pprintf_prompt(pNew, "type \"partner %s\" to accept.\n", pp->name);
646   pprintf(p, "Making a partnership offer to %s.\n", player_globals.parray[pNew].name);
647   add_request(p, pNew, PEND_PARTNER);
648
649   return COM_OK;
650 }
651
652 static int set_busy(int p, char *var, char *val)
653 {
654   struct player *pp = &player_globals.parray[p];
655   if (!val) {
656     if (pp->busy != NULL) {
657       free (pp->busy);
658       pp->busy = NULL;
659     }
660     pprintf(p, "Your \"busy\" string was cleared.\n");
661     return VAR_OK;
662   }
663   if ((val) && (!printablestring(val)))
664     return VAR_BADVAL;
665   pp->busy = strdup(val);
666   pprintf(p, "Your \"busy\" string was set to \" %s\"\n", pp->busy);
667   return VAR_OK;
668 }
669
670 /* this is really ugly */
671 static int set_plan(int p, char *var, char *val)
672 {
673   struct player *pp = &player_globals.parray[p];
674   int which;
675   int i;
676
677   if (val && !printablestring(val))
678     return VAR_BADVAL;
679   which = atoi(var);            /* Must be an integer, no test needed */
680
681   if (which > MAX_PLAN)
682     return VAR_BADVAL;
683
684   if (which > pp->num_plan)
685     which = pp->num_plan + 1;
686
687   if (which == 0) {  /* shove from top */
688     if (pp->num_plan >= MAX_PLAN) { /* free the bottom string */
689       if (pp->planLines[pp->num_plan - 1] != NULL)
690         free(pp->planLines[pp->num_plan - 1]);
691     }
692     if (pp->num_plan) {
693       for (i = (pp->num_plan >= MAX_PLAN) ? MAX_PLAN - 1 : pp->num_plan; i > 0; i--)
694         pp->planLines[i] = pp->planLines[i - 1];
695     }
696     if (pp->num_plan < MAX_PLAN)
697       pp->num_plan++;
698 /* kludged the next line: "" was NULL, but crashed on pprintf. fb 2.24.96 */
699     pp->planLines[0] = ((val == NULL) ? "": strdup(val));
700     pprintf(p, "\nPlan variable %d changed to '%s'.\n", which+1, pp->planLines[which]);
701     pprintf(p, "All other variables moved down.\n");
702     return VAR_OK;
703   }
704   if (which > pp->num_plan) {   /* new line at bottom */
705     if (pp->num_plan >= MAX_PLAN) {     /* shove the old lines up */
706       if (pp->planLines[0] != NULL)
707         free(pp->planLines[0]);
708       for (i = 0; i < pp->num_plan; i++)
709         pp->planLines[i] = pp->planLines[i + 1];
710     } else {
711       pp->num_plan++;
712     }
713 /* kludged the next line: "" was NULL, but crashed on pprintf. fb2.24.96 */
714     pp->planLines[which - 1] = ((val == NULL) ? "": strdup(val));
715     pprintf(p, "\nPlan variable %d changed to '%s'.\n", which, pp->planLines[which-1]);
716     return VAR_OK;
717   }
718   which--;
719   if (pp->planLines[which] != NULL) {
720     free(pp->planLines[which]);
721   }
722   if (val != NULL) {
723     pp->planLines[which] = strdup(val);
724     pprintf(p, "\nPlan variable %d changed to '%s'.\n", which+1, pp->planLines[which]);
725   } else {
726     pp->planLines[which] = NULL;
727     if (which == pp->num_plan - 1) {    /* clear nulls from bottom */
728       while ((pp->num_plan > 0) && (pp->planLines[pp->num_plan - 1] == NULL)) {
729         pp->num_plan--;
730     pprintf(p, "\nPlan variable %d cleared.\n", which+1);
731       }
732     } else if (which == 0) {    /* clear nulls from top */
733       while ((which < pp->num_plan) && (pp->planLines[which] == NULL)) {
734         which++;
735       }
736       if (which != pp->num_plan) {
737         for (i = which; i < pp->num_plan; i++)
738           pp->planLines[i - which] = pp->planLines[i];
739       }
740       pp->num_plan -= which;
741     }
742   }
743   return VAR_OK;
744 }
745
746 static int set_formula(int p, char *var, char *val)
747 {
748   int which;
749   struct player *me = &player_globals.parray[p];
750
751 #ifdef NO_FORMULAS
752   pprintf(p, "Sorry -- not available because of a bug\n");
753   return COM_OK;
754 #else
755   if (isdigit(var[1]))
756     which = var[1] - '1';
757   else
758     which = MAX_FORMULA;
759
760   if (val != NULL) {
761     val = eatwhite(val);
762     if (val[0] == '\0')
763       val = NULL;
764   }
765   if (!SetValidFormula(p, which, val))
766     return VAR_BADVAL;
767
768   if (which < MAX_FORMULA) {
769     if (val != NULL) {
770       while (me->num_formula < which) {
771         me->formulaLines[me->num_formula] = NULL;
772         (me->num_formula)++;
773       }
774       if (me->num_formula <= which)
775         me->num_formula = which + 1;
776       pprintf(p, "Formula variable f%d set to %s.\n",
777               which + 1, me->formulaLines[which]);
778       return VAR_OK;
779     }
780     pprintf(p, "Formula variable f%d unset.\n", which + 1);
781     if (which + 1 >= me->num_formula) {
782       while (which >= 0 && me->formulaLines[which] == NULL)
783         which--;
784       me->num_formula = which + 1;
785     }
786   } else {
787     if (me->formula != NULL)
788       pprintf(p, "Formula set to %s.\n", me->formula);
789     else
790       pprintf(p, "Formula unset.\n");
791   }
792   return VAR_OK;
793 #endif
794 }
795
796 var_list variables[] = {
797   {"ads", set_ads},
798   {"seek", set_ads},
799   {"availinfo", set_availinfo},
800   {"availmax", set_availmax},
801   {"availmin", set_availmin},
802   {"open", set_open},
803   {"tourney", set_tourney},
804   {"simopen", set_sopen},
805   {"rated", set_rated},
806   {"ropen", set_ropen},
807   {"cshout", set_cshout},
808   {"shout", set_shout},
809   {"kibitz", set_kibitz},
810   {"kiblevel", set_kiblevel},
811   {"tell", set_tell},
812   {"notifiedby", set_notifiedby},
813   {"pinform", set_pinform},
814   {"i_login", set_pinform},
815   {"ginform", set_ginform},
816   {"i_game", set_ginform},
817   {"automail", set_automail},
818   {"mailmess", set_mailmess},
819   {"bell", set_bell},
820   {"pgn", set_pgn},
821   {"private", set_private},
822   {"jprivate", set_jprivate},
823   {"highlight", set_highlight},
824   {"style", set_style},
825   {"flip", set_flip},
826   {"prompt", set_prompt},
827   {"promote", set_promote},
828   {"time", set_time},
829   {"inc", set_inc},
830   {"height", set_height},
831   {"width", set_width},
832   {"language", set_language},
833   {"busy", set_busy},
834   {"0", set_plan},
835   {"1", set_plan},
836   {"2", set_plan},
837   {"3", set_plan},
838   {"4", set_plan},
839   {"5", set_plan},
840   {"6", set_plan},
841   {"7", set_plan},
842   {"8", set_plan},
843   {"9", set_plan},
844   {"10", set_plan},
845   {"f1", set_formula},
846   {"f2", set_formula},
847   {"f3", set_formula},
848   {"f4", set_formula},
849   {"f5", set_formula},
850   {"f6", set_formula},
851   {"f7", set_formula},
852   {"f8", set_formula},
853   {"f9", set_formula},
854   {"formula", set_formula},
855   {"interface", set_interface},
856   {NULL, NULL}
857 };
858
859 static int set_find(char *var)
860 {
861   int i = 0;
862   int gotIt = -1;
863   int len = strlen(var);
864
865   while (variables[i].name) {
866     if (!strncmp(variables[i].name, var, len)) {
867       if (len == strlen(variables[i].name)) {
868         return i;
869       } else if (gotIt >= 0) {
870         return -VAR_AMBIGUOUS;
871       }
872       gotIt = i;
873     }
874     i++;
875   }
876   if (gotIt >= 0) {
877     return gotIt;
878   }
879   return -VAR_NOSUCH;
880 }
881
882 int var_set(int p, char *var, char *val, int *wh)
883 {
884   int which;
885
886   if (!var)
887     return VAR_NOSUCH;
888   if ((which = set_find(var)) < 0) {
889     return -which;
890   }
891   *wh = which;
892   return variables[which].var_func(p, (isdigit(*variables[which].name) ? var : variables[which].name), val);
893 }
894
895 int com_variables(int p, param_list param)
896 {
897   int p1, connected;
898   int i;
899
900   if (param[0].type == TYPE_WORD) {
901     if (!FindPlayer(p, param[0].val.word, &p1, &connected))
902       return COM_OK;
903   } else {
904       p1 = p;
905       connected = 1;
906   }
907
908   pprintf(p, "Variable settings of %s:\n\n", player_globals.parray[p1].name);
909
910   pprintf(p, "time=%-3d    private=%d     shout=%d         pin=%d           style=%-3d\n",
911           player_globals.parray[p1].d_time, BoolCheckPFlag(p1, PFLAG_PRIVATE),
912           BoolCheckPFlag(p1, PFLAG_SHOUT), BoolCheckPFlag(p1, PFLAG_PIN),
913           player_globals.parray[p1].style + 1);
914   pprintf(p, "inc=%-3d     jprivate=%d    cshout=%d        notifiedby=%d    flip=%d\n",
915           player_globals.parray[p1].d_inc, BoolCheckPFlag(p1, PFLAG_JPRIVATE),
916           BoolCheckPFlag(p1, PFLAG_CSHOUT), BoolCheckPFlag(p1, PFLAG_NOTIFYBY),
917           BoolCheckPFlag(p1, PFLAG_FLIP));
918   pprintf(p, "                          kibitz=%d        availinfo=%d     highlight=%d\n", 
919           BoolCheckPFlag(p1, PFLAG_KIBITZ), BoolCheckPFlag(p1, PFLAG_AVAIL),
920           player_globals.parray[p1].highlight);
921   pprintf(p, "rated=%d     automail=%d    kiblevel=%-4d   availmin=%-4d   bell=%d\n",
922           BoolCheckPFlag(p1, PFLAG_RATED), BoolCheckPFlag(p1, PFLAG_AUTOMAIL),
923           player_globals.parray[p1].kiblevel, player_globals.parray[p1].availmin, 
924           BoolCheckPFlag(p1, PFLAG_BELL));
925   pprintf(p, "ropen=%d     pgn=%d         tell=%d          availmax=%-4d   width=%-3d\n",
926           BoolCheckPFlag(p1, PFLAG_ROPEN), BoolCheckPFlag(p1, PFLAG_PGN),
927           BoolCheckPFlag(p1, PFLAG_TELL), player_globals.parray[p1].availmax,
928           player_globals.parray[p1].d_width);
929   pprintf(p, "open=%d                    mailmess=%d      gin=%d           height=%-3d\n", 
930           BoolCheckPFlag(p1, PFLAG_OPEN), BoolCheckPFlag(p1, PFLAG_MAILMESS), 
931           BoolCheckPFlag(p1, PFLAG_GIN), player_globals.parray[p1].d_height);
932   pprintf(p, "simopen=%d   tourney=%d     Lang=%s", 
933           BoolCheckPFlag(p1, PFLAG_SIMOPEN), BoolCheckPFlag(p1, PFLAG_TOURNEY),
934           Language(player_globals.parray[p1].language));
935
936   if (player_globals.parray[p1].prompt)
937     pprintf(p, "                    Prompt: %s\n", player_globals.parray[p1].prompt);
938   else
939     pprintf(p, "\n");
940
941   if (player_globals.parray[p1].partner >= 0)
942     pprintf(p, "\nBughouse partner: %s\n", player_globals.parray[player_globals.parray[p1].partner].name);
943
944   if (player_globals.parray[p1].num_formula) {
945     pprintf(p, "\n");
946     for (i = 0; i < player_globals.parray[p1].num_formula; i++) {
947       if (player_globals.parray[p1].formulaLines[i] != NULL)
948         pprintf(p, " f%d: %s\n", i + 1, player_globals.parray[p1].formulaLines[i]);
949       else
950         pprintf(p, " f%d:\n", i + 1);
951     }
952   }
953   if (player_globals.parray[p1].formula != NULL)
954     pprintf(p, "\nFormula: %s\n", player_globals.parray[p1].formula);
955   else
956     pprintf(p, "\n");
957
958   if (!connected)
959     player_remove(p1);
960   return COM_OK;
961 }
962
963 /* tournset (cause settourney is BAD for set)
964  *   used by Tournament Director programs to set/unset the
965  *   tourney variable of another registered player.
966  * fics usage: tournset playername int   (int can be 0 or 1)
967  */
968 int com_tournset(int p, param_list param)
969 {
970   struct player *pp = &player_globals.parray[p];
971   int p1, v;
972
973   if (!in_list(p, L_TD, pp->name)) {
974     pprintf(p, "Only TD programs are allowed to use this command.\n");
975     return COM_OK;
976   }
977   if (((p1 = player_find_bylogin(param[0].val.word)) < 0)
978       || (!CheckPFlag(p1, PFLAG_REG))) {
979      return COM_OK;
980   }
981   v = BoolCheckPFlag(p1, PFLAG_TOURNEY);
982   if (param[1].val.integer == 0) {  /* set it to 0 */
983     if (v == 1) {
984       SetPFlag(p1, PFLAG_TOURNEY, 0);
985       pprintf_prompt(p1, "\n%s has set your tourney variable to OFF.\n",
986             pp->name);
987     }
988   } else {  /* set it to 1 */
989     if (v == 0) {
990       SetPFlag(p1, PFLAG_TOURNEY, 1);
991       pprintf_prompt(p1, "\n%s has set your tourney variable to ON.\n",
992             pp->name);
993     }
994   }
995   return COM_OK;
996 }
997
998