Macros | Functions | Variables
feOpt.cc File Reference
#include <kernel/mod2.h>
#include <string.h>
#include <stdlib.h>
#include <factory/factory.h>
#include "feOpt.h"
#include <misc/options.h>
#include <misc/sirandom.h>
#include "fehelp.h"
#include <omalloc/omalloc.h>
#include <resources/feResource.h>
#include <kernel/oswrapper/feread.h>
#include <kernel/oswrapper/timer.h>
#include "ipshell.h"
#include "tok.h"
#include "sdb.h"
#include "cntrlc.h"
#include <errno.h>

Go to the source code of this file.

Macros

#define FE_OPT_STRUCTURE
 

Functions

feOptIndex feGetOptIndex (const char *name)
 
feOptIndex feGetOptIndex (int optc)
 
static const char * feOptAction (feOptIndex opt)
 
const char * feSetOptValue (feOptIndex opt, char *optarg)
 
const char * feSetOptValue (feOptIndex opt, int optarg)
 
void fePrintOptValues ()
 
void feOptHelp (const char *name)
 
void feOptDumpVersionTuple (void)
 

Variables

const char SHORT_OPTS_STRING [] = "bdhpqstvxec:r:u:"
 

Macro Definition Documentation

◆ FE_OPT_STRUCTURE

#define FE_OPT_STRUCTURE

Definition at line 18 of file feOpt.cc.

Function Documentation

◆ feGetOptIndex() [1/2]

feOptIndex feGetOptIndex ( const char *  name)

Definition at line 104 of file feOpt.cc.

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 }
feOptIndex
Definition: feOptGen.h:15
struct fe_option feOptSpec[]
char name(const Variable &v)
Definition: factory.h:178

◆ feGetOptIndex() [2/2]

feOptIndex feGetOptIndex ( int  optc)

Definition at line 117 of file feOpt.cc.

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 }
feOptIndex
Definition: feOptGen.h:15
int val
Definition: fegetopt.h:88
struct fe_option feOptSpec[]
#define LONG_OPTION_RETURN
Definition: feOptTab.h:4

◆ feOptAction()

static const char * feOptAction ( feOptIndex  opt)
static

Definition at line 201 of file feOpt.cc.

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 (feOptSpec[FE_OPT_NO_TTY].value)
229  return NULL;
230 
231  case FE_OPT_SDB:
232  #ifdef HAVE_SDB
233  if (feOptSpec[FE_OPT_SDB].value)
234  sdb_flags = 1;
235  else
236  sdb_flags = 0;
237  #endif
238  return NULL;
239 
240  case FE_OPT_VERSION:
241  {
242  char *s=versionString();
243  printf("%s",s);
244  omFree(s);
245  return NULL;
246  }
247 
248  case FE_OPT_ECHO:
249  si_echo = (int) ((long)(feOptSpec[FE_OPT_ECHO].value));
250  if (si_echo < 0 || si_echo > 9)
251  return "argument of option is not in valid range 0..9";
252  return NULL;
253 
254  case FE_OPT_RANDOM:
255  siRandomStart = (unsigned int) ((unsigned long)
256  (feOptSpec[FE_OPT_RANDOM].value));
259  return NULL;
260 
261  case FE_OPT_EMACS:
262  if (feOptSpec[FE_OPT_EMACS].value)
263  {
264  // print EmacsDir and InfoFile so that Emacs
265  // mode can pcik it up
266  Warn("EmacsDir: %s", (feResource('e' /*"EmacsDir"*/) != NULL ?
267  feResource('e' /*"EmacsDir"*/) : ""));
268  Warn("InfoFile: %s", (feResource('i' /*"InfoFile"*/) != NULL ?
269  feResource('i' /*"InfoFile"*/) : ""));
270  }
271  return NULL;
272 
273  case FE_OPT_NO_WARN:
274  if (feOptSpec[FE_OPT_NO_WARN].value)
275  feWarn = FALSE;
276  else
277  feWarn = TRUE;
278  return NULL;
279 
280  case FE_OPT_NO_OUT:
281  if (feOptSpec[FE_OPT_NO_OUT].value)
282  feOut = FALSE;
283  else
284  feOut = TRUE;
285  return NULL;
286 
287  case FE_OPT_MIN_TIME:
288  {
289  double mintime = atof((char*) feOptSpec[FE_OPT_MIN_TIME].value);
290  if (mintime <= 0) return "invalid float argument";
291  SetMinDisplayTime(mintime);
292  return NULL;
293  }
294 
295  case FE_OPT_BROWSER:
296  feHelpBrowser((char*) feOptSpec[FE_OPT_BROWSER].value, 1);
297 
298  case FE_OPT_TICKS_PER_SEC:
299  {
300  int ticks = (int) ((long)(feOptSpec[FE_OPT_TICKS_PER_SEC].value));
301  if (ticks <= 0)
302  return "integer argument must be larger than 0";
303  SetTimerResolution(ticks);
304  return NULL;
305  }
306 
307  case FE_OPT_DUMP_VERSIONTUPLE:
308  {
310  return NULL;
311  }
312 
313  default:
314  return NULL;
315  }
316 }
const char * feHelpBrowser(char *which, int warn)
Definition: fehelp.cc:262
const CanonicalForm int s
Definition: facAbsFact.cc:55
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition: feread.cc:34
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
char * versionString()
Definition: misc_ip.cc:778
#define FALSE
Definition: auxiliary.h:94
BOOLEAN feOut
Definition: reporter.cc:50
#define V_LOAD_LIB
Definition: options.h:45
static char * feResource(feResourceConfig config, int warn)
Definition: feResource.cc:258
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:451
int siRandomStart
Definition: cntrlc.cc:102
#define TRUE
Definition: auxiliary.h:98
void * value
Definition: fegetopt.h:93
int traceit
Definition: febase.cc:47
#define Sy_bit(x)
Definition: options.h:30
void feOptDumpVersionTuple(void)
Definition: feOpt.cc:405
void SetTimerResolution(int res)
Definition: timer.cc:24
#define omFree(addr)
Definition: omAllocDecl.h:261
struct fe_option feOptSpec[]
void SetMinDisplayTime(double mtime)
Definition: timer.cc:29
char * feArgv0
Definition: feResource.cc:19
#define NULL
Definition: omList.c:10
int siSeed
Definition: sirandom.c:29
void feOptHelp(const char *name)
Definition: feOpt.cc:354
BOOLEAN feWarn
Definition: reporter.cc:49
unsigned si_opt_2
Definition: options.c:6
int si_echo
Definition: febase.cc:41
#define Warn
Definition: emacs.cc:80

◆ feOptDumpVersionTuple()

void feOptDumpVersionTuple ( void  )

Definition at line 405 of file feOpt.cc.

406 {
407  printf("%s\n",VERSION);
408 }
#define VERSION
Definition: mod2.h:16

◆ feOptHelp()

void feOptHelp ( const char *  name)

Definition at line 354 of file feOpt.cc.

355 {
356  int i = 0;
357  char tmp[20];
358 #if defined(ESINGULAR)
359  printf("ESingular starts up Singular within emacs;\n");
360 #elif defined(TSINGULAR)
361  printf("TSingular starts up Singular within a terminal window;\n");
362 #endif
363  printf("Singular is a Computer Algebra System (CAS) for Polynomial Computations.\n");
364  printf("Usage: %s [options] [file1 [file2 ...]]\n", name);
365  printf("Options:\n");
366 
367  while (feOptSpec[i].name != 0)
368  {
369  if (feOptSpec[i].help != NULL
370 #ifdef SING_NDEBUG
371  && *(feOptSpec[i].help) != '/'
372 #endif
373  )
374  {
375  if (feOptSpec[i].has_arg > 0)
376  {
377  if (feOptSpec[i].has_arg > 1)
378  sprintf(tmp, "%s[=%s]", feOptSpec[i].name, feOptSpec[i].arg_name);
379  else
380  sprintf(tmp, "%s=%s", feOptSpec[i].name, feOptSpec[i].arg_name);
381 
382  printf(" %c%c --%-20s %s\n",
383  (feOptSpec[i].val != LONG_OPTION_RETURN ? '-' : ' '),
384  (feOptSpec[i].val != LONG_OPTION_RETURN ? feOptSpec[i].val : ' '),
385  tmp,
386  feOptSpec[i].help);
387  }
388  else
389  {
390  printf(" %c%c --%-20s %s\n",
391  (feOptSpec[i].val != LONG_OPTION_RETURN ? '-' : ' '),
392  (feOptSpec[i].val != LONG_OPTION_RETURN ? feOptSpec[i].val : ' '),
393  feOptSpec[i].name,
394  feOptSpec[i].help);
395  }
396  }
397  i++;
398  }
399 
400  printf("\nFor more information, type `help;' from within Singular or visit\n");
401  printf("http://www.singular.uni-kl.de or consult the\n");
402  printf("Singular manual (available as on-line info or html manual).\n");
403 }
const char * arg_name
Definition: fegetopt.h:90
int has_arg
Definition: fegetopt.h:87
int val
Definition: fegetopt.h:88
#define SING_NDEBUG
Definition: factoryconf.h:262
struct fe_option feOptSpec[]
int i
Definition: cfEzgcd.cc:123
char name(const Variable &v)
Definition: factory.h:178
#define help
Definition: libparse.cc:1228
#define NULL
Definition: omList.c:10
#define LONG_OPTION_RETURN
Definition: feOptTab.h:4

◆ fePrintOptValues()

void fePrintOptValues ( )

Definition at line 319 of file feOpt.cc.

320 {
321  int i = 0;
322 
323  while (feOptSpec[i].name != 0)
324  {
325  if (feOptSpec[i].help != NULL && feOptSpec[i].type != feOptUntyped
326 #ifndef SING_NDEBUG
327  && *(feOptSpec[i].help) != '/'
328 #endif
329  )
330  {
331  if (feOptSpec[i].type == feOptString)
332  {
333  if (feOptSpec[i].value == NULL)
334  {
335  Print("// --%-15s\n", feOptSpec[i].name);
336  }
337  else
338  {
339  Print("// --%-15s \"%s\"\n", feOptSpec[i].name, (char*) feOptSpec[i].value);
340  }
341  }
342  else
343  {
344  Print("// --%-15s %d\n", feOptSpec[i].name, (int)(long)feOptSpec[i].value);
345  }
346  }
347  i++;
348  }
349 }
feOptType type
Definition: fegetopt.h:92
#define Print
Definition: emacs.cc:83
void * value
Definition: fegetopt.h:93
#define SING_NDEBUG
Definition: factoryconf.h:262
struct fe_option feOptSpec[]
int i
Definition: cfEzgcd.cc:123
char name(const Variable &v)
Definition: factory.h:178
#define help
Definition: libparse.cc:1228
#define NULL
Definition: omList.c:10

◆ feSetOptValue() [1/2]

const char* feSetOptValue ( feOptIndex  opt,
char *  optarg 
)

Definition at line 153 of file feOpt.cc.

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 }
feOptType type
Definition: fegetopt.h:92
void * value
Definition: fegetopt.h:93
static const char * feOptAction(feOptIndex opt)
Definition: feOpt.cc:201
int set
Definition: fegetopt.h:94
#define omFree(addr)
Definition: omAllocDecl.h:261
#define assume(x)
Definition: mod2.h:394
struct fe_option feOptSpec[]
#define NULL
Definition: omList.c:10
#define omStrDup(s)
Definition: omAllocDecl.h:263

◆ feSetOptValue() [2/2]

const char* feSetOptValue ( feOptIndex  opt,
int  optarg 
)

Definition at line 187 of file feOpt.cc.

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 }
feOptType type
Definition: fegetopt.h:92
void * value
Definition: fegetopt.h:93
static const char * feOptAction(feOptIndex opt)
Definition: feOpt.cc:201
struct fe_option feOptSpec[]

Variable Documentation

◆ SHORT_OPTS_STRING

const char SHORT_OPTS_STRING[] = "bdhpqstvxec:r:u:"

Definition at line 29 of file feOpt.cc.