From 6b5e9aec8e0120669cad45056fbf268163b02233 Mon Sep 17 00:00:00 2001 From: Ginger Bill Date: Mon, 12 Jun 2017 15:42:21 +0100 Subject: [PATCH] Pascal style declaration grouping with () --- code/demo.odin | 32 +- core/_preload.odin | 266 ++-- core/bits.odin | 43 +- core/fmt.odin | 15 +- core/hash.odin | 84 +- core/math.odin | 45 +- core/mem.odin | 6 +- core/opengl.odin | 6 +- core/opengl_constants.odin | 2734 ++++++++++++++++++------------------ core/os.odin | 8 +- core/os_linux.odin | 144 +- core/os_windows.odin | 88 +- core/os_x.odin | 153 +- core/raw.odin | 48 +- core/sync.odin | 6 +- core/sync_linux.odin | 6 +- core/sync_windows.odin | 6 +- core/utf16.odin | 15 +- core/utf8.odin | 102 +- src/check_stmt.cpp | 205 +-- src/checker.cpp | 295 ++-- src/ir.cpp | 138 +- src/parser.cpp | 563 +++++--- src/ssa.cpp | 57 +- 24 files changed, 2595 insertions(+), 2470 deletions(-) diff --git a/code/demo.odin b/code/demo.odin index 3a4893934..b6d425915 100644 --- a/code/demo.odin +++ b/code/demo.odin @@ -1,15 +1,23 @@ -import "fmt.odin"; -import "atomics.odin"; -import "bits.odin"; -import "math.odin"; -import "mem.odin"; -import "opengl.odin"; -import "strconv.odin"; -import "strings.odin"; -import "sync.odin"; -import "types.odin"; -import "utf8.odin"; -import "utf16.odin"; +import ( + "fmt.odin"; + "hash.odin"; + "atomics.odin"; + "bits.odin"; + "math.odin"; + "mem.odin"; + "opengl.odin"; + "strconv.odin"; + "strings.odin"; + "sync.odin"; + "types.odin"; + "utf8.odin"; + "utf16.odin"; +) + +const ( + X = 123; + Y = 432; +) proc main() { proc(s: string){ diff --git a/core/_preload.odin b/core/_preload.odin index 2fd021be9..1d65cc1c1 100644 --- a/core/_preload.odin +++ b/core/_preload.odin @@ -1,10 +1,11 @@ #shared_global_scope; -import "os.odin"; -import "fmt.odin"; -import "utf8.odin"; -import "raw.odin"; - +import ( + "os.odin"; + "fmt.odin"; + "utf8.odin"; + "raw.odin"; +) // Naming Conventions: // In general, PascalCase for types and snake_case for values // @@ -24,95 +25,98 @@ import "raw.odin"; // IMPORTANT NOTE(bill): Do not change the order of any of this data // The compiler relies upon this _exact_ order -type TypeInfoEnumValue raw_union { - f: f64, - i: i128, -} -// NOTE(bill): This must match the compiler's -type CallingConvention enum { - Odin = 0, - C = 1, - Std = 2, - Fast = 3, -} +type ( + TypeInfoEnumValue raw_union { + f: f64, + i: i128, + } + // NOTE(bill): This must match the compiler's + CallingConvention enum { + Odin = 0, + C = 1, + Std = 2, + Fast = 3, + } -type TypeInfoRecord struct #ordered { - types: []^TypeInfo, - names: []string, - offsets: []int, // offsets may not be used in tuples - usings: []bool, // usings may not be used in tuples - packed: bool, - ordered: bool, - custom_align: bool, -} + TypeInfoRecord struct #ordered { + types: []^TypeInfo, + names: []string, + offsets: []int, // offsets may not be used in tuples + usings: []bool, // usings may not be used in tuples + packed: bool, + ordered: bool, + custom_align: bool, + } -type TypeInfo union { - size: int, - align: int, + TypeInfo union { + size: int, + align: int, - Named{name: string, base: ^TypeInfo}, - Integer{signed: bool}, - Rune{}, - Float{}, - Complex{}, - String{}, - Boolean{}, - Any{}, - Pointer{ - elem: ^TypeInfo, // nil -> rawptr - }, - Atomic{elem: ^TypeInfo}, - Procedure{ - params: ^TypeInfo, // TypeInfo.Tuple - results: ^TypeInfo, // TypeInfo.Tuple - variadic: bool, - convention: CallingConvention, - }, - Array{ - elem: ^TypeInfo, - elem_size: int, - count: int, - }, - DynamicArray{elem: ^TypeInfo, elem_size: int}, - Slice {elem: ^TypeInfo, elem_size: int}, - Vector {elem: ^TypeInfo, elem_size, count: int}, - Tuple {using record: TypeInfoRecord}, // Only really used for procedures - Struct {using record: TypeInfoRecord}, - RawUnion {using record: TypeInfoRecord}, - Union{ - common_fields: struct { - types: []^TypeInfo, - names: []string, - offsets: []int, // offsets may not be used in tuples + Named{name: string, base: ^TypeInfo}, + Integer{signed: bool}, + Rune{}, + Float{}, + Complex{}, + String{}, + Boolean{}, + Any{}, + Pointer{ + elem: ^TypeInfo, // nil -> rawptr }, - variant_names: []string, - variant_types: []^TypeInfo, - }, - Enum{ - base: ^TypeInfo, - names: []string, - values: []TypeInfoEnumValue, - }, - Map{ - key: ^TypeInfo, - value: ^TypeInfo, - generated_struct: ^TypeInfo, - count: int, // == 0 if dynamic - }, - BitField{ - names: []string, - bits: []i32, - offsets: []i32, - }, -} - + Atomic{elem: ^TypeInfo}, + Procedure{ + params: ^TypeInfo, // TypeInfo.Tuple + results: ^TypeInfo, // TypeInfo.Tuple + variadic: bool, + convention: CallingConvention, + }, + Array{ + elem: ^TypeInfo, + elem_size: int, + count: int, + }, + DynamicArray{elem: ^TypeInfo, elem_size: int}, + Slice {elem: ^TypeInfo, elem_size: int}, + Vector {elem: ^TypeInfo, elem_size, count: int}, + Tuple {using record: TypeInfoRecord}, // Only really used for procedures + Struct {using record: TypeInfoRecord}, + RawUnion {using record: TypeInfoRecord}, + Union{ + common_fields: struct { + types: []^TypeInfo, + names: []string, + offsets: []int, // offsets may not be used in tuples + }, + variant_names: []string, + variant_types: []^TypeInfo, + }, + Enum{ + base: ^TypeInfo, + names: []string, + values: []TypeInfoEnumValue, + }, + Map{ + key: ^TypeInfo, + value: ^TypeInfo, + generated_struct: ^TypeInfo, + count: int, // == 0 if dynamic + }, + BitField{ + names: []string, + bits: []i32, + offsets: []i32, + }, + } +) // NOTE(bill): only the ones that are needed (not all types) // This will be set by the compiler -var __type_table: []TypeInfo; +var ( + __type_table: []TypeInfo; -var __argv__: ^^u8; -var __argc__: i32; + __argv__: ^^u8; + __argc__: i32; +) proc type_info_base(info: ^TypeInfo) -> ^TypeInfo { if info == nil { @@ -151,29 +155,31 @@ proc read_cycle_counter() -> u64 #foreign __llvm_core "llvm.readcyclecounter"; // IMPORTANT NOTE(bill): Must be in this order (as the compiler relies upon it) -type AllocatorMode enum u8 { - Alloc, - Free, - FreeAll, - Resize, -} -type AllocatorProc proc(allocator_data: rawptr, mode: AllocatorMode, - size, alignment: int, - old_memory: rawptr, old_size: int, flags: u64) -> rawptr; -type Allocator struct #ordered { - procedure: AllocatorProc, - data: rawptr, -} +type ( + AllocatorMode enum u8 { + Alloc, + Free, + FreeAll, + Resize, + } + AllocatorProc proc(allocator_data: rawptr, mode: AllocatorMode, + size, alignment: int, + old_memory: rawptr, old_size: int, flags: u64) -> rawptr; + Allocator struct #ordered { + procedure: AllocatorProc, + data: rawptr, + } -type Context struct #ordered { - thread_id: int, + Context struct #ordered { + thread_id: int, - allocator: Allocator, + allocator: Allocator, - user_data: rawptr, - user_index: int, -} + user_data: rawptr, + user_index: int, + } +) #thread_local var __context: Context; @@ -553,33 +559,35 @@ proc __default_hash_string(s: string) -> u128 { const __INITIAL_MAP_CAP = 16; -type __MapKey struct #ordered { - hash: u128, - str: string, -} +type ( + __MapKey struct #ordered { + hash: u128, + str: string, + } -type __MapFindResult struct #ordered { - hash_index: int, - entry_prev: int, - entry_index: int, -} + __MapFindResult struct #ordered { + hash_index: int, + entry_prev: int, + entry_index: int, + } -type __MapEntryHeader struct #ordered { - key: __MapKey, - next: int, -/* - value: Value_Type, -*/ -} + __MapEntryHeader struct #ordered { + key: __MapKey, + next: int, + /* + value: Value_Type, + */ + } -type __MapHeader struct #ordered { - m: ^raw.DynamicMap, - is_key_string: bool, - entry_size: int, - entry_align: int, - value_offset: int, - value_size: int, -} + __MapHeader struct #ordered { + m: ^raw.DynamicMap, + is_key_string: bool, + entry_size: int, + entry_align: int, + value_offset: int, + value_size: int, + } +) proc __dynamic_map_reserve(using header: __MapHeader, cap: int) { __dynamic_array_reserve(&m.hashes, size_of(int), align_of(int), cap); diff --git a/core/bits.odin b/core/bits.odin index 9512c3768..6bda85488 100644 --- a/core/bits.odin +++ b/core/bits.odin @@ -1,27 +1,28 @@ -const U8_MIN = u8(0); -const U16_MIN = u16(0); -const U32_MIN = u32(0); -const U64_MIN = u64(0); -const U128_MIN = u128(0); +const ( + U8_MIN = u8(0); + U16_MIN = u16(0); + U32_MIN = u32(0); + U64_MIN = u64(0); + U128_MIN = u128(0); -const I8_MIN = i8(-0x80); -const I16_MIN = i16(-0x8000); -const I32_MIN = i32(-0x8000_0000); -const I64_MIN = i64(-0x8000_0000_0000_0000); -const I128_MIN = i128(-0x8000_0000_0000_0000_0000_0000_0000_0000); + I8_MIN = i8(-0x80); + I16_MIN = i16(-0x8000); + I32_MIN = i32(-0x8000_0000); + I64_MIN = i64(-0x8000_0000_0000_0000); + I128_MIN = i128(-0x8000_0000_0000_0000_0000_0000_0000_0000); -const U8_MAX = ~u8(0); -const U16_MAX = ~u16(0); -const U32_MAX = ~u32(0); -const U64_MAX = ~u64(0); -const U128_MAX = ~u128(0); - -const I8_MAX = i8(0x7f); -const I16_MAX = i16(0x7fff); -const I32_MAX = i32(0x7fff_ffff); -const I64_MAX = i64(0x7fff_ffff_ffff_ffff); -const I128_MAX = i128(0x7fff_ffff_ffff_ffff_ffff_ffff_ffff_ffff); + U8_MAX = ~u8(0); + U16_MAX = ~u16(0); + U32_MAX = ~u32(0); + U64_MAX = ~u64(0); + U128_MAX = ~u128(0); + I8_MAX = i8(0x7f); + I16_MAX = i16(0x7fff); + I32_MAX = i32(0x7fff_ffff); + I64_MAX = i64(0x7fff_ffff_ffff_ffff); + I128_MAX = i128(0x7fff_ffff_ffff_ffff_ffff_ffff_ffff_ffff); +) proc count_ones(i: u8) -> u8 { proc __llvm_ctpop(u8) -> u8 #foreign __llvm_core "llvm.ctpop.i8"; return __llvm_ctpop(i); } proc count_ones(i: i8) -> i8 { proc __llvm_ctpop(i8) -> i8 #foreign __llvm_core "llvm.ctpop.i8"; return __llvm_ctpop(i); } diff --git a/core/fmt.odin b/core/fmt.odin index 24920d349..d82dc5fdc 100644 --- a/core/fmt.odin +++ b/core/fmt.odin @@ -1,10 +1,11 @@ -import "os.odin"; -import "mem.odin"; -import "utf8.odin"; -import "types.odin"; -import "strconv.odin"; -import "raw.odin"; - +import ( + "os.odin"; + "mem.odin"; + "utf8.odin"; + "types.odin"; + "strconv.odin"; + "raw.odin"; +) const _BUFFER_SIZE = 1<<12; diff --git a/core/hash.odin b/core/hash.odin index df7f3c01b..c0bf5a1fb 100644 --- a/core/hash.odin +++ b/core/hash.odin @@ -1,61 +1,61 @@ -crc32 :: proc(data: []u8) -> u32 { - result := ~u32(0); +proc crc32(data: []u8) -> u32 { + var result = ~u32(0); for b in data { result = result>>8 ~ _crc32_table[(result ~ u32(b)) & 0xff]; } return ~result; } -crc64 :: proc(data: []u8) -> u64 { - result := ~u64(0); +proc crc64(data: []u8) -> u64 { + var result = ~u64(0); for b in data { result = result>>8 ~ _crc64_table[(result ~ u64(b)) & 0xff]; } return ~result; } -fnv32 :: proc(data: []u8) -> u32 { - h: u32 = 0x811c9dc5; +proc fnv32(data: []u8) -> u32 { + var h: u32 = 0x811c9dc5; for b in data { h = (h * 0x01000193) ~ u32(b); } return h; } -fnv64 :: proc(data: []u8) -> u64 { - h: u64 = 0xcbf29ce484222325; +proc fnv64(data: []u8) -> u64 { + var h: u64 = 0xcbf29ce484222325; for b in data { h = (h * 0x100000001b3) ~ u64(b); } return h; } -fnv32a :: proc(data: []u8) -> u32 { - h: u32 = 0x811c9dc5; +proc fnv32a(data: []u8) -> u32 { + var h: u32 = 0x811c9dc5; for b in data { h = (h ~ u32(b)) * 0x01000193; } return h; } -fnv64a :: proc(data: []u8) -> u64 { - h: u64 = 0xcbf29ce484222325; +proc fnv64a(data: []u8) -> u64 { + var h: u64 = 0xcbf29ce484222325; for b in data { h = (h ~ u64(b)) * 0x100000001b3; } return h; } -murmur32 :: proc(data: []u8) -> u32 { - c1_32: u32 : 0xcc9e2d51; - c2_32: u32 : 0x1b873593; +proc murmur32(data: []u8) -> u32 { + const c1_32: u32 = 0xcc9e2d51; + const c2_32: u32 = 0x1b873593; - h1: u32 = 0; - nblocks := len(data)/4; - p := &data[0]; - p1 := p + 4*nblocks; + var h1: u32 = 0; + var nblocks = len(data)/4; + var p = &data[0]; + var p1 = p + 4*nblocks; for ; p < p1; p += 4 { - k1 := ^u32(p)^; + var k1 = ^u32(p)^; k1 *= c1_32; k1 = (k1 << 15) | (k1 >> 17); @@ -66,9 +66,9 @@ murmur32 :: proc(data: []u8) -> u32 { h1 = h1*5 + 0xe6546b64; } - tail := data[nblocks*4 ..]; + var tail = data[nblocks*4 ..]; - k1: u32; + var k1: u32; match len(tail)&3 { case 3: k1 ~= u32(tail[2]) << 16; @@ -95,18 +95,18 @@ murmur32 :: proc(data: []u8) -> u32 { return h1; } -murmur64 :: proc(data: []u8) -> u64 { - SEED :: 0x9747b28c; +proc murmur64(data: []u8) -> u64 { + const SEED = 0x9747b28c; when size_of(int) == 8 { - m :: 0xc6a4a7935bd1e995; - r :: 47; + const m = 0xc6a4a7935bd1e995; + const r = 47; - h: u64 = SEED ~ (u64(len(data)) * m); - data64 := slice_ptr(^u64(&data[0]), len(data)/size_of(u64)); + var h: u64 = SEED ~ (u64(len(data)) * m); + var data64 = slice_ptr(^u64(&data[0]), len(data)/size_of(u64)); for _, i in data64 { - k := data64[i]; + var k = data64[i]; k *= m; k ~= k>>r; @@ -134,18 +134,18 @@ murmur64 :: proc(data: []u8) -> u64 { return h; } else { - m :: 0x5bd1e995; - r :: 24; + const m = 0x5bd1e995; + const r = 24; - h1 := u32(SEED) ~ u32(len(data)); - h2 := u32(SEED) >> 32; + var h1 = u32(SEED) ~ u32(len(data)); + var h2 = u32(SEED) >> 32; - data32 := slice_ptr(cast(^u32)&data[0], len(data)/size_of(u32)); - len := len(data); + var data32 = slice_ptr(cast(^u32)&data[0], len(data)/size_of(u32)); + var len = len(data); - i := 0; + var i = 0; for len >= 8 { - k1, k2: u32; + var k1, k2: u32; k1 = data32[i]; i++; k1 *= m; k1 ~= k1>>r; @@ -164,7 +164,7 @@ murmur64 :: proc(data: []u8) -> u64 { } if len >= 4 { - k1: u32; + var k1: u32; k1 = data32[i]; i++; k1 *= m; k1 ~= k1>>r; @@ -175,7 +175,7 @@ murmur64 :: proc(data: []u8) -> u64 { } // TODO(bill): Fix this - #no_bounds_check data8 := slice_to_bytes(data32[i..])[0..<3]; + #no_bounds_check var data8 = slice_to_bytes(data32[i..])[0..<3]; match len { case 3: h2 ~= u32(data8[2]) << 16; @@ -197,13 +197,13 @@ murmur64 :: proc(data: []u8) -> u64 { h2 ~= h1>>19; h2 *= m; - h := cast(u64)(h1)<<32 | cast(u64)(h2); + var h = cast(u64)(h1)<<32 | cast(u64)(h2); return h; } } -immutable _crc32_table := [256]u32{ +let _crc32_table = [256]u32{ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, @@ -269,7 +269,7 @@ immutable _crc32_table := [256]u32{ 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d, }; -immutable _crc64_table := [256]u64{ +let _crc64_table = [256]u64{ 0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5, 0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a, 0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b, diff --git a/core/math.odin b/core/math.odin index 6cd4556c1..51aa14f64 100644 --- a/core/math.odin +++ b/core/math.odin @@ -1,31 +1,34 @@ -const TAU = 6.28318530717958647692528676655900576; -const PI = 3.14159265358979323846264338327950288; -const ONE_OVER_TAU = 0.636619772367581343075535053490057448; -const ONE_OVER_PI = 0.159154943091895335768883763372514362; +const ( + TAU = 6.28318530717958647692528676655900576; + PI = 3.14159265358979323846264338327950288; + ONE_OVER_TAU = 0.636619772367581343075535053490057448; + ONE_OVER_PI = 0.159154943091895335768883763372514362; -const E = 2.71828182845904523536; -const SQRT_TWO = 1.41421356237309504880168872420969808; -const SQRT_THREE = 1.73205080756887729352744634150587236; -const SQRT_FIVE = 2.23606797749978969640917366873127623; + E = 2.71828182845904523536; + SQRT_TWO = 1.41421356237309504880168872420969808; + SQRT_THREE = 1.73205080756887729352744634150587236; + SQRT_FIVE = 2.23606797749978969640917366873127623; -const LOG_TWO = 0.693147180559945309417232121458176568; -const LOG_TEN = 2.30258509299404568401799145468436421; + LOG_TWO = 0.693147180559945309417232121458176568; + LOG_TEN = 2.30258509299404568401799145468436421; -const EPSILON = 1.19209290e-7; + EPSILON = 1.19209290e-7; -const τ = TAU; -const π = PI; - -type Vec2 [vector 2]f32; -type Vec3 [vector 3]f32; -type Vec4 [vector 4]f32; + τ = TAU; + π = PI; +) +type ( + Vec2 [vector 2]f32; + Vec3 [vector 3]f32; + Vec4 [vector 4]f32; // Column major -type Mat2 [2][2]f32; -type Mat3 [3][3]f32; -type Mat4 [4][4]f32; + Mat2 [2][2]f32; + Mat3 [3][3]f32; + Mat4 [4][4]f32; -type Complex complex64; + Complex complex64; +) proc sqrt(x: f32) -> f32 #foreign __llvm_core "llvm.sqrt.f32"; proc sqrt(x: f64) -> f64 #foreign __llvm_core "llvm.sqrt.f64"; diff --git a/core/mem.odin b/core/mem.odin index 6f55f48f5..359ff31fc 100644 --- a/core/mem.odin +++ b/core/mem.odin @@ -1,5 +1,7 @@ -import "fmt.odin"; -import "os.odin"; +import ( + "fmt.odin"; + "os.odin"; +) proc swap(b: u16) -> u16 #foreign __llvm_core "llvm.bswap.i16"; proc swap(b: u32) -> u32 #foreign __llvm_core "llvm.bswap.i32"; diff --git a/core/opengl.odin b/core/opengl.odin index fe78ba6c5..2f835249c 100644 --- a/core/opengl.odin +++ b/core/opengl.odin @@ -1,7 +1,9 @@ #foreign_system_library lib "opengl32.lib" when ODIN_OS == "windows"; #foreign_system_library lib "gl" when ODIN_OS == "linux"; -import win32 "sys/windows.odin" when ODIN_OS == "windows"; -import "sys/wgl.odin" when ODIN_OS == "windows"; +import ( + win32 "sys/windows.odin" when ODIN_OS == "windows"; + "sys/wgl.odin" when ODIN_OS == "windows"; +) import_load "opengl_constants.odin"; proc Clear (mask: u32) #foreign lib "glClear"; diff --git a/core/opengl_constants.odin b/core/opengl_constants.odin index d112756b6..eff1fd8b6 100644 --- a/core/opengl_constants.odin +++ b/core/opengl_constants.odin @@ -1,1385 +1,1385 @@ +const ( + FALSE = 0; + TRUE = 1; -const FALSE = 0; -const TRUE = 1; + DEPTH_BUFFER_BIT = 0x00000100; + STENCIL_BUFFER_BIT = 0x00000400; + COLOR_BUFFER_BIT = 0x00004000; + POINTS = 0x0000; + LINES = 0x0001; + LINE_LOOP = 0x0002; + LINE_STRIP = 0x0003; + TRIANGLES = 0x0004; + TRIANGLE_STRIP = 0x0005; + TRIANGLE_FAN = 0x0006; + QUADS = 0x0007; + NEVER = 0x0200; + LESS = 0x0201; + EQUAL = 0x0202; + LEQUAL = 0x0203; + GREATER = 0x0204; + NOTEQUAL = 0x0205; + GEQUAL = 0x0206; + ALWAYS = 0x0207; + ZERO = 0; + ONE = 1; + SRC_COLOR = 0x0300; + ONE_MINUS_SRC_COLOR = 0x0301; + SRC_ALPHA = 0x0302; + ONE_MINUS_SRC_ALPHA = 0x0303; + DST_ALPHA = 0x0304; + ONE_MINUS_DST_ALPHA = 0x0305; + DST_COLOR = 0x0306; + ONE_MINUS_DST_COLOR = 0x0307; + SRC_ALPHA_SATURATE = 0x0308; + NONE = 0; + FRONT_LEFT = 0x0400; + FRONT_RIGHT = 0x0401; + BACK_LEFT = 0x0402; + BACK_RIGHT = 0x0403; + FRONT = 0x0404; + BACK = 0x0405; + LEFT = 0x0406; + RIGHT = 0x0407; + FRONT_AND_BACK = 0x0408; + NO_ERROR = 0; + INVALID_ENUM = 0x0500; + INVALID_VALUE = 0x0501; + INVALID_OPERATION = 0x0502; + OUT_OF_MEMORY = 0x0505; + CW = 0x0900; + CCW = 0x0901; + POINT_SIZE = 0x0B11; + POINT_SIZE_RANGE = 0x0B12; + POINT_SIZE_GRANULARITY = 0x0B13; + LINE_SMOOTH = 0x0B20; + LINE_WIDTH = 0x0B21; + LINE_WIDTH_RANGE = 0x0B22; + LINE_WIDTH_GRANULARITY = 0x0B23; + POLYGON_MODE = 0x0B40; + POLYGON_SMOOTH = 0x0B41; + CULL_FACE = 0x0B44; + CULL_FACE_MODE = 0x0B45; + FRONT_FACE = 0x0B46; + DEPTH_RANGE = 0x0B70; + DEPTH_TEST = 0x0B71; + DEPTH_WRITEMASK = 0x0B72; + DEPTH_CLEAR_VALUE = 0x0B73; + DEPTH_FUNC = 0x0B74; + STENCIL_TEST = 0x0B90; + STENCIL_CLEAR_VALUE = 0x0B91; + STENCIL_FUNC = 0x0B92; + STENCIL_VALUE_MASK = 0x0B93; + STENCIL_FAIL = 0x0B94; + STENCIL_PASS_DEPTH_FAIL = 0x0B95; + STENCIL_PASS_DEPTH_PASS = 0x0B96; + STENCIL_REF = 0x0B97; + STENCIL_WRITEMASK = 0x0B98; + VIEWPORT = 0x0BA2; + DITHER = 0x0BD0; + BLEND_DST = 0x0BE0; + BLEND_SRC = 0x0BE1; + BLEND = 0x0BE2; + LOGIC_OP_MODE = 0x0BF0; + COLOR_LOGIC_OP = 0x0BF2; + DRAW_BUFFER = 0x0C01; + READ_BUFFER = 0x0C02; + SCISSOR_BOX = 0x0C10; + SCISSOR_TEST = 0x0C11; + COLOR_CLEAR_VALUE = 0x0C22; + COLOR_WRITEMASK = 0x0C23; + DOUBLEBUFFER = 0x0C32; + STEREO = 0x0C33; + LINE_SMOOTH_HINT = 0x0C52; + POLYGON_SMOOTH_HINT = 0x0C53; + UNPACK_SWAP_BYTES = 0x0CF0; + UNPACK_LSB_FIRST = 0x0CF1; + UNPACK_ROW_LENGTH = 0x0CF2; + UNPACK_SKIP_ROWS = 0x0CF3; + UNPACK_SKIP_PIXELS = 0x0CF4; + UNPACK_ALIGNMENT = 0x0CF5; + PACK_SWAP_BYTES = 0x0D00; + PACK_LSB_FIRST = 0x0D01; + PACK_ROW_LENGTH = 0x0D02; + PACK_SKIP_ROWS = 0x0D03; + PACK_SKIP_PIXELS = 0x0D04; + PACK_ALIGNMENT = 0x0D05; + MAX_TEXTURE_SIZE = 0x0D33; + MAX_VIEWPORT_DIMS = 0x0D3A; + SUBPIXEL_BITS = 0x0D50; + TEXTURE_1D = 0x0DE0; + TEXTURE_2D = 0x0DE1; + POLYGON_OFFSET_UNITS = 0x2A00; + POLYGON_OFFSET_POINT = 0x2A01; + POLYGON_OFFSET_LINE = 0x2A02; + POLYGON_OFFSET_FILL = 0x8037; + POLYGON_OFFSET_FACTOR = 0x8038; + TEXTURE_BINDING_1D = 0x8068; + TEXTURE_BINDING_2D = 0x8069; + TEXTURE_WIDTH = 0x1000; + TEXTURE_HEIGHT = 0x1001; + TEXTURE_INTERNAL_FORMAT = 0x1003; + TEXTURE_BORDER_COLOR = 0x1004; + TEXTURE_RED_SIZE = 0x805C; + TEXTURE_GREEN_SIZE = 0x805D; + TEXTURE_BLUE_SIZE = 0x805E; + TEXTURE_ALPHA_SIZE = 0x805F; + DONT_CARE = 0x1100; + FASTEST = 0x1101; + NICEST = 0x1102; + BYTE = 0x1400; + UNSIGNED_BYTE = 0x1401; + SHORT = 0x1402; + UNSIGNED_SHORT = 0x1403; + INT = 0x1404; + UNSIGNED_INT = 0x1405; + FLOAT = 0x1406; + DOUBLE = 0x140A; + STACK_OVERFLOW = 0x0503; + STACK_UNDERFLOW = 0x0504; + CLEAR = 0x1500; + AND = 0x1501; + AND_REVERSE = 0x1502; + COPY = 0x1503; + AND_INVERTED = 0x1504; + NOOP = 0x1505; + XOR = 0x1506; + OR = 0x1507; + NOR = 0x1508; + EQUIV = 0x1509; + INVERT = 0x150A; + OR_REVERSE = 0x150B; + COPY_INVERTED = 0x150C; + OR_INVERTED = 0x150D; + NAND = 0x150E; + SET = 0x150F; + TEXTURE = 0x1702; + COLOR = 0x1800; + DEPTH = 0x1801; + STENCIL = 0x1802; + STENCIL_INDEX = 0x1901; + DEPTH_COMPONENT = 0x1902; + RED = 0x1903; + GREEN = 0x1904; + BLUE = 0x1905; + ALPHA = 0x1906; + RGB = 0x1907; + RGBA = 0x1908; + POINT = 0x1B00; + LINE = 0x1B01; + FILL = 0x1B02; + KEEP = 0x1E00; + REPLACE = 0x1E01; + INCR = 0x1E02; + DECR = 0x1E03; + VENDOR = 0x1F00; + RENDERER = 0x1F01; + VERSION = 0x1F02; + EXTENSIONS = 0x1F03; + NEAREST = 0x2600; + LINEAR = 0x2601; + NEAREST_MIPMAP_NEAREST = 0x2700; + LINEAR_MIPMAP_NEAREST = 0x2701; + NEAREST_MIPMAP_LINEAR = 0x2702; + LINEAR_MIPMAP_LINEAR = 0x2703; + TEXTURE_MAG_FILTER = 0x2800; + TEXTURE_MIN_FILTER = 0x2801; + TEXTURE_WRAP_S = 0x2802; + TEXTURE_WRAP_T = 0x2803; + PROXY_TEXTURE_1D = 0x8063; + PROXY_TEXTURE_2D = 0x8064; + REPEAT = 0x2901; + R3_G3_B2 = 0x2A10; + RGB4 = 0x804F; + RGB5 = 0x8050; + RGB8 = 0x8051; + RGB10 = 0x8052; + RGB12 = 0x8053; + RGB16 = 0x8054; + RGBA2 = 0x8055; + RGBA4 = 0x8056; + RGB5_A1 = 0x8057; + RGBA8 = 0x8058; + RGB10_A2 = 0x8059; + RGBA12 = 0x805A; + RGBA16 = 0x805B; + VERTEX_ARRAY = 0x8074; -const DEPTH_BUFFER_BIT = 0x00000100; -const STENCIL_BUFFER_BIT = 0x00000400; -const COLOR_BUFFER_BIT = 0x00004000; -const POINTS = 0x0000; -const LINES = 0x0001; -const LINE_LOOP = 0x0002; -const LINE_STRIP = 0x0003; -const TRIANGLES = 0x0004; -const TRIANGLE_STRIP = 0x0005; -const TRIANGLE_FAN = 0x0006; -const QUADS = 0x0007; -const NEVER = 0x0200; -const LESS = 0x0201; -const EQUAL = 0x0202; -const LEQUAL = 0x0203; -const GREATER = 0x0204; -const NOTEQUAL = 0x0205; -const GEQUAL = 0x0206; -const ALWAYS = 0x0207; -const ZERO = 0; -const ONE = 1; -const SRC_COLOR = 0x0300; -const ONE_MINUS_SRC_COLOR = 0x0301; -const SRC_ALPHA = 0x0302; -const ONE_MINUS_SRC_ALPHA = 0x0303; -const DST_ALPHA = 0x0304; -const ONE_MINUS_DST_ALPHA = 0x0305; -const DST_COLOR = 0x0306; -const ONE_MINUS_DST_COLOR = 0x0307; -const SRC_ALPHA_SATURATE = 0x0308; -const NONE = 0; -const FRONT_LEFT = 0x0400; -const FRONT_RIGHT = 0x0401; -const BACK_LEFT = 0x0402; -const BACK_RIGHT = 0x0403; -const FRONT = 0x0404; -const BACK = 0x0405; -const LEFT = 0x0406; -const RIGHT = 0x0407; -const FRONT_AND_BACK = 0x0408; -const NO_ERROR = 0; -const INVALID_ENUM = 0x0500; -const INVALID_VALUE = 0x0501; -const INVALID_OPERATION = 0x0502; -const OUT_OF_MEMORY = 0x0505; -const CW = 0x0900; -const CCW = 0x0901; -const POINT_SIZE = 0x0B11; -const POINT_SIZE_RANGE = 0x0B12; -const POINT_SIZE_GRANULARITY = 0x0B13; -const LINE_SMOOTH = 0x0B20; -const LINE_WIDTH = 0x0B21; -const LINE_WIDTH_RANGE = 0x0B22; -const LINE_WIDTH_GRANULARITY = 0x0B23; -const POLYGON_MODE = 0x0B40; -const POLYGON_SMOOTH = 0x0B41; -const CULL_FACE = 0x0B44; -const CULL_FACE_MODE = 0x0B45; -const FRONT_FACE = 0x0B46; -const DEPTH_RANGE = 0x0B70; -const DEPTH_TEST = 0x0B71; -const DEPTH_WRITEMASK = 0x0B72; -const DEPTH_CLEAR_VALUE = 0x0B73; -const DEPTH_FUNC = 0x0B74; -const STENCIL_TEST = 0x0B90; -const STENCIL_CLEAR_VALUE = 0x0B91; -const STENCIL_FUNC = 0x0B92; -const STENCIL_VALUE_MASK = 0x0B93; -const STENCIL_FAIL = 0x0B94; -const STENCIL_PASS_DEPTH_FAIL = 0x0B95; -const STENCIL_PASS_DEPTH_PASS = 0x0B96; -const STENCIL_REF = 0x0B97; -const STENCIL_WRITEMASK = 0x0B98; -const VIEWPORT = 0x0BA2; -const DITHER = 0x0BD0; -const BLEND_DST = 0x0BE0; -const BLEND_SRC = 0x0BE1; -const BLEND = 0x0BE2; -const LOGIC_OP_MODE = 0x0BF0; -const COLOR_LOGIC_OP = 0x0BF2; -const DRAW_BUFFER = 0x0C01; -const READ_BUFFER = 0x0C02; -const SCISSOR_BOX = 0x0C10; -const SCISSOR_TEST = 0x0C11; -const COLOR_CLEAR_VALUE = 0x0C22; -const COLOR_WRITEMASK = 0x0C23; -const DOUBLEBUFFER = 0x0C32; -const STEREO = 0x0C33; -const LINE_SMOOTH_HINT = 0x0C52; -const POLYGON_SMOOTH_HINT = 0x0C53; -const UNPACK_SWAP_BYTES = 0x0CF0; -const UNPACK_LSB_FIRST = 0x0CF1; -const UNPACK_ROW_LENGTH = 0x0CF2; -const UNPACK_SKIP_ROWS = 0x0CF3; -const UNPACK_SKIP_PIXELS = 0x0CF4; -const UNPACK_ALIGNMENT = 0x0CF5; -const PACK_SWAP_BYTES = 0x0D00; -const PACK_LSB_FIRST = 0x0D01; -const PACK_ROW_LENGTH = 0x0D02; -const PACK_SKIP_ROWS = 0x0D03; -const PACK_SKIP_PIXELS = 0x0D04; -const PACK_ALIGNMENT = 0x0D05; -const MAX_TEXTURE_SIZE = 0x0D33; -const MAX_VIEWPORT_DIMS = 0x0D3A; -const SUBPIXEL_BITS = 0x0D50; -const TEXTURE_1D = 0x0DE0; -const TEXTURE_2D = 0x0DE1; -const POLYGON_OFFSET_UNITS = 0x2A00; -const POLYGON_OFFSET_POINT = 0x2A01; -const POLYGON_OFFSET_LINE = 0x2A02; -const POLYGON_OFFSET_FILL = 0x8037; -const POLYGON_OFFSET_FACTOR = 0x8038; -const TEXTURE_BINDING_1D = 0x8068; -const TEXTURE_BINDING_2D = 0x8069; -const TEXTURE_WIDTH = 0x1000; -const TEXTURE_HEIGHT = 0x1001; -const TEXTURE_INTERNAL_FORMAT = 0x1003; -const TEXTURE_BORDER_COLOR = 0x1004; -const TEXTURE_RED_SIZE = 0x805C; -const TEXTURE_GREEN_SIZE = 0x805D; -const TEXTURE_BLUE_SIZE = 0x805E; -const TEXTURE_ALPHA_SIZE = 0x805F; -const DONT_CARE = 0x1100; -const FASTEST = 0x1101; -const NICEST = 0x1102; -const BYTE = 0x1400; -const UNSIGNED_BYTE = 0x1401; -const SHORT = 0x1402; -const UNSIGNED_SHORT = 0x1403; -const INT = 0x1404; -const UNSIGNED_INT = 0x1405; -const FLOAT = 0x1406; -const DOUBLE = 0x140A; -const STACK_OVERFLOW = 0x0503; -const STACK_UNDERFLOW = 0x0504; -const CLEAR = 0x1500; -const AND = 0x1501; -const AND_REVERSE = 0x1502; -const COPY = 0x1503; -const AND_INVERTED = 0x1504; -const NOOP = 0x1505; -const XOR = 0x1506; -const OR = 0x1507; -const NOR = 0x1508; -const EQUIV = 0x1509; -const INVERT = 0x150A; -const OR_REVERSE = 0x150B; -const COPY_INVERTED = 0x150C; -const OR_INVERTED = 0x150D; -const NAND = 0x150E; -const SET = 0x150F; -const TEXTURE = 0x1702; -const COLOR = 0x1800; -const DEPTH = 0x1801; -const STENCIL = 0x1802; -const STENCIL_INDEX = 0x1901; -const DEPTH_COMPONENT = 0x1902; -const RED = 0x1903; -const GREEN = 0x1904; -const BLUE = 0x1905; -const ALPHA = 0x1906; -const RGB = 0x1907; -const RGBA = 0x1908; -const POINT = 0x1B00; -const LINE = 0x1B01; -const FILL = 0x1B02; -const KEEP = 0x1E00; -const REPLACE = 0x1E01; -const INCR = 0x1E02; -const DECR = 0x1E03; -const VENDOR = 0x1F00; -const RENDERER = 0x1F01; -const VERSION = 0x1F02; -const EXTENSIONS = 0x1F03; -const NEAREST = 0x2600; -const LINEAR = 0x2601; -const NEAREST_MIPMAP_NEAREST = 0x2700; -const LINEAR_MIPMAP_NEAREST = 0x2701; -const NEAREST_MIPMAP_LINEAR = 0x2702; -const LINEAR_MIPMAP_LINEAR = 0x2703; -const TEXTURE_MAG_FILTER = 0x2800; -const TEXTURE_MIN_FILTER = 0x2801; -const TEXTURE_WRAP_S = 0x2802; -const TEXTURE_WRAP_T = 0x2803; -const PROXY_TEXTURE_1D = 0x8063; -const PROXY_TEXTURE_2D = 0x8064; -const REPEAT = 0x2901; -const R3_G3_B2 = 0x2A10; -const RGB4 = 0x804F; -const RGB5 = 0x8050; -const RGB8 = 0x8051; -const RGB10 = 0x8052; -const RGB12 = 0x8053; -const RGB16 = 0x8054; -const RGBA2 = 0x8055; -const RGBA4 = 0x8056; -const RGB5_A1 = 0x8057; -const RGBA8 = 0x8058; -const RGB10_A2 = 0x8059; -const RGBA12 = 0x805A; -const RGBA16 = 0x805B; -const VERTEX_ARRAY = 0x8074; + UNSIGNED_BYTE_3_3_2 = 0x8032; + UNSIGNED_SHORT_4_4_4_4 = 0x8033; + UNSIGNED_SHORT_5_5_5_1 = 0x8034; + UNSIGNED_INT_8_8_8_8 = 0x8035; + UNSIGNED_INT_10_10_10_2 = 0x8036; + TEXTURE_BINDING_3D = 0x806A; + PACK_SKIP_IMAGES = 0x806B; + PACK_IMAGE_HEIGHT = 0x806C; + UNPACK_SKIP_IMAGES = 0x806D; + UNPACK_IMAGE_HEIGHT = 0x806E; + TEXTURE_3D = 0x806F; + PROXY_TEXTURE_3D = 0x8070; + TEXTURE_DEPTH = 0x8071; + TEXTURE_WRAP_R = 0x8072; + MAX_3D_TEXTURE_SIZE = 0x8073; + UNSIGNED_BYTE_2_3_3_REV = 0x8362; + UNSIGNED_SHORT_5_6_5 = 0x8363; + UNSIGNED_SHORT_5_6_5_REV = 0x8364; + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365; + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366; + UNSIGNED_INT_8_8_8_8_REV = 0x8367; + UNSIGNED_INT_2_10_10_10_REV = 0x8368; + BGR = 0x80E0; + BGRA = 0x80E1; + MAX_ELEMENTS_VERTICES = 0x80E8; + MAX_ELEMENTS_INDICES = 0x80E9; + CLAMP_TO_EDGE = 0x812F; + TEXTURE_MIN_LOD = 0x813A; + TEXTURE_MAX_LOD = 0x813B; + TEXTURE_BASE_LEVEL = 0x813C; + TEXTURE_MAX_LEVEL = 0x813D; + SMOOTH_POINT_SIZE_RANGE = 0x0B12; + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13; + SMOOTH_LINE_WIDTH_RANGE = 0x0B22; + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23; + ALIASED_LINE_WIDTH_RANGE = 0x846E; -const UNSIGNED_BYTE_3_3_2 = 0x8032; -const UNSIGNED_SHORT_4_4_4_4 = 0x8033; -const UNSIGNED_SHORT_5_5_5_1 = 0x8034; -const UNSIGNED_INT_8_8_8_8 = 0x8035; -const UNSIGNED_INT_10_10_10_2 = 0x8036; -const TEXTURE_BINDING_3D = 0x806A; -const PACK_SKIP_IMAGES = 0x806B; -const PACK_IMAGE_HEIGHT = 0x806C; -const UNPACK_SKIP_IMAGES = 0x806D; -const UNPACK_IMAGE_HEIGHT = 0x806E; -const TEXTURE_3D = 0x806F; -const PROXY_TEXTURE_3D = 0x8070; -const TEXTURE_DEPTH = 0x8071; -const TEXTURE_WRAP_R = 0x8072; -const MAX_3D_TEXTURE_SIZE = 0x8073; -const UNSIGNED_BYTE_2_3_3_REV = 0x8362; -const UNSIGNED_SHORT_5_6_5 = 0x8363; -const UNSIGNED_SHORT_5_6_5_REV = 0x8364; -const UNSIGNED_SHORT_4_4_4_4_REV = 0x8365; -const UNSIGNED_SHORT_1_5_5_5_REV = 0x8366; -const UNSIGNED_INT_8_8_8_8_REV = 0x8367; -const UNSIGNED_INT_2_10_10_10_REV = 0x8368; -const BGR = 0x80E0; -const BGRA = 0x80E1; -const MAX_ELEMENTS_VERTICES = 0x80E8; -const MAX_ELEMENTS_INDICES = 0x80E9; -const CLAMP_TO_EDGE = 0x812F; -const TEXTURE_MIN_LOD = 0x813A; -const TEXTURE_MAX_LOD = 0x813B; -const TEXTURE_BASE_LEVEL = 0x813C; -const TEXTURE_MAX_LEVEL = 0x813D; -const SMOOTH_POINT_SIZE_RANGE = 0x0B12; -const SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13; -const SMOOTH_LINE_WIDTH_RANGE = 0x0B22; -const SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23; -const ALIASED_LINE_WIDTH_RANGE = 0x846E; + TEXTURE0 = 0x84C0; + TEXTURE1 = 0x84C1; + TEXTURE2 = 0x84C2; + TEXTURE3 = 0x84C3; + TEXTURE4 = 0x84C4; + TEXTURE5 = 0x84C5; + TEXTURE6 = 0x84C6; + TEXTURE7 = 0x84C7; + TEXTURE8 = 0x84C8; + TEXTURE9 = 0x84C9; + TEXTURE10 = 0x84CA; + TEXTURE11 = 0x84CB; + TEXTURE12 = 0x84CC; + TEXTURE13 = 0x84CD; + TEXTURE14 = 0x84CE; + TEXTURE15 = 0x84CF; + TEXTURE16 = 0x84D0; + TEXTURE17 = 0x84D1; + TEXTURE18 = 0x84D2; + TEXTURE19 = 0x84D3; + TEXTURE20 = 0x84D4; + TEXTURE21 = 0x84D5; + TEXTURE22 = 0x84D6; + TEXTURE23 = 0x84D7; + TEXTURE24 = 0x84D8; + TEXTURE25 = 0x84D9; + TEXTURE26 = 0x84DA; + TEXTURE27 = 0x84DB; + TEXTURE28 = 0x84DC; + TEXTURE29 = 0x84DD; + TEXTURE30 = 0x84DE; + TEXTURE31 = 0x84DF; + ACTIVE_TEXTURE = 0x84E0; + MULTISAMPLE = 0x809D; + SAMPLE_ALPHA_TO_COVERAGE = 0x809E; + SAMPLE_ALPHA_TO_ONE = 0x809F; + SAMPLE_COVERAGE = 0x80A0; + SAMPLE_BUFFERS = 0x80A8; + SAMPLES = 0x80A9; + SAMPLE_COVERAGE_VALUE = 0x80AA; + SAMPLE_COVERAGE_INVERT = 0x80AB; + TEXTURE_CUBE_MAP = 0x8513; + TEXTURE_BINDING_CUBE_MAP = 0x8514; + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515; + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516; + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517; + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518; + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519; + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A; + PROXY_TEXTURE_CUBE_MAP = 0x851B; + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C; + COMPRESSED_RGB = 0x84ED; + COMPRESSED_RGBA = 0x84EE; + TEXTURE_COMPRESSION_HINT = 0x84EF; + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0; + TEXTURE_COMPRESSED = 0x86A1; + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2; + COMPRESSED_TEXTURE_FORMATS = 0x86A3; + CLAMP_TO_BORDER = 0x812D; -const TEXTURE0 = 0x84C0; -const TEXTURE1 = 0x84C1; -const TEXTURE2 = 0x84C2; -const TEXTURE3 = 0x84C3; -const TEXTURE4 = 0x84C4; -const TEXTURE5 = 0x84C5; -const TEXTURE6 = 0x84C6; -const TEXTURE7 = 0x84C7; -const TEXTURE8 = 0x84C8; -const TEXTURE9 = 0x84C9; -const TEXTURE10 = 0x84CA; -const TEXTURE11 = 0x84CB; -const TEXTURE12 = 0x84CC; -const TEXTURE13 = 0x84CD; -const TEXTURE14 = 0x84CE; -const TEXTURE15 = 0x84CF; -const TEXTURE16 = 0x84D0; -const TEXTURE17 = 0x84D1; -const TEXTURE18 = 0x84D2; -const TEXTURE19 = 0x84D3; -const TEXTURE20 = 0x84D4; -const TEXTURE21 = 0x84D5; -const TEXTURE22 = 0x84D6; -const TEXTURE23 = 0x84D7; -const TEXTURE24 = 0x84D8; -const TEXTURE25 = 0x84D9; -const TEXTURE26 = 0x84DA; -const TEXTURE27 = 0x84DB; -const TEXTURE28 = 0x84DC; -const TEXTURE29 = 0x84DD; -const TEXTURE30 = 0x84DE; -const TEXTURE31 = 0x84DF; -const ACTIVE_TEXTURE = 0x84E0; -const MULTISAMPLE = 0x809D; -const SAMPLE_ALPHA_TO_COVERAGE = 0x809E; -const SAMPLE_ALPHA_TO_ONE = 0x809F; -const SAMPLE_COVERAGE = 0x80A0; -const SAMPLE_BUFFERS = 0x80A8; -const SAMPLES = 0x80A9; -const SAMPLE_COVERAGE_VALUE = 0x80AA; -const SAMPLE_COVERAGE_INVERT = 0x80AB; -const TEXTURE_CUBE_MAP = 0x8513; -const TEXTURE_BINDING_CUBE_MAP = 0x8514; -const TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515; -const TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516; -const TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517; -const TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518; -const TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519; -const TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A; -const PROXY_TEXTURE_CUBE_MAP = 0x851B; -const MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C; -const COMPRESSED_RGB = 0x84ED; -const COMPRESSED_RGBA = 0x84EE; -const TEXTURE_COMPRESSION_HINT = 0x84EF; -const TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0; -const TEXTURE_COMPRESSED = 0x86A1; -const NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2; -const COMPRESSED_TEXTURE_FORMATS = 0x86A3; -const CLAMP_TO_BORDER = 0x812D; + BLEND_DST_RGB = 0x80C8; + BLEND_SRC_RGB = 0x80C9; + BLEND_DST_ALPHA = 0x80CA; + BLEND_SRC_ALPHA = 0x80CB; + POINT_FADE_THRESHOLD_SIZE = 0x8128; + DEPTH_COMPONENT16 = 0x81A5; + DEPTH_COMPONENT24 = 0x81A6; + DEPTH_COMPONENT32 = 0x81A7; + MIRRORED_REPEAT = 0x8370; + MAX_TEXTURE_LOD_BIAS = 0x84FD; + TEXTURE_LOD_BIAS = 0x8501; + INCR_WRAP = 0x8507; + DECR_WRAP = 0x8508; + TEXTURE_DEPTH_SIZE = 0x884A; + TEXTURE_COMPARE_MODE = 0x884C; + TEXTURE_COMPARE_FUNC = 0x884D; + FUNC_ADD = 0x8006; + FUNC_SUBTRACT = 0x800A; + FUNC_REVERSE_SUBTRACT = 0x800B; + MIN = 0x8007; + MAX = 0x8008; + CONSTANT_COLOR = 0x8001; + ONE_MINUS_CONSTANT_COLOR = 0x8002; + CONSTANT_ALPHA = 0x8003; + ONE_MINUS_CONSTANT_ALPHA = 0x8004; -const BLEND_DST_RGB = 0x80C8; -const BLEND_SRC_RGB = 0x80C9; -const BLEND_DST_ALPHA = 0x80CA; -const BLEND_SRC_ALPHA = 0x80CB; -const POINT_FADE_THRESHOLD_SIZE = 0x8128; -const DEPTH_COMPONENT16 = 0x81A5; -const DEPTH_COMPONENT24 = 0x81A6; -const DEPTH_COMPONENT32 = 0x81A7; -const MIRRORED_REPEAT = 0x8370; -const MAX_TEXTURE_LOD_BIAS = 0x84FD; -const TEXTURE_LOD_BIAS = 0x8501; -const INCR_WRAP = 0x8507; -const DECR_WRAP = 0x8508; -const TEXTURE_DEPTH_SIZE = 0x884A; -const TEXTURE_COMPARE_MODE = 0x884C; -const TEXTURE_COMPARE_FUNC = 0x884D; -const FUNC_ADD = 0x8006; -const FUNC_SUBTRACT = 0x800A; -const FUNC_REVERSE_SUBTRACT = 0x800B; -const MIN = 0x8007; -const MAX = 0x8008; -const CONSTANT_COLOR = 0x8001; -const ONE_MINUS_CONSTANT_COLOR = 0x8002; -const CONSTANT_ALPHA = 0x8003; -const ONE_MINUS_CONSTANT_ALPHA = 0x8004; + BUFFER_SIZE = 0x8764; + BUFFER_USAGE = 0x8765; + QUERY_COUNTER_BITS = 0x8864; + CURRENT_QUERY = 0x8865; + QUERY_RESULT = 0x8866; + QUERY_RESULT_AVAILABLE = 0x8867; + ARRAY_BUFFER = 0x8892; + ELEMENT_ARRAY_BUFFER = 0x8893; + ARRAY_BUFFER_BINDING = 0x8894; + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F; + READ_ONLY = 0x88B8; + WRITE_ONLY = 0x88B9; + READ_WRITE = 0x88BA; + BUFFER_ACCESS = 0x88BB; + BUFFER_MAPPED = 0x88BC; + BUFFER_MAP_POINTER = 0x88BD; + STREAM_DRAW = 0x88E0; + STREAM_READ = 0x88E1; + STREAM_COPY = 0x88E2; + STATIC_DRAW = 0x88E4; + STATIC_READ = 0x88E5; + STATIC_COPY = 0x88E6; + DYNAMIC_DRAW = 0x88E8; + DYNAMIC_READ = 0x88E9; + DYNAMIC_COPY = 0x88EA; + SAMPLES_PASSED = 0x8914; + SRC1_ALPHA = 0x8589; -const BUFFER_SIZE = 0x8764; -const BUFFER_USAGE = 0x8765; -const QUERY_COUNTER_BITS = 0x8864; -const CURRENT_QUERY = 0x8865; -const QUERY_RESULT = 0x8866; -const QUERY_RESULT_AVAILABLE = 0x8867; -const ARRAY_BUFFER = 0x8892; -const ELEMENT_ARRAY_BUFFER = 0x8893; -const ARRAY_BUFFER_BINDING = 0x8894; -const ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; -const VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F; -const READ_ONLY = 0x88B8; -const WRITE_ONLY = 0x88B9; -const READ_WRITE = 0x88BA; -const BUFFER_ACCESS = 0x88BB; -const BUFFER_MAPPED = 0x88BC; -const BUFFER_MAP_POINTER = 0x88BD; -const STREAM_DRAW = 0x88E0; -const STREAM_READ = 0x88E1; -const STREAM_COPY = 0x88E2; -const STATIC_DRAW = 0x88E4; -const STATIC_READ = 0x88E5; -const STATIC_COPY = 0x88E6; -const DYNAMIC_DRAW = 0x88E8; -const DYNAMIC_READ = 0x88E9; -const DYNAMIC_COPY = 0x88EA; -const SAMPLES_PASSED = 0x8914; -const SRC1_ALPHA = 0x8589; + BLEND_EQUATION_RGB = 0x8009; + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622; + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623; + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624; + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625; + CURRENT_VERTEX_ATTRIB = 0x8626; + VERTEX_PROGRAM_POINT_SIZE = 0x8642; + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645; + STENCIL_BACK_FUNC = 0x8800; + STENCIL_BACK_FAIL = 0x8801; + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802; + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803; + MAX_DRAW_BUFFERS = 0x8824; + DRAW_BUFFER0 = 0x8825; + DRAW_BUFFER1 = 0x8826; + DRAW_BUFFER2 = 0x8827; + DRAW_BUFFER3 = 0x8828; + DRAW_BUFFER4 = 0x8829; + DRAW_BUFFER5 = 0x882A; + DRAW_BUFFER6 = 0x882B; + DRAW_BUFFER7 = 0x882C; + DRAW_BUFFER8 = 0x882D; + DRAW_BUFFER9 = 0x882E; + DRAW_BUFFER10 = 0x882F; + DRAW_BUFFER11 = 0x8830; + DRAW_BUFFER12 = 0x8831; + DRAW_BUFFER13 = 0x8832; + DRAW_BUFFER14 = 0x8833; + DRAW_BUFFER15 = 0x8834; + BLEND_EQUATION_ALPHA = 0x883D; + MAX_VERTEX_ATTRIBS = 0x8869; + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A; + MAX_TEXTURE_IMAGE_UNITS = 0x8872; + FRAGMENT_SHADER = 0x8B30; + VERTEX_SHADER = 0x8B31; + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49; + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A; + MAX_VARYING_FLOATS = 0x8B4B; + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C; + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D; + SHADER_TYPE = 0x8B4F; + FLOAT_VEC2 = 0x8B50; + FLOAT_VEC3 = 0x8B51; + FLOAT_VEC4 = 0x8B52; + INT_VEC2 = 0x8B53; + INT_VEC3 = 0x8B54; + INT_VEC4 = 0x8B55; + BOOL = 0x8B56; + BOOL_VEC2 = 0x8B57; + BOOL_VEC3 = 0x8B58; + BOOL_VEC4 = 0x8B59; + FLOAT_MAT2 = 0x8B5A; + FLOAT_MAT3 = 0x8B5B; + FLOAT_MAT4 = 0x8B5C; + SAMPLER_1D = 0x8B5D; + SAMPLER_2D = 0x8B5E; + SAMPLER_3D = 0x8B5F; + SAMPLER_CUBE = 0x8B60; + SAMPLER_1D_SHADOW = 0x8B61; + SAMPLER_2D_SHADOW = 0x8B62; + DELETE_STATUS = 0x8B80; + COMPILE_STATUS = 0x8B81; + LINK_STATUS = 0x8B82; + VALIDATE_STATUS = 0x8B83; + INFO_LOG_LENGTH = 0x8B84; + ATTACHED_SHADERS = 0x8B85; + ACTIVE_UNIFORMS = 0x8B86; + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87; + SHADER_SOURCE_LENGTH = 0x8B88; + ACTIVE_ATTRIBUTES = 0x8B89; + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A; + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B; + SHADING_LANGUAGE_VERSION = 0x8B8C; + CURRENT_PROGRAM = 0x8B8D; + POINT_SPRITE_COORD_ORIGIN = 0x8CA0; + LOWER_LEFT = 0x8CA1; + UPPER_LEFT = 0x8CA2; + STENCIL_BACK_REF = 0x8CA3; + STENCIL_BACK_VALUE_MASK = 0x8CA4; + STENCIL_BACK_WRITEMASK = 0x8CA5; -const BLEND_EQUATION_RGB = 0x8009; -const VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622; -const VERTEX_ATTRIB_ARRAY_SIZE = 0x8623; -const VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624; -const VERTEX_ATTRIB_ARRAY_TYPE = 0x8625; -const CURRENT_VERTEX_ATTRIB = 0x8626; -const VERTEX_PROGRAM_POINT_SIZE = 0x8642; -const VERTEX_ATTRIB_ARRAY_POINTER = 0x8645; -const STENCIL_BACK_FUNC = 0x8800; -const STENCIL_BACK_FAIL = 0x8801; -const STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802; -const STENCIL_BACK_PASS_DEPTH_PASS = 0x8803; -const MAX_DRAW_BUFFERS = 0x8824; -const DRAW_BUFFER0 = 0x8825; -const DRAW_BUFFER1 = 0x8826; -const DRAW_BUFFER2 = 0x8827; -const DRAW_BUFFER3 = 0x8828; -const DRAW_BUFFER4 = 0x8829; -const DRAW_BUFFER5 = 0x882A; -const DRAW_BUFFER6 = 0x882B; -const DRAW_BUFFER7 = 0x882C; -const DRAW_BUFFER8 = 0x882D; -const DRAW_BUFFER9 = 0x882E; -const DRAW_BUFFER10 = 0x882F; -const DRAW_BUFFER11 = 0x8830; -const DRAW_BUFFER12 = 0x8831; -const DRAW_BUFFER13 = 0x8832; -const DRAW_BUFFER14 = 0x8833; -const DRAW_BUFFER15 = 0x8834; -const BLEND_EQUATION_ALPHA = 0x883D; -const MAX_VERTEX_ATTRIBS = 0x8869; -const VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A; -const MAX_TEXTURE_IMAGE_UNITS = 0x8872; -const FRAGMENT_SHADER = 0x8B30; -const VERTEX_SHADER = 0x8B31; -const MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49; -const MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A; -const MAX_VARYING_FLOATS = 0x8B4B; -const MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C; -const MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D; -const SHADER_TYPE = 0x8B4F; -const FLOAT_VEC2 = 0x8B50; -const FLOAT_VEC3 = 0x8B51; -const FLOAT_VEC4 = 0x8B52; -const INT_VEC2 = 0x8B53; -const INT_VEC3 = 0x8B54; -const INT_VEC4 = 0x8B55; -const BOOL = 0x8B56; -const BOOL_VEC2 = 0x8B57; -const BOOL_VEC3 = 0x8B58; -const BOOL_VEC4 = 0x8B59; -const FLOAT_MAT2 = 0x8B5A; -const FLOAT_MAT3 = 0x8B5B; -const FLOAT_MAT4 = 0x8B5C; -const SAMPLER_1D = 0x8B5D; -const SAMPLER_2D = 0x8B5E; -const SAMPLER_3D = 0x8B5F; -const SAMPLER_CUBE = 0x8B60; -const SAMPLER_1D_SHADOW = 0x8B61; -const SAMPLER_2D_SHADOW = 0x8B62; -const DELETE_STATUS = 0x8B80; -const COMPILE_STATUS = 0x8B81; -const LINK_STATUS = 0x8B82; -const VALIDATE_STATUS = 0x8B83; -const INFO_LOG_LENGTH = 0x8B84; -const ATTACHED_SHADERS = 0x8B85; -const ACTIVE_UNIFORMS = 0x8B86; -const ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87; -const SHADER_SOURCE_LENGTH = 0x8B88; -const ACTIVE_ATTRIBUTES = 0x8B89; -const ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A; -const FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B; -const SHADING_LANGUAGE_VERSION = 0x8B8C; -const CURRENT_PROGRAM = 0x8B8D; -const POINT_SPRITE_COORD_ORIGIN = 0x8CA0; -const LOWER_LEFT = 0x8CA1; -const UPPER_LEFT = 0x8CA2; -const STENCIL_BACK_REF = 0x8CA3; -const STENCIL_BACK_VALUE_MASK = 0x8CA4; -const STENCIL_BACK_WRITEMASK = 0x8CA5; + PIXEL_PACK_BUFFER = 0x88EB; + PIXEL_UNPACK_BUFFER = 0x88EC; + PIXEL_PACK_BUFFER_BINDING = 0x88ED; + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF; + FLOAT_MAT2x3 = 0x8B65; + FLOAT_MAT2x4 = 0x8B66; + FLOAT_MAT3x2 = 0x8B67; + FLOAT_MAT3x4 = 0x8B68; + FLOAT_MAT4x2 = 0x8B69; + FLOAT_MAT4x3 = 0x8B6A; + SRGB = 0x8C40; + SRGB8 = 0x8C41; + SRGB_ALPHA = 0x8C42; + SRGB8_ALPHA8 = 0x8C43; + COMPRESSED_SRGB = 0x8C48; + COMPRESSED_SRGB_ALPHA = 0x8C49; -const PIXEL_PACK_BUFFER = 0x88EB; -const PIXEL_UNPACK_BUFFER = 0x88EC; -const PIXEL_PACK_BUFFER_BINDING = 0x88ED; -const PIXEL_UNPACK_BUFFER_BINDING = 0x88EF; -const FLOAT_MAT2x3 = 0x8B65; -const FLOAT_MAT2x4 = 0x8B66; -const FLOAT_MAT3x2 = 0x8B67; -const FLOAT_MAT3x4 = 0x8B68; -const FLOAT_MAT4x2 = 0x8B69; -const FLOAT_MAT4x3 = 0x8B6A; -const SRGB = 0x8C40; -const SRGB8 = 0x8C41; -const SRGB_ALPHA = 0x8C42; -const SRGB8_ALPHA8 = 0x8C43; -const COMPRESSED_SRGB = 0x8C48; -const COMPRESSED_SRGB_ALPHA = 0x8C49; + COMPARE_REF_TO_TEXTURE = 0x884E; + CLIP_DISTANCE0 = 0x3000; + CLIP_DISTANCE1 = 0x3001; + CLIP_DISTANCE2 = 0x3002; + CLIP_DISTANCE3 = 0x3003; + CLIP_DISTANCE4 = 0x3004; + CLIP_DISTANCE5 = 0x3005; + CLIP_DISTANCE6 = 0x3006; + CLIP_DISTANCE7 = 0x3007; + MAX_CLIP_DISTANCES = 0x0D32; + MAJOR_VERSION = 0x821B; + MINOR_VERSION = 0x821C; + NUM_EXTENSIONS = 0x821D; + CONTEXT_FLAGS = 0x821E; + COMPRESSED_RED = 0x8225; + COMPRESSED_RG = 0x8226; + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001; + RGBA32F = 0x8814; + RGB32F = 0x8815; + RGBA16F = 0x881A; + RGB16F = 0x881B; + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD; + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF; + MIN_PROGRAM_TEXEL_OFFSET = 0x8904; + MAX_PROGRAM_TEXEL_OFFSET = 0x8905; + CLAMP_READ_COLOR = 0x891C; + FIXED_ONLY = 0x891D; + MAX_VARYING_COMPONENTS = 0x8B4B; + TEXTURE_1D_ARRAY = 0x8C18; + PROXY_TEXTURE_1D_ARRAY = 0x8C19; + TEXTURE_2D_ARRAY = 0x8C1A; + PROXY_TEXTURE_2D_ARRAY = 0x8C1B; + TEXTURE_BINDING_1D_ARRAY = 0x8C1C; + TEXTURE_BINDING_2D_ARRAY = 0x8C1D; + R11F_G11F_B10F = 0x8C3A; + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B; + RGB9_E5 = 0x8C3D; + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E; + TEXTURE_SHARED_SIZE = 0x8C3F; + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76; + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F; + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80; + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83; + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84; + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85; + PRIMITIVES_GENERATED = 0x8C87; + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88; + RASTERIZER_DISCARD = 0x8C89; + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A; + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B; + INTERLEAVED_ATTRIBS = 0x8C8C; + SEPARATE_ATTRIBS = 0x8C8D; + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E; + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F; + RGBA32UI = 0x8D70; + RGB32UI = 0x8D71; + RGBA16UI = 0x8D76; + RGB16UI = 0x8D77; + RGBA8UI = 0x8D7C; + RGB8UI = 0x8D7D; + RGBA32I = 0x8D82; + RGB32I = 0x8D83; + RGBA16I = 0x8D88; + RGB16I = 0x8D89; + RGBA8I = 0x8D8E; + RGB8I = 0x8D8F; + RED_INTEGER = 0x8D94; + GREEN_INTEGER = 0x8D95; + BLUE_INTEGER = 0x8D96; + RGB_INTEGER = 0x8D98; + RGBA_INTEGER = 0x8D99; + BGR_INTEGER = 0x8D9A; + BGRA_INTEGER = 0x8D9B; + SAMPLER_1D_ARRAY = 0x8DC0; + SAMPLER_2D_ARRAY = 0x8DC1; + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3; + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4; + SAMPLER_CUBE_SHADOW = 0x8DC5; + UNSIGNED_INT_VEC2 = 0x8DC6; + UNSIGNED_INT_VEC3 = 0x8DC7; + UNSIGNED_INT_VEC4 = 0x8DC8; + INT_SAMPLER_1D = 0x8DC9; + INT_SAMPLER_2D = 0x8DCA; + INT_SAMPLER_3D = 0x8DCB; + INT_SAMPLER_CUBE = 0x8DCC; + INT_SAMPLER_1D_ARRAY = 0x8DCE; + INT_SAMPLER_2D_ARRAY = 0x8DCF; + UNSIGNED_INT_SAMPLER_1D = 0x8DD1; + UNSIGNED_INT_SAMPLER_2D = 0x8DD2; + UNSIGNED_INT_SAMPLER_3D = 0x8DD3; + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4; + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6; + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7; + QUERY_WAIT = 0x8E13; + QUERY_NO_WAIT = 0x8E14; + QUERY_BY_REGION_WAIT = 0x8E15; + QUERY_BY_REGION_NO_WAIT = 0x8E16; + BUFFER_ACCESS_FLAGS = 0x911F; + BUFFER_MAP_LENGTH = 0x9120; + BUFFER_MAP_OFFSET = 0x9121; + DEPTH_COMPONENT32F = 0x8CAC; + DEPTH32F_STENCIL8 = 0x8CAD; + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD; + INVALID_FRAMEBUFFER_OPERATION = 0x0506; + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210; + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211; + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212; + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213; + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214; + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215; + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216; + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217; + FRAMEBUFFER_DEFAULT = 0x8218; + FRAMEBUFFER_UNDEFINED = 0x8219; + DEPTH_STENCIL_ATTACHMENT = 0x821A; + MAX_RENDERBUFFER_SIZE = 0x84E8; + DEPTH_STENCIL = 0x84F9; + UNSIGNED_INT_24_8 = 0x84FA; + DEPTH24_STENCIL8 = 0x88F0; + TEXTURE_STENCIL_SIZE = 0x88F1; + TEXTURE_RED_TYPE = 0x8C10; + TEXTURE_GREEN_TYPE = 0x8C11; + TEXTURE_BLUE_TYPE = 0x8C12; + TEXTURE_ALPHA_TYPE = 0x8C13; + TEXTURE_DEPTH_TYPE = 0x8C16; + UNSIGNED_NORMALIZED = 0x8C17; + FRAMEBUFFER_BINDING = 0x8CA6; + DRAW_FRAMEBUFFER_BINDING = 0x8CA6; + RENDERBUFFER_BINDING = 0x8CA7; + READ_FRAMEBUFFER = 0x8CA8; + DRAW_FRAMEBUFFER = 0x8CA9; + READ_FRAMEBUFFER_BINDING = 0x8CAA; + RENDERBUFFER_SAMPLES = 0x8CAB; + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0; + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1; + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2; + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3; + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4; + FRAMEBUFFER_COMPLETE = 0x8CD5; + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6; + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7; + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB; + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC; + FRAMEBUFFER_UNSUPPORTED = 0x8CDD; + MAX_COLOR_ATTACHMENTS = 0x8CDF; + COLOR_ATTACHMENT0 = 0x8CE0; + COLOR_ATTACHMENT1 = 0x8CE1; + COLOR_ATTACHMENT2 = 0x8CE2; + COLOR_ATTACHMENT3 = 0x8CE3; + COLOR_ATTACHMENT4 = 0x8CE4; + COLOR_ATTACHMENT5 = 0x8CE5; + COLOR_ATTACHMENT6 = 0x8CE6; + COLOR_ATTACHMENT7 = 0x8CE7; + COLOR_ATTACHMENT8 = 0x8CE8; + COLOR_ATTACHMENT9 = 0x8CE9; + COLOR_ATTACHMENT10 = 0x8CEA; + COLOR_ATTACHMENT11 = 0x8CEB; + COLOR_ATTACHMENT12 = 0x8CEC; + COLOR_ATTACHMENT13 = 0x8CED; + COLOR_ATTACHMENT14 = 0x8CEE; + COLOR_ATTACHMENT15 = 0x8CEF; + COLOR_ATTACHMENT16 = 0x8CF0; + COLOR_ATTACHMENT17 = 0x8CF1; + COLOR_ATTACHMENT18 = 0x8CF2; + COLOR_ATTACHMENT19 = 0x8CF3; + COLOR_ATTACHMENT20 = 0x8CF4; + COLOR_ATTACHMENT21 = 0x8CF5; + COLOR_ATTACHMENT22 = 0x8CF6; + COLOR_ATTACHMENT23 = 0x8CF7; + COLOR_ATTACHMENT24 = 0x8CF8; + COLOR_ATTACHMENT25 = 0x8CF9; + COLOR_ATTACHMENT26 = 0x8CFA; + COLOR_ATTACHMENT27 = 0x8CFB; + COLOR_ATTACHMENT28 = 0x8CFC; + COLOR_ATTACHMENT29 = 0x8CFD; + COLOR_ATTACHMENT30 = 0x8CFE; + COLOR_ATTACHMENT31 = 0x8CFF; + DEPTH_ATTACHMENT = 0x8D00; + STENCIL_ATTACHMENT = 0x8D20; + FRAMEBUFFER = 0x8D40; + RENDERBUFFER = 0x8D41; + RENDERBUFFER_WIDTH = 0x8D42; + RENDERBUFFER_HEIGHT = 0x8D43; + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44; + STENCIL_INDEX1 = 0x8D46; + STENCIL_INDEX4 = 0x8D47; + STENCIL_INDEX8 = 0x8D48; + STENCIL_INDEX16 = 0x8D49; + RENDERBUFFER_RED_SIZE = 0x8D50; + RENDERBUFFER_GREEN_SIZE = 0x8D51; + RENDERBUFFER_BLUE_SIZE = 0x8D52; + RENDERBUFFER_ALPHA_SIZE = 0x8D53; + RENDERBUFFER_DEPTH_SIZE = 0x8D54; + RENDERBUFFER_STENCIL_SIZE = 0x8D55; + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56; + MAX_SAMPLES = 0x8D57; + FRAMEBUFFER_SRGB = 0x8DB9; + HALF_FLOAT = 0x140B; + MAP_READ_BIT = 0x0001; + MAP_WRITE_BIT = 0x0002; + MAP_INVALIDATE_RANGE_BIT = 0x0004; + MAP_INVALIDATE_BUFFER_BIT = 0x0008; + MAP_FLUSH_EXPLICIT_BIT = 0x0010; + MAP_UNSYNCHRONIZED_BIT = 0x0020; + COMPRESSED_RED_RGTC1 = 0x8DBB; + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC; + COMPRESSED_RG_RGTC2 = 0x8DBD; + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE; + RG = 0x8227; + RG_INTEGER = 0x8228; + R8 = 0x8229; + R16 = 0x822A; + RG8 = 0x822B; + RG16 = 0x822C; + R16F = 0x822D; + R32F = 0x822E; + RG16F = 0x822F; + RG32F = 0x8230; + R8I = 0x8231; + R8UI = 0x8232; + R16I = 0x8233; + R16UI = 0x8234; + R32I = 0x8235; + R32UI = 0x8236; + RG8I = 0x8237; + RG8UI = 0x8238; + RG16I = 0x8239; + RG16UI = 0x823A; + RG32I = 0x823B; + RG32UI = 0x823C; + VERTEX_ARRAY_BINDING = 0x85B5; -const COMPARE_REF_TO_TEXTURE = 0x884E; -const CLIP_DISTANCE0 = 0x3000; -const CLIP_DISTANCE1 = 0x3001; -const CLIP_DISTANCE2 = 0x3002; -const CLIP_DISTANCE3 = 0x3003; -const CLIP_DISTANCE4 = 0x3004; -const CLIP_DISTANCE5 = 0x3005; -const CLIP_DISTANCE6 = 0x3006; -const CLIP_DISTANCE7 = 0x3007; -const MAX_CLIP_DISTANCES = 0x0D32; -const MAJOR_VERSION = 0x821B; -const MINOR_VERSION = 0x821C; -const NUM_EXTENSIONS = 0x821D; -const CONTEXT_FLAGS = 0x821E; -const COMPRESSED_RED = 0x8225; -const COMPRESSED_RG = 0x8226; -const CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001; -const RGBA32F = 0x8814; -const RGB32F = 0x8815; -const RGBA16F = 0x881A; -const RGB16F = 0x881B; -const VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD; -const MAX_ARRAY_TEXTURE_LAYERS = 0x88FF; -const MIN_PROGRAM_TEXEL_OFFSET = 0x8904; -const MAX_PROGRAM_TEXEL_OFFSET = 0x8905; -const CLAMP_READ_COLOR = 0x891C; -const FIXED_ONLY = 0x891D; -const MAX_VARYING_COMPONENTS = 0x8B4B; -const TEXTURE_1D_ARRAY = 0x8C18; -const PROXY_TEXTURE_1D_ARRAY = 0x8C19; -const TEXTURE_2D_ARRAY = 0x8C1A; -const PROXY_TEXTURE_2D_ARRAY = 0x8C1B; -const TEXTURE_BINDING_1D_ARRAY = 0x8C1C; -const TEXTURE_BINDING_2D_ARRAY = 0x8C1D; -const R11F_G11F_B10F = 0x8C3A; -const UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B; -const RGB9_E5 = 0x8C3D; -const UNSIGNED_INT_5_9_9_9_REV = 0x8C3E; -const TEXTURE_SHARED_SIZE = 0x8C3F; -const TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76; -const TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F; -const MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80; -const TRANSFORM_FEEDBACK_VARYINGS = 0x8C83; -const TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84; -const TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85; -const PRIMITIVES_GENERATED = 0x8C87; -const TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88; -const RASTERIZER_DISCARD = 0x8C89; -const MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A; -const MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B; -const INTERLEAVED_ATTRIBS = 0x8C8C; -const SEPARATE_ATTRIBS = 0x8C8D; -const TRANSFORM_FEEDBACK_BUFFER = 0x8C8E; -const TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F; -const RGBA32UI = 0x8D70; -const RGB32UI = 0x8D71; -const RGBA16UI = 0x8D76; -const RGB16UI = 0x8D77; -const RGBA8UI = 0x8D7C; -const RGB8UI = 0x8D7D; -const RGBA32I = 0x8D82; -const RGB32I = 0x8D83; -const RGBA16I = 0x8D88; -const RGB16I = 0x8D89; -const RGBA8I = 0x8D8E; -const RGB8I = 0x8D8F; -const RED_INTEGER = 0x8D94; -const GREEN_INTEGER = 0x8D95; -const BLUE_INTEGER = 0x8D96; -const RGB_INTEGER = 0x8D98; -const RGBA_INTEGER = 0x8D99; -const BGR_INTEGER = 0x8D9A; -const BGRA_INTEGER = 0x8D9B; -const SAMPLER_1D_ARRAY = 0x8DC0; -const SAMPLER_2D_ARRAY = 0x8DC1; -const SAMPLER_1D_ARRAY_SHADOW = 0x8DC3; -const SAMPLER_2D_ARRAY_SHADOW = 0x8DC4; -const SAMPLER_CUBE_SHADOW = 0x8DC5; -const UNSIGNED_INT_VEC2 = 0x8DC6; -const UNSIGNED_INT_VEC3 = 0x8DC7; -const UNSIGNED_INT_VEC4 = 0x8DC8; -const INT_SAMPLER_1D = 0x8DC9; -const INT_SAMPLER_2D = 0x8DCA; -const INT_SAMPLER_3D = 0x8DCB; -const INT_SAMPLER_CUBE = 0x8DCC; -const INT_SAMPLER_1D_ARRAY = 0x8DCE; -const INT_SAMPLER_2D_ARRAY = 0x8DCF; -const UNSIGNED_INT_SAMPLER_1D = 0x8DD1; -const UNSIGNED_INT_SAMPLER_2D = 0x8DD2; -const UNSIGNED_INT_SAMPLER_3D = 0x8DD3; -const UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4; -const UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6; -const UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7; -const QUERY_WAIT = 0x8E13; -const QUERY_NO_WAIT = 0x8E14; -const QUERY_BY_REGION_WAIT = 0x8E15; -const QUERY_BY_REGION_NO_WAIT = 0x8E16; -const BUFFER_ACCESS_FLAGS = 0x911F; -const BUFFER_MAP_LENGTH = 0x9120; -const BUFFER_MAP_OFFSET = 0x9121; -const DEPTH_COMPONENT32F = 0x8CAC; -const DEPTH32F_STENCIL8 = 0x8CAD; -const FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD; -const INVALID_FRAMEBUFFER_OPERATION = 0x0506; -const FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210; -const FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211; -const FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212; -const FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213; -const FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214; -const FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215; -const FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216; -const FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217; -const FRAMEBUFFER_DEFAULT = 0x8218; -const FRAMEBUFFER_UNDEFINED = 0x8219; -const DEPTH_STENCIL_ATTACHMENT = 0x821A; -const MAX_RENDERBUFFER_SIZE = 0x84E8; -const DEPTH_STENCIL = 0x84F9; -const UNSIGNED_INT_24_8 = 0x84FA; -const DEPTH24_STENCIL8 = 0x88F0; -const TEXTURE_STENCIL_SIZE = 0x88F1; -const TEXTURE_RED_TYPE = 0x8C10; -const TEXTURE_GREEN_TYPE = 0x8C11; -const TEXTURE_BLUE_TYPE = 0x8C12; -const TEXTURE_ALPHA_TYPE = 0x8C13; -const TEXTURE_DEPTH_TYPE = 0x8C16; -const UNSIGNED_NORMALIZED = 0x8C17; -const FRAMEBUFFER_BINDING = 0x8CA6; -const DRAW_FRAMEBUFFER_BINDING = 0x8CA6; -const RENDERBUFFER_BINDING = 0x8CA7; -const READ_FRAMEBUFFER = 0x8CA8; -const DRAW_FRAMEBUFFER = 0x8CA9; -const READ_FRAMEBUFFER_BINDING = 0x8CAA; -const RENDERBUFFER_SAMPLES = 0x8CAB; -const FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0; -const FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1; -const FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2; -const FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3; -const FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4; -const FRAMEBUFFER_COMPLETE = 0x8CD5; -const FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6; -const FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7; -const FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB; -const FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC; -const FRAMEBUFFER_UNSUPPORTED = 0x8CDD; -const MAX_COLOR_ATTACHMENTS = 0x8CDF; -const COLOR_ATTACHMENT0 = 0x8CE0; -const COLOR_ATTACHMENT1 = 0x8CE1; -const COLOR_ATTACHMENT2 = 0x8CE2; -const COLOR_ATTACHMENT3 = 0x8CE3; -const COLOR_ATTACHMENT4 = 0x8CE4; -const COLOR_ATTACHMENT5 = 0x8CE5; -const COLOR_ATTACHMENT6 = 0x8CE6; -const COLOR_ATTACHMENT7 = 0x8CE7; -const COLOR_ATTACHMENT8 = 0x8CE8; -const COLOR_ATTACHMENT9 = 0x8CE9; -const COLOR_ATTACHMENT10 = 0x8CEA; -const COLOR_ATTACHMENT11 = 0x8CEB; -const COLOR_ATTACHMENT12 = 0x8CEC; -const COLOR_ATTACHMENT13 = 0x8CED; -const COLOR_ATTACHMENT14 = 0x8CEE; -const COLOR_ATTACHMENT15 = 0x8CEF; -const COLOR_ATTACHMENT16 = 0x8CF0; -const COLOR_ATTACHMENT17 = 0x8CF1; -const COLOR_ATTACHMENT18 = 0x8CF2; -const COLOR_ATTACHMENT19 = 0x8CF3; -const COLOR_ATTACHMENT20 = 0x8CF4; -const COLOR_ATTACHMENT21 = 0x8CF5; -const COLOR_ATTACHMENT22 = 0x8CF6; -const COLOR_ATTACHMENT23 = 0x8CF7; -const COLOR_ATTACHMENT24 = 0x8CF8; -const COLOR_ATTACHMENT25 = 0x8CF9; -const COLOR_ATTACHMENT26 = 0x8CFA; -const COLOR_ATTACHMENT27 = 0x8CFB; -const COLOR_ATTACHMENT28 = 0x8CFC; -const COLOR_ATTACHMENT29 = 0x8CFD; -const COLOR_ATTACHMENT30 = 0x8CFE; -const COLOR_ATTACHMENT31 = 0x8CFF; -const DEPTH_ATTACHMENT = 0x8D00; -const STENCIL_ATTACHMENT = 0x8D20; -const FRAMEBUFFER = 0x8D40; -const RENDERBUFFER = 0x8D41; -const RENDERBUFFER_WIDTH = 0x8D42; -const RENDERBUFFER_HEIGHT = 0x8D43; -const RENDERBUFFER_INTERNAL_FORMAT = 0x8D44; -const STENCIL_INDEX1 = 0x8D46; -const STENCIL_INDEX4 = 0x8D47; -const STENCIL_INDEX8 = 0x8D48; -const STENCIL_INDEX16 = 0x8D49; -const RENDERBUFFER_RED_SIZE = 0x8D50; -const RENDERBUFFER_GREEN_SIZE = 0x8D51; -const RENDERBUFFER_BLUE_SIZE = 0x8D52; -const RENDERBUFFER_ALPHA_SIZE = 0x8D53; -const RENDERBUFFER_DEPTH_SIZE = 0x8D54; -const RENDERBUFFER_STENCIL_SIZE = 0x8D55; -const FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56; -const MAX_SAMPLES = 0x8D57; -const FRAMEBUFFER_SRGB = 0x8DB9; -const HALF_FLOAT = 0x140B; -const MAP_READ_BIT = 0x0001; -const MAP_WRITE_BIT = 0x0002; -const MAP_INVALIDATE_RANGE_BIT = 0x0004; -const MAP_INVALIDATE_BUFFER_BIT = 0x0008; -const MAP_FLUSH_EXPLICIT_BIT = 0x0010; -const MAP_UNSYNCHRONIZED_BIT = 0x0020; -const COMPRESSED_RED_RGTC1 = 0x8DBB; -const COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC; -const COMPRESSED_RG_RGTC2 = 0x8DBD; -const COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE; -const RG = 0x8227; -const RG_INTEGER = 0x8228; -const R8 = 0x8229; -const R16 = 0x822A; -const RG8 = 0x822B; -const RG16 = 0x822C; -const R16F = 0x822D; -const R32F = 0x822E; -const RG16F = 0x822F; -const RG32F = 0x8230; -const R8I = 0x8231; -const R8UI = 0x8232; -const R16I = 0x8233; -const R16UI = 0x8234; -const R32I = 0x8235; -const R32UI = 0x8236; -const RG8I = 0x8237; -const RG8UI = 0x8238; -const RG16I = 0x8239; -const RG16UI = 0x823A; -const RG32I = 0x823B; -const RG32UI = 0x823C; -const VERTEX_ARRAY_BINDING = 0x85B5; + SAMPLER_2D_RECT = 0x8B63; + SAMPLER_2D_RECT_SHADOW = 0x8B64; + SAMPLER_BUFFER = 0x8DC2; + INT_SAMPLER_2D_RECT = 0x8DCD; + INT_SAMPLER_BUFFER = 0x8DD0; + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5; + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8; + TEXTURE_BUFFER = 0x8C2A; + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B; + TEXTURE_BINDING_BUFFER = 0x8C2C; + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D; + TEXTURE_RECTANGLE = 0x84F5; + TEXTURE_BINDING_RECTANGLE = 0x84F6; + PROXY_TEXTURE_RECTANGLE = 0x84F7; + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8; + R8_SNORM = 0x8F94; + RG8_SNORM = 0x8F95; + RGB8_SNORM = 0x8F96; + RGBA8_SNORM = 0x8F97; + R16_SNORM = 0x8F98; + RG16_SNORM = 0x8F99; + RGB16_SNORM = 0x8F9A; + RGBA16_SNORM = 0x8F9B; + SIGNED_NORMALIZED = 0x8F9C; + PRIMITIVE_RESTART = 0x8F9D; + PRIMITIVE_RESTART_INDEX = 0x8F9E; + COPY_READ_BUFFER = 0x8F36; + COPY_WRITE_BUFFER = 0x8F37; + UNIFORM_BUFFER = 0x8A11; + UNIFORM_BUFFER_BINDING = 0x8A28; + UNIFORM_BUFFER_START = 0x8A29; + UNIFORM_BUFFER_SIZE = 0x8A2A; + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B; + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C; + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D; + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E; + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F; + MAX_UNIFORM_BLOCK_SIZE = 0x8A30; + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31; + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32; + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33; + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34; + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35; + ACTIVE_UNIFORM_BLOCKS = 0x8A36; + UNIFORM_TYPE = 0x8A37; + UNIFORM_SIZE = 0x8A38; + UNIFORM_NAME_LENGTH = 0x8A39; + UNIFORM_BLOCK_INDEX = 0x8A3A; + UNIFORM_OFFSET = 0x8A3B; + UNIFORM_ARRAY_STRIDE = 0x8A3C; + UNIFORM_MATRIX_STRIDE = 0x8A3D; + UNIFORM_IS_ROW_MAJOR = 0x8A3E; + UNIFORM_BLOCK_BINDING = 0x8A3F; + UNIFORM_BLOCK_DATA_SIZE = 0x8A40; + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41; + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42; + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43; + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44; + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45; + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46; + INVALID_INDEX = 0xFFFFFFFF; -const SAMPLER_2D_RECT = 0x8B63; -const SAMPLER_2D_RECT_SHADOW = 0x8B64; -const SAMPLER_BUFFER = 0x8DC2; -const INT_SAMPLER_2D_RECT = 0x8DCD; -const INT_SAMPLER_BUFFER = 0x8DD0; -const UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5; -const UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8; -const TEXTURE_BUFFER = 0x8C2A; -const MAX_TEXTURE_BUFFER_SIZE = 0x8C2B; -const TEXTURE_BINDING_BUFFER = 0x8C2C; -const TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D; -const TEXTURE_RECTANGLE = 0x84F5; -const TEXTURE_BINDING_RECTANGLE = 0x84F6; -const PROXY_TEXTURE_RECTANGLE = 0x84F7; -const MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8; -const R8_SNORM = 0x8F94; -const RG8_SNORM = 0x8F95; -const RGB8_SNORM = 0x8F96; -const RGBA8_SNORM = 0x8F97; -const R16_SNORM = 0x8F98; -const RG16_SNORM = 0x8F99; -const RGB16_SNORM = 0x8F9A; -const RGBA16_SNORM = 0x8F9B; -const SIGNED_NORMALIZED = 0x8F9C; -const PRIMITIVE_RESTART = 0x8F9D; -const PRIMITIVE_RESTART_INDEX = 0x8F9E; -const COPY_READ_BUFFER = 0x8F36; -const COPY_WRITE_BUFFER = 0x8F37; -const UNIFORM_BUFFER = 0x8A11; -const UNIFORM_BUFFER_BINDING = 0x8A28; -const UNIFORM_BUFFER_START = 0x8A29; -const UNIFORM_BUFFER_SIZE = 0x8A2A; -const MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B; -const MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C; -const MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D; -const MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E; -const MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F; -const MAX_UNIFORM_BLOCK_SIZE = 0x8A30; -const MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31; -const MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32; -const MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33; -const UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34; -const ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35; -const ACTIVE_UNIFORM_BLOCKS = 0x8A36; -const UNIFORM_TYPE = 0x8A37; -const UNIFORM_SIZE = 0x8A38; -const UNIFORM_NAME_LENGTH = 0x8A39; -const UNIFORM_BLOCK_INDEX = 0x8A3A; -const UNIFORM_OFFSET = 0x8A3B; -const UNIFORM_ARRAY_STRIDE = 0x8A3C; -const UNIFORM_MATRIX_STRIDE = 0x8A3D; -const UNIFORM_IS_ROW_MAJOR = 0x8A3E; -const UNIFORM_BLOCK_BINDING = 0x8A3F; -const UNIFORM_BLOCK_DATA_SIZE = 0x8A40; -const UNIFORM_BLOCK_NAME_LENGTH = 0x8A41; -const UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42; -const UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43; -const UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44; -const UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45; -const UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46; -const INVALID_INDEX = 0xFFFFFFFF; + CONTEXT_CORE_PROFILE_BIT = 0x00000001; + CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002; + LINES_ADJACENCY = 0x000A; + LINE_STRIP_ADJACENCY = 0x000B; + TRIANGLES_ADJACENCY = 0x000C; + TRIANGLE_STRIP_ADJACENCY = 0x000D; + PROGRAM_POINT_SIZE = 0x8642; + MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29; + FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7; + FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8; + GEOMETRY_SHADER = 0x8DD9; + GEOMETRY_VERTICES_OUT = 0x8916; + GEOMETRY_INPUT_TYPE = 0x8917; + GEOMETRY_OUTPUT_TYPE = 0x8918; + MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF; + MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0; + MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1; + MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122; + MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123; + MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124; + MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125; + CONTEXT_PROFILE_MASK = 0x9126; + DEPTH_CLAMP = 0x864F; + QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C; + FIRST_VERTEX_CONVENTION = 0x8E4D; + LAST_VERTEX_CONVENTION = 0x8E4E; + PROVOKING_VERTEX = 0x8E4F; + TEXTURE_CUBE_MAP_SEAMLESS = 0x884F; + MAX_SERVER_WAIT_TIMEOUT = 0x9111; + OBJECT_TYPE = 0x9112; + SYNC_CONDITION = 0x9113; + SYNC_STATUS = 0x9114; + SYNC_FLAGS = 0x9115; + SYNC_FENCE = 0x9116; + SYNC_GPU_COMMANDS_COMPLETE = 0x9117; + UNSIGNALED = 0x9118; + SIGNALED = 0x9119; + ALREADY_SIGNALED = 0x911A; + TIMEOUT_EXPIRED = 0x911B; + CONDITION_SATISFIED = 0x911C; + WAIT_FAILED = 0x911D; + TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF; + SYNC_FLUSH_COMMANDS_BIT = 0x00000001; + SAMPLE_POSITION = 0x8E50; + SAMPLE_MASK = 0x8E51; + SAMPLE_MASK_VALUE = 0x8E52; + MAX_SAMPLE_MASK_WORDS = 0x8E59; + TEXTURE_2D_MULTISAMPLE = 0x9100; + PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101; + TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102; + PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103; + TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104; + TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105; + TEXTURE_SAMPLES = 0x9106; + TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107; + SAMPLER_2D_MULTISAMPLE = 0x9108; + INT_SAMPLER_2D_MULTISAMPLE = 0x9109; + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A; + SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B; + INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C; + UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D; + MAX_COLOR_TEXTURE_SAMPLES = 0x910E; + MAX_DEPTH_TEXTURE_SAMPLES = 0x910F; + MAX_INTEGER_SAMPLES = 0x9110; -const CONTEXT_CORE_PROFILE_BIT = 0x00000001; -const CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002; -const LINES_ADJACENCY = 0x000A; -const LINE_STRIP_ADJACENCY = 0x000B; -const TRIANGLES_ADJACENCY = 0x000C; -const TRIANGLE_STRIP_ADJACENCY = 0x000D; -const PROGRAM_POINT_SIZE = 0x8642; -const MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29; -const FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7; -const FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8; -const GEOMETRY_SHADER = 0x8DD9; -const GEOMETRY_VERTICES_OUT = 0x8916; -const GEOMETRY_INPUT_TYPE = 0x8917; -const GEOMETRY_OUTPUT_TYPE = 0x8918; -const MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF; -const MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0; -const MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1; -const MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122; -const MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123; -const MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124; -const MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125; -const CONTEXT_PROFILE_MASK = 0x9126; -const DEPTH_CLAMP = 0x864F; -const QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C; -const FIRST_VERTEX_CONVENTION = 0x8E4D; -const LAST_VERTEX_CONVENTION = 0x8E4E; -const PROVOKING_VERTEX = 0x8E4F; -const TEXTURE_CUBE_MAP_SEAMLESS = 0x884F; -const MAX_SERVER_WAIT_TIMEOUT = 0x9111; -const OBJECT_TYPE = 0x9112; -const SYNC_CONDITION = 0x9113; -const SYNC_STATUS = 0x9114; -const SYNC_FLAGS = 0x9115; -const SYNC_FENCE = 0x9116; -const SYNC_GPU_COMMANDS_COMPLETE = 0x9117; -const UNSIGNALED = 0x9118; -const SIGNALED = 0x9119; -const ALREADY_SIGNALED = 0x911A; -const TIMEOUT_EXPIRED = 0x911B; -const CONDITION_SATISFIED = 0x911C; -const WAIT_FAILED = 0x911D; -const TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF; -const SYNC_FLUSH_COMMANDS_BIT = 0x00000001; -const SAMPLE_POSITION = 0x8E50; -const SAMPLE_MASK = 0x8E51; -const SAMPLE_MASK_VALUE = 0x8E52; -const MAX_SAMPLE_MASK_WORDS = 0x8E59; -const TEXTURE_2D_MULTISAMPLE = 0x9100; -const PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101; -const TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102; -const PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103; -const TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104; -const TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105; -const TEXTURE_SAMPLES = 0x9106; -const TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107; -const SAMPLER_2D_MULTISAMPLE = 0x9108; -const INT_SAMPLER_2D_MULTISAMPLE = 0x9109; -const UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A; -const SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B; -const INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C; -const UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D; -const MAX_COLOR_TEXTURE_SAMPLES = 0x910E; -const MAX_DEPTH_TEXTURE_SAMPLES = 0x910F; -const MAX_INTEGER_SAMPLES = 0x9110; + VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE; + SRC1_COLOR = 0x88F9; + ONE_MINUS_SRC1_COLOR = 0x88FA; + ONE_MINUS_SRC1_ALPHA = 0x88FB; + MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC; + ANY_SAMPLES_PASSED = 0x8C2F; + SAMPLER_BINDING = 0x8919; + RGB10_A2UI = 0x906F; + TEXTURE_SWIZZLE_R = 0x8E42; + TEXTURE_SWIZZLE_G = 0x8E43; + TEXTURE_SWIZZLE_B = 0x8E44; + TEXTURE_SWIZZLE_A = 0x8E45; + TEXTURE_SWIZZLE_RGBA = 0x8E46; + TIME_ELAPSED = 0x88BF; + TIMESTAMP = 0x8E28; + INT_2_10_10_10_REV = 0x8D9F; -const VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE; -const SRC1_COLOR = 0x88F9; -const ONE_MINUS_SRC1_COLOR = 0x88FA; -const ONE_MINUS_SRC1_ALPHA = 0x88FB; -const MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC; -const ANY_SAMPLES_PASSED = 0x8C2F; -const SAMPLER_BINDING = 0x8919; -const RGB10_A2UI = 0x906F; -const TEXTURE_SWIZZLE_R = 0x8E42; -const TEXTURE_SWIZZLE_G = 0x8E43; -const TEXTURE_SWIZZLE_B = 0x8E44; -const TEXTURE_SWIZZLE_A = 0x8E45; -const TEXTURE_SWIZZLE_RGBA = 0x8E46; -const TIME_ELAPSED = 0x88BF; -const TIMESTAMP = 0x8E28; -const INT_2_10_10_10_REV = 0x8D9F; + SAMPLE_SHADING = 0x8C36; + MIN_SAMPLE_SHADING_VALUE = 0x8C37; + MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E; + MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F; + TEXTURE_CUBE_MAP_ARRAY = 0x9009; + TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A; + PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B; + SAMPLER_CUBE_MAP_ARRAY = 0x900C; + SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D; + INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E; + UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F; + DRAW_INDIRECT_BUFFER = 0x8F3F; + DRAW_INDIRECT_BUFFER_BINDING = 0x8F43; + GEOMETRY_SHADER_INVOCATIONS = 0x887F; + MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A; + MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B; + MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C; + FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D; + MAX_VERTEX_STREAMS = 0x8E71; + DOUBLE_VEC2 = 0x8FFC; + DOUBLE_VEC3 = 0x8FFD; + DOUBLE_VEC4 = 0x8FFE; + DOUBLE_MAT2 = 0x8F46; + DOUBLE_MAT3 = 0x8F47; + DOUBLE_MAT4 = 0x8F48; + DOUBLE_MAT2x3 = 0x8F49; + DOUBLE_MAT2x4 = 0x8F4A; + DOUBLE_MAT3x2 = 0x8F4B; + DOUBLE_MAT3x4 = 0x8F4C; + DOUBLE_MAT4x2 = 0x8F4D; + DOUBLE_MAT4x3 = 0x8F4E; + ACTIVE_SUBROUTINES = 0x8DE5; + ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6; + ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47; + ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48; + ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49; + MAX_SUBROUTINES = 0x8DE7; + MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8; + NUM_COMPATIBLE_SUBROUTINES = 0x8E4A; + COMPATIBLE_SUBROUTINES = 0x8E4B; + PATCHES = 0x000E; + PATCH_VERTICES = 0x8E72; + PATCH_DEFAULT_INNER_LEVEL = 0x8E73; + PATCH_DEFAULT_OUTER_LEVEL = 0x8E74; + TESS_CONTROL_OUTPUT_VERTICES = 0x8E75; + TESS_GEN_MODE = 0x8E76; + TESS_GEN_SPACING = 0x8E77; + TESS_GEN_VERTEX_ORDER = 0x8E78; + TESS_GEN_POINT_MODE = 0x8E79; + ISOLINES = 0x8E7A; + FRACTIONAL_ODD = 0x8E7B; + FRACTIONAL_EVEN = 0x8E7C; + MAX_PATCH_VERTICES = 0x8E7D; + MAX_TESS_GEN_LEVEL = 0x8E7E; + MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F; + MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80; + MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81; + MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82; + MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83; + MAX_TESS_PATCH_COMPONENTS = 0x8E84; + MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85; + MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86; + MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89; + MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A; + MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C; + MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D; + MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E; + MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F; + UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0; + UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1; + TESS_EVALUATION_SHADER = 0x8E87; + TESS_CONTROL_SHADER = 0x8E88; + TRANSFORM_FEEDBACK = 0x8E22; + TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23; + TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24; + TRANSFORM_FEEDBACK_BINDING = 0x8E25; + MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70; -const SAMPLE_SHADING = 0x8C36; -const MIN_SAMPLE_SHADING_VALUE = 0x8C37; -const MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E; -const MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F; -const TEXTURE_CUBE_MAP_ARRAY = 0x9009; -const TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A; -const PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B; -const SAMPLER_CUBE_MAP_ARRAY = 0x900C; -const SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D; -const INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E; -const UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F; -const DRAW_INDIRECT_BUFFER = 0x8F3F; -const DRAW_INDIRECT_BUFFER_BINDING = 0x8F43; -const GEOMETRY_SHADER_INVOCATIONS = 0x887F; -const MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A; -const MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B; -const MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C; -const FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D; -const MAX_VERTEX_STREAMS = 0x8E71; -const DOUBLE_VEC2 = 0x8FFC; -const DOUBLE_VEC3 = 0x8FFD; -const DOUBLE_VEC4 = 0x8FFE; -const DOUBLE_MAT2 = 0x8F46; -const DOUBLE_MAT3 = 0x8F47; -const DOUBLE_MAT4 = 0x8F48; -const DOUBLE_MAT2x3 = 0x8F49; -const DOUBLE_MAT2x4 = 0x8F4A; -const DOUBLE_MAT3x2 = 0x8F4B; -const DOUBLE_MAT3x4 = 0x8F4C; -const DOUBLE_MAT4x2 = 0x8F4D; -const DOUBLE_MAT4x3 = 0x8F4E; -const ACTIVE_SUBROUTINES = 0x8DE5; -const ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6; -const ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47; -const ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48; -const ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49; -const MAX_SUBROUTINES = 0x8DE7; -const MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8; -const NUM_COMPATIBLE_SUBROUTINES = 0x8E4A; -const COMPATIBLE_SUBROUTINES = 0x8E4B; -const PATCHES = 0x000E; -const PATCH_VERTICES = 0x8E72; -const PATCH_DEFAULT_INNER_LEVEL = 0x8E73; -const PATCH_DEFAULT_OUTER_LEVEL = 0x8E74; -const TESS_CONTROL_OUTPUT_VERTICES = 0x8E75; -const TESS_GEN_MODE = 0x8E76; -const TESS_GEN_SPACING = 0x8E77; -const TESS_GEN_VERTEX_ORDER = 0x8E78; -const TESS_GEN_POINT_MODE = 0x8E79; -const ISOLINES = 0x8E7A; -const FRACTIONAL_ODD = 0x8E7B; -const FRACTIONAL_EVEN = 0x8E7C; -const MAX_PATCH_VERTICES = 0x8E7D; -const MAX_TESS_GEN_LEVEL = 0x8E7E; -const MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F; -const MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80; -const MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81; -const MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82; -const MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83; -const MAX_TESS_PATCH_COMPONENTS = 0x8E84; -const MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85; -const MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86; -const MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89; -const MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A; -const MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C; -const MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D; -const MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E; -const MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F; -const UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0; -const UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1; -const TESS_EVALUATION_SHADER = 0x8E87; -const TESS_CONTROL_SHADER = 0x8E88; -const TRANSFORM_FEEDBACK = 0x8E22; -const TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23; -const TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24; -const TRANSFORM_FEEDBACK_BINDING = 0x8E25; -const MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70; + FIXED = 0x140C; + IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A; + IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B; + LOW_FLOAT = 0x8DF0; + MEDIUM_FLOAT = 0x8DF1; + HIGH_FLOAT = 0x8DF2; + LOW_INT = 0x8DF3; + MEDIUM_INT = 0x8DF4; + HIGH_INT = 0x8DF5; + SHADER_COMPILER = 0x8DFA; + SHADER_BINARY_FORMATS = 0x8DF8; + NUM_SHADER_BINARY_FORMATS = 0x8DF9; + MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB; + MAX_VARYING_VECTORS = 0x8DFC; + MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD; + RGB565 = 0x8D62; + PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257; + PROGRAM_BINARY_LENGTH = 0x8741; + NUM_PROGRAM_BINARY_FORMATS = 0x87FE; + PROGRAM_BINARY_FORMATS = 0x87FF; + VERTEX_SHADER_BIT = 0x00000001; + FRAGMENT_SHADER_BIT = 0x00000002; + GEOMETRY_SHADER_BIT = 0x00000004; + TESS_CONTROL_SHADER_BIT = 0x00000008; + TESS_EVALUATION_SHADER_BIT = 0x00000010; + ALL_SHADER_BITS = 0xFFFFFFFF; + PROGRAM_SEPARABLE = 0x8258; + ACTIVE_PROGRAM = 0x8259; + PROGRAM_PIPELINE_BINDING = 0x825A; + MAX_VIEWPORTS = 0x825B; + VIEWPORT_SUBPIXEL_BITS = 0x825C; + VIEWPORT_BOUNDS_RANGE = 0x825D; + LAYER_PROVOKING_VERTEX = 0x825E; + VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F; + UNDEFINED_VERTEX = 0x8260; -const FIXED = 0x140C; -const IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A; -const IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B; -const LOW_FLOAT = 0x8DF0; -const MEDIUM_FLOAT = 0x8DF1; -const HIGH_FLOAT = 0x8DF2; -const LOW_INT = 0x8DF3; -const MEDIUM_INT = 0x8DF4; -const HIGH_INT = 0x8DF5; -const SHADER_COMPILER = 0x8DFA; -const SHADER_BINARY_FORMATS = 0x8DF8; -const NUM_SHADER_BINARY_FORMATS = 0x8DF9; -const MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB; -const MAX_VARYING_VECTORS = 0x8DFC; -const MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD; -const RGB565 = 0x8D62; -const PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257; -const PROGRAM_BINARY_LENGTH = 0x8741; -const NUM_PROGRAM_BINARY_FORMATS = 0x87FE; -const PROGRAM_BINARY_FORMATS = 0x87FF; -const VERTEX_SHADER_BIT = 0x00000001; -const FRAGMENT_SHADER_BIT = 0x00000002; -const GEOMETRY_SHADER_BIT = 0x00000004; -const TESS_CONTROL_SHADER_BIT = 0x00000008; -const TESS_EVALUATION_SHADER_BIT = 0x00000010; -const ALL_SHADER_BITS = 0xFFFFFFFF; -const PROGRAM_SEPARABLE = 0x8258; -const ACTIVE_PROGRAM = 0x8259; -const PROGRAM_PIPELINE_BINDING = 0x825A; -const MAX_VIEWPORTS = 0x825B; -const VIEWPORT_SUBPIXEL_BITS = 0x825C; -const VIEWPORT_BOUNDS_RANGE = 0x825D; -const LAYER_PROVOKING_VERTEX = 0x825E; -const VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F; -const UNDEFINED_VERTEX = 0x8260; + COPY_READ_BUFFER_BINDING = 0x8F36; + COPY_WRITE_BUFFER_BINDING = 0x8F37; + TRANSFORM_FEEDBACK_ACTIVE = 0x8E24; + TRANSFORM_FEEDBACK_PAUSED = 0x8E23; + UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127; + UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128; + UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129; + UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A; + PACK_COMPRESSED_BLOCK_WIDTH = 0x912B; + PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C; + PACK_COMPRESSED_BLOCK_DEPTH = 0x912D; + PACK_COMPRESSED_BLOCK_SIZE = 0x912E; + NUM_SAMPLE_COUNTS = 0x9380; + MIN_MAP_BUFFER_ALIGNMENT = 0x90BC; + ATOMIC_COUNTER_BUFFER = 0x92C0; + ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1; + ATOMIC_COUNTER_BUFFER_START = 0x92C2; + ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3; + ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4; + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5; + ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB; + MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC; + MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD; + MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE; + MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF; + MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0; + MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1; + MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2; + MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3; + MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4; + MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5; + MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6; + MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7; + MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8; + MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC; + ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9; + UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA; + UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB; + VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001; + ELEMENT_ARRAY_BARRIER_BIT = 0x00000002; + UNIFORM_BARRIER_BIT = 0x00000004; + TEXTURE_FETCH_BARRIER_BIT = 0x00000008; + SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020; + COMMAND_BARRIER_BIT = 0x00000040; + PIXEL_BUFFER_BARRIER_BIT = 0x00000080; + TEXTURE_UPDATE_BARRIER_BIT = 0x00000100; + BUFFER_UPDATE_BARRIER_BIT = 0x00000200; + FRAMEBUFFER_BARRIER_BIT = 0x00000400; + TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800; + ATOMIC_COUNTER_BARRIER_BIT = 0x00001000; + ALL_BARRIER_BITS = 0xFFFFFFFF; + MAX_IMAGE_UNITS = 0x8F38; + MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39; + IMAGE_BINDING_NAME = 0x8F3A; + IMAGE_BINDING_LEVEL = 0x8F3B; + IMAGE_BINDING_LAYERED = 0x8F3C; + IMAGE_BINDING_LAYER = 0x8F3D; + IMAGE_BINDING_ACCESS = 0x8F3E; + IMAGE_1D = 0x904C; + IMAGE_2D = 0x904D; + IMAGE_3D = 0x904E; + IMAGE_2D_RECT = 0x904F; + IMAGE_CUBE = 0x9050; + IMAGE_BUFFER = 0x9051; + IMAGE_1D_ARRAY = 0x9052; + IMAGE_2D_ARRAY = 0x9053; + IMAGE_CUBE_MAP_ARRAY = 0x9054; + IMAGE_2D_MULTISAMPLE = 0x9055; + IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056; + INT_IMAGE_1D = 0x9057; + INT_IMAGE_2D = 0x9058; + INT_IMAGE_3D = 0x9059; + INT_IMAGE_2D_RECT = 0x905A; + INT_IMAGE_CUBE = 0x905B; + INT_IMAGE_BUFFER = 0x905C; + INT_IMAGE_1D_ARRAY = 0x905D; + INT_IMAGE_2D_ARRAY = 0x905E; + INT_IMAGE_CUBE_MAP_ARRAY = 0x905F; + INT_IMAGE_2D_MULTISAMPLE = 0x9060; + INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061; + UNSIGNED_INT_IMAGE_1D = 0x9062; + UNSIGNED_INT_IMAGE_2D = 0x9063; + UNSIGNED_INT_IMAGE_3D = 0x9064; + UNSIGNED_INT_IMAGE_2D_RECT = 0x9065; + UNSIGNED_INT_IMAGE_CUBE = 0x9066; + UNSIGNED_INT_IMAGE_BUFFER = 0x9067; + UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068; + UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069; + UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A; + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B; + UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C; + MAX_IMAGE_SAMPLES = 0x906D; + IMAGE_BINDING_FORMAT = 0x906E; + IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7; + IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8; + IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9; + MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA; + MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB; + MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC; + MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD; + MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE; + MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF; + COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C; + COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D; + COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E; + COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F; + TEXTURE_IMMUTABLE_FORMAT = 0x912F; -const COPY_READ_BUFFER_BINDING = 0x8F36; -const COPY_WRITE_BUFFER_BINDING = 0x8F37; -const TRANSFORM_FEEDBACK_ACTIVE = 0x8E24; -const TRANSFORM_FEEDBACK_PAUSED = 0x8E23; -const UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127; -const UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128; -const UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129; -const UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A; -const PACK_COMPRESSED_BLOCK_WIDTH = 0x912B; -const PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C; -const PACK_COMPRESSED_BLOCK_DEPTH = 0x912D; -const PACK_COMPRESSED_BLOCK_SIZE = 0x912E; -const NUM_SAMPLE_COUNTS = 0x9380; -const MIN_MAP_BUFFER_ALIGNMENT = 0x90BC; -const ATOMIC_COUNTER_BUFFER = 0x92C0; -const ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1; -const ATOMIC_COUNTER_BUFFER_START = 0x92C2; -const ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3; -const ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4; -const ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5; -const ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB; -const MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC; -const MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD; -const MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE; -const MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF; -const MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0; -const MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1; -const MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2; -const MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3; -const MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4; -const MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5; -const MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6; -const MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7; -const MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8; -const MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC; -const ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9; -const UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA; -const UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB; -const VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001; -const ELEMENT_ARRAY_BARRIER_BIT = 0x00000002; -const UNIFORM_BARRIER_BIT = 0x00000004; -const TEXTURE_FETCH_BARRIER_BIT = 0x00000008; -const SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020; -const COMMAND_BARRIER_BIT = 0x00000040; -const PIXEL_BUFFER_BARRIER_BIT = 0x00000080; -const TEXTURE_UPDATE_BARRIER_BIT = 0x00000100; -const BUFFER_UPDATE_BARRIER_BIT = 0x00000200; -const FRAMEBUFFER_BARRIER_BIT = 0x00000400; -const TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800; -const ATOMIC_COUNTER_BARRIER_BIT = 0x00001000; -const ALL_BARRIER_BITS = 0xFFFFFFFF; -const MAX_IMAGE_UNITS = 0x8F38; -const MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39; -const IMAGE_BINDING_NAME = 0x8F3A; -const IMAGE_BINDING_LEVEL = 0x8F3B; -const IMAGE_BINDING_LAYERED = 0x8F3C; -const IMAGE_BINDING_LAYER = 0x8F3D; -const IMAGE_BINDING_ACCESS = 0x8F3E; -const IMAGE_1D = 0x904C; -const IMAGE_2D = 0x904D; -const IMAGE_3D = 0x904E; -const IMAGE_2D_RECT = 0x904F; -const IMAGE_CUBE = 0x9050; -const IMAGE_BUFFER = 0x9051; -const IMAGE_1D_ARRAY = 0x9052; -const IMAGE_2D_ARRAY = 0x9053; -const IMAGE_CUBE_MAP_ARRAY = 0x9054; -const IMAGE_2D_MULTISAMPLE = 0x9055; -const IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056; -const INT_IMAGE_1D = 0x9057; -const INT_IMAGE_2D = 0x9058; -const INT_IMAGE_3D = 0x9059; -const INT_IMAGE_2D_RECT = 0x905A; -const INT_IMAGE_CUBE = 0x905B; -const INT_IMAGE_BUFFER = 0x905C; -const INT_IMAGE_1D_ARRAY = 0x905D; -const INT_IMAGE_2D_ARRAY = 0x905E; -const INT_IMAGE_CUBE_MAP_ARRAY = 0x905F; -const INT_IMAGE_2D_MULTISAMPLE = 0x9060; -const INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061; -const UNSIGNED_INT_IMAGE_1D = 0x9062; -const UNSIGNED_INT_IMAGE_2D = 0x9063; -const UNSIGNED_INT_IMAGE_3D = 0x9064; -const UNSIGNED_INT_IMAGE_2D_RECT = 0x9065; -const UNSIGNED_INT_IMAGE_CUBE = 0x9066; -const UNSIGNED_INT_IMAGE_BUFFER = 0x9067; -const UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068; -const UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069; -const UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A; -const UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B; -const UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C; -const MAX_IMAGE_SAMPLES = 0x906D; -const IMAGE_BINDING_FORMAT = 0x906E; -const IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7; -const IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8; -const IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9; -const MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA; -const MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB; -const MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC; -const MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD; -const MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE; -const MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF; -const COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C; -const COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D; -const COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E; -const COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F; -const TEXTURE_IMMUTABLE_FORMAT = 0x912F; + NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9; + VERTEX_ATTRIB_ARRAY_LONG = 0x874E; + COMPRESSED_RGB8_ETC2 = 0x9274; + COMPRESSED_SRGB8_ETC2 = 0x9275; + COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276; + COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277; + COMPRESSED_RGBA8_ETC2_EAC = 0x9278; + COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279; + COMPRESSED_R11_EAC = 0x9270; + COMPRESSED_SIGNED_R11_EAC = 0x9271; + COMPRESSED_RG11_EAC = 0x9272; + COMPRESSED_SIGNED_RG11_EAC = 0x9273; + PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69; + ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A; + MAX_ELEMENT_INDEX = 0x8D6B; + COMPUTE_SHADER = 0x91B9; + MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB; + MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC; + MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD; + MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262; + MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263; + MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264; + MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265; + MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266; + MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB; + MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE; + MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF; + COMPUTE_WORK_GROUP_SIZE = 0x8267; + UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC; + ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED; + DISPATCH_INDIRECT_BUFFER = 0x90EE; + DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF; + COMPUTE_SHADER_BIT = 0x00000020; + DEBUG_OUTPUT_SYNCHRONOUS = 0x8242; + DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243; + DEBUG_CALLBACK_FUNCTION = 0x8244; + DEBUG_CALLBACK_USER_PARAM = 0x8245; + DEBUG_SOURCE_API = 0x8246; + DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247; + DEBUG_SOURCE_SHADER_COMPILER = 0x8248; + DEBUG_SOURCE_THIRD_PARTY = 0x8249; + DEBUG_SOURCE_APPLICATION = 0x824A; + DEBUG_SOURCE_OTHER = 0x824B; + DEBUG_TYPE_ERROR = 0x824C; + DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D; + DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E; + DEBUG_TYPE_PORTABILITY = 0x824F; + DEBUG_TYPE_PERFORMANCE = 0x8250; + DEBUG_TYPE_OTHER = 0x8251; + MAX_DEBUG_MESSAGE_LENGTH = 0x9143; + MAX_DEBUG_LOGGED_MESSAGES = 0x9144; + DEBUG_LOGGED_MESSAGES = 0x9145; + DEBUG_SEVERITY_HIGH = 0x9146; + DEBUG_SEVERITY_MEDIUM = 0x9147; + DEBUG_SEVERITY_LOW = 0x9148; + DEBUG_TYPE_MARKER = 0x8268; + DEBUG_TYPE_PUSH_GROUP = 0x8269; + DEBUG_TYPE_POP_GROUP = 0x826A; + DEBUG_SEVERITY_NOTIFICATION = 0x826B; + MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C; + DEBUG_GROUP_STACK_DEPTH = 0x826D; + BUFFER = 0x82E0; + SHADER = 0x82E1; + PROGRAM = 0x82E2; + QUERY = 0x82E3; + PROGRAM_PIPELINE = 0x82E4; + SAMPLER = 0x82E6; + MAX_LABEL_LENGTH = 0x82E8; + DEBUG_OUTPUT = 0x92E0; + CONTEXT_FLAG_DEBUG_BIT = 0x00000002; + MAX_UNIFORM_LOCATIONS = 0x826E; + FRAMEBUFFER_DEFAULT_WIDTH = 0x9310; + FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311; + FRAMEBUFFER_DEFAULT_LAYERS = 0x9312; + FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313; + FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314; + MAX_FRAMEBUFFER_WIDTH = 0x9315; + MAX_FRAMEBUFFER_HEIGHT = 0x9316; + MAX_FRAMEBUFFER_LAYERS = 0x9317; + MAX_FRAMEBUFFER_SAMPLES = 0x9318; + INTERNALFORMAT_SUPPORTED = 0x826F; + INTERNALFORMAT_PREFERRED = 0x8270; + INTERNALFORMAT_RED_SIZE = 0x8271; + INTERNALFORMAT_GREEN_SIZE = 0x8272; + INTERNALFORMAT_BLUE_SIZE = 0x8273; + INTERNALFORMAT_ALPHA_SIZE = 0x8274; + INTERNALFORMAT_DEPTH_SIZE = 0x8275; + INTERNALFORMAT_STENCIL_SIZE = 0x8276; + INTERNALFORMAT_SHARED_SIZE = 0x8277; + INTERNALFORMAT_RED_TYPE = 0x8278; + INTERNALFORMAT_GREEN_TYPE = 0x8279; + INTERNALFORMAT_BLUE_TYPE = 0x827A; + INTERNALFORMAT_ALPHA_TYPE = 0x827B; + INTERNALFORMAT_DEPTH_TYPE = 0x827C; + INTERNALFORMAT_STENCIL_TYPE = 0x827D; + MAX_WIDTH = 0x827E; + MAX_HEIGHT = 0x827F; + MAX_DEPTH = 0x8280; + MAX_LAYERS = 0x8281; + MAX_COMBINED_DIMENSIONS = 0x8282; + COLOR_COMPONENTS = 0x8283; + DEPTH_COMPONENTS = 0x8284; + STENCIL_COMPONENTS = 0x8285; + COLOR_RENDERABLE = 0x8286; + DEPTH_RENDERABLE = 0x8287; + STENCIL_RENDERABLE = 0x8288; + FRAMEBUFFER_RENDERABLE = 0x8289; + FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A; + FRAMEBUFFER_BLEND = 0x828B; + READ_PIXELS = 0x828C; + READ_PIXELS_FORMAT = 0x828D; + READ_PIXELS_TYPE = 0x828E; + TEXTURE_IMAGE_FORMAT = 0x828F; + TEXTURE_IMAGE_TYPE = 0x8290; + GET_TEXTURE_IMAGE_FORMAT = 0x8291; + GET_TEXTURE_IMAGE_TYPE = 0x8292; + MIPMAP = 0x8293; + MANUAL_GENERATE_MIPMAP = 0x8294; + AUTO_GENERATE_MIPMAP = 0x8295; + COLOR_ENCODING = 0x8296; + SRGB_READ = 0x8297; + SRGB_WRITE = 0x8298; + FILTER = 0x829A; + VERTEX_TEXTURE = 0x829B; + TESS_CONTROL_TEXTURE = 0x829C; + TESS_EVALUATION_TEXTURE = 0x829D; + GEOMETRY_TEXTURE = 0x829E; + FRAGMENT_TEXTURE = 0x829F; + COMPUTE_TEXTURE = 0x82A0; + TEXTURE_SHADOW = 0x82A1; + TEXTURE_GATHER = 0x82A2; + TEXTURE_GATHER_SHADOW = 0x82A3; + SHADER_IMAGE_LOAD = 0x82A4; + SHADER_IMAGE_STORE = 0x82A5; + SHADER_IMAGE_ATOMIC = 0x82A6; + IMAGE_TEXEL_SIZE = 0x82A7; + IMAGE_COMPATIBILITY_CLASS = 0x82A8; + IMAGE_PIXEL_FORMAT = 0x82A9; + IMAGE_PIXEL_TYPE = 0x82AA; + SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC; + SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD; + SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE; + SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF; + TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1; + TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2; + TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3; + CLEAR_BUFFER = 0x82B4; + TEXTURE_VIEW = 0x82B5; + VIEW_COMPATIBILITY_CLASS = 0x82B6; + FULL_SUPPORT = 0x82B7; + CAVEAT_SUPPORT = 0x82B8; + IMAGE_CLASS_4_X_32 = 0x82B9; + IMAGE_CLASS_2_X_32 = 0x82BA; + IMAGE_CLASS_1_X_32 = 0x82BB; + IMAGE_CLASS_4_X_16 = 0x82BC; + IMAGE_CLASS_2_X_16 = 0x82BD; + IMAGE_CLASS_1_X_16 = 0x82BE; + IMAGE_CLASS_4_X_8 = 0x82BF; + IMAGE_CLASS_2_X_8 = 0x82C0; + IMAGE_CLASS_1_X_8 = 0x82C1; + IMAGE_CLASS_11_11_10 = 0x82C2; + IMAGE_CLASS_10_10_10_2 = 0x82C3; + VIEW_CLASS_128_BITS = 0x82C4; + VIEW_CLASS_96_BITS = 0x82C5; + VIEW_CLASS_64_BITS = 0x82C6; + VIEW_CLASS_48_BITS = 0x82C7; + VIEW_CLASS_32_BITS = 0x82C8; + VIEW_CLASS_24_BITS = 0x82C9; + VIEW_CLASS_16_BITS = 0x82CA; + VIEW_CLASS_8_BITS = 0x82CB; + VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC; + VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD; + VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE; + VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF; + VIEW_CLASS_RGTC1_RED = 0x82D0; + VIEW_CLASS_RGTC2_RG = 0x82D1; + VIEW_CLASS_BPTC_UNORM = 0x82D2; + VIEW_CLASS_BPTC_FLOAT = 0x82D3; + UNIFORM = 0x92E1; + UNIFORM_BLOCK = 0x92E2; + PROGRAM_INPUT = 0x92E3; + PROGRAM_OUTPUT = 0x92E4; + BUFFER_VARIABLE = 0x92E5; + SHADER_STORAGE_BLOCK = 0x92E6; + VERTEX_SUBROUTINE = 0x92E8; + TESS_CONTROL_SUBROUTINE = 0x92E9; + TESS_EVALUATION_SUBROUTINE = 0x92EA; + GEOMETRY_SUBROUTINE = 0x92EB; + FRAGMENT_SUBROUTINE = 0x92EC; + COMPUTE_SUBROUTINE = 0x92ED; + VERTEX_SUBROUTINE_UNIFORM = 0x92EE; + TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF; + TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0; + GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1; + FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2; + COMPUTE_SUBROUTINE_UNIFORM = 0x92F3; + TRANSFORM_FEEDBACK_VARYING = 0x92F4; + ACTIVE_RESOURCES = 0x92F5; + MAX_NAME_LENGTH = 0x92F6; + MAX_NUM_ACTIVE_VARIABLES = 0x92F7; + MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8; + NAME_LENGTH = 0x92F9; + TYPE = 0x92FA; + ARRAY_SIZE = 0x92FB; + OFFSET = 0x92FC; + BLOCK_INDEX = 0x92FD; + ARRAY_STRIDE = 0x92FE; + MATRIX_STRIDE = 0x92FF; + IS_ROW_MAJOR = 0x9300; + ATOMIC_COUNTER_BUFFER_INDEX = 0x9301; + BUFFER_BINDING = 0x9302; + BUFFER_DATA_SIZE = 0x9303; + NUM_ACTIVE_VARIABLES = 0x9304; + ACTIVE_VARIABLES = 0x9305; + REFERENCED_BY_VERTEX_SHADER = 0x9306; + REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307; + REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308; + REFERENCED_BY_GEOMETRY_SHADER = 0x9309; + REFERENCED_BY_FRAGMENT_SHADER = 0x930A; + REFERENCED_BY_COMPUTE_SHADER = 0x930B; + TOP_LEVEL_ARRAY_SIZE = 0x930C; + TOP_LEVEL_ARRAY_STRIDE = 0x930D; + LOCATION = 0x930E; + LOCATION_INDEX = 0x930F; + IS_PER_PATCH = 0x92E7; + SHADER_STORAGE_BUFFER = 0x90D2; + SHADER_STORAGE_BUFFER_BINDING = 0x90D3; + SHADER_STORAGE_BUFFER_START = 0x90D4; + SHADER_STORAGE_BUFFER_SIZE = 0x90D5; + MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6; + MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7; + MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8; + MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9; + MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA; + MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB; + MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC; + MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD; + MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE; + SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF; + SHADER_STORAGE_BARRIER_BIT = 0x00002000; + MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39; + DEPTH_STENCIL_TEXTURE_MODE = 0x90EA; + TEXTURE_BUFFER_OFFSET = 0x919D; + TEXTURE_BUFFER_SIZE = 0x919E; + TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F; + TEXTURE_VIEW_MIN_LEVEL = 0x82DB; + TEXTURE_VIEW_NUM_LEVELS = 0x82DC; + TEXTURE_VIEW_MIN_LAYER = 0x82DD; + TEXTURE_VIEW_NUM_LAYERS = 0x82DE; + TEXTURE_IMMUTABLE_LEVELS = 0x82DF; + VERTEX_ATTRIB_BINDING = 0x82D4; + VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5; + VERTEX_BINDING_DIVISOR = 0x82D6; + VERTEX_BINDING_OFFSET = 0x82D7; + VERTEX_BINDING_STRIDE = 0x82D8; + MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9; + MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA; + VERTEX_BINDING_BUFFER = 0x8F4F; -const NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9; -const VERTEX_ATTRIB_ARRAY_LONG = 0x874E; -const COMPRESSED_RGB8_ETC2 = 0x9274; -const COMPRESSED_SRGB8_ETC2 = 0x9275; -const COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276; -const COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277; -const COMPRESSED_RGBA8_ETC2_EAC = 0x9278; -const COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279; -const COMPRESSED_R11_EAC = 0x9270; -const COMPRESSED_SIGNED_R11_EAC = 0x9271; -const COMPRESSED_RG11_EAC = 0x9272; -const COMPRESSED_SIGNED_RG11_EAC = 0x9273; -const PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69; -const ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A; -const MAX_ELEMENT_INDEX = 0x8D6B; -const COMPUTE_SHADER = 0x91B9; -const MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB; -const MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC; -const MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD; -const MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262; -const MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263; -const MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264; -const MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265; -const MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266; -const MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB; -const MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE; -const MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF; -const COMPUTE_WORK_GROUP_SIZE = 0x8267; -const UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC; -const ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED; -const DISPATCH_INDIRECT_BUFFER = 0x90EE; -const DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF; -const COMPUTE_SHADER_BIT = 0x00000020; -const DEBUG_OUTPUT_SYNCHRONOUS = 0x8242; -const DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243; -const DEBUG_CALLBACK_FUNCTION = 0x8244; -const DEBUG_CALLBACK_USER_PARAM = 0x8245; -const DEBUG_SOURCE_API = 0x8246; -const DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247; -const DEBUG_SOURCE_SHADER_COMPILER = 0x8248; -const DEBUG_SOURCE_THIRD_PARTY = 0x8249; -const DEBUG_SOURCE_APPLICATION = 0x824A; -const DEBUG_SOURCE_OTHER = 0x824B; -const DEBUG_TYPE_ERROR = 0x824C; -const DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D; -const DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E; -const DEBUG_TYPE_PORTABILITY = 0x824F; -const DEBUG_TYPE_PERFORMANCE = 0x8250; -const DEBUG_TYPE_OTHER = 0x8251; -const MAX_DEBUG_MESSAGE_LENGTH = 0x9143; -const MAX_DEBUG_LOGGED_MESSAGES = 0x9144; -const DEBUG_LOGGED_MESSAGES = 0x9145; -const DEBUG_SEVERITY_HIGH = 0x9146; -const DEBUG_SEVERITY_MEDIUM = 0x9147; -const DEBUG_SEVERITY_LOW = 0x9148; -const DEBUG_TYPE_MARKER = 0x8268; -const DEBUG_TYPE_PUSH_GROUP = 0x8269; -const DEBUG_TYPE_POP_GROUP = 0x826A; -const DEBUG_SEVERITY_NOTIFICATION = 0x826B; -const MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C; -const DEBUG_GROUP_STACK_DEPTH = 0x826D; -const BUFFER = 0x82E0; -const SHADER = 0x82E1; -const PROGRAM = 0x82E2; -const QUERY = 0x82E3; -const PROGRAM_PIPELINE = 0x82E4; -const SAMPLER = 0x82E6; -const MAX_LABEL_LENGTH = 0x82E8; -const DEBUG_OUTPUT = 0x92E0; -const CONTEXT_FLAG_DEBUG_BIT = 0x00000002; -const MAX_UNIFORM_LOCATIONS = 0x826E; -const FRAMEBUFFER_DEFAULT_WIDTH = 0x9310; -const FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311; -const FRAMEBUFFER_DEFAULT_LAYERS = 0x9312; -const FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313; -const FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314; -const MAX_FRAMEBUFFER_WIDTH = 0x9315; -const MAX_FRAMEBUFFER_HEIGHT = 0x9316; -const MAX_FRAMEBUFFER_LAYERS = 0x9317; -const MAX_FRAMEBUFFER_SAMPLES = 0x9318; -const INTERNALFORMAT_SUPPORTED = 0x826F; -const INTERNALFORMAT_PREFERRED = 0x8270; -const INTERNALFORMAT_RED_SIZE = 0x8271; -const INTERNALFORMAT_GREEN_SIZE = 0x8272; -const INTERNALFORMAT_BLUE_SIZE = 0x8273; -const INTERNALFORMAT_ALPHA_SIZE = 0x8274; -const INTERNALFORMAT_DEPTH_SIZE = 0x8275; -const INTERNALFORMAT_STENCIL_SIZE = 0x8276; -const INTERNALFORMAT_SHARED_SIZE = 0x8277; -const INTERNALFORMAT_RED_TYPE = 0x8278; -const INTERNALFORMAT_GREEN_TYPE = 0x8279; -const INTERNALFORMAT_BLUE_TYPE = 0x827A; -const INTERNALFORMAT_ALPHA_TYPE = 0x827B; -const INTERNALFORMAT_DEPTH_TYPE = 0x827C; -const INTERNALFORMAT_STENCIL_TYPE = 0x827D; -const MAX_WIDTH = 0x827E; -const MAX_HEIGHT = 0x827F; -const MAX_DEPTH = 0x8280; -const MAX_LAYERS = 0x8281; -const MAX_COMBINED_DIMENSIONS = 0x8282; -const COLOR_COMPONENTS = 0x8283; -const DEPTH_COMPONENTS = 0x8284; -const STENCIL_COMPONENTS = 0x8285; -const COLOR_RENDERABLE = 0x8286; -const DEPTH_RENDERABLE = 0x8287; -const STENCIL_RENDERABLE = 0x8288; -const FRAMEBUFFER_RENDERABLE = 0x8289; -const FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A; -const FRAMEBUFFER_BLEND = 0x828B; -const READ_PIXELS = 0x828C; -const READ_PIXELS_FORMAT = 0x828D; -const READ_PIXELS_TYPE = 0x828E; -const TEXTURE_IMAGE_FORMAT = 0x828F; -const TEXTURE_IMAGE_TYPE = 0x8290; -const GET_TEXTURE_IMAGE_FORMAT = 0x8291; -const GET_TEXTURE_IMAGE_TYPE = 0x8292; -const MIPMAP = 0x8293; -const MANUAL_GENERATE_MIPMAP = 0x8294; -const AUTO_GENERATE_MIPMAP = 0x8295; -const COLOR_ENCODING = 0x8296; -const SRGB_READ = 0x8297; -const SRGB_WRITE = 0x8298; -const FILTER = 0x829A; -const VERTEX_TEXTURE = 0x829B; -const TESS_CONTROL_TEXTURE = 0x829C; -const TESS_EVALUATION_TEXTURE = 0x829D; -const GEOMETRY_TEXTURE = 0x829E; -const FRAGMENT_TEXTURE = 0x829F; -const COMPUTE_TEXTURE = 0x82A0; -const TEXTURE_SHADOW = 0x82A1; -const TEXTURE_GATHER = 0x82A2; -const TEXTURE_GATHER_SHADOW = 0x82A3; -const SHADER_IMAGE_LOAD = 0x82A4; -const SHADER_IMAGE_STORE = 0x82A5; -const SHADER_IMAGE_ATOMIC = 0x82A6; -const IMAGE_TEXEL_SIZE = 0x82A7; -const IMAGE_COMPATIBILITY_CLASS = 0x82A8; -const IMAGE_PIXEL_FORMAT = 0x82A9; -const IMAGE_PIXEL_TYPE = 0x82AA; -const SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC; -const SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD; -const SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE; -const SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF; -const TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1; -const TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2; -const TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3; -const CLEAR_BUFFER = 0x82B4; -const TEXTURE_VIEW = 0x82B5; -const VIEW_COMPATIBILITY_CLASS = 0x82B6; -const FULL_SUPPORT = 0x82B7; -const CAVEAT_SUPPORT = 0x82B8; -const IMAGE_CLASS_4_X_32 = 0x82B9; -const IMAGE_CLASS_2_X_32 = 0x82BA; -const IMAGE_CLASS_1_X_32 = 0x82BB; -const IMAGE_CLASS_4_X_16 = 0x82BC; -const IMAGE_CLASS_2_X_16 = 0x82BD; -const IMAGE_CLASS_1_X_16 = 0x82BE; -const IMAGE_CLASS_4_X_8 = 0x82BF; -const IMAGE_CLASS_2_X_8 = 0x82C0; -const IMAGE_CLASS_1_X_8 = 0x82C1; -const IMAGE_CLASS_11_11_10 = 0x82C2; -const IMAGE_CLASS_10_10_10_2 = 0x82C3; -const VIEW_CLASS_128_BITS = 0x82C4; -const VIEW_CLASS_96_BITS = 0x82C5; -const VIEW_CLASS_64_BITS = 0x82C6; -const VIEW_CLASS_48_BITS = 0x82C7; -const VIEW_CLASS_32_BITS = 0x82C8; -const VIEW_CLASS_24_BITS = 0x82C9; -const VIEW_CLASS_16_BITS = 0x82CA; -const VIEW_CLASS_8_BITS = 0x82CB; -const VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC; -const VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD; -const VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE; -const VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF; -const VIEW_CLASS_RGTC1_RED = 0x82D0; -const VIEW_CLASS_RGTC2_RG = 0x82D1; -const VIEW_CLASS_BPTC_UNORM = 0x82D2; -const VIEW_CLASS_BPTC_FLOAT = 0x82D3; -const UNIFORM = 0x92E1; -const UNIFORM_BLOCK = 0x92E2; -const PROGRAM_INPUT = 0x92E3; -const PROGRAM_OUTPUT = 0x92E4; -const BUFFER_VARIABLE = 0x92E5; -const SHADER_STORAGE_BLOCK = 0x92E6; -const VERTEX_SUBROUTINE = 0x92E8; -const TESS_CONTROL_SUBROUTINE = 0x92E9; -const TESS_EVALUATION_SUBROUTINE = 0x92EA; -const GEOMETRY_SUBROUTINE = 0x92EB; -const FRAGMENT_SUBROUTINE = 0x92EC; -const COMPUTE_SUBROUTINE = 0x92ED; -const VERTEX_SUBROUTINE_UNIFORM = 0x92EE; -const TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF; -const TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0; -const GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1; -const FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2; -const COMPUTE_SUBROUTINE_UNIFORM = 0x92F3; -const TRANSFORM_FEEDBACK_VARYING = 0x92F4; -const ACTIVE_RESOURCES = 0x92F5; -const MAX_NAME_LENGTH = 0x92F6; -const MAX_NUM_ACTIVE_VARIABLES = 0x92F7; -const MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8; -const NAME_LENGTH = 0x92F9; -const TYPE = 0x92FA; -const ARRAY_SIZE = 0x92FB; -const OFFSET = 0x92FC; -const BLOCK_INDEX = 0x92FD; -const ARRAY_STRIDE = 0x92FE; -const MATRIX_STRIDE = 0x92FF; -const IS_ROW_MAJOR = 0x9300; -const ATOMIC_COUNTER_BUFFER_INDEX = 0x9301; -const BUFFER_BINDING = 0x9302; -const BUFFER_DATA_SIZE = 0x9303; -const NUM_ACTIVE_VARIABLES = 0x9304; -const ACTIVE_VARIABLES = 0x9305; -const REFERENCED_BY_VERTEX_SHADER = 0x9306; -const REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307; -const REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308; -const REFERENCED_BY_GEOMETRY_SHADER = 0x9309; -const REFERENCED_BY_FRAGMENT_SHADER = 0x930A; -const REFERENCED_BY_COMPUTE_SHADER = 0x930B; -const TOP_LEVEL_ARRAY_SIZE = 0x930C; -const TOP_LEVEL_ARRAY_STRIDE = 0x930D; -const LOCATION = 0x930E; -const LOCATION_INDEX = 0x930F; -const IS_PER_PATCH = 0x92E7; -const SHADER_STORAGE_BUFFER = 0x90D2; -const SHADER_STORAGE_BUFFER_BINDING = 0x90D3; -const SHADER_STORAGE_BUFFER_START = 0x90D4; -const SHADER_STORAGE_BUFFER_SIZE = 0x90D5; -const MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6; -const MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7; -const MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8; -const MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9; -const MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA; -const MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB; -const MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC; -const MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD; -const MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE; -const SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF; -const SHADER_STORAGE_BARRIER_BIT = 0x00002000; -const MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39; -const DEPTH_STENCIL_TEXTURE_MODE = 0x90EA; -const TEXTURE_BUFFER_OFFSET = 0x919D; -const TEXTURE_BUFFER_SIZE = 0x919E; -const TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F; -const TEXTURE_VIEW_MIN_LEVEL = 0x82DB; -const TEXTURE_VIEW_NUM_LEVELS = 0x82DC; -const TEXTURE_VIEW_MIN_LAYER = 0x82DD; -const TEXTURE_VIEW_NUM_LAYERS = 0x82DE; -const TEXTURE_IMMUTABLE_LEVELS = 0x82DF; -const VERTEX_ATTRIB_BINDING = 0x82D4; -const VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5; -const VERTEX_BINDING_DIVISOR = 0x82D6; -const VERTEX_BINDING_OFFSET = 0x82D7; -const VERTEX_BINDING_STRIDE = 0x82D8; -const MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9; -const MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA; -const VERTEX_BINDING_BUFFER = 0x8F4F; + MAX_VERTEX_ATTRIB_STRIDE = 0x82E5; + PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221; + TEXTURE_BUFFER_BINDING = 0x8C2A; + MAP_PERSISTENT_BIT = 0x0040; + MAP_COHERENT_BIT = 0x0080; + DYNAMIC_STORAGE_BIT = 0x0100; + CLIENT_STORAGE_BIT = 0x0200; + CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000; + BUFFER_IMMUTABLE_STORAGE = 0x821F; + BUFFER_STORAGE_FLAGS = 0x8220; + CLEAR_TEXTURE = 0x9365; + LOCATION_COMPONENT = 0x934A; + TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B; + TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C; + QUERY_BUFFER = 0x9192; + QUERY_BUFFER_BARRIER_BIT = 0x00008000; + QUERY_BUFFER_BINDING = 0x9193; + QUERY_RESULT_NO_WAIT = 0x9194; + MIRROR_CLAMP_TO_EDGE = 0x8743; -const MAX_VERTEX_ATTRIB_STRIDE = 0x82E5; -const PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221; -const TEXTURE_BUFFER_BINDING = 0x8C2A; -const MAP_PERSISTENT_BIT = 0x0040; -const MAP_COHERENT_BIT = 0x0080; -const DYNAMIC_STORAGE_BIT = 0x0100; -const CLIENT_STORAGE_BIT = 0x0200; -const CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000; -const BUFFER_IMMUTABLE_STORAGE = 0x821F; -const BUFFER_STORAGE_FLAGS = 0x8220; -const CLEAR_TEXTURE = 0x9365; -const LOCATION_COMPONENT = 0x934A; -const TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B; -const TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C; -const QUERY_BUFFER = 0x9192; -const QUERY_BUFFER_BARRIER_BIT = 0x00008000; -const QUERY_BUFFER_BINDING = 0x9193; -const QUERY_RESULT_NO_WAIT = 0x9194; -const MIRROR_CLAMP_TO_EDGE = 0x8743; - -const CONTEXT_LOST = 0x0507; -const NEGATIVE_ONE_TO_ONE = 0x935E; -const ZERO_TO_ONE = 0x935F; -const CLIP_ORIGIN = 0x935C; -const CLIP_DEPTH_MODE = 0x935D; -const QUERY_WAIT_INVERTED = 0x8E17; -const QUERY_NO_WAIT_INVERTED = 0x8E18; -const QUERY_BY_REGION_WAIT_INVERTED = 0x8E19; -const QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A; -const MAX_CULL_DISTANCES = 0x82F9; -const MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA; -const TEXTURE_TARGET = 0x1006; -const QUERY_TARGET = 0x82EA; -const GUILTY_CONTEXT_RESET = 0x8253; -const INNOCENT_CONTEXT_RESET = 0x8254; -const UNKNOWN_CONTEXT_RESET = 0x8255; -const RESET_NOTIFICATION_STRATEGY = 0x8256; -const LOSE_CONTEXT_ON_RESET = 0x8252; -const NO_RESET_NOTIFICATION = 0x8261; -const CONTEXT_FLAG_ROBUST_ACCESS_BIT = 0x00000004; -const CONTEXT_RELEASE_BEHAVIOR = 0x82FB; -const CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC; - -const DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242; -const DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243; -const DEBUG_CALLBACK_FUNCTION_ARB = 0x8244; -const DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245; -const DEBUG_SOURCE_API_ARB = 0x8246; -const DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247; -const DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248; -const DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249; -const DEBUG_SOURCE_APPLICATION_ARB = 0x824A; -const DEBUG_SOURCE_OTHER_ARB = 0x824B; -const DEBUG_TYPE_ERROR_ARB = 0x824C; -const DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D; -const DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E; -const DEBUG_TYPE_PORTABILITY_ARB = 0x824F; -const DEBUG_TYPE_PERFORMANCE_ARB = 0x8250; -const DEBUG_TYPE_OTHER_ARB = 0x8251; -const MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143; -const MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144; -const DEBUG_LOGGED_MESSAGES_ARB = 0x9145; -const DEBUG_SEVERITY_HIGH_ARB = 0x9146; -const DEBUG_SEVERITY_MEDIUM_ARB = 0x9147; -const DEBUG_SEVERITY_LOW_ARB = 0x9148; + CONTEXT_LOST = 0x0507; + NEGATIVE_ONE_TO_ONE = 0x935E; + ZERO_TO_ONE = 0x935F; + CLIP_ORIGIN = 0x935C; + CLIP_DEPTH_MODE = 0x935D; + QUERY_WAIT_INVERTED = 0x8E17; + QUERY_NO_WAIT_INVERTED = 0x8E18; + QUERY_BY_REGION_WAIT_INVERTED = 0x8E19; + QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A; + MAX_CULL_DISTANCES = 0x82F9; + MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA; + TEXTURE_TARGET = 0x1006; + QUERY_TARGET = 0x82EA; + GUILTY_CONTEXT_RESET = 0x8253; + INNOCENT_CONTEXT_RESET = 0x8254; + UNKNOWN_CONTEXT_RESET = 0x8255; + RESET_NOTIFICATION_STRATEGY = 0x8256; + LOSE_CONTEXT_ON_RESET = 0x8252; + NO_RESET_NOTIFICATION = 0x8261; + CONTEXT_FLAG_ROBUST_ACCESS_BIT = 0x00000004; + CONTEXT_RELEASE_BEHAVIOR = 0x82FB; + CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC; + DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242; + DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243; + DEBUG_CALLBACK_FUNCTION_ARB = 0x8244; + DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245; + DEBUG_SOURCE_API_ARB = 0x8246; + DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247; + DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248; + DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249; + DEBUG_SOURCE_APPLICATION_ARB = 0x824A; + DEBUG_SOURCE_OTHER_ARB = 0x824B; + DEBUG_TYPE_ERROR_ARB = 0x824C; + DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D; + DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E; + DEBUG_TYPE_PORTABILITY_ARB = 0x824F; + DEBUG_TYPE_PERFORMANCE_ARB = 0x8250; + DEBUG_TYPE_OTHER_ARB = 0x8251; + MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143; + MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144; + DEBUG_LOGGED_MESSAGES_ARB = 0x9145; + DEBUG_SEVERITY_HIGH_ARB = 0x9146; + DEBUG_SEVERITY_MEDIUM_ARB = 0x9147; + DEBUG_SEVERITY_LOW_ARB = 0x9148; +) diff --git a/core/os.odin b/core/os.odin index 35daa13ad..cf326d48d 100644 --- a/core/os.odin +++ b/core/os.odin @@ -1,6 +1,8 @@ -import_load "os_windows.odin" when ODIN_OS == "windows"; -import_load "os_x.odin" when ODIN_OS == "osx"; -import_load "os_linux.odin" when ODIN_OS == "linux"; +import_load ( + "os_windows.odin" when ODIN_OS == "windows"; + "os_x.odin" when ODIN_OS == "osx"; + "os_linux.odin" when ODIN_OS == "linux"; +) proc write_string(fd: Handle, str: string) -> (int, Errno) { return write(fd, []u8(str)); diff --git a/core/os_linux.odin b/core/os_linux.odin index 1a3e82bbf..948fcf7d5 100644 --- a/core/os_linux.odin +++ b/core/os_linux.odin @@ -1,36 +1,40 @@ +#foreign_system_library dl "dl"; +#foreign_system_library libc "c"; import "strings.odin"; -type Handle i32; -type FileTime u64; -type Errno i32; +type ( + Handle i32; + FileTime u64; + Errno i32; +) -// INVALID_HANDLE: Handle : -1; +const ( + O_RDONLY = 0x00000; + O_WRONLY = 0x00001; + O_RDWR = 0x00002; + O_CREAT = 0x00040; + O_EXCL = 0x00080; + O_NOCTTY = 0x00100; + O_TRUNC = 0x00200; + O_NONBLOCK = 0x00800; + O_APPEND = 0x00400; + O_SYNC = 0x01000; + O_ASYNC = 0x02000; + O_CLOEXEC = 0x80000; + SEEK_SET = 0; + SEEK_CUR = 1; + SEEK_END = 2; + SEEK_DATA = 3; + SEEK_HOLE = 4; + SEEK_MAX = SEEK_HOLE; -const O_RDONLY = 0x00000; -const O_WRONLY = 0x00001; -const O_RDWR = 0x00002; -const O_CREAT = 0x00040; -const O_EXCL = 0x00080; -const O_NOCTTY = 0x00100; -const O_TRUNC = 0x00200; -const O_NONBLOCK = 0x00800; -const O_APPEND = 0x00400; -const O_SYNC = 0x01000; -const O_ASYNC = 0x02000; -const O_CLOEXEC = 0x80000; -const SEEK_SET = 0; -const SEEK_CUR = 1; -const SEEK_END = 2; -const SEEK_DATA = 3; -const SEEK_HOLE = 4; -const SEEK_MAX = SEEK_HOLE; - -// NOTE(zangent): These are OS specific! -// Do not mix these up! -const RTLD_LAZY = 0x001; -const RTLD_NOW = 0x002; -const RTLD_BINDING_MASK = 0x3; -const RTLD_GLOBAL = 0x100; + // NOTE(zangent): These are OS specific! + // Do not mix these up! + RTLD_LAZY = 0x001; + RTLD_NOW = 0x002; + RTLD_BINDING_MASK = 0x3; + RTLD_GLOBAL = 0x100; +) // "Argv" arguments converted to Odin strings let args = _alloc_command_line_arguments(); @@ -70,41 +74,39 @@ type Stat struct #ordered { }; // File type +const ( + S_IFMT = 0170000; // Type of file mask + S_IFIFO = 0010000; // Named pipe (fifo) + S_IFCHR = 0020000; // Character special + S_IFDIR = 0040000; // Directory + S_IFBLK = 0060000; // Block special + S_IFREG = 0100000; // Regular + S_IFLNK = 0120000; // Symbolic link + S_IFSOCK = 0140000; // Socket -const S_IFMT = 0170000; // Type of file mask -const S_IFIFO = 0010000; // Named pipe (fifo) -const S_IFCHR = 0020000; // Character special -const S_IFDIR = 0040000; // Directory -const S_IFBLK = 0060000; // Block special -const S_IFREG = 0100000; // Regular -const S_IFLNK = 0120000; // Symbolic link -const S_IFSOCK = 0140000; // Socket + // File mode + // Read, write, execute/search by owner + S_IRWXU = 0000700; // RWX mask for owner + S_IRUSR = 0000400; // R for owner + S_IWUSR = 0000200; // W for owner + S_IXUSR = 0000100; // X for owner -// File mode -// Read, write, execute/search by owner + // Read, write, execute/search by group + S_IRWXG = 0000070; // RWX mask for group + S_IRGRP = 0000040; // R for group + S_IWGRP = 0000020; // W for group + S_IXGRP = 0000010; // X for group -const S_IRWXU = 0000700; // RWX mask for owner -const S_IRUSR = 0000400; // R for owner -const S_IWUSR = 0000200; // W for owner -const S_IXUSR = 0000100; // X for owner + // Read, write, execute/search by others + S_IRWXO = 0000007; // RWX mask for other + S_IROTH = 0000004; // R for other + S_IWOTH = 0000002; // W for other + S_IXOTH = 0000001; // X for other -// Read, write, execute/search by group - -const S_IRWXG = 0000070; // RWX mask for group -const S_IRGRP = 0000040; // R for group -const S_IWGRP = 0000020; // W for group -const S_IXGRP = 0000010; // X for group - -// Read, write, execute/search by others - -const S_IRWXO = 0000007; // RWX mask for other -const S_IROTH = 0000004; // R for other -const S_IWOTH = 0000002; // W for other -const S_IXOTH = 0000001; // X for other - -const S_ISUID = 0004000; // Set user id on execution -const S_ISGID = 0002000; // Set group id on execution -const S_ISVTX = 0001000; // Directory restrcted delete + S_ISUID = 0004000; // Set user id on execution + S_ISGID = 0002000; // Set group id on execution + S_ISVTX = 0001000; // Directory restrcted delete +) proc S_ISLNK (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFLNK; } proc S_ISREG (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFREG; } @@ -114,13 +116,12 @@ proc S_ISBLK (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFBLK; } proc S_ISFIFO(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFIFO; } proc S_ISSOCK(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFSOCK;} -const R_OK = 4; // Test for read permission -const W_OK = 2; // Test for write permission -const X_OK = 1; // Test for execute permission -const F_OK = 0; // Test for file existance - -#foreign_system_library dl "dl"; -#foreign_system_library libc "c"; +const ( + R_OK = 4; // Test for read permission + W_OK = 2; // Test for write permission + X_OK = 1; // Test for execute permission + F_OK = 0; // Test for file existance +) proc _unix_open (path: ^u8, mode: int) -> Handle #foreign libc "open"; proc _unix_close (fd: Handle) -> i32 #foreign libc "close"; @@ -187,10 +188,11 @@ proc file_size(fd: Handle) -> (i64, Errno) { // NOTE(bill): Uses startup to initialize it -var stdin: Handle = 0; -var stdout: Handle = 1; -var stderr: Handle = 2; - +var ( + stdin: Handle = 0; + stdout: Handle = 1; + stderr: Handle = 2; +) /* TODO(zangent): Implement these! proc last_write_time(fd: Handle) -> FileTime {} proc last_write_time_by_name(name: string) -> FileTime {} diff --git a/core/os_windows.odin b/core/os_windows.odin index 68e657fd1..ab5e676e3 100644 --- a/core/os_windows.odin +++ b/core/os_windows.odin @@ -1,52 +1,54 @@ import win32 "sys/windows.odin"; -type Handle int; -type FileTime u64; -type Errno int; +type ( + Handle int; + FileTime u64; + Errno int; +) -const INVALID_HANDLE: Handle = -1; +const ( + INVALID_HANDLE: Handle = -1; + O_RDONLY = 0x00000; + O_WRONLY = 0x00001; + O_RDWR = 0x00002; + O_CREAT = 0x00040; + O_EXCL = 0x00080; + O_NOCTTY = 0x00100; + O_TRUNC = 0x00200; + O_NONBLOCK = 0x00800; + O_APPEND = 0x00400; + O_SYNC = 0x01000; + O_ASYNC = 0x02000; + O_CLOEXEC = 0x80000; -const O_RDONLY = 0x00000; -const O_WRONLY = 0x00001; -const O_RDWR = 0x00002; -const O_CREAT = 0x00040; -const O_EXCL = 0x00080; -const O_NOCTTY = 0x00100; -const O_TRUNC = 0x00200; -const O_NONBLOCK = 0x00800; -const O_APPEND = 0x00400; -const O_SYNC = 0x01000; -const O_ASYNC = 0x02000; -const O_CLOEXEC = 0x80000; - -const ERROR_NONE: Errno = 0; -const ERROR_FILE_NOT_FOUND: Errno = 2; -const ERROR_PATH_NOT_FOUND: Errno = 3; -const ERROR_ACCESS_DENIED: Errno = 5; -const ERROR_NO_MORE_FILES: Errno = 18; -const ERROR_HANDLE_EOF: Errno = 38; -const ERROR_NETNAME_DELETED: Errno = 64; -const ERROR_FILE_EXISTS: Errno = 80; -const ERROR_BROKEN_PIPE: Errno = 109; -const ERROR_BUFFER_OVERFLOW: Errno = 111; -const ERROR_INSUFFICIENT_BUFFER: Errno = 122; -const ERROR_MOD_NOT_FOUND: Errno = 126; -const ERROR_PROC_NOT_FOUND: Errno = 127; -const ERROR_DIR_NOT_EMPTY: Errno = 145; -const ERROR_ALREADY_EXISTS: Errno = 183; -const ERROR_ENVVAR_NOT_FOUND: Errno = 203; -const ERROR_MORE_DATA: Errno = 234; -const ERROR_OPERATION_ABORTED: Errno = 995; -const ERROR_IO_PENDING: Errno = 997; -const ERROR_NOT_FOUND: Errno = 1168; -const ERROR_PRIVILEGE_NOT_HELD: Errno = 1314; -const WSAEACCES: Errno = 10013; -const WSAECONNRESET: Errno = 10054; - -// Windows reserves errors >= 1<<29 for application use -const ERROR_FILE_IS_PIPE: Errno = 1<<29 + 0; + ERROR_NONE: Errno = 0; + ERROR_FILE_NOT_FOUND: Errno = 2; + ERROR_PATH_NOT_FOUND: Errno = 3; + ERROR_ACCESS_DENIED: Errno = 5; + ERROR_NO_MORE_FILES: Errno = 18; + ERROR_HANDLE_EOF: Errno = 38; + ERROR_NETNAME_DELETED: Errno = 64; + ERROR_FILE_EXISTS: Errno = 80; + ERROR_BROKEN_PIPE: Errno = 109; + ERROR_BUFFER_OVERFLOW: Errno = 111; + ERROR_INSUFFICIENT_BUFFER: Errno = 122; + ERROR_MOD_NOT_FOUND: Errno = 126; + ERROR_PROC_NOT_FOUND: Errno = 127; + ERROR_DIR_NOT_EMPTY: Errno = 145; + ERROR_ALREADY_EXISTS: Errno = 183; + ERROR_ENVVAR_NOT_FOUND: Errno = 203; + ERROR_MORE_DATA: Errno = 234; + ERROR_OPERATION_ABORTED: Errno = 995; + ERROR_IO_PENDING: Errno = 997; + ERROR_NOT_FOUND: Errno = 1168; + ERROR_PRIVILEGE_NOT_HELD: Errno = 1314; + WSAEACCES: Errno = 10013; + WSAECONNRESET: Errno = 10054; + // Windows reserves errors >= 1<<29 for application use + ERROR_FILE_IS_PIPE: Errno = 1<<29 + 0; +) // "Argv" arguments converted to Odin strings let args = _alloc_command_line_arguments(); diff --git a/core/os_x.odin b/core/os_x.odin index c75da9836..197b24e1a 100644 --- a/core/os_x.odin +++ b/core/os_x.odin @@ -1,43 +1,46 @@ +#foreign_system_library dl "dl"; +#foreign_system_library libc "c"; import "fmt.odin"; import "strings.odin"; -type Handle i32; -type FileTime u64; -type Errno int; +type ( + Handle i32; + FileTime u64; + Errno int; -// TODO(zangent): Find out how to make this work on x64 and x32. -type AddressSize i64; + AddressSize int; +) -// INVALID_HANDLE: Handle : -1; +const ( + O_RDONLY = 0x00000; + O_WRONLY = 0x00001; + O_RDWR = 0x00002; + O_CREAT = 0x00040; + O_EXCL = 0x00080; + O_NOCTTY = 0x00100; + O_TRUNC = 0x00200; + O_NONBLOCK = 0x00800; + O_APPEND = 0x00400; + O_SYNC = 0x01000; + O_ASYNC = 0x02000; + O_CLOEXEC = 0x80000; + SEEK_SET = 0; + SEEK_CUR = 1; + SEEK_END = 2; + SEEK_DATA = 3; + SEEK_HOLE = 4; + SEEK_MAX = SEEK_HOLE; -const O_RDONLY = 0x00000; -const O_WRONLY = 0x00001; -const O_RDWR = 0x00002; -const O_CREAT = 0x00040; -const O_EXCL = 0x00080; -const O_NOCTTY = 0x00100; -const O_TRUNC = 0x00200; -const O_NONBLOCK = 0x00800; -const O_APPEND = 0x00400; -const O_SYNC = 0x01000; -const O_ASYNC = 0x02000; -const O_CLOEXEC = 0x80000; -const SEEK_SET = 0; -const SEEK_CUR = 1; -const SEEK_END = 2; -const SEEK_DATA = 3; -const SEEK_HOLE = 4; -const SEEK_MAX = SEEK_HOLE; - -// NOTE(zangent): These are OS specific! -// Do not mix these up! -const RTLD_LAZY = 0x1; -const RTLD_NOW = 0x2; -const RTLD_LOCAL = 0x4; -const RTLD_GLOBAL = 0x8; -const RTLD_NODELETE = 0x80; -const RTLD_NOLOAD = 0x10; -const RTLD_FIRST = 0x100; + // NOTE(zangent): These are OS specific! + // Do not mix these up! + RTLD_LAZY = 0x1; + RTLD_NOW = 0x2; + RTLD_LOCAL = 0x4; + RTLD_GLOBAL = 0x8; + RTLD_NODELETE = 0x80; + RTLD_NOLOAD = 0x10; + RTLD_FIRST = 0x100; +) var args: [dynamic]string; @@ -71,41 +74,39 @@ type Stat struct #ordered { }; // File type +const ( + S_IFMT = 0170000; // Type of file mask + S_IFIFO = 0010000; // Named pipe (fifo) + S_IFCHR = 0020000; // Character special + S_IFDIR = 0040000; // Directory + S_IFBLK = 0060000; // Block special + S_IFREG = 0100000; // Regular + S_IFLNK = 0120000; // Symbolic link + S_IFSOCK = 0140000; // Socket -const S_IFMT = 0170000; // Type of file mask -const S_IFIFO = 0010000; // Named pipe (fifo) -const S_IFCHR = 0020000; // Character special -const S_IFDIR = 0040000; // Directory -const S_IFBLK = 0060000; // Block special -const S_IFREG = 0100000; // Regular -const S_IFLNK = 0120000; // Symbolic link -const S_IFSOCK = 0140000; // Socket + // File mode + // Read, write, execute/search by owner + S_IRWXU = 0000700; // RWX mask for owner + S_IRUSR = 0000400; // R for owner + S_IWUSR = 0000200; // W for owner + S_IXUSR = 0000100; // X for owner -// File mode -// Read, write, execute/search by owner + // Read, write, execute/search by group + S_IRWXG = 0000070; // RWX mask for group + S_IRGRP = 0000040; // R for group + S_IWGRP = 0000020; // W for group + S_IXGRP = 0000010; // X for group -const S_IRWXU = 0000700; // RWX mask for owner -const S_IRUSR = 0000400; // R for owner -const S_IWUSR = 0000200; // W for owner -const S_IXUSR = 0000100; // X for owner + // Read, write, execute/search by others + S_IRWXO = 0000007; // RWX mask for other + S_IROTH = 0000004; // R for other + S_IWOTH = 0000002; // W for other + S_IXOTH = 0000001; // X for other -// Read, write, execute/search by group - -const S_IRWXG = 0000070; // RWX mask for group -const S_IRGRP = 0000040; // R for group -const S_IWGRP = 0000020; // W for group -const S_IXGRP = 0000010; // X for group - -// Read, write, execute/search by others - -const S_IRWXO = 0000007; // RWX mask for other -const S_IROTH = 0000004; // R for other -const S_IWOTH = 0000002; // W for other -const S_IXOTH = 0000001; // X for other - -const S_ISUID = 0004000; // Set user id on execution -const S_ISGID = 0002000; // Set group id on execution -const S_ISVTX = 0001000; // Directory restrcted delete + S_ISUID = 0004000; // Set user id on execution + S_ISGID = 0002000; // Set group id on execution + S_ISVTX = 0001000; // Directory restrcted delete +) proc S_ISLNK (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFLNK; } proc S_ISREG (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFREG; } @@ -115,13 +116,12 @@ proc S_ISBLK (m: u32) -> bool #inline {return (m & S_IFMT) == S_IFBLK; } proc S_ISFIFO(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFIFO; } proc S_ISSOCK(m: u32) -> bool #inline {return (m & S_IFMT) == S_IFSOCK;} -const R_OK = 4; // Test for read permission -const W_OK = 2; // Test for write permission -const X_OK = 1; // Test for execute permission -const F_OK = 0; // Test for file existance - -#foreign_system_library dl "dl"; -#foreign_system_library libc "c"; +const ( + R_OK = 4; // Test for read permission + W_OK = 2; // Test for write permission + X_OK = 1; // Test for execute permission + F_OK = 0; // Test for file existance +) proc unix_open (path: ^u8, mode: int) -> Handle #foreign libc "open"; proc unix_close (handle: Handle) #foreign libc "close"; @@ -206,10 +206,11 @@ proc file_size(fd: Handle) -> (i64, Errno) { // NOTE(bill): Uses startup to initialize it -var stdin: Handle = 0; // get_std_handle(win32.STD_INPUT_HANDLE); -var stdout: Handle = 1; // get_std_handle(win32.STD_OUTPUT_HANDLE); -var stderr: Handle = 2; // get_std_handle(win32.STD_ERROR_HANDLE); - +var ( + stdin: Handle = 0; // get_std_handle(win32.STD_INPUT_HANDLE); + stdout: Handle = 1; // get_std_handle(win32.STD_OUTPUT_HANDLE); + stderr: Handle = 2; // get_std_handle(win32.STD_ERROR_HANDLE); +) /* TODO(zangent): Implement these! proc last_write_time(fd: Handle) -> FileTime {} proc last_write_time_by_name(name: string) -> FileTime {} diff --git a/core/raw.odin b/core/raw.odin index 3a9048bb4..e3384daf6 100644 --- a/core/raw.odin +++ b/core/raw.odin @@ -1,27 +1,29 @@ -type Any struct #ordered { - data: rawptr, - type_info: ^TypeInfo, -}; +type ( + Any struct #ordered { + data: rawptr, + type_info: ^TypeInfo, + }; -type String struct #ordered { - data: ^u8, - len: int, -}; + String struct #ordered { + data: ^u8, + len: int, + }; -type Slice struct #ordered { - data: rawptr, - len: int, - cap: int, -}; + Slice struct #ordered { + data: rawptr, + len: int, + cap: int, + }; -type DynamicArray struct #ordered { - data: rawptr, - len: int, - cap: int, - allocator: Allocator, -}; + DynamicArray struct #ordered { + data: rawptr, + len: int, + cap: int, + allocator: Allocator, + }; -type DynamicMap struct #ordered { - hashes: [dynamic]int, - entries: DynamicArray, -}; + DynamicMap struct #ordered { + hashes: [dynamic]int, + entries: DynamicArray, + }; +) diff --git a/core/sync.odin b/core/sync.odin index 9c3fc3188..ad08f0b18 100644 --- a/core/sync.odin +++ b/core/sync.odin @@ -1,2 +1,4 @@ -import_load "sync_windows.odin" when ODIN_OS == "windows"; -import_load "sync_linux.odin" when ODIN_OS == "linux"; +import_load ( + "sync_windows.odin" when ODIN_OS == "windows"; + "sync_linux.odin" when ODIN_OS == "linux"; +) diff --git a/core/sync_linux.odin b/core/sync_linux.odin index cee68f420..c3fc649b9 100644 --- a/core/sync_linux.odin +++ b/core/sync_linux.odin @@ -1,5 +1,7 @@ -import "atomics.odin"; -import "os.odin"; +import ( + "atomics.odin"; + "os.odin"; +) type Semaphore struct { // _handle: win32.Handle, diff --git a/core/sync_windows.odin b/core/sync_windows.odin index 1f9410202..353fb755f 100644 --- a/core/sync_windows.odin +++ b/core/sync_windows.odin @@ -1,5 +1,7 @@ -import win32 "sys/windows.odin" when ODIN_OS == "windows"; -import "atomics.odin"; +import ( + win32 "sys/windows.odin" when ODIN_OS == "windows"; + "atomics.odin"; +) type Semaphore struct { _handle: win32.Handle, diff --git a/core/utf16.odin b/core/utf16.odin index bda5161b7..a996a334b 100644 --- a/core/utf16.odin +++ b/core/utf16.odin @@ -1,11 +1,12 @@ -const REPLACEMENT_CHAR = '\uFFFD'; -const MAX_RUNE = '\U0010FFFF'; - -const _surr1 = 0xd800; -const _surr2 = 0xdc00; -const _surr3 = 0xe000; -const _surr_self = 0x10000; +const ( + REPLACEMENT_CHAR = '\uFFFD'; + MAX_RUNE = '\U0010FFFF'; + _surr1 = 0xd800; + _surr2 = 0xdc00; + _surr3 = 0xe000; + _surr_self = 0x10000; +) proc is_surrogate(r: rune) -> bool { return _surr1 <= r && r < _surr3; diff --git a/core/utf8.odin b/core/utf8.odin index a100423a2..b6bd7fbab 100644 --- a/core/utf8.odin +++ b/core/utf8.odin @@ -1,62 +1,66 @@ -const RUNE_ERROR = '\ufffd'; -const RUNE_SELF = 0x80; -const RUNE_BOM = 0xfeff; -const RUNE_EOF = ~rune(0); -const MAX_RUNE = '\U0010ffff'; -const UTF_MAX = 4; +const ( + RUNE_ERROR = '\ufffd'; + RUNE_SELF = 0x80; + RUNE_BOM = 0xfeff; + RUNE_EOF = ~rune(0); + MAX_RUNE = '\U0010ffff'; + UTF_MAX = 4; -const SURROGATE_MIN = 0xd800; -const SURROGATE_MAX = 0xdfff; + SURROGATE_MIN = 0xd800; + SURROGATE_MAX = 0xdfff; -const T1 = 0b0000_0000; -const TX = 0b1000_0000; -const T2 = 0b1100_0000; -const T3 = 0b1110_0000; -const T4 = 0b1111_0000; -const T5 = 0b1111_1000; + T1 = 0b0000_0000; + TX = 0b1000_0000; + T2 = 0b1100_0000; + T3 = 0b1110_0000; + T4 = 0b1111_0000; + T5 = 0b1111_1000; -const MASKX = 0b0011_1111; -const MASK2 = 0b0001_1111; -const MASK3 = 0b0000_1111; -const MASK4 = 0b0000_0111; + MASKX = 0b0011_1111; + MASK2 = 0b0001_1111; + MASK3 = 0b0000_1111; + MASK4 = 0b0000_0111; -const RUNE1_MAX = 1<<7 - 1; -const RUNE2_MAX = 1<<11 - 1; -const RUNE3_MAX = 1<<16 - 1; + RUNE1_MAX = 1<<7 - 1; + RUNE2_MAX = 1<<11 - 1; + RUNE3_MAX = 1<<16 - 1; -// The default lowest and highest continuation byte. -const LOCB = 0b1000_0000; -const HICB = 0b1011_1111; + // The default lowest and highest continuation byte. + LOCB = 0b1000_0000; + HICB = 0b1011_1111; +) type AcceptRange struct { lo, hi: u8 } -let accept_ranges = [5]AcceptRange{ - {0x80, 0xbf}, - {0xa0, 0xbf}, - {0x80, 0x9f}, - {0x90, 0xbf}, - {0x80, 0x8f}, -}; +let ( + accept_ranges = [5]AcceptRange{ + {0x80, 0xbf}, + {0xa0, 0xbf}, + {0x80, 0x9f}, + {0x90, 0xbf}, + {0x80, 0x8f}, + }; -let accept_sizes = [256]u8{ - 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f - 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f - 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f - 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x30-0x3f - 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x40-0x4f - 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x50-0x5f - 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x60-0x6f - 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x70-0x7f + accept_sizes = [256]u8{ + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x30-0x3f + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x40-0x4f + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x50-0x5f + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x60-0x6f + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x70-0x7f - 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x80-0x8f - 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x90-0x9f - 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xa0-0xaf - 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xb0-0xbf - 0xf1, 0xf1, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xc0-0xcf - 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xd0-0xdf - 0x13, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x23, 0x03, 0x03, // 0xe0-0xef - 0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff -}; + 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x80-0x8f + 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x90-0x9f + 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xa0-0xaf + 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xb0-0xbf + 0xf1, 0xf1, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xc0-0xcf + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xd0-0xdf + 0x13, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x23, 0x03, 0x03, // 0xe0-0xef + 0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff + }; +) proc encode_rune(r: rune) -> ([4]u8, int) { var buf: [4]u8; diff --git a/src/check_stmt.cpp b/src/check_stmt.cpp index 65a6387f8..af5f5edeb 100644 --- a/src/check_stmt.cpp +++ b/src/check_stmt.cpp @@ -1535,121 +1535,126 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) { check_stmt(c, pa->body, mod_flags); case_end; - - case_ast_node(vd, ValueDecl, node); + case_ast_node(gd, GenDecl, node); GB_ASSERT(!c->context.scope->is_file); - if (vd->token.kind == Token_const) { - // NOTE(bill): Handled elsewhere - } else { - Entity **entities = gb_alloc_array(c->allocator, Entity *, vd->names.count); - isize entity_count = 0; + for_array(i, gd->specs) { + AstNode *spec = gd->specs[i]; + switch (gd->token.kind) { + case Token_var: + case Token_let: { + ast_node(vd, ValueSpec, spec); - if (vd->flags & VarDeclFlag_thread_local) { - vd->flags &= ~VarDeclFlag_thread_local; - error_node(node, "`thread_local` may only be applied to a variable declaration"); - } + Entity **entities = gb_alloc_array(c->allocator, Entity *, vd->names.count); + isize entity_count = 0; - for_array(i, vd->names) { - AstNode *name = vd->names[i]; - Entity *entity = NULL; - if (name->kind != AstNode_Ident) { - error_node(name, "A variable declaration must be an identifier"); - } else { - Token token = name->Ident; - String str = token.string; - Entity *found = NULL; - // NOTE(bill): Ignore assignments to `_` - if (str != "_") { - found = current_scope_lookup_entity(c->context.scope, str); - } - if (found == NULL) { - entity = make_entity_variable(c->allocator, c->context.scope, token, NULL, (vd->flags&VarDeclFlag_immutable) != 0); - entity->identifier = name; + if (gd->flags & VarDeclFlag_thread_local) { + gd->flags &= ~VarDeclFlag_thread_local; + error_node(node, "`thread_local` may only be applied to a variable declaration"); + } + + for_array(i, vd->names) { + AstNode *name = vd->names[i]; + Entity *entity = NULL; + if (name->kind != AstNode_Ident) { + error_node(name, "A variable declaration must be an identifier"); } else { - TokenPos pos = found->token.pos; - error(token, - "Redeclaration of `%.*s` in this scope\n" - "\tat %.*s(%td:%td)", - LIT(str), LIT(pos.file), pos.line, pos.column); - entity = found; + Token token = name->Ident; + String str = token.string; + Entity *found = NULL; + // NOTE(bill): Ignore assignments to `_` + if (str != "_") { + found = current_scope_lookup_entity(c->context.scope, str); + } + if (found == NULL) { + entity = make_entity_variable(c->allocator, c->context.scope, token, NULL, (gd->flags&VarDeclFlag_immutable) != 0); + entity->identifier = name; + } else { + TokenPos pos = found->token.pos; + error(token, + "Redeclaration of `%.*s` in this scope\n" + "\tat %.*s(%td:%td)", + LIT(str), LIT(pos.file), pos.line, pos.column); + entity = found; + } + } + if (entity == NULL) { + entity = make_entity_dummy_variable(c->allocator, c->global_scope, ast_node_token(name)); + } + entity->parent_proc_decl = c->context.curr_proc_decl; + entities[entity_count++] = entity; + } + + Type *init_type = NULL; + if (vd->type) { + init_type = check_type(c, vd->type, NULL); + if (init_type == NULL) { + init_type = t_invalid; } } - if (entity == NULL) { - entity = make_entity_dummy_variable(c->allocator, c->global_scope, ast_node_token(name)); - } - entity->parent_proc_decl = c->context.curr_proc_decl; - entities[entity_count++] = entity; - } - Type *init_type = NULL; - if (vd->type) { - init_type = check_type(c, vd->type, NULL); - if (init_type == NULL) { - init_type = t_invalid; - } - } - - for (isize i = 0; i < entity_count; i++) { - Entity *e = entities[i]; - GB_ASSERT(e != NULL); - if (e->flags & EntityFlag_Visited) { - e->type = t_invalid; - continue; - } - e->flags |= EntityFlag_Visited; - - if (e->type == NULL) { - e->type = init_type; - } - } - - check_arity_match(c, vd); - check_init_variables(c, entities, entity_count, vd->values, str_lit("variable declaration")); - - for (isize i = 0; i < entity_count; i++) { - add_entity(c, c->context.scope, entities[i]->identifier, entities[i]); - } - - if ((vd->flags & VarDeclFlag_using) != 0) { - Token token = ast_node_token(node); - if (vd->type != NULL && entity_count > 1) { - error(token, "`using` can only be applied to one variable of the same type"); - // TODO(bill): Should a `continue` happen here? - } - - for (isize entity_index = 0; entity_index < entity_count; entity_index++) { - Entity *e = entities[entity_index]; - if (e == NULL) { + for (isize i = 0; i < entity_count; i++) { + Entity *e = entities[i]; + GB_ASSERT(e != NULL); + if (e->flags & EntityFlag_Visited) { + e->type = t_invalid; continue; } - if (e->kind != Entity_Variable) { - continue; - } - bool is_immutable = e->Variable.is_immutable; - String name = e->token.string; - Type *t = base_type(type_deref(e->type)); + e->flags |= EntityFlag_Visited; - if (is_type_struct(t) || is_type_raw_union(t)) { - Scope **found = map_get(&c->info.scopes, hash_pointer(t->Record.node)); - GB_ASSERT(found != NULL); - for_array(i, (*found)->elements.entries) { - Entity *f = (*found)->elements.entries[i].value; - if (f->kind == Entity_Variable) { - Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type); - uvar->Variable.is_immutable = is_immutable; - Entity *prev = scope_insert_entity(c->context.scope, uvar); - if (prev != NULL) { - error(token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string)); - return; + if (e->type == NULL) { + e->type = init_type; + } + } + + check_arity_match(c, vd); + check_init_variables(c, entities, entity_count, vd->values, str_lit("variable declaration")); + + for (isize i = 0; i < entity_count; i++) { + add_entity(c, c->context.scope, entities[i]->identifier, entities[i]); + } + + if ((gd->flags & VarDeclFlag_using) != 0) { + Token token = ast_node_token(node); + if (vd->type != NULL && entity_count > 1) { + error(token, "`using` can only be applied to one variable of the same type"); + // TODO(bill): Should a `continue` happen here? + } + + for (isize entity_index = 0; entity_index < entity_count; entity_index++) { + Entity *e = entities[entity_index]; + if (e == NULL) { + continue; + } + if (e->kind != Entity_Variable) { + continue; + } + bool is_immutable = e->Variable.is_immutable; + String name = e->token.string; + Type *t = base_type(type_deref(e->type)); + + if (is_type_struct(t) || is_type_raw_union(t)) { + Scope **found = map_get(&c->info.scopes, hash_pointer(t->Record.node)); + GB_ASSERT(found != NULL); + for_array(i, (*found)->elements.entries) { + Entity *f = (*found)->elements.entries[i].value; + if (f->kind == Entity_Variable) { + Entity *uvar = make_entity_using_variable(c->allocator, e, f->token, f->type); + uvar->Variable.is_immutable = is_immutable; + Entity *prev = scope_insert_entity(c->context.scope, uvar); + if (prev != NULL) { + error(token, "Namespace collision while `using` `%.*s` of: %.*s", LIT(name), LIT(prev->token.string)); + return; + } } } + } else { + // NOTE(bill): skip the rest to remove extra errors + error(token, "`using` can only be applied to variables of type struct or raw_union"); + return; } - } else { - // NOTE(bill): skip the rest to remove extra errors - error(token, "`using` can only be applied to variables of type struct or raw_union"); - return; } } + } break; } } case_end; diff --git a/src/checker.cpp b/src/checker.cpp index 26ef9992f..9b6c81622 100644 --- a/src/checker.cpp +++ b/src/checker.cpp @@ -1249,7 +1249,7 @@ void init_preload(Checker *c) { -bool check_arity_match(Checker *c, AstNodeValueDecl *d); +bool check_arity_match(Checker *c, AstNodeValueSpec *s); void check_collect_entities(Checker *c, Array nodes, bool is_file_scope); void check_collect_entities_from_when_stmt(Checker *c, AstNodeWhenStmt *ws, bool is_file_scope); @@ -1362,27 +1362,27 @@ void check_procedure_overloading(Checker *c, Entity *e) { -bool check_arity_match(Checker *c, AstNodeValueDecl *d) { - isize lhs = d->names.count; - isize rhs = d->values.count; +bool check_arity_match(Checker *c, AstNodeValueSpec *spec) { + isize lhs = spec->names.count; + isize rhs = spec->values.count; if (rhs == 0) { - if (d->type == NULL) { - error_node(d->names[0], "Missing type or initial expression"); + if (spec->type == NULL) { + error_node(spec->names[0], "Missing type or initial expression"); return false; } } else if (lhs < rhs) { - if (lhs < d->values.count) { - AstNode *n = d->values[lhs]; + if (lhs < spec->values.count) { + AstNode *n = spec->values[lhs]; gbString str = expr_to_string(n); error_node(n, "Extra initial expression `%s`", str); gb_string_free(str); } else { - error_node(d->names[0], "Extra initial expression"); + error_node(spec->names[0], "Extra initial expression"); } return false; } else if (lhs > rhs && rhs != 1) { - AstNode *n = d->names[rhs]; + AstNode *n = spec->names[rhs]; gbString str = expr_to_string(n); error_node(n, "Missing expression for `%s`", str); gb_string_free(str); @@ -1450,114 +1450,166 @@ void check_collect_entities(Checker *c, Array nodes, bool is_file_sco } case_end; - case_ast_node(vd, ValueDecl, decl); - if (vd->token.kind != Token_const) { - if (!c->context.scope->is_file) { - // NOTE(bill): local scope -> handle later and in order - break; - } - // NOTE(bill): You need to store the entity information here unline a constant declaration - isize entity_cap = vd->names.count; - isize entity_count = 0; - Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_cap); - DeclInfo *di = NULL; - if (vd->values.count > 0) { - di = make_declaration_info(heap_allocator(), c->context.scope, c->context.decl); - di->entities = entities; - di->type_expr = vd->type; - di->init_expr = vd->values[0]; - - - if (vd->flags & VarDeclFlag_thread_local) { - error_node(decl, "#thread_local variable declarations cannot have initialization values"); + case_ast_node(gd, GenDecl, decl); + for_array(i, gd->specs) { + AstNode *spec = gd->specs[i]; + switch (gd->token.kind) { + case Token_var: + case Token_let: { + if (!c->context.scope->is_file) { + // NOTE(bill): local scope -> handle later and in order + break; } - } + ast_node(vd, ValueSpec, spec); + + // NOTE(bill): You need to store the entity information here unline a constant declaration + isize entity_cap = vd->names.count; + isize entity_count = 0; + Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_cap); + DeclInfo *di = NULL; + if (vd->values.count > 0) { + di = make_declaration_info(heap_allocator(), c->context.scope, c->context.decl); + di->entities = entities; + di->type_expr = vd->type; + di->init_expr = vd->values[0]; - for_array(i, vd->names) { - AstNode *name = vd->names[i]; - AstNode *value = NULL; - if (i < vd->values.count) { - value = vd->values[i]; + if (gd->flags & VarDeclFlag_thread_local) { + error_node(decl, "#thread_local variable declarations cannot have initialization values"); + } } + + + for_array(i, vd->names) { + AstNode *name = vd->names[i]; + AstNode *value = NULL; + if (i < vd->values.count) { + value = vd->values[i]; + } + if (name->kind != AstNode_Ident) { + error_node(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); + continue; + } + Entity *e = make_entity_variable(c->allocator, c->context.scope, name->Ident, NULL, (gd->flags&VarDeclFlag_immutable) != 0); + e->Variable.is_thread_local = (gd->flags & VarDeclFlag_thread_local) != 0; + e->identifier = name; + + if (gd->flags & VarDeclFlag_using) { + gd->flags &= ~VarDeclFlag_using; // NOTE(bill): This error will be only caught once + error_node(name, "`using` is not allowed at the file scope"); + } + entities[entity_count++] = e; + + DeclInfo *d = di; + if (d == NULL) { + AstNode *init_expr = value; + d = make_declaration_info(heap_allocator(), e->scope, c->context.decl); + d->type_expr = vd->type; + d->init_expr = init_expr; + } + + add_entity_and_decl_info(c, name, e, d); + } + + if (di != NULL) { + di->entity_count = entity_count; + } + + check_arity_match(c, vd); + } break; + + case Token_const: { + ast_node(vd, ValueSpec, spec); + + for_array(i, vd->names) { + AstNode *name = vd->names[i]; + if (name->kind != AstNode_Ident) { + error_node(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); + continue; + } + + AstNode *init = NULL; + if (i < vd->values.count) { + init = vd->values[i]; + } + + DeclInfo *d = make_declaration_info(c->allocator, c->context.scope, c->context.decl); + Entity *e = NULL; + + AstNode *up_init = unparen_expr(init); + // if (up_init != NULL && is_ast_node_type(up_init)) { + // AstNode *type = up_init; + // e = make_entity_type_name(c->allocator, d->scope, name->Ident, NULL); + // // TODO(bill): What if vd->type != NULL??? How to handle this case? + // d->type_expr = type; + // d->init_expr = type; + // } else if (up_init != NULL && up_init->kind == AstNode_Alias) { + // #if 1 + // error_node(up_init, "#alias declarations are not yet supported"); + // continue; + // #else + // e = make_entity_alias(c->allocator, d->scope, name->Ident, NULL, EntityAlias_Invalid, NULL); + // d->type_expr = vd->type; + // d->init_expr = up_init->Alias.expr; + // #endif + // // } else if (init != NULL && up_init->kind == AstNode_ProcLit) { + // // e = make_entity_procedure(c->allocator, d->scope, name->Ident, NULL, up_init->ProcLit.tags); + // // d->proc_lit = up_init; + // // d->type_expr = vd->type; + // } else { + e = make_entity_constant(c->allocator, d->scope, name->Ident, NULL, empty_exact_value); + d->type_expr = vd->type; + d->init_expr = init; + // } + GB_ASSERT(e != NULL); + e->identifier = name; + + add_entity_and_decl_info(c, name, e, d); + } + + check_arity_match(c, vd); + } break; + + case Token_type: { + ast_node(td, TypeSpec, spec); + + AstNode *name = td->name; if (name->kind != AstNode_Ident) { error_node(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); - continue; - } - Entity *e = make_entity_variable(c->allocator, c->context.scope, name->Ident, NULL, (vd->flags&VarDeclFlag_immutable) != 0); - e->Variable.is_thread_local = (vd->flags & VarDeclFlag_thread_local) != 0; - e->identifier = name; - - if (vd->flags & VarDeclFlag_using) { - vd->flags &= ~VarDeclFlag_using; // NOTE(bill): This error will be only caught once - error_node(name, "`using` is not allowed at the file scope"); - } - entities[entity_count++] = e; - - DeclInfo *d = di; - if (d == NULL) { - AstNode *init_expr = value; - d = make_declaration_info(heap_allocator(), e->scope, c->context.decl); - d->type_expr = vd->type; - d->init_expr = init_expr; + break; } - add_entity_and_decl_info(c, name, e, d); - } - - if (di != NULL) { - di->entity_count = entity_count; - } - - check_arity_match(c, vd); - } else { - for_array(i, vd->names) { - AstNode *name = vd->names[i]; - if (name->kind != AstNode_Ident) { - error_node(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); - continue; - } - - AstNode *init = NULL; - if (i < vd->values.count) { - init = vd->values[i]; - } DeclInfo *d = make_declaration_info(c->allocator, c->context.scope, c->context.decl); Entity *e = NULL; - AstNode *up_init = unparen_expr(init); - // if (up_init != NULL && is_ast_node_type(up_init)) { - // AstNode *type = up_init; - // e = make_entity_type_name(c->allocator, d->scope, name->Ident, NULL); - // // TODO(bill): What if vd->type != NULL??? How to handle this case? - // d->type_expr = type; - // d->init_expr = type; - // } else if (up_init != NULL && up_init->kind == AstNode_Alias) { - // #if 1 - // error_node(up_init, "#alias declarations are not yet supported"); - // continue; - // #else - // e = make_entity_alias(c->allocator, d->scope, name->Ident, NULL, EntityAlias_Invalid, NULL); - // d->type_expr = vd->type; - // d->init_expr = up_init->Alias.expr; - // #endif - // // } else if (init != NULL && up_init->kind == AstNode_ProcLit) { - // // e = make_entity_procedure(c->allocator, d->scope, name->Ident, NULL, up_init->ProcLit.tags); - // // d->proc_lit = up_init; - // // d->type_expr = vd->type; - // } else { - e = make_entity_constant(c->allocator, d->scope, name->Ident, NULL, empty_exact_value); - d->type_expr = vd->type; - d->init_expr = init; - // } - GB_ASSERT(e != NULL); + AstNode *type = unparen_expr(td->type); + e = make_entity_type_name(c->allocator, d->scope, name->Ident, NULL); + // TODO(bill): What if vd->type != NULL??? How to handle this case? + d->type_expr = type; + d->init_expr = type; + e->identifier = name; - add_entity_and_decl_info(c, name, e, d); - } + } break; - check_arity_match(c, vd); + case Token_import: + case Token_import_load: { + ast_node(id, ImportSpec, spec); + if (!c->context.scope->is_file) { + if (id->is_import) { + error_node(decl, "import declarations are only allowed in the file scope"); + } else { + error_node(decl, "import_load declarations are only allowed in the file scope"); + } + // NOTE(bill): _Should_ be caught by the parser + // TODO(bill): Better error handling if it isn't + continue; + } + DelayedDecl di = {c->context.scope, spec}; + array_add(&c->delayed_imports, di); + } break; + } } case_end; @@ -1579,41 +1631,6 @@ void check_collect_entities(Checker *c, Array nodes, bool is_file_sco add_entity_and_decl_info(c, name, e, d); case_end; - case_ast_node(td, TypeDecl, decl); - AstNode *name = td->name; - if (name->kind != AstNode_Ident) { - error_node(name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[name->kind])); - break; - } - - - DeclInfo *d = make_declaration_info(c->allocator, c->context.scope, c->context.decl); - Entity *e = NULL; - - AstNode *type = unparen_expr(td->type); - e = make_entity_type_name(c->allocator, d->scope, name->Ident, NULL); - // TODO(bill): What if vd->type != NULL??? How to handle this case? - d->type_expr = type; - d->init_expr = type; - - e->identifier = name; - add_entity_and_decl_info(c, name, e, d); - case_end; - - case_ast_node(id, ImportDecl, decl); - if (!c->context.scope->is_file) { - if (id->is_import) { - error_node(decl, "#import declarations are only allowed in the file scope"); - } else { - error_node(decl, "#load declarations are only allowed in the file scope"); - } - // NOTE(bill): _Should_ be caught by the parser - // TODO(bill): Better error handling if it isn't - continue; - } - DelayedDecl di = {c->context.scope, decl}; - array_add(&c->delayed_imports, di); - case_end; case_ast_node(fl, ForeignLibrary, decl); if (!c->context.scope->is_file) { if (fl->is_system) { @@ -1882,7 +1899,7 @@ void check_import_entities(Checker *c, Map *file_scopes) { for_array(i, c->delayed_imports) { Scope *parent_scope = c->delayed_imports[i].parent; AstNode *decl = c->delayed_imports[i].decl; - ast_node(id, ImportDecl, decl); + ast_node(id, ImportSpec, decl); Token token = id->relpath; GB_ASSERT(parent_scope->is_file); diff --git a/src/ir.cpp b/src/ir.cpp index abf2d80be..accdeb86e 100644 --- a/src/ir.cpp +++ b/src/ir.cpp @@ -5793,7 +5793,7 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { case_ast_node(us, UsingStmt, node); for_array(i, us->list) { AstNode *decl = unparen_expr(us->list[i]); - if (decl->kind == AstNode_ValueDecl) { + if (decl->kind == AstNode_GenDecl) { ir_build_stmt(proc, decl); } } @@ -5812,56 +5812,88 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { ir_build_assign_op(proc, addr, v_one, op); case_end; - case_ast_node(vd, ValueDecl, node); - if (vd->token.kind != Token_const) { - irModule *m = proc->module; - gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena); + case_ast_node(gd, GenDecl, node); + for_array(i, gd->specs) { + AstNode *spec = gd->specs[i]; + switch (gd->token.kind) { + case Token_var: + case Token_let: { + ast_node(vd, ValueSpec, spec); - if (vd->values.count == 0) { // declared and zero-initialized - for_array(i, vd->names) { - AstNode *name = vd->names[i]; - if (!ir_is_blank_ident(name)) { - ir_add_local_for_identifier(proc, name, true); - } - } - } else { // Tuple(s) - Array lvals = {}; - Array inits = {}; - array_init(&lvals, m->tmp_allocator, vd->names.count); - array_init(&inits, m->tmp_allocator, vd->names.count); + irModule *m = proc->module; + gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena); - for_array(i, vd->names) { - AstNode *name = vd->names[i]; - irAddr lval = ir_addr(NULL); - if (!ir_is_blank_ident(name)) { - ir_add_local_for_identifier(proc, name, false); - lval = ir_build_addr(proc, name); - } - - array_add(&lvals, lval); - } - - for_array(i, vd->values) { - irValue *init = ir_build_expr(proc, vd->values[i]); - Type *t = ir_type(init); - if (t->kind == Type_Tuple) { - for (isize i = 0; i < t->Tuple.variable_count; i++) { - Entity *e = t->Tuple.variables[i]; - irValue *v = ir_emit_struct_ev(proc, init, i); - array_add(&inits, v); + if (vd->values.count == 0) { // declared and zero-initialized + for_array(i, vd->names) { + AstNode *name = vd->names[i]; + if (!ir_is_blank_ident(name)) { + ir_add_local_for_identifier(proc, name, true); } - } else { - array_add(&inits, init); + } + } else { // Tuple(s) + Array lvals = {}; + Array inits = {}; + array_init(&lvals, m->tmp_allocator, vd->names.count); + array_init(&inits, m->tmp_allocator, vd->names.count); + + for_array(i, vd->names) { + AstNode *name = vd->names[i]; + irAddr lval = ir_addr(NULL); + if (!ir_is_blank_ident(name)) { + ir_add_local_for_identifier(proc, name, false); + lval = ir_build_addr(proc, name); + } + + array_add(&lvals, lval); + } + + for_array(i, vd->values) { + irValue *init = ir_build_expr(proc, vd->values[i]); + Type *t = ir_type(init); + if (t->kind == Type_Tuple) { + for (isize i = 0; i < t->Tuple.variable_count; i++) { + Entity *e = t->Tuple.variables[i]; + irValue *v = ir_emit_struct_ev(proc, init, i); + array_add(&inits, v); + } + } else { + array_add(&inits, init); + } + } + + + for_array(i, inits) { + ir_addr_store(proc, lvals[i], inits[i]); } } + gb_temp_arena_memory_end(tmp); + } break; - for_array(i, inits) { - ir_addr_store(proc, lvals[i], inits[i]); + case Token_type: { + ast_node(td, TypeSpec, node); + + AstNode *ident = td->name; + GB_ASSERT(ident->kind == AstNode_Ident); + Entity *e = entity_of_ident(proc->module->info, ident); + GB_ASSERT(e != NULL); + if (e->kind == Entity_TypeName) { + // NOTE(bill): Generate a new name + // parent_proc.name-guid + String ts_name = e->token.string; + isize name_len = proc->name.len + 1 + ts_name.len + 1 + 10 + 1; + u8 *name_text = gb_alloc_array(proc->module->allocator, u8, name_len); + i32 guid = cast(i32)proc->module->members.entries.count; + name_len = gb_snprintf(cast(char *)name_text, name_len, "%.*s.%.*s-%d", LIT(proc->name), LIT(ts_name), guid); + String name = make_string(name_text, name_len-1); + + irValue *value = ir_value_type_name(proc->module->allocator, + name, e->type); + map_set(&proc->module->entity_names, hash_pointer(e), name); + ir_gen_global_type_name(proc->module, e, name); } + } break; } - - gb_temp_arena_memory_end(tmp); } case_end; @@ -5936,28 +5968,6 @@ void ir_build_stmt_internal(irProcedure *proc, AstNode *node) { } case_end; - case_ast_node(td, TypeDecl, node); - AstNode *ident = td->name; - GB_ASSERT(ident->kind == AstNode_Ident); - Entity *e = entity_of_ident(proc->module->info, ident); - GB_ASSERT(e != NULL); - if (e->kind == Entity_TypeName) { - // NOTE(bill): Generate a new name - // parent_proc.name-guid - String ts_name = e->token.string; - isize name_len = proc->name.len + 1 + ts_name.len + 1 + 10 + 1; - u8 *name_text = gb_alloc_array(proc->module->allocator, u8, name_len); - i32 guid = cast(i32)proc->module->members.entries.count; - name_len = gb_snprintf(cast(char *)name_text, name_len, "%.*s.%.*s-%d", LIT(proc->name), LIT(ts_name), guid); - String name = make_string(name_text, name_len-1); - - irValue *value = ir_value_type_name(proc->module->allocator, - name, e->type); - map_set(&proc->module->entity_names, hash_pointer(e), name); - ir_gen_global_type_name(proc->module, e, name); - } - case_end; - case_ast_node(as, AssignStmt, node); ir_emit_comment(proc, str_lit("AssignStmt")); diff --git a/src/parser.cpp b/src/parser.cpp index d3347bbef..47056373c 100644 --- a/src/parser.cpp +++ b/src/parser.cpp @@ -297,13 +297,6 @@ AST_NODE_KIND(_ComplexStmtEnd, "", i32) \ AST_NODE_KIND(_StmtEnd, "", i32) \ AST_NODE_KIND(_DeclBegin, "", i32) \ AST_NODE_KIND(BadDecl, "bad declaration", struct { Token begin, end; }) \ - AST_NODE_KIND(ValueDecl, "value declaration", struct { \ - Token token; \ - Array names; \ - AstNode * type; \ - Array values; \ - u32 flags; \ - }) \ AST_NODE_KIND(ProcDecl, "procedure declaration", struct { \ Token token; \ AstNode *name; \ @@ -314,20 +307,6 @@ AST_NODE_KIND(_DeclBegin, "", i32) \ String foreign_name; \ String link_name; \ }) \ - AST_NODE_KIND(TypeDecl, "type declaration", struct { \ - Token token; \ - AstNode *name; \ - AstNode *type; \ - }) \ - AST_NODE_KIND(ImportDecl, "import declaration", struct { \ - Token token; \ - bool is_import; \ - Token relpath; \ - String fullpath; \ - Token import_name; \ - AstNode *cond; \ - AstNode *note; \ - }) \ AST_NODE_KIND(ForeignLibrary, "foreign library", struct { \ Token token, filepath; \ Token library_name; \ @@ -339,6 +318,29 @@ AST_NODE_KIND(_DeclBegin, "", i32) \ Token token; \ AstNode *name; \ }) \ + AST_NODE_KIND(GenDecl, "generic declaration", struct { \ + Token token; \ + Token open; \ + Token close; \ + Array specs; \ + u64 flags; \ + }) \ + AST_NODE_KIND(ValueSpec, "value specification", struct { \ + Array names; \ + AstNode * type; \ + Array values; \ + }) \ + AST_NODE_KIND(TypeSpec, "type specification", struct { \ + AstNode *name; \ + AstNode *type; \ + }) \ + AST_NODE_KIND(ImportSpec, "import specification", struct { \ + bool is_import; \ + Token relpath; \ + String fullpath; \ + Token import_name; \ + AstNode *cond; \ + }) \ AST_NODE_KIND(_DeclEnd, "", i32) \ AST_NODE_KIND(Field, "field", struct { \ Array names; \ @@ -540,12 +542,15 @@ Token ast_node_token(AstNode *node) { case AstNode_PushContext: return node->PushContext.token; case AstNode_BadDecl: return node->BadDecl.begin; - case AstNode_ValueDecl: return node->ValueDecl.token; case AstNode_ProcDecl: return node->ProcDecl.token; - case AstNode_ImportDecl: return node->ImportDecl.token; case AstNode_ForeignLibrary: return node->ForeignLibrary.token; case AstNode_Label: return node->Label.token; + case AstNode_GenDecl: return node->GenDecl.token; + case AstNode_ValueSpec: return ast_node_token(node->ValueSpec.names[0]); + case AstNode_ImportSpec: return node->ImportSpec.import_name; + case AstNode_TypeSpec: return ast_node_token(node->TypeSpec.name); + case AstNode_Field: if (node->Field.names.count > 0) { @@ -761,15 +766,6 @@ AstNode *clone_ast_node(gbAllocator a, AstNode *node) { break; case AstNode_BadDecl: break; - case AstNode_ValueDecl: - n->ValueDecl.names = clone_ast_node_array(a, n->ValueDecl.names); - n->ValueDecl.type = clone_ast_node(a, n->ValueDecl.type); - n->ValueDecl.values = clone_ast_node_array(a, n->ValueDecl.values); - break; - case AstNode_ImportDecl: - n->ImportDecl.cond = clone_ast_node(a, n->ImportDecl.cond); - n->ImportDecl.note = clone_ast_node(a, n->ImportDecl.note); - break; case AstNode_ForeignLibrary: n->ForeignLibrary.cond = clone_ast_node(a, n->ForeignLibrary.cond); break; @@ -1428,15 +1424,6 @@ AstNode *ast_map_type(AstFile *f, Token token, AstNode *count, AstNode *key, Ast } -AstNode *ast_value_decl(AstFile *f, Token token, Array names, AstNode *type, Array values) { - AstNode *result = make_ast_node(f, AstNode_ValueDecl); - result->ValueDecl.token = token; - result->ValueDecl.names = names; - result->ValueDecl.type = type; - result->ValueDecl.values = values; - return result; -} - AstNode *ast_proc_decl(AstFile *f, Token token, AstNode *name, AstNode *type, AstNode *body, u64 tags, AstNode *foreign_library, String foreign_name, String link_name) { AstNode *result = make_ast_node(f, AstNode_ProcDecl); @@ -1451,25 +1438,6 @@ AstNode *ast_proc_decl(AstFile *f, Token token, AstNode *name, AstNode *type, As return result; } -AstNode *ast_type_decl(AstFile *f, Token token, AstNode *name, AstNode *type) { - AstNode *result = make_ast_node(f, AstNode_TypeDecl); - result->TypeDecl.token = token; - result->TypeDecl.name = name; - result->TypeDecl.type = type; - return result; -} - - -AstNode *ast_import_decl(AstFile *f, Token token, bool is_import, Token relpath, Token import_name, AstNode *cond) { - AstNode *result = make_ast_node(f, AstNode_ImportDecl); - result->ImportDecl.token = token; - result->ImportDecl.is_import = is_import; - result->ImportDecl.relpath = relpath; - result->ImportDecl.import_name = import_name; - result->ImportDecl.cond = cond; - return result; -} - AstNode *ast_foreign_library(AstFile *f, Token token, Token filepath, Token library_name, AstNode *cond, bool is_system) { AstNode *result = make_ast_node(f, AstNode_ForeignLibrary); result->ForeignLibrary.token = token; @@ -1487,6 +1455,41 @@ AstNode *ast_label_decl(AstFile *f, Token token, AstNode *name) { return result; } +AstNode *ast_gen_decl(AstFile *f, Token token, Token open, Token close, Array specs) { + AstNode *result = make_ast_node(f, AstNode_GenDecl); + result->GenDecl.token = token; + result->GenDecl.open = open; + result->GenDecl.close = close; + result->GenDecl.specs = specs; + return result; +} + +AstNode *ast_value_spec(AstFile *f, Array names, AstNode *type, Array values) { + AstNode *result = make_ast_node(f, AstNode_ValueSpec); + result->ValueSpec.names = names; + result->ValueSpec.type = type; + result->ValueSpec.values = values; + return result; +} + +AstNode *ast_type_spec(AstFile *f, AstNode *name, AstNode *type) { + AstNode *result = make_ast_node(f, AstNode_TypeSpec); + result->TypeSpec.name = name; + result->TypeSpec.type = type; + return result; +} + +AstNode *ast_import_spec(AstFile *f, bool is_import, Token relpath, Token import_name, AstNode *cond) { + AstNode *result = make_ast_node(f, AstNode_ImportSpec); + result->ImportSpec.is_import = is_import; + result->ImportSpec.relpath = relpath; + result->ImportSpec.import_name = import_name; + result->ImportSpec.cond = cond; + return result; +} + + + bool next_token(AstFile *f) { Token prev = f->curr_token; @@ -1688,18 +1691,9 @@ bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) { return s->ProcLit.body != NULL; case AstNode_ProcDecl: return s->ProcDecl.body != NULL; - case AstNode_TypeDecl: - return is_semicolon_optional_for_node(f, s->TypeDecl.type); - - case AstNode_ValueDecl: - if (s->ValueDecl.token.kind != Token_const) { - if (s->ValueDecl.values.count > 0) { - AstNode *last = s->ValueDecl.values[s->ValueDecl.values.count-1]; - return is_semicolon_optional_for_node(f, last); - } - } - break; + case AstNode_TypeSpec: + return is_semicolon_optional_for_node(f, s->TypeSpec.type); } return false; @@ -2526,61 +2520,6 @@ AstNode *parse_type(AstFile *f) { return type; } - -AstNode *parse_value_decl(AstFile *f, Token token) { - Array lhs = parse_lhs_expr_list(f); - AstNode *type = NULL; - Array values = {}; - bool is_mutable = token.kind != Token_const; - - if (allow_token(f, Token_Colon)) { - type = parse_type(f); - } else if (f->curr_token.kind != Token_Eq && - f->curr_token.kind != Token_Semicolon) { - syntax_error(f->curr_token, "Expected a type separator `:` or `=`"); - } - - - switch (f->curr_token.kind) { - case Token_Eq: - next_token(f); - values = parse_rhs_expr_list(f); - if (values.count > lhs.count) { - syntax_error(f->curr_token, "Too many values on the right hand side of the declaration"); - } else if (values.count < lhs.count && !is_mutable) { - syntax_error(f->curr_token, "All constant declarations must be defined"); - } else if (values.count == 0) { - syntax_error(f->curr_token, "Expected an expression for this declaration"); - } - break; - } - - if (is_mutable) { - if (type == NULL && values.count == 0) { - syntax_error(f->curr_token, "Missing variable type or initialization"); - return ast_bad_decl(f, f->curr_token, f->curr_token); - } - } else { - if (type == NULL && values.count == 0 && lhs.count > 0) { - syntax_error(f->curr_token, "Missing constant value"); - return ast_bad_decl(f, f->curr_token, f->curr_token); - } - } - - if (values.data == NULL) { - values = make_ast_node_array(f); - } - - - Array specs = {}; - array_init(&specs, heap_allocator(), 1); - AstNode *decl = ast_value_decl(f, token, lhs, type, values); - if (token.kind == Token_let) { - decl->ValueDecl.flags |= VarDeclFlag_immutable; - } - return decl; -} - AstNode *parse_proc_decl(AstFile *f) { TokenKind look_ahead = look_ahead_token_kind(f, 1); if (look_ahead != Token_Ident) { @@ -2611,11 +2550,179 @@ AstNode *parse_proc_decl(AstFile *f) { return ast_proc_decl(f, token, name, type, body, tags, foreign_library, foreign_name, link_name); } -AstNode *parse_type_decl(AstFile *f) { - Token token = expect_token(f, Token_type); + +#define PARSE_SPEC_FUNC(name) AstNode *name(AstFile *f, Token token) +typedef PARSE_SPEC_FUNC(ParseSpecFunc); + +AstNode *parse_gen_decl(AstFile *f, Token token, ParseSpecFunc *func) { + Array specs = {}; + Token open = {}; + Token close = {}; + + if (f->curr_token.kind == Token_OpenParen) { + specs = make_ast_node_array(f); + open = expect_token(f, Token_OpenParen); + while (f->curr_token.kind != Token_CloseParen && + f->curr_token.kind != Token_EOF) { + AstNode *spec = func(f, token); + array_add(&specs, spec); + expect_semicolon(f, spec); + } + close = expect_token(f, Token_CloseParen); + } else { + array_init(&specs, heap_allocator(), 1); + array_add(&specs, func(f, token)); + } + + AstNode *decl = ast_gen_decl(f, token, open, close, specs); + if (token.kind == Token_let) { + decl->GenDecl.flags |= VarDeclFlag_immutable; + } + return decl; +} + +PARSE_SPEC_FUNC(parse_value_spec) { + bool is_mutable = token.kind != Token_const; + + Array names = parse_ident_list(f); + AstNode *type = NULL; + Array values = {}; + + if (allow_token(f, Token_Colon)) { + type = parse_type(f); + } else if (f->curr_token.kind != Token_Eq && + f->curr_token.kind != Token_Semicolon) { + syntax_error(f->curr_token, "Expected a type separator `:` or `=`"); + } + + if (allow_token(f, Token_Eq)) { + values = parse_rhs_expr_list(f); + if (values.count > names.count) { + syntax_error(f->curr_token, "Too many values on the right hand side of the declaration"); + } else if (values.count < names.count && !is_mutable) { + syntax_error(f->curr_token, "All constant declarations must be defined"); + } else if (values.count == 0) { + syntax_error(f->curr_token, "Expected an expression for this declaration"); + } + } + + + if (is_mutable) { + if (type == NULL && values.count == 0) { + syntax_error(f->curr_token, "Missing variable type or initialization"); + return ast_bad_decl(f, f->curr_token, f->curr_token); + } + } else { + if (type == NULL && values.count == 0 && names.count > 0) { + syntax_error(f->curr_token, "Missing constant value"); + return ast_bad_decl(f, f->curr_token, f->curr_token); + } + } + + if (values.data == NULL) { + values = make_ast_node_array(f); + } + + return ast_value_spec(f, names, type, values); +} + +PARSE_SPEC_FUNC(parse_type_spec) { AstNode *name = parse_ident(f); AstNode *type = parse_type(f); - return ast_type_decl(f, token, name, type); + return ast_type_spec(f, name, type); +} + +PARSE_SPEC_FUNC(parse_import_spec) { + if (token.kind == Token_import) { + AstNode *cond = NULL; + Token import_name = {}; + + switch (f->curr_token.kind) { + case Token_Period: + import_name = f->curr_token; + import_name.kind = Token_Ident; + next_token(f); + break; + case Token_Ident: + import_name = f->curr_token; + next_token(f); + break; + default: + import_name.pos = f->curr_token.pos; + break; + } + + if (import_name.string == "_") { + syntax_error(import_name, "Illegal import name: `_`"); + } + + Token file_path = expect_token_after(f, Token_String, "import"); + if (allow_token(f, Token_when)) { + cond = parse_expr(f, false); + } + + AstNode *spec = NULL; + if (f->curr_proc != NULL) { + syntax_error(import_name, "You cannot use `import` within a procedure. This must be done at the file scope"); + spec = ast_bad_decl(f, import_name, file_path); + } else { + spec = ast_import_spec(f, true, file_path, import_name, cond); + } + return spec; + } else { + AstNode *cond = NULL; + Token file_path = expect_token_after(f, Token_String, "import_load"); + Token import_name = file_path; + import_name.string = str_lit("."); + + if (allow_token(f, Token_when)) { + cond = parse_expr(f, false); + } + + AstNode *spec = NULL; + if (f->curr_proc != NULL) { + syntax_error(import_name, "You cannot use `import_load` within a procedure. This must be done at the file scope"); + spec = ast_bad_decl(f, import_name, file_path); + } else { + spec = ast_import_spec(f, false, file_path, import_name, cond); + } + return spec; + } +} + +AstNode *parse_decl(AstFile *f) { + ParseSpecFunc *func = NULL; + switch (f->curr_token.kind) { + case Token_var: + case Token_const: + case Token_let: + func = parse_value_spec; + break; + + case Token_type: + func = parse_type_spec; + break; + + case Token_import: + case Token_import_load: + func = parse_import_spec; + break; + + case Token_proc: + return parse_proc_decl(f); + + default: { + Token tok = f->curr_token; + fix_advance_to_next_stmt(f); + syntax_error(tok, "Expected a declaration"); + return ast_bad_decl(f, tok, f->curr_token); + } + } + + Token token = f->curr_token; + next_token(f); + + return parse_gen_decl(f, token, func); } @@ -2626,8 +2733,7 @@ AstNode *parse_simple_stmt(AstFile *f, StmtAllowFlag flags) { case Token_var: case Token_const: case Token_let: - next_token(f); - return parse_value_decl(f, token); + return parse_decl(f); } Array lhs = parse_lhs_expr_list(f); @@ -3723,20 +3829,11 @@ AstNode *parse_stmt(AstFile *f) { case Token_var: case Token_const: case Token_let: - s = parse_simple_stmt(f, StmtAllowFlag_None); - expect_semicolon(f, s); - return s; - case Token_proc: - s = parse_proc_decl(f); - expect_semicolon(f, s); - return s; - case Token_type: - s = parse_type_decl(f); - expect_semicolon(f, s); - return s; - + case Token_import: + case Token_import_load: + return parse_decl(f); case Token_if: return parse_if_stmt(f); case Token_when: return parse_when_stmt(f); @@ -3767,8 +3864,7 @@ AstNode *parse_stmt(AstFile *f) { AstNode *decl = NULL; if (f->curr_token.kind == Token_var || f->curr_token.kind == Token_let) { - Token var = f->curr_token; next_token(f); - decl = parse_value_decl(f, var); + decl = parse_decl(f); expect_semicolon(f, decl); } else { Array list = parse_lhs_expr_list(f); @@ -3785,20 +3881,17 @@ AstNode *parse_stmt(AstFile *f) { } - if (decl != NULL && decl->kind == AstNode_ValueDecl) { - #if 1 - if (decl->ValueDecl.token.kind == Token_const) { - syntax_error(token, "`using` may not be applied to constant declarations"); + if (decl != NULL && decl->kind == AstNode_GenDecl) { + if (decl->GenDecl.token.kind != Token_var && + decl->GenDecl.token.kind != Token_let) { + syntax_error(token, "`using` may only be applied to variable declarations"); return decl; } if (f->curr_proc == NULL) { syntax_error(token, "`using` is not allowed at the file scope"); } else { - decl->ValueDecl.flags |= VarDeclFlag_using; + decl->GenDecl.flags |= VarDeclFlag_using; } - #else - decl->ValueDecl.flags |= VarDeclFlag_using; - #endif return decl; } @@ -3846,6 +3939,7 @@ AstNode *parse_stmt(AstFile *f) { return ast_push_context(f, token, expr, body); } break; +#if 0 case Token_import: { Token token = expect_token(f, Token_import); AstNode *cond = NULL; @@ -3907,6 +4001,7 @@ AstNode *parse_stmt(AstFile *f) { expect_semicolon(f, decl); return decl; } +#endif case Token_Hash: { AstNode *s = NULL; @@ -3989,14 +4084,15 @@ AstNode *parse_stmt(AstFile *f) { } else if (tag == "thread_local") { AstNode *s = parse_stmt(f); - if (s->kind == AstNode_ValueDecl) { - if (s->ValueDecl.token.kind == Token_const) { - syntax_error(token, "`thread_local` may not be applied to constant declarations"); + if (s->kind == AstNode_GenDecl) { + if (s->GenDecl.token.kind != Token_var && + s->GenDecl.token.kind != Token_let) { + syntax_error(token, "`thread_local` may only be applied to variable declarations"); } if (f->curr_proc != NULL) { syntax_error(token, "`thread_local` is only allowed at the file scope"); } else { - s->ValueDecl.flags |= VarDeclFlag_thread_local; + s->GenDecl.flags |= VarDeclFlag_thread_local; } return s; } @@ -4219,87 +4315,94 @@ void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, Arraykind != AstNode_EmptyStmt) { // NOTE(bill): Sanity check syntax_error_node(node, "Only declarations are allowed at file scope %.*s", LIT(ast_node_strings[node->kind])); - } else if (node->kind == AstNode_ImportDecl) { - ast_node(id, ImportDecl, node); - String collection_name = {}; - String oirignal_string = id->relpath.string; - String file_str = id->relpath.string; - gbAllocator allocator = heap_allocator(); // TODO(bill): Change this allocator - String import_file = {}; + } else if (node->kind == AstNode_GenDecl) { + ast_node(gd, GenDecl, node); + if (gd->token.kind == Token_import || + gd->token.kind == Token_import_load) { + for_array(spec_index, gd->specs) { + AstNode *spec = gd->specs[spec_index]; + ast_node(id, ImportSpec, spec); + String collection_name = {}; + String oirignal_string = id->relpath.string; + String file_str = id->relpath.string; + gbAllocator allocator = heap_allocator(); // TODO(bill): Change this allocator + String import_file = {}; - #if 0 - isize colon_pos = -1; - for (isize j = 0; j < file_str.len; j++) { - if (file_str[j] == ':') { - colon_pos = j; - break; - } - } - if (colon_pos > 0) { - collection_name = make_string(file_str.text, colon_pos); - file_str.text += colon_pos+1; - file_str.len -= colon_pos+1; - } + #if 0 + isize colon_pos = -1; + for (isize j = 0; j < file_str.len; j++) { + if (file_str[j] == ':') { + colon_pos = j; + break; + } + } + if (colon_pos > 0) { + collection_name = make_string(file_str.text, colon_pos); + file_str.text += colon_pos+1; + file_str.len -= colon_pos+1; + } - if (collection_name.len == 0) { - syntax_error_node(node, "Missing import collection for path: `%.*s`", LIT(oirignal_string)); - decls[i] = ast_bad_decl(f, id->relpath, id->relpath); - continue; - } + if (collection_name.len == 0) { + syntax_error_node(node, "Missing import collection for path: `%.*s`", LIT(oirignal_string)); + decls[i] = ast_bad_decl(f, id->relpath, id->relpath); + continue; + } - if (collection_name == "core") { - String abs_path = get_fullpath_core(allocator, file_str); - if (gb_file_exists(cast(char *)abs_path.text)) { // NOTE(bill): This should be null terminated - import_file = abs_path; - } - } else if (collection_name == "local") { - String rel_path = get_fullpath_relative(allocator, base_dir, file_str); - if (gb_file_exists(cast(char *)rel_path.text)) { // NOTE(bill): This should be null terminated + if (collection_name == "core") { + String abs_path = get_fullpath_core(allocator, file_str); + if (gb_file_exists(cast(char *)abs_path.text)) { // NOTE(bill): This should be null terminated + import_file = abs_path; + } + } else if (collection_name == "local") { + String rel_path = get_fullpath_relative(allocator, base_dir, file_str); + if (gb_file_exists(cast(char *)rel_path.text)) { // NOTE(bill): This should be null terminated + import_file = rel_path; + } + } else { + syntax_error_node(node, "Unknown import collection: `%.*s`", LIT(collection_name)); + decls[i] = ast_bad_decl(f, id->relpath, id->relpath); + continue; + } + + if (!is_import_path_valid(file_str)) { + if (id->is_import) { + syntax_error_node(node, "Invalid import path: `%.*s`", LIT(file_str)); + } else { + syntax_error_node(node, "Invalid include path: `%.*s`", LIT(file_str)); + } + // NOTE(bill): It's a naughty name + decls[i] = ast_bad_decl(f, id->relpath, id->relpath); + continue; + } + + #else + if (!is_import_path_valid(file_str)) { + if (id->is_import) { + syntax_error_node(node, "Invalid import path: `%.*s`", LIT(file_str)); + } else { + syntax_error_node(node, "Invalid include path: `%.*s`", LIT(file_str)); + } + // NOTE(bill): It's a naughty name + decls[i] = ast_bad_decl(f, id->relpath, id->relpath); + continue; + } + + + String rel_path = get_fullpath_relative(allocator, base_dir, file_str); import_file = rel_path; - } - } else { - syntax_error_node(node, "Unknown import collection: `%.*s`", LIT(collection_name)); - decls[i] = ast_bad_decl(f, id->relpath, id->relpath); - continue; - } + if (!gb_file_exists(cast(char *)rel_path.text)) { // NOTE(bill): This should be null terminated + String abs_path = get_fullpath_core(allocator, file_str); + if (gb_file_exists(cast(char *)abs_path.text)) { + import_file = abs_path; + } + } + #endif - if (!is_import_path_valid(file_str)) { - if (id->is_import) { - syntax_error_node(node, "Invalid import path: `%.*s`", LIT(file_str)); - } else { - syntax_error_node(node, "Invalid include path: `%.*s`", LIT(file_str)); - } - // NOTE(bill): It's a naughty name - decls[i] = ast_bad_decl(f, id->relpath, id->relpath); - continue; - } - - #else - if (!is_import_path_valid(file_str)) { - if (id->is_import) { - syntax_error_node(node, "Invalid import path: `%.*s`", LIT(file_str)); - } else { - syntax_error_node(node, "Invalid include path: `%.*s`", LIT(file_str)); - } - // NOTE(bill): It's a naughty name - decls[i] = ast_bad_decl(f, id->relpath, id->relpath); - continue; - } - - - String rel_path = get_fullpath_relative(allocator, base_dir, file_str); - import_file = rel_path; - if (!gb_file_exists(cast(char *)rel_path.text)) { // NOTE(bill): This should be null terminated - String abs_path = get_fullpath_core(allocator, file_str); - if (gb_file_exists(cast(char *)abs_path.text)) { - import_file = abs_path; + id->fullpath = import_file; + try_add_import_path(p, import_file, file_str, ast_node_token(node).pos); } } - #endif - - id->fullpath = import_file; - try_add_import_path(p, import_file, file_str, ast_node_token(node).pos); } else if (node->kind == AstNode_ForeignLibrary) { AstNodeForeignLibrary *fl = &node->ForeignLibrary; String file_str = fl->filepath.string; diff --git a/src/ssa.cpp b/src/ssa.cpp index 18de4d767..5eef0602d 100644 --- a/src/ssa.cpp +++ b/src/ssa.cpp @@ -1948,7 +1948,7 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { case_ast_node(us, UsingStmt, node); for_array(i, us->list) { AstNode *decl = unparen_expr(us->list[i]); - if (decl->kind == AstNode_ValueDecl) { + if (decl->kind == AstNode_GenDecl) { ssa_build_stmt(p, decl); } } @@ -1968,61 +1968,6 @@ void ssa_build_stmt_internal(ssaProc *p, AstNode *node) { ssa_build_assign_op(p, addr, ssa_const_int(p, t, 1), op); case_end; - case_ast_node(vd, ValueDecl, node); - if (vd->token.kind != Token_const) { - ssaModule *m = p->module; - gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena); - if (vd->values.count == 0) { - for_array(i, vd->names) { - AstNode *name = vd->names[i]; - if (!ssa_is_blank_ident(name)) { - ssa_add_local_for_ident(p, name); - } - } - } else { - Array lvals = {0}; - Array inits = {0}; - array_init(&lvals, m->tmp_allocator, vd->names.count); - array_init(&inits, m->tmp_allocator, vd->names.count); - - for_array(i, vd->names) { - AstNode *name = vd->names[i]; - ssaAddr lval = ssa_addr(NULL); - if (!ssa_is_blank_ident(name)) { - lval = ssa_add_local_for_ident(p, name); - } - - array_add(&lvals, lval); - } - - for_array(i, vd->values) { - ssaValue *init = ssa_build_expr(p, vd->values[i]); - if (init == NULL) { // TODO(bill): remove this - continue; - } - Type *t = base_type(init->type); - if (t->kind == Type_Tuple) { - for (isize i = 0; i < t->Tuple.variable_count; i++) { - // Entity *e = t->Tuple.variables[i]; - ssaValue *v = ssa_emit_value_index(p, init, i); - array_add(&inits, v); - } - } else { - array_add(&inits, init); - } - } - - for_array(i, inits) { - ssa_addr_store(p, lvals[i], inits[i]); - } - } - - gb_temp_arena_memory_end(tmp); - } else { - GB_PANIC("TODO(bill): ssa_build_stmt Type/Proc Entities"); - } - case_end; - case_ast_node(as, AssignStmt, node); ssa_emit_comment(p, str_lit("AssignStmt"));