我學編譯原理沒有多久，剛剛學到語義分析，所以我也算是菜鳥。。。 無意間看到了《自己動手寫編譯器、連結器》這本書，覺得實現一個編譯器才算是真正的入門。

本來我是沒有決心寫好一個c語言的編譯器的，因為c語言的詞法、語法等等有太多的內容，但是無奈曾經也就學習過c語言、c++、scheme（學了一點點就沒學了），

硬著頭皮去看書、敲程式碼，並且整理。我的意思就是選擇說選擇一門你熟悉的語言，然後學習之。不要三天打魚。寫一個編譯器不是想象中的那麼簡單，如果學習到了一半

就放棄了，那麼效果肯定不會太理想。我下面的程式碼參考了《自己動手寫編譯器、連結器》這本書，這也是我第一次寫c語言編譯器。但是我是用了c++實現，或許我的程式碼風格

很像c（那是因為我的水平不高），但也花了幾天的時間去學習。。。

或許還存在著一些錯誤，在等我我寫完語法分析等等之後才會發現。。所以說湊合著看吧。。畢竟我也是第一次寫這玩意

#ifndef Lexc___hpp

#define Lexc___hpp

#include <stdio.h>

#include <fstream>

#include <iostream>

#include <vector>

#include <cctype>

//類似於string的資料結構

struct

DynString

{

int     count;

int     capacity;           //capacity容量

char    *data;              //指標

};

//每一個data存放一個string

template <typename T>

struct DynArray

{

int     count;

int     capacity;

    T       *data;

};

struct TkWord

{

int             tkcode;                    

//單詞編碼

TkWord          *next;

std::string     spelling;

//   Sysbol          *sym_struct;      第六節才會講

};

enum e_TokenCode

{

/* 運算子及分隔符 */

    TK_PLUS,// + 加號

    TK_MINUS,// - 減號

    TK_STAR,// * 星號

    TK_DIVIDE,// / 除號

    TK_MOD,// % 求餘運算子

    TK_EQ,// == 等於號

    TK_NEQ,// != 不等於號

    TK_LT,// < 小於號

    TK_LEQ,// <= 小於等於號

    TK_GT,// > 大於號

    TK_GEQ,// >= 大於等於號

    TK_ASSIGN,// = 賦值運算子

    TK_POINTSTO,// -> 指向結構體成員運算子

    TK_DOT,// . 結構體成員運算子

    TK_AND,         // & 地址與運算子

    TK_OPENPA,// ( 左圓括號

    TK_CLOSEPA,// ) 右圓括號

    TK_OPENBR,// [ 左中括號

    TK_CLOSEBR,// ] 右圓括號

    TK_BEGIN,// { 左大括號

    TK_END,// } 右大括號

    TK_SEMICOLON,// ; 分號

    TK_COMMA,// , 逗號

    TK_ELLIPSIS,// ... 省略號

    TK_EOF,// 檔案結束符

/* 常量 */

    TK_CINT,// 整型常量

    TK_CCHAR,// 字元常量

    TK_CSTR,// 字串常量

/* 關鍵字 */

    KW_CHAR,// char關鍵字

    KW_SHORT,// short關鍵字

    KW_INT,// int關鍵字

    KW_VOID,// void關鍵字

    KW_STRUCT,// struct關鍵字

    KW_IF,// if關鍵字

    KW_ELSE,// else關鍵字

    KW_FOR,// for關鍵字

    KW_CONTINUE,// continue關鍵字

    KW_BREAK,// break關鍵字

    KW_RETURN,// return關鍵字

    KW_SIZEOF,// sizeof關鍵字

    KW_ALIGN,// __align關鍵字

    KW_CDECL,// __cdecl關鍵字 standard c call

    KW_STDCALL,     // __stdcall關鍵字 pascal c call

/* 識別符號 */

    TK_IDENT

};

class __DynString

{

public:

using dynstring = DynString;

class __DynArray;

char ch = 0;

    __DynString(): get_i(0)

    {

pstr = newdynstring;

pstr->data = newchar;

pstr->count = 0;

pstr->capacity = 0;

    }

void dynstring_init(int init)

    {

pstr->data = newchar[init];

pstr->count = 0;

pstr->capacity = init;

    }

void dynstring_free()

    {

if(pstr->data != nullptr)

        {

deletepstr->data;

// std::cout << "s\n";

        }

pstr->count = 0;

pstr->capacity = 0;

    }

void dynstring_reset()

    {

dynstring_free();

dynstring_init(8);

    }

void dynstring_realloc(int new_size)

    {

int capacity;

char *data;

        capacity = pstr->capacity;

while(capacity < new_size)

            capacity = capacity * 2;

        data = (char *)realloc(pstr->data, capacity);

pstr->capacity = capacity;

pstr->data = data;

    }

void dynstring_chcat(int ch)

    {

int count = pstr->count + 1;

if(count > pstr->capacity)

dynstring_realloc(count);

pstr->data[count - 1] = ch;

pstr->count = count;

    }

void dynstring_print()

    {

std::cout << pstr->data;

    }

char* getdata()

    {

char *ch;

        ch = pstr->data;

return ch;

    }

private:

int         get_i;                  //計數

dynstring   *pstr;            //指標

};

template<typename T>

class __DynArray

{

public:

using dynarray = DynArray<T>;

    __DynArray()

    {

parr = newdynarray;

parr->data = new T[4];

parr->count = 0;

parr->capacity = 4;

    }

void init(int init)

    {

parr = newdynarray;

parr->data = new T[init];

parr->count = 0;

parr->capacity = init;

    }

void dynarray_realloc(int new_size)

    {

int capacity;

        T   *data;

        capacity = parr->capacity;

while(capacity < new_size)

            capacity = capacity * 2;

        data = new T[capacity];

for(auto vt = 0; vt < parr->capacity; ++vt)

            data[vt] = parr->data[vt];

parr->capacity  = capacity;

parr->data = data;

    }

void dynarray_add(T data)

    {

int count;

        count = parr->count + 1;

if(count > parr->capacity)

dynarray_realloc(count);

parr->data[count - 1] = data;

parr->count = count;

    }

void dynarray_free()

    {

void **p;

for(p = parr->data; parr->count; ++p, --parr->count)

if(*p)

free(*p);

parr->data = nullptr;

    }

int dynarray_search(int key)

    {

int **p = (int**)parr->data;

for(int i = 0; i < parr->count; ++i, p++)

if(key == **p)

return i;

return -1;

    }

void dynarray_print()

    {

auto size = parr->count;

//  std::cout << size;

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

std::cout << parr->data[i].spelling << " " ;

//.. std::cout << std::endl;

    }

int getint()

    {

int temp = parr->count;

return temp;

    }

TkWord getdata(int v)

    {

TkWord tk = parr->data[v];

return tk;

    }

private:

dynarray        *parr;

};

template <typename T>

class __TkWord

{

public:

using tkword = TkWord;

__DynArray<T>  tktable;

    __TkWord<T>(): token(0)

    {

tp = newtkword;

tp->tkcode = 0;

tp->spelling = "\0";

tp->next = 0;

    }

tkword *tkword_direct_insert()

    {

int keyno = elf_hash(tp->spelling);

tktable.dynarray_add(*tp);

tp->next = tk_hashtable[keyno];

tk_hashtable[keyno] = tp;

returntp;

    }

tkword *tkword_find(char *p, int keyno)

    {

//tkword *tp = nullptr;

auto tp1 = tk_hashtable[keyno];

if(tp1 == NULL)

returnnullptr;

returntp;

    }

tkword *tkword_insert(char *p)

    {

int keyno = elf_hash(p);

tp = tkword_find(p, keyno);

if(tp == nullptr)

        {

size_t length = strlen(p);

tp = newtkword[length + 1];

tp->next = tk_hashtable[keyno];

tk_hashtable[keyno] = tp;

tktable.dynarray_add(*tp);

tp->tkcode = tktable.getint() - 1;

char *s = (char *)tp + sizeof(tkword);

for(auto end = p + length; p < end;)

                *s++ = *p++;

            *s = (char)'\0';

        }

returntp;

    }

/*

     void *Lex::mallocz(int size)

     {

     void *ptr;

     ptr = mallocz(size);

相關推薦