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; }