/*
設計模式例程
根據有關例程綜合而成

石銀峰于2002/04/17在杭州整理
*/
/*
意圖
	為子系統中的一組接口提供一個一致的界面，F a c a d e 模式定義了一個高層接口，這個接口使得這一子系統更加容易使用。 
適用性
	當你要為一個復雜子系統提供一個簡單接口時。子系統往往因為不斷演化而變得越來越復雜。大多數模式使用時都會產生更多更小的類。這使得子系統更具可重用性，也更容易對子系統進行定制，但這也給那些不需要定制子系統的用戶帶來一些使用上的困難。F a c a d e 可以提供一個簡單的缺省視圖，這一視圖對大多數用戶來說已經足夠，而那些需要更多的可定制性的用戶可以越過f a c a d e 層。 
	客戶程序與抽象類的實現部分之間存在著很大的依賴性。引入f a c a d e 將這個子系統與客戶以及其他的子系統分離，可以提高子系統的獨立性和可移植性。 
	當你需要構建一個層次結構的子系統時，使用f a c a d e 模式定義子系統中每層的入口點。如果子系統之間是相互依賴的，你可以讓它們僅通過f a c a d e 進行通訊，從而簡化了它們之間的依賴關系。  
*/

/*
	Compiler
		:........Compile() =======> all of classes...
		
*/

// this project can't running...

#include "../public/defs.h"
#include "../public/Foundation.H"
#include "../public/List.h"

class istream;
class ostream;
class Token;
class ProgramNodeBuilder;
class ProgramNode;
class StatementNode;
class ExpressionNode;
class CodeGenerator;
class BytecodeStream{};

/*****************************************************************************/
// Token
class Token{
	//...
};

/*****************************************************************************/
/* Scanner
*/
class Scanner {
public:
    Scanner(istream&);
    virtual ~Scanner();

    virtual Token& Scan();
private:
    istream& _inputStream;
};

Scanner::Scanner(istream& io): _inputStream(io){
	output("Scanner::Scanner(istream& io): _inputStream(io)\n");
}
Scanner::~Scanner(){
	output("Scanner::~Scanner()\n");
}
Token& Scanner::Scan(){
	output("Token& Scanner::Scan()\n");
	Token *t = new Token;
	return *t;
}

/*****************************************************************************/
/* Parser
*/
class Parser {
public:
    Parser();
    virtual ~Parser();

    virtual void Parse(Scanner&, ProgramNodeBuilder&);
};

Parser::Parser(){
	output("Parser::Parser()\n");
}
Parser::~Parser(){
	output("Parser::~Parser()\n");
}
void Parser::Parse(Scanner&, ProgramNodeBuilder&){
	output("void Parser::Parse(Scanner&, ProgramNodeBuilder&)\n");
}
/*****************************************************************************/
/* ProgramNodeBuilder
*/
class ProgramNodeBuilder {
public:
    ProgramNodeBuilder();
/*
*/
    virtual ProgramNode* NewVariable(
        char* variableName
    ) const;
/*
*/
    virtual ProgramNode* NewAssignment(
        ProgramNode* variable, ProgramNode* expression
    ) const;
/*
*/
    virtual ProgramNode* NewReturnStatement(
        ProgramNode* value
    ) const;
/*
*/
    virtual ProgramNode* NewCondition(
        ProgramNode* condition,
        ProgramNode* truePart, ProgramNode* falsePart
    ) const;
    // ...
/*
*/
    ProgramNode* GetRootNode();
private:
    ProgramNode* _node;
};

ProgramNodeBuilder::ProgramNodeBuilder(){
	output("ProgramNodeBuilder::ProgramNodeBuilder()\n");
	_node = NULL;
}
ProgramNode* ProgramNodeBuilder::GetRootNode(){
	output("ProgramNode* ProgramNodeBuilder::GetRootNode()\n");
	return _node;
}

ProgramNode* ProgramNodeBuilder::NewVariable(
        char* variableName
		) const{
	output("ProgramNode* ProgramNodeBuilder::NewVariable");
	return _node;
}
/*
*/
ProgramNode* ProgramNodeBuilder::NewAssignment(
        ProgramNode* variable, ProgramNode* expression
		) const{
	output("ProgramNode* ProgramNodeBuilder::NewAssignment(\n");
	return _node;
}
/*
*/
ProgramNode* ProgramNodeBuilder::NewReturnStatement(
        ProgramNode* value
		) const{
	output("ProgramNode* ProgramNodeBuilder::NewReturnStatement(");
	return _node;
}
/*
*/
ProgramNode* ProgramNodeBuilder::NewCondition(
        ProgramNode* condition,
        ProgramNode* truePart, ProgramNode* falsePart
		) const{
	output("ProgramNode* ProgramNodeBuilder::NewCondition(\n");
	return _node;
}

// ...
/*****************************************************************************/
/* ProgramNode
*/
class ProgramNode {
public:
    // program node manipulation
    virtual void GetSourcePosition(int& line, int& index);
    // ...
/*
*/
    // child manipulation
    virtual void Add(ProgramNode*);
    virtual void Remove(ProgramNode*);
    // ...

    virtual void Traverse(CodeGenerator&);
protected:
    ProgramNode();
};

/*****************************************************************************/
/* CodeGenerator
*/
class CodeGenerator {
public:
    virtual void Visit(StatementNode*);
    virtual void Visit(ExpressionNode*);
    // ...
protected:
    CodeGenerator(BytecodeStream&);
protected:
    BytecodeStream& _output;
};

CodeGenerator::CodeGenerator(BytecodeStream& io) : _output(io){
	output("CodeGenerator::CodeGenerator(BytecodeStream& io) : _output(io)\n");
}
void CodeGenerator::Visit(StatementNode*){
	output("void CodeGenerator::Visit(StatementNode*)\n");
}
void CodeGenerator::Visit(ExpressionNode*){
	output("void CodeGenerator::Visit(ExpressionNode*)\n");
}

/*****************************************************************************/
/* ExpressionNode
*/
class ExpressionNode : public ProgramNode {
public:
    ExpressionNode();
    virtual void GetSourcePosition(int& line, int& index);
    virtual void Add(ProgramNode*);
    virtual void Remove(ProgramNode*);

    virtual void Traverse(CodeGenerator&);
protected:
    List<ProgramNode*>* _children;
};
/*
*/
void ExpressionNode::Traverse (CodeGenerator& cg) {
	output("void ExpressionNode::Traverse (CodeGenerator& cg) \n");
    cg.Visit(this);

    ListIterator<ProgramNode*> i(_children);

    for (i.First(); !i.IsDone(); i.Next()) {
        i.CurrentItem()->Traverse(cg);
    }
}
/*****************************************************************************/
/* StatementNode
*/
class StatementNode : public ProgramNode{
	//...
};

/*****************************************************************************/
/* VariableNode
*/
class VariableNode : public ProgramNode{
	//..
};

/*****************************************************************************/
/* RISCCodeGenerator
*/
class  RISCCodeGenerator : public CodeGenerator {
public:
    RISCCodeGenerator(BytecodeStream&);
    virtual void Visit(StatementNode*);
    virtual void Visit(ExpressionNode*);
    // ...
};
/*****************************************************************************/
/* StackMachineCodeGenerator
*/
class StackMachineCodeGenerator : public CodeGenerator{
	//...
};

RISCCodeGenerator::RISCCodeGenerator(BytecodeStream& io) : CodeGenerator(io){
	output("RISCCodeGenerator::RISCCodeGenerator(BytecodeStream& io) : CodeGenerator(io)\n");
}
void RISCCodeGenerator::Visit(StatementNode*){
	output("void RISCCodeGenerator::Visit(StatementNode*)\n");
}
void RISCCodeGenerator::Visit(ExpressionNode*){
	output("void RISCCodeGenerator::Visit(ExpressionNode*)\n");
}

/*****************************************************************************/
/* Compiler
*/
class Compiler {
public:
    Compiler(){};

    virtual void Compile(istream&, BytecodeStream&);
};

void Compiler::Compile (
    istream& input, BytecodeStream& output
) {
	output("void Compiler::Compile ");
    Scanner scanner(input);
    ProgramNodeBuilder builder;
    Parser parser;

    parser.Parse(scanner, builder);

    RISCCodeGenerator generator(output);
    ProgramNode* parseTree = builder.GetRootNode();
    parseTree->Traverse(generator);
}

/*
*/
main(){
	output("main()\n");

	BytecodeStream bs;

	Compiler compiler;
	compiler.Compile(cin,bs);

	pause();
	return 0;
}