public bool TryApply(StringBuilder s, BitsValue v)
{
if (!v.TryGetBinaryPattern(this.Width, out var pattern))
{
return(false);
}
if (Higher >= s.Length)
{
return(false);
}
var pIdx = pattern.Length - 1;
var sIdx = s.Length - Lower - 1;
for (var i = Lower; i <= Higher; i++, pIdx--, sIdx--)
{
if (s[sIdx] == '1' || s[sIdx] == '0')
{
return(false);
}
s[sIdx] = pattern[pIdx];
}
return(true);
}
private void LoadValue(BitsValue value)
{
Generator.Ldc_I8((long)value.Number);
Generator.Conv <ulong>();
Generator.Ldc_I4(value.Length);
NumberToBitsValue(true);
}
public static BitsValue DoOperation(BitsValue left, BitsValue right, Operator op, SourceSpan span)
{
var maxLen = left.Length > right.Length ? left.Length : right.Length;
switch (op)
{
case Operator.And:
return(new BitsValue(left.Number & right.Number, maxLen));
case Operator.Or:
return(new BitsValue(left.Number | right.Number, maxLen));
case Operator.Xor:
return(new BitsValue(left.Number ^ right.Number, maxLen));
case Operator.ShiftLeft:
return(new BitsValue(left.Number << (int)right.Number, left.Length + (int)right.Number));
case Operator.ShiftRight:
return(new BitsValue(left.Number >> (int)right.Number, left.Length - (int)right.Number));
case Operator.Add:
return(new BitsValue(left.Number + right.Number));
case Operator.Subtract:
return(new BitsValue(left.Number - right.Number));
case Operator.Multiply:
return(new BitsValue(left.Number * right.Number));
case Operator.Divide:
return(new BitsValue(left.Number / right.Number));
case Operator.Power:
return(new BitsValue((ulong)Math.Pow(left.Number, right.Number)));
case Operator.Modulus:
return(new BitsValue(left.Number % right.Number));
case Operator.EqualsCompare:
return(new BitsValue(left.Number == right.Number ? 1ul : 0, 1));
case Operator.NotEqualsCompare:
return(new BitsValue(left.Number != right.Number ? 1ul : 0, 1));
case Operator.Greater:
return(new BitsValue(left.Number > right.Number ? 1ul : 0, 1));
case Operator.Lesser:
return(new BitsValue(left.Number < right.Number ? 1ul : 0, 1));
}
throw new InterpreterException("Unknown operator", span);
}
public void SetOutputs(int start, BitsValue values)
{
if (Noop)
{
return;
}
var bitsVal = new BitsValue(values);
Console.WriteLine($"Set outputs [{start}..{start + values.Length}] to {bitsVal.Number} ({bitsVal})");
}
public static bool TryParse(string s, out BitsValue bv)
{
if (s == "ignore")
{
bv = new BitsValue(-1, ignored: true);
return(true);
}
if (SmartParser.Instance.TryParse(s, typeof(int), out var result))
{
bv = new BitsValue((int)result);
return(true);
}
bv = new BitsValue(-1);
return(false);
}
private static Tuple <string, string> ParseLine(string lineContent, int opcodeLength = 32)
{
var pattern = new StringBuilder(new String('_', opcodeLength));
var elems = lineContent.Split(LineSplitPatterns, StringSplitOptions.RemoveEmptyEntries);
if (elems.Length < 2)
{
throw new RecoverableException($"Couldn't split line: {lineContent}");
}
var instructionName = elems[0];
foreach (var elem in elems.Skip(1))
{
var parts = elem.Split(PartSplitPatterns);
if (parts.Length != 2)
{
// let's ignore all non-explicit ranges
continue;
}
if (!BitsRange.TryParse(parts[0], out var range))
{
throw new RecoverableException($"Couldn't parse range: {parts[0]}");
}
if (!BitsValue.TryParse(parts[1], out var value))
{
throw new RecoverableException($"Couldn't parse value: {parts[1]}");
}
if (!range.TryApply(pattern, value))
{
throw new RecoverableException($"Couldn't apply value {value} in range {range} to pattern {pattern}");
}
}
return(Tuple.Create(instructionName, pattern.ToString()));
}
public void WriteRegister(int index, BitsValue value)
{
Registers[index] = value;
}
public void Set(string name, BitsValue val) => Variables[name] = val;
private static bool IsTruthy(BitsValue value) => value.Number > 0;
public NumberLiteralExpression(SourceSpan span, BitsValue value) : base(span)
{
this.Value = value;
}
public NumberLiteralExpression(BitsValue value, SourceLocation location) : base(location)
{
this.Value = value;
}
