Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/GAP/pkg/ace/src/   (Algebra von RWTH Aachen Version 4.15.1©)  Datei vom 10.3.2025 mit Größe 14 kB image not shown  

Quelle  util2.c   Sprache: C

 

/**************************************************************************

        util2.c
        Colin Ramsay (cram@itee.uq.edu.au)
        6 Dec 00

        ADVANCED COSET ENUMERATOR, Version 3.001

        Copyright 2000
        Centre for Discrete Mathematics and Computing,
        Department of Mathematics and 
          Department of Computer Science & Electrical Engineering,
        The University of Queensland, QLD 4072.
(http://staff.itee.uq.edu.au/havas)

These are the utilities for Level 2 of ACE.

**************************************************************************/


#include "al2.h"

#include <string.h>
#include <ctype.h>
#include <sys/types.h>
#include <time.h>

        /******************************************************************
        void al2_init(void)

        One-off initialisation of the Level 2 stuff, and all lower levels.
Note that there is no need to initialise, for example, intarr[].
        ******************************************************************/


void al2_init(void)
  {
  al1_init();

  okstart = okcont   = okredo = FALSE;
  tabinfo = tabindex = FALSE;
  lresult = -8192;   /* invalid mode ! */

  echo   = FALSE;
  skipnl = TRUE;

  currip = currkey[0] = currname[0] = '\0';

  currword = NULL;
  currsiz  = currexp = 0;

  intcnt = 0;

  srand((unsigned int)time(NULL)); /* Seed rand() with time */
  }

 /******************************************************************
        char *al2_strdup(char *s)

        strdup() is not ANSI C, so this is our version.  Should we regard
an error as fatal, and abort?
******************************************************************/


char *al2_strdup(char *s)
  {
  char *t;

  if ((t = malloc(strlen(s)+1)) == NULL)
    { al2_continue("out of memory in al2_strdup()"); }

  return(strcpy(t,s));
  }

 /******************************************************************
        int al2_outlen(int i)

Returns the print-length of an integer i (i.e., ~ $\log_{10}i$).
The int i is assumed to satisfy i >= 0.
******************************************************************/


int al2_outlen(int i)
  {
  int len = 1;

  while ((i /= 10) != 0)
    { len++; }

  return(len);
  }

/**************************************************************************
All Level 2 errors are filtered by one of the following three handlers. 
These take the appropriate action, and then jump back to the top-level
main() routine; ie, the outermost level of Level 2.  We swallow the 
remainder of any input line (possibly losing some commands); so multi-line 
commands in error may not be properly tidied-up. The question of what
exactly to do if fip/fop are not stdin/stdout is put in the `too hard' 
basket; we simply switch them both back to their defaults.  Note that, 
although the code for _continue() & _restart() is the same, they return to 
different points (& do different things) in main().

Warning: The error-handling is fairly basic, since it's not our intent to
develop a fully-fledged interactive interface.  We simply tidy-up the best
we can and carry on.
**************************************************************************/


 /******************************************************************
void al2_continue(char *msg)

An error has occurred, but it doesn't affected the ok... flags, or
the table's validity.
        ******************************************************************/


void al2_continue(char *msg)
  {
  if (fop != stdout)
    {
    if (fop != NULL)
      { fclose(fop); }
    fop = stdout;
    }
  if (fip != stdin)
    {
    if (fip != NULL)
      { fclose(fip); }
    fip = stdin;
    currip = '\0';
    }

  fflush(fop);
  fprintf(fop, "** ERROR (continuing with next line)\n");
  fprintf(fop, " %s\n", msg);

  while ( !(currip == '\n' || currip == '\r' || currip == EOF) )
    { al2_nextip(); }

  longjmp(env,1);
  }

 /******************************************************************
void al2_restart(char *msg)

Something nasty has happened & we'll be disallowing continue/redo.
        ******************************************************************/


void al2_restart(char *msg)
  {
  if (fop != stdout)
    {
    if (fop != NULL)
      { fclose(fop); }
    fop = stdout;
    }
  if (fip != stdin)
    {
    if (fip != NULL)
      { fclose(fip); }
    fip = stdin;
    currip = '\0';
    }

  fflush(fop);
  fprintf(fop, "** ERROR (restarting with next line)\n");
  fprintf(fop, " %s\n", msg);

  while ( !(currip == '\n' || currip == '\r' || currip == EOF) )
    { al2_nextip(); }

  longjmp(env,2);
  }

 /******************************************************************
void al2_abort(char *msg)

No point in being clever here, we're going to stop.
        ******************************************************************/


void al2_abort(char *msg)
  {
  if (fop != stdout)
    {
    if (fop != NULL)
      { fclose(fop); }
    fop = stdout;
    }
  if (fip != stdin)
    {
    if (fip != NULL)
      { fclose(fip); }
    fip = stdin;
    currip = '\0';
    }

  fflush(fop);
  fprintf(fop, "** ERROR (aborting)\n");
  fprintf(fop, " %s\n", msg);

  longjmp(env,3);
  }

        /******************************************************************
void al2_aip(char *name)

Switch to a new input file.  We abort via _restart() if this is not
possible, and that call will reset fip/fop properly.
        ******************************************************************/


void al2_aip(char *name)
  {
  /* Close the current input file (unless it is 'stdin'). */

  if (fip != stdin && fip != NULL)  
    { fclose(fip); }
  fip = NULL;

  /* Try to open the new input file (unless it is 'stdin'). */

  if (strcmp(name, "stdin") != 0)  
    { 
    if ((fip = fopen(name, "r")) == NULL)
      { al2_restart("can't open new input, using 'stdin'"); }
    }
  else
    { fip = stdin; }

  currip = '\0';    /* Initialise current i/p char. */
  }

        /******************************************************************
void al2_aop(char *name)

Switch to a new output file.  We abort via _restart() if this is 
not possible, and that call will reset fip/fop properly.  Note
that there is no need to run setvbuf() on stdout, since this was 
done in the call to al0_init().
        ******************************************************************/


void al2_aop(char *name)
  {
  /* Close the current output file (unless it is 'stdout'). */

  if (fop != stdout && fop != NULL)  
    { fclose(fop); }
  fop = NULL;

  /* Try to open the new output file (unless it is 'stdout'). */

  if (strcmp(name, "stdout") != 0)  
    { 
    if ((fop = fopen(name, "w")) == NULL)
      {
      fop = stdout;
      fprintf(fop, "can't open new output, using 'stdout'");
      }
    else
      { setvbuf(fop, NULL, _IOLBF, 0); } /* line buffered o/p */
    }
  else
    { fop = stdout; }
  }

        /******************************************************************
        void al2_dump(Logic allofit)

        Dump out the internals of Level 2 of ACE, working through al2.h
        more or less in order.
        ******************************************************************/


void al2_dump(Logic allofit)
  {
  int i;

  fprintf(fop, " #---- %s: Level 2 Dump ----\n", ACE_VER);

 /* env; - nothing (meaningful) we can do here! */

 /* okstart, okcont, okredo; */
  fprintf(fop, "okstart=%d okcont=%d okredo=%d\n"
                okstart,   okcont,   okredo);

 /* tabinfo, tabindex, lresult */
  fprintf(fop, "tabinfo=%d tabindex=%d lresult=%d\n"
                tabinfo,   tabindex,   lresult);

 /* echo, skipnl, currip, currkey, currname; */
  fprintf(fop, "echo=%d skipnl=%d currip=%d", echo, skipnl, currip);
  if (isprint(currip))
    { fprintf(fop, "(%c)\n", currip); }
  else
    { fprintf(fop, "\n"); }
  fprintf(fop, "currkey=%s\n", currkey);
  fprintf(fop, "currname=%s\n", currname);

 /* *currword, currsiz, currexp; */
  fprintf(fop, "currsize=%d currexp=%d currword=", currsiz, currexp);
  if (currword == NULL)
    { fprintf(fop, "NULL"); }
  else
    {
    if (allofit)
      {
      for (i = 0; i < currsiz; i++)
        { fprintf(fop, "%d ", currword[i]); }
      }
    else
      { fprintf(fop, "non-NULL"); }
    }
  fprintf(fop, "\n");

 /* intcnt, intarr[32]; */
  if (intcnt == 0)
    { fprintf(fop, "intcnt=0 (empty)\n"); }
  else
    {
    fprintf(fop, "intcnt=%d intarr[]=", intcnt);
    for (i = 0; i < intcnt; i++)
      { fprintf(fop, "%d ", intarr[i]); }
    fprintf(fop, "\n");
    }

  fprintf(fop, " #---------------------------------\n");
  }

        /******************************************************************
void al2_opt(void)

Pretty-print the date of compilation and all the various options
included in this build.
        ******************************************************************/


void al2_opt(void)
  {
  fprintf(fop, "%s executable\n", ACE_VER);

  fprintf(fop, "Level 0 options:\n");
#ifdef AL0_STAT
  fprintf(fop, " statistics package = on\n");
#else
  fprintf(fop, " statistics package = off\n");
#endif
#ifdef AL0_CC
  fprintf(fop, " coinc processing messages = on\n");
#else
  fprintf(fop, " coinc processing messages = off\n");
#endif
#ifdef AL0_DD
  fprintf(fop, " dedn processing messages = on\n");
#else
  fprintf(fop, " dedn processing messages = off\n");
#endif

  fprintf(fop, "Level 1 options:\n");
#ifdef AL1_BINARY
  fprintf(fop, " workspace multipliers = binary\n");
#else
  fprintf(fop, " workspace multipliers = decimal\n");
#endif

  fprintf(fop, "Level 2 options:\n");
#ifdef AL2_HINFO
  fprintf(fop, " host info = on\n");
#else
  fprintf(fop, " host info = off\n");
#endif
  }

        /******************************************************************
void al2_help(void)
        ******************************************************************/


void al2_help(void)
  {
  fprintf(fop, " #---- %s: Level 2 Help ----\n", ACE_VER);
  fprintf(fop, "add gen[erators] / sg : ;\n");
  fprintf(fop, "add rel[ators] / rl : ;\n");
  fprintf(fop, "aep : 1..7 ;\n");
  fprintf(fop, "ai / alter i[nput] : [] ;\n");
  fprintf(fop, "ao / alter o[utput] : [] ;\n");
  fprintf(fop, "as[is] : [0/1] ;\n");
  fprintf(fop, "beg[in] / end / start ;\n");
  fprintf(fop, "bye / exit / q[uit] ;\n");
  fprintf(fop, "cc / coset coinc[idence] : int ;\n");
  fprintf(fop, "c[factor] / ct[ factor] : [int] ;\n");
  fprintf(fop, "check / redo ;\n");
  fprintf(fop, "com[paction] : [0..100] ;\n");
  fprintf(fop, "cont[inue] ;\n");
  fprintf(fop, "cy[cles] ;\n");
  fprintf(fop, "ded mo[de] / dmod[e] : [0..4] ;\n");
  fprintf(fop, "ded si[ze] / dsiz[e] : [0/1..] ;\n");
  fprintf(fop, "def[ault] ;\n");
  fprintf(fop, "del gen[erators] / ds : ;\n");
  fprintf(fop, "del rel[ators] / dr : ;\n");
  fprintf(fop, "d[ump] : [0/1/2[,0/1]] ;\n");
  fprintf(fop, "easy ;\n");
  fprintf(fop, "echo : [0/1] ;\n");
  fprintf(fop, "enum[eration] / group name : ;\n");
  fprintf(fop, "fel[sch] : [0/1] ;\n");
  fprintf(fop, "f[factor] / fi[ll factor] : [0/1..] ;\n");
  fprintf(fop, "gen[erators] / subgroup gen[erators] : ;\n");
  fprintf(fop, "gr[oup generators]: [ / int] ;\n");
  fprintf(fop, "group relators / rel[ators] : ;\n");
  fprintf(fop, "hard ;\n");
  fprintf(fop, "h[elp] ;\n");
  fprintf(fop, "hlt ;\n");
  fprintf(fop, "ho[le limit] : [-1/0..100] ;\n");
  fprintf(fop, "look[ahead] : [0/1..4] ;\n");
  fprintf(fop, "loop[ limit] : [0/1..] ;\n");
  fprintf(fop, "max[ cosets] : [0/2..] ;\n");
  fprintf(fop, "mend[elsohn] : [0/1] ;\n");
  fprintf(fop, "mess[ages] / mon[itor] : [int] ;\n");
  fprintf(fop, "mo[de] ;\n");
  fprintf(fop, "nc / normal[ closure] : [0/1] ;\n");
  fprintf(fop, "no[ relators in subgroup] : [-1/0/1..] ;\n");
  fprintf(fop, "oo / order[ option] : int ;\n");
  fprintf(fop, "opt[ions] ;\n");
  fprintf(fop, "par[ameters] ; - old option (ignored)\n");
  fprintf(fop, "path[ compression] : [0/1] ;\n");
  fprintf(fop, "pd mo[de] / pmod[e] : [0/1..3] ;\n");
  fprintf(fop, "pd si[ze] / psiz[e] : [0/2/4/8/...] ;\n");
  fprintf(fop, "print det[ails] / sr : [int] ;\n");
  fprintf(fop, "pr[int table] : [[-]int[,int[,int]]] ;\n");
  fprintf(fop, "pure c[t] ;\n");
  fprintf(fop, "pure r[t] ;\n");
  fprintf(fop, "rc / random coinc[idences]: int[,int] ;\n");
  fprintf(fop, "rec[over] / contig[uous] ;\n");
  fprintf(fop, "rep : 1..7[,int] ;\n");
  fprintf(fop, "restart ; - old option (ignored)\n");
  fprintf(fop, "r[factor] / rt[ factor] : [int] ;\n");
  fprintf(fop, "row[ filling] : [0/1] ;\n");
  fprintf(fop, "sc / stabil[ising cosets] : int ;\n");
  fprintf(fop, "sims : 1/3/5/7/9 ;\n");
  fprintf(fop, "st[andard table] ;\n");
#ifdef AL0_STAT
  fprintf(fop, "stat[istics] / stats ;\n");
#endif
  fprintf(fop, "style ;\n");
  fprintf(fop, "subg[roup name] : ;\n");
  fprintf(fop, "sys[tem] : ;\n");
  fprintf(fop, "text : ;\n");
  fprintf(fop, "ti[me limit] : [-1/0/1..] ;\n");
  fprintf(fop, "tw / trace[ word] : int, ;\n");
  fprintf(fop, "wo[rkspace] : [int[k/m/g]] ;\n");
  fprintf(fop, "# ... - a comment (ignored)\n");
  fprintf(fop, " #---------------------------------\n");
  }

        /******************************************************************
void al2_nextip(void)

Primes currip with the next character from fip, if we're not at the
end-of-file.  Echoes the character if echo is on.
        ******************************************************************/


void al2_nextip(void)
  {
  if (currip != EOF) 
    { 
    currip = fgetc(fip); 

    if (echo && currip != EOF) 
      { fputc(currip, fop); }
    }
  }

        /******************************************************************
void al2_skipws(void)

Skip all whitespace characters.
        ******************************************************************/


void al2_skipws(void)
  {
  Logic comment = (currip == '#');

  while ( currip == ' ' || currip == '\t' || comment || 
          (skipnl && (currip == '\n' || currip == '\r')) ) 
    {
    al2_nextip();
    comment = (currip == '#' || 
           (comment && currip != '\n' && currip != '\r' && currip != EOF));
    }
  }

        /******************************************************************
void al2_nextnw(void)

Skip to the next non-whitespace character.
        ******************************************************************/


void al2_nextnw(void)
  {
  al2_nextip();
  al2_skipws();
  }


93%


¤ Dauer der Verarbeitung: 0.34 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland






Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.