feOpt.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT: Implementation of option buisness
6 */
7 
8 
9 
10 
11 #include <kernel/mod2.h>
12 
13 #include <string.h>
14 #include <stdlib.h>
15 
16 #include <factory/factory.h>
17 
18 #define FE_OPT_STRUCTURE
19 #include "feOpt.h"
20 
21 #if !defined(GENERATE_OPTION_INDEX) && !defined(ESINGULAR) && !defined(TSINGULAR)
22 #include <misc/options.h>
23 #include <misc/sirandom.h>
24 #endif
25 
26 #include "fehelp.h"
27 
28 
29 const char SHORT_OPTS_STRING[] = "bdhpqstvxec:r:u:";
30 
31 //////////////////////////////////////////////////////////////
32 //
33 // Generation of feOptIndex
34 //
35 #ifdef GENERATE_OPTION_INDEX
36 
37 #include <stdio.h>
38 #include <unistd.h>
39 #include <stdlib.h>
40 int main()
41 {
42  FILE* fd;
43 #ifdef ESINGULAR
44  fd = fopen("feOptES.xx", "w");
45 #elif defined(TSINGULAR)
46  fd = fopen("feOptTS.xx", "w");
47 #else
48  fd = fopen("feOpt.xx", "w");
49 #endif
50 
51  if (fd == NULL) exit(1);
52 
53  int i = 0;
54 
55  fputs("typedef enum\n{\n", fd);
56 
57  while (feOptSpec[i].name != NULL)
58  {
59  const char* name = feOptSpec[i].name;
60  fputs("FE_OPT_", fd);
61  while (*name != 0)
62  {
63  if (*name == '-')
64  {
65  putc('_', fd);
66  }
67  else if (*name >= 97 && *name <= 122)
68  {
69  putc(*name - 32, fd);
70  }
71  else
72  {
73  putc(*name, fd);
74  }
75  name++;
76  }
77  if (i == 0)
78  {
79  fputs("=0", fd);
80  }
81  i++;
82  fputs(",\n ", fd);
83  }
84 
85  fprintf(fd, "FE_OPT_UNDEF\n} feOptIndex;\n");
86  fclose(fd);
87 #ifdef ESINGULAR
88  rename("feOptES.xx", "feOptES.inc");
89 #elif defined(TSINGULAR)
90  rename("feOptTS.xx", "feOptTS.inc");
91 #else
92  rename("feOpt.xx", "feOpt.inc");
93 #endif
94  return(0);
95 }
96 
97 #else // ! GENERATE_OPTION_INDEX
98 
99 ///////////////////////////////////////////////////////////////
100 //
101 // Getting Values
102 //
103 
105 {
106  int opt = 0;
107 
108  while (opt != (int) FE_OPT_UNDEF)
109  {
110  if (strcmp(feOptSpec[opt].name, name) == 0)
111  return (feOptIndex) opt;
112  opt = opt + 1;
113  }
114  return FE_OPT_UNDEF;
115 }
116 
118 {
119  int opt = 0;
120 
121  if (optc == LONG_OPTION_RETURN) return FE_OPT_UNDEF;
122 
123  while (opt != (int) FE_OPT_UNDEF)
124  {
125  if (feOptSpec[opt].val == optc)
126  return (feOptIndex) opt;
127  opt = opt + 1;
128  }
129  return FE_OPT_UNDEF;
130 }
131 
132 ///////////////////////////////////////////////////////////////
133 //
134 // Setting Values
135 //
136 //
137 // Return: NULL -- everything ok
138 // "error-string" on error
139 #if !defined(ESINGULAR) && !defined(TSINGULAR)
140 #include <omalloc/omalloc.h>
141 #include <resources/feResource.h>
142 #include <kernel/oswrapper/feread.h>
143 #include <kernel/oswrapper/timer.h>
144 
145 #include "ipshell.h"
146 #include "tok.h"
147 #include "sdb.h"
148 #include "cntrlc.h"
149 
150 #include <errno.h>
151 
152 static const char* feOptAction(feOptIndex opt);
153 const char* feSetOptValue(feOptIndex opt, char* optarg)
154 {
155  if (opt == FE_OPT_UNDEF) return "option undefined";
156 
157  if (feOptSpec[opt].type != feOptUntyped)
158  {
159  if (feOptSpec[opt].type != feOptString)
160  {
161  if (optarg != NULL)
162  {
163  errno = 0;
164  feOptSpec[opt].value = (void*) strtol(optarg, NULL, 10);
165  if (errno) return "invalid integer argument";
166  }
167  else
168  {
169  feOptSpec[opt].value = (void*) 0;
170  }
171  }
172  else
173  {
174  assume(feOptSpec[opt].type == feOptString);
175  if (feOptSpec[opt].set && feOptSpec[opt].value != NULL)
176  omFree(feOptSpec[opt].value);
177  if (optarg != NULL)
178  feOptSpec[opt].value = omStrDup(optarg);
179  else
180  feOptSpec[opt].value = NULL;
181  feOptSpec[opt].set = 1;
182  }
183  }
184  return feOptAction(opt);
185 }
186 
187 const char* feSetOptValue(feOptIndex opt, int optarg)
188 {
189  if (opt == FE_OPT_UNDEF) return "option undefined";
190 
191  if (feOptSpec[opt].type != feOptUntyped)
192  {
193  if (feOptSpec[opt].type == feOptString)
194  return "option value needs to be an integer";
195 
196  feOptSpec[opt].value = (void*)(long) optarg;
197  }
198  return feOptAction(opt);
199 }
200 
201 static const char* feOptAction(feOptIndex opt)
202 {
203  // do some special actions
204  switch(opt)
205  {
206  case FE_OPT_BATCH:
207  if (feOptSpec[FE_OPT_BATCH].value)
209  return NULL;
210 
211  case FE_OPT_HELP:
213  return NULL;
214 
215  case FE_OPT_PROFILE:
216  traceit=1024;
217  return NULL;
218 
219  case FE_OPT_QUIET:
220  if (feOptSpec[FE_OPT_QUIET].value)
221  si_opt_2 &= ~(Sy_bit(0)|Sy_bit(V_LOAD_LIB));
222  else
224  return NULL;
225 
226  case FE_OPT_NO_TTY:
227 #if defined(HAVE_FEREAD) || defined(HAVE_READLINE)
228  if (feOptSpec[FE_OPT_NO_TTY].value)
230 #endif
231  return NULL;
232 
233  case FE_OPT_SDB:
234  #ifdef HAVE_SDB
235  if (feOptSpec[FE_OPT_SDB].value)
236  sdb_flags = 1;
237  else
238  sdb_flags = 0;
239  #endif
240  return NULL;
241 
242  case FE_OPT_VERSION:
243  {
244  char *s=versionString();
245  printf("%s",s);
246  omFree(s);
247  return NULL;
248  }
249 
250  case FE_OPT_ECHO:
251  si_echo = (int) ((long)(feOptSpec[FE_OPT_ECHO].value));
252  if (si_echo < 0 || si_echo > 9)
253  return "argument of option is not in valid range 0..9";
254  return NULL;
255 
256  case FE_OPT_RANDOM:
257  siRandomStart = (unsigned int) ((unsigned long)
258  (feOptSpec[FE_OPT_RANDOM].value));
261  return NULL;
262 
263  case FE_OPT_EMACS:
264  if (feOptSpec[FE_OPT_EMACS].value)
265  {
266  // print EmacsDir and InfoFile so that Emacs
267  // mode can pcik it up
268  Warn("EmacsDir: %s", (feResource('e' /*"EmacsDir"*/) != NULL ?
269  feResource('e' /*"EmacsDir"*/) : ""));
270  Warn("InfoFile: %s", (feResource('i' /*"InfoFile"*/) != NULL ?
271  feResource('i' /*"InfoFile"*/) : ""));
272  }
273  return NULL;
274 
275  case FE_OPT_NO_WARN:
276  if (feOptSpec[FE_OPT_NO_WARN].value)
277  feWarn = FALSE;
278  else
279  feWarn = TRUE;
280  return NULL;
281 
282  case FE_OPT_NO_OUT:
283  if (feOptSpec[FE_OPT_NO_OUT].value)
284  feOut = FALSE;
285  else
286  feOut = TRUE;
287  return NULL;
288 
289  case FE_OPT_MIN_TIME:
290  {
291  double mintime = atof((char*) feOptSpec[FE_OPT_MIN_TIME].value);
292  if (mintime <= 0) return "invalid float argument";
293  SetMinDisplayTime(mintime);
294  return NULL;
295  }
296 
297  case FE_OPT_BROWSER:
298  feHelpBrowser((char*) feOptSpec[FE_OPT_BROWSER].value, 1);
299 
300  case FE_OPT_TICKS_PER_SEC:
301  {
302  int ticks = (int) ((long)(feOptSpec[FE_OPT_TICKS_PER_SEC].value));
303  if (ticks <= 0)
304  return "integer argument must be larger than 0";
305  SetTimerResolution(ticks);
306  return NULL;
307  }
308 
309  case FE_OPT_DUMP_VERSIONTUPLE:
310  {
312  return NULL;
313  }
314 
315  default:
316  return NULL;
317  }
318 }
319 
320 // Prints usage message
322 {
323  int i = 0;
324 
325  while (feOptSpec[i].name != 0)
326  {
327  if (feOptSpec[i].help != NULL && feOptSpec[i].type != feOptUntyped
328 #ifndef SING_NDEBUG
329  && *(feOptSpec[i].help) != '/'
330 #endif
331  )
332  {
333  if (feOptSpec[i].type == feOptString)
334  {
335  if (feOptSpec[i].value == NULL)
336  {
337  Print("// --%-15s\n", feOptSpec[i].name);
338  }
339  else
340  {
341  Print("// --%-15s \"%s\"\n", feOptSpec[i].name, (char*) feOptSpec[i].value);
342  }
343  }
344  else
345  {
346  Print("// --%-15s %d\n", feOptSpec[i].name, (int)(long)feOptSpec[i].value);
347  }
348  }
349  i++;
350  }
351 }
352 
353 #endif // ! ESingular
354 
355 // Prints help message
356 void feOptHelp(const char* name)
357 {
358  int i = 0;
359  char tmp[20];
360 #if defined(ESINGULAR)
361  printf("ESingular starts up Singular within emacs;\n");
362 #elif defined(TSINGULAR)
363  printf("TSingular starts up Singular within a terminal window;\n");
364 #endif
365  printf("Singular is a Computer Algebra System (CAS) for Polynomial Computations.\n");
366  printf("Usage: %s [options] [file1 [file2 ...]]\n", name);
367  printf("Options:\n");
368 
369  while (feOptSpec[i].name != 0)
370  {
371  if (feOptSpec[i].help != NULL
372 #ifdef SING_NDEBUG
373  && *(feOptSpec[i].help) != '/'
374 #endif
375  )
376  {
377  if (feOptSpec[i].has_arg > 0)
378  {
379  if (feOptSpec[i].has_arg > 1)
380  sprintf(tmp, "%s[=%s]", feOptSpec[i].name, feOptSpec[i].arg_name);
381  else
382  sprintf(tmp, "%s=%s", feOptSpec[i].name, feOptSpec[i].arg_name);
383 
384  printf(" %c%c --%-20s %s\n",
385  (feOptSpec[i].val != LONG_OPTION_RETURN ? '-' : ' '),
386  (feOptSpec[i].val != LONG_OPTION_RETURN ? feOptSpec[i].val : ' '),
387  tmp,
388  feOptSpec[i].help);
389  }
390  else
391  {
392  printf(" %c%c --%-20s %s\n",
393  (feOptSpec[i].val != LONG_OPTION_RETURN ? '-' : ' '),
394  (feOptSpec[i].val != LONG_OPTION_RETURN ? feOptSpec[i].val : ' '),
395  feOptSpec[i].name,
396  feOptSpec[i].help);
397  }
398  }
399  i++;
400  }
401 
402  printf("\nFor more information, type `help;' from within Singular or visit\n");
403  printf("http://www.singular.uni-kl.de or consult the\n");
404  printf("Singular manual (available as on-line info or html manual).\n");
405 }
406 
408 {
409  printf("%s\n",VERSION);
410 }
411 
412 #endif // GENERATE_OPTION_INDEX
feOptIndex
Definition: feOptGen.h:15
int status int fd
Definition: si_signals.h:59
const char * feHelpBrowser(char *which, int warn)
Definition: fehelp.cc:260
const CanonicalForm int s
Definition: facAbsFact.cc:55
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition: feread.cc:33
void factoryseed(int s)
random seed initializer
Definition: cf_random.cc:176
static double mintime
Definition: timer.cc:22
int sdb_flags
Definition: sdb.cc:32
#define Print
Definition: emacs.cc:83
int main(int argc, char *argv[])
Definition: omTables.c:165
char * versionString()
Definition: misc_ip.cc:783
#define FALSE
Definition: auxiliary.h:140
BOOLEAN feOut
Definition: reporter.cc:50
#define V_LOAD_LIB
Definition: options.h:45
static char * feResource(feResourceConfig config, int warn)
Definition: feResource.cc:252
char * name
Definition: fegetopt.h:83
char * fe_fgets(const char *pr, char *s, int size)
Definition: feread.cc:310
char * fe_fgets_dummy(const char *, char *, int)
Definition: feread.cc:418
int siRandomStart
Definition: cntrlc.cc:103
#define TRUE
Definition: auxiliary.h:144
void * value
Definition: fegetopt.h:93
const char * feSetOptValue(feOptIndex opt, char *optarg)
Definition: feOpt.cc:153
int traceit
Definition: febase.cc:47
#define Sy_bit(x)
Definition: options.h:30
static const char * feOptAction(feOptIndex opt)
Definition: feOpt.cc:201
void feOptDumpVersionTuple(void)
Definition: feOpt.cc:407
int set
Definition: fegetopt.h:94
void SetTimerResolution(int res)
Definition: timer.cc:24
#define omFree(addr)
Definition: omAllocDecl.h:261
#define assume(x)
Definition: mod2.h:405
struct fe_option feOptSpec[]
void fePrintOptValues()
Definition: feOpt.cc:321
int i
Definition: cfEzgcd.cc:123
void SetMinDisplayTime(double mtime)
Definition: timer.cc:29
#define help
Definition: libparse.cc:1228
char * feArgv0
Definition: feResource.cc:19
char name(const Variable &v)
Definition: variable.h:95
#define NULL
Definition: omList.c:10
#define VERSION
Definition: mod2.h:21
#define LONG_OPTION_RETURN
Definition: feOptTab.h:4
int siSeed
Definition: sirandom.c:29
void feOptHelp(const char *name)
Definition: feOpt.cc:356
feOptIndex feGetOptIndex(const char *name)
Definition: feOpt.cc:104
BOOLEAN feWarn
Definition: reporter.cc:49
unsigned si_opt_2
Definition: options.c:6
const char SHORT_OPTS_STRING[]
Definition: feOpt.cc:29
int si_echo
Definition: febase.cc:41
#define Warn
Definition: emacs.cc:80
#define omStrDup(s)
Definition: omAllocDecl.h:263