一个文本翻译工具的实现

一、需求

一个文本翻译工具，功能类似于汇编器，能够把一些字符串（程序的助记符）翻译为其他的字符串或者数字，并打印到文本文件中。完成的功能如下：

1.        助记符翻译
2.        程序地址分配
3.        Label替换程序地址
4.        数据地址替换
5.        宏定义的展开

输入文件格式
1.        纯文本文件，允许行首有多个空格或者制表符。同一行内，语句之间用一个或者多个空格或者制表符隔开。

2.        不区分大小写。

3.        注释以“;”开始，占单独一行。处理的时候丢弃注释行。

4.        Label以“%”开始，以“:”结束，占单独一行。主要用于表示跳转的目的地址。

5.        立即数以“#”开始，以16进制表示。

6.        立即程序地址和立即数据地址都以“&”开始，以16进制表示。

输出文件格式

文件1：
   16’h程序地址：begin
instr = {...}; end
文件2：

   所有立即数据地址，每行一个。

助记符翻译

   阴影文字不做翻译，直接输出。xx为my
label的低8位。

Jmp &my_label	{`brch, `drt, `cnd_non, `jmp_next, 8’hxx}
Jz & my_label	{`brch, `drt, `cnd_z, `jmp_next, 8’hxx}
Jnz & my_label	{`brch, `drt, `cnd_nz, `jmp_next, 8’hxx}
Jc & my_label	{`brch, `drt, `cnd_c, `jmp_next, 8’hxx}
Jnc & my_label	{`brch, `drt, `cnd_nz, `jmp_next, 8’hxx}
Jw & my_label	{`brch, `drt, `cnd_non, `jmp_wait, 8’hxx}
Jmp @ r1r0	{`brch, `ptr, `cnd_non, `jmp_next, 8’h00}
Jz @ r1r0	{`brch, `ptr, `cnd_z, `jmp_next, 8’h00}
Jnz @ r1r0	{`brch, `ptr, `cnd_nz, `jmp_next, 8’h00}
Jc @ r1r0	{`brch, `ptr, `cnd_c, `jmp_next, 8’h00}
Jnc @ r1r0	{`brch, `ptr, `cnd_nc, `jmp_next, 8’h00}
Jw @ r1r0	{`brch, `ptr, `cnd_non, `jmp_wait, 8’h00}

Add rega regb	{`arth, `add, `rega, `regb}
Sub rega regb	{`arth, `sub, `rega, `regb}
Mul rega regb	{`arth, `mul, `rega, `regb}
Mac rega regb	{`arth, `mac, `rega, `regb}
Div rega regb	{`arth, `div, `rega, `regb}
Sqt rega regb	{`arth, `sqt, `rega, `regb}

Nop	{16’b0}
Shl 0nmb regs	{`shft, `left, `with_0, `act, `nmb, `regs}
Shl 1nmb regs	{`shft, `left, `with_1, `act, `nmb, `regs}
Shl snmb regs	{`shft, `left, `with_s, `act, `nmb, `regs}
Rttlregs	{`shft, `left, `with_r, `act, 1’b1, `regs}
Shr 0nmb regs	{`shft, `right, `with_0, `act, `nmb, `regs}
Shr 1nmb regs	{`shft, `right, `with_1, `act, `nmb, `regs}
Shr snmb regs	{`shft, `right, `with_s, `act, `nmb, `regs}
Rttrregs	{`shft, `right, `with_r, `act, 1’b1, `regs}

Ldregs #立即数	{`ldst, `ld_drt_data, `regs, 8’h立即数}
Ldregs &立即地址	{`ldst, `ld_drt_addr, `regs, `立即数据地址}
Stregs &立即地址	{`ldst, `st_drt_addr, `regs, `立即数据地址}
Ldrega regb	{`ldst, `reg_or_ptr, `rega, `ld_reg, `regb}
Strega regb	{`ldst, `reg_or_ptr, `rega, `st_reg, `regb}
Ldregs @ r1r0	{`ldst, `reg_or_ptr, `regs, `ld_ptr, 4’b0}
Stregs @ r1r0	{`ldst, `reg_or_ptr, `regs, `st_ptr, 4’b0}

程序地址分配，Label程序地址替换

每一行有效语句分配一个16位16进制的程序地址。对于注释行不分配；对于label行，其表示的是下一行有效语句的地址。

源程序内跳转指令中的跳转目标地址会使用label表示，汇编器把label替换为label表示的实际地址的低8位。把跳转指令之前的“#label_page”替换为label表示的实际地址的高8位。

数据地址替换

保留源程序中的数据地址到输出文件1。同时将其输出到文件2。

宏定义的展开

使用macro_def: name(base_para)标记一段对程序的宏定义。在程序中通过macro_gen:
name(base_arg)引用，汇编器将这一段宏定义展开，展开时用base_arg添加到宏定义代码段中的立即地址之前。

输入范例

; an input file example

              mul        r32_0   r32_1

%my_label  ld        r64_0   &alu_result

              ld          r3          #my_label_page

jz           my_label

              st         r64_0     &data_save

           ld          r1          #5a

输出文件1范例

16’h0000: begin instr = {`arth, `mul, `r32_0, `r32_1}                     ; end

16’h0001: begin instr = {`ldst, `ld_drt_addr, `r64_0, `alu_result }    ; end

16’h0002: begin instr = {`ldst, `ld_drt_data, `r3, 8’h00 }                ;end

16’h0003: begin instr = {`brch, `drt, `cnd_z, `jmp_next, 8’h01}            ; end

16’h0004: begin instr = {`ldst, `st_drt_addr, `r64_0, `data_save}             ; end

16’h0005: begin instr = {`ldst, `ld_drt_data, `r2, 8’h5a}                ; end

输出文件2范例

`define alu_result  8’h00

`define data_save   8’h01

二、实现

用VS2013控制台实现

1、需要转换的文件格式如下：

macrostart

macro_def : test1 ( base_para )
{
st r64_0 & data_save
ld r1 # 5a
arth_mus r32_0 r32_1
}

macro_def : test2 ( base_para )
{
arth_mus r32_0 r32_1
% my_label :
ld r64_0 & alu_result
jnz & my_label
}

datastart

; an input file example

arth_mus r32_0 r32_1
st r64_0 & szy_data_save
ld r1 # 5a
arth_mus r32_0 r32_1

ld r1 # 5a
arth_mus r32_0 r32_1

arth_mus r32_0 r32_1
st r64_0 & szy_data_save
ld r1 # 5a
arth_mus r32_0 r32_1

macro_gen : test2 ( lpf )

% my_label :
ld r64_0 & alu_result
ld r3 # my_label_page
jz & my_label
arth_mus r32_0 r32_1

macro_gen : test1 ( cic )

% szy_my_label :
ld r64_0 & szy_alu_result
st r64_0 & data_save
ld r1 # 5a

由于需要区别宏和数据，我用了macrostart和datastart分开这两部分。

2、需要的参数如下：

（至少两个参数）程序 输入文件

如果多余两个参数，则对参数进行分类：一类是以"-"开头的，一类则是文件（输入文件和输出文件）

对于以"-"开头的，目前只识别 -d、-r、-md、-m

这四个参数分别表示处理完翻译之后会打印 最终数据、寄存器信息、宏展开后的数据、宏信息

最多有5个文件，若有5个文件，则分别表示 （若不足5个，那就只处理相应的前几个文件）

输入文件、最终数据文件、寄存器信息文件、宏展开后的数据文件、宏信息文件

//命令行参数处理
set<int> paraset;//带‘-’参数集合，存储的是到全局数组的偏移量
vector<string> filelist;//文件列表
for (int i = 1; i < argc; i++)
{
string currpara(argv[i]);
if (currpara.empty())continue;

if (currpara[0] == '-')//带‘-’参数
{
//判断能否识别这个参数
auto it = find(g_para, g_para + g_paran, currpara);
if (it == g_para + g_paran)//没有找到
{
cout << "\nerror: not indentifies the \"" << currpara << "\".\n";
cout << "----------------------------------\n";
return 0;
}
paraset.insert(it - g_para);
}
else filelist.push_back(currpara);//文件
}

if (filelist.empty())
{
cout << "\nerror: not find infile.\n";
cout << "----------------------------------\n";
return 0;
}
else if (filelist.size() > 5)
{
cout << "\nerror: file num too more(greater than 5).\n";
cout << "----------------------------------\n";
return 0;
}

默认第二个参数是输入的文件。

g_para和g_paran是两个全局变量：

//四个带-的参数: -d,-rd,-md,-m
const int g_paran = 4;
const string g_para[g_paran] = { "-d", "-r", "-md", "-m" };//依次会打印asmalgorithm中的私有成员
enum g_parai{ D = 0, R, MD, M };


3、读取需要转换的文件

//获取输入文件数据
string filedata;//文件数据
string errmsg;
if (!ReadFile(filelist[0], filedata, errmsg))//获取数据
{
cout << "\n" << errmsg << "\nexit!\n";
cout << "----------------------------------\n";
return 0;
}

ReadFile实现为：

bool ReadFile(const string &file, string & filedata, std::string &errmsg)
{
filedata.clear();
errmsg.clear();

ifstream fin;
fin.open(file.c_str());
if (!fin.is_open())
{
errmsg = "not open file: \"" + file + "\"";
return false;
}

ostringstream ss;
ss << fin.rdbuf();

filedata = ss.str();

fin.close();

return true;
}

4、转换文件

//处理输入的文件数据
AsmAlgorithm myasm;
if (!myasm.Handle(filedata,errmsg))//处理数据
{
cout << "\n" << errmsg << "\nexit!\n";
cout << "----------------------------------\n";
return 0;
}

定义了一个类AsmAlgorithm，用它的Handle成员来统一处理。

5、AsmAlgorithm类

AsmAlgorithm类如下：

class AsmAlgorithm
{
public:
AsmAlgorithm();
~AsmAlgorithm();

public://行为

//核心算法处理
/*
总处理函数
对于原始文件的一行，判断是哪种处理，并调用相应处理, 然后包裹格式来获取新行
*/
bool Handle(const std::string &idata, std::string & errmsg);

//获取数据成员信息
const std::vector<std::string>& GetData();
const std::vector<std::string>& GetReg();
const std::vector<std::vector<std::string>>& GetMacroData();
const std::set<MacroInfo>& GetMacro();

private:
//注释处理 无

//标签处理
static bool LabelHandle(const int cmdindex, const std::vector<std::string> &isource,
std::vector<std::string> &odst, std::string &errmsg);

//跳转处理  拿到输入的数据，按照某种格式输出
static bool JumpHandle(const int cmdindex, const std::vector<std::string> &isource,
std::vector<std::string> &odst, std::string &errmsg);

//操作处理
static bool OperatorHandle(const int cmdindex, const std::vector<std::string> &isource,
std::vector<std::string>&odst, std::string &errmsg);

//shell处理
static bool ShellHandle(const int cmdindex, const std::vector<std::string> &isource,
std::vector<std::string>&odst, std::string &errmsg);

//传送处理
static bool TransmitHandle(const int cmdindex, const std::vector<std::string> &isource,
std::vector<std::string>&odst, std::string &errmsg);

//////////////////////////////////////////////////////////////////////////
//辅助方法
//大写转小写
static std::string MyToLower(const std::string & str);

//包裹函数 把一个容器包装成一个字符串 对应于文件1中的字符串格式
static std::string Wrapper(const std::vector<std::string> isource);

//包裹文件2的字符串格式
static std::string Wrapper(const std::pair<std::string, int> & regitem);

//添加一个立即地址到寄存器列表中
static void AddRegAddr(const std::string ®);

//拼接错误函数
static std::string SplitError(const std::string &cause, const std::string &line);

//获取宏域内的信息
static bool GetMacroInfo(const std::string &data, std::set<MacroInfo> &odata, std::string & errmsg);

//获取数据域内的信息
static bool GetDataAreaInfo(const std::string &idata, const std::set<MacroInfo> &vmi,
std::vector<std::vector<std::string>> &odata, std::string &errmsg);

private:
std::vector<std::string >		m_data;//最终的数据信息，若有文件1，将会写入到文件1
std::vector<std::string >		m_reg;//寄存器信息，若有文件2，将会写入到文件2
std::vector<std::vector<std::string>>	m_macrodata;//宏展开后的数据信息，若有文件3，将会写入到文件3
std::set<MacroInfo>			m_macro;//宏信息，若有文件4，将会写入到文件4
};

其中MacroInfo这个宏定义成了：

struct MacroInfo
{
std::string name;//这个宏的名字
std::string parameter;//这个宏的参数
std::vector<std::vector<std::string>> cmdlist;//这个宏里面的命令列表
friend bool operator<(const MacroInfo &item1, const MacroInfo &item2)
{
return item1.name < item2.name;
}
};

6、一些全局变量以及宏等

//宏定义和展开的入口
#define MACRODEF "macro_def"
#define MACROGEN "macro_gen"

//当前行地址
static int g_currlineaddr = -1;//<=0xffffffff

//寄存器地址
static int g_regaddr = -1;//<=0xff
vector<pair<string, int>> g_reglist;//寄存器列表

//标签地址
static map<string, int> g_labeladdrmap;//<标签，地址>

//注释处理的助记符
static const string	g_NC = ";";//note cmd

//标签处理的助记符
static const string	g_LS = "%";//label start
static const string	g_LE = ":";//label end

//跳转处理的的助记符
static const int	g_JCN = 6;//Jump cmd num
static const string	g_JC[g_JCN] = { "jmp", "jz", "jnz", "jc", "jnc", "jw" };//Jump cmd
enum			g_JCI{ JMP = 0, JZ, JNZ, JC, JNC, JW };//Jump cmd index
static const int	g_JFN = 2;//Jump  flag num
static const string	g_JF[g_JFN] = { "&", "@" };//Jump flag
enum			g_JFI{ JAND = 0, JAT };//Jump cmd flag

//操作处理的的助记符
static const string	g_OP = "arth_";//operator prefix
static const string	g_OC = "arth";//operator cmd

//shell处理的助记符
static const int	g_SCN = 5;//shell cmd num
static string		g_SC[g_SCN] = { "nop", "shl", "rttl", "shr", "rttr" };//shell cmd
enum			g_SCI{ NOP = 0, SHL, RTTL, SHR, RTTR };//shell cmd index
static const int	g_SFN = 3;//shell flag num
static string		g_SF[g_SFN] = { "0", "1", "s" };//shell flag
enum			g_SFI{ SFI0 = 0, SFI1, SFIS };//shell flag index

//传送处理的助记符
static const int	g_TCN = 2;//transmit cmd num
static string		g_TC[g_TCN] = { "ld", "st" };//transmit cmd
enum			g_TCI{ LD = 0, ST };//transmit cmd index
static const int	g_TFN = 3;//transmit flag num
static string		g_TF[g_TFN] = { "#", "&", "@" };//transmit flag num
enum			g_TFI{TWELL=0,TAND,TAT};//transmit flag index

7、AsmAlgorithm处理

Handle成员：

数据准备工作：

bool AsmAlgorithm::Handle(const string &idata,string & errmsg)
{
errmsg.clear();

//私有数据的初始化
m_macro.clear();
m_macrodata.clear();
m_data.clear();
m_reg.clear();

g_labeladdrmap.clear();//清空标签地址
g_reglist.clear();//清空寄存器地址信息

接着查找宏域和数据域

/*
获取的文件数据
它有两部分，宏和数据(宏不是必须存在的（若存在，则必须在数据域前面），数据是必须存在的)
用macrostart开始的是宏，直到遇到datastart
用datastart开始的是数据，直到文件结束
*/
/*
宏的格式：文件数据中遇到这个宏名时会把里面的标签(格式为 % label :)
和 &地址（跳转中的&地址和传送中的地址）添加相应的label和地址的前缀（实参_）
macro_def : 宏名 （ 参数 )
{
文件数据中的数据格式
}
例如：
macro_def : test1 ( base_para )
{
st 		r64_0	& data_save
ld		r1		# 5a
mul		r32_0 	r32_1
}
*/

//////////////////////////////////////////////////////////////////////////
//查找宏区域
auto macrostart = idata.find(MACROSTART);//查找macrostart
string tmpstr(idata.substr(0,macrostart));
int LF = tmpstr.rfind("\n");//从后往前找换行符,行首
if (LF + 1 != macrostart)//行首的下一个不是macrostart
{
errmsg = SplitError("\"macrostart\" is not at top of line",
idata.substr(LF+1, macrostart - LF) + MACROSTART + "...");
return false;
}

//查找数据区域
auto datastart = idata.find(DATASTART);//查找datastart
tmpstr = idata.substr(0, datastart);
LF = tmpstr.rfind("\n");//从后往前找换行符,行首
if (LF + 1 != datastart)//行首的下一个不是datastart
{
errmsg = SplitError("\"datastart\" is not at top of line",
idata.substr(LF+1, datastart - LF) + DATASTART + "...");
return false;
}

//判断宏域和数据域的位置关系
if (datastart == string::npos)//没有找到数据域开始的部分
{
errmsg = "not find data area from the infile.\n";
return false;
}
if (macrostart != string::npos && macrostart > datastart)//宏域在数据域之后，错误
{
errmsg = "the macrostart is not at behand of datastart.\n";
return false;
}

处理宏域并宏展开：

//////////////////////////////////////////////////////////////////////////
if (macrostart != string::npos)//有宏域
{
//处理宏域
if (!GetMacroInfo(idata.substr(macrostart, datastart - macrostart), m_macro, errmsg))
return false;
}

//宏展开和填写标签地址信息
if (!GetDataAreaInfo(idata.substr(datastart), m_macro, m_macrodata, errmsg))
return false;

处理完宏域之后，接着处理数据域（把它们放入一个vector的m_macrodata里面），处理数据域时，遇到宏定义需要宏展开（宏的信息在m_macro中），并且还需要填写标签地址信息（标签地址信息是一个全局变量g_labeladdrmap）。

数据处理：

//////////////////////////////////////////////////////////////////////////
//数据处理。。。
using fun_manager =
bool(*)(const int, const vector<string> &, vector<string> &, string &);//函数对象
vector<string> cmdlist;//命令列表，含所有命令
map<int, fun_manager,greater<int>> cmdfunmap;//函数对象的映射关系
cmdfunmap.insert({ cmdlist.end() - cmdlist.begin(), LabelHandle });
cmdlist.push_back(g_LS);//标签 0
cmdfunmap.insert({ cmdlist.end() - cmdlist.begin(), JumpHandle });
cmdlist.insert(cmdlist.end(), g_JC, g_JC + g_JCN);//跳转
cmdfunmap.insert({ cmdlist.end() - cmdlist.begin(), OperatorHandle });
cmdlist.insert(cmdlist.end(), g_OC);//操作
cmdfunmap.insert({ cmdlist.end() - cmdlist.begin(), ShellHandle });
cmdlist.insert(cmdlist.end(), g_SC, g_SC + g_SCN);//shell
cmdfunmap.insert({ cmdlist.end() - cmdlist.begin(), TransmitHandle });
cmdlist.insert(cmdlist.end(), g_TC, g_TC + g_TCN);//传送

for (vector<vector<string>>::size_type i = 0; i < m_macrodata.size(); i++)
{//执行原始文件的每一行
vector<string> oldformat = m_macrodata[i];//获取输入的数据格式
string cmd(MyToLower(oldformat[0]));//获取命令

auto cmdit = find(cmdlist.begin(), cmdlist.end(), cmd);//查找这个命令是否存在
if (cmdit == cmdlist.end())//没有找到
{
errmsg = SplitError("command is not find", Vector2String(oldformat));
return false;
}
const int cmdoffset = cmdit - cmdlist.begin();//cmd的偏移
const auto realit = find_if(cmdfunmap.cbegin(), cmdfunmap.cend(), //获取需要执行的cmd属于哪一类
[cmdoffset](const pair<int, fun_manager>&item){return cmdoffset >=item.first; });

vector<string> newformat;//输出的数据格式

//需要执行function的命令
if (!realit->second(cmdoffset - realit->first, oldformat, newformat, errmsg))
{
return false;
}

if (realit->first == 0)//标签的处理，不用添加到输出容器中
{
continue;
}

string newline = Wrapper(newformat);//包裹起来

//追加到新容器中，之后会把这个容器的内容写到目标文件中
m_data.push_back(newline);
}

我把需要转换的命令分成了五类：标签（%开头的）、跳转（J开头的）、操作（add、sub、mul等）、shell（nop、shl、rttl等）、传送（ld，st），它们不区分大小写，我统一用MyToLower转换成小写了。

fun_manager在必要的时候分别指向这五类函数。

主要算法是遍历每一行，通过命令来判断这一行应该属于哪一类处理，然后调用相应的函数来处理这一行数据。

再介绍辅助函数

MyToLower：

string AsmAlgorithm::MyToLower(const string & str)
{
string ret;

for (string::size_type i = 0; i < str.size();i++)
{
ret += tolower(str[i]);
}

return ret;
}

Wrapper：

string AsmAlgorithm::Wrapper(const vector<string> isource)
{//格式：16’h0000: begin instr = {`arth, `mul, `r32_0, `r32_1}; end
g_currlineaddr++;
if (g_currlineaddr > 0xffffffff)
{
g_currlineaddr = 0;
}

char sztmp[50] = { 0 };//前缀部分
MySprintf(sztmp, sizeof(sztmp), "16'h%04x : begin instr = ", (short)(g_currlineaddr));

string vsstr = "{" + Vector2String(isource, ",") + "}";//数据部分

ostringstream sout;
sout << sztmp << setw(45) << left << vsstr << ";end";
return sout.str();
}

std::string AsmAlgorithm::Wrapper(const std::pair<std::string, int> & regitem)
{//格式： `define alu_result	8’h00

char regstr[10] = { 0 };
MySprintf(regstr, sizeof(regstr), " 8'h%02x", (char)(regitem.second));

ostringstream sout;
sout << "`define " << setw(15) << left << regitem.first.c_str() << regstr;

return sout.str();
}

SplitError：

string AsmAlgorithm::SplitError(const string &cause, const string &line)
{
char szerr[300] = { 0 };
MySprintf(szerr, sizeof(szerr), "error[%s]: \"%s\"\n", cause.c_str(), line.c_str());

return string(szerr);
}

因为我的程序也会在gcc下编译，所以MySprintf是：

#if defined(_WIN32)|| defined(WIN32) || defined(_WIN64) || defined(WIN64) || defined(_WIN32_WINNT)
#define  MySprintf	sprintf_s//Win下
#else
#define  MySprintf	snprintf//linux下
#endif

AddRegAddr：

void AsmAlgorithm::AddRegAddr(const std::string ®)
{
g_regaddr++;
if (g_regaddr > 0xff)
{
g_regaddr = 0;
}

g_reglist.push_back(pair<string, int>(reg, g_regaddr));
}

处理宏域的GetMacroInfo：

bool AsmAlgorithm::GetMacroInfo(const string &data, set<MacroInfo> &odata, string &errmsg)
{
/*
格式
macro_def : test1 ( base_para )
{
st 		r64_0	& data_save
ld		r1		# 5a
mul		r32_0 	r32_1
}
*/

stringstream sin(data);

string line;
getline(sin, line);//第一行的格式应该是 macrostart
vector<string> FML = String2Vector(line);//first macro list
if (FML.size() != 1 || FML[0] != MACROSTART)//不是“macrostart”格式
{
errmsg = SplitError("format is not \"macrostart\"", line);
return false;
}

//先获取所有数据到容器里面,
//空行舍弃、只含有空格的行也舍弃，以;开头的行（注释行）也舍弃
vector<vector<string>> linelist;
while (getline(sin, line))
{
if (line.empty()) continue;//空行
vector<string> s2v = String2Vector(line);
if (s2v.empty()) continue;//只含有空格的行
if (s2v[0] == g_NC) continue;//注释行
linelist.push_back(s2v);
}

//对每一行，开始找macro_def
const int linesize = linelist.size();
int titleline = 0;
for (int i = 0; i < linesize; i++)
{
vector<string> itemlist = linelist[i];

if (itemlist.size() != 6
|| itemlist[0] != MACRODEF
|| itemlist[1] != ":"
|| itemlist[3] != "("
|| itemlist[5] != ")")//这个macro_def不符合格式，错误
{
errmsg = SplitError("format is not \"macro_def : name ( base_para )\"", Vector2String(linelist[i]));
return false;
}
//找到这个宏的题头了
MacroInfo info;
info.name = itemlist[2];
info.parameter = itemlist[4];
titleline = i;//记录下题头行

//开始找这个宏包含的命令信息
//先找{符号
i++;
if (i == linesize)
{
errmsg = SplitError("not find the \"{\" after the macrotitile", Vector2String(linelist[titleline]));
return false;
}
itemlist = linelist[i];
if (!(itemlist.size() == 1 && itemlist[0] == "{"))//这行不是只含有{，则认为是错的
{
errmsg = SplitError("the line is not \"{\" after macrotitle", Vector2String(linelist[titleline]));
errmsg += "it is \"" + Vector2String(linelist[i]) + "\"\n";
return false;
}

//开始找命令行信息了
bool bfindend = false;//用}来判断这个宏的结束
for (i++; i < linesize;i++)
{
itemlist = linelist[i];
if (itemlist.size() == 1 && itemlist[0] == "}")//找到一个只含有}的行
{
bfindend = true;
break;
}
info.cmdlist.push_back(itemlist);
}
if (!bfindend)//遍历完宏域，都没有找到}，则认为是错的
{
errmsg = SplitError("not find the \"}\" of the macro_def", Vector2String(linelist[titleline]));
return false;
}

//找到}了
//判断以前是否有这个宏定义
auto it = find_if(odata.begin(), odata.end(),
[info](const MacroInfo &item){return info.name == item.name; });
if (it != odata.end())//这个宏定义已经存在了
{
errmsg = "the macro define of \"" + info.name + "\"have 2 times or more.\n";
return false;
}
odata.insert(info);
}

return true;
}

获取数据域内的信息GetDataAreaInfo：

bool AsmAlgorithm::GetDataAreaInfo(const string &idata, const set<MacroInfo> &vmi,
vector<vector<string>> &odata,string &errmsg)
{//遇到宏定义需要展开,并填写标签地址
odata.clear();
errmsg.clear();

stringstream sin(idata);

string line;
getline(sin, line);//第一行的格式应该是 datastart
vector<string> FDL = String2Vector(line);//first data list
if (FDL.size() != 1 || FDL[0] != DATASTART)//不是“datastart”格式
{
errmsg = SplitError("format is not \"datastart\"", line);
return false;
}

while (getline(sin, line))
{
if (line.empty())continue;//空行
vector<string> linelist = String2Vector(line);//拆分当前行
if (linelist.empty())continue;//只有空格的行
if (linelist[0] == g_NC)continue;//注释行舍弃

string firstitem = MyToLower(linelist[0]);
const auto findpos = firstitem.find(g_OP);//查找operator处理
if (findpos == 0)//找到 arth_
{
linelist.insert(linelist.begin(), g_OC);
linelist[1] = firstitem.substr(g_OP.size());
}

const string cmd(linelist[0]);//获取命令

//只有宏展开入口macro_gen
if (cmd == MACROGEN)//宏展开
{
if (linelist.size() != 6
|| linelist[0] != MACROGEN
|| linelist[1] != ":"
|| linelist[3] != "("
|| linelist[5] != ")")//这个macro_gen不符合格式
{
errmsg = SplitError("format is not \"macro_gen : name ( para )\"", line);
return false;
}

//将这一行替换为宏定义
//查找这个宏
auto macroit = find_if(vmi.begin(), vmi.end(),
[linelist](const MacroInfo &item){return linelist[2] == item.name; });
if (macroit == vmi.end())//没有找到这个宏定义
{
errmsg = "not find macro define of the \"" + linelist[2] + "\".\n";
return false;
}

for (vector<vector<string>>::size_type i = 0; i < macroit->cmdlist.size(); i++)
{//把标签和&的都添加前缀
vector<string> itemlist = macroit->cmdlist[i];//获取一个命令行的容器

const string mcmd(MyToLower(itemlist[0]));//获取命令

string firstitem = MyToLower(itemlist[0]);
const auto findpos = firstitem.find(g_OP);//查找operator处理
if (findpos == 0)//找到 arth_
{
itemlist.insert(itemlist.begin(), g_OC);
itemlist[1] = firstitem.substr(g_OP.size());
}

//跳转
auto jumpit = find_if(g_JC, g_JC + g_JCN,
[mcmd](const string & item){return item == mcmd; });

//传送
auto tramsit = find_if(g_TC, g_TC + g_TCN,
[mcmd](const string & item){return item == mcmd; });

if (jumpit != g_JC + g_JCN)//跳转处理
{
if (itemlist.size() == 3 && itemlist[1] == g_JF[g_JFI::JAND])//是jxx & xxx
{
itemlist[2] = linelist[4] + "_" + itemlist[2];
}
odata.push_back(itemlist);
}
else if (tramsit != g_TC + g_TCN)//传送处理
{
if (itemlist.size() == 4 && itemlist[2] == g_TF[g_TFI::TAND])//是 ld/st xxx & xxx
{
itemlist[3] = linelist[4] + "_" + itemlist[3];
}
odata.push_back(itemlist);
}
else if (mcmd==g_LS)//标签
{
if (itemlist.size() == 3 && itemlist[2] == g_LE)//完全匹配标签
{
itemlist[1] = linelist[4] + "_" + itemlist[1];
odata.push_back(itemlist);

//写到标签地址中
g_labeladdrmap[itemlist[1]] = odata.size() - g_labeladdrmap.size() - 1;
}
else
{
errmsg = SplitError("format is not \"% label :\" from macro \"" + macroit->name + "\"",
Vector2String(itemlist));
return false;
}
}
else//宏中的其他命令
{
odata.push_back(itemlist);
}
}
}
else//除了宏之外的行信息
{
if (cmd == g_LS)//标签行
{
if (linelist.size() == 3 && linelist[2] == g_LE)//完全匹配标签
{
odata.push_back(linelist);

//写到标签地址中
g_labeladdrmap[linelist[1]] = odata.size() - g_labeladdrmap.size() - 1;
}
else
{
errmsg = SplitError("format is not \"% label :\"", line);
return false;
}
}
else//其他的行
{
odata.push_back(linelist);
}
}
}

return true;
}

最后介绍五类转换函数：

标签的LabelHandle：

bool AsmAlgorithm::LabelHandle(const int cmdindex, const vector<string> &isource,
vector<string> &odst, string &errmsg)
{//格式 % label : //为了和另外几个xxxHandle函数统一，也用了输出容器，其实不需要输出容器
odst.clear();
errmsg.clear();

if (isource.size() != 3 || isource[2] != g_LE)
{
errmsg = AsmAlgorithm::SplitError("format is not \"% label :\"", Vector2String(isource));
return false;
}

//添加到地址 其实在宏展开的时候就已经写好了
g_labeladdrmap[isource[1]] = g_currlineaddr + 1;

return true;
}

这里为了和另外几个转换函数风格一致，我用了isource容器，但用不上，需要注意这个isource不能添加到输出容器中。

跳转的JumpHandle：

bool AsmAlgorithm::JumpHandle(const int cmdindex, const vector<string> &isource,
vector<string> &odst, string &errmsg)
{//格式 jxx &/@ label/r1r0
/*
Jmp & my_label	{`brch, `drt, `cnd_non, `jmp_next, 8’hxx}
Jz & my_label		{`brch, `drt, `cnd_z, `jmp_next, 8’hxx}
Jnz & my_label	{`brch, `drt, `cnd_nz, `jmp_next, 8’hxx}
Jc & my_label		{`brch, `drt, `cnd_c, `jmp_next, 8’hxx}
Jnc & my_label	{`brch, `drt, `cnd_nc, `jmp_next, 8’hxx}
Jw & my_label		{`brch, `drt, `cnd_non, `jmp_wait, 8’hxx}

Jmp @ r1r0		{`brch, `ptr, `cnd_non, `jmp_next, 8’h00}
Jz @ r1r0		{`brch, `ptr, `cnd_z, `jmp_next, 8’h00}
Jnz @ r1r0		{`brch, `ptr, `cnd_nz, `jmp_next, 8’h00}
Jc @ r1r0		{`brch, `ptr, `cnd_c, `jmp_next, 8’h00}
Jnc @ r1r0		{`brch, `ptr, `cnd_nc, `jmp_next, 8’h00}
Jw @ r1r0		{`brch, `ptr, `cnd_non, `jmp_wait, 8’h00}
*/

odst.clear();
errmsg.clear();

if (isource.size() != 3)
{
errmsg = SplitError("format is not \"jxx &/@ label/r1r0\"", Vector2String(isource));
return false;
}

string flag(MyToLower(isource[1]));//获取符号

auto flagit = find(g_JF, g_JF + g_JFN, flag);//查找符号
if (flagit == g_JF + g_JFN)//没找到符号
{
errmsg = SplitError("not find flag \"@/&\"", Vector2String(isource));
return false;
}

if (*flagit == g_JF[g_JFI::JAND])//&
{
if (g_labeladdrmap.find(isource[2]) == g_labeladdrmap.end())//查找标签
{//没找到
errmsg = SplitError("not find the label address", Vector2String(isource));
return false;
}

string tmparray[5] = { "`brch", "`drt", "`cnd_non", "`jmp_next", "8'h" };
odst.assign(tmparray, tmparray + 5);
char sztmp[20] = { 0 };
MySprintf(sztmp, sizeof(sztmp), "%02x", (char)(g_labeladdrmap[isource[2]]));
odst[4] += sztmp;

switch (cmdindex)
{
case g_JCI::JMP:
break;
case g_JCI::JZ:
odst[2] = "`cnd_z";
break;
case g_JCI::JNZ:
odst[2] = "`cnd_nz";
break;
case g_JCI::JC:
odst[2] = "`cnd_c";
break;
case g_JCI::JNC:
odst[2] = "`cnd_nc";
break;
case g_JCI::JW:
odst[3] = "`jmp_wait";
break;
default:
errmsg = SplitError("format is not \"jxx &/@ label/r1r0\"", Vector2String(isource));
return false;
}

return true;
}
else //@
{
if (MyToLower(isource[2]) != MyToLower("r1r0"))
{
errmsg = SplitError("not defined", Vector2String(isource));
return false;
}

string tmparray[5] = { "`brch", "`ptr", "`cnd_non", "`jmp_next", "8'h00" };
odst.assign(tmparray, tmparray + 5);

switch (cmdindex)
{
case g_JCI::JMP:
break;
case g_JCI::JZ:
odst[2] = "`cnd_z";
break;
case g_JCI::JNZ:
odst[2] = "`cnd_nz";
break;
case g_JCI::JC:
odst[2] = "`cnd_c";
break;
case g_JCI::JNC:
odst[2] = "`cnd_nc";
break;
case g_JCI::JW:
odst[3] = "`jmp_wait";
break;
default:
errmsg = SplitError("format is not \"jxx &/@ label/r1r0\"", Vector2String(isource));
return false;
}

return true;
}
}

操作的OperatorHandle：

bool AsmAlgorithm::OperatorHandle(const int cmdindex, const vector<string> &isource,
vector<string>&odst, string &errmsg)
{//格式 operator rega regb
/*
Add rega regb	{`arth, `add, `rega, `regb}
Sub rega regb	{`arth, `sub, `rega, `regb}
Mul rega regb	{`arth, `mul, `rega, `regb}
Mac rega regb	{`arth, `mac, `rega, `regb}
Div rega regb	{`arth, `div, `rega, `regb}
Sqt rega regb	{`arth, `sqt, `rega, `regb}
*/

odst.clear();
errmsg.clear();

if (isource.size() != 4)
{
errmsg = SplitError("format is not \"operator rega regb\"", Vector2String(isource));
return false;
}

//{`arth, `add, `rega, `regb}
odst.push_back("`" + isource[0]);
odst.push_back("`" + isource[1]);
odst.push_back("`" + isource[2]);
odst.push_back("`" + isource[3]);

return true;
}

shell的ShellHandle：

bool AsmAlgorithm::ShellHandle(const int cmdindex, const vector<string> &isource,
vector<string>&odst, string &errmsg)
{//格式 Shl 0 nmb regs
/*
Nop {16’b0}
Shl 0 nmb regs {`shft, `left, `with_0, `act, `nmb, `regs}
Shl 1 nmb regs {`shft, `left, `with_1, `act, `nmb, `regs}
Shl s nmb regs {`shft, `left, `with_s, `act, `nmb, `regs}
Rttl regs {`shft, `left, `with_r, `act, 1’b1, `regs}

Shr 0 nmb regs {`shft, `right, `with_0, `act, `nmb, `regs}
Shr 1 nmb regs {`shft, `right, `with_1, `act, `nmb, `regs}
Shr s nmb regs {`shft, `right, `with_s, `act, `nmb, `regs}
Rttr regs {`shft, `right, `with_r, `act, 1’b1, `regs}
*/

odst.clear();
errmsg.clear();

string tmparray[6] = { "`shft", "`left", "`with_", "`act", "`", "`" };
odst.assign(tmparray, tmparray + 6);

switch (cmdindex)
{
case g_SCI::NOP:
{
if (isource.size() != 1)
{
errmsg = SplitError("format is not \"nop\"", Vector2String(isource));
return false;
}
odst.clear();
odst.push_back("16'b0");
break;
}
case g_SCI::RTTL:
case g_SCI::RTTR:
{
if (isource.size() != 2)
{
errmsg = SplitError("format is not \"rttl/rttr regs\"", Vector2String(isource));
return false;
}
odst[2] = "`with_r";
odst[4] = "1'b1";
odst[5] += isource[1];
if (cmdindex == g_SCI::RTTR)
{
odst[1] = "`right";
}
break;
}
case g_SCI::SHL:
case g_SCI::SHR:
{
if (isource.size() != 4)
{
errmsg = SplitError("format is not \"shl/shr 0/1/s nmb regs\"", Vector2String(isource));
return false;
}

string flag(MyToLower(isource[1]));//获取符号
auto flagit = find(g_SF, g_SF + g_SFN, flag);
if (flagit == g_SF + g_SFN)//没找到
{
errmsg = SplitError("not find flag \"0/1/s\"", Vector2String(isource));
return false;
}

odst[2] += g_SF[flagit - g_SF];
odst[4] += isource[2];
odst[5] += isource[3];
if (cmdindex == g_SCI::SHR)
{
odst[1] = "`right";
}
break;
}
default:
{
errmsg = SplitError("format is not \"nop/shl/shr/rttl/rttr ...\"", Vector2String(isource));
return false;
}
}

return true;
}

传送的TransmitHandle：

bool AsmAlgorithm::TransmitHandle(const int cmdindex, const vector<string> &isource,
vector<string>&odst, string &errmsg)
{//格式 ld/st regx #/&/@/_ xxx
/*
Ld regs # 立即数		{`ldst, `ld_drt_data, `regs, 8’h立即数}
Ld regs & 立即地址	{`ldst, `ld_drt_addr, `regs, `立即数据地址}
St regs & 立即地址	{`ldst, `st_drt_addr, `regs, `立即数据地址}
Ld rega regb			{`ldst, `reg_or_ptr, `rega, `ld_reg, `regb}
St rega regb			{`ldst, `reg_or_ptr, `rega, `st_reg, `regb}
Ld regs @ r1r0		{`ldst, `reg_or_ptr, `regs, `ld_ptr, 4’b0}
St regs @ r1r0		{`ldst, `reg_or_ptr, `regs, `st_ptr, 4’b0}
*/

odst.clear();
errmsg.clear();

const int isourcesize = isource.size();
if (isourcesize != 3 && isourcesize != 4)
{
errmsg = SplitError("format is not \"ld/st regx #/&/@/_ xxx\"", Vector2String(isource));
return false;
}

if (isourcesize == 3)
{
string temparray[5] = { "`ldst", "`reg_or_ptr", "`", "`ld_reg", "`" };
odst.assign(temparray, temparray + 5);
odst[2] += isource[1];
odst[4] += isource[2];
if (cmdindex==g_TCI::ST)
{
odst[3] = "`st_reg";
}
return true;
}
else//4个元素
{
auto flagit = find(g_TF, g_TF + g_TFN, isource[2]);//查找标志
if (flagit == g_TF + g_TFN)//没找到
{
errmsg = SplitError("not find flag \"#/&/@\"", Vector2String(isource));
return false;
}

const int flagoffset = flagit - g_TF;//获取标志所在的偏移量
switch (flagoffset)
{
case g_TFI::TWELL://#
{
string temparray[4] = { "`ldst", "`ld_drt_data", "`", "8'h"};
odst.assign(temparray, temparray + 4);
odst[2] += isource[1];

//判断是label_page还是立即数
const auto findpos = isource[3].rfind("_page");
if (findpos == string::npos)//没找到 _page
{
odst[3] += isource[3];
}
else
{
string label = isource[3].substr(0, findpos);
if (g_labeladdrmap.find(label) == g_labeladdrmap.end())//查找标签
{//没找到
errmsg = SplitError("not find the label address", Vector2String(isource));
return false;
}

char hight8addr[20] = { 0 };
MySprintf(hight8addr, sizeof(hight8addr), "%02x", (char)(g_labeladdrmap[label] >> 8));
odst[3] += hight8addr;
}

return true;
}
case g_TFI::TAND://&
{
string temparray[4] = { "`ldst", "`ld_drt_addr", "`", "`" };
odst.assign(temparray, temparray + 4);
odst[2] += isource[1];
odst[3] += isource[3];

if (cmdindex==g_TCI::ST)
{
odst[1] = "`st_drt_addr";
}

//判断是否已存在，如果存在就不用写到寄存器地址列表中
string reg = isource[3];
auto regit = find_if(g_reglist.begin(), g_reglist.end(),
[reg](const pair<string, int> & item){return item.first == reg; });
if (regit == g_reglist.end())
{
AddRegAddr(isource[3]);//添加到寄存器地址列表中去
}

return true;
}
case g_TFI::TAT://@
{
if (MyToLower(isource[3]) != MyToLower("r1r0"))
{
errmsg = SplitError("not defined", Vector2String(isource));
return false;
}

string temparray[5] = { "`ldst", "`reg_or_ptr", "`", "`ld_ptr", "4'b0" };
odst.assign(temparray, temparray + 5);
odst[2] += isource[1];
if (cmdindex == g_TCI::ST)
{
odst[3] = "`st_ptr";
}
return true;
}
default:
{
errmsg = SplitError("format is not \"ld/st regx #/&/@/_ xxx\"", Vector2String(isource));
return false;
}
}
}

return true;
}

获取私有成员变量的get函数不再列出。

8、打印结果

在主程序中，调用Handle处理完之后就可以打印信息：

//写入文件中
switch (filelist.size())
{
case 5:
cout << "macro info into " << filelist[4] << endl;
WriteFile(filelist[4], myasm.GetMacro());
case 4:
cout << "macro and data info into " << filelist[3] << endl;
WriteFile(filelist[3], myasm.GetMacroData());
case 3:
cout << "register info into " << filelist[2] << endl;
WriteFile(filelist[2], myasm.GetReg());
case 2:
cout << "data info into " << filelist[1] << endl;
WriteFile(filelist[1], myasm.GetData());
default:
break;
}

//打印到界面上
cout << endl;
for (auto it = paraset.begin(); it != paraset.end(); ++it)
{
switch (*it)
{
case g_parai::D:
cout << "print data info :" << endl;
cout << myasm.GetData()<<endl;
break;
case g_parai::R:
cout << "print register info :" << endl;
cout << myasm.GetReg() << endl;
break;
case g_parai::MD:
cout << "print macro and data info :" << endl;
cout << myasm.GetMacroData() << endl;
break;
case g_parai::M:
cout << "print macro info :" << endl;
cout << myasm.GetMacro() << endl;
break;
default:
break;
}
}

9、在Win控制台和gcc下的makefile

win32：

#Win下编译
#需要vcvars32.bat环境支持
#nmake 本文件
asmtranslator.exe : main.obj asmalgorithm.obj file.obj
link.exe main.obj asmalgorithm.obj file.obj /out:asmtranslator.exe
@del *.obj

main.obj:main.cpp
cl.exe /c /EHsc main.cpp

asmalgorithm.obj:asmalgorithm.cpp
cl.exe /c /EHsc asmalgorithm.cpp

file.obj:file.cpp
cl.exe /c /EHsc file.cpp

这个需要vcvars32.bat的环境支持。我开始编的时候能编译过去，后来不知调整了什么就编译不过了，只能分开编译。

gcc：

#g++ build
#make -f thisfile

AsmTranslator.out: main.o asmalgorithm.o file.o
g++ -o AsmTranslator.out main.o asmalgorithm.o file.o

#clear .o file
@rm -rf *.o

main.o: main.cpp
g++ -std=c++11 -c main.cpp

asmalgorithm.o: asmalgorithm.cpp asmalgorithm.h os.h
g++ -std=c++11 -c asmalgorithm.cpp

file.o: file.cpp file.h
g++ -std=c++11 -c file.cpp

10、测试：

我用1中的那个文件在gcc中使用 ./AsmTranslator.out infile.txt -d -r 测试结果如下：

----------welcome-----------------
welcom to ./AsmTranslator.out!

print data info :
16'h0000 : begin instr = {`arth,`mus,`r32_0,`r32_1} ;end
16'h0001 : begin instr = {`ldst,`st_drt_addr,`r64_0,`szy_data_save} ;end
16'h0002 : begin instr = {`ldst,`ld_drt_data,`r1,8'h5a} ;end
16'h0003 : begin instr = {`arth,`mus,`r32_0,`r32_1} ;end
16'h0004 : begin instr = {`ldst,`ld_drt_data,`r1,8'h5a} ;end
16'h0005 : begin instr = {`arth,`mus,`r32_0,`r32_1} ;end
16'h0006 : begin instr = {`arth,`mus,`r32_0,`r32_1} ;end
16'h0007 : begin instr = {`ldst,`st_drt_addr,`r64_0,`szy_data_save} ;end
16'h0008 : begin instr = {`ldst,`ld_drt_data,`r1,8'h5a} ;end
16'h0009 : begin instr = {`arth,`mus,`r32_0,`r32_1} ;end
16'h000a : begin instr = {`arth,`mus,`r32_0,`r32_1} ;end
16'h000b : begin instr = {`ldst,`ld_drt_addr,`r64_0,`lpf_alu_result} ;end
16'h000c : begin instr = {`brch,`drt,`cnd_nz,`jmp_next,8'h0b} ;end
16'h000d : begin instr = {`ldst,`ld_drt_addr,`r64_0,`alu_result} ;end
16'h000e : begin instr = {`ldst,`ld_drt_data,`r3,8'h00} ;end
16'h000f : begin instr = {`brch,`drt,`cnd_z,`jmp_next,8'h0d} ;end
16'h0010 : begin instr = {`arth,`mus,`r32_0,`r32_1} ;end
16'h0011 : begin instr = {`ldst,`st_drt_addr,`r64_0,`cic_data_save} ;end
16'h0012 : begin instr = {`ldst,`ld_drt_data,`r1,8'h5a} ;end
16'h0013 : begin instr = {`arth,`mus,`r32_0,`r32_1} ;end
16'h0014 : begin instr = {`ldst,`ld_drt_addr,`r64_0,`szy_alu_result} ;end
16'h0015 : begin instr = {`ldst,`st_drt_addr,`r64_0,`data_save} ;end
16'h0016 : begin instr = {`ldst,`ld_drt_data,`r1,8'h5a} ;end

print register info :
`define szy_data_save 8'h00
`define lpf_alu_result 8'h01
`define alu_result 8'h02
`define cic_data_save 8'h03
`define szy_alu_result 8'h04
`define data_save 8'h05

----------------------------------11、我已压缩这个工程传到http://download.csdn.net/detail/u011311985/9405378这儿了，有需要的朋友可以下载。