function doEmitTypes()

in benchmarks/JetStream2/WSL/SPIRVCodegen.js [108:175]

• 66 lines of code
• 25 McCabe index (conditional complexity)

        function doEmitTypes(type)
        {
            if (emittedTypes.has(type[0]))
                return;
            emittedTypes.add(type[0]);
            if (typeof type[1] == "object") {
                if (type[1].fieldTypes) {
                    for (let fieldType of type[1].fieldTypes) {
                        let key = reverseTypeMap.get(fieldType);
                        let value = typeMap.get(key);
                        doEmitTypes([key, value]);
                    }
                    switch (type[0]) {
                    case "struct vec2<> { int32 x; int32 y }":
                    case "struct vec2<> { uint32 x; uint32 y; }":
                    case "struct vec2<> { float32 x; float32 y; }":
                    case "struct vec2<> { float64 x; float64 y; }":
                    case "struct vec3<> { int32 x; int32 y; int32 z; }":
                    case "struct vec3<> { uint32 x; uint32 y; uint32 z; }":
                    case "struct vec3<> { float32 x; float32 y; float32 z; }":
                    case "struct vec3<> { float64 x; float64 y; float64 z; }":
                    case "struct vec4<> { int32 x; int32 y; int32 z; int32 w; }":
                    case "struct vec4<> { uint32 x; uint32 y; uint32 z; uint32 w; }":
                    case "struct vec4<> { float32 x; float32 y; float32 z; float32 w; }":
                    case "struct vec4<> { float64 x; float64 y; float64 z; float64 w; }":
                        assembler.append(new spirv.ops.TypeVector(type[1].id, type[1].fieldTypes[0], type[1].fieldTypes.length));
                        break;
                    default:
                        assembler.append(new spirv.ops.TypeStruct(type[1].id, ...type[1].fieldTypes));
                        break;
                    }
                } else {
                    if (!type[1].elementType)
                        throw new Error("Unknown type!");
            
                    let elementType = type[1].elementType;
                    let key = reverseTypeMap.get(elementType);
                    let value = typeMap.get(key);
                    doEmitTypes([key, value]);

                    let id = currentId++;
                    assembler.append(new spirv.ops.Constant(typeMap.get(program.intrinsics.uint32), id, type[1].numElements));
                    assembler.append(new spirv.ops.TypeArray(type[1].id, elementType, id));
                }
            } else {
                switch (type[0].name) {
                case "void":
                    assembler.append(new spirv.ops.TypeVoid(type[1]));
                    break;
                case "bool":
                    assembler.append(new spirv.ops.TypeBool(type[1]));
                    break;
                case "int32":
                    assembler.append(new spirv.ops.TypeInt(type[1], 32, 1));
                    break;
                case "uint32":
                case "uint8":
                    assembler.append(new spirv.ops.TypeInt(type[1], 32, 0));
                    break;
                case "float32":
                    assembler.append(new spirv.ops.TypeFloat(type[1], 32));
                    break;
                case "float64":
                    assembler.append(new spirv.ops.TypeFloat(type[1], 64));
                    break;
                }
            }
        }