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"); }
/// <summary> /// Search the given span for any instances of classified tags /// </summary> public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans) { if (Settings.Default.SyntaxHighlighting_On) { if (spans.Count == 0) { //there is no content in the buffer yield break; } DateTime time1 = DateTime.Now; ITextSnapshot snapshot = spans[0].Snapshot; foreach (IMappingTagSpan <AsmTokenTag> tagSpan in this.aggregator_.GetTags(spans)) { NormalizedSnapshotSpanCollection tagSpans = tagSpan.Span.GetSpans(snapshot); switch (tagSpan.Tag.Type) { case AsmTokenType.Mnemonic: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.mnemonic_)); break; case AsmTokenType.MnemonicOff: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.mnemonicOff_)); break; case AsmTokenType.Register: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.register_)); break; case AsmTokenType.Remark: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.remark_)); break; case AsmTokenType.Directive: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.directive_)); break; case AsmTokenType.Constant: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.constant_)); break; case AsmTokenType.Jump: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.jump_)); break; case AsmTokenType.Label: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.label_)); break; case AsmTokenType.LabelDef: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.labelDef_)); break; case AsmTokenType.Misc: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.misc_)); break; case AsmTokenType.UserDefined1: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.userDefined1_)); break; case AsmTokenType.UserDefined2: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.userDefined2_)); break; case AsmTokenType.UserDefined3: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this.userDefined3_)); break; default: break; } } AsmDudeToolsStatic.Print_Speed_Warning(time1, "Asm Classifier"); } }
/// <summary> /// Search the given span for any instances of classified tags /// </summary> public IEnumerable <ITagSpan <ClassificationTag> > GetTags(NormalizedSnapshotSpanCollection spans) { if (Settings.Default.SyntaxHighlighting_On) { if (spans.Count == 0) { //there is no content in the buffer yield break; } DateTime time1 = DateTime.Now; foreach (IMappingTagSpan <AsmTokenTag> tagSpan in this._aggregator.GetTags(spans)) { NormalizedSnapshotSpanCollection tagSpans = tagSpan.Span.GetSpans(spans[0].Snapshot); switch (tagSpan.Tag.Type) { case AsmTokenType.Mnemonic: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this._mnemonic)); break; case AsmTokenType.Register: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this._register)); break; case AsmTokenType.Remark: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this._remark)); break; case AsmTokenType.Directive: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this._directive)); break; case AsmTokenType.Constant: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this._constant)); break; case AsmTokenType.Jump: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this._jump)); break; case AsmTokenType.Label: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this._label)); break; case AsmTokenType.LabelDef: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this._labelDef)); break; case AsmTokenType.Misc: yield return(new TagSpan <ClassificationTag>(tagSpans[0], this._misc)); break; default: break; } } AsmDudeToolsStatic.Print_Speed_Warning(time1, "Asm Classifier"); } }
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(); var pos = new List <(int BeginPos, int Length, bool IsLabel)>(AsmSourceTools.SplitIntoKeywordPos(line)); int offset = containingLine.Start.Position; int nKeywords = pos.Count; // if the line does not contain a Mnemonic, assume it is a source code line and make it a remark #region Check source code line if (IsSourceCode(line, pos)) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span((0, line.Length, false), offset, curSpan), this._remark)); continue; // go to the next line } #endregion for (int k = 0; k < nKeywords; k++) { string asmToken = NasmIntelTokenTagger.Keyword(pos[k], line); // keyword k is a label definition if (pos[k].IsLabel) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef)); continue; } AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type_Att(asmToken); switch (keywordType) { case AsmTokenType.Jump: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._jump)); k++; // goto the next word if (k == nKeywords) { break; // there are no next words } string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line); switch (asmToken2) { case "WORD": case "DWORD": case "QWORD": case "SHORT": case "NEAR": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc)); k++; if (k == nKeywords) { break; } string asmToken3 = NasmIntelTokenTagger.Keyword(pos[k], line); switch (asmToken3) { case "PTR": { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._misc)); break; } yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._label)); break; } break; } default: { if (RegisterTools.IsRegister(asmToken2)) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._register)); } else { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._label)); } break; } } break; } case AsmTokenType.UNKNOWN: // asmToken is not a known keyword, check if it is numerical { //if (AsmTools.AsmSourceTools.Parse_Constant(asmToken, true).Valid) if (AsmSourceTools.Evaluate_Constant(asmToken, true).Valid) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant)); } else if (asmToken.StartsWith("\"") && asmToken.EndsWith("\"")) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant)); } else { //yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._UNKNOWN); } break; } case AsmTokenType.Directive: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive)); break; } case AsmTokenType.Mnemonic: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._mnemonic)); break; } case AsmTokenType.Register: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._register)); break; } default: break; } } } AsmDudeToolsStatic.Print_Speed_Warning(time1, "NasmAttDisassemblyTokenTagger"); }
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(); var pos = new List <(int BeginPos, int Length, bool IsLabel)>(AsmSourceTools.SplitIntoKeywordPos(line)); int offset = containingLine.Start.Position; int nKeywords = pos.Count; for (int k = 0; k < nKeywords; k++) { string asmToken = NasmIntelTokenTagger.Keyword(pos[k], line); // keyword starts with a remark char if (AsmSourceTools.IsRemarkChar(asmToken[0])) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._remark)); continue; } // keyword k is a label definition if (pos[k].IsLabel) { SnapshotSpan labelDefSpan = NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan); //AsmDudeToolsStatic.Output_INFO("MasmTokenTagger:GetTags: found label " + asmToken +" at line "+containingLine.LineNumber); if (asmToken.Equals("@@")) { // TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc. } else { var v = this.Make_AsmTokenTag_LabelDef(containingLine.LineNumber); yield return(new TagSpan <AsmTokenTag>(labelDefSpan, v)); } continue; } AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type_Intel(asmToken); switch (keywordType) { case AsmTokenType.Jump: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._jump)); k++; // goto the next word if (k == nKeywords) { break; } string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line); switch (asmToken2) { case "$": case "@B": case "@F": { // TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc. break; } case "WORD": case "DWORD": case "QWORD": case "SHORT": case "NEAR": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc)); k++; if (k == nKeywords) { break; } string asmToken3 = NasmIntelTokenTagger.Keyword(pos[k], line); switch (asmToken3) { case "$": case "@B": case "@F": { // TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc. break; } case "PTR": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._misc)); break; } default: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.Make_AsmTokenTag_Label(containingLine.LineNumber))); break; } } break; } default: { if (RegisterTools.IsRegister(asmToken2)) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._register)); } else { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.Make_AsmTokenTag_Label(containingLine.LineNumber))); } break; } } break; } case AsmTokenType.UNKNOWN: // asmToken is not a known keyword, check if it is numerical { if (AsmTools.AsmSourceTools.Evaluate_Constant(asmToken, true).Valid) //if (AsmTools.AsmSourceTools.Parse_Constant(asmToken, true).Valid) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant)); } else if (asmToken.StartsWith("\"") && asmToken.EndsWith("\"")) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant)); } else { bool isUnknown = true; // do one word lookahead; see whether we can understand the current unknown word if ((k + 1) < nKeywords) { k++; string nextKeyword = NasmIntelTokenTagger.Keyword(pos[k], line); switch (nextKeyword) { case "PROC": case "EQU": case "LABEL": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef)); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive)); isUnknown = false; break; } case "PROTO": { // a proto is considered a label definition but it should not clash with other label definitions yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k - 1], offset, curSpan), this._labelDef_PROTO)); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive)); isUnknown = false; break; } default: { k--; break; } } } // do one word look back; see whether we can understand the current unknown word if (k > 0) { string previousKeyword = NasmIntelTokenTagger.Keyword(pos[k - 1], line); switch (previousKeyword) { case "ALIAS": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef)); isUnknown = false; break; } case "INCLUDE": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._constant)); isUnknown = false; break; } default: { break; } } } if (isUnknown) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._UNKNOWN)); } } break; } case AsmTokenType.Directive: { AssemblerEnum assember = this._asmDudeTools.Get_Assembler(asmToken); if (assember.HasFlag(AssemblerEnum.MASM)) // this MASM token-tagger only tags MASM directives { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._directive)); switch (asmToken) { case "INVOKE": { k++; // goto the next word if (k == nKeywords) { break; } string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.Make_AsmTokenTag_Label(containingLine.LineNumber))); break; } case "EXTRN": case "EXTERN": { k++; // goto the next word if (k == nKeywords) { break; } string asmToken2 = NasmIntelTokenTagger.Keyword(pos[k], line); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._labelDef_PROTO)); break; } } } } break; default: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), new AsmTokenTag(keywordType))); break; } } } } AsmDudeToolsStatic.Print_Speed_Warning(time1, "MasmTokenTagger"); }
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(); List <(int BeginPos, int Length, bool IsLabel)> pos = new List <(int BeginPos, int Length, bool IsLabel)>(AsmSourceTools.SplitIntoKeywordPos(line)); int offset = containingLine.Start.Position; int nKeywords = pos.Count; for (int k = 0; k < nKeywords; k++) { string asmToken = AsmSourceTools.Keyword(pos[k], line); // keyword starts with a remark char if (AsmSourceTools.IsRemarkChar(asmToken[0])) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._remark)); continue; } // keyword k is a label definition if (pos[k].IsLabel) { //AsmDudeToolsStatic.Output_INFO("NasmTokenTagger:GetTags: found label " +asmToken); if (this.IsProperLabelDef(asmToken, containingLine.LineNumber, out AsmTokenTag asmTokenTag)) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), asmTokenTag)); continue; } } AsmTokenType keywordType = this._asmDudeTools.Get_Token_Type_Intel(asmToken); switch (keywordType) { case AsmTokenType.Jump: { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._jump)); k++; // goto the next word if (k == nKeywords) { break; // there are no next words } string asmToken2 = AsmSourceTools.Keyword(pos[k], line); switch (asmToken2) { case "WORD": case "DWORD": case "QWORD": case "SHORT": case "NEAR": { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._misc)); k++; if (k == nKeywords) { break; } string asmToken3 = AsmSourceTools.Keyword(pos[k], line); if (asmToken3.Equals("PTR")) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._misc)); } else { if (this.IsProperLabel(asmToken3, containingLine.LineNumber, out AsmTokenTag asmTokenTag)) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), asmTokenTag)); } } break; } default: { if (RegisterTools.IsRegister(asmToken2, true)) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._register)); } else { if (this.IsProperLabel(asmToken2, containingLine.LineNumber, out AsmTokenTag asmTokenTag)) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), asmTokenTag)); } } break; } } break; } case AsmTokenType.UNKNOWN: // asmToken is not a known keyword, check if it is numerical { if (AsmSourceTools.Evaluate_Constant(asmToken, true).Valid) //if (AsmSourceTools.Parse_Constant(asmToken, true).Valid) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._constant)); } else if (asmToken.StartsWith("\"") && asmToken.EndsWith("\"")) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._constant)); } else { bool isUnknown = true; // do one word lookahead; see whether we can understand the current unknown word if ((k + 1) < nKeywords) { k++; string nextKeyword = AsmSourceTools.Keyword(pos[k], line); switch (nextKeyword) { case "LABEL": { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k - 1], offset, curSpan), this._labelDef)); yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._directive)); isUnknown = false; break; } default: { k--; break; } } } // do one word look back; see whether we can understand the current unknown word if (k > 0) { string previousKeyword = AsmSourceTools.Keyword(pos[k - 1], line); switch (previousKeyword) { case "ALIAS": { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._labelDef)); isUnknown = false; break; } case "INCLUDE": { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._constant)); isUnknown = false; break; } default: { break; } } } if (isUnknown) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._UNKNOWN)); } } break; } case AsmTokenType.Directive: { AssemblerEnum assember = this._asmDudeTools.Get_Assembler(asmToken); if (assember.HasFlag(AssemblerEnum.NASM_INTEL) || assember.HasFlag(AssemblerEnum.NASM_ATT)) { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._directive)); } break; } case AsmTokenType.Mnemonic: { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._mnemonic)); break; } case AsmTokenType.Register: { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this._register)); break; } default: { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), new AsmTokenTag(keywordType))); break; } } } } AsmDudeToolsStatic.Print_Speed_Warning(time1, "NasmIntelTokenTagger"); }
public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets) { Contract.Requires(session != null); Contract.Requires(completionSets != null); try { //AsmDudeToolsStatic.Output_INFO(string.Format(AsmDudeToolsStatic.CultureUI, "{0}:AugmentCompletionSession", this.ToString())); if (!Settings.Default.CodeCompletion_On) { return; } DateTime time1 = DateTime.Now; ITextSnapshot snapshot = this.buffer_.CurrentSnapshot; SnapshotPoint triggerPoint = (SnapshotPoint)session.GetTriggerPoint(snapshot); if (triggerPoint == null) { return; } ITextSnapshotLine line = triggerPoint.GetContainingLine(); //1] check if current position is in a remark; if we are in a remark, no code completion #region if (triggerPoint.Position > 1) { char currentTypedChar = (triggerPoint - 1).GetChar(); //AsmDudeToolsStatic.Output_INFO("CodeCompletionSource:AugmentCompletionSession: current char = "+ currentTypedChar); if (!currentTypedChar.Equals('#')) { //TODO UGLY since the user can configure this starting character int pos = triggerPoint.Position - line.Start; if (AsmSourceTools.IsInRemark(pos, line.GetText())) { //AsmDudeToolsStatic.Output_INFO("CodeCompletionSource:AugmentCompletionSession: currently in a remark section"); return; } else { // AsmDudeToolsStatic.Output_INFO("CodeCompletionSource:AugmentCompletionSession: not in a remark section"); } } } #endregion //2] find the start of the current keyword #region SnapshotPoint start = triggerPoint; while ((start > line.Start) && !AsmSourceTools.IsSeparatorChar((start - 1).GetChar())) { start -= 1; } #endregion //3] get the word that is currently being typed #region ITrackingSpan applicableTo = snapshot.CreateTrackingSpan(new SnapshotSpan(start, triggerPoint), SpanTrackingMode.EdgeInclusive); string partialKeyword = applicableTo.GetText(snapshot); bool useCapitals = AsmDudeToolsStatic.Is_All_upcase(partialKeyword); string lineStr = line.GetText(); (string label, Mnemonic mnemonic, string[] args, string remark)t = AsmSourceTools.ParseLine(lineStr); Mnemonic mnemonic = t.mnemonic; string previousKeyword_upcase = AsmDudeToolsStatic.Get_Previous_Keyword(line.Start, start).ToUpperInvariant(); //AsmDudeToolsStatic.Output_INFO(string.Format(AsmDudeToolsStatic.CultureUI, "{0}:AugmentCompletionSession. lineStr=\"{1}\"; previousKeyword=\"{2}\"", this.ToString(), lineStr, previousKeyword)); if (mnemonic == Mnemonic.NONE) { if (previousKeyword_upcase.Equals("INVOKE", StringComparison.Ordinal)) //TODO INVOKE is a MASM keyword not a NASM one... { // Suggest a label IEnumerable <Completion> completions = this.Label_Completions(useCapitals, false); if (completions.Any()) { completionSets.Add(new CompletionSet("Labels", "Labels", applicableTo, completions, Enumerable.Empty <Completion>())); } } else { { ISet <AsmTokenType> selected1 = new HashSet <AsmTokenType> { AsmTokenType.Directive, AsmTokenType.Jump, AsmTokenType.Misc, AsmTokenType.Mnemonic }; IEnumerable <Completion> completions1 = this.Selected_Completions(useCapitals, selected1, true); if (completions1.Any()) { completionSets.Add(new CompletionSet("All", "All", applicableTo, completions1, Enumerable.Empty <Completion>())); } } if (false) { ISet <AsmTokenType> selected2 = new HashSet <AsmTokenType> { AsmTokenType.Jump, AsmTokenType.Mnemonic }; IEnumerable <Completion> completions2 = this.Selected_Completions(useCapitals, selected2, false); if (completions2.Any()) { completionSets.Add(new CompletionSet("Instr", "Instr", applicableTo, completions2, Enumerable.Empty <Completion>())); } } if (false) { ISet <AsmTokenType> selected3 = new HashSet <AsmTokenType> { AsmTokenType.Directive, AsmTokenType.Misc }; IEnumerable <Completion> completions3 = this.Selected_Completions(useCapitals, selected3, true); if (completions3.Any()) { completionSets.Add(new CompletionSet("Directive", "Directive", applicableTo, completions3, Enumerable.Empty <Completion>())); } } } } else { // the current line contains a mnemonic //AsmDudeToolsStatic.Output_INFO("CodeCompletionSource:AugmentCompletionSession; mnemonic=" + mnemonic+ "; previousKeyword="+ previousKeyword); if (AsmSourceTools.IsJump(AsmSourceTools.ParseMnemonic(previousKeyword_upcase, true))) { //AsmDudeToolsStatic.Output_INFO("CodeCompletionSource:AugmentCompletionSession; previous keyword is a jump mnemonic"); // previous keyword is jump (or call) mnemonic. Suggest "SHORT" or a label IEnumerable <Completion> completions = this.Label_Completions(useCapitals, true); if (completions.Any()) { completionSets.Add(new CompletionSet("Labels", "Labels", applicableTo, completions, Enumerable.Empty <Completion>())); } } else if (previousKeyword_upcase.Equals("SHORT", StringComparison.Ordinal) || previousKeyword_upcase.Equals("NEAR", StringComparison.Ordinal)) { // Suggest a label IEnumerable <Completion> completions = this.Label_Completions(useCapitals, false); if (completions.Any()) { completionSets.Add(new CompletionSet("Labels", "Labels", applicableTo, completions, Enumerable.Empty <Completion>())); } } else { IList <Operand> operands = AsmSourceTools.MakeOperands(t.args); ISet <AsmSignatureEnum> allowed = new HashSet <AsmSignatureEnum>(); int commaCount = AsmSignature.Count_Commas(lineStr); IEnumerable <AsmSignatureElement> allSignatures = this.asmDudeTools_.Mnemonic_Store.GetSignatures(mnemonic); ISet <Arch> selectedArchitectures = AsmDudeToolsStatic.Get_Arch_Swithed_On(); foreach (AsmSignatureElement se in AsmSignatureHelpSource.Constrain_Signatures(allSignatures, operands, selectedArchitectures)) { if (commaCount < se.Operands.Count) { foreach (AsmSignatureEnum s in se.Operands[commaCount]) { allowed.Add(s); } } } IEnumerable <Completion> completions = this.Mnemonic_Operand_Completions(useCapitals, allowed, line.LineNumber); if (completions.Any()) { completionSets.Add(new CompletionSet("All", "All", applicableTo, completions, Enumerable.Empty <Completion>())); } } } #endregion AsmDudeToolsStatic.Print_Speed_Warning(time1, "Code Completion"); } catch (Exception e) { AsmDudeToolsStatic.Output_ERROR(string.Format(AsmDudeToolsStatic.CultureUI, "{0}:AugmentCompletionSession; e={1}", this.ToString(), e.ToString())); } }
public IEnumerable <ITagSpan <AsmTokenTag> > GetTags_NEW(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_upcase = containingLine.GetText().ToUpper(CultureInfo.InvariantCulture); int offset = containingLine.Start.Position; IEnumerator <(int beginPos, int length, bool isLabel)> enumerator = AsmSourceTools.SplitIntoKeywordPos(line_upcase).GetEnumerator(); bool needToAdvance = false; bool hasNext = enumerator.MoveNext(); if (!hasNext) { break; } (int beginPos, int length, bool isLabel)prev = (0, 0, false); (int beginPos, int length, bool isLabel)current = enumerator.Current; while (hasNext) { string asmToken = AsmSourceTools.Keyword(current, line_upcase); // keyword starts with a remark char if (AsmSourceTools.IsRemarkChar(asmToken[0])) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.remark_)); continue; } // keyword k is a label definition if (current.isLabel) { SnapshotSpan labelDefSpan = NasmIntelTokenTagger.New_Span(current, offset, curSpan); //AsmDudeToolsStatic.Output_INFO("MasmTokenTagger:GetTags: found label " + asmToken +" at line "+containingLine.LineNumber); if (asmToken.Equals("@@", StringComparison.Ordinal)) { // TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc. } else { yield return(new TagSpan <AsmTokenTag>(labelDefSpan, this.Make_AsmTokenTag_LabelDef(containingLine.LineNumber))); } continue; } AsmTokenType keywordType = this.asmDudeTools_.Get_Token_Type_Intel(asmToken); switch (keywordType) { case AsmTokenType.Jump: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.jump_)); { // go to the next word if (needToAdvance) { hasNext = enumerator.MoveNext(); prev = current; current = enumerator.Current; } needToAdvance = true; } string asmToken2 = AsmSourceTools.Keyword(current, line_upcase); switch (asmToken2) { case "$": case "@B": case "@F": { // TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc. break; } case "WORD": case "DWORD": case "QWORD": case "SHORT": case "NEAR": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.misc_)); { // go to the next word if (needToAdvance) { hasNext = enumerator.MoveNext(); prev = current; current = enumerator.Current; } needToAdvance = true; } switch (AsmSourceTools.Keyword(current, line_upcase)) { case "$": case "@B": case "@F": { // TODO: special MASM label, for the moment, ignore it, later: check whether it is used etc. break; } case "PTR": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.misc_)); break; } default: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.Make_AsmTokenTag_Label(containingLine.LineNumber))); break; } } break; } default: { if (RegisterTools.IsRegister(asmToken2)) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.register_)); } else { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.Make_AsmTokenTag_Label(containingLine.LineNumber))); } break; } } break; } case AsmTokenType.UNKNOWN: // asmToken is not a known keyword, check if it is numerical { //if (AsmTools.AsmSourceTools.Evaluate_Constant(asmToken, true).valid) if (AsmSourceTools.Parse_Constant(asmToken, true).valid) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.constant_)); } else if (asmToken.StartsWith("\"", StringComparison.Ordinal) && asmToken.EndsWith("\"", StringComparison.Ordinal)) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.constant_)); } else { // do one word look back; see whether we can understand the current unknown word string previousKeyword = AsmSourceTools.Keyword(prev, line_upcase); switch (previousKeyword) { case "ALIAS": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.labelDef_)); break; } default: { break; } } // do one word lookahead; see whether we can understand the current unknown word // go to the next word needToAdvance = false; if (enumerator.MoveNext()) { prev = current; current = enumerator.Current; string nextKeyword = AsmSourceTools.Keyword(current, line_upcase); switch (nextKeyword) { case "PROC": case "EQU": case "LABEL": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(prev, offset, curSpan), this.labelDef_)); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.directive_)); break; } case "PROTO": { // a proto is considered a label definition but it should not clash with other label definitions yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(prev, offset, curSpan), this.labelDef_PROTO_)); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.directive_)); break; } default: break; } } else { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.UNKNOWN_)); } } break; } case AsmTokenType.Directive: { AssemblerEnum assember = this.asmDudeTools_.Get_Assembler(asmToken); if (assember.HasFlag(AssemblerEnum.MASM)) // this MASM token-tagger only tags MASM directives { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.directive_)); if (asmToken.Equals("INVOKE", StringComparison.Ordinal)) { { // go to the next word if (needToAdvance) { hasNext = enumerator.MoveNext(); prev = current; current = enumerator.Current; } needToAdvance = true; } //string asmToken2 = NasmTokenTagger.Keyword(current, line); yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), this.Make_AsmTokenTag_Label(containingLine.LineNumber))); } } break; } default: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(current, offset, curSpan), new AsmTokenTag(keywordType))); break; } } { // go to the next word if (needToAdvance) { hasNext = enumerator.MoveNext(); prev = current; current = enumerator.Current; } needToAdvance = true; } } } AsmDudeToolsStatic.Print_Speed_Warning(time1, "MasmTokenTagger"); }
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_upcase = containingLine.GetText().ToUpperInvariant(); List <(int beginPos, int length, bool isLabel)> pos = new List <(int beginPos, int length, bool isLabel)>(AsmSourceTools.SplitIntoKeywordPos(line_upcase)); int offset = containingLine.Start.Position; int nKeywords = pos.Count; #region Check if the current line is a line of source code if (IsSourceCode(line_upcase, pos)) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span((0, line_upcase.Length, false), offset, curSpan), this.remark_)); continue; // go to the next line } #endregion for (int k = 0; k < nKeywords; k++) { string asmToken = AsmSourceTools.Keyword(pos[k], line_upcase); // keyword starts with a remark char if (AsmSourceTools.IsRemarkChar(asmToken[0])) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.remark_)); continue; } // keyword k is a label definition if (pos[k].isLabel) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.labelDef_)); continue; } AsmTokenType keywordType = this.asmDudeTools_.Get_Token_Type_Att(asmToken); switch (keywordType) { case AsmTokenType.Jump: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.jump_)); k++; // goto the next word if (k == nKeywords) { break; // there are no next words } string asmToken2 = AsmSourceTools.Keyword(pos[k], line_upcase); switch (asmToken2) { case "WORD": case "DWORD": case "QWORD": case "SHORT": case "NEAR": { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.misc_)); k++; if (k == nKeywords) { break; } string asmToken3 = AsmSourceTools.Keyword(pos[k], line_upcase); switch (asmToken3) { case "PTR": { yield return(new TagSpan <AsmTokenTag>(New_Span(pos[k], offset, curSpan), this.misc_)); break; } yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.label_)); break; } break; } default: { if (RegisterTools.IsRegister(asmToken2)) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.register_)); } else if (AsmSourceTools.Evaluate_Constant(asmToken2, true).valid) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.constant_)); } else { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.label_)); } break; } } break; } case AsmTokenType.UNKNOWN: // asmToken is not a known keyword, check if it is numerical { if (AsmSourceTools.Evaluate_Constant(asmToken, true).valid) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.constant_)); } else if (asmToken.StartsWith("$", StringComparison.Ordinal)) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.constant_)); } else if (asmToken.StartsWith("\"", StringComparison.Ordinal) && asmToken.EndsWith("\"", StringComparison.Ordinal)) { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.constant_)); } else { //yield return new TagSpan<AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this._UNKNOWN); } break; } case AsmTokenType.Directive: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.directive_)); break; } case AsmTokenType.Mnemonic: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.mnemonic_)); break; } case AsmTokenType.Register: { yield return(new TagSpan <AsmTokenTag>(NasmIntelTokenTagger.New_Span(pos[k], offset, curSpan), this.register_)); break; } default: break; } } } AsmDudeToolsStatic.Print_Speed_Warning(time1, "NasmAttDisassemblyTokenTagger"); }
public void AugmentCompletionSession(ICompletionSession session, IList <CompletionSet> completionSets) { //AsmDudeToolsStatic.Output(string.Format("INFO: {0}:AugmentCompletionSession", this.ToString())); if (this._disposed) { return; } if (!Settings.Default.CodeCompletion_On) { return; } try { DateTime time1 = DateTime.Now; ITextSnapshot snapshot = this._buffer.CurrentSnapshot; SnapshotPoint triggerPoint = (SnapshotPoint)session.GetTriggerPoint(snapshot); if (triggerPoint == null) { return; } ITextSnapshotLine line = triggerPoint.GetContainingLine(); //1] check if current position is in a remark; if we are in a remark, no code completion #region if (triggerPoint.Position > 1) { char currentTypedChar = (triggerPoint - 1).GetChar(); //AsmDudeToolsStatic.Output("INFO: CodeCompletionSource:AugmentCompletionSession: current char = "+ currentTypedChar); if (!currentTypedChar.Equals('#')) { //TODO UGLY since the user can configure this starting character int pos = triggerPoint.Position - line.Start; if (AsmSourceTools.IsInRemark(pos, line.GetText())) { //AsmDudeToolsStatic.Output("INFO: CodeCompletionSource:AugmentCompletionSession: currently in a remark section"); return; } else { // AsmDudeToolsStatic.Output("INFO: CodeCompletionSource:AugmentCompletionSession: not in a remark section"); } } } #endregion //2] find the start of the current keyword #region SnapshotPoint start = triggerPoint; while ((start > line.Start) && !AsmTools.AsmSourceTools.IsSeparatorChar((start - 1).GetChar())) { start -= 1; } #endregion //3] get the word that is currently being typed #region ITrackingSpan applicableTo = snapshot.CreateTrackingSpan(new SnapshotSpan(start, triggerPoint), SpanTrackingMode.EdgeInclusive); string partialKeyword = applicableTo.GetText(snapshot); bool useCapitals = AsmDudeToolsStatic.Is_All_Upper(partialKeyword); SortedSet <Completion> completions = null; string lineStr = line.GetText(); var t = AsmSourceTools.ParseLine(lineStr); Mnemonic mnemonic = t.Item2; //AsmDudeToolsStatic.Output_INFO("CodeCompletionSource:AugmentCompletionSession; lineStr="+ lineStr+ "; t.Item1="+t.Item1); string previousKeyword = AsmDudeToolsStatic.Get_Previous_Keyword(line.Start, start).ToUpper(); if (mnemonic == Mnemonic.UNKNOWN) { //AsmDudeToolsStatic.Output_INFO("CodeCompletionSource:AugmentCompletionSession; lineStr=" + lineStr + "; previousKeyword=" + previousKeyword); if (previousKeyword.Equals("INVOKE")) //TODO INVOKE is a MASM keyword not a NASM one... { // Suggest a label completions = Label_Completions(); } else { ISet <AsmTokenType> selected = new HashSet <AsmTokenType> { AsmTokenType.Directive, AsmTokenType.Jump, AsmTokenType.Misc, AsmTokenType.Mnemonic }; completions = Selected_Completions(useCapitals, selected); } } else { // the current line contains a mnemonic //AsmDudeToolsStatic.Output("INFO: CodeCompletionSource:AugmentCompletionSession; mnemonic=" + mnemonic+ "; previousKeyword="+ previousKeyword); if (AsmSourceTools.IsJump(AsmSourceTools.ParseMnemonic(previousKeyword))) { //AsmDudeToolsStatic.Output("INFO: CodeCompletionSource:AugmentCompletionSession; previous keyword is a jump mnemonic"); // previous keyword is jump (or call) mnemonic. Suggest "SHORT" or a label completions = Label_Completions(); completions.Add(new Completion("SHORT", (useCapitals) ? "SHORT" : "short", null, this._icons[AsmTokenType.Misc], "")); completions.Add(new Completion("NEAR", (useCapitals) ? "NEAR" : "near", null, this._icons[AsmTokenType.Misc], "")); } else if (previousKeyword.Equals("SHORT") || previousKeyword.Equals("NEAR")) { // Suggest a label completions = Label_Completions(); } else { IList <Operand> operands = AsmSourceTools.MakeOperands(t.Item3); ISet <AsmSignatureEnum> allowed = new HashSet <AsmSignatureEnum>(); int commaCount = AsmSignature.Count_Commas(lineStr); IList <AsmSignatureElement> allSignatures = this._asmDudeTools.Mnemonic_Store.GetSignatures(mnemonic); ISet <Arch> selectedArchitectures = AsmDudeToolsStatic.Get_Arch_Swithed_On(); foreach (AsmSignatureElement se in AsmSignatureHelpSource.Constrain_Signatures(allSignatures, operands, selectedArchitectures)) { if (commaCount < se.Operands.Count) { foreach (AsmSignatureEnum s in se.Operands[commaCount]) { allowed.Add(s); } } } completions = Mnemonic_Operand_Completions(useCapitals, allowed); } } //AsmDudeToolsStatic.Output("INFO: CodeCompletionSource:AugmentCompletionSession; nCompletions=" + completions.Count); #endregion completionSets.Add(new CompletionSet("Tokens", "Tokens", applicableTo, completions, Enumerable.Empty <Completion>())); AsmDudeToolsStatic.Print_Speed_Warning(time1, "Code Completion"); } catch (Exception e) { AsmDudeToolsStatic.Output_ERROR(string.Format("{0}:AugmentCompletionSession; e={1}", ToString(), e.ToString())); } }