facade.cpp

设计模式的VC例子

/*
设计模式例程
根据有关例程综合而成

石银峰于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;
}