break;
}
- if (parse_possible_directive(parser, "import")) {
- // :LinearTokenDependent
- parse_import_statement(parser, parser->curr - 2);
- needs_semicolon = 0;
- break;
- }
-
if (next_tokens_are(parser, 2, '#', Token_Type_Symbol)) {
retval = (AstNode *) parse_factor(parser);
break;
expect_token(parser, Token_Type_Literal_String);
return;
}
- else if (parse_possible_directive(parser, "import")) {
- parse_import_statement(parser, dir_token);
- return;
- }
else {
OnyxToken* directive_token = expect_token(parser, '#');
OnyxToken* symbol_token = parser->curr;
package_node->type_node = builtin_package_id_type;
package_node->token = token;
+ if (peek_token(0)->type == Token_Type_Keyword_Package) {
+ package_node->token = expect_token(parser, Token_Type_Keyword_Package);
+ }
+
if (!parse_package_name(parser, package_node)) return;
AstImport *import_node = make_node(AstImport, Ast_Kind_Import);
package core.alloc.arena
-#import core
+use core
// This allocator is mostly used for making many fixed-size
// allocation (i.e. allocations that will not need to change
// is not needed for the general purpose heap allocator,
// as that already has a thread-safe implementation.
-#import core.sync
+use core.sync
AtomicAllocator :: struct {
a: Allocator;
package core.alloc.fixed
-#import core
+use core
// This allocator is very simple and always returns the same pointer,
// unless too much memory is asked for, in which case it returns null.
// // Every allocation here will automatically be freed
// }
-#import core
+use core
GCState :: struct {
backing_allocator: Allocator;
package core.alloc.heap
-#import runtime
-#import core
+use runtime
+use core
// This is the implementation for the general purpose heap allocator.
// prints every allocation/deallocation made by that
// allocator.
-#import core
+use core
#local
Allocation_Action_Strings := str.[
package core.alloc.pool
-#import core
+use core
// A pool allocator is an O(1) allocator that is capable of allocating and freeing.
// It is able to do both in constant time because it maintains a linked list of all
package core.alloc.ring
-#import core
+use core
// This allocator is great for temporary memory, such as returning
// a pointer from a function, or storing a formatted string. The
package builtin
-#import runtime
+use runtime
//
// Explanation of `package builtin`
package core.array
-#import core
+use core
// [..] T == Array(T)
// where
package core.avl_tree
-#import core
-#import core.math
+use core
+use core.math
AVL_Tree :: struct (T: type_expr) {
data: T;
package core.bucket_array
-#import core
-#import core.array
-#import core.iter
+use core
+use core.array
+use core.iter
Bucket_Array :: struct (T: type_expr) {
allocator : Allocator;
package core.heap
-#import core.array
+use core.array
Heap :: struct (T: type_expr) {
data: [..] T;
package core.iter
-#import core
-#import core.memory
-#import core.alloc
-#import core.array
-#import runtime
+use core
+use core.memory
+use core.alloc
+use core.array
+use runtime
use core {Pair}
use core.intrinsics.types {type_is_struct}
package core.list
-#import core
+use core
ListElem :: struct (T: type_expr) {
next: &ListElem(T) = null;
package core.map
-#import core
-#import core.array
-#import core.hash
-#import core.memory
-#import core.math
-#import core.conv
+use core
+use core.array
+use core.hash
+use core.memory
+use core.math
+use core.conv
use core {Optional}
use core.intrinsics.onyx { __initialize }
// helper methods that make it easier to work with Results.
//
-#import core
-#import core.conv
+use core
+use core.conv
use core {Optional}
package core.set
-#import core
-#import core.array
-#import core.hash
-#import core.memory
-#import core.math
+use core
+use core.array
+use core.hash
+use core.memory
+use core.math
use core {Optional}
Enable_Custom_Formatters :: true
-#import core.string
-#import core.math
+use core.string
+use core.math
//
// Converts a string into an integer. Works with positive and
package core.conv
-#import core.map
-#import core.string
-#import core.array
-#import core.math
-#import runtime
+use core.map
+use core.string
+use core.array
+use core.math
+use runtime
//
// Parses many different types from a string into a value.
package core.encoding.base64
-#import core.array
+use core.array
//
// A simple Base64 encoding and decoding library. Currently
// it ergonomic to work with.
//
-#import core
-#import core.string
-#import core.array
-#import core.iter
-#import core.conv
-#import core.io
-#import core.test
-#import runtime
+use core
+use core.string
+use core.array
+use core.iter
+use core.conv
+use core.io
+use core.test
+use runtime
use core.misc {any_as}
use runtime.info {
// display_name=Player
//
-#import core.alloc
-#import core.conv
-#import core.string
-#import core.io
+use core.alloc
+use core.conv
+use core.string
+use core.io
use core { aprintf }
use core.intrinsics.types { type_is_struct }
package core.encoding.utf8
-#import core.string
-#import core.array
-#import core.iter
+use core.string
+use core.array
+use core.iter
rune :: i32
package core.intrinsics.atomics
#local {
- #import runtime
+ use runtime
#if !runtime.Multi_Threading_Enabled {
#error "Multi-threading is not enabled so you cannot include the 'core.intrinsics.atomics' package."
package core.io
-#import core.memory
+use core.memory
BinaryWriter :: struct {
// reader could not, like 'read the next line',
// or 'read until a period'.
-#import core.memory
-#import core.math
-#import core.array
-#import core.iter
+use core.memory
+use core.math
+use core.array
+use core.iter
Reader :: struct {
stream: &Stream;
// in anyway.
package core
-#import runtime
+use runtime
//
package core.io
-#import core.conv
-#import core.string
-#import core.memory
+use core.conv
+use core.string
+use core.memory
// io.Writer is a buffered-writer. The important thing to not forget
// when using io.Writer is that it has to be flushed when you are done
package core.misc
-#import runtime
-#import core.iter
-#import core.array
-#import core.string
+use runtime
+use core.iter
+use core.array
+use core.string
use runtime.info {
get_type_info,
#error "Cannot include this file. Platform not supported.";
}
-#import core.sync
-#import core.thread
-#import core.array
-#import core.memory
-#import core.alloc
-#import core.os
-#import core.iter
-#import runtime
+use core.sync
+use core.thread
+use core.array
+use core.memory
+use core.alloc
+use core.os
+use core.iter
+use runtime
#if !runtime.Multi_Threading_Enabled {
#error "Expected multi-threading to be enabled for TCP server.";
#if #defined (runtime.Generated_Foreign_Info) {
-#import core
-#import runtime
+use core
+use runtime
#if runtime.compiler_os == .Linux {
#if #defined (runtime.vars.CC) {
// to the same idea as 'null' in Onyx.
if this.data == 0 do return null;
- #import core.intrinsics.wasm
+ use core.intrinsics.wasm
// Using 1 instead of 0 because a null pointer (0) converts
// to the memory address 0, not the base address for the WASM
// memory.
#error "Cannot include this file. Platform not supported.";
}
-#import core.string
-#import runtime
+use core.string
+use runtime
#local fs :: runtime.platform
package core.os
-#import runtime
+use runtime
#if !runtime.platform.Supports_Os {
#error "Cannot include this file. Platform not supported.";
#error "Cannot include this file. Platform not supported.";
}
-#import core.io
-#import runtime
+use core.io
+use runtime
use runtime.platform {
__process_spawn,
package core.random
-#import core
+use core
//
// The state of a random number generator.
// Returns a random string of length `bytes_long`. If `alpha_numeric` is
// true, then the string will only consist of alpha-numeric characters.
string :: (self: &Random, bytes_long: u32, alpha_numeric := false, allocator := context.allocator) -> str {
- #import core.memory
+ use core.memory
s := memory.make_slice(u8, bytes_long, allocator=allocator);
for& s {
package runtime.info
-#import core
-#import core.io
+use core
+use core.io
write_type_name :: (writer: &io.Writer, t: type_expr) {
info := get_type_info(t);
}
for_all_types :: macro (body: Code) {
- #import runtime
+ use runtime
for runtime.info.type_table.count {
type_info := runtime.info.type_table[it];
package runtime.info
-#import core.array
+use core.array
tagged_procedures: [] &Tagged_Procedure
package runtime.platform
-#import core {*}
+use core {*}
FileData :: #distinct i64
DirectoryData :: #distinct u64
package core.env
-#import runtime
-#import core.map
-#import core.memory
-#import core.string
-#import wasi
+use runtime
+use core.map
+use core.memory
+use core.string
+use wasi
#if runtime.runtime != .Wasi
#load "./wasi_defs"
#load "./wasi_fs"
-#import core
-#import wasi
-#import runtime
+use core
+use wasi
+use runtime
use core
use wasi {
package runtime.platform
-#import runtime
-#import core
-#import wasi
+use runtime
+use core
+use wasi
use core
package core
-#import runtime
+use runtime
#load "./alloc/alloc"
package core.string
-#import core.math
+use core.math
String_Buffer :: struct {
data : [&] u8;
//
to_dyn_str :: (x: str, allocator := context.allocator) -> dyn_str {
- #import core.array
+ use core.array
return array.make(x, allocator);
}
delete :: macro (x: &dyn_str, idx: u32) -> u8 {
- #import core.array
+ use core.array
return array.delete(x, idx);
}
append :: #match {
macro (x: &dyn_str, other: str) {
- #import core.array
+ use core.array
array.concat(x, other);
},
macro (x: &dyn_str, other: u8) {
- #import core.array
+ use core.array
array.push(x, other);
},
}
clear :: macro (x: &dyn_str) {
- #import core.array
+ use core.array
array.clear(x);
}
retreat :: macro (x: &dyn_str, chars := 1) {
- #import core.array
+ use core.array
array.pop(x, chars);
}
insert :: #match #locked {
macro (x: &dyn_str, idx: u32, new_str: str) -> bool {
- #import core.array
+ use core.array
return array.insert(x, idx, new_str);
},
macro (x: &dyn_str, idx: u32, ch: u8) -> bool {
- #import core.array
+ use core.array
return array.insert(x, idx, ch);
}
}
package core.string
-#import core.alloc
-#import core.alloc.arena
-#import core.memory
+use core.alloc
+use core.alloc.arena
+use core.memory
//
// Many times, storing strings is annoying because you need
package core.sync
-#import runtime
-#import core
+use runtime
+use core
use core.intrinsics.atomics
package core.test
-#import core
-#import core.array
-#import core.string
-#import runtime
+use core
+use core.array
+use core.string
+use runtime
use core {printf}
package core.time
-#import core
-#import core.os
-#import core.conv
-#import runtime
+use core
+use core.os
+use core.conv
+use runtime
use runtime.platform {
__time_gmtime,
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
// The following declares a fixed-size array of 10 i32s on the stack. Currently,
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
// A dummy array to demonstrate.
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
// Declaring dynamic arrays in Onyx looks like this. The
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
// To declare a simple, use the enum keyword.
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
x := 10 + 3 * 5;
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
// Onyx does not have map type built into the language semantics,
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
// Here are the uses of 'use' currently.
// is a subpackage of 'core' and the above 'use core' makes this package
// available for you to write code like 'string.equal(...)'. However, because it is
// a namespace, you can 'use' it.
- use string
+ use core.string
s := " Some string ...";
t := strip_leading_whitespace(s); // This would have to be 'string.strip_leading_whitespace' otherwise.
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
// See the overloaded procedure defined below.
Person :: struct { name: str; age: i32; }
// The overload option for hashing a person:
-#match (package core).hash.to_u32 (use p: Person) -> u32 {
+#match hash.to_u32 (use p: Person) -> u32 {
return hash.to_u32(name) * 16239563 + age;
}
#load "core/std"
-#import core
-use core
+use core {*}
main :: (args: [] cstr) {
}
#load "core/std"
-#import core
use core { println }
main :: (args: [] cstr) {
#load "core/std"
-#import core
-use core
+use core {*}
// Operator overloading allows you to define what it means to perform
// a binary operation between two types. In Onyx, they are defined in
}
#load "core/std"
-#import core
-use core
+use core {*}
}
#load "core/std"
-#import core
-use core
+use core {*}
}
#load "core/std"
-#import core
-use core
+use core {*}
}
#load "core/std"
-#import core
-use core
+use core {*}
}
#load "core/std"
-#import core
-use core
-use core.intrinsics.onyx
+use core {*}
+use core.intrinsics.onyx {*}
}
#load "core/std"
-#import core
-use core
+use core {*}
#load "core/std"
-#import core
-#import core.io
-#import core.array
+use core
+use core.io
+use core.array
use core {printf}
main :: (args: [] cstr) {
#load "core/std"
-#import core {*}
+use core {*}
count_ending_paths :: (nums: [..] u32) -> u64 {
tally := array.make(u64, nums.count);
#load "core/std"
-#import core {*}
+use core {*}
Ship :: struct {
x : i32 = 0;
#load "core/std"
-#import core {*}
+use core {*}
inv_mod :: (a_: i64, m_: i64) -> i64 {
if m_ <= 1 do return 0;
#load "core/std"
-#import core {*}
+use core {*}
MASK_SIZE :: 36
Bitmask :: [MASK_SIZE] u8;
#load "core/std"
-#import core {*}
+use core {*}
initial_numbers := u32.[ 1, 20, 8, 12, 0, 14 ];
#load "core/std"
-#import core {*}
+use core {*}
Field :: struct {
name : str = "";
#load "core/std"
-#import core {*}
+use core {*}
parse_factor :: (file: &str) -> u64 {
string.strip_leading_whitespace(file);
#load "core/std"
-#import core {*}
+use core {*}
// nt -> t
Term :: struct {
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
contents := #file_contents "./tests/aoc-2020/input/day2.txt";
#load "core/std"
-#import core {*}
+use core {*}
TILE_DATA_WIDTH :: 10
TILE_DATA_HEIGHT :: 10
#load "core/std"
-#import core {*}
+use core {*}
/*
What questions the data layout needs to answer easily:
#load "core/std"
-#import core {*}
+use core {*}
key_arena : alloc.arena.ArenaState;
key_alloc : Allocator;
#load "core/std"
-#import core {*}
+use core {*}
cups : [..] i32;
#load "core/std"
-#import core {*}
+use core {*}
Vec2 :: struct {
x: i32 = 0;
#load "core/std"
-#import core {*}
+use core {*}
power_mod :: (base: u32, exp: u32, mod: u32) -> u32 {
t: u64 = 1;
#load "core/std"
-#import core {*}
+use core {*}
Point :: struct {
x, y : i32;
#load "core/std"
-#import core {*}
+use core {*}
// Returns the number of fields
process_passport :: (contents: &str) -> u32 {
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
contents := #file_contents "./tests/aoc-2020/input/day5.txt";
#load "core/std"
-#import core {*}
+use core {*}
part_1 :: (contents: &str) -> u32 {
chars : [26] bool;
#load "core/std"
-#import core {*}
+use core {*}
BagGraph :: struct {
nodes : [..] &BagNode;
#load "core/std"
-#import core {*}
+use core {*}
OpCode :: enum (u16) {
Nop; Acc; Jmp;
#load "core/std"
-#import core {*}
+use core {*}
find_contiguous_subarray_with_sum :: (nums: [..] u64, sum: u64) -> (i32, i32) {
start := 0;
#load "core/std"
-#import core.io
-#import core.os
-#import core {printf}
+use core.io
+use core.os
+use core {printf}
count_increasing :: (arr: [] $T) -> u32 {
increased_count := 0;
PART :: 2
-#import core {*}
+use core {*}
main :: (args) => {
for file: os.with_file("tests/aoc-2021/input/day02.txt") {
#load "core/std"
-#import core {*}
+use core {*}
read_binary :: (r: &io.Reader) -> i32 {
n := 0;
#load "core/std"
-#import core {*}
+use core {*}
Cell :: u8
#load "core/std"
-#import core {*}
+use core {*}
Line :: struct {
x1, y1: i32;
#load "core/std"
-#import core {*}
+use core {*}
main :: (args) => {
for file: os.with_file("./tests/aoc-2021/input/day06.txt") {
#load "core/std"
-#import core {*}
+use core {*}
main :: (args) => {
for file: os.with_file("./tests/aoc-2021/input/day07.txt") {
PART :: 2
#load "core/std"
-#import core {*}
+use core {*}
// Encoded segments
//
#load "core/std"
-#import core {*}
+use core {*}
Pos :: struct {x,y: i32;}
#match hash.to_u32 (use p: Pos) => x * 13 & 17 * y;
#load "core/std"
-#import core {*}
+use core {*}
main :: (args) => {
for file: os.with_file("./tests/aoc-2021/input/day10.txt") {
#load "core/std"
-#import core {*}
+use core {*}
Pos :: struct {x, y:i32;}
#match hash.to_u32 (use p: Pos) => x * 45238271 + y * 34725643;
#load "core/std"
-#import core {*}
+use core {*}
Communative_Pair :: struct (T: type_expr) where hash.Hashable(T) {
a, b: T;
#load "core/std"
-#import core {*}
+use core {*}
Point :: struct {
x, y: i32;
#load "core/std"
-#import core {*}
+use core {*}
Rule :: struct {
pair: Pair(u8, u8);
#load "core/std"
-#import core {*}
+use core {*}
queued :: struct { x, y: i32; cost: i32; };
#operator == (u1, u2: queued) => u1.x == u2.x && u1.y == u2.y;
#load "core/std"
-#import core {*}
+use core {*}
base16_to_hex :: (s: str) -> u32 {
res := 0;
#load "core/std"
-#import core {*}
+use core {*}
tx0: i32
ty0: i32
#load "core/std"
-#import core {*}
+use core {*}
Vec2 :: struct { x: i32; y: i32; }
#load "core/std"
-#import core
-#import core.conv
+use core
+use core.conv
use core {println}
#load "core/std"
#load "core/intrinsics/atomics"
-#import core {*}
-#import core.intrinsics.atomics {*}
+use core {*}
+use core.intrinsics.atomics {*}
Shared_Data :: struct {
arr: [] i32;
#load "core/std"
-#import core {*}
+use core {*}
dumb :: (it: Iterator, m: &Map) {
println(it.Iter_Type);
#load "core/std"
-#import core {*}
+use core {*}
main :: () {
tree: &avl_tree.AVL_Tree(i32);
#load "core/std"
-#import core {*}
+use core {*}
count_to :: ($N: i32) {
for i: 0 .. N do printf("{} ", i);
#load "core/std"
-#import core {*}
+use core {*}
Foo :: struct {
x, y: i32;
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
ba := bucket_array.make(i32, 4);
#load "core/std"
-#import core {*}
+use core {*}
S :: struct {
some_array: [..] struct {
#load "core/std"
-#import core {*}
+use core {*}
test_macro :: macro () {
defer {
#load "core/std"
-#import core {*}
+use core {*}
custom_iterator :: () -> Iterator(i32) {
#load "core/std"
-#import core {*}
+use core {*}
Point :: struct { x, y: i32; }
#load "core/std"
-#import core {*}
+use core {*}
SomeNamespace :: struct {
foo :: () {
-#import core
+use core
use core {printf}
main :: () {
#load "core/std"
-#import core {*}
+use core {*}
using_callsite :: (value: $T, site := #callsite) {
println(value);
}
}
-#import runtime
+use runtime
#load "core/std"
-#import core {*}
+use core {*}
Test_VTable :: struct {
first : (i32) -> i32;
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
baked_proc :: (x: $T, $func: (T) -> typeof x) -> T {
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
defer println("At the end!");
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
println(#defined(stdio));
-#import core.string
-#import core.conv
-#import core
+use core.string
+use core.conv
+use core
use core {
println
-#import core
+use core
use core {println}
foo :: (x: ?i32) -> i32 {
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
imap : Map(i32, str);
#load "core/std"
-#import core {*}
+use core {*}
main :: (args) => {
{
#load "core/std"
-#import core {*}
+use core {*}
first_init :: #init #after second_init () {
println("In an #init proc.");
#load "core/std"
-#import core
-#import core.hash
-#import core.conv
-#import core.array
-#import core.iter
+use core
+use core.hash
+use core.conv
+use core.array
+use core.iter
use core {println, printf}
#load "core/std"
-#import core {*}
+use core {*}
count_iterator :: (lo: $T, hi: T, step: T = 1) -> Iterator(T) {
return iter.generator(
-#import core
-#import core.list
+use core
+use core.list
use core {println}
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
foo :: (x: i32, y: f32) {
#load "core/std"
-#import core {printf, map}
+use core {printf, map}
main :: (args: [] cstr) {
printf("{} {} {{}} {} {.1} {.5} {}\n", 123, "Test", false, 12.34, 12.3456789, [..] map.Map(i32, str));
#load "core/std"
-#import core {*}
+use core {*}
Vec3 :: struct {
#load "core/std"
-#import core {*}
+use core {*}
Complex :: struct {
re : f32 = 0;
-#import core
-#import core.encoding.osad
+use core
+use core.encoding.osad
use core {printf}
#load "core/std"
-#import core {*}
+use core {*}
overloaded :: #match {
#order 10 (x: i32) { println("Option X"); },
-#import core
+use core
use core { println }
main :: () {
#load "core/std"
-#import core
+use core
use core {println}
overloaded :: #match {
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
#load "core/std"
-#import core {*}
-#import runtime.info
+use core {*}
+use runtime.info
Base :: struct (T: type_expr) {
const: i32;
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
NewPolyStruct :: struct (T: type_expr, N: i32) {
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
arr := u32.[ 1, 2, 3, 4, 5 ];
#load "core/std"
-#import core {*}
+use core {*}
main :: (args) => {
x: [..] i32;
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
-#import core
-#import core.encoding.base64
+use core
+use core.encoding.base64
decode_test :: () {
for .[
#load "core/std"
-#import core
-#import core.io
+use core
+use core.io
use core {println}
main :: (args: [] cstr) {
#load "core/std"
-#import core {*}
+use core {*}
main :: (args: [] cstr) {
#load "core/std"
-#import core {*}
+use core {*}
Person_Vtable :: struct {
greet: (&Person) -> void;
#load "core/std"
-#import core {*}
+use core {*}
Vector2 :: struct { x, y: i32; }
#operator == macro (v1: Vector2, v2: Vector2) => v1.x == v2.x && v1.y == v2.y;
-#import core
-#import core.encoding.utf8
-#import runtime
+use core
+use core.encoding.utf8
+use runtime
use core {print, println, printf}
#load "core/std"
-#import core {*};
+use core {*};
old_va_test :: (prefix: str, va: ..i32) {
println(prefix);
projects / onyx.git / commitdiff