textfile.h

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef FILE_TEXTFILE_H
#define FILE_TEXTFILE_H

#include "fastlib/base/base.h"
#include "fastlib/col/col_string.h"

#include <cstdio>
#include <ctype.h>
#include <stdarg.h>

class TextLineReader {
  FORBID_ACCIDENTAL_COPIES(TextLineReader);
  
 private:
  FILE *f_;
  String line_;
  int line_num_;
  bool has_line_;
  
 public:
  TextLineReader() {
    f_ = NULL;
  }
  
  ~TextLineReader() {
    if (f_) {
      ::fclose(f_);
    }
  }
  
  success_t Open(const char *fname);
  
  void Close() {
    (void)fclose(f_);
    f_ = NULL;
  }
  
  bool MoreLines() {
    return has_line_;
  }

  int line_num() const {
    return line_num_;
  }
  
  String& Peek() {
    return line_;
  }
  
  const String& Peek() const {
    return line_;
  }
  
  bool Gobble();

  COMPILER_PRINTF(2, 3)
  void Error(const char *msg, ...);
  
 private:
  char *ReadLine_();
};

class TextTokenizer {
  FORBID_ACCIDENTAL_COPIES(TextTokenizer);
 public:
  enum TokenType {
    INVALID = -1,
    END,
    PUNCT,
    IDENTIFIER,
    STRING,
    DOUBLE,
    INTEGER
  };
  
  enum Features {
    WANT_NEWLINE = 0x01
  };
 
 private:
  FILE *f_;
  String next_;
  TokenType next_type_;
  String cur_;
  TokenType cur_type_;
  const char *comment_start_;
  const char *ident_extra_;
  int features_;
  int line_;
  
 public:
  TextTokenizer() {
    f_ = NULL;
  }
  ~TextTokenizer() {
    if (unlikely(f_ != NULL)) {
      (void) fclose(f_);
    }
    DEBUG_POISON_PTR(f_);
  }
  
  success_t Open(const char *fname,
      const char *comment_chars = "", const char *ident_extra = "",
      int features = 0);

  
  const String& Peek() const {
    return next_;
  }
  
  TokenType PeekType() const {
    return next_type_;
  }
  
  const String& Current() const {
    return cur_;
  }
  
  TokenType CurrentType() const {
    return cur_type_;
  }
  
  void Gobble();
  
  bool MoreTokens() const {
    return next_type_ != END;
  }
  
  bool Match(const char *exact) {
    if (next_ == exact) {
      Gobble();
      return true;
    } else {
      return false;
    }
  }
  
  bool MatchNoCase(const char *str) {
    if (next_.EqualsNoCase(str)) {
      Gobble();
      return true;
    } else {
      return false;
    }
  }
  
  bool MatchInteger() {
    return MatchType(INTEGER);
  }
  
  bool MatchDouble() {
    return MatchType(DOUBLE);
  }
  
  bool MatchNumber() {
    return MatchInteger() || MatchDouble();
  }
  
  bool MatchIdentifier() {
    return MatchType(IDENTIFIER);
  }
  
  bool MatchQuasiIdentifier() {
    return MatchIdentifier() || MatchNumber();
  }
  
  bool MatchString() {
    return MatchType(STRING);
  }
  
  bool MatchPunct() {
    return MatchType(PUNCT);
  }
  
  bool MatchType(TokenType type) {
    if (next_type_ == type) {
      Gobble();
      return true;
    } else {
      return false;
    }
  }
  
  int line() const {
    return line_;
  }

  COMPILER_PRINTF(2, 3)
  void Error(const char *msg, ...);
  
 private:
  int GetChar_() {
    return ::getc(f_);
  }
  
  void Unget_(int c) {
    ::ungetc(c, f_);
  }
  
  bool IsEOF_() {
    return ::feof(f_);
  }
  
  char Skip_(ArrayList<char> *token);
  
  char NextChar_(ArrayList<char> *token);

  char NextChar_();
  
  void UndoNextChar_(ArrayList<char> *token);
  
  void Error_(const char *msg, const ArrayList<char>& token);
  
  bool isident_begin_(int c) const {
    return isalpha(c) || unlikely(c == '_');
  }
  
  bool isident_rest_(int c) const {
    return isalnum(c) || unlikely(c == '_') || (c != 0 && strchr(ident_extra_, c));
  }

  void ScanNumber_(char c, ArrayList<char> *token);

  void ScanString_(char ending, ArrayList<char> *token);
  
  void Scan_(ArrayList<char> *token);
};

class TextWriter {
  FORBID_ACCIDENTAL_COPIES(TextWriter);
  
 private:
  FILE *f_;
  
 public:
  TextWriter() {
    f_ = NULL;
  }
  
  ~TextWriter() {
    if (f_) {
      MUST_PASS(SUCCESS_FROM_C(::fclose(f_)));
    }
    DEBUG_POISON_PTR(f_);
  }
  
  success_t Open(const char *fname) {
    f_ = ::fopen(fname, "w");
    return (unlikely(!f_)) ? SUCCESS_FAIL : SUCCESS_PASS;
  }
  
  success_t Close() {
    int rv = fclose(f_);
    f_ = NULL;
    return unlikely(rv < 0) ? SUCCESS_FAIL : SUCCESS_PASS;
  }
  
  success_t Printf(const char *format, ...);
  
  success_t Write(const char *s) {
    return SUCCESS_FROM_C(fputs(s, f_));
  }
  
  success_t Write(int i) {
    return SUCCESS_FROM_C(fprintf(f_, "%d", i));
  }
  
  success_t Write(unsigned int i) {
    return SUCCESS_FROM_C(fprintf(f_, "%u", i));
  }

  success_t Write(long i) {
    return SUCCESS_FROM_C(fprintf(f_, "%ld", i));
  }
  
  success_t Write(unsigned long i) {
    return SUCCESS_FROM_C(fprintf(f_, "%lu", i));
  }
  
  success_t Write(long long i) {
    return SUCCESS_FROM_C(fprintf(f_, "%lld", i));
  }
  
  success_t Write(unsigned long long i) {
    return SUCCESS_FROM_C(fprintf(f_, "%llu", i));
  }
  
  success_t Write(double d) {
    return SUCCESS_FROM_C(fprintf(f_, "%.15e", d));
  }
};

#endif