ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-06-18 11:52:22 -07:00
Code Issues Packages Projects Releases Wiki Activity

Generic (grouped) declarations: var, let, const, type, import, include

Browse Source
This commit is contained in:
Ginger Bill
2016-12-20 18:58:17 +00:00
parent 478d63424f
commit d0e1efe622
20 changed files with 763 additions and 730 deletions
Download Patch File Download Diff File Expand all files Collapse all files
code/demo.odin
+17 -22
View File
@@ -1,36 +1,31 @@
#import "atomic.odin";
#import "fmt.odin";
#import "hash.odin";
#import "math.odin";
#import "mem.odin";
#import "opengl.odin";
#import "os.odin";
#import "sync.odin";
#import "utf8.odin";
type float32 f32;
const (
X = iota;
Y;
Z;
A = iota+1;
B;
C;
);
import (
"atomic.odin";
"fmt.odin";
"hash.odin";
"math.odin";
"mem.odin";
"opengl.odin";
"os.odin";
"sync.odin";
"utf8.odin";
)
type Byte_Size f64;
const (
_ = iota; // ignore first value by assigning to blank identifier
KB Byte_Size = 1 << (10 * iota);
// Because there is no type or expression, the previous one is used but
// with `iota` incremented by one
MB;
GB;
TB;
PB;
EB;
);
)
proc main() {
var x = 123;
fmt.println(x);
fmt.println("Here");
}
core/_preload.odin
+80 -78
View File
@@ -1,8 +1,10 @@
#shared_global_scope;
#import "os.odin";
#import "fmt.odin";
#import "mem.odin";
import (
"os.odin";
"fmt.odin";
"mem.odin";
)
// IMPORTANT NOTE(bill): `type_info` & `type_info_val` cannot be used within a
// #shared_global_scope due to the internals of the compiler.
@@ -12,65 +14,67 @@
// IMPORTANT NOTE(bill): Do not change the order of any of this data
// The compiler relies upon this _exact_ order
type Type_Info_Member struct #ordered {
name string; // can be empty if tuple
type_info ^Type_Info;
offset int; // offsets are not used in tuples
}
type Type_Info_Record struct #ordered {
fields []Type_Info_Member;
size int; // in bytes
align int; // in bytes
packed bool;
ordered bool;
}
type (
Type_Info_Member struct #ordered {
name string; // can be empty if tuple
type_info ^Type_Info;
offset int; // offsets are not used in tuples
}
Type_Info_Record struct #ordered {
fields []Type_Info_Member;
size int; // in bytes
align int; // in bytes
packed bool;
ordered bool;
}
type Type_Info union {
Named struct #ordered {
name string;
base ^Type_Info; // This will _not_ be a Type_Info.Named
};
Integer struct #ordered {
size int; // in bytes
signed bool;
};
Float struct #ordered {
size int; // in bytes
};
Any struct #ordered {};
String struct #ordered {};
Boolean struct #ordered {};
Pointer struct #ordered {
elem ^Type_Info; // nil -> rawptr
};
Maybe struct #ordered {
elem ^Type_Info;
};
Procedure struct #ordered {
params ^Type_Info; // Type_Info.Tuple
results ^Type_Info; // Type_Info.Tuple
variadic bool;
};
Array struct #ordered {
elem ^Type_Info;
elem_size int;
count int;
};
Slice struct #ordered {
elem ^Type_Info;
elem_size int;
};
Vector struct #ordered {
elem ^Type_Info;
elem_size int;
count int;
align int;
};
Tuple Type_Info_Record;
Struct Type_Info_Record;
Union Type_Info_Record;
Raw_Union Type_Info_Record;
};
Type_Info union {
Named struct #ordered {
name string;
base ^Type_Info; // This will _not_ be a Type_Info.Named
};
Integer struct #ordered {
size int; // in bytes
signed bool;
};
Float struct #ordered {
size int; // in bytes
};
Any struct #ordered {};
String struct #ordered {};
Boolean struct #ordered {};
Pointer struct #ordered {
elem ^Type_Info; // nil -> rawptr
};
Maybe struct #ordered {
elem ^Type_Info;
};
Procedure struct #ordered {
params ^Type_Info; // Type_Info.Tuple
results ^Type_Info; // Type_Info.Tuple
variadic bool;
};
Array struct #ordered {
elem ^Type_Info;
elem_size int;
count int;
};
Slice struct #ordered {
elem ^Type_Info;
elem_size int;
};
Vector struct #ordered {
elem ^Type_Info;
elem_size int;
count int;
align int;
};
Tuple Type_Info_Record;
Struct Type_Info_Record;
Union Type_Info_Record;
Raw_Union Type_Info_Record;
}
)
proc type_info_base(info ^Type_Info) -> ^Type_Info {
if info == nil {
@@ -115,26 +119,24 @@ const (
ALLOCATOR_FREE_ALL;
ALLOCATOR_RESIZE;
);
type Allocator_Proc proc(allocator_data rawptr, mode Allocator_Mode,
size, alignment int,
old_memory rawptr, old_size int, flags u64) -> rawptr;
type (
Allocator_Proc proc(allocator_data rawptr, mode Allocator_Mode,
size, alignment int,
old_memory rawptr, old_size int, flags u64) -> rawptr;
Allocator struct #ordered {
procedure Allocator_Proc;
data rawptr;
}
Context struct #ordered {
thread_id int;
allocator Allocator;
type Allocator struct #ordered {
procedure Allocator_Proc;
data rawptr;
}
type Context struct #ordered {
thread_id int;
allocator Allocator;
user_data rawptr;
user_index int;
}
user_data rawptr;
user_index int;
}
);
#thread_local var __context Context;
core/atomic.odin
+1 -1
View File
@@ -1,7 +1,7 @@
// TODO(bill): Use assembly instead here to implement atomics
// Inline vs external file?
#import win32 "sys/windows.odin" when ODIN_OS == "windows";
import win32 "sys/windows.odin" when ODIN_OS == "windows";
var _ = compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
core/fmt.odin
+5 -3
View File
@@ -1,6 +1,8 @@
#import "os.odin";
#import "mem.odin";
#import "utf8.odin";
import (
"os.odin";
"mem.odin";
"utf8.odin";
)
const PRINT_BUF_SIZE = 1<<12;
core/math.odin
+9 -8
View File
@@ -16,16 +16,17 @@ const (
τ = TAU;
π = PI;
);
)
type Vec2 [vector 2]f32;
type Vec3 [vector 3]f32;
type Vec4 [vector 4]f32;
type Mat2 [2]Vec2;
type Mat3 [3]Vec3;
type Mat4 [4]Vec4;
type (
Vec2 [vector 2]f32;
Vec3 [vector 3]f32;
Vec4 [vector 4]f32;
Mat2 [2]Vec2;
Mat3 [3]Vec3;
Mat4 [4]Vec4;
)
proc sqrt32(x f32) -> f32 #foreign "llvm.sqrt.f32"
proc sqrt64(x f64) -> f64 #foreign "llvm.sqrt.f64"
core/mem.odin
+17 -14
View File
@@ -1,5 +1,7 @@
#import "fmt.odin";
#import "os.odin";
import (
"fmt.odin";
"os.odin";
)
proc set(data rawptr, value i32, len int) -> rawptr #link_name "__mem_set" {
proc llvm_memset_64bit(dst rawptr, val byte, len int, align i32, is_volatile bool) #foreign "llvm.memset.p0i8.i64"
@@ -92,6 +94,7 @@ proc align_forward(ptr rawptr, align int) -> rawptr {
type Allocation_Header struct {
size int;
}
proc allocation_header_fill(header ^Allocation_Header, data rawptr, size int) {
header.size = size;
var ptr = (header+1) as ^int;
@@ -113,18 +116,18 @@ proc allocation_header(data rawptr) -> ^Allocation_Header {
// Custom allocators
type (
Arena struct {
backing Allocator;
memory []byte;
temp_count int;
}
type Arena struct {
backing Allocator;
memory []byte;
temp_count int;
}
type Arena_Temp_Memory struct {
arena ^Arena;
original_count int;
}
Arena_Temp_Memory struct {
arena ^Arena;
original_count int;
}
)
@@ -270,7 +273,7 @@ proc align_of_type_info(type_info ^Type_Info) -> int {
proc align_formula(size, align int) -> int {
var result = size + align-1;
return result - result%align;
};
}
proc size_of_type_info(type_info ^Type_Info) -> int {
const WORD_SIZE = size_of(int);
core/opengl.odin
+2 -2
View File
@@ -1,6 +1,6 @@
#foreign_system_library "opengl32" when ODIN_OS == "windows";
#import win32 "sys/windows.odin" when ODIN_OS == "windows";
#include "opengl_constants.odin";
import win32 "sys/windows.odin" when ODIN_OS == "windows";
include "opengl_constants.odin";
proc Clear (mask u32) #foreign "glClear"
proc ClearColor (r, g, b, a f32) #foreign "glClearColor"
core/os.odin
+1 -1
View File
@@ -1,2 +1,2 @@
#include "os_windows.odin" when ODIN_OS == "windows"
include "os_windows.odin" when ODIN_OS == "windows"
core/os_windows.odin
+25 -20
View File
@@ -1,17 +1,21 @@
#import win32 "sys/windows.odin";
#import "fmt.odin";
import (
win32 "sys/windows.odin";
"fmt.odin";
)
type File_Time u64;
type (
File_Time u64;
type File_Handle raw_union {
p rawptr;
i int;
}
File_Handle raw_union {
p rawptr;
i int;
}
type File struct {
handle File_Handle;
last_write_time File_Time;
}
File struct {
handle File_Handle;
last_write_time File_Time;
}
)
proc open(name string) -> (File, bool) {
using win32;
@@ -92,16 +96,17 @@ const (
);
// NOTE(bill): Uses startup to initialize it
var __std_files = [FILE_STANDARD_COUNT]File{
{handle = win32.GetStdHandle(win32.STD_INPUT_HANDLE) transmute File_Handle },
{handle = win32.GetStdHandle(win32.STD_OUTPUT_HANDLE) transmute File_Handle },
{handle = win32.GetStdHandle(win32.STD_ERROR_HANDLE) transmute File_Handle },
};
var stdin = ^__std_files[FILE_STANDARD_INPUT];
var stdout = ^__std_files[FILE_STANDARD_OUTPUT];
var stderr = ^__std_files[FILE_STANDARD_ERROR];
var (
__std_files = [FILE_STANDARD_COUNT]File{
{handle = win32.GetStdHandle(win32.STD_INPUT_HANDLE) transmute File_Handle },
{handle = win32.GetStdHandle(win32.STD_OUTPUT_HANDLE) transmute File_Handle },
{handle = win32.GetStdHandle(win32.STD_ERROR_HANDLE) transmute File_Handle },
};
stdin = ^__std_files[FILE_STANDARD_INPUT];
stdout = ^__std_files[FILE_STANDARD_OUTPUT];
stderr = ^__std_files[FILE_STANDARD_ERROR];
)
proc read_entire_file(name string) -> ([]byte, bool) {
core/sync.odin
+15 -12
View File
@@ -1,17 +1,20 @@
#import win32 "sys/windows.odin" when ODIN_OS == "windows";
#import "atomic.odin";
import (
win32 "sys/windows.odin" when ODIN_OS == "windows";
"atomic.odin";
)
type Semaphore struct {
handle win32.HANDLE;
}
type Mutex struct {
semaphore Semaphore;
counter i32;
owner i32;
recursion i32;
}
type (
Semaphore struct {
handle win32.HANDLE;
}
Mutex struct {
semaphore Semaphore;
counter i32;
owner i32;
recursion i32;
}
)
proc current_thread_id() -> i32 {
return win32.GetCurrentThreadId() as i32;
core/sys/windows.odin
+250 -237
View File
@@ -1,117 +1,124 @@
#foreign_system_library "user32" when ODIN_OS == "windows";
#foreign_system_library "gdi32" when ODIN_OS == "windows";
type HANDLE rawptr;
type HWND HANDLE;
type HDC HANDLE;
type HINSTANCE HANDLE;
type HICON HANDLE;
type HCURSOR HANDLE;
type HMENU HANDLE;
type HBRUSH HANDLE;
type HGDIOBJ HANDLE;
type HMODULE HANDLE;
type WPARAM uint;
type LPARAM int;
type LRESULT int;
type ATOM i16;
type BOOL i32;
type WNDPROC proc(hwnd HWND, msg u32, wparam WPARAM, lparam LPARAM) -> LRESULT;
type (
HANDLE rawptr;
HWND HANDLE;
HDC HANDLE;
HINSTANCE HANDLE;
HICON HANDLE;
HCURSOR HANDLE;
HMENU HANDLE;
HBRUSH HANDLE;
HGDIOBJ HANDLE;
HMODULE HANDLE;
WPARAM uint;
LPARAM int;
LRESULT int;
ATOM i16;
BOOL i32;
WNDPROC proc(hwnd HWND, msg u32, wparam WPARAM, lparam LPARAM) -> LRESULT;
)
const INVALID_HANDLE_VALUE = (-1 as int) as HANDLE;
const (
INVALID_HANDLE_VALUE = (-1 as int) as HANDLE;
const CS_VREDRAW = 0x0001;
const CS_HREDRAW = 0x0002;
const CS_OWNDC = 0x0020;
const CW_USEDEFAULT = -0x80000000;
CS_VREDRAW = 0x0001;
CS_HREDRAW = 0x0002;
CS_OWNDC = 0x0020;
CW_USEDEFAULT = -0x80000000;
const WS_OVERLAPPED = 0;
const WS_MAXIMIZEBOX = 0x00010000;
const WS_MINIMIZEBOX = 0x00020000;
const WS_THICKFRAME = 0x00040000;
const WS_SYSMENU = 0x00080000;
const WS_CAPTION = 0x00C00000;
const WS_VISIBLE = 0x10000000;
const WS_OVERLAPPEDWINDOW = WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX;
WS_OVERLAPPED = 0;
WS_MAXIMIZEBOX = 0x00010000;
WS_MINIMIZEBOX = 0x00020000;
WS_THICKFRAME = 0x00040000;
WS_SYSMENU = 0x00080000;
WS_CAPTION = 0x00C00000;
WS_VISIBLE = 0x10000000;
WS_OVERLAPPEDWINDOW = WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX;
const WM_DESTROY = 0x0002;
const WM_CLOSE = 0x0010;
const WM_QUIT = 0x0012;
const WM_KEYDOWN = 0x0100;
const WM_KEYUP = 0x0101;
WM_DESTROY = 0x0002;
WM_CLOSE = 0x0010;
WM_QUIT = 0x0012;
WM_KEYDOWN = 0x0100;
WM_KEYUP = 0x0101;
const PM_REMOVE = 1;
PM_REMOVE = 1;
const COLOR_BACKGROUND = 1 as HBRUSH;
const BLACK_BRUSH = 4;
COLOR_BACKGROUND = 1 as HBRUSH;
BLACK_BRUSH = 4;
const SM_CXSCREEN = 0;
const SM_CYSCREEN = 1;
SM_CXSCREEN = 0;
SM_CYSCREEN = 1;
const SW_SHOW = 5;
SW_SHOW = 5;
)
type POINT struct #ordered {
x, y i32;
}
type (
POINT struct #ordered {
x, y i32;
}
WNDCLASSEXA struct #ordered {
size, style u32;
wnd_proc WNDPROC;
cls_extra, wnd_extra i32;
instance HINSTANCE;
icon HICON;
cursor HCURSOR;
background HBRUSH;
menu_name, class_name ^u8;
sm HICON;
}
type WNDCLASSEXA struct #ordered {
size, style u32;
wnd_proc WNDPROC;
cls_extra, wnd_extra i32;
instance HINSTANCE;
icon HICON;
cursor HCURSOR;
background HBRUSH;
menu_name, class_name ^u8;
sm HICON;
}
MSG struct #ordered {
hwnd HWND;
message u32;
wparam WPARAM;
lparam LPARAM;
time u32;
pt POINT;
}
type MSG struct #ordered {
hwnd HWND;
message u32;
wparam WPARAM;
lparam LPARAM;
time u32;
pt POINT;
}
RECT struct #ordered {
left i32;
top i32;
right i32;
bottom i32;
}
type RECT struct #ordered {
left i32;
top i32;
right i32;
bottom i32;
}
FILETIME struct #ordered {
low_date_time, high_date_time u32;
}
type FILETIME struct #ordered {
low_date_time, high_date_time u32;
}
BY_HANDLE_FILE_INFORMATION struct #ordered {
file_attributes u32;
creation_time,
last_access_time,
last_write_time FILETIME;
volume_serial_number,
file_size_high,
file_size_low,
number_of_links,
file_index_high,
file_index_low u32;
}
type BY_HANDLE_FILE_INFORMATION struct #ordered {
file_attributes u32;
creation_time,
last_access_time,
last_write_time FILETIME;
volume_serial_number,
file_size_high,
file_size_low,
number_of_links,
file_index_high,
file_index_low u32;
}
WIN32_FILE_ATTRIBUTE_DATA struct #ordered {
file_attributes u32;
creation_time,
last_access_time,
last_write_time FILETIME;
file_size_high,
file_size_low u32;
}
type WIN32_FILE_ATTRIBUTE_DATA struct #ordered {
file_attributes u32;
creation_time,
last_access_time,
last_write_time FILETIME;
file_size_high,
file_size_low u32;
}
type GET_FILEEX_INFO_LEVELS i32;
const GetFileExInfoStandard = 0 as GET_FILEEX_INFO_LEVELS;
const GetFileExMaxInfoLevel = 1 as GET_FILEEX_INFO_LEVELS;
GET_FILEEX_INFO_LEVELS i32;
)
const (
GetFileExInfoStandard = 0 as GET_FILEEX_INFO_LEVELS;
GetFileExMaxInfoLevel = 1 as GET_FILEEX_INFO_LEVELS;
)
proc GetLastError () -> i32 #foreign #dll_import
proc ExitProcess (exit_code u32) #foreign #dll_import
@@ -176,24 +183,25 @@ proc GetFileSizeEx (file_handle HANDLE, file_size ^i64) -> BOOL #for
proc GetFileAttributesExA (filename ^u8, info_level_id GET_FILEEX_INFO_LEVELS, file_info rawptr) -> BOOL #foreign #dll_import
proc GetFileInformationByHandle(file_handle HANDLE, file_info ^BY_HANDLE_FILE_INFORMATION) -> BOOL #foreign #dll_import
const FILE_SHARE_READ = 0x00000001;
const FILE_SHARE_WRITE = 0x00000002;
const FILE_SHARE_DELETE = 0x00000004;
const FILE_GENERIC_ALL = 0x10000000;
const FILE_GENERIC_EXECUTE = 0x20000000;
const FILE_GENERIC_WRITE = 0x40000000;
const FILE_GENERIC_READ = 0x80000000;
const (
FILE_SHARE_READ = 0x00000001;
FILE_SHARE_WRITE = 0x00000002;
FILE_SHARE_DELETE = 0x00000004;
FILE_GENERIC_ALL = 0x10000000;
FILE_GENERIC_EXECUTE = 0x20000000;
FILE_GENERIC_WRITE = 0x40000000;
FILE_GENERIC_READ = 0x80000000;
const STD_INPUT_HANDLE = -10;
const STD_OUTPUT_HANDLE = -11;
const STD_ERROR_HANDLE = -12;
const CREATE_NEW = 1;
const CREATE_ALWAYS = 2;
const OPEN_EXISTING = 3;
const OPEN_ALWAYS = 4;
const TRUNCATE_EXISTING = 5;
STD_INPUT_HANDLE = -10;
STD_OUTPUT_HANDLE = -11;
STD_ERROR_HANDLE = -12;
CREATE_NEW = 1;
CREATE_ALWAYS = 2;
OPEN_EXISTING = 3;
OPEN_ALWAYS = 4;
TRUNCATE_EXISTING = 5;
)
@@ -240,31 +248,34 @@ proc ReadBarrier () #foreign
// GDI
type BITMAPINFOHEADER struct #ordered {
size u32;
width, height i32;
planes, bit_count i16;
compression u32;
size_image u32;
x_pels_per_meter i32;
y_pels_per_meter i32;
clr_used u32;
clr_important u32;
}
type BITMAPINFO struct #ordered {
using header BITMAPINFOHEADER;
colors [1]RGBQUAD;
}
type (
BITMAPINFOHEADER struct #ordered {
size u32;
width, height i32;
planes, bit_count i16;
compression u32;
size_image u32;
x_pels_per_meter i32;
y_pels_per_meter i32;
clr_used u32;
clr_important u32;
}
BITMAPINFO struct #ordered {
using header BITMAPINFOHEADER;
colors [1]RGBQUAD;
}
type RGBQUAD struct #ordered {
blue, green, red, reserved byte;
}
RGBQUAD struct #ordered {
blue, green, red, reserved byte;
}
)
const BI_RGB = 0;
const DIB_RGB_COLORS = 0x00;
const SRCCOPY = 0x00cc0020 as u32;
const (
BI_RGB = 0;
DIB_RGB_COLORS = 0x00;
SRCCOPY = 0x00cc0020 as u32;
)
proc StretchDIBits(hdc HDC,
x_dst, y_dst, width_dst, height_dst i32,
@@ -284,64 +295,67 @@ proc GetClientRect(hwnd HWND, rect ^RECT) -> BOOL #foreign
// Windows OpenGL
const (
PFD_TYPE_RGBA = 0;
PFD_TYPE_COLORINDEX = 1;
PFD_MAIN_PLANE = 0;
PFD_OVERLAY_PLANE = 1;
PFD_UNDERLAY_PLANE = -1;
PFD_DOUBLEBUFFER = 1;
PFD_STEREO = 2;
PFD_DRAW_TO_WINDOW = 4;
PFD_DRAW_TO_BITMAP = 8;
PFD_SUPPORT_GDI = 16;
PFD_SUPPORT_OPENGL = 32;
PFD_GENERIC_FORMAT = 64;
PFD_NEED_PALETTE = 128;
PFD_NEED_SYSTEM_PALETTE = 0x00000100;
PFD_SWAP_EXCHANGE = 0x00000200;
PFD_SWAP_COPY = 0x00000400;
PFD_SWAP_LAYER_BUFFERS = 0x00000800;
PFD_GENERIC_ACCELERATED = 0x00001000;
PFD_DEPTH_DONTCARE = 0x20000000;
PFD_DOUBLEBUFFER_DONTCARE = 0x40000000;
PFD_STEREO_DONTCARE = 0x80000000;
)
const PFD_TYPE_RGBA = 0;
const PFD_TYPE_COLORINDEX = 1;
const PFD_MAIN_PLANE = 0;
const PFD_OVERLAY_PLANE = 1;
const PFD_UNDERLAY_PLANE = -1;
const PFD_DOUBLEBUFFER = 1;
const PFD_STEREO = 2;
const PFD_DRAW_TO_WINDOW = 4;
const PFD_DRAW_TO_BITMAP = 8;
const PFD_SUPPORT_GDI = 16;
const PFD_SUPPORT_OPENGL = 32;
const PFD_GENERIC_FORMAT = 64;
const PFD_NEED_PALETTE = 128;
const PFD_NEED_SYSTEM_PALETTE = 0x00000100;
const PFD_SWAP_EXCHANGE = 0x00000200;
const PFD_SWAP_COPY = 0x00000400;
const PFD_SWAP_LAYER_BUFFERS = 0x00000800;
const PFD_GENERIC_ACCELERATED = 0x00001000;
const PFD_DEPTH_DONTCARE = 0x20000000;
const PFD_DOUBLEBUFFER_DONTCARE = 0x40000000;
const PFD_STEREO_DONTCARE = 0x80000000;
type HGLRC HANDLE;
type PROC proc();
type wglCreateContextAttribsARBType proc(hdc HDC, hshareContext rawptr, attribList ^i32) -> HGLRC;
type (
HGLRC HANDLE;
PROC proc();
wglCreateContextAttribsARBType proc(hdc HDC, hshareContext rawptr, attribList ^i32) -> HGLRC;
type PIXELFORMATDESCRIPTOR struct #ordered {
size,
version,
flags u32;
PIXELFORMATDESCRIPTOR struct #ordered {
size,
version,
flags u32;
pixel_type,
color_bits,
red_bits,
red_shift,
green_bits,
green_shift,
blue_bits,
blue_shift,
alpha_bits,
alpha_shift,
accum_bits,
accum_red_bits,
accum_green_bits,
accum_blue_bits,
accum_alpha_bits,
depth_bits,
stencil_bits,
aux_buffers,
layer_type,
reserved byte;
pixel_type,
color_bits,
red_bits,
red_shift,
green_bits,
green_shift,
blue_bits,
blue_shift,
alpha_bits,
alpha_shift,
accum_bits,
accum_red_bits,
accum_green_bits,
accum_blue_bits,
accum_alpha_bits,
depth_bits,
stencil_bits,
aux_buffers,
layer_type,
reserved byte;
layer_mask,
visible_mask,
damage_mask u32;
}
layer_mask,
visible_mask,
damage_mask u32;
}
)
proc GetDC (h HANDLE) -> HDC #foreign
proc SetPixelFormat (hdc HDC, pixel_format i32, pfd ^PIXELFORMATDESCRIPTOR ) -> BOOL #foreign #dll_import
@@ -349,11 +363,13 @@ proc ChoosePixelFormat(hdc HDC, pfd ^PIXELFORMATDESCRIPTOR) -> i32 #foreign #dll
proc SwapBuffers (hdc HDC) -> BOOL #foreign #dll_import
proc ReleaseDC (wnd HWND, hdc HDC) -> i32 #foreign #dll_import
const WGL_CONTEXT_MAJOR_VERSION_ARB = 0x2091;
const WGL_CONTEXT_MINOR_VERSION_ARB = 0x2092;
const WGL_CONTEXT_PROFILE_MASK_ARB = 0x9126;
const WGL_CONTEXT_CORE_PROFILE_BIT_ARB = 0x0001;
const WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x0002;
const (
WGL_CONTEXT_MAJOR_VERSION_ARB = 0x2091;
WGL_CONTEXT_MINOR_VERSION_ARB = 0x2092;
WGL_CONTEXT_PROFILE_MASK_ARB = 0x9126;
WGL_CONTEXT_CORE_PROFILE_BIT_ARB = 0x0001;
WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x0002;
)
proc wglCreateContext (hdc HDC) -> HGLRC #foreign #dll_import
proc wglMakeCurrent (hdc HDC, hglrc HGLRC) -> BOOL #foreign #dll_import
@@ -365,60 +381,57 @@ proc wglDeleteContext (hglrc HGLRC) -> BOOL #foreign #dll_import
proc GetKeyState (v_key i32) -> i16 #foreign #dll_import
proc GetAsyncKeyState(v_key i32) -> i16 #foreign #dll_import
proc is_key_down(key Key_Code) -> bool {
return GetAsyncKeyState(key as i32) < 0;
}
proc is_key_down(key i32) -> bool #inline { return GetAsyncKeyState(key) < 0; }
type Key_Code i32;
const (
KEY_LBUTTON Key_Code = 0x01;
KEY_RBUTTON = 0x02;
KEY_CANCEL = 0x03;
KEY_MBUTTON = 0x04;
KEY_LBUTTON = 0x01;
KEY_RBUTTON = 0x02;
KEY_CANCEL = 0x03;
KEY_MBUTTON = 0x04;
KEY_BACK = 0x08;
KEY_TAB = 0x09;
KEY_BACK = 0x08;
KEY_TAB = 0x09;
KEY_CLEAR = 0x0C;
KEY_RETURN = 0x0D;
KEY_CLEAR = 0x0C;
KEY_RETURN = 0x0D;
KEY_SHIFT = 0x10;
KEY_CONTROL = 0x11;
KEY_MENU = 0x12;
KEY_PAUSE = 0x13;
KEY_CAPITAL = 0x14;
KEY_SHIFT = 0x10;
KEY_CONTROL = 0x11;
KEY_MENU = 0x12;
KEY_PAUSE = 0x13;
KEY_CAPITAL = 0x14;
KEY_KANA = 0x15;
KEY_HANGEUL = 0x15;
KEY_HANGUL = 0x15;
KEY_JUNJA = 0x17;
KEY_FINAL = 0x18;
KEY_HANJA = 0x19;
KEY_KANJI = 0x19;
KEY_KANA = 0x15;
KEY_HANGEUL = 0x15;
KEY_HANGUL = 0x15;
KEY_JUNJA = 0x17;
KEY_FINAL = 0x18;
KEY_HANJA = 0x19;
KEY_KANJI = 0x19;
KEY_ESCAPE = 0x1B;
KEY_ESCAPE = 0x1B;
KEY_CONVERT = 0x1C;
KEY_NONCONVERT = 0x1D;
KEY_ACCEPT = 0x1E;
KEY_MODECHANGE = 0x1F;
KEY_CONVERT = 0x1C;
KEY_NONCONVERT = 0x1D;
KEY_ACCEPT = 0x1E;
KEY_MODECHANGE = 0x1F;
KEY_SPACE = 0x20;
KEY_PRIOR = 0x21;
KEY_NEXT = 0x22;
KEY_END = 0x23;
KEY_HOME = 0x24;
KEY_LEFT = 0x25;
KEY_UP = 0x26;
KEY_RIGHT = 0x27;
KEY_DOWN = 0x28;
KEY_SELECT = 0x29;
KEY_PRINT = 0x2A;
KEY_EXECUTE = 0x2B;
KEY_SNAPSHOT = 0x2C;
KEY_INSERT = 0x2D;
KEY_DELETE = 0x2E;
KEY_HELP = 0x2F;
KEY_SPACE = 0x20;
KEY_PRIOR = 0x21;
KEY_NEXT = 0x22;
KEY_END = 0x23;
KEY_HOME = 0x24;
KEY_LEFT = 0x25;
KEY_UP = 0x26;
KEY_RIGHT = 0x27;
KEY_DOWN = 0x28;
KEY_SELECT = 0x29;
KEY_PRINT = 0x2A;
KEY_EXECUTE = 0x2B;
KEY_SNAPSHOT = 0x2C;
KEY_INSERT = 0x2D;
KEY_DELETE = 0x2E;
KEY_HELP = 0x2F;
KEY_NUM0 = '0';
KEY_NUM1 = '1';
@@ -522,5 +535,5 @@ const (
KEY_NONAME = 0xFC;
KEY_PA1 = 0xFD;
KEY_OEM_CLEAR = 0xFE;
);
)
core/utf8.odin
+27 -25
View File
@@ -14,33 +14,35 @@ type Accept_Range struct {
lo, hi u8;
};
var accept_ranges = [5]Accept_Range{
{0x80, 0xbf},
{0xa0, 0xbf},
{0x80, 0x9f},
{0x90, 0xbf},
{0x80, 0x8f},
};
var (
accept_ranges = [5]Accept_Range{
{0x80, 0xbf},
{0xa0, 0xbf},
{0x80, 0x9f},
{0x90, 0xbf},
{0x80, 0x8f},
};
var accept_sizes = [256]byte{
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]byte{
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]byte, int) {
var buf [4]byte;
src/checker/checker.c
+41 -40
View File
@@ -1137,13 +1137,23 @@ void check_global_collect_entities_from_file(Checker *c, Scope *parent_scope, As
}
AstNodeValueSpec empty_spec_ = {0}, *empty_spec = &empty_spec_;
AstNodeValueSpec *last = NULL;
AstNodeValueSpec *prev_spec = NULL;
for_array(iota, gd->specs) {
AstNode *spec = gd->specs.e[iota];
switch (spec->kind) {
case_ast_node(is, ImportSpec, spec);
if (!parent_scope->is_file) {
// NOTE(bill): _Should_ be caught by the parser
// TODO(bill): Better error handling if it isn't
continue;
}
DelayedDecl di = {parent_scope, spec};
array_add(&c->delayed_imports, di);
case_end;
case_ast_node(vs, ValueSpec, spec);
switch (vs->keyword) {
case Token_let:
case Token_var: {
// NOTE(bill): You need to store the entity information here unline a constant declaration
isize entity_count = vs->names.count;
@@ -1168,7 +1178,7 @@ void check_global_collect_entities_from_file(Checker *c, Scope *parent_scope, As
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, parent_scope, name->Ident, NULL);
Entity *e = make_entity_variable(c->allocator, parent_scope, name->Ident, NULL, vs->keyword == Token_let);
e->identifier = name;
entities[entity_index++] = e;
@@ -1189,9 +1199,9 @@ void check_global_collect_entities_from_file(Checker *c, Scope *parent_scope, As
case Token_const: {
if (vs->type != NULL || vs->values.count > 0) {
last = vs;
} else if (last == NULL) {
last = empty_spec;
prev_spec = vs;
} else if (prev_spec == NULL) {
prev_spec = empty_spec;
}
for_array(i, vs->names) {
@@ -1206,36 +1216,42 @@ void check_global_collect_entities_from_file(Checker *c, Scope *parent_scope, As
e->identifier = name;
AstNode *init = NULL;
if (i < last->values.count) {
init = last->values.e[i];
if (i < prev_spec->values.count) {
init = prev_spec->values.e[i];
}
DeclInfo *di = make_declaration_info(c->allocator, e->scope);
di->type_expr = last->type;
di->type_expr = prev_spec->type;
di->init_expr = init;
add_entity_and_decl_info(c, name, e, di);
}
check_arity_match(c, vs, last);
check_arity_match(c, vs, prev_spec);
} break;
}
case_end;
case_ast_node(ts, TypeSpec, spec);
if (ts->name->kind != AstNode_Ident) {
error_node(ts->name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[ts->name->kind]));
continue;
}
ast_node(n, Ident, ts->name);
Entity *e = make_entity_type_name(c->allocator, parent_scope, *n, NULL);
e->identifier = ts->name;
DeclInfo *d = make_declaration_info(c->allocator, e->scope);
d->type_expr = ts->type;
d->init_expr = ts->type;
add_entity_and_decl_info(c, ts->name, e, d);
case_end;
default:
error(ast_node_token(spec), "Invalid specification in declaration: `%.*s`", LIT(ast_node_strings[spec->kind]));
break;
}
}
case_end;
case_ast_node(id, ImportDecl, decl);
if (!parent_scope->is_file) {
// NOTE(bill): _Should_ be caught by the parser
// TODO(bill): Better error handling if it isn't
continue;
}
DelayedDecl di = {parent_scope, decl};
array_add(&c->delayed_imports, di);
case_end;
case_ast_node(fl, ForeignLibrary, decl);
if (!parent_scope->is_file) {
// NOTE(bill): _Should_ be caught by the parser
@@ -1246,20 +1262,6 @@ void check_global_collect_entities_from_file(Checker *c, Scope *parent_scope, As
DelayedDecl di = {parent_scope, decl};
array_add(&c->delayed_foreign_libraries, di);
case_end;
case_ast_node(td, TypeDecl, decl);
if (td->name->kind != AstNode_Ident) {
error_node(td->name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[td->name->kind]));
continue;
}
ast_node(n, Ident, td->name);
Entity *e = make_entity_type_name(c->allocator, parent_scope, *n, NULL);
e->identifier = td->name;
DeclInfo *d = make_declaration_info(c->allocator, e->scope);
d->type_expr = td->type;
d->init_expr = td->type;
add_entity_and_decl_info(c, td->name, e, d);
case_end;
case_ast_node(pd, ProcDecl, decl);
if (pd->name->kind != AstNode_Ident) {
error_node(pd->name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[pd->name->kind]));
@@ -1286,8 +1288,9 @@ void check_global_collect_entities_from_file(Checker *c, Scope *parent_scope, As
void check_import_entities(Checker *c, MapScope *file_scopes) {
for_array(i, c->delayed_imports) {
Scope *parent_scope = c->delayed_imports.e[i].parent;
AstNode *decl = c->delayed_imports.e[i].decl;
ast_node(id, ImportDecl, decl);
AstNode *spec = c->delayed_imports.e[i].decl;
ast_node(id, ImportSpec, spec);
Token token = id->relpath;
HashKey key = hash_string(id->fullpath);
Scope **found = map_scope_get(file_scopes, key);
@@ -1296,13 +1299,13 @@ void check_import_entities(Checker *c, MapScope *file_scopes) {
Scope *scope = file_scopes->entries.e[scope_index].value;
gb_printf_err("%.*s\n", LIT(scope->file->tokenizer.fullpath));
}
gb_printf_err("%.*s(%td:%td)\n", LIT(id->token.pos.file), id->token.pos.line, id->token.pos.column);
gb_printf_err("%.*s(%td:%td)\n", LIT(token.pos.file), token.pos.line, token.pos.column);
GB_PANIC("Unable to find scope for file: %.*s", LIT(id->fullpath));
}
Scope *scope = *found;
if (scope->is_global) {
error(id->token, "Importing a #shared_global_scope is disallowed and unnecessary");
error(token, "Importing a #shared_global_scope is disallowed and unnecessary");
continue;
}
@@ -1332,7 +1335,7 @@ void check_import_entities(Checker *c, MapScope *file_scopes) {
if (!previously_added) {
array_add(&parent_scope->imported, scope);
} else {
warning(id->token, "Multiple #import of the same file within this scope");
warning(token, "Multiple #import of the same file within this scope");
}
if (str_eq(id->import_name.string, str_lit("."))) {
@@ -1381,9 +1384,7 @@ void check_import_entities(Checker *c, MapScope *file_scopes) {
if (is_string_an_identifier(filename)) {
import_name = filename;
} else {
error(id->token,
"File name, %.*s, cannot be as an import name as it is not a valid identifier",
LIT(filename));
error(token, "File name, %.*s, cannot be as an import name as it is not a valid identifier", LIT(filename));
}
}
src/checker/decl.c
+3 -3
View File
@@ -99,7 +99,7 @@ void check_init_variables(Checker *c, Entity **lhs, isize lhs_count, AstNodeArra
}
void check_var_spec_node(Checker *c, AstNodeValueSpec *vs) {
GB_ASSERT(vs->keyword == Token_var);
GB_ASSERT(vs->keyword == Token_var || vs->keyword == Token_let);
isize entity_count = vs->names.count;
isize entity_index = 0;
Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_count);
@@ -116,7 +116,7 @@ void check_var_spec_node(Checker *c, AstNodeValueSpec *vs) {
found = current_scope_lookup_entity(c->context.scope, str);
}
if (found == NULL) {
entity = make_entity_variable(c->allocator, c->context.scope, token, NULL);
entity = make_entity_variable(c->allocator, c->context.scope, token, NULL, vs->keyword == Token_let);
add_entity_definition(&c->info, name, entity);
} else {
TokenPos pos = found->token.pos;
@@ -156,7 +156,7 @@ void check_var_spec_node(Checker *c, AstNodeValueSpec *vs) {
e->type = init_type;
}
check_arity_match(c, vs, NULL);
check_init_variables(c, entities, entity_count, vs->values, str_lit("variable declaration"));
for_array(i, vs->names) {
src/checker/entity.c
+9 -8
View File
@@ -55,9 +55,9 @@ struct Entity {
ExactValue value;
} Constant;
struct {
b32 is_let;
i32 field_index;
i32 field_src_index;
i32 field_index;
i32 field_src_index;
bool is_let;
} Variable;
i32 TypeName;
struct {
@@ -97,8 +97,9 @@ Entity *alloc_entity(gbAllocator a, EntityKind kind, Scope *scope, Token token,
return entity;
}
Entity *make_entity_variable(gbAllocator a, Scope *scope, Token token, Type *type) {
Entity *make_entity_variable(gbAllocator a, Scope *scope, Token token, Type *type, bool is_let) {
Entity *entity = alloc_entity(a, Entity_Variable, scope, token, type);
entity->Variable.is_let = is_let;
return entity;
}
@@ -123,7 +124,7 @@ Entity *make_entity_type_name(gbAllocator a, Scope *scope, Token token, Type *ty
}
Entity *make_entity_param(gbAllocator a, Scope *scope, Token token, Type *type, bool anonymous) {
Entity *entity = make_entity_variable(a, scope, token, type);
Entity *entity = make_entity_variable(a, scope, token, type, false);
entity->flags |= EntityFlag_Used;
entity->flags |= EntityFlag_Anonymous*(anonymous != 0);
entity->flags |= EntityFlag_Param;
@@ -131,7 +132,7 @@ Entity *make_entity_param(gbAllocator a, Scope *scope, Token token, Type *type,
}
Entity *make_entity_field(gbAllocator a, Scope *scope, Token token, Type *type, bool anonymous, i32 field_src_index) {
Entity *entity = make_entity_variable(a, scope, token, type);
Entity *entity = make_entity_variable(a, scope, token, type, false);
entity->Variable.field_src_index = field_src_index;
entity->Variable.field_index = field_src_index;
entity->flags |= EntityFlag_Field;
@@ -140,7 +141,7 @@ Entity *make_entity_field(gbAllocator a, Scope *scope, Token token, Type *type,
}
Entity *make_entity_vector_elem(gbAllocator a, Scope *scope, Token token, Type *type, i32 field_src_index) {
Entity *entity = make_entity_variable(a, scope, token, type);
Entity *entity = make_entity_variable(a, scope, token, type, false);
entity->Variable.field_src_index = field_src_index;
entity->Variable.field_index = field_src_index;
entity->flags |= EntityFlag_Field;
@@ -185,6 +186,6 @@ Entity *make_entity_implicit_value(gbAllocator a, String name, Type *type, Impli
Entity *make_entity_dummy_variable(gbAllocator a, Scope *file_scope, Token token) {
token.string = str_lit("_");
return make_entity_variable(a, file_scope, token, NULL);
return make_entity_variable(a, file_scope, token, NULL, false);
}
src/checker/expr.c
+41 -41
View File
@@ -128,6 +128,44 @@ void check_local_collect_entities(Checker *c, AstNodeArray nodes, DelayedEntitie
} break;
}
case_end;
case_ast_node(ts, TypeSpec, spec);
if (ts->name->kind != AstNode_Ident) {
error_node(ts->name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[ts->name->kind]));
break;
}
Token name_token = ts->name->Ident;
Entity *e = make_entity_type_name(c->allocator, c->context.scope, name_token, NULL);
e->identifier = ts->name;
DeclInfo *d = make_declaration_info(c->allocator, e->scope);
d->type_expr = ts->type;
add_entity_and_decl_info(c, ts->name, e, d);
DelayedEntity delay = {ts->name, e, d};
array_add(delayed_entities, delay);
if (dof != NULL) {
if (str_eq(name_token.string, str_lit("_"))) {
dof->other_fields[dof->other_field_index++] = e;
} else {
HashKey key = hash_string(name_token.string);
if (map_entity_get(dof->entity_map, key) != NULL) {
// TODO(bill): Scope checking already checks the declaration
error(name_token, "`%.*s` is already declared in this record", LIT(name_token.string));
} else {
map_entity_set(dof->entity_map, key, e);
dof->other_fields[dof->other_field_index++] = e;
}
add_entity(c, c->context.scope, ts->name, e);
add_entity_use(c, ts->name, e);
}
}
case_end;
}
}
case_end;
@@ -147,47 +185,6 @@ void check_local_collect_entities(Checker *c, AstNodeArray nodes, DelayedEntitie
check_entity_decl(c, e, d, NULL, NULL);
case_end;
#endif
case_ast_node(td, TypeDecl, node);
if (!ast_node_expect(td->name, AstNode_Ident)) {
break;
}
if (td->name->kind != AstNode_Ident) {
error_node(td->name, "A declaration's name must be an identifier, got %.*s", LIT(ast_node_strings[td->name->kind]));
continue;
}
Token name_token = td->name->Ident;
Entity *e = make_entity_type_name(c->allocator, c->context.scope, name_token, NULL);
e->identifier = td->name;
DeclInfo *d = make_declaration_info(c->allocator, e->scope);
d->type_expr = td->type;
add_entity_and_decl_info(c, td->name, e, d);
DelayedEntity delay = {td->name, e, d};
array_add(delayed_entities, delay);
if (dof != NULL) {
if (str_eq(name_token.string, str_lit("_"))) {
dof->other_fields[dof->other_field_index++] = e;
} else {
HashKey key = hash_string(name_token.string);
if (map_entity_get(dof->entity_map, key) != NULL) {
// TODO(bill): Scope checking already checks the declaration
error(name_token, "`%.*s` is already declared in this record", LIT(name_token.string));
} else {
map_entity_set(dof->entity_map, key, e);
dof->other_fields[dof->other_field_index++] = e;
}
add_entity(c, c->context.scope, td->name, e);
add_entity_use(c, td->name, e);
}
}
case_end;
}
}
@@ -900,6 +897,9 @@ void check_identifier(Checker *c, Operand *o, AstNode *n, Type *named_type) {
}
#else
o->mode = Addressing_Variable;
if (e->Variable.is_let) {
o->mode = Addressing_Value;
}
#endif
break;
src/checker/stmt.c
+22 -8
View File
@@ -21,15 +21,27 @@ void check_stmt_list(Checker *c, AstNodeArray stmts, u32 flags) {
bool ft_ok = (flags & Stmt_FallthroughAllowed) != 0;
u32 f = flags & (~Stmt_FallthroughAllowed);
for_array(i, stmts) {
isize max = stmts.count;
for (isize i = stmts.count-1; i >= 0; i--) {
if (stmts.e[i]->kind != AstNode_EmptyStmt) {
break;
}
max--;
}
for (isize i = 0; i < max; i++) {
AstNode *n = stmts.e[i];
if (n->kind == AstNode_EmptyStmt) {
continue;
}
u32 new_flags = f;
if (ft_ok && i+1 == stmts.count) {
if (ft_ok && i+1 == max) {
new_flags |= Stmt_FallthroughAllowed;
}
if (n->kind == AstNode_ReturnStmt && i+1 < max) {
error_node(n, "Statements after this `return` are never executed");
}
check_stmt(c, n, new_flags);
}
@@ -835,7 +847,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
tt = make_type_pointer(c->allocator, case_type);
add_type_info_type(c, tt);
}
Entity *tag_var = make_entity_variable(c->allocator, c->context.scope, ms->var->Ident, tt);
Entity *tag_var = make_entity_variable(c->allocator, c->context.scope, ms->var->Ident, tt, false);
tag_var->flags |= EntityFlag_Used;
add_entity(c, c->context.scope, ms->var, tag_var);
add_entity_use(c, ms->var, tag_var);
@@ -1078,6 +1090,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
switch (spec->kind) {
case_ast_node(vs, ValueSpec, spec);
switch (vs->keyword) {
case Token_let:
case Token_var: {
isize entity_count = vs->names.count;
isize entity_index = 0;
@@ -1095,7 +1108,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
found = current_scope_lookup_entity(c->context.scope, str);
}
if (found == NULL) {
entity = make_entity_variable(c->allocator, c->context.scope, token, NULL);
entity = make_entity_variable(c->allocator, c->context.scope, token, NULL, vs->keyword == Token_let);
add_entity_definition(&c->info, name, entity);
} else {
TokenPos pos = found->token.pos;
@@ -1146,10 +1159,15 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
} break;
case Token_const:
// NOTE(bill): Handled elsewhere
break;
}
case_end;
case_ast_node(ts, TypeSpec, spec);
// NOTE(bill): Handled elsewhere
case_end;
default:
error(ast_node_token(spec), "Invalid specification in declaration: `%.*s`", LIT(ast_node_strings[spec->kind]));
break;
@@ -1157,10 +1175,6 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
}
case_end;
case_ast_node(td, TypeDecl, node);
// NOTE(bill): Handled elsewhere
case_end;
case_ast_node(pd, ProcDecl, node);
// NOTE(bill): Handled elsewhere
#if 1
src/parser.c
+170 -181
View File
@@ -231,22 +231,29 @@ AST_NODE_KIND(_SpecBegin, "", i32) \
AstNode * type; \
AstNodeArray values; \
}) \
AST_NODE_KIND(TypeSpec, "type specification", struct { \
AstNode *name; \
AstNode *type; \
AstNode *note; \
}) \
AST_NODE_KIND(ImportSpec, "import specification", struct { \
Token relpath; \
String fullpath; \
Token import_name; \
bool is_load; \
AstNode *cond; \
AstNode *note; \
}) \
AST_NODE_KIND(_SpecEnd, "", i32) \
AST_NODE_KIND(_DeclBegin, "", i32) \
AST_NODE_KIND(BadDecl, "bad declaration", struct { Token begin, end; }) \
AST_NODE_KIND(GenericDecl, "generic declaration", struct { \
AST_NODE_KIND(GenericDecl, "declaration", struct { \
Token token; \
Token open, close; \
AstNodeArray specs; \
u64 tags; \
bool is_using; \
}) \
AST_NODE_KIND(TypeDecl, "type declaration", struct { \
Token token; \
AstNode *name; \
AstNode *type; \
AstNode *note; \
}) \
AST_NODE_KIND(ProcDecl, "procedure declaration", struct { \
AstNode *name; \
AstNode *type; \
@@ -256,14 +263,6 @@ AST_NODE_KIND(_DeclBegin, "", i32) \
String link_name; \
AstNode *note; \
}) \
AST_NODE_KIND(ImportDecl, "import declaration", struct { \
Token token, relpath; \
String fullpath; \
Token import_name; \
bool is_load; \
AstNode *cond; \
AstNode *note; \
}) \
AST_NODE_KIND(ForeignLibrary, "foreign library", struct { \
Token token, filepath; \
String base_dir; \
@@ -467,15 +466,16 @@ Token ast_node_token(AstNode *node) {
return node->GenericDecl.token;
case AstNode_ProcDecl:
return ast_node_token(node->ProcDecl.name);
case AstNode_TypeDecl:
return ast_node_token(node->TypeDecl.name);
case AstNode_ImportDecl:
return node->ImportDecl.token;
case AstNode_ForeignLibrary:
return node->ForeignLibrary.token;
case AstNode_ValueSpec:
return ast_node_token(node->ValueSpec.names.e[0]);
case AstNode_TypeSpec:
return ast_node_token(node->TypeSpec.name);
case AstNode_ImportSpec:
return node->ImportSpec.relpath;
case AstNode_Parameter: {
if (node->Parameter.names.count > 0) {
@@ -992,26 +992,6 @@ AstNode *make_enum_type(AstFile *f, Token token, AstNode *base_type, AstNodeArra
return result;
}
AstNode *make_type_decl(AstFile *f, Token token, AstNode *name, AstNode *type) {
AstNode *result = make_node(f, AstNode_TypeDecl);
result->TypeDecl.token = token;
result->TypeDecl.name = name;
result->TypeDecl.type = type;
return result;
}
AstNode *make_import_decl(AstFile *f, Token token, Token relpath, Token import_name,
AstNode *cond,
bool is_load) {
AstNode *result = make_node(f, AstNode_ImportDecl);
result->ImportDecl.token = token;
result->ImportDecl.relpath = relpath;
result->ImportDecl.import_name = import_name;
result->ImportDecl.cond = cond;
result->ImportDecl.is_load = is_load;
return result;
}
AstNode *make_foreign_library(AstFile *f, Token token, Token filepath, AstNode *cond, bool is_system) {
AstNode *result = make_node(f, AstNode_ForeignLibrary);
result->ForeignLibrary.token = token;
@@ -1042,6 +1022,22 @@ AstNode *make_value_spec(AstFile *f, TokenKind keyword, AstNodeArray names, AstN
return result;
}
AstNode *make_type_spec(AstFile *f, AstNode *name, AstNode *type) {
AstNode *result = make_node(f, AstNode_TypeSpec);
result->TypeSpec.name = name;
result->TypeSpec.type = type;
return result;
}
AstNode *make_import_spec(AstFile *f, Token relpath, Token import_name, AstNode *cond, bool is_load) {
AstNode *result = make_node(f, AstNode_ImportSpec);
result->ImportSpec.relpath = relpath;
result->ImportSpec.import_name = import_name;
result->ImportSpec.cond = cond;
result->ImportSpec.is_load = is_load;
return result;
}
bool next_token(AstFile *f) {
@@ -1137,6 +1133,7 @@ void fix_advance_to_next_stmt(AstFile *f) {
return;
case Token_var:
case Token_let:
case Token_const:
case Token_type:
case Token_proc:
@@ -1198,20 +1195,29 @@ void expect_semicolon(AstFile *f, AstNode *s) {
return;
}
if (s != NULL) {
if (s != NULL && prev_token.pos.line != f->curr_token.pos.line) {
switch (s->kind) {
case AstNode_ProcDecl:
return;
case AstNode_TypeDecl:
case AstNode_GenericDecl:
if (s->GenericDecl.close.kind == Token_CloseParen) {
return;
} else if (s->GenericDecl.token.kind == Token_type) {
if (f->prev_token.kind == Token_CloseBrace) {
return;
}
}
break;
case AstNode_TypeSpec:
if (f->prev_token.kind == Token_CloseBrace) {
return;
}
break;
}
syntax_error(prev_token, "Expected `;` after %.*s, got %.*s %d %d",
LIT(ast_node_strings[s->kind]), LIT(token_strings[prev_token.kind]),
Token_Semicolon, prev_token.kind);
syntax_error(prev_token, "Expected `;` after %.*s, got %.*s",
LIT(ast_node_strings[s->kind]), LIT(token_strings[prev_token.kind]));
} else {
syntax_error(prev_token, "Expected `;`");
}
@@ -1853,17 +1859,17 @@ AstNodeArray parse_identfier_list(AstFile *f) {
}
void parse_check_name_list_for_reserves(AstFile *f, AstNodeArray names) {
for_array(i, names) {
AstNode *name = names.e[i];
if (name->kind == AstNode_Ident) {
String n = name->Ident.string;
// NOTE(bill): Check for reserved identifiers
if (str_eq(n, str_lit("context"))) {
syntax_error_node(name, "`context` is a reserved identifier");
break;
}
}
}
// for_array(i, names) {
// AstNode *name = names.e[i];
// if (name->kind == AstNode_Ident) {
// String n = name->Ident.string;
// // NOTE(bill): Check for reserved identifiers
// if (str_eq(n, str_lit("context"))) {
// syntax_error_node(name, "`context` is a reserved identifier");
// break;
// }
// }
// }
}
AstNode *parse_type_attempt(AstFile *f) {
@@ -1933,6 +1939,7 @@ PARSE_SPEC_PROC(parse_value_spec) {
switch (keyword) {
case Token_var:
case Token_let:
if (type == NULL && values.count == 0 && names.count > 0) {
syntax_error(f->curr_token, "Missing type or initialization");
return make_bad_decl(f, f->curr_token, f->curr_token);
@@ -1953,13 +1960,66 @@ PARSE_SPEC_PROC(parse_value_spec) {
return make_value_spec(f, keyword, names, type, values);
}
AstNode *parse_type_decl(AstFile *f) {
Token token = expect_token(f, Token_type);
PARSE_SPEC_PROC(parse_type_spec) {
AstNode *name = parse_identifier(f);
AstNode *type = parse_type(f);
return make_type_decl(f, token, name, type);
return make_type_spec(f, name, type);
}
PARSE_SPEC_PROC(parse_import_spec) {
AstNode *cond = NULL;
Token import_name = {0};
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 (str_eq(import_name.string, str_lit("_"))) {
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 = make_bad_decl(f, import_name, file_path);
} else {
spec = make_import_spec(f, file_path, import_name, cond, false);
}
return spec;
}
PARSE_SPEC_PROC(parse_include_spec) {
AstNode *cond = NULL;
Token file_path = expect_token_after(f, Token_String, "include");
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 `include` within a procedure. This must be done at the file scope");
spec = make_bad_decl(f, import_name, file_path);
} else {
spec = make_import_spec(f, file_path, import_name, cond, true);
}
return spec;
}
AstNode *parse_proc_decl(AstFile *f);
@@ -1967,15 +2027,21 @@ AstNode *parse_proc_decl(AstFile *f);
AstNode *parse_decl(AstFile *f) {
switch (f->curr_token.kind) {
case Token_var:
case Token_let:
case Token_const:
return parse_generic_decl(f, f->curr_token.kind, parse_value_spec);
case Token_type:
return parse_type_decl(f);
return parse_generic_decl(f, f->curr_token.kind, parse_type_spec);
case Token_proc:
return parse_proc_decl(f);
case Token_import:
return parse_generic_decl(f, f->curr_token.kind, parse_import_spec);
case Token_include:
return parse_generic_decl(f, f->curr_token.kind, parse_include_spec);
default: {
Token token = f->curr_token;
syntax_error(token, "Expected a declaration");
@@ -1989,6 +2055,7 @@ AstNode *parse_decl(AstFile *f) {
AstNode *parse_simple_stmt(AstFile *f) {
switch (f->curr_token.kind) {
case Token_var:
case Token_let:
case Token_const:
return parse_decl(f);
}
@@ -2276,41 +2343,6 @@ AstNode *parse_identifier_or_type(AstFile *f) {
return make_raw_union_type(f, token, decls, decl_count);
}
case Token_enum: {
Token token = expect_token(f, Token_enum);
AstNode *base_type = NULL;
Token open, close;
if (f->curr_token.kind != Token_OpenBrace) {
base_type = parse_type(f);
}
AstNodeArray fields = make_ast_node_array(f);
open = expect_token_after(f, Token_OpenBrace, "`enum`");
while (f->curr_token.kind != Token_CloseBrace &&
f->curr_token.kind != Token_EOF) {
AstNode *name = parse_identifier(f);
AstNode *value = NULL;
Token eq = empty_token;
if (f->curr_token.kind == Token_Eq) {
eq = expect_token(f, Token_Eq);
value = parse_value(f);
}
AstNode *field = make_field_value(f, name, value, eq);
array_add(&fields, field);
if (f->curr_token.kind != Token_Comma) {
break;
}
next_token(f);
}
close = expect_token(f, Token_CloseBrace);
return make_enum_type(f, token, base_type, fields);
}
case Token_proc:
return parse_proc_type(f);
@@ -2722,9 +2754,6 @@ AstNode *parse_stmt(AstFile *f) {
Token token = f->curr_token;
switch (token.kind) {
// Operands
case Token_var:
case Token_const:
case Token_Ident:
case Token_Integer:
case Token_Float:
@@ -2740,10 +2769,14 @@ AstNode *parse_stmt(AstFile *f) {
expect_semicolon(f, s);
return s;
case Token_var:
case Token_let:
case Token_const:
case Token_proc:
return parse_proc_decl(f);
case Token_type:
s = parse_type_decl(f);
case Token_import:
case Token_include:
s = parse_decl(f);
expect_semicolon(f, s);
return s;
@@ -2775,12 +2808,16 @@ AstNode *parse_stmt(AstFile *f) {
while (e->kind == AstNode_SelectorExpr) {
e = unparen_expr(e->SelectorExpr.selector);
}
if (e->kind == AstNode_Ident) {
if (e->kind == AstNode_Ident) {
valid = true;
}
} break;
case AstNode_GenericDecl:
valid = node->GenericDecl.token.kind == Token_var;
if (node->GenericDecl.token.kind == Token_var) {
valid = true;
} else if (node->GenericDecl.token.kind == Token_let) {
valid = true;
}
break;
}
@@ -2861,60 +2898,6 @@ AstNode *parse_stmt(AstFile *f) {
}
expect_semicolon(f, s);
return s;
} else if (str_eq(tag, str_lit("import"))) {
AstNode *cond = NULL;
Token import_name = {0};
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 = hash_token.pos;
break;
}
if (str_eq(import_name.string, str_lit("_"))) {
syntax_error(token, "Illegal import name: `_`");
}
Token file_path = expect_token_after(f, Token_String, "#import");
if (allow_token(f, Token_when)) {
cond = parse_expr(f, false);
}
if (f->curr_proc != NULL) {
syntax_error(token, "You cannot use #import within a procedure. This must be done at the file scope");
s = make_bad_decl(f, token, file_path);
} else {
s = make_import_decl(f, hash_token, file_path, import_name, cond, false);
}
expect_semicolon(f, s);
return s;
} else if (str_eq(tag, str_lit("include"))) {
AstNode *cond = NULL;
Token file_path = expect_token(f, Token_String);
Token import_name = file_path;
import_name.string = str_lit(".");
if (allow_token(f, Token_when)) {
cond = parse_expr(f, false);
}
if (f->curr_proc == NULL) {
s = make_import_decl(f, hash_token, file_path, import_name, cond, true);
} else {
syntax_error(token, "You cannot use #include within a procedure. This must be done at the file scope");
s = make_bad_decl(f, token, file_path);
}
expect_semicolon(f, s);
return s;
} else if (str_eq(tag, str_lit("thread_local"))) {
AstNode *decl = parse_simple_stmt(f);
if (decl->kind == AstNode_GenericDecl &&
@@ -3143,35 +3126,41 @@ void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, AstNodeArray
node->kind != 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) {
AstNodeImportDecl *id = &node->ImportDecl;
String file_str = id->relpath.string;
} else if (node->kind == AstNode_GenericDecl) {
AstNodeGenericDecl *gd = &node->GenericDecl;
for_array(spec_index, gd->specs) {
AstNode *spec = gd->specs.e[spec_index];
switch (spec->kind) {
case_ast_node(is, ImportSpec, spec);
String file_str = is->relpath.string;
if (!is_import_path_valid(file_str)) {
if (id->is_load) {
syntax_error_node(node, "Invalid #include path: `%.*s`", LIT(file_str));
} else {
syntax_error_node(node, "Invalid #import path: `%.*s`", LIT(file_str));
}
// NOTE(bill): It's a naughty name
decls.e[i] = make_bad_decl(f, id->token, id->token);
continue;
}
if (!is_import_path_valid(file_str)) {
if (is->is_load) {
syntax_error_node(node, "Invalid #include path: `%.*s`", LIT(file_str));
} else {
syntax_error_node(node, "Invalid #import path: `%.*s`", LIT(file_str));
}
// NOTE(bill): It's a naughty name
gd->specs.e[spec_index] = make_bad_decl(f, is->relpath, is->relpath);
continue;
}
gbAllocator allocator = heap_allocator(); // TODO(bill): Change this allocator
gbAllocator allocator = heap_allocator(); // TODO(bill): Change this allocator
String rel_path = get_fullpath_relative(allocator, base_dir, file_str);
String 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;
String rel_path = get_fullpath_relative(allocator, base_dir, file_str);
String 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;
}
}
is->fullpath = import_file;
try_add_import_path(p, import_file, file_str, ast_node_token(node).pos);
case_end;
}
}
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;
src/ssa.c
+25 -23
View File
@@ -1233,7 +1233,8 @@ ssaValue *ssa_add_local_generated(ssaProcedure *proc, Type *type) {
Entity *e = make_entity_variable(proc->module->allocator,
scope,
empty_token,
type);
type,
false);
return ssa_add_local(proc, e);
}
@@ -2603,6 +2604,8 @@ ssaValue *ssa_build_single_expr(ssaProcedure *proc, AstNode *expr, TypeAndValue
// return v;
// }
return ssa_emit_load(proc, v);
} else if (e != NULL && e->kind == Entity_Variable) {
return ssa_addr_load(proc, ssa_build_addr(proc, expr));
}
return NULL;
case_end;
@@ -3854,6 +3857,7 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) {
switch (vs->keyword) {
case Token_const:
break;
case Token_let:
case Token_var: {
ssaModule *m = proc->module;
gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&m->tmp_arena);
@@ -3910,6 +3914,24 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) {
} break;
}
case_end;
case_ast_node(ts, TypeSpec, spec);
// NOTE(bill): Generate a new name
// parent_proc.name-guid
String ts_name = ts->name->Ident.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);
Entity **found = map_entity_get(&proc->module->info->definitions, hash_pointer(ts->name));
GB_ASSERT(found != NULL);
Entity *e = *found;
ssaValue *value = ssa_make_value_type_name(proc->module->allocator,
name, e->type);
map_string_set(&proc->module->type_names, hash_pointer(e->type), name);
ssa_gen_global_type_name(proc->module, e, name);
case_end;
}
}
case_end;
@@ -3987,26 +4009,6 @@ void ssa_build_stmt_internal(ssaProcedure *proc, AstNode *node) {
}
case_end;
case_ast_node(td, TypeDecl, node);
// NOTE(bill): Generate a new name
// parent_proc.name-guid
String td_name = td->name->Ident.string;
isize name_len = proc->name.len + 1 + td_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(td_name), guid);
String name = make_string(name_text, name_len-1);
Entity **found = map_entity_get(&proc->module->info->definitions, hash_pointer(td->name));
GB_ASSERT(found != NULL);
Entity *e = *found;
ssaValue *value = ssa_make_value_type_name(proc->module->allocator,
name, e->type);
map_string_set(&proc->module->type_names, hash_pointer(e->type), name);
ssa_gen_global_type_name(proc->module, e, name);
case_end;
case_ast_node(ids, IncDecStmt, node);
ssa_emit_comment(proc, str_lit("IncDecStmt"));
TokenKind op = ids->op.kind;
@@ -4705,7 +4707,7 @@ void ssa_init_module(ssaModule *m, Checker *c, BuildContext *build_context) {
{
String name = str_lit(SSA_TYPE_INFO_DATA_NAME);
isize count = c->info.type_info_map.entries.count;
Entity *e = make_entity_variable(m->allocator, NULL, make_token_ident(name), make_type_array(m->allocator, t_type_info, count));
Entity *e = make_entity_variable(m->allocator, NULL, make_token_ident(name), make_type_array(m->allocator, t_type_info, count), false);
ssaValue *g = ssa_make_value_global(m->allocator, e, NULL);
g->Global.is_private = true;
ssa_module_add_value(m, e, g);
@@ -4737,7 +4739,7 @@ void ssa_init_module(ssaModule *m, Checker *c, BuildContext *build_context) {
String name = str_lit(SSA_TYPE_INFO_DATA_MEMBER_NAME);
Entity *e = make_entity_variable(m->allocator, NULL, make_token_ident(name),
make_type_array(m->allocator, t_type_info_member, count));
make_type_array(m->allocator, t_type_info_member, count), false);
ssaValue *g = ssa_make_value_global(m->allocator, e, NULL);
ssa_module_add_value(m, e, g);
map_ssa_value_set(&m->members, hash_string(name), g);
src/tokenizer.c
+3 -3
View File
@@ -85,9 +85,10 @@ TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
TOKEN_KIND(Token_type, "type"), \
TOKEN_KIND(Token_proc, "proc"), \
TOKEN_KIND(Token_var, "var"), \
TOKEN_KIND(Token_let, "let"), \
TOKEN_KIND(Token_const, "const"), \
/* TOKEN_KIND(Token_import, "import"), */\
/* TOKEN_KIND(Token_include, "include"), */\
TOKEN_KIND(Token_import, "import"), \
TOKEN_KIND(Token_include, "include"), \
TOKEN_KIND(Token_macro, "macro"), \
TOKEN_KIND(Token_match, "match"), \
TOKEN_KIND(Token_break, "break"), \
@@ -106,7 +107,6 @@ TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
TOKEN_KIND(Token_struct, "struct"), \
TOKEN_KIND(Token_union, "union"), \
TOKEN_KIND(Token_raw_union, "raw_union"), \
TOKEN_KIND(Token_enum, "enum"), \
TOKEN_KIND(Token_vector, "vector"), \
TOKEN_KIND(Token_using, "using"), \
TOKEN_KIND(Token_asm, "asm"), \