Beispiel #1
0
        public static void WriteValue(VirtualMachine vm, int memoryIndex, string name, ValueType type, StringBuilder sb, JsonWriter.ObjectScope writer)
        {
            writer.String("name", name);

            sb.Clear();
            type.Format(vm.chunk, sb);
            writer.String("type", sb.ToString());

            sb.Clear();
            DebugHelper.ValueToString(
                vm,
                memoryIndex,
                type,
                sb
                );
            writer.String("value", sb.ToString());
        }
Beispiel #2
0
        private static void NestedValues(VirtualMachine vm, ref int memoryIndex, string[] path, int pathIndex, ValueType type, StringBuilder sb, JsonWriter.ObjectScope writer)
        {
            var isReferenceType = type.IsArray || type.IsReference;

            if (pathIndex < path.Length)
            {
                if (isReferenceType)
                {
                    return;
                }

                var name = path[pathIndex++];
                if (type.kind == TypeKind.Struct)
                {
                    var structType = vm.chunk.structTypes.buffer[type.index];
                    for (var i = 0; i < structType.fields.length; i++)
                    {
                        var field = vm.chunk.structTypeFields.buffer[structType.fields.index + i];
                        if (field.name == name)
                        {
                            NestedValues(
                                vm,
                                ref memoryIndex,
                                path,
                                pathIndex,
                                field.type,
                                sb,
                                writer
                                );
                            break;
                        }

                        memoryIndex += field.type.GetSize(vm.chunk);
                    }
                }
                else if (type.kind == TypeKind.Tuple)
                {
                    if (!int.TryParse(name, out var elementIndex))
                    {
                        return;
                    }

                    var tupleType = vm.chunk.tupleTypes.buffer[type.index];
                    for (var i = 0; i < tupleType.elements.length; i++)
                    {
                        var elementType = vm.chunk.tupleElementTypes.buffer[tupleType.elements.index + i];

                        if (elementIndex == i)
                        {
                            NestedValues(
                                vm,
                                ref memoryIndex,
                                path,
                                pathIndex,
                                elementType,
                                sb,
                                writer
                                );
                            break;
                        }

                        memoryIndex += elementType.GetSize(vm.chunk);
                    }
                }
            }
            else
            {
                DebugHelper.WriteValue(
                    vm,
                    memoryIndex,
                    path[path.Length - 1],
                    type,
                    sb,
                    writer
                    );

                if (isReferenceType)
                {
                    return;
                }

                if (type.kind == TypeKind.Struct)
                {
                    using var valueWriter = writer.Array("values");
                    var structType = vm.chunk.structTypes.buffer[type.index];
                    for (var i = 0; i < structType.fields.length; i++)
                    {
                        var field = vm.chunk.structTypeFields.buffer[structType.fields.index + i];
                        using var fieldWriter = valueWriter.Object;

                        DebugHelper.WriteValue(
                            vm,
                            memoryIndex,
                            field.name,
                            field.type,
                            sb,
                            fieldWriter
                            );

                        memoryIndex += field.type.GetSize(vm.chunk);
                    }
                }
                else if (type.kind == TypeKind.Tuple)
                {
                    using var valueWriter = writer.Array("values");
                    var tupleType = vm.chunk.tupleTypes.buffer[type.index];
                    for (var i = 0; i < tupleType.elements.length; i++)
                    {
                        var elementType = vm.chunk.tupleElementTypes.buffer[tupleType.elements.index + i];
                        using var elementWriter = valueWriter.Object;

                        DebugHelper.WriteValue(
                            vm,
                            memoryIndex,
                            i.ToString(),
                            elementType,
                            sb,
                            elementWriter
                            );

                        memoryIndex += elementType.GetSize(vm.chunk);
                    }
                }
            }
        }