From 6168403e0ded41d19147ef3d256c51ec08f9ff7f Mon Sep 17 00:00:00 2001 From: Brendan Hansen Date: Mon, 31 Aug 2020 17:42:18 -0500 Subject: [PATCH] refactoring core libraries --- Makefile | 4 +- core/alloc.onyx | 9 +- core/core.onyx | 8 - core/file.onyx | 3 +- core/intrinsics.onyx | 2 +- core/js/webgl.js | 266 +++++++++++++ core/js/webgl.onyx | 841 ++++++++++++++++++++++++++++++++++++++++ core/math.onyx | 2 +- core/memory.onyx | 2 +- core/printing.onyx | 124 ------ core/random.onyx | 2 +- core/std/js.onyx | 15 + core/std/wasi.onyx | 17 + core/stdio.onyx | 74 ++-- core/string.onyx | 4 - core/sys/js.onyx | 26 ++ core/sys/wasi.onyx | 43 ++ core/wasi.onyx | 35 +- misc/onyx.sublime-build | 2 +- onyx | Bin 582304 -> 582312 bytes progs/poly_test.onyx | 13 +- src/onyx.c | 4 +- src/onyxsymres.c | 2 + 23 files changed, 1262 insertions(+), 236 deletions(-) delete mode 100644 core/core.onyx create mode 100644 core/js/webgl.js create mode 100644 core/js/webgl.onyx delete mode 100644 core/printing.onyx create mode 100644 core/std/js.onyx create mode 100644 core/std/wasi.onyx create mode 100644 core/sys/js.onyx create mode 100644 core/sys/wasi.onyx diff --git a/Makefile b/Makefile index 0dbd8ab9..4778e4be 100644 --- a/Makefile +++ b/Makefile @@ -21,7 +21,7 @@ LIBS= TARGET=./onyx # These aren't working yet -INSTALL_FOLDER=/usr/share/onyx/core +INSTALL_FOLDER=/usr/share/onyx DEFINES=-DCORE_INSTALLATION=$(INSTALL_FOLDER) ifeq ($(RELEASE), 1) @@ -38,7 +38,7 @@ $(TARGET): $(OBJ_FILES) install: $(TARGET) core/* cp $(TARGET) /usr/bin/ - cp -r core/* $(INSTALL_FOLDER) + cp -r core/ $(INSTALL_FOLDER)/ install_syntax: misc/onyx.vim misc/onyx.sublime-syntax cp ./misc/onyx_compiler.vim /usr/share/vim/vim82/compiler/onyx.vim diff --git a/core/alloc.onyx b/core/alloc.onyx index 2d82bae8..72cfa6cf 100644 --- a/core/alloc.onyx +++ b/core/alloc.onyx @@ -1,10 +1,7 @@ -package memory +package core -#include_file "memory" -#include_file "intrinsics" - -use package builtin -use package intrinsics { memory_size, memory_grow } +#include_file "core/memory" +#include_file "core/intrinsics" heap_allocator : Allocator; diff --git a/core/core.onyx b/core/core.onyx deleted file mode 100644 index 45346071..00000000 --- a/core/core.onyx +++ /dev/null @@ -1,8 +0,0 @@ -package core - -#include_file "alloc" -#include_file "intrinsics" -#include_file "memory" -#include_file "printing" -#include_file "random" -#include_file "string" diff --git a/core/file.onyx b/core/file.onyx index b36ea634..70ac2683 100644 --- a/core/file.onyx +++ b/core/file.onyx @@ -1,9 +1,10 @@ -package file +package core_file // Many of these functions will be improved when // multiple return values are implemented. use package builtin +use package core use package wasi OpenMode :: enum { diff --git a/core/intrinsics.onyx b/core/intrinsics.onyx index 3d727272..38aa0f00 100644 --- a/core/intrinsics.onyx +++ b/core/intrinsics.onyx @@ -1,4 +1,4 @@ -package intrinsics +package core memory_size :: proc -> i32 #intrinsic --- memory_grow :: proc (val: i32) -> i32 #intrinsic --- diff --git a/core/js/webgl.js b/core/js/webgl.js new file mode 100644 index 00000000..16b971e2 --- /dev/null +++ b/core/js/webgl.js @@ -0,0 +1,266 @@ +WebGl_Wasm = { + init(name, namelen) { + const decoder = new TextDecoder(); + const str = new Uint8Array(WASM_MEMORY.buffer, name, namelen); + const canvasname = decoder.decode(str); + + this.programs = []; + this.shaders = []; + this.buffers = []; + this.framebuffers = []; + this.renderbuffers = []; + this.textures = []; + this.uniformlocs = []; + + this.canvas = document.getElementById(canvasname); + if (this.canvas == null) return 0; + + this.gl = this.canvas.getContext("webgl2"); + if (this.gl == null) return 0; + + return 1; + }, + + activeTexture(texture) { this.gl.activeTexture(texture); }, + attachShader(program, shader) { this.gl.attachShader(this.programs[program], this.shaders[shader]); return this.programs[program]; }, + bindAttribLocation(program, index, name, namelen) { console.log("NOT IMPLEMENTED!"); }, + bindBuffer(target, buffer) { + if (buffer == -1) { + this.gl.bindBuffer(target, null); + } else { + this.gl.bindBuffer(target, this.buffers[buffer]); + } + }, + bindFramebuffer(target, framebuffer) { this.gl.bindFramebuffer(target, this.framebuffers[framebuffer]); }, + bindRenderbuffer(target, renderbuffer) { this.gl.bindRenderbuffer(target, this.renderbuffers[renderbuffer]); }, + bindTexture(target, texture) { this.gl.bindTexture(target, this.textures[texture]); }, + blendColor(red, green, blue, alpha) { this.gl.blendColor(red, green, blue, alpha); }, + blendEquation(mode) { this.gl.blendEquation(mode); }, + blendEquationSeparate(modeRGB, modeAlpha) { this.gl.blendEquationSeparate(modeRGB, modeAlpha); }, + blendFunc(sfactor, dfactor) { this.gl.blendFunc(sfactor, dfactor); }, + blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha) { this.gl.blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha); }, + + blitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, mask, filter) { + this.gl.blitFramebuffer(sx0, sy0, sx1, sy1, dx0, dy0, dx1, dy1, mask, filter); + }, + + bufferDataWithData(target, bufferdata, bufferlen, usage) { + const data = new DataView(WASM_MEMORY.buffer, bufferdata, bufferlen); + this.gl.bufferData(target, data, usage); + }, + + bufferDataNoData(target, size, usage) { this.gl.bufferData(target, size, usage); }, + bufferSubData(target, offset, bufferdata, bufferlen) { + const data = new DataView(WASM_MEMORY.buffer, bufferdata, bufferlen); + this.gl.bufferSubData(target, offset, data); + }, + checkFrameBufferStatus(target) { return this.gl.checkFrameBufferStatus(target); }, + clear(bit) { this.gl.clear(bit); }, + clearColor(r, g, b, a) { this.gl.clearColor(r, g, b, a); }, + clearDepth(depth) { this.gl.clearDepth(depth); }, + clearStencil(stencil) { this.gl.clearStencil(stencil); }, + colorMask(r, g, b, a) { this.gl.colorMask(r, g, b, a); }, + compileShader(shader) { this.gl.compileShader(this.shaders[shader]); }, + compressedTexImage2D(target, level, internalformat, width, height, border, data, datalen) { + const pixels = new DataView(WASM_MEMORY.buffer, data, datalen); + this.gl.compressedTexImage2D(target, level, internalformat, width, height, border, pixels); + }, + compressedTexSubImage2D(target, level, internalformat, xoff, yoff, width, height, format, data, datalen) { + const pixels = new DataView(WASM_MEMORY.buffer, data, datalen); + this.gl.compressedSubTexImage2D(target, level, internalformat, xoff, yoff, width, height, format, pixels); + }, + copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size) { this.gl.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); }, + copyTexImage2D(target, level, internalforamt, x, y, width, height, border) { + this.gl.copyTexImage2D(target, level, internalforamt, x, y, width, height, border); + }, + copyTexSubImage2D(target, level, xoff, yoff, x, y, width, height) { + this.gl.copyTexSubImage2D(target, level, xoff, yoff, x, y, width, height); + }, + createBuffer() { + const buf = this.gl.createBuffer(); + if (buf == null) return -1; + + this.buffers.push(buf); + return this.buffers.length - 1; + }, + createFramebuffer() { + const buf = this.gl.createFramebuffer(); + if (buf == null) return -1; + + this.framebuffers.push(buf); + return this.framebuffers.length - 1; + }, + createProgram() { + const prog = this.gl.createProgram(); + if (prog == null) return -1; + + this.programs.push(prog); + return this.programs.length - 1; + }, + createRenderbuffer() { + const buf = this.gl.createRenderbuffer(); + if (buf == null) return -1; + + this.renderbuffers.push(buf); + return this.renderbuffers.length - 1; + }, + createShader(type) { + const shader = this.gl.createShader(type); + if (shader == null) return -1; + + this.shaders.push(shader); + return this.shaders.length - 1; + }, + createTexture() { + const texture = this.gl.createTexture(); + if (texture == null) return -1; + + this.textures.push(texture); + return this.textures.length - 1; + }, + cullFace(mode) { this.gl.cullFace(mode); }, + deleteBuffer(buffer) { this.gl.deleteBuffer(this.buffers[buffer]); }, + deleteFramebuffer(framebuffer) { this.gl.deleteFramebuffer(this.framebuffers[framebuffer]); }, + deleteProgram(program) { this.gl.deleteProgram(this.programs[program]); }, + deleteRenderbuffer(renderbuffer) { this.gl.deleteRenderbuffer(this.renderbuffers[renderbuffer]); }, + deleteShader(shader) { this.gl.deleteShader(this.shaders[shader]); }, + deleteTexture(texture) { this.gl.deleteTexture(this.textures[texture]); }, + depthFunc(func) { this.gl.depthFunc(func); }, + depthMask(flag) { this.gl.depthMask(flag); }, + depthRange(znear, zfar) { this.gl.depthRange(znear, zfar); }, + detachShader(program, shader) { this.gl.detachShader(this.programs[program], this.shaders[shader]); }, + disable(cap) { this.gl.disable(cap); }, + disableVertexAttribArray(index) { this.gl.disableVertexAttribArray(index); }, + drawArrays(mode, first, count) { this.gl.drawArrays(mode, first, count); }, + drawElements(mode, count, type, offset) { this.gl.drawElements(mode, count, type, offset); }, + enable(cap) { this.gl.enable(cap); }, + enableVertexAttribArray(index) { this.gl.enableVertexAttribArray(index); }, + finish() { this.gl.finish(); }, + flush() { this.gl.flush(); }, + framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer) { + this.gl.framebufferRenderbuffer(target, attachment, renderbuffertarget, this.renderbuffers[renderbuffer]); + }, + framebufferTexture2D(target, attachment, texttarget, texture, level) { + this.gl.framebufferTexture2D(target, attachment, texttarget, this.textures[texture], level); + }, + framebufferTextureLayer(target, attachment, texture, level, layer) { this.gl.framebufferTextureLayer(target, attachment, this.textures[texture], level, layer); }, + frontFace(mode) { this.gl.frontFace(mode); }, + generateMipmap(target) { this.gl.generateMipmap(target); }, + getActiveAttrib(program, index, out) { + const loc = this.gl.getActiveAttrib(this.programs[program], index); + const data = new Int32Array(WASM_MEMORY.buffer, out, 2); + data[0] = loc.size; + data[1] = loc.type; + }, + getActiveUniform(program, index, out) { + const loc = this.gl.getActiveUniform(this.programs[program], index); + const data = new Int32Array(WASM_MEMORY.buffer, out, 2); + data[0] = loc.size; + data[1] = loc.type; + }, + // getAttachedShaders() { console.log("NOT IMPLEMENTED!"); }, + getAttribLocation(program, name, namelen) { + const decoder = new TextDecoder(); + const str = new Uint8Array(WASM_MEMORY.buffer, name, namelen); + const attribname = decoder.decode(str); + + return this.gl.getAttribLocation(this.programs[program], attribname); + }, + // getBufferParameter() { console.log("NOT IMPLEMENTED!"); }, + getBufferSubData(target, srcbyteoffset, dstbufferdata, dstbufferlen, dstoffset, length) { + const dst = new DataView(WASM_MEMORY.buffer, dstbufferdata, dstbufferlen); + this.gl.getBufferSubData(target, srcbyteoffset, dst, dstoffset, length); + }, + getError() { return this.gl.getError(); }, + getInternalformatParameter(target, internalformat, pname) { return this.gl.getInternalformatParameter(target, internalformat, pname); }, + // many of the 'gets() { console.log("NOT IMPLEMENTED!"); }, + getShaderParameter(shader, param) { return this.gl.getShaderParameter(this.shaders[shader], param); }, + getProgramParameter(program, param) { return this.gl.getProgramParameter(this.programs[program], param); }, + getUniformLocation(program, name, namelen) { + const decoder = new TextDecoder(); + const str = new Int8Array(WASM_MEMORY.buffer, name, namelen); + const uniname = decoder.decode(str); + + this.uniformlocs.push(this.gl.getUniformLocation(this.programs[program], uniname)); + return this.uniformlocs.length - 1; + }, + getVertexAttribOffset(index, pname) { return this.gl.getVertexAttribOffset(index, pname); }, + hint(target, mode) { this.gl.hint(target, mode); }, + isEnabled(cap) { return this.gl.isEnabled(cap); }, + invalidateFramebuffer(target, attachdata, attachlen) { + const attachments = new Int32Array(WASM_MEMORY.buffer, attachdata, attachlen); + this.gl.invalidateFramebuffer(target, attacements); + }, + invalidateSubFramebuffer(target, attachdata, attachlen, x, y, width, height) { + const attachments = new Int32Array(WASM_MEMORY.buffer, attachdata, attachlen); + this.gl.invalidateFramebuffer(target, attacements, x, y, width, height); + }, + lineWidth(width) { this.gl.lineWidth(width); }, + linkProgram(program) { this.gl.linkProgram(this.programs[program]); }, + pixelStorei(pname, param) { this.gl.pixelStorei(pname, param); }, + polygonOffset(factor, units) { this.gl.polygonOffset(factor, units); }, + printProgramInfoLog(program) { console.log(this.gl.getProgramInfoLog(this.programs[program])); }, + printShaderInfoLog(shader) { console.log(this.gl.getShaderInfoLog(this.shaders[shader])); }, + readPixels(x, y, width, height, format, type, pixels, pixelslen) { + const pixeldata = new Uint8Array(WASM_MEMORY.buffer, pixels, pixelslen); + this.gl.readPixels(x, y, width, height, format, type, pixeldata); + }, + readBuffer(src) { this.gl.readBuffer(src); }, + renderbufferStorageMultisample(target, samples, internalforamt, width, height) { + this.gl.renderbufferStorageMultisample(target, samples, internalforamt, width, height); + }, + sampleCoverage(value, invert) { this.gl.sampleCoverage(value, invert); }, + scissor(x, y, width, height) { this.gl.scissor(x, y, width, height); }, + shaderSource(shader, source, sourcelen) { + const decoder = new TextDecoder(); + const str = new Int8Array(WASM_MEMORY.buffer, source, sourcelen); + const sourcedata = decoder.decode(str); + + this.gl.shaderSource(this.shaders[shader], sourcedata); + }, + stencilFunc(func, ref, mask) { this.gl.stencilFunc(func, ref, mask); }, + stencilFuncSeparate(face, func, ref, mask) { this.gl.stencilFuncSeparate(face, func, ref, mask); }, + stencilMask(mask) { this.gl.stencilMask(mask); }, + stencilMaskSeparate(face, mask) { this.gl.stencilMaskSeparate(face, mask); }, + stencilOp(fail, zfail, mask) { this.gl.stencilOp(fail, zfail, mask); }, + stencilOpSeparate(face, fail, zfail, zpass) { this.gl.stencilOpSeparate(face, fail, zfail, zpass); }, + texImage2D(target, level, internalforamt, width, height, border, format, type, pixels, pixelslen) { + const data = new DataView(WASM_MEMORY.buffer, pixels, pixelslen); + this.gl.texImage2D(target, level, internalforamt, width, height, border, format, type, data); + }, + texParameterf(target, pname, param) { this.gl.texParameterf(target, pname, param); }, + texParameteri(target, pname, param) { this.gl.texParameteri(target, pname, param); }, + texSubImage2D(target, level, xoff, yoff, width, height, format, type, pixels, pixelslen) { + const data = new Uint8Array(WASM_MEMORY.buffer, pixels, pixelslen); + this.gl.texSubImage2D(target, level, xoff, yoff, width, height, format, type, data); + }, + uniform1f(loc, x) { this.gl.uniform1f(this.uniformlocs[loc], x); }, + uniform1i(loc, x) { this.gl.uniform1i(this.uniformlocs[loc], x); }, + uniform2f(loc, x, y) { this.gl.uniform2f(this.uniformlocs[loc], x, y); }, + uniform2i(loc, x, y) { this.gl.uniform2i(this.uniformlocs[loc], x, y); }, + uniform3f(loc, x, y, z) { this.gl.uniform3f(this.uniformlocs[loc], x, y, z); }, + uniform3i(loc, x, y, z) { this.gl.uniform3i(this.uniformlocs[loc], x, y, z); }, + uniform4f(loc, x, y, z, w) { this.gl.uniform4f(this.uniformlocs[loc], x, y, z, w); }, + uniform4i(loc, x, y, z, w) { this.gl.uniform4i(this.uniformlocs[loc], x, y, z, w); }, + uniformMatrix2(loc, transpose, valueptr) { + const data = new Float32Array(WASM_MEMORY.buffer, valueptr, 4); + this.gl.uniformMatrix2fv(this.uniformlocs[loc], transpose, data); + }, + uniformMatrix3(loc, transpose, valueptr) { + const data = new Float32Array(WASM_MEMORY.buffer, valueptr, 9); + this.gl.uniformMatrix3fv(this.uniformlocs[loc], transpose, data); + }, + uniformMatrix4(loc, transpose, valueptr) { + const data = new Float32Array(WASM_MEMORY.buffer, valueptr, 16); + this.gl.uniformMatrix4fv(this.uniformlocs[loc], transpose, data); + }, + useProgram(program) { this.gl.useProgram(this.programs[program]); }, + validateProgram(program) { this.gl.validateProgram(this.program[program]); }, + vertexAttrib1f(idx, x) { this.gl.vertexAttrib1f(idx, x); }, + vertexAttrib2f(idx, x, y) { this.gl.vertexAttrib2f(idx, x, y); }, + vertexAttrib3f(idx, x, y, z) { this.gl.vertexAttrib3f(idx, x, y, z); }, + vertexAttrib4f(idx, x, y, z, w) { this.gl.vertexAttrib4f(idx, x, y, z, w); }, + vertexAttribPointer(idx, size, type, normalized, stride, offset) { this.gl.vertexAttribPointer(idx, size, type, normalized, stride, offset); }, + viewport(x, y, width, height) { this.gl.viewport(x, y, width, height); }, + +}; diff --git a/core/js/webgl.onyx b/core/js/webgl.onyx new file mode 100644 index 00000000..738f8b12 --- /dev/null +++ b/core/js/webgl.onyx @@ -0,0 +1,841 @@ +package gl +// To be used with the corresponding gl.js + +use package builtin + +// ClearBufferMask +DEPTH_BUFFER_BIT :: 0x00000100 +STENCIL_BUFFER_BIT :: 0x00000400 +COLOR_BUFFER_BIT :: 0x00004000 + +// BeginMode +POINTS :: 0x0000 +LINES :: 0x0001 +LINE_LOOP :: 0x0002 +LINE_STRIP :: 0x0003 +TRIANGLES :: 0x0004 +TRIANGLE_STRIP :: 0x0005 +TRIANGLE_FAN :: 0x0006 + +// AlphaFunction (not supported in ES20) +// NEVER +// LESS +// EQUAL +// LEQUAL +// GREATER +// NOTEQUAL +// GEQUAL +// ALWAYS + +// BlendingFactorDest +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 + +// BlendingFactorSrc +// ZERO +// ONE +DST_COLOR :: 0x0306 +ONE_MINUS_DST_COLOR :: 0x0307 +SRC_ALPHA_SATURATE :: 0x0308 +// SRC_ALPHA +// ONE_MINUS_SRC_ALPHA +// DST_ALPHA +// ONE_MINUS_DST_ALPHA + +// BlendEquationSeparate +FUNC_ADD :: 0x8006 +BLEND_EQUATION :: 0x8009 +BLEND_EQUATION_RGB :: 0x8009 // same as BLEND_EQUATION +BLEND_EQUATION_ALPHA :: 0x883D + +// BlendSubtract +FUNC_SUBTRACT :: 0x800A +FUNC_REVERSE_SUBTRACT :: 0x800B + +// Separate Blend Functions +BLEND_DST_RGB :: 0x80C8 +BLEND_SRC_RGB :: 0x80C9 +BLEND_DST_ALPHA :: 0x80CA +BLEND_SRC_ALPHA :: 0x80CB +CONSTANT_COLOR :: 0x8001 +ONE_MINUS_CONSTANT_COLOR :: 0x8002 +CONSTANT_ALPHA :: 0x8003 +ONE_MINUS_CONSTANT_ALPHA :: 0x8004 +BLEND_COLOR :: 0x8005 + +// Buffer Objects +ARRAY_BUFFER :: 0x8892 +ELEMENT_ARRAY_BUFFER :: 0x8893 +ARRAY_BUFFER_BINDING :: 0x8894 +ELEMENT_ARRAY_BUFFER_BINDING :: 0x8895 + +STREAM_DRAW :: 0x88E0 +STATIC_DRAW :: 0x88E4 +DYNAMIC_DRAW :: 0x88E8 + +BUFFER_SIZE :: 0x8764 +BUFFER_USAGE :: 0x8765 + +CURRENT_VERTEX_ATTRIB :: 0x8626 + +// CullFaceMode +FRONT :: 0x0404 +BACK :: 0x0405 +FRONT_AND_BACK :: 0x0408 + +// DepthFunction +// NEVER +// LESS +// EQUAL +// LEQUAL +// GREATER +// NOTEQUAL +// GEQUAL +// ALWAYS + +// EnableCap +// TEXTURE_2D +CULL_FACE :: 0x0B44 +BLEND :: 0x0BE2 +DITHER :: 0x0BD0 +STENCIL_TEST :: 0x0B90 +DEPTH_TEST :: 0x0B71 +SCISSOR_TEST :: 0x0C11 +POLYGON_OFFSET_FILL :: 0x8037 +SAMPLE_ALPHA_TO_COVERAGE :: 0x809E +SAMPLE_COVERAGE :: 0x80A0 + +// ErrorCode +NO_ERROR :: 0 +INVALID_ENUM :: 0x0500 +INVALID_VALUE :: 0x0501 +INVALID_OPERATION :: 0x0502 +OUT_OF_MEMORY :: 0x0505 + +// FrontFaceDirection +CW :: 0x0900 +CCW :: 0x0901 + +// GetPName +LINE_WIDTH :: 0x0B21 +ALIASED_POINT_SIZE_RANGE :: 0x846D +ALIASED_LINE_WIDTH_RANGE :: 0x846E +CULL_FACE_MODE :: 0x0B45 +FRONT_FACE :: 0x0B46 +DEPTH_RANGE :: 0x0B70 +DEPTH_WRITEMASK :: 0x0B72 +DEPTH_CLEAR_VALUE :: 0x0B73 +DEPTH_FUNC :: 0x0B74 +STENCIL_CLEAR_VALUE :: 0x0B91 +STENCIL_FUNC :: 0x0B92 +STENCIL_FAIL :: 0x0B94 +STENCIL_PASS_DEPTH_FAIL :: 0x0B95 +STENCIL_PASS_DEPTH_PASS :: 0x0B96 +STENCIL_REF :: 0x0B97 +STENCIL_VALUE_MASK :: 0x0B93 +STENCIL_WRITEMASK :: 0x0B98 +STENCIL_BACK_FUNC :: 0x8800 +STENCIL_BACK_FAIL :: 0x8801 +STENCIL_BACK_PASS_DEPTH_FAIL :: 0x8802 +STENCIL_BACK_PASS_DEPTH_PASS :: 0x8803 +STENCIL_BACK_REF :: 0x8CA3 +STENCIL_BACK_VALUE_MASK :: 0x8CA4 +STENCIL_BACK_WRITEMASK :: 0x8CA5 +VIEWPORT :: 0x0BA2 +SCISSOR_BOX :: 0x0C10 +// SCISSOR_TEST +COLOR_CLEAR_VALUE :: 0x0C22 +COLOR_WRITEMASK :: 0x0C23 +UNPACK_ALIGNMENT :: 0x0CF5 +PACK_ALIGNMENT :: 0x0D05 +MAX_TEXTURE_SIZE :: 0x0D33 +MAX_VIEWPORT_DIMS :: 0x0D3A +SUBPIXEL_BITS :: 0x0D50 +RED_BITS :: 0x0D52 +GREEN_BITS :: 0x0D53 +BLUE_BITS :: 0x0D54 +ALPHA_BITS :: 0x0D55 +DEPTH_BITS :: 0x0D56 +STENCIL_BITS :: 0x0D57 +POLYGON_OFFSET_UNITS :: 0x2A00 +// POLYGON_OFFSET_FILL +POLYGON_OFFSET_FACTOR :: 0x8038 +TEXTURE_BINDING_2D :: 0x8069 +SAMPLE_BUFFERS :: 0x80A8 +SAMPLES :: 0x80A9 +SAMPLE_COVERAGE_VALUE :: 0x80AA +SAMPLE_COVERAGE_INVERT :: 0x80AB + +// GetTextureParameter +// TEXTURE_MAG_FILTER +// TEXTURE_MIN_FILTER +// TEXTURE_WRAP_S +// TEXTURE_WRAP_T + +COMPRESSED_TEXTURE_FORMATS :: 0x86A3 + +// HintMode +DONT_CARE :: 0x1100 +FASTEST :: 0x1101 +NICEST :: 0x1102 + +// HintTarget +GENERATE_MIPMAP_HINT :: 0x8192 + +// DataType +BYTE :: 0x1400 +UNSIGNED_BYTE :: 0x1401 +SHORT :: 0x1402 +UNSIGNED_SHORT :: 0x1403 +INT :: 0x1404 +UNSIGNED_INT :: 0x1405 +FLOAT :: 0x1406 + +// PixelFormat +DEPTH_COMPONENT :: 0x1902 +ALPHA :: 0x1906 +RGB :: 0x1907 +RGBA :: 0x1908 +LUMINANCE :: 0x1909 +LUMINANCE_ALPHA :: 0x190A + +// PixelType +// UNSIGNED_BYTE +UNSIGNED_SHORT_4_4_4_4 :: 0x8033 +UNSIGNED_SHORT_5_5_5_1 :: 0x8034 +UNSIGNED_SHORT_5_6_5 :: 0x8363 + +// Shaders +FRAGMENT_SHADER :: 0x8B30 +VERTEX_SHADER :: 0x8B31 +MAX_VERTEX_ATTRIBS :: 0x8869 +MAX_VERTEX_UNIFORM_VECTORS :: 0x8DFB +MAX_VARYING_VECTORS :: 0x8DFC +MAX_COMBINED_TEXTURE_IMAGE_UNITS :: 0x8B4D +MAX_VERTEX_TEXTURE_IMAGE_UNITS :: 0x8B4C +MAX_TEXTURE_IMAGE_UNITS :: 0x8872 +MAX_FRAGMENT_UNIFORM_VECTORS :: 0x8DFD +SHADER_TYPE :: 0x8B4F +DELETE_STATUS :: 0x8B80 +LINK_STATUS :: 0x8B82 +VALIDATE_STATUS :: 0x8B83 +ATTACHED_SHADERS :: 0x8B85 +ACTIVE_UNIFORMS :: 0x8B86 +ACTIVE_ATTRIBUTES :: 0x8B89 +SHADING_LANGUAGE_VERSION :: 0x8B8C +CURRENT_PROGRAM :: 0x8B8D + +// StencilFunction +NEVER :: 0x0200 +LESS :: 0x0201 +EQUAL :: 0x0202 +LEQUAL :: 0x0203 +GREATER :: 0x0204 +NOTEQUAL :: 0x0205 +GEQUAL :: 0x0206 +ALWAYS :: 0x0207 + +// StencilOp +// ZERO +KEEP :: 0x1E00 +REPLACE :: 0x1E01 +INCR :: 0x1E02 +DECR :: 0x1E03 +INVERT :: 0x150A +INCR_WRAP :: 0x8507 +DECR_WRAP :: 0x8508 + +// StringName +VENDOR :: 0x1F00 +RENDERER :: 0x1F01 +VERSION :: 0x1F02 + +// TextureMagFilter +NEAREST :: 0x2600 +LINEAR :: 0x2601 + +// TextureMinFilter +// NEAREST +// LINEAR +NEAREST_MIPMAP_NEAREST :: 0x2700 +LINEAR_MIPMAP_NEAREST :: 0x2701 +NEAREST_MIPMAP_LINEAR :: 0x2702 +LINEAR_MIPMAP_LINEAR :: 0x2703 + +// TextureParameterName +TEXTURE_MAG_FILTER :: 0x2800 +TEXTURE_MIN_FILTER :: 0x2801 +TEXTURE_WRAP_S :: 0x2802 +TEXTURE_WRAP_T :: 0x2803 + +// TextureTarget +TEXTURE_2D :: 0x0DE1 +TEXTURE :: 0x1702 + +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 +MAX_CUBE_MAP_TEXTURE_SIZE :: 0x851C + +// TextureUnit +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 + +// TextureWrapMode +REPEAT :: 0x2901 +CLAMP_TO_EDGE :: 0x812F +MIRRORED_REPEAT :: 0x8370 + +// Uniform Types +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_2D :: 0x8B5E +SAMPLER_CUBE :: 0x8B60 + +// Vertex Arrays +VERTEX_ATTRIB_ARRAY_ENABLED :: 0x8622 +VERTEX_ATTRIB_ARRAY_SIZE :: 0x8623 +VERTEX_ATTRIB_ARRAY_STRIDE :: 0x8624 +VERTEX_ATTRIB_ARRAY_TYPE :: 0x8625 +VERTEX_ATTRIB_ARRAY_NORMALIZED :: 0x886A +VERTEX_ATTRIB_ARRAY_POINTER :: 0x8645 +VERTEX_ATTRIB_ARRAY_BUFFER_BINDING :: 0x889F + +// Read Format +IMPLEMENTATION_COLOR_READ_TYPE :: 0x8B9A +IMPLEMENTATION_COLOR_READ_FORMAT :: 0x8B9B + +// Shader Source +COMPILE_STATUS :: 0x8B81 + +// Shader Precision-Specified Types +LOW_FLOAT :: 0x8DF0 +MEDIUM_FLOAT :: 0x8DF1 +HIGH_FLOAT :: 0x8DF2 +LOW_INT :: 0x8DF3 +MEDIUM_INT :: 0x8DF4 +HIGH_INT :: 0x8DF5 + +// Framebuffer Object. +FRAMEBUFFER :: 0x8D40 +RENDERBUFFER :: 0x8D41 + +RGBA4 :: 0x8056 +RGB5_A1 :: 0x8057 +RGB565 :: 0x8D62 +DEPTH_COMPONENT16 :: 0x81A5 +STENCIL_INDEX :: 0x1901 +STENCIL_INDEX8 :: 0x8D48 +DEPTH_STENCIL :: 0x84F9 + +RENDERBUFFER_WIDTH :: 0x8D42 +RENDERBUFFER_HEIGHT :: 0x8D43 +RENDERBUFFER_INTERNAL_FORMAT :: 0x8D44 +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_ATTACHMENT_OBJECT_TYPE :: 0x8CD0 +FRAMEBUFFER_ATTACHMENT_OBJECT_NAME :: 0x8CD1 +FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL :: 0x8CD2 +FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE :: 0x8CD3 + +COLOR_ATTACHMENT0 :: 0x8CE0 +DEPTH_ATTACHMENT :: 0x8D00 +STENCIL_ATTACHMENT :: 0x8D20 +DEPTH_STENCIL_ATTACHMENT :: 0x821A + +NONE :: 0 + +FRAMEBUFFER_COMPLETE :: 0x8CD5 +FRAMEBUFFER_INCOMPLETE_ATTACHMENT :: 0x8CD6 +FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT :: 0x8CD7 +FRAMEBUFFER_INCOMPLETE_DIMENSIONS :: 0x8CD9 +FRAMEBUFFER_UNSUPPORTED :: 0x8CDD + +FRAMEBUFFER_BINDING :: 0x8CA6 +RENDERBUFFER_BINDING :: 0x8CA7 +MAX_RENDERBUFFER_SIZE :: 0x84E8 + +INVALID_FRAMEBUFFER_OPERATION :: 0x0506 + +READ_BUFFER :: 0x0C02 +UNPACK_ROW_LENGTH :: 0x0CF2 +UNPACK_SKIP_ROWS :: 0x0CF3 +UNPACK_SKIP_PIXELS :: 0x0CF4 +PACK_ROW_LENGTH :: 0x0D02 +PACK_SKIP_ROWS :: 0x0D03 +PACK_SKIP_PIXELS :: 0x0D04 +COLOR :: 0x1800 +DEPTH :: 0x1801 +STENCIL :: 0x1802 +RED :: 0x1903 +RGB8 :: 0x8051 +RGBA8 :: 0x8058 +RGB10_A2 :: 0x8059 +TEXTURE_BINDING_3D :: 0x806A +UNPACK_SKIP_IMAGES :: 0x806D +UNPACK_IMAGE_HEIGHT :: 0x806E +TEXTURE_3D :: 0x806F +TEXTURE_WRAP_R :: 0x8072 +MAX_3D_TEXTURE_SIZE :: 0x8073 +UNSIGNED_INT_2_10_10_10_REV :: 0x8368 +MAX_ELEMENTS_VERTICES :: 0x80E8 +MAX_ELEMENTS_INDICES :: 0x80E9 +TEXTURE_MIN_LOD :: 0x813A +TEXTURE_MAX_LOD :: 0x813B +TEXTURE_BASE_LEVEL :: 0x813C +TEXTURE_MAX_LEVEL :: 0x813D +MIN :: 0x8007 +MAX :: 0x8008 +DEPTH_COMPONENT24 :: 0x81A6 +MAX_TEXTURE_LOD_BIAS :: 0x84FD +TEXTURE_COMPARE_MODE :: 0x884C +TEXTURE_COMPARE_FUNC :: 0x884D +CURRENT_QUERY :: 0x8865 +QUERY_RESULT :: 0x8866 +QUERY_RESULT_AVAILABLE :: 0x8867 +STREAM_READ :: 0x88E1 +STREAM_COPY :: 0x88E2 +STATIC_READ :: 0x88E5 +STATIC_COPY :: 0x88E6 +DYNAMIC_READ :: 0x88E9 +DYNAMIC_COPY :: 0x88EA +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 +MAX_FRAGMENT_UNIFORM_COMPONENTS :: 0x8B49 +MAX_VERTEX_UNIFORM_COMPONENTS :: 0x8B4A +SAMPLER_3D :: 0x8B5F +SAMPLER_2D_SHADOW :: 0x8B62 +FRAGMENT_SHADER_DERIVATIVE_HINT :: 0x8B8B +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 +SRGB8_ALPHA8 :: 0x8C43 +COMPARE_REF_TO_TEXTURE :: 0x884E +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 +MAX_VARYING_COMPONENTS :: 0x8B4B +TEXTURE_2D_ARRAY :: 0x8C1A +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 +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 +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 +RGB_INTEGER :: 0x8D98 +RGBA_INTEGER :: 0x8D99 +SAMPLER_2D_ARRAY :: 0x8DC1 +SAMPLER_2D_ARRAY_SHADOW :: 0x8DC4 +SAMPLER_CUBE_SHADOW :: 0x8DC5 +UNSIGNED_INT_VEC2 :: 0x8DC6 +UNSIGNED_INT_VEC3 :: 0x8DC7 +UNSIGNED_INT_VEC4 :: 0x8DC8 +INT_SAMPLER_2D :: 0x8DCA +INT_SAMPLER_3D :: 0x8DCB +INT_SAMPLER_CUBE :: 0x8DCC +INT_SAMPLER_2D_ARRAY :: 0x8DCF +UNSIGNED_INT_SAMPLER_2D :: 0x8DD2 +UNSIGNED_INT_SAMPLER_3D :: 0x8DD3 +UNSIGNED_INT_SAMPLER_CUBE :: 0x8DD4 +UNSIGNED_INT_SAMPLER_2D_ARRAY :: 0x8DD7 +DEPTH_COMPONENT32F :: 0x8CAC +DEPTH32F_STENCIL8 :: 0x8CAD +FLOAT_32_UNSIGNED_INT_24_8_REV :: 0x8DAD +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 +UNSIGNED_INT_24_8 :: 0x84FA +DEPTH24_STENCIL8 :: 0x88F0 +UNSIGNED_NORMALIZED :: 0x8C17 +DRAW_FRAMEBUFFER_BINDING :: 0x8CA6 +READ_FRAMEBUFFER :: 0x8CA8 +DRAW_FRAMEBUFFER :: 0x8CA9 +READ_FRAMEBUFFER_BINDING :: 0x8CAA +RENDERBUFFER_SAMPLES :: 0x8CAB +FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER :: 0x8CD4 +MAX_COLOR_ATTACHMENTS :: 0x8CDF +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 +FRAMEBUFFER_INCOMPLETE_MULTISAMPLE :: 0x8D56 +MAX_SAMPLES :: 0x8D57 +HALF_FLOAT :: 0x140B +RG :: 0x8227 +RG_INTEGER :: 0x8228 +R8 :: 0x8229 +RG8 :: 0x822B +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 +R8_SNORM :: 0x8F94 +RG8_SNORM :: 0x8F95 +RGB8_SNORM :: 0x8F96 +RGBA8_SNORM :: 0x8F97 +SIGNED_NORMALIZED :: 0x8F9C +COPY_READ_BUFFER :: 0x8F36 +COPY_WRITE_BUFFER :: 0x8F37 +COPY_READ_BUFFER_BINDING :: 0x8F36 +COPY_WRITE_BUFFER_BINDING :: 0x8F37 +UNIFORM_BUFFER :: 0x8A11 +UNIFORM_BUFFER_BINDING :: 0x8A28 +UNIFORM_BUFFER_START :: 0x8A29 +UNIFORM_BUFFER_SIZE :: 0x8A2A +MAX_VERTEX_UNIFORM_BLOCKS :: 0x8A2B +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_FRAGMENT_UNIFORM_COMPONENTS :: 0x8A33 +UNIFORM_BUFFER_OFFSET_ALIGNMENT :: 0x8A34 +ACTIVE_UNIFORM_BLOCKS :: 0x8A36 +UNIFORM_TYPE :: 0x8A37 +UNIFORM_SIZE :: 0x8A38 +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_ACTIVE_UNIFORMS :: 0x8A42 +UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES :: 0x8A43 +UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER :: 0x8A44 +UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER :: 0x8A46 +INVALID_INDEX :: 0xFFFFFFF +MAX_VERTEX_OUTPUT_COMPONENTS :: 0x9122 +MAX_FRAGMENT_INPUT_COMPONENTS :: 0x9125 +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 +SYNC_FLUSH_COMMANDS_BIT :: 0x0000001 +VERTEX_ATTRIB_ARRAY_DIVISOR :: 0x88FE +ANY_SAMPLES_PASSED :: 0x8C2F +ANY_SAMPLES_PASSED_CONSERVATIVE :: 0x8D6A +SAMPLER_BINDING :: 0x8919 +RGB10_A2UI :: 0x906F +INT_2_10_10_10_REV :: 0x8D9F +TRANSFORM_FEEDBACK :: 0x8E22 +TRANSFORM_FEEDBACK_PAUSED :: 0x8E23 +TRANSFORM_FEEDBACK_ACTIVE :: 0x8E24 +TRANSFORM_FEEDBACK_BINDING :: 0x8E25 +TEXTURE_IMMUTABLE_FORMAT :: 0x912F +MAX_ELEMENT_INDEX :: 0x8D6B +TEXTURE_IMMUTABLE_LEVELS :: 0x82DF +TIMEOUT_IGNORED :: -1 + +// WebGL-specific enums +UNPACK_FLIP_Y_WEBGL :: 0x9240 +UNPACK_PREMULTIPLY_ALPHA_WEBGL :: 0x9241 +CONTEXT_LOST_WEBGL :: 0x9242 +UNPACK_COLORSPACE_CONVERSION_WEBGL :: 0x9243 +BROWSER_DEFAULT_WEBGL :: 0x9244 +MAX_CLIENT_WAIT_TIMEOUT_WEBGL :: 0x9247 + +GLenum :: #type u32 +GLboolean :: #type bool +GLbitfield :: #type u32 +GLbyte :: #type i8 +GLshort :: #type i16 +GLint :: #type i32 +GLsizei :: #type i32 +GLintptr :: #type i64 +GLsizeiptr :: #type i64 +GLubyte :: #type u8 +GLushort :: #type u16 +GLuint :: #type u32 +GLfloat :: #type f32 +GLclampf :: #type f32 + +GLProgram :: #type i32 +GLShader :: #type i32 +GLFramebuffer :: #type i32 +GLRenderbuffer :: #type i32 +GLTexture :: #type i32 +GLBuffer :: #type i32 +GLUniformLocation :: #type i32 + +GLActiveInfo :: struct { + size : GLint; + type : GLenum; + + // Not used + name : ^u8; +} + +GLMat2 :: #type [4] GLfloat +GLMat3 :: #type [9] GLfloat +GLMat4 :: #type [16] GLfloat + +activeTexture :: proc (texture: GLenum) #foreign "gl" "activeTexture" --- +attachShader :: proc (program: GLProgram, shader: GLShader) -> GLProgram #foreign "gl" "attachShader" --- +bindAttribLocation :: proc (program: GLProgram, index: GLuint, name: string) #foreign "gl" "bindAttribLocation" --- +bindBuffer :: proc (target: GLenum, buffer: GLBuffer) #foreign "gl" "bindBuffer" --- +bindFramebuffer :: proc (target: GLenum, framebuffer: GLFramebuffer) #foreign "gl" "bindFramebuffer" --- +bindRenderbuffer :: proc (target: GLenum, renderbuffer: GLRenderbuffer) #foreign "gl" "bindRenderbuffer" --- +bindTexture :: proc (target: GLenum, texture: GLTexture) #foreign "gl" "bindTexture" --- +blendColor :: proc (red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf) #foreign "gl" "blendColor" --- +blendEquation :: proc (mode: GLenum) #foreign "gl" "blendEquation" --- +blendEquationSeparate :: proc (modeRGB: GLenum, modeAlpha: GLenum) #foreign "gl" "blendEquationSeparate" --- +blendFunc :: proc (sfactor: GLenum, dfactor: GLenum) #foreign "gl" "blendFunc" --- +blendFuncSeparate :: proc (srcRGB: GLenum, dstRGB: GLenum, srcAlpha: GLenum, dstAlpha: GLenum) #foreign "gl" "blendFuncSeparate" --- +blitFramebuffer :: proc (sx0: GLint, sy0: GLint, sx1: GLint, sy1: GLint, dx0: GLint, dy0: GLint, dx1: GLint, dy1: GLint, mask: GLbitfield, filter: GLenum) #foreign "gl" "blitFramebuffer" --- +bufferDataWithData :: proc (target: GLenum, buffer: Buffer, usage: GLenum) #foreign "gl" "bufferDataWithData" --- +bufferDataNoData :: proc (target: GLenum, size: GLsizeiptr, usage: GLenum) #foreign "gl" "bufferDataNoData" --- +bufferData :: proc #overloaded { bufferDataWithData, bufferDataNoData } +bufferSubData :: proc (target: GLenum, offset: GLintptr, data: string) #foreign "gl" "bufferSubData" --- +checkFrameBufferStatus :: proc (target: GLenum) -> GLenum #foreign "gl" "checkFrameBufferStatus" --- +clear :: proc (mask: GLbitfield) #foreign "gl" "clear" --- +clearColor :: proc (red: GLclampf, green: GLclampf, blue: GLclampf, alpha: GLclampf) #foreign "gl" "clearColor" --- +clearDepth :: proc (depth: GLclampf) #foreign "gl" "clearDepth" --- +clearStencil :: proc (s: GLint) #foreign "gl" "clearStencil" --- +colorMask :: proc (red: GLboolean, green: GLboolean, blue: GLboolean, alpha: GLboolean) #foreign "gl" "colorMask" --- +compileShader :: proc (shader: GLShader) #foreign "gl" "compileShader" --- +compressedTexImage2D :: proc (target: GLenum, level: GLint, internalformat: GLenum, width: GLsizei, height: GLsizei, border: GLint, data: string) #foreign "gl" "compressedTexImage2D" --- +compressedTexSubImage2D :: proc (target: GLenum, level: GLint, internalformat: GLenum, xoff: GLint, yoff: GLint, width: GLsizei, height: GLsizei, format: GLenum, data: string) #foreign "gl" "compressedTexSubImage2D" --- +copyBufferSubData :: proc (readTarget: GLenum, writeTarget: GLenum, readOffset: GLintptr, writeOffset: GLintptr, size: GLsizeiptr) #foreign "gl" "copyBufferSubData" --- +copyTexImage2D :: proc (target: GLenum, level: GLint, internalformat: GLenum, x: GLint, y: GLint, width: GLsizei, height: GLsizei, border: GLint) #foreign "gl" "copyTexImage2D" --- +copyTexSubImage2D :: proc (target: GLenum, level: GLint, xoff: GLint, yoff: GLint, x: GLint, y: GLint, width: GLsizei, height: GLsizei) #foreign "gl" "copyTexSubImage2D" --- +createBuffer :: proc -> GLBuffer #foreign "gl" "createBuffer" --- +createFramebuffer :: proc -> GLFramebuffer #foreign "gl" "createFramebuffer" --- +createProgram :: proc -> GLProgram #foreign "gl" "createProgram" --- +createRenderbuffer :: proc -> GLRenderbuffer #foreign "gl" "createRenderbuffer" --- +createShader :: proc (type: GLenum) -> GLShader #foreign "gl" "createShader" --- +createTexture :: proc -> GLTexture #foreign "gl" "createTexture" --- +cullFace :: proc (mode: GLenum) #foreign "gl" "cullFace" --- +deleteBuffer :: proc (buffer: GLBuffer) #foreign "gl" "deleteBuffer" --- +deleteFramebuffer :: proc (framebuffer: GLFramebuffer) #foreign "gl" "deleteFramebuffer" --- +deleteProgram :: proc (program: GLProgram) #foreign "gl" "deleteProgram" --- +deleteRenderbuffer :: proc (renderbuffer: GLRenderbuffer) #foreign "gl" "deleteRenderbuffer" --- +deleteShader :: proc (shader: GLShader) #foreign "gl" "deleteShader" --- +deleteTexture :: proc (texture: GLTexture) #foreign "gl" "deleteTexture" --- +depthFunc :: proc (func: GLenum) #foreign "gl" "depthFunc" --- +depthMask :: proc (flag: GLboolean) #foreign "gl" "depthMask" --- +depthRange :: proc (zNear: GLclampf, zFar: GLclampf) #foreign "gl" "depthRange" --- +detachShader :: proc (program: GLProgram, shader: GLShader) #foreign "gl" "detachShader" --- +disable :: proc (cap: GLenum) #foreign "gl" "disable" --- +disableVertexAttribArray :: proc (index: GLuint) #foreign "gl" "disableVertexAttribArray" --- +drawArrays :: proc (mode: GLenum, first: GLint, count: GLsizei) #foreign "gl" "drawArrays" --- +drawElements :: proc (mode: GLenum, count: GLsizei, type: GLenum, offset: GLint) #foreign "gl" "drawElements" --- +enable :: proc (cap: GLenum) #foreign "gl" "enable" --- +enableVertexAttribArray :: proc (index: GLuint) #foreign "gl" "enableVertexAttribArray" --- +finish :: proc #foreign "gl" "finish" --- +flush :: proc #foreign "gl" "flush" --- +framebufferRenderbuffer :: proc (target: GLenum, attachment: GLenum, renderbuffertarget: GLenum, renderbuffer: GLRenderbuffer) #foreign "gl" "framebufferRenderbuffer" --- +framebufferTexture2D :: proc (target: GLenum, attachment: GLenum, textarget: GLenum, texture: GLTexture, level: GLint) #foreign "gl" "framebufferTexture2D" --- +framebufferTextureLayer :: proc (target: GLenum, attachment: GLenum, texture: GLTexture, level: GLint, layer: GLint) #foreign "gl" "framebufferTextureLayer" --- +frontFace :: proc (mode: GLenum) #foreign "gl" "frontFace" --- +generateMipmap :: proc (target: GLenum) #foreign "gl" "generateMipmap" --- +getActiveAttrib :: proc (program: GLProgram, index: GLuint, out: ^GLActiveInfo) #foreign "gl" "getActiveAttrib" --- +getActiveUniform :: proc (program: GLProgram, index: GLuint, out: ^GLActiveInfo) #foreign "gl" "getActiveUniform" --- +// getAttachedShaders does not work yet because we can't return a list of things +getAttribLocation :: proc (program: GLProgram, name: string) -> GLint #foreign "gl" "getAttribLocation" --- +getBufferSubData :: proc (target: GLenum, srcByteOffset: GLintptr, dstBuffer: string, dstOffset: GLuint, length: GLuint) #foreign "gl" "getBufferSubData" --- +// getBufferParameter and getParameter do not work +getError :: proc -> GLenum #foreign "gl" "getError" --- +getInternalformatParameter :: proc (target: GLenum, internalFormat: GLenum, pname: GLenum) -> GLenum #foreign "gl" "getInternalformatParameter" --- +// many of the 'gets' don't work yet because they return very javascripty things +getProgramParameter :: proc (program: GLProgram, pname: GLenum) -> GLenum #foreign "gl" "getProgramParameter" --- +getShaderParameter :: proc (shader: GLShader, pname: GLenum) -> GLenum #foreign "gl" "getShaderParameter" --- +getUniformLocation :: proc (program: GLProgram, name: string) -> GLUniformLocation #foreign "gl" "getUniformLocation" --- +getVertexAttribOffset :: proc (index: GLuint, pname: GLenum) #foreign "gl" "getVertexAttribOffset" --- +hint :: proc (target: GLenum, mode: GLenum) #foreign "gl" "hint" --- +init :: proc (canvasname: string) -> GLboolean #foreign "gl" "init" --- +invalidateFramebuffer :: proc (target: GLenum, attachments: string) #foreign "gl" "invalidateFramebuffer" --- +invalidateSubFramebuffer :: proc (target: GLenum, attachments: string, x: GLint, y: GLint, width: GLsizei, height: GLsizei) #foreign "gl" "invalidateSubFramebuffer" --- +isEnabled :: proc (cap: GLenum) -> GLboolean #foreign "gl" "isEnabled" --- +lineWidth :: proc (width: GLfloat) #foreign "gl" "lineWidth" --- +linkProgram :: proc (program: GLProgram) #foreign "gl" "linkProgram" --- +pixelStorei :: proc (pname: GLenum, param: GLenum) #foreign "gl" "pixelStorei" --- +polygonOffset :: proc (factor: GLfloat, units: GLfloat) #foreign "gl" "polygonOffset" --- +printProgramInfoLog :: proc (program: GLProgram) #foreign "gl" "printProgramInfoLog" --- +printShaderInfoLog :: proc (shader: GLShader) #foreign "gl" "printShaderInfoLog" --- +readBuffer :: proc (src: GLenum) #foreign "gl" "readBuffer" --- +readPixels :: proc (x: GLint, y: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: string) #foreign "gl" "readPixels" --- +renderbufferStorageMultisample :: proc (target: GLenum, samples: GLsizei, internalforamt: GLenum, width: GLsizei, height: GLsizei) #foreign "gl" "renderbufferStorageMultisample" --- +sampleCoverage :: proc (value: GLclampf, invert: GLboolean) #foreign "gl" "sampleCoverage" --- +scissor :: proc (x: GLint, y: GLint, width: GLsizei, height: GLsizei) #foreign "gl" "scissor" --- +shaderSource :: proc (shader: GLShader, source: string) #foreign "gl" "shaderSource" --- +stencilFunc :: proc (func: GLenum, ref: GLint, mask: GLuint) #foreign "gl" "stencilFunc" --- +stencilFuncSeparate :: proc (face: GLenum, func: GLenum, ref: GLint, mask: GLuint) #foreign "gl" "stencilFuncSeparate" --- +stencilMask :: proc (mask: GLuint) #foreign "gl" "stencilMask" --- +stencilMaskSeparate :: proc (face: GLenum, mask: GLenum) #foreign "gl" "stencilMaskSeparate" --- +stencilOp :: proc (fail: GLenum, zfail: GLenum, zpass: GLenum) #foreign "gl" "stencilOp" --- +stencilOpSeparate :: proc (face: GLenum, fail: GLenum, zfail: GLenum, zpass: GLenum) #foreign "gl" "stencilOpSeparate" --- +texImage2D :: proc (target: GLenum, level: GLint, internalFormat: GLenum, width: GLsizei, height: GLsizei, border: GLint, format: GLenum, type: GLenum, pixels: string) #foreign "gl" "texImage2D" --- +texParameterf :: proc (target: GLenum, pname: GLenum, param: GLfloat) #foreign "gl" "texParameterf" --- +texParameteri :: proc (target: GLenum, pname: GLenum, param: GLint) #foreign "gl" "texParameteri" --- +texSubImage2D :: proc (target: GLenum, level: GLint, xoff: GLint, yoff: GLint, width: GLsizei, height: GLsizei, format: GLenum, type: GLenum, pixels: string) #foreign "gl" "texSubImage2D" --- +uniform1f :: proc (loc: GLUniformLocation, x: GLfloat) #foreign "gl" "uniform1f" --- +uniform1i :: proc (loc: GLUniformLocation, x: GLint) #foreign "gl" "uniform1i" --- +uniform2f :: proc (loc: GLUniformLocation, x: GLfloat, y: GLfloat) #foreign "gl" "uniform2f" --- +uniform2i :: proc (loc: GLUniformLocation, x: GLint, y: GLint) #foreign "gl" "uniform2i" --- +uniform3f :: proc (loc: GLUniformLocation, x: GLfloat, y: GLfloat, z: GLfloat) #foreign "gl" "uniform3f" --- +uniform3i :: proc (loc: GLUniformLocation, x: GLint, y: GLint, z: GLint) #foreign "gl" "uniform3i" --- +uniform4f :: proc (loc: GLUniformLocation, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) #foreign "gl" "uniform4f" --- +uniform4i :: proc (loc: GLUniformLocation, x: GLint, y: GLint, z: GLint, w: GLint) #foreign "gl" "uniform4i" --- +uniformMatrix2 :: proc (loc: GLUniformLocation, transpose: GLboolean, value: GLMat2) #foreign "gl" "uniformMatrix2" --- +uniformMatrix3 :: proc (loc: GLUniformLocation, transpose: GLboolean, value: GLMat3) #foreign "gl" "uniformMatrix3" --- +uniformMatrix4 :: proc (loc: GLUniformLocation, transpose: GLboolean, value: GLMat4) #foreign "gl" "uniformMatrix4" --- +useProgram :: proc (program: GLProgram) #foreign "gl" "useProgram" --- +validateProgram :: proc (program: GLProgram) #foreign "gl" "validateProgram" --- +vertexAttrib1f :: proc (idx: GLuint, x: GLfloat) #foreign "gl" "vertexAttrib1f" --- +vertexAttrib2f :: proc (idx: GLuint, x: GLfloat, y: GLfloat) #foreign "gl" "vertexAttrib2f" --- +vertexAttrib3f :: proc (idx: GLuint, x: GLfloat, y: GLfloat, z: GLfloat) #foreign "gl" "vertexAttrib3f" --- +vertexAttrib4f :: proc (idx: GLuint, x: GLfloat, y: GLfloat, z: GLfloat, w: GLfloat) #foreign "gl" "vertexAttrib4f" --- +vertexAttribPointer :: proc (idx: GLuint, size: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLint) #foreign "gl" "vertexAttribPointer" --- +viewport :: proc (x: GLint, y: GLint, width: GLsizei, height: GLsizei) #foreign "gl" "viewport" --- diff --git a/core/math.onyx b/core/math.onyx index 8151c32d..9c222850 100644 --- a/core/math.onyx +++ b/core/math.onyx @@ -1,4 +1,4 @@ -package math +package core PI :: 3.14159265f; TAU :: 6.28318330f; diff --git a/core/memory.onyx b/core/memory.onyx index aa6ff6e5..c1223d88 100644 --- a/core/memory.onyx +++ b/core/memory.onyx @@ -1,4 +1,4 @@ -package memory +package core memory_copy :: proc (dst_: rawptr, src_: rawptr, len: u32) { dst := cast(^u8) dst_; diff --git a/core/printing.onyx b/core/printing.onyx deleted file mode 100644 index 9569ed3e..00000000 --- a/core/printing.onyx +++ /dev/null @@ -1,124 +0,0 @@ -package printing - -print_bool :: proc (value: bool) #foreign "host" "print" --- -print_i32 :: proc (value: i32) #foreign "host" "print" --- -print_f32 :: proc (value: f32) #foreign "host" "print" --- -print_i64 :: proc (value: i64) #foreign "host" "print" --- -print_f64 :: proc (value: f64) #foreign "host" "print" --- - -PrintableArray :: struct { - data: ^u8; - len: i32; -} - -print_i32arr :: proc (arr: [] i32, len: i32) { - for i: 0, len do print(arr[i]); -} - -print_i64arr :: proc (arr: [] i64, len: i32) { - for i: 0, len do print(arr[i]); -} - -print_f32arr :: proc (arr: [] f32, len: i32) { - for i: 0, len do print(arr[i]); -} - -print_f64arr :: proc (arr: [] f64, len: i32) { - for i: 0, len do print(arr[i]); -} - -// NOTE: print null-terminated string -print_str_by_byte :: proc (str: ^u8) { - c := str; - while *c != cast(u8) 0 { - print(cast(i32) (*c)); - c += 1; - } -} - -print_str :: proc (str: ^u8) #foreign "host" "print_str" --- - -print_str_len :: proc (str: [] u8, len: i32) { - for i: 0, len do print(cast(i32) str[i]); -} - -print_u64_with_base :: proc (n_: u64, base: u64) { - n := n_; - str: [128] u8; - for i: 0, 128 do str[i] = #char "\0"; - - c := cast(^u8) ^str[127]; - *c = #char "\0"; - c -= 1; - - if n == 0l { - *c = #char "0"; - c -= 1; - } else { - while n > 0l { - m :: n % base; - - ch := cast(u8) 0; - - // TODO: Replace with array lookup when array literals are added - if m == 0l do ch = #char "0"; - elseif m == 1l do ch = #char "1"; - elseif m == 2l do ch = #char "2"; - elseif m == 3l do ch = #char "3"; - elseif m == 4l do ch = #char "4"; - elseif m == 5l do ch = #char "5"; - elseif m == 6l do ch = #char "6"; - elseif m == 7l do ch = #char "7"; - elseif m == 8l do ch = #char "8"; - elseif m == 9l do ch = #char "9"; - elseif m == 10l do ch = #char "A"; - elseif m == 11l do ch = #char "B"; - elseif m == 12l do ch = #char "C"; - elseif m == 13l do ch = #char "D"; - elseif m == 14l do ch = #char "E"; - elseif m == 15l do ch = #char "F"; - - *c = ch; - c -= 1; - - n /= base; - } - } - - if base == 16l { - *c = #char "x"; - c -= 1; - *c = #char "0"; - c -= 1; - } - - if base == 2l { - *c = #char "b"; - c -= 1; - *c = #char "0"; - c -= 1; - } - - print(c + 1); -} - -print_u64 :: proc (n: u64) do print_u64_with_base(n, 10l); -print_hex :: proc (n: u64) do print_u64_with_base(n, 16l); -print_bin :: proc (n: u64) do print_u64_with_base(n, 2l); -print_ptr :: proc (p: rawptr) do print_hex(cast(u64) p); - -print :: proc #overloaded { - print_bool, - print_i32, - print_f32, - print_i64, - print_f64, - - print_i32arr, - print_i64arr, - print_f32arr, - print_f64arr, - - print_str, - print_str_len, -} diff --git a/core/random.onyx b/core/random.onyx index ab515814..fd4a557d 100644 --- a/core/random.onyx +++ b/core/random.onyx @@ -1,4 +1,4 @@ -package random +package core #private seed := 8675309 diff --git a/core/std/js.onyx b/core/std/js.onyx new file mode 100644 index 00000000..df151685 --- /dev/null +++ b/core/std/js.onyx @@ -0,0 +1,15 @@ +package core + +use package builtin + +#include_file "core/alloc" +#include_file "core/intrinsics" +#include_file "core/math" +#include_file "core/memory" +#include_file "core/random" +#include_file "core/stdio" +#include_file "core/string" + +#include_file "core/sys/js" + + diff --git a/core/std/wasi.onyx b/core/std/wasi.onyx new file mode 100644 index 00000000..13c24ffb --- /dev/null +++ b/core/std/wasi.onyx @@ -0,0 +1,17 @@ +package core + +use package builtin + +#include_file "core/alloc" +#include_file "core/file" +#include_file "core/intrinsics" +#include_file "core/math" +#include_file "core/memory" +#include_file "core/random" +#include_file "core/stdio" +#include_file "core/string" +#include_file "core/wasi" + +#include_file "core/sys/wasi" + + diff --git a/core/stdio.onyx b/core/stdio.onyx index d9360c75..a0f0794b 100644 --- a/core/stdio.onyx +++ b/core/stdio.onyx @@ -1,19 +1,32 @@ -package stdio +package core -use package builtin -use package core -use package wasi +// It is expected that a file will be included that will be part +// of the system package +use package system as system + +#private +print_buffer : StringBuilder; + +stdio_init :: proc { + print_buffer = string_builder_make(2048); +} print_string :: proc (s: string) { - string_builder_append(^cout_state.sb, s); - if s.data[s.count - 1] == #char "\n" do print_flush(); + string_builder_append(^print_buffer, s); + if s.data[s.count - 1] == #char "\n" do print_buffer_flush(); } -print_cstring :: proc (s: cstring) do string_builder_append(^cout_state.sb, s); -print_i64 :: proc (n: i64, base := 10l) do string_builder_append(^cout_state.sb, n, base); -print_i32 :: proc (n: i32, base := 10) do string_builder_append(^cout_state.sb, cast(i64) n, cast(u64) base); -print_bool :: proc (b: bool) do string_builder_append(^cout_state.sb, b); -print_ptr :: proc (p: rawptr) do string_builder_append(^cout_state.sb, cast(i64) p, 16l); +print_cstring :: proc (s: cstring) do string_builder_append(^print_buffer, s); +print_i64 :: proc (n: i64, base := 10l) do string_builder_append(^print_buffer, n, base); +print_i32 :: proc (n: i32, base := 10) do string_builder_append(^print_buffer, cast(i64) n, cast(u64) base); +print_bool :: proc (b: bool) do string_builder_append(^print_buffer, b); +print_ptr :: proc (p: rawptr) do string_builder_append(^print_buffer, cast(i64) p, 16l); + +print :: proc #overloaded { + print_string, print_cstring, + print_i64, print_i32, + print_bool, print_ptr, +} // This works on both slices and arrays print_array :: proc (arr: $T, sep := " ") { @@ -25,38 +38,11 @@ print_array :: proc (arr: $T, sep := " ") { print("\n"); } -print :: proc #overloaded { - print_string, - print_cstring, - print_i64, - print_i32, - print_bool, - print_ptr, +print_buffer_flush :: proc { + ^print_buffer + |> string_builder_to_string() + |> system.output_string(); + + ^print_buffer |> string_builder_clear(); } -print_flush :: proc { - ^cout_state.sb |> string_builder_to_string() |> raw_print(cout_state.fd); - ^cout_state.sb |> string_builder_clear(); -} - -#private -raw_print :: proc (s: string, fd: FileDescriptor) -> u32 { - vec := IOVec.{ buf = s.data, len = s.count }; - tmp : Size; - fd_write(fd, IOVecArray.{ ^vec, 1 }, ^tmp); - fd_datasync(fd); - return tmp; -} - -ConsoleOutput :: struct { - sb : StringBuilder; - fd : FileDescriptor; -} - -#private -cout_state : ConsoleOutput - -stdio_init :: proc { - cout_state.fd = cast(FileDescriptor) 1; - cout_state.sb = string_builder_make(2048); -} \ No newline at end of file diff --git a/core/string.onyx b/core/string.onyx index 5ee643ae..b81b6227 100644 --- a/core/string.onyx +++ b/core/string.onyx @@ -1,9 +1,5 @@ package core -use package builtin -use package memory -use package wasi - string_make :: proc #overloaded { string_make_from_cstring } #private diff --git a/core/sys/js.onyx b/core/sys/js.onyx new file mode 100644 index 00000000..69d47149 --- /dev/null +++ b/core/sys/js.onyx @@ -0,0 +1,26 @@ +package system + +use package builtin +use package core +use package main as main + +output_string :: proc (s: string) -> u32 #foreign "host" "print_str" --- + +// The builtin _start proc. +// Sets up everything needed for execution. +proc #export "_start" { + memory_init(); + + context.allocator = heap_allocator; + context.temp_allocator = heap_allocator; + + stdio_init(); + + args : [] cstring; + args.data = null; + args.count = 0; + + main.main(args); + + print_buffer_flush(); +} diff --git a/core/sys/wasi.onyx b/core/sys/wasi.onyx new file mode 100644 index 00000000..828aefb7 --- /dev/null +++ b/core/sys/wasi.onyx @@ -0,0 +1,43 @@ +package system + +#include_file "core/wasi" + +use package builtin +use package wasi +use package core +use package main as main + +STDOUT_FILENO :: 1 + +output_string :: proc (s: string) -> u32 { + vec := IOVec.{ buf = s.data, len = s.count }; + tmp : Size; + fd_write(STDOUT_FILENO, IOVecArray.{ ^vec, 1 }, ^tmp); + fd_datasync(STDOUT_FILENO); + return tmp; +} + +// The builtin _start proc. +// Sets up everything needed for execution. +proc #export "_start" { + memory_init(); + + context.allocator = heap_allocator; + context.temp_allocator = heap_allocator; + + argc : Size; + argv_buf_size : Size; + + args_sizes_get(^argc, ^argv_buf_size); + + argv := cast(^cstring) calloc(sizeof cstring * argc); + argv_buf := cast(cstring) calloc(argv_buf_size); + + args_get(argv, argv_buf); + + stdio_init(); + + main.main(argv[0 : argc]); + + print_buffer_flush(); +} diff --git a/core/wasi.onyx b/core/wasi.onyx index d96d67ba..088192e6 100644 --- a/core/wasi.onyx +++ b/core/wasi.onyx @@ -1,11 +1,14 @@ package wasi -#include_file "stdio" +use package builtin +use package core { + memory_init, + stdio_init, + print_buffer_flush, + heap_allocator +} use package main as main -use package builtin -use package memory -use package stdio as io Size :: #type u32; Filesize :: #type u64; @@ -425,27 +428,3 @@ sock_shutdown :: proc (fd: FileDescriptor, how: SDFlags) -> Errno #foreign "wasi -// The builtin _start proc. -// Sets up everything needed for execution. -proc #export "_start" { - memory_init(); - - context.allocator = heap_allocator; - context.temp_allocator = heap_allocator; - - argc : Size; - argv_buf_size : Size; - - args_sizes_get(^argc, ^argv_buf_size); - - argv := cast(^cstring) calloc(sizeof cstring * argc); - argv_buf := cast(cstring) calloc(argv_buf_size); - - args_get(argv, argv_buf); - - io.stdio_init(); - - main.main(argv[0 : argc]); - - io.print_flush(); -} diff --git a/misc/onyx.sublime-build b/misc/onyx.sublime-build index fcf81eac..a910832d 100644 --- a/misc/onyx.sublime-build +++ b/misc/onyx.sublime-build @@ -1,6 +1,6 @@ { "target": "exec", - "shell_cmd": "/usr/bin/onyx -o \"${folder}/${file_base_name}.wasm\" \"$file\"", + "shell_cmd": "/usr/bin/onyx -verbose -o \"${folder}/${file_base_name}.wasm\" \"$file\"", "working_dir": "${folder}", "selector": "source.onyx", "file_regex": "^\\(([^:]+):([0-9]+),([0-9]+)\\) (.*)", diff --git a/onyx b/onyx index a791f6afd2353990c2bd967a51e84082ad9352f8..421c68222492f731b377b666e4487f71f41b1664 100755 GIT binary patch delta 37055 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%0D87>B^Kr5$u_>A!gh1RKulFU(q=h^dtSc7ONjC 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 YO^yc8h>ON(+wIeG$@>CnUl?Kk4`1t5CjbBd delta 37070 zcmc${2UJx_^Dlb3&)Etp0!j{&L6V4yh>C)Wf{Kb66~#E_oD*hc5EYMF#xbWc4?0K3 zoE^vPm~$FY%sIinzwQmfd^6ww-Fw$t@3B_-tM0C@uCC6#_dc#W>b2~s*Q~NEIm7>s z`N92MC;kp*TC>Bf^t8><2gjPVuh`)I#LiRfXaBNuR$%61{<4hauY0*JHr=A8gh=1a zM;@IxTb>!~9bqU&O}TE;0n16VnDMo5yzxd@3F9rlnno}GKJ0)o!{3W_G4Ajm!90y2 z0U`WN6Jv6~HdZsURABRBY@+dpuovubX3NUunERu;C?oY)Z0eQR)N?VZcXySAVX>*# zV^cpOI;%|Ps_-8e`_)(?VlZo&IX=RkvoVvlGTfO`{MsvuP7nIrDDQ=88VO0Vj`d%*D*kS2$(JPUES8Wms(H z$kuoCdMi&(37?p)ap|Dq`j~p0*cawPvwr7hnJe23E5g=hI(M$mSUY34E*s5SIZ6e~ zj2+uK^XWB=pS$`Sle-Q!o9j>z&rTXYbv>ZpX3uGVb?(BSR?ocFZFW(3pm*O0gWe^S zQ$I)U!d4rP4)kGHjM)Ph>+cui6z#$_Bkap_+6D<>ghl4%LBBIL)VOTO2|Y8*lNvX) zxW00*lyWd0IB%8t>(I@NZ8LTqet<2`^c_)~v5lEMN7iEcyH}-v6!4vp&-?t&W~`$!tHPIODpPGBP4F zb*3$6^)r`d+~91HanzhK{MqBoFLTTo+i%p*^I;1z{pVRR*4|i^;+d6k8hzo9AIZG# z#uf8>GZ&-fg0lSW&zTVmdYd7%W_bg4&iH0|Pi}Ejiq*{=y@E0R?79s3WG-3h&CGQw z(>-}^rqdZ`t#{3Qyh`QlhVk**t@;a>G)L%*e`Ut&-GZn}9bO{y^*VcQaCpq5xY2*Z zV>s1%V=IthVw-iVdR9KHQ_JzHw5yYn16zWuI-jEy&T`OS##|LM1iY+h#2 z?plo9$?UhM9^;t@L`C?sN5(6A1CyEES(@MGxgu7`%PCdRpk zdZQ8f;WNy^c>ZuKJ8N`0lE!Kq*Bq(M)$_*eBQ@DRW8l#%?66UP%$N1g3^+Df&*~Ys z{@#pD$~2rzGq6d{=8Q%pr!OZ(|`lMh%o9^={zDr;$6dohvOX0ku`>e&Y4{wrnJL*wl$*Z421W%aX98n0e$WB#e9PB$xd z;t?wv@5LN4n_UZGY@~7G^_I-bc>Vf9%xpt$xN&%M?ybJO+cMb&mKwcof8!t889naI zW}Py(-+{YP(7g@}gQVmAsvMnd@xw@#V7&ftBPuxcQ6w7k=%b}F_f{d1vtTYeqjGcI(iO5_;%UmF^-RSWw zz~+v^^IU(qFDD5v)k9?SRrS zccPV=!8ThHz7+guV^4}Z@Y%OR6B6X3_bw)^TG|qkD&z>6hzi8olW}z(UEMQkKy3TJ^@K4@yvCJ6y zvH|B|#<4Hm*bw7SFC84Rn`=r@_El*${0oiSjAveUE*d^rvd8lhMz_~q z?4q&u>%k5uE64_f0a4Hk3(}f^6hGtH*Pg{^iNuLxvUEd2=)5a)KzFfy<5Bevq2P!^ zmXk8_heR6OhOW^yHZ5$nNK8|VfL&rS|INL?30;i+-;`rN7?-{o&E6Yb-g>j6#^|?W zSzY6Sx6#~Yo>BiU)PMP0sbGZwt-V|i%erIa)k5d9n57A17?a-p$X*z;-c@8@j4to1 zg`de`c^&6;-MscXEDBEx8$3tq90J(oDU2##U{qb>jQ1y4wz1U*UrgO&KQy(9F$!sm zk`fe4qw($suTpPji%6KHm}&9%jJ6+xtD9~}|9z6aOI5Z@shCe`x{04GET>*TF{uY) z(`_b$!Q!mE`pR@^1|B;UuyZ5}K{(wT;Yk@Zsu~M6F8frL-7^0EDJo^-mx6+pfsbY9)VnZX z68P-aV8#ljF___ksS9SHU?RaJ3#Jm7R)Prx(?~F$U}6O02&TGVtiV(hOi?hE!6Y4S z5u5rbHg!zqw9lnj>1s2j+p7!En$l$4^d-JtMHwHHmDlOqV^c4SDj)n+RmDuZQur!O zv5?u0XZfFi59AOnl;L<*sT0QNuYMRyJ-#}#^~T9xJ=s{}y00VoUuTS#IiB3|lQH(& zQTEkXGRKQ~XI99m#<=BaW4~Na_RKgtHxP5jzFaSM%6K1qKVwPNi)}PkP*b`6FCsrH zXS}P1v)ywYm>1{o=SH$wY|Gp;tTO9C3S$k;j-<-U9i>FQ`s;|E5h8^1Ji~g ztQO-|FHJ9tvYE{MhjCI__i@JMH%hYzT4c^Xv*$Fo81pWY@{H-STG9Su%(Y>6!B?^q z%7>IV9jl4# z`U*ZP8~kL-0PlZF@SSYGmx?`(?#Wz3;ZnB=k(zWxWSu8?7y2UjQG)+Wt|h=H3;r@i zfp1t>@R>H>Rayv@f5Fy*iUbLfSp^~`g~;K*iC7DfKD1tF|L_!ieL5xh+k*F_m!hP@ zf;SYXDJ9f||4q$WA#$(ucVkKm5u3k>Ocx^isI>*O4-ot!8YTFaf*(#l3BH=(ThKx9 z0Um;{P@vL5sO*a7DyUykA!1pY%t|tsBF~;6@QeaVLeB-k|4#9O-zE4p)E|7qWrCkr z>bsd`gw9{{XMNfDsX`>VK*ULi82={HPl!a)HKDz^;GO83;3EY8k=!g%l9%BBwEkX_ zn5CZ-{hJyyA+oJN#9N3w#6JZUe31o_88i(Vi(C?XFWMmZJ%W#=GnUM$$U4E7r5E6f zW(eNQnk=oDW04UekVWOJAkk`j=+i*h{)nnzeKNWr!S_nSfoQ@B9`eO4N>>lT1x)*a5~4k+mJOcl6(sKQ~^5 zIpyiFXV*-TjN%(Sg|&z5cW2h<>%W zJtf((qL@~eI6zrP+Uvkv%u5WA)w38t_Z`@H)`_|}qTH|aha(GgEVWJO9*p%)E`{H9 ze<4dJs7Rp@0cWYP6HdG%`$$^zI8>fp-Uc+uN5&Xx6Gr|79G+~rMn zWmq+~k(!oaVeCCkD}%O}OdHFvGOo_Oq|GjXe{4mb)8jI%cJSAEs+xKT_T5cwf_Xe_ zLrvV7<+Tc9&_xXqX3U%HGgP50=CNsH`XRVNuk`lXc@(tLaxy=I-}xhICOs7`jv2 zzsljz1;ZpR^$225h|$r4u$G3i@f7C8>aglG(u*x%_sPbaMU@_p=?M${1OeLqU;+K$ z%^LD4tI5iVm0|ViPjBXjh4Y&?b7%hK>cf75&-eJC5Bx$meOO;MksA22ok1@yV~>O4 z7W@Pcq=jAVBsKpD_{Ua!HHG-GR2Dhu3~J-Q^7$x7|1F+ z{rD+Y+vCTk4f%voTq%DPuO{mt=Hjw0N!qqvfM%O_n&=Y8vu>x-%pjZvHvd}0M~*Gg zwJbVm@|_FhZ~v&thtP~5mdN^2RuHRi@$y2!cJcw$48{&(3!M$dL^h4=%CQUVBRwg{ zS~^a-#B{&C6zf=e*yeL+lJv-3fULgMIt1x1~vprO*0*f|u zdV${9_>nF3uE5OLE*esS_2brO>8}c`HaDE5z=~{*S)Ep*mSHh;ts=(YSTa;%&DmQ@ zti;^8*((}ViAA%cw6_vV4BFpZI^=)=%^}q$O2$nlbt*R0#5S?;s`2tfx~~)2J1^wtFT5E(@z%oY8(vObONZ4)ZpaUz@dhJ3t9guU$nJt4R#%KOMXF1+O_$ljN^03H0nt0LNz?6e$3HmY zj3JNe>`O?`c&WaZ0L^W_4TYM?4yqV9N+*$kS>FbH%Xm&5H#57EO7%jq<*9EZ3v$*= z4f6gqtQ$0>g}rVlRX=TL-1^j(PDWymSxc5RSRA@VVhyxNeOg=t(|QQ)tHGSjOK9R2 z4e5Rj=FhHEiJI81FQNuDS)0fPNApMEk4>3w*6-S3X5up|n02$hus!Bg_7JqwD>2={ z-f)c<>D%dkP1Ydb_>p`S94c^fdxcSK+eTzgQ<@1tHaqb3s8tjTak9^gazs>d!B5O` zzyWabfw9Kulcgy$idnPQrlV18C}TaTdM)Pf5Oq6OjZJUD(0%Wsd`vd-BI0)%Q;WSf zTUk#QwTed8X2%VKZ(=m1A9XBpS4;tAs7oCzOZRD69oB@6HodNc{RkHP3UyhXaGQhq zmT!KKM$x7pneFv0QJ^xT4i_grtV%-HO%aLG$6q1OH=+S(TaX)038eIK?4?H z>;5kiS1Gh13*&Yvw73y-q6rPr(>Br3hAf_Srqc1u%eKhaf9l;w4dSs1e53L4SXGU5 zCm!-~6x;~ggJ+b`h?QomsB0sL+^0p2SZnm*ca2y*R+XwZhRR!`{;6^<4Q>oWE{@U+ zIocT0PCwE&L9Re*&;+^8jQnS=DKxPOavd3|<@&P;awSu#1mtp|HVMeJUz@D{=KWzb zI{~?NjL>pDNI_!elQ7&_8|Widb6)ROhHbszlQ*c17CSTt-abTC&+ZUtxDrgg2*Rd&;j zR;&!S97JDRv96AfwqlWs7H5<6u+%N+;^~pI0a@`hqBR@spDdCwzlr2`n`N@ANZxr| z4wmOeyg;@mNuN0wqrrO*hV_t zj=8#i4U##&0d|QaS>Zdj(^NDG`G2O3No-*I@LO592qG1p@L7v)ULQ7h{4(I zxGoZtQ_M1$&3 zt9b?r+a|Y`GrQbl+zpV{-V=~F`_~YAjF?&9<#2LIw=GNMI$){2O^rIB>vy2F2w8@U zTzN}FV1TwXSSr?qVwC{;(t!m!UG*3G<=XIbZFoH`?3jp2Q}$EMWLDjBf(Yel8tR|F z$h0dI+k`eJvmht00!8m@Nk!J0qGCdk4>@+kR&lVYR!8Qfw@6%FFx|zQdURpuSW5Lx z1##uU=ij|$t;FM+(zwci_p=3GRO9~={MVu~{)ymUYW!2dKhXGRg1=IT|3l-Y&ixwy zP{?E!O_7QoiNIPd;j!QsX}pY|sqyzj{6vkHMhw&V`y#%V#@`iuheGnr3dz*d_ytfA1HWBjV~v7y~c+M{-d}zOIIogK3n4}3jU79R}%b1 zjSmz2@j~&tC7+^Y-l8Rx7eXrw@l=RUE5xT1;s+JtZsAW!pE?c-cSdX}s)1)eO26QG?PVLx`48 zO7LD9Z!LIxjh8aT3(3e?H(il3Z{;CMk)8Ch#>@B{8ZUL8)p)5#UQ?zkHmg_)hC!i( z4TUl<)p)7YsPUGGEYyo#>*PtDHMNE<7L6eHD2mW*{uaEL;+h0C9Euz0gtCd0Wx!1AwH#$ z{2+~&dVVOxw=E=tBhPm|wKYCPS{kkeB#$NWdu`k_UN%8#jh99g)p%J0JR}nGvf!5* zUqV#ofyT?cS2SMc{X^qr-u-BQky!>Z3kj_)lzEZH%Z@X%5I<4lrP0GQUUs@(8ZQg( zpz*TcW*RTcs;BW5tHk_YO$*4(AsR1-hnL37;bgDza`+Y3csX2Ed3IFf{P9-fD~j4b z*7yj)-_ZD)fNfS&PFmnWx0A`V3V!^BzMrGFoXA(?hFh>Ow4CbO>yusWQj5CuDVSa&312R8(eHJ{22WD{)$*TyBGxFe0Zo4=v_ zWI8&KHDfjwwf>QmK|zCAH^;-+j{eq4)0w?o>a4s1I-N}$2D7>bc7)yx$F8%ispbgQ zpE({|2XUMWQFhoF^ck2?aWTYm>BLCpW_D&Z_L38iG@)ca?nq{%ScJu&kjlT=Ibmuv z3i~-8yNVKCGiUm7Gz&00)I{vL2iK)D=!6c^Wq{QH_gB6;GG{3}j~mKtnm(Szx<}yQIrf+Hkz>Bt z()N_T+L|A%V0t&6IV-FdSxv=We<{_R%5cd=y{EERcF442DqG2{ci?d*bWB60X+pXFKhF*j5BA8~QOKZTR^RBV3JDK!l`a!otan4N(=Hl3Zxel5YvPoi@(@f={Y1NWtw zhnN|iT+Ajqww{8TzSU}4euS*)^O2}&vZ>n=*2Mz$|M4>$Wp?%slG1F?nHp_i?G0u< zZit}L)3kjHOE(i+&z&rQvp7?q-|$Ew$Sz6xJT>O##4$J75I4LS=hYqM{3++tu}aAENE2F zDbh{pf3TsBju&b`ajK?xWT;g9uo4viOfHYmX-1l=KVmEO>@wZWVyWEXp{dssX2Dn_ zjd;r5^0+X~z328Y3lrXR*nszCsQPmj*XZ?~T=XyLgszo^v$Z0gmz70$2BQeqilSR- zJ)`JdS%HaTwzDA^vMtVugngI?(Dui(-q6M8>;oQ6oP5D@*b6%GlGXL@j+>9X624VL z33hV(64u36mar=TCCs4;uULS^Ht_j_VKw!5#b!G?i5wnUjtLmt@Mn%ca{NLzuW>cg zjheh>wR|4l_+G^P3dm4V%W&6QX0R0*tU}22n*G9>QqMOm&>`fKtdneoOV>qi%SouR zj?TSdE~ek#uvU6DmpneOz3d9z`M_FOEP=9o<1$RqADNGyTU|7D|H4Y>@i=%$4y(+I zdC{gE*56`MnF8726p+iRxY(T43i&8pm6msr7v(OzR>L$lmo+HPHknSEb0@}@(4%5J z$j$hhFmZB!c`(#2wUZok)wGyD#Y45d)UhacB9-y-rjf<@0drQ-RLz#VGTizn+VM|O z4qm)C3^EQc=eDH{dj$LfmZqPE9{GDbXnemv2*m7Kd+1G2M6$qHg+q8zXuOO|CA3~ z;OAHx9Kih`usDDp!}WLPK<0+$-FbN3^iG2hx%2pW$`55vKTx z{H30aFhz#*<&3SQJ5~5_`+)2mH8wrw9BwAfaP;1ifb!Fnt){*a{2X@-&w{c5dD;!D zd0i^o1D#p@Os%SOcc!oLActx^XAU&F4tJ(ak=(+pZM@Wg2au6`y2Xuq((CfQnX}Zk z2HbbU)V3z?z%e>^NAp;Vfp-cdx{*~aJ`z{>X|;IO(jNz5j32;Uege(|9?xn-S8MTP zvs>7*z{uOCsM@?8V~=P_9UhKryi0Z9lo;v}!(D5Ay`7^znIx7#u?WfcDq_u0(F3UD zpcs+gcCY|wjcy>Nu4B9Bg+|co`aG7MpcnOdd)$=8H{jegRXYE3>_n8TUR#eRpzilc_m+HqSgMLsYgUf6UgHtXgqr&VM{!C|8F>u5jF2c5TbQu)37o zjz49+s6i5+$QskxBz}_@!^8Df+}CumJuk}njs4P?Upw+Mj6J5aop@V|uUI1TC(oCr z@XmZ4XO~TPyJ7(H%w4iD6HM&ExXVrvs$e?ZoriN#zg|4t?3$bKlkIh?(~G-1Zu=Ge z2K}eEc-sd<=r=4`V8WJ|#`NMv7_YFMj`!vPw52z** zpSMW4gB3UH=Pmg*oI_B%s~w|zGD$AEVyj~D$x(D9<+A|oYPC{btg`4#PJb_PX1>1c zIMF3UsNr|*_*_6}kKI>&NZ%fP`uFY{OG5_m^0<#*Gk^~?%W;r}w|^GincSM9hx5|LhyBVHOAGsKBb3;FA@89)+H9)~ zDcekahGL#(Gbn2qPr%AkbvPW|mPQTdRZ#l&;oKh^(c1|5hy$FqwmLfMblKLZMfUfo zB8Wo7d#W~qPr>7WLnDx}Jv|$Nj5mJH&sf|cFXOH6QJ?H(#>W&l5>wws)4GvZ0N7B| z-BH{^&#uyou{_ZK)bboP+Ybvp9>$Az8sxi*;VVSj#C*!O)FO{(VWzH?!n2&F4E0oog!Z!E22vQo!9#B`KJr>1h76ueHCZ$y!4id8{KnWpFq zLWXI|2b|^e%!TSF1tAoBvmgYM&VCQU+QSHBi+4#h<2QXz6UHxVTM&dAV?hW-OeqMV z_z?vmnAW=>1hYF7go;j6nu<`mQipz<#$Bz>P!5hVSuo(77(e^z@iab7Mm6pOs>m`rSaxy=ay+42S~b`#xvdd z9NBwbWxI;~Bg(ug-dc~xkREaZg&(HO>AX6GUrpzMeBm6rmxdLxQabO8@kB{8xEJ+F z=azIi9s9qXl$*|zSQ~0LgSWw!)-;2Auwc`*8T@0{8|AdEgUkE+_5=GDF70g#S!`Z0X zNg6#LiP5GZ3wTLp(KM~VQ*~+9LjIWr(T|JxdyBq!%`Sg|>SUU}m|HXMFp-un;n!@_ zaZ{6@HXgiOyy)OkUfXo;CqCN1KAYlK^0j)$gppz<60Q38S3TB~#accUPuAzI#m1Ly zFx^*ZJyaf%e|Gl?StFL=LLtDmha;SS&3%J(joI>Cq5e|KQ^H$2Y9Smy_3k5 zro@^qAK<4M_V%j|@kI=$@2De~NjFl@BiN-cq_iX4(PBzxoo?Sa+2144Cqz{DLQ!}l z_Xw7PMO6GKceZ~ij$o+=@pMlSGCFOAy+)Boxnq_6-xF_iDo9+Pn?GT@Uc_U<^vL;$ z$ZCH|-W!PvvS~EqC~t07QRGfb`b6oAaAr`BVZf+V>lhC$tsjU=rccIAleQEN!Wqc< z823esZaT(m;q|Lm$GENSnX}Rt;vJyxcS<;^9p?$$E{Xaa=M_ueYbQj+2({>WSh}c} zDf2kjGusY_WH1>Jor*=_JgT_Z^v4MdGmGl&3%X}{Q`M7vb_wh^PhaMhSp}2f3dSt^ zk%F%Bzwltc^fmqgFDn$g&hO(1>htTo36_i+H@E}dy=!%YhuK8D%WE-Zo$xt2hWUG1 zc7ylDiyM|VaqwGAmv8cD^d5&>yjk7)o8YYaYoz092)@Kx;RU4=_}En2&H~aSyNHy` zq>2^C@M{)z5F9E!*+ULK!UdX1OA> zcoX~vUA)abEe>F1&Wcmzux5yONX5| zBN!qq^YdGY^E*MEtRmxT*u#qtU`4n_B% zxN#wcB@y-nRR+}uwFe1>1A$XOB7bENZT-xhQ-0{(uT#g~?tVU<{L1NOAo{|;(B^-M z`!~7&)3{n8HUGW9e^b;9MhpaX0aXDl28}aqWBSrOWpWtaZvuS*Ezd*27pBMm5iXqe zf5TtP)3+rox98sq`k$2T&CB!$aAW0Mb<2NHUxer7#fgfD^cEl|P!7U(O`8n*$2_in zRIXYsI#(@KD_8vldRQC1txm2wCI$_Qt^b;Ox$2JCT=hs?u6nUPI!J?D^$$?JhPmo- zP`!8{sF>+iQT<_-a;7b0+vKWe1cASrhk_S$|3AX{@%i}d{~N`}0LYB_r(BAfipaU3 z<)BTVU7*65k0N{?bPMzZ^d7`;inRbaf_y-sph!?0s0FAas1IlaXfh}Rv;?#sv;%Yy zbQ*N6c}lMO2+V6x4#>Pku4)VN00o00Krx^MP!gyIXb5OLC>^u_v>LPxv={U{=o082 z=sD;!NNEYLf?PrVpfFH0C?1rUf`7V#27tzZQbBV;%R!q!yFf=l=RvnXPeAWMtQ9-} zas>H+LP3$BI8X~vM^GQo2+(9u251RrJ!l8$Am}tGJ14V=46LVA4L@-@J z13+Uysi3)_<)BTVU7(|&^PpRxC!qHrh7M{0as>H+LP3$BI8X~vM^GQoP*4hJ8Yly_ z5VR7s5wxR?L$10H%yG~;&^3@4d)aMhpq+k3%Cj!Hs(aV}?@Rfe zQ#dNozEDLjgCAHZ{BISUBGbJKYQ8xy!@@i~l!s5tP-PE&K)3HZiab{SB2l;|} zMi)?i+`nO-T#C9J8S*ps!0QqJCj7q>X9qp`ly5}gd_wm>sqMc-{-4L?7kB}Mn8ORz zLH$e~UitDO5o+`Vh>{<`3Py5ON*2X^W=sH-kGPDe${ z>f=+Mu1DY8sH*4jt)jq7I1B%@5+4R_(83~4(BxHr59i1KH*{I2s(R=a_-`_ea56`H z*uN(JTZa6&FdXBlzrWtbwo}+HZg?2UIpTLvAcfcYib5t8#hj%)aqgDdG z0=5SFoz78*1FxLPQRf4<;__oB(Cl1}dKFk1_zBnr=-{N&Jq1<)emS3`wgW!8kfV+U zp1YW%E_T8@j;k-{sCy7G?OKj{6FBBZj`|HaGAl=Qch>2yKg&_;0L#D3QM&{8y~ffa|{Gs8%jI-NdgsYI$H-ZjRanxKNj?_6NprJpTu#0k^uO z=yd17oI}L#O0N0}7*!-!wQ|+zB8uj!<$=S2O@PyIJ<%U{8aNBM+Z+mjLyIFnFrXyz z0~0KBRhu$8osCtlS_yc|I#+EC>{tpr7+|~&&Yr+Ww%DPhfZ1%9tKJ0O2I|~&x*VW8 zFvC7qjRHOZCIe#}abN`=1FixNb;8mIyaId(?BJZM8r*fdc|dPqtP6H0z}vtsz#QNt zV2_|&bsaDnhxwFKV9an5eg(_~T6sW0dDI*@COlVd4qOBr4%}NUSDg>c2JQsbt&S}b z@TWRh3W48Za#aUUoo-lNoUnoW>!IerA7hap_%06lfs1gU+zE_ofbH^CFcTX<0Wi36 zuIl2Y(|IMJ=D-y=pCtpwwu0rrwMnoX__kxNdJ0&q8w>{?90-?tqtlK@!N74daAg4; zF%upGE}xaFE(5-w4UYk5%+FP`fDX%XTq@xMi+7{OKxga%n*%pt2RInG?jS4{>DU$S z0qT$82o0Qc98Kk`)3rMVR|89*hO2>(FXpPa+IQyw;6<~^mzpAzda||oz zaA0^46aec4Ljf>31PXu)LZJYdQV|LQbh^8hpa5tYj{HD<1o8uIsv|!zJQDeVXKEln zFaitSC*V%3ISzrC4}etyG5)J!@o9~SNA;ip=-NSc0nF1$F`If^@pY zKzHDNU=;8ZFd6956rKY%1TF)v0UiLBZ-)H9{y<%@PImz44lLFj`GZs7LNLjQ*a4gb zJOx|@9Nj`yj{tuGJ_J^5sj7x@7{5SoV4qg1S_fDfpQv;JE(T5l{t8?Le4dE>z@BZ8 zAGjN62+`>-0lk6I?T|kO%qB2hfUT3D0GJJ21$@yS3V>5OKmpJ^Syj#OgENbPWq~Jw zvB1~B?!aF=E~=Um3uYFW?!au|G@v^c z-*vzaz!SiqfLXwgK(h+yTR*635b!dv39xi`RqYS#4V(q6(?eCa0+$2N0Y~&y)mOmF zK&y)IbT4#Xpha&rMQsA+QEw;!R_X%C{qw4R903w#6|4m>>xy&o7p1-&0wYpSZ=1YQJw z1BRqxNyqCM3w}iB1Kv#mlMKdsI(jegL^|3Y=!tLQj{uhg9|HfJh0aq28`li99dN}w zRc#1759|%hSpd%gn=FLufzFFzIIzVM)Eqc;BMgtgDB6tq2G}wan9rYKPx4Qnqh_1^|wH8-JCRxP~& zUs=tqrFUazXa|5l-Ab2h>B}%*dS6TLgMMTbpfLhY(h?DQnGTB3CAuddj#wOE6nO~POVM$9FTK;39J%H3KN7K1$j} zJp@drbOBbhO{6WN^8(t_YZ2)|whaKz6wv^Yu9PSskVXjTMhgV|M7spsq-z4g>9c?i z_s=5$NI4Px<#tV$m7dN2N_BGrx8d-9JF)Dy_u zC>_zP6m1i*nl1@AMxO<^kZU8om*?xAxB+5?o6(DjW^_kXJ4c=Fb1&-D2&(*PGQ?r^ zdI1JHEubd77O4j{sL-JynrP%K)_C#+XVSW(GC$}bWK1h$`R0tJQ9%h6GbN=be6gbctEKFIBgPX zyXdqCb*0w=^kmx~~rqAcA%YxI@(!)2rn(W@sGab*-AEVj0n2>(e(}(1mjv^5NxH%h(mu_Ex?bC z3hN@~x)QwrqBhp;kh+LM1^h_~0;bad0l!m*fbq0Vz&<)JU<|z$fFCzW0`#F!0gEXi z3GF(Rh9JbBR;77K`ZD@W)l|x^3iq8$(i`~WYIGT~Yy!O(S%#8rdq50@3CN%p0=Cl- z0URK!aGu@^C_%Oz;EgqP3%p^VCLQ4C8`J_R_~D!(0*cVw4lv1|c8SpM zbWK1aeHO5d9Fqa)lmdb&Q2=^#GBUKMB_ec|_6jIYw?t$Dv5p80Cl3Ls6x|VH-=$?< z^~QBX=`CrpNZUcH1)QLx5J8`QBA^jjbV6hj1$RQIDSA^HEFI0CDINNYDw1w zxKj>*zZgNDo%Oz0G~znz@%Axgbk^G|pK$46W7^hPztqgwgd0pvdh2&Gw%ugjSHG zlK0{(7PHc#)Vu<$+UAQi>!^vi7N>iY&GHS{b1*->e{Zq2;N|_PpHqdLDfmbI69eW(`gNLn&eHz~$eE=d4H%iB4@bsd zGNhz3TSiWpEhU|eGBjTU+c`2cdyY&CoU31j?C0jnP>*?1=Q|BjNJ@SqnKpO6J{gi9 z=1U{GE|6*W7wFd@GIgPZ@{9C@TAWy<$B)29nWik&+cKmsUZ%eZ7_nSt`LJA;F@A+q zcYlS9?66XX4y@E~fMoAg`V)Y#)%t^gkE=xn(}XqpLuTx)DQ1hlNeP7K?bd&?LY3iQ z*kyWkN^@QFv-vJ|FfBW)FD?AH{i5_r(Lbf>L;sZZvAiVhSa?YqV1HRgZoMo+!B-^w ztbyNEnRei+bXC`DGL(BwW>38?!RCgH+;l@$qvTDQJ?*CSN`+ezuHBN(8E{))0nVXS z_oP$C-`8it`mhIjLou{CI>S@ZDSY0^S~MPRaHkRP^hwBY<(;fVz2oO#wX=@Ojs-vwzbgFZ< z2GNb;?F^zDO}3M1SM6kE3wr^k3-$*5gf*JeQN}tt8AShEXb3y1;)G)@zUQQM?`j@u*`%J5h#pmP+k`NQ+a8WMX1#MW2iLh zP^e6^tso<3OE6hhG;|k64X-3)-&c}GjSG{ZoG@ur`^wU&V&T%Li{a9!xmBc5?h%HE zMc5US5@qlgBQKq zK;85iJ5zkOL!nCIWXL4$QXm$|pWO&8CI@_m|@ZkM0lrz_m6aBFvIRIKmUJb?pJ z4X!=|yLHszTb7Vs2AiUG1&g|toC7C>#Zks)Lje77#o%dLJ<#wLOQvbTU;{pli!zyp zXd}{jxEzs~8Ec6NWAwrpNi~ectMI00Y1+W#=~6Z&U8*ZKL(4fs>dBfR2j-laa$qLSk^|E%Lr9u_ z&M>qz#}Bx%MFu-;eH|7V%HbGVZxMWRpGGY*_+qoULPVCM^NS3XSu~j~Hn`&w!hf+L z1mFK9E=J@@nzb0+V>11*7#T9?&0=JTB9A4|Ql45YG5BGxK4yu*4Yw9cmKdV>>+*DW ziJ=1j6hbyX87g3VUGFEzrqZaN45L_W`uLNf3eO3o(53KrQ|htQkj$U^(H~0MuuOJ*ek$Sa+3{FE=#CX8ZMWLn8LJ z4OSTH@GJ+)SYfEeX49W5pr!&jtc0jNHC|~5#y!QDm4*@gOHul?(%^${lFO_D)TTPC zU~3``TV-g1>YZ3+h{U0}$ZA;Ago0PYEgh-RYPdX!wyZYzxVK?imp+u&v%>~;*6Eih z-?Rbk*Nfh*My01w*)^!;5=s{E3(a3+2*uCfom_)77s_1&H@)~w71pBY1JrdbV!P7< z5t>P-)*2%03bw7<0Qfvrr)wNf9;5YJO@FL2_=?5o&Cdq0g{-o{upjVggW)gSSlroY zaCBHwQ#0=Oyurm5cTsRNjUSWT1P|_`@|z50nL>%148!nU$@xw2Lv#AL$q;LkU+$#u zIlVqpv(1LG*57x^?pl(`G<~ySDeN!>ZPUhJ{a*~}!mg{^QJn-+i5=RiSY?+SS!uiE z82qwJ4hG|IvP+lQExYuh-Es_G+$|-2_sGbVd!%Iby)v{*f~oR8Lz?(l5k&6m#RN zvA88&Lf+>L;+IZi&l$XNpzd=H-RKIU7yq9c3@QY=}bHcP|^NSr;6EG|in%L01e(9Ct-OUNiUuwqL_IOQ7s)vPXtq$B;}g zrCrzh#rhlC+-z}M_KWD-hBPrZpS~|!+x>y;7c(Eo)-L-{HfZKU*`Vbg$$ruOk(Av1 zNJduqOG=*Cpyy*5`B;N4Su%7lONxwqBIjner!utjsZ?D%Tf&)aDcRteOndlD_MDjK z(w6PdWm@P9IX7R`Amyc;qU~RyVKK#4d#z2;32&tAnKx2v;#(QI{8p+9e8jG77Wp zqT-4N&+b9{iYvkVWjA_WTp5Y`tnMY05KQy)ODH|@0|t5vB@jQ+7Gk0Fz|Hjn3&jWb z0sAc!Tx4~oyB10XT;r84sZ7KHok~J2LYBxMPPHwSHtYxb$x`vc#C6D0sl-1f(I-nK z8Eu+qrKIyuZ7Iu2DT8auqSi_@`e~ds6dapf#Br96Mx zf{vC_rlM2Emqrzj(&f^~(vOoONxWe|Vem@;gY37BYY>`?gxs%EDo z;a+ipow5NFbc{W6Jfb1?N?rU&@*aDoD*x7yKG`dkFbsknU{4F`=KvQZ&~*nT0K-mk zL{Sbj-chNF>!Cf4N@EPW5>84lhzxg9+;KC$zzMa?twCp5cVf zsWW`Hi;g-g3AmcGcR^%pn&hJR^7rLwql;1*H*ODHka0IDuCTZ-1-U9QxM&&Z3NM$W z)vgd}O*dVY8u)C+xs37)z8W}FMhQa|4Q|Lcm3-Y`cL;TNQ}9D0bk9xc$1EtpT}i|h z=mvMC9DWh|y1TLv<`3~e3H4~PfFpF+LkYz%b-edb`e5qr>~o z%fZl4IuN4tMMCM2vxlKhb=S!h_;^>ijGl_Ordb_2-A~L z1^>IjA$nOs>Bcrt%ZjkE1DPr+-|(nsdnM&MJ~W#dhN42LWM$a#bqs|8v5dE^42Q+h z1QFU!>ng*wK6JaX5{}u_E*wMj2Gt6O`ybJYaOE=9Lzrq}?Ts)GJ`oT@}1Un6QS zUN%|JjGOh zrXFgDtz)brE)!5fA7m zmem1DV=Sxsj9DqZ_ekGHiRW+dYxixGezgwt(Zri;OQtSRoS~STMQeMp3^&2?_@{oF zMBZ*g=Z7;Ci*%WacW}fB^#bYJ!m?i|wyn|{cizj}Ds9TVa$~yAtMPFD`>mq1Nf(P- z(3tkx0jYL7%p&D!Njt^9m5UG4>5YyxA*HW^UuMzIajYx&jjrJ5Im!6N(5WY98K33^ ze!k;RLgtM-_+?IlSIqR4akSQNag`~Zsd$p&-xJ@$>8uRJ%m$!}=2L#t=?o=GD5ARN zZYauNWs6%_+_ReP^~0|SE9J~;p}yu5@Ovvtd5dij)0wY9(Mp)bCGckEhw*8o5@{*U zo>u0YL`sd4_YiO}??^u-DUKx%dLgd1xj5*0n-8I*Nf>B@=oylnJD~`rooyTnY;As9 zC`yun?&h^k?(G$SUV0HcQPdzR%pR8%zie0PS8A86bPwtRtyZiUvoc_hY&Rd(WW||z zx;XmUr5F$@!HQeUir9CdSIJ6pN(z1(AWu~-R#NZS|R*Z>IP!WN}WV@OP#&Q!5TCDe35-~f$<5f zQpp^Ve>U{%N^L}4S*g89N0CB|wP5-yNVh+VuaQ|RW+B{VJDT*JFrkjdMZMxv^oTI6 zlr1H8!o-35zfM?v5~yfr^qU0g*jag76+fo0b704~)e1AXp$c5Yj&t)K(kc7UN7xB1 zWM)@Pl=-_BveMbNq8VMVZbX@mcEP>@>YDu^<^$8zACxs>Dk#@m4)^iB3wn#2rSd(P#@@DQ{7^ zQo(Qr*Xe~2_tzIevRQ95Sa}|3H4g#vU82E*N;O5N(wYB?6dqh!D6#Tuj$wvRS)<@L z19P)6&xTeW>LhYGn12?M6+|FK=Waenh*q=~KZ;cr_gw<@q7+_99}aQrLFnOH58{1F z-a$;MQnJsrmfgr4-GG<6jSDG#slCW$D3vY-fle>7@xl6a$PlssL+>i%L#;;RF^IWQ zqzrQue1gtANLV()?G)-@W$iUEz4ktP`+bA|qwio7nsmWU zG~lcp4SUE4hirB{wB&w;)tmGHR`K(^@v?iBOw$)%w}hbO<(LcHgWB|9i`{eL<(N5a z$pO9ht8{v;=Ai-I7Xy+1B~yNn_QOHnHY5_| zI8IIZSfqv1NBP2?aFreWsNQR9e`ea4s}28}B`2Itet{!G*zHz?)Z?R236{YpqNTmp zmXEkf@dcR52GHCBO!kSi3Q;V-oyvBq_i$v)XLMTZE5{|7p-hPkXV08*S#8Tx50}Qi zOJ|wr6x}Sq>Zd2&wN3>09Kk+s{~a6m2_>u(eQ?)r2EH8EGl(mER{-Z=(rfF`>0Bh% zV=0(OLlO1r_>;`=hBRJ_45!)aMYQ<^6Yg;Cr!DKnU~?I}G0&M#?dwIK{#McQtfJXG zNh7}F+RRJiR*B7OY#IG)y%>tMR)74UKEwj&-7mof+5;2W?{WRO=4Vst1~Ei7m$-?t zwXDh=VYQaHhh<~AxIEHo^utwK*^wKYO7$DW0EdSMxHn7#zpDicc2?Imh@p;Z*rL~% z#!QMR6iK1{G8w(i4B;V>XYl9}xKrP12F`}y3>6iMiOze`I`v{xtVCm5LFWs_RNSF; z7l|xqFSI%RIWw43mr{KZ#=lew+9<+%!2g;)+cdt$RKF2x*p*bYQ4DnUg`4#ICDl4Q zvQZ2kGJ@I1nR?7#>1Xt*pY579rXQOhZuaJjpIgY`5tDo5!{_>4rtw2F&Glfpce9yR zdqg;PM|(UXIdC*5xnXxqhM`z(#NcB{o3PC~KqEGZ{?V~)lHGI+1M25Fk~?-kmpuq~ z=lMON9HO(iJm>6!C&~(1vq?;noacR<3&42}WT6(>WxGXY^Q3Fh`#I@xyXBpUaxM${P<7mc*XT(^XpWMQk%?UP3b5f~wvq;A4%x-KJ{d0RW zQs$$YKK4A2_l)r4@^~ z`z?P=w-1w9#JfM{QGU98EMH?7%#D4$PG$qS72xbQi^W|%(z)gm?Z)+5`g^g69b*wC z`iQ1WqC`mq+hZ*6jJF3|!n1RHuOWH@x3O5eotHdO^jL{V(tFd65-izzvE%NO#-G9K zF2s;fD|PfOsq5G^!BS@cg^`#TXzBFx>14z%p%+LDaMo~%{%Kf^;27;BF;i;(WGGuQ zVm)+wDLTguiYyf_EW?vZ#c0P2&f!DDm_~)AVz?ul8|G2Nc!xeJ6>)u2nf0iVApJI5 z8+9M!Erv0aLd(RE2Q0kBxL4w7F*mqz95hr_&WpLo6?E88?QVfKDwmgZ4Tf=nmY0ce zM+@`U7{-gVr%c3!MzTw4jCe^mPm3PTEg{{oKaYAUAlp{)7#@t8wN-@NJ%yP!8T#ZZ zS#hz=74o0mP~{MlMrB(uMJ%DiTQR7ALSJshrezEn<%sI(UXEP!a5;7)f25`5BF=f7 zjgOF-Eu}*c;TZQHCi=1cKsQ09(5C{EYrn8ByX_q25Rqhb6q2X2y3TrC1M%h$e;U1JaGwH`2 zA|;@hP1q|%H#gzFfEXsz?Ykx2Le6fNR2oFvs&GcpL07B9aA!RCk+s5VdWAH+8Vl63 z^mMftf$90RY7ypqk`=N=uj5z_G}Fh`7&gP{=V~z~IK4<#+Dutzn4gO$VRjFv=`|uc z^AWZyQxXR$&9PmYmn=;#UZx0naJ<#u+#mO{u7`4W!#M2L*y>CX#|;PrpB7!o1H3_3#CEA(;k0SucHWWH6sl&{mAxm)GIa85B0Bd3Yfcq{7xYO= z^Y>kvpIMr0=v2{98agB9Exw*6tUUk>)uL0m?I%f&%Nt~FbGkSpk~ud{lhnoG?!(z8 zVIt#vQMr;d`4-aK*n{IFX%U6(6n!RGB;&-u|6@qvEouJ2Bf=<|#{K^cX}1iaWjiqw zS!Edgze(@EgOd&uJ$btRf)4Ezv4IEJ#$jRt@3Bw;?ziZ-onpYCcrNWASq(q&i?R{E z?ka6ZisjqHS`ppLs+K|GA+8oIP;=c2DX$ibt5>MDRtyX-R*5sZ5~n|8CH}HjLoyNPrpaFGgkQ=!l2FaSuqN#OOBbZ+&qMZ1Ax2E6px9WTsRRIaK9Cp+H9_281 zD;=*xbHNwPH2qh9HPk(WX_!f`$)v9q$RdSzS(Q53vMQt=g`dEg{3tcklqMFnR?xTY zl$sg!B6|E!)<_^V+w&#o<}OXg6knq_<$s^gy#8F}r~Jn+L1(jh(qfL%r}g4q41DOk z^PRu3-w*j)eYKVr@4`s-4mIq;tW-l+cVV0yN5KtPvf-N)4VYCrxI**%#Y8){U-V3a zrQneY2U+23Ht=bwFrO~4LJIY06hi`Mb0PoW@8G1E31d(|H}0O*y+QrtQ1MBQZM|`O@$94nCehFP`PM|SH(r(g zU99{YlTUZ=!6rYArtCpB9rVf`%!s3zrNhrP&0@if_8C|E8-B)M`f!hU%z2#cEtdHU zayMJ~&uA7o0dI1}6#7{u`6idnHjBZIne4vRenuAE)`IzHDY;v)c)7tGulgCoXjThW zIk{YC|0yX~(FTa%oVFJ6#L&S^Ia^XbyIh)&^Dryu+eUrLCkv1I89_9r6~{tDxH41y ztR?1ATG5IF|18?y3a5=?Gp0!71v(ETG>e@)#V<Uqc`u$Y-gVf%dudI}8N=Ih#@;m2yW&oBfQ@F~X$~~3-+&JER`xM3n!N_$5pfRo zP#O0KwVp?8?r#P^Wcy`-_x&t0*xz=2jrXf;Q~2Awh1B?j+1Km8*c{+*d!mwnhkD27 zm|Ohy4)5nLo4@+$N#4`BW}LtIdkmSP*X2-epH(Iv*lef20dsq2%e=Qh$z&v^FJgqbkt3qMnoTBn9)Q zUzje3PHsjq$C17TT1|^3Tqn7;emsIf>k)EqF{9kqmPj~J!RZQq@Ode3z{tZPQ_25I z9%gkPlCbrg1Hh{ke1Y1xz!A# z!Y?@`{GEbF;2nE_D}RyjxA-9~2NQ1N63xQ9_W&Q}k3k@;l#v#p;0)?yI8MnUlxb-S zj-tR4z@J={$u_Cf1qz-|2_4HXZf6CSA$pn;%21X)2~zo#Qa-4Z^Jo!ZzJXYV3=Yys zTqS2tlgb;Fa>#Acnk!2Fu9DxQa1U@(>wm+m-wI$%Cn#b4%rKk|6xIqWi0Yhtm~?OXo;9 zO0n9|I=NlFM`7h=koyDvOf&*Uc`Jk{_=hK@oRmCD$yd|Da@2+ICfPWdN}HwNz0?X; zz9aPKax)Tlm9Cd#Ao+swx0yLuJm?j$Xx7`38mD|#2u6osi}K0Mu&GYeI#kXH3f@nd z73hSY9FwUZQ1D^}JE@&hcR!0PS1<;+3Ue-ge~`M}taGjXMP~h(C;BXlxY^1KiC1KdqAPOcoM;j<}7c@Vm7jfl!T$6lXDZWpCC#}JJy9*43B+@xSsU;_**r@%%SmPQec z=3IVcv!D^2-|#n~5Y(KkWn<;e4Kk5VHllZS-+J#=@L+N`f%5~(&=c!k zwz7f(_du(LBKAOQsB*w`sidVTtpT(MTCVOp{O1+CpQ@PTEFA&~o-e(`T;G;RyM9$% z7nE`$c2nRwPCZ-3sof;Q8cf#xyaI94+QsuI_iojw!7q>TH1} z(G=K<=o}?*ghI5UE#Q7aK`ZL*v^wDN4N+73Nds!>B-HR=@Fh-EO|HFIECx-I)_$bs z*A}IGbCZ-muFQN>$p_JkNak{@X6b`3D>#eV_o9$1ln;DWXTxug*$3Q2{ zhbuVaU9<==9t6#24^!*UdB-egiouSPAaL5nMvfy}0wiW)Z7?zhx`B#eB z5Bn-+zJuC9;_80PGf2UBU>U4FXb)D%?k~-_KvjS-(w+1opKJW>F@)>ZU%YBTX}#*z51Q`{ zviallocator, compiler_state->queued_files, 4); - bh_arr_push(compiler_state->queued_files, lookup_included_file(compiler_state, "builtin")); + bh_arr_push(compiler_state->queued_files, lookup_included_file(compiler_state, "core/builtin")); // NOTE: Add all files passed by command line to the queue bh_arr_each(const char *, filename, opts->files) diff --git a/src/onyxsymres.c b/src/onyxsymres.c index e048f544..23ba952f 100644 --- a/src/onyxsymres.c +++ b/src/onyxsymres.c @@ -461,6 +461,8 @@ void symres_function(AstFunction* func) { bh_arr_each(AstParam, param, func->params) { if (param->default_value != NULL) { symres_expression(¶m->default_value); + if (onyx_has_errors()) return; + if (check_expression(¶m->default_value)) return; } } -- 2.25.1