adding types opcodes

Author: Kbz-8

src/Module.zig

@@ -95,23 +95,23 @@ pub fn init(allocator: std.mem.Allocator, source: []const SpvWord) ModuleError!S
 
     self.it = WordIterator.init(self.code);
 
-    const magic = self.it.next() orelse return ModuleError.InvalidSpirV;
+    const magic = self.it.next() catch return ModuleError.InvalidSpirV;
     if (magic != spv.SpvMagicNumber) {
         return ModuleError.InvalidMagic;
     }
     if (!checkEndiannessFromSpvMagic(magic)) {
         return ModuleError.UnsupportedEndianness;
     }
 
-    const version = self.it.next() orelse return ModuleError.InvalidSpirV;
+    const version = self.it.next() catch return ModuleError.InvalidSpirV;
     self.version_major = @intCast((version & 0x00FF0000) >> 16);
     self.version_minor = @intCast((version & 0x0000FF00) >> 8);
 
-    const generator = self.it.next() orelse return ModuleError.InvalidSpirV;
+    const generator = self.it.next() catch return ModuleError.InvalidSpirV;
     self.generator_id = @intCast((generator & 0xFFFF0000) >> 16);
     self.generator_version = @intCast(generator & 0x0000FFFF);
 
-    self.bound = self.it.next() orelse return ModuleError.InvalidSpirV;
+    self.bound = self.it.next() catch return ModuleError.InvalidSpirV;
     self.results.resize(allocator, self.bound) catch return ModuleError.OutOfMemory;
     for (self.results.items) |*result| {
         result.* = Result.init();
@@ -181,7 +181,7 @@ fn checkEndiannessFromSpvMagic(magic: SpvWord) bool {
 fn pass(self: *Self, allocator: std.mem.Allocator, opcodes: std.EnumSet(spv.SpvOp)) ModuleError!void {
     var rt = Runtime.init(self);
     defer rt.deinit();
-    while (rt.it.next()) |opcode_data| {
+    while (rt.it.nextOrNull()) |opcode_data| {
         const word_count = ((opcode_data & (~spv.SpvOpCodeMask)) >> spv.SpvWordCountShift) - 1;
         const opcode = (opcode_data & spv.SpvOpCodeMask);
 

src/Result.zig

@@ -6,20 +6,36 @@ const SpvByte = spv.SpvByte;
 const SpvWord = spv.SpvWord;
 const SpvBool = spv.SpvBool;
 
-const RType = enum {
+const Type = enum {
     None,
     String,
     Extension,
-    Function_type,
+    FunctionType,
     Type,
     Variable,
     Constant,
     Function,
-    Access_chain,
-    Function_parameter,
+    AccessChain,
+    FunctionParameter,
     Label,
 };
 
+const ValueType = enum {
+    Void,
+    Bool,
+    Int,
+    Float,
+    Vector,
+    Matrix,
+    Array,
+    RuntimeArray,
+    Structure,
+    Image,
+    Sampler,
+    SampledImage,
+    Pointer,
+};
+
 const ImageInfo = struct {
     dim: spv.SpvDim,
     depth: SpvByte,
@@ -33,37 +49,81 @@ const ImageInfo = struct {
 const Decoration = struct {
     rtype: spv.SpvDecoration,
     literal_1: SpvWord,
-    literal_2: SpvWord,
+    literal_2: ?SpvWord,
     index: SpvWord,
 };
 
 const Self = @This();
 
 name: ?[]const u8,
-ptr: SpvWord,
 
-storage_class: spv.SpvStorageClass,
 parent: ?*const Self,
 
 member_names: std.ArrayList([]const u8),
 members: std.ArrayList(spv.SpvMember),
 
 decorations: std.ArrayList(Decoration),
 
-/// Only for functions
-return_type: SpvWord,
-
-rtype: RType,
+res_type: Type,
+type_data: union(Type) {
+    None: struct {},
+    String: []const u8,
+    Extension: struct {},
+    FunctionType: struct {
+        return_type: SpvWord,
+    },
+    Type: struct {
+        value_type: ValueType,
+        data: union(ValueType) {
+            Void: struct {},
+            Bool: struct {},
+            Int: struct {
+                bit_length: SpvWord,
+                is_signed: bool,
+            },
+            Float: struct {
+                bit_length: SpvWord,
+            },
+            Vector: struct {
+                components_type: ValueType,
+            },
+            Matrix: struct {
+                column_type: ValueType,
+            },
+            Array: struct {},
+            RuntimeArray: struct {},
+            Structure: struct {},
+            Image: struct {},
+            Sampler: struct {},
+            SampledImage: struct {},
+            Pointer: struct {
+                storage_class: spv.SpvStorageClass,
+            },
+        },
+        member_count: SpvWord = 0,
+        id: SpvWord = 0,
+    },
+    Variable: struct {},
+    Constant: struct {},
+    Function: struct {
+        /// Allocated array
+        params: []SpvWord,
+    },
+    AccessChain: struct {},
+    FunctionParameter: struct {},
+    Label: struct {},
+},
 
 pub fn init() Self {
-    return std.mem.zeroInit(Self, .{
+    return .{
         .name = null,
         .parent = null,
-        .member_names = std.ArrayList([]const u8).empty,
-        .members = std.ArrayList(spv.SpvMember).empty,
-        .decorations = std.ArrayList(Decoration).empty,
-        .rtype = RType.None,
-    });
+        .member_names = .empty,
+        .members = .empty,
+        .decorations = .empty,
+        .res_type = .None,
+        .type_data = undefined,
+    };
 }
 
 pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
@@ -73,6 +133,11 @@ pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
     for (self.member_names.items) |name| {
         allocator.free(name);
     }
+    // FIXME
+    //switch (self.type_data) {
+    //    .Function => |data| allocator.free(data.params),
+    //    else => {},
+    //}
     self.member_names.deinit(allocator);
     self.members.deinit(allocator);
     self.decorations.deinit(allocator);

src/WordIterator.zig

@@ -1,6 +1,8 @@
 const std = @import("std");
 const spv = @import("spv.zig");
 
+const RuntimeError = @import("Runtime.zig").RuntimeError;
+
 const SpvWord = spv.SpvWord;
 
 const Self = @This();
@@ -15,16 +17,22 @@ pub fn init(buffer: []const SpvWord) Self {
     };
 }
 
-pub fn next(self: *Self) ?SpvWord {
+pub fn nextOrNull(self: *Self) ?SpvWord {
     const word = self.peek() orelse return null;
     self.index += 1;
     return word;
 }
 
-pub fn nextAs(self: *Self, comptime E: type) ?E {
-    const word = self.peek() orelse return null;
-    self.index += 1;
-    return std.enums.fromInt(E, word);
+pub inline fn nextAsOrNull(self: *Self, comptime E: type) ?E {
+    return if (self.nextOrNull()) |word| std.enums.fromInt(E, word) else null;
+}
+
+pub inline fn next(self: *Self) RuntimeError!SpvWord {
+    return self.nextOrNull() orelse return RuntimeError.InvalidSpirV;
+}
+
+pub fn nextAs(self: *Self, comptime E: type) RuntimeError!E {
+    return self.nextAsOrNull(E) orelse return RuntimeError.InvalidSpirV;
 }
 
 pub fn peek(self: *const Self) ?SpvWord {