public Object SubArgumentsAndSymbols(Object original, Sequence macro, SequenceMacroReference macroReference, String expansionSymbol) //Substitute paramater references with arguments, prepend expansion symbol to internal symbol references
{
if (!(original is String))
{
return(original); //No operation required if original is a literal value
}
String value = original as String;
SymbolSelector sel = SymbolSelector.TryParse(value);
if (sel != null)
{
value = sel.Symbol;
Object newValue = (macro.Parameters.Contains(value)) ? macroReference.Arguments[macro.Parameters.IndexOf(value)]
: (macro.Symbols.ContainsKey(value)) ? expansionSymbol + "." + value
: value;
return(newValue.ToString() + $"[{sel.Selector.ToString()}]");
}
else
{
return((macro.Parameters.Contains(value)) ? macroReference.Arguments[macro.Parameters.IndexOf(value)]
: (macro.Symbols.ContainsKey(value)) ? expansionSymbol + "." + value
: value);
}
}
public void ExpandMicroprogram(Microprogram microprogram) //Expands all macro references and resolves constants/macro variables
{
Microprogram = microprogram;
Sequence sequence;
do
{
sequence = microprogram.Symbols.Where(kv => ((kv.Value is Sequence) && (kv.Value as Sequence).Unexpanded && !(kv.Value as Sequence).IsMacro && (kv.Value as Sequence).Steps.Count > 0)).Select(kv => (Sequence)kv.Value).FirstOrDefault(); //Get first unexpanded sequence
if (sequence == null)
{
break;
}
int macroAddr;
for (macroAddr = 0; macroAddr < sequence.Steps.Count; macroAddr++)
{
if (sequence.Steps[macroAddr].Type == SequenceStepType.MacroReference)
{
break; //Find the first macro reference within the sequence
}
}
SequenceMacroReference mRef = sequence.Steps[macroAddr] as SequenceMacroReference;
if (microprogram[mRef.Symbol] == null || !(microprogram[mRef.Symbol] is Sequence))
{
throw new MicroassemblerExpansionException($"Macro {mRef.Symbol} referenced on line {mRef.Line} does not exist");
}
Sequence macro = (Sequence)Microprogram[mRef.Symbol];
if (macro.Parameters.Count > mRef.Arguments.Count)
{
throw new MicroassemblerExpansionException($"Macro reference on line {mRef.Line} provides {mRef.Arguments.Count} arguments, while the referenced macro has {macro.Parameters.Count} parameters");
}
List <SequenceStep> copiedSteps = macro.Steps.Select(s => (SequenceStep)s.Clone()).ToList();
//Find a unique expansion symbol
String expansionSymbol;
int symNum = 0;
do
{
expansionSymbol = ((String.IsNullOrEmpty(mRef.ParentReference)) ? "_" : mRef.ParentReference + "._") + mRef.Symbol + "_" + symNum.ToString();
symNum++;
}while (sequence[expansionSymbol] != null);
//Recursively Offset all address symbols after the macro
RecurseOffset(sequence, macroAddr, macro.Steps.Count - 1); //The macro call step is removed, so that is not counted as part of the offset
//Create a container for symbols within the expanded macro and copy symbols from the original macro
SymbolContainer expansionContainer = new SymbolContainer();
macro.Symbols.ForEach(kv => expansionContainer.Symbols.Add(kv.Key, (kv.Value is ICloneable) ? (kv.Value as ICloneable).Clone() : kv.Value));
sequence[expansionSymbol] = expansionContainer;
expansionContainer.Symbols.ForEach(kv => OffsetObject(kv.Value, macroAddr));
//Replace parameter references in copied steps with arguments, also add the expanded symbol name to any internal macro symbol references
foreach (SequenceStep step in copiedSteps)
{
if (step is SequenceMacroReference)
{
SequenceMacroReference stepRef = step as SequenceMacroReference;
if (stepRef.Symbol.Equals(mRef.Symbol))
{
throw new MicroassemblerExpansionException($"Caught recursive macro self-reference on line {stepRef.Line}"); //Sanity check
}
stepRef.Arguments = stepRef.Arguments.Select(a => SubArgumentsAndSymbols(a, macro, mRef, expansionSymbol)).ToList();
stepRef.ParentReference = expansionSymbol;
}
else if (step is SequenceAssertion)
{
SequenceAssertion stepAssertion = step as SequenceAssertion;
stepAssertion.AssertedSignals = stepAssertion.AssertedSignals.Select(kv => new KeyValuePair <ControlWordLabel, Object>(kv.Key, SubArgumentsAndSymbols(kv.Value, macro, mRef, expansionSymbol))).ToDictionary(kv => kv.Key, kv => kv.Value);
}
}
//Remove macro reference and insert steps
sequence.Steps.RemoveAt(macroAddr);
sequence.Steps.InsertRange(macroAddr, copiedSteps);
}while (sequence != null);
}
public Sequence ParseSequence(Boolean isMacro) // Parses a sequence and return an object representation (used for both normal sequences and macros)
{
Sequence sequence = new Sequence()
{
IsMacro = isMacro
};
if (Enumerator.HasToken() && Enumerator.Current.TokenType == TokenType.ParenList)
{
if (!isMacro)
{
throw new MicroassemblerParseException(Enumerator.Last, "Only macros can define a parameter list");
}
List <Object> parameters = (List <Object>)Enumerator.Current.Value;
Enumerator.Advance();
if (parameters.Where(p => !(p is String) || (p is String && ((String)p).Any(Char.IsWhiteSpace))).Any())
{
throw new MicroassemblerParseException(Enumerator.Last, "Parameter definitions may only contain non-whitespace-delimited words");
}
sequence.Parameters.AddRange(parameters.Cast <String>());
}
VerifySyntaxToken(TokenType.OpenBlock, "{");
String word = "";
do
{
if (Enumerator.HasToken() && Enumerator.Current.TokenType == TokenType.CloseBlock)
{
Enumerator.Advance();
break;
}
word = GetWordToken();
if (word.StartsWith("::") && word.EndsWith("::"))
{
String label = word.Substring(2, word.Length - 4);
sequence[label] = new SequenceLabel {
LocalAddress = sequence.Steps.Count
};
}
else if (Enumerator.HasToken() && Enumerator.Current.TokenType == TokenType.ParenList)
{
List <Object> arguments = (List <Object>)Enumerator.Current.Value;
Enumerator.Advance();
SequenceMacroReference step = new SequenceMacroReference()
{
Arguments = arguments, Symbol = word, Line = Enumerator.Last.Line
};
sequence.Steps.Add(step);
}
else if (word.ToLower().Equals("assert"))
{
SequenceAssertion step = ParseSequenceAssertion();
sequence.Steps.Add(step);
}
else
{
throw new MicroassemblerParseException(Enumerator.Last);
}
}while (true);
return(sequence);
}
