TextInput.h

Go to the documentation of this file.

#ifndef G3D_TextInput_h
#define G3D_TextInput_h

#include "G3D/platform.h"
#include "G3D/Array.h"
#include "G3D/Set.h"
#include "G3D/ParseError.h"
#include <string>
#include <queue>
#include <ctype.h>
#include <stdio.h>

namespace G3D {

class Token {
public:

 enum ExtendedType {
 DOUBLE_QUOTED_TYPE, 
 SINGLE_QUOTED_TYPE, 
 SYMBOL_TYPE,
 FLOATING_POINT_TYPE, 
 INTEGER_TYPE,
 BOOLEAN_TYPE,
 LINE_COMMENT_TYPE,
 BLOCK_COMMENT_TYPE,
 NEWLINE_TYPE,
 END_TYPE
 };

 enum Type {
 STRING = DOUBLE_QUOTED_TYPE, 
 SYMBOL = SYMBOL_TYPE, 
 NUMBER = FLOATING_POINT_TYPE, 
 BOOLEAN = BOOLEAN_TYPE,
 COMMENT = LINE_COMMENT_TYPE,
 NEWLINE = NEWLINE_TYPE,
 END = END_TYPE
 };

private:

 friend class TextInput;

 std::string _string;

 bool _bool;
 int _line;
 int _character;
 uint64 _bytePosition;
 Type _type;
 ExtendedType _extendedType;

public:

 Token() :
 _string(""),
 _bool(false),
 _line(0), 
 _character(0), 
 _bytePosition(0),
 _type(END), 
 _extendedType(END_TYPE) {}

 Token(Type t, ExtendedType e, const std::string& s, int L, int c, uint64 byte)
 : _string(s), _bool(false), _line(L), _character(c), _bytePosition(byte), _type(t), _extendedType(e) {}

 Token(Type t, ExtendedType e, const std::string& s, bool b, int L, int c, uint64 byte)
 : _string(s), _bool(b), _line(L), _character(c), _bytePosition(byte), _type(t), _extendedType(e) {}

 Type type() const {
 return _type;
 }

 ExtendedType extendedType() const {
 return _extendedType;
 }

 const std::string& string() const {
 return _string;
 }

 bool boolean() const {
 return _bool;
 }

 int line() const {
 return _line;
 }

 int character() const {
 return _character;
 }

 uint64 bytePosition() const {
 return _bytePosition;
 }

 double number() const;
};


class TextInput {
public:
 static double parseNumber(const std::string& _string);

 static bool parseBoolean(const std::string& _string);


 class Settings {
 public:
 bool cppBlockComments;

 bool cppLineComments;

 bool otherLineComments;

 bool escapeSequencesInStrings;

 char otherCommentCharacter;

 char otherCommentCharacter2;

 bool generateCommentTokens;

 bool generateNewlineTokens;

 bool signedNumbers;

 bool singleQuotedStrings;

 char singleQuoteCharacter;
 
 std::string sourceFileName;

 
 int startingLineNumberOffset;

 bool msvcFloatSpecials;

 bool simpleFloatSpecials;

 bool proofSymbols;

 bool caseSensitive;

 Set<std::string> trueSymbols;

 Set<std::string> falseSymbols;

 Settings();
 };
 
private:

 Array<Settings> settingsStack;

 std::deque<Token> stack;

 Array<char> buffer;

 int currentCharOffset;

 int lineNumber;

 int charNumber;

 Settings options;
 
 void init();

 int eatInputChar();

 int peekInputChar(int distance = 0);

 inline int eatAndPeekInputChar() {
 eatInputChar();
 return peekInputChar(0);
 }

 void nextToken(Token& t);

 void parseQuotedString(unsigned char delimiter, Token& t);

 void initFromString(const char* str, int len, const Settings& settings);

public:

 class TokenException : public ParseError {
 public:
 std::string sourceFile;

 virtual ~TokenException() {}

 protected:
 
 TokenException(
 const std::string& src,
 int ln,
 int ch);

 };

 class BadMSVCSpecial : public TokenException {
 public:

 BadMSVCSpecial(
 const std::string& src,
 int ln,
 int ch);
 };

 class WrongTokenType : public TokenException {
 public:
 Token::Type expected;
 Token::Type actual;

 WrongTokenType(
 const std::string& src,
 int ln,
 int ch,
 Token::Type e,
 Token::Type a);
 };

 class WrongSymbol : public TokenException {
 public:
 std::string expected;
 std::string actual;

 WrongSymbol(
 const std::string& src,
 int ln,
 int ch,
 const std::string& e,
 const std::string& a);
 };


 class WrongString : public TokenException {
 public:
 std::string expected;
 std::string actual;

 WrongString(
 const std::string& src,
 int ln,
 int ch,
 const std::string& e,
 const std::string& a);
 };

 TextInput(const std::string& filename, const Settings& settings = Settings());

 enum FS {FROM_STRING};
 TextInput(FS fs, const std::string& str, const Settings& settings = Settings());

 TextInput(FS fs, const char* str, size_t strLen, const Settings& settings = Settings());

 bool hasMore();

 void pushSettings(const Settings& settings) {
 settingsStack.push(options);
 options = settings;
 }

 void popSettings() {
 options = settingsStack.pop();
 }

 Token read();

 void read(Token& t);

 Token readSignificant();

 double readNumber();

 int readInteger();

 bool readBoolean();

 Token readStringToken();

 std::string readString();

 void readString(const std::string& s);

 std::string readUntilNewlineAsString();

 std::string readUntilDelimiterAsString(const char delimiter1, const char delimiter2 = '\0');

 Token readCommentToken();

 std::string readComment();

 void readComment(const std::string& s);

 Token readNewlineToken();

 std::string readNewline();

 void readNewline(const std::string& s);

 Token readSymbolToken();

 void readSymbolToken(Token& t);

 std::string readSymbol();

 void readSymbol(const std::string& symbol);


 void readSymbols(const std::string& s1, const std::string& s2) {
 readSymbol(s1);
 readSymbol(s2);
 }

 void readSymbols(
 const std::string& s1, 
 const std::string& s2, 
 const std::string& s3) {
 readSymbol(s1);
 readSymbol(s2);
 readSymbol(s3);
 }

 void readSymbols(
 const std::string& s1, 
 const std::string& s2, 
 const std::string& s3, 
 const std::string& s4) {
 readSymbol(s1);
 readSymbol(s2);
 readSymbol(s3);
 readSymbol(s4);
 }

 Token peek();

 int peekLineNumber();

 int peekCharacterNumber();

 void push(const Token& t);

 const std::string& filename() const;
};

void deserialize(bool& b, TextInput& ti);
void deserialize(int& b, TextInput& ti);
void deserialize(uint8& b, TextInput& ti);
void deserialize(double& b, TextInput& ti);
void deserialize(float& b, TextInput& ti);
void deserialize(std::string& b, TextInput& ti);

} // namespace

#endif