public IEnumerable <ITagSpan <AsmTokenTag> > GetTags(NormalizedSnapshotSpanCollection spans) { DateTime time1 = DateTime.Now; if (spans.Count == 0) { //there is no content in the buffer yield break; } foreach (SnapshotSpan curSpan in spans) { ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine(); string line = containingLine.GetText().ToUpper(); IList <(int, int, bool)> pos = AsmSourceTools.SplitIntoKeywordPos(line); int offset = containingLine.Start.Position; int nKeywords = pos.Count; for (int k = 0; k < nKeywords; k++) { string asmToken = Keyword(pos[k], line); AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type(asmToken); if ((keywordType == AsmTokenType.Mnemonic) || (keywordType == AsmTokenType.Jump)) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), new AsmTokenTag(keywordType))); } } } AsmDudeToolsStatic.Print_Speed_Warning(time1, "DebugTokenTagger"); }
public override void PreprocessMouseUp(MouseButtonEventArgs e) { if (Settings.Default.AsmDoc_On) { try { if (this.mouseDownAnchorPoint_.HasValue && this.state_.Enabled) { Point currentMousePosition = this.RelativeToView(e.GetPosition(this.view_.VisualElement)); if (!this.InDragOperation(this.mouseDownAnchorPoint_.Value, currentMousePosition)) { this.state_.Enabled = false; ITextViewLine line = this.view_.TextViewLines.GetTextViewLineContainingYCoordinate(currentMousePosition.Y); SnapshotPoint?bufferPosition = line.GetBufferPositionFromXCoordinate(currentMousePosition.X); string keyword = AsmDudeToolsStatic.Get_Keyword_Str(bufferPosition); if (keyword != null) { (Mnemonic mnemonic, AttType type) = AsmSourceTools.ParseMnemonic_Att(keyword, false); System.Runtime.CompilerServices.ConfiguredTaskAwaitable <bool> result = this.Dispatch_Goto_DocAsync(mnemonic).ConfigureAwait(false); // use .ConfigureAwait(false) to signal your intention for continuation. } this.Set_Highlight_Span(null); this.view_.Selection.Clear(); e.Handled = true; } } this.mouseDownAnchorPoint_ = null; } catch (Exception ex) { AsmDudeToolsStatic.Output_ERROR(string.Format(AsmDudeToolsStatic.CultureUI, "{0} PreprocessMouseUp; e={1}", this.ToString(), ex.ToString())); } } }
/// <summary>Perform onestep forward and return the state of the regular branch</summary> public static State SimpleStep_Backward(string line, State state) { string prevKey = Tools.CreateKey(state.Tools.Rand); var content = AsmSourceTools.ParseLine(line); using (var opcodeBase = Runner.InstantiateOpcode(content.Mnemonic, content.Args, (prevKey, state.TailKey, state.TailKey), state.Tools)) { if (opcodeBase == null) { return(null); } if (opcodeBase.IsHalted) { return(null); } opcodeBase.Execute(); State stateOut = new State(state); stateOut.Update_Backward(opcodeBase.Updates.Regular, prevKey); opcodeBase.Updates.Regular?.Dispose(); opcodeBase.Updates.Branch?.Dispose(); if (!state.Tools.Quiet) { Console.WriteLine("INFO: Runner:SimpleStep_Backward: after \"" + line + "\" we know:"); } if (!state.Tools.Quiet) { Console.WriteLine(stateOut); } return(stateOut); } }
public void Test_AsmSourceTools_splitIntoKeywordsPos() { { const string line = " db \"This string contains the word jmp inside of it\",0"; IList <(int, int, bool)> result = new List <(int, int, bool)>(AsmSourceTools.SplitIntoKeywordPos(line)); for (int i = 0; i < result.Count; ++i) { Console.WriteLine(line.Substring(result[i].Item1, result[i].Item2 - result[i].Item1)); } Assert.AreEqual(3, result.Count); Assert.AreEqual("db", line.Substring(result[0].Item1, result[0].Item2 - result[0].Item1)); Assert.AreEqual("\"This string contains the word jmp inside of it\"", line.Substring(result[1].Item1, result[1].Item2 - result[1].Item1)); Assert.AreEqual("0", line.Substring(result[2].Item1, result[2].Item2 - result[2].Item1)); } { const string line = " call ??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z"; IList <(int, int, bool)> result = new List <(int, int, bool)>(AsmSourceTools.SplitIntoKeywordPos(line)); for (int i = 0; i < result.Count; ++i) { Console.WriteLine(line.Substring(result[i].Item1, result[i].Item2 - result[i].Item1)); } Assert.AreEqual(2, result.Count); Assert.AreEqual("call", line.Substring(result[0].Item1, result[0].Item2 - result[0].Item1)); Assert.AreEqual("??$?6U?$char_traits@D@std@@@std@@YAAEAV?$basic_ostream@DU?$char_traits@D@std@@@0@AEAV10@PEBD@Z", line.Substring(result[1].Item1, result[1].Item2 - result[1].Item1)); } }
/// <summary>Guess whether the provided buffer has assembly in Masm syntax (return true) or Gas syntax (return false)</summary> public static bool Guess_Masm_Syntax(ITextBuffer buffer, int nLinesMax = 30) { //AsmDudeToolsStatic.Output_INFO(string.Format("{0}:Guess_Masm_Syntax. file=\"{1}\"", "AsmDudeToolsStatic", AsmDudeToolsStatic.GetFilename(buffer))); ITextSnapshot snapshot = buffer.CurrentSnapshot; int evidence_masm = 0; for (int i = 0; i < Math.Min(snapshot.LineCount, nLinesMax); ++i) { string line_capitals = snapshot.GetLineFromLineNumber(i).GetText().ToUpper(); //AsmDudeToolsStatic.Output_INFO(string.Format("{0}:Guess_Masm_Syntax {1}:\"{2}\"", "AsmDudeToolsStatic", i, line_capitals)); List <string> keywords = AsmSourceTools.SplitIntoKeywordsList(line_capitals); foreach (string word in keywords) { switch (word) { case "PTR": case "@B": case "@F": evidence_masm++; break; case ".INTEL_SYNTAX": case ".ATT_SYNTAX": return(false); // we know for sure } } } bool result = (evidence_masm > 0); AsmDudeToolsStatic.Output_INFO(string.Format("{0}:Guess_Masm_Syntax; result {1}; file=\"{2}\"; evidence_masm {3}", "AsmDudeToolsStatic", result, AsmDudeToolsStatic.GetFilename(buffer), evidence_masm)); return(result); }
public void SetDescription(Rn reg, AsmDudeTools asmDudeTools) { string regStr = reg.ToString(); this.Description.Inlines.Add(new Run("Register ") { FontWeight = FontWeights.Bold, Foreground = this._foreground }); this.Description.Inlines.Add(new Run(regStr) { FontWeight = FontWeights.Bold, Foreground = new SolidColorBrush(AsmDudeToolsStatic.ConvertColor(Settings.Default.SyntaxHighlighting_Register)) }); Arch arch = RegisterTools.GetArch(reg); string archStr = (arch == Arch.ARCH_NONE) ? "" : " [" + ArchTools.ToString(arch) + "] "; string descr = asmDudeTools.Get_Description(regStr); if (regStr.Length > (AsmDudePackage.maxNumberOfCharsInToolTips / 2)) { descr = "\n" + descr; } string full_Descr = AsmSourceTools.Linewrap(":" + archStr + descr, AsmDudePackage.maxNumberOfCharsInToolTips); this.Description.Inlines.Add(new Run(full_Descr) { Foreground = this._foreground }); }
public void Test_AsmSourceTools_parseMnemonic() { foreach (Mnemonic x in Enum.GetValues(typeof(Mnemonic))) { Assert.AreEqual(AsmSourceTools.ParseMnemonic(x.ToString(), true), x, "Parsing string " + x.ToString() + " does not yield the same enumeration."); } }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread(); try { SnapshotPoint currentPoint = this._textView.Caret.Position.BufferPosition; if ((currentPoint != null) && (currentPoint > 0)) { SnapshotPoint point = currentPoint - 1; if (point.Position > 1) { ITextSnapshotLine line = point.Snapshot.GetLineFromPosition(point.Position); string lineStr = line.GetText(); int pos = point.Position - line.Start; if (!AsmSourceTools.IsInRemark(pos, lineStr)) { //check if current position is in a remark; if we are in a remark, no signature help if ((pguidCmdGroup == VSConstants.VSStd2K) && (nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)) { char typedChar = this.GetTypeChar(pvaIn); if (char.IsWhiteSpace(typedChar) || typedChar.Equals(',')) { (string Label, Mnemonic Mnemonic, string[] Args, string Remark)t = AsmSourceTools.ParseLine(lineStr); if (this._session != null) { this._session.Dismiss(); // cleanup previous session } if (t.Mnemonic != Mnemonic.NONE) { this._session = this._broker.TriggerSignatureHelp(this._textView); } } else if (AsmSourceTools.IsRemarkChar(typedChar) && (this._session != null)) { this._session.Dismiss(); this._session = null; } } else { bool enterPressed = nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN; if (enterPressed && (this._session != null)) { this._session.Dismiss(); this._session = null; } } } } } } catch (Exception e) { AsmDudeToolsStatic.Output_ERROR(string.Format("{0}:Exec; e={1}", this.ToString(), e.ToString())); } return(this._nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
public void AddData(MicroArch microArch, string filename) { AsmDudeToolsStatic.Output_INFO("PerformanceStore:AddData: microArch=" + microArch + "; filename=" + filename); try { System.IO.StreamReader file = new System.IO.StreamReader(filename); string line; while ((line = file.ReadLine()) != null) { if ((line.Trim().Length > 0) && (!line.StartsWith(";"))) { string[] columns = line.Split('\t'); if (columns.Length == 5) { { // handle instruction foreach (string mnemonicStr in columns[0].Split(' ')) { if (mnemonicStr.Length > 0) { Mnemonic mnemonic = AsmSourceTools.ParseMnemonic(mnemonicStr); if (mnemonic == Mnemonic.UNKNOWN) { AsmDudeToolsStatic.Output_WARNING("PerformanceStore:LoadData: microArch=" + microArch + ": unknown mnemonic " + mnemonicStr + " in line: " + line); } else { PerformanceItem item = new PerformanceItem(); item._microArch = microArch; item._instr = mnemonic; item._args = columns[1]; item._latency = columns[2]; item._throughput = columns[3]; item._remark = columns[4]; this._data.Add(item); } } } } } else { AsmDudeToolsStatic.Output_WARNING("PerformanceStore:AddData: found " + columns.Length + " columns; funky line" + line); } } } file.Close(); } catch (FileNotFoundException) { AsmDudeToolsStatic.Output_ERROR("PerformanceStore:LoadData: could not find file \"" + filename + "\"."); } catch (Exception e) { AsmDudeToolsStatic.Output_ERROR("PerformanceStore:LoadData: error while reading file \"" + filename + "\"." + e); } }
public void Test_AsmSourceTools_Get_Related_Constant() { int nBits = 64; ulong value = 3352562; string original = value.ToString(Culture); string related = AsmSourceTools.Get_Related_Constant(original, value, nBits); Console.WriteLine(related); }
private IDictionary <string, IList <Mnemonic> > Load_Instruction_Translation(string filename) { IDictionary <string, IList <Mnemonic> > translations = new Dictionary <string, IList <Mnemonic> >(); try { StreamReader file = new StreamReader(filename); string line; while ((line = file.ReadLine()) != null) { if ((line.Trim().Length > 0) && (!line.StartsWith(";"))) { string[] columns = line.Split('\t'); if (columns.Length == 2) { string key = columns[0].Trim(); IList <Mnemonic> values = new List <Mnemonic>(); foreach (string mnemonicStr in columns[1].Trim().Split(' ')) { Mnemonic mnemonic = AsmSourceTools.ParseMnemonic(mnemonicStr); if (mnemonic == Mnemonic.NONE) { AsmDudeToolsStatic.Output_WARNING("PerformanceStore:Load_Instruction_Translation: key=" + columns[0] + ": unknown mnemonic " + mnemonicStr + " in line: " + line); } else { values.Add(mnemonic); } } //AsmDudeToolsStatic.Output_INFO("PerformanceStore:Load_Instruction_Translation: key=" + key + " = " + String.Join(",", values)); if (translations.ContainsKey(key)) { AsmDudeToolsStatic.Output_WARNING("PerformanceStore:Load_Instruction_Translation: key=" + key + " in line: " + line + " already used"); } else { translations.Add(key, values); } } } } file.Close(); } catch (FileNotFoundException) { AsmDudeToolsStatic.Output_ERROR("PerformanceStore:Load_Instruction_Translation: could not find file \"" + filename + "\"."); } catch (Exception e) { AsmDudeToolsStatic.Output_ERROR("PerformanceStore:Load_Instruction_Translation: error while reading file \"" + filename + "\"." + e); } return(translations); }
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut) { try { SnapshotPoint currentPoint = _textView.Caret.Position.BufferPosition; if ((currentPoint != null) && (currentPoint > 0)) { SnapshotPoint point = currentPoint - 1; if (point.Position > 1) { ITextSnapshotLine line = point.Snapshot.GetLineFromPosition(point.Position); string lineStr = line.GetText(); int pos = point.Position - line.Start; if (!AsmSourceTools.isInRemark(pos, lineStr)) //check if current position is in a remark; if we are in a remark, no signature help { if ((pguidCmdGroup == VSConstants.VSStd2K) && (nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)) { char typedChar = this.GetTypeChar(pvaIn); if (char.IsWhiteSpace(typedChar) || typedChar.Equals(',')) { var t = AsmSourceTools.parseLine(lineStr); if (this._session != null) { this._session.Dismiss(); // cleanup previous session } if (t.Item2 != Mnemonic.UNKNOWN) { this._session = _broker.TriggerSignatureHelp(_textView); } } else if (AsmSourceTools.isRemarkChar(typedChar) && (this._session != null)) { this._session.Dismiss(); this._session = null; } } else { bool enterPressed = (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN); if (enterPressed && (this._session != null)) { this._session.Dismiss(); this._session = null; } } } } } } catch (Exception e) { AsmDudeToolsStatic.Output(string.Format("ERROR: {0}:Exec; e={1}", this.ToString(), e.ToString())); } return(_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)); }
public void Test_AsmSourceTools_OperandType() { foreach (Ot1 x1 in Enum.GetValues(typeof(Ot1))) { foreach (Ot1 x2 in Enum.GetValues(typeof(Ot1))) { (Ot1, Ot1)t = AsmSourceTools.SplitOt(AsmSourceTools.MergeOt(x1, x2)); Assert.AreEqual(t.Item1, x1, string.Empty); Assert.AreEqual(t.Item2, x2, string.Empty); } } }
private AssemblerEnum Retrieve_Assembler(XmlNode node) { try { XmlAttribute archAttribute = node.Attributes["tool"]; return((archAttribute == null) ? AssemblerEnum.UNKNOWN : AsmSourceTools.ParseAssembler(archAttribute.Value)); } catch (Exception) { return(AssemblerEnum.UNKNOWN); } }
public void Test_AsmSourceTools_OperandType() { foreach (Ot x1 in Enum.GetValues(typeof(Ot))) { foreach (Ot x2 in Enum.GetValues(typeof(Ot))) { Tuple <Ot, Ot> t = AsmSourceTools.splitOt(AsmSourceTools.mergeOt(x1, x2)); Assert.AreEqual(t.Item1, x1, ""); Assert.AreEqual(t.Item2, x2, ""); } } }
/// <summary>Perform one step forward and return the regular branch</summary> public static State SimpleStep_Forward(string line, State state) { if (state == null) { Console.WriteLine("WARNING: Runner:SimpleStep_Forward: provided state is null"); return(null); } try { Tools tools = state.Tools; string nextKey = Tools.CreateKey(tools.Rand); string nextKeyBranch = "DUMMY_NOT_USED"; (string label, Mnemonic mnemonic, string[] args, string remark) = AsmSourceTools.ParseLine(line); using (OpcodeBase opcodeBase = InstantiateOpcode(mnemonic, args, (state.HeadKey, nextKey, nextKeyBranch), tools)) { if (opcodeBase == null) { return(null); } if (opcodeBase.IsHalted) { Console.WriteLine("WARNING: Runner:SimpleStep_Forward: line: " + line + " is halted. Message: " + opcodeBase.SyntaxError); return(null); } opcodeBase.Execute(); State stateOut = new State(state); stateOut.Update_Forward(opcodeBase.Updates.regular); stateOut.Frozen = true; opcodeBase.Updates.regular?.Dispose(); opcodeBase.Updates.branch?.Dispose(); if (!tools.Quiet) { Console.WriteLine("INFO: Runner:SimpleStep_Forward: after \"" + line + "\" we know:"); } if (!tools.Quiet) { Console.WriteLine(stateOut); } return(stateOut); } } catch (Exception e) { Console.WriteLine("WARNING: Runner:SimpleStep_Forward: Exception at line: " + line + "; e=" + e.Message); return(new State(state)); } }
/// <summary> /// Find the previous keyword (if any) that exists BEFORE the provided triggerPoint, and the provided start. /// Eg. qqqq xxxxxx yyyyyyy zzzzzz /// ^ ^ /// |begin |end /// the previous keyword is xxxxxx /// </summary> /// <param name="begin"></param> /// <param name="end"></param> /// <returns></returns> public static string getPreviousKeyword(SnapshotPoint begin, SnapshotPoint end) { // return getPreviousKeyword(begin.GetContainingLine.) if (end == 0) { return(""); } int beginLine = begin.GetContainingLine().Start; int beginPos = begin.Position - beginLine; int endPos = end.Position - beginLine; return(AsmSourceTools.getPreviousKeyword(beginPos, endPos, begin.GetContainingLine().GetText())); }
public void Test_AsmSourceTools_GetPreviousKeyword() { const string line = " mov rax, rbx;bla"; { int begin = 0; int end = 8; string result = AsmSourceTools.GetPreviousKeyword(begin, end, line); string msg = "line=\"" + line + "\"; result=\"" + result + "\"; begin=" + begin + "; end=" + end; Assert.AreEqual("mov", result, msg); } { int begin = 4; int end = 8; string result = AsmSourceTools.GetPreviousKeyword(begin, end, line); string msg = "line=\"" + line + "\"; result=\"" + result + "\"; begin=" + begin + "; end=" + end; Assert.AreEqual("mov", result, msg); } { int begin = 5; int end = 8; string result = AsmSourceTools.GetPreviousKeyword(begin, end, line); string msg = "line=\"" + line + "\"; result=\"" + result + "\"; begin=" + begin + "; end=" + end; Assert.AreEqual("ov", result, msg); } { int begin = 0; int end = 7; string result = AsmSourceTools.GetPreviousKeyword(begin, end, line); string msg = "line=\"" + line + "\"; result=\"" + result + "\"; begin=" + begin + "; end=" + end; Assert.AreEqual("mov", result, msg); } { int begin = 0; int end = 6; string result = AsmSourceTools.GetPreviousKeyword(begin, end, line); string msg = "line=\"" + line + "\"; result=\"" + result + "\"; begin=" + begin + "; end=" + end; Assert.AreEqual(string.Empty, result, msg); } { int begin = 0; int end = 11; string result = AsmSourceTools.GetPreviousKeyword(begin, end, line); string msg = "line=\"" + line + "\"; result=\"" + result + "\"; begin=" + begin + "; end=" + end; Assert.AreEqual("rax", result, msg); } }
static Tuple <Mnemonic, List <IformRegister>, int, bool, float, float> ParseLine(string line) { var x = line.Split(','); if (x.Length != 5) { Console.WriteLine("ERROR: could not parse " + line); } var y = x[0].Split('_'); Mnemonic mnemonic = AsmSourceTools.ParseMnemonic(y[0], true); List <IformRegister> args = new List <IformRegister>(); for (int i = 1; i < y.Length; ++i) { var z = ParseIformRegister(y[i], false); if (z == IformRegister.UNKNOWN) { //Console.WriteLine("WARNING: could not parse " + line); } else if (z == IformRegister.IGNORE) { } else { args.Add(z); } } int n_bits = -1; Int32.TryParse(x[1], out n_bits); bool use_mask = (x[2] == "yes"); float throughput = -1; float.TryParse(x[3], out throughput); float latency = -1; float.TryParse(x[4], out latency); return(Tuple.Create(mnemonic, args, n_bits, use_mask, throughput, latency)); }
public void SetAsmSim(AsmSimulator asmSimulator, Rn reg, int lineNumber, bool isExpanded) { Contract.Requires(asmSimulator != null); this.asmSimulator_ = asmSimulator; this.lineNumber_ = lineNumber; bool empty = true; if (this.asmSimulator_.Enabled & Settings.Default.AsmSim_Show_Register_In_Register_Tooltip) { this.AsmSimGridExpander.IsExpanded = isExpanded; this.AsmSimGridExpanderNumeration.Text = Settings.Default.AsmSim_Show_Register_In_Register_Tooltip_Numeration; this.Generate(true, reg); this.Generate(false, reg); empty = false; } this.AsmSimGridExpander.Visibility = empty ? Visibility.Collapsed : Visibility.Visible; this.AsmSimGridBorder.Visibility = empty ? Visibility.Collapsed : Visibility.Visible; this.AsmSimGridExpanderNumeration.SelectionChanged += (sender, i) => { string numerationStr = ((sender as ComboBox).SelectedItem as ComboBoxItem).Content.ToString(); NumerationEnum numeration = AsmSourceTools.ParseNumeration(numerationStr, false); if (numeration == NumerationEnum.UNKNOWN) { AsmDudeToolsStatic.Output_WARNING("SetAsmSim:smSimGridExpanderNumeration.SelectionChanged: unknown numerationStr=" + numerationStr); } //AsmDudeToolsStatic.Output_INFO("AsmSimGridExpanderNumeration:SelectionChanged: numeration="+ numeration); string content_before = this.asmSimulator_.Get_Register_Value_If_Already_Computed(reg, this.lineNumber_, true, numeration); if (content_before != null) { this.textBox_before_.Text = content_before; } string content_after = this.asmSimulator_.Get_Register_Value_If_Already_Computed(reg, this.lineNumber_, false, numeration); if (content_after != null) { this.textBox_after_.Text = content_after; } }; }
/// <summary> /// get url for the provided keyword. Returns empty string if the keyword does not exist or the keyword does not have an url. /// </summary> public string Get_Url(string keyword) { // no need to pre-process this information. try { string keywordUpper = keyword.ToUpper(); Mnemonic mnemonic = AsmSourceTools.ParseMnemonic(keyword); if (mnemonic != Mnemonic.UNKNOWN) { string url = this.Mnemonic_Store.GetHtmlRef(mnemonic); //AsmDudeToolsStatic.Output(string.Format("INFO: {0}:getUrl: keyword {1}; url {2}.", this.ToString(), keyword, url)); return(url); } return(""); } catch (Exception e) { AsmDudeToolsStatic.Output(string.Format("ERROR: {0}:getUrl: exception {1}.", ToString(), e.ToString())); return(""); } }
public AsmTokenType Get_Token_Type_Att(string keyword) { Debug.Assert(keyword == keyword.ToUpper()); int length = keyword.Length; Debug.Assert(length > 0); char firstChar = keyword[0]; #region Test if keyword is a register if (firstChar == '%') { string keyword2 = keyword.Substring(1); Rn reg = RegisterTools.ParseRn(keyword2, true); if (reg != Rn.NOREG) { if (RegisterSwitchedOn(reg)) { return(AsmTokenType.Register); } } } #endregion #region Test if keyword is an imm if (firstChar == '$') { return(AsmTokenType.Constant); } #endregion #region Test if keyword is an instruction { Mnemonic mnemonic = AsmSourceTools.ParseMnemonic_Att(keyword, true); if (mnemonic != Mnemonic.NONE) { if (MnemonicSwitchedOn(mnemonic)) { return((AsmSourceTools.IsJump(mnemonic)) ? AsmTokenType.Jump : AsmTokenType.Mnemonic); } } } #endregion return((this._type.TryGetValue(keyword, out var tokenType)) ? tokenType : AsmTokenType.UNKNOWN); }
public AsmTokenType Get_Token_Type_Att(string keyword) { Contract.Requires(keyword != null); Contract.Requires(keyword == keyword.ToUpperInvariant()); int length = keyword.Length; Contract.Requires(length > 0); char firstChar = keyword[0]; #region Test if keyword is a register if (firstChar == '%') { string keyword2 = keyword.Substring(1); Rn reg = RegisterTools.ParseRn(keyword2, true); if (reg != Rn.NOREG) { return((this.RegisterSwitchedOn(reg)) ? AsmTokenType.Register : AsmTokenType.Register); //TODO } } #endregion #region Test if keyword is an imm if (firstChar == '$') { return(AsmTokenType.Constant); } #endregion #region Test if keyword is an instruction { (Mnemonic mnemonic, AttType type) = AsmSourceTools.ParseMnemonic_Att(keyword, true); if (mnemonic != Mnemonic.NONE) { return((this.MnemonicSwitchedOn(mnemonic)) ? AsmSourceTools.IsJump(mnemonic) ? AsmTokenType.Jump : AsmTokenType.Mnemonic : AsmSourceTools.IsJump(mnemonic) ? AsmTokenType.Jump : AsmTokenType.MnemonicOff); } } #endregion return(this.type_.TryGetValue(keyword, out AsmTokenType tokenType) ? tokenType : AsmTokenType.UNKNOWN); }
public AsmTokenType Get_Token_Type(string keyword) { Mnemonic mnemonic = AsmSourceTools.ParseMnemonic(keyword); if (mnemonic != Mnemonic.UNKNOWN) { if (AsmSourceTools.IsJump(mnemonic)) { return(AsmTokenType.Jump); } return(AsmTokenType.Mnemonic); } if (this._type.TryGetValue(keyword.ToUpper(), out var tokenType)) { return(tokenType); } return(AsmTokenType.UNKNOWN); }
/// <summary>Perform one step forward and return states for both branches</summary> public static (State Regular, State Branch) Step_Forward(string line, State state) { try { string nextKey = Tools.CreateKey(state.Tools.Rand); string nextKeyBranch = nextKey + "!BRANCH"; var content = AsmSourceTools.ParseLine(line); using (var opcodeBase = Runner.InstantiateOpcode(content.Mnemonic, content.Args, (state.HeadKey, nextKey, nextKeyBranch), state.Tools)) { if (opcodeBase == null) { return(Regular : null, Branch : null); } if (opcodeBase.IsHalted) { return(Regular : null, Branch : null); } opcodeBase.Execute(); State stateRegular = null; if (opcodeBase.Updates.Regular != null) { stateRegular = new State(state); stateRegular.Update_Forward(opcodeBase.Updates.Regular); opcodeBase.Updates.Regular.Dispose(); } State stateBranch = null; if (opcodeBase.Updates.Branch != null) { stateBranch = new State(state); stateBranch.Update_Forward(opcodeBase.Updates.Branch); opcodeBase.Updates.Branch.Dispose(); } return(Regular : stateRegular, Branch : stateBranch); } } catch (Exception e) { Console.WriteLine("WARNING: Runner:Step_Forward: Exception at line: " + line + "; e=" + e.Message); return(null, null); } }
public AsmTokenType getTokenType(string keyword) { string keyword2 = keyword.ToUpper(); Mnemonic mnemonic = AsmSourceTools.parseMnemonic(keyword2); if (mnemonic != Mnemonic.UNKNOWN) { if (AsmSourceTools.isJump(mnemonic)) { return(AsmTokenType.Jump); } return(AsmTokenType.Mnemonic); } AsmTokenType tokenType; if (this._type.TryGetValue(keyword2, out tokenType)) { return(tokenType); } return(AsmTokenType.UNKNOWN); }
private Span Get_Keyword_Span_At_Point(SnapshotPoint triggerPoint) { ITextSnapshotLine line = triggerPoint.GetContainingLine(); //1] find the start of the current keyword SnapshotPoint start = triggerPoint; while ((start > line.Start) && !AsmSourceTools.IsSeparatorChar((start - 1).GetChar())) { start -= 1; } //2] find the end of the current keyword SnapshotPoint end = triggerPoint; while (((end + 1) < line.End) && !AsmSourceTools.IsSeparatorChar((end + 1).GetChar())) { end += 1; } //3] get the word under the mouse return(new SnapshotSpan(start, end + 1)); }
public void SetDescription(Mnemonic mnemonic, AsmDudeTools asmDudeTools) { string mnemonicStr = mnemonic.ToString(); this.Description.Inlines.Add(new Run("Mnemonic ") { FontWeight = FontWeights.Bold, Foreground = this._foreground }); this.Description.Inlines.Add(new Run(mnemonicStr) { FontWeight = FontWeights.Bold, Foreground = new SolidColorBrush(AsmDudeToolsStatic.ConvertColor((AsmSourceTools.IsJump(mnemonic) ? Settings.Default.SyntaxHighlighting_Jump : Settings.Default.SyntaxHighlighting_Opcode))) }); string archStr = ":" + ArchTools.ToString(asmDudeTools.Mnemonic_Store.GetArch(mnemonic)) + " "; string descr = asmDudeTools.Mnemonic_Store.GetDescription(mnemonic); string full_Descr = AsmSourceTools.Linewrap(archStr + descr, AsmDudePackage.maxNumberOfCharsInToolTips); this.Description.Inlines.Add(new Run(full_Descr) { Foreground = this._foreground }); }
public AsmTokenType Get_Token_Type_Intel(string keyword) { Debug.Assert(keyword == keyword.ToUpper()); Mnemonic mnemonic = AsmSourceTools.ParseMnemonic(keyword, true); if (mnemonic != Mnemonic.NONE) { return((this.MnemonicSwitchedOn(mnemonic)) ? AsmSourceTools.IsJump(mnemonic) ? AsmTokenType.Jump : AsmTokenType.Mnemonic : AsmSourceTools.IsJump(mnemonic) ? AsmTokenType.Jump : AsmTokenType.MnemonicOff); } Rn reg = RegisterTools.ParseRn(keyword, true); if (reg != Rn.NOREG) { return((this.RegisterSwitchedOn(reg)) ? AsmTokenType.Register : AsmTokenType.Register); //TODO } return(this._type.TryGetValue(keyword, out AsmTokenType tokenType) ? tokenType : AsmTokenType.UNKNOWN); }
public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList <ISignature> signatures) { //AsmDudeToolsStatic.Output_INFO("AsmSignatureHelpSource: AugmentSignatureHelpSession"); //if (true) return; if (!Settings.Default.SignatureHelp_On) { return; } try { DateTime time1 = DateTime.Now; ITextSnapshot snapshot = this._buffer.CurrentSnapshot; int position = session.GetTriggerPoint(this._buffer).GetPosition(snapshot); ITrackingSpan applicableToSpan = this._buffer.CurrentSnapshot.CreateTrackingSpan(new Span(position, 0), SpanTrackingMode.EdgeInclusive, 0); ITextSnapshotLine line = snapshot.GetLineFromPosition(position); string lineStr = line.GetText(); //AsmDudeToolsStatic.Output_INFO("AsmSignatureHelpSource: AugmentSignatureHelpSession: lineStr=" + lineStr+ "; positionInLine=" + positionInLine); var t = AsmSourceTools.ParseLine(lineStr); IList <Operand> operands = AsmSourceTools.MakeOperands(t.Args); Mnemonic mnemonic = t.Mnemonic; ISet <Arch> selectedArchitectures = AsmDudeToolsStatic.Get_Arch_Swithed_On(); //AsmDudeToolsStatic.Output_INFO("AsmSignatureHelpSource: AugmentSignatureHelpSession: selected architectures=" + ArchTools.ToString(selectedArchitectures)); foreach (AsmSignatureElement se in AsmSignatureHelpSource.Constrain_Signatures(this._store.GetSignatures(mnemonic), operands, selectedArchitectures)) { signatures.Add(Create_Signature(this._buffer, se, applicableToSpan)); } AsmDudeToolsStatic.Print_Speed_Warning(time1, "Signature Help"); } catch (Exception e) { AsmDudeToolsStatic.Output_ERROR(string.Format("{0}:AugmentSignatureHelpSession; e={1}", ToString(), e.ToString())); } }