public static void ForEachBit(this FuncBuilder f, IntExpression expr, int offset, int count, bool bigEndian, ActionOnIntExpr action)
{
int inclusiveStart;
int exclusiveEnd;
int increment;
if (!bigEndian)
{
inclusiveStart = offset;
exclusiveEnd = offset + count;
increment = 1;
}
else
{
inclusiveStart = offset + count - 1;
exclusiveEnd = offset - 1;
increment = -1;
}
f.For(i => i.Value = inclusiveStart, i => i < exclusiveEnd, i => i.Value = i + increment)
.Do(i => {
var mask = ((IntExpression)1).ShiftLeft(i);
var bitInPosition = f.Declare.Int("bitInPosition");
bitInPosition.Value = expr & mask;
action(bitInPosition);
});
}
private readonly Format16OpCode inverseOpCode; //should we wish to invert this operator, because (a<b)==!(a>=b), therefore BGE
private CompareOp(IntExpression lhs, IntExpression rhs, Format16OpCode branchOpCode, Format16OpCode inverseOpCode)
{
this.lhs = lhs;
this.rhs = rhs;
this.branchOpCode = branchOpCode;
this.inverseOpCode = inverseOpCode;
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (type == typeof(IntExpression))
{
IntExpression result = new IntExpression(null, "", dictionary["abbr"] as string)
{
Data = dictionary["data"],
Min = Convert.ToInt32(dictionary["min"]),
Max = Convert.ToInt32(dictionary["max"]),
};
return(result);
}
else if (type == typeof(UTrack))
{
UTrack result = new UTrack()
{
Name = dictionary["name"] as string,
Comment = dictionary["comment"] as string,
TrackNo = Convert.ToInt32(dictionary["trackno"]),
Singer = new USinger(dictionary["singer"] as string),
};
return(result);
}
else if (type == typeof(USinger))
{
USinger result = new USinger(dictionary["name"] as string);
return(result);
}
else
{
return(null);
}
}
public void Write(IntExpression value)
{
var f=FuncBuilder.Instance;
f.If(value!=0)
.Then(Set)
.Else(Clear)
.Endif();
}
private static IEnumerable <IInstruction> GetIntExpressionInstructions(this IntExpression intExpression)
{
List <IInstruction> instructions = new List <IInstruction>();
instructions.Add(LdcInstruction.WithValue(intExpression.Value.ToString()));
//instructions.AddRange(JasminLibraryFunctionsHelper.GetIntegerValueOf(JasminReferenceConstants.JavaIntegerClass));
return(instructions);
}
public void Write(IntExpression value)
{
var f = FuncBuilder.Instance;
f.If(value != 0)
.Then(Set)
.Else(Clear)
.Endif();
}
public void Initialize(MethodDispatchTablePointer firmware, IntExpression pinNumber, bool initialValue)
{
firmware.GetPIOAndBitmask(pinNumber, ref pio, ref bitmask);
pio.PER=bitmask; //enable PIO function
if(initialValue) {
pio.SODR=bitmask; //output should start high
} else {
pio.CODR=bitmask; //output should start low
}
pio.OER=bitmask; //enable output
}
// branchOpCode: the normal case: (a<b) therefore BLT
// flipOpCode: the flipped case: (a<b)==(b>a), therefore BGT
// inverseOpCode: the inverse case: (a<b)==!(a>=b), therefore BGE
// flipInverseOpCode: the flipped inverse case: (a<b)==!(b<=a), therefore BLE
private static CompareOp CreateHelper(IntExpression lhs, IntExpression rhs,
Format16OpCode branchOpCode, Format16OpCode flipOpCode, Format16OpCode inverseOpCode, Format16OpCode flipInverseOpCode)
{
if (lhs.IsConstant())
{
if (rhs.IsConstant())
{
throw new Exception("ridiculous");
}
//flip the constant over to the right side, for better code generation
return(new CompareOp(rhs, lhs, flipOpCode, flipInverseOpCode));
}
return(new CompareOp(lhs, rhs, branchOpCode, inverseOpCode));
}
public void Initialize(MethodDispatchTablePointer firmware, IntExpression pinNumber, bool initialValue)
{
firmware.GetPIOAndBitmask(pinNumber, ref pio, ref bitmask);
pio.PER = bitmask; //enable PIO function
if (initialValue)
{
pio.SODR = bitmask; //output should start high
}
else
{
pio.CODR = bitmask; //output should start low
}
pio.OER = bitmask; //enable output
}
internal static int?GetValueOrNull(this IntExpression expression, DialogStateManager state)
{
if (expression != null)
{
var(value, valueError) = expression.TryGetValue(state);
if (valueError != null)
{
throw new InvalidOperationException($"Expression evaluation resulted in an error. Expression: {expression.ExpressionText}. Error: {valueError}");
}
return(value);
}
return(null);
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
UProject result = new UProject();
string ustxVersion = dictionary["ustxversion"] as string;
USTx.Project = result;
result.Name = dictionary["name"] as string;
result.Comment = dictionary["comment"] as string;
result.OutputDir = dictionary["output"] as string;
result.CacheDir = dictionary["cache"] as string;
result.BPM = Convert.ToDouble(dictionary["bpm"]);
result.BeatPerBar = Convert.ToInt32(dictionary["bpbar"]);
result.BeatUnit = Convert.ToInt32(dictionary["bunit"]);
result.Resolution = Convert.ToInt32(dictionary["res"]);
foreach (var pair in (Dictionary <string, object>)(dictionary["exptable"]))
{
var exp = serializer.ConvertToType(pair.Value, typeof(IntExpression)) as IntExpression;
var _exp = new IntExpression(null, pair.Key, exp.Abbr)
{
Data = exp.Data,
Min = exp.Min,
Max = exp.Max,
};
result.ExpressionTable.Add(pair.Key, _exp);
}
var singers = dictionary["singers"] as ArrayList;
foreach (var singer in singers)
{
result.Singers.Add(serializer.ConvertToType(singer, typeof(USinger)) as USinger);
}
foreach (var track in dictionary["tracks"] as ArrayList)
{
var _tarck = serializer.ConvertToType(track, typeof(UTrack)) as UTrack;
result.Tracks.Add(_tarck);
}
foreach (var part in dictionary["parts"] as ArrayList)
{
result.Parts.Add(serializer.ConvertToType(part, typeof(UPart)) as UPart);
}
USTx.Project = null;
return(result);
}
public void NodeQuery_Bug2125()
{
Expression exp;
ExpressionList expList;
var query1 = new NodeQuery();
exp = new SearchExpression("dummy");
query1.Add(exp);
Assert.IsTrue(Object.ReferenceEquals(exp.Parent, query1), "#1");
expList = new ExpressionList(ChainOperator.And);
query1.Add(expList);
Assert.IsTrue(Object.ReferenceEquals(expList.Parent, query1), "#2");
exp = new StringExpression(StringAttribute.Name, StringOperator.Equal, "Root");
expList.Add(exp);
Assert.IsTrue(Object.ReferenceEquals(exp.Parent, expList), "#3");
exp = new IntExpression(IntAttribute.Id, ValueOperator.Equal, 2);
expList.Add(exp);
Assert.IsTrue(Object.ReferenceEquals(exp.Parent, expList), "#4");
//------------------------------------------------------------------------------------
var query2 = new NodeQuery
(
new SearchExpression("dummy"),
new ExpressionList
(
ChainOperator.And,
new StringExpression(StringAttribute.Name, StringOperator.Equal, "Root"),
new IntExpression(IntAttribute.Id, ValueOperator.Equal, 2)
)
);
Assert.IsTrue(Object.ReferenceEquals(query2.Expressions[0].Parent, query2), "#5");
Assert.IsTrue(Object.ReferenceEquals(query2.Expressions[1].Parent, query2), "#6");
Assert.IsTrue(Object.ReferenceEquals(((ExpressionList)query2.Expressions[1]).Expressions[0].Parent, query2.Expressions[1]), "#7");
Assert.IsTrue(Object.ReferenceEquals(((ExpressionList)query2.Expressions[1]).Expressions[1].Parent, query2.Expressions[1]), "#8");
}
public static void Return(this FuncBuilder f, IntExpression expr)
{
using (f.OpenScope("return")) {
var emitter = CodeGenerator.Emitter;
var resultStorage = f.Declare.Int("result");
var exprResult = expr.EvaluateTo(resultStorage);
var exprRegOrByte = exprResult.ToRegisterOrByte(f.Scratch0);
if (exprRegOrByte.IsRegister)
{
emitter.EmitRegisterMoveIfDifferent(Register.R0, exprRegOrByte.Register);
}
else
{
emitter.Emit(Format3OpCode.MOV, Register.R0, exprRegOrByte.Byte);
}
BranchLogic.UnconditionalBranchTo(f.TheExitLabel);
}
}
public IndirectIntReference this[IntExpression index]
{
get {
return new IndirectIntReference(this, index);
}
}
private void SetHelper(int offset, IntExpression value)
{
this.AsIntPointer()[offset].Value=value;
}
public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
UProject result = new UProject();
string ustxVersion = dictionary["ustxversion"] as string;
USTx.Project = result;
result.Name = dictionary["name"] as string;
result.Comment = dictionary["comment"] as string;
result.OutputDir = dictionary["output"] as string;
result.CacheDir = dictionary["cache"] as string;
result.BPM = Convert.ToDouble(dictionary["bpm"]);
result.BeatPerBar = Convert.ToInt32(dictionary["bpbar"]);
result.BeatUnit = Convert.ToInt32(dictionary["bunit"]);
result.Resolution = Convert.ToInt32(dictionary["res"]);
foreach (var pair in (Dictionary<string, object>)(dictionary["exptable"]))
{
var exp = serializer.ConvertToType(pair.Value, typeof(IntExpression)) as IntExpression;
var _exp = new IntExpression(null, pair.Key, exp.Abbr)
{
Data = exp.Data,
Min = exp.Min,
Max = exp.Max,
};
result.ExpressionTable.Add(pair.Key, _exp);
}
var singers = dictionary["singers"] as ArrayList;
foreach (var singer in singers)
result.Singers.Add(serializer.ConvertToType(singer, typeof(USinger)) as USinger);
foreach (var track in dictionary["tracks"] as ArrayList)
{
var _tarck = serializer.ConvertToType(track, typeof(UTrack)) as UTrack;
result.Tracks.Add(_tarck);
}
foreach (var part in dictionary["parts"] as ArrayList)
result.Parts.Add(serializer.ConvertToType(part, typeof(UPart)) as UPart);
USTx.Project = null;
return result;
}
public IntVariable Int(string name, IntExpression optionalInitialValue = null)
{
return((IntVariable)DeclareHelper(name, new IntVariable(), optionalInitialValue));
}
public void EnqueueDelta(MethodDispatchTablePointer firmware, IntExpression delayInMicroseconds)
{
firmware.HAL_EnqueueDelta(storage, delayInMicroseconds);
}
public static CompareOp CreateEqual(IntExpression lhs, IntExpression rhs)
{
return(CreateHelper(lhs, rhs, Format16OpCode.BEQ, Format16OpCode.BEQ, Format16OpCode.BNE, Format16OpCode.BNE));
}
public IndirectByteReference this[IntExpression index] {
get {
return(new IndirectByteReference(this, index));
}
}
private void SetHelper(int offset, IntExpression value)
{
this.AsIntPointer()[offset].Value = value;
}
public static CompareOp CreateLessThanOrEqual(IntExpression lhs, IntExpression rhs)
{
return(CreateHelper(lhs, rhs, Format16OpCode.BLE, Format16OpCode.BGE, Format16OpCode.BGT, Format16OpCode.BLT));
}
public void EnqueueDelta(MethodDispatchTablePointer firmware, IntExpression delayInMicroseconds)
{
firmware.HAL_EnqueueDelta(storage, delayInMicroseconds);
}
public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
if (type == typeof(IntExpression))
{
IntExpression result = new IntExpression(null, "", dictionary["abbr"] as string)
{
Data = dictionary["data"],
Min = Convert.ToInt32(dictionary["min"]),
Max = Convert.ToInt32(dictionary["max"]),
};
return result;
}
else if (type == typeof(UTrack))
{
UTrack result = new UTrack()
{
Name = dictionary["name"] as string,
Comment = dictionary["comment"] as string,
TrackNo = Convert.ToInt32(dictionary["trackno"]),
Singer = new USinger() { Name = dictionary["singer"] as string }
};
return result;
}
else if (type == typeof(USinger))
{
USinger result = new USinger()
{
Name = dictionary["name"] as string,
Path = dictionary["path"] as string
};
return result;
}
else return null;
}
public static void GetPIOAndBitmask(this MethodDispatchTablePointer md, IntExpression pin, ref PIOReferenceVariable pio, ref IntVariable bitmask)
{
md.GetPIOReference(ref pio, pin.ShiftRight(5)); // pin/32
bitmask.Value = ((IntExpression)1).ShiftLeft(pin & 0x1f); // 1<<(pin%32)
}
