public GenericInterPropertyWrapper(InterProperty property, IntermediateBuilder context, InterGenericType type) : base(property, context) { _type = type; _propertyType = _type.InstantiateGenericType(property.Type); }
public virtual void Bind(IntermediateBuilder context) { if (Type == null) { Type = context.ResolveType(TypeName); } }
public override void Bind(IntermediateBuilder context) { if (_ids.Length == 1) { string name = _ids[0]; foreach (var field in Owner.Owner.Fields) { if (field.Name != name) { continue; } IsStatic = field.IsStatic; _field = new FieldOrPropertySymbol(field.Symbol); _field.Bind(context); Type = _field.Type; return; } //TODO: Add properties } int i = 0; for (; i < _ids.Length; i++) { Type = context.ResolveType(new BasicTypeName(string.Join('.', _ids[0..(i + 1)]), _namespaceContext));
public virtual IEnumerable <IMethodWrapper> GetConstructors(IntermediateBuilder context) { foreach (var f in _type.GetConstructors()) { yield return(new ConstructorInfoWrapper(f, context)); } }
public virtual IEnumerable <IMethodWrapper> GetFunctions(IntermediateBuilder context) { foreach (var f in _type.GetMethods()) { yield return(new MethodInfoWrapper(f, context)); } }
public virtual IEnumerable <IFieldWrapper> GetFields(IntermediateBuilder context) { foreach (var f in _type.GetFields()) { yield return(new FieldInfoWrapper(f, context)); } }
public override IEnumerable <IMethodWrapper> GetFunctions(IntermediateBuilder context) { foreach (var f in typeof(string).GetMethods()) { yield return(new MethodInfoWrapper(f, context)); } }
public override IEnumerable <IFieldWrapper> GetFields(IntermediateBuilder context) { foreach (var f in _intertype.Fields) { yield return(new InterFieldWrapper(f)); } }
public virtual IEnumerable <IPropertyWrapper> GetProperties(IntermediateBuilder context) { foreach (var f in _type.GetProperties()) { yield return(new PropertyInfoWrapper(f, context)); } }
public override IEnumerable <IMethodWrapper> GetConstructors(IntermediateBuilder context) { foreach (var f in _intertype.Constructors) { yield return(new InterMethodWrapper(f, context)); } }
public override void Bind(IntermediateBuilder context) { _op1.Bind(context); _op2.Bind(context); CodeType wideType = _op1.Type.GetWiderType(_op2.Type); if (wideType is UserType) { var user = UserType.ToUserType(wideType); var overload = user.GetOperatorOverload(Op, context); if (overload != null) { _overload = new InterCall(overload, new CodeValue[] { _op1, _op2 }, true); _overload.SetOwner(Owner); _overload.Bind(context); return; } } if (_op1.Type != wideType) { _op1 = new ConvertedValue(_op1, wideType, Owner); _op1.Bind(context); } if (_op2.Type != wideType) { _op2 = new ConvertedValue(_op2, wideType, Owner); _op2.Bind(context); } }
public override IEnumerable <IPropertyWrapper> GetProperties(IntermediateBuilder context) { foreach (var f in _intertype.Properties) { yield return(new InterPropertyWrapper(f, context)); } }
public GenericInterMethodWrapper(InterMethod method, IntermediateBuilder context, InterGenericType type) : base(method, context) { _type = type; if (method.ReturnType is GenericParameterType) { var par = method.ReturnType as GenericParameterType; _returnType = new GenericParameterType(_type.GenericParameters[par.Index], par.Index); } else { _returnType = method.ReturnType; } _returnType = _type.InstantiateGenericType(method.ReturnType); _args = new CodeType[method.Arguments.Length]; for (int i = 0; i < _args.Length; i++) { var p = method.Arguments[i]; p.Bind(context); _args[i] = _type.InstantiateGenericType(p.Type); } }
public override void BindSubMembers(IntermediateBuilder builder) { foreach (var a in _baseArgs) { a.Bind(builder); } IMethodWrapper baseCon = builder.FindMostApplicableConstructor(_callThis ? new InterUserType(Owner) : UserType.ToUserType(Owner.BaseType), _baseArgs); AddInstruction(new InterCall(baseCon, _baseArgs, false, ThisPointer), 0); foreach (var field in Owner.Fields) { if (field.IsStatic || field.Initializer == null) { continue; } AddInstruction(new InterCopy(field.Symbol, field.Initializer), 0); } base.BindSubMembers(builder); }
public void Bind(IntermediateBuilder builder) { BaseType = builder.ResolveType(BaseTypeName); if (Constructors.Count == 0) { Constructors.Add(new InterConstructor(this)); } }
public override void Bind(IntermediateBuilder context) { base.Bind(context); _op1.Bind(context); _op2.Bind(context); _exp.Bind(context); }
public override void Bind(IntermediateBuilder context) { base.Bind(context); if (hasValue) { _exp.Bind(context); } }
private IEnumerable <IDamageSpecification> BuildAilmentDamage(IntermediateBuilder intermediateBuilder) { if (_damageSource is DamageSource source && source != DamageSource.OverTime) { return(intermediateBuilder.BuildAilmentDamage(source)); } return(Enums.GetValues <DamageSource>().SelectMany(intermediateBuilder.BuildAilmentDamage)); }
public override void Bind(IntermediateBuilder context) { base.Bind(context); if (_typeName == TypeName.Unknown) { return; } _type = context.ResolveType(_typeName); }
public virtual IEnumerable <IPropertyWrapper> GetIndexers(IntermediateBuilder context) { foreach (var f in _type.GetProperties()) { if (f.GetIndexParameters().Length > 0) { yield return(new PropertyInfoWrapper(f, context)); } } }
public override void Bind(IntermediateBuilder context) { if (Type != null) { return; } _op.Bind(context); Type = _op.GetResultType(); }
public override void Bind(IntermediateBuilder context) { _owner?.Bind(context); if (Type != null) { return; } UserType type = (_owner != null ? _owner.Type : _owningType) as UserType; if (_owningType == null) { _owningType = type; } IPropertyWrapper matchProperty = null; var t = type; while (matchProperty == null && t != CodeType.Object) { foreach (var f in t.GetProperties(context)) { if (f.Name == ID) { matchProperty = f; break; } } if (matchProperty == null) { t = t.GetBaseType(); } } _owningType = t; Debug.Assert(matchProperty != null); Type = matchProperty.Type; Property = matchProperty; if (Property.CanRead) { _get = new InterCall(Property.GetFunction, true, _owner); _get.SetOwner(context.CurrentMethod); } if (Property.CanWrite) { _set = new InterCall(Property.SetFunction, true, _owner); _set.SetOwner(context.CurrentMethod); } }
public override IMethodWrapper GetOperatorOverload(Operator op, IntermediateBuilder context) { if (op.Type == Operator.OperatorType.Add) { return(new MethodInfoWrapper(typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string) }), context)); } else { return(base.GetOperatorOverload(op, context)); } }
public override void Bind(IntermediateBuilder context) { if (_op == null) { base.Bind(context); } else { _op.Bind(context); Type = _op.Type; } }
public virtual IMethodWrapper GetOperatorOverload(Operator op, IntermediateBuilder context) { foreach (var w in GetFunctions(context)) { if (w.Name == op.GetOverloadName()) { return(w); } } return(null); }
public override void BindSubMembers(IntermediateBuilder builder) { foreach (var field in Owner.Fields) { if (!field.IsStatic) { continue; } AddInstruction(new InterCopy(field.Symbol, field.Initializer)); } base.BindSubMembers(builder); }
public override void Bind(IntermediateBuilder context) { _owner?.Bind(context); if (_owningTypeName != TypeName.Unknown) { _owningType = UserType.ToUserType(context.ResolveType(_owningTypeName)); } if (Field != null) { Type = Field.Type; return; } UserType type = (_owningType != null ? _owningType : _owner.Type) as UserType; if (_owningType == null) { _owningType = type; } IFieldWrapper matchField = null; var t = type; while (matchField == null && t != CodeType.Object) { foreach (var f in t.GetFields(context)) { if (f.Name == ID) { matchField = f; break; } } if (matchField == null) { t = t.GetBaseType(); } } _owningType = t; //Debug.Assert(matchField != null); if (matchField == null) { return; } Type = matchField.Type; Field = matchField; }
public void BindSubSubMembers(IntermediateBuilder builder) { Initializer.BindSubMembers(builder); foreach (var constructor in Constructors) { constructor.BindSubMembers(builder); } foreach (var method in Methods) { method.BindSubMembers(builder); } }
public override void Bind(IntermediateBuilder context) { _field.Bind(context); if (_field.Type == null) { IsProperty = true; _property.Bind(context); Type = _property.Type; } else { IsField = true; Type = _field.Type; } }
public override IMethodWrapper GetConversionMethod(IntermediateBuilder context, CodeValue from) { UserType user = UserType.ToUserType(from.Type); IMethodWrapper match = null; foreach (var f in user.GetFunctions(context)) { if (f.Name == "ToString") { match = f; break; } } Debug.Assert(match != null); return(match); }