public override IR subscript(IR i, IR index, IRList list) { if (index.dType != Lookup.I32) { throw Jolly.addError(new SourceLocation(), "Only int can be used as subscript"); } return(list.Add(IR.operation <IR_Substript>(i, index, null))); }
public override IR getMember(IR i, int index, IRList list) { if (index >= members.Length) { throw Jolly.addError(new SourceLocation(), "Out of index bounds"); } return(list.Add(IR.getMember(i, members[index], index))); }
static IR packTuple(AST_Tuple tuple, DataType_Tuple tupleType) { IR_Allocate alloc = new IR_Allocate { dType = tupleType }; tuple.values.forEach((val, i) => { IR member = instructions.Add(IR.getMember(alloc, tupleType.members[i], i)); instructions.Add(IR.operation <IR_Assign>(member, val.result, null)); }); return(alloc); }
static void implicitCast(ref IR ir, DataType to) { if (ir.dType != to) { Cast cast; if (!Lookup.implicitCast.get(ir.dType, to, out cast)) { throw Jolly.addError(new SourceLocation(), "Cannot implicitly cast {0} to {1}".fill(ir.dType, to)); } ir = cast(ir, to); } }
static void dereference(AST_Node node) { IR refIR = (node as AST_Operation)?.a.result ?? node.result; var reference = refIR.dType as DataType_Reference; if (isStatic(refIR.dKind) || reference == null) { throw Jolly.addError((node as AST_Operation ?? node).location, "Cannot dereference this"); } node.result = instructions.Add(new IR_Dereference { target = refIR, dType = reference.referenced }); }
public static IR cast <T>(IR from, DataType to, StaticExec exec) where T : IR_Cast, new() { if (exec != null && @from.dKind == ValueKind.STATIC_VALUE) { return(new IR_Literal { dType = to, data = exec(((IR_Literal)@from).data, 0) }); } return(new T { @from = @from, dType = to }); }
public static IR operation <T>(IR a, IR b, StaticExec exec) where T : IR_Operation, new() { if (exec != null && a.dKind == ValueKind.STATIC_VALUE && b.dKind == ValueKind.STATIC_VALUE) { return(new IR_Literal { dType = a.dType, data = exec(((IR_Literal)a).data, ((IR_Literal)a).data) }); } return(new T { a = a, b = b, dType = a.dType }); }
public override IR implicitCast(IR i, DataType to, IRList list) { if (!(to is DataType_Reference)) { return(null); } DataType_Struct iterator = this; while (iterator != null) { if (iterator == to) { return(list.Add(IR.cast <IR_Reinterpret>(i, to, null))); } } return(null); }
static void assign(AST_Node node) { var op = (AST_Operation)node; if ((op.a.result.dKind & ~ValueKind.ADDRES) != 0) { throw Jolly.addError(op.location, "Cannot assign to this"); } load(op.b); implicitCast(ref op.b.result, op.a.result.dType); //TODO: Assign to tuple containing names: someStruct.(a, b) = (0, 1); if (op.a.result.irType == NT.ALLOCATE) { ((IR_Allocate)op.a.result).initialized = true; } op.result = instructions.Add(IR.operation <IR_Assign>(op.a.result, op.b.result, null)); }
public override IR getMember(IR i, string name, IRList list) { int index; DataType_Struct iterator = this; while (iterator != null) { if (iterator.memberMap.TryGetValue(name, out index)) { IR _struct = i; if (iterator != this) { _struct = list.Add(IR.cast <IR_Reinterpret>(i, iterator, null)); } return(list.Add(IR.getMember(_struct, iterator.members[index], index + (iterator.inherits == null ? 0 : 1)))); } iterator = iterator.inherits; } return(null); }
static void basicOperator <T>(AST_Node node, Func <object, object, object> staticExec) where T : IR_Operation, new() { var op = (AST_Operation)node; load(op.a); load(op.b); IR aIR = op.a.result, bIR = op.b.result; if (aIR.dType != bIR.dType) { // TODO: This always tries to cast's the left type to the right type then right to left, // maybe this should be decided by the operator's left to right'ness. Cast cast; if (Lookup.implicitCast.get(aIR.dType, bIR.dType, out cast)) { aIR = cast(aIR, bIR.dType); } else if (Lookup.implicitCast.get(aIR.dType, bIR.dType, out cast)) { bIR = cast(bIR, aIR.dType); } else { throw Jolly.addError(op.location, "Cannot use operator on {0} and {1}".fill(aIR.dType, bIR.dType)); } } if ((aIR.dKind & bIR.dKind & ValueKind.STATIC_VALUE) != 0 && staticExec != null) { op.result = new IR_Literal { dType = aIR.dType, data = staticExec(((IR_Literal)aIR).data, ((IR_Literal)bIR).data) }; return; } op.result = instructions.Add(new T { a = aIR, b = bIR, dType = aIR.dType }); }
public virtual IR getMember(IR i, int index, IRList list) => null;
public virtual IR getMember(IR i, string name, IRList list) => null;
public static IR getMember(IR _struct, DataType result, int index) { return(new IR_GetMember { _struct = _struct, index = index, dType = result }); }
public virtual IR operator_assign(IR other) => null;
public virtual IR subscript(IR i, IR subscript, IRList list) => null;
public virtual IR implicitCast(IR i, DataType to, IRList list) => null;