scummvm/engines/twp/yack.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef TWP_YACK_H
#define TWP_YACK_H

#include "common/array.h"
#include "common/str.h"
#include "common/stream.h"
#include "common/debug.h"
#include "twp/util.h"

namespace Twp {

enum class YackTokenId {
	None,
	NewLine,
	Identifier,
	WaitWhile,
	Int,
	Float,
	Whitespace,
	Colon,
	Condition,
	String,
	Assign,
	Comment,
	Goto,
	Code,
	Dollar,
	End
};

// enumeration that lists all errors that can occur
enum YackError {
	ERR_NONE,              // no error
	ERR_INVALIDYackToken,  // invalid YackToken
	ERR_STRINGEXPECTED,    // string expected
	ERR_COLONEXPECTED,     // `:` expected
	ERR_COMMAEXPECTED,     // `,` expected
	ERR_BRACKETRIEXPECTED, // `]` expected
	ERR_CURLYRIEXPECTED,   // `}` expected
	ERR_QUOTEEXPECTED,     // `"` or `'` expected
	ERR_EOC_EXPECTED,      // `*/` expected
	ERR_EOFEXPECTED,       // EOF expected
	ERR_EXPREXPECTED       // expr expected
};

class YackVisitor;
class YackNode {
public:
	virtual ~YackNode() {}

	virtual void accept(YackVisitor &v) = 0;
};

// Represents a condition
class YCond : public YackNode {
public:
	virtual ~YCond() {}

public:
	int _line;
};

class YCodeCond : public YCond {
public:
	YCodeCond(int line) { _line = line; }
	virtual ~YCodeCond() {}
	virtual void accept(YackVisitor &v) override;

public:
	Common::String _code;
};

class YOnce : public YCond {
public:
	YOnce(int line) { _line = line; }
	virtual ~YOnce() {}
	virtual void accept(YackVisitor &v) override;
};

class YShowOnce : public YCond {
public:
	YShowOnce(int line) { _line = line; }
	virtual ~YShowOnce() {}
	virtual void accept(YackVisitor &v) override;
};

class YOnceEver : public YCond {
public:
	YOnceEver(int line) { _line = line; }
	virtual ~YOnceEver() {}
	virtual void accept(YackVisitor &v) override;
};

class YTempOnce : public YCond {
public:
	YTempOnce(int line) { _line = line; }
	virtual ~YTempOnce() {}
	virtual void accept(YackVisitor &v) override;
};

// Expression
class YExp : public YackNode {
public:
	YExp() {}
	virtual ~YExp() {}
};

class YGoto : public YExp {
public:
	YGoto(int line) { _line = line; }
	virtual ~YGoto() {}
	virtual void accept(YackVisitor &v) override;

public:
	Common::String _name;
	int _line = 0;
};

class YCodeExp : public YExp {
public:
	virtual ~YCodeExp() {}
	virtual void accept(YackVisitor &v) override;

public:
	Common::String _code;
};

class YChoice : public YExp {
public:
	virtual ~YChoice() {}
	virtual void accept(YackVisitor &v) override;

public:
	int _number = 0;
	Common::String _text;
	Common::SharedPtr<YGoto> _goto;
};

class YSay : public YExp {
public:
	virtual ~YSay() {}
	virtual void accept(YackVisitor &v) override;

public:
	Common::String _actor;
	Common::String _text;
};

class YPause : public YExp {
public:
	virtual ~YPause() {}
	virtual void accept(YackVisitor &v) override;

public:
	int _time = 0;
};

class YParrot : public YExp {
public:
	virtual ~YParrot() {}
	virtual void accept(YackVisitor &v) override;

public:
	bool _active = true;
};

class YDialog : public YExp {
public:
	virtual ~YDialog() {}
	virtual void accept(YackVisitor &v) override;

public:
	Common::String _actor;
};

class YOverride : public YExp {
public:
	virtual ~YOverride() {}
	virtual void accept(YackVisitor &v) override;

public:
	Common::String _node;
};

class YShutup : public YExp {
public:
	virtual ~YShutup() {}
	virtual void accept(YackVisitor &v) override;
};

class YAllowObjects : public YExp {
public:
	virtual ~YAllowObjects() {}
	virtual void accept(YackVisitor &v) override;

public:
	bool _active = true;
};

class YLimit : public YExp {
public:
	virtual ~YLimit() {}
	virtual void accept(YackVisitor &v) override;

public:
	int _max = 8;
};

class YWaitWhile : public YExp {
public:
	virtual ~YWaitWhile() {}
	virtual void accept(YackVisitor &v) override;

public:
	Common::String _cond;
};

class YWaitFor : public YExp {
public:
	virtual ~YWaitFor() {}
	virtual void accept(YackVisitor &v) override;

public:
	Common::String _actor;
};

//

class YStatement : public YackNode {
public:
	virtual ~YStatement() override {}

	virtual void accept(YackVisitor &v) override;

public:
	Common::SharedPtr<YExp> _exp;
	Common::Array<Common::SharedPtr<YCond> > _conds;
};

class YLabel : public YackNode {
public:
	YLabel(int line);
	virtual ~YLabel() override;
	virtual void accept(YackVisitor &v) override;

public:
	Common::String _name;
	Common::Array<Common::SharedPtr<YStatement> > _stmts;
	int _line = 0;
};

class YCompilationUnit : public YackNode {
public:
	virtual ~YCompilationUnit() override;
	virtual void accept(YackVisitor &v) override;

public:
	Common::Array<Common::SharedPtr<YLabel> > _labels;
};

class YackVisitor {
public:
	virtual ~YackVisitor() {}

	virtual void visit(const YCompilationUnit &node) { defaultVisit(node); }
	virtual void visit(const YStatement &node) { defaultVisit(node); }
	virtual void visit(const YWaitFor &node) { defaultVisit(node); }
	virtual void visit(const YWaitWhile &node) { defaultVisit(node); }
	virtual void visit(const YLimit &node) { defaultVisit(node); }
	virtual void visit(const YAllowObjects &node) { defaultVisit(node); }
	virtual void visit(const YShutup &node) { defaultVisit(node); }
	virtual void visit(const YOverride &node) { defaultVisit(node); }
	virtual void visit(const YDialog &node) { defaultVisit(node); }
	virtual void visit(const YParrot &node) { defaultVisit(node); }
	virtual void visit(const YPause &node) { defaultVisit(node); }
	virtual void visit(const YSay &node) { defaultVisit(node); }
	virtual void visit(const YChoice &node) { defaultVisit(node); }
	virtual void visit(const YCodeExp &node) { defaultVisit(node); }
	virtual void visit(const YGoto &node) { defaultVisit(node); }
	virtual void visit(const YTempOnce &node) { defaultVisit(node); }
	virtual void visit(const YOnceEver &node) { defaultVisit(node); }
	virtual void visit(const YShowOnce &node) { defaultVisit(node); }
	virtual void visit(const YOnce &node) { defaultVisit(node); }
	virtual void visit(const YCodeCond &node) { defaultVisit(node); }
	virtual void visit(const YLabel &node) { defaultVisit(node); }

	virtual void defaultVisit(const YackNode &node) {}
};

struct YackToken {
	YackTokenId id = YackTokenId::None;
	int64 start = 0;
	int64 end = 0;
	int line = 0;

	Common::String toString() const;
};

class YackTokenReader {
public:
	class Iterator {
	public:
		using value_type = YackToken;
		using difference_type = ptrdiff_t;
		using pointer = YackToken *;
		using reference = YackToken &;

	private:
		YackTokenReader *_reader = nullptr;
		int64 _pos = 0;
		YackToken _token;

	public:
		Iterator() {}
		Iterator(YackTokenReader &reader, int64 pos);
		Iterator(const Iterator &it);
		Iterator &operator++();
		Iterator operator++(int);

		Iterator &operator=(const Iterator &rhs) {
			_pos = rhs._pos;
			_token = rhs._token;
			_reader = rhs._reader;
			return *this;
		}
		bool operator==(const Iterator &rhs) const { return _pos == rhs._pos; }
		bool operator!=(const Iterator &rhs) const { return _pos != rhs._pos; }
		YackToken &operator*();
		const YackToken &operator*() const;
		YackToken *operator->();
	};

	using iterator = Iterator;

public:
	void open(Common::SeekableReadStream *stream);

	iterator begin();
	iterator end();
	Common::String readText(const YackToken &YackToken);

private:
	bool readYackToken(YackToken &YackToken);
	Common::String readText(int64 pos, int64 size);
	YackTokenId readYackTokenId();
	YackTokenId readCode();
	YackTokenId readCondition();
	YackTokenId readDollar();
	YackTokenId readNumber();
	YackTokenId readComment();
	YackTokenId readString();
	YackTokenId readIdentifier(char c);
	byte peek();
	void ignore(int64 n = 1, int delim = EOF);

private:
	Common::SeekableReadStream *_stream = nullptr;
	int _line = 0;

	friend class YackParser;
};

class YackParser {
public:
	YackParser() {}
	YCompilationUnit *parse(Common::SeekableReadStream *stream);

private:
	bool match(const std::initializer_list<YackTokenId> &ids);
	Common::SharedPtr<YLabel> parseLabel();
	Common::SharedPtr<YStatement> parseStatement();
	Common::SharedPtr<YCond> parseCondition();
	Common::SharedPtr<YExp> parseExpression();
	Common::SharedPtr<YSay> parseSayExpression();
	Common::SharedPtr<YExp> parseWaitWhileExpression();
	Common::SharedPtr<YExp> parseInstructionExpression();
	Common::SharedPtr<YGoto> parseGotoExpression();
	Common::SharedPtr<YCodeExp> parseCodeExpression();
	Common::SharedPtr<YChoice> parseChoiceExpression();

private:
	YackTokenReader _reader;
	YackTokenReader::iterator _it;
};

class YackDump : public YackVisitor {
public:
	virtual ~YackDump() {}

	virtual void visit(const YCompilationUnit &node) {
		debug("CompilationUnit:");
		for (const auto &cond : node._labels) {
			cond->accept(*this);
		}
	}
	virtual void visit(const YLabel &node) {
		debug("Label: %s [%d]", node._name.c_str(), node._line);
		for (const auto &stmt : node._stmts) {
			stmt->accept(*this);
		}
	}
	virtual void visit(const YStatement &node) {
		debug("Statement:");
		for (const auto &cond : node._conds) {
			cond->accept(*this);
		}
		node._exp->accept(*this);
	}
	virtual void visit(const YWaitFor &node) { debug("WaifFor %s", node._actor.c_str()); }
	virtual void visit(const YWaitWhile &node) { debug("WaitWhile %s", node._cond.c_str()); }
	virtual void visit(const YLimit &node) { debug("Limit: %d", node._max); }
	virtual void visit(const YAllowObjects &node) { debug("AllowObjects"); }
	virtual void visit(const YShutup &node) { debug("Shutup"); }
	virtual void visit(const YOverride &node) { defaultVisit(node); }
	virtual void visit(const YDialog &node) { debug("Dialog: %s", node._actor.c_str()); }
	virtual void visit(const YParrot &node) { debug("Parrot: %s", node._active ? "YES" : "NO"); }
	virtual void visit(const YPause &node) { debug("Pause: %d", node._time); }
	virtual void visit(const YSay &node) { debug("Say: actor: %s, text = %s", node._actor.c_str(), node._text.c_str()); }
	virtual void visit(const YChoice &node) { debug("Choice %d: %s -> %s", node._number, node._text.c_str(), node._goto->_name.c_str()); }
	virtual void visit(const YCodeExp &node) { debug("Code: %s", node._code.c_str()); }
	virtual void visit(const YGoto &node) { debug("Goto: %s", node._name.c_str()); }
	virtual void visit(const YTempOnce &node) { debug("TempOnce"); }
	virtual void visit(const YOnceEver &node) { debug("OnceEver"); }
	virtual void visit(const YShowOnce &node) { debug("ShowOnce"); }
	virtual void visit(const YOnce &node) { debug("Once"); }
	virtual void visit(const YCodeCond &node) { debug("Cond: %s", node._code.c_str()); }

	virtual void defaultVisit(const YackNode &node) {}
};

} // namespace Twp

#endif