/*                                                +++++++++++        */
# define FILENAME                                 "myawk.2.c"
/*                                                +++++++++++        */

# include "util.h"

/*     ===================                                  */
FILE * NarrowFileBetwStrgs(FILE * in, char * s1, char * s2)
/*     ===================                                  */
{
  TokenizeData D={0}, *d=&D;
  FILE * out = tmpfile();
  if (out ==  NULL) 
    STDERR("NarrowFileBetwStrgs can not open a tmpfile");
  d->fp = in;
  InitLexer(d);
  while (TokenizeLine(d)) 
    if (OnBetwStrgs(d,s1,s2)) 
      fprintf(out,"%s\n",d->T[0]);
  return out;
}


/*   =====                                                */
bool StrEq (char * a, char * b)
/*   =====                                                */
{
  if (a == b)
    return true ;
  else if (a == NULL || b == NULL)
    return false ;
  else if (strcmp(a,b))
    return false ;
  else 
    return true ;
}

/*     ==========                                                */
char * SaveString (char * s)
/*     ==========                                                */
{
  if (s == NULL) 
    return NULL ;
  else {
    char * s2 = (char *) malloc(strlen(s)+1);
    return strcpy(s2,s);
  }
}

/*             ==========                                                */
TokenizeData * InitTokens (TokenizeData * d, char * filename) 
/*             ==========                                                */
{
  int i;
  d->initialized = 1;
  if (d->debug) {
    STDERR("Begin InitTokens()") ;
  } else {
    d->debug = 0;
  }
  if (filename == "-" || filename == NULL) {
    d->fp = stdin ;
    if (d->debug)
      fprintf(stderr,"InitTokens: opened stdin\n");
  } else if (filename != NULL) {
    d->filename = filename ;
    d->fp = fopen(filename,"r") ;
    if (d->fp == NULL) {
      STDERR("InitTokens can not open file");
      ATOE(d->filename);
    } else if (d->debug)
      fprintf(stderr,"InitTokens: opened file %s\n",d->filename);
  }
  for (i=0; i<TOKMAXFLAG; i++) d->flag[i] = 0;
  d->whitespace = " \t\n" ;
  d->NR = 0;
  d->NF = 0;
  for (i=0; i<MAXTOK; i++) {
    d->D[i] = 0; 
    d->T[i] = NULL ;
  }
  for (i=0; i<BUFSIZ; i++) {
    d->KeepBuf[i] = 0; 
    d->TokBuf[i] = 0 ;
  }
  return d;
}

/*   =========                                                */
bool InitLexer (TokenizeData * d)
/*   =========                                                */
{
  int i;
  if (d == NULL) 
    d = (TokenizeData * ) calloc(1,sizeof(TokenizeData)) ;
  d->initialized = 1;
  if (d->debug) {
    fprintf(stderr,"InitLexer: BEGINS\n");
  } else {
    d->debug = 0;
  }
  if (d->fp != NULL) {
    rewind(d->fp);
    if (d->debug)
      fprintf(stderr,"InitLexer: rewound file\n");
  } else if (d->fp == NULL && 
	     (d->filename == NULL || d->filename[0] == '-')) {
    d->fp = stdin ;
    if (d->debug)
      fprintf(stderr,"InitLexer: opened stdin\n");
  } else if (d->fp == NULL && d->filename != NULL) {
    d->fp = fopen(d->filename,"r") ;
    if (d->fp == NULL) {
      fprintf(stderr,"InitLexer: Cannot open file %s\n",d->filename);
      return false ;
    } else if (d->debug)
      fprintf(stderr,"InitLexer: opened file %s\n",d->filename);
  }
  for (i=0; i<TOKMAXFLAG; i++) d->flag[i] = 0;
  d->whitespace = " \t\n" ;
  d->NR = 0;
  d->NF = 0;
  d->RS = 0;
  for (i=0; i<MAXTOK; i++) {
    d->D[i] = 0; 
    d->T[i] = NULL ;
  }
  for (i=0; i<BUFSIZ; i++) {
    d->KeepBuf[i] = 0; 
    d->TokBuf[i] = 0 ;
  }
  if (d->debug) 
    fprintf(stderr,"InitLexer: ENDS\n");
  return true;
}

/*     ======================                                              */
char * ConvertUnixControlChar(char * s) 
/*     ======================                                              */
{
  char buf[BUFSIZ];
  char * p = s, * b = buf;
  if (s == NULL)
    return NULL ;
  while (*p) {
    if (p[0] == '\\' && p[1] == 'n') {
      *b = '\n' ;
      p ++;
    } else if (p[0] == '\\' && p[1] == 't') {
      *b = '\t' ;
      p++;
    } else {
      *b = *p;
    }
    p++;
    b++;
  }
  *b = '\0';
  fprintf(stderr,"%s [%d] (ConvertUnixControlChar): %s --> %s\n",
	  __FILE__,__LINE__,s,buf);
  return SaveString(buf);
}


/*  ===============                                        */
int StreqWithSpaces(const char * s1, const char * s2)
/*  ===============                                        */
{
  char t1[BUFSIZ], t2[BUFSIZ];
  sscanf(s1,"%s",t1);
  sscanf(s2,"%s",t2);
  return STREQ(t1,t2);
}

/*     =============                                       */
char * StringOfIndex (int i, StringIndex ** SI)
/*     =============                                       */
{
  if (*SI == NULL) {
    return NULL ; 
  } else if (i == (*SI)->n) {
    return (*SI)->strg ;
  } else {
    return StringOfIndex(i, &(*SI)->ptr) ;
  }
}

int IndexOfString2(char s[], StringIndex * SI)
{
  if (STREQ(SI->strg,s)) {
    return SI->n ;
  } else if (SI->ptr == NULL) {
    StringIndex * NSI = (SI->ptr = AllocateN(StringIndex,1));
    NSI->ptr = NULL ;
    NSI->strg = StringAllocate(s);
    return (NSI->n   = SI->n + 1) ;
  } else {
    return IndexOfString2(s, SI->ptr) ;
  }
}


/*     ===============                                      */
char * fgets_WithDelim(char *s,int n, FILE * iop, char ws[])
/*     ===============                                      */
{
  register int c;
  register char *cs ;
  
  cs = s ;
  while (--n > 0 && (c = getc(iop)) != EOF) 
    if (strchr(ws,(*cs++ = c)) != NULL) 
      break ;
  *cs = '\0' ;
  return (c == EOF && cs == s) ? NULL : s ;
}

/*  =============                                       */
int IndexOfString(char s[], StringIndex ** SIP)
/*  =============                                       */
{
  StringIndex * SI = *SIP ;
  if (s == NULL) {
    STDERR("s == NULL");
    return 0;
  }
  if (SI == NULL) {
    SI = AllocateN(StringIndex,1);
    SI->n = 0 ;
    SI->strg = StringAllocate(s);
    SI->ptr = NULL ;
    *SIP = SI ;
    return 0;
  } else {
    return IndexOfString2(s, SI);
  }
}

/* First Index of String is 0 */

/*  =================                                        */
int LastIndexOfString(StringIndex * SI)
/*  =================                                        */
{
  StringIndex * SI2 ;
  int i;
  
  for (SI2 = SI; SI2 != NULL ; SI2 = SI2->ptr) 
    i = SI2->n ;
  return i ;
}

/*   ==============                                        */
bool InSymbolTableP (char * s, StringIndex * SI)
/*   ==============                                        */
{
  if (SI == NULL) 
    return 0;
  else if (STREQ(SI->strg,s))
    return 1;
  else 
    return (InSymbolTableP(s,SI->ptr)) ;
}

/*   =====================                                        */
int  SymbolTableIndexNoAdd (char * s, StringIndex * SI)
/*   =====================                                        */
{
  if (SI == NULL) 
    return SYMBOL_NOT_IN_TABLE;
  else if (STREQ(SI->strg,s))
    return SI->n;
  else 
    return (SymbolTableIndexNoAdd(s,SI->ptr)) ;
}

/*   ===================                                        */
void PrintIndexedStrings(StringIndex * SI)
/*   ===================                                        */
{
  StringIndex * SI2 ;
  for (SI2 = SI; SI2 != NULL ; SI2 = SI2->ptr)  {
    fprintf(stderr,"%4d\t%s\n",SI2->n,SI2->strg);
  }
}




/*   ===========                                           */
void PrintTokens(char * T[],FILE *stream)
/*   ===========                                           */
{
  int i = 0;
  if (T == NULL) 
    return ;
  for(i=0; T[i] != NULL; i++) {
    fprintf(stream,"[ %d ]: %s\n",i,T[i]);
  }
  CR ; CR;
}

/*   ============                                           */
void PrintTokens2(TokenizeData * d, FILE * stream)
/*   ============                                           */
{
  int i = 0;
  if (d->T == NULL) 
    return ;
  for(i=0; d->T[i] != NULL; i++) {
    fprintf(stream,"[ %5d ][ %3d ]: %s\n",d->NR,i,d->T[i]);
  }
  fprintf(stream,"\n");
}

/*       =============                                           */
double * ToksToDoubles(char *T[], double *D) 
/*       =============                                           */
{
  int i;
  if (T==NULL) 
    return NULL ;
  for (i=1; T[i] != NULL ; i++)
    D[i] = atof(T[i]);
  D[0] = (double) i;
  D[i] = 0 ;
  return D ;
}

/*      ============                                           */
char ** TokenizeLine(TokenizeData * d)
/*      ============                                           */
{
  if (!d->initialized) 
    InitLexer(d);
  {
    char **T = d->T ;
    char * eof = (d->RS == NULL ?
		  fgets(d->KeepBuf,BUFSIZ,d->fp) :
		  fgets_WithDelim(d->KeepBuf,BUFSIZ,d->fp,d->RS)) ;
    d->NF = 0;
    if (eof == NULL)  {
      if (d->debug) STDERR("eof == NULL");
      return NULL ;
    } else {
      char * strtokP = d->TokBuf;
      T[0] = d->KeepBuf;
      T[0][strlen(T[0])-1] = '\0';
      strcpy(strtokP,T[0]);    
      do {
	d->NF++ ;
	if (d->NF >= 1000) {
	  STDERR("(d->NF >= 1000)");
	}
	if (d->NF >= MAXTOK) {
	  STDERR("(d->NF >= MAXTOK)");
	}
	T[d->NF] = strtok(strtokP,d->whitespace);
	strtokP = NULL ;
      } while ( T[d->NF] != NULL ) ;
      ToksToDoubles(T,d->D);
      d->NF-- ;
      d->NR ++ ;
      if (d->debug) {
	PrintTokens2(d,stderr);
      }
      return T ;
    }
  }
}
/*  ============                                           */
int TokenizeFile
/*  ============                                           */
  (void (*function)(), TokenizeData * d)
{
  char **T ;
  if (d->debug) STDERR("Beginning TokenizeStdin");
  while ((T = TokenizeLine(d)) != NULL) {
    (*function)(T,d->D,d) ;
  }
  return d->NR ;
}

/*   ============                                           */
bool TrueBetweenP(bool OnMatch, bool OffMatch, int i )
/*   ============                                           */
{
  static bool * OnFlag; 
  static bool * OffFlag; 
  static bool init = false ;
  if (!init) {
    OnFlag = (bool *) calloc(100, sizeof(bool));
    OffFlag  = (bool *) calloc(100, sizeof(bool));
    init = true ;
  }
  if (!OnFlag[i] && !OffFlag[i] && OnMatch && !OffMatch ) {
    OnFlag[i] = true ;
    return false ;
  } else if (OnFlag[i] && !OffFlag[i] && !OnMatch && OffMatch ) {
    OffFlag[i] = true ;
    return false  ;
  } else if (OnFlag[i] && OffFlag[i]) {
    return false ;
  } else if (OnFlag[i]) {
    return true ;
  } else {
    return false ;
  }
}

/*   =======                                           */
bool OnBetwP(bool OnMatch, bool OffMatch, int * flag )
/*   =======                                           */
{
  if (*flag & 4) 
    fprintf(stderr,"OnBetwP: OnMatch=%d  OffMatch=%d *flag=%d (*flag & 1)=%d\n",
	    OnMatch,OffMatch,*flag,(int) (*flag &1));
  if (!(*flag & 1) && !(*flag & 2) && OnMatch && !OffMatch ) {
    *flag |= 1 ;
    return false ;
  } else if ((*flag & 1) && !(*flag & 2) && !OnMatch && OffMatch ) {
    *flag |= 2 ;
    return false  ;
  } else if ((*flag & 1) && (*flag & 2)) {
    return false ;
  } else if (*flag & 1) {
    return true ;
  } else {
    return false ;
  }
}

/*   ================                                           */
bool InclusiveOnBetwP(bool OnMatch, bool OffMatch, int * flag )
/*   ================                                           */
{
  if (*flag & 4) 
    fprintf(stderr,"OnBetwP: OnMatch=%d  OffMatch=%d *flag=%d (*flag & 1)=%d\n",
	    OnMatch,OffMatch,*flag,(int) (*flag &1));
  if (!(*flag & 1) && !(*flag & 2) && OnMatch && !OffMatch ) {
    *flag |= 1 ;
    return true ;
  } else if ((*flag & 1) && !(*flag & 2) && !OnMatch && OffMatch ) {
    *flag |= 2 ;
    return true ;
  } else if ((*flag & 1) && (*flag & 2)) {
    return false ;
  } else if (*flag & 1) {
    return true ;
  } else {
    return false ;
  }
}

/*   ===========                                           */
bool OnBetwStrgs(TokenizeData * d, char * s1, char * s2)
/*   ===========                                           */
{
  return OnBetwStrgs2(d,s1,s2,0)  ;
}

/*   ============                                           */
bool OnBetwStrgs2(TokenizeData * d, char * s1, char * s2, int n)
/*   ============                                           */
{
  return OnBetwP(StrEq(d->T[1],s1),
		 StrEq(d->T[1],s2),&d->flag[n])  ;
}

/*   ====================                                           */
bool InclusiveOnBetwStrgs(TokenizeData * d, char * s1, char * s2, int n)
/*   ====================                                           */
{
  return InclusiveOnBetwP(StrEq(d->T[1],s1),
		 StrEq(d->T[1],s2),&d->flag[n])  ;
}

/*   ====================                                           */
bool InclusiveOnAfterStrg(TokenizeData * d, char * s1)
/*   ====================                                           */
{
  return InclusiveOnBetwP(StrEq(d->T[1],s1),
		 0,&d->flag[0])  ;
}

/*   =====================                                           */
bool InclusiveTrueBetweenP(bool OnMatch, bool OffMatch, int i )
/*   =====================                                           */
{
  static bool * OnFlag; 
  static bool * OffFlag; 
  static bool init = false ;
  if (!init) {
    OnFlag = (bool *) calloc(100, sizeof(bool));
    OffFlag  = (bool *) calloc(100, sizeof(bool));
    init = true ;
  }
  if (!OnFlag[i] && !OffFlag[i] && OnMatch && !OffMatch ) {
    OnFlag[i] = true ;
    return true ;
  } else if (OnFlag[i] && !OffFlag[i] && !OnMatch && OffMatch ) {
    OffFlag[i] = true ;
    return true  ;
  } else if (OnFlag[i] && OffFlag[i]) {
    return false ;
  } else if (OnFlag[i]) {
    return true ;
  } else {
    return false ;
  }
}