xalm/doxygen/librw_8h_source.html

 #ifndef GELIB_IO_H

 #define GELIB_IO_H


 #include "gelib.h"


 #include <stdio.h>


 #define _ARRAYS


 namespace gelibspace {


 class Dvctr;


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

 //* *** *** *** ***                      GENERAL FUNCTIONS                       *** *** *** ***

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

 bool isWordChar (char C);

 bool isLineChar (char C);

 bool isSpaceChar (char C);


 long giveLineLength (const char *src);


 char* strdupl (const char *src);

 char* strdupl (const char *src1, const char *src2);

 char* strdupl (const char *src1, const char *src2, const char *src3);

 char* pathstrdupl (const char *src);


 void errorr_expected (const char* file, int line, const char *msg, const char *expctd, const char *src);

 void errorr_expected (const char* file, int line, const char *msg,         int expctd, const char *src);

 void errorr_expected (const char* file, int line, const char *msg,        long expctd, const char *src);

 void errorr_expected (const char* file, int line, const char *msg,      double expctd, const char *src);


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

 //* *** *** *** ***                     ARGUMENTS PROCESSING                     *** *** *** ***

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

 long AP_find_option (int argc, char *argv[], const char *s);

 void AP_fprint_arguments (FILE *stream, int argc, char *argv[]);


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

 //* *** *** *** ***                       FILE PROCESSING                        *** *** *** ***

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

 bool FP_skip_comment  (FILE *stream);

 void FP_skip_line_commented  (FILE *stream);

 void FP_skip_line_fast_skip_commented  (FILE *stream, int n=1);

 bool FP_skip_line  (FILE *stream, int n=1);

 bool FP_skip_expected_string (FILE *src, const char *expctd, bool cs);

 bool FP_skip_behind_line_starting_with (FILE *stream, const char *string, bool cs);


 bool FP_skip_to_line_starting_with (FILE *stream, const char *string, bool cs);

 bool FP_skip_to_line_starting_With (FILE *stream, const char *string, bool cs);


 bool FP_skip_to_line_starting_with (FILE *stream, char C);


 void FP_copy_file (FILE *sour,FILE *dest);


 bool FP_copy_behind_line (FILE *sour, FILE *dest, int n=1);

 bool FP_copy_behind_line_starting_with (FILE *src, FILE *dest, const char *expctd, bool cs);


 bool FP_scan_array (FILE *stream, int n, int    *dest);

 bool FP_scan_array (FILE *stream, int n, long   *dest);

 bool FP_scan_array (FILE *stream, int n, double *dest);


 long FP_number_of_words (FILE *stream);

 long FP_number_of_lines (FILE *stream, bool rwd=false);


 bool FP_skip_nonword (FILE *stream);


 bool FP_skip_space (FILE *stream);


 long FP_scan_line_skip_emptyORcommented (FILE *stream, char *dest);


 long FP_scan_line (FILE *stream, char *dest);


 long FP_scan_line_alloc (FILE *stream, char *&dest);


 int FP_scan_word (FILE *stream, char *dest);


 bool FP_scan_expected_word (FILE *src, const char *expctd, bool cs=true);


 void FP_scan_expected_word_FL (const char* file, int line, FILE *src, const char *expctd, const char *msg, bool cs);

 #define FP_scan_expected_word_exit(_1,_2,_3,_4) FP_scan_expected_word_FL (__FILE__, __LINE__, _1,_2,_3,_4)

 void FP_scan_expected_line_FL (const char* file, int line, FILE *src, const char *expctd, const char *msg, bool cs);

 #define FP_scan_expected_line_exit(_1,_2,_3,_4) FP_scan_expected_line_FL (__FILE__, __LINE__, _1,_2,_3,_4)


 bool FP_scan_expected_number (FILE *src, long expctd);


 template <class ArgType>

 void FP_scan_expected_number_FL (const char* file, int line, FILE *src, ArgType expctd, const char *msg)

 {

   if (!FP_scan_expected_number (src, expctd))

     errorr_expected (file, line, msg, expctd, ""); // misto "" by tam mel byt retezec s prectenym cislem, casem to dodelej, asi budes muset predelat errorr_expected

 }

 #define FP_scan_expected_number_exit(_1,_2,_3) FP_scan_expected_number_FL (__FILE__, __LINE__, _1,_2,_3)


 //void FP_scan_expected_long number (FILE *stream, ArgType expctd)

 //{

 //  ArgType aux;

 //  SP_scan_number (src, aux);

 //  if (aux != expctd)  return false;

 //  return true;

 //

 //fscanf (in, "%ld", &auxl);  if ( auxl != -1)  _errorr3 ("Invalid structure of the given UNV file: actual != expected -- %ld != %ld", -1, auxl);

 //

 //

 //}


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

 //* *** *** *** ***                      STRING PROCESSING                       *** *** *** ***

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


 bool SP_cutcomment (char *src);


 bool SP_replace_char (char *str, char s, char d);


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

 //* ***   ***   ***   SKIPING   ***   ***   ***

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


 bool SP_skip_space (const char *&src);

 bool SP_skip_word (const char *&src, int n=1);

 bool SP_skip_int (const char *&src);


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

 //* ***   ***   ***   SCANNING   ***   ***   ***

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

 void SP_unscan_word (const char *&src, const char *w);


 bool SP_scan_character (const char *&src, char &dest);

 long SP_scan_word      (const char *&src, char *dest);

 long SP_scan_line      (const char *&src, char *dest);

 long SP_scan_line_alloc (const char *&src, char *&dest);


 bool SP_scan_expected_word (const char *&src, const char *expctd, bool cs=true);


 void SP_scan_expected_word_FL (const char* file, int line, const char *&src, const char *expctd,                                            const char *msg, bool cs);

 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);

 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);

 //

 #define SP_scan_expected_word_exit( _1,_2,_3,_4)       SP_scan_expected_word_FL (__FILE__, __LINE__, _1,_2,_3,_4)

 #define SP_scan_expected_word2_exit(_1,_2,_3,_4,_5)    SP_scan_expected_word_FL (__FILE__, __LINE__, _1,_2,_3,_4,_5)

 #define SP_scan_expected_word3_exit(_1,_2,_3,_4,_5,_6) SP_scan_expected_word_FL (__FILE__, __LINE__, _1,_2,_3,_4,_5,_6)


 bool SP_scan_number (const char *&src, int    &dest);

 bool SP_scan_number (const char *&src, long   &dest);

 bool SP_scan_number (const char *&src, double &dest);


 template <class ArgType>

 bool SP_scan_expected_number (const char *&src, ArgType expctd)

 {

   ArgType aux;

   return (SP_scan_number (src, aux)  &&  aux == expctd);

 }


 template <class ArgType>

 void SP_scan_expected_number_FL (const char* file, int line, const char *&src, ArgType expctd, const char *msg)

 {

   if (!SP_scan_expected_number (src, expctd))

     errorr_expected (file, line, msg, expctd, src);

 }

 #define SP_scan_expected_number_exit(_1,_2,_3) SP_scan_expected_number_FL (__FILE__, __LINE__, _1,_2,_3)


 template <class ArgType> bool SP_scan_array (const char *&src, int  n, ArgType *a) {  while (--n)  SP_scan_number (src, (a++)[0]);  return SP_scan_number (src, a[0]); }

 template <class ArgType> bool SP_scan_array (const char *&src, long n, ArgType *a) {  while (--n)  SP_scan_number (src, (a++)[0]);  return SP_scan_number (src, a[0]); }


 template <class ArgType>

 bool SP_scan_array_alloc (const char *&src, long &n, ArgType *&a)

 {

   SP_scan_number (src, n);

   a = new ArgType[n];

   return SP_scan_array (src, n, a);

 }


 bool SP_scan_array_L (const char *&src, int L, double *a);


 #ifdef _ARRAYS

 bool SP_scan_Dvctr_exit (const char *&src, int n, Dvctr *v);

 #endif


 template <class ArgType>

 bool SP_scan_Xvctr (const char *&src, ArgType *dest)

 {

   long n;

   SP_scan_number (src, n);

   dest->resize_ignore_vals(n);

   return SP_scan_array (src, n, dest->give_ptr2val());

 }


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

 //* ***   ***   ***   PRINTING   ***   ***   ***

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


 bool SP_print_space (const char *&src, FILE *stream);

 bool SP_print_word (const char *&src, FILE *stream);


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

 //* *** *** *** ***                      OBSOLETE FUNCTIONS                      *** *** *** ***

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

 long find_double (long n, long* p);


 void sprint_param (char *s, char *argv[], int n);


 void read_star_end (FILE *stream,int n=1);

 void read_star (FILE *stream);


 void copy_star_end (FILE *sour,FILE *dest,int n=1);

 void copy_star (FILE *sour,FILE *dest);


 void copy_to_end_line (FILE *sour,FILE *dest);


 int  extract_long   (const char *s1, const char *s2, long &a);

 int  extract_double (const char *s1, const char *s2, double &a);


 void extract_double_array (const char *s1, const char *s2, long n, double *a);


 void give_line (FILE *stream,char *&s);

 void ad_line (FILE *stream,char *s);


 } // namespace gelibspace


 #endif // GELIB_IO_H

gelibspace::isLineChar
bool isLineChar(char C)
return true if character C is "normal" char or "space" char –> C != ' ' '\0' ''
Definition: librw.cpp:26

gelibspace::SP_print_word
bool SP_print_word(const char *&src, FILE *stream)
... word
Definition: librw.cpp:717

gelibspace::give_line
void give_line(FILE *stream, char *&s)

gelibspace::FP_skip_expected_string
bool FP_skip_expected_string(FILE *src, const char *expctd, bool cs)
... word and compare with expected one
Definition: librw.cpp:436

gelibspace::SP_cutcomment
bool SP_cutcomment(char *src)
cut of comment == end of line starting by '#'
Definition: librw.cpp:504

gelibspace::FP_skip_line_commented
void FP_skip_line_commented(FILE *stream)
move file descriptor to the start of the new noncommented line, without checking of EOF ...
Definition: librw.cpp:145

gelibspace::sprint_param
void sprint_param(char *s, char *argv[], int n)
Definition: librw.cpp:743

gelibspace::giveLineLength
long giveLineLength(const char *src)
return length of line == sting compount of "line chars"
Definition: librw.cpp:43

gelibspace::FP_skip_line
bool FP_skip_line(FILE *stream, int n)
move file descriptor to the start of the n-th new line //[former read_line]
Definition: librw.cpp:167

gelibspace::extract_long
int extract_long(const char *s1, const char *s2, long &a)
Definition: librw.cpp:780

gelib.h
General functions.

gelibspace::isSpaceChar
bool isSpaceChar(char C)
return true if character C is "space" char –> C == ' ' ''
Definition: librw.cpp:32

gelibspace::FP_scan_expected_line_FL
void FP_scan_expected_line_FL(const char *file, int line, FILE *src, const char *expctd, const char *msg, bool cs)
... line and compare with expected one, exit if false
Definition: librw.cpp:479

gelibspace::strdupl
char * strdupl(const char *src)
standard strdup - Memory for the new string is obtained with malloc(3), and can be freed with free(3)...
Definition: librw.cpp:53

gelibspace::copy_to_end_line
void copy_to_end_line(FILE *sour, FILE *dest)
Definition: librw.cpp:772

gelibspace::extract_double
int extract_double(const char *s1, const char *s2, double &a)
v retezci s1 se najde key retezec s2 a za nim se precte double
Definition: librw.cpp:790

gelibspace::SP_scan_expected_number_FL
void SP_scan_expected_number_FL(const char *file, int line, const char *&src, ArgType expctd, const char *msg)
... number and compare with expected one, exit if false
Definition: librw.h:237

gelibspace::SP_scan_word
long SP_scan_word(const char *&src, char *dest)
... word; return value is length of the word
Definition: librw.cpp:608

gelibspace::SP_scan_array
bool SP_scan_array(const char *&src, int n, ArgType *a)
... array of numbers
Definition: librw.h:246

gelibspace::FP_copy_file
void FP_copy_file(FILE *sour, FILE *dest)
[former copy_file]
Definition: librw.cpp:212

gelibspace::FP_scan_expected_number_FL
void FP_scan_expected_number_FL(const char *file, int line, FILE *src, ArgType expctd, const char *msg)
... number and compare with expected one, exit if false
Definition: librw.h:141

gelibspace::isWordChar
bool isWordChar(char C)
 *** *** *** *** GENERAL FUNCTIONS *** *** *** ***  return true if character C is "normal" char –> C...
Definition: librw.cpp:20

gelibspace::extract_double_array
void extract_double_array(const char *s1, const char *s2, long n, double *a)
Definition: librw.cpp:799

gelibspace::SP_skip_space
bool SP_skip_space(const char *&src)
... space == ' ' and '' characters
Definition: librw.cpp:545

gelibspace::AP_fprint_arguments
void AP_fprint_arguments(FILE *stream, int argc, char *argv[])
print arguments to stream
Definition: librw.cpp:106

gelibspace::FP_scan_array
bool FP_scan_array(FILE *stream, int n, int *dest)
scan/copy array of numbers from src to dest, src pointer is shifted over the field ...
Definition: librw.cpp:274

gelibspace::SP_scan_expected_word_FL
void SP_scan_expected_word_FL(const char *file, int line, const char *&src, const char *expctd, const char *msg, bool cs)
... word and compare with expected one/two/three, exit if false
Definition: librw.cpp:670

gelibspace::FP_skip_comment
bool FP_skip_comment(FILE *stream)
 *** *** *** *** FILE PROCESSING *** *** *** ***  general rules for file processing: ...
Definition: librw.cpp:130

gelibspace::FP_number_of_words
long FP_number_of_words(FILE *stream)
count number of words (see isWordChar) in file
Definition: librw.cpp:280

gelibspace::FP_scan_line
long FP_scan_line(FILE *stream, char *dest)
scan/copy line == string without ' ' from stream
Definition: librw.cpp:381

gelibspace::read_star
void read_star(FILE *stream)
Definition: librw.cpp:754

gelibspace::read_star_end
void read_star_end(FILE *stream, int n)
Definition: librw.cpp:750

gelibspace::FP_skip_space
bool FP_skip_space(FILE *stream)
... space
Definition: librw.cpp:337

gelibspace::FP_scan_line_alloc
long FP_scan_line_alloc(FILE *stream, char *&dest)
scan/copy line == string without ' ' from stream; dest is NULL and allocated here ...
Definition: librw.cpp:400

gelibspace::SP_skip_int
bool SP_skip_int(const char *&src)
... word compound of digits and space before
Definition: librw.cpp:566

gelibspace::SP_scan_number
bool SP_scan_number(const char *&src, int &dest)
... number of type int/long/double
Definition: librw.cpp:675

gelibspace::errorr_expected
void errorr_expected(const char *file, int line, const char *msg, const char *expctd, const char *src)
 *** *** *** *** STRING PROCESSING *** *** *** ***  src pointer is always shifted over the skipped/sc...
Definition: librw.cpp:498

gelibspace::FP_scan_expected_word
bool FP_scan_expected_word(FILE *src, const char *expctd, bool cs)
... word and compare with expected one
Definition: librw.cpp:448

gelibspace::FP_skip_line_fast_skip_commented
void FP_skip_line_fast_skip_commented(FILE *stream, int n)
move file descriptor to the start of the n-th new line, without checking of EOF
Definition: librw.cpp:155

gelibspace::FP_skip_to_line_starting_With
bool FP_skip_to_line_starting_With(FILE *stream, const char *string, bool cs)
move file descriptor to the line starting with string, exactly behind the string; NO white space can ...
Definition: librw.cpp:201

gelibspace::SP_unscan_word
void SP_unscan_word(const char *&src, const char *w)
 *** *** *** SCANNING *** *** ***  unscan word == shift pointer back over word
Definition: librw.cpp:584

gelibspace::SP_scan_line
long SP_scan_line(const char *&src, char *dest)
... line; return value is length of the line
Definition: librw.cpp:624

gelibspace::find_double
long find_double(long n, long *p)
 *** *** *** *** OBSOLETE FUNCTIONS *** *** *** ***
Definition: librw.cpp:731

gelibspace::SP_scan_Dvctr_exit
bool SP_scan_Dvctr_exit(const char *&src, int n, Dvctr *v)
Definition: librw.cpp:692

gelibspace::SP_scan_line_alloc
long SP_scan_line_alloc(const char *&src, char *&dest)
... line; return value is length of the line; dest is NULL and allocated here
Definition: librw.cpp:639

gelibspace::SP_replace_char
bool SP_replace_char(char *str, char s, char d)
replace src char to dest char
Definition: librw.cpp:517

gelibspace::SP_scan_Xvctr
bool SP_scan_Xvctr(const char *&src, ArgType *dest)
bool SP_scan_Dvctr (const char *&src, Dvctr *dest);
Definition: librw.h:268

gelibspace::FP_skip_behind_line_starting_with
bool FP_skip_behind_line_starting_with(FILE *stream, const char *string, bool cs)
move file descriptor to the start of the new line after the one starting with string ...
Definition: librw.cpp:181

gelibspace::AP_find_option
long AP_find_option(int argc, char *argv[], const char *s)
 *** *** *** *** ARGUMENTS PROCESSING *** *** *** ***  terminology: tar -cz -f archiv.tgz archiv/ /// fce name | arguments /// fce name | options | parameters /// fce name | opt | opt | opt argum.
Definition: librw.cpp:97

gelibspace::SP_scan_array_L
bool SP_scan_array_L(const char *&src, int L, double *a)
Definition: librw.cpp:681

gelibspace::SP_scan_character
bool SP_scan_character(const char *&src, char &dest)
scanning == scan ... to variable dest and shift src pointer at the end of ...
Definition: librw.cpp:597

gelibspace::FP_skip_to_line_starting_with
bool FP_skip_to_line_starting_with(FILE *stream, const char *string, bool cs)
move file descriptor to the line starting with string, exactly behind the string; white space can be ...
Definition: librw.cpp:191

gelibspace::FP_scan_line_skip_emptyORcommented
long FP_scan_line_skip_emptyORcommented(FILE *stream, char *dest)
 *** *** *** SCANNING *** *** ***  scanning == scan ...
Definition: librw.cpp:369

gelibspace::SP_print_space
bool SP_print_space(const char *&src, FILE *stream)
 *** *** *** PRINTING *** *** ***  printing == print ...
Definition: librw.cpp:707

gelibspace::copy_star_end
void copy_star_end(FILE *sour, FILE *dest, int n)
read line of file until  , no save, dava bacha na EOF
Definition: librw.cpp:761

gelibspace::FP_number_of_lines
long FP_number_of_lines(FILE *stream, bool rwd)
count number of lines in file
Definition: librw.cpp:300

gelibspace::SP_scan_array_alloc
bool SP_scan_array_alloc(const char *&src, long &n, ArgType *&a)
Definition: librw.h:250

gelibspace::FP_copy_behind_line
bool FP_copy_behind_line(FILE *sour, FILE *dest, int n)
copy from file to file behind the line [former copy_line]
Definition: librw.cpp:220

gelibspace::FP_copy_behind_line_starting_with
bool FP_copy_behind_line_starting_with(FILE *src, FILE *dest, const char *expctd, bool cs)
copy from file to file behind the line starting with string
Definition: librw.cpp:237

gelibspace
Definition: arrays.cpp:10

gelibspace::FP_skip_nonword
bool FP_skip_nonword(FILE *stream)
 *** *** *** SKIPING *** *** ***  skiping == shift stream pointer at the first char which is not ...
Definition: librw.cpp:324

gelibspace::SP_scan_expected_number
bool SP_scan_expected_number(const char *&src, ArgType expctd)
... number and compare with expected one
Definition: librw.h:229

gelibspace::FP_scan_expected_number
bool FP_scan_expected_number(FILE *src, long expctd)
... number and compare with expected one
Definition: librw.cpp:485

gelibspace::FP_scan_expected_word_FL
void FP_scan_expected_word_FL(const char *file, int line, FILE *src, const char *expctd, const char *msg, bool cs)
... word and compare with expected one, exit if false
Definition: librw.cpp:458

gelibspace::FP_scan_word
int FP_scan_word(FILE *src, char *dest)
... word; return value is length of the word
Definition: librw.cpp:416

gelibspace::ad_line
void ad_line(FILE *stream, char *s)
Definition: librw.cpp:807

gelibspace::SP_skip_word
bool SP_skip_word(const char *&src, int n)
... word and space before
Definition: librw.cpp:552

gelibspace::copy_star
void copy_star(FILE *sour, FILE *dest)
Definition: librw.cpp:765

gelibspace::pathstrdupl
char * pathstrdupl(const char *src)
Definition: librw.cpp:73

gelibspace::SP_scan_expected_word
bool SP_scan_expected_word(const char *&src, const char *expctd, bool cs)
... word and compare with expected one
Definition: librw.cpp:660