c语言写编译器怎么写,自个儿动手写C语言编译器（1）

自己动手写C语言编译器(1)

直接上代码 (表达式树  在此 初具 模型 )

由于没有做前期的“词法分析”，

1.支持 单个 字符 形式的变量

2.支持 单个 字符形式的操作符

3.支持 优先级 。

不支持

1.不支持多个字符的操作符和变量。

2. 不支持左右结合性

3.不支持函数

4. 不支持语句

5. 不支持关键字。

这些将陆续添加 。

// MyCompiler.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include

#include

#include

#include

#include

#include

//把Token转换为字符串

#define ATokenToString(l, r) if(l == r)return #r;

using namespace std;

namespace tokens{

enum TOKEN

{

INVALID_TYPE,

WHITE_SPACE,

NAME,

NUMBER,

END,

PLUS,

MINUS,

MUL,

DIV,

PRINT,

ASSIGN,

LP,

RP,

};

static string MyTokenToString(TOKEN token)

{

ATokenToString(token, WHITE_SPACE)

ATokenToString(token, NAME)

ATokenToString(token, NUMBER)

ATokenToString(token, END)

ATokenToString(token, PLUS)

ATokenToString(token, MINUS)

ATokenToString(token, MUL)

ATokenToString(token, DIV)

ATokenToString(token, PRINT)

ATokenToString(token, ASSIGN)

ATokenToString(token, LP)

ATokenToString(token, RP)

return "";

}

}

class tokenizer

{

int mTokenTypes[256];

string mCurrentStrToken;

tokens::TOKEN mCurrentTokenType;

istream& mIfStream;

public:

tokenizer(istream& infile):mIfStream(infile)

{

memset(mTokenTypes, 0, 256);

mTokenTypes['+'] = tokens::PLUS;

mTokenTypes['-'] = tokens::MINUS;

mTokenTypes['*'] = tokens::MUL;

mTokenTypes['/'] = tokens::DIV;

mTokenTypes[';'] = tokens::PRINT;

mTokenTypes['='] = tokens::ASSIGN;

mTokenTypes['('] = tokens::LP;

mTokenTypes[')'] = tokens::RP;

mTokenTypes['\t'] = tokens::WHITE_SPACE;

mTokenTypes[' '] = tokens::WHITE_SPACE;

char ch = 0;

for (ch = 'a'; ch <= 'z'; ch ++)

{

mTokenTypes[ch] = tokens::NAME;

}

for(ch = 'A'; ch <= 'Z'; ch ++)

{

mTokenTypes[ch] = tokens::NAME;

}

for(ch = '0'; ch <= '9'; ch ++)

{

mTokenTypes[ch] = tokens::NUMBER;

}

mTokenTypes['.'] = tokens::NUMBER;

}

bool hasNext()

{

char temptoken = 0;

if(mIfStream.get(temptoken))

{

mIfStream.putback(temptoken);

return true;

}

return false;

}

const string getCurrent()

{

return mCurrentStrToken;

}

tokens::TOKEN getTokenType()

{

return mCurrentTokenType;

}

const string getNext()

{

string strValue;

char ch = 0;

mIfStream>>ch;

mCurrentTokenType = (tokens::TOKEN)mTokenTypes[ch];

mIfStream.putback(ch);

mIfStream>>strValue;

mCurrentStrToken = strValue;

return strValue;

}

};

class Node;

struct NodeVisitor

{

virtual void BeginVisitTree(Node* nod) = 0;

virtual void VisitNode(Node* nod) = 0;

virtual void EndVisitTree(Node* nod) = 0;

};

class Node

{

char m_Data;

NodeVisitor* m_pGetNode;

public:

Node* m_pLeftChild;

Node* m_pRightChild;

Node* m_pParent;

int m_priority_level;

public:

char getData()

{

return m_Data;

}

Node()

{

m_Data = 0;

m_pLeftChild = NULL;

m_pRightChild = NULL;

m_pParent = NULL;

//空的Node，优先级最低

m_priority_level = 0;

}

Node(char data)

{

m_Data = data;

m_pLeftChild = NULL;

m_pRightChild = NULL;

m_pParent = NULL;

m_priority_level = 0;

}

void set(Node* pL, Node* pR)

{

m_pLeftChild = pL;

m_pRightChild = pR;

}

void setLeft(Node* pLeft)

{

m_pLeftChild = pLeft;

}

void setRight(Node* pRight)

{

m_pRightChild = pRight;

}

void accept(NodeVisitor* pGetIt)

{

m_pGetNode = pGetIt;

}

void Postorder_Traversal(NodeVisitor* pVisiter)

{

if(m_pLeftChild != NULL)

m_pLeftChild->Postorder_Traversal(pVisiter);

if (m_pRightChild != NULL)

m_pRightChild->Postorder_Traversal(pVisiter);

pVisiter->VisitNode(this);

}

void Inorder_Traversal(NodeVisitor* pVisiter)

{

//Begin Tree.

pVisiter->BeginVisitTree(this);

if(m_pLeftChild != NULL)m_pLeftChild->Inorder_Traversal(pVisiter);

//Visit this node.

//Node should not be diffrent from tree.

pVisiter->VisitNode(this);

if (m_pRightChild != NULL)m_pRightChild->Inorder_Traversal(pVisiter);

//End Tree.

pVisiter->EndVisitTree(this);

}

};

class ExpressionVisiter: public NodeVisitor

{

public:

void BeginVisitTree(Node* nod)

{

if (nod->m_pLeftChild != NULL && nod->m_pRightChild != NULL)

{

printf("%c", '(');

}

}

void VisitNode(Node* nod)

{

printf("%c", nod->getData());

}

void EndVisitTree(Node* nod)

{

if (nod->m_pLeftChild != NULL && nod->m_pRightChild != NULL)

{

printf("%c", ')');

}

}

};

class Tree

{

public:

Tree()

{

pHead = new Node();

}

Node* pHead;

~Tree()

{

}

Node* getNext()

{

}

void Postorder_Traversal(NodeVisitor* pVisiter)

{

if(pHead->m_pLeftChild!=NULL)

pHead->m_pLeftChild->Postorder_Traversal(pVisiter);

}

void Inorder_Traversal(NodeVisitor* pVisiter)

{

if(pHead->m_pLeftChild!=NULL)

pHead->m_pLeftChild->Inorder_Traversal(pVisiter);

}

Node* getCurrent()

{

}

Node* getFirst()

{

}

bool bHasNext()

{

}

void setValue(Node* pNode)

{

pHead->m_pLeftChild = pNode;

}

};

//打印一个字符串的所有排列。

void printSequence(char* pChara)

{

int i = 0;

static int MAX_LEN = strlen(pChara);

if (pChara[0] == '\0')

{

for (int i = 0; i < MAX_LEN; i ++)

{

printf("%c", pChara[i + 1]);

}

printf("\n", "");

}

char* tempChar = pChara;

while (*tempChar != '\0' )

{

char* pMyString = new char[MAX_LEN + 1];

memcpy(pMyString, pChara, MAX_LEN + 1);

memcpy(pMyString + i, pMyString + i + 1, MAX_LEN - i);

pMyString[MAX_LEN] = *tempChar;

printSequence(pMyString);

tempChar ++;

i ++;

delete[] pMyString;

}

}

#ifdef TEST

int main(int argc, char* argv[])

{

ExpressionVisiter visister;

Tree* pTree = new Tree();

Node* pNode1 = new Node('-');

Node* pNode11 = new Node('+');

Node* pNode12 = new Node('/');

Node* pNode111 = new Node('a');

Node* pNode112 = new Node('*');

Node* pNode121 = new Node('e');

Node* pNode122 = new Node('f');

Node* pNode1121 = new Node('b');

Node* pNode1122 = new Node('-');

Node* pNode11221 = new Node('c');

Node* pNode11222 = new Node('d');

pNode1->set(pNode11, pNode12);

pNode11->set(pNode111, pNode112);

pNode12->set(pNode121, pNode122);

pNode112->set(pNode1121, pNode1122);

pNode1122->set(pNode11221, pNode11222);

pTree->setValue(pNode1);

pTree->Inorder_Traversal(&visister);

//printSequence("a");

system("PAUSE");

return 1;

}

#else

//字符的类型

class SH_CHARACTER_TYPE

{

public:

enum CHARACTER_TYPE

{

ILLIGAL_CHAR = 0x00000000,

DIGITAL_CHAR = 0x00000001,

NON_DIGITAL_CHAR = 0x00000002,

UNIVERSAL_CHAR = 0x00000004,

INTEGER_CONSTANT_CHAR = 0x00000008,

FLOATING_CONSTANT_CHAR = 0x00000010,

ENUMERATION_CONSTANT_CHAR = 0x00000020,

CHARACTER_CONSTANT_CHAR = 0x00000040,

STRING_LITERAL_CHAR = 0x00000080,

PUNCTUATOR_CHAR = 0x00000100,

EOL_CHAR = 0x00000200,

EOF_CHAR = 0x00000400,

WHITESPACE_CHAR = 0x00000800,

OPERATOR_CHAR = 0x00001000,

};

};

class sh_ctype

{

private:

int ctypeTable[256];

public:

void clear()

{

//清除

for (int i = 0; i < 256; ++ i)

{

ctypeTable[i] = SH_CHARACTER_TYPE::ILLIGAL_CHAR;

}

}

sh_ctype()

{

clear();

setCtype('a', 'z', SH_CHARACTER_TYPE::NON_DIGITAL_CHAR);

setCtype('A', 'Z', SH_CHARACTER_TYPE::NON_DIGITAL_CHAR);

setCtype('0', '9', SH_CHARACTER_TYPE::DIGITAL_CHAR);

setCtype('0', '9', SH_CHARACTER_TYPE::INTEGER_CONSTANT_CHAR);

setCtype('x', SH_CHARACTER_TYPE::INTEGER_CONSTANT_CHAR);

setCtype('X', SH_CHARACTER_TYPE::INTEGER_CONSTANT_CHAR);

setCtype('u', SH_CHARACTER_TYPE::INTEGER_CONSTANT_CHAR);

setCtype('U', SH_CHARACTER_TYPE::INTEGER_CONSTANT_CHAR);

setCtype('l', SH_CHARACTER_TYPE::INTEGER_CONSTANT_CHAR);

setCtype('L', SH_CHARACTER_TYPE::INTEGER_CONSTANT_CHAR);

setCtype('0', '9', SH_CHARACTER_TYPE::FLOATING_CONSTANT_CHAR);

setCtype('e', SH_CHARACTER_TYPE::FLOATING_CONSTANT_CHAR);

setCtype('E', SH_CHARACTER_TYPE::FLOATING_CONSTANT_CHAR);

setCtype('l', SH_CHARACTER_TYPE::FLOATING_CONSTANT_CHAR);

setCtype('L', SH_CHARACTER_TYPE::FLOATING_CONSTANT_CHAR);

setCtype('f', SH_CHARACTER_TYPE::FLOATING_CONSTANT_CHAR);

setCtype('F', SH_CHARACTER_TYPE::FLOATING_CONSTANT_CHAR);

//标点符号字符

setCtype(0x21,0x2F, SH_CHARACTER_TYPE::PUNCTUATOR_CHAR);

setCtype(0x3a,0x40, SH_CHARACTER_TYPE::PUNCTUATOR_CHAR);

setCtype(0x5B,0x60, SH_CHARACTER_TYPE::PUNCTUATOR_CHAR);

//空白字符

setCtype(0x20, SH_CHARACTER_TYPE::WHITESPACE_CHAR);

setCtype(0x09, 0x0D, SH_CHARACTER_TYPE::WHITESPACE_CHAR);

setCtype('+', SH_CHARACTER_TYPE::OPERATOR_CHAR);

}

//断定是否是某种类型

bool assert(char ch, SH_CHARACTER_TYPE::CHARACTER_TYPE type)

{

if ((getCtype(ch)&type) == type)

{

return true;

}

return false;

}

void setCtype(char from, char to, SH_CHARACTER_TYPE::CHARACTER_TYPE type)

{

for (char ch = from; ch <= to ; ++ ch)

{

ctypeTable[ch] = ctypeTable[ch]|type;

}

}

void setCtype(char ch, SH_CHARACTER_TYPE::CHARACTER_TYPE type)

{

ctypeTable[ch] = ctypeTable[ch]|type;

}

int getCtype(char ch)

{

return ctypeTable[ch];

}

};

int getLevel(char ch)

{

switch(ch)

{

case ',':

return 0;

case '=':

return 1;

case '|':

return 2;

case '^':

return 3;

case '>': case '

return 5;

case '+' : case '-':

return 6;

case '*': case '/':

return 7;

case '&':

return 8;

case '.':

return 9;

default:

return INT_MAX;

}

}

static int const INVALID = 0;

static int const EXPRESSION = 0x0001;

static int const LVALUE = 0x0002;

static int const OPERATOR_LEFT = 0x0004;

static int const OPERATOR_RIGHT = 0x0008;

int main(int argc, char* argv[])

{

sh_ctype ct;

Node* pHead = NULL;

Node* preTreeOperator = NULL;

char ch;

while (cin.get(ch) && ch != '\n')

{

//如果目前没有操作子Tree

if (preTreeOperator == NULL)

{

preTreeOperator = new Node(ch);

preTreeOperator->m_priority_level = getLevel(ch);

pHead = preTreeOperator;

continue;

}

else

{

Node* no = new Node(ch);

no->m_priority_level = getLevel(ch);

Node* theTree = preTreeOperator;

if(pHead->m_priority_level == no->m_priority_level

&& pHead->m_priority_level == INT_MAX)

{

std::cout<

system("PAUSE");

return;

}

else if (no->m_priority_level <= pHead->m_priority_level)

{

pHead->m_pParent = no;

no->m_pLeftChild = pHead;

pHead = no;

preTreeOperator = no;

continue;

}

if(theTree->m_priority_level == no->m_priority_level

&& theTree->m_priority_level == INT_MAX)

{

std::cout<

system("PAUSE");

return;

}

while (theTree!= NULL&& theTree->m_priority_level >= no->m_priority_level)

{

theTree = theTree->m_pParent;

}

if (theTree != NULL)

{

no->m_pLeftChild = theTree->m_pRightChild;

no->m_pParent = theTree;

theTree->m_pRightChild = no;

preTreeOperator = no;

}

}

}

Tree tree;

ExpressionVisiter vister;

tree.setValue(pHead);

tree.Inorder_Traversal(&vister);

system("PAUSE");

}

#endif

1 楼

wuhanxiang

2011-07-29

楼主看不懂啊，能不能多写点说明性的文字，解释下..

2 楼

juda

2011-08-02

楼主太蛋疼了