librw.cpp

Go to the documentation of this file.

#include "librw.h"

#include "gelib.h"
#include "arrays.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>


namespace gelibspace {

#define CHECK_DEST  if (!dest) _errorr("destination is not allocated")


bool get_confirm (const char *s, bool expected)
{
  fprintf(stdin, "\n%s", s);
  if (expected == true)  fprintf (stdin, " (Y or n): ");
  else                   fprintf (stdin, " (y or N): ");
  fflush(stdin);
  scanf("%*c"); printf("\n");
  return true;
}

bool isWordChar (char C)
{
  return ( ( C == ' '  ||  C == '\t'  ||  C == '\n'  ||  C == '\0'  ||  C == '\r'  ||  C == EOF) ? false : true);
}

bool isLineChar (char C)
{
  return ( (                              C == '\n'  ||  C == '\0'  ||  C == '\r'  ||  C == EOF) ? false : true);
}

bool isSpaceChar (char C)
{
  return ( ( C == ' '  ||  C == '\t'                                                           ) ? true : false);
}

bool isDigitChar (char C)
{
  return ( ( C < 48  ||  C > 57 ) ? false : true);
}

long giveLineLength (const char *src)
{
  long n = 0;
  while (isLineChar(src[n]))  n++;
  
  return n;
}

char* strdupl (const char *src)
{
  if (src==NULL)  return NULL;
  long len = strlen (src) + 1;
  char *dest = new char[len];
  return (char *) memcpy (dest, src, len);
}
char* strdupl (const char *src1, const char *src2)
{
  char *aux = new char[strlen(src1) + strlen(src2) + 1];
  sprintf (aux, "%s%s", src1, src2);
  return aux;
}
char* strdupl (const char *src1, const char *src2, const char *src3)
{
  char *aux = new char[strlen(src1) + strlen(src2) + strlen(src3) + 1];
  sprintf (aux, "%s%s%s", src1, src2, src3);
  return aux;
}

char* pathstrdupl (const char *src)
{
  long len = strlen (src) + 2;
  char *dest = new char[len];
  memcpy (dest, src, len);
  if (dest[len-3] != DIRSEPARATOR) {
    dest[len-2] = DIRSEPARATOR;
    dest[len-1] = '\0';
  }
  return (char *) dest;
}



long AP_find_option (int argc, char *argv[], const char *s)
{
  for (int i=1; i<argc; i++)
    if (!_STRCASECMP(s,argv[i])) return i;

  return 0;
}

void AP_fprint_arguments (FILE *stream, int argc, char *argv[])
{
  fprintf (stream,"\n Command line:");
  fprintf (stream,"\n  %s ",argv[0]);
  for (int i=1;i<argc;i++)
    fprintf (stream," %c",argv[i][0]);

  fprintf (stream,"\n  options: ");
  for (int i=1;i<argc;i++)
    fprintf (stream," %s",argv[i]);

  fprintf (stream,"\n\n");
}





bool FP_skip_comment  (FILE *stream)
{
  char c;
  while (true) {
    c = getc(stream);
    if (c == EOF) { ungetc(c, stream);  return false; }
    if (! isWordChar(c))  continue;
    if (c == '#')  FP_skip_line (stream);
    else { ungetc(c, stream);  return true; }
  }
  
  return false;
}

void FP_skip_line_commented  (FILE *stream)
{
  char c;
  while ((c = getc(stream)) == '#')
    FP_skip_line (stream);
  
  ungetc (c, stream);
}

void FP_skip_line_fast_skip_commented  (FILE *stream, int n)
{
  char c;
  while (n--) {
    c = getc(stream);
    if (c == '\n')  continue;
    if (c == '#' )  n++;
    while ( getc(stream) != '\n') ;
  }
}

bool FP_skip_line  (FILE *stream, int n)
{
  char c;
  while (n--)
    while (true) {
      c = getc(stream);
      if (c == '\n') break;
      if (c == EOF ) { ungetc(c, stream); return false; }
    }
  
  return true;
}

bool FP_skip_behind_line_starting_with (FILE *stream, const char *string, bool cs)
{
  while (true) {
    if (!FP_skip_space(stream))                         return false;
    if ( FP_skip_expected_string (stream, string, cs))  return (FP_skip_line (stream));
    if (!FP_skip_line (stream))                         return false;
  }
}

bool FP_skip_to_line_starting_with (FILE *stream, const char *string, bool cs)
{
  while (true) {
    if (!FP_skip_space(stream))                         return false;
    if ( FP_skip_expected_string (stream, string, cs))  return true;
    if (!FP_skip_line (stream))                         return false;
  }
}

bool FP_skip_to_line_starting_With (FILE *stream, const char *string, bool cs)
{
  while (true) {
    //if (!FP_skip_space(stream))                         return false;
    if ( FP_skip_expected_string (stream, string, cs))  return true;
    if (!FP_skip_line (stream))                         return false;
  }
}


void FP_copy_file (FILE *sour,FILE *dest)
{
  int c;
  while ((c = getc(sour)) != EOF)  putc (c,dest);
}

bool FP_cmp_files (const char *file1, const char *file2)
{
  FILE *f1 = _openFileN ("r", "The first compared file", file1);
  FILE *f2 = _openFileN ("r", "The second compared file", file2);
  
  bool status = false;
  int c1, c2;
  
  while (true) {
    c1 = getc(f1);
    c2 = getc(f2);
    
    if (c1 != c2) {
      status = true;
      break;
    }
    
    if (c1 == EOF) break;
  }
  
  fclose (f1);
  fclose (f2);
  
  return status;
}



bool FP_copy_behind_line (FILE *sour, FILE *dest, int n)
{
  char c;
  while (n--) {
    do {
      c = getc(sour);
      if (c == EOF)  return false;
      putc(c,dest);
    }
    while(c!='\n');
  }
  return true;
}



bool FP_copy_behind_line_starting_with (FILE *src, FILE *dest, const char *expctd, bool cs)
{
  char c;
  int n;
  while (true) {
    c = fgetc (src);  ungetc(c, src);
    if (c == EOF)  return false;
    
    // copy untill expected string is same
    n = 0;
    if (cs) while (expctd[n] != '\0') { c = getc(src);  fprintf (dest, "%c", c);  if (        c  !=         expctd[n] )  break;   n++; }
    else    while (expctd[n] != '\0') { c = getc(src);  fprintf (dest, "%c", c);  if (tolower(c) != tolower(expctd[n]))  break;   n++; }
    
    // copy to endfile
    if (c != '\n') FP_copy_behind_line (src, dest, cs);
    
    if (expctd[n] == '\0') return true;
  }
}


bool FP_skip_to_line_starting_with (FILE *stream, char C)
{
  char c;
  while ( (c = fgetc (stream)) != C )
    while (c != '\n')
      if (c == EOF ) { ungetc(c, stream); return false; }
      else c = fgetc(stream);
  
  ungetc (c, stream);
  return true;
}


bool FP_scan_array (FILE *stream, int n, int    *dest) {  while (n--) if (fscanf (stream, "%d",  dest++) == 0)  return false;   return true; }
bool FP_scan_array (FILE *stream, int n, long   *dest) {  while (n--) if (fscanf (stream, "%ld", dest++) == 0)  return false;   return true; }
bool FP_scan_array (FILE *stream, int n, double *dest) {  while (n--) if (fscanf (stream, "%lf", dest++) == 0)  return false;   return true; }


long FP_number_of_words (FILE *stream)
{
  char c;
  long answer = 0;
  bool space = true;

  while ((c = getc(stream)) != EOF)
    if (isWordChar(c)) {
      if (space) {
    answer++;
    space = false;
      }
    }
    else
      space = true;

  return answer;
}

long FP_number_of_lines (FILE *stream, bool rwd)
{
  int c;
  long lines = 0, fp = 0;

  if (rwd)  fp = ftell(stream);

  while ((c = getc(stream)) != EOF)
    if(c == '\n')
      lines++;

  if (rwd)  fseek(stream, fp, SEEK_SET);

  return lines;
}




bool FP_skip_nonword (FILE *stream)
{
  char c;
  while ((c = getc(stream)) != EOF)
    if (isWordChar(c)) {
      ungetc (c, stream);
      return true;
    }
  
  ungetc (c, stream);
  return false;
}
bool FP_skip_space (FILE *stream)
{
  char c;
  while ((c = getc(stream)) != EOF)
    if (!isSpaceChar(c)) {
      ungetc (c, stream);
      return true;
    }
  
  ungetc (c, stream);
  return false;
}
bool FP_skip_word (FILE *stream)
{
  //FP_skip_space (stream);   toto odkomentuj a pust testy !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  char c;
  while (true) {
    c = getc(stream);
    if (!isWordChar(c))  break;
  }
  
  ungetc (c, stream);
  return true;
}


long FP_scan_line_skip_emptyORcommented (FILE *stream, char *dest)
{
  char c;
  FP_skip_space (stream);
  while ((c = getc(stream)) == '#' || c == '\n')
    if (c == '#')  FP_skip_line (stream);
  
  ungetc (c, stream);
  
  return FP_scan_line (stream, dest);
}
long FP_scan_line (FILE *stream, char *dest)
{
  long n=0;
  while (isLineChar(dest[n] = getc(stream)))
    n++;
  
  if (dest[n] == EOF) {
    ungetc(EOF, stream);
    if (n==0)  return -1;
  }
  
  if (dest[n] == '\r')  getc(stream);      // win end of line
  //if (dest[n]   == '\r') { dest[n+1] = getc(stream);  if (dest[n+1] == '\r')  getc(stream); } // vorlasovo docasne
  
  dest[n] = '\0';
  
  return n;
}
long FP_scan_line_alloc (FILE *stream, char *&dest)
{
  if (dest)  _errorr("allocated");
  
  char aux[10001];
  long n = FP_scan_line (stream, aux);
  
  dest = new char[n+1];
  
  long i = n+1;
  while (i--)  dest[i] = aux[i];
  
  return n;
}

int FP_scan_word (FILE *src, char *dest)
{
  if (! FP_skip_nonword (src))  return 0;
  
  // scan word
  char c;
  register int n = 0;
  while (true) {
    c = getc(src);
    if (isWordChar(c))  dest[n++] = c;
    else                break;
  }
  
  ungetc (c, src);
  dest[n] = '\0';
  
  return n;
}
 
bool FP_skip_expected_string (FILE *src, const char *expctd, bool cs)
{
  char c;
  register int n = 0;
  
  if (cs) while (expctd[n] != '\0') { c = getc(src);  if (        c  !=         expctd[n] )  { ungetc (c, src);  break; }  n++; }
  else    while (expctd[n] != '\0') { c = getc(src);  if (tolower(c) != tolower(expctd[n]))  { ungetc (c, src);  break; }  n++; }
  
  return (expctd[n] == '\0');
}
 
bool FP_scan_expected_word (FILE *src, const char *expctd, bool cs)
{
  if (! FP_skip_nonword (src))                      return false;
  if (! FP_skip_expected_string (src, expctd, cs))  return false;
  
  FP_skip_word (src);
  return true;
}

void FP_scan_expected_word_FL (const char* file, int line, FILE *src, const char *expctd, const char *msg, bool cs)
{
  if (!FP_scan_expected_word (src, expctd, cs))  errorr_expected (file, line, msg, expctd, NULL);
}

bool FP_scan_expected_line (FILE *src, const char *expctd, bool cs)
{
  if (! FP_skip_space (src))                        return false;
  if (! FP_skip_expected_string (src, expctd, cs))  return false;
  if (! FP_skip_space (src))                        return false;
  
  char c = getc(src);
  if (c == '\r')  c = getc(src);
  if (c == EOF)   ungetc(c, src);
  if (c == '\n')  return true;
  
  return false;
}

void FP_scan_expected_line_FL (const char* file, int line, FILE *src, const char *expctd, const char *msg, bool cs)
{
  if (!FP_scan_expected_line (src, expctd, cs))  errorr_expected (file, line, msg, expctd, NULL);
}

bool FP_scan_expected_number (FILE *src, long expctd)
{
  long aux;
  return (fscanf (src, "%ld", &aux) == 1  &&  aux == expctd);
}



void errorr_expected (const char* file, int line, const char *msg, const char *expctd, const char *src)  { errorr (file, line, "%s, expected \"%s\"  != \"%s\"", msg, expctd, src); }
void errorr_expected (const char* file, int line, const char *msg,         int expctd, const char *src)  { errorr (file, line, "%s, expected \"%d\"  != \"%s\"", msg, expctd, src); }
void errorr_expected (const char* file, int line, const char *msg,        long expctd, const char *src)  { errorr (file, line, "%s, expected \"%ld\" != \"%s\"", msg, expctd, src); }
void errorr_expected (const char* file, int line, const char *msg,      double expctd, const char *src)  { errorr (file, line, "%s, expected \"%lf\" != \"%s\"", msg, expctd, src); }

bool SP_cutcomment (char *src)
{
  while (*src != '\0')
    if (*src != '#')  src++;
    else {
      while (*(--src) == ' ') ;
      src[1] = '\0';
      return true;
    }
  
  return false;
}
bool SP_replace_char (char *str, char s, char d)
{
  bool retval = false;
  
  while (*str != '\0') {
    if (*str == s) {
      str[0] = d;
      retval = true;
    }
    str = str + 1;
  }
  return retval;
}



bool SP_unskip_space (const char *&src)
{
  while (src[-1]==' ' || src[-1]=='\t')  src--;
  return true;
}

bool SP_skip_space (const char *&src)
{
  while (src[0]==' ' || src[0]=='\t')  src++;
  return true;
}

bool SP_skip_word (const char *&src, int n)
{
  while (n--) {
    SP_skip_space (src);
    // check word presence
    if (src[0]=='\n' || src[0]=='\0')  return false;
    // skip word
    while ( isWordChar(src[0]) )  src++;
  }
  
  return true;
}

bool SP_skip_int (const char *&src)
{
  SP_skip_space (src);
  // check word presence
  if (src[0]=='\n' || src[0]=='\0')  return false;
  
  // skip sign
  if (src[0]=='+' || src[0]=='-') src++;
  // skip word
  while ( isDigitChar(src[0]) )  src++;
  
  return true;
}

void SP_unscan_word (const char *&src, const char *w)
{
  SP_unskip_space (src);
  // find length of word
  long n = strlen(w);
  src = src-n;
  
  while (n--)  if (src[n] != w[n]) _errorr ("unscan error");
}


bool SP_scan_character (const char *&src, char &dest)
{
  SP_skip_space (src);
  //
  if (src[0]=='\n' || src[0]=='\0' || src[0]=='\r')
    return false;

  dest = src[0];  src++;
  return true;
}
long SP_scan_word (const char *&src, char *dest)
{
  SP_skip_space (src);
  
  // find length of word
  long n=0;
  while (isWordChar(src[n]))  n++;
  // copy word
  strncpy (dest, src, n);
  dest[n] = '\0';
  // shift src pointer
  src += n;

  return n;
}
long SP_scan_line (const char *&src, char *dest)
{
  CHECK_DEST;

  long n=0;
  while (isLineChar(src[n])) {
    dest[n] = src[n];
    n++;
  }
  dest[n] = '\0';
  src += n;

  return n;
}
long SP_scan_line_alloc (const char *&src, char *&dest)
{
  if (dest)  _errorr("allocated");
  
  SP_skip_space (src);
  
  long n = giveLineLength (src);
  
  dest = new char[n+1];
  
  long i = n;
  while (i--)  dest[i] = src[i];
  
  dest[n] = '\0';
  
  src += n;
  
  return n;
}

bool SP_scan_expected_word (const char *&src, const char *expctd, bool cs)
{
  SP_skip_space (src);
  register int n = -1;
  if (cs) {  while (expctd[++n] != '\0')  if (        src[n]  !=         expctd[n] )  return false;  }
  else    {  while (expctd[++n] != '\0')  if (tolower(src[n]) != tolower(expctd[n]))  return false;  }
  src += n;
  return true;
}
void SP_scan_expected_word_FL (const char* file, int line, const char *&src, const char *expctd,                                            const char *msg, bool cs) { if (                                                                                              !SP_scan_expected_word (src, expctd,  cs))  errorr_expected (file, line, msg, expctd, src); }
void SP_scan_expected_word_FL (const char* file, int line, const char *&src, const char *expctd1, const char *expctd2,                      const char *msg, bool cs) { if (                                               !SP_scan_expected_word (src, expctd2, cs)  &&  !SP_scan_expected_word (src, expctd1, cs))  errorr          (file, line, "%s, expected \"%s\" or \"%s\" != \"%s\"",           msg, expctd1, expctd2,          src); }
void SP_scan_expected_word_FL (const char* file, int line, const char *&src, const char *expctd1, const char *expctd2, const char *expctd3, const char *msg, bool cs) { if (!SP_scan_expected_word (src, expctd3, cs)  &&  !SP_scan_expected_word (src, expctd2, cs)  &&  !SP_scan_expected_word (src, expctd1, cs))  errorr          (file, line, "%s, expected \"%s\" or \"%s\" or \"%s\" != \"%s\"", msg, expctd1, expctd2, expctd2, src); }

bool SP_scan_number (const char *&src, int    &dest) { sscanf (src,  "%d", &dest);  return SP_skip_int  (src); }
bool SP_scan_number (const char *&src, long   &dest) { sscanf (src, "%ld", &dest);  return SP_skip_int  (src); }
bool SP_scan_number (const char *&src, double &dest) { sscanf (src, "%lf", &dest);  return SP_skip_word (src); }


bool SP_scan_array_L (const char *&src, int L, double *a)
{
  if (!SP_scan_expected_number (src, L))  {
    _warningg2 ("The length of array of doubles is not \"%d\"", L);
    return false;
  }
  return SP_scan_array (src, L, a);
}

#ifdef _ARRAYS
bool SP_scan_Dvctr_exit (const char *&src, int n, Dvctr *v)
{
  if (!SP_scan_expected_number (src, n))  _errorr("unexpected number of components in scanned array");
  v->resize_ignore_vals(n);
  return SP_scan_array (src, n, v->give_ptr2val());
}
#endif



bool SP_print_space (const char *&src, FILE *stream)
{
  while ( isSpaceChar(src[0]) ) {
    fprintf (stream, "%c", src[0]);
    src++;
  }
  return true;
}

bool SP_print_word (const char *&src, FILE *stream)
{
  SP_skip_space (src);
  while ( isWordChar(src[0]) ) {
    fprintf (stream, "%c", src[0]);
    src++;
  }
  return true;
}


long find_double (long n, long* p)
{
  int i, j;

  for (i=0; i<n; i++)
    for (j=i+1; j<n; j++)
      if (p[i]==p[j]) return i+1;

  return 0;
}


void sprint_param (char *s, char *argv[], int n)
{
  ;            sprintf (strchr(s,'\0'), " ");
  while (n--)  sprintf (strchr(s,'\0'), " %s", *(argv-n));
}


void read_star_end (FILE *stream,int n)
{
  while (n--) { read_star (stream); FP_skip_line (stream); }
}
void read_star (FILE *stream)
{
  char c;
  while ((c = getc (stream)) != '*' ) ;
  ungetc (c,stream);
}

void copy_star_end (FILE *sour,FILE *dest,int n)
{
  while (n--) { copy_star (sour,dest); FP_copy_behind_line (sour,dest); }
}
void copy_star (FILE *sour,FILE *dest)
{
  char c;
  while ((c = getc (sour)) != '*') putc (c,dest);
  ungetc (c,sour);
}

void copy_to_end_line (FILE *sour,FILE *dest)
{
  char c;
  while ((c = getc (sour)) != '\n')  putc (c,dest);
  ungetc ('\n',sour);
}


int extract_long (const char *s1, const char *s2, long &a)
{
  const char *ss = strstr (s1,s2);
  if (ss==NULL) return 1;
  ss += strlen(s2);
  sscanf (ss,"%ld",&a);
  return 0;
}

int extract_double (const char *s1, const char *s2, double &a)
{
  const char *ss = strstr (s1,s2);
  if (ss==NULL) return 1;
  ss += strlen(s2);
  sscanf (ss,"%lf",&a);
  return 0;
}

void extract_double_array (const char *s1, const char *s2, long n, double *a)
{
  const char *ss = strstr (s1,s2);
  //if (ss==NULL) return 1;
  ss += strlen(s2);
  SP_scan_array_L (ss, n, a);
}

void ad_line (FILE *stream,char *s)
{
  char c;
  long l = strlen (s);
  char* ss = s + l;
  register long i=0;
  while ((c = getc(stream)) != '\n')   ss[i++] = c;
  ss[i] = '\0';
}

} // namespace gelibspace