~muMECH/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;


 bool get_confirm (const char *s, bool expected);


 //* ********************************************************************************************
 //* *** *** *** ***                      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_cmp_files (const char *file1, const char *file2);

 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 != &#39; &#39; &#39;\0&#39; &#39;&#39;
Definition: librw.cpp:37

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

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:475

gelibspace::SP_cutcomment
bool SP_cutcomment(char *src)
cut of comment == end of line starting by &#39;#&#39;
Definition: librw.cpp:543

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:156

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

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

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:178

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

gelibspace::get_confirm
bool get_confirm(const char *s, bool expected)
Definition: librw.cpp:17

gelib.h
General functions.

gelibspace::isSpaceChar
bool isSpaceChar(char C)
return true if character C is "space" char –> C == &#39; &#39; &#39;&#39;
Definition: librw.cpp:43

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:518

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:64

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

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:829

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:244

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

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

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

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:148

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

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

gelibspace::SP_skip_space
bool SP_skip_space(const char *&src)
... space == &#39; &#39; and &#39;&#39; characters
Definition: librw.cpp:584

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

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:313

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:709

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

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

gelibspace::FP_scan_line
long FP_scan_line(FILE *stream, char *dest)
scan/copy line == string without &#39; &#39; from stream
Definition: librw.cpp:420

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

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

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

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

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

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

gelibspace::Dvctr
Definition: arrays.h:583

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:537

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:487

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:166

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:212

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:623

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

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

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

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:678

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

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:275

gelibspace::FP_cmp_files
bool FP_cmp_files(const char *file1, const char *file2)
Return false if no differences.
Definition: librw.cpp:230

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:192

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:108

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

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:636

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:202

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

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

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:800

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

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

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:259

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:276

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:363

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

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

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:497

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

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

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

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

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

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:699