First commit

This commit is contained in:
Olivier Guinart 2016-12-30 16:46:52 -08:00
commit d821e25fdb
28 changed files with 3985 additions and 0 deletions

View File

@ -0,0 +1,84 @@
using System.ComponentModel.Composition;
using System.Windows.Media;
using Microsoft.VisualStudio.Text.Classification;
using Microsoft.VisualStudio.Utilities;
//using Microsoft.VisualStudio.Language.StandardClassification;
namespace VSMerlin32.Coloring.Classification
{
#region Format definition
[Export(typeof(EditorFormatDefinition))]
[ClassificationType(ClassificationTypeNames = Merlin32TokenHelper.Merlin32Comment)]
[Name("Merlin32CommentFormat")]
[UserVisible(false)]
[Order(Before = Priority.Default)]
internal sealed class CommentFormat : ClassificationFormatDefinition
{
public CommentFormat()
{
this.DisplayName = "This is a comment"; //human readable version of the name
this.ForegroundColor = Colors.Green;
}
}
[Export(typeof(EditorFormatDefinition))]
[ClassificationType(ClassificationTypeNames = Merlin32TokenHelper.Merlin32Opcode)]
[Name("Merlin32OpcodeFormat")]
[UserVisible(false)]
[Order(Before = Priority.Default)]
internal sealed class OpcodeFormat : ClassificationFormatDefinition
{
public OpcodeFormat()
{
this.DisplayName = "This is an opcode"; //human readable version of the name
this.ForegroundColor = Colors.Blue;
// this.IsBold = true;
}
}
[Export(typeof(EditorFormatDefinition))]
[ClassificationType(ClassificationTypeNames = Merlin32TokenHelper.Merlin32Directive)]
[Name("Merlin32DirectiveFormat")]
[UserVisible(false)]
[Order(Before = Priority.Default)]
internal sealed class DirectiveFormat : ClassificationFormatDefinition
{
public DirectiveFormat()
{
this.DisplayName = "This is an directive"; //human readable version of the name
this.ForegroundColor = Colors.DarkCyan;
// this.IsBold = true;
}
}
[Export(typeof(EditorFormatDefinition))]
[ClassificationType(ClassificationTypeNames = Merlin32TokenHelper.Merlin32DataDefine)]
[Name("Merlin32DataDefineFormat")]
[UserVisible(false)]
[Order(Before = Priority.Default)]
internal sealed class DataDefineFormat : ClassificationFormatDefinition
{
public DataDefineFormat()
{
this.DisplayName = "This is data definition"; //human readable version of the name
this.ForegroundColor = Colors.DarkOrchid;
// this.IsBold = true;
}
}
[Export(typeof(EditorFormatDefinition))]
[ClassificationType(ClassificationTypeNames = Merlin32TokenHelper.Merlin32Text)]
[Name("Merlin32TextFormat")]
[UserVisible(false)]
[Order(Before = Priority.Default)]
internal sealed class TextFormat : ClassificationFormatDefinition
{
public TextFormat()
{
this.DisplayName = "This is a text"; //human readable version of the name
this.ForegroundColor = Colors.DarkRed;
}
}
#endregion //Format definition
}

View File

@ -0,0 +1,48 @@
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Text.Classification;
using Microsoft.VisualStudio.Utilities;
namespace VSMerlin32.Coloring.Classification
{
internal static class OrdinaryClassificationDefinition
{
#region Type definition
/// <summary>
/// Defines the "opcode" classification type.
/// </summary>
[Export(typeof(ClassificationTypeDefinition))]
[Name(Merlin32TokenHelper.Merlin32Opcode)]
internal static ClassificationTypeDefinition opcode = null;
/// <summary>
/// Defines the "directive" classification type.
/// </summary>
[Export(typeof(ClassificationTypeDefinition))]
[Name(Merlin32TokenHelper.Merlin32Directive)]
internal static ClassificationTypeDefinition directive = null;
/// <summary>
/// Defines the "datadefine" classification type.
/// </summary>
[Export(typeof(ClassificationTypeDefinition))]
[Name(Merlin32TokenHelper.Merlin32DataDefine)]
internal static ClassificationTypeDefinition datadefine = null;
/// <summary>
/// Defines the "text" classification type.
/// </summary>
[Export(typeof(ClassificationTypeDefinition))]
[Name(Merlin32TokenHelper.Merlin32Text)]
internal static ClassificationTypeDefinition text = null;
/// <summary>
/// Defines the "comment" classification type.
/// </summary>
[Export(typeof(ClassificationTypeDefinition))]
[Name(Merlin32TokenHelper.Merlin32Comment)]
internal static ClassificationTypeDefinition comment = null;
#endregion
}
}

View File

@ -0,0 +1,79 @@
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Classification;
using Microsoft.VisualStudio.Text.Tagging;
using Microsoft.VisualStudio.Utilities;
namespace VSMerlin32.Coloring.Classification
{
[Export(typeof(ITaggerProvider))]
[ContentType("Merlin32")]
[TagType(typeof(ClassificationTag))]
internal sealed class Merlin32ClassifierProvider : ITaggerProvider
{
[Export]
[Name("Merlin32")]
[BaseDefinition("code")]
internal static ContentTypeDefinition Merlin32ContentType = null;
[Export]
[FileExtension(".s")]
[ContentType("Merlin32")]
internal static FileExtensionToContentTypeDefinition Merlin32FileType = null;
[Import]
internal IClassificationTypeRegistryService ClassificationTypeRegistry = null;
[Import]
internal IBufferTagAggregatorFactoryService aggregatorFactory = null;
public ITagger<T> CreateTagger<T>(ITextBuffer buffer) where T : ITag
{
ITagAggregator<Merlin32TokenTag> Merlin32TagAggregator =
aggregatorFactory.CreateTagAggregator<Merlin32TokenTag>(buffer);
return new Merlin32Classifier(buffer, Merlin32TagAggregator, ClassificationTypeRegistry) as ITagger<T>;
}
}
internal sealed class Merlin32Classifier : ITagger<ClassificationTag>
{
ITextBuffer _buffer;
ITagAggregator<Merlin32TokenTag> _aggregator;
IDictionary<Merlin32TokenTypes, IClassificationType> _Merlin32Types;
internal Merlin32Classifier(ITextBuffer buffer,
ITagAggregator<Merlin32TokenTag> Merlin32TagAggregator,
IClassificationTypeRegistryService typeService)
{
_buffer = buffer;
_aggregator = Merlin32TagAggregator;
_Merlin32Types = new Dictionary<Merlin32TokenTypes, IClassificationType>();
foreach (Merlin32TokenTypes token in Enum.GetValues(typeof(Merlin32TokenTypes)))
_Merlin32Types[token] = typeService.GetClassificationType(token.ToString());
}
public event EventHandler<SnapshotSpanEventArgs> TagsChanged
{
add { }
remove { }
}
public IEnumerable<ITagSpan<ClassificationTag>> GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (var tagSpan in this._aggregator.GetTags(spans))
{
var tagSpans = tagSpan.Span.GetSpans(spans[0].Snapshot);
yield return
new TagSpan<ClassificationTag>(tagSpans[0],
new ClassificationTag(_Merlin32Types[tagSpan.Tag.Tokentype]));
}
}
}
}

View File

@ -0,0 +1,16 @@
using Microsoft.VisualStudio.Text;
namespace VSMerlin32.Coloring.Data
{
internal class SnapshotHelper
{
public SnapshotSpan Snapshot { get; private set; }
public Merlin32TokenTypes TokenType { get; private set; }
public SnapshotHelper(SnapshotSpan span, Merlin32TokenTypes type)
{
Snapshot = span;
TokenType = type;
}
}
}

View File

@ -0,0 +1,130 @@
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using Microsoft.VisualStudio.Text;
using VSMerlin32.Coloring.Data;
namespace VSMerlin32.Coloring
{
internal class Merlin32CodeHelper
{
const string COMMENT_REG = @"((\u003B)|(\u002A))(.*)"; // ;
//const string KEYLINE_REG = @"\u0023([\w]*)"; // #
//const string HEAD_REG = @"^(\w)+(.*)\u003a\u002d"; // :-
const string TEXT_REG = @"(""|')[^']*(""|')";
//const string PUBLIC_REG = @"^\u003a\u002d+(.)*";
// const string OPCODE_REG = @"(org)|(ldy)";
// OPCODE_REG is initialized dynamically below.
static string OPCODE_REG = "";
//const string TEXT2_REG = @"\$[^']*\$";
static string DIRECTIVE_REG = "";
static string DATADEFINE_REG = "";
public static IEnumerable<SnapshotHelper> GetTokens(SnapshotSpan span)
{
string strTempRegex; // temp var string
ITextSnapshotLine containingLine = span.Start.GetContainingLine();
int curLoc = containingLine.Start.Position;
string formattedLine = containingLine.GetText();
int commentMatch = int.MaxValue;
Regex reg = new Regex(COMMENT_REG);
foreach (Match match in reg.Matches(formattedLine))
{
commentMatch = match.Index < commentMatch ? match.Index : commentMatch;
yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Comment);
}
/*
reg = new Regex(KEYLINE_REG);
foreach (Match match in reg.Matches(formattedLine))
{
if (match.Index < commentMatch)
yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Keyline);
}
reg = new Regex(HEAD_REG);
foreach (Match match in reg.Matches(formattedLine))
{
if (match.Index < commentMatch)
{
int length = formattedLine.IndexOf("(");
yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), length != -1 ? length : match.Length), Merlin32TokenTypes.Merlin32Keyline);
}
}
*/
reg = new Regex(TEXT_REG);
foreach (Match match in reg.Matches(formattedLine))
{
if (match.Index < commentMatch)
yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Text);
}
// OG NEW
// OPCODES
strTempRegex = "";
foreach (Merlin32Opcodes token in Enum.GetValues(typeof(Merlin32Opcodes)))
{
strTempRegex += (token.ToString() + ("|"));
}
// we remove the last "|" added
strTempRegex = strTempRegex.Remove(strTempRegex.LastIndexOf("|"));
OPCODE_REG = string.Format(@"\b({0})\b", strTempRegex);
reg = new Regex(OPCODE_REG,RegexOptions.IgnoreCase);
foreach (Match match in reg.Matches(formattedLine))
{
if (match.Index < commentMatch)
yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Opcode);
}
// OG NEW
// DIRECTIVES
strTempRegex = "";
foreach (Merlin32Directives token in Enum.GetValues(typeof(Merlin32Directives)))
{
if (token.ToString() != Resources.directives.ELUP)
strTempRegex += (token.ToString() + ("|"));
}
// we remove the last "|" added
// strTempRegex = strTempRegex.Remove(strTempRegex.LastIndexOf("|"));
// DIRECTIVE_REG = string.Format(@"\b({0})\b", strTempRegex);
DIRECTIVE_REG = string.Format(@"\b({0})\b|{1}", strTempRegex, Resources.directives.ELUPRegex);
reg = new Regex(DIRECTIVE_REG, RegexOptions.IgnoreCase);
foreach (Match match in reg.Matches(formattedLine))
{
if (match.Index < commentMatch)
yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Directive);
}
// OG NEW
// DATADEFINES
strTempRegex = "";
foreach (Merlin32DataDefines token in Enum.GetValues(typeof(Merlin32DataDefines)))
{
strTempRegex += (token.ToString() + ("|"));
}
// we remove the last "|" added
strTempRegex = strTempRegex.Remove(strTempRegex.LastIndexOf("|"));
DATADEFINE_REG = string.Format(@"\b({0})\b", strTempRegex);
reg = new Regex(DATADEFINE_REG, RegexOptions.IgnoreCase);
foreach (Match match in reg.Matches(formattedLine))
{
if (match.Index < commentMatch)
yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32DataDefine);
}
/*
reg = new Regex(PUBLIC_REG);
foreach (Match match in reg.Matches(formattedLine))
{
if (match.Index < commentMatch)
yield return new SnapshotHelper(new SnapshotSpan(new SnapshotPoint(span.Snapshot, match.Index + curLoc), match.Length), Merlin32TokenTypes.Merlin32Publictoken);
}
*/
}
}
}

View File

@ -0,0 +1,79 @@
// Copyright (c) Microsoft Corporation
// All rights reserved
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Tagging;
using Microsoft.VisualStudio.Utilities;
using VSMerlin32.Coloring.Data;
namespace VSMerlin32.Coloring
{
[Export(typeof(ITaggerProvider))]
[ContentType("Merlin32")]
[TagType(typeof(Merlin32TokenTag))]
internal sealed class Merlin32TokenTagProvider : ITaggerProvider
{
public ITagger<T> CreateTagger<T>(ITextBuffer buffer) where T : ITag
{
return new Merlin32TokenTagger(buffer) as ITagger<T>;
}
}
public class Merlin32TokenTag : ITag
{
public Merlin32TokenTypes Tokentype { get; private set; }
public Merlin32TokenTag(Merlin32TokenTypes type)
{
this.Tokentype = type;
}
}
internal sealed class Merlin32TokenTagger : ITagger<Merlin32TokenTag>
{
ITextBuffer _buffer;
IDictionary<string, Merlin32TokenTypes> _Merlin32Types;
internal Merlin32TokenTagger(ITextBuffer buffer)
{
_buffer = buffer;
_Merlin32Types = new Dictionary<string, Merlin32TokenTypes>();
foreach (Merlin32TokenTypes token in Enum.GetValues(typeof(Merlin32TokenTypes)))
_Merlin32Types.Add(token.ToString(), token);
}
public event EventHandler<SnapshotSpanEventArgs> TagsChanged
{
add { }
remove { }
}
// OG !!!
public IEnumerable<ITagSpan<Merlin32TokenTag>> GetTags(NormalizedSnapshotSpanCollection spans)
{
foreach (SnapshotSpan curSpan in spans)
{
ITextSnapshotLine containingLine = curSpan.Start.GetContainingLine();
int curLoc = containingLine.Start.Position;
string formattedLine = containingLine.GetText();
foreach (SnapshotHelper item in Merlin32CodeHelper.GetTokens(curSpan))
{
if (item.Snapshot.IntersectsWith(curSpan))
yield return new TagSpan<Merlin32TokenTag>(item.Snapshot,
new Merlin32TokenTag(item.TokenType));
}
//add an extra char location because of the space
curLoc += formattedLine.Length + 1;
}
}
}
}

View File

@ -0,0 +1,108 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Resources;
using System.Reflection;
using System.Collections;
namespace VSMerlin32
{
public enum Merlin32Opcodes
{
ADC, ADCL, AND, ANDL, ASL,
BCC, BLT, BCS, BGE, BEQ, BIT, BMI, BNE, BPL, BRA, BRK, BRL, BVC, BVS,
CLC, CLD, CLI, CLV, CMP, CMPL, COP, CPX, CPY,
DEC, DEX, DEY,
EOR, EORL,
INC, INX, INY,
JMP, JML, JMPL, JSR, JSL,
LDA, LDAL, LDX, LDY, LSR,
MVN, MVP,
NOP,
ORA, ORAL,
PEA, PEI, PER, PHA, PHB, PHD, PHK, PHP, PHX, PHY, PLA, PLB, PLD, PLP, PLX, PLY,
REP, ROL, ROR, RTI, RTL, RTS,
SBC, SBCL, SEC, SED, SEI, SEP, STA, STAL, STP, STX, STY, STZ,
TAX, TAY, TCD, TCS, TDC, TRB, TSB, TSC, TSX, TXA, TXS, TXY, TYA, TYX,
WAI, WDM,
XBA, XCE
}
public enum Merlin32Directives
{
EQU,
ANOP, ORG, PUT, PUTBIN, /* PUTBIN n'existe pas dans Merlin 16+ */
START, END,
DUM, DEND,
MX, XC, LONGA, LONGI,
USE, USING,
REL, DSK, LNK, SAV,
TYP,
IF, DO, ELSE, FIN,
LUP, ELUP, // --^, ignored for now (invalid enum)
ERR, DAT,
AST, CYC, EXP, LST, LSTDO, PAG, TTL, SKP, TR, KBD, PAU, SW, USR
}
public enum Merlin32DataDefines
{
DA, DW, DDB, DFB, DB, ADR, ADRL, HEX, DS,
DC, DE, /* ? */
ASC, DCI, INV, FLS, REV, STR, STRL,
CHK
}
class Merlin32KeywordsHelper
{
/* The regex for opcodes is now defined in Merlin32CodeHelper.cs
public const string strMerlin32OpcodesRegex =
@"\b(ADC(L?)|AND(L?)|ASL|BCC|BCS|BEQ|BIT|BMI|BNE|BPL|BRA|BRK|BRL|BVC|BVS|CLC|CLD|CLI|CLV|CMP(L?)|COP|CPX|CPY|DEC|DEX|DEY|EOR(L?)|INC|INX|INY|JMP(L?)|JML|JSR|JSL|LDA(L?)|LDX|LDY|LSR|MVN|MVP|NOP|ORA(L?)|ORG|PEA|PEI|PER|PHA|PHB|PHD|PHK|PHP|PHX|PHY|PLA|PLB|PLD|PLP|PLX|PLY|REP|ROL|ROR|RTI|RTL|RTS|SBC(L?)|SEC|SED|SEI|SEP|STA(L?)|STP|STX|STY|STZ|TAX|TAY|TCD|TCS|TDC|TRB|TSB|TSC|TSX|TXA|TXS|TXY|TYA|TYX|WAI|WDM|XBA|XCE)\b";
*/
public IDictionary<string, string> _Merlin32KeywordsQuickInfo;
public Merlin32KeywordsHelper()
{
// Read the resources for opcodes, all of them...
ResourceSet rsOpcodes = VSMerlin32.Resources.opcodes.ResourceManager.GetResourceSet(System.Globalization.CultureInfo.CurrentCulture, true, true);
// Read the resources for directives too, all of them...
ResourceSet rsDirectives = VSMerlin32.Resources.directives.ResourceManager.GetResourceSet(System.Globalization.CultureInfo.CurrentCulture, true, true);
// Read the resources for datadefines too, all of them...
ResourceSet rsData = VSMerlin32.Resources.data.ResourceManager.GetResourceSet(System.Globalization.CultureInfo.CurrentCulture, true, true);
_Merlin32KeywordsQuickInfo = new Dictionary<string, string>();
foreach (Merlin32Opcodes token in Enum.GetValues(typeof(Merlin32Opcodes)))
{
// _Merlin32OpcodesQuickInfo[token.ToString()] = token.ToString();
_Merlin32KeywordsQuickInfo[token.ToString()] = rsOpcodes.GetString(token.ToString());
}
foreach (Merlin32Directives token in Enum.GetValues(typeof(Merlin32Directives)))
{
_Merlin32KeywordsQuickInfo[token.ToString()] = rsDirectives.GetString(token.ToString());
}
foreach (Merlin32DataDefines token in Enum.GetValues(typeof(Merlin32DataDefines)))
{
_Merlin32KeywordsQuickInfo[token.ToString()] = rsData.GetString(token.ToString());
}
/*
_Merlin32OpcodesQuickInfo[Merlin32Opcodes.ORG.ToString()] = VSMerlin32.strings.ORG;
*/
}
}
internal sealed class Merlin32TokenHelper
{
public const string Merlin32Opcode = "Merlin32Opcode";
public const string Merlin32Directive = "Merlin32Directive";
public const string Merlin32DataDefine = "Merlin32DataDefine";
public const string Merlin32Text = "Merlin32Text";
public const string Merlin32Comment = "Merlin32Comment";
}
public enum Merlin32TokenTypes
{
Merlin32Opcode, Merlin32Directive, Merlin32DataDefine, Merlin32Text, Merlin32Comment
}
}

View File

@ -0,0 +1,176 @@
using System;
using System.ComponentModel.Composition;
using System.Runtime.InteropServices;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Editor;
using Microsoft.VisualStudio.Language.Intellisense;
using Microsoft.VisualStudio.OLE.Interop;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.TextManager.Interop;
using Microsoft.VisualStudio.Utilities;
using Microsoft.VisualStudio.Text.Operations;
namespace VSMerlin32
{
#region Command Filter
[Export(typeof(IVsTextViewCreationListener))]
[Name("Merlin32CompletionController")]
[ContentType("Merlin32")]
[TextViewRole(PredefinedTextViewRoles.Editable)]
internal sealed class VsTextViewCreationListener : IVsTextViewCreationListener
{
[Import]
internal IVsEditorAdaptersFactoryService AdaptersFactory = null;
[Import]
internal ICompletionBroker CompletionBroker { get; set; }
[Import]
internal SVsServiceProvider ServiceProvider { get; set; }
public void VsTextViewCreated(IVsTextView textViewAdapter)
{
ITextView textView = AdaptersFactory.GetWpfTextView(textViewAdapter);
if (textView == null)
return;
Func<CommandFilter> createCommandHandler = delegate() { return new CommandFilter(textViewAdapter, textView, this); };
textView.Properties.GetOrCreateSingletonProperty(createCommandHandler);
}
}
internal sealed class CommandFilter : IOleCommandTarget
{
private IOleCommandTarget m_nextCommandHandler;
private ITextView m_textView;
private VsTextViewCreationListener m_provider;
private ICompletionSession m_session;
internal CommandFilter(IVsTextView textViewAdapter, ITextView textView, VsTextViewCreationListener provider)
{
this.m_textView = textView;
this.m_provider = provider;
//add the command to the command chain
textViewAdapter.AddCommandFilter(this, out m_nextCommandHandler);
}
public int QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText)
{
return m_nextCommandHandler.QueryStatus(ref pguidCmdGroup, cCmds, prgCmds, pCmdText);
}
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider))
{
return m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
}
//make a copy of this so we can look at it after forwarding some commands
uint commandID = nCmdID;
char typedChar = char.MinValue;
//make sure the input is a char before getting it
if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)
{
typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn);
}
//check for a commit character
if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN
|| nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB
|| char.IsWhiteSpace(typedChar)
|| char.IsPunctuation(typedChar))
{
//check for a a selection
if (m_session != null && !m_session.IsDismissed)
{
//if the selection is fully selected, commit the current session
if (m_session.SelectedCompletionSet.SelectionStatus.IsSelected)
{
m_session.Commit();
//also, don't add the character to the buffer
return VSConstants.S_OK;
}
else
{
//if there is no selection, dismiss the session
m_session.Dismiss();
}
}
}
//pass along the command so the char is added to the buffer
int retVal = m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
bool handled = false;
if (!typedChar.Equals(char.MinValue) && ((char.IsLetterOrDigit(typedChar)) || ((typedChar == '\'') || (typedChar == '"'))))
{
if (m_session == null || m_session.IsDismissed) // If there is no active session, bring up completion
{
this.TriggerCompletion();
// No need to filter for single and double-quotes, the choice IS the characted, just doubled, and already populated in a single completionset if we're here...
if ((typedChar == '\'') || (typedChar == '"'))
{
// We need to save the currect caret position because we'll position it in between the single/double quotes after the commit...
ITextCaret CaretBeforeCommit = m_session.TextView.Caret;
m_session.Commit();
this.m_textView.Caret.MoveTo(CaretBeforeCommit.Position.BufferPosition - 1);
}
else
{
m_session.Filter();
}
}
else //the completion session is already active, so just filter
{
m_session.Filter();
}
handled = true;
}
else if (commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE //redo the filter if there is a deletion
|| commandID == (uint)VSConstants.VSStd2KCmdID.DELETE)
{
if (m_session != null && !m_session.IsDismissed)
m_session.Filter();
handled = true;
}
if (handled) return VSConstants.S_OK;
return retVal;
}
private bool TriggerCompletion()
{
//the caret must be in a non-projection location
SnapshotPoint? caretPoint =
m_textView.Caret.Position.Point.GetPoint(
textBuffer => (!textBuffer.ContentType.IsOfType("projection")), PositionAffinity.Predecessor);
if (!caretPoint.HasValue)
{
return false;
}
m_session = m_provider.CompletionBroker.CreateCompletionSession(m_textView,
caretPoint.Value.Snapshot.CreateTrackingPoint(caretPoint.Value.Position, PointTrackingMode.Positive),
true);
//subscribe to the Dismissed event on the session
m_session.Dismissed += this.OnSessionDismissed;
m_session.Start();
return true;
}
private void OnSessionDismissed(object sender, EventArgs e)
{
m_session.Dismissed -= this.OnSessionDismissed;
m_session = null;
}
}
#endregion
}

View File

@ -0,0 +1,148 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Language.Intellisense;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Operations;
using Microsoft.VisualStudio.Utilities;
namespace VSMerlin32
{
[Export(typeof(ICompletionSourceProvider))]
[ContentType("Merlin32")]
[Name("Merlin32Completion")]
internal class Merlin32CompletionSourceProvider : ICompletionSourceProvider
{
[Import]
internal ITextStructureNavigatorSelectorService NavigatorService { get; set; }
public ICompletionSource TryCreateCompletionSource(ITextBuffer textBuffer)
{
return new Merlin32CompletionSource(this, textBuffer);
}
}
internal class Merlin32CompletionSource : ICompletionSource
{
private Merlin32CompletionSourceProvider m_sourceprovider;
private ITextBuffer m_buffer;
private List<Completion> m_compList;
private bool m_isDisposed = false;
public Merlin32CompletionSource(Merlin32CompletionSourceProvider sourceprovider, ITextBuffer buffer)
{
m_sourceprovider = sourceprovider;
m_buffer = buffer;
}
public void AugmentCompletionSession(ICompletionSession session, IList<CompletionSet> completionSets)
{
if (m_isDisposed)
throw new ObjectDisposedException("Merlin32CompletionSource");
List<string> strList = new List<string>();
char chTyped = ((session.TextView.Caret.Position.BufferPosition) - 1).GetChar();
// Testing for single and double quotes because these will be autocompleted...
if ((chTyped == '\'') || (chTyped == '"'))
{
strList.Add(chTyped.ToString() + chTyped.ToString());
}
else
{
// If the user has been typing lowercase, we'll present a lowercase list of keywords/opcodes...
if (char.IsLower(chTyped))
{
foreach (Merlin32Opcodes token in Enum.GetValues(typeof(Merlin32Opcodes)))
{
strList.Add(token.ToString().ToLower());
}
foreach (Merlin32Directives token in Enum.GetValues(typeof(Merlin32Directives)))
{
if (token.ToString().ToLower() == Merlin32Directives.ELUP.ToString().ToLower())
{
strList.Add(Resources.directives.ELUPValue);
}
else
{
strList.Add(token.ToString().ToLower());
}
}
foreach (Merlin32DataDefines token in Enum.GetValues(typeof(Merlin32DataDefines)))
{
strList.Add(token.ToString().ToLower());
}
}
else
{
foreach (Merlin32Opcodes token in Enum.GetValues(typeof(Merlin32Opcodes)))
{
strList.Add(token.ToString());
}
foreach (Merlin32Directives token in Enum.GetValues(typeof(Merlin32Directives)))
{
if (token.ToString() == Merlin32Directives.ELUP.ToString())
{
strList.Add(Resources.directives.ELUPValue);
}
else
{
strList.Add(token.ToString());
}
}
foreach (Merlin32DataDefines token in Enum.GetValues(typeof(Merlin32DataDefines)))
{
strList.Add(token.ToString());
}
}
// OG We also need to replace "ELUP" with "--^"
// OG 2015/10/21
strList.Sort();
// strList[strList.IndexOf(Merlin32Directives.ELUP.ToString())] = "--^";
// OG
}
m_compList = new List<Completion>();
foreach (string str in strList)
m_compList.Add(new Completion(str, str, str, null, null));
/*
ITextSnapshot snapshot = _buffer.CurrentSnapshot;
var triggerPoint = (SnapshotPoint)session.GetTriggerPoint(snapshot);
if (triggerPoint == null)
return;
var line = triggerPoint.GetContainingLine();
SnapshotPoint start = triggerPoint;
while (start > line.Start && !char.IsWhiteSpace((start - 1).GetChar()))
{
start -= 1;
}
var applicableTo = snapshot.CreateTrackingSpan(new SnapshotSpan(start, triggerPoint), SpanTrackingMode.EdgeInclusive);
*/
completionSets.Add(new CompletionSet("All", "All", FindTokenSpanAtPosition(session.GetTriggerPoint(m_buffer), session), m_compList, null));
}
private ITrackingSpan FindTokenSpanAtPosition(ITrackingPoint point, ICompletionSession session)
{
SnapshotPoint currentPoint = (session.TextView.Caret.Position.BufferPosition) - 1;
ITextStructureNavigator navigator = m_sourceprovider.NavigatorService.GetTextStructureNavigator(m_buffer);
TextExtent extent = navigator.GetExtentOfWord(currentPoint);
return currentPoint.Snapshot.CreateTrackingSpan(extent.Span, SpanTrackingMode.EdgeInclusive);
}
public void Dispose()
{
if (!m_isDisposed)
{
GC.SuppressFinalize(this);
m_isDisposed = true;
}
}
}
}

View File

@ -0,0 +1,107 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.VisualStudio.Language.Intellisense;
using System.Collections.ObjectModel;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Tagging;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Utilities;
using VSMerlin32.Coloring;
namespace VSMerlin32
{
[Export(typeof(IQuickInfoSourceProvider))]
[ContentType("Merlin32")]
[Name("Merlin32QuickInfo")]
class Merlin32QuickInfoSourceProvider : IQuickInfoSourceProvider
{
[Import]
IBufferTagAggregatorFactoryService aggService = null;
public IQuickInfoSource TryCreateQuickInfoSource(ITextBuffer textBuffer)
{
return new Merlin32QuickInfoSource(textBuffer, aggService.CreateTagAggregator<Merlin32TokenTag>(textBuffer));
}
}
class Merlin32QuickInfoSource : IQuickInfoSource
{
private ITagAggregator<Merlin32TokenTag> _aggregator;
private ITextBuffer _buffer;
private Merlin32KeywordsHelper _Merlin32OpcodesHelper = new Merlin32KeywordsHelper();
private bool _disposed = false;
public Merlin32QuickInfoSource(ITextBuffer buffer, ITagAggregator<Merlin32TokenTag> aggregator)
{
_aggregator = aggregator;
_buffer = buffer;
}
public void AugmentQuickInfoSession(IQuickInfoSession session, IList<object> quickInfoContent, out ITrackingSpan applicableToSpan)
{
applicableToSpan = null;
if (_disposed)
throw new ObjectDisposedException("TestQuickInfoSource");
var triggerPoint = (SnapshotPoint) session.GetTriggerPoint(_buffer.CurrentSnapshot);
if (triggerPoint == null)
return;
foreach (IMappingTagSpan<Merlin32TokenTag> curTag in _aggregator.GetTags(new SnapshotSpan(triggerPoint, triggerPoint)))
{
if ((curTag.Tag.Tokentype == Merlin32TokenTypes.Merlin32Opcode) || (curTag.Tag.Tokentype == Merlin32TokenTypes.Merlin32Directive) || (curTag.Tag.Tokentype == Merlin32TokenTypes.Merlin32DataDefine))
{
var tagSpan = curTag.Span.GetSpans(_buffer).First();
// Before
//if (tagSpan.GetText() == Merlin32Opcodes.ORG.ToString())
//{
// applicableToSpan = _buffer.CurrentSnapshot.CreateTrackingSpan(tagSpan, SpanTrackingMode.EdgeExclusive);
// quickInfoContent.Add("Must be followed by the program's origin, e.g. org $800");
//}
// OG After
applicableToSpan = _buffer.CurrentSnapshot.CreateTrackingSpan(tagSpan, SpanTrackingMode.EdgeExclusive);
if (tagSpan.GetText() == Resources.directives.ELUPValue)
{
quickInfoContent.Add(_Merlin32OpcodesHelper._Merlin32KeywordsQuickInfo[Merlin32Directives.ELUP.ToString()]);
}
else
{
// TODO: why do I get an exception here if I don't test for string.Empty!?
/*
System.Collections.Generic.KeyNotFoundException was unhandled by user code
HResult=-2146232969
Message=The given key was not present in the dictionary.
Source=mscorlib
StackTrace:
at System.Collections.Generic.Dictionary`2.get_Item(TKey key)
at VSMerlin32.Merlin32QuickInfoSource.AugmentQuickInfoSession(IQuickInfoSession session, IList`1 quickInfoContent, ITrackingSpan& applicableToSpan) in c:\Users\Olivier\Documents\Visual Studio 2013\Projects\Merlin32 Language Service\Merlin32Language\Intellisense\Merlin32QuickInfoSource.cs:line 77
at Microsoft.VisualStudio.Language.Intellisense.Implementation.QuickInfoSession.Recalculate()
at Microsoft.VisualStudio.Language.Intellisense.Implementation.QuickInfoSession.Start()
at Microsoft.VisualStudio.Language.Intellisense.Implementation.DefaultQuickInfoController.OnTextView_MouseHover(Object sender, MouseHoverEventArgs e)
at Microsoft.VisualStudio.Text.Editor.Implementation.WpfTextView.RaiseHoverEvents()
InnerException:
*/
// Compare with changeset 151, you'll see why I ask...
if (string.Empty != tagSpan.GetText())
{
quickInfoContent.Add(_Merlin32OpcodesHelper._Merlin32KeywordsQuickInfo[tagSpan.GetText().ToUpper()]);
}
}
}
}
}
public void Dispose()
{
_disposed = true;
}
}
}

View File

@ -0,0 +1,105 @@
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) Microsoft Corporation. All rights reserved.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
using System;
using System.Collections.Generic;
using System.Windows.Input;
using Microsoft.VisualStudio.Language.Intellisense;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.Utilities;
namespace VSLTK.Intellisense
{
#region IIntellisenseController
internal class TemplateQuickInfoController : IIntellisenseController
{
#region Private Data Members
private ITextView _textView;
private IList<ITextBuffer> _subjectBuffers;
private TemplateQuickInfoControllerProvider _componentContext;
private IQuickInfoSession _session;
#endregion
#region Constructors
internal TemplateQuickInfoController(ITextView textView, IList<ITextBuffer> subjectBuffers, TemplateQuickInfoControllerProvider componentContext)
{
_textView = textView;
_subjectBuffers = subjectBuffers;
_componentContext = componentContext;
_textView.MouseHover += this.OnTextViewMouseHover;
}
#endregion
#region IIntellisenseController Members
public void ConnectSubjectBuffer(ITextBuffer subjectBuffer)
{
}
public void DisconnectSubjectBuffer(ITextBuffer subjectBuffer)
{
}
public void Detach(ITextView textView)
{
if (_textView == textView)
{
_textView.MouseHover -= this.OnTextViewMouseHover;
_textView = null;
}
}
#endregion
#region Event Handlers
private void OnTextViewMouseHover(object sender, MouseHoverEventArgs e)
{
SnapshotPoint? point = this.GetMousePosition(new SnapshotPoint(_textView.TextSnapshot, e.Position));
if (point != null)
{
ITrackingPoint triggerPoint = point.Value.Snapshot.CreateTrackingPoint(point.Value.Position,
PointTrackingMode.Positive);
// Find the broker for this buffer
if (!_componentContext.QuickInfoBroker.IsQuickInfoActive(_textView))
{
_session = _componentContext.QuickInfoBroker.CreateQuickInfoSession(_textView, triggerPoint, true);
_session.Start();
}
}
}
#endregion
#region Private Implementation
private SnapshotPoint? GetMousePosition(SnapshotPoint topPosition)
{
// Map this point down to the appropriate subject buffer.
return _textView.BufferGraph.MapDownToFirstMatch
(
topPosition,
PointTrackingMode.Positive,
snapshot => _subjectBuffers.Contains(snapshot.TextBuffer),
PositionAffinity.Predecessor
);
}
#endregion
}
#endregion
}

View File

@ -0,0 +1,41 @@
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) Microsoft Corporation. All rights reserved.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
using System.Collections.Generic;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Language.Intellisense;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.Utilities;
namespace VSLTK.Intellisense
{
#region IIntellisenseControllerProvider
[Export(typeof(IIntellisenseControllerProvider))]
[Name("Template QuickInfo Controller")]
[ContentType("text")]
internal class TemplateQuickInfoControllerProvider : IIntellisenseControllerProvider
{
#region Asset Imports
[Import]
internal IQuickInfoBroker QuickInfoBroker { get; set; }
#endregion
#region IIntellisenseControllerFactory Members
public IIntellisenseController TryCreateIntellisenseController(ITextView textView,
IList<ITextBuffer> subjectBuffers)
{
return new TemplateQuickInfoController(textView, subjectBuffers, this);
}
#endregion
}
#endregion
}

21
License.txt Normal file
View File

@ -0,0 +1,21 @@
MIT License
Copyright (c) 2016 OlivierGuinart
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

210
Merlin32Language.csproj Normal file
View File

@ -0,0 +1,210 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<MinimumVisualStudioVersion>14.0</MinimumVisualStudioVersion>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
<VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
<SccProjectName>SAK</SccProjectName>
<SccLocalPath>SAK</SccLocalPath>
<SccAuxPath>SAK</SccAuxPath>
<SccProvider>SAK</SccProvider>
<FileUpgradeFlags>
</FileUpgradeFlags>
<UpgradeBackupLocation>
</UpgradeBackupLocation>
<OldToolsVersion>4.0</OldToolsVersion>
<TargetFrameworkProfile />
<PublishUrl>publish\</PublishUrl>
<Install>true</Install>
<InstallFrom>Disk</InstallFrom>
<UpdateEnabled>false</UpdateEnabled>
<UpdateMode>Foreground</UpdateMode>
<UpdateInterval>7</UpdateInterval>
<UpdateIntervalUnits>Days</UpdateIntervalUnits>
<UpdatePeriodically>false</UpdatePeriodically>
<UpdateRequired>false</UpdateRequired>
<MapFileExtensions>true</MapFileExtensions>
<ApplicationRevision>0</ApplicationRevision>
<ApplicationVersion>1.0.0.%2a</ApplicationVersion>
<IsWebBootstrapper>false</IsWebBootstrapper>
<UseApplicationTrust>false</UseApplicationTrust>
<BootstrapperEnabled>true</BootstrapperEnabled>
</PropertyGroup>
<PropertyGroup>
<SignAssembly>false</SignAssembly>
</PropertyGroup>
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>10.0.20305</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectTypeGuids>{82b43b9b-a64c-4715-b499-d71e9ca2bd60};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
<ProjectGuid>{F091221E-FD10-41A7-AAC4-C9359178BDB1}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>VSMerlin32</RootNamespace>
<AssemblyName>Merlin32Language</AssemblyName>
<TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<GeneratePkgDefFile>false</GeneratePkgDefFile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<StartAction>Program</StartAction>
<StartProgram>$(ProgramFiles)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe</StartProgram>
<StartArguments>/rootsuffix Exp</StartArguments>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<StartAction>Program</StartAction>
<StartProgram>$(ProgramFiles)\Microsoft Visual Studio 14.0\Common7\IDE\devenv.exe</StartProgram>
<StartArguments>/rootsuffix Exp</StartArguments>
</PropertyGroup>
<ItemGroup>
<Reference Include="Microsoft.VisualStudio.CoreUtility">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Editor">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Language.Intellisense">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.OLE.Interop">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Shell.Interop" />
<Reference Include="Microsoft.VisualStudio.Shell.Interop.8.0" />
<Reference Include="Microsoft.VisualStudio.Shell.Interop.9.0" />
<Reference Include="Microsoft.VisualStudio.Shell.Interop.10.0" />
<Reference Include="Microsoft.VisualStudio.Shell.Interop.11.0" />
<Reference Include="Microsoft.VisualStudio.Shell.Interop.12.0">
<EmbedInteropTypes>true</EmbedInteropTypes>
</Reference>
<Reference Include="Microsoft.VisualStudio.Shell.12.0" />
<Reference Include="Microsoft.VisualStudio.Shell.Immutable.10.0" />
<Reference Include="Microsoft.VisualStudio.Shell.Immutable.11.0" />
<Reference Include="Microsoft.VisualStudio.Shell.Immutable.12.0" />
<Reference Include="Microsoft.VisualStudio.Text.Data">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Text.Logic">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Text.UI">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.Text.UI.Wpf">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.TextManager.Interop, Version=7.1.40304.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<Reference Include="PresentationCore" />
<Reference Include="PresentationFramework" />
<Reference Include="System" />
<Reference Include="System.ComponentModel.Composition" />
<Reference Include="System.Core" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
<Reference Include="System.Xaml" />
<Reference Include="WindowsBase" />
</ItemGroup>
<ItemGroup>
<Compile Include="Coloring\Classification\ClassificationFormat.cs" />
<Compile Include="Coloring\Classification\ClassificationType.cs" />
<Compile Include="Coloring\Data\SnapshotHelper.cs" />
<Compile Include="Resources\data.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>data.resx</DependentUpon>
</Compile>
<Compile Include="Resources\directives.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>directives.resx</DependentUpon>
</Compile>
<Compile Include="Intellisense\CompletionController.cs" />
<Compile Include="Intellisense\CompletionSource.cs" />
<Compile Include="Intellisense\Merlin32QuickInfoSource.cs" />
<Compile Include="Coloring\Merlin32CodeHelper.cs" />
<Compile Include="Coloring\Merlin32TokenTypes.cs" />
<Compile Include="Coloring\Merlin32TokenTag.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Coloring\Classification\Merlin32sClassifier.cs" />
<Compile Include="Intellisense\QuickInfoController.cs" />
<Compile Include="Intellisense\QuickInfoControllerProvider.cs" />
<Compile Include="Resources\opcodes.Designer.cs">
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
<DependentUpon>opcodes.resx</DependentUpon>
</Compile>
</ItemGroup>
<ItemGroup>
<None Include="source.extension.vsixmanifest">
<SubType>Designer</SubType>
</None>
</ItemGroup>
<ItemGroup>
<Content Include="License.txt">
<IncludeInVSIX>true</IncludeInVSIX>
</Content>
<Content Include="Test\HelloWorld.s" />
<Content Include="VSLanguageServiceIcon.jpg">
<IncludeInVSIX>true</IncludeInVSIX>
</Content>
<Content Include="VSLanguageServicePreviewImage.jpg">
<IncludeInVSIX>true</IncludeInVSIX>
</Content>
</ItemGroup>
<ItemGroup>
<EmbeddedResource Include="Resources\data.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>data.Designer.cs</LastGenOutput>
</EmbeddedResource>
<EmbeddedResource Include="Resources\directives.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>directives.Designer.cs</LastGenOutput>
</EmbeddedResource>
<EmbeddedResource Include="Resources\opcodes.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>opcodes.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
<ItemGroup>
<BootstrapperPackage Include=".NETFramework,Version=v4.5">
<Visible>False</Visible>
<ProductName>Microsoft .NET Framework 4.5 %28x86 and x64%29</ProductName>
<Install>true</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
<Visible>False</Visible>
<ProductName>.NET Framework 3.5 SP1</ProductName>
<Install>false</Install>
</BootstrapperPackage>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<Import Project="$(VSToolsPath)\VSSDK\Microsoft.VsSDK.targets" Condition="'$(VSToolsPath)' != ''" />
<PropertyGroup>
<PreBuildEvent>
</PreBuildEvent>
</PropertyGroup>
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>

31
Merlin32Language.sln Normal file
View File

@ -0,0 +1,31 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 14
VisualStudioVersion = 14.0.24720.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Merlin32Language", "Merlin32Language.csproj", "{F091221E-FD10-41A7-AAC4-C9359178BDB1}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{F091221E-FD10-41A7-AAC4-C9359178BDB1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{F091221E-FD10-41A7-AAC4-C9359178BDB1}.Debug|Any CPU.Build.0 = Debug|Any CPU
{F091221E-FD10-41A7-AAC4-C9359178BDB1}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
{F091221E-FD10-41A7-AAC4-C9359178BDB1}.Release|Any CPU.ActiveCfg = Release|Any CPU
{F091221E-FD10-41A7-AAC4-C9359178BDB1}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(TeamFoundationVersionControl) = preSolution
SccNumberOfProjects = 2
SccEnterpriseProvider = {4CA58AB2-18FA-4F8D-95D4-32DDF27D184C}
SccTeamFoundationServer = https://aito.visualstudio.com/
SccLocalPath0 = .
SccProjectUniqueName1 = Merlin32Language.csproj
SccLocalPath1 = .
EndGlobalSection
EndGlobal

BIN
Merlin32LanguageService.gif Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 55 KiB

View File

@ -0,0 +1,33 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("VSMerlin32")]
[assembly: AssemblyDescription("Merlin32 classifier extension to the Visual Studio Editor")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("VSMerlin32")]
[assembly: AssemblyCopyright("Copyright © Olivier Guinart")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

17
README.md Normal file
View File

@ -0,0 +1,17 @@
# Merlin32 Visual Studio Language Service
Visual Studio language service for 6502 Merlin32 cross-assembler (http://brutaldeluxe.fr/products/crossdevtools/merlin/index.html).
Provides the ability to develop 6502 assembly programs within a modern IDE.
Features:
* Syntax coloring
* Statement completion
* Opcodes tooltip
![](https://github.com/OlivierGuinart/Merlin32Language/blob/master/Merlin32LanguageService.gif)
Visual Studio extension available in the Visual Studio gallery: https://marketplace.visualstudio.com/vsgallery/4f84ade5-b04b-451f-92fc-272c06f31359

234
Resources/data.Designer.cs generated Normal file
View File

@ -0,0 +1,234 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace VSMerlin32.Resources {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class data {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal data() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("VSMerlin32.Resources.data", typeof(data).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to Define ADdRess (3 bytes).
/// </summary>
internal static string ADR {
get {
return ResourceManager.GetString("ADR", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define ADdRess Long (4 bytes).
/// </summary>
internal static string ADRL {
get {
return ResourceManager.GetString("ADRL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define ASCii (&quot;&quot; positive, &apos;&apos; negative).
/// </summary>
internal static string ASC {
get {
return ResourceManager.GetString("ASC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Place a CHecKsum in object code.
/// </summary>
internal static string CHK {
get {
return ResourceManager.GetString("CHK", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define Address (2 bytes).
/// </summary>
internal static string DA {
get {
return ResourceManager.GetString("DA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define Byte (1 byte).
/// </summary>
internal static string DB {
get {
return ResourceManager.GetString("DB", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ???.
/// </summary>
internal static string DC {
get {
return ResourceManager.GetString("DC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define Dextral Character Inverted.
/// </summary>
internal static string DCI {
get {
return ResourceManager.GetString("DCI", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define Double Byte (2 bytes).
/// </summary>
internal static string DDB {
get {
return ResourceManager.GetString("DDB", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ???.
/// </summary>
internal static string DE {
get {
return ResourceManager.GetString("DE", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to DeFine Byte (1 byte).
/// </summary>
internal static string DFB {
get {
return ResourceManager.GetString("DFB", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define Storage (x bytes) (e.g. DS 10 (put $00 in 10 bytes), DS 10,$80 (put $80 in 10 bytes)).
/// </summary>
internal static string DS {
get {
return ResourceManager.GetString("DS", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define Word (2 bytes).
/// </summary>
internal static string DW {
get {
return ResourceManager.GetString("DW", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define FLaShing text.
/// </summary>
internal static string FLS {
get {
return ResourceManager.GetString("FLS", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define HEX data (1 byte).
/// </summary>
internal static string HEX {
get {
return ResourceManager.GetString("HEX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define INVerse text.
/// </summary>
internal static string INV {
get {
return ResourceManager.GetString("INV", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define REVerse.
/// </summary>
internal static string REV {
get {
return ResourceManager.GetString("REV", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define STRing with leading length (1 byte).
/// </summary>
internal static string STR {
get {
return ResourceManager.GetString("STR", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define STRing Long with leading length (2 bytes).
/// </summary>
internal static string STRL {
get {
return ResourceManager.GetString("STRL", resourceCulture);
}
}
}
}

177
Resources/data.resx Normal file
View File

@ -0,0 +1,177 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="ADR" xml:space="preserve">
<value>Define ADdRess (3 bytes)</value>
</data>
<data name="ADRL" xml:space="preserve">
<value>Define ADdRess Long (4 bytes)</value>
</data>
<data name="ASC" xml:space="preserve">
<value>Define ASCii ("" positive, '' negative)</value>
</data>
<data name="CHK" xml:space="preserve">
<value>Place a CHecKsum in object code</value>
</data>
<data name="DA" xml:space="preserve">
<value>Define Address (2 bytes)</value>
</data>
<data name="DB" xml:space="preserve">
<value>Define Byte (1 byte)</value>
</data>
<data name="DC" xml:space="preserve">
<value>???</value>
</data>
<data name="DCI" xml:space="preserve">
<value>Define Dextral Character Inverted</value>
</data>
<data name="DDB" xml:space="preserve">
<value>Define Double Byte (2 bytes)</value>
</data>
<data name="DE" xml:space="preserve">
<value>???</value>
</data>
<data name="DFB" xml:space="preserve">
<value>DeFine Byte (1 byte)</value>
</data>
<data name="DS" xml:space="preserve">
<value>Define Storage (x bytes) (e.g. DS 10 (put $00 in 10 bytes), DS 10,$80 (put $80 in 10 bytes))</value>
</data>
<data name="DW" xml:space="preserve">
<value>Define Word (2 bytes)</value>
</data>
<data name="FLS" xml:space="preserve">
<value>Define FLaShing text</value>
</data>
<data name="HEX" xml:space="preserve">
<value>Define HEX data (1 byte)</value>
</data>
<data name="INV" xml:space="preserve">
<value>Define INVerse text</value>
</data>
<data name="REV" xml:space="preserve">
<value>Define REVerse</value>
</data>
<data name="STR" xml:space="preserve">
<value>Define STRing with leading length (1 byte)</value>
</data>
<data name="STRL" xml:space="preserve">
<value>Define STRing Long with leading length (2 bytes)</value>
</data>
</root>

450
Resources/directives.Designer.cs generated Normal file
View File

@ -0,0 +1,450 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace VSMerlin32.Resources {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class directives {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal directives() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("VSMerlin32.Resources.directives", typeof(directives).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to ???.
/// </summary>
internal static string ANOP {
get {
return ResourceManager.GetString("ANOP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Send a line of ASTerisks.
/// </summary>
internal static string AST {
get {
return ResourceManager.GetString("AST", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Calculate and print CYCle times for the code.
/// </summary>
internal static string CYC {
get {
return ResourceManager.GetString("CYC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to DATe stamp assembly listing.
/// </summary>
internal static string DAT {
get {
return ResourceManager.GetString("DAT", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Dummy section END.
/// </summary>
internal static string DEND {
get {
return ResourceManager.GetString("DEND", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to DO directive.
/// </summary>
internal static string DO {
get {
return ResourceManager.GetString("DO", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define the name of the output binary after the directive.
/// </summary>
internal static string DSK {
get {
return ResourceManager.GetString("DSK", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to DUMmy section start.
/// </summary>
internal static string DUM {
get {
return ResourceManager.GetString("DUM", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ELSE condition.
/// </summary>
internal static string ELSE {
get {
return ResourceManager.GetString("ELSE", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to End of LUP.
/// </summary>
internal static string ELUP {
get {
return ResourceManager.GetString("ELUP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to (--\^).
/// </summary>
internal static string ELUPRegex {
get {
return ResourceManager.GetString("ELUPRegex", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to --^.
/// </summary>
internal static string ELUPValue {
get {
return ResourceManager.GetString("ELUPValue", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to END of source file.
/// </summary>
internal static string END {
get {
return ResourceManager.GetString("END", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define constant values (same as =).
/// </summary>
internal static string EQU {
get {
return ResourceManager.GetString("EQU", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Force ERRor.
/// </summary>
internal static string ERR {
get {
return ResourceManager.GetString("ERR", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Macro EXPand control.
/// </summary>
internal static string EXP {
get {
return ResourceManager.GetString("EXP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Mandatory ENDdirective for IF and DO .
/// </summary>
internal static string FIN {
get {
return ResourceManager.GetString("FIN", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to IF condition.
/// </summary>
internal static string IF {
get {
return ResourceManager.GetString("IF", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define label from KeyBoarD.
/// </summary>
internal static string KBD {
get {
return ResourceManager.GetString("KBD", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Relocate code (same as DSK in Merlin 32).
/// </summary>
internal static string LNK {
get {
return ResourceManager.GetString("LNK", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ???.
/// </summary>
internal static string LONGA {
get {
return ResourceManager.GetString("LONGA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ???.
/// </summary>
internal static string LONGI {
get {
return ResourceManager.GetString("LONGI", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to LiSTing control.
/// </summary>
internal static string LST {
get {
return ResourceManager.GetString("LST", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to LiSTDO OFF areas of code.
/// </summary>
internal static string LSTDO {
get {
return ResourceManager.GetString("LSTDO", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Repeat portions of the code (until the --^ directive).
/// </summary>
internal static string LUP {
get {
return ResourceManager.GetString("LUP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Set the size for M (Accumulator) and X (X and Y Registers).
/// </summary>
internal static string MX {
get {
return ResourceManager.GetString("MX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Must be followed by the program&apos;s origin, e.g. org $800.
/// </summary>
internal static string ORG {
get {
return ResourceManager.GetString("ORG", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to New PAGe.
/// </summary>
internal static string PAG {
get {
return ResourceManager.GetString("PAG", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to PAUse.
/// </summary>
internal static string PAU {
get {
return ResourceManager.GetString("PAU", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Insert the content of a source file.
/// </summary>
internal static string PUT {
get {
return ResourceManager.GetString("PUT", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ???.
/// </summary>
internal static string PUTBIN {
get {
return ResourceManager.GetString("PUTBIN", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Use at the start of the program to write 16 bit relocatable code.
/// </summary>
internal static string REL {
get {
return ResourceManager.GetString("REL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Define the name of the output binary before the directive.
/// </summary>
internal static string SAV {
get {
return ResourceManager.GetString("SAV", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to SKiP lines.
/// </summary>
internal static string SKP {
get {
return ResourceManager.GetString("SKP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ???.
/// </summary>
internal static string START {
get {
return ResourceManager.GetString("START", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to SWeet16 opcodes.
/// </summary>
internal static string SW {
get {
return ResourceManager.GetString("SW", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to TRuncate control.
/// </summary>
internal static string TR {
get {
return ResourceManager.GetString("TR", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to TiTLe heading.
/// </summary>
internal static string TTL {
get {
return ResourceManager.GetString("TTL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Set the output file type (one byte: $00-$FF).
/// </summary>
internal static string TYP {
get {
return ResourceManager.GetString("TYP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Insert macros.
/// </summary>
internal static string USE {
get {
return ResourceManager.GetString("USE", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ???.
/// </summary>
internal static string USING {
get {
return ResourceManager.GetString("USING", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ???.
/// </summary>
internal static string USR {
get {
return ResourceManager.GetString("USR", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ???.
/// </summary>
internal static string XC {
get {
return ResourceManager.GetString("XC", resourceCulture);
}
}
}
}

249
Resources/directives.resx Normal file
View File

@ -0,0 +1,249 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="ANOP" xml:space="preserve">
<value>???</value>
</data>
<data name="AST" xml:space="preserve">
<value>Send a line of ASTerisks</value>
</data>
<data name="CYC" xml:space="preserve">
<value>Calculate and print CYCle times for the code</value>
</data>
<data name="DAT" xml:space="preserve">
<value>DATe stamp assembly listing</value>
</data>
<data name="DEND" xml:space="preserve">
<value>Dummy section END</value>
</data>
<data name="DO" xml:space="preserve">
<value>DO directive</value>
</data>
<data name="DSK" xml:space="preserve">
<value>Define the name of the output binary after the directive</value>
</data>
<data name="DUM" xml:space="preserve">
<value>DUMmy section start</value>
</data>
<data name="ELSE" xml:space="preserve">
<value>ELSE condition</value>
</data>
<data name="ELUP" xml:space="preserve">
<value>End of LUP</value>
</data>
<data name="ELUPRegex" xml:space="preserve">
<value>(--\^)</value>
</data>
<data name="ELUPValue" xml:space="preserve">
<value>--^</value>
</data>
<data name="END" xml:space="preserve">
<value>END of source file</value>
</data>
<data name="EQU" xml:space="preserve">
<value>Define constant values (same as =)</value>
</data>
<data name="ERR" xml:space="preserve">
<value>Force ERRor</value>
</data>
<data name="EXP" xml:space="preserve">
<value>Macro EXPand control</value>
</data>
<data name="FIN" xml:space="preserve">
<value>Mandatory ENDdirective for IF and DO </value>
</data>
<data name="IF" xml:space="preserve">
<value>IF condition</value>
</data>
<data name="KBD" xml:space="preserve">
<value>Define label from KeyBoarD</value>
</data>
<data name="LNK" xml:space="preserve">
<value>Relocate code (same as DSK in Merlin 32)</value>
</data>
<data name="LONGA" xml:space="preserve">
<value>???</value>
</data>
<data name="LONGI" xml:space="preserve">
<value>???</value>
</data>
<data name="LST" xml:space="preserve">
<value>LiSTing control</value>
</data>
<data name="LSTDO" xml:space="preserve">
<value>LiSTDO OFF areas of code</value>
</data>
<data name="LUP" xml:space="preserve">
<value>Repeat portions of the code (until the --^ directive)</value>
</data>
<data name="MX" xml:space="preserve">
<value>Set the size for M (Accumulator) and X (X and Y Registers)</value>
</data>
<data name="ORG" xml:space="preserve">
<value>Must be followed by the program's origin, e.g. org $800</value>
</data>
<data name="PAG" xml:space="preserve">
<value>New PAGe</value>
</data>
<data name="PAU" xml:space="preserve">
<value>PAUse</value>
</data>
<data name="PUT" xml:space="preserve">
<value>Insert the content of a source file</value>
</data>
<data name="PUTBIN" xml:space="preserve">
<value>???</value>
</data>
<data name="REL" xml:space="preserve">
<value>Use at the start of the program to write 16 bit relocatable code</value>
</data>
<data name="SAV" xml:space="preserve">
<value>Define the name of the output binary before the directive</value>
</data>
<data name="SKP" xml:space="preserve">
<value>SKiP lines</value>
</data>
<data name="START" xml:space="preserve">
<value>???</value>
</data>
<data name="SW" xml:space="preserve">
<value>SWeet16 opcodes</value>
</data>
<data name="TR" xml:space="preserve">
<value>TRuncate control</value>
</data>
<data name="TTL" xml:space="preserve">
<value>TiTLe heading</value>
</data>
<data name="TYP" xml:space="preserve">
<value>Set the output file type (one byte: $00-$FF)</value>
</data>
<data name="USE" xml:space="preserve">
<value>Insert macros</value>
</data>
<data name="USING" xml:space="preserve">
<value>???</value>
</data>
<data name="USR" xml:space="preserve">
<value>???</value>
</data>
<data name="XC" xml:space="preserve">
<value>???</value>
</data>
</root>

972
Resources/opcodes.Designer.cs generated Normal file
View File

@ -0,0 +1,972 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:4.0.30319.42000
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
namespace VSMerlin32.Resources {
using System;
/// <summary>
/// A strongly-typed resource class, for looking up localized strings, etc.
/// </summary>
// This class was auto-generated by the StronglyTypedResourceBuilder
// class via a tool like ResGen or Visual Studio.
// To add or remove a member, edit your .ResX file then rerun ResGen
// with the /str option, or rebuild your VS project.
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class opcodes {
private static global::System.Resources.ResourceManager resourceMan;
private static global::System.Globalization.CultureInfo resourceCulture;
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
internal opcodes() {
}
/// <summary>
/// Returns the cached ResourceManager instance used by this class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Resources.ResourceManager ResourceManager {
get {
if (object.ReferenceEquals(resourceMan, null)) {
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("VSMerlin32.Resources.opcodes", typeof(opcodes).Assembly);
resourceMan = temp;
}
return resourceMan;
}
}
/// <summary>
/// Overrides the current thread's CurrentUICulture property for all
/// resource lookups using this strongly typed resource class.
/// </summary>
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
internal static global::System.Globalization.CultureInfo Culture {
get {
return resourceCulture;
}
set {
resourceCulture = value;
}
}
/// <summary>
/// Looks up a localized string similar to ADd with Carry.
/// </summary>
internal static string ADC {
get {
return ResourceManager.GetString("ADC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ADd with Carry Long.
/// </summary>
internal static string ADCL {
get {
return ResourceManager.GetString("ADCL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Bitwise AND with accumulator.
/// </summary>
internal static string AND {
get {
return ResourceManager.GetString("AND", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Bitwise AND with accumulator, Long.
/// </summary>
internal static string ANDL {
get {
return ResourceManager.GetString("ANDL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ASL shifts all bits left one position. 0 is shifted into bit 0 and the original bit 7 is shifted into the Carry.
/// </summary>
internal static string ASL {
get {
return ResourceManager.GetString("ASL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Branch if Carry Clear.
/// </summary>
internal static string BCC {
get {
return ResourceManager.GetString("BCC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Branch if Carry Set.
/// </summary>
internal static string BCS {
get {
return ResourceManager.GetString("BCS", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Branch if EQual/Branch if zero.
/// </summary>
internal static string BEQ {
get {
return ResourceManager.GetString("BEQ", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to BIt Test.
/// </summary>
internal static string BIT {
get {
return ResourceManager.GetString("BIT", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Branch if MInus value.
/// </summary>
internal static string BMI {
get {
return ResourceManager.GetString("BMI", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Branch if Not Equal/Branch if not zero.
/// </summary>
internal static string BNE {
get {
return ResourceManager.GetString("BNE", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Branch if PLus value.
/// </summary>
internal static string BPL {
get {
return ResourceManager.GetString("BPL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to BRanch Always.
/// </summary>
internal static string BRA {
get {
return ResourceManager.GetString("BRA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Software BReaK.
/// </summary>
internal static string BRK {
get {
return ResourceManager.GetString("BRK", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to BRanch always Long.
/// </summary>
internal static string BRL {
get {
return ResourceManager.GetString("BRL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Branch if oVerflow Clear.
/// </summary>
internal static string BVC {
get {
return ResourceManager.GetString("BVC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Branch if oVerflow Set.
/// </summary>
internal static string BVS {
get {
return ResourceManager.GetString("BVS", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to CLear Carry flag.
/// </summary>
internal static string CLC {
get {
return ResourceManager.GetString("CLC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to CLear Decimal flag.
/// </summary>
internal static string CLD {
get {
return ResourceManager.GetString("CLD", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to CLear Interrupt flag.
/// </summary>
internal static string CLI {
get {
return ResourceManager.GetString("CLI", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to CLear oVerflow flag.
/// </summary>
internal static string CLV {
get {
return ResourceManager.GetString("CLV", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to CoMPare accumulator with memory.
/// </summary>
internal static string CMP {
get {
return ResourceManager.GetString("CMP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to CoMPare accumulator with memory, Long.
/// </summary>
internal static string CMPL {
get {
return ResourceManager.GetString("CMPL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to COProcessor empowerment (interrupt).
/// </summary>
internal static string COP {
get {
return ResourceManager.GetString("COP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ComPare X with memory.
/// </summary>
internal static string CPX {
get {
return ResourceManager.GetString("CPX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ComPare Y with memory.
/// </summary>
internal static string CPY {
get {
return ResourceManager.GetString("CPY", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to DECrement accumulator or memory.
/// </summary>
internal static string DEC {
get {
return ResourceManager.GetString("DEC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to DEcrement X.
/// </summary>
internal static string DEX {
get {
return ResourceManager.GetString("DEX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Decrement Y.
/// </summary>
internal static string DEY {
get {
return ResourceManager.GetString("DEY", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Exclusive OR accumulator with memory.
/// </summary>
internal static string EOR {
get {
return ResourceManager.GetString("EOR", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Exclusive OR accumulator with memory, Long.
/// </summary>
internal static string EORL {
get {
return ResourceManager.GetString("EORL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to INCrement accumulator or memory.
/// </summary>
internal static string INC {
get {
return ResourceManager.GetString("INC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to INcrement X.
/// </summary>
internal static string INX {
get {
return ResourceManager.GetString("INX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to INcrement Y.
/// </summary>
internal static string INY {
get {
return ResourceManager.GetString("INY", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to JuMp, Long.
/// </summary>
internal static string JML {
get {
return ResourceManager.GetString("JML", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to JuMP.
/// </summary>
internal static string JMP {
get {
return ResourceManager.GetString("JMP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to JuMP, Long.
/// </summary>
internal static string JMPL {
get {
return ResourceManager.GetString("JMPL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Jump to Subroutine, Long.
/// </summary>
internal static string JSL {
get {
return ResourceManager.GetString("JSL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Jump to SubRoutine.
/// </summary>
internal static string JSR {
get {
return ResourceManager.GetString("JSR", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to LoaD Accumulator.
/// </summary>
internal static string LDA {
get {
return ResourceManager.GetString("LDA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to LoaD Accumulator, Long.
/// </summary>
internal static string LDAL {
get {
return ResourceManager.GetString("LDAL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to LoaD X register.
/// </summary>
internal static string LDX {
get {
return ResourceManager.GetString("LDX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to LoaD Y register.
/// </summary>
internal static string LDY {
get {
return ResourceManager.GetString("LDY", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to LSR shifts all bits right one position. 0 is shifted into bit 7 and the original bit 0 is shifted into the Carry.
/// </summary>
internal static string LSR {
get {
return ResourceManager.GetString("LSR", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Block MoVe Negative.
/// </summary>
internal static string MVN {
get {
return ResourceManager.GetString("MVN", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Block MoVe Positive.
/// </summary>
internal static string MVP {
get {
return ResourceManager.GetString("MVP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to No OPeration.
/// </summary>
internal static string NOP {
get {
return ResourceManager.GetString("NOP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Bitwise OR Accumulator with memory.
/// </summary>
internal static string ORA {
get {
return ResourceManager.GetString("ORA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Bitwise OR Accumulator with memory, Long.
/// </summary>
internal static string ORAL {
get {
return ResourceManager.GetString("ORAL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Push Effective Address.
/// </summary>
internal static string PEA {
get {
return ResourceManager.GetString("PEA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Push Effective Indirect address.
/// </summary>
internal static string PEI {
get {
return ResourceManager.GetString("PEI", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Push program countEr Relative.
/// </summary>
internal static string PER {
get {
return ResourceManager.GetString("PER", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to PusH Accumulator.
/// </summary>
internal static string PHA {
get {
return ResourceManager.GetString("PHA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to PusH data Bank register.
/// </summary>
internal static string PHB {
get {
return ResourceManager.GetString("PHB", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to PusH Direct page register.
/// </summary>
internal static string PHD {
get {
return ResourceManager.GetString("PHD", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to PusH program banK register.
/// </summary>
internal static string PHK {
get {
return ResourceManager.GetString("PHK", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to PusH Processor status flags.
/// </summary>
internal static string PHP {
get {
return ResourceManager.GetString("PHP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to PusH X.
/// </summary>
internal static string PHX {
get {
return ResourceManager.GetString("PHX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to PusH Y.
/// </summary>
internal static string PHY {
get {
return ResourceManager.GetString("PHY", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Pull Accumulator.
/// </summary>
internal static string PLA {
get {
return ResourceManager.GetString("PLA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Pull data Bank register.
/// </summary>
internal static string PLB {
get {
return ResourceManager.GetString("PLB", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Pull Direct page register.
/// </summary>
internal static string PLD {
get {
return ResourceManager.GetString("PLD", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Pull Processor status flags.
/// </summary>
internal static string PLP {
get {
return ResourceManager.GetString("PLP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Pull X.
/// </summary>
internal static string PLX {
get {
return ResourceManager.GetString("PLX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Pull Y.
/// </summary>
internal static string PLY {
get {
return ResourceManager.GetString("PLY", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to REset Processor status flag.
/// </summary>
internal static string REP {
get {
return ResourceManager.GetString("REP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ROtate Left accumulator or memory.
/// </summary>
internal static string ROL {
get {
return ResourceManager.GetString("ROL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ROtate Right accumulator or memory.
/// </summary>
internal static string ROR {
get {
return ResourceManager.GetString("ROR", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ReTurn from Interrupt.
/// </summary>
internal static string RTI {
get {
return ResourceManager.GetString("RTI", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ReTurn from subroutine, Long.
/// </summary>
internal static string RTL {
get {
return ResourceManager.GetString("RTL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to ReTurn from Subroutine; pulls the top two bytes off the stack (low byte first) and transfers program control to that address+1.
/// </summary>
internal static string RTS {
get {
return ResourceManager.GetString("RTS", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to SuBtract with Carry.
/// </summary>
internal static string SBC {
get {
return ResourceManager.GetString("SBC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to SuBtract with Carry Long.
/// </summary>
internal static string SBCL {
get {
return ResourceManager.GetString("SBCL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to SEt Carry flag.
/// </summary>
internal static string SEC {
get {
return ResourceManager.GetString("SEC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to SEt Decimal flag.
/// </summary>
internal static string SED {
get {
return ResourceManager.GetString("SED", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to SEt Interrupt flag.
/// </summary>
internal static string SEI {
get {
return ResourceManager.GetString("SEI", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to SEt Processor status flag.
/// </summary>
internal static string SEP {
get {
return ResourceManager.GetString("SEP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to STore Accumulator to memory.
/// </summary>
internal static string STA {
get {
return ResourceManager.GetString("STA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to STore Accumulator to memory, Long.
/// </summary>
internal static string STAL {
get {
return ResourceManager.GetString("STAL", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to SToP the clock.
/// </summary>
internal static string STP {
get {
return ResourceManager.GetString("STP", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to STore X to memory.
/// </summary>
internal static string STX {
get {
return ResourceManager.GetString("STX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to STore Y to memory.
/// </summary>
internal static string STY {
get {
return ResourceManager.GetString("STY", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to STore Zero to memory.
/// </summary>
internal static string STZ {
get {
return ResourceManager.GetString("STZ", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer Accumulator to X.
/// </summary>
internal static string TAX {
get {
return ResourceManager.GetString("TAX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer Accumulator to Y.
/// </summary>
internal static string TAY {
get {
return ResourceManager.GetString("TAY", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer aCcumulator to Direct page.
/// </summary>
internal static string TCD {
get {
return ResourceManager.GetString("TCD", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer aCcumulator to Stack page.
/// </summary>
internal static string TCS {
get {
return ResourceManager.GetString("TCS", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer Direct page to aCcumulator.
/// </summary>
internal static string TDC {
get {
return ResourceManager.GetString("TDC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Test and Reset Bit.
/// </summary>
internal static string TRB {
get {
return ResourceManager.GetString("TRB", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Test and Set Bit.
/// </summary>
internal static string TSB {
get {
return ResourceManager.GetString("TSB", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer Stack pointer to aCcumulator.
/// </summary>
internal static string TSC {
get {
return ResourceManager.GetString("TSC", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer Stack pointer to X.
/// </summary>
internal static string TSX {
get {
return ResourceManager.GetString("TSX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer X to Accumulator.
/// </summary>
internal static string TXA {
get {
return ResourceManager.GetString("TXA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer X to Stack pointer.
/// </summary>
internal static string TXS {
get {
return ResourceManager.GetString("TXS", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer X to Y.
/// </summary>
internal static string TXY {
get {
return ResourceManager.GetString("TXY", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer Y to Accumulator.
/// </summary>
internal static string TYA {
get {
return ResourceManager.GetString("TYA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Transfer Y to X.
/// </summary>
internal static string TYX {
get {
return ResourceManager.GetString("TYX", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to WAIt for interrupt.
/// </summary>
internal static string WAI {
get {
return ResourceManager.GetString("WAI", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Reserved for future use, it performs no operation.
/// </summary>
internal static string WDM {
get {
return ResourceManager.GetString("WDM", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to EXchange low and high byte of the Accumulator.
/// </summary>
internal static string XBA {
get {
return ResourceManager.GetString("XBA", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to EXchange Carry and Emulation.
/// </summary>
internal static string XCE {
get {
return ResourceManager.GetString("XCE", resourceCulture);
}
}
}
}

423
Resources/opcodes.resx Normal file
View File

@ -0,0 +1,423 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="ADC" xml:space="preserve">
<value>ADd with Carry</value>
</data>
<data name="ADCL" xml:space="preserve">
<value>ADd with Carry Long</value>
</data>
<data name="AND" xml:space="preserve">
<value>Bitwise AND with accumulator</value>
</data>
<data name="ANDL" xml:space="preserve">
<value>Bitwise AND with accumulator, Long</value>
</data>
<data name="ASL" xml:space="preserve">
<value>ASL shifts all bits left one position. 0 is shifted into bit 0 and the original bit 7 is shifted into the Carry</value>
</data>
<data name="BCC" xml:space="preserve">
<value>Branch if Carry Clear</value>
</data>
<data name="BCS" xml:space="preserve">
<value>Branch if Carry Set</value>
</data>
<data name="BEQ" xml:space="preserve">
<value>Branch if EQual/Branch if zero</value>
</data>
<data name="BIT" xml:space="preserve">
<value>BIt Test</value>
</data>
<data name="BMI" xml:space="preserve">
<value>Branch if MInus value</value>
</data>
<data name="BNE" xml:space="preserve">
<value>Branch if Not Equal/Branch if not zero</value>
</data>
<data name="BPL" xml:space="preserve">
<value>Branch if PLus value</value>
</data>
<data name="BRA" xml:space="preserve">
<value>BRanch Always</value>
</data>
<data name="BRK" xml:space="preserve">
<value>Software BReaK</value>
</data>
<data name="BRL" xml:space="preserve">
<value>BRanch always Long</value>
</data>
<data name="BVC" xml:space="preserve">
<value>Branch if oVerflow Clear</value>
</data>
<data name="BVS" xml:space="preserve">
<value>Branch if oVerflow Set</value>
</data>
<data name="CLC" xml:space="preserve">
<value>CLear Carry flag</value>
</data>
<data name="CLD" xml:space="preserve">
<value>CLear Decimal flag</value>
</data>
<data name="CLI" xml:space="preserve">
<value>CLear Interrupt flag</value>
</data>
<data name="CLV" xml:space="preserve">
<value>CLear oVerflow flag</value>
</data>
<data name="CMP" xml:space="preserve">
<value>CoMPare accumulator with memory</value>
</data>
<data name="CMPL" xml:space="preserve">
<value>CoMPare accumulator with memory, Long</value>
</data>
<data name="COP" xml:space="preserve">
<value>COProcessor empowerment (interrupt)</value>
</data>
<data name="CPX" xml:space="preserve">
<value>ComPare X with memory</value>
</data>
<data name="CPY" xml:space="preserve">
<value>ComPare Y with memory</value>
</data>
<data name="DEC" xml:space="preserve">
<value>DECrement accumulator or memory</value>
</data>
<data name="DEX" xml:space="preserve">
<value>DEcrement X</value>
</data>
<data name="DEY" xml:space="preserve">
<value>Decrement Y</value>
</data>
<data name="EOR" xml:space="preserve">
<value>Exclusive OR accumulator with memory</value>
</data>
<data name="EORL" xml:space="preserve">
<value>Exclusive OR accumulator with memory, Long</value>
</data>
<data name="INC" xml:space="preserve">
<value>INCrement accumulator or memory</value>
</data>
<data name="INX" xml:space="preserve">
<value>INcrement X</value>
</data>
<data name="INY" xml:space="preserve">
<value>INcrement Y</value>
</data>
<data name="JML" xml:space="preserve">
<value>JuMp, Long</value>
</data>
<data name="JMP" xml:space="preserve">
<value>JuMP</value>
</data>
<data name="JMPL" xml:space="preserve">
<value>JuMP, Long</value>
</data>
<data name="JSL" xml:space="preserve">
<value>Jump to Subroutine, Long</value>
</data>
<data name="JSR" xml:space="preserve">
<value>Jump to SubRoutine</value>
</data>
<data name="LDA" xml:space="preserve">
<value>LoaD Accumulator</value>
</data>
<data name="LDAL" xml:space="preserve">
<value>LoaD Accumulator, Long</value>
</data>
<data name="LDX" xml:space="preserve">
<value>LoaD X register</value>
</data>
<data name="LDY" xml:space="preserve">
<value>LoaD Y register</value>
</data>
<data name="LSR" xml:space="preserve">
<value>LSR shifts all bits right one position. 0 is shifted into bit 7 and the original bit 0 is shifted into the Carry</value>
</data>
<data name="MVN" xml:space="preserve">
<value>Block MoVe Negative</value>
</data>
<data name="MVP" xml:space="preserve">
<value>Block MoVe Positive</value>
</data>
<data name="NOP" xml:space="preserve">
<value>No OPeration</value>
</data>
<data name="ORA" xml:space="preserve">
<value>Bitwise OR Accumulator with memory</value>
</data>
<data name="ORAL" xml:space="preserve">
<value>Bitwise OR Accumulator with memory, Long</value>
</data>
<data name="PEA" xml:space="preserve">
<value>Push Effective Address</value>
</data>
<data name="PEI" xml:space="preserve">
<value>Push Effective Indirect address</value>
</data>
<data name="PER" xml:space="preserve">
<value>Push program countEr Relative</value>
</data>
<data name="PHA" xml:space="preserve">
<value>PusH Accumulator</value>
</data>
<data name="PHB" xml:space="preserve">
<value>PusH data Bank register</value>
</data>
<data name="PHD" xml:space="preserve">
<value>PusH Direct page register</value>
</data>
<data name="PHK" xml:space="preserve">
<value>PusH program banK register</value>
</data>
<data name="PHP" xml:space="preserve">
<value>PusH Processor status flags</value>
</data>
<data name="PHX" xml:space="preserve">
<value>PusH X</value>
</data>
<data name="PHY" xml:space="preserve">
<value>PusH Y</value>
</data>
<data name="PLA" xml:space="preserve">
<value>Pull Accumulator</value>
</data>
<data name="PLB" xml:space="preserve">
<value>Pull data Bank register</value>
</data>
<data name="PLD" xml:space="preserve">
<value>Pull Direct page register</value>
</data>
<data name="PLP" xml:space="preserve">
<value>Pull Processor status flags</value>
</data>
<data name="PLX" xml:space="preserve">
<value>Pull X</value>
</data>
<data name="PLY" xml:space="preserve">
<value>Pull Y</value>
</data>
<data name="REP" xml:space="preserve">
<value>REset Processor status flag</value>
</data>
<data name="ROL" xml:space="preserve">
<value>ROtate Left accumulator or memory</value>
</data>
<data name="ROR" xml:space="preserve">
<value>ROtate Right accumulator or memory</value>
</data>
<data name="RTI" xml:space="preserve">
<value>ReTurn from Interrupt</value>
</data>
<data name="RTL" xml:space="preserve">
<value>ReTurn from subroutine, Long</value>
</data>
<data name="RTS" xml:space="preserve">
<value>ReTurn from Subroutine; pulls the top two bytes off the stack (low byte first) and transfers program control to that address+1</value>
</data>
<data name="SBC" xml:space="preserve">
<value>SuBtract with Carry</value>
</data>
<data name="SBCL" xml:space="preserve">
<value>SuBtract with Carry Long</value>
</data>
<data name="SEC" xml:space="preserve">
<value>SEt Carry flag</value>
</data>
<data name="SED" xml:space="preserve">
<value>SEt Decimal flag</value>
</data>
<data name="SEI" xml:space="preserve">
<value>SEt Interrupt flag</value>
</data>
<data name="SEP" xml:space="preserve">
<value>SEt Processor status flag</value>
</data>
<data name="STA" xml:space="preserve">
<value>STore Accumulator to memory</value>
</data>
<data name="STAL" xml:space="preserve">
<value>STore Accumulator to memory, Long</value>
</data>
<data name="STP" xml:space="preserve">
<value>SToP the clock</value>
</data>
<data name="STX" xml:space="preserve">
<value>STore X to memory</value>
</data>
<data name="STY" xml:space="preserve">
<value>STore Y to memory</value>
</data>
<data name="STZ" xml:space="preserve">
<value>STore Zero to memory</value>
</data>
<data name="TAX" xml:space="preserve">
<value>Transfer Accumulator to X</value>
</data>
<data name="TAY" xml:space="preserve">
<value>Transfer Accumulator to Y</value>
</data>
<data name="TCD" xml:space="preserve">
<value>Transfer aCcumulator to Direct page</value>
</data>
<data name="TCS" xml:space="preserve">
<value>Transfer aCcumulator to Stack page</value>
</data>
<data name="TDC" xml:space="preserve">
<value>Transfer Direct page to aCcumulator</value>
</data>
<data name="TRB" xml:space="preserve">
<value>Test and Reset Bit</value>
</data>
<data name="TSB" xml:space="preserve">
<value>Test and Set Bit</value>
</data>
<data name="TSC" xml:space="preserve">
<value>Transfer Stack pointer to aCcumulator</value>
</data>
<data name="TSX" xml:space="preserve">
<value>Transfer Stack pointer to X</value>
</data>
<data name="TXA" xml:space="preserve">
<value>Transfer X to Accumulator</value>
</data>
<data name="TXS" xml:space="preserve">
<value>Transfer X to Stack pointer</value>
</data>
<data name="TXY" xml:space="preserve">
<value>Transfer X to Y</value>
</data>
<data name="TYA" xml:space="preserve">
<value>Transfer Y to Accumulator</value>
</data>
<data name="TYX" xml:space="preserve">
<value>Transfer Y to X</value>
</data>
<data name="WAI" xml:space="preserve">
<value>WAIt for interrupt</value>
</data>
<data name="WDM" xml:space="preserve">
<value>Reserved for future use, it performs no operation</value>
</data>
<data name="XBA" xml:space="preserve">
<value>EXchange low and high byte of the Accumulator</value>
</data>
<data name="XCE" xml:space="preserve">
<value>EXchange Carry and Emulation</value>
</data>
</root>

11
Test/HelloWorld.s Normal file
View File

@ -0,0 +1,11 @@
; Uses S-C Assembler variant.
* This is also a valid comment...
org $800
main ldy #$00
start_loop lda HelloWorld,y
beq end_loop
jsr $fded ; ROM routine, COUT, y is preserved
iny
bne start_loop
end_loop rts
HelloWorld ASC "HELLO WORLD!"00

BIN
VSLanguageServiceIcon.jpg Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 21 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 38 KiB

View File

@ -0,0 +1,36 @@
<?xml version="1.0" encoding="utf-8"?>
<!--//***************************************************************************
//
// Copyright (c) Microsoft Corporation. All rights reserved.
// This code is licensed under the Visual Studio SDK license terms.
// THIS CODE IS PROVIDED *AS IS* WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY
// IMPLIED WARRANTIES OF FITNESS FOR A PARTICULAR
// PURPOSE, MERCHANTABILITY, OR NON-INFRINGEMENT.
//
//***************************************************************************-->
<PackageManifest Version="2.0.0" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011">
<Metadata>
<Identity Id="Merlin32Language..c729d6b2-f512-49ed-893d-a8f61f25db98" Version="1.0" Language="en-US" Publisher="Olivier Guinart" />
<DisplayName>Merlin32 Language Service</DisplayName>
<Description xml:space="preserve">Merlin32 classifier extension to the Visual Studio Editor.</Description>
<MoreInfo>http://www.brutaldeluxe.fr/products/crossdevtools/merlin/</MoreInfo>
<License>License.txt</License>
<GettingStartedGuide>https://github.com/OlivierGuinart/Merlin32Language</GettingStartedGuide>
<Icon>VSLanguageServiceIcon.jpg</Icon>
<PreviewImage>VSLanguageServicePreviewImage.jpg</PreviewImage>
<Tags>6502, merlin32, assembly language, language service, Apple II</Tags>
</Metadata>
<Installation>
<InstallationTarget Id="Microsoft.VisualStudio.Pro" Version="[12.0,15.0)" />
<InstallationTarget Version="[12.0,15.0)" Id="Microsoft.VisualStudio.IntegratedShell" />
<InstallationTarget Version="[12.0,15.0)" Id="Microsoft.VisualStudio.Community" />
<InstallationTarget Version="[12.0,15.0)" Id="Microsoft.VisualStudio.Enterprise" />
</Installation>
<Dependencies>
<Dependency Id="Microsoft.Framework.NDP" DisplayName="Microsoft .NET Framework" d:Source="Manual" Version="4.5" />
</Dependencies>
<Assets>
<Asset Type="Microsoft.VisualStudio.MefComponent" d:Source="Project" d:ProjectName="%CurrentProject%" Path="|%CurrentProject%|" />
</Assets>
</PackageManifest>