rabix
/
RedPanda-CPP
mirror of https://github.com/Reduced-panda/RedPanda-CPP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- enhancement: Show descriptions mouse tip for assebmly instructions. (editor / cpu info dialog) 

- fix: When completing resigter names, an extra '%' is wrongly added.
This commit is contained in:
Roy Qu 2023-02-26 17:50:03 +08:00
parent 511b6c679b
commit c9bb03350d
17 changed files with 4512 additions and 816 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
NEWS.md
View File

@ -2,7 +2,7 @@ Red Panda C++ Version 2.15
- fix: Static class members is not correctly recognized as static.
- fix: Function with reference type return value is not correctly parsed.
- enhancement: Add descriptions for x86 registers in the cpu info dialog.
- enhancement: Add description tooltips for x86 registers in the cpu info dialog.
- fix: Search dialog shouldn't have "prompt when replace".
- change: Default value for the debugger debugger panel "memory view's columns" is changed from 8 to 16.
- change: Default value for the debugger debugger panel "memory view's rows" is changed from 8 to 16.
@ -11,6 +11,8 @@ Red Panda C++ Version 2.15
- enhancement: Auto close other search/replace dialogs when start to search/replace.
- change: Remove "prompt when replace" in the replace.
- fix: Search/replace with regex is not correctly handled.
- enhancement: Show descriptions mouse tip for assebmly instructions. (editor / cpu info dialog)
- fix: When completing resigter names, an extra '%' is wrongly added.
Red Panda C++ Version 2.14

4
RedPandaIDE/RedPandaIDE.pro
View File

@ -450,7 +450,9 @@ TRANSLATIONS += \
translations/RedPandaIDE_pt_BR.ts
EXTRA_TRANSLATIONS += \
../libs/redpanda_qt_utils/qt_utils_zh_CN.ts
../libs/redpanda_qt_utils/qt_utils_zh_CN.ts \
../libs/qsynedit/qsynedit_zh_CN.ts
#CONFIG += lrelease embed_translations

37
RedPandaIDE/editor.cpp
View File

@ -206,9 +206,10 @@ Editor::Editor(QWidget *parent, const QString& filename,
mAutoBackupTimer.setInterval(1);
connect(&mAutoBackupTimer, &QTimer::timeout,
this, &Editor::onAutoBackupTimer);
}
connect(&mTooltipTimer, &QTimer::timeout,
this, &Editor::onTooltipTimer);
}
connect(horizontalScrollBar(), &QScrollBar::valueChanged,
this, &Editor::onScrollBarValueChanged);
@ -1909,6 +1910,17 @@ void Editor::onTooltipTimer()
s = expression.join(""); // information during coding
}
break;
case TipType::Keyword:
if (syntaxer() &&
(syntaxer()->language() == QSynedit::ProgrammingLanguage::Assembly
|| syntaxer()->language() == QSynedit::ProgrammingLanguage::ATTAssembly)
) {
if (!mCompletionPopup->isVisible()
&& !mHeaderCompletionPopup->isVisible()) {
s = wordAtRowCol(p);
}
}
break;
case TipType::Selection:
s = selText(); // when a selection is available, always only use that
break;
@ -1938,7 +1950,6 @@ void Editor::onTooltipTimer()
mHoverModifiedLine=line;
}
}
// Remove hint
cancelHint();
mCurrentWord = s;
@ -1966,11 +1977,21 @@ void Editor::onTooltipTimer()
if (pMainWindow->debugger()->executing()
&& (pSettings->editor().enableDebugTooltips())) {
showDebugHint(s,p.line);
} else if (pSettings->editor().enableIdentifierToolTips()) { //if devEditor.ParserHints {
} else if (pSettings->editor().enableIdentifierToolTips()) {
hint = getParserHint(expression, s, p.line);
}
}
break;
case TipType::Keyword:
if (pSettings->editor().enableIdentifierToolTips()) {
if (syntaxer() &&
(syntaxer()->language() == QSynedit::ProgrammingLanguage::Assembly
|| syntaxer()->language() == QSynedit::ProgrammingLanguage::ATTAssembly)
) {
hint = QSynedit::ASMSyntaxer::Instructions.value(s.toLower(),"");
}
}
break;
case TipType::Error:
if (pSettings->editor().enableIssueToolTips())
hint = getErrorHint(pError);
@ -3324,7 +3345,7 @@ void Editor::showCompletion(const QString& preWord,bool autoComplete, CodeComple
else if (word.startsWith("%"))
keywords = QSynedit::ASMSyntaxer::ATTRegisters;
else
keywords = QSynedit::ASMSyntaxer::Instructions;
keywords = QSynedit::ASMSyntaxer::InstructionNames;
} else {
int pos = word.lastIndexOf(".");
if (pos>=0) {
@ -3557,7 +3578,7 @@ void Editor::completionInsert(bool appendFunc)
QSynedit::BufferCoord pStart = wordStart();
if (syntaxer() && syntaxer()->language()==QSynedit::ProgrammingLanguage::ATTAssembly) {
if (statement->command.startsWith(".")
|| statement->command.startsWith("#"))
|| statement->command.startsWith("%"))
pStart.ch--;
}
setCaretAndSelection(pStart,pStart,p);
@ -3828,8 +3849,11 @@ Editor::TipType Editor::getTipType(QPoint point, QSynedit::BufferCoord& pos)
return TipType::Selection;
} else if (mParser && mParser->isIncludeLine(document()->getLine(pos.line-1))) {
return TipType::Preprocessor;
}else if (attr == syntaxer()->identifierAttribute())
}else if (attr->tokenType() == QSynedit::TokenType::Identifier) {
return TipType::Identifier;
} else if (attr->tokenType() == QSynedit::TokenType::Keyword) {
return TipType::Keyword;
}
}
}
}
@ -3843,7 +3867,6 @@ void Editor::cancelHint()
mHoverModifiedLine=-1;
}
//MainForm.Debugger.OnEvalReady := nil;
// disable editor hint
QToolTip::hideText();

1
RedPandaIDE/editor.h
View File

@ -104,6 +104,7 @@ public:
Preprocessor, // cursor hovers above preprocessor line
Identifier, // cursor hovers above identifier
Selection, // cursor hovers above selection
Keyword,
None, // mouseover not allowed
Error //Cursor hovers above error line/item;
};

23
RedPandaIDE/mainwindow.cpp
View File

@ -415,6 +415,17 @@ MainWindow::MainWindow(QWidget *parent)
connect(ui->menuProject, &QMenu::aboutToShow,
this, &MainWindow::updateProjectActions);
QString cpuArch = QSysInfo::currentCpuArchitecture();
if (cpuArch == "i386") {
ui->actionIA_32_Assembly_Language_Reference_Manual->setVisible(true);
ui->actionx86_Assembly_Language_Reference_Manual->setVisible(false);
} else if (cpuArch=="x86_64") {
ui->actionIA_32_Assembly_Language_Reference_Manual->setVisible(true);
ui->actionx86_Assembly_Language_Reference_Manual->setVisible(true);
} else {
ui->actionIA_32_Assembly_Language_Reference_Manual->setVisible(false);
ui->actionx86_Assembly_Language_Reference_Manual->setVisible(false);
}
ui->actionEGE_Manual->setVisible(pSettings->environment().language()=="zh_CN");
ui->actionDocument->setVisible(pSettings->environment().language()=="zh_CN");
@ -9553,3 +9564,15 @@ void MainWindow::on_actionGNU_Assembler_Manual_triggered()
{
QDesktopServices::openUrl(QUrl("https://sourceware.org/binutils/docs/as/index.html"));
}
void MainWindow::on_actionx86_Assembly_Language_Reference_Manual_triggered()
{
QDesktopServices::openUrl(QUrl("https://docs.oracle.com/cd/E19120-01/open.solaris/817-5477/index.html"));
}
void MainWindow::on_actionIA_32_Assembly_Language_Reference_Manual_triggered()
{
QDesktopServices::openUrl(QUrl("https://docs.oracle.com/cd/E19455-01/806-3773/index.html"));
}

4
RedPandaIDE/mainwindow.h
View File

@ -793,6 +793,10 @@ private slots:
void on_actionGNU_Assembler_Manual_triggered();
void on_actionx86_Assembly_Language_Reference_Manual_triggered();
void on_actionIA_32_Assembly_Language_Reference_Manual_triggered();
private:
Ui::MainWindow *ui;
bool mFullInitialized;

12
RedPandaIDE/mainwindow.ui
View File

@ -270,6 +270,8 @@
<addaction name="actionC_Reference"/>
<addaction name="actionC_C_Reference"/>
<addaction name="actionGNU_Assembler_Manual"/>
<addaction name="actionx86_Assembly_Language_Reference_Manual"/>
<addaction name="actionIA_32_Assembly_Language_Reference_Manual"/>
<addaction name="actionRaylib_Manual"/>
<addaction name="actionEGE_Manual"/>
<addaction name="separator"/>
@ -3319,6 +3321,16 @@
<string>GNU Assembler Manual</string>
</property>
</action>
<action name="actionx86_Assembly_Language_Reference_Manual">
<property name="text">
<string>x86 Assembly Language Reference Manual</string>
</property>
</action>
<action name="actionIA_32_Assembly_Language_Reference_Manual">
<property name="text">
<string>IA-32 Assembly Language Reference Manual</string>
</property>
</action>
</widget>
<customwidgets>
<customwidget>

12
RedPandaIDE/translations/RedPandaIDE_pt_BR.ts
View File

@ -5040,6 +5040,14 @@
<source>Please turn off your compiler set&apos;s &quot;Strip executable (-s)&quot; option, recompile and retry debug.</source>
<translation type="unfinished"></translation>
</message>
<message>
<source>x86 Assembly Language Reference Manual</source>
<translation type="unfinished"></translation>
</message>
<message>
<source>IA-32 Assembly Language Reference Manual</source>
<translation type="unfinished"></translation>
</message>
</context>
<context>
<name>NewClassDialog</name>
@ -6771,7 +6779,7 @@
</message>
<message>
<source>Prompt on replace</source>
<translation type="unfinished">Perguntar ao substituir</translation>
<translation type="obsolete">Perguntar ao substituir</translation>
</message>
<message>
<source>Case Sensitive</source>
@ -6850,7 +6858,7 @@
</message>
<message>
<source>Prompt on replace</source>
<translation>Perguntar ao substituir</translation>
<translation type="vanished">Perguntar ao substituir</translation>
</message>
<message>
<source>Scope:</source>

1314
RedPandaIDE/translations/RedPandaIDE_zh_CN.ts
View File

File diff suppressed because it is too large Load Diff

16
RedPandaIDE/translations/RedPandaIDE_zh_TW.ts
View File

@ -4793,6 +4793,14 @@
<source>Please turn off your compiler set&apos;s &quot;Strip executable (-s)&quot; option, recompile and retry debug.</source>
<translation type="unfinished"></translation>
</message>
<message>
<source>x86 Assembly Language Reference Manual</source>
<translation type="unfinished"></translation>
</message>
<message>
<source>IA-32 Assembly Language Reference Manual</source>
<translation type="unfinished"></translation>
</message>
</context>
<context>
<name>NewClassDialog</name>
@ -6350,10 +6358,6 @@
<source>Regular Expression</source>
<translation type="unfinished"></translation>
</message>
<message>
<source>Prompt on replace</source>
<translation type="unfinished"></translation>
</message>
<message>
<source>Case Sensitive</source>
<translation type="unfinished"></translation>
@ -6421,10 +6425,6 @@
<source>Wrap Around</source>
<translation type="unfinished"></translation>
</message>
<message>
<source>Prompt on replace</source>
<translation type="unfinished"></translation>
</message>
<message>
<source>Scope:</source>
<translation type="unfinished"></translation>

6
RedPandaIDE/widgets/cpudialog.ui
View File

@ -80,7 +80,7 @@
</widget>
</item>
<item>
<widget class="QSynedit::QSynEdit" name="txtCode">
<widget class="Editor" name="txtCode">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>3</horstretch>
@ -230,9 +230,9 @@
</widget>
<customwidgets>
<customwidget>
<class>QSynedit::QSynEdit</class>
<class>Editor</class>
<extends>QFrame</extends>
<header location="global">qsynedit/qsynedit.h</header>
<header>editor.h</header>
<container>1</container>
</customwidget>
</customwidgets>

3
libs/qsynedit/qsynedit.pro
View File

@ -67,3 +67,6 @@ HEADERS += \
qsynedit/syntaxer/syntaxer.h
INCLUDEPATH += ../redpanda_qt_utils
TRANSLATIONS += \
qsynedit_zh_CN.ts

4
libs/qsynedit/qsynedit/painter.cpp
View File

@ -963,8 +963,8 @@ void QSynEditPainter::paintLines()
sToken = edit->mSyntaxer->getToken();
// Maybe should also test whether GetTokenPos changed...
if (sToken.isEmpty()) {
qDebug()<<QSynEdit::tr("The highlighter seems to be in an infinite loop");
throw BaseError(QSynEdit::tr("The highlighter seems to be in an infinite loop"));
//qDebug()<<QSynEdit::tr("The highlighter seems to be in an infinite loop");
throw BaseError(QSynEdit::tr("The syntaxer seems to be in an infinite loop"));
}
}
//nTokenColumnsBefore = edit->charToColumn(sLine,edit->mHighlighter->getTokenPos()+1)-1;

22
libs/qsynedit/qsynedit/qsynedit.cpp
View File

@ -5278,33 +5278,11 @@ int QSynEdit::searchReplace(const QString &sSearch, const QString &sReplace, Sea
void QSynEdit::doLinesDeleted(int firstLine, int count)
{
emit linesDeleted(firstLine, count);
// // gutter marks
// for i := 0 to Marks.Count - 1 do begin
// if Marks[i].Line >= FirstLine + Count then
// Marks[i].Line := Marks[i].Line - Count
// else if Marks[i].Line > FirstLine then
// Marks[i].Line := FirstLine;
// end;
// // plugins
// if fPlugins <> nil then begin
// for i := 0 to fPlugins.Count - 1 do
// TSynEditPlugin(fPlugins[i]).LinesDeleted(FirstLine, Count);
// end;
}
void QSynEdit::doLinesInserted(int firstLine, int count)
{
emit linesInserted(firstLine, count);
// // gutter marks
// for i := 0 to Marks.Count - 1 do begin
// if Marks[i].Line >= FirstLine then
// Marks[i].Line := Marks[i].Line + Count;
// end;
// // plugins
// if fPlugins <> nil then begin
// for i := 0 to fPlugins.Count - 1 do
// TSynEditPlugin(fPlugins[i]).LinesInserted(FirstLine, Count);
// end;
}
void QSynEdit::properSetLine(int ALine, const QString &ALineText, bool notify)

880
libs/qsynedit/qsynedit/syntaxer/asm.cpp
View File

@ -20,6 +20,9 @@
namespace QSynedit {
QSet<QString> ASMSyntaxer::InstructionNames;
QMap<QString,QString> ASMSyntaxer::Instructions;
const QSet<QString> ASMSyntaxer::Registers {
"ah","al","ax","eax",
"bh","bl","bx","ebx",
@ -78,120 +81,6 @@ const QSet<QString> ASMSyntaxer::ATTRegisters {
"%xmm12","%xmm13","%xmm14","%xmm15",
};
const QSet<QString> ASMSyntaxer::Instructions {
"aaa","aad","aam","aas","adc","adcx","add",
"addb","addw","addl","addq", "addpd","addps",
"addsd","addss","addsubpd","addsubps","adox","aesdec","aesdec128kl","aesdec256kl","aesdeclast","aesdecwide128kl",
"aesdecwide256kl","aesenc","aesenc128kl","aesenc256kl","aesenclast","aesencwide128kl","aesencwide256kl","aesimc","aeskeygenassist","and",
"andn","andnpd","andnps","andpd","andps","andb","andw","andl","andq","arpl","bextr","blendpd","blendps","blendvpd",
"blendvps","blsi","blsmsk","blsr","bndcl","bndcn","bndcu","bndldx","bndmk","bndmov",
"bndstx","bound","bsf","bsr","bswap","bt","btc","btr","bts","bzhi",
"call","cbw","cdq","cdqe","clac","clc","cld","cldemote","clflush","clflushopt",
"cli","clrssbsy","clts","clwb","cmc","cmova","cmovae","cmovb","cmovbe","cmovc",
"cmove","cmovg","cmovge","cmovl","cmovle","cmovna","cmovnae","cmovnb","cmovnbe","cmovnc",
"cmovne","cmovng","cmovnge","cmovnl","cmovnle","cmovno","cmovnp","cmovns","cmovnz","cmovo",
"cmovp","cmovpe","cmovpo","cmovs","cmovz","cmp","cmpb","cmpw","cmpl","cmpq",
"cmppd","cmpps","cmps","cmpsb", "cmpsd","cmpsq","cmpss","cmpsw","cmpxchg","cmpxchg16b","cmpxchg8b","comisd","comiss","cpuid",
"cqo","crc32","cvtdq2pd","cvtdq2ps","cvtpd2dq","cvtpd2pi","cvtpd2ps","cvtpi2pd","cvtpi2ps","cvtps2dq",
"cvtps2pd","cvtps2pi","cvtsd2si","cvtsd2ss","cvtsi2sd","cvtsi2ss","cvtss2sd","cvtss2si","cvttpd2dq","cvttpd2pi",
"cvttps2dq","cvttps2pi","cvttsd2si","cvttss2si","cwd","cwde","daa","das","dec","div",
"divpd","divps","divsd","divss","dppd","dpps","emms","encodekey128","encodekey256","endbr32",
"endbr64","enter","extractps","f2xm1","fabs","fadd","faddp","fbld","fbstp","fchs",
"fclex","fcmovb","fcmove","fcmovbe","fcmovu","fcmovnb","fcmovne","fcmovnbe","fcmovnu","fcom",
"fcomi","fcomip","fcomp","fcompp","fcos","fdecstp","fdiv","fdivp","fdivr","fdivrp",
"ffree","fiadd","ficom","ficomp","fidiv","fidivr","fild","fimul","fincstp","finit",
"fist","fistp","fisttp","fisub","fisubr","fld","fld1","fldcw","fldenv","fldl2e",
"fldl2t","fldlg2","fldln2","fldpi","fldz","fmul","fmulp","fnclex","fninit","fnop",
"fnsave","fnstcw","fnstenv","fnstsw","fpatan","fprem","fprem1","fptan","frndint","frstor",
"fsave","fscale","fsin","fsincos","fsqrt","fst","fstcw","fstenv","fstp","fstsw",
"fsub","fsubp","fsubr","fsubrp","ftst","fucom","fucomi","fucomip","fucomp","fucompp",
"fwait","fxam","fxch","fxrstor","fxsave","fxtract","fyl2x","fyl2xp1","gf2p8affineinvqb","gf2p8affineqb",
"gf2p8mulb","haddpd","haddps","hlt","hreset","hsubpd","hsubps","idiv","idivb","idivw","idivl","idivq","imul",
"imulb","imulw","imull","imulq","in", "inc","incsspd","incsspq","ins","insb","insd","insertps","insw","int n","int1",
"int3","into","invd","invlpg","invpcid","iret","iretd","iretq","jmp","ja",
"jae","jb","jbe","jc","jcxz","je","jecxz","jg","jge","jl",
"jle","jna","jnae","jnb","jnbe","jnc","jne","jng","jnge","jnl",
"jnle","jno","jnp","jns","jnz","jo","jp","jpe","jpo","jrcxz",
"js","jz","kaddb","kaddd","kaddq","kaddw","kandb","kandd","kandnb","kandnd",
"kandnq","kandnw","kandq","kandw","kmovb","kmovd","kmovq","kmovw","knotb","knotd",
"knotq","knotw","korb","kord","korq","kortestb","kortestd","kortestq","kortestw","korw",
"kshiftlb","kshiftld","kshiftlq","kshiftlw","kshiftrb","kshiftrd","kshiftrq","kshiftrw","ktestb","ktestd",
"ktestq","ktestw","kunpckbw","kunpckdq","kunpckwd","kxnorb","kxnord","kxnorq","kxnorw","kxorb",
"kxord","kxorq","kxorw","lahf","lar","lddqu","ldmxcsr","lds","lea","leaq","leave",
"les","lfence","lfs","lgdt","lgs","lidt","lldt","lmsw","loadiwkey","lock",
"lods","lodsb","lodsd","lodsq","lodsw","loop","loope","loopne","lsl","lss",
"ltr","lzcnt","maskmovdqu","maskmovq","maxpd","maxps","maxsd","maxss","mfence","minpd",
"minps","minsd","minss","monitor","mov","movapd","movaps","movbe","movd","movddup",
"movdir64b","movdiri","movdq2q","movdqa","movdqu","movhlps","movhpd","movhps","movlhps","movlpd",
"movlps","movmskpd","movmskps","movntdq","movntdqa","movnti","movntpd","movntps","movntq","movq",
"movq2dq","movs","movsb","movsd","movshdup","movsldup","movsq","movss","movsw","movsx",
"movsxd","movupd","movups","movzx", "movb","movs","movl",
"mpsadbw","mul","mulpd","mulps","mulsd","mulss",
"mulx","mwait","neg","nop","not","or","orb","orw","orl","orq","orpd","orps","out","outs",
"outsb","outsd","outsw","pabsb","pabsd","pabsq","pabsw","packssdw","packsswb","packusdw",
"packuswb","paddb","paddd","paddq","paddsb","paddsw","paddusb","paddusw","paddw","palignr",
"pand","pandn","pause","pavgb","pavgw","pblendvb","pblendw","pclmulqdq","pcmpeqb","pcmpeqd",
"pcmpeqq","pcmpeqw","pcmpestri","pcmpestrm","pcmpgtb","pcmpgtd","pcmpgtq","pcmpgtw","pcmpistri","pcmpistrm",
"pconfig","pdep","pext","pextrb","pextrd","pextrq","pextrw","phaddd","phaddsw","phaddw",
"phminposuw","phsubd","phsubsw","phsubw","pinsrb","pinsrd","pinsrq","pinsrw","pmaddubsw","pmaddwd",
"pmaxsb","pmaxsd","pmaxsq","pmaxsw","pmaxub","pmaxud","pmaxuq","pmaxuw","pminsb","pminsd",
"pminsq","pminsw","pminub","pminud","pminuq","pminuw","pmovmskb","pmovsx","pmovzx","pmuldq",
"pmulhrsw","pmulhuw","pmulhw","pmulld","pmullq","pmullw","pmuludq","pop","popa","popad",
"popcnt","popf","popfd","popfq","popq","por","prefetchw","prefetchh","psadbw","pshufb","pshufd",
"pshufhw","pshuflw","pshufw","psignb","psignd","psignw","pslld","pslldq","psllq","psllw",
"psrad","psraq","psraw","psrld","psrldq","psrlq","psrlw","psubb","psubd","psubq",
"psubsb","psubsw","psubusb","psubusw","psubw","ptest","ptwrite","punpckhbw","punpckhdq","punpckhqdq",
"punpckhwd","punpcklbw","punpckldq","punpcklqdq","punpcklwd","push","pusha","pushad","pushf","pushfd",
"pushfq","pushq","pxor","rcl","rcpps","rcpss","rcr","rdfsbase","rdgsbase","rdmsr","rdpid",
"rdpkru","rdpmc","rdrand","rdseed","rdsspd","rdsspq","rdtsc","rdtscp","rep","repe",
"repne","repnz","repz","ret","rol","ror","rorx","roundpd","roundps","roundsd",
"roundss","rsm","rsqrtps","rsqrtss","rstorssp","sahf","sal","salb","salw","sall","salq","sar","sarb","sarw","sarl","sarq","sarx","saveprevssp",
"sbb","scas","scasb","scasd","scasw","serialize","setssbsy","seta","setae","setb",
"setbe","setc","sete","setg","setge","setl","setle","setna","setnae","setnb",
"setnbe","setnc","setne","setng","setnge","setnl","setnle","setno","setnp","setns",
"setnz","seto","setp","setpe","setpo","sets","setz","sfence","sgdt","sha1msg1",
"sha1msg2","sha1nexte","sha1rnds4","sha256msg1","sha256msg2","sha256rnds2","shl","shld","shlx","shr",
"shrd","shrx","shufpd","shufps","sidt","sldt","smsw","sqrtpd","sqrtps","sqrtsd",
"sqrtss","stac","stc","std","sti","stmxcsr","stos","stosb","stosd","stosq",
"stosw","str","sub","subpd","subps","subsd","subss","swapgs","syscall","sysenter",
"sysexit","sysret","test","tpause","tzcnt","ucomisd","ucomiss","ud","umonitor","umwait",
"unpckhpd","unpckhps","unpcklpd","unpcklps","valignd","valignq","vblendmpd","vblendmps","vbroadcast","vcompresspd",
"vcompressps","vcompressw","vcvtne2ps2bf16","vcvtneps2bf16","vcvtpd2qq","vcvtpd2udq","vcvtpd2uqq","vcvtph2ps","vcvtps2ph","vcvtps2qq",
"vcvtps2udq","vcvtps2uqq","vcvtqq2pd","vcvtqq2ps","vcvtsd2usi","vcvtss2usi","vcvttpd2qq","vcvttpd2udq","vcvttpd2uqq","vcvttps2qq",
"vcvttps2udq","vcvttps2uqq","vcvttsd2usi","vcvttss2usi","vcvtudq2pd","vcvtudq2ps","vcvtuqq2pd","vcvtuqq2ps","vcvtusi2sd","vcvtusi2ss",
"vdbpsadbw","vdpbf16ps","verr","verw","vexpandpd","vexpandps","vextractf128","vextractf32x4","vextractf32x8","vextractf64x2",
"vextractf64x4","vextracti128","vextracti32x4","vextracti32x8","vextracti64x2","vextracti64x4","vfixupimmpd","vfixupimmps","vfixupimmsd","vfixupimmss",
"vfmadd132pd","vfmadd132ps","vfmadd132sd","vfmadd132ss","vfmadd213pd","vfmadd213ps","vfmadd213sd","vfmadd213ss","vfmadd231pd","vfmadd231ps",
"vfmadd231sd","vfmadd231ss","vfmaddsub132pd","vfmaddsub132ps","vfmaddsub213pd","vfmaddsub213ps","vfmaddsub231pd","vfmaddsub231ps","vfmsub132pd","vfmsub132ps",
"vfmsub132sd","vfmsub132ss","vfmsub213pd","vfmsub213ps","vfmsub213sd","vfmsub213ss","vfmsub231pd","vfmsub231ps","vfmsub231sd","vfmsub231ss",
"vfmsubadd132pd","vfmsubadd132ps","vfmsubadd213pd","vfmsubadd213ps","vfmsubadd231pd","vfmsubadd231ps","vfnmadd132pd","vfnmadd132ps","vfnmadd132sd","vfnmadd132ss",
"vfnmadd213pd","vfnmadd213ps","vfnmadd213sd","vfnmadd213ss","vfnmadd231pd","vfnmadd231ps","vfnmadd231sd","vfnmadd231ss","vfnmsub132pd","vfnmsub132ps",
"vfnmsub132sd","vfnmsub132ss","vfnmsub213pd","vfnmsub213ps","vfnmsub213sd","vfnmsub213ss","vfnmsub231pd","vfnmsub231ps","vfnmsub231sd","vfnmsub231ss",
"vfpclasspd","vfpclassps","vfpclasssd","vfpclassss","vgatherdpd","vgatherdps","vgatherqpd","vgatherqps","vgetexppd","vgetexpps",
"vgetexpsd","vgetexpss","vgetmantpd","vgetmantps","vgetmantsd","vgetmantss","vinsertf128","vinsertf32x4","vinsertf32x8","vinsertf64x2",
"vinsertf64x4","vinserti128","vinserti32x4","vinserti32x8","vinserti64x2","vinserti64x4","vmaskmov","vmovdqa32","vmovdqa64","vmovdqu16",
"vmovdqu32","vmovdqu64","vmovdqu8","vp2intersectd","vp2intersectq","vpblendd","vpblendmb","vpblendmd","vpblendmq","vpblendmw",
"vpbroadcast","vpbroadcastb","vpbroadcastd","vpbroadcastm","vpbroadcastq","vpbroadcastw","vpcmpb","vpcmpd","vpcmpq","vpcmpub",
"vpcmpud","vpcmpuq","vpcmpuw","vpcmpw","vpcompressb","vpcompressd","vpcompressq","vpconflictd","vpconflictq","vpdpbusd",
"vpdpbusds","vpdpwssd","vpdpwssds","vperm2f128","vperm2i128","vpermb","vpermd","vpermi2b","vpermi2d","vpermi2pd",
"vpermi2ps","vpermi2q","vpermi2w","vpermilpd","vpermilps","vpermpd","vpermps","vpermq","vpermt2b","vpermt2d",
"vpermt2pd","vpermt2ps","vpermt2q","vpermt2w","vpermw","vpexpandb","vpexpandd","vpexpandq","vpexpandw","vpgatherdd",
"vpgatherdq","vpgatherqd","vpgatherqq","vplzcntd","vplzcntq","vpmadd52huq","vpmadd52luq","vpmaskmov","vpmovb2m","vpmovd2m",
"vpmovdb","vpmovdw","vpmovm2b","vpmovm2d","vpmovm2q","vpmovm2w","vpmovq2m","vpmovqb","vpmovqd","vpmovqw",
"vpmovsdb","vpmovsdw","vpmovsqb","vpmovsqd","vpmovsqw","vpmovswb","vpmovusdb","vpmovusdw","vpmovusqb","vpmovusqd",
"vpmovusqw","vpmovuswb","vpmovw2m","vpmovwb","vpmultishiftqb","vpopcnt","vprold","vprolq","vprolvd","vprolvq",
"vprord","vprorq","vprorvd","vprorvq","vpscatterdd","vpscatterdq","vpscatterqd","vpscatterqq","vpshld","vpshldv",
"vpshrd","vpshrdv","vpshufbitqmb","vpsllvd","vpsllvq","vpsllvw","vpsravd","vpsravq","vpsravw","vpsrlvd",
"vpsrlvq","vpsrlvw","vpternlogd","vpternlogq","vptestmb","vptestmd","vptestmq","vptestmw","vptestnmb","vptestnmd",
"vptestnmq","vptestnmw","vrangepd","vrangeps","vrangesd","vrangess","vrcp14pd","vrcp14ps","vrcp14sd","vrcp14ss",
"vreducepd","vreduceps","vreducesd","vreducess","vrndscalepd","vrndscaleps","vrndscalesd","vrndscaless","vrsqrt14pd","vrsqrt14ps",
"vrsqrt14sd","vrsqrt14ss","vscalefpd","vscalefps","vscalefsd","vscalefss","vscatterdpd","vscatterdps","vscatterqpd","vscatterqps",
"vshuff32x4","vshuff64x2","vshufi32x4","vshufi64x2","vtestpd","vtestps","vzeroall","vzeroupper","wait","wbinvd",
"wbnoinvd","wrfsbase","wrgsbase","wrmsr","wrpkru","wrssd","wrssq","wrussd","wrussq","xabort",
"xacquire","xadd","xbegin","xchg","xend","xgetbv","xlat","xlatb","xor","xorb","xorw","xorl","xorq","xorpd",
"xorps","xrelease","xrstor","xrstors","xsave","xsavec","xsaveopt","xsaves","xsetbv","xtest",
};
const QSet<QString> ASMSyntaxer::Directives {
"section","global","extern","segment",
"db","dw","dd","dq","dt","do","dy","dz",
@ -233,6 +122,7 @@ const QSet<QString> ASMSyntaxer::ATTDirectives {
ASMSyntaxer::ASMSyntaxer(bool isATT):
mATT(isATT)
{
initData();
mNumberAttribute = std::make_shared<TokenAttribute>(SYNS_AttrNumber, TokenType::Number);
addAttribute(mNumberAttribute);
mDirectiveAttribute = std::make_shared<TokenAttribute>(SYNS_AttrVariable, TokenType::Keyword);
@ -440,6 +330,766 @@ bool ASMSyntaxer::isIdentStartChar(const QChar &ch)
return false;
}
void ASMSyntaxer::initData()
{
if (Instructions.isEmpty()) {
// https://docs.oracle.com/cd/E19120-01/open.solaris/817-5477/ennbz/index.html
//Data Transfer Instruction
Instructions.insert("bswap",QObject::tr("byte swap."));
Instructions.insert("bswapl",QObject::tr("byte swap."));
Instructions.insert("bswapq",QObject::tr("byte swap."));
Instructions.insert("cbtw",QObject::tr("convert %1 to %2.").arg(QObject::tr("byte"),QObject::tr("word")));
Instructions.insert("cltd",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("double word"),"%eax",QObject::tr("quad word"),"%edx:%eax"));
Instructions.insert("cltq",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("double word"),"%eax",QObject::tr("quad word"),"%rax"));
Instructions.insert("cmove",QObject::tr("Conditional move if equal"));
Instructions.insert("cmovz",QObject::tr("Conditional move if zero."));
Instructions.insert("cmovne",QObject::tr("Conditional move if not equal."));
Instructions.insert("cmovnz",QObject::tr("Conditional move if not equal."));
Instructions.insert("cmova",QObject::tr("Conditional move if above."));
Instructions.insert("cmovbe",QObject::tr("Conditional move if not below or equal."));
Instructions.insert("cmovae",QObject::tr("Conditional move if above or equal."));
Instructions.insert("cmovnb",QObject::tr("Conditional move if not below."));
Instructions.insert("cmovb",QObject::tr("Conditional move if below."));
Instructions.insert("cmovnae",QObject::tr("Conditional move if not above or equal."));
Instructions.insert("cmovbe",QObject::tr("Conditional move if below or equal."));
Instructions.insert("cmovna",QObject::tr("Conditional move if not above."));
Instructions.insert("cmovg",QObject::tr("Conditional move if greater."));
Instructions.insert("cmovnle",QObject::tr("Conditional move if not less or equal."));
Instructions.insert("cmovge",QObject::tr("Conditional move if greater or equal."));
Instructions.insert("cmovnl",QObject::tr("Conditional move if not less."));
Instructions.insert("cmovl",QObject::tr("Conditional move if less."));
Instructions.insert("cmovnge",QObject::tr("Conditional move if not greater or equal."));
Instructions.insert("cmovle",QObject::tr("Conditional move if less or equal."));
Instructions.insert("cmovng",QObject::tr("Conditional move if not greater."));
Instructions.insert("cmovc",QObject::tr("Conditional move if carry."));
Instructions.insert("cmovnc",QObject::tr("Conditional move if not carry."));
Instructions.insert("cmovo",QObject::tr("Conditional move if overflow."));
Instructions.insert("cmovno",QObject::tr("Conditional move if not overflow."));
Instructions.insert("cmovs",QObject::tr("Conditional move if sign (negative)."));
Instructions.insert("cmovns",QObject::tr("Conditional move if not sign (non-negative)."));
Instructions.insert("cmovp",QObject::tr("Conditional move if parity."));
Instructions.insert("cmovpe",QObject::tr("Conditional move if parity even."));
Instructions.insert("cmovnp",QObject::tr("Conditional move if not parity."));
Instructions.insert("cmovpo",QObject::tr("Conditional move if parity odd."));
Instructions.insert("cmpxchg",QObject::tr("Compare and exchange."));
Instructions.insert("cmpxchg8b",QObject::tr("Compare and exchange 8 bytes."));
Instructions.insert("cqtd",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("quad word"),"%rax",QObject::tr("oct word"),"%rdx:%rax"));
Instructions.insert("cqto",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("quad word"),"%rax",QObject::tr("oct word"),"%rdx:%rax"));
Instructions.insert("cwtd",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("word"),"%ax",QObject::tr("double word"),"%dx:%ax"));
Instructions.insert("cwtl",QObject::tr("convert %1 in %2 to %3 in %4.").arg(QObject::tr("word"),"%ax",QObject::tr("double word"),"%eax"));
Instructions.insert("mov",QObject::tr("move data between immediate values, general purpose registers, segment registers, and memory."));
Instructions.insert("movb",QObject::tr("move %1 data between immediate values, general purpose registers, segment registers, and memory.").arg(QObject::tr("byte")));
Instructions.insert("movw",QObject::tr("Move %1.").arg(QObject::tr("word")));
Instructions.insert("movl",QObject::tr("Move %1.").arg(QObject::tr("double word")));
Instructions.insert("movq",QObject::tr("Move %1.").arg(QObject::tr("quad word")));
Instructions.insert("movabs",QObject::tr("move immediate value to register."));
Instructions.insert("movabsb",QObject::tr("move immediate %1 value to register.").arg(QObject::tr("byte")));
Instructions.insert("movabsw",QObject::tr("move immediate %1 value to register.").arg(QObject::tr("word")));
Instructions.insert("movabsl",QObject::tr("move immediate %1 value to register.").arg(QObject::tr("double word")));
Instructions.insert("movabsq",QObject::tr("move immediate %1 value to register.").arg(QObject::tr("quad word")));
Instructions.insert("movabsa",QObject::tr("move immediate value to register %al/%ax/%eax/%rax."));
Instructions.insert("movabsba",QObject::tr("move immediate %1 value to register %2.").arg(QObject::tr("byte"),"%al"));
Instructions.insert("movabswa",QObject::tr("move immediate %1 value to register %2.").arg(QObject::tr("word"),"%ax"));
Instructions.insert("movabsla",QObject::tr("move immediate %1 value to register %2.").arg(QObject::tr("double word"),"%eax"));
Instructions.insert("movabsqa",QObject::tr("move immediate %1 value to register %2.").arg(QObject::tr("quad word"),"%rax"));
Instructions.insert("movsx",QObject::tr("Move and sign extension.")); //intel
Instructions.insert("movsbw",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("word")));
Instructions.insert("movsbl",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("double word")));
Instructions.insert("movswl",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("word"),QObject::tr("double word")));
Instructions.insert("movsbq",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("quad word")));
Instructions.insert("movswq",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("word"),QObject::tr("quad word")));
Instructions.insert("movslq",QObject::tr("Move sign-extended %1 to %2.").arg(QObject::tr("double word"),QObject::tr("quad word")));
Instructions.insert("movzx",QObject::tr("Move with zero extension.")); //intel
Instructions.insert("movzbw",QObject::tr("Move zero-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("word")));
Instructions.insert("movzbl",QObject::tr("Move zero-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("double word")));
Instructions.insert("movzwl",QObject::tr("Move zero-extended %1 to %2.").arg(QObject::tr("word"),QObject::tr("double word")));
Instructions.insert("movzbq",QObject::tr("Move zero-extended %1 to %2.").arg(QObject::tr("byte"),QObject::tr("quad word")));
Instructions.insert("movzwq",QObject::tr("Move zero-extended %1 to %2.").arg(QObject::tr("word"),QObject::tr("quad word")));
Instructions.insert("pop",QObject::tr("Pop stack."));
Instructions.insert("popw",QObject::tr("Pop %1 off stack.").arg(QObject::tr("word")));
Instructions.insert("popl",QObject::tr("Pop %1 off stack.").arg(QObject::tr("double word")));
Instructions.insert("popq",QObject::tr("Pop %1 off stack.").arg(QObject::tr("quad word")));
Instructions.insert("popa",QObject::tr("Pop general-purpose registers from stack."));
Instructions.insert("popaw",QObject::tr("Pop general-purpose registers from stack."));
Instructions.insert("popad",QObject::tr("Pop general-purpose registers from stack."));
Instructions.insert("push",QObject::tr("Push stack."));
Instructions.insert("pushw",QObject::tr("Push %1 onto stack.").arg(QObject::tr("word")));
Instructions.insert("pushl",QObject::tr("Push %1 onto stack.").arg(QObject::tr("double word")));
Instructions.insert("pushq",QObject::tr("Push %1 onto stack.").arg(QObject::tr("quad word")));
Instructions.insert("pusha",QObject::tr("Push general-purpose registers onto stack."));
Instructions.insert("pushaw",QObject::tr("Push general-purpose registers onto stack."));
Instructions.insert("pushal",QObject::tr("Push general-purpose registers onto stack."));
Instructions.insert("xadd",QObject::tr("Exchange and add %1.").arg("integer"));
Instructions.insert("xaddb",QObject::tr("Exchange and add %1.").arg("byte"));
Instructions.insert("xaddw",QObject::tr("Exchange and add %1.").arg("word"));
Instructions.insert("xaddl",QObject::tr("Exchange and add %1.").arg("double word"));
Instructions.insert("xaddq",QObject::tr("Exchange and add %1.").arg("quad word"));
Instructions.insert("xchg",QObject::tr("Exchange %1.").arg("integer"));
Instructions.insert("xchgb",QObject::tr("Exchange %1.").arg("byte"));
Instructions.insert("xchgw",QObject::tr("Exchange %1.").arg("word"));
Instructions.insert("xchgl",QObject::tr("Exchange %1.").arg("double word"));
Instructions.insert("xchgq",QObject::tr("Exchange %1.").arg("quad word"));
//Binary Arithmetic Instructions
Instructions.insert("adcx",QObject::tr("add unsigned %1 with carry.").arg(QObject::tr("integer"))); //intel
// Instructions.insert("adcxb",QObject::tr("add unsigned %1 with carry.").arg(QObject::tr("byte")));
// Instructions.insert("adcxw",QObject::tr("add unsigned %1 with carry.").arg(QObject::tr("word")));
// Instructions.insert("adcxl",QObject::tr("add unsigned %1 with carry.").arg(QObject::tr("double word")));
// Instructions.insert("adcxq",QObject::tr("add unsigned %1 with carry.").arg(QObject::tr("quad word")));
Instructions.insert("ado",QObject::tr("add unsigned %1 with overflow.").arg(QObject::tr("integer"))); //intel
// Instructions.insert("adob",QObject::tr("add unsigned %1 with overflow.").arg(QObject::tr("byte")));
// Instructions.insert("adow",QObject::tr("add unsigned %1 with overflow.").arg(QObject::tr("word")));
// Instructions.insert("adol",QObject::tr("add unsigned %1 with overflow.").arg(QObject::tr("double word")));
// Instructions.insert("adoq",QObject::tr("add unsigned %1 with overflow.").arg(QObject::tr("quad word")));
Instructions.insert("adc",QObject::tr("add %1 with carry.").arg(QObject::tr("integer")));
Instructions.insert("adcb",QObject::tr("add %1 with carry.").arg(QObject::tr("byte")));
Instructions.insert("adcw",QObject::tr("add %1 with carry.").arg(QObject::tr("word")));
Instructions.insert("adcl",QObject::tr("add %1 with carry.").arg(QObject::tr("double word")));
Instructions.insert("adcq",QObject::tr("add %1 with carry.").arg(QObject::tr("quad word")));
Instructions.insert("add",QObject::tr("add %1.").arg(QObject::tr("integer")));
Instructions.insert("addb",QObject::tr("add %1.").arg(QObject::tr("byte")));
Instructions.insert("addw",QObject::tr("add %1.").arg(QObject::tr("word")));
Instructions.insert("addl",QObject::tr("add %1.").arg(QObject::tr("double word")));
Instructions.insert("addq",QObject::tr("add %1.").arg(QObject::tr("quad word")));
Instructions.insert("cmp",QObject::tr("compare."));
Instructions.insert("cmpb",QObject::tr("compare %1.").arg(QObject::tr("byte")));
Instructions.insert("cmpw",QObject::tr("compare %1.").arg(QObject::tr("word")));
Instructions.insert("cmpl",QObject::tr("compare %1.").arg(QObject::tr("double word")));
Instructions.insert("cmpq",QObject::tr("compare %1.").arg(QObject::tr("quad word")));
Instructions.insert("dec",QObject::tr("decrement by 1."));
Instructions.insert("decb",QObject::tr("decrement %1 by 1.").arg(QObject::tr("byte")));
Instructions.insert("decw",QObject::tr("decrement %1 by 1.").arg(QObject::tr("word")));
Instructions.insert("decl",QObject::tr("decrement %1 by 1.").arg(QObject::tr("double word")));
Instructions.insert("decq",QObject::tr("decrement %1 by 1.").arg(QObject::tr("quad word")));
Instructions.insert("div",QObject::tr("unsigned %1 divide.").arg(QObject::tr("integer")));
Instructions.insert("divb",QObject::tr("unsigned %1 divide.").arg(QObject::tr("byte")));
Instructions.insert("divw",QObject::tr("unsigned %1 divide.").arg(QObject::tr("word")));
Instructions.insert("divl",QObject::tr("unsigned %1 divide.").arg(QObject::tr("double word")));
Instructions.insert("divq",QObject::tr("unsigned %1 divide.").arg(QObject::tr("quad word")));
Instructions.insert("idiv",QObject::tr("signed %1 divide.").arg(QObject::tr("integer")));
Instructions.insert("idivb",QObject::tr("signed %1 divide.").arg(QObject::tr("byte")));
Instructions.insert("idivw",QObject::tr("signed %1 divide.").arg(QObject::tr("word")));
Instructions.insert("idivl",QObject::tr("signed %1 divide.").arg(QObject::tr("double word")));
Instructions.insert("idivq",QObject::tr("signed %1 divide.").arg(QObject::tr("quad word")));
Instructions.insert("imul",QObject::tr("signed %1 multiply.").arg(QObject::tr("integer")));
Instructions.insert("imulb",QObject::tr("signed %1 multiply.").arg(QObject::tr("byte")));
Instructions.insert("imulw",QObject::tr("signed %1 multiply.").arg(QObject::tr("word")));
Instructions.insert("imull",QObject::tr("signed %1 multiply.").arg(QObject::tr("double word")));
Instructions.insert("imulq",QObject::tr("signed %1 multiply.").arg(QObject::tr("quad word")));
Instructions.insert("inc",QObject::tr("increment by 1."));
Instructions.insert("incb",QObject::tr("increment %1 by 1.").arg(QObject::tr("byte")));
Instructions.insert("incw",QObject::tr("increment %1 by 1.").arg(QObject::tr("word")));
Instructions.insert("incl",QObject::tr("increment %1 by 1.").arg(QObject::tr("double word")));
Instructions.insert("incq",QObject::tr("increment %1 by 1.").arg(QObject::tr("quad word")));
Instructions.insert("mul",QObject::tr("unsigned %1 multiply.").arg(QObject::tr("integer")));
Instructions.insert("mulb",QObject::tr("unsigned %1 multiply.").arg(QObject::tr("byte")));
Instructions.insert("mulw",QObject::tr("unsigned %1 multiply.").arg(QObject::tr("word")));
Instructions.insert("mull",QObject::tr("unsigned %1 multiply.").arg(QObject::tr("double word")));
Instructions.insert("mulq",QObject::tr("unsigned %1 multiply.").arg(QObject::tr("quad word")));
Instructions.insert("neg",QObject::tr("Two's complement negation."));
Instructions.insert("negb",QObject::tr("Replace the value of the %1 with its two's complement").arg("byte"));
Instructions.insert("negw",QObject::tr("Replace the value of the %1 with its two's complement").arg("word"));
Instructions.insert("negl",QObject::tr("Replace the value of the %1 with its two's complement").arg("double word"));
Instructions.insert("negq",QObject::tr("Replace the value of the %1 with its two's complement").arg("quad word"));
Instructions.insert("sbb",QObject::tr("subtract %1 with borrow.").arg(QObject::tr("integer")));
Instructions.insert("sbbb",QObject::tr("subtract %1 with borrow.").arg(QObject::tr("byte")));
Instructions.insert("sbbw",QObject::tr("subtract %1 with borrow.").arg(QObject::tr("word")));
Instructions.insert("sbbl",QObject::tr("subtract %1 with borrow.").arg(QObject::tr("double word")));
Instructions.insert("sbbq",QObject::tr("subtract %1 with borrow.").arg(QObject::tr("quad word")));
Instructions.insert("sub",QObject::tr("subtract %1.").arg(QObject::tr("integer")));
Instructions.insert("subb",QObject::tr("subtract %1.").arg(QObject::tr("byte")));
Instructions.insert("subw",QObject::tr("subtract %1.").arg(QObject::tr("word")));
Instructions.insert("subl",QObject::tr("subtract %1.").arg(QObject::tr("double word")));
Instructions.insert("subq",QObject::tr("subtract %1.").arg(QObject::tr("quad word")));
//Decimal Arithmetic Instructions
Instructions.insert("aaa",QObject::tr("ascii adjust after addition."));
Instructions.insert("aad",QObject::tr("ascii adjust before division."));
Instructions.insert("aam",QObject::tr("ascii adjust after multiplication."));
Instructions.insert("aas",QObject::tr("ascii adjust after subtraction."));
Instructions.insert("daa",QObject::tr("decimal adjust after addition."));
Instructions.insert("das",QObject::tr("decimal adjust after subtraction."));
//Logical Instructions
Instructions.insert("and",QObject::tr("bitwise logical AND."));
Instructions.insert("andb",QObject::tr("bitwise logical AND on %1 values.").arg(QObject::tr("byte")));
Instructions.insert("andw",QObject::tr("bitwise logical AND on %1 values.").arg(QObject::tr("word")));
Instructions.insert("andl",QObject::tr("bitwise logical AND on %1 values.").arg(QObject::tr("double word")));
Instructions.insert("andq",QObject::tr("bitwise logical AND on %1 values.").arg(QObject::tr("quad word")));
Instructions.insert("not",QObject::tr("bitwise logical NOT."));
Instructions.insert("notb",QObject::tr("bitwise logical NOT on %1 value.").arg(QObject::tr("byte")));
Instructions.insert("notw",QObject::tr("bitwise logical NOT on %1 value.").arg(QObject::tr("word")));
Instructions.insert("notl",QObject::tr("bitwise logical NOT on %1 value.").arg(QObject::tr("double word")));
Instructions.insert("notq",QObject::tr("bitwise logical NOT on %1 value.").arg(QObject::tr("quad word")));
Instructions.insert("or",QObject::tr("bitwise logical OR."));
Instructions.insert("orb",QObject::tr("bitwise logical OR on %1 values.").arg(QObject::tr("byte")));
Instructions.insert("orw",QObject::tr("bitwise logical OR on %1 values.").arg(QObject::tr("word")));
Instructions.insert("orl",QObject::tr("bitwise logical OR on %1 values.").arg(QObject::tr("double word")));
Instructions.insert("orq",QObject::tr("bitwise logical OR on %1 values.").arg(QObject::tr("quad word")));
Instructions.insert("xor",QObject::tr("bitwise logical XOR."));
Instructions.insert("xorb",QObject::tr("bitwise logical XOR on %1 values.").arg(QObject::tr("byte")));
Instructions.insert("xorw",QObject::tr("bitwise logical XOR on %1 values.").arg(QObject::tr("word")));
Instructions.insert("xorl",QObject::tr("bitwise logical XOR on %1 values.").arg(QObject::tr("double word")));
Instructions.insert("xorq",QObject::tr("bitwise logical XOR on %1 values.").arg(QObject::tr("quad word")));
//Shift and Rotate Instructions
Instructions.insert("rcl",QObject::tr("rotate %1 through carry left.").arg(QObject::tr("integer")));
Instructions.insert("rclb",QObject::tr("rotate %1 through carry left.").arg(QObject::tr("byte")));
Instructions.insert("rclw",QObject::tr("rotate %1 through carry left.").arg(QObject::tr("word")));
Instructions.insert("rcll",QObject::tr("rotate %1 through carry left.").arg(QObject::tr("double word")));
Instructions.insert("rclq",QObject::tr("rotate %1 through carry left.").arg(QObject::tr("quad word")));
Instructions.insert("rcr",QObject::tr("rotate %1 through carry right.").arg(QObject::tr("integer")));
Instructions.insert("rcrb",QObject::tr("rotate %1 through carry right.").arg(QObject::tr("byte")));
Instructions.insert("rcrw",QObject::tr("rotate %1 through carry right.").arg(QObject::tr("word")));
Instructions.insert("rcrl",QObject::tr("rotate %1 through carry right.").arg(QObject::tr("double word")));
Instructions.insert("rcrq",QObject::tr("rotate %1 through carry right.").arg(QObject::tr("quad word")));
Instructions.insert("rol",QObject::tr("rotate %1 left.").arg(QObject::tr("integer")));
Instructions.insert("rolb",QObject::tr("rotate %1 left.").arg(QObject::tr("byte")));
Instructions.insert("rolw",QObject::tr("rotate %1 left.").arg(QObject::tr("word")));
Instructions.insert("roll",QObject::tr("rotate %1 left.").arg(QObject::tr("double word")));
Instructions.insert("rolq",QObject::tr("rotate %1 left.").arg(QObject::tr("quad word")));
Instructions.insert("ror",QObject::tr("rotate %1 right.").arg(QObject::tr("integer")));
Instructions.insert("rorb",QObject::tr("rotate %1 right.").arg(QObject::tr("byte")));
Instructions.insert("rorw",QObject::tr("rotate %1 right.").arg(QObject::tr("word")));
Instructions.insert("rorl",QObject::tr("rotate %1 right.").arg(QObject::tr("double word")));
Instructions.insert("rorq",QObject::tr("rotate %1 right.").arg(QObject::tr("quad word")));
Instructions.insert("sal",QObject::tr("shift %1 arithmetic left.").arg(QObject::tr("integer")));
Instructions.insert("salb",QObject::tr("shift %1 arithmetic left.").arg(QObject::tr("byte")));
Instructions.insert("salw",QObject::tr("shift %1 arithmetic left.").arg(QObject::tr("word")));
Instructions.insert("sall",QObject::tr("shift %1 arithmetic left.").arg(QObject::tr("double word")));
Instructions.insert("salq",QObject::tr("shift %1 arithmetic left.").arg(QObject::tr("quad word")));
Instructions.insert("sar",QObject::tr("shift %1 arithmetic right.").arg(QObject::tr("integer")));
Instructions.insert("sarb",QObject::tr("shift %1 arithmetic right.").arg(QObject::tr("byte")));
Instructions.insert("sarw",QObject::tr("shift %1 arithmetic right.").arg(QObject::tr("word")));
Instructions.insert("sarl",QObject::tr("shift %1 arithmetic right.").arg(QObject::tr("double word")));
Instructions.insert("sarq",QObject::tr("shift %1 arithmetic right.").arg(QObject::tr("quad word")));
Instructions.insert("shl",QObject::tr("shift %1 logical left.").arg(QObject::tr("integer")));
Instructions.insert("shlb",QObject::tr("shift %1 logical left.").arg(QObject::tr("byte")));
Instructions.insert("shlw",QObject::tr("shift %1 logical left.").arg(QObject::tr("word")));
Instructions.insert("shll",QObject::tr("shift %1 logical left.").arg(QObject::tr("double word")));
Instructions.insert("shlq",QObject::tr("shift %1 logical left.").arg(QObject::tr("quad word")));
Instructions.insert("shr",QObject::tr("shift %1 logical right.").arg(QObject::tr("integer")));
Instructions.insert("shrb",QObject::tr("shift %1 logical right.").arg(QObject::tr("byte")));
Instructions.insert("shrw",QObject::tr("shift %1 logical right.").arg(QObject::tr("word")));
Instructions.insert("shrl",QObject::tr("shift %1 logical right.").arg(QObject::tr("double word")));
Instructions.insert("shrq",QObject::tr("shift %1 logical right.").arg(QObject::tr("quad word")));
Instructions.insert("shld",QObject::tr("shift %1 left double.").arg(QObject::tr("integer")));
Instructions.insert("shldb",QObject::tr("shift %1 left double.").arg(QObject::tr("byte")));
Instructions.insert("shldw",QObject::tr("shift %1 left double.").arg(QObject::tr("word")));
Instructions.insert("shldl",QObject::tr("shift %1 left double.").arg(QObject::tr("double word")));
Instructions.insert("shldq",QObject::tr("shift %1 left double.").arg(QObject::tr("quad word")));
Instructions.insert("shrd",QObject::tr("shift %1 right double.").arg(QObject::tr("integer")));
Instructions.insert("shrdb",QObject::tr("shift %1 right double.").arg(QObject::tr("byte")));
Instructions.insert("shrdw",QObject::tr("shift %1 right double.").arg(QObject::tr("word")));
Instructions.insert("shrdl",QObject::tr("shift %1 right double.").arg(QObject::tr("double word")));
Instructions.insert("shrdq",QObject::tr("shift %1 right double.").arg(QObject::tr("quad word")));
//Bit and Byte Instructions
Instructions.insert("bsf",QObject::tr("bit scan forward."));
Instructions.insert("bsfw",QObject::tr("bit scan forward in the %1 operand.").arg(QObject::tr("word")));
Instructions.insert("bsfl",QObject::tr("bit scan forward in the %1 operand.").arg(QObject::tr("double word")));
Instructions.insert("bsfq",QObject::tr("bit scan forward in the %1 operand.").arg(QObject::tr("quad word")));
Instructions.insert("bsr",QObject::tr("bit scan reserve."));
Instructions.insert("bsrw",QObject::tr("bit scan reserve in the %1 operand.").arg(QObject::tr("word")));
Instructions.insert("bsrl",QObject::tr("bit scan reserve in the %1 operand.").arg(QObject::tr("double word")));
Instructions.insert("bsrq",QObject::tr("bit scan reserve in the %1 operand.").arg(QObject::tr("quad word")));
Instructions.insert("bt",QObject::tr("bit test."));
Instructions.insert("btw",QObject::tr("bit test in the %1 operand.").arg(QObject::tr("word")));
Instructions.insert("btl",QObject::tr("bit test in the %1 operand.").arg(QObject::tr("double word")));
Instructions.insert("btq",QObject::tr("bit test in the %1 operand.").arg(QObject::tr("quad word")));
Instructions.insert("btc",QObject::tr("bit test and complement."));
Instructions.insert("btcw",QObject::tr("bit test and complement in the %1 operand.").arg(QObject::tr("word")));
Instructions.insert("btcl",QObject::tr("bit test and complement in the %1 operand.").arg(QObject::tr("double word")));
Instructions.insert("btcq",QObject::tr("bit test and complement in the %1 operand.").arg(QObject::tr("quad word")));
Instructions.insert("btr",QObject::tr("bit test and reset."));
Instructions.insert("btrw",QObject::tr("bit test and reset in the %1 operand.").arg(QObject::tr("word")));
Instructions.insert("btrl",QObject::tr("bit test and reset in the %1 operand.").arg(QObject::tr("double word")));
Instructions.insert("btrq",QObject::tr("bit test and reset in the %1 operand.").arg(QObject::tr("quad word")));
Instructions.insert("bts",QObject::tr("bit test and set."));
Instructions.insert("btsw",QObject::tr("bit test and set in the %1 operand.").arg(QObject::tr("word")));
Instructions.insert("btsl",QObject::tr("bit test and set in the %1 operand.").arg(QObject::tr("double word")));
Instructions.insert("btsq",QObject::tr("bit test and set in the %1 operand.").arg(QObject::tr("quad word")));
Instructions.insert("seta",QObject::tr("set byte if above."));
Instructions.insert("setae",QObject::tr("set byte if above or equal."));
Instructions.insert("setb",QObject::tr("set byte if below."));
Instructions.insert("setbe",QObject::tr("set byte if below or equal."));
Instructions.insert("setc",QObject::tr("set byte if carry."));
Instructions.insert("sete",QObject::tr("set byte if equal."));
Instructions.insert("setg",QObject::tr("set byte if greater."));
Instructions.insert("setge",QObject::tr("set byte if greater or equal."));
Instructions.insert("setl",QObject::tr("set byte if less."));
Instructions.insert("setle",QObject::tr("set byte if less or equal."));
Instructions.insert("setna",QObject::tr("set byte if not above."));
Instructions.insert("setnae",QObject::tr("set byte if not above or equal."));
Instructions.insert("setnb",QObject::tr("set byte if not below."));
Instructions.insert("setnbe",QObject::tr("set byte if not below or equal."));
Instructions.insert("setnc",QObject::tr("set byte if not carry."));
Instructions.insert("setne",QObject::tr("set byte if not equal."));
Instructions.insert("setng",QObject::tr("set byte if not greater."));
Instructions.insert("setnge",QObject::tr("set byte if not greater or equal."));
Instructions.insert("setnl",QObject::tr("set byte if not less."));
Instructions.insert("setnle",QObject::tr("set byte if not less or equal."));
Instructions.insert("setno",QObject::tr("set byte if not overflow."));
Instructions.insert("setnp",QObject::tr("set byte if not parity."));
Instructions.insert("setns",QObject::tr("set byte if not sign (non-negative)."));
Instructions.insert("setnz",QObject::tr("set byte if not zero."));
Instructions.insert("seto",QObject::tr("set byte if overflow."));
Instructions.insert("setp",QObject::tr("set byte if parity."));
Instructions.insert("setpe",QObject::tr("set byte if parity even."));
Instructions.insert("setpo",QObject::tr("set byte if parity odd."));
Instructions.insert("sets",QObject::tr("set byte if sign (negative)."));
Instructions.insert("setz",QObject::tr("set byte if zero."));
Instructions.insert("test",QObject::tr("logical compare."));
Instructions.insert("testb",QObject::tr("logical compare %1.").arg(QObject::tr("byte")));
Instructions.insert("testw",QObject::tr("logical compare %1.").arg(QObject::tr("word")));
Instructions.insert("testl",QObject::tr("logical compare %1.").arg(QObject::tr("double word")));
Instructions.insert("testq",QObject::tr("logical compare %1.").arg(QObject::tr("quad word")));
//Control Transfer Instructions
Instructions.insert("bound",QObject::tr("detect value out of range."));
Instructions.insert("boundw",QObject::tr("detect %1 value out of range.").arg(QObject::tr("word")));
Instructions.insert("boundl",QObject::tr("detect %1 value out of range.").arg(QObject::tr("double word")));
Instructions.insert("call",QObject::tr("call procedure."));
Instructions.insert("enter",QObject::tr("high-level procedure entry."));
Instructions.insert("int",QObject::tr("software interrupt."));
Instructions.insert("into",QObject::tr("interrupt on overflow."));
Instructions.insert("iret",QObject::tr("return from interrupt."));
Instructions.insert("ja",QObject::tr("jump if above."));
Instructions.insert("jae",QObject::tr("jump if above or equal."));
Instructions.insert("jb",QObject::tr("jump if below."));
Instructions.insert("jbe",QObject::tr("jump if below or equal."));
Instructions.insert("jc",QObject::tr("jump if carry."));
Instructions.insert("jcxz",QObject::tr("jump register %cx zero"));
Instructions.insert("je",QObject::tr("jump if equal."));
Instructions.insert("jecxz",QObject::tr("jump register %ecx zero"));
Instructions.insert("jg",QObject::tr("jump if greater."));
Instructions.insert("jge",QObject::tr("jump if greater or equal."));
Instructions.insert("jl",QObject::tr("jump if less."));
Instructions.insert("jle",QObject::tr("jump if less or equal."));
Instructions.insert("jmp",QObject::tr("jump."));
Instructions.insert("jnae",QObject::tr("jump if not above or equal."));
Instructions.insert("jnb",QObject::tr("jump if not below."));
Instructions.insert("jnbe",QObject::tr("jump if not below or equal."));
Instructions.insert("jnc",QObject::tr("jump if not carry."));
Instructions.insert("jne",QObject::tr("jump if not equal."));
Instructions.insert("jng",QObject::tr("jump if not greater."));
Instructions.insert("jnge",QObject::tr("jump if not greater or equal."));
Instructions.insert("jnl",QObject::tr("jump if not less."));
Instructions.insert("jnle",QObject::tr("jump if not less or equal."));
Instructions.insert("jno",QObject::tr("jump if not overflow."));
Instructions.insert("jnp",QObject::tr("jump if not parity."));
Instructions.insert("jns",QObject::tr("jump if not sign (non-negative)."));
Instructions.insert("jnz",QObject::tr("jump if not zero."));
Instructions.insert("jo",QObject::tr("jump if overflow."));
Instructions.insert("jp",QObject::tr("jump if parity."));
Instructions.insert("jpe",QObject::tr("jump if parity even."));
Instructions.insert("jpo",QObject::tr("jump if parity odd."));
Instructions.insert("js",QObject::tr("jump if sign (negative)."));
Instructions.insert("jz",QObject::tr("jump if zero."));
Instructions.insert("lcall",QObject::tr("call far procedure."));
Instructions.insert("leave",QObject::tr("high-level procedure exit."));
Instructions.insert("loop",QObject::tr("loop with %ecx counter"));
Instructions.insert("loope",QObject::tr("loop with %ecx and equal"));
Instructions.insert("loopne",QObject::tr("loop with %ecx and not equal"));
Instructions.insert("loopnz",QObject::tr("loop with %ecx and not zero"));
Instructions.insert("loopz",QObject::tr("loop with %ecx and zero"));
Instructions.insert("lret",QObject::tr("return from far procedure."));
Instructions.insert("ret",QObject::tr("return."));
//String Instructions
Instructions.insert("coms",QObject::tr("compare string."));
Instructions.insert("cpmsb",QObject::tr("compare %1 string.").arg(QObject::tr("byte")));
Instructions.insert("cmpsw",QObject::tr("compare %1 string.").arg(QObject::tr("word")));
Instructions.insert("cmpsl",QObject::tr("compare %1 string.").arg(QObject::tr("double word")));
Instructions.insert("cmpsq",QObject::tr("compare %1 string.").arg(QObject::tr("quad word")));
Instructions.insert("lods",QObject::tr("load string."));
Instructions.insert("lodsb",QObject::tr("load %1 string.").arg(QObject::tr("byte")));
Instructions.insert("lodsw",QObject::tr("load %1 string.").arg(QObject::tr("word")));
Instructions.insert("lodsl",QObject::tr("load %1 string.").arg(QObject::tr("double word")));
Instructions.insert("lodsq",QObject::tr("load %1 string.").arg(QObject::tr("quad word")));
Instructions.insert("movs",QObject::tr("move string."));
Instructions.insert("movsb",QObject::tr("move %1 string.").arg(QObject::tr("byte")));
Instructions.insert("movsw",QObject::tr("move %1 string.").arg(QObject::tr("word")));
Instructions.insert("movsl",QObject::tr("move %1 string.").arg(QObject::tr("double word")));
Instructions.insert("movsq",QObject::tr("move %1 string.").arg(QObject::tr("quad word")));
Instructions.insert("rep",QObject::tr("repeat while %ecx not zero"));
Instructions.insert("repnz",QObject::tr("repeat while not equal."));
Instructions.insert("repnz",QObject::tr("repeat while not zero."));
Instructions.insert("repz",QObject::tr("repeat while equal."));
Instructions.insert("repz",QObject::tr("repeat while zero."));
Instructions.insert("scas",QObject::tr("scan string."));
Instructions.insert("scasb",QObject::tr("scan %1 string.").arg(QObject::tr("byte")));
Instructions.insert("scasw",QObject::tr("scan %1 string.").arg(QObject::tr("word")));
Instructions.insert("scasl",QObject::tr("scan %1 string.").arg(QObject::tr("double word")));
Instructions.insert("scasq",QObject::tr("scan %1 string.").arg(QObject::tr("quad word")));
Instructions.insert("stos",QObject::tr("store string."));
Instructions.insert("stosb",QObject::tr("store %1 string.").arg(QObject::tr("byte")));
Instructions.insert("stosw",QObject::tr("store %1 string.").arg(QObject::tr("word")));
Instructions.insert("stosl",QObject::tr("store %1 string.").arg(QObject::tr("double word")));
Instructions.insert("stosq",QObject::tr("store %1 string.").arg(QObject::tr("quad word")));
//I/O Instructions
Instructions.insert("in",QObject::tr("read from a port."));
Instructions.insert("ins",QObject::tr("input string from a port."));
Instructions.insert("insb",QObject::tr("input byte string from port."));
Instructions.insert("insl",QObject::tr("input double word string from port."));
Instructions.insert("insw",QObject::tr("input word string from port."));
Instructions.insert("out",QObject::tr("write to a port."));
Instructions.insert("outs",QObject::tr("output string to port."));
Instructions.insert("outsb",QObject::tr("output byte string to port."));
Instructions.insert("outsl",QObject::tr("output double word string to port."));
Instructions.insert("outsw",QObject::tr("output word string to port."));
//Flag Control (EFLAG) Instructions
Instructions.insert("clc",QObject::tr("clear carry flag."));
Instructions.insert("cld",QObject::tr("clear direction flag."));
Instructions.insert("cli",QObject::tr("clear interrupt flag."));
Instructions.insert("cmc",QObject::tr("complement carry flag."));
Instructions.insert("lahf",QObject::tr("load flags into %ah register"));
Instructions.insert("popfw",QObject::tr("pop %eflags from stack"));
Instructions.insert("popf{lq}",QObject::tr("pop %eflags from stack"));
Instructions.insert("pushfw",QObject::tr("push %eflags onto stack"));
Instructions.insert("pushf{lq}",QObject::tr("push %eflags onto stack"));
Instructions.insert("sahf",QObject::tr("store %ah register into flags"));
Instructions.insert("stc",QObject::tr("set carry flag."));
Instructions.insert("std",QObject::tr("set direction flag."));
Instructions.insert("sti",QObject::tr("set interrupt flag."));
//Segment Register Instructions
Instructions.insert("lds",QObject::tr("load far pointer using %ds"));
Instructions.insert("les",QObject::tr("load far pointer using %es"));
Instructions.insert("lfs",QObject::tr("load far pointer using %fs"));
Instructions.insert("lgs",QObject::tr("load far pointer using %gs"));
Instructions.insert("lss",QObject::tr("load far pointer using %ss"));
Instructions.insert("cpuid",QObject::tr("processor identification."));
Instructions.insert("lea",QObject::tr("load effective address."));
Instructions.insert("leaw",QObject::tr("load effective address."));
Instructions.insert("leal",QObject::tr("load effective address."));
Instructions.insert("leaq",QObject::tr("load effective address."));
Instructions.insert("nop",QObject::tr("no operation."));
Instructions.insert("ud2",QObject::tr("undefined instruction."));
Instructions.insert("xlat",QObject::tr("table lookup translation."));
Instructions.insert("xlatb",QObject::tr("table lookup translation."));
//Floating-Point Instructions
//Data Transfer Instructions (Floating Point)
Instructions.insert("fbld",QObject::tr("load bcd."));
Instructions.insert("fbstp",QObject::tr("store bcd and pop."));
Instructions.insert("fcmovb",QObject::tr("floating-point conditional move if below."));
Instructions.insert("fcmovbe",QObject::tr("floating-point conditional move if below or equal."));
Instructions.insert("fcmove",QObject::tr("floating-point conditional move if equal."));
Instructions.insert("fcmovnb",QObject::tr("floating-point conditional move if not below."));
Instructions.insert("fcmovnbe",QObject::tr("floating-point conditional move if not below or equal."));
Instructions.insert("fcmovne",QObject::tr("floating-point conditional move if not equal."));
Instructions.insert("fcmovnu",QObject::tr("floating-point conditional move if unordered."));
Instructions.insert("fcmovu",QObject::tr("floating-point conditional move if unordered."));
Instructions.insert("fild",QObject::tr("load integer."));
Instructions.insert("fist",QObject::tr("store integer."));
Instructions.insert("fistp",QObject::tr("store integer and pop."));
Instructions.insert("fld",QObject::tr("load floating-point value."));
Instructions.insert("fst",QObject::tr("store floating-point value."));
Instructions.insert("fstp",QObject::tr("store floating-point value and pop."));
Instructions.insert("fxch",QObject::tr("exchange registers ."));
//Basic Arithmetic Instructions (Floating-Point)
Instructions.insert("fabs",QObject::tr("absolute value."));
Instructions.insert("fadd",QObject::tr("add floating-point."));
Instructions.insert("faddp",QObject::tr("add floating-point and pop."));
Instructions.insert("fchs",QObject::tr("change sign."));
Instructions.insert("fdiv",QObject::tr("divide floating-point."));
Instructions.insert("fdivp",QObject::tr("divide floating-point and pop."));
Instructions.insert("fdivr",QObject::tr("divide floating-point reverse."));
Instructions.insert("fdivrp",QObject::tr("divide floating-point reverse and pop."));
Instructions.insert("fiadd",QObject::tr("add integer."));
Instructions.insert("fidiv",QObject::tr("divide integer."));
Instructions.insert("fidivr",QObject::tr("divide integer reverse."));
Instructions.insert("fimul",QObject::tr("multiply integer."));
Instructions.insert("fisub",QObject::tr("subtract integer."));
Instructions.insert("fisubr",QObject::tr("subtract integer reverse."));
Instructions.insert("fmul",QObject::tr("multiply floating-point."));
Instructions.insert("fmulp",QObject::tr("multiply floating-point and pop."));
Instructions.insert("fprem",QObject::tr("partial remainder."));
Instructions.insert("fprem1",QObject::tr("ieee partial remainder."));
Instructions.insert("frndint",QObject::tr("round to integer."));
Instructions.insert("fscale",QObject::tr("scale by power of two."));
Instructions.insert("fsqrt",QObject::tr("square root."));
Instructions.insert("fsub",QObject::tr("subtract floating-point."));
Instructions.insert("fsubp",QObject::tr("subtract floating-point and pop."));
Instructions.insert("fsubr",QObject::tr("subtract floating-point reverse."));
Instructions.insert("fsubrp",QObject::tr("subtract floating-point reverse and pop."));
Instructions.insert("fxtract",QObject::tr("extract exponent and significand ."));
//Comparison Instructions (Floating-Point)
Instructions.insert("fcom",QObject::tr("compare floating-point."));
Instructions.insert("fcomi",QObject::tr("compare floating-point and set %eflags."));
Instructions.insert("fcomip",QObject::tr("compare floating-point, set %eflags, and pop."));
Instructions.insert("fcomp",QObject::tr("compare floating-point and pop."));
Instructions.insert("fcompp",QObject::tr("compare floating-point and pop twice."));
Instructions.insert("ficom",QObject::tr("compare integer."));
Instructions.insert("ficomp",QObject::tr("compare integer and pop."));
Instructions.insert("ftst",QObject::tr("test floating-point (compare with 0.0)."));
Instructions.insert("fucom",QObject::tr("unordered compare floating-point."));
Instructions.insert("fucomi",QObject::tr("unordered compare floating-point and set %eflags."));
Instructions.insert("fucomip",QObject::tr("unordered compare floating-point, set %eflags, and pop."));
Instructions.insert("fucomp",QObject::tr("unordered compare floating-point and pop."));
Instructions.insert("fucompp",QObject::tr("compare floating-point and pop twice."));
Instructions.insert("fxam",QObject::tr("examine floating-point ."));
Instructions.insert("transcendental",QObject::tr("instructions (floating-point) ."));
Instructions.insert("the",QObject::tr("transcendental instructions perform trigonometric and logarithmic operations on floating-point operands. ."));
Instructions.insert("table",QObject::tr("3–16 transcendental instructions (floating-point)."));
Instructions.insert("solaris",QObject::tr("mnemonic  description."));
Instructions.insert("f2xm1",QObject::tr("computes 2x-1."));
Instructions.insert("fcos",QObject::tr("cosine."));
Instructions.insert("fpatan",QObject::tr("partial arctangent."));
Instructions.insert("fptan",QObject::tr("partial tangent."));
Instructions.insert("fsin",QObject::tr("sine."));
Instructions.insert("fsincos",QObject::tr("sine and cosine."));
Instructions.insert("fyl2x",QObject::tr("computes y * log2x."));
Instructions.insert("fyl2xp1",QObject::tr("computes y * log2(x+1)."));
//Load Constants (Floating-Point) Instructions
Instructions.insert("fld1",QObject::tr("load +1.0."));
Instructions.insert("fldl2e",QObject::tr("load log2e."));
Instructions.insert("fldl2t",QObject::tr("load log210."));
Instructions.insert("fldlg2",QObject::tr("load log102."));
Instructions.insert("fldln2",QObject::tr("load loge2."));
Instructions.insert("fldpi",QObject::tr("load π."));
Instructions.insert("fldz",QObject::tr("load +0.0 ."));
//Control Instructions (Floating-Point)
Instructions.insert("fclex",QObject::tr("clear floating-point exception flags after checking for error conditions."));
Instructions.insert("fdecstp",QObject::tr("decrement floating-point register stack pointer."));
Instructions.insert("ffree",QObject::tr("free floating-point register."));
Instructions.insert("fincstp",QObject::tr("increment floating-point register stack pointer."));
Instructions.insert("finit",QObject::tr("initialize floating-point unit after checking error conditions."));
Instructions.insert("fldcw",QObject::tr("load floating-point unit control word."));
Instructions.insert("fldenv",QObject::tr("load floating-point unit environment."));
Instructions.insert("fnclex",QObject::tr("clear floating-point exception flags without checking for error conditions."));
Instructions.insert("fninit",QObject::tr("initialize floating-point unit without checking error conditions."));
Instructions.insert("fnop",QObject::tr("floating-point no operation."));
Instructions.insert("fnsave",QObject::tr("save floating-point unit state without checking error conditions."));
Instructions.insert("fnstcw",QObject::tr("store floating-point unit control word without checking error conditions."));
Instructions.insert("fnstenv",QObject::tr("store floating-point unit environment without checking error conditions."));
Instructions.insert("fnstsw",QObject::tr("store floating-point unit status word without checking error conditions."));
Instructions.insert("frstor",QObject::tr("restore floating-point unit state."));
Instructions.insert("fsave",QObject::tr("save floating-point unit state after checking error conditions."));
Instructions.insert("fstcw",QObject::tr("store floating-point unit control word after checking error conditions."));
Instructions.insert("fstenv",QObject::tr("store floating-point unit environment after checking error conditions."));
Instructions.insert("fstsw",QObject::tr("store floating-point unit status word after checking error conditions."));
Instructions.insert("fwait",QObject::tr("wait for floating-point unit."));
Instructions.insert("wait",QObject::tr("wait for floating-point unit."));
//SIMD State Management Instructions
Instructions.insert("fxrstor",QObject::tr("restore floating-point unit and simd state."));
Instructions.insert("fxsave",QObject::tr("save floating-point unit and simd state."));
//MMX Instructions
//Data Transfer Instructions (MMX)
Instructions.insert("movd",QObject::tr("Move %1.").arg(QObject::tr("double word")));
//Conversion Instructions (MMX)
Instructions.insert("packssdw",QObject::tr("pack doublewords into words with signed saturation."));
Instructions.insert("packsswb",QObject::tr("pack words into bytes with signed saturation."));
Instructions.insert("packuswb",QObject::tr("pack words into bytes with unsigned saturation."));
Instructions.insert("punpckhbw",QObject::tr("unpack high-order bytes."));
Instructions.insert("punpckhdq",QObject::tr("unpack high-order doublewords."));
Instructions.insert("punpckhwd",QObject::tr("unpack high-order words."));
Instructions.insert("punpcklbw",QObject::tr("unpack low-order bytes."));
Instructions.insert("punpckldq",QObject::tr("unpack low-order doublewords."));
Instructions.insert("punpcklwd",QObject::tr("unpack low-order words."));
//Packed Arithmetic Instructions (MMX)
Instructions.insert("paddb",QObject::tr("add packed byte integers."));
Instructions.insert("paddd",QObject::tr("add packed doubleword integers."));
Instructions.insert("paddsb",QObject::tr("add packed signed byte integers with signed saturation."));
Instructions.insert("paddsw",QObject::tr("add packed signed word integers with signed saturation."));
Instructions.insert("paddusb",QObject::tr("add packed unsigned byte integers with unsigned saturation."));
Instructions.insert("paddusw",QObject::tr("add packed unsigned word integers with unsigned saturation."));
Instructions.insert("paddw",QObject::tr("add packed word integers."));
Instructions.insert("pmaddwd",QObject::tr("multiply and add packed word integers."));
Instructions.insert("pmulhw",QObject::tr("multiply packed signed word integers and store high result."));
Instructions.insert("pmullw",QObject::tr("multiply packed signed word integers and store low result."));
Instructions.insert("psubb",QObject::tr("subtract packed byte integers."));
Instructions.insert("psubd",QObject::tr("subtract packed doubleword integers."));
Instructions.insert("psubsb",QObject::tr("subtract packed signed byte integers with signed saturation."));
Instructions.insert("psubsw",QObject::tr("subtract packed signed word integers with signed saturation."));
Instructions.insert("psubusb",QObject::tr("subtract packed unsigned byte integers with unsigned saturation."));
Instructions.insert("psubusw",QObject::tr("subtract packed unsigned word integers with unsigned saturation."));
Instructions.insert("psubw",QObject::tr("subtract packed word integers."));
//Comparison Instructions (MMX)
Instructions.insert("pcmpeqb",QObject::tr("compare packed bytes for equal."));
Instructions.insert("pcmpeqd",QObject::tr("compare packed doublewords for equal."));
Instructions.insert("pcmpeqw",QObject::tr("compare packed words for equal."));
Instructions.insert("pcmpgtb",QObject::tr("compare packed signed byte integers for greater than."));
Instructions.insert("pcmpgtd",QObject::tr("compare packed signed doubleword integers for greater than."));
Instructions.insert("pcmpgtw",QObject::tr("compare packed signed word integers for greater than."));
//Logical Instructions (MMX)
Instructions.insert("pand",QObject::tr("bitwise logical and."));
Instructions.insert("pandn",QObject::tr("bitwise logical and not."));
Instructions.insert("por",QObject::tr("bitwise logical or."));
Instructions.insert("pxor",QObject::tr("bitwise logical xor."));
//Shift and Rotate Instructions (MMX)
Instructions.insert("pslld",QObject::tr("shift packed doublewords left logical."));
Instructions.insert("psllq",QObject::tr("shift packed quadword left logical."));
Instructions.insert("psllw",QObject::tr("shift packed words left logical."));
Instructions.insert("psrad",QObject::tr("shift packed doublewords right arithmetic."));
Instructions.insert("psraw",QObject::tr("shift packed words right arithmetic."));
Instructions.insert("psrld",QObject::tr("shift packed doublewords right logical."));
Instructions.insert("psrlq",QObject::tr("shift packed quadword right logical."));
Instructions.insert("psrlw",QObject::tr("shift packed words right logical."));
//State Management Instructions (MMX)
Instructions.insert("emms",QObject::tr("empty mmx state."));
//SSE Instructions
//SIMD Single-Precision Floating-Point Instructions (SSE)
//Data Transfer Instructions (SSE)
Instructions.insert("solaris",QObject::tr("mnemonic  description."));
Instructions.insert("movaps",QObject::tr("move four aligned packed single-precision floating-point values between xmm registers or memory."));
Instructions.insert("movhlps",QObject::tr("move two packed single-precision floating-point values from the high quadword of an xmm register to the low quadword of another xmm register."));
Instructions.insert("movhps",QObject::tr("move two packed single-precision floating-point values to or from the high quadword of an xmm register or memory."));
Instructions.insert("movlhps",QObject::tr("move two packed single-precision floating-point values from the low quadword of an xmm register to the high quadword of another xmm register."));
Instructions.insert("movlps",QObject::tr("move two packed single-precision floating-point values to or from the low quadword of an xmm register or memory."));
Instructions.insert("movmskps",QObject::tr("extract sign mask from four packed single-precision floating-point values."));
Instructions.insert("movss",QObject::tr("move scalar single-precision floating-point value between xmm registers or memory."));
Instructions.insert("movups",QObject::tr("move four unaligned packed single-precision floating-point values between xmm registers or memory."));
//Packed Arithmetic Instructions (SSE)
Instructions.insert("addps",QObject::tr("add packed single-precision floating-point values."));
Instructions.insert("addss",QObject::tr("add scalar single-precision floating-point values."));
Instructions.insert("divps",QObject::tr("divide packed single-precision floating-point values."));
Instructions.insert("divss",QObject::tr("divide scalar single-precision floating-point values."));
Instructions.insert("maxps",QObject::tr("return maximum packed single-precision floating-point values."));
Instructions.insert("maxss",QObject::tr("return maximum scalar single-precision floating-point values."));
Instructions.insert("minps",QObject::tr("return minimum packed single-precision floating-point values."));
Instructions.insert("minss",QObject::tr("return minimum scalar single-precision floating-point values.."));
Instructions.insert("mulps",QObject::tr("multiply packed single-precision floating-point values."));
Instructions.insert("mulss",QObject::tr("multiply scalar single-precision floating-point values."));
Instructions.insert("rcpps",QObject::tr("compute reciprocals of packed single-precision floating-point values."));
Instructions.insert("rcpss",QObject::tr("compute reciprocal of scalar single-precision floating-point values."));
Instructions.insert("rsqrtps",QObject::tr("compute reciprocals of square roots of packed single-precision floating-point values."));
Instructions.insert("rsqrtss",QObject::tr("compute reciprocal of square root of scalar single-precision floating-point values."));
Instructions.insert("sqrtps",QObject::tr("compute square roots of packed single-precision floating-point values."));
Instructions.insert("sqrtss",QObject::tr("compute square root of scalar single-precision floating-point values."));
Instructions.insert("subps",QObject::tr("subtract packed single-precision floating-point values."));
Instructions.insert("subss",QObject::tr("subtract scalar single-precision floating-point values."));
//Comparison Instructions (SSE)
Instructions.insert("cmpps",QObject::tr("compare packed single-precision floating-point values."));
Instructions.insert("cmpss",QObject::tr("compare scalar single-precision floating-point values."));
Instructions.insert("comiss",QObject::tr("perform ordered comparison of scalar single-precision floating-point values and set flags in eflags register."));
Instructions.insert("ucomiss",QObject::tr("perform unordered comparison of scalar single-precision floating-point values and set flags in eflags register."));
//Logical Instructions (SSE)
Instructions.insert("andnps",QObject::tr("perform bitwise logical and not of packed single-precision floating-point values."));
Instructions.insert("andps",QObject::tr("perform bitwise logical and of packed single-precision floating-point values."));
Instructions.insert("orps",QObject::tr("perform bitwise logical or of packed single-precision floating-point values."));
Instructions.insert("xorps",QObject::tr("perform bitwise logical xor of packed single-precision floating-point values."));
//Shuffle and Unpack Instructions (SSE)
Instructions.insert("shufps",QObject::tr("shuffles values in packed single-precision floating-point operands."));
Instructions.insert("unpckhps",QObject::tr("unpacks and interleaves the two high-order values from two single-precision floating-point operands."));
Instructions.insert("unpcklps",QObject::tr("unpacks and interleaves the two low-order values from two single-precision floating-point operands."));
//Conversion Instructions (SSE)
Instructions.insert("cvtpi2ps",QObject::tr("convert packed doubleword integers to packed single-precision floating-point values."));
Instructions.insert("cvtps2pi",QObject::tr("convert packed single-precision floating-point values to packed doubleword integers."));
Instructions.insert("cvtsi2ss",QObject::tr("convert doubleword integer to scalar single-precision floating-point value."));
Instructions.insert("cvtss2si",QObject::tr("convert scalar single-precision floating-point value to a doubleword integer."));
Instructions.insert("cvttps2pi",QObject::tr("convert with truncation packed single-precision floating-point values to packed doubleword integers."));
Instructions.insert("cvttss2si",QObject::tr("convert with truncation scalar single-precision floating-point value to scalar doubleword integer."));
//MXCSR State Management Instructions (SSE)
Instructions.insert("ldmxcsr",QObject::tr("load %mxcsr register."));
Instructions.insert("stmxcsr",QObject::tr("save %mxcsr register state."));
//64–Bit SIMD Integer Instructions (SSE)
Instructions.insert("pavgb",QObject::tr("compute average of packed unsigned byte integers."));
Instructions.insert("pavgw",QObject::tr("compute average of packed unsigned byte integers."));
Instructions.insert("pextrw",QObject::tr("extract word."));
Instructions.insert("pinsrw",QObject::tr("insert word."));
Instructions.insert("pmaxsw",QObject::tr("maximum of packed signed word integers."));
Instructions.insert("pmaxub",QObject::tr("maximum of packed unsigned byte integers."));
Instructions.insert("pminsw",QObject::tr("minimum of packed signed word integers."));
Instructions.insert("pminub",QObject::tr("minimum of packed unsigned byte integers."));
Instructions.insert("pmovmskb",QObject::tr("move byte mask."));
Instructions.insert("pmulhuw",QObject::tr("multiply packed unsigned integers and store high result."));
Instructions.insert("psadbw",QObject::tr("compute sum of absolute differences."));
Instructions.insert("pshufw",QObject::tr("shuffle packed integer word in mmx register."));
//Miscellaneous Instructions (SSE)
Instructions.insert("maskmovq",QObject::tr("non-temporal store of selected bytes from an mmx register into memory."));
Instructions.insert("movntps",QObject::tr("non-temporal store of four packed single-precision floating-point values from an xmm register into memory."));
Instructions.insert("movntq",QObject::tr("non-temporal store of quadword from an mmx register into memory."));
Instructions.insert("prefetchnta",QObject::tr("prefetch data into non-temporal cache structure and into a location close to the processor."));
Instructions.insert("prefetcht0",QObject::tr("prefetch data into all levels of the cache hierarchy."));
Instructions.insert("prefetcht1",QObject::tr("prefetch data into level 2 cache and higher."));
Instructions.insert("prefetcht2",QObject::tr("prefetch data into level 2 cache and higher."));
Instructions.insert("sfence",QObject::tr("serialize store operations."));
//SSE2 Instructions
//SSE2 Packed and Scalar Double-Precision Floating-Point Instructions
//SSE2 Data Movement Instructions
Instructions.insert("movapd",QObject::tr("move two aligned packed double-precision floating-point values between xmm registers and memory."));
Instructions.insert("movhpd",QObject::tr("move high packed double-precision floating-point value to or from the high quadword of an xmm register and memory."));
Instructions.insert("movlpd",QObject::tr("move low packed single-precision floating-point value to or from the low quadword of an xmm register and memory."));
Instructions.insert("movmskpd",QObject::tr("extract sign mask from two packed double-precision floating-point values."));
Instructions.insert("movsd",QObject::tr("move scalar double-precision floating-point value between xmm registers and memory.."));
Instructions.insert("movupd",QObject::tr("move two unaligned packed double-precision floating-point values between xmm registers and memory."));
//SSE2 Packed Arithmetic Instructions
Instructions.insert("addpd",QObject::tr("add packed double-precision floating-point values."));
Instructions.insert("addsd",QObject::tr("add scalar double-precision floating-point values."));
Instructions.insert("divpd",QObject::tr("divide packed double-precision floating-point values."));
Instructions.insert("divsd",QObject::tr("divide scalar double-precision floating-point values."));
Instructions.insert("maxpd",QObject::tr("return maximum packed double-precision floating-point values."));
Instructions.insert("maxsd",QObject::tr("return maximum scalar double-precision floating-point value."));
Instructions.insert("minpd",QObject::tr("return minimum packed double-precision floating-point values."));
Instructions.insert("minsd",QObject::tr("return minimum scalar double-precision floating-point value."));
Instructions.insert("mulpd",QObject::tr("multiply packed double-precision floating-point values."));
Instructions.insert("mulsd",QObject::tr("multiply scalar double-precision floating-point values."));
Instructions.insert("sqrtpd",QObject::tr("compute packed square roots of packed double-precision floating-point values."));
Instructions.insert("sqrtsd",QObject::tr("compute scalar square root of scalar double-precision floating-point value."));
Instructions.insert("subpd",QObject::tr("subtract packed double-precision floating-point values."));
Instructions.insert("subsd",QObject::tr("subtract scalar double-precision floating-point values."));
//SSE2 Logical Instructions
Instructions.insert("andnpd",QObject::tr("perform bitwise logical and not of packed double-precision floating-point values."));
Instructions.insert("andpd",QObject::tr("perform bitwise logical and of packed double-precision floating-point values."));
Instructions.insert("orpd",QObject::tr("perform bitwise logical or of packed double-precision floating-point values."));
Instructions.insert("xorpd",QObject::tr("perform bitwise logical xor of packed double-precision floating-point values."));
//SSE2 Compare Instructions
Instructions.insert("cmppd",QObject::tr("compare packed double-precision floating-point values."));
Instructions.insert("cmpsd",QObject::tr("compare scalar double-precision floating-point values."));
Instructions.insert("comisd",QObject::tr("perform ordered comparison of scalar double-precision floating-point values and set flags in eflags register."));
Instructions.insert("ucomisd",QObject::tr("perform unordered comparison of scalar double-precision floating-point values and set flags in eflags register."));
//SSE2 Shuffle and Unpack Instructions
Instructions.insert("shufpd",QObject::tr("shuffle values in packed double-precision floating-point operands."));
Instructions.insert("unpckhpd",QObject::tr("unpack and interleave the high values from two packed double-precision floating-point operands."));
Instructions.insert("unpcklpd",QObject::tr("unpack and interleave the low values from two packed double-precision floating-point operands."));
//SSE2 Conversion Instructions
Instructions.insert("cvtdq2pd",QObject::tr("convert packed doubleword integers to packed double-precision floating-point values."));
Instructions.insert("cvtpd2dq",QObject::tr("convert packed double-precision floating-point values to packed doubleword integers."));
Instructions.insert("cvtpd2pi",QObject::tr("convert packed double-precision floating-point values to packed doubleword integers."));
Instructions.insert("cvtpd2ps",QObject::tr("convert packed double-precision floating-point values to packed single-precision floating-point values."));
Instructions.insert("cvtpi2pd",QObject::tr("convert packed doubleword integers to packed double-precision floating-point values."));
Instructions.insert("cvtps2pd",QObject::tr("convert packed single-precision floating-point values to packed double-precision floating-point values."));
Instructions.insert("cvtsd2si",QObject::tr("convert scalar double-precision floating-point values to a doubleword integer."));
Instructions.insert("cvtsd2ss",QObject::tr("convert scalar double-precision floating-point values to scalar single-precision floating-point values."));
Instructions.insert("cvtsi2sd",QObject::tr("convert doubleword integer to scalar double-precision floating-point value."));
Instructions.insert("cvtss2sd",QObject::tr("convert scalar single-precision floating-point values to scalar double-precision floating-point values."));
Instructions.insert("cvttpd2dq",QObject::tr("convert with truncation packed double-precision floating-point values to packed doubleword integers."));
Instructions.insert("cvttpd2pi",QObject::tr("convert with truncation packed double-precision floating-point values to packed doubleword integers."));
Instructions.insert("cvttsd2si",QObject::tr("convert with truncation scalar double-precision floating-point values to scalar doubleword integers."));
//SSE2 Packed Single-Precision Floating-Point Instructions
Instructions.insert("cvtdq2ps",QObject::tr("convert packed doubleword integers to packed single-precision floating-point values."));
Instructions.insert("cvtps2dq",QObject::tr("convert packed single-precision floating-point values to packed doubleword integers."));
Instructions.insert("cvttps2dq",QObject::tr("convert with truncation packed single-precision floating-point values to packed doubleword integers."));
//SSE2 128–Bit SIMD Integer Instructions
Instructions.insert("movdq2q",QObject::tr("move quadword integer from xmm to mmx registers."));
Instructions.insert("movdqa",QObject::tr("move aligned double quadword."));
Instructions.insert("movdqu",QObject::tr("move unaligned double quadword."));
Instructions.insert("movq2dq",QObject::tr("move quadword integer from mmx to xmm registers."));
Instructions.insert("paddq",QObject::tr("add packed quadword integers."));
Instructions.insert("pmuludq",QObject::tr("multiply packed unsigned doubleword integers."));
Instructions.insert("pshufd",QObject::tr("shuffle packed doublewords."));
Instructions.insert("pshufhw",QObject::tr("shuffle packed high words."));
Instructions.insert("pshuflw",QObject::tr("shuffle packed low words."));
Instructions.insert("pslldq",QObject::tr("shift double quadword left logical."));
Instructions.insert("psrldq",QObject::tr("shift double quadword right logical."));
Instructions.insert("psubq",QObject::tr("subtract packed quadword integers."));
Instructions.insert("punpckhqdq",QObject::tr("unpack high quadwords."));
Instructions.insert("punpcklqdq",QObject::tr("unpack low quadwords."));
//SSE2 Miscellaneous Instructions
Instructions.insert("clflush",QObject::tr("flushes and invalidates a memory operand and its associated cache line from all levels of the processor's cache hierarchy."));
Instructions.insert("lfence",QObject::tr("serializes load operations."));
Instructions.insert("maskmovdqu",QObject::tr("non-temporal store of selected bytes from an xmm register into memory."));
Instructions.insert("mfence",QObject::tr("serializes load and store operations."));
Instructions.insert("movntdq",QObject::tr("non-temporal store of double quadword from an xmm register into memory."));
Instructions.insert("movnti",QObject::tr("non-temporal store of a doubleword from a general-purpose register into memory."));
Instructions.insert("movntpd",QObject::tr("non-temporal store of two packed double-precision floating-point values from an xmm register into memory."));
Instructions.insert("pause",QObject::tr("improves the performance of spin-wait loops."));
InstructionNames=QSet<QString>(Instructions.keyBegin(),Instructions.keyEnd());
}
}
bool ASMSyntaxer::eol() const
{
return mTokenID == TokenId::Null;
@ -618,7 +1268,7 @@ void ASMSyntaxer::resetState()
QSet<QString> ASMSyntaxer::keywords()
{
if (mKeywordsCache.isEmpty()) {
mKeywordsCache=Instructions;
mKeywordsCache=InstructionNames;
if (!isATT()) {
mKeywordsCache.unite(Directives);
mKeywordsCache.unite(Registers);

4
libs/qsynedit/qsynedit/syntaxer/asm.h
View File

@ -53,7 +53,8 @@ public:
const PTokenAttribute &labelAttribute() const;
const PTokenAttribute &registerAttribute() const;
static const QSet<QString> Instructions;
static QMap<QString,QString> Instructions;
static QSet<QString> InstructionNames;
static const QSet<QString> Registers;
static const QSet<QString> ATTRegisters;
static const QSet<QString> Directives;
@ -91,6 +92,7 @@ private:
void SymbolProc();
void UnknownProc();
bool isIdentStartChar(const QChar& ch);
static void initData();
// SynHighlighter interface
public:

2980
libs/qsynedit/qsynedit_zh_CN.ts Normal file
View File

File diff suppressed because it is too large Load Diff