First working compile of refactor to add explicit typing to declarations
and support untyped empty collections and `none`s
This commit is contained in:
parent
fadcb45baf
commit
0b8074154e
@ -18,7 +18,7 @@ you want to have an empty array, you must specify what type goes inside the arra
|
||||
like this:
|
||||
|
||||
```tomo
|
||||
empty := [:Int]
|
||||
empty : [Int] = []
|
||||
```
|
||||
|
||||
For type annotations, an array that holds items with type `T` is written as `[T]`.
|
||||
|
||||
@ -82,7 +82,7 @@ func _add(x, y:Int -> Int):
|
||||
return x + y
|
||||
|
||||
struct add_args(x,y:Int)
|
||||
add_cache := @{:add_args,Int}
|
||||
add_cache : @{add_args=Int} = @{}
|
||||
|
||||
func add(x, y:Int -> Int):
|
||||
args := add_args(x, y)
|
||||
|
||||
@ -361,7 +361,7 @@ An iterator function that counts onward from the starting integer.
|
||||
|
||||
**Example:**
|
||||
```tomo
|
||||
nums := &[:Int]
|
||||
nums : &[Int] = &[]
|
||||
for i in 5:onward():
|
||||
nums:insert(i)
|
||||
stop if i == 10
|
||||
|
||||
@ -75,7 +75,7 @@ first option is to not account for it, in which case you'll get a runtime error
|
||||
if you use a reducer on something that has no values:
|
||||
|
||||
```tomo
|
||||
>> nums := [:Int]
|
||||
>> nums : [Int] = []
|
||||
>> (+: nums)!
|
||||
|
||||
Error: this collection was empty!
|
||||
|
||||
@ -18,7 +18,7 @@ a runtime check and error if there's a null value, or you can use `or` to
|
||||
provide a fallback value:
|
||||
|
||||
```tomo
|
||||
nums := [:Int]
|
||||
nums : [Int] = []
|
||||
sum := (+: nums)
|
||||
|
||||
>> sum
|
||||
|
||||
@ -21,7 +21,7 @@ nums := {10, 20, 30}
|
||||
Empty sets must specify the item type explicitly:
|
||||
|
||||
```tomo
|
||||
empty := {:Int}
|
||||
empty : {Int} = {}
|
||||
```
|
||||
|
||||
For type annotations, a set that holds items with type `T` is written as `{T}`.
|
||||
|
||||
@ -17,7 +17,7 @@ table := {"A"=10, "B"=20}
|
||||
Empty tables must specify the key and value types explicitly:
|
||||
|
||||
```tomo
|
||||
empty := {:Text=Int}
|
||||
empty : {Text=Int} = {}
|
||||
```
|
||||
|
||||
For type annotations, a table that maps keys with type `K` to values of type
|
||||
|
||||
@ -24,7 +24,7 @@ lang Colorful:
|
||||
say(c:for_terminal(), newline=newline)
|
||||
|
||||
|
||||
func main(texts:[Text], files=[:Path], by_line=no):
|
||||
func main(texts:[Text], files:[Path]=[], by_line=no):
|
||||
for i,text in texts:
|
||||
colorful := Colorful.from_text(text)
|
||||
colorful:print(newline=no)
|
||||
@ -141,7 +141,7 @@ struct _TermState(
|
||||
):
|
||||
|
||||
func apply(old,new:_TermState -> Text):
|
||||
sequences := &[:Text]
|
||||
sequences : &[Text] = &[]
|
||||
_toggle2(sequences, old.bold, old.dim, new.bold, new.dim, "1", "2", "22")
|
||||
_toggle2(sequences, old.italic, old.fraktur, new.italic, new.fraktur, "3", "20", "23")
|
||||
_toggle(sequences, old.underline, new.underline, "4", "24")
|
||||
|
||||
@ -46,16 +46,16 @@ struct ProgramResult(stdout:[Byte], stderr:[Byte], exit_type:ExitType):
|
||||
else:
|
||||
return no
|
||||
|
||||
struct Command(command:Text, args=[:Text], env={:Text=Text}):
|
||||
func from_path(path:Path, args=[:Text], env={:Text=Text} -> Command):
|
||||
struct Command(command:Text, args:[Text]=[], env:{Text=Text}={}):
|
||||
func from_path(path:Path, args:[Text]=[], env:{Text=Text}={} -> Command):
|
||||
return Command(Text(path), args, env)
|
||||
|
||||
func result(command:Command, input="", input_bytes=[:Byte] -> ProgramResult):
|
||||
func result(command:Command, input="", input_bytes:[Byte]=[] -> ProgramResult):
|
||||
if input.length > 0:
|
||||
(&input_bytes):insert_all(input:bytes())
|
||||
|
||||
stdout := [:Byte]
|
||||
stderr := [:Byte]
|
||||
stdout : [Byte] = []
|
||||
stderr : [Byte] = []
|
||||
status := run_command(command.command, command.args, command.env, input_bytes, &stdout, &stderr)
|
||||
|
||||
if inline C : Bool { WIFEXITED(_$status) }:
|
||||
@ -80,7 +80,7 @@ struct Command(command:Text, args=[:Text], env={:Text=Text}):
|
||||
func get_output(command:Command, input="", trim_newline=yes -> Text?):
|
||||
return command:result(input=input):output_text(trim_newline=trim_newline)
|
||||
|
||||
func get_output_bytes(command:Command, input="", input_bytes=[:Byte] -> [Byte]?):
|
||||
func get_output_bytes(command:Command, input="", input_bytes:[Byte]=[] -> [Byte]?):
|
||||
result := command:result(input=input, input_bytes=input_bytes)
|
||||
when result.exit_type is Exited(status):
|
||||
if status == 0: return result.stdout
|
||||
|
||||
@ -10,7 +10,7 @@ func main(map=(./map.txt)):
|
||||
world := @World(
|
||||
player=@Player(Vector2(0,0), Vector2(0,0)),
|
||||
goal=@Box(Vector2(0,0), Vector2(50,50), color=Color(0x10,0xa0,0x10)),
|
||||
boxes=@[:@Box],
|
||||
boxes=@[],
|
||||
)
|
||||
world:load_map(map_contents)
|
||||
|
||||
|
||||
@ -70,7 +70,7 @@ struct World(player:@Player, goal:@Box, boxes:@[@Box], dt_accum=Num32(0.0), won=
|
||||
func load_map(w:@World, map:Text):
|
||||
if map:has("[]"):
|
||||
map = map:translate({"[]"="#", "@ "="@", " "=" "})
|
||||
w.boxes = @[:@Box]
|
||||
w.boxes = @[]
|
||||
box_size := Vector2(50., 50.)
|
||||
for y,line in map:lines():
|
||||
for x,cell in line:split():
|
||||
|
||||
@ -3,7 +3,7 @@ use pthreads
|
||||
func _assert_success(name:Text, val:Int32; inline):
|
||||
fail("$name() failed!") if val < 0
|
||||
|
||||
struct ConnectionQueue(_connections=@[:Int32], _mutex=pthread_mutex_t.new(), _cond=pthread_cond_t.new()):
|
||||
struct ConnectionQueue(_connections:@[Int32]=@[], _mutex=pthread_mutex_t.new(), _cond=pthread_cond_t.new()):
|
||||
func enqueue(queue:ConnectionQueue, connection:Int32):
|
||||
queue._mutex:lock()
|
||||
queue._connections:insert(connection)
|
||||
|
||||
@ -17,7 +17,7 @@ use ./connection-queue.tm
|
||||
|
||||
func serve(port:Int32, handler:func(request:HTTPRequest -> HTTPResponse), num_threads=16):
|
||||
connections := ConnectionQueue()
|
||||
workers := &[:@pthread_t]
|
||||
workers : &[@pthread_t] = &[]
|
||||
for i in num_threads:
|
||||
workers:insert(pthread_t.new(func():
|
||||
repeat:
|
||||
@ -82,7 +82,7 @@ struct HTTPRequest(method:Text, path:Text, version:Text, headers:[Text], body:Te
|
||||
body := rest[-1]
|
||||
return HTTPRequest(method, path, version, headers, body)
|
||||
|
||||
struct HTTPResponse(body:Text, status=200, content_type="text/plain", headers={:Text=Text}):
|
||||
struct HTTPResponse(body:Text, status=200, content_type="text/plain", headers:{Text=Text}={}):
|
||||
func bytes(r:HTTPResponse -> [Byte]):
|
||||
body_bytes := r.body:bytes()
|
||||
extra_headers := (++: "$k: $v$(\r\n)" for k,v in r.headers) or ""
|
||||
@ -114,7 +114,7 @@ enum RouteEntry(ServeFile(file:Path), Redirect(destination:Text)):
|
||||
return HTTPResponse("Found", 302, headers={"Location"=destination})
|
||||
|
||||
func load_routes(directory:Path -> {Text=RouteEntry}):
|
||||
routes := &{:Text=RouteEntry}
|
||||
routes : &{Text=RouteEntry} = &{}
|
||||
for file in (directory ++ (./*)):glob():
|
||||
skip unless file:is_file()
|
||||
contents := file:read() or skip
|
||||
|
||||
@ -7,8 +7,8 @@ struct HTTPResponse(code:Int, body:Text)
|
||||
|
||||
enum _Method(GET, POST, PUT, PATCH, DELETE)
|
||||
|
||||
func _send(method:_Method, url:Text, data:Text?, headers=[:Text] -> HTTPResponse):
|
||||
chunks := @[:Text]
|
||||
func _send(method:_Method, url:Text, data:Text?, headers:[Text]=[] -> HTTPResponse):
|
||||
chunks : @[Text] = @[]
|
||||
save_chunk := func(chunk:CString, size:Int64, n:Int64):
|
||||
chunks:insert(inline C:Text {
|
||||
Text$format("%.*s", _$size*_$n, _$chunk)
|
||||
@ -81,7 +81,7 @@ func _send(method:_Method, url:Text, data:Text?, headers=[:Text] -> HTTPResponse
|
||||
}
|
||||
return HTTPResponse(Int(code), "":join(chunks))
|
||||
|
||||
func get(url:Text, headers=[:Text] -> HTTPResponse):
|
||||
func get(url:Text, headers:[Text]=[] -> HTTPResponse):
|
||||
return _send(GET, url, none, headers)
|
||||
|
||||
func post(url:Text, data="", headers=["Content-Type: application/json", "Accept: application/json"] -> HTTPResponse):
|
||||
|
||||
@ -11,8 +11,8 @@ _HELP := "
|
||||
|
||||
func parse_ini(path:Path -> {Text={Text=Text}}):
|
||||
text := path:read() or exit("Could not read INI file: $\[31;1]$(path)$\[]")
|
||||
sections := @{:Text=@{Text=Text}}
|
||||
current_section := @{:Text=Text}
|
||||
sections : @{Text=@{Text=Text}} = @{}
|
||||
current_section : @{Text=Text} = @{}
|
||||
|
||||
# Line wraps:
|
||||
text = text:replace_pattern($Pat/\{1 nl}{0+space}/, " ")
|
||||
@ -22,7 +22,7 @@ func parse_ini(path:Path -> {Text={Text=Text}}):
|
||||
skip if line:starts_with(";") or line:starts_with("#")
|
||||
if line:matches_pattern($Pat/[?]/):
|
||||
section_name := line:replace($Pat/[?]/, "\1"):trim():lower()
|
||||
current_section = @{:Text=Text}
|
||||
current_section = @{}
|
||||
sections[section_name] = current_section
|
||||
else if line:matches_pattern($Pat/{..}={..}/):
|
||||
key := line:replace_pattern($Pat/{..}={..}/, "\1"):trim():lower()
|
||||
|
||||
@ -59,7 +59,7 @@ func main():
|
||||
my_numbers := [10, 20, 30]
|
||||
|
||||
# Empty arrays require specifying the type:
|
||||
empty_array := [:Int]
|
||||
empty_array : [Int] = []
|
||||
>> empty_array.length
|
||||
= 0
|
||||
|
||||
@ -123,7 +123,7 @@ func main():
|
||||
= 0
|
||||
|
||||
# Empty tables require specifying the key and value types:
|
||||
empty_table := {:Text=Int}
|
||||
empty_table : {Text=Int} = {}
|
||||
|
||||
# Tables can be iterated over either by key or key,value:
|
||||
for key in table:
|
||||
|
||||
@ -3,7 +3,7 @@ use <stdio.h>
|
||||
|
||||
timestamp_format := CString("%F %T")
|
||||
|
||||
logfiles := @{:Path}
|
||||
logfiles : @{Path} = @{}
|
||||
|
||||
func _timestamp(->Text):
|
||||
c_str := inline C:CString {
|
||||
|
||||
@ -65,7 +65,7 @@ struct pthread_t(; extern, opaque):
|
||||
func detatch(p:pthread_t): inline C { pthread_detach(_$p); }
|
||||
|
||||
struct IntQueue(_queue:@[Int], _mutex:@pthread_mutex_t, _cond:@pthread_cond_t):
|
||||
func new(initial=[:Int] -> IntQueue):
|
||||
func new(initial:[Int]=[] -> IntQueue):
|
||||
return IntQueue(@initial, pthread_mutex_t.new(), pthread_cond_t.new())
|
||||
|
||||
func give(q:IntQueue, n:Int):
|
||||
|
||||
@ -110,7 +110,7 @@ A copy of the given RNG.
|
||||
|
||||
**Example:**
|
||||
```tomo
|
||||
>> rng := RNG.new([:Byte])
|
||||
>> rng := RNG.new([])
|
||||
>> copy := rng:copy()
|
||||
|
||||
>> rng:bytes(10)
|
||||
|
||||
@ -4,7 +4,7 @@ use ./sysrandom.h
|
||||
use ./chacha.h
|
||||
|
||||
struct chacha_ctx(j0,j1,j2,j3,j4,j5,j6,j7,j8,j9,j10,j11,j12,j13,j14,j15:Int32; extern, secret):
|
||||
func from_seed(seed=[:Byte] -> chacha_ctx):
|
||||
func from_seed(seed:[Byte]=[] -> chacha_ctx):
|
||||
return inline C : chacha_ctx {
|
||||
chacha_ctx ctx;
|
||||
uint8_t seed_bytes[KEYSZ + IVSZ] = {};
|
||||
@ -24,10 +24,10 @@ func _os_random_bytes(count:Int64 -> [Byte]):
|
||||
(Array_t){.length=_$count, .data=random_bytes, .stride=1, .atomic=1};
|
||||
}
|
||||
|
||||
struct RandomNumberGenerator(_chacha:chacha_ctx, _random_bytes=[:Byte]; secret):
|
||||
struct RandomNumberGenerator(_chacha:chacha_ctx, _random_bytes:[Byte]=[]; secret):
|
||||
func new(seed=none:[Byte], -> @RandomNumberGenerator):
|
||||
ctx := chacha_ctx.from_seed(seed or _os_random_bytes(40))
|
||||
return @RandomNumberGenerator(ctx, [:Byte])
|
||||
return @RandomNumberGenerator(ctx, [])
|
||||
|
||||
func _rekey(rng:&RandomNumberGenerator):
|
||||
rng._random_bytes = inline C : [Byte] {
|
||||
|
||||
@ -24,7 +24,7 @@ lang Shell:
|
||||
func command(shell:Shell -> Command):
|
||||
return Command("sh", ["-c", shell.text])
|
||||
|
||||
func result(shell:Shell, input="", input_bytes=[:Byte] -> ProgramResult):
|
||||
func result(shell:Shell, input="", input_bytes:[Byte]=[] -> ProgramResult):
|
||||
return shell:command():result(input=input, input_bytes=input_bytes)
|
||||
|
||||
func run(shell:Shell -> ExitType):
|
||||
@ -33,7 +33,7 @@ lang Shell:
|
||||
func get_output(shell:Shell, input="", trim_newline=yes -> Text?):
|
||||
return shell:command():get_output(input=input, trim_newline=trim_newline)
|
||||
|
||||
func get_output_bytes(shell:Shell, input="", input_bytes=[:Byte] -> [Byte]?):
|
||||
func get_output_bytes(shell:Shell, input="", input_bytes:[Byte]=[] -> [Byte]?):
|
||||
return shell:command():get_output_bytes(input=input, input_bytes=input_bytes)
|
||||
|
||||
func by_line(shell:Shell -> func(->Text?)?):
|
||||
|
||||
@ -11,7 +11,7 @@ _HELP := "
|
||||
"
|
||||
|
||||
func find_urls(path:Path -> [Text]):
|
||||
urls := @[:Text]
|
||||
urls : @[Text] = @[]
|
||||
if path:is_directory():
|
||||
for f in path:children():
|
||||
urls:insert_all(find_urls(f))
|
||||
@ -25,7 +25,7 @@ func main(paths:[Path]):
|
||||
if paths.length == 0:
|
||||
paths = [(./)]
|
||||
|
||||
urls := (++: find_urls(p) for p in paths) or [:Text]
|
||||
urls := (++: find_urls(p) for p in paths) or []
|
||||
|
||||
github_token := (~/.config/tomo/github-token):read()
|
||||
|
||||
|
||||
@ -14,9 +14,9 @@ enum Dependency(File(path:Path), Module(name:Text))
|
||||
func _get_file_dependencies(file:Path -> {Dependency}):
|
||||
if not file:is_file():
|
||||
!! Could not read file: $file
|
||||
return {:Dependency}
|
||||
return {}
|
||||
|
||||
deps := @{:Dependency}
|
||||
deps : @{Dependency} = @{}
|
||||
if lines := file:by_line():
|
||||
for line in lines:
|
||||
if line:matches_pattern($Pat/use {..}.tm/):
|
||||
@ -30,14 +30,14 @@ func _get_file_dependencies(file:Path -> {Dependency}):
|
||||
func _build_dependency_graph(dep:Dependency, dependencies:@{Dependency,{Dependency}}):
|
||||
return if dependencies:has(dep)
|
||||
|
||||
dependencies[dep] = {:Dependency} # Placeholder
|
||||
dependencies[dep] = {} # Placeholder
|
||||
|
||||
dep_deps := when dep is File(path):
|
||||
_get_file_dependencies(path)
|
||||
is Module(module):
|
||||
dir := (~/.local/share/tomo/installed/$module)
|
||||
module_deps := @{:Dependency}
|
||||
visited := @{:Path}
|
||||
module_deps : @{Dependency} = @{}
|
||||
visited : @{Path} = @{}
|
||||
unvisited := @{f:resolved() for f in dir:files() if f:extension() == ".tm"}
|
||||
while unvisited.length > 0:
|
||||
file := unvisited.items[-1]
|
||||
@ -58,7 +58,7 @@ func _build_dependency_graph(dep:Dependency, dependencies:@{Dependency,{Dependen
|
||||
_build_dependency_graph(dep2, dependencies)
|
||||
|
||||
func get_dependency_graph(dep:Dependency -> {Dependency,{Dependency}}):
|
||||
graph := @{:Dependency,{Dependency}}
|
||||
graph : @{Dependency={Dependency}} = @{}
|
||||
_build_dependency_graph(dep, graph)
|
||||
return graph
|
||||
|
||||
@ -82,16 +82,16 @@ func _draw_tree(dep:Dependency, dependencies:{Dependency,{Dependency}}, already_
|
||||
|
||||
child_prefix := prefix ++ (if is_last: " " else: "│ ")
|
||||
|
||||
children := dependencies[dep] or {:Dependency}
|
||||
children := dependencies[dep] or {}
|
||||
for i,child in children.items:
|
||||
is_child_last := (i == children.length)
|
||||
_draw_tree(child, dependencies, already_printed, child_prefix, is_child_last)
|
||||
|
||||
func draw_tree(dep:Dependency, dependencies:{Dependency,{Dependency}}):
|
||||
printed := @{:Dependency}
|
||||
printed : @{Dependency} = @{}
|
||||
say(_printable_name(dep))
|
||||
printed:add(dep)
|
||||
deps := dependencies[dep] or {:Dependency}
|
||||
deps := dependencies[dep] or {}
|
||||
for i,child in deps.items:
|
||||
is_child_last := (i == deps.length)
|
||||
_draw_tree(child, dependencies, already_printed=printed, is_last=is_child_last)
|
||||
|
||||
@ -33,7 +33,7 @@ func wrap(text:Text, width:Int, min_split=3, hyphen="-" -> Text):
|
||||
... and I can't split it without splitting into chunks smaller than $min_split.
|
||||
")
|
||||
|
||||
lines := @[:Text]
|
||||
lines : @[Text] = @[]
|
||||
line := ""
|
||||
for word in text:split($/{whitespace}/):
|
||||
letters := word:split()
|
||||
@ -93,7 +93,7 @@ func main(files:[Path], width=80, inplace=no, min_split=3, rewrap=yes, hyphen=UN
|
||||
(/dev/stdout)
|
||||
|
||||
first := yes
|
||||
wrapped_paragraphs := @[:Text]
|
||||
wrapped_paragraphs : @[Text] = @[]
|
||||
for paragraph in text:split($/{2+ nl}/):
|
||||
wrapped_paragraphs:insert(
|
||||
wrap(paragraph, width=width, min_split=min_split, hyphen=hyphen)
|
||||
|
||||
119
src/ast.c
119
src/ast.c
@ -10,23 +10,47 @@
|
||||
#include "stdlib/text.h"
|
||||
#include "cordhelpers.h"
|
||||
|
||||
static const char *OP_NAMES[] = {
|
||||
[BINOP_UNKNOWN]="unknown",
|
||||
[BINOP_POWER]="^", [BINOP_MULT]="*", [BINOP_DIVIDE]="/",
|
||||
[BINOP_MOD]="mod", [BINOP_MOD1]="mod1", [BINOP_PLUS]="+", [BINOP_MINUS]="minus",
|
||||
[BINOP_CONCAT]="++", [BINOP_LSHIFT]="<<", [BINOP_ULSHIFT]="<<<",
|
||||
[BINOP_RSHIFT]=">>", [BINOP_URSHIFT]=">>>", [BINOP_MIN]="min",
|
||||
[BINOP_MAX]="max", [BINOP_EQ]="==", [BINOP_NE]="!=", [BINOP_LT]="<",
|
||||
[BINOP_LE]="<=", [BINOP_GT]=">", [BINOP_GE]=">=", [BINOP_CMP]="<>",
|
||||
[BINOP_AND]="and", [BINOP_OR]="or", [BINOP_XOR]="xor",
|
||||
CONSTFUNC const char *binop_method_name(ast_e tag) {
|
||||
switch (tag) {
|
||||
case Power: case PowerUpdate: return "power";
|
||||
case Multiply: case MultiplyUpdate: return "times";
|
||||
case Divide: case DivideUpdate: return "divided_by";
|
||||
case Mod: case ModUpdate: return "modulo";
|
||||
case Mod1: case Mod1Update: return "modulo1";
|
||||
case Plus: case PlusUpdate: return "plus";
|
||||
case Minus: case MinusUpdate: return "minus";
|
||||
case Concat: case ConcatUpdate: return "concatenated_with";
|
||||
case LeftShift: case LeftShiftUpdate: return "left_shifted";
|
||||
case RightShift: case RightShiftUpdate: return "right_shifted";
|
||||
case UnsignedLeftShift: case UnsignedLeftShiftUpdate: return "unsigned_left_shifted";
|
||||
case UnsignedRightShift: case UnsignedRightShiftUpdate: return "unsigned_right_shifted";
|
||||
case And: case AndUpdate: return "bit_and";
|
||||
case Or: case OrUpdate: return "bit_or";
|
||||
case Xor: case XorUpdate: return "bit_xor";
|
||||
default: return NULL;
|
||||
}
|
||||
};
|
||||
|
||||
const char *binop_method_names[BINOP_XOR+1] = {
|
||||
[BINOP_POWER]="power", [BINOP_MULT]="times", [BINOP_DIVIDE]="divided_by",
|
||||
[BINOP_MOD]="modulo", [BINOP_MOD1]="modulo1", [BINOP_PLUS]="plus", [BINOP_MINUS]="minus",
|
||||
[BINOP_CONCAT]="concatenated_with", [BINOP_LSHIFT]="left_shifted", [BINOP_RSHIFT]="right_shifted",
|
||||
[BINOP_ULSHIFT]="unsigned_left_shifted", [BINOP_URSHIFT]="unsigned_right_shifted",
|
||||
[BINOP_AND]="bit_and", [BINOP_OR]="bit_or", [BINOP_XOR]="bit_xor",
|
||||
CONSTFUNC const char *binop_operator(ast_e tag) {
|
||||
switch (tag) {
|
||||
case Multiply: case MultiplyUpdate: return "*";
|
||||
case Divide: case DivideUpdate: return "/";
|
||||
case Mod: case ModUpdate: return "%";
|
||||
case Plus: case PlusUpdate: return "+";
|
||||
case Minus: case MinusUpdate: return "-";
|
||||
case LeftShift: case LeftShiftUpdate: return "<<";
|
||||
case RightShift: case RightShiftUpdate: return ">>";
|
||||
case And: case AndUpdate: return "&";
|
||||
case Or: case OrUpdate: return "|";
|
||||
case Xor: case XorUpdate: return "^";
|
||||
case Equals: return "==";
|
||||
case NotEquals: return "!=";
|
||||
case LessThan: return "<";
|
||||
case LessThanOrEquals: return "<=";
|
||||
case GreaterThan: return ">";
|
||||
case GreaterThanOrEquals: return ">=";
|
||||
default: return NULL;
|
||||
}
|
||||
};
|
||||
|
||||
static CORD ast_list_to_xml(ast_list_t *asts);
|
||||
@ -100,7 +124,7 @@ CORD ast_to_xml(ast_t *ast)
|
||||
switch (ast->tag) {
|
||||
#define T(type, ...) case type: { auto data = ast->__data.type; (void)data; return CORD_asprintf(__VA_ARGS__); }
|
||||
T(Unknown, "<Unknown>")
|
||||
T(None, "<None>%r</None>", type_ast_to_xml(data.type))
|
||||
T(None, "<None/>")
|
||||
T(Bool, "<Bool value=\"%s\" />", data.b ? "yes" : "no")
|
||||
T(Var, "<Var>%s</Var>", data.name)
|
||||
T(Int, "<Int>%s</Int>", data.str)
|
||||
@ -108,22 +132,24 @@ CORD ast_to_xml(ast_t *ast)
|
||||
T(TextLiteral, "%r", xml_escape(data.cord))
|
||||
T(TextJoin, "<Text%r>%r</Text>", data.lang ? CORD_all(" lang=\"", data.lang, "\"") : CORD_EMPTY, ast_list_to_xml(data.children))
|
||||
T(Path, "<Path>%s</Path>", data.path)
|
||||
T(Declare, "<Declare var=\"%r\">%r</Declare>", ast_to_xml(data.var), ast_to_xml(data.value))
|
||||
T(Declare, "<Declare var=\"%r\">%r%r</Declare>", ast_to_xml(data.var), type_ast_to_xml(data.type), ast_to_xml(data.value))
|
||||
T(Assign, "<Assign><targets>%r</targets><values>%r</values></Assign>", ast_list_to_xml(data.targets), ast_list_to_xml(data.values))
|
||||
T(BinaryOp, "<BinaryOp op=\"%r\">%r %r</BinaryOp>", xml_escape(OP_NAMES[data.op]), ast_to_xml(data.lhs), ast_to_xml(data.rhs))
|
||||
T(UpdateAssign, "<UpdateAssign op=\"%r\">%r %r</UpdateAssign>", xml_escape(OP_NAMES[data.op]), ast_to_xml(data.lhs), ast_to_xml(data.rhs))
|
||||
#define BINOP(name) T(name, "<" #name ">%r %r</" #name ">", data.lhs, data.rhs)
|
||||
BINOP(Power) BINOP(PowerUpdate) BINOP(Multiply) BINOP(MultiplyUpdate) BINOP(Divide) BINOP(DivideUpdate) BINOP(Mod) BINOP(ModUpdate)
|
||||
BINOP(Mod1) BINOP(Mod1Update) BINOP(Plus) BINOP(PlusUpdate) BINOP(Minus) BINOP(MinusUpdate) BINOP(Concat) BINOP(ConcatUpdate)
|
||||
BINOP(LeftShift) BINOP(LeftShiftUpdate) BINOP(RightShift) BINOP(RightShiftUpdate) BINOP(UnsignedLeftShift) BINOP(UnsignedLeftShiftUpdate)
|
||||
BINOP(UnsignedRightShift) BINOP(UnsignedRightShiftUpdate) BINOP(And) BINOP(AndUpdate) BINOP(Or) BINOP(OrUpdate)
|
||||
BINOP(Xor) BINOP(XorUpdate)
|
||||
#undef BINOP
|
||||
T(Negative, "<Negative>%r</Negative>", ast_to_xml(data.value))
|
||||
T(Not, "<Not>%r</Not>", ast_to_xml(data.value))
|
||||
T(HeapAllocate, "<HeapAllocate>%r</HeapAllocate>", ast_to_xml(data.value))
|
||||
T(StackReference, "<StackReference>%r</StackReference>", ast_to_xml(data.value))
|
||||
T(Min, "<Min>%r%r%r</Min>", ast_to_xml(data.lhs), ast_to_xml(data.rhs), optional_tagged("key", data.key))
|
||||
T(Max, "<Max>%r%r%r</Max>", ast_to_xml(data.lhs), ast_to_xml(data.rhs), optional_tagged("key", data.key))
|
||||
T(Array, "<Array>%r%r</Array>", optional_tagged_type("item-type", data.item_type), ast_list_to_xml(data.items))
|
||||
T(Set, "<Set>%r%r</Set>",
|
||||
optional_tagged_type("item-type", data.item_type),
|
||||
ast_list_to_xml(data.items))
|
||||
T(Table, "<Table>%r%r%r%r</Table>",
|
||||
optional_tagged_type("key-type", data.key_type), optional_tagged_type("value-type", data.value_type),
|
||||
T(Array, "<Array>%r</Array>", ast_list_to_xml(data.items))
|
||||
T(Set, "<Set>%r</Set>", ast_list_to_xml(data.items))
|
||||
T(Table, "<Table>%r%r</Table>",
|
||||
optional_tagged("default-value", data.default_value),
|
||||
ast_list_to_xml(data.entries), optional_tagged("fallback", data.fallback))
|
||||
T(TableEntry, "<TableEntry>%r%r</TableEntry>", ast_to_xml(data.key), ast_to_xml(data.value))
|
||||
@ -145,7 +171,7 @@ CORD ast_to_xml(ast_t *ast)
|
||||
T(Repeat, "<Repeat>%r</Repeat>", optional_tagged("body", data.body))
|
||||
T(If, "<If>%r%r%r</If>", optional_tagged("condition", data.condition), optional_tagged("body", data.body), optional_tagged("else", data.else_body))
|
||||
T(When, "<When><subject>%r</subject>%r%r</When>", ast_to_xml(data.subject), when_clauses_to_xml(data.clauses), optional_tagged("else", data.else_body))
|
||||
T(Reduction, "<Reduction op=%r%r>%r</Reduction>", xml_escape(OP_NAMES[data.op]), optional_tagged("key", data.key),
|
||||
T(Reduction, "<Reduction op=%r%r>%r</Reduction>", xml_escape(binop_method_name(data.op)), optional_tagged("key", data.key),
|
||||
optional_tagged("iterable", data.iter))
|
||||
T(Skip, "<Skip>%r</Skip>", data.target)
|
||||
T(Stop, "<Stop>%r</Stop>", data.target)
|
||||
@ -313,4 +339,45 @@ void visit_topologically(ast_list_t *asts, Closure_t fn)
|
||||
}
|
||||
}
|
||||
|
||||
CONSTFUNC bool is_binary_operation(ast_t *ast)
|
||||
{
|
||||
switch (ast->tag) {
|
||||
case BINOP_CASES: return true;
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
|
||||
CONSTFUNC bool is_update_assignment(ast_t *ast)
|
||||
{
|
||||
switch (ast->tag) {
|
||||
case PowerUpdate: case MultiplyUpdate: case DivideUpdate: case ModUpdate: case Mod1Update:
|
||||
case PlusUpdate: case MinusUpdate: case ConcatUpdate: case LeftShiftUpdate: case UnsignedLeftShiftUpdate:
|
||||
case RightShiftUpdate: case UnsignedRightShiftUpdate: case AndUpdate: case OrUpdate: case XorUpdate:
|
||||
return true;
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
|
||||
CONSTFUNC ast_e binop_tag(ast_e tag)
|
||||
{
|
||||
switch (tag) {
|
||||
case PowerUpdate: return Power;
|
||||
case MultiplyUpdate: return Multiply;
|
||||
case DivideUpdate: return Divide;
|
||||
case ModUpdate: return Mod;
|
||||
case Mod1Update: return Mod1;
|
||||
case PlusUpdate: return Plus;
|
||||
case MinusUpdate: return Minus;
|
||||
case ConcatUpdate: return Concat;
|
||||
case LeftShiftUpdate: return LeftShift;
|
||||
case UnsignedLeftShiftUpdate: return UnsignedLeftShift;
|
||||
case RightShiftUpdate: return RightShift;
|
||||
case UnsignedRightShiftUpdate: return UnsignedRightShift;
|
||||
case AndUpdate: return And;
|
||||
case OrUpdate: return Or;
|
||||
case XorUpdate: return Xor;
|
||||
default: return Unknown;
|
||||
}
|
||||
}
|
||||
|
||||
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
|
||||
|
||||
55
src/ast.h
55
src/ast.h
@ -20,6 +20,7 @@
|
||||
#define WrapAST(ast, ast_tag, ...) (new(ast_t, .file=(ast)->file, .start=(ast)->start, .end=(ast)->end, .tag=ast_tag, .__data.ast_tag={__VA_ARGS__}))
|
||||
#define TextAST(ast, _str) WrapAST(ast, TextLiteral, .str=GC_strdup(_str))
|
||||
#define Match(x, _tag) ((x)->tag == _tag ? &(x)->__data._tag : (errx(1, __FILE__ ":%d This was supposed to be a " # _tag "\n", __LINE__), &(x)->__data._tag))
|
||||
#define BINARY_OPERANDS(ast) ({ if (!is_binary_operation(ast)) errx(1, __FILE__ ":%d This is not a binary operation!", __LINE__); (ast)->__data.Plus; })
|
||||
|
||||
#define REVERSE_LIST(list) do { \
|
||||
__typeof(list) _prev = NULL; \
|
||||
@ -37,6 +38,9 @@
|
||||
struct binding_s;
|
||||
typedef struct type_ast_s type_ast_t;
|
||||
typedef struct ast_s ast_t;
|
||||
typedef struct {
|
||||
ast_t *lhs, *rhs;
|
||||
} binary_operands_t;
|
||||
|
||||
typedef struct ast_list_s {
|
||||
ast_t *ast;
|
||||
@ -55,17 +59,6 @@ typedef struct when_clause_s {
|
||||
struct when_clause_s *next;
|
||||
} when_clause_t;
|
||||
|
||||
typedef enum {
|
||||
BINOP_UNKNOWN,
|
||||
BINOP_POWER=100, BINOP_MULT, BINOP_DIVIDE, BINOP_MOD, BINOP_MOD1, BINOP_PLUS,
|
||||
BINOP_MINUS, BINOP_CONCAT, BINOP_LSHIFT, BINOP_ULSHIFT, BINOP_RSHIFT, BINOP_URSHIFT, BINOP_MIN,
|
||||
BINOP_MAX, BINOP_EQ, BINOP_NE, BINOP_LT, BINOP_LE, BINOP_GT, BINOP_GE,
|
||||
BINOP_CMP,
|
||||
BINOP_AND, BINOP_OR, BINOP_XOR,
|
||||
} binop_e;
|
||||
|
||||
extern const char *binop_method_names[BINOP_XOR+1];
|
||||
|
||||
typedef enum {
|
||||
UnknownTypeAST,
|
||||
VarTypeAST,
|
||||
@ -117,6 +110,15 @@ struct type_ast_s {
|
||||
} __data;
|
||||
};
|
||||
|
||||
#define BINOP_CASES Power: case Multiply: case Divide: case Mod: case Mod1: case Plus: case Minus: case Concat: case LeftShift: case UnsignedLeftShift: \
|
||||
case RightShift: case UnsignedRightShift: case Equals: case NotEquals: case LessThan: case LessThanOrEquals: case GreaterThan: \
|
||||
case GreaterThanOrEquals: case Compare: case And: case Or: case Xor: \
|
||||
case PowerUpdate: case MultiplyUpdate: case DivideUpdate: case ModUpdate: case Mod1Update: case PlusUpdate: case MinusUpdate: case ConcatUpdate: \
|
||||
case LeftShiftUpdate: case UnsignedLeftShiftUpdate
|
||||
#define UPDATE_CASES PowerUpdate: case MultiplyUpdate: case DivideUpdate: case ModUpdate: case Mod1Update: case PlusUpdate: case MinusUpdate: \
|
||||
case ConcatUpdate: case LeftShiftUpdate: case UnsignedLeftShiftUpdate: case RightShiftUpdate: case UnsignedRightShiftUpdate: \
|
||||
case AndUpdate: case OrUpdate: case XorUpdate
|
||||
|
||||
typedef enum {
|
||||
Unknown = 0,
|
||||
None, Bool, Var,
|
||||
@ -124,7 +126,11 @@ typedef enum {
|
||||
TextLiteral, TextJoin, PrintStatement,
|
||||
Path,
|
||||
Declare, Assign,
|
||||
BinaryOp, UpdateAssign,
|
||||
Power, Multiply, Divide, Mod, Mod1, Plus, Minus, Concat, LeftShift, UnsignedLeftShift,
|
||||
RightShift, UnsignedRightShift, Equals, NotEquals, LessThan, LessThanOrEquals, GreaterThan,
|
||||
GreaterThanOrEquals, Compare, And, Or, Xor,
|
||||
PowerUpdate, MultiplyUpdate, DivideUpdate, ModUpdate, Mod1Update, PlusUpdate, MinusUpdate, ConcatUpdate, LeftShiftUpdate, UnsignedLeftShiftUpdate,
|
||||
RightShiftUpdate, UnsignedRightShiftUpdate, AndUpdate, OrUpdate, XorUpdate,
|
||||
Not, Negative, HeapAllocate, StackReference,
|
||||
Min, Max,
|
||||
Array, Set, Table, TableEntry, Comprehension,
|
||||
@ -152,9 +158,7 @@ struct ast_s {
|
||||
const char *start, *end;
|
||||
union {
|
||||
struct {} Unknown;
|
||||
struct {
|
||||
type_ast_t *type;
|
||||
} None;
|
||||
struct {} None;
|
||||
struct {
|
||||
bool b;
|
||||
} Bool;
|
||||
@ -182,16 +186,17 @@ struct ast_s {
|
||||
} PrintStatement;
|
||||
struct {
|
||||
ast_t *var;
|
||||
type_ast_t *type;
|
||||
ast_t *value;
|
||||
} Declare;
|
||||
struct {
|
||||
ast_list_t *targets, *values;
|
||||
} Assign;
|
||||
struct {
|
||||
ast_t *lhs;
|
||||
binop_e op;
|
||||
ast_t *rhs;
|
||||
} BinaryOp, UpdateAssign;
|
||||
binary_operands_t Power, Multiply, Divide, Mod, Mod1, Plus, Minus, Concat, LeftShift, UnsignedLeftShift,
|
||||
RightShift, UnsignedRightShift, Equals, NotEquals, LessThan, LessThanOrEquals, GreaterThan,
|
||||
GreaterThanOrEquals, Compare, And, Or, Xor,
|
||||
PowerUpdate, MultiplyUpdate, DivideUpdate, ModUpdate, Mod1Update, PlusUpdate, MinusUpdate, ConcatUpdate, LeftShiftUpdate, UnsignedLeftShiftUpdate,
|
||||
RightShiftUpdate, UnsignedRightShiftUpdate, AndUpdate, OrUpdate, XorUpdate;
|
||||
struct {
|
||||
ast_t *value;
|
||||
} Not, Negative, HeapAllocate, StackReference;
|
||||
@ -199,15 +204,12 @@ struct ast_s {
|
||||
ast_t *lhs, *rhs, *key;
|
||||
} Min, Max;
|
||||
struct {
|
||||
type_ast_t *item_type;
|
||||
ast_list_t *items;
|
||||
} Array;
|
||||
struct {
|
||||
type_ast_t *item_type;
|
||||
ast_list_t *items;
|
||||
} Set;
|
||||
struct {
|
||||
type_ast_t *key_type, *value_type;
|
||||
ast_t *default_value;
|
||||
ast_t *fallback;
|
||||
ast_list_t *entries;
|
||||
@ -272,7 +274,7 @@ struct ast_s {
|
||||
} When;
|
||||
struct {
|
||||
ast_t *iter, *key;
|
||||
binop_e op;
|
||||
ast_e op;
|
||||
} Reduction;
|
||||
struct {
|
||||
const char *target;
|
||||
@ -345,5 +347,10 @@ const char *ast_source(ast_t *ast);
|
||||
CORD type_ast_to_xml(type_ast_t *ast);
|
||||
PUREFUNC bool is_idempotent(ast_t *ast);
|
||||
void visit_topologically(ast_list_t *ast, Closure_t fn);
|
||||
CONSTFUNC bool is_update_assignment(ast_t *ast);
|
||||
CONSTFUNC const char *binop_method_name(ast_e tag);
|
||||
CONSTFUNC const char *binop_operator(ast_e tag);
|
||||
CONSTFUNC ast_e binop_tag(ast_e tag);
|
||||
CONSTFUNC bool is_binary_operation(ast_t *ast);
|
||||
|
||||
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
|
||||
|
||||
1275
src/compile.c
1275
src/compile.c
File diff suppressed because it is too large
Load Diff
@ -122,7 +122,7 @@ env_t *global_env(void)
|
||||
{"right_shifted", "Int$right_shifted", "func(x,y:Int -> Int)"},
|
||||
{"sqrt", "Int$sqrt", "func(x:Int -> Int?)"},
|
||||
{"times", "Int$times", "func(x,y:Int -> Int)"},
|
||||
{"to", "Int$to", "func(first:Int,last:Int,step=none:Int -> func(->Int?))"},
|
||||
{"to", "Int$to", "func(first:Int,last:Int,step:Int?=none -> func(->Int?))"},
|
||||
)},
|
||||
{"Int64", Type(IntType, .bits=TYPE_IBITS64), "Int64_t", "Int64$info", TypedArray(ns_entry_t,
|
||||
{"abs", "labs", "func(i:Int64 -> Int64)"},
|
||||
@ -139,7 +139,7 @@ env_t *global_env(void)
|
||||
{"modulo1", "Int64$modulo1", "func(x,y:Int64 -> Int64)"},
|
||||
{"octal", "Int64$octal", "func(i:Int64, digits=0, prefix=yes -> Text)"},
|
||||
{"onward", "Int64$onward", "func(first:Int64,step=Int64(1) -> func(->Int64?))"},
|
||||
{"to", "Int64$to", "func(first:Int64,last:Int64,step=none:Int64 -> func(->Int64?))"},
|
||||
{"to", "Int64$to", "func(first:Int64,last:Int64,step:Int64?=none -> func(->Int64?))"},
|
||||
{"unsigned_left_shifted", "Int64$unsigned_left_shifted", "func(x:Int64,y:Int64 -> Int64)"},
|
||||
{"unsigned_right_shifted", "Int64$unsigned_right_shifted", "func(x:Int64,y:Int64 -> Int64)"},
|
||||
{"wrapping_minus", "Int64$wrapping_minus", "func(x:Int64,y:Int64 -> Int64)"},
|
||||
@ -160,7 +160,7 @@ env_t *global_env(void)
|
||||
{"modulo1", "Int32$modulo1", "func(x,y:Int32 -> Int32)"},
|
||||
{"octal", "Int32$octal", "func(i:Int32, digits=0, prefix=yes -> Text)"},
|
||||
{"onward", "Int32$onward", "func(first:Int32,step=Int32(1) -> func(->Int32?))"},
|
||||
{"to", "Int32$to", "func(first:Int32,last:Int32,step=none:Int32 -> func(->Int32?))"},
|
||||
{"to", "Int32$to", "func(first:Int32,last:Int32,step:Int32?=none -> func(->Int32?))"},
|
||||
{"unsigned_left_shifted", "Int32$unsigned_left_shifted", "func(x:Int32,y:Int32 -> Int32)"},
|
||||
{"unsigned_right_shifted", "Int32$unsigned_right_shifted", "func(x:Int32,y:Int32 -> Int32)"},
|
||||
{"wrapping_minus", "Int32$wrapping_minus", "func(x:Int32,y:Int32 -> Int32)"},
|
||||
@ -181,7 +181,7 @@ env_t *global_env(void)
|
||||
{"modulo1", "Int16$modulo1", "func(x,y:Int16 -> Int16)"},
|
||||
{"octal", "Int16$octal", "func(i:Int16, digits=0, prefix=yes -> Text)"},
|
||||
{"onward", "Int16$onward", "func(first:Int16,step=Int16(1) -> func(->Int16?))"},
|
||||
{"to", "Int16$to", "func(first:Int16,last:Int16,step=none:Int16 -> func(->Int16?))"},
|
||||
{"to", "Int16$to", "func(first:Int16,last:Int16,step:Int16?=none -> func(->Int16?))"},
|
||||
{"unsigned_left_shifted", "Int16$unsigned_left_shifted", "func(x:Int16,y:Int16 -> Int16)"},
|
||||
{"unsigned_right_shifted", "Int16$unsigned_right_shifted", "func(x:Int16,y:Int16 -> Int16)"},
|
||||
{"wrapping_minus", "Int16$wrapping_minus", "func(x:Int16,y:Int16 -> Int16)"},
|
||||
@ -202,7 +202,7 @@ env_t *global_env(void)
|
||||
{"modulo1", "Int8$modulo1", "func(x,y:Int8 -> Int8)"},
|
||||
{"octal", "Int8$octal", "func(i:Int8, digits=0, prefix=yes -> Text)"},
|
||||
{"onward", "Int8$onward", "func(first:Int8,step=Int8(1) -> func(->Int8?))"},
|
||||
{"to", "Int8$to", "func(first:Int8,last:Int8,step=none:Int8 -> func(->Int8?))"},
|
||||
{"to", "Int8$to", "func(first:Int8,last:Int8,step:Int8?=none -> func(->Int8?))"},
|
||||
{"unsigned_left_shifted", "Int8$unsigned_left_shifted", "func(x:Int8,y:Int8 -> Int8)"},
|
||||
{"unsigned_right_shifted", "Int8$unsigned_right_shifted", "func(x:Int8,y:Int8 -> Int8)"},
|
||||
{"wrapping_minus", "Int8$wrapping_minus", "func(x:Int8,y:Int8 -> Int8)"},
|
||||
@ -310,11 +310,11 @@ env_t *global_env(void)
|
||||
{"owner", "Path$owner", "func(path:Path, follow_symlinks=yes -> Text?)"},
|
||||
{"parent", "Path$parent", "func(path:Path -> Path)"},
|
||||
{"read", "Path$read", "func(path:Path -> Text?)"},
|
||||
{"read_bytes", "Path$read_bytes", "func(path:Path, limit=none:Int -> [Byte]?)"},
|
||||
{"read_bytes", "Path$read_bytes", "func(path:Path, limit:Int?=none -> [Byte]?)"},
|
||||
{"relative_to", "Path$relative_to", "func(path:Path, relative_to:Path -> Path)"},
|
||||
{"remove", "Path$remove", "func(path:Path, ignore_missing=no)"},
|
||||
{"resolved", "Path$resolved", "func(path:Path, relative_to=(./) -> Path)"},
|
||||
{"set_owner", "Path$set_owner", "func(path:Path, owner=none:Text, group=none:Text, follow_symlinks=yes)"},
|
||||
{"set_owner", "Path$set_owner", "func(path:Path, owner:Text?=none, group:Text?=none, follow_symlinks=yes)"},
|
||||
{"subdirectories", "Path$children", "func(path:Path, include_hidden=no -> [Path])"},
|
||||
{"unique_directory", "Path$unique_directory", "func(path:Path -> Path)"},
|
||||
{"write", "Path$write", "func(path:Path, text:Text, permissions=Int32(0o644))"},
|
||||
@ -508,7 +508,7 @@ env_t *global_env(void)
|
||||
{"say", "say", "func(text:Text, newline=yes)"},
|
||||
{"print", "say", "func(text:Text, newline=yes)"},
|
||||
{"ask", "ask", "func(prompt:Text, bold=yes, force_tty=yes -> Text?)"},
|
||||
{"exit", "tomo_exit", "func(message=none:Text, code=Int32(1) -> Abort)"},
|
||||
{"exit", "tomo_exit", "func(message:Text?=none, code=Int32(1) -> Abort)"},
|
||||
{"fail", "fail_text", "func(message:Text -> Abort)"},
|
||||
{"sleep", "sleep_num", "func(seconds:Num)"},
|
||||
};
|
||||
@ -749,6 +749,18 @@ PUREFUNC binding_t *get_constructor(env_t *env, type_t *t, arg_ast_t *args)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
PUREFUNC binding_t *get_metamethod_binding(env_t *env, ast_e tag, ast_t *lhs, ast_t *rhs, type_t *ret)
|
||||
{
|
||||
const char *method_name = binop_method_name(tag);
|
||||
if (!method_name) return NULL;
|
||||
binding_t *b = get_namespace_binding(env, lhs, method_name);
|
||||
if (!b || b->type->tag != FunctionType) return NULL;
|
||||
auto fn = Match(b->type, FunctionType);
|
||||
if (!type_eq(fn->ret, ret)) return NULL;
|
||||
arg_ast_t *args = new(arg_ast_t, .value=lhs, .next=new(arg_ast_t, .value=rhs));
|
||||
return is_valid_call(env, fn->args, args, true) ? b : NULL;
|
||||
}
|
||||
|
||||
void set_binding(env_t *env, const char *name, type_t *type, CORD code)
|
||||
{
|
||||
assert(name);
|
||||
|
||||
@ -85,6 +85,7 @@ env_t *namespace_env(env_t *env, const char *namespace_name);
|
||||
})
|
||||
binding_t *get_binding(env_t *env, const char *name);
|
||||
binding_t *get_constructor(env_t *env, type_t *t, arg_ast_t *args);
|
||||
PUREFUNC binding_t *get_metamethod_binding(env_t *env, ast_e tag, ast_t *lhs, ast_t *rhs, type_t *ret);
|
||||
void set_binding(env_t *env, const char *name, type_t *type, CORD code);
|
||||
binding_t *get_namespace_binding(env_t *env, ast_t *self, const char *name);
|
||||
#define code_err(ast, ...) compiler_err((ast)->file, (ast)->start, (ast)->end, __VA_ARGS__)
|
||||
|
||||
180
src/parse.c
180
src/parse.c
@ -48,16 +48,16 @@ typedef struct {
|
||||
#define PARSER(name) ast_t *name(parse_ctx_t *ctx, const char *pos)
|
||||
|
||||
int op_tightness[] = {
|
||||
[BINOP_POWER]=9,
|
||||
[BINOP_MULT]=8, [BINOP_DIVIDE]=8, [BINOP_MOD]=8, [BINOP_MOD1]=8,
|
||||
[BINOP_PLUS]=7, [BINOP_MINUS]=7,
|
||||
[BINOP_CONCAT]=6,
|
||||
[BINOP_LSHIFT]=5, [BINOP_RSHIFT]=5,
|
||||
[BINOP_MIN]=4, [BINOP_MAX]=4,
|
||||
[BINOP_EQ]=3, [BINOP_NE]=3,
|
||||
[BINOP_LT]=2, [BINOP_LE]=2, [BINOP_GT]=2, [BINOP_GE]=2,
|
||||
[BINOP_CMP]=2,
|
||||
[BINOP_AND]=1, [BINOP_OR]=1, [BINOP_XOR]=1,
|
||||
[Power]=9,
|
||||
[Multiply]=8, [Divide]=8, [Mod]=8, [Mod1]=8,
|
||||
[Plus]=7, [Minus]=7,
|
||||
[Concat]=6,
|
||||
[LeftShift]=5, [RightShift]=5, [UnsignedLeftShift]=5, [UnsignedRightShift]=5,
|
||||
[Min]=4, [Max]=4,
|
||||
[Equals]=3, [NotEquals]=3,
|
||||
[LessThan]=2, [LessThanOrEquals]=2, [GreaterThan]=2, [GreaterThanOrEquals]=2,
|
||||
[Compare]=2,
|
||||
[And]=1, [Or]=1, [Xor]=1,
|
||||
};
|
||||
|
||||
static const char *keywords[] = {
|
||||
@ -79,7 +79,7 @@ static INLINE const char* get_word(const char **pos);
|
||||
static INLINE const char* get_id(const char **pos);
|
||||
static INLINE bool comment(const char **pos);
|
||||
static INLINE bool indent(parse_ctx_t *ctx, const char **pos);
|
||||
static INLINE binop_e match_binary_operator(const char **pos);
|
||||
static INLINE ast_e match_binary_operator(const char **pos);
|
||||
static ast_t *parse_comprehension_suffix(parse_ctx_t *ctx, ast_t *expr);
|
||||
static ast_t *parse_field_suffix(parse_ctx_t *ctx, ast_t *lhs);
|
||||
static ast_t *parse_fncall_suffix(parse_ctx_t *ctx, ast_t *fn);
|
||||
@ -685,15 +685,6 @@ PARSER(parse_array) {
|
||||
whitespace(&pos);
|
||||
|
||||
ast_list_t *items = NULL;
|
||||
type_ast_t *item_type = NULL;
|
||||
if (match(&pos, ":")) {
|
||||
whitespace(&pos);
|
||||
item_type = expect(ctx, pos-1, &pos, parse_type, "I couldn't parse a type for this array");
|
||||
whitespace(&pos);
|
||||
match(&pos, ",");
|
||||
whitespace(&pos);
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
ast_t *item = optional(ctx, &pos, parse_extended_expr);
|
||||
if (!item) break;
|
||||
@ -711,7 +702,7 @@ PARSER(parse_array) {
|
||||
expect_closing(ctx, &pos, "]", "I wasn't able to parse the rest of this array");
|
||||
|
||||
REVERSE_LIST(items);
|
||||
return NewAST(ctx->file, start, pos, Array, .item_type=item_type, .items=items);
|
||||
return NewAST(ctx->file, start, pos, Array, .items=items);
|
||||
}
|
||||
|
||||
PARSER(parse_table) {
|
||||
@ -722,20 +713,6 @@ PARSER(parse_table) {
|
||||
whitespace(&pos);
|
||||
|
||||
ast_list_t *entries = NULL;
|
||||
type_ast_t *key_type = NULL, *value_type = NULL;
|
||||
if (match(&pos, ":")) {
|
||||
whitespace(&pos);
|
||||
key_type = expect(ctx, pos-1, &pos, parse_type, "I couldn't parse a key type for this table");
|
||||
whitespace(&pos);
|
||||
if (match(&pos, "=")) {
|
||||
value_type = expect(ctx, pos-1, &pos, parse_type, "I couldn't parse the value type for this table");
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
whitespace(&pos);
|
||||
match(&pos, ",");
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
const char *entry_start = pos;
|
||||
ast_t *key = optional(ctx, &pos, parse_extended_expr);
|
||||
@ -787,8 +764,7 @@ PARSER(parse_table) {
|
||||
whitespace(&pos);
|
||||
expect_closing(ctx, &pos, "}", "I wasn't able to parse the rest of this table");
|
||||
|
||||
return NewAST(ctx->file, start, pos, Table, .key_type=key_type, .value_type=value_type,
|
||||
.default_value=default_value, .entries=entries, .fallback=fallback);
|
||||
return NewAST(ctx->file, start, pos, Table, .default_value=default_value, .entries=entries, .fallback=fallback);
|
||||
}
|
||||
|
||||
PARSER(parse_set) {
|
||||
@ -801,18 +777,6 @@ PARSER(parse_set) {
|
||||
whitespace(&pos);
|
||||
|
||||
ast_list_t *items = NULL;
|
||||
type_ast_t *item_type = NULL;
|
||||
if (match(&pos, ":")) {
|
||||
whitespace(&pos);
|
||||
item_type = expect(ctx, pos-1, &pos, parse_type, "I couldn't parse a key type for this set");
|
||||
whitespace(&pos);
|
||||
if (match(&pos, ","))
|
||||
return NULL;
|
||||
whitespace(&pos);
|
||||
match(&pos, ",");
|
||||
whitespace(&pos);
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
ast_t *item = optional(ctx, &pos, parse_extended_expr);
|
||||
if (!item) break;
|
||||
@ -834,7 +798,7 @@ PARSER(parse_set) {
|
||||
whitespace(&pos);
|
||||
expect_closing(ctx, &pos, "}", "I wasn't able to parse the rest of this set");
|
||||
|
||||
return NewAST(ctx->file, start, pos, Set, .item_type=item_type, .items=items);
|
||||
return NewAST(ctx->file, start, pos, Set, .items=items);
|
||||
}
|
||||
|
||||
ast_t *parse_field_suffix(parse_ctx_t *ctx, ast_t *lhs) {
|
||||
@ -874,11 +838,11 @@ PARSER(parse_reduction) {
|
||||
if (!match(&pos, "(")) return NULL;
|
||||
|
||||
whitespace(&pos);
|
||||
binop_e op = match_binary_operator(&pos);
|
||||
if (op == BINOP_UNKNOWN) return NULL;
|
||||
ast_e op = match_binary_operator(&pos);
|
||||
if (op == Unknown) return NULL;
|
||||
|
||||
ast_t *key = NULL;
|
||||
if (op == BINOP_MIN || op == BINOP_MAX) {
|
||||
if (op == Min || op == Max) {
|
||||
key = NewAST(ctx->file, pos, pos, Var, .name="$");
|
||||
for (bool progress = true; progress; ) {
|
||||
ast_t *new_term;
|
||||
@ -1425,16 +1389,7 @@ PARSER(parse_none) {
|
||||
const char *start = pos;
|
||||
if (!match_word(&pos, "none"))
|
||||
return NULL;
|
||||
|
||||
const char *none_end = pos;
|
||||
spaces(&pos);
|
||||
if (!match(&pos, ":"))
|
||||
return NewAST(ctx->file, start, none_end, None, .type=NULL);
|
||||
|
||||
spaces(&pos);
|
||||
type_ast_t *type = parse_type(ctx, pos);
|
||||
if (!type) return NULL;
|
||||
return NewAST(ctx->file, start, type->end, None, .type=type);
|
||||
return NewAST(ctx->file, start, pos, None);
|
||||
}
|
||||
|
||||
PARSER(parse_deserialize) {
|
||||
@ -1602,53 +1557,53 @@ ast_t *parse_fncall_suffix(parse_ctx_t *ctx, ast_t *fn) {
|
||||
return NewAST(ctx->file, start, pos, FunctionCall, .fn=fn, .args=args);
|
||||
}
|
||||
|
||||
binop_e match_binary_operator(const char **pos)
|
||||
ast_e match_binary_operator(const char **pos)
|
||||
{
|
||||
switch (**pos) {
|
||||
case '+': {
|
||||
*pos += 1;
|
||||
return match(pos, "+") ? BINOP_CONCAT : BINOP_PLUS;
|
||||
return match(pos, "+") ? Concat : Plus;
|
||||
}
|
||||
case '-': {
|
||||
*pos += 1;
|
||||
if ((*pos)[0] != ' ' && (*pos)[-2] == ' ') // looks like `fn -5`
|
||||
return BINOP_UNKNOWN;
|
||||
return BINOP_MINUS;
|
||||
return Unknown;
|
||||
return Minus;
|
||||
}
|
||||
case '*': *pos += 1; return BINOP_MULT;
|
||||
case '/': *pos += 1; return BINOP_DIVIDE;
|
||||
case '^': *pos += 1; return BINOP_POWER;
|
||||
case '*': *pos += 1; return Multiply;
|
||||
case '/': *pos += 1; return Divide;
|
||||
case '^': *pos += 1; return Power;
|
||||
case '<': {
|
||||
*pos += 1;
|
||||
if (match(pos, "=")) return BINOP_LE; // "<="
|
||||
else if (match(pos, ">")) return BINOP_CMP; // "<>"
|
||||
if (match(pos, "=")) return LessThanOrEquals; // "<="
|
||||
else if (match(pos, ">")) return Compare; // "<>"
|
||||
else if (match(pos, "<")) {
|
||||
if (match(pos, "<"))
|
||||
return BINOP_ULSHIFT; // "<<<"
|
||||
return BINOP_LSHIFT; // "<<"
|
||||
} else return BINOP_LT;
|
||||
return UnsignedLeftShift; // "<<<"
|
||||
return LeftShift; // "<<"
|
||||
} else return LessThan;
|
||||
}
|
||||
case '>': {
|
||||
*pos += 1;
|
||||
if (match(pos, "=")) return BINOP_GE; // ">="
|
||||
if (match(pos, "=")) return GreaterThanOrEquals; // ">="
|
||||
if (match(pos, ">")) {
|
||||
if (match(pos, ">"))
|
||||
return BINOP_URSHIFT; // ">>>"
|
||||
return BINOP_RSHIFT; // ">>"
|
||||
return UnsignedRightShift; // ">>>"
|
||||
return RightShift; // ">>"
|
||||
}
|
||||
return BINOP_GT;
|
||||
return GreaterThan;
|
||||
}
|
||||
default: {
|
||||
if (match(pos, "!=")) return BINOP_NE;
|
||||
else if (match(pos, "==") && **pos != '=') return BINOP_EQ;
|
||||
else if (match_word(pos, "and")) return BINOP_AND;
|
||||
else if (match_word(pos, "or")) return BINOP_OR;
|
||||
else if (match_word(pos, "xor")) return BINOP_XOR;
|
||||
else if (match_word(pos, "mod1")) return BINOP_MOD1;
|
||||
else if (match_word(pos, "mod")) return BINOP_MOD;
|
||||
else if (match_word(pos, "_min_")) return BINOP_MIN;
|
||||
else if (match_word(pos, "_max_")) return BINOP_MAX;
|
||||
else return BINOP_UNKNOWN;
|
||||
if (match(pos, "!=")) return NotEquals;
|
||||
else if (match(pos, "==") && **pos != '=') return Equals;
|
||||
else if (match_word(pos, "and")) return And;
|
||||
else if (match_word(pos, "or")) return Or;
|
||||
else if (match_word(pos, "xor")) return Xor;
|
||||
else if (match_word(pos, "mod1")) return Mod1;
|
||||
else if (match_word(pos, "mod")) return Mod;
|
||||
else if (match_word(pos, "_min_")) return Min;
|
||||
else if (match_word(pos, "_max_")) return Max;
|
||||
else return Unknown;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1660,9 +1615,9 @@ static ast_t *parse_infix_expr(parse_ctx_t *ctx, const char *pos, int min_tightn
|
||||
int64_t starting_line = get_line_number(ctx->file, pos);
|
||||
int64_t starting_indent = get_indent(ctx, pos);
|
||||
spaces(&pos);
|
||||
for (binop_e op; (op=match_binary_operator(&pos)) != BINOP_UNKNOWN && op_tightness[op] >= min_tightness; spaces(&pos)) {
|
||||
for (ast_e op; (op=match_binary_operator(&pos)) != Unknown && op_tightness[op] >= min_tightness; spaces(&pos)) {
|
||||
ast_t *key = NULL;
|
||||
if (op == BINOP_MIN || op == BINOP_MAX) {
|
||||
if (op == Min || op == Max) {
|
||||
key = NewAST(ctx->file, pos, pos, Var, .name="$");
|
||||
for (bool progress = true; progress; ) {
|
||||
ast_t *new_term;
|
||||
@ -1688,12 +1643,12 @@ static ast_t *parse_infix_expr(parse_ctx_t *ctx, const char *pos, int min_tightn
|
||||
if (!rhs) break;
|
||||
pos = rhs->end;
|
||||
|
||||
if (op == BINOP_MIN) {
|
||||
if (op == Min) {
|
||||
return NewAST(ctx->file, lhs->start, rhs->end, Min, .lhs=lhs, .rhs=rhs, .key=key);
|
||||
} else if (op == BINOP_MAX) {
|
||||
} else if (op == Max) {
|
||||
return NewAST(ctx->file, lhs->start, rhs->end, Max, .lhs=lhs, .rhs=rhs, .key=key);
|
||||
} else {
|
||||
lhs = NewAST(ctx->file, lhs->start, rhs->end, BinaryOp, .lhs=lhs, .op=op, .rhs=rhs);
|
||||
lhs = new(ast_t, .file=ctx->file, .start=lhs->start, .end=rhs->end, .tag=op, .__data.Plus.lhs=lhs, .__data.Plus.rhs=rhs);
|
||||
}
|
||||
}
|
||||
return lhs;
|
||||
@ -1709,8 +1664,11 @@ PARSER(parse_declaration) {
|
||||
if (!var) return NULL;
|
||||
pos = var->end;
|
||||
spaces(&pos);
|
||||
if (!match(&pos, ":=")) return NULL;
|
||||
if (!match(&pos, ":")) return NULL;
|
||||
spaces(&pos);
|
||||
type_ast_t *type = optional(ctx, &pos, parse_type);
|
||||
spaces(&pos);
|
||||
if (!match(&pos, "=")) return NULL;
|
||||
ast_t *val = optional(ctx, &pos, parse_extended_expr);
|
||||
if (!val) {
|
||||
if (optional(ctx, &pos, parse_use))
|
||||
@ -1718,7 +1676,7 @@ PARSER(parse_declaration) {
|
||||
else
|
||||
parser_err(ctx, pos, eol(pos), "This is not a valid expression");
|
||||
}
|
||||
return NewAST(ctx->file, start, pos, Declare, .var=var, .value=val);
|
||||
return NewAST(ctx->file, start, pos, Declare, .var=var, .type=type, .value=val);
|
||||
}
|
||||
|
||||
PARSER(parse_update) {
|
||||
@ -1726,23 +1684,23 @@ PARSER(parse_update) {
|
||||
ast_t *lhs = optional(ctx, &pos, parse_expr);
|
||||
if (!lhs) return NULL;
|
||||
spaces(&pos);
|
||||
binop_e op;
|
||||
if (match(&pos, "+=")) op = BINOP_PLUS;
|
||||
else if (match(&pos, "++=")) op = BINOP_CONCAT;
|
||||
else if (match(&pos, "-=")) op = BINOP_MINUS;
|
||||
else if (match(&pos, "*=")) op = BINOP_MULT;
|
||||
else if (match(&pos, "/=")) op = BINOP_DIVIDE;
|
||||
else if (match(&pos, "^=")) op = BINOP_POWER;
|
||||
else if (match(&pos, "<<=")) op = BINOP_LSHIFT;
|
||||
else if (match(&pos, "<<<=")) op = BINOP_ULSHIFT;
|
||||
else if (match(&pos, ">>=")) op = BINOP_RSHIFT;
|
||||
else if (match(&pos, ">>>=")) op = BINOP_URSHIFT;
|
||||
else if (match(&pos, "and=")) op = BINOP_AND;
|
||||
else if (match(&pos, "or=")) op = BINOP_OR;
|
||||
else if (match(&pos, "xor=")) op = BINOP_XOR;
|
||||
ast_e op;
|
||||
if (match(&pos, "+=")) op = Plus;
|
||||
else if (match(&pos, "++=")) op = Concat;
|
||||
else if (match(&pos, "-=")) op = Minus;
|
||||
else if (match(&pos, "*=")) op = Multiply;
|
||||
else if (match(&pos, "/=")) op = Divide;
|
||||
else if (match(&pos, "^=")) op = Power;
|
||||
else if (match(&pos, "<<=")) op = LeftShift;
|
||||
else if (match(&pos, "<<<=")) op = UnsignedLeftShift;
|
||||
else if (match(&pos, ">>=")) op = RightShift;
|
||||
else if (match(&pos, ">>>=")) op = UnsignedRightShift;
|
||||
else if (match(&pos, "and=")) op = And;
|
||||
else if (match(&pos, "or=")) op = Or;
|
||||
else if (match(&pos, "xor=")) op = Xor;
|
||||
else return NULL;
|
||||
ast_t *rhs = expect(ctx, start, &pos, parse_extended_expr, "I expected an expression here");
|
||||
return NewAST(ctx->file, start, pos, UpdateAssign, .lhs=lhs, .rhs=rhs, .op=op);
|
||||
return new(ast_t, .file=ctx->file, .start=start, .end=pos, .tag=op, .__data.PlusUpdate.lhs=lhs, .__data.PlusUpdate.rhs=rhs);
|
||||
}
|
||||
|
||||
PARSER(parse_assignment) {
|
||||
|
||||
120
src/repl.c
120
src/repl.c
@ -186,31 +186,31 @@ static Int_t ast_to_int(env_t *env, ast_t *ast)
|
||||
}
|
||||
}
|
||||
|
||||
static double ast_to_num(env_t *env, ast_t *ast)
|
||||
{
|
||||
type_t *t = get_type(env, ast);
|
||||
switch (t->tag) {
|
||||
case BigIntType: case IntType: {
|
||||
number_t num;
|
||||
eval(env, ast, &num);
|
||||
if (t->tag == BigIntType)
|
||||
return Num$from_int(num.integer, false);
|
||||
switch (Match(t, IntType)->bits) {
|
||||
case TYPE_IBITS64: return Num$from_int64(num.i64, false);
|
||||
case TYPE_IBITS32: return Num$from_int32(num.i32);
|
||||
case TYPE_IBITS16: return Num$from_int16(num.i16);
|
||||
case TYPE_IBITS8: return Num$from_int8(num.i8);
|
||||
default: print_err("Invalid int bits");
|
||||
}
|
||||
}
|
||||
case NumType: {
|
||||
number_t num;
|
||||
eval(env, ast, &num);
|
||||
return Match(t, NumType)->bits == TYPE_NBITS32 ? (double)num.n32 : (double)num.n64;
|
||||
}
|
||||
default: print_err("Cannot convert to number");
|
||||
}
|
||||
}
|
||||
// static double ast_to_num(env_t *env, ast_t *ast)
|
||||
// {
|
||||
// type_t *t = get_type(env, ast);
|
||||
// switch (t->tag) {
|
||||
// case BigIntType: case IntType: {
|
||||
// number_t num;
|
||||
// eval(env, ast, &num);
|
||||
// if (t->tag == BigIntType)
|
||||
// return Num$from_int(num.integer, false);
|
||||
// switch (Match(t, IntType)->bits) {
|
||||
// case TYPE_IBITS64: return Num$from_int64(num.i64, false);
|
||||
// case TYPE_IBITS32: return Num$from_int32(num.i32);
|
||||
// case TYPE_IBITS16: return Num$from_int16(num.i16);
|
||||
// case TYPE_IBITS8: return Num$from_int8(num.i8);
|
||||
// default: print_err("Invalid int bits");
|
||||
// }
|
||||
// }
|
||||
// case NumType: {
|
||||
// number_t num;
|
||||
// eval(env, ast, &num);
|
||||
// return Match(t, NumType)->bits == TYPE_NBITS32 ? (double)num.n32 : (double)num.n64;
|
||||
// }
|
||||
// default: print_err("Cannot convert to number");
|
||||
// }
|
||||
// }
|
||||
|
||||
static Text_t obj_to_text(type_t *t, const void *obj, bool use_color)
|
||||
{
|
||||
@ -386,76 +386,6 @@ void eval(env_t *env, ast_t *ast, void *dest)
|
||||
if (dest) *(CORD*)dest = ret;
|
||||
break;
|
||||
}
|
||||
case BinaryOp: {
|
||||
auto binop = Match(ast, BinaryOp);
|
||||
if (t->tag == IntType || t->tag == BigIntType) {
|
||||
#define CASE_OP(OP_NAME, method_name) case BINOP_##OP_NAME: {\
|
||||
Int_t lhs = ast_to_int(env, binop->lhs); \
|
||||
Int_t rhs = ast_to_int(env, binop->rhs); \
|
||||
Int_t result = Int$ ## method_name (lhs, rhs); \
|
||||
if (t->tag == BigIntType) {\
|
||||
*(Int_t*)dest = result; \
|
||||
return; \
|
||||
} \
|
||||
switch (Match(t, IntType)->bits) { \
|
||||
case 64: *(int64_t*)dest = Int64$from_int(result, false); return; \
|
||||
case 32: *(int32_t*)dest = Int32$from_int(result, false); return; \
|
||||
case 16: *(int16_t*)dest = Int16$from_int(result, false); return; \
|
||||
case 8: *(int8_t*)dest = Int8$from_int(result, false); return; \
|
||||
default: print_err("Invalid int bits"); \
|
||||
} \
|
||||
break; \
|
||||
}
|
||||
switch (binop->op) {
|
||||
CASE_OP(MULT, times) CASE_OP(DIVIDE, divided_by) CASE_OP(PLUS, plus) CASE_OP(MINUS, minus)
|
||||
CASE_OP(RSHIFT, right_shifted) CASE_OP(LSHIFT, left_shifted)
|
||||
CASE_OP(MOD, modulo) CASE_OP(MOD1, modulo1)
|
||||
CASE_OP(AND, bit_and) CASE_OP(OR, bit_or) CASE_OP(XOR, bit_xor)
|
||||
default: break;
|
||||
}
|
||||
#undef CASE_OP
|
||||
} else if (t->tag == NumType) {
|
||||
#define CASE_OP(OP_NAME, C_OP) case BINOP_##OP_NAME: {\
|
||||
double lhs = ast_to_num(env, binop->lhs); \
|
||||
double rhs = ast_to_num(env, binop->rhs); \
|
||||
if (Match(t, NumType)->bits == 64) \
|
||||
*(double*)dest = (double)(lhs C_OP rhs); \
|
||||
else \
|
||||
*(float*)dest = (float)(lhs C_OP rhs); \
|
||||
return; \
|
||||
}
|
||||
switch (binop->op) {
|
||||
CASE_OP(MULT, *) CASE_OP(DIVIDE, /) CASE_OP(PLUS, +) CASE_OP(MINUS, -)
|
||||
default: break;
|
||||
}
|
||||
#undef CASE_OP
|
||||
}
|
||||
switch (binop->op) {
|
||||
case BINOP_EQ: case BINOP_NE: case BINOP_LT: case BINOP_LE: case BINOP_GT: case BINOP_GE: {
|
||||
type_t *t_lhs = get_type(env, binop->lhs);
|
||||
if (!type_eq(t_lhs, get_type(env, binop->rhs)))
|
||||
print_err("Comparisons between different types aren't supported");
|
||||
const TypeInfo_t *info = type_to_type_info(t_lhs);
|
||||
size_t value_size = type_size(t_lhs);
|
||||
char lhs[value_size], rhs[value_size];
|
||||
eval(env, binop->lhs, lhs);
|
||||
eval(env, binop->rhs, rhs);
|
||||
int cmp = generic_compare(lhs, rhs, info);
|
||||
switch (binop->op) {
|
||||
case BINOP_EQ: *(bool*)dest = (cmp == 0); break;
|
||||
case BINOP_NE: *(bool*)dest = (cmp != 0); break;
|
||||
case BINOP_GT: *(bool*)dest = (cmp > 0); break;
|
||||
case BINOP_GE: *(bool*)dest = (cmp >= 0); break;
|
||||
case BINOP_LT: *(bool*)dest = (cmp < 0); break;
|
||||
case BINOP_LE: *(bool*)dest = (cmp <= 0); break;
|
||||
default: break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: print_err(1, "Binary op not implemented for ", type_to_str(t), ": ", ast_to_xml_str(ast));
|
||||
}
|
||||
break;
|
||||
}
|
||||
case Index: {
|
||||
auto index = Match(ast, Index);
|
||||
type_t *indexed_t = get_type(env, index->indexed);
|
||||
|
||||
559
src/typecheck.c
559
src/typecheck.c
@ -135,27 +135,27 @@ type_t *parse_type_ast(env_t *env, type_ast_t *ast)
|
||||
errx(1, "Unreachable");
|
||||
}
|
||||
|
||||
static PUREFUNC bool risks_zero_or_inf(ast_t *ast)
|
||||
{
|
||||
switch (ast->tag) {
|
||||
case Int: {
|
||||
const char *str = Match(ast, Int)->str;
|
||||
OptionalInt_t int_val = Int$from_str(str);
|
||||
return (int_val.small == 0x1); // zero
|
||||
}
|
||||
case Num: {
|
||||
return Match(ast, Num)->n == 0.0;
|
||||
}
|
||||
case BinaryOp: {
|
||||
auto binop = Match(ast, BinaryOp);
|
||||
if (binop->op == BINOP_MULT || binop->op == BINOP_DIVIDE || binop->op == BINOP_MIN || binop->op == BINOP_MAX)
|
||||
return risks_zero_or_inf(binop->lhs) || risks_zero_or_inf(binop->rhs);
|
||||
else
|
||||
return true;
|
||||
}
|
||||
default: return true;
|
||||
}
|
||||
}
|
||||
// static PUREFUNC bool risks_zero_or_inf(ast_t *ast)
|
||||
// {
|
||||
// switch (ast->tag) {
|
||||
// case Int: {
|
||||
// const char *str = Match(ast, Int)->str;
|
||||
// OptionalInt_t int_val = Int$from_str(str);
|
||||
// return (int_val.small == 0x1); // zero
|
||||
// }
|
||||
// case Num: {
|
||||
// return Match(ast, Num)->n == 0.0;
|
||||
// }
|
||||
// case BINOP_CASES: {
|
||||
// binary_operands_t binop = BINARY_OPERANDS(ast);
|
||||
// if (ast->tag == Multiply || ast->tag == Divide || ast->tag == Min || ast->tag == Max)
|
||||
// return risks_zero_or_inf(binop.lhs) || risks_zero_or_inf(binop.rhs);
|
||||
// else
|
||||
// return true;
|
||||
// }
|
||||
// default: return true;
|
||||
// }
|
||||
// }
|
||||
|
||||
PUREFUNC type_t *get_math_type(env_t *env, ast_t *ast, type_t *lhs_t, type_t *rhs_t)
|
||||
{
|
||||
@ -312,7 +312,7 @@ void bind_statement(env_t *env, ast_t *statement)
|
||||
if (get_binding(env, name))
|
||||
code_err(decl->var, "A ", type_to_str(get_binding(env, name)->type), " called ", quoted(name), " has already been defined");
|
||||
bind_statement(env, decl->value);
|
||||
type_t *type = get_type(env, decl->value);
|
||||
type_t *type = decl->type ? parse_type_ast(env, decl->type) : get_type(env, decl->value);
|
||||
if (!type)
|
||||
code_err(decl->value, "I couldn't figure out the type of this value");
|
||||
if (type->tag == FunctionType)
|
||||
@ -617,12 +617,7 @@ type_t *get_type(env_t *env, ast_t *ast)
|
||||
#endif
|
||||
switch (ast->tag) {
|
||||
case None: {
|
||||
if (!Match(ast, None)->type)
|
||||
return Type(OptionalType, .type=NULL);
|
||||
type_t *t = parse_type_ast(env, Match(ast, None)->type);
|
||||
if (t->tag == OptionalType)
|
||||
code_err(ast, "Nested optional types are not supported. This should be: `none:", type_to_str(Match(t, OptionalType)->type), "`");
|
||||
return Type(OptionalType, .type=t);
|
||||
return Type(OptionalType, .type=NULL);
|
||||
}
|
||||
case Bool: {
|
||||
return Type(BoolType);
|
||||
@ -714,115 +709,91 @@ type_t *get_type(env_t *env, ast_t *ast)
|
||||
case Array: {
|
||||
auto array = Match(ast, Array);
|
||||
type_t *item_type = NULL;
|
||||
if (array->item_type) {
|
||||
item_type = parse_type_ast(env, array->item_type);
|
||||
} else if (array->items) {
|
||||
for (ast_list_t *item = array->items; item; item = item->next) {
|
||||
ast_t *item_ast = item->ast;
|
||||
env_t *scope = env;
|
||||
while (item_ast->tag == Comprehension) {
|
||||
auto comp = Match(item_ast, Comprehension);
|
||||
scope = for_scope(
|
||||
scope, FakeAST(For, .iter=comp->iter, .vars=comp->vars));
|
||||
item_ast = comp->expr;
|
||||
}
|
||||
type_t *t2 = get_type(scope, item_ast);
|
||||
type_t *merged = item_type ? type_or_type(item_type, t2) : t2;
|
||||
if (!merged)
|
||||
code_err(item->ast,
|
||||
"This array item has type ", type_to_str(t2),
|
||||
", which is different from earlier array items which have type ", type_to_str(item_type));
|
||||
item_type = merged;
|
||||
for (ast_list_t *item = array->items; item; item = item->next) {
|
||||
ast_t *item_ast = item->ast;
|
||||
env_t *scope = env;
|
||||
while (item_ast->tag == Comprehension) {
|
||||
auto comp = Match(item_ast, Comprehension);
|
||||
scope = for_scope(
|
||||
scope, FakeAST(For, .iter=comp->iter, .vars=comp->vars));
|
||||
item_ast = comp->expr;
|
||||
}
|
||||
} else {
|
||||
code_err(ast, "I can't figure out what type this array has because it has no members or explicit type");
|
||||
type_t *t2 = get_type(scope, item_ast);
|
||||
type_t *merged = item_type ? type_or_type(item_type, t2) : t2;
|
||||
if (!merged)
|
||||
code_err(item->ast,
|
||||
"This array item has type ", type_to_str(t2),
|
||||
", which is different from earlier array items which have type ", type_to_str(item_type));
|
||||
item_type = merged;
|
||||
}
|
||||
if (has_stack_memory(item_type))
|
||||
code_err(ast, "Arrays cannot hold stack references, because the array may outlive the stack frame the reference was created in.");
|
||||
|
||||
if (!item_type)
|
||||
code_err(ast, "I couldn't figure out the item type for this array!");
|
||||
if (item_type && has_stack_memory(item_type))
|
||||
code_err(ast, "Arrays cannot hold stack references, because the array may outlive the stack frame the reference was created in.");
|
||||
|
||||
return Type(ArrayType, .item_type=item_type);
|
||||
}
|
||||
case Set: {
|
||||
auto set = Match(ast, Set);
|
||||
type_t *item_type = NULL;
|
||||
if (set->item_type) {
|
||||
item_type = parse_type_ast(env, set->item_type);
|
||||
} else {
|
||||
for (ast_list_t *item = set->items; item; item = item->next) {
|
||||
ast_t *item_ast = item->ast;
|
||||
env_t *scope = env;
|
||||
while (item_ast->tag == Comprehension) {
|
||||
auto comp = Match(item_ast, Comprehension);
|
||||
scope = for_scope(
|
||||
scope, FakeAST(For, .iter=comp->iter, .vars=comp->vars));
|
||||
item_ast = comp->expr;
|
||||
}
|
||||
|
||||
type_t *this_item_type = get_type(scope, item_ast);
|
||||
type_t *item_merged = type_or_type(item_type, this_item_type);
|
||||
if (!item_merged)
|
||||
code_err(item_ast,
|
||||
"This set item has type ", type_to_str(this_item_type),
|
||||
", which is different from earlier set items which have type ", type_to_str(item_type));
|
||||
item_type = item_merged;
|
||||
for (ast_list_t *item = set->items; item; item = item->next) {
|
||||
ast_t *item_ast = item->ast;
|
||||
env_t *scope = env;
|
||||
while (item_ast->tag == Comprehension) {
|
||||
auto comp = Match(item_ast, Comprehension);
|
||||
scope = for_scope(
|
||||
scope, FakeAST(For, .iter=comp->iter, .vars=comp->vars));
|
||||
item_ast = comp->expr;
|
||||
}
|
||||
|
||||
type_t *this_item_type = get_type(scope, item_ast);
|
||||
type_t *item_merged = type_or_type(item_type, this_item_type);
|
||||
if (!item_merged)
|
||||
code_err(item_ast,
|
||||
"This set item has type ", type_to_str(this_item_type),
|
||||
", which is different from earlier set items which have type ", type_to_str(item_type));
|
||||
item_type = item_merged;
|
||||
}
|
||||
|
||||
if (!item_type)
|
||||
code_err(ast, "I couldn't figure out the item type for this set!");
|
||||
|
||||
if (has_stack_memory(item_type))
|
||||
if (item_type && has_stack_memory(item_type))
|
||||
code_err(ast, "Sets cannot hold stack references because the set may outlive the reference's stack frame.");
|
||||
|
||||
return Type(SetType, .item_type=item_type);
|
||||
}
|
||||
case Table: {
|
||||
auto table = Match(ast, Table);
|
||||
type_t *key_type = NULL, *value_type = NULL;
|
||||
if (table->key_type && table->value_type) {
|
||||
key_type = parse_type_ast(env, table->key_type);
|
||||
value_type = parse_type_ast(env, table->value_type);
|
||||
} else if (table->key_type && table->default_value) {
|
||||
key_type = parse_type_ast(env, table->key_type);
|
||||
value_type = get_type(env, table->default_value);
|
||||
} else {
|
||||
for (ast_list_t *entry = table->entries; entry; entry = entry->next) {
|
||||
ast_t *entry_ast = entry->ast;
|
||||
env_t *scope = env;
|
||||
while (entry_ast->tag == Comprehension) {
|
||||
auto comp = Match(entry_ast, Comprehension);
|
||||
scope = for_scope(
|
||||
scope, FakeAST(For, .iter=comp->iter, .vars=comp->vars));
|
||||
entry_ast = comp->expr;
|
||||
}
|
||||
|
||||
auto e = Match(entry_ast, TableEntry);
|
||||
type_t *key_t = get_type(scope, e->key);
|
||||
type_t *value_t = get_type(scope, e->value);
|
||||
|
||||
type_t *key_merged = key_type ? type_or_type(key_type, key_t) : key_t;
|
||||
if (!key_merged)
|
||||
code_err(entry->ast,
|
||||
"This table entry has type ", type_to_str(key_t),
|
||||
", which is different from earlier table entries which have type ", type_to_str(key_type));
|
||||
key_type = key_merged;
|
||||
|
||||
type_t *val_merged = value_type ? type_or_type(value_type, value_t) : value_t;
|
||||
if (!val_merged)
|
||||
code_err(entry->ast,
|
||||
"This table entry has type ", type_to_str(value_t),
|
||||
", which is different from earlier table entries which have type ", type_to_str(value_type));
|
||||
value_type = val_merged;
|
||||
for (ast_list_t *entry = table->entries; entry; entry = entry->next) {
|
||||
ast_t *entry_ast = entry->ast;
|
||||
env_t *scope = env;
|
||||
while (entry_ast->tag == Comprehension) {
|
||||
auto comp = Match(entry_ast, Comprehension);
|
||||
scope = for_scope(
|
||||
scope, FakeAST(For, .iter=comp->iter, .vars=comp->vars));
|
||||
entry_ast = comp->expr;
|
||||
}
|
||||
|
||||
auto e = Match(entry_ast, TableEntry);
|
||||
type_t *key_t = get_type(scope, e->key);
|
||||
type_t *value_t = get_type(scope, e->value);
|
||||
|
||||
type_t *key_merged = key_type ? type_or_type(key_type, key_t) : key_t;
|
||||
if (!key_merged)
|
||||
code_err(entry->ast,
|
||||
"This table entry has type ", type_to_str(key_t),
|
||||
", which is different from earlier table entries which have type ", type_to_str(key_type));
|
||||
key_type = key_merged;
|
||||
|
||||
type_t *val_merged = value_type ? type_or_type(value_type, value_t) : value_t;
|
||||
if (!val_merged)
|
||||
code_err(entry->ast,
|
||||
"This table entry has type ", type_to_str(value_t),
|
||||
", which is different from earlier table entries which have type ", type_to_str(value_type));
|
||||
value_type = val_merged;
|
||||
}
|
||||
|
||||
if (!key_type || !value_type)
|
||||
code_err(ast, "I couldn't figure out the key and value types for this table!");
|
||||
|
||||
if (has_stack_memory(key_type) || has_stack_memory(value_type))
|
||||
if ((key_type && has_stack_memory(key_type)) || (value_type && has_stack_memory(value_type)))
|
||||
code_err(ast, "Tables cannot hold stack references because the table may outlive the reference's stack frame.");
|
||||
|
||||
return Type(TableType, .key_type=key_type, .value_type=value_type, .default_value=table->default_value, .env=env);
|
||||
}
|
||||
case TableEntry: {
|
||||
@ -998,7 +969,7 @@ type_t *get_type(env_t *env, ast_t *ast)
|
||||
|
||||
// Early out if the type is knowable without any context from the block:
|
||||
switch (last->ast->tag) {
|
||||
case UpdateAssign: case Assign: case Declare: case FunctionDef: case ConvertDef: case StructDef: case EnumDef: case LangDef: case Extend:
|
||||
case UPDATE_CASES: case Assign: case Declare: case FunctionDef: case ConvertDef: case StructDef: case EnumDef: case LangDef: case Extend:
|
||||
return Type(VoidType);
|
||||
default: break;
|
||||
}
|
||||
@ -1022,7 +993,7 @@ type_t *get_type(env_t *env, ast_t *ast)
|
||||
case Extern: {
|
||||
return parse_type_ast(env, Match(ast, Extern)->type);
|
||||
}
|
||||
case Declare: case Assign: case DocTest: {
|
||||
case Declare: case Assign: case UPDATE_CASES: case DocTest: {
|
||||
return Type(VoidType);
|
||||
}
|
||||
case Use: {
|
||||
@ -1078,169 +1049,160 @@ type_t *get_type(env_t *env, ast_t *ast)
|
||||
}
|
||||
code_err(ast, "I only know how to get 'not' of boolean, numeric, and optional pointer types, not ", type_to_str(t));
|
||||
}
|
||||
case BinaryOp: {
|
||||
auto binop = Match(ast, BinaryOp);
|
||||
type_t *lhs_t = get_type(env, binop->lhs),
|
||||
*rhs_t = get_type(env, binop->rhs);
|
||||
case Or: {
|
||||
binary_operands_t binop = BINARY_OPERANDS(ast);
|
||||
type_t *lhs_t = get_type(env, binop.lhs);
|
||||
type_t *rhs_t = get_type(env, binop.rhs);
|
||||
|
||||
if (lhs_t->tag == BigIntType && rhs_t->tag != BigIntType && is_numeric_type(rhs_t) && binop->lhs->tag == Int) {
|
||||
lhs_t = rhs_t;
|
||||
} else if (rhs_t->tag == BigIntType && lhs_t->tag != BigIntType && is_numeric_type(lhs_t) && binop->rhs->tag == Int) {
|
||||
|
||||
rhs_t = lhs_t;
|
||||
}
|
||||
|
||||
#define binding_works(name, self, lhs_t, rhs_t, ret_t) \
|
||||
({ binding_t *b = get_namespace_binding(env, self, name); \
|
||||
(b && b->type->tag == FunctionType && ({ auto fn = Match(b->type, FunctionType); \
|
||||
(type_eq(fn->ret, ret_t) \
|
||||
&& (fn->args && type_eq(fn->args->type, lhs_t)) \
|
||||
&& (fn->args->next && can_promote(rhs_t, fn->args->next->type))); })); })
|
||||
// Check for a binop method like plus() etc:
|
||||
switch (binop->op) {
|
||||
case BINOP_MULT: {
|
||||
if (is_numeric_type(lhs_t) && binding_works("scaled_by", binop->rhs, rhs_t, lhs_t, rhs_t))
|
||||
return rhs_t;
|
||||
else if (is_numeric_type(rhs_t) && binding_works("scaled_by", binop->lhs, lhs_t, rhs_t, lhs_t))
|
||||
return lhs_t;
|
||||
else if (type_eq(lhs_t, rhs_t) && binding_works(binop_method_names[binop->op], binop->lhs, lhs_t, rhs_t, lhs_t))
|
||||
return lhs_t;
|
||||
break;
|
||||
}
|
||||
case BINOP_PLUS: case BINOP_MINUS: case BINOP_AND: case BINOP_OR: case BINOP_XOR: case BINOP_CONCAT: {
|
||||
if (type_eq(lhs_t, rhs_t) && binding_works(binop_method_names[binop->op], binop->lhs, lhs_t, rhs_t, lhs_t))
|
||||
return lhs_t;
|
||||
break;
|
||||
}
|
||||
case BINOP_DIVIDE: case BINOP_MOD: case BINOP_MOD1: {
|
||||
if (is_numeric_type(rhs_t) && binding_works(binop_method_names[binop->op], binop->lhs, lhs_t, rhs_t, lhs_t))
|
||||
return lhs_t;
|
||||
break;
|
||||
}
|
||||
case BINOP_LSHIFT: case BINOP_RSHIFT: case BINOP_ULSHIFT: case BINOP_URSHIFT: {
|
||||
return lhs_t;
|
||||
}
|
||||
case BINOP_POWER: {
|
||||
if (is_numeric_type(rhs_t) && binding_works(binop_method_names[binop->op], binop->lhs, lhs_t, rhs_t, lhs_t))
|
||||
return lhs_t;
|
||||
break;
|
||||
}
|
||||
default: break;
|
||||
}
|
||||
#undef binding_works
|
||||
|
||||
switch (binop->op) {
|
||||
case BINOP_AND: {
|
||||
if (lhs_t->tag == BoolType && rhs_t->tag == BoolType) {
|
||||
return lhs_t;
|
||||
} else if ((lhs_t->tag == BoolType && rhs_t->tag == OptionalType) ||
|
||||
(lhs_t->tag == OptionalType && rhs_t->tag == BoolType)) {
|
||||
return Type(BoolType);
|
||||
} else if (lhs_t->tag == BoolType && (rhs_t->tag == AbortType || rhs_t->tag == ReturnType)) {
|
||||
return lhs_t;
|
||||
} else if (rhs_t->tag == AbortType || rhs_t->tag == ReturnType) {
|
||||
return lhs_t;
|
||||
} else if (rhs_t->tag == OptionalType) {
|
||||
if (can_promote(lhs_t, rhs_t))
|
||||
return rhs_t;
|
||||
} else if (lhs_t->tag == PointerType && rhs_t->tag == PointerType) {
|
||||
auto lhs_ptr = Match(lhs_t, PointerType);
|
||||
auto rhs_ptr = Match(rhs_t, PointerType);
|
||||
if (type_eq(lhs_ptr->pointed, rhs_ptr->pointed))
|
||||
return Type(PointerType, .pointed=lhs_ptr->pointed);
|
||||
} else if ((is_int_type(lhs_t) && is_int_type(rhs_t))
|
||||
|| (lhs_t->tag == ByteType && rhs_t->tag == ByteType)) {
|
||||
return get_math_type(env, ast, lhs_t, rhs_t);
|
||||
}
|
||||
code_err(ast, "I can't figure out the type of this `and` expression between a ", type_to_str(lhs_t), " and a ", type_to_str(rhs_t));
|
||||
}
|
||||
case BINOP_OR: {
|
||||
if (lhs_t->tag == BoolType && rhs_t->tag == BoolType) {
|
||||
return lhs_t;
|
||||
} else if ((lhs_t->tag == BoolType && rhs_t->tag == OptionalType) ||
|
||||
(lhs_t->tag == OptionalType && rhs_t->tag == BoolType)) {
|
||||
return Type(BoolType);
|
||||
} else if (lhs_t->tag == BoolType && (rhs_t->tag == AbortType || rhs_t->tag == ReturnType)) {
|
||||
return lhs_t;
|
||||
} else if ((is_int_type(lhs_t) && is_int_type(rhs_t))
|
||||
|| (lhs_t->tag == ByteType && rhs_t->tag == ByteType)) {
|
||||
return get_math_type(env, ast, lhs_t, rhs_t);
|
||||
} else if (lhs_t->tag == OptionalType) {
|
||||
if (rhs_t->tag == AbortType || rhs_t->tag == ReturnType)
|
||||
return Match(lhs_t, OptionalType)->type;
|
||||
if (can_promote(rhs_t, lhs_t))
|
||||
return rhs_t;
|
||||
} else if (lhs_t->tag == PointerType) {
|
||||
auto lhs_ptr = Match(lhs_t, PointerType);
|
||||
if (rhs_t->tag == AbortType || rhs_t->tag == ReturnType) {
|
||||
return Type(PointerType, .pointed=lhs_ptr->pointed);
|
||||
} else if (rhs_t->tag == PointerType) {
|
||||
auto rhs_ptr = Match(rhs_t, PointerType);
|
||||
if (type_eq(rhs_ptr->pointed, lhs_ptr->pointed))
|
||||
return Type(PointerType, .pointed=lhs_ptr->pointed);
|
||||
}
|
||||
} else if (rhs_t->tag == OptionalType) {
|
||||
return type_or_type(lhs_t, rhs_t);
|
||||
}
|
||||
code_err(ast, "I can't figure out the type of this `or` expression between a ", type_to_str(lhs_t), " and a ", type_to_str(rhs_t));
|
||||
}
|
||||
case BINOP_XOR: {
|
||||
if (lhs_t->tag == BoolType && rhs_t->tag == BoolType) {
|
||||
return lhs_t;
|
||||
} else if ((lhs_t->tag == BoolType && rhs_t->tag == OptionalType) ||
|
||||
(lhs_t->tag == OptionalType && rhs_t->tag == BoolType)) {
|
||||
return Type(BoolType);
|
||||
} else if ((is_int_type(lhs_t) && is_int_type(rhs_t))
|
||||
|| (lhs_t->tag == ByteType && rhs_t->tag == ByteType)) {
|
||||
return get_math_type(env, ast, lhs_t, rhs_t);
|
||||
}
|
||||
|
||||
code_err(ast, "I can't figure out the type of this `xor` expression between a ", type_to_str(lhs_t), " and a ", type_to_str(rhs_t));
|
||||
}
|
||||
case BINOP_CONCAT: {
|
||||
if (!type_eq(lhs_t, rhs_t))
|
||||
code_err(ast, "The type on the left side of this concatenation doesn't match the right side: ", type_to_str(lhs_t),
|
||||
" vs. ", type_to_str(rhs_t));
|
||||
if (lhs_t->tag == ArrayType || lhs_t->tag == TextType || lhs_t->tag == SetType)
|
||||
return lhs_t;
|
||||
|
||||
code_err(ast, "Only array/set/text value types support concatenation, not ", type_to_str(lhs_t));
|
||||
}
|
||||
case BINOP_EQ: case BINOP_NE: case BINOP_LT: case BINOP_LE: case BINOP_GT: case BINOP_GE: {
|
||||
if (!can_promote(lhs_t, rhs_t) && !can_promote(rhs_t, lhs_t))
|
||||
code_err(ast, "I can't compare these two different types: ", type_to_str(lhs_t), " vs ", type_to_str(rhs_t));
|
||||
// `opt? or (x == y)` / `(x == y) or opt?` is a boolean conditional:
|
||||
if ((lhs_t->tag == OptionalType && rhs_t->tag == BoolType)
|
||||
|| (lhs_t->tag == BoolType && rhs_t->tag == OptionalType)) {
|
||||
return Type(BoolType);
|
||||
}
|
||||
case BINOP_CMP:
|
||||
return Type(IntType, .bits=TYPE_IBITS32);
|
||||
case BINOP_POWER: {
|
||||
type_t *result = get_math_type(env, ast, lhs_t, rhs_t);
|
||||
if (result->tag == NumType)
|
||||
|
||||
if (lhs_t->tag == OptionalType) {
|
||||
if (rhs_t->tag == OptionalType) {
|
||||
type_t *result = most_complete_type(lhs_t, rhs_t);
|
||||
if (result == NULL)
|
||||
code_err(ast, "I could not determine the type of ", type_to_str(lhs_t), " `or` ", type_to_str(rhs_t));
|
||||
return result;
|
||||
return Type(NumType, .bits=TYPE_NBITS64);
|
||||
}
|
||||
case BINOP_MULT: case BINOP_DIVIDE: {
|
||||
type_t *math_type = get_math_type(env, ast, value_type(lhs_t), value_type(rhs_t));
|
||||
if (value_type(lhs_t)->tag == NumType || value_type(rhs_t)->tag == NumType) {
|
||||
if (risks_zero_or_inf(binop->lhs) && risks_zero_or_inf(binop->rhs))
|
||||
return Type(OptionalType, math_type);
|
||||
else
|
||||
return math_type;
|
||||
} else if (rhs_t->tag == AbortType || rhs_t->tag == ReturnType) {
|
||||
return Match(lhs_t, OptionalType)->type;
|
||||
}
|
||||
return math_type;
|
||||
type_t *non_opt = Match(lhs_t, OptionalType)->type;
|
||||
non_opt = most_complete_type(non_opt, rhs_t);
|
||||
if (non_opt != NULL)
|
||||
return non_opt;
|
||||
} else if ((is_numeric_type(lhs_t) || lhs_t->tag == BoolType)
|
||||
&& (is_numeric_type(rhs_t) || rhs_t->tag == BoolType)
|
||||
&& lhs_t->tag != NumType && rhs_t->tag != NumType) {
|
||||
if (can_promote(rhs_t, lhs_t))
|
||||
return lhs_t;
|
||||
else if (can_promote(lhs_t, rhs_t))
|
||||
return rhs_t;
|
||||
} else if (lhs_t->tag == SetType && rhs_t->tag == SetType && type_eq(lhs_t, rhs_t)) {
|
||||
return lhs_t;
|
||||
}
|
||||
default: {
|
||||
return get_math_type(env, ast, lhs_t, rhs_t);
|
||||
code_err(ast, "I couldn't figure out how to do `or` between ", type_to_str(lhs_t), " and ", type_to_str(rhs_t));
|
||||
}
|
||||
case And: {
|
||||
binary_operands_t binop = BINARY_OPERANDS(ast);
|
||||
type_t *lhs_t = get_type(env, binop.lhs);
|
||||
type_t *rhs_t = get_type(env, binop.rhs);
|
||||
|
||||
// `and` between optionals/bools is a boolean expression like `if opt? and opt?:` or `if x > 0 and opt?:`
|
||||
if ((lhs_t->tag == OptionalType || lhs_t->tag == BoolType)
|
||||
&& (rhs_t->tag == OptionalType || rhs_t->tag == BoolType)) {
|
||||
return Type(BoolType);
|
||||
}
|
||||
|
||||
// Bitwise AND:
|
||||
if ((is_numeric_type(lhs_t) || lhs_t->tag == BoolType)
|
||||
&& (is_numeric_type(rhs_t) || rhs_t->tag == BoolType)
|
||||
&& lhs_t->tag != NumType && rhs_t->tag != NumType) {
|
||||
if (can_promote(rhs_t, lhs_t))
|
||||
return lhs_t;
|
||||
else if (can_promote(lhs_t, rhs_t))
|
||||
return rhs_t;
|
||||
} else if (lhs_t->tag == SetType && rhs_t->tag == SetType && type_eq(lhs_t, rhs_t)) {
|
||||
return lhs_t;
|
||||
}
|
||||
code_err(ast, "I couldn't figure out how to do `and` between ", type_to_str(lhs_t), " and ", type_to_str(rhs_t));
|
||||
}
|
||||
case Xor: {
|
||||
binary_operands_t binop = BINARY_OPERANDS(ast);
|
||||
type_t *lhs_t = get_type(env, binop.lhs);
|
||||
type_t *rhs_t = get_type(env, binop.rhs);
|
||||
|
||||
// `xor` between optionals/bools is a boolean expression like `if opt? xor opt?:` or `if x > 0 xor opt?:`
|
||||
if ((lhs_t->tag == OptionalType || lhs_t->tag == BoolType)
|
||||
&& (rhs_t->tag == OptionalType || rhs_t->tag == BoolType)) {
|
||||
return Type(BoolType);
|
||||
}
|
||||
|
||||
// Bitwise XOR:
|
||||
if ((is_numeric_type(lhs_t) || lhs_t->tag == BoolType)
|
||||
&& (is_numeric_type(rhs_t) || rhs_t->tag == BoolType)
|
||||
&& lhs_t->tag != NumType && rhs_t->tag != NumType) {
|
||||
if (can_promote(rhs_t, lhs_t))
|
||||
return lhs_t;
|
||||
else if (can_promote(lhs_t, rhs_t))
|
||||
return rhs_t;
|
||||
} else if (lhs_t->tag == SetType && rhs_t->tag == SetType && type_eq(lhs_t, rhs_t)) {
|
||||
return lhs_t;
|
||||
}
|
||||
code_err(ast, "I couldn't figure out how to do `xor` between ", type_to_str(lhs_t), " and ", type_to_str(rhs_t));
|
||||
}
|
||||
case Compare: {
|
||||
binary_operands_t binop = BINARY_OPERANDS(ast);
|
||||
type_t *lhs_t = get_type(env, binop.lhs);
|
||||
type_t *rhs_t = get_type(env, binop.rhs);
|
||||
|
||||
if (can_promote(rhs_t, lhs_t) || can_promote(lhs_t, rhs_t))
|
||||
return Type(IntType, .bits=TYPE_IBITS32);
|
||||
|
||||
code_err(ast, "I don't know how to compare ", type_to_str(lhs_t), " and ", type_to_str(rhs_t));
|
||||
}
|
||||
case Equals: case NotEquals: case LessThan: case LessThanOrEquals: case GreaterThan: case GreaterThanOrEquals: {
|
||||
binary_operands_t binop = BINARY_OPERANDS(ast);
|
||||
type_t *lhs_t = get_type(env, binop.lhs);
|
||||
type_t *rhs_t = get_type(env, binop.rhs);
|
||||
if (can_promote(rhs_t, lhs_t) || can_promote(lhs_t, rhs_t))
|
||||
return Type(BoolType);
|
||||
|
||||
code_err(ast, "I don't know how to compare ", type_to_str(lhs_t), " and ", type_to_str(rhs_t));
|
||||
}
|
||||
case Power: case Multiply: case Divide: case Mod: case Mod1: case Plus: case Minus: case LeftShift:
|
||||
case UnsignedLeftShift: case RightShift: case UnsignedRightShift: {
|
||||
binary_operands_t binop = BINARY_OPERANDS(ast);
|
||||
type_t *lhs_t = get_type(env, binop.lhs);
|
||||
type_t *rhs_t = get_type(env, binop.rhs);
|
||||
|
||||
if (ast->tag == LeftShift || ast->tag == UnsignedLeftShift || ast->tag == RightShift || ast->tag == UnsignedRightShift) {
|
||||
if (!is_int_type(rhs_t))
|
||||
code_err(binop.rhs, "I only know how to do bit shifting by integer amounts, not ", type_to_str(rhs_t));
|
||||
}
|
||||
|
||||
type_t *overall_t = (can_promote(rhs_t, lhs_t) ? lhs_t : (can_promote(lhs_t, rhs_t) ? rhs_t : NULL));
|
||||
if (ast->tag == Multiply || ast->tag == Divide) {
|
||||
binding_t *b = is_numeric_type(lhs_t) ? get_metamethod_binding(env, ast->tag, binop.lhs, binop.rhs, lhs_t)
|
||||
: get_metamethod_binding(env, ast->tag, binop.rhs, binop.lhs, rhs_t);
|
||||
if (b) return overall_t;
|
||||
} else {
|
||||
if (overall_t == NULL)
|
||||
code_err(ast, "I don't know how to do math operations between ", type_to_str(lhs_t), " and ", type_to_str(rhs_t));
|
||||
|
||||
binding_t *b = get_metamethod_binding(env, ast->tag, binop.lhs, binop.rhs, overall_t);
|
||||
if (b) return overall_t;
|
||||
}
|
||||
if (is_numeric_type(lhs_t) && is_numeric_type(rhs_t))
|
||||
return overall_t;
|
||||
code_err(ast, "I don't know how to do math operations between ", type_to_str(lhs_t), " and ", type_to_str(rhs_t));
|
||||
}
|
||||
case Concat: {
|
||||
binary_operands_t binop = BINARY_OPERANDS(ast);
|
||||
type_t *lhs_t = get_type(env, binop.lhs);
|
||||
type_t *rhs_t = get_type(env, binop.rhs);
|
||||
|
||||
type_t *overall_t = (can_promote(rhs_t, lhs_t) ? lhs_t : (can_promote(lhs_t, rhs_t) ? rhs_t : NULL));
|
||||
if (overall_t == NULL)
|
||||
code_err(ast, "I don't know how to do operations between ", type_to_str(lhs_t), " and ", type_to_str(rhs_t));
|
||||
|
||||
binding_t *b = get_metamethod_binding(env, ast->tag, binop.lhs, binop.rhs, overall_t);
|
||||
if (b) return overall_t;
|
||||
|
||||
if (overall_t->tag == ArrayType || overall_t->tag == SetType || overall_t->tag == TextType)
|
||||
return overall_t;
|
||||
|
||||
code_err(ast, "I don't know how to do concatenation between ", type_to_str(lhs_t), " and ", type_to_str(rhs_t));
|
||||
}
|
||||
|
||||
case Reduction: {
|
||||
auto reduction = Match(ast, Reduction);
|
||||
type_t *iter_t = get_type(env, reduction->iter);
|
||||
|
||||
if (reduction->op == BINOP_EQ || reduction->op == BINOP_NE || reduction->op == BINOP_LT
|
||||
|| reduction->op == BINOP_LE || reduction->op == BINOP_GT || reduction->op == BINOP_GE)
|
||||
if (reduction->op == Equals || reduction->op == NotEquals || reduction->op == LessThan
|
||||
|| reduction->op == LessThanOrEquals || reduction->op == GreaterThan || reduction->op == GreaterThanOrEquals)
|
||||
return Type(OptionalType, .type=Type(BoolType));
|
||||
|
||||
type_t *iterated = get_iterated_type(iter_t);
|
||||
@ -1249,9 +1211,6 @@ type_t *get_type(env_t *env, ast_t *ast)
|
||||
return iterated->tag == OptionalType ? iterated : Type(OptionalType, .type=iterated);
|
||||
}
|
||||
|
||||
case UpdateAssign:
|
||||
return Type(VoidType);
|
||||
|
||||
case Min: case Max: {
|
||||
// Unsafe! These types *should* have the same fields and this saves a lot of duplicate code:
|
||||
ast_t *lhs = ast->__data.Min.lhs, *rhs = ast->__data.Min.rhs;
|
||||
@ -1310,8 +1269,9 @@ type_t *get_type(env_t *env, ast_t *ast)
|
||||
env_t *truthy_scope = env;
|
||||
env_t *falsey_scope = env;
|
||||
if (if_->condition->tag == Declare) {
|
||||
type_t *condition_type = get_type(env, Match(if_->condition, Declare)->value);
|
||||
const char *varname = Match(Match(if_->condition, Declare)->var, Var)->name;
|
||||
auto decl = Match(if_->condition, Declare);
|
||||
type_t *condition_type = decl->type ? parse_type_ast(env, decl->type) : get_type(env, decl->value);
|
||||
const char *varname = Match(decl->var, Var)->name;
|
||||
if (streq(varname, "_"))
|
||||
code_err(if_->condition, "To use `if var := ...:`, you must choose a real variable name, not `_`");
|
||||
|
||||
@ -1456,7 +1416,7 @@ type_t *get_type(env_t *env, ast_t *ast)
|
||||
PUREFUNC bool is_discardable(env_t *env, ast_t *ast)
|
||||
{
|
||||
switch (ast->tag) {
|
||||
case UpdateAssign: case Assign: case Declare: case FunctionDef: case ConvertDef: case StructDef: case EnumDef:
|
||||
case UPDATE_CASES: case Assign: case Declare: case FunctionDef: case ConvertDef: case StructDef: case EnumDef:
|
||||
case LangDef: case Use: case Extend:
|
||||
return true;
|
||||
default: break;
|
||||
@ -1610,13 +1570,13 @@ PUREFUNC bool is_constant(env_t *env, ast_t *ast)
|
||||
}
|
||||
case Not: return is_constant(env, Match(ast, Not)->value);
|
||||
case Negative: return is_constant(env, Match(ast, Negative)->value);
|
||||
case BinaryOp: {
|
||||
auto binop = Match(ast, BinaryOp);
|
||||
switch (binop->op) {
|
||||
case BINOP_UNKNOWN: case BINOP_POWER: case BINOP_CONCAT: case BINOP_MIN: case BINOP_MAX: case BINOP_CMP:
|
||||
case BINOP_CASES: {
|
||||
binary_operands_t binop = BINARY_OPERANDS(ast);
|
||||
switch (ast->tag) {
|
||||
case Power: case Concat: case Min: case Max: case Compare:
|
||||
return false;
|
||||
default:
|
||||
return is_constant(env, binop->lhs) && is_constant(env, binop->rhs);
|
||||
return is_constant(env, binop.lhs) && is_constant(env, binop.rhs);
|
||||
}
|
||||
}
|
||||
case Use: return true;
|
||||
@ -1626,4 +1586,49 @@ PUREFUNC bool is_constant(env_t *env, ast_t *ast)
|
||||
}
|
||||
}
|
||||
|
||||
PUREFUNC bool can_compile_to_type(env_t *env, ast_t *ast, type_t *needed)
|
||||
{
|
||||
if (needed->tag == OptionalType && ast->tag == None) {
|
||||
return true;
|
||||
}
|
||||
|
||||
needed = non_optional(needed);
|
||||
if (needed->tag == ArrayType && ast->tag == Array) {
|
||||
type_t *item_type = Match(needed, ArrayType)->item_type;
|
||||
for (ast_list_t *item = Match(ast, Array)->items; item; item = item->next) {
|
||||
if (!can_compile_to_type(env, item->ast, item_type))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
} else if (needed->tag == SetType && ast->tag == Set) {
|
||||
type_t *item_type = Match(needed, SetType)->item_type;
|
||||
for (ast_list_t *item = Match(ast, Set)->items; item; item = item->next) {
|
||||
if (!can_compile_to_type(env, item->ast, item_type))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
} else if (needed->tag == TableType && ast->tag == Table) {
|
||||
type_t *key_type = Match(needed, TableType)->key_type;
|
||||
type_t *value_type = Match(needed, TableType)->value_type;
|
||||
for (ast_list_t *entry = Match(ast, Table)->entries; entry; entry = entry->next) {
|
||||
if (entry->ast->tag != TableEntry)
|
||||
continue; // TODO: fix this
|
||||
auto e = Match(entry->ast, TableEntry);
|
||||
if (!can_compile_to_type(env, e->key, key_type) || !can_compile_to_type(env, e->value, value_type))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
} else if (needed->tag == PointerType) {
|
||||
auto ptr = Match(needed, PointerType);
|
||||
if (ast->tag == HeapAllocate)
|
||||
return !ptr->is_stack && can_compile_to_type(env, Match(ast, HeapAllocate)->value, ptr->pointed);
|
||||
else if (ast->tag == StackReference)
|
||||
return ptr->is_stack && can_compile_to_type(env, Match(ast, StackReference)->value, ptr->pointed);
|
||||
else
|
||||
return can_promote(needed, get_type(env, ast));
|
||||
} else {
|
||||
return can_promote(needed, get_type(env, ast));
|
||||
}
|
||||
}
|
||||
|
||||
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
|
||||
|
||||
@ -29,5 +29,6 @@ type_t *get_method_type(env_t *env, ast_t *self, const char *name);
|
||||
PUREFUNC bool is_constant(env_t *env, ast_t *ast);
|
||||
Table_t *get_arg_bindings(env_t *env, arg_t *spec_args, arg_ast_t *call_args, bool promotion_allowed);
|
||||
bool is_valid_call(env_t *env, arg_t *spec_args, arg_ast_t *call_args, bool promotion_allowed);
|
||||
PUREFUNC bool can_compile_to_type(env_t *env, ast_t *ast, type_t *needed);
|
||||
|
||||
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
|
||||
|
||||
109
src/types.c
109
src/types.c
@ -360,6 +360,16 @@ PUREFUNC bool can_promote(type_t *actual, type_t *needed)
|
||||
return true;
|
||||
}
|
||||
|
||||
// Empty literals:
|
||||
if (actual->tag == ArrayType && needed->tag == ArrayType && Match(actual, ArrayType)->item_type == NULL)
|
||||
return true; // [] -> [T]
|
||||
if (actual->tag == SetType && needed->tag == SetType && Match(actual, SetType)->item_type == NULL)
|
||||
return true; // {/} -> {T}
|
||||
if (actual->tag == TableType && needed->tag == SetType && Match(actual, TableType)->key_type == NULL && Match(actual, TableType)->value_type == NULL)
|
||||
return true; // {} -> {T}
|
||||
if (actual->tag == TableType && needed->tag == TableType && Match(actual, TableType)->key_type == NULL && Match(actual, TableType)->value_type == NULL)
|
||||
return true; // {} -> {K=V}
|
||||
|
||||
// Cross-promotion between tables with default values and without
|
||||
if (needed->tag == TableType && actual->tag == TableType) {
|
||||
auto actual_table = Match(actual, TableType);
|
||||
@ -708,4 +718,103 @@ PUREFUNC type_t *get_iterated_type(type_t *t)
|
||||
}
|
||||
}
|
||||
|
||||
CONSTFUNC bool is_incomplete_type(type_t *t)
|
||||
{
|
||||
if (t == NULL) return true;
|
||||
switch (t->tag) {
|
||||
case ReturnType: return is_incomplete_type(Match(t, ReturnType)->ret);
|
||||
case OptionalType: return is_incomplete_type(Match(t, OptionalType)->type);
|
||||
case ArrayType: return is_incomplete_type(Match(t, ArrayType)->item_type);
|
||||
case SetType: return is_incomplete_type(Match(t, SetType)->item_type);
|
||||
case TableType: {
|
||||
auto table = Match(t, TableType);
|
||||
return is_incomplete_type(table->key_type) || is_incomplete_type(table->value_type);
|
||||
}
|
||||
case FunctionType: {
|
||||
auto fn = Match(t, FunctionType);
|
||||
for (arg_t *arg = fn->args; arg; arg = arg->next) {
|
||||
if (arg->type == NULL || is_incomplete_type(arg->type))
|
||||
return true;
|
||||
}
|
||||
return fn->ret ? is_incomplete_type(fn->ret) : false;
|
||||
}
|
||||
case ClosureType: return is_incomplete_type(Match(t, ClosureType)->fn);
|
||||
case PointerType: return is_incomplete_type(Match(t, PointerType)->pointed);
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
|
||||
CONSTFUNC type_t *most_complete_type(type_t *t1, type_t *t2)
|
||||
{
|
||||
if (!t1) return t2;
|
||||
if (!t2) return t1;
|
||||
|
||||
if (is_incomplete_type(t1) && is_incomplete_type(t2))
|
||||
return NULL;
|
||||
else if (!is_incomplete_type(t1) && !is_incomplete_type(t2) && type_eq(t1, t2))
|
||||
return t1;
|
||||
|
||||
if (t1->tag != t2->tag)
|
||||
return NULL;
|
||||
|
||||
switch (t1->tag) {
|
||||
case ReturnType: {
|
||||
type_t *ret = most_complete_type(Match(t1, ReturnType)->ret, Match(t1, ReturnType)->ret);
|
||||
return ret ? Type(ReturnType, ret) : NULL;
|
||||
}
|
||||
case OptionalType: {
|
||||
type_t *opt = most_complete_type(Match(t1, OptionalType)->type, Match(t2, OptionalType)->type);
|
||||
return opt ? Type(OptionalType, opt) : NULL;
|
||||
}
|
||||
case ArrayType: {
|
||||
type_t *item = most_complete_type(Match(t1, ArrayType)->item_type, Match(t2, ArrayType)->item_type);
|
||||
return item ? Type(ArrayType, item) : NULL;
|
||||
}
|
||||
case SetType: {
|
||||
type_t *item = most_complete_type(Match(t1, SetType)->item_type, Match(t2, SetType)->item_type);
|
||||
return item ? Type(SetType, item) : NULL;
|
||||
}
|
||||
case TableType: {
|
||||
auto table1 = Match(t1, TableType);
|
||||
auto table2 = Match(t2, TableType);
|
||||
type_t *key = most_complete_type(table1->key_type, table2->key_type);
|
||||
type_t *value = most_complete_type(table1->value_type, table2->value_type);
|
||||
return (key && value) ? Type(TableType, key, value) : NULL;
|
||||
}
|
||||
case FunctionType: {
|
||||
auto fn1 = Match(t1, FunctionType);
|
||||
auto fn2 = Match(t2, FunctionType);
|
||||
arg_t *args = NULL;
|
||||
for (arg_t *arg1 = fn1->args, *arg2 = fn2->args; arg1 || arg2; arg1 = arg1->next, arg2 = arg2->next) {
|
||||
if (!arg1 || !arg2)
|
||||
return NULL;
|
||||
|
||||
type_t *arg_type = most_complete_type(arg1->type, arg2->type);
|
||||
if (!arg_type) return NULL;
|
||||
args = new(arg_t, .type=arg_type, .next=args);
|
||||
}
|
||||
REVERSE_LIST(args);
|
||||
type_t *ret = most_complete_type(fn1->ret, fn2->ret);
|
||||
return ret ? Type(FunctionType, .args=args, .ret=ret) : NULL;
|
||||
}
|
||||
case ClosureType: {
|
||||
type_t *fn = most_complete_type(Match(t1, ClosureType)->fn, Match(t1, ClosureType)->fn);
|
||||
return fn ? Type(ClosureType, fn) : NULL;
|
||||
}
|
||||
case PointerType: {
|
||||
auto ptr1 = Match(t1, PointerType);
|
||||
auto ptr2 = Match(t2, PointerType);
|
||||
if (ptr1->is_stack != ptr2->is_stack)
|
||||
return NULL;
|
||||
type_t *pointed = most_complete_type(ptr1->pointed, ptr2->pointed);
|
||||
return pointed ? Type(PointerType, .is_stack=ptr1->is_stack, .pointed=pointed) : NULL;
|
||||
}
|
||||
default: {
|
||||
if (is_incomplete_type(t1) || is_incomplete_type(t2))
|
||||
return NULL;
|
||||
return type_eq(t1, t2) ? t1 : NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
|
||||
|
||||
@ -147,6 +147,8 @@ PUREFUNC const char *enum_single_value_tag(type_t *enum_type, type_t *t);
|
||||
PUREFUNC bool is_int_type(type_t *t);
|
||||
PUREFUNC bool is_numeric_type(type_t *t);
|
||||
PUREFUNC bool is_packed_data(type_t *t);
|
||||
CONSTFUNC bool is_incomplete_type(type_t *t);
|
||||
CONSTFUNC type_t *most_complete_type(type_t *t1, type_t *t2);
|
||||
PUREFUNC size_t type_size(type_t *t);
|
||||
PUREFUNC size_t type_align(type_t *t);
|
||||
PUREFUNC size_t unpadded_struct_size(type_t *t);
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
func main():
|
||||
do:
|
||||
>> [:Num32]
|
||||
= [:Num32]
|
||||
>> nums : [Num32] = []
|
||||
= []
|
||||
|
||||
do:
|
||||
>> arr := [10, 20, 30]
|
||||
@ -104,7 +104,7 @@ func main():
|
||||
>> heap := @[(i * 1337) mod 37 for i in 10]
|
||||
>> heap:heapify()
|
||||
>> heap
|
||||
sorted := @[:Int]
|
||||
sorted : @[Int] = @[]
|
||||
repeat:
|
||||
sorted:insert(heap:heap_pop() or stop)
|
||||
>> sorted == sorted:sorted()
|
||||
@ -112,7 +112,7 @@ func main():
|
||||
for i in 10:
|
||||
heap:heap_push((i*13337) mod 37)
|
||||
>> heap
|
||||
sorted = @[:Int]
|
||||
sorted = @[]
|
||||
repeat:
|
||||
sorted:insert(heap:heap_pop() or stop)
|
||||
>> sorted == sorted:sorted()
|
||||
@ -181,6 +181,6 @@ func main():
|
||||
= &[10, 30, 40]
|
||||
>> nums:clear()
|
||||
>> nums
|
||||
= &[:Int]
|
||||
= &[]
|
||||
>> nums:pop()
|
||||
= none:Int
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
func main():
|
||||
x := 123
|
||||
nums := @[:Int]
|
||||
nums : @[Int] = @[]
|
||||
do:
|
||||
defer:
|
||||
nums:insert(x)
|
||||
|
||||
@ -32,18 +32,18 @@ func table_key_str(t:{Text=Text} -> Text):
|
||||
func main():
|
||||
>> all_nums([10,20,30])
|
||||
= "10,20,30,"
|
||||
>> all_nums([:Int])
|
||||
>> all_nums([])
|
||||
= "EMPTY"
|
||||
|
||||
>> labeled_nums([10,20,30])
|
||||
= "1:10,2:20,3:30,"
|
||||
>> labeled_nums([:Int])
|
||||
>> labeled_nums([])
|
||||
= "EMPTY"
|
||||
|
||||
>> t := {"key1"="value1", "key2"="value2"}
|
||||
>> table_str(t)
|
||||
= "key1:value1,key2:value2,"
|
||||
>> table_str({:Text=Text})
|
||||
>> table_str({})
|
||||
= "EMPTY"
|
||||
|
||||
>> table_key_str(t)
|
||||
|
||||
@ -8,11 +8,11 @@ func returns_imported_type(->ImportedType):
|
||||
return get_value() # Imported from ./use_import.tm
|
||||
|
||||
func main():
|
||||
>> [:vectors.Vec2]
|
||||
>> empty : [vectors.Vec2] = []
|
||||
>> returns_vec()
|
||||
= Vec2(x=1, y=2)
|
||||
|
||||
>> [:ImportedType]
|
||||
>> imported : [ImportedType] = []
|
||||
>> returns_imported_type()
|
||||
= ImportedType("Hello")
|
||||
|
||||
|
||||
@ -25,7 +25,7 @@ func main():
|
||||
= ["AB", "BC", "CD"]
|
||||
|
||||
do:
|
||||
result := @[:Text]
|
||||
result : @[Text] = @[]
|
||||
for foo in pairwise(values):
|
||||
result:insert("$(foo.x)$(foo.y)")
|
||||
>> result[]
|
||||
|
||||
@ -247,8 +247,8 @@ func main():
|
||||
= yes
|
||||
>> {none:Int, none:Int}
|
||||
= {none:Int}
|
||||
>> {:Int? none, none}
|
||||
= {none:Int}
|
||||
>> nones : {Int?} = {none, none}
|
||||
= {none}
|
||||
>> [5?, none:Int, none:Int, 6?]:sorted()
|
||||
= [none:Int, none:Int, 5, 6]
|
||||
|
||||
|
||||
@ -25,7 +25,7 @@ func main():
|
||||
>> tmpfile:read()
|
||||
= "Hello world!"?
|
||||
>> tmpfile:read_bytes()
|
||||
= [:Byte, 0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21]?
|
||||
= [0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21]?
|
||||
>> tmpdir:files():has(tmpfile)
|
||||
= yes
|
||||
|
||||
|
||||
@ -4,13 +4,14 @@ func main():
|
||||
>> (+: [10, 20, 30])
|
||||
= 60?
|
||||
|
||||
>> (+: [:Int])
|
||||
>> empty_ints : [Int] = []
|
||||
>> (+: empty_ints)
|
||||
= none : Int
|
||||
|
||||
>> (+: [10, 20, 30]) or 0
|
||||
= 60
|
||||
|
||||
>> (+: [:Int]) or 0
|
||||
>> (+: empty_ints) or 0
|
||||
= 0
|
||||
|
||||
>> (_max_: [3, 5, 2, 1, 4])
|
||||
@ -36,7 +37,7 @@ func main():
|
||||
>> (<=: [1, 2, 2, 3, 4])!
|
||||
= yes
|
||||
|
||||
>> (<=: [:Int])
|
||||
>> (<=: empty_ints)
|
||||
= none : Bool
|
||||
|
||||
>> (<=: [5, 4, 3, 2, 1])!
|
||||
|
||||
@ -96,11 +96,11 @@ func main():
|
||||
|
||||
>> {1=1, 2=2} <> {2=2, 1=1}
|
||||
= Int32(0)
|
||||
>> [{:Int=Int}, {0=0}, {99=99}, {1=1, 2=2, 3=3}, {1=1, 99=99, 3=3}, {1=1, 2=-99, 3=3}, {1=1, 99=-99, 3=4}]:sorted()
|
||||
= [{:Int=Int}, {0=0}, {1=1, 2=-99, 3=3}, {1=1, 2=2, 3=3}, {1=1, 99=99, 3=3}, {1=1, 99=-99, 3=4}, {99=99}]
|
||||
>> ints : [{Int=Int}] = [{}, {0=0}, {99=99}, {1=1, 2=2, 3=3}, {1=1, 99=99, 3=3}, {1=1, 2=-99, 3=3}, {1=1, 99=-99, 3=4}]:sorted()
|
||||
= [{}, {0=0}, {1=1, 2=-99, 3=3}, {1=1, 2=2, 3=3}, {1=1, 99=99, 3=3}, {1=1, 99=-99, 3=4}, {99=99}]
|
||||
|
||||
>> [{:Int}, {1}, {2}, {99}, {0, 3}, {1, 2}, {99}]:sorted()
|
||||
= [{:Int}, {0, 3}, {1}, {1, 2}, {2}, {99}, {99}]
|
||||
>> other_ints : [{Int}] = [{}, {1}, {2}, {99}, {0, 3}, {1, 2}, {99}]:sorted()
|
||||
= [{}, {0, 3}, {1}, {1, 2}, {2}, {99}, {99}]
|
||||
|
||||
do:
|
||||
# Default values:
|
||||
|
||||
18
test/text.tm
18
test/text.tm
@ -53,10 +53,10 @@ func main():
|
||||
>> amelie:split()
|
||||
= ["A", "m", "é", "l", "i", "e"]
|
||||
>> amelie:utf32_codepoints()
|
||||
= [:Int32, 65, 109, 233, 108, 105, 101]
|
||||
= [65, 109, 233, 108, 105, 101]
|
||||
>> amelie:bytes()
|
||||
= [:Byte, 0x41, 0x6D, 0xC3, 0xA9, 0x6C, 0x69, 0x65]
|
||||
>> Text.from_bytes([:Byte 0x41, 0x6D, 0xC3, 0xA9, 0x6C, 0x69, 0x65])!
|
||||
= [0x41, 0x6D, 0xC3, 0xA9, 0x6C, 0x69, 0x65]
|
||||
>> Text.from_bytes([0x6D, 0xC3, 0xA9, 0x6C, 0x69, 0x65])!
|
||||
= "Amélie"
|
||||
>> Text.from_bytes([Byte(0xFF)])
|
||||
= none:Text
|
||||
@ -65,9 +65,9 @@ func main():
|
||||
>> amelie2:split()
|
||||
= ["A", "m", "é", "l", "i", "e"]
|
||||
>> amelie2:utf32_codepoints()
|
||||
= [:Int32, 65, 109, 233, 108, 105, 101]
|
||||
= [65, 109, 233, 108, 105, 101]
|
||||
>> amelie2:bytes()
|
||||
= [:Byte, 0x41, 0x6D, 0xC3, 0xA9, 0x6C, 0x69, 0x65]
|
||||
= [0x41, 0x6D, 0xC3, 0xA9, 0x6C, 0x69, 0x65]
|
||||
|
||||
>> amelie:codepoint_names()
|
||||
= ["LATIN CAPITAL LETTER A", "LATIN SMALL LETTER M", "LATIN SMALL LETTER E WITH ACUTE", "LATIN SMALL LETTER L", "LATIN SMALL LETTER I", "LATIN SMALL LETTER E"]
|
||||
@ -136,7 +136,7 @@ func main():
|
||||
>> "one$(\r\n)two$(\r\n)three$(\r\n)":lines()
|
||||
= ["one", "two", "three"]
|
||||
>> "":lines()
|
||||
= [:Text]
|
||||
= []
|
||||
|
||||
!! Test splitting and joining text:
|
||||
>> "one,, two,three":split(",")
|
||||
@ -171,11 +171,11 @@ func main():
|
||||
>> "+":join(["one"])
|
||||
= "one"
|
||||
|
||||
>> "+":join([:Text])
|
||||
>> "+":join([])
|
||||
= ""
|
||||
|
||||
>> "":split()
|
||||
= [:Text]
|
||||
= []
|
||||
|
||||
!! Test text slicing:
|
||||
>> "abcdef":slice()
|
||||
@ -196,7 +196,7 @@ func main():
|
||||
>> house:codepoint_names()
|
||||
= ["CJK Unified Ideographs-5BB6"]
|
||||
>> house:utf32_codepoints()
|
||||
= [:Int32, 23478]
|
||||
= [23478]
|
||||
|
||||
>> "🐧":codepoint_names()
|
||||
= ["PENGUIN"]
|
||||
|
||||
Loading…
Reference in New Issue
Block a user