public ProjectionDefinition <T, T> Compile <T>(FieldSpec fieldSpec) { var sb = new StringBuilder(); sb.Append("{ "); for (int i = 0; i < fieldSpec.Fields.Length; i++) { var field = fieldSpec.Fields[i]; string name = MongoNameFixer.Field(field.Name); if (String.CompareOrdinal(name, "textScore") == 0) { sb.AppendFormat("{0} : {{ $meta : \"textScore\" }}", name); } else if (field.Presence == FieldSpecPresence.Included) { sb.AppendFormat("{0} : 1", name); } else { sb.AppendFormat("{0} : 0", name); } if (i < fieldSpec.Fields.Length - 1) { sb.Append(", "); } } sb.Append(" }"); return(new BsonDocumentProjectionDefinition <T, T>(BsonSerializer.Deserialize <BsonDocument>(sb.ToString()))); }
public Join(Expr outer, Expr inner, FieldSpec <T> outerFieldSpec, FieldSpec <T> innerFieldSpec) { Outer = outer; Inner = inner; OuterFieldSpec = outerFieldSpec; InnerFieldSpec = innerFieldSpec; }
public MixInstruction GetInstruction(byte opcode, FieldSpec fieldSpec) { if (!mOpcodeInstructionMap.TryGetValue(opcode, out List <MixInstruction> instructions)) { return(null); } int startIndex = 0; MixInstruction defaultInstruction = null; if (instructions[0].FieldSpec == null) { defaultInstruction = instructions[0]; startIndex = 1; } for (int index = startIndex; index < instructions.Count; index++) { if (instructions[index].FieldSpec == fieldSpec) { return(instructions[index]); } } return(defaultInstruction); }
private static UpversionType AnalyzeFields(IList <FieldSpec> oldFields, IList <FieldSpec> newFields) { foreach (FieldSpec oldField in oldFields) { FieldSpec newField = newFields .FirstOrDefault(field => field.Name.Name.Equals(oldField.Name.Name, StringComparison.InvariantCulture)); if (newField == null) { return(UpversionType.Major); } // Verify types are equal. This will false-positive on string/String conversions, but that's a minor issue for later consideration. if (!oldField.Type.Equals(newField.Type, StringComparison.InvariantCulture)) { return(UpversionType.Major); } // Validate modifiers. if ((oldField.IsUserModifiable && !newField.IsUserModifiable) || (oldField.IsStatic != newField.IsStatic)) { return(UpversionType.Major); } } if (newFields.Count != oldFields.Count) { return(UpversionType.Minor); } return(UpversionType.Patch); }
private static FieldSpecList ReadTextSchema(IEnumerable <string> enumerator) { var result = new FieldSpecList(); foreach (var item in enumerator) { string line = RemoveComments(item).ToLower().Trim(' ', '\t'); if (string.IsNullOrEmpty(line)) { continue; } var len = FieldSpecList.ReadRecordLength(line); if (len.HasValue) { result.RecordLength = len.Value; continue; } var spec = FieldSpec.ToFieldSpec(line); result.Add(spec); } return(result); }
public static WordField LoadFromRegister(FieldSpec fieldSpec, Register register) { int fieldSpecByteCount = fieldSpec.ByteCount; if (fieldSpecByteCount > register.ByteCountWithPadding) { throw new ArgumentOutOfRangeException("fieldSpec", fieldSpec, "bytecount too large for this register"); } WordField field = new WordField(fieldSpec, fieldSpecByteCount); int fromRegisterStartIndex = register.ByteCountWithPadding - fieldSpecByteCount; fieldSpecByteCount--; while (fieldSpecByteCount >= 0) { field[fieldSpecByteCount] = register.GetByteWithPadding(fromRegisterStartIndex + fieldSpecByteCount); fieldSpecByteCount--; } if (fieldSpec.IncludesSign) { field.Sign = register.Sign; } return(field); }
public void Test_gt4_snapshot_3() { var fsa = new FieldSpec <int>("a"); var fsb = new FieldSpec <int>("b"); var store1 = TableStore.Create(fsa, fsb); var students = Table.Create(store1); var fa = store1.GetField(fsa); var fb = store1.GetField(fsb); var r1 = store1.Insert(); r1.SetValue(fa, 0); r1.SetValue(fb, 5); var r2 = store1.Insert(); r2.SetValue(fa, 1); r2.SetValue(fb, 6); var r3 = store1.Insert(); r3.SetValue(fa, 2); r3.SetValue(fb, 5); var fsc = new FieldSpec <int>("c"); var fsd = new FieldSpec <int>("d"); var store2 = TableStore.Create(fsc, fsd); var r4 = store2.Insert(); var fc = store2.GetField(fsc); var fd = store2.GetField(fsd); r4.SetValue(fc, 5); r4.SetValue(fd, 2); var r5 = store2.Insert(); r5.SetValue(fc, 7); r5.SetValue(fd, 3); var(_, snapshot, test) = Table.Join(Table.Create(store1), Table.Create(store2), fsb, fsc); Assert.Equal(new Array8[] { new Array8(2) { [0] = 0, [1] = 0 }, new Array8(2) { [0] = 2, [1] = 0 } }, snapshot()); }
public void AddFieldToList(SPOList spoList, FieldSpec fs) { List spList = context.Web.Lists.GetById(spoList.Id); string fieldSchema = "<Field ID='" + Guid.NewGuid() + "' " + "Type='" + fs.Type + "' " + "Name='" + fs.Name + "' " + "StaticName='" + fs.Name + "' " + "DisplayName='" + fs.Name + "' />"; Field field = spList.Fields.AddFieldAsXml(fieldSchema, true, AddFieldOptions.AddToDefaultContentType); context.ExecuteQuery(); }
public void Test_gt4_test_3() { var fsa = new FieldSpec <int>("a"); var fsb = new FieldSpec <int>("b"); var store1 = TableStore.Create(fsa, fsb); var fa = store1.GetField(fsa); var fb = store1.GetField(fsb); var r1 = store1.Insert(); r1.SetValue(fa, 0); r1.SetValue(fb, 5); var r2 = store1.Insert(); r2.SetValue(fa, 1); r2.SetValue(fb, 6); var r3 = store1.Insert(); r3.SetValue(fa, 2); r3.SetValue(fb, 5); var fsc = new FieldSpec <int>("c"); var fsd = new FieldSpec <int>("d"); var store2 = TableStore.Create(fsc, fsd); var fc = store2.GetField(fsc); var fd = store2.GetField(fsd); var r4 = store2.Insert(); r4.SetValue(fc, 5); r4.SetValue(fd, 2); var r5 = store2.Insert(); r5.SetValue(fc, 7); r5.SetValue(fd, 3); var(_, snapshot, test) = Table.Join(Table.Create(store1), Table.Create(store2), fsb, fsc); Assert.Empty(test(store2[1])); }
public void FieldAndClassTest() { ClassSpec classSpec = NapackFileAnalyzer.Analyze("Test", "unused", SampleStrings.LargeSampleClass).Classes.First(); Assert.AreEqual(1, classSpec.PublicFields.Count); FieldSpec field = classSpec.PublicFields.First(); Assert.IsNotNull(field.Name); Assert.IsNotNull(field.Name.Name); Assert.IsNotNull(field.Name.Documentation); Assert.IsNotNull(field.Type); Assert.IsTrue(field.IsConst); Assert.IsFalse(field.IsStatic); Assert.IsFalse(field.IsReadonly); }
MixInstruction(byte opcode, FieldSpec fieldSpec, MetaFieldSpec metaFieldSpec, string mnemonic, int tickCount, Executor executor, Validator validator) : base(mnemonic) { // if the MetaFieldSpec Presence is Forbidden then an instruction fieldspec must be specified. Likewise, if an instruction fieldspec is provided, the MetaFieldSpec Presence must be Forbidden. if ((fieldSpec == null && metaFieldSpec.Presence == Instruction.MetaFieldSpec.Presences.Forbidden) || (metaFieldSpec.Presence != Instruction.MetaFieldSpec.Presences.Forbidden && fieldSpec != null)) { throw new ArgumentException("forbidden fieldspec presence makes instruction fieldspec mandatory and vice versa"); } Opcode = opcode; FieldSpec = fieldSpec; MetaFieldSpec = metaFieldSpec; TickCount = tickCount; mExecutor = executor ?? throw new ArgumentNullException(nameof(executor)); mValidator = validator; }
public void Test_b_gt_5() { var fsa = new FieldSpec <int>("a"); var fsb = new FieldSpec <int>("b"); var store1 = TableStore.Create(fsa, fsb); var fa = store1.GetField(fsa); var fb = store1.GetField(fsb); var expr = new Gt <int>(fsb, 5); var(_, snapshot, test) = Table.Filter(Table.Create(store1), expr); var r1 = store1.Insert(); r1.SetValue(fa, 0); r1.SetValue(fb, 5); var r2 = store1.Insert(); r2.SetValue(fa, 1); r2.SetValue(fb, 6); var r3 = store1.Insert(); r3.SetValue(fa, 2); r3.SetValue(fb, 7); Assert.Equal(new Array8[] { new Array8(1) { [0] = 1 }, new Array8(1) { [0] = 2 } }, snapshot()); Assert.Empty(test(store1[0])); Assert.Equal(new Array8[] { new Array8(1) { [0] = 1 } }, test(store1[1])); Assert.Equal(new Array8[] { new Array8(1) { [0] = 2 } }, test(store1[2])); }
public static WordField LoadFromFullWord(FieldSpec fieldSpec, FullWord word) { int fieldSpecByteCount = fieldSpec.ByteCount; WordField field = new WordField(fieldSpec, fieldSpecByteCount); int lowBoundByteIndex = fieldSpec.LowBoundByteIndex; for (int i = 0; i < fieldSpecByteCount; i++) { field[i] = word[lowBoundByteIndex + i]; } if (fieldSpec.IncludesSign) { field.Sign = word.Sign; } return(field); }
public void Test_gt5_snapshot() { var fsa = new FieldSpec <int>("a"); var fsb = new FieldSpec <int>("b"); var store = TableStore.Create(fsa, fsb); var fa = store.GetField(fsa); var fb = store.GetField(fsb); var students = Table.Create(store); var(_, snapshot, test) = Table.Gt(students, fsb, 5); var r1 = store.Insert(); r1.SetValue(fa, 0); r1.SetValue(fb, 5); Assert.Empty(snapshot()); }
public void Test() { var fsa = new FieldSpec <int>("a"); var fsb = new FieldSpec <int>("b"); var store = TableStore.Create(fsa, fsb); var fa = store.GetField(fsa); var fb = store.GetField(fsb); var sourceTable = Table.Create(store); var subManager = new SubscriptionManager(sourceTable); subManager.Subscribe(">,b,4i", (r, changeType, n) => { Console.WriteLine("hello"); }); subManager.Insert(store, r => { r.SetValue(fa, 0); r.SetValue(fb, 5); }); }
public void Test_gt4_notify_2() { var fsa = new FieldSpec <int>("a"); var fsb = new FieldSpec <int>("b"); var store = TableStore.Create(fsa, fsb); var fa = store.GetField(fsa); var fb = store.GetField(fsb); var students = Table.Create(store); var(_, snapshot, test) = Table.Gt(students, fsb, 4); var r1 = store.Insert(); r1.SetValue(fa, 0); r1.SetValue(fb, 5); var r2 = store.Insert(); r2.SetValue(fa, 1); r2.SetValue(fb, 6); var r3 = store.Insert(); r3.SetValue(fa, 2); r3.SetValue(fb, 4); Assert.Equal(new Array8[] { new Array8(1) { [0] = 0 } }, test(store[0])); Assert.Equal(new Array8[] { new Array8(1) { [0] = 1 } }, test(store[1])); Assert.Empty(test(store[2])); }
public void Test_gt4_snapshot() { var fsa = new FieldSpec <int>("a"); var fsb = new FieldSpec <int>("b"); var store = TableStore.Create(fsa, fsb); var fa = store.GetField(fsa); var fb = store.GetField(fsb); var students = Table.Create(store); var(_, snapshot, test) = Table.Gt(students, fsb, 4); var r1 = store.Insert(); r1.SetValue(fa, 0); r1.SetValue(fb, 5); Assert.Equal(new Array8[] { new Array8(1) { [0] = 0 } }, snapshot()); }
void AddInstruction(string mnemonic, byte opcode, FieldSpec fieldSpec, int tickCount, MixInstruction.Executor executor, MixInstruction.Validator validator) => AddInstruction(mnemonic, new MixInstruction(opcode, fieldSpec, mnemonic, tickCount, executor, validator));
public InstructionSet() { var fullWordMetaSpec = new MetaFieldSpec(true, FullWordRegister.DefaultFieldSpec); var indexMetaSpec = new MetaFieldSpec(true, IndexRegister.DefaultFieldSpec); FieldSpec[] rangeSpecs = new FieldSpec[8]; for (int i = 0; i < rangeSpecs.Length; i++) { rangeSpecs[i] = new FieldSpec(i); } MixInstruction.Executor executor = LoadInstructions.Load; MixInstruction.Validator validator = InstructionHelpers.ValidateIndexAndFieldSpec; AddInstruction("LDA", 8, fullWordMetaSpec, 2, executor, validator); AddInstruction("LD1", 9, indexMetaSpec, 2, executor, validator); AddInstruction("LD2", 10, indexMetaSpec, 2, executor, validator); AddInstruction("LD3", 11, indexMetaSpec, 2, executor, validator); AddInstruction("LD4", 12, indexMetaSpec, 2, executor, validator); AddInstruction("LD5", 13, indexMetaSpec, 2, executor, validator); AddInstruction("LD6", 14, indexMetaSpec, 2, executor, validator); AddInstruction("LDX", 15, fullWordMetaSpec, 2, executor, validator); executor = LoadInstructions.LoadNegative; AddInstruction("LDAN", 16, fullWordMetaSpec, 2, executor, validator); AddInstruction("LD1N", 17, indexMetaSpec, 2, executor, validator); AddInstruction("LD2N", 18, indexMetaSpec, 2, executor, validator); AddInstruction("LD3N", 19, indexMetaSpec, 2, executor, validator); AddInstruction("LD4N", 20, indexMetaSpec, 2, executor, validator); AddInstruction("LD5N", 21, indexMetaSpec, 2, executor, validator); AddInstruction("LD6N", 22, indexMetaSpec, 2, executor, validator); AddInstruction("LDXN", 23, fullWordMetaSpec, 2, executor, validator); executor = StoreInstructions.StoreRegister; AddInstruction("STA", 24, fullWordMetaSpec, 2, executor, validator); AddInstruction("ST1", 25, indexMetaSpec, 2, executor, validator); AddInstruction("ST2", 26, indexMetaSpec, 2, executor, validator); AddInstruction("ST3", 27, indexMetaSpec, 2, executor, validator); AddInstruction("ST4", 28, indexMetaSpec, 2, executor, validator); AddInstruction("ST5", 29, indexMetaSpec, 2, executor, validator); AddInstruction("ST6", 30, indexMetaSpec, 2, executor, validator); AddInstruction("STX", 31, fullWordMetaSpec, 2, executor, validator); AddInstruction("STJ", 32, new MetaFieldSpec(true, AddressRegister.DefaultFieldSpec), 2, executor, validator); executor = StoreInstructions.StoreZero; AddInstruction("STZ", 33, new MetaFieldSpec(true, Memory.DefaultFieldSpec), 2, executor, validator); executor = ArithmaticInstructions.AddSubstract; AddInstruction("ADD", 1, fullWordMetaSpec, 2, executor, validator); AddInstruction("SUB", 2, fullWordMetaSpec, 2, executor, validator); executor = ArithmaticInstructions.Multiply; AddInstruction("MUL", 3, fullWordMetaSpec, 10, executor, validator); executor = ArithmaticInstructions.Divide; AddInstruction("DIV", 4, fullWordMetaSpec, 12, executor, validator); executor = ComparisonInstructions.Compare; AddInstruction("CMPA", 56, fullWordMetaSpec, 2, executor, validator); AddInstruction("CMP1", 57, indexMetaSpec, 2, executor, validator); AddInstruction("CMP2", 58, indexMetaSpec, 2, executor, validator); AddInstruction("CMP3", 59, indexMetaSpec, 2, executor, validator); AddInstruction("CMP4", 60, indexMetaSpec, 2, executor, validator); AddInstruction("CMP5", 61, indexMetaSpec, 2, executor, validator); AddInstruction("CMP6", 62, indexMetaSpec, 2, executor, validator); AddInstruction("CMPX", 63, fullWordMetaSpec, 2, executor, validator); executor = AddressTransferInstructions.Increase; validator = InstructionHelpers.ValidateIndex; AddInstruction("INCA", 48, rangeSpecs[0], 1, executor, validator); AddInstruction("INC1", 49, rangeSpecs[0], 1, executor, validator); AddInstruction("INC2", 50, rangeSpecs[0], 1, executor, validator); AddInstruction("INC3", 51, rangeSpecs[0], 1, executor, validator); AddInstruction("INC4", 52, rangeSpecs[0], 1, executor, validator); AddInstruction("INC5", 53, rangeSpecs[0], 1, executor, validator); AddInstruction("INC6", 54, rangeSpecs[0], 1, executor, validator); AddInstruction("INCX", 55, rangeSpecs[0], 1, executor, validator); executor = AddressTransferInstructions.Decrease; AddInstruction("DECA", 48, rangeSpecs[1], 1, executor, validator); AddInstruction("DEC1", 49, rangeSpecs[1], 1, executor, validator); AddInstruction("DEC2", 50, rangeSpecs[1], 1, executor, validator); AddInstruction("DEC3", 51, rangeSpecs[1], 1, executor, validator); AddInstruction("DEC4", 52, rangeSpecs[1], 1, executor, validator); AddInstruction("DEC5", 53, rangeSpecs[1], 1, executor, validator); AddInstruction("DEC6", 54, rangeSpecs[1], 1, executor, validator); AddInstruction("DECX", 55, rangeSpecs[1], 1, executor, validator); executor = AddressTransferInstructions.Enter; AddInstruction("ENTA", 48, rangeSpecs[2], 1, executor, validator); AddInstruction("ENT1", 49, rangeSpecs[2], 1, executor, validator); AddInstruction("ENT2", 50, rangeSpecs[2], 1, executor, validator); AddInstruction("ENT3", 51, rangeSpecs[2], 1, executor, validator); AddInstruction("ENT4", 52, rangeSpecs[2], 1, executor, validator); AddInstruction("ENT5", 53, rangeSpecs[2], 1, executor, validator); AddInstruction("ENT6", 54, rangeSpecs[2], 1, executor, validator); AddInstruction("ENTX", 55, rangeSpecs[2], 1, executor, validator); executor = AddressTransferInstructions.EnterNegative; AddInstruction("ENNA", 48, rangeSpecs[3], 1, executor, validator); AddInstruction("ENN1", 49, rangeSpecs[3], 1, executor, validator); AddInstruction("ENN2", 50, rangeSpecs[3], 1, executor, validator); AddInstruction("ENN3", 51, rangeSpecs[3], 1, executor, validator); AddInstruction("ENN4", 52, rangeSpecs[3], 1, executor, validator); AddInstruction("ENN5", 53, rangeSpecs[3], 1, executor, validator); AddInstruction("ENN6", 54, rangeSpecs[3], 1, executor, validator); AddInstruction("ENNX", 55, rangeSpecs[3], 1, executor, validator); executor = JumpInstructions.NonRegJump; AddInstruction("JMP", 39, rangeSpecs[0], 1, executor, validator); AddInstruction("JSJ", 39, rangeSpecs[1], 1, executor, validator); AddInstruction("JOV", 39, rangeSpecs[2], 1, executor, validator); AddInstruction("JNOV", 39, rangeSpecs[3], 1, executor, validator); AddInstruction("JL", 39, rangeSpecs[4], 1, executor, validator); AddInstruction("JE", 39, rangeSpecs[5], 1, executor, validator); AddInstruction("JG", 39, rangeSpecs[6], 1, executor, validator); AddInstruction("JGE", 39, rangeSpecs[7], 1, executor, validator); AddInstruction("JNE", 39, new FieldSpec(8), 1, executor, validator); AddInstruction("JLE", 39, new FieldSpec(9), 1, executor, validator); executor = JumpInstructions.RegJump; AddInstruction("JAN", 40, rangeSpecs[0], 1, executor, validator); AddInstruction("JAZ", 40, rangeSpecs[1], 1, executor, validator); AddInstruction("JAP", 40, rangeSpecs[2], 1, executor, validator); AddInstruction("JANN", 40, rangeSpecs[3], 1, executor, validator); AddInstruction("JANZ", 40, rangeSpecs[4], 1, executor, validator); AddInstruction("JANP", 40, rangeSpecs[5], 1, executor, validator); AddInstruction("JAE", 40, rangeSpecs[6], 1, executor, validator); AddInstruction("JAO", 40, rangeSpecs[7], 1, executor, validator); AddInstruction("J1N", 41, rangeSpecs[0], 1, executor, validator); AddInstruction("J1Z", 41, rangeSpecs[1], 1, executor, validator); AddInstruction("J1P", 41, rangeSpecs[2], 1, executor, validator); AddInstruction("J1NN", 41, rangeSpecs[3], 1, executor, validator); AddInstruction("J1NZ", 41, rangeSpecs[4], 1, executor, validator); AddInstruction("J1NP", 41, rangeSpecs[5], 1, executor, validator); AddInstruction("J2N", 42, rangeSpecs[0], 1, executor, validator); AddInstruction("J2Z", 42, rangeSpecs[1], 1, executor, validator); AddInstruction("J2P", 42, rangeSpecs[2], 1, executor, validator); AddInstruction("J2NN", 42, rangeSpecs[3], 1, executor, validator); AddInstruction("J2NZ", 42, rangeSpecs[4], 1, executor, validator); AddInstruction("J2NP", 42, rangeSpecs[5], 1, executor, validator); AddInstruction("J3N", 43, rangeSpecs[0], 1, executor, validator); AddInstruction("J3Z", 43, rangeSpecs[1], 1, executor, validator); AddInstruction("J3P", 43, rangeSpecs[2], 1, executor, validator); AddInstruction("J3NN", 43, rangeSpecs[3], 1, executor, validator); AddInstruction("J3NZ", 43, rangeSpecs[4], 1, executor, validator); AddInstruction("J3NP", 43, rangeSpecs[5], 1, executor, validator); AddInstruction("J4N", 44, rangeSpecs[0], 1, executor, validator); AddInstruction("J4Z", 44, rangeSpecs[1], 1, executor, validator); AddInstruction("J4P", 44, rangeSpecs[2], 1, executor, validator); AddInstruction("J4NN", 44, rangeSpecs[3], 1, executor, validator); AddInstruction("J4NZ", 44, rangeSpecs[4], 1, executor, validator); AddInstruction("J4NP", 44, rangeSpecs[5], 1, executor, validator); AddInstruction("J5N", 45, rangeSpecs[0], 1, executor, validator); AddInstruction("J5Z", 45, rangeSpecs[1], 1, executor, validator); AddInstruction("J5P", 45, rangeSpecs[2], 1, executor, validator); AddInstruction("J5NN", 45, rangeSpecs[3], 1, executor, validator); AddInstruction("J5NZ", 45, rangeSpecs[4], 1, executor, validator); AddInstruction("J5NP", 45, rangeSpecs[5], 1, executor, validator); AddInstruction("J6N", 46, rangeSpecs[0], 1, executor, validator); AddInstruction("J6Z", 46, rangeSpecs[1], 1, executor, validator); AddInstruction("J6P", 46, rangeSpecs[2], 1, executor, validator); AddInstruction("J6NN", 46, rangeSpecs[3], 1, executor, validator); AddInstruction("J6NZ", 46, rangeSpecs[4], 1, executor, validator); AddInstruction("J6NP", 46, rangeSpecs[5], 1, executor, validator); AddInstruction("JXN", 47, rangeSpecs[0], 1, executor, validator); AddInstruction("JXZ", 47, rangeSpecs[1], 1, executor, validator); AddInstruction("JXP", 47, rangeSpecs[2], 1, executor, validator); AddInstruction("JXNN", 47, rangeSpecs[3], 1, executor, validator); AddInstruction("JXNZ", 47, rangeSpecs[4], 1, executor, validator); AddInstruction("JXNP", 47, rangeSpecs[5], 1, executor, validator); AddInstruction("JXE", 47, rangeSpecs[6], 1, executor, validator); AddInstruction("JXO", 47, rangeSpecs[7], 1, executor, validator); executor = FloatingPointInstructions.DoFloatingPoint; AddInstruction("FADD", 1, rangeSpecs[6], 4, executor, validator); AddInstruction("FSUB", 2, rangeSpecs[6], 4, executor, validator); AddInstruction("FMUL", 3, rangeSpecs[6], 9, executor, validator); AddInstruction("FDIV", 4, rangeSpecs[6], 11, executor, validator); AddInstruction("FLOT", 5, rangeSpecs[6], 3, executor, validator); AddInstruction("FIX", 5, rangeSpecs[7], 3, executor, validator); AddInstruction(FloatingPointInstructions.FcmpMnemonic, 56, rangeSpecs[6], 4, executor, validator); executor = MiscInstructions.Move; AddInstruction("MOVE", 7, new MetaFieldSpec(false, rangeSpecs[1]), 1, executor, validator); var ioMetaSpec = new MetaFieldSpec(MetaFieldSpec.Presences.Mandatory, false); executor = IOInstructions.JumpIfBusy; validator = IOInstructions.InstanceValid; AddInstruction("JBUS", 34, ioMetaSpec, 1, executor, validator); executor = IOInstructions.IOControl; AddInstruction("IOC", 35, ioMetaSpec, 1, executor, validator); executor = IOInstructions.Input; AddInstruction("IN", IOInstructions.INOpCode, ioMetaSpec, 1, executor, validator); executor = IOInstructions.Output; AddInstruction("OUT", 37, ioMetaSpec, 1, executor, validator); executor = IOInstructions.JumpIfReady; AddInstruction("JRED", 38, ioMetaSpec, 1, executor, validator); executor = ShiftInstructions.ShiftA; AddInstruction("SLA", 6, rangeSpecs[0], 2, executor, null); AddInstruction("SRA", 6, rangeSpecs[1], 2, executor, null); executor = ShiftInstructions.ShiftAX; AddInstruction("SLAX", 6, rangeSpecs[2], 2, executor, null); AddInstruction("SRAX", 6, rangeSpecs[3], 2, executor, null); AddInstruction("SLC", 6, rangeSpecs[4], 2, executor, null); AddInstruction("SRC", 6, rangeSpecs[5], 2, executor, null); executor = ShiftInstructions.ShiftAXBinary; AddInstruction("SLB", 6, rangeSpecs[6], 2, executor, null); AddInstruction("SRB", 6, rangeSpecs[7], 2, executor, null); executor = MiscInstructions.Noop; AddInstruction("NOP", 0, new MetaFieldSpec(false, rangeSpecs[0]), 1, executor, null); executor = MiscInstructions.ConvertToNumeric; AddInstruction("NUM", 5, rangeSpecs[0], 10, executor, null); executor = MiscInstructions.ConvertToChar; AddInstruction("CHAR", 5, rangeSpecs[1], 10, executor, null); executor = MiscInstructions.Halt; AddInstruction("HLT", 5, rangeSpecs[2], 10, executor, null); executor = MiscInstructions.ForceInterrupt; AddInstruction("INT", 5, new FieldSpec(9), 2, executor, null); }
public static IValue ParseValue(string text, int sectionCharIndex, ParsingStatus status) { // split the text to parse in its W-value components var textParts = text.Split(new char[] { ',' }); int currentIndex = 0; var register = new FullWordRegister(); var word = new FullWord(0); // parse and apply each component to the word that contains the result foreach (string part in textParts) { // parse the address part... var braceIndex = part.IndexOf('('); var address = ExpressionValue.ParseValue((braceIndex == -1) ? part : part.Substring(0, braceIndex), sectionCharIndex + currentIndex, status); if (address == null) { return(null); } // ... and check if it is valid var addressSign = address.GetSign(status.LocationCounter); var addressMagnitude = address.GetMagnitude(status.LocationCounter); if (addressMagnitude > register.MaxMagnitude) { status.ReportParsingError(sectionCharIndex + currentIndex, (braceIndex == -1) ? part.Length : braceIndex, "W-value field value invalid"); return(null); } register.MagnitudeLongValue = addressMagnitude; register.Sign = addressSign; int fieldValue = FullWord.ByteCount; // if a fieldspec part is present... if (braceIndex >= 0) { // ... parse its value... var field = FPartValue.ParseValue(part.Substring(braceIndex), (sectionCharIndex + currentIndex) + braceIndex, status); if (field == null) { return(null); } // ... and check if it is valid if (field.GetValue(status.LocationCounter) != FPartValue.Default) { fieldValue = (int)field.GetValue(status.LocationCounter); } } // use the fieldspec value to create and check an actual fieldspec var fieldSpec = new FieldSpec(fieldValue); if (!fieldSpec.IsValid) { status.ReportParsingError((sectionCharIndex + currentIndex) + braceIndex, part.Length - braceIndex, "field must be a fieldspec"); return(null); } // apply the component to the word that will contain the end result WordField.LoadFromRegister(fieldSpec, register).ApplyToFullWord(word); currentIndex += part.Length + 1; } return(new NumberValue(word.Sign, word.MagnitudeLongValue)); }
internal static ClassSpec AnalyzeClassSyntaxTree(string napackName, string filename, ClassDeclarationSyntax classNode) { ClassSpec classSpec = new ClassSpec(); classSpec.Name = DocumentedElement.LoadFromSyntaxNode(classNode); classSpec.IsAbstract = classNode.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.AbstractKeyword)); classSpec.IsStatic = classNode.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.StaticKeyword)); classSpec.IsSealed = classSpec.IsStatic || classNode.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.SealedKeyword)); // Parse classes recursively foreach (ClassDeclarationSyntax node in classNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.ClassDeclaration))) { if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword)) || (classSpec.ProtectedItemsConsideredPublic && node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword)))) { // This recursion will exit because we aren't *compiling* the code, but merely parsing it. classSpec.PublicClasses.Add(AnalyzeClassSyntaxTree(napackName, filename, node)); } } // Parse methods foreach (MethodDeclarationSyntax node in classNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.MethodDeclaration))) { if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword)) || (classSpec.ProtectedItemsConsideredPublic && node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword)))) { classSpec.PublicMethods.Add(MethodSpec.LoadFromSyntaxNode(node)); } } // Parse constructors foreach (ConstructorDeclarationSyntax node in classNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.ConstructorDeclaration))) { if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword)) || (classSpec.ProtectedItemsConsideredPublic && node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword)))) { classSpec.PublicConstructors.Add(ConstructorSpec.LoadFromSyntaxNode(node)); } } // Parse fields foreach (FieldDeclarationSyntax node in classNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.FieldDeclaration))) { if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword)) || (classSpec.ProtectedItemsConsideredPublic && node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword)))) { classSpec.PublicFields.Add(FieldSpec.LoadFromSyntaxNode(node)); } } // Parse properties foreach (PropertyDeclarationSyntax node in classNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.PropertyDeclaration))) { if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword)) || (classSpec.ProtectedItemsConsideredPublic && node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword)))) { classSpec.PublicProperties.Add(PropertySpec.LoadFromSyntaxNode(node)); } } return(classSpec); }
/// <summary> /// Create a MIX instruction with the specified opcode, fieldspec, mnemonic, tickCount, executor and validator. /// The instruction's MetaFieldSpec will indicate that for this instruction, fieldspecs are forbidden in the MIXAL code. /// </summary> public MixInstruction(byte opcode, FieldSpec fieldSpec, string mnemonic, int tickCount, Executor executor, Validator validator) : this(opcode, fieldSpec, new MetaFieldSpec(), mnemonic, tickCount, executor, validator) { }
private WordField(FieldSpec fieldSpec, int byteCount) : base(byteCount) { mFieldSpec = fieldSpec; }
static void Main(string[] args) { var srcPath = "C:/Users/v-chph/Downloads/DatCon-master/DatCon/src/DatConRecs/"; var fileNames = Directory.GetFiles(srcPath, "*.java", SearchOption.AllDirectories); var typeLookup = new Dictionary <string, string> { { ".getByte(", "byte" }, { ".getUnsignedByte(", "byte" }, { ".getUnsignedInt(", "UInt32" }, { ".getUnsignedShort(", "UInt16" }, { ".getFloat(", "float" }, { ".getShort(", "short" }, { ".getInt(", "int" }, { ".getDouble(", "double" }, { ".getString(", "string" }, { ".getCleanString(", "string" } }; var specString = "new RecClassSpec("; var recSpecs = new Dictionary <string, RecordSpec>(); foreach (var fn in fileNames) { var lines = File.ReadAllLines(fn); foreach (var l in lines) { if (l.Contains(specString)) { if (l.Trim().StartsWith("//")) { continue; } var ia = l.IndexOf(specString) + specString.Length; var ib = l.IndexOf(".class"); if (ib < 0) { continue; } var name = l.Substring(ia, ib - ia); var parts = l.Substring(ib).Split(new char[] { ',', ')' }); if (parts.Length < 3) { continue; } var id = parts[1].Trim(); var len = parts[2].Trim(); Console.WriteLine("{0},{1},{2}", name, id, len); var cleanName = name.TrimEnd(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '_' }); var dirName = Path.GetFileName(Directory.GetParent(fn).ToString()); recSpecs[name] = new RecordSpec { name = cleanName, id = id, len = len, definedIn = dirName }; } } } var allLines = new List <string>(); var validLines = new List <string>(); var invalidLines = new List <string>(); validLines.Add("definedIn,groupName,groupId,groupLen,name,offset,type,validParse,sourceLine"); foreach (var fn in fileNames) { var lines = File.ReadAllLines(fn); foreach (var l in lines) { foreach (var key in typeLookup.Keys) { if (l.Trim().StartsWith("//")) { continue; } if (l.Contains(key)) { var name = l.Split('=')[0].Trim(); var ia = l.IndexOf(key) + key.Length; var ib = l.IndexOf(')', ia); var offStr = l.Substring(ia, ib - ia); var valid = true; int off; if (typeLookup[key] == "string") { off = 0; } else if (!int.TryParse(offStr, out off)) { valid = false; } var groupName = Path.GetFileNameWithoutExtension(fn); var recSpec = new RecordSpec { name = "unk", id = "0", len = "0" }; if (recSpecs.Keys.Contains(groupName)) { recSpec = recSpecs[groupName]; } else { valid = false; } if (name.StartsWith("double "))//special case for a few lines that are defined like this. { name = name.Substring("double ".Length); } //groupName = groupName.TrimEnd(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '_' }); var outLine = String.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8}", Path.GetFileName(Directory.GetParent(fn).ToString()), recSpec.name, recSpec.id, recSpec.len, name, off, typeLookup[key], valid, l.Trim()); if (recSpec.id == "65533") { } if (valid) { var field = new FieldSpec() { name = name, offset = off, type = typeLookup[key] }; recSpec.fields.Add(field); validLines.Add(outLine); } else { invalidLines.Add(outLine); } } } } } var destPath = "../../../TelloLib/"; File.WriteAllLines(destPath + "parsedRecSpecs.csv", validLines.Concat(invalidLines).ToArray()); string json = JsonConvert.SerializeObject(recSpecs.Values.ToArray(), Formatting.Indented); File.WriteAllText(destPath + "parsedRecSpecs.json", json); //var xx = JsonConvert.DeserializeObject(json); }
protected static CreateFieldRequest FieldCreateRequestFromSpec(FieldSpec spec) { return(CreateFieldRequest.Builder().With((ResourceId)(int)spec.Resource, (FieldType)(int)spec.FieldType, spec.Label == null ? spec.Key.ToString() : spec.Label).Build().Content); }
/// <summary> /// Creates a MetaFieldSpec that describes an Optional fieldspec, with a specified default value. /// It can also specifies if the fieldspec is a range, like (0:5), or a value, like (19). /// </summary> /// <param name="fieldIsRange"></param> /// <param name="defaultFieldSpec"></param> public MetaFieldSpec(bool fieldIsRange, FieldSpec defaultFieldSpec) : this(Presences.Optional, fieldIsRange, defaultFieldSpec) { }
private FieldSpec UniteSubSpecsForField(OpCodeFamilyKb fkb, String fname) { // 1. Create a field spec var fspecs = fkb.SubSpecs.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Fields.Values.SingleOrDefault(f => f.Name == fname) ?? new FieldSpec { Name = fname }); var united = new FieldSpec(); united.Name = fname; // 2. Find out an unified type (it should be specified at least once and every time the same) var ftypes = fspecs.Values.Select(v => v.Type); var ftype = ftypes.Where(v => v != null).Distinct().Single(); united.Type = ftype; // 3. Normalize initializers for every opcode (replace null with default(T)) foreach (var spec in fspecs.Values) { var init = spec.Initializer; if (init.IsNullOrEmpty()) { spec.Initializer = "default(" + ftype.GetCSharpRef(ToCSharpOptions.ForCodegen) + ")"; } } // 4. Now assemble all initializers into a single language construct var initGroups = fspecs.Where(kvp => kvp.Value.Initializer.IsNeitherNullNorEmpty()) .GroupBy(kvp => kvp.Value.Initializer, kvp => kvp.Key); (initGroups.Count() >= 1).AssertTrue(); // 4.1. There's only 1 possible opcode => 1 possible initializer // or maybe all initializers for different opcodes are the same. // This means that we can reuse its expression and assign the value to the field. EZ! if (initGroups.Count() == 1) { var initCode = initGroups.Single().Key; if (!initCode.EndsWith(";")) { initCode = initCode + ";"; } initCode = fname + " = " + initCode; united.Initializer = (initCode + Environment.NewLine); } // 4.2. There are multiple distinct initializers // Thus, we're forced to implement a switch depending on the opcode. // Default will crash the switch since we're unprepared to it. else { var init = new StringBuilder(); init.AppendLine(String.Format("switch(({0})OpSpec.OpCode.Value)", typeof(UInt16).GetCSharpRef(ToCSharpOptions.ForCodegen))); init.AppendLine("{"); foreach (var initGroup in initGroups) { foreach (var opcode in initGroup) { var @case = "case " + opcode.GetCSharpByteSequence() + ":"; @case = @case + " //" + opcode.Name; init.AppendLine(@case.Indent()); } var initCode = initGroup.Key; if (!initCode.EndsWith(";")) { initCode = initCode + ";"; } initCode = fname + " = " + initCode; init.AppendLine(initCode.Indent().Indent()); init.AppendLine("break;".Indent().Indent()); } init.AppendLine("default:".Indent()); var throwOnUnknown = String.Format("throw {0}.Fail();", typeof(AssertionHelper).GetCSharpRef(ToCSharpOptions.ForCodegen)); init.AppendLine(throwOnUnknown.Indent().Indent()); init.AppendLine("}"); united.Initializer = init.ToString(); } return(united); }
static public RecordSpec[] Parse(byte[] data) { var records = new List <RecordSpec>(); int pos = 0; //A packet can contain more than one record. while (pos < data.Length - 2) //-2 for CRC bytes at end of packet. { if (data[pos] != 'U') //Check magic byte { pos += 1; //Console.WriteLine("PARSE ERROR!!!"); continue; } var len = data[pos + 1]; if (data[pos + 2] != 0)//Should always be zero (so far) { pos += 1; //Console.WriteLine("SIZE OVERFLOW!!!"); break; } var crc = data[pos + 3]; //todo Check crc. var id = BitConverter.ToUInt16(data, pos + 4); var xorBuf = new byte[256]; byte xorValue = data[pos + 6]; var recSpecId = /*len + "_" +*/ id.ToString(); //Console.WriteLine(recSpecId); if (recordSpecLookup.Keys.Contains(recSpecId)) { for (var i = 0; i < len; i++)//Decrypt payload. { xorBuf[i] = (byte)(data[pos + i] ^ xorValue); } int baseOffset = 10; var record = recordSpecLookup[recSpecId]; var newRecord = new RecordSpec() { name = record.name, id = record.id, definedIn = record.definedIn, len = record.len, fields = new List <FieldSpec>() }; var fields = record.fields; foreach (var field in fields) { var newField = new FieldSpec() { name = field.name, type = field.type, offset = field.offset, }; switch (field.type) { case "byte": field.value = xorBuf[baseOffset + field.offset]; break; case "short": field.value = BitConverter.ToInt16(xorBuf, baseOffset + field.offset); break; case "UInt16": field.value = BitConverter.ToUInt16(xorBuf, baseOffset + field.offset); break; case "int": field.value = BitConverter.ToInt32(xorBuf, baseOffset + field.offset); break; case "UInt32": field.value = BitConverter.ToUInt32(xorBuf, baseOffset + field.offset); break; case "float": field.value = BitConverter.ToSingle(xorBuf, baseOffset + field.offset); break; case "double": field.value = BitConverter.ToDouble(xorBuf, baseOffset + field.offset); break; case "string": field.value = System.Text.Encoding.Default.GetString(xorBuf, baseOffset + field.offset, len - 15); break; } newField.value = field.value; newRecord.fields.Add(newField); } //Console.WriteLine(record.ToString()); records.Add(newRecord); } else { Console.WriteLine("Not found:" + recSpecId + " len:" + len); } pos += len; } return(records.ToArray()); }
MetaFieldSpec(Presences presence, bool fieldIsRange, FieldSpec defaultFieldSpec) { Presence = presence; FieldIsRange = fieldIsRange; DefaultFieldSpec = defaultFieldSpec; }
public SerializedObjectFields(Type t, ISerializableObjectFieldSerializerFactory factory, bool forNetwork) { if (!typeof(Actor).IsAssignableFrom(t)) { throw new ObjectSerializationException("Type is not a serializable object!"); } for (; t != typeof(object); t = t.BaseType) { var members = t.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic); foreach (var field in members) { if (field.DeclaringType != t) { continue; } var attributes = System.Attribute.GetCustomAttributes(field); if (forNetwork) { foreach (var attr in attributes) { var replication = attr as Replicated; if (replication != null) { var serializedField = new FieldSpec(); serializedField.field = field; serializedField.fieldID = (ushort)++_nextFieldID; serializedField.replication = replication; serializedField.isObjectReference = typeof(SerializableObject).IsAssignableFrom(field.FieldType); serializedField.serializer = factory.GetSerializerForField(serializedField); if (replication.Notify != null) { serializedField.onRep = t.GetMethod(replication.Notify, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.ExactBinding, null, System.Type.EmptyTypes, null); if (serializedField.onRep == null) { throw new MissingMemberException(t.FullName + " is missing replication notification method " + serializedField.onRep + " specified by replicated field " + field.Name); } } _serializedFields.Add(serializedField.fieldID, serializedField); } } } else { bool isTransient = true; foreach (var attr in attributes) { isTransient = !(attr is UnityEngine.SerializeField); if (!isTransient) { break; } } if (!isTransient) { var serializedField = new FieldSpec(); serializedField.field = field; serializedField.fieldID = (ushort)++_nextFieldID; serializedField.serializer = factory.GetSerializerForField(serializedField); serializedField.isObjectReference = typeof(SerializableObject).IsAssignableFrom(field.FieldType); _serializedFields.Add(serializedField.fieldID, serializedField); } } } } if (_serializedFields.Values.Count > MAX_REPLICATED_FIELDS) { throw new ObjectSerializationException("Too many replicated fields!"); } }