#include "gdbprocess.h"

GDBProcess::GDBProcess(QObject *parent) : QObject(parent)
{
 process=new QProcess();
}

GDBProcess::~GDBProcess()
{
 delete process;
}

//运行一条GDB命令并获取输出字符串
QString GDBProcess::runCmd(const QString &cmd)
{
 process->readAllStandardOutput();
 process->write(cmd.toStdString().c_str());
 QString res="";
 do{
 process->waitForReadyRead(1);
 res+=process->readAllStandardOutput();
 }while(!res.endsWith("(gdb) "));
 return res;
}

//启动GDB进程
void GDBProcess::start()
{
 process->setProgram(QCoreApplication::applicationDirPath()+"/gdb/gdb.exe");//设置程序路径
 process->setWorkingDirectory(QCoreApplication::applicationDirPath()+"/gdb");//设置工作路径
 process->setNativeArguments("-q");//设置gdb在安静模式下打开
 process->start();//QProcess::Unbuffered|QProcess::ReadWrite);
 runCmd("set confirm off\r\n");//设置不要手动确认
 runCmd("set print pretty on\r\n");//设置结构体规范打印
}

//停止GDB进程
void GDBProcess::stop()
{
 if(process->state()!=QProcess::NotRunning)
 process->kill();
}

//命令GDB连接到远程目标,参数为"地址:端口号"
void GDBProcess::connectToRemote(const QString &addr)
{
 runCmd("target remote "+addr+"\r\n");
 runCmd("monitor resume\r\n");//恢复目标程序运行
}

//命令GDB从远处目标断开
void GDBProcess::disconnectFromRemote()
{
 runCmd("disconnect\r\n");
}

//设定临时符号文件名,文件位于GDB程序目录下
void GDBProcess::setTempSymbolFileName(const QString &name)
{
 tempSymbolFileName=name;
}

//加载符号文件,将指定文件复制到临时文件中,并加载到GDB中
void GDBProcess::loadSymbolFile(const QString &path)
{
 unloadSymbolFile();//确保卸载当前的临时文件
 QString tempPath=QCoreApplication::applicationDirPath()+"/gdb/"+tempSymbolFileName;//拼接临时文件路径
 QFile::copy(path,tempPath);//将所选符号文件复制为临时文件
 runCmd("symbol-file "+tempSymbolFileName+"\r\n");//设置符号文件
}

//卸载符号文件
void GDBProcess::unloadSymbolFile()
{
 runCmd("symbol-file\r\n");//取消符号文件,解除文件占用
 QString tempPath=QCoreApplication::applicationDirPath()+"/gdb/"+tempSymbolFileName;//拼接临时文件路径
 QFile::remove(tempPath);//删除复制过来的临时文件
}

//设置display列表
void GDBProcess::setDisplayList(QStringList &list)
{
 runCmd("delete display\r\n");//删除之前发送的变量列表
 foreach(QString name,list)//向display表中依次添加变量名
 runCmd("display "+name+"\r\n");
}

//截取display指令所返回字符串中指定变量名的变量值
QString GDBProcess::captureValueFromDisplay(const QString &rawDisplay, const QString &name)
{
 QString regName="";
 for(int i=0;i<name.length();i++)//将变量名每个转换为16进制格式,用于正则匹配
 regName+=QString("\\x%1").arg(name.at(i).unicode(),0,16);

 QRegExp rx(QString("\\d+:\\s%1\\s=\\s(.*)\\r\\n[\\d\\(]").arg(regName));//正则匹配模板,匹配选中的变量名并截取出变量值
 rx.setMinimal(true);//使用非贪心模式

 if(rx.indexIn(rawDisplay)!=-1)
 return rx.cap(1);//正则中截取出的字符串即为变量当前值
 else
 return "";
}

//尝试将display所返回的变量值转为double,返回值为是否转换成功
bool GDBProcess::getDoubleFromDisplayValue(const QString &rawValue, double &result)
{
 if(rawValue.isEmpty())
 return false;
 if(rawValue.contains('{')||rawValue.contains('(')
 ||rawValue.contains('<')||rawValue.contains('['))//若含有这些符号,表示该变量可能为复合类型,不能被解析
 return false;
 result=rawValue.mid(0,rawValue.indexOf(' ')).toDouble();
 return true;
}

//将gdb所返回的无符号数组变量值转换为uint数组
QList<uint> GDBProcess::getUintArrayFromDisplay(const QString &rawDisplay)
{
 QRegExp rx("\\{(.*)\\}");
 rx.indexIn(rawDisplay);
 QString raw=rx.cap(1);
 raw=raw.replace("\r\n ","");
 QStringList rawList=raw.split(", ");
 QList<uint> numList;
 for(int index=0;index<rawList.size();index++)
 {
 if(rawList[index].contains('<'))//查找并展开重复值
 {
 QRegExp repeatRx("(\\d+)\\s<repeats\\s(\\d+)\\stimes>");
 repeatRx.indexIn(rawList[index]);
 int num=repeatRx.cap(1).toUInt();
 int times=repeatRx.cap(2).toUInt();
 for(int i=0;i<times;i++)
 numList<<num;
 }
 else
 {
 numList<<rawList[index].toUInt();
 }
 }
 return numList;
}

//命令GDB设定变量值
void GDBProcess::setVarValue(const QString &varFullName, double value)
{
 runCmd(QString("set %1=%2\r\n").arg(varFullName).arg(value));
}

//判断指定变量名是否为可展开类型
bool GDBProcess::checkExpandableType(const QString &varFullName)
{
 QString whatis=runCmd(QString("whatis %1\r\n").arg(varFullName));//先使用whatis指令判断数组和函数指针
 whatis.remove("type = ");
 whatis.remove("\r\n(gdb) ");
 if(whatis.contains("["))
 return true;
 if(whatis.contains('('))
 return false;
 QString ptype=runCmd(QString("ptype %1\r\n").arg(varFullName));//再使用ptype指令判断是否是其他可展开类型
 ptype.remove("type = ");
 if(ptype.startsWith("struct")||ptype.startsWith("union")||ptype.startsWith("class"))
 return true;
 return false;
}

//从GDB原始输出(info variables/ptype等指令)中解析变量列表
QStringList GDBProcess::getVarListFromRawOutput(const QString &rawVarList)
{
 QStringList list;
 QRegExp rootRx("\\s([^ (]*\\(\\*|)([^ ):]+)(\\)\\(.*\\)|\\s:\\s\\d+|);");//正则匹配模板
 rootRx.setMinimal(true);//非贪心匹配
 int pos=0;
 while((pos=rootRx.indexIn(rawVarList,pos))!=-1)
 {
 QString name=rootRx.cap(2);//获取截取出的变量名部分
 if(name.contains('*'))//手动剔除'*'
 name.remove('*');
 if(name.contains('['))//手动剔除数组长度部分
 name.remove(QRegExp("\\[\\d+\\]"));
 if(name!="const")//排除解析出来是保留字的情况
 list.append(name);
 pos+=rootRx.matchedLength();
 }
 return list;
}

//在raw字符串(可能由ptype等指令输出)中删除由'{}'嵌套的部分(跳过前offset个字符)
void GDBProcess::removeInnerSection(QString &raw, int offset)
{
 for(int startPos=offset;startPos<raw.length();startPos++)//startPos指针向后移动查找'{'
 {
 if(raw.at(startPos)=='{')//若找到'{',开始寻找对应的'}'
 {
 int innerLayer=1;//当前endPos所在的嵌套层级
 for(int endPos=startPos+1;endPos<raw.length();endPos++)//endPos指针向后查找对应的'}'
 {
 if(raw.at(endPos)=='{')//每遇到一个'{'则嵌套层级+1
 innerLayer++;
 else if(raw.at(endPos)=='}')//每遇到一个'}'则嵌套层级-1
 innerLayer--;

 if(raw.at(endPos)=='}' && innerLayer==0)//若遇到'}'时嵌套层级为0,表示找到了对应的'}'
 {
 raw.remove(startPos,endPos-startPos+1);//删除从'{'到'}'的子串
 startPos--;
 break;
 }
 }
 }
 }
}