build/re2c/stream_lc.h

   1 /*
   2  Author: Marcus Boerger <helly@users.sourceforge.net>
   3 */
   4
   5 /* $Id: stream_lc.h 858 2008-04-03 20:53:44Z helly $ */
   6
   7 #ifndef _stream_lc_h
   8 #define _stream_lc_h
   9
  10 #include <iosfwd>
  11 #include <fstream>
  12 #include <assert.h>
  13 #include <stdio.h>
  14
  15 namespace re2c
  16 {
  17
  18 template<class _E, class _Tr = std::char_traits<_E> >
  19 class basic_null_streambuf
  20         : public std::basic_streambuf<_E, _Tr>
  21 {
  22 public:
  23         basic_null_streambuf()
  24                 : std::basic_streambuf<_E, _Tr>()
  25         {
  26         }
  27 };
  28
  29 typedef basic_null_streambuf<char> null_streambuf;
  30
  31 template<class _E, class _Tr = std::char_traits<_E> >
  32 class basic_null_stream
  33         : public std::basic_ostream<_E, _Tr>
  34 {
  35 public:
  36         basic_null_stream()
  37                 : std::basic_ostream<_E, _Tr>(null_buf = new basic_null_streambuf<_E, _Tr>())
  38         {
  39         }
  40
  41         virtual ~basic_null_stream()
  42         {
  43                 delete null_buf;
  44         }
  45
  46         basic_null_stream& put(_E)
  47         {
  48                 // nothing to do
  49                 return *this;
  50         }
  51
  52         basic_null_stream& write(const _E *, std::streamsize)
  53         {
  54                 // nothing to do
  55                 return *this;
  56         }
  57
  58 protected:
  59         basic_null_streambuf<_E, _Tr> * null_buf;
  60 };
  61
  62 typedef basic_null_stream<char> null_stream;
  63
  64 class line_number
  65 {
  66 public:
  67         virtual ~line_number()
  68         {
  69         }
  70
  71         virtual uint get_line() const = 0;
  72 };
  73
  74 template<class _E, class _Tr = std::char_traits<_E> >
  75 class basic_filebuf_lc
  76         : public std::basic_streambuf<_E, _Tr>
  77         , public line_number
  78 {
  79 public:
  80         typedef std::basic_streambuf<_E, _Tr> _Mybase;
  81         typedef basic_filebuf_lc<_E, _Tr> _Myt;
  82         typedef _E char_type;
  83         typedef _Tr traits_type;
  84         typedef typename _Tr::int_type int_type;
  85         typedef typename _Tr::pos_type pos_type;
  86         typedef typename _Tr::off_type off_type;
  87
  88         basic_filebuf_lc(FILE *_fp = 0)
  89                 : _Mybase()
  90                 , fp(_fp)
  91                 , must_close(false)
  92                 , fline(1)
  93         {
  94         }
  95
  96         virtual ~basic_filebuf_lc()
  97         {
  98                 sync();
  99                 if (must_close)
 100                 {
 101                         close();
 102                 }
 103         }
 104
 105         uint get_line() const
 106         {
 107                 return fline + 1;
 108         }
 109
 110         bool is_open() const
 111         {
 112                 return fp != 0;
 113         }
 114
 115         _Myt* open(const char *filename, std::ios_base::openmode mode = std::ios_base::out)
 116         {
 117                 if (fp != 0)
 118                 {
 119                         return 0;
 120                 }
 121                 const char * fmode = (mode & std::ios_base::out)
 122                                    ? "wt"
 123                                    : "rt";
 124                 if ((fp = fopen(filename, fmode)) == 0)
 125                 {
 126                         return 0;
 127                 }
 128
 129                 must_close = true;
 130                 return this;
 131         }
 132
 133         _Myt* open(FILE * _fp)
 134         {
 135                 if (fp != 0)
 136                 {
 137                         return 0;
 138                 }
 139                 fp = _fp;
 140                 must_close = false;
 141                 return this;
 142         }
 143
 144         _Myt* close()
 145         {
 146                 sync();
 147
 148                 if (fp == 0 || fclose(fp) != 0)
 149                 {
 150                         fp = 0;
 151                         return 0;
 152                 }
 153                 else
 154                 {
 155                         fp = 0;
 156                         return this;
 157                 }
 158         }
 159
 160 protected:
 161
 162         virtual int_type overflow(int_type c = _Tr::eof())
 163         {
 164                 if (c == '\n')
 165                 {
 166                         ++fline;
 167                 }
 168                 if (_Tr::eq_int_type(_Tr::eof(), c))
 169                 {
 170                         return _Tr::not_eof(c);
 171                 }
 172                 else
 173                 {
 174                         buffer += _Tr::to_char_type(c);
 175                         return c;
 176                 }
 177         }
 178
 179         virtual int_type pbackfail(int_type c = _Tr::eof())
 180         {
 181                 assert(0);
 182                 c = 0;
 183                 return _Tr::eof();
 184         }
 185
 186         virtual int_type underflow() // don't point past it
 187         {
 188                 int c;
 189
 190                 if (buffer.length())
 191                 {
 192                         return buffer[0];
 193                 }
 194                 if (fp == 0 || ((c = fgetc(fp)) == EOF))
 195                 {
 196                         return _Tr::eof();
 197                 }
 198                 buffer += (char)c;
 199                 return c;
 200         }
 201
 202         virtual int_type uflow() // point past it
 203         {
 204                 int c;
 205
 206                 if (buffer.length())
 207                 {
 208                         c = buffer[0];
 209                         buffer.erase(0, 1);
 210                         return c;
 211                 }
 212                 if (fp == 0 || ((c = fgetc(fp)) == EOF))
 213                 {
 214                         return _Tr::eof();
 215                 }
 216                 else if (c == '\n')
 217                 {
 218                         ++fline;
 219                 }
 220                 return c;
 221         }
 222
 223 #if 0
 224         virtual std::streamsize xsgetn(_E* buf, std::streamsize n)
 225         {
 226                 std::streamsize r = 0;
 227                 while(n--)
 228                 {
 229                         int_type c = underflow();
 230                         if (_Tr::eq_int_type(_Tr::eof(), c))
 231                         {
 232                                 break;
 233                         }
 234                         buf[r++] = c;
 235                 }
 236                 buf[r] = '\0';
 237                 return r;
 238         }
 239 #endif
 240
 241         virtual pos_type seekoff(off_type off, std::ios_base::seekdir whence,
 242                 std::ios_base::openmode = (std::ios_base::openmode)(std::ios_base::in | std::ios_base::out))
 243         {
 244                 return fseek(fp, (long)off, whence);
 245         }
 246
 247         virtual pos_type seekpos(pos_type fpos,
 248                 std::ios_base::openmode = (std::ios_base::openmode)(std::ios_base::in | std::ios_base::out))
 249         {
 250                 return fseek(fp, (long)fpos, SEEK_SET);
 251         }
 252
 253         virtual _Mybase * setbuf(_E *, std::streamsize)
 254         {
 255                 assert(0);
 256                 return this;
 257         }
 258
 259         virtual int sync()
 260         {
 261                 if (buffer.length() != 0) {
 262                         fwrite(buffer.c_str(), sizeof(_E), buffer.length(), fp);
 263                 }
 264                 buffer.clear();
 265                 return fp == 0
 266                         || _Tr::eq_int_type(_Tr::eof(), overflow())
 267                         || 0 <= fflush(fp) ? 0 : -1;
 268         }
 269
 270         virtual std::streamsize xsputn(const _E *buf, std::streamsize cnt)
 271         {
 272                 if (buffer.length() != 0) {
 273                         fwrite(buffer.c_str(), sizeof(_E), buffer.length(), fp);
 274                 }
 275                 buffer.clear();
 276                 /*fline += std::count(buf, buf + cnt, '\n');*/
 277                 for (std::streamsize pos = 0; pos < cnt; ++pos)
 278                 {
 279                         if (buf[pos] == '\n')
 280                         {
 281                                 ++fline;
 282                         }
 283                 }
 284                 if (cnt != 0) {
 285                         return fwrite(buf, sizeof(_E), cnt, fp);
 286                 } else {
 287                         return 0;
 288                 }
 289         }
 290
 291 private:
 292
 293         FILE * fp;
 294         bool   must_close;
 295         uint   fline;
 296         std::basic_string<_E, _Tr> buffer;
 297 };
 298
 299 typedef basic_filebuf_lc<char> filebuf_lc;
 300
 301 template<
 302         class _E,
 303         class _BaseStream,
 304         std::ios_base::openmode  _DefOpenMode,
 305         class _Tr = std::char_traits<_E> >
 306 class basic_fstream_lc
 307         : public _BaseStream
 308         , public line_number
 309 {
 310 public:
 311         typedef basic_fstream_lc<_E, _BaseStream, _DefOpenMode, _Tr> _Myt;
 312         typedef std::basic_ios<_E, _Tr> _Myios;
 313         typedef _BaseStream _Mybase;
 314         typedef basic_filebuf_lc<_E, _Tr> _Mybuf;
 315
 316         basic_fstream_lc()
 317                 : _Mybase(mybuf = new _Mybuf())
 318         {
 319         }
 320
 321         virtual ~basic_fstream_lc()
 322         {
 323                 delete mybuf;
 324         }
 325
 326         bool is_open() const
 327         {
 328                 return mybuf->is_open();
 329         }
 330
 331         _Myt& open(const char * filename, std::ios_base::openmode mode = _DefOpenMode)
 332         {
 333                 if ((mode & _DefOpenMode) == 0 || mybuf->open(filename, mode) == 0)
 334                 {
 335                         _Myios::setstate(std::ios_base::failbit);
 336                 }
 337                 return *this;
 338         }
 339
 340         _Myt& open(FILE *fp)
 341         {
 342                 if (mybuf->open(fp) == 0)
 343                 {
 344                         _Myios::setstate(std::ios_base::failbit);
 345                 }
 346                 return *this;
 347         }
 348
 349         void close()
 350         {
 351                 if (mybuf->close() == 0)
 352                 {
 353                         _Myios::setstate(std::ios_base::failbit);
 354                 }
 355         }
 356
 357         uint get_line() const
 358         {
 359                 return mybuf->get_line();
 360         }
 361
 362 protected:
 363         mutable _Mybuf *mybuf;
 364 };
 365
 366 template<class _E, class _Tr = std::char_traits<_E> >
 367 class basic_ofstream_lc
 368         : public basic_fstream_lc<_E, std::basic_ostream<_E, _Tr>, std::ios_base::out, _Tr>
 369 {
 370 };
 371
 372 typedef basic_ofstream_lc<char> ofstream_lc;
 373
 374 template<class _E, class _Tr = std::char_traits<_E> >
 375 class basic_ifstream_lc
 376         : public basic_fstream_lc<_E, std::basic_istream<_E, _Tr>, std::ios_base::in, _Tr>
 377 {
 378 };
 379
 380 typedef basic_ifstream_lc<char> ifstream_lc;
 381
 382 class file_info
 383 {
 384 public:
 385
 386         static std::string escape(const std::string& _str)
 387         {
 388                 std::string str(_str);
 389                 size_t l = str.length();
 390                 for (size_t p = 0; p < l; ++p)
 391                 {
 392                         if (str[p] == '\\')
 393                         {
 394                                 str.insert(++p, "\\");
 395                                 ++l;
 396                         }
 397                 }
 398                 return str;
 399         }
 400
 401         file_info()
 402                 : ln(NULL)
 403         {
 404         }
 405
 406         file_info(const std::string& _fname, const line_number* _ln, bool _escape = true)
 407                 : fname(_escape ? escape(_fname) : _fname)
 408                 , ln(_ln)
 409         {
 410         }
 411
 412         file_info(const file_info& oth, const line_number* _ln = NULL)
 413                 : fname(oth.fname)
 414                 , ln(_ln)
 415         {
 416         }
 417
 418         file_info& operator = (const file_info& oth)
 419         {
 420                 *(const_cast<std::string*>(&this->fname)) = oth.fname;
 421                 ln = oth.ln;
 422                 return *this;
 423         }
 424
 425         void set_fname(const std::string& _fname)
 426         {
 427                 *(const_cast<std::string*>(&this->fname)) = _fname;
 428         }
 429
 430         const std::string  fname;
 431         const line_number* ln;
 432 };
 433
 434 std::ostream& operator << (std::ostream& o, const file_info& li);
 435
 436 } // end namespace re2c
 437
 438 #endif /* _stream_lc_h */