gclib/gclib/gcdb.h

#ifndef __GCDB_H
#define __GCDB_H
#include <stdlib.h>
#include <stddef.h>
#include <fcntl.h>
#include <sys/stat.h>
#include "GBase.h"

#if defined(__WIN32__) || defined(WIN32)
  #define PROT_READ  1
  #define PROT_WRITE  2
  #define PROT_READWRITE  3
  #define MAP_SHARED  1
  #define MAP_PRIVATE  2
  #define F_OK 0
  #define R_OK 4
  #define W_OK 2
  #define RW_OK 6

  #if !defined(MAP_FAILED)
  #define MAP_FAILED      ((void *) -1)
  #endif
  void *mmap(char *,size_t,int,int,int,off_t);
  int   munmap(void *,size_t);
#else
  #include <sys/mman.h>
#endif

#define MAX_UINT 0xFFFFFFFFUL


//=====================================================
//-------------     buffer stuff    -------------------
//=====================================================
#define GCDBUFFER_INSIZE 8192
#define GCDBUFFER_OUTSIZE 8192


typedef int (*opfunc)(int, char*, size_t);

//typedef unsigned long gcdb_seek_pos;
typedef off_t gcdb_seek_pos;
typedef unsigned int (*uint_conv)(void*); //uint conversion function pointer
typedef off_t (*offt_conv)(void*); //uint conversion function pointer


//conversion function --> to platform independent uint
extern uint_conv gcvt_uint;
extern offt_conv gcvt_offt;

int endian_test(void);
unsigned int uint32_sun(void* x86int);
unsigned int uint32_x86(void* x86int);
//for file offsets: off_t runtime conversions:
off_t offt_sun(void* offt);
off_t offt_x86(void* offt);


class GCDBuffer {
 public:
  char *x;
  unsigned int p;
  unsigned int n;
  int fd;
  opfunc op;
//methods:
  GCDBuffer() {
    x=NULL;
    fd=0;
    op=NULL;
    n=0;
    //check endianness
    gcvt_uint=(endian_test())? &uint32_sun : &uint32_x86;
    gcvt_offt=(endian_test())? &offt_sun : &offt_x86;
    }
  GCDBuffer(opfunc aop,int afd,char *buf,unsigned int len) {
    //check endianness
    gcvt_uint=(endian_test())? &uint32_sun : &uint32_x86;
    gcvt_offt=(endian_test())? &offt_sun : &offt_x86;
    init(aop, afd, buf, len);
    }
  void init(opfunc aop,int afd,char *buf,unsigned int len) {
     x=buf;
     fd=afd;
     op=aop;
     p=0;
     n=len;
     }
  int  flush();
  int  write_all(char* buf, unsigned int pt);
  int  put(char* buf,unsigned int len);
  int  putalign(char* buf,unsigned int len);
  int  putflush(char* buf,unsigned int len);
  int  puts(char *buf);
  int  putsalign(char *buf);
  int  putsflush(char *buf);
  int  oneRead(char* buf, unsigned int len);
  int  getthis(char* buf,unsigned int len);
  int  get(char* buf,unsigned int len);
  int  bget(char* buf,unsigned int len);
  int  feed();
  char *peek();
  void seek(unsigned int len);
  int copy(GCDBuffer* bin);
};


//=====================================================
//-------------     cdb utils       -------------------
//=====================================================
#ifndef __WIN32__
 extern int errno;
#endif
extern int error_intr;
extern int error_nomem;
extern int error_proto;

//additional data to be appended to the cdb file:
#define CDBMSK_OPT_MULTI    0x00000001
#define CDBMSK_OPT_C        0x00000002
#define CDBMSK_OPT_CADD     0x00000004
#define CDBMSK_OPT_COMPRESS 0x00000008
//creates a compressed version of the database
//uses plenty of unions for ensuring compatibility with
// the old 'CIDX' info structure

//damn, sun and 64bit machines
// align this to 64bit -- so sizeof() is misled!
#pragma pack(4)
// I wish, but stupid gcc 2.95.3 alpha-decosf version does not
// recognize this pragma directive !!?
//
struct cdbInfo {
    uint32 num_keys;
    union {
     uint32 num_records;
     char oldtag[4]; // 'CIDX' for old tag style
     };
    // data file size -- used to be  uint32, now it could be 64bit
    union {
     off_t dbsize;
     uint32 oldnum[2]; //num_keys, num_records
     };
    union {
     uint32 idxflags;
     uint32 old_dbsize;
     };
    union {
     int dbnamelen;
     int old_idxflags;
     };
      // -- the actual db name precedes this fixed-size record
    union {
     char tag[4]; //'CDBX' for new files with LFS
     uint32 old_dbnamelen;
     };
   };
#pragma pack()

extern int cdbInfoSIZE;

void uint32_pack(char *,uint32);
void uint32_pack_big(char *,uint32);
void uint32_unpack(char *,uint32 *);
void uint32_unpack_big(char *,uint32 *);

//=====================================================
//-------------     cdb index       -------------------
//=====================================================

#define CDB_HPLIST 1000

struct cdb_hp { uint32 h; uint32 p; } ;

struct cdb_hplist {
  struct cdb_hp hp[CDB_HPLIST];
  struct cdb_hplist *next;
  int num;
  };

//the index file should always be smaller than 4GB !

class GCdbWrite {
   GCDBuffer* cdbuf;
   char bspace[8192];
   char fname[1024];
   char final[2048];
   uint32 count[256];
   uint32 start[256];
   struct cdb_hplist *head;
   struct cdb_hp *split; /* includes space for hash */
   struct cdb_hp *hash;
   uint32 numentries;
   uint32 pos; //file position
   int posplus(uint32 len);
   int fd; //file descriptor
  public:
  //methods:
   GCdbWrite(int afd); //was: init
   GCdbWrite(char* fname);
   ~GCdbWrite();
   int addbegin(unsigned int keylen,unsigned int datalen);
   int addend(unsigned int keylen,unsigned int datalen,uint32 h);
   int addrec(const char *key,unsigned int keylen,char *data,unsigned int datalen);
   int add(const char *key, char *data, unsigned int datalen);
   int getNumEntries() { return numentries; }
   int finish();
   int close();
   int getfd() { return fd; }
   char* getfile() { return fname; }
};


//=====================================================
//-------------        cdb          -------------------
//=====================================================

#define CDB_HASHSTART 5381

uint32 cdb_hashadd(uint32,unsigned char);
uint32 cdb_hash(const char *,unsigned int);

class GCdbRead {
  uint32 size; // initialized if map is nonzero
  uint32 loop; // number of hash slots searched under this key
  uint32 khash; // initialized if loop is nonzero
  uint32 kpos; // initialized if loop is nonzero
  uint32 hpos; // initialized if loop is nonzero
  uint32 hslots; // initialized if loop is nonzero
  uint32 dpos; // initialized if cdb_findnext() returns 1
  uint32 dlen; // initialized if cdb_findnext() returns 1
  char fname[1024];
  char *map; // 0 if no map is available
  int fd;
 public:
//methods:
  GCdbRead(int fd); //was cdb_init
  GCdbRead(char* afname); //was cdb_init
  ~GCdbRead(); //was cdb_free
  int read(char *,unsigned int,uint32);
  int match(const char *key, unsigned int len, uint32 pos);
  void findstart() { loop =0; }
  int findnext(const char *key,unsigned int len);
  int find(const char *key);
  int datapos() { return dpos; }
  int datalen() { return dlen; }
  int getfd() { return fd; }
  char* getfile() { return fname; }
};

class GReadBuf {
 protected:
  FILE* f;
  uchar* buf;
  int buflen;
  int bufused; //
  int bufpos;
  off_t fpos;
  bool eof;
  bool eob;

  int refill(bool repos=false) {
   //refill the buffer-----------
   if (repos && bufpos==0) return 0; //no need to repos
   if (eof) return 0;
   int fr=0;
   if (repos && bufpos<bufused) {
      int kept=bufused-bufpos;
      memmove((void*)buf, (void*)(buf+bufpos),kept);
      fr=(int)fread((void *)(buf+kept), 1, buflen-kept, f);
      if (fr<buflen-kept) eof=true;
      buf[kept+fr]='\0';
      bufused=kept+fr;
      }
     else {
      fr=(int)fread((void *)buf, 1, buflen, f);
      if (fr<buflen) eof=true;
      buf[fr]='\0'; //only for text record parsers
      bufused=fr;
      }
   if (feof(f)) eof=true;
   if (ferror(f)) {
     GMessage("GReadBuf::refill - error at fread!\n");
     eof=true;
     }
   bufpos=0;
   fpos+=fr; //bytes read from file so far
   return fr;
   }
 public:
  GReadBuf(FILE* fin, int bsize=4096) {
    f=fin;
    buflen=bsize;
    GMALLOC(buf,buflen+1);
    bufpos=0; //current pointer for get function
    bufused=0;
    fpos=0;
    eof=false;
    eob=false;
    refill();
    }
  ~GReadBuf() { GFREE(buf); }
  
  //reads len chars from stream into the outbuf
  //updates bufpos
  //->returns the number of bytes read
  int get(uchar *outbuf, int len) {
    if (eob) return 0;
    int rd=0; //bytes read
    while (!eob && rd<len) {
      int to_read=GMIN((bufused-bufpos),(len-rd));
      memcpy((void*)(outbuf+rd),(void*)(buf+bufpos), to_read);
      bufpos+=to_read;
      rd+=to_read;
      if (bufpos>=bufused) {
        if (eof) eob=true;
           else refill();
        }
      }//while
    return rd;
    }

  uchar* getStr(uchar *outbuf, int len) {
    int rd=get(outbuf,len);
    if (rd==0) return NULL;
      else {
       outbuf[rd]='\0';
       return outbuf;
       }
    }

  // getc equivalent
  int getch() {
    if (eob) return -1;
    int ch=(int)(uchar)buf[bufpos];
    bufpos++;
    if (bufpos>=bufused) {
        if (eof) eob=true;
           else refill();
        }
    return ch;
    }

  //---
  bool isEof() { return eob; }
  bool ended() { return eob; }
  off_t getPos() {
  //returns the virtual file position
  // = the actual file offset of the byte at bufpos
    return fpos-(bufused-bufpos);
    }
  //skip into the stream the specified number of bytes
  int skip(int skiplen) {
   if (eob) return 0;
   int r=0; //the actual number of bytes skipped
   while (skiplen && !eob) {
     int dif=GMIN(bufused-bufpos,skiplen);
     skiplen-=dif;
     bufpos+=dif;
     r+=dif;
     if (bufpos>=bufused) {
       if (eof) { eob=true; return r; }
       refill();
       }
     }
    return r;
   }
  //look ahead without updating the read pointer (bufpos)
  //Cannot peek more than buflen!
  int peek(uchar* outbuf, int len) {
    if (eob) return -1;
    //if (eob || len>buflen) return -1;
    if (len>bufused-bufpos) refill(true);
    int mlen=GMIN((bufused-bufpos),len);
    memcpy((void*)outbuf, (void*)(buf+bufpos), mlen);
    return mlen;
    }

  uchar* peekStr(uchar* outbuf, int len) {
   int rd=peek(outbuf,len);
   if (rd>0) { outbuf[rd]='\0'; return outbuf; }
        else return NULL;
   }
  //looks ahead to check if what follows matches 
  int peekCmp(char* cmpstr, int cmplen=0) {
    if (eob) //GError("GReadBuf::peekcmp error: eob!\n");
         return -2;
    if (!cmplen) cmplen=strlen(cmpstr);
    if (cmplen>bufused-bufpos) {
       refill(true);
       if (cmplen>bufused-bufpos) return -2;
       }
    //use memcmp
    return memcmp((void*)(buf+bufpos), cmpstr, cmplen);
    }
    
};

//circular line buffer, with read-ahead (peeking) capability
class GReadBufLine {   
  protected:
    struct BufLine {
        off_t fpos;
        int len;
        char* chars;
        };
    int bufcap; //total number of lines in the buf array
    int bufidx; // the "current line" index in buf array
    bool isEOF;
    int lno;
    FILE* file;
    off_t filepos; //current file/stream offset for the first char of buf[bufidx]
    BufLine* buf; //array of bufferred lines
    char* readline(int idx);//read line from file into the buffer
    int fillbuf();
    bool isEOB;
  public:
    const char* line(); //gets current line and advances the "current line" pointer
                     //use putLine() to revert/undo this advancement
    off_t fpos(); //gets current line's byte offset in the file
                        // does NOT advance the "current line" pointer
    int   len();  //gets current line's length
                       // does NOT advance the "current line" pointer
    bool isEof() { return isEOB; }
    bool eof() { return isEOB; }
    off_t getfpos() { return fpos(); }
    const char* getline() { return line();  }
    const char* getLine() { return line();  }
    int getLen() { return len();  }
    int linenumber() { return lno; }
    int lineno() { return lno; }
    int getLineNo()  { return lno; }
    void putLine();
    GReadBufLine(FILE* stream, int bcap=20) {
      if (bcap<2) bcap=2; //at least 1 prev line is needed for putLine()
      bufcap=bcap;
      bufidx=-1;
      isEOB=false;
      isEOF=false;
      lno=0;
      GMALLOC(buf, bufcap * sizeof(BufLine));
      for (int i=0;i<bufcap;i++) {
          buf[i].chars=NULL;
          buf[i].fpos=-1;
          buf[i].len=0;
          }
      file=stream;
      fillbuf();
      }
    ~GReadBufLine() {
      for (int i=0;i<bufcap;i++) {
          GFREE(buf[i].chars);
          }
      GFREE(buf);
      }
};

#endif
Revision:	2
Committed:	Mon Mar 22 22:03:27 2010 UTC (10 years, 9 months ago) by gpertea
File size:	12290 byte(s)
Log Message:	added my gclib source files
Line	User	Rev	File contents
1	gpertea	2	#ifndef __GCDB_H
2			#define __GCDB_H
3			#include <stdlib.h>
4			#include <stddef.h>
5			#include <fcntl.h>
6			#include <sys/stat.h>
7			#include "GBase.h"
8
9			#if defined(__WIN32__) \|\| defined(WIN32)
10			#define PROT_READ 1
11			#define PROT_WRITE 2
12			#define PROT_READWRITE 3
13			#define MAP_SHARED 1
14			#define MAP_PRIVATE 2
15			#define F_OK 0
16			#define R_OK 4
17			#define W_OK 2
18			#define RW_OK 6
19
20			#if !defined(MAP_FAILED)
21			#define MAP_FAILED ((void *) -1)
22			#endif
23			void mmap(char ,size_t,int,int,int,off_t);
24			int munmap(void *,size_t);
25			#else
26			#include <sys/mman.h>
27			#endif
28
29			#define MAX_UINT 0xFFFFFFFFUL
30
31
32			//=====================================================
33			//------------- buffer stuff -------------------
34			//=====================================================
35			#define GCDBUFFER_INSIZE 8192
36			#define GCDBUFFER_OUTSIZE 8192
37
38
39			typedef int (opfunc)(int, char, size_t);
40
41			//typedef unsigned long gcdb_seek_pos;
42			typedef off_t gcdb_seek_pos;
43			typedef unsigned int (uint_conv)(void); //uint conversion function pointer
44			typedef off_t (offt_conv)(void); //uint conversion function pointer
45
46
47			//conversion function --> to platform independent uint
48			extern uint_conv gcvt_uint;
49			extern offt_conv gcvt_offt;
50
51			int endian_test(void);
52			unsigned int uint32_sun(void* x86int);
53			unsigned int uint32_x86(void* x86int);
54			//for file offsets: off_t runtime conversions:
55			off_t offt_sun(void* offt);
56			off_t offt_x86(void* offt);
57
58
59			class GCDBuffer {
60			public:
61			char *x;
62			unsigned int p;
63			unsigned int n;
64			int fd;
65			opfunc op;
66			//methods:
67			GCDBuffer() {
68			x=NULL;
69			fd=0;
70			op=NULL;
71			n=0;
72			//check endianness
73			gcvt_uint=(endian_test())? &uint32_sun : &uint32_x86;
74			gcvt_offt=(endian_test())? &offt_sun : &offt_x86;
75			}
76			GCDBuffer(opfunc aop,int afd,char *buf,unsigned int len) {
77			//check endianness
78			gcvt_uint=(endian_test())? &uint32_sun : &uint32_x86;
79			gcvt_offt=(endian_test())? &offt_sun : &offt_x86;
80			init(aop, afd, buf, len);
81			}
82			void init(opfunc aop,int afd,char *buf,unsigned int len) {
83			x=buf;
84			fd=afd;
85			op=aop;
86			p=0;
87			n=len;
88			}
89			int flush();
90			int write_all(char* buf, unsigned int pt);
91			int put(char* buf,unsigned int len);
92			int putalign(char* buf,unsigned int len);
93			int putflush(char* buf,unsigned int len);
94			int puts(char *buf);
95			int putsalign(char *buf);
96			int putsflush(char *buf);
97			int oneRead(char* buf, unsigned int len);
98			int getthis(char* buf,unsigned int len);
99			int get(char* buf,unsigned int len);
100			int bget(char* buf,unsigned int len);
101			int feed();
102			char *peek();
103			void seek(unsigned int len);
104			int copy(GCDBuffer* bin);
105			};
106
107
108			//=====================================================
109			//------------- cdb utils -------------------
110			//=====================================================
111			#ifndef __WIN32__
112			extern int errno;
113			#endif
114			extern int error_intr;
115			extern int error_nomem;
116			extern int error_proto;
117
118			//additional data to be appended to the cdb file:
119			#define CDBMSK_OPT_MULTI 0x00000001
120			#define CDBMSK_OPT_C 0x00000002
121			#define CDBMSK_OPT_CADD 0x00000004
122			#define CDBMSK_OPT_COMPRESS 0x00000008
123			//creates a compressed version of the database
124			//uses plenty of unions for ensuring compatibility with
125			// the old 'CIDX' info structure
126
127			//damn, sun and 64bit machines
128			// align this to 64bit -- so sizeof() is misled!
129			#pragma pack(4)
130			// I wish, but stupid gcc 2.95.3 alpha-decosf version does not
131			// recognize this pragma directive !!?
132			//
133			struct cdbInfo {
134			uint32 num_keys;
135			union {
136			uint32 num_records;
137			char oldtag[4]; // 'CIDX' for old tag style
138			};
139			// data file size -- used to be uint32, now it could be 64bit
140			union {
141			off_t dbsize;
142			uint32 oldnum[2]; //num_keys, num_records
143			};
144			union {
145			uint32 idxflags;
146			uint32 old_dbsize;
147			};
148			union {
149			int dbnamelen;
150			int old_idxflags;
151			};
152			// -- the actual db name precedes this fixed-size record
153			union {
154			char tag[4]; //'CDBX' for new files with LFS
155			uint32 old_dbnamelen;
156			};
157			};
158			#pragma pack()
159
160			extern int cdbInfoSIZE;
161
162			void uint32_pack(char *,uint32);
163			void uint32_pack_big(char *,uint32);
164			void uint32_unpack(char ,uint32 );
165			void uint32_unpack_big(char ,uint32 );
166
167			//=====================================================
168			//------------- cdb index -------------------
169			//=====================================================
170
171			#define CDB_HPLIST 1000
172
173			struct cdb_hp { uint32 h; uint32 p; } ;
174
175			struct cdb_hplist {
176			struct cdb_hp hp[CDB_HPLIST];
177			struct cdb_hplist *next;
178			int num;
179			};
180
181			//the index file should always be smaller than 4GB !
182
183			class GCdbWrite {
184			GCDBuffer* cdbuf;
185			char bspace[8192];
186			char fname[1024];
187			char final[2048];
188			uint32 count[256];
189			uint32 start[256];
190			struct cdb_hplist *head;
191			struct cdb_hp split; / includes space for hash */
192			struct cdb_hp *hash;
193			uint32 numentries;
194			uint32 pos; //file position
195			int posplus(uint32 len);
196			int fd; //file descriptor
197			public:
198			//methods:
199			GCdbWrite(int afd); //was: init
200			GCdbWrite(char* fname);
201			~GCdbWrite();
202			int addbegin(unsigned int keylen,unsigned int datalen);
203			int addend(unsigned int keylen,unsigned int datalen,uint32 h);
204			int addrec(const char key,unsigned int keylen,char data,unsigned int datalen);
205			int add(const char key, char data, unsigned int datalen);
206			int getNumEntries() { return numentries; }
207			int finish();
208			int close();
209			int getfd() { return fd; }
210			char* getfile() { return fname; }
211			};
212
213
214			//=====================================================
215			//------------- cdb -------------------
216			//=====================================================
217
218			#define CDB_HASHSTART 5381
219
220			uint32 cdb_hashadd(uint32,unsigned char);
221			uint32 cdb_hash(const char *,unsigned int);
222
223			class GCdbRead {
224			uint32 size; // initialized if map is nonzero
225			uint32 loop; // number of hash slots searched under this key
226			uint32 khash; // initialized if loop is nonzero
227			uint32 kpos; // initialized if loop is nonzero
228			uint32 hpos; // initialized if loop is nonzero
229			uint32 hslots; // initialized if loop is nonzero
230			uint32 dpos; // initialized if cdb_findnext() returns 1
231			uint32 dlen; // initialized if cdb_findnext() returns 1
232			char fname[1024];
233			char *map; // 0 if no map is available
234			int fd;
235			public:
236			//methods:
237			GCdbRead(int fd); //was cdb_init
238			GCdbRead(char* afname); //was cdb_init
239			~GCdbRead(); //was cdb_free
240			int read(char *,unsigned int,uint32);
241			int match(const char *key, unsigned int len, uint32 pos);
242			void findstart() { loop =0; }
243			int findnext(const char *key,unsigned int len);
244			int find(const char *key);
245			int datapos() { return dpos; }
246			int datalen() { return dlen; }
247			int getfd() { return fd; }
248			char* getfile() { return fname; }
249			};
250
251			class GReadBuf {
252			protected:
253			FILE* f;
254			uchar* buf;
255			int buflen;
256			int bufused; //
257			int bufpos;
258			off_t fpos;
259			bool eof;
260			bool eob;
261
262			int refill(bool repos=false) {
263			//refill the buffer-----------
264			if (repos && bufpos==0) return 0; //no need to repos
265			if (eof) return 0;
266			int fr=0;
267			if (repos && bufpos<bufused) {
268			int kept=bufused-bufpos;
269			memmove((void)buf, (void)(buf+bufpos),kept);
270			fr=(int)fread((void *)(buf+kept), 1, buflen-kept, f);
271			if (fr<buflen-kept) eof=true;
272			buf[kept+fr]='\0';
273			bufused=kept+fr;
274			}
275			else {
276			fr=(int)fread((void *)buf, 1, buflen, f);
277			if (fr<buflen) eof=true;
278			buf[fr]='\0'; //only for text record parsers
279			bufused=fr;
280			}
281			if (feof(f)) eof=true;
282			if (ferror(f)) {
283			GMessage("GReadBuf::refill - error at fread!\n");
284			eof=true;
285			}
286			bufpos=0;
287			fpos+=fr; //bytes read from file so far
288			return fr;
289			}
290			public:
291			GReadBuf(FILE* fin, int bsize=4096) {
292			f=fin;
293			buflen=bsize;
294			GMALLOC(buf,buflen+1);
295			bufpos=0; //current pointer for get function
296			bufused=0;
297			fpos=0;
298			eof=false;
299			eob=false;
300			refill();
301			}
302			~GReadBuf() { GFREE(buf); }
303
304			//reads len chars from stream into the outbuf
305			//updates bufpos
306			//->returns the number of bytes read
307			int get(uchar *outbuf, int len) {
308			if (eob) return 0;
309			int rd=0; //bytes read
310			while (!eob && rd<len) {
311			int to_read=GMIN((bufused-bufpos),(len-rd));
312			memcpy((void)(outbuf+rd),(void)(buf+bufpos), to_read);
313			bufpos+=to_read;
314			rd+=to_read;
315			if (bufpos>=bufused) {
316			if (eof) eob=true;
317			else refill();
318			}
319			}//while
320			return rd;
321			}
322
323			uchar* getStr(uchar *outbuf, int len) {
324			int rd=get(outbuf,len);
325			if (rd==0) return NULL;
326			else {
327			outbuf[rd]='\0';
328			return outbuf;
329			}
330			}
331
332			// getc equivalent
333			int getch() {
334			if (eob) return -1;
335			int ch=(int)(uchar)buf[bufpos];
336			bufpos++;
337			if (bufpos>=bufused) {
338			if (eof) eob=true;
339			else refill();
340			}
341			return ch;
342			}
343
344			//---
345			bool isEof() { return eob; }
346			bool ended() { return eob; }
347			off_t getPos() {
348			//returns the virtual file position
349			// = the actual file offset of the byte at bufpos
350			return fpos-(bufused-bufpos);
351			}
352			//skip into the stream the specified number of bytes
353			int skip(int skiplen) {
354			if (eob) return 0;
355			int r=0; //the actual number of bytes skipped
356			while (skiplen && !eob) {
357			int dif=GMIN(bufused-bufpos,skiplen);
358			skiplen-=dif;
359			bufpos+=dif;
360			r+=dif;
361			if (bufpos>=bufused) {
362			if (eof) { eob=true; return r; }
363			refill();
364			}
365			}
366			return r;
367			}
368			//look ahead without updating the read pointer (bufpos)
369			//Cannot peek more than buflen!
370			int peek(uchar* outbuf, int len) {
371			if (eob) return -1;
372			//if (eob \|\| len>buflen) return -1;
373			if (len>bufused-bufpos) refill(true);
374			int mlen=GMIN((bufused-bufpos),len);
375			memcpy((void)outbuf, (void)(buf+bufpos), mlen);
376			return mlen;
377			}
378
379			uchar* peekStr(uchar* outbuf, int len) {
380			int rd=peek(outbuf,len);
381			if (rd>0) { outbuf[rd]='\0'; return outbuf; }
382			else return NULL;
383			}
384			//looks ahead to check if what follows matches
385			int peekCmp(char* cmpstr, int cmplen=0) {
386			if (eob) //GError("GReadBuf::peekcmp error: eob!\n");
387			return -2;
388			if (!cmplen) cmplen=strlen(cmpstr);
389			if (cmplen>bufused-bufpos) {
390			refill(true);
391			if (cmplen>bufused-bufpos) return -2;
392			}
393			//use memcmp
394			return memcmp((void*)(buf+bufpos), cmpstr, cmplen);
395			}
396
397			};
398
399			//circular line buffer, with read-ahead (peeking) capability
400			class GReadBufLine {
401			protected:
402			struct BufLine {
403			off_t fpos;
404			int len;
405			char* chars;
406			};
407			int bufcap; //total number of lines in the buf array
408			int bufidx; // the "current line" index in buf array
409			bool isEOF;
410			int lno;
411			FILE* file;
412			off_t filepos; //current file/stream offset for the first char of buf[bufidx]
413			BufLine* buf; //array of bufferred lines
414			char* readline(int idx);//read line from file into the buffer
415			int fillbuf();
416			bool isEOB;
417			public:
418			const char* line(); //gets current line and advances the "current line" pointer
419			//use putLine() to revert/undo this advancement
420			off_t fpos(); //gets current line's byte offset in the file
421			// does NOT advance the "current line" pointer
422			int len(); //gets current line's length
423			// does NOT advance the "current line" pointer
424			bool isEof() { return isEOB; }
425			bool eof() { return isEOB; }
426			off_t getfpos() { return fpos(); }
427			const char* getline() { return line(); }
428			const char* getLine() { return line(); }
429			int getLen() { return len(); }
430			int linenumber() { return lno; }
431			int lineno() { return lno; }
432			int getLineNo() { return lno; }
433			void putLine();
434			GReadBufLine(FILE* stream, int bcap=20) {
435			if (bcap<2) bcap=2; //at least 1 prev line is needed for putLine()
436			bufcap=bcap;
437			bufidx=-1;
438			isEOB=false;
439			isEOF=false;
440			lno=0;
441			GMALLOC(buf, bufcap * sizeof(BufLine));
442			for (int i=0;i<bufcap;i++) {
443			buf[i].chars=NULL;
444			buf[i].fpos=-1;
445			buf[i].len=0;
446			}
447			file=stream;
448			fillbuf();
449			}
450			~GReadBufLine() {
451			for (int i=0;i<bufcap;i++) {
452			GFREE(buf[i].chars);
453			}
454			GFREE(buf);
455			}
456			};
457
458			#endif