/// <summary>
/// Singleton pattern: use AsmDudeTools.Instance for the instance of this class
/// </summary>
private AsmDudeTools()
{
//AsmDudeToolsStatic.Output(string.Format("INFO: AsmDudeTools constructor"));
#region Initialize ErrorListProvider
IServiceProvider serviceProvider = new ServiceProvider(Package.GetGlobalService(typeof(Microsoft.VisualStudio.OLE.Interop.IServiceProvider)) as Microsoft.VisualStudio.OLE.Interop.IServiceProvider);
this._errorListProvider = new ErrorListProvider(serviceProvider);
this._errorListProvider.ProviderName = "Asm Errors";
this._errorListProvider.ProviderGuid = new Guid(EnvDTE.Constants.vsViewKindCode);
#endregion
this._smartThreadPool = new SmartThreadPool();
//this._smartThreadPool.Start();
#region load signature store
string path = AsmDudeToolsStatic.getInstallPath() + "Resources" + Path.DirectorySeparatorChar;
//string filename = path + "mnemonics-nasm.txt";
string filename_Regular = path + "signature-june2016.txt";
string filename_Hand = path + "signature-hand-1.txt";
this._mnemonicStore = new MnemonicStore(filename_Regular, filename_Hand);
#endregion
this.initData();
#region Experiments
if (false)
{
string filename2 = AsmDudeToolsStatic.getInstallPath() + "Resources" + Path.DirectorySeparatorChar + "mnemonics-nasm.txt";
MnemonicStore store2 = new MnemonicStore(filename2, null);
ISet <String> archs = new SortedSet <String>();
IDictionary <string, string> signaturesIntel = new Dictionary <string, string>();
IDictionary <string, string> signaturesNasm = new Dictionary <string, string>();
foreach (Mnemonic mnemonic in Enum.GetValues(typeof(Mnemonic)))
{
IList <AsmSignatureElement> intel = this._mnemonicStore.getSignatures(mnemonic);
IList <AsmSignatureElement> nasm = store2.getSignatures(mnemonic);
signaturesIntel.Clear();
signaturesNasm.Clear();
foreach (AsmSignatureElement e in intel)
{
string instruction = e.mnemonic.ToString() + " " + e.operandsStr;
if (signaturesIntel.ContainsKey(instruction))
{
AsmDudeToolsStatic.Output("WARNING: Intel " + instruction + ": is already present with arch " + signaturesIntel[instruction] + "; new arch " + e.archStr);
}
else
{
signaturesIntel.Add(instruction, e.archStr);
}
}
foreach (AsmSignatureElement e in nasm)
{
string instruction = e.mnemonic.ToString() + " " + e.operandsStr;
if (signaturesNasm.ContainsKey(instruction))
{
// AsmDudeToolsStatic.Output("WARNING: Nasm " + instruction + ": is already present with arch " + signaturesNasm[instruction] + "; new arch " + e.archStr);
}
else
{
signaturesNasm.Add(instruction, e.archStr);
}
}
foreach (AsmSignatureElement e in intel)
{
string instruction = e.mnemonic.ToString() + " " + e.operandsStr;
//AsmDudeToolsStatic.Output("Intel " + instruction + ": arch" + e.archStr);
if ((e.archStr == null) || (e.archStr.Length == 0))
{
if (signaturesNasm.ContainsKey(instruction))
{
AsmDudeToolsStatic.Output("Intel " + instruction + " has no arch, but NASM has \"" + signaturesNasm[instruction] + "\".");
}
else
{
if (signaturesNasm.Count == 1)
{
AsmDudeToolsStatic.Output("Intel " + instruction + " has no arch, but NASM has \"" + signaturesNasm.GetEnumerator().Current + "\".");
}
else
{
AsmDudeToolsStatic.Output("Intel " + instruction + " has no arch:");
foreach (KeyValuePair <string, string> pair in signaturesNasm)
{
AsmDudeToolsStatic.Output("\tNASM has " + pair.Key + ": \"" + pair.Value + "\".");
}
AsmDudeToolsStatic.Output(" ----");
}
}
}
}
if (false)
{
if (intel.Count != nasm.Count)
{
foreach (AsmSignatureElement e in intel)
{
AsmDudeToolsStatic.Output("INTEL " + mnemonic + ": " + e);
}
foreach (AsmSignatureElement e in nasm)
{
AsmDudeToolsStatic.Output("NASM " + mnemonic + ": " + e);
}
}
}
}
foreach (String str in archs)
{
AsmDudeToolsStatic.Output("INTEL arch " + str);
}
}
if (false)
{
foreach (Arch arch in Enum.GetValues(typeof(Arch)))
{
int counter = 0;
ISet <Mnemonic> usedMnemonics = new HashSet <Mnemonic>();
foreach (Mnemonic mnemonic in Enum.GetValues(typeof(Mnemonic)))
{
if (this.mnemonicStore.getArch(mnemonic).Contains(arch))
{
//AsmDudeToolsStatic.Output("INFO: AsmDudeTools constructor: arch="+arch+"; mnemonic=" + mnemonic);
counter++;
usedMnemonics.Add(mnemonic);
}
}
string str = "";
foreach (Mnemonic mnemonic in usedMnemonics)
{
str += mnemonic.ToString() + ",";
}
AsmDudeToolsStatic.Output("INFO: AsmDudeTools constructor: Architecture Option " + arch + " enables mnemonics " + str);
}
}
if (false)
{
foreach (Mnemonic mnemonic in Enum.GetValues(typeof(Mnemonic)))
{
string keyword = mnemonic.ToString().ToUpper();
if (this._description.ContainsKey(keyword))
{
string description = this._description[keyword];
string reference = this.getUrl(keyword);
this.mnemonicStore.setHtmlRef(mnemonic, reference);
}
}
AsmDudeToolsStatic.Output(this.mnemonicStore.ToString());
}
if (false)
{
ISet <string> archs = new HashSet <string>();
foreach (Mnemonic mnemonic in Enum.GetValues(typeof(Mnemonic)))
{
if (!this._mnemonicStore.hasElement(mnemonic))
{
AsmDudeToolsStatic.Output("INFO: AsmDudeTools constructor: mnemonic " + mnemonic + " is not present");
}
foreach (AsmSignatureElement e in this._mnemonicStore.getSignatures(mnemonic))
{
foreach (string s in e.archStr.Split(','))
{
archs.Add(s.Trim());
}
}
}
foreach (string s in archs)
{
AsmDudeToolsStatic.Output(s + ",");
}
}
#endregion
}
