public override void Prepare(Generator generator, TypeReference inferredType)
{
base.Prepare(generator, inferredType);
if (float_)
{
typeReference = floatType;
}
else
{
if ((inferredType != null) && byteType.Supports(inferredType) && (value >= byte.MinValue) && (value <= byte.MaxValue))
{
typeReference = byteType;
}
else if ((inferredType != null) && floatType.Supports(inferredType))
{
float_ = true;
typeReference = floatType;
floatVal = value;
}
else
{
typeReference = intType;
}
}
}
public override void Resolve(Generator generator)
{
base.Resolve(generator);
intType = generator.Resolver.ResolveDefinitionType(this, new TypeName(new Identifier(this, "pluk.base.Int")));
floatType = generator.Resolver.ResolveDefinitionType(this, new TypeName(new Identifier(this, "pluk.base.Float")));
byteType = generator.Resolver.ResolveDefinitionType(this, new TypeName(new Identifier(this, "pluk.base.Byte")));
}
public override void Resolve(Generator generator)
{
base.Resolve(generator);
parent.Resolve(generator);
argument.Resolve(generator);
boolType = generator.Resolver.ResolveDefinitionType(this, new TypeName(new Identifier(this, "pluk.base.Bool")));
}
public override void Resolve(Generator generator)
{
base.Resolve(generator);
if (!inferred)
{
Require.Unassigned(type);
type = generator.Resolver.ResolveDefinitionType(typeName, typeName);
}
}
public override bool Equals(object obj)
{
DefinitionTypeReference dtr = obj as DefinitionTypeReference;
if (dtr == null)
{
return(false);
}
return(dtr.TypeName.Equals(TypeName));
}
public override void Prepare(Generator generator, TypeReference inferredType)
{
base.Prepare(generator, inferredType);
TypeReference suggestion = inferredType;
if ((suggestion != null) && (suggestion.IsFunction))
{
suggestion = ((FunctionTypeReference)suggestion).ReturnType;
}
if ((suggestion != null) && (suggestion.IsNullable))
{
suggestion = ((NullableTypeReference)suggestion).Parent;
}
if (inferred)
{
type = suggestion as DefinitionTypeReference;
}
if (type == null)
{
if (suggestion == null)
{
throw new CompilerException(this, Resource.TypeOfExpressionUnclear);
}
else
{
throw new CompilerException(this, string.Format(Resource.Culture,
Resource.CanOnlyCreateNewInstanceOfClass, suggestion.TypeName.Data));
}
}
else
if (type.Definition.Modifiers.Abstract)
{
throw new CompilerException(this, string.Format(Resource.Culture,
Resource.CannotCreateInstanceOfAbstractClass, type.Definition.Name.Data));
}
constructor = type.Definition.FindConstructor(this, inferredType, generator.Resolver.CurrentDefinition);
}
public override void Resolve(Generator generator)
{
base.Resolve(generator);
literalStringType = generator.Resolver.ResolveDefinitionType(this, new TypeName(new Identifier(this, "pluk.base.StaticString")));
stringType = generator.Resolver.ResolveDefinitionType(this, new TypeName(new Identifier(this, "pluk.base.String")));
}
public void Resolve(Generator generator)
{
intType = generator.Resolver.ResolveDefinitionType(this, new TypeName(new Identifier(this, "pluk.base.Int")));
voidType = generator.Resolver.ResolveType(this, new TypeName(new Identifier(this, "void")));
}
public override void Resolve(Generator generator)
{
base.Resolve(generator);
expression.Resolve(generator);
exceptionType = generator.Resolver.ResolveDefinitionType(this, new TypeName(new Identifier(this, "pluk.base.Exception")));
}
public override void Generate(Generator generator)
{
base.Generate(generator);
if (target == null)
{
int slot = generator.Resolver.ResolveSlotOffset(name);
value.Generate(generator);
type.GenerateConversion(this, generator, value.TypeReference);
generator.Symbols.Source(generator.Assembler.Region.CurrentLocation, this);
generator.Resolver.WriteSlot(this, slot);
generator.Assembler.StoreVariable(slot);
}
else
{
target.Generate(generator);
TypeReference thisType = target.TypeReference;
bool staticRef = thisType is StaticTypeReference;
Definition thisDefinition;
if (staticRef)
{
thisDefinition = ((StaticTypeReference)thisType).Parent.Definition;
}
else
{
thisDefinition = ((DefinitionTypeReference)thisType).Definition;
}
if (thisDefinition.HasField(name, staticRef))
{
Field field = thisDefinition.GetField(name, staticRef);
if (!field.GetModifiers.Static)
{
generator.Assembler.PushValue();
int fieldOffset = thisDefinition.GetFieldOffset(this, name, generator.Resolver.CurrentDefinition, true);
if (target is IIncompleteSlotAssignment)
{
if (((IIncompleteSlotAssignment)target).IsIncompleteSlot())
{
generator.Resolver.AssignField(field);
}
}
value.Generate(generator);
type.GenerateConversion(value, generator, value.TypeReference);
generator.Symbols.Source(generator.Assembler.Region.CurrentLocation, this);
TypeReference slot = field.TypeReference;
if (slot.IsNullable)
{
slot = ((NullableTypeReference)slot).Parent;
}
DefinitionTypeReference dtr = slot as DefinitionTypeReference;
if ((dtr != null) && (!dtr.Definition.GarbageCollectable))
{
generator.Assembler.StoreInFieldOfSlotNoTouch(fieldOffset);
}
else
{
generator.Assembler.StoreInFieldOfSlot(generator.Toucher, fieldOffset);
}
}
else
{
generator.Assembler.PushValue();
if (target is IIncompleteSlotAssignment)
{
if (((IIncompleteSlotAssignment)target).IsIncompleteSlot())
{
generator.Resolver.AssignField(field);
}
}
value.Generate(generator);
type.GenerateConversion(value, generator, value.TypeReference);
generator.Symbols.Source(generator.Assembler.Region.CurrentLocation, this);
generator.Assembler.Store(field.StaticSlot);
}
}
else
{
int propertySlot = thisDefinition.GetSetPropertyOffset(this, name, generator.Resolver.CurrentDefinition);
generator.Symbols.Source(generator.Assembler.Region.CurrentLocation, this);
generator.Assembler.FetchMethod(propertySlot);
generator.Assembler.PushValue();
value.Generate(generator);
type.GenerateConversion(value, generator, value.TypeReference);
generator.Assembler.PushValue();
Placeholder retSite = generator.Assembler.CallFromStack(1);
generator.AddCallTraceEntry(retSite, this, generator.Resolver.CurrentDefinition.Name.DataModifierLess, generator.Resolver.CurrentFieldName);
}
}
}
public StaticTypeReference(ILocation location, DefinitionTypeReference parent)
: base(location)
{
Require.Assigned(parent);
this.parent = parent;
}
