public static void Serialize(this SerializingContainer2 sc, ref NameReference name)
{
if (sc.IsLoading)
{
name = sc.ms.ReadNameReference(sc.Pcc);
}
else
{
sc.ms.Writer.WriteNameReference(name, sc.Pcc);
}
}
protected override void Serialize(SerializingContainer2 sc)
{
if (sc.IsLoading)
{
IsIndexed = !sc.ms.ReadBoolInt();
sc.ms.Skip(-4);
}
else
{
//If there are no cells, IsIndexed has to be true, since there is no way to differentiate between
//a cell count of zero and the extra zero that is present when IsIndexed is true.
IsIndexed |= Cells.IsEmpty();
}
if (IsIndexed)
{
sc.SerializeConstInt(0);
}
int cellIndex = 0;
//If IsIndexed, the index needs to be read and written, so just use the normal Serialize for ints.
//If it's not indexed, we don't need to write anything, but the Dictionary still needs to be populated with a value
sc.Serialize(ref Cells, IsIndexed ? (SCExt.SerializeDelegate <int>)SCExt.Serialize : (SerializingContainer2 sc2, ref int idx) => idx = cellIndex++, SCExt.Serialize);
if (!IsIndexed)
{
sc.SerializeConstInt(0);
}
int count = ColumnNames?.Count ?? 0;
sc.Serialize(ref count);
if (sc.IsLoading)
{
int index = 0;
ColumnNames = new List <NameReference>(count);
for (int i = 0; i < count; i++)
{
NameReference tmp = default;
sc.Serialize(ref tmp);
sc.Serialize(ref index);
ColumnNames.Add(tmp);
}
}
else
{
for (int i = 0; i < count; i++)
{
NameReference tmp = ColumnNames[i];
sc.Serialize(ref tmp);
sc.Serialize(ref i);
}
}
}
public ConstructorCall Init(string member, IExpression initValue, out Assignment assignment)
{
if (this.build != null)
{
throw new InvalidOperationException();
}
assignment = Assignment.CreateInitialization(NameReference.Create(varReference, member), initValue);
this.objectInitialization.Add(assignment);
return(this);
}
public FunctionCall ConvertIndexerIntoSetter(IExpression rhs)
{
this.ChildrenNodes.WhereType <IOwnedNode>().ForEach(it => it.DetachFrom(this));
NameReference idx_getter = this.Name;
idx_getter.Prefix.DetachFrom(idx_getter);
return(new FunctionCall(CallMode.Indexer,
NameReference.Create(this.Name.Prefix, NameFactory.PropertySetter),
this.UserArguments.Concat(FunctionArgument.Create(NameFactory.PropertySetterValueParameter, rhs)),
requestedOutcomeType: null));
}
public IInterpreter InitializationWithOptionalAssignment()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DebugThrowOnError = true,
DiscardingAnyExpressionDuringTests = true,
}.SetMutability(mutability));
var root_ns = env.Root;
// this test is a bit tougher than regular opt.assignment, because variables will be
// initialized for the first time with this assigment
root_ns.AddBuilder(FunctionBuilder.Create("main",
ExpressionReadMode.OptionalUse,
NameFactory.Nat8NameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("acc", null, Nat8Literal.Create("0"), env.Options.ReassignableModifier()),
VariableDeclaration.CreateStatement("x", null,
ExpressionFactory.OptionOf(NameFactory.Nat8NameReference(), Nat8Literal.Create("3"))),
VariableDeclaration.CreateStatement("z", null,
ExpressionFactory.OptionOf(NameFactory.Nat8NameReference(), Nat8Literal.Create("5"))),
VariableDeclaration.CreateStatement("a", NameFactory.Nat8NameReference(), null, env.Options.ReassignableModifier()),
VariableDeclaration.CreateStatement("b", NameFactory.Nat8NameReference(), null, env.Options.ReassignableModifier()),
IfBranch.CreateIf(ExpressionFactory.OptionalAssignment(
new[] { NameReference.Create("a"), NameReference.Create("b") },
new[] { NameReference.Create("x"), NameReference.Create("z") }),
new[] {
// assign tracker should recognize the variable is initialized
ExpressionFactory.IncBy("acc", NameReference.Create("a")),
},
// making else branch a dead one
IfBranch.CreateElse(ExpressionFactory.GenericThrow())),
// assign tracker should recognize the variable is initialized (because `else` branch of above `if` is dead)
ExpressionFactory.IncBy("acc", NameReference.Create("b")),
Return.Create(NameReference.Create("acc"))
)));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual((byte)8, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter MinLimitVariadicFunctionWithSpread()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"sum",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
// let i0 = n.at(0)
VariableDeclaration.CreateStatement("i0", null, FunctionCall.Create(NameReference.Create("n", NameFactory.PropertyIndexerName),
FunctionArgument.Create(NatLiteral.Create("0")))),
// let i1 = n.at(1)
VariableDeclaration.CreateStatement("i1", null, FunctionCall.Create(NameReference.Create("n", NameFactory.PropertyIndexerName),
FunctionArgument.Create(NatLiteral.Create("1")))),
// return i0+i1
Return.Create(ExpressionFactory.Add("i0", "i1"))
}))
.Parameters(FunctionParameter.Create("n", NameFactory.Int64NameReference(), Variadic.Create(2), null, isNameRequired: false)));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("x", null,
ExpressionFactory.HeapConstructor(NameFactory.ChunkNameReference(NameFactory.Int64NameReference()),
FunctionArgument.Create(NatLiteral.Create("2"))),
env.Options.ReassignableModifier()),
Assignment.CreateStatement(FunctionCall.Indexer(NameReference.Create("x"), FunctionArgument.Create(NatLiteral.Create("0"))),
Int64Literal.Create("-6")),
Assignment.CreateStatement(FunctionCall.Indexer(NameReference.Create("x"), FunctionArgument.Create(NatLiteral.Create("1"))),
Int64Literal.Create("8")),
Return.Create(FunctionCall.Create(NameReference.Create("sum"),
FunctionArgument.Create(Spread.Create(NameReference.Create("x")))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter CallingTraitMethod()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DebugThrowOnError = true,
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.CreateInterface("ISay")
.With(FunctionBuilder.CreateDeclaration("say", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference())));
root_ns.AddBuilder(TypeBuilder.Create("Say")
.With(FunctionBuilder.Create("say", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("2"))
}))
.SetModifier(EntityModifier.Override))
.Parents("ISay"));
root_ns.AddBuilder(TypeBuilder.Create("Greeter", "T"));
root_ns.AddBuilder(TypeBuilder.Create("Greeter", "X")
.SetModifier(EntityModifier.Trait)
.Constraints(ConstraintBuilder.Create("X").Inherits("ISay"))
.With(FunctionBuilder.Create("hello", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(
Return.Create(FunctionCall.Create(NameReference.Create("s", "say")))
))
.Parameters(FunctionParameter.Create("s", NameFactory.ReferenceNameReference("X")))));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("g", null,
ExpressionFactory.StackConstructor(NameReference.Create("Greeter", NameReference.Create("Say")))),
VariableDeclaration.CreateStatement("y", null, ExpressionFactory.StackConstructor("Say")),
Return.Create(FunctionCall.Create(NameReference.Create("g", "hello"), NameReference.Create("y")))
)));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public override void Evaluate(ComputationContext ctx)
{
if (this.Evaluation == null)
{
this.Evaluation = ctx.Env.UnitEvaluation;
NameReference req_typename = NameFactory.PointerNameReference(NameFactory.ExceptionNameReference());
IEntityInstance eval_typename = req_typename.Evaluated(ctx, EvaluationCall.AdHocCrossJump);
this.DataTransfer(ctx, ref this.expr, eval_typename);
}
}
internal NameReference GetThisNameReference()
{
if (this.thisNameReference == null)
{
this.thisNameReference = NameReference.Create(null, NameFactory.ThisVariableName, null,
//this,
this.MetaThisParameter.InstanceOf, isLocal: true);
this.thisNameReference.AttachTo(this);
}
return(this.thisNameReference);
}
public IInterpreter InheritingEnums()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.CreateEnum("Weekend")
.With(EnumCaseBuilder.Create("Sat", "Sun"))
.SetModifier(EntityModifier.Base));
root_ns.AddBuilder(TypeBuilder.CreateEnum("First")
.With(EnumCaseBuilder.Create("Mon"))
.Parents("Weekend"));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.NatNameReference(),
Block.CreateStatement(new IExpression[] {
// let a Weekend = First.Sat
VariableDeclaration.CreateStatement("a", NameReference.Create("Weekend"),
// please note we only refer to "Sat" through "First", the type is still "Weekend"
NameReference.Create("First", "Sat")),
// var b First = Weekend.Sun
VariableDeclaration.CreateStatement("b", NameReference.Create("First"), NameReference.Create("Weekend", "Sun"),
env.Options.ReassignableModifier()),
// b = First.Mon
Assignment.CreateStatement(NameReference.Create("b"), NameReference.Create("First", "Mon")),
// let x = a to Nat; // 0
VariableDeclaration.CreateStatement("x", null, FunctionCall.ConvCall(NameReference.Create("a"),
NameFactory.NatNameReference())),
// let y = b to Nat; // 2
VariableDeclaration.CreateStatement("y", null, FunctionCall.ConvCall(NameReference.Create("b"),
NameFactory.NatNameReference())),
// return x + y
Return.Create(ExpressionFactory.Add(NameReference.Create("x"), NameReference.Create("y")))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2UL, result.RetValue.PlainValue);
}
return(interpreter);
}
public NameReference ReadNameRef()
{
if (Position + 8 > Size)
{
return(new NameReference());
}
var NameRef = new NameReference();
NameRef.Index = BitConverter.ToInt32(_data, _position(4));
NameRef.ModNumber = BitConverter.ToInt32(_data, _position(4)) - 1;
return(NameRef);
}
public static T TryGetTargetEntity <T>(this IExpression expr, out NameReference nameReference)
where T : class, IEntity
{
nameReference = expr as NameReference;
if (nameReference != null)
{
return(nameReference.Binding.Match.Instance.Target as T);
}
else
{
return(null);
}
}
public IErrorReporter ErrorAbusingForcedConst()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create("Stone"));
root_ns.AddBuilder(TypeBuilder.Create("Mutator", "M")
.With(FunctionBuilder.Create("violate", NameFactory.UnitNameReference(), Block.CreateStatement())
.SetModifier(EntityModifier.Mutable))
.SetModifier(EntityModifier.Mutable));
root_ns.AddBuilder(TypeBuilder.Create("Mangler")
.SetModifier(EntityModifier.Mutable)
.With(VariableDeclaration.CreateStatement("m",
NameFactory.PointerNameReference(NameReference.Create("Mutator", NameReference.Create("Stone"))),
Undef.Create(),
EntityModifier.Public | env.Options.ReassignableModifier()))
);
FunctionCall mut_call = FunctionCall.Create(NameReference.CreateThised("f", "m", NameFactory.MutableName("violate")));
IExpression assignment = Assignment.CreateStatement(NameReference.CreateThised("f", "m"), Undef.Create());
root_ns.AddBuilder(TypeBuilder.Create("Keeper")
.With(VariableDeclaration.CreateStatement("f",
NameFactory.PointerNameReference(NameReference.Create(TypeMutability.ForceConst, "Mangler")),
Undef.Create(),
EntityModifier.Public))
.With(FunctionBuilder.Create("testing", NameFactory.UnitNameReference(),
Block.CreateStatement(
mut_call,
assignment
))));
resolver = NameResolver.Create(env);
Assert.AreEqual(2, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AlteringNonMutableInstance, mut_call));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AlteringNonMutableInstance, assignment));
}
return(resolver);
}
public IErrorReporter ErrorMatchingIntersection()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowProtocols = true,
DiscardingAnyExpressionDuringTests = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.CreateInterface("IGetPos")
.With(FunctionBuilder.CreateDeclaration("getSome", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference())));
root_ns.AddBuilder(TypeBuilder.CreateInterface("IGetNeg")
.With(FunctionBuilder.CreateDeclaration("getMore", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference())));
root_ns.AddBuilder(TypeBuilder.Create("GetAll")
.With(FunctionBuilder.Create("getSome", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("3"))
})))
.With(FunctionBuilder.Create("getMore", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("-1"))
}))));
NameReferenceIntersection intersection = NameReferenceIntersection.Create(
NameFactory.PointerNameReference(NameReference.Create("IGetNeg")),
NameFactory.PointerNameReference(NameReference.Create("IGetPos")));
IExpression init_value = ExpressionFactory.HeapConstructor("GetAll");
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.CannotBeRead,
NameFactory.UnitNameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("a", intersection, init_value),
ExpressionFactory.Readout("a")
})));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, init_value));
}
return(resolver);
}
public IInterpreter VirtualCall()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create("MyBase")
.SetModifier(EntityModifier.Base)
.With(FunctionBuilder.Create(
"bar",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("33"))
}))
.SetModifier(EntityModifier.Base)));
TypeDefinition type_impl = root_ns.AddBuilder(TypeBuilder.Create("SomeChild")
.With(FunctionBuilder.Create("bar",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("2"))
}))
.SetModifier(EntityModifier.Override | EntityModifier.UnchainBase))
.Parents(NameReference.Create("MyBase")));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("i", NameFactory.PointerNameReference(NameReference.Create("MyBase")),
ExpressionFactory.HeapConstructor(NameReference.Create("SomeChild"))),
Return.Create(FunctionCall.Create(NameReference.Create("i", "bar")))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IErrorReporter ErrorEscapingReferenceWithAttachmentObject()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true
}
.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create("Keeper")
.With(VariableDeclaration.CreateStatement("world",
NameFactory.PointerNameReference(NameFactory.IntNameReference()), Undef.Create(), EntityModifier.Public))
.With(FunctionBuilder.CreateInitConstructor(Block.CreateStatement(
Assignment.CreateStatement(NameReference.CreateThised("world"), NameReference.Create("in_value"))
))
.Parameters(FunctionParameter.Create("in_value", NameFactory.PointerNameReference(NameFactory.IntNameReference())))));
Assignment assign = Assignment.CreateStatement(NameReference.Create("attach"),
ExpressionFactory.StackConstructor("Keeper", NameReference.Create("i"))).Cast <Assignment>();
FunctionDefinition func = root_ns.AddBuilder(FunctionBuilder.Create("notimportant",
ExpressionReadMode.OptionalUse,
NameFactory.UnitNameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("attach", NameReference.Create("Keeper"),
Undef.Create(), EntityModifier.Reassignable),
Block.CreateStatement(
VariableDeclaration.CreateStatement("i", NameFactory.ReferenceNameReference(NameFactory.IntNameReference()),
IntLiteral.Create("0")),
// cannot execute this assignment because the reference would move from here to outer scope
// just wrapped in `Keeper` instance
// please note this `Keeper` instance is attached to `i`
// (triggered by conversion reference->pointer in constructor), so it cannot outlive it
assign,
ExpressionFactory.Readout("attach")
)
)));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.EscapingReference, assign.RhsValue));
}
return(resolver);
}
public IErrorReporter ErrorCallingTraitMethodOnHost()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.CreateInterface("ISay")
.With(FunctionBuilder.CreateDeclaration("say", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference())));
root_ns.AddBuilder(TypeBuilder.Create("NoSay"));
// this function is located in trait, thus unavailable
FunctionCall int_call = FunctionCall.Create(NameReference.CreateThised("hello"));
root_ns.AddBuilder(TypeBuilder.Create("Greeter", "T")
.With(FunctionBuilder.Create("reaching", NameFactory.UnitNameReference(),
Block.CreateStatement(int_call))));
root_ns.AddBuilder(TypeBuilder.Create("Greeter", "X")
.SetModifier(EntityModifier.Trait)
.Constraints(ConstraintBuilder.Create("X").Inherits("ISay"))
.With(FunctionBuilder.Create("hello", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(
Return.Create(Int64Literal.Create("7"))
))));
FunctionCall ext_call = FunctionCall.Create(NameReference.Create("g", "hello"));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("g", null,
ExpressionFactory.StackConstructor(NameReference.Create("Greeter", NameReference.Create("NoSay")))),
Return.Create(ext_call)
)));
resolver = NameResolver.Create(env);
Assert.AreEqual(2, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ReferenceNotFound, ext_call.Name));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ReferenceNotFound, int_call.Name));
}
return(resolver);
}
public IInterpreter NoExtrasWithCopyConstructor()
{
// nothing is written in stone, but for now let's treat assignment in declaration as assignment
// not copy constructor (as in C++)
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create("Point")
.SetModifier(EntityModifier.Mutable)
.With(FunctionBuilder.CreateInitConstructor(Block.CreateStatement()))
// copy-constructor
.With(FunctionBuilder.CreateInitConstructor(Block.CreateStatement(
Assignment.CreateStatement(NameReference.CreateThised("x"), Nat8Literal.Create("66"))
)).Parameters(FunctionParameter.Create("p", NameFactory.ReferenceNameReference("Point"),
ExpressionReadMode.CannotBeRead)))
.With(PropertyBuilder.Create(env.Options, "x", () => NameFactory.Nat8NameReference())
.With(VariableDeclaration.CreateStatement("f", NameFactory.Nat8NameReference(), null,
env.Options.ReassignableModifier()))
.WithGetter(Block.CreateStatement(Return.Create(NameReference.CreateThised("f"))))
.WithSetter(Block.CreateStatement(Assignment.CreateStatement(NameReference.CreateThised("f"),
ExpressionFactory.Mul(NameFactory.PropertySetterValueReference(), Nat8Literal.Create("2")))))));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Nat8NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("p", null,
ConstructorCall.StackConstructor(NameReference.Create("Point"))
.Init("x", Nat8Literal.Create("7"))
.Build()),
// bit-copy of the object, there is no calling copy-constructor here
VariableDeclaration.CreateStatement("r", null, NameReference.Create("p")),
Return.Create(NameReference.Create(NameReference.Create("r"), "x"))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual((byte)14, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter OverridingMethodWithIndexerGetter()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.CreateInterface("IProvider")
.With(FunctionBuilder.CreateDeclaration(NameFactory.PropertyIndexerName, ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference())
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference()))));
root_ns.AddBuilder(TypeBuilder.Create("Middle")
.Parents("IProvider")
.SetModifier(EntityModifier.Base)
.With(FunctionBuilder.Create(NameFactory.PropertyIndexerName, ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(Return.Create(Int64Literal.Create("500"))))
.SetModifier(EntityModifier.Override | EntityModifier.UnchainBase)
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead))));
root_ns.AddBuilder(TypeBuilder.Create("Last")
.Parents("Middle")
.SetModifier(EntityModifier.Base)
.With(PropertyBuilder.CreateIndexer(env.Options, NameFactory.Int64NameReference())
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead))
.With(PropertyMemberBuilder.CreateIndexerGetter(Block.CreateStatement(Return.Create(Int64Literal.Create("2"))))
.Modifier(EntityModifier.Override | EntityModifier.UnchainBase))));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("p", NameFactory.PointerNameReference("IProvider"),
ExpressionFactory.HeapConstructor("Last")),
Return.Create(FunctionCall.Create(NameReference.Create("p", NameFactory.PropertyIndexerName),
FunctionArgument.Create(Int64Literal.Create("18"))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IErrorReporter ErrorEscapingReceivedReferenceFromFunction()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true
}
.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create("selector",
ExpressionReadMode.ReadRequired,
NameFactory.ReferenceNameReference(NameFactory.IntNameReference()),
Block.CreateStatement(
ExpressionFactory.Readout("b"),
Return.Create(NameReference.Create("a"))
))
.Parameters(
FunctionParameter.Create("a", NameFactory.ReferenceNameReference(NameFactory.IntNameReference())),
FunctionParameter.Create("b", NameFactory.ReferenceNameReference(NameFactory.IntNameReference()))));
FunctionCall call = FunctionCall.Create("selector", IntLiteral.Create("2"), IntLiteral.Create("3"));
FunctionDefinition func = root_ns.AddBuilder(FunctionBuilder.Create("notimportant",
ExpressionReadMode.OptionalUse,
NameFactory.UnitNameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("h", NameFactory.ReferenceNameReference(NameFactory.IntNameReference()),
IntLiteral.Create("0"), EntityModifier.Reassignable),
Block.CreateStatement(
// error: the most alive reference the function can return is limited to this scope
// so it cannot be assigned to outer-scope variable
Assignment.CreateStatement(NameReference.Create("h"), call)
),
ExpressionFactory.Readout("h")
)));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.EscapingReference, call));
}
return(resolver);
}
public IErrorReporter ErrorHasConstraint()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true, AllowProtocols = true
}.SetMutability(mutability));
var root_ns = env.Root;
FunctionDefinition func_constraint = FunctionBuilder.CreateDeclaration("getMe",
ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference());
// this function accepts any parameter where parameter type has function "getMe"
FunctionDefinition constrained_func = root_ns.AddBuilder(FunctionBuilder.Create("proxy",
TemplateParametersBuffer.Create().Add("T").Values,
ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(), Block.CreateStatement(new[] {
Return.Create(FunctionCall.Create(NameReference.Create("t", "getMe")))
}))
.Constraints(ConstraintBuilder.Create("T").Has(func_constraint))
.Parameters(FunctionParameter.Create("t", NameFactory.PointerNameReference("T"))));
// this type does NOT have function "getMe"
TypeDefinition type_impl = root_ns.AddBuilder(TypeBuilder.Create("YMan")
.With(FunctionBuilder.Create("missing",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("2"))
}))));
FunctionCall call = FunctionCall.Create(NameReference.Create("proxy"), FunctionArgument.Create(NameReference.Create("y_man")));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("y_man", null, ExpressionFactory.HeapConstructor(NameReference.Create("YMan"))),
Return.Create(call)
})));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ViolatedHasFunctionConstraint, call.Callee));
}
return(resolver);
}
public IErrorReporter InternalDirectTranslationTables()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
MiniEnvironment = true
}.SetMutability(mutability));
var root_ns = env.Root;
const string parent_typename = "Oldman";
const string parent_elemtype = "PT";
FunctionDefinition base_func = FunctionBuilder.CreateDeclaration("getMe",
ExpressionReadMode.CannotBeRead,
NameFactory.ReferenceNameReference(parent_elemtype));
TypeDefinition parent = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(parent_typename,
TemplateParametersBuffer.Create(parent_elemtype).Values))
.SetModifier(EntityModifier.Abstract)
.With(base_func));
const string child_typename = "Kid";
const string child_elemtype = "CT";
FunctionDefinition deriv_func = FunctionBuilder.Create("getMe",
ExpressionReadMode.CannotBeRead,
NameFactory.ReferenceNameReference(child_elemtype),
Block.CreateStatement(Return.Create(Undef.Create())))
.SetModifier(EntityModifier.Override);
TypeDefinition child = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(child_typename,
TemplateParametersBuffer.Create(child_elemtype).Values))
.Parents(NameReference.Create(parent_typename, NameReference.Create(child_elemtype)))
.With(deriv_func));
resolver = NameResolver.Create(env);
// testing here template translation
EntityInstance child_ancestor = child.Inheritance.OrderedAncestorsWithoutObject.Single();
IEntityInstance translated = base_func.ResultTypeName.Evaluation.Components.TranslateThrough(child_ancestor);
// we have single function overriden, so it is easy to debug and spot if something goes wrong
bool result = FunctionDefinitionExtension.IsDerivedOf(resolver.Context, deriv_func, base_func, child_ancestor);
Assert.IsTrue(result);
}
return(resolver);
}
public static bool IsValue(this IExpression @this, IOptions options)
{
NameReference nameReference = (@this as NameReference);
// todo: make it nice, such exception is ugly
if (nameReference?.Name == NameFactory.BaseVariableName)
{
return(true);
}
IEntity entity = nameReference?.Binding.Match.Instance.Target;
bool result = (entity == null || (!entity.IsType() && !entity.IsNamespace()));
return(result);
}
public IErrorReporter ErrorAccessNotGranted()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability));
var root_ns = env.Root;
NameReference forbidden_access = NameReference.CreateThised("x");
VariableDeclaration decl = VariableBuilder.CreateStatement("y", NameFactory.Int64NameReference(), null)
.Modifier(EntityModifier.Public | env.Options.ReassignableModifier())
.GrantAccess("twin");
root_ns.AddBuilder(TypeBuilder.Create("Point")
.SetModifier(EntityModifier.Mutable)
.With(FunctionBuilder.Create("friendly",
NameFactory.UnitNameReference(),
Block.CreateStatement( ExpressionFactory.Readout(NameFactory.ThisVariableName, "x"))))
.With(FunctionBuilder.Create("foe",
NameFactory.UnitNameReference(),
Block.CreateStatement( ExpressionFactory.Readout(forbidden_access))))
.With(FunctionBuilder.Create("twin",
NameFactory.UnitNameReference(),
Block.CreateStatement()))
.With(FunctionBuilder.Create("twin",
NameFactory.UnitNameReference(),
Block.CreateStatement(Return.Create(NameReference.Create("p"))))
.Parameters(FunctionParameter.Create("p", NameFactory.UnitNameReference())))
.With(VariableBuilder.CreateStatement("x", NameFactory.Int64NameReference(), null)
.Modifier(EntityModifier.Private | env.Options.ReassignableModifier())
.GrantAccess("friendly"))
.With(decl));
resolver = NameResolver.Create(env);
Assert.AreEqual(3, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AccessForbidden, forbidden_access));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AmbiguousReference, decl.AccessGrants.Single()));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AccessGrantsOnExposedMember, decl.AccessGrants.Single()));
}
return resolver;
}
public IErrorReporter ErrorViolatingConstConstraint()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create("Bar")
.SetModifier(EntityModifier.Mutable));
root_ns.AddBuilder(TypeBuilder.Create("Foo"));
// we build type Point<T> with enforced "const" on T -- meaning we can pass only trully immutable types
// as T
VariableDeclaration field = VariableDeclaration.CreateStatement("m", NameReference.Create("T"),
Undef.Create(), modifier: EntityModifier.Public);
TypeDefinition point_type = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Point",
TemplateParametersBuffer.Create().Add("T").Values))
.Constraints(ConstraintBuilder.Create("T")
.SetModifier(EntityModifier.Const))
.With(field));
// Bar is mutable type, so we cannot construct Point<Bar> since Point requires immutable type
NameReference wrong_type = NameReference.Create("Point", NameReference.Create("Bar"));
var func_def = root_ns.AddBuilder(FunctionBuilder.Create(
"foo", null,
ExpressionReadMode.OptionalUse,
NameFactory.UnitNameReference(),
Block.CreateStatement(new[] {
VariableDeclaration.CreateStatement("x", NameReference.Create("Point", NameReference.Create("Foo")), Undef.Create()),
VariableDeclaration.CreateStatement("y", wrong_type, Undef.Create()),
ExpressionFactory.Readout("x"),
ExpressionFactory.Readout("y"),
})));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ViolatedMutabilityConstraint, wrong_type));
}
return(resolver);
}
protected override void Serialize(SerializingContainer2 sc)
{
if (sc.Game == MEGame.ME2)
{
int dummy = 0;
sc.Serialize(ref dummy);
sc.Serialize(ref dummy);
sc.Serialize(ref dummy);
sc.SerializeFileOffset();
}
if (sc.Game == MEGame.UDK)
{
if (sc.IsSaving && RawAnimationData is null)
{
DecompressAnimationData();
}
sc.Serialize(ref RawAnimationData, SCExt.Serialize);
}
if (sc.IsLoading)
{
compressedDataSource = sc.Game;
NumFrames = Export.GetProperty <IntProperty>("NumFrames")?.Value ?? 0;
RateScale = Export.GetProperty <FloatProperty>("RateScale")?.Value ?? 1f;
SequenceLength = Export.GetProperty <FloatProperty>("SequenceLength")?.Value ?? 0;
Name = Export.GetProperty <NameProperty>("SequenceName")?.Value ?? Export.ObjectName;
TrackOffsets = Export.GetProperty <ArrayProperty <IntProperty> >("CompressedTrackOffsets").Select(i => i.Value).ToArray();
if (compressedDataSource == MEGame.UDK)
{
Bones = ((ExportEntry)Export.Parent)?.GetProperty <ArrayProperty <NameProperty> >("TrackBoneNames")?.Select(np => $"{np}").ToList();
}
else
{
var animsetData = Export.GetProperty <ObjectProperty>("m_pBioAnimSetData");
//In ME2, BioAnimSetData can sometimes be in a different package.
Bones = animsetData != null && Export.FileRef.IsUExport(animsetData.Value)
? Export.FileRef.GetUExport(animsetData.Value)?.GetProperty <ArrayProperty <NameProperty> >("TrackBoneNames")?.Select(np => $"{np}").ToList()
: null;
}
Bones ??= Enumerable.Repeat("???", TrackOffsets.Length / 4).ToList();
Enum.TryParse(Export.GetProperty <EnumProperty>("KeyEncodingFormat")?.Value.Name, out keyEncoding);
Enum.TryParse(Export.GetProperty <EnumProperty>("RotationCompressionFormat")?.Value.Name, out rotCompression);
Enum.TryParse(Export.GetProperty <EnumProperty>("TranslationCompressionFormat")?.Value.Name, out posCompression);
}
sc.Serialize(ref CompressedAnimationData, SCExt.Serialize);
}
public IInterpreter TypeUnion()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowProtocols = true,
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create("GetPos")
.With(FunctionBuilder.Create("getSome", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("3"))
}))));
root_ns.AddBuilder(TypeBuilder.Create("GetNeg")
.With(FunctionBuilder.Create("getSome", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("-1"))
}))));
NameReferenceUnion union = NameReferenceUnion.Create(NameFactory.PointerNameReference(NameReference.Create("GetNeg")),
NameFactory.PointerNameReference(NameReference.Create("GetPos")));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("a", union, Undef.Create(), env.Options.ReassignableModifier()),
VariableDeclaration.CreateStatement("b", union, Undef.Create(), env.Options.ReassignableModifier()),
Assignment.CreateStatement(NameReference.Create("a"), ExpressionFactory.HeapConstructor("GetPos")),
Assignment.CreateStatement(NameReference.Create("b"), ExpressionFactory.HeapConstructor("GetNeg")),
VariableDeclaration.CreateStatement("x", null, FunctionCall.Create(NameReference.Create("a", "getSome"))),
VariableDeclaration.CreateStatement("y", null, FunctionCall.Create(NameReference.Create("b", "getSome"))),
Return.Create(ExpressionFactory.Add(NameReference.Create("x"), NameReference.Create("y")))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter HasConstraintWithValue()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true,
AllowProtocols = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
FunctionDefinition func_constraint = FunctionBuilder.CreateDeclaration("getMe",
ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference());
root_ns.AddBuilder(FunctionBuilder.Create("proxy",
TemplateParametersBuffer.Create().Add("T").Values,
ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(), Block.CreateStatement(new[] {
Return.Create(FunctionCall.Create(NameReference.Create("t", "getMe")))
}))
.Constraints(ConstraintBuilder.Create("T").Has(func_constraint))
.Parameters(FunctionParameter.Create("t", NameReference.Create("T"))));
TypeDefinition type_impl = root_ns.AddBuilder(TypeBuilder.Create("Y")
.With(FunctionBuilder.Create("getMe",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("2"))
}))));
FunctionCall call = FunctionCall.Create(NameReference.Create("proxy"), FunctionArgument.Create(NameReference.Create("y")));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("y", null, ExpressionFactory.StackConstructor(NameReference.Create("Y"))),
Return.Create(call)
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public static PropertyBuilder CreateAutoFull(IOptions options, string name, NameReference typename,
out PropertyMembers members, IExpression initValue = null)
{
PropertyBuilder builder = PropertyBuilder.Create(options, name, () => typename)
.WithAutoField(initValue, options.ReassignableModifier(), out VariableDeclaration field)
.WithAutoGetter(out FunctionDefinition getter)
.WithAutoSetter(out FunctionDefinition setter);
members = new PropertyMembers()
{
Field = field, Getter = getter, Setter = setter
};
return(builder);
}
public static IExpression Tuple(params IExpression[] arguments)
{
if (arguments.Length == 0)
{
throw new System.Exception();
}
else if (arguments.Length == 1)
{
return(arguments.Single());
}
else
{
return(FunctionCall.Create(NameReference.Create(NameFactory.TupleFactoryReference(), NameFactory.CreateFunctionName), arguments));
}
}
public override bool Deserialize()
{
var result = base.Deserialize();
var ArrayInfo = Data.ReadInt32();
ArraySize = (UInt16)(ArrayInfo & 0x0000FFFFU);
ArrayElementSize = (UInt16)(ArrayInfo >> 16);
PropertyFlags = (PropertyFlags)Data.ReadUInt64();
if (PropertyFlags.HasFlag(PropertyFlags.Net))
ReplicateOffset = Data.ReadUInt16();
_CategoryNameRef = Data.ReadNameRef();
Category = PCC.GetName(_CategoryNameRef);
ReplicateOffset = Data.ReadUInt16(); // TODO: verify, see code
ReplicateIndex = Data.ReadUInt16();
return result;
}
public bool Deserialize()
{
NameRef = Data.ReadNameRef();
Name = PCC.GetName(NameRef);
if (String.Equals(Name, "None", StringComparison.OrdinalIgnoreCase))
return false;
if (NameRef.ModNumber > -1)
{
if (NameRef.ModNumber > 0x1F) // Some weird inner name
{ // TODO: figure this out!
NameReference secondary;
secondary.Index = NameRef.ModNumber;
secondary.ModNumber = Data.ReadInt32();
SecondaryName = PCC.GetName(secondary);
Name = SecondaryName + "_" + NameRef.Index; // TODO: correct?
}
else
{
Name = Name + "_" + NameRef.ModNumber;
}
}
/*if (Name == String.Empty && SecondaryName == String.Empty) //(SecondaryName == String.Empty || SecondaryName == null))
return false;*/
TypeNameRef = Data.ReadNameRef();
if (TypeNameRef.ModNumber > -1) // another weird thing, this type name something unknown, but possibly the modnumber represents component type?
{
if (Data.ReadInt32() != 0)
return false;
TypeName = PCC.Names[TypeNameRef.ModNumber + 1]; // TODO: nonstandard, clean up.
if (String.Equals(TypeName, "None", StringComparison.OrdinalIgnoreCase))
return false; //TODO: Sort this arcane shit out.
var pTypeName = PCC.GetName(Data.ReadNameRef());
Type = (PropertyType)Enum.Parse(typeof(PropertyType), pTypeName);
}
else
{
TypeName = PCC.GetName(TypeNameRef);
/*if (TypeName == String.Empty)
return false;*/
Type = (PropertyType)Enum.Parse(typeof(PropertyType), TypeName);
}
Size = Data.ReadUInt32();
ArrayIndex = Data.ReadUInt32();
return DeserializeValue(Type, out Value, Size);
}
public static List<Property> ReadProp(PCCObject pcc, byte[] raw, int start)
{
Property p;
PropertyValue v;
int sname;
List<Property> result = new List<Property>();
int pos = start;
if (raw.Length - pos < 8)
return result;
int name = (int)BitConverter.ToInt64(raw, pos);
if (!pcc.IsName(name))
return result;
int MEtype = pcc.GameVersion;
string t = pcc.GetNameEntry(name);
bool test = t == "None";
if (MEtype == 3)
{
t = pcc.Names[name];
test = pcc.Names[name] == "None";
}
else if (MEtype != 1 && MEtype != 2)
{
DebugOutput.PrintLn("Failed to get ME Game Type.");
return new List<Property>();
}
if (test)
{
p = new Property();
p.Name = t;
p.TypeVal = Type.None;
p.i = 0;
p.offsetval = pos;
p.Size = (MEtype == 3) ? 8 : 20;
p.Value = new PropertyValue();
p.raw = BitConverter.GetBytes((Int64)name);
p.offend = pos + ((MEtype == 3) ? 8 : 20);
result.Add(p);
return result;
}
int type = (int)BitConverter.ToInt64(raw, pos + 8);
int size = BitConverter.ToInt32(raw, pos + 16);
int idx = BitConverter.ToInt32(raw, pos + 20); //Unused
if (!pcc.IsName(type) || size < 0 || size >= raw.Length)
return result;
string tp = (MEtype == 3) ? pcc.Names[type] : pcc.GetNameEntry(type);
switch (tp)
{
case "BoolProperty":
p = new Property();
p.TypeVal = Type.BoolProperty;
p.Name = t;
p.Size = size;
v = new PropertyValue();
if (MEtype == 3)
{
p.offsetval = pos + 24;
pos += 25;
byte temp = raw[p.offsetval];
v.IntValue = (int)temp;
v.Boolereno = temp == 1;
}
else
{
p.i = 0;
v.IntValue = BitConverter.ToInt32(raw, pos + ((MEtype == 2) ? 24 : 16)); //Guess. I haven't seen a true boolproperty yet
pos += 28;
}
p.Value = v;
break;
case "NameProperty":
p = new Property();
p.TypeVal = Type.NameProperty;
p.Name = t;
p.Size = size;
v = new PropertyValue();
if (MEtype == 3)
{
pos += 24;
v.IntValue = BitConverter.ToInt32(raw, pos);
v.StringValue = pcc.GetNameEntry(v.IntValue);
// Heff: Temporary modification to handle name refs properly, until we can rewrite the whole property system accross all tools
var nameRef = new NameReference();
nameRef.index = v.IntValue;
nameRef.count = BitConverter.ToInt32(raw, pos + 4);
nameRef.Name = pcc.GetNameEntry(nameRef.index);
if (nameRef.count > 0)
nameRef.Name += "_" + (nameRef.count - 1);
v.NameValue = nameRef;
pos += size;
}
else
{
//pos += 32;
//int tempInt = BitConverter.ToInt32(raw, pos + 24);
p.i = 0;
v.IntValue = BitConverter.ToInt32(raw, pos + 24);
v.StringValue = pcc.GetNameEntry(v.IntValue);
// Heff: Temporary modification to handle name refs properly, until we can rewrite the whole property system accross all tools
var nameRef = new NameReference();
nameRef.index = v.IntValue;
nameRef.count = BitConverter.ToInt32(raw, pos + 4);
nameRef.Name = pcc.GetNameEntry(nameRef.index);
if (nameRef.count > 0)
nameRef.Name += "_" + (nameRef.count - 1);
v.NameValue = nameRef;
pos += 32;
}
p.Value = v;
break;
case "IntProperty":
p = new Property();
p.TypeVal = Type.IntProperty;
v = new PropertyValue();
p.Name = t;
p.Size = size;
if (MEtype == 3)
{
pos += 24;
v.IntValue = (int)BitConverter.ToInt64(raw, pos);
pos += size;
}
else
{
v.IntValue = BitConverter.ToInt32(raw, pos + 24);
p.i = 0;
p.offsetval = pos + 24;
pos += 28;
}
p.Value = v;
break;
case "DelegateProperty":
p = new Property();
p.Name = t;
p.TypeVal = Type.DelegateProperty;
p.i = 0;
p.offsetval = pos + 24;
v = new PropertyValue();
v.IntValue = BitConverter.ToInt32(raw, pos + 28);
v.len = size;
v.Array = new List<PropertyValue>();
if (MEtype != 3)
p.Size = size;
pos += 24;
for (int i = 0; i < size; i++)
{
PropertyValue v2 = new PropertyValue();
if (pos < raw.Length)
v2.IntValue = raw[pos];
v.Array.Add(v2);
pos++;
}
p.Value = v;
break;
case "ArrayProperty":
int count = (int)BitConverter.ToInt64(raw, pos + 24);
p = new Property();
p.Name = t;
if (MEtype != 3)
p.Size = size;
p.TypeVal = Type.ArrayProperty;
p.i = 0;
p.offsetval = pos + 24;
v = new PropertyValue();
v.IntValue = type;
v.len = size - 4;
count = v.len;//TODO can be other objects too
v.Array = new List<PropertyValue>();
pos += 28;
for (int i = 0; i < count; i++)
{
PropertyValue v2 = new PropertyValue();
if (pos < raw.Length)
v2.IntValue = raw[pos];
v.Array.Add(v2);
pos++;
}
p.Value = v;
break;
case "StrProperty":
if (MEtype == 2)
count = (int)BitConverter.ToInt32(raw, pos + 24);
else
count = (int)BitConverter.ToInt64(raw, pos + 24);
p = new Property();
p.Name = t;
if (MEtype != 3)
p.Size = size;
p.TypeVal = Type.StrProperty;
p.i = 0;
p.offsetval = pos + 24;
if (MEtype == 3)
count *= -1;
v = new PropertyValue();
v.IntValue = type;
v.len = count;
pos += 28;
string s = "";
for (int i = 0; i < ((MEtype == 3) ? count : count - 1); i++)
{
s += (char)raw[pos];
if (MEtype == 3)
pos += 2;
else
pos++;
}
if (MEtype != 3)
pos++;
v.StringValue = s;
p.Value = v;
break;
case "StructProperty":
sname = (int)BitConverter.ToInt64(raw, pos + 24);
p = new Property();
p.Name = t;
p.Size = size;
p.TypeVal = Type.StructProperty;
p.i = 0;
p.offsetval = pos + 24;
v = new PropertyValue();
v.IntValue = sname;
v.len = size;
v.Array = new List<PropertyValue>();
if (MEtype == 3)
v.StringValue = pcc.Names[sname];
else if (MEtype == 3)
v.StringValue = pcc.GetNameEntry(sname);
pos += 32;
for (int i = 0; i < size; i += ((MEtype == 3) ? 1 : 4))
{
PropertyValue v2 = new PropertyValue();
//if (pos < raw.Length)
// v2.IntValue = raw[pos];
//v.Array.Add(v2);
//pos++;
if (pos < raw.Length)
v2.IntValue = (MEtype == 3) ? raw[pos] : BitConverter.ToInt32(raw, pos);
v.Array.Add(v2);
pos += (MEtype == 3) ? 1 : 4;
}
p.Value = v;
break;
case "ByteProperty":
if (MEtype == 3)
sname = (int)BitConverter.ToInt64(raw, pos + 24);
else
sname = BitConverter.ToInt32(raw, pos + 24);
p = new Property();
p.Name = t;
p.Size = size;
p.TypeVal = Type.ByteProperty;
p.i = 0;
p.offsetval = pos + 32;
v = new PropertyValue();
v.StringValue = (MEtype == 3) ? pcc.GetNameEntry(sname) : pcc.GetNameEntry(sname);
v.len = size;
if (MEtype == 3)
{
pos += 32;
v.IntValue = BitConverter.ToInt32(raw, pos);
v.String2 = pcc.Names[v.IntValue];
// Heff: Temporary modification to handle name refs properly, until we can rewrite the whole property system accross all tools
// This is stupid for enum properties, but as the enum itself will probably never be a name with index it works..
var nameRef = new NameReference();
nameRef.index = v.IntValue;
nameRef.count = BitConverter.ToInt32(raw, pos + 4);
nameRef.Name = pcc.GetNameEntry(nameRef.index);
if (nameRef.count > 0)
nameRef.Name += "_" + (nameRef.count - 1);
v.NameValue = nameRef;
pos += size;
}
else
{
v.IntValue = BitConverter.ToInt32(raw, pos + 28);
if (MEtype == 2)
v.String2 = pcc.GetNameEntry(v.IntValue);
pos += 32;
}
//v.IntValue = (int)BitConverter.ToInt64(raw, pos);
//pos += size;
p.Value = v;
break;
case "FloatProperty":
if (MEtype == 1)
sname = (int)BitConverter.ToInt64(raw, pos + 24);
else if (MEtype == 2)
sname = BitConverter.ToInt32(raw, pos + 24);
p = new Property();
p.Name = t;
p.Size = size;
p.TypeVal = Type.FloatProperty;
p.i = 0;
p.offsetval = (MEtype != 3) ? pos + 24 : 24;
v = new PropertyValue();
v.FloatValue = BitConverter.ToSingle(raw, pos + 24);
v.len = size;
pos += 28;
p.Value = v;
break;
default:
p = new Property();
p.Name = t;
p.TypeVal = getType(pcc, type);
p.i = 0;
if (MEtype != 3)
p.Size = size;
p.offsetval = pos + 24;
p.Value = ReadValue(pcc, raw, pos + 24, type);
pos += p.Value.len + 24;
break;
}
p.raw = new byte[pos - start];
p.offend = pos;
if (pos < raw.Length)
for (int i = 0; i < pos - start; i++)
p.raw[i] = raw[start + i];
result.Add(p);
if (pos != start) result.AddRange(ReadProp(pcc, raw, pos));
return result;
}
private static PropertyValue ReadValue(PCCObject pcc, byte[] raw, int start, int type)
{
PropertyValue v = new PropertyValue();
switch (pcc.GetNameEntry(type))
{
case "IntProperty":
case "FloatProperty":
case "ObjectProperty":
case "StringRefProperty":
v.IntValue = BitConverter.ToInt32(raw, start);
v.len = 4;
break;
case "NameProperty":
v.IntValue = BitConverter.ToInt32(raw, start);
var nameRef = new NameReference();
nameRef.index = v.IntValue;
nameRef.count = BitConverter.ToInt32(raw, start + 4);
nameRef.Name = pcc.GetNameEntry(nameRef.index);
if (nameRef.count > 0)
nameRef.Name += "_" + (nameRef.count - 1);
v.NameValue = nameRef;
v.len = 8;
break;
case "BoolProperty":
if (start < raw.Length)
v.IntValue = raw[start];
v.len = 1;
break;
}
return v;
}
