mirror of
https://github.com/fadden/6502bench.git
synced 2024-09-11 20:54:37 +00:00
The disassembled lines are now shown in the custom-styled list view. The DisplayList isn't being kept up to date on edits, but since we can't edit anything yet that's not too limiting. Pulled more code over, including the mostly-GUI-agnostic bits of the source generation and assembler execution code.
171 lines
5.6 KiB
C#
171 lines
5.6 KiB
C#
/*
|
|
* Copyright 2019 faddenSoft
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
|
|
namespace SourceGenWPF.AsmGen {
|
|
/// <summary>
|
|
/// Static information on assemblers supported by SourceGen. This is relevant for both
|
|
/// assembly source generation and assembler execution. Nothing here is affected
|
|
/// by whether or not the assembler in question is actually installed.
|
|
/// </summary>
|
|
public class AssemblerInfo {
|
|
/// <summary>
|
|
/// Enumeration of supported assemblers. Alphabetical order looks nicest.
|
|
/// </summary>
|
|
public enum Id {
|
|
Unknown = 0,
|
|
Tass64,
|
|
Cc65,
|
|
Merlin32,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Static information for all known assemblers.
|
|
///
|
|
/// The AsmType argument may be null. This is useful for non-cross assemblers.
|
|
/// </summary>
|
|
private static AssemblerInfo[] sInfo = new AssemblerInfo[] {
|
|
new AssemblerInfo(Id.Unknown, "???", null, null),
|
|
new AssemblerInfo(Id.Tass64, "64tass", typeof(GenTass64), typeof(AsmTass64)),
|
|
new AssemblerInfo(Id.Cc65, "cc65", typeof(GenCc65), typeof(AsmCc65)),
|
|
new AssemblerInfo(Id.Merlin32, "Merlin 32", typeof(GenMerlin32), typeof(AsmMerlin32)),
|
|
};
|
|
|
|
/// <summary>
|
|
/// Identifier.
|
|
/// </summary>
|
|
public Id AssemblerId { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Human-readable name.
|
|
/// </summary>
|
|
public string Name { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Type of generator class.
|
|
/// </summary>
|
|
public Type GenType { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Type of assembler class.
|
|
/// </summary>
|
|
public Type AsmType { get; private set; }
|
|
|
|
|
|
private AssemblerInfo(Id id, string name, Type genType, Type asmType) {
|
|
AssemblerId = id;
|
|
Name = name;
|
|
GenType = genType;
|
|
AsmType = asmType;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns an AssemblerInfo object for the specified id.
|
|
/// </summary>
|
|
/// <param name="id">Assembler identifier.</param>
|
|
/// <returns>Reference to AssemblerInfo object.</returns>
|
|
public static AssemblerInfo GetAssemblerInfo(Id id) {
|
|
return sInfo[(int)id];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generator factory method.
|
|
/// </summary>
|
|
/// <param name="id">ID of assembler to return generator instance for.</param>
|
|
/// <returns>New source generator object.</returns>
|
|
public static IGenerator GetGenerator(Id id) {
|
|
Type genType = sInfo[(int)id].GenType;
|
|
if (genType == null) {
|
|
Debug.Assert(false); // unexpected for generator
|
|
return null;
|
|
} else {
|
|
return (IGenerator)Activator.CreateInstance(genType);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Assembler factory method.
|
|
/// </summary>
|
|
/// <param name="id">ID of assembler to return assembler instance for.</param>
|
|
/// <returns>New assembler interface object.</returns>
|
|
public static IAssembler GetAssembler(Id id) {
|
|
Type asmType = sInfo[(int)id].AsmType;
|
|
if (asmType == null) {
|
|
return null;
|
|
} else {
|
|
return (IAssembler)Activator.CreateInstance(asmType);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Provides a way to iterate through the set of known assemblers. This is probably
|
|
/// YAGNI -- we could just return the array -- but it would allow us to apply filters,
|
|
/// e.g. strip out assemblers that don't support 65816 code when that's the selected
|
|
/// CPU definition.
|
|
/// </summary>
|
|
private class AssemblerInfoIterator : IEnumerator<AssemblerInfo> {
|
|
private int mIndex = -1;
|
|
|
|
public AssemblerInfo Current {
|
|
get {
|
|
if (mIndex < 0) {
|
|
// not started
|
|
return null;
|
|
}
|
|
return sInfo[mIndex];
|
|
}
|
|
}
|
|
|
|
object IEnumerator.Current {
|
|
get {
|
|
return Current;
|
|
}
|
|
}
|
|
|
|
public void Dispose() { }
|
|
|
|
public bool MoveNext() {
|
|
if (mIndex < 0) {
|
|
// skip element 0 (Unknown)
|
|
mIndex = 1;
|
|
} else {
|
|
mIndex++;
|
|
if (mIndex >= sInfo.Length) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void Reset() {
|
|
mIndex = -1;
|
|
}
|
|
}
|
|
|
|
public static IEnumerator<AssemblerInfo> GetInfoEnumerator() {
|
|
return new AssemblerInfoIterator();
|
|
}
|
|
|
|
|
|
public override string ToString() {
|
|
return "Asm " + ((int)AssemblerId).ToString() + ": " + Name;
|
|
}
|
|
}
|
|
}
|