diff --git a/Cargo.lock b/Cargo.lock index adca287..66ed691 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3,5 +3,5 @@ version = 4 [[package]] -name = "dino" +name = "rex" version = "0.1.0" diff --git a/Cargo.toml b/Cargo.toml index a6045ab..fbf6d4c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] -name = "dino" +name = "rex" version = "0.1.0" edition = "2021" -description = "The Dino programming language compiler" +description = "The Rex programming language compiler" [dependencies] diff --git a/README.md b/README.md index e794015..2d41f47 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@

- Dino, the mascot + Rex, the mascot

-

Dino

+

Rex

A small, fast language. It looks like Go, runs like C, and you never write anything low-level. @@ -10,10 +10,10 @@ --- -Dino compiles to C and then to a native program. There is no garbage collector, no pointers +Rex compiles to C and then to a native program. There is no garbage collector, no pointers and no manual memory: you write plain code and the compiler works out the rest. -```dino +```rex enum Shape { Circle(r: float) Rect(w, h: float) @@ -52,7 +52,7 @@ func main() { error: age cannot be negative ``` -## Why Dino +## Why Rex - **Simple syntax.** `var`, `func`, `for`, `match`. One loop keyword, no semicolons, no parentheses around conditions. Types are inferred. @@ -63,42 +63,42 @@ error: age cannot be negative missing is `T?`. Both must be handled. - **Modern basics.** Enums that carry data, exhaustive `match`, generics, interfaces, closures, maps, characters, modules. -- **C and C++ libraries.** `import "raylib.h"` and call it: Dino reads the header itself, +- **C and C++ libraries.** `import "raylib.h"` and call it: Rex reads the header itself, links the library, and builds your own `.c`/`.cpp` files next to the program. -- **Tooling included.** A formatter, a language server, and editor files, all in the one `dino` +- **Tooling included.** A formatter, a language server, and editor files, all in the one `rex` program. ## Get started You need a [Rust toolchain](https://rustup.rs) to build the compiler and a C compiler -(`gcc` or `clang`, available as `cc`) to build your programs. Dino itself has no dependencies. +(`gcc` or `clang`, available as `cc`) to build your programs. Rex itself has no dependencies. ```text cargo build --release -cp target/release/dino ~/.local/bin/ # or anywhere on your PATH +cp target/release/rex ~/.local/bin/ # or anywhere on your PATH ``` -Save this as `hello.dino`: +Save this as `hello.rex`: -```dino +```rex func main() { - print("Hello, Dino!") + print("Hello, Rex!") } ``` ```text -dino run hello.dino +rex run hello.rex ``` | Command | What it does | |---------|--------------| -| `dino run file.dino [args...]` | Compile and run. Extra words reach the program as `os.args`. | -| `dino build file.dino -o out` | Make an executable you can keep. | -| `dino check file.dino` | Look for errors without building. | -| `dino emit-c file.dino` | Print the generated C. | -| `dino fmt [--check] path...` | Format code (`--check` only reports). | -| `dino lsp` | Start the language server (editors run this for you). | -| `dino header file.h [word]` | Show what Dino can use from a C header. | +| `rex run file.rex [args...]` | Compile and run. Extra words reach the program as `os.args`. | +| `rex build file.rex -o out` | Make an executable you can keep. | +| `rex check file.rex` | Look for errors without building. | +| `rex emit-c file.rex` | Print the generated C. | +| `rex fmt [--check] path...` | Format code (`--check` only reports). | +| `rex lsp` | Start the language server (editors run this for you). | +| `rex header file.h [word]` | Show what Rex can use from a C header. | ## Learn the language diff --git a/SPEC.md b/SPEC.md index 8983326..e70353e 100644 --- a/SPEC.md +++ b/SPEC.md @@ -1,4 +1,4 @@ -# Dino language spec (draft) +# Rex language spec (draft) Goal: Go-like simplicity, C++/Rust speed, no GC, no low-level syntax. Targets: game dev, CLI tools, desktop apps. @@ -160,8 +160,8 @@ Targets: game dev, CLI tools, desktop apps. passing lists around costs nothing. Every test program runs under the address sanitizer, so a leak, double free or use after free fails the test. -- **Imports**: `import os` (built-in) or `import utils` (the file `utils.dino` next to the - main file; `import tools.fs` is `tools/fs.dino`, used as `fs.name`). Use things as +- **Imports**: `import os` (built-in) or `import utils` (the file `utils.rex` next to the + main file; `import tools.fs` is `tools/fs.rex`, used as `fs.name`). Use things as `utils.double(2)`, `utils.Vec2{1.0, 2.0}`, `utils.Shape.Circle(1.0)`, `utils.SCALE`, and `utils.Vec2` in types. Only `pub` functions, consts, types, methods and fields can be used from another file (fields are private too unless written `pub x: int`). Each file has its own imports and its @@ -185,12 +185,12 @@ Targets: game dev, CLI tools, desktop apps. invalid UTF-8 comes out as U+FFFD). `s[i]` is the character starting at byte `i` (panics out of range or in the middle of a character); strings can't be assigned to. Methods `is_digit is_letter is_alnum is_space is_upper is_lower upper lower` (ASCII plus Latin-1 letters). `s.chars()` gives a `[]char`. Not yet: `[]char`→string. -- **Formatter** `dino fmt [--check] ..` (`src/fmt.rs`): text based, so comments and blank lines survive. +- **Formatter** `rex fmt [--check] ..` (`src/fmt.rs`): text based, so comments and blank lines survive. 4-space indent, spaces around binary operators and after `,` `:`, tight `Point{...}` / map literals and `[]T`, at most one blank line, trailing `//` comments of neighbouring lines aligned. It never moves line breaks (a one-line block stays one line), indents continuation lines (after an operator, or inside open brackets) one level, and verifies that the token stream is unchanged before writing. `examples/` must stay formatted (a test checks). -- **Editor support** (`editors/`): `dino lsp` is a language server (`src/lsp.rs`, own JSON in `src/json.rs`, no +- **Editor support** (`editors/`): `rex lsp` is a language server (`src/lsp.rs`, own JSON in `src/json.rs`, no dependencies): full-text sync, error diagnostics from the real checker (imports read from disk or from open buffers; errors in other files shown at the top of the importing file; UTF-16 columns), whole-file formatting. `editors/vscode` (extension + TextMate grammar), `editors/vim` (syntax), `editors/README.md` (Neovim, Helix, others). @@ -204,16 +204,16 @@ Targets: game dev, CLI tools, desktop apps. guessed from the header path, else `import "x.h" link "x"` (`-lx`). A header next to the program adds `-I` and builds the `.c`/`.cpp`/`.cc` file with the same name into the program (C++ with `c++`, linked with `-lstdc++`). Types: C ints -> sized numbers (`int` i32, `long` int, `size_t` u64), `double` float, `char` i8 (takes `'a'`), - `char *` -> string (copied both ways, NULL -> ""), enums -> `i32` constants, plain structs -> Dino structs with the + `char *` -> string (copied both ways, NULL -> ""), enums -> `i32` constants, plain structs -> Rex structs with the C field names (`raylib.Color`; converted field by field at calls), other pointers -> pointer types (`Ty::CPtr`, `stdio.FILE`, `nil` = NULL, `==` compares); `void *` (`pointer`) mixes with every pointer type. `T *` parameters take a variable (the address is passed; counts as a change for inferred mutation) or a list (its items); `const T *` also takes any value. Constants: numbers, strings, and struct literals like `CLITERAL(Color){...}` (emitted as the macro). Programs that import headers are built with `-std=gnu11`. Not supported (a clear error when called): variadic functions, callbacks, unions/arrays by value, lists of - structs, `long double`, function-like macros. Dino never frees C memory. `dino header x.h [word]` lists what Dino sees. + structs, `long double`, function-like macros. Rex never frees C memory. `rex header x.h [word]` lists what Rex sees. - **String slicing**: `s[a..b]`, `s[a..]`, `s[..b]` (byte positions, bounds checked; panics with "the length is N"). -- **Running**: `dino run file.dino a b c` passes `a b c` to the program (`os.args`). +- **Running**: `rex run file.rex a b c` passes `a b c` to the program (`os.args`). - **Example**: `examples/calc/` is a multi-file calculator (tokenizer, parser, evaluator, shared scope); `session.txt` / `session.out` are checked by a test. ## Open questions @@ -225,6 +225,6 @@ Working: functions, int/float/bool/string, var/const, if/else, for (infinite, while, range with step, over lists), break/continue, string interpolation, print, structs with methods (value semantics, inferred mutation), lists (value semantics, bounds checked), enums with data + exhaustive match, errors (`error`, -multi-value returns, `?`), optionals (`T?`, `nil`, narrowing), `dino run`. +multi-value returns, `?`), optionals (`T?`, `nil`, narrowing), `rex run`. Not yet: nested match patterns, `==` on lists/structs, top-level const lists. These give a clear "not supported yet" error. Known gaps: memory is only freed on normal exits (a panic just ends the program). diff --git a/docs/01-first-steps.md b/docs/01-first-steps.md index 39a0ad5..d3865e5 100644 --- a/docs/01-first-steps.md +++ b/docs/01-first-steps.md @@ -2,40 +2,40 @@ ## Running a program -Save this as `hello.dino`: +Save this as `hello.rex`: -```dino +```rex func main() { - print("Hello, Dino!") + print("Hello, Rex!") } ``` ```text -Hello, Dino! +Hello, Rex! ``` Every program starts at `func main()`. Run it from the project folder: ```text -cargo run -q -- run hello.dino +cargo run -q -- run hello.rex ``` -The compiler turns your Dino code into C and builds it with your C compiler (`cc`, so you -need gcc or clang installed). If you build the `dino` binary once, the commands are: +The compiler turns your Rex code into C and builds it with your C compiler (`cc`, so you +need gcc or clang installed). If you build the `rex` binary once, the commands are: | Command | What it does | |---------|--------------| -| `dino run file.dino [args...]` | Compile and run. Extra words are given to the program (`os.args`). | -| `dino build file.dino -o out` | Make an executable you can keep. | -| `dino check file.dino` | Look for errors without building. | -| `dino emit-c file.dino` | Print the generated C. | -| `dino fmt file-or-folder...` | Tidy the code in place (`--check` only reports). | +| `rex run file.rex [args...]` | Compile and run. Extra words are given to the program (`os.args`). | +| `rex build file.rex -o out` | Make an executable you can keep. | +| `rex check file.rex` | Look for errors without building. | +| `rex emit-c file.rex` | Print the generated C. | +| `rex fmt file-or-folder...` | Tidy the code in place (`--check` only reports). | ## print `print` takes any number of values, separates them with spaces, and ends the line. It can print numbers, strings, lists, maps, structs, enums and more. -```dino +```rex func main() { print("score:", 42, true) print([1, 2, 3]) @@ -52,7 +52,7 @@ Notice that a float always shows a `.0` so you can tell `3.0` from `3`. ## Comments -```dino +```rex // a comment runs to the end of the line func main() { print("hi") // so does this @@ -64,7 +64,7 @@ hi ## Reading the error messages -Dino tries hard to explain mistakes. For example, forgetting that `int` and `float` +Rex tries hard to explain mistakes. For example, forgetting that `int` and `float` don't mix: ```text @@ -79,16 +79,16 @@ message and worth fixing. `editors/` has colours, live error underlines and format-on-save for VS Code, Neovim, Vim and Helix (any editor that can run a language server works). See `editors/README.md`. It is the compiler itself doing the checking, so you see the same messages as in the terminal. The -server is started with `dino lsp`. +server is started with `rex lsp`. ## Formatting your code -`dino fmt` rewrites your files in one standard style, so you never argue about spaces: +`rex fmt` rewrites your files in one standard style, so you never argue about spaces: ```text -dino fmt hello.dino # one file -dino fmt src/ # every .dino file in a folder -dino fmt --check src/ # change nothing; exit code 1 if something is untidy +rex fmt hello.rex # one file +rex fmt src/ # every .rex file in a folder +rex fmt --check src/ # change nothing; exit code 1 if something is untidy ``` It uses 4-space indents, one space around operators, `a: int` colons, `Point{x: 1}` literals, diff --git a/docs/02-values-and-types.md b/docs/02-values-and-types.md index c84aeb0..4fb0058 100644 --- a/docs/02-values-and-types.md +++ b/docs/02-values-and-types.md @@ -4,27 +4,27 @@ `var` makes a variable you can change. The type is worked out from the value. -```dino +```rex func main() { var score = 10 score = score + 5 score += 1 print(score) - var name: string = "Dino" // you may write the type after a colon - var ratio: float = 1 // a whole-number literal fits a float + var name: string = "Rex" // you may write the type after a colon + var ratio: float = 1 // a whole-number literal fits a float print(name, ratio) } ``` ```text 16 -Dino 1.0 +Rex 1.0 ``` `const` is a value that never changes. It must be known when the program is compiled (you can't call functions in it). -```dino +```rex const MAX = 100 const GREETING = "hi" @@ -53,7 +53,7 @@ func main() { Sized numbers exist for when you need exact control: `i8 i16 i32 u8 u16 u32 u64 f32` (`i64` is the same as `int`, `f64` the same as `float`). -```dino +```rex func main() { var small: u8 = 200 var wrapped = small + 100 // whole numbers wrap around: 300 - 256 @@ -82,7 +82,7 @@ Rules worth remembering: Put values inside text with `{ }`. Write a literal brace as `\{`. -```dino +```rex func main() { var name = "Ada" var age = 36 @@ -106,7 +106,7 @@ starts_with ends_with index_of to_int to_float`. See the [cheatsheet](11-cheatsh `s[a..b]` is the part from byte `a` up to (not including) `b`. Leave a side out to go to the edge. -```dino +```rex func main() { var s = "hello world" print(s[0..5]) @@ -127,7 +127,7 @@ A slice outside the string stops the program with a message that shows the lengt A `char` is **one character**, written with single quotes. Double quotes are for text. -```dino +```rex func main() { var c = 'a' print(c, c == 'a', c < 'b') @@ -145,7 +145,7 @@ a! Going through a string gives characters: -```dino +```rex func main() { var s = "héllo 42" var letters = 0 @@ -181,7 +181,7 @@ h é l - `char` can be compared (`== != < > <= >=`), matched with `match`, and used as a map key. It does no arithmetic: use `int(c)` and `char(n)` if you need that. -```dino +```rex func kind(c: char): string { return match c { '+' => "plus" diff --git a/docs/03-control-flow.md b/docs/03-control-flow.md index 5e95b3c..d753bf9 100644 --- a/docs/03-control-flow.md +++ b/docs/03-control-flow.md @@ -4,7 +4,7 @@ No parentheses around the condition. The braces are required. The condition must be a `bool`. -```dino +```rex func main() { var temp = 21 if temp > 30 { @@ -26,7 +26,7 @@ Combine conditions with `&&`, `||` and `!`. The right side only runs when needed There is one keyword for every kind of loop. -```dino +```rex func main() { for i in 0..3 { // 0, 1, 2: the end is not included print("i =", i) @@ -83,7 +83,7 @@ the loop is safe. `match` picks a branch by shape. It must cover every possibility, otherwise the compiler lists what is missing. `_` means "anything else". -```dino +```rex enum Shape { Circle(r: float) Rect(w, h: float) @@ -119,7 +119,7 @@ zero one many `match` works on enums, ints, bools and strings. Used as a **value** (like above) each arm is one expression. Used as a **statement** an arm can be a block: -```dino +```rex func main() { var cmd = "stop" match cmd { diff --git a/docs/04-functions.md b/docs/04-functions.md index a10e5d6..9e90911 100644 --- a/docs/04-functions.md +++ b/docs/04-functions.md @@ -1,6 +1,6 @@ # 4. Functions -```dino +```rex func add(a: int, b: int): int { return a + b } @@ -25,7 +25,7 @@ Names in a row can share a type: `func area(w, h: float): float`. A function can return more than one value. The most common use is a value and an `error`. -```dino +```rex func divide(a, b: int): (int, error) { if b == 0 { return 0, error("cannot divide by zero") @@ -53,7 +53,7 @@ A parameter is a copy as far as you can tell: changing it inside never changes t variable. (When a function only *reads* a parameter, the compiler passes it without copying, so big lists are free to pass around.) -```dino +```rex func grow(xs: []int): []int { xs.push(99) return xs @@ -73,7 +73,7 @@ func main() { A function has a type like `func(int): int`. You can store it, pass it and return it. -```dino +```rex func double(x: int): int { return x * 2 } func apply(f: func(int): int, x: int): int { @@ -96,7 +96,7 @@ func main() { ### Short lambdas `x => x * 2` and `(a, b) => a + b` are shorthand for a one-expression function. The types -come from where it is used, so it works where Dino already knows what function is expected +come from where it is used, so it works where Rex already knows what function is expected (a parameter, a typed variable, a struct field, or another argument of a generic function). The short form is one expression; for several statements use the long `func(x: int): int { }`. @@ -105,7 +105,7 @@ The short form is one expression; for several statements use the long `func(x: i A function written inside another can use the variables around it. It **copies** them when it is created and keeps its own copy from then on. -```dino +```rex func make_counter(): func(): int { var n = 0 return func(): int { diff --git a/docs/05-lists-and-maps.md b/docs/05-lists-and-maps.md index 51f7b62..53e80b8 100644 --- a/docs/05-lists-and-maps.md +++ b/docs/05-lists-and-maps.md @@ -4,7 +4,7 @@ An ordered, growable sequence. -```dino +```rex func main() { var nums = [10, 20, 30] nums.push(40) @@ -35,7 +35,7 @@ Facts: - Going outside the list (`nums[9]`) or popping an empty list stops the program with a message. - **Lists are values.** `var b = a` copies the list. Changing `b` leaves `a` alone. -```dino +```rex func main() { var a = [1, 2, 3] var b = a @@ -51,7 +51,7 @@ func main() { A map finds a value by a **key** instead of a position, like a phone book. -```dino +```rex func main() { var ages = {"alice": 30, "bob": 25} ages["carol"] = 41 // add a new entry @@ -67,7 +67,7 @@ func main() { ### Making a map -```dino +```rex func main() { var a = {"x": 1, "y": 2} // types are guessed from the entries var b: map[string, int] = {} // empty: the type comes from the variable @@ -100,7 +100,7 @@ The value can be anything: numbers, strings, lists, structs, even other maps. | `m.keys()` | a list of the keys | | `m.values()` | a list of the values | -```dino +```rex func main() { var stock = {"apple": 3, "pear": 0} print(stock.has("apple"), stock.has("fig")) @@ -120,7 +120,7 @@ true false `m[k] = v` adds or replaces. `m.remove(k)` deletes (and does nothing if the key is missing). -```dino +```rex func main() { var m = {"a": 1, "b": 2} m["c"] = 3 @@ -137,7 +137,7 @@ func main() { The most common map job is counting. `m[k] += 1` on a key that isn't there yet starts from zero, so you don't have to check first. -```dino +```rex func main() { var counts: map[string, int] = {} for w in "a b a c b a".split(" ") { @@ -156,7 +156,7 @@ func main() { Entries come out **in the order they were added**, so output is always predictable. -```dino +```rex func main() { var prices = {"tea": 2.5, "cake": 4.0} for name, price in prices { @@ -178,7 +178,7 @@ cake `var b = a` copies the whole map. A map inside a struct is copied with the struct. -```dino +```rex func main() { var a = {"x": 1} var b = a diff --git a/docs/06-structs-and-enums.md b/docs/06-structs-and-enums.md index 167a731..cfb0359 100644 --- a/docs/06-structs-and-enums.md +++ b/docs/06-structs-and-enums.md @@ -4,13 +4,13 @@ A struct groups related values. **Methods go inside the struct** and see the fields directly. -```dino +```rex struct Player { name: string hp: int x, y: float // names in a row share a type - func hurt(amount: int) { // changes hp, so Dino knows it modifies the player + func hurt(amount: int) { // changes hp, so Rex knows it modifies the player hp -= amount } @@ -45,7 +45,7 @@ method of the same struct (`hurt(2)`), then a global function. ### Structs are values -```dino +```rex struct Point { x, y: int } func main() { @@ -64,7 +64,7 @@ Point{x: 1, y: 2} Point{x: 99, y: 2} ### Methods that return values, and nested data -```dino +```rex struct Vec2 { x, y: float @@ -98,7 +98,7 @@ Vec2{x: 3.0, y: 1.0} [Vec2{x: 1.0, y: 1.0}] 10.0 An enum is "one of these cases", and each case can carry data. -```dino +```rex enum Event { Quit Key(code: int) diff --git a/docs/07-errors-and-nil.md b/docs/07-errors-and-nil.md index bc59820..2bccf8b 100644 --- a/docs/07-errors-and-nil.md +++ b/docs/07-errors-and-nil.md @@ -1,12 +1,12 @@ # 7. Errors and nil -Dino has no exceptions. A function that can fail says so in its result, and you handle it. +Rex has no exceptions. A function that can fail says so in its result, and you handle it. ## error `error` is a type that is either `nil` (all fine) or holds a message. -```dino +```rex func parse_age(s: string): (int, error) { var n, err = s.to_int() if err != nil { @@ -40,7 +40,7 @@ func main() { Writing `?` after a call means "if this failed, return the error from *my* function too". Otherwise you get the value. -```dino +```rex func half(n: int): (int, error) { if n % 2 != 0 { return 0, error("{n} is odd") } return n / 2, nil @@ -69,9 +69,9 @@ if it returns an error, the program prints `error: message` and exits with code ## Optional values: `T?` -A `T?` is either a `T` or `nil`. It is how Dino says "this might be missing". +A `T?` is either a `T` or `nil`. It is how Rex says "this might be missing". -```dino +```rex func find(names: []string, wanted: string): int? { for i, n in names { if n == wanted { return i } @@ -105,7 +105,7 @@ program with a message instead of misbehaving.) Maps give you optionals too: -```dino +```rex func main() { var ports = {"http": 80} var p = ports.get("https") diff --git a/docs/08-memory.md b/docs/08-memory.md index cd3d23c..ae96d7a 100644 --- a/docs/08-memory.md +++ b/docs/08-memory.md @@ -10,7 +10,7 @@ and it also happens on an early `return`, `break`, `continue` or `?`. Giving a value a new owner **copies** it: -```dino +```rex func main() { var a = [1, 2, 3] var b = a // b is a real copy @@ -36,7 +36,7 @@ All tests of the compiler run under a memory checker, so leaks and double frees Sometimes you really do want several owners of **one** value (a texture used by many sprites, a window and its buttons). Write `shared`: -```dino +```rex struct Texture { name: string uses: int @@ -75,7 +75,7 @@ func main() { If a window owns its buttons and each button owns its window, neither would ever be freed. Make one side `weak`: it points at the value without keeping it alive. -```dino +```rex struct Window { title: string buttons: []shared Button @@ -118,7 +118,7 @@ OK clicked, window is gone - To use the value as an owner, call `w.upgrade()`. It gives a `shared T?`: the value (now with one more owner, so it can't vanish while you hold it) or `nil`. -```dino +```rex struct Node { name: string } func main() { diff --git a/docs/09-generics-and-interfaces.md b/docs/09-generics-and-interfaces.md index 144af8f..e7acf75 100644 --- a/docs/09-generics-and-interfaces.md +++ b/docs/09-generics-and-interfaces.md @@ -5,7 +5,7 @@ Put the type names in `[ ]` after the function name. The compiler works the real types out from the arguments. -```dino +```rex func first[T](xs: []T): T { return xs[0] } @@ -38,7 +38,7 @@ Generics cost nothing at run time: every set of types gets its own compiled copy A generic function can take functions too, which makes `map` and `filter` easy to write: -```dino +```rex func map[T, U](xs: []T, f: func(T): U): []U { var out: []U for x in xs { out.push(f(x)) } @@ -59,7 +59,7 @@ func main() { Structs and enums can take types too. When you **use** one, write the types out. -```dino +```rex struct Stack[T] { items: []T @@ -93,7 +93,7 @@ Maybe[string].Some(hi) An interface lists methods. A type follows it just by having those methods, with no `implements` keyword. -```dino +```rex interface Shape { area(): float name(): string @@ -114,7 +114,7 @@ struct Circle { ### As a rule for generics -```dino +```rex interface Shape { area(): float } @@ -141,7 +141,7 @@ area is 9.0 An interface is also a type of its own. A variable of that type can hold any value that has the methods, and the right method runs at run time. This is how you build a mixed list. -```dino +```rex interface Shape { area(): float name(): string diff --git a/docs/10-modules-and-stdlib.md b/docs/10-modules-and-stdlib.md index 2e0dece..a726cbc 100644 --- a/docs/10-modules-and-stdlib.md +++ b/docs/10-modules-and-stdlib.md @@ -2,12 +2,12 @@ ## Splitting a program into files -`import utils` brings in the file `utils.dino` that sits next to your main file. Use its +`import utils` brings in the file `utils.rex` that sits next to your main file. Use its contents with the module name in front. Only things marked `pub` can be used from outside. -`utils.dino`: +`utils.rex`: -```dino +```rex pub const SCALE = 10 pub struct Vec2 { @@ -20,9 +20,9 @@ pub func double(n: int): int { return n * 2 } func secret() {} // private: only this file can call it ``` -`main.dino`: +`main.rex`: -```dino +```rex import utils func main() { @@ -32,7 +32,7 @@ func main() { } ``` -- Folders work too: `import tools.fs` is the file `tools/fs.dino`, used as `fs.name`. +- Folders work too: `import tools.fs` is the file `tools/fs.rex`, used as `fs.name`. - Fields are private as well unless written `pub x: int`. - Every file has its own names, so two files can both define `helper`. - Import loops and missing files are errors. An error message names the file it is in. @@ -59,7 +59,7 @@ Import them like your own files: `import os`. `sqrt pow floor ceil round trunc sin cos tan asin acos atan atan2 exp log log10 hypot min max abs`, and the values `PI` and `E`. -```dino +```rex import math func main() { @@ -79,7 +79,7 @@ func main() { `upper lower trim split lines fields replace repeat contains starts_with ends_with index_of to_int to_float`, plus `len()` and slicing. -```dino +```rex func main() { var csv = " a, b ,c " for part in csv.split(",") { @@ -101,7 +101,7 @@ A list of strings can be joined: `["a", "b"].join("-")`. ## A program that reads input -```dino +```rex import os func main() { diff --git a/docs/11-cheatsheet.md b/docs/11-cheatsheet.md index 6820134..85a6989 100644 --- a/docs/11-cheatsheet.md +++ b/docs/11-cheatsheet.md @@ -1,7 +1,7 @@ # 11. Cheatsheet ## Basics -```dino +```rex var x = 1 // changeable; type inferred var y: float = 2 // with a type const MAX = 100 // fixed @@ -15,7 +15,7 @@ print("x is {x}", y) // interpolation with { } Convert numbers with `float(x)`, `int(x)`, `u8(x)`. ## Control flow -```dino +```rex if a > b { } else if a == b { } else { } for i in 0..10 { } // 0..9 for i in 0..10 step 2 { } @@ -28,7 +28,7 @@ match v { 1 => a, _ => b } ``` ## Functions -```dino +```rex func add(a, b: int): int { return a + b } func f(): (int, error) { return 1, nil } var n, err = f() @@ -38,14 +38,14 @@ var h = x => x * 2 // where the type is known ``` ## Lists -```dino +```rex var xs = [1, 2, 3] var e: []int xs.push(4) xs.pop() xs.len() xs[0] xs[0] = 9 xs[1..3] ``` ## Maps -```dino +```rex var m = {"a": 1} var e: map[string, int] = {} var e2 = map[string, int]{} m["b"] = 2 // add or replace @@ -56,7 +56,7 @@ m.get_or("z", 0) m.len() m.keys() m.values() m.remove("a") ``` ## Strings -```dino +```rex s.len() s.upper() s.lower() s.trim() s.split(",") s.lines() s.fields() s.replace(a, b) s.repeat(n) s.contains(x) s.starts_with(x) s.ends_with(x) s.index_of(x) s.to_int() s.to_float() s[1..4] s[2..] s[..3] @@ -64,7 +64,7 @@ s.index_of(x) s.to_int() s.to_float() s[1..4] s[2..] s[..3] ``` ## Characters -```dino +```rex var c = 'a' '\n' 'é' // one character, single quotes c == 'a' c < 'z' // compare c.is_digit() c.is_letter() c.is_alnum() c.is_space() c.is_upper() c.is_lower() @@ -75,7 +75,7 @@ s[i] // the char starting at byte i ``` ## Structs and enums -```dino +```rex struct P { name: string x, y: float @@ -91,19 +91,19 @@ E.B(3) match e { A => 1, B(n) => n } ``` ## Errors and nil -```dino +```rex error("message {x}") err != nil return 0, nil var v: int? = nil if v != nil { v } if v == nil { return } ``` ## Sharing -```dino +```rex var a = shared T{...} var b = a // same value, two owners var w = weak a w.upgrade() // shared T? (nil if gone) ``` ## Generics and interfaces -```dino +```rex func first[T](xs: []T): T { return xs[0] } func big[T: Ordered](a, b: T): T { ... } // Ordered, Number, or an interface struct Stack[T] { items: []T } Stack[int]{} @@ -112,15 +112,15 @@ var s: Shape = Circle{1.0} ``` ## Files -```dino -import utils // utils.dino next to this file -import tools.fs // tools/fs.dino, used as fs.name +```rex +import utils // utils.rex next to this file +import tools.fs // tools/fs.rex, used as fs.name import os // built-in: os math time pub func f() {} // visible to other files ``` ## C libraries -```dino +```rex import "zlib.h" // zlib.crc32(...), zlib.Z_OK, types like zlib.gzFile import "raylib.h" { InitWindow } // only these names, used bare import "foo.h" link "foo" // when pkg-config doesn't know it (libfoo.so) @@ -129,7 +129,7 @@ lib.fill(buf, n) // T* parameters take a variable or a list ``` ## Commands -`dino run f.dino args…` · `dino build f.dino -o out` · `dino check f.dino` · `dino emit-c f.dino` · `dino fmt path` (`--check` to only report) · `dino lsp` (editor server) · `dino header x.h [word]` (what a C header offers) +`rex run f.rex args…` · `rex build f.rex -o out` · `rex check f.rex` · `rex emit-c f.rex` · `rex fmt path` (`--check` to only report) · `rex lsp` (editor server) · `rex header x.h [word]` (what a C header offers) ## Things that stop the program (exit code 2) Divide by zero · list index/slice out of range · `pop` on an empty list · reading a missing diff --git a/docs/12-calculator-walkthrough.md b/docs/12-calculator-walkthrough.md index cf2b11c..d81c507 100644 --- a/docs/12-calculator-walkthrough.md +++ b/docs/12-calculator-walkthrough.md @@ -4,7 +4,7 @@ The folder `examples/calc/` holds a calculator split over five files. It uses al everything from these notes. Run it: ```text -cargo run -q -- run examples/calc/main.dino examples/calc/session.txt +cargo run -q -- run examples/calc/main.rex examples/calc/session.txt ``` or type calculations interactively by leaving off the file name. @@ -21,11 +21,11 @@ sqrt(16) + max(1, 5) | File | Job | Features it shows | |------|-----|-------------------| -| `token.dino` | Turns text into tokens | enums, structs, `char`, string slicing, errors | -| `ast.dino` | The shape of a calculation | an enum that holds other nodes | -| `parser.dino` | Builds the tree | a struct with methods, `?`, recursion | -| `eval.dino` | Computes the answer | `match`, maps, function values, closures | -| `main.dino` | Reads lines and prints | `import`, `os`, `shared` | +| `token.rex` | Turns text into tokens | enums, structs, `char`, string slicing, errors | +| `ast.rex` | The shape of a calculation | an enum that holds other nodes | +| `parser.rex` | Builds the tree | a struct with methods, `?`, recursion | +| `eval.rex` | Computes the answer | `match`, maps, function values, closures | +| `main.rex` | Reads lines and prints | `import`, `os`, `shared` | ## 1. Tokens @@ -39,7 +39,7 @@ kind of token starts there: `c.is_digit()` starts a number, `c.is_letter()` a na ## 2. The tree -```dino +```rex pub enum Node { Num(value: float) Var(name: string) @@ -63,7 +63,7 @@ with `?`. The scope that remembers variables and functions is two maps: -```dino +```rex pub struct Scope { variables: map[string, float] builtins: map[string, Builtin] @@ -74,7 +74,7 @@ pub struct Scope { A built-in function is a struct holding its name, how many arguments it takes, and a function value: -```dino +```rex s.builtins["sqrt"] = Builtin{"sqrt", 1, a => math.sqrt(a[0])} ``` @@ -86,7 +86,7 @@ which gives `nil` when it isn't there, turned into a friendly error. The scope is created once as `shared`, so every line sees the variables set by the lines before it, with no need to pass the scope back and forth: -```dino +```rex var scope = shared eval.new_scope() ... run_line(scope, line) diff --git a/docs/13-c-libraries.md b/docs/13-c-libraries.md index 122b212..269968c 100644 --- a/docs/13-c-libraries.md +++ b/docs/13-c-libraries.md @@ -1,8 +1,8 @@ # 13. C and C++ libraries A huge amount of useful code is written in C: graphics (raylib, SDL), compression (zlib), -databases (SQLite), and the C library that comes with every system. Dino can use it -directly. You don't write any declarations: Dino reads the library's **header file** (the +databases (SQLite), and the C library that comes with every system. Rex can use it +directly. You don't write any declarations: Rex reads the library's **header file** (the `.h` file that lists what the library has) and works out the rest. ## Importing a header @@ -10,7 +10,7 @@ directly. You don't write any declarations: Dino reads the library's **header fi Put the header's name in quotes. Its functions, types and constants are then used with the header's name in front, the same way as your own files (`import utils` gives `utils.name`). -```dino +```rex import "string.h" import "stdlib.h" @@ -33,7 +33,7 @@ gives `SDL`, `"my-lib.h"` gives `my_lib`. To choose another one, write it before When you only want some things from a header, list them in braces. Those names are then used **without** a prefix, and nothing else from the header is visible: -```dino +```rex import "math.h" { cbrt, hypot } func main() { @@ -44,12 +44,12 @@ func main() { 3.0 5.0 ``` -(`math.h` is the C math library. Dino's own `import math` is usually nicer; this is just a +(`math.h` is the C math library. Rex's own `import math` is usually nicer; this is just a small example.) -## How C types look in Dino +## How C types look in Rex -| In C | In Dino | +| In C | In Rex | |------|---------| | `int`, `unsigned int`, `short`, ... | `i32`, `u32`, `i16`, ... | | `long`, `long long`, `int64_t` | `int` | @@ -59,28 +59,28 @@ small example.) | `bool` | `bool` | | `const char *` and `char *` | `string` | | an `enum` | its values are constants (`i32`) | -| a `struct` with plain fields | a Dino struct: `raylib.Color{255, 0, 0, 255}` | +| a `struct` with plain fields | a Rex struct: `raylib.Color{255, 0, 0, 255}` | | any other pointer (`FILE *`, `SDL_Window *`) | a pointer type: `stdio.FILE`, `SDL.SDL_Window` | | `NULL` | `nil` | -Numbers follow the usual Dino rule: a number written in the code fits any number type, but +Numbers follow the usual Rex rule: a number written in the code fits any number type, but a variable has to be converted, for example `i32(n)` when the C function takes an `int`. -Text works both ways: a Dino string is handed to C as a C string, and a C string that comes -back becomes a Dino string (a copy, so it stays valid). +Text works both ways: a Rex string is handed to C as a C string, and a C string that comes +back becomes a Rex string (a copy, so it stays valid). ## Pointers: things you only pass around Many C libraries give you a pointer to something they manage, like an open file or a -window. In Dino you keep it in a variable, hand it back to the library, and compare it with +window. In Rex you keep it in a variable, hand it back to the library, and compare it with `nil` to see if it is missing: -```dino +```rex import "stdio.h" import os func main() { - var f = stdio.fopen("/tmp/dino-hello.txt", "w") + var f = stdio.fopen("/tmp/rex-hello.txt", "w") if f == nil { print("can't open the file") return @@ -88,7 +88,7 @@ func main() { stdio.fputs("hello from C\n", f) stdio.fclose(f) - var text, err = os.read_file("/tmp/dino-hello.txt") + var text, err = os.read_file("/tmp/rex-hello.txt") print(text.trim(), err) } ``` @@ -98,16 +98,16 @@ hello from C nil The type can be written like any other: `var f: stdio.FILE` starts out as `nil`. -**Dino does not free C things for you.** Whatever the library opens or creates, close or +**Rex does not free C things for you.** Whatever the library opens or creates, close or free it with the library's own function (`fclose`, `sqlite3_close`, `UnloadTexture`, ...). ## Functions that write into your variables Some C functions give back extra results by writing into a variable you pass them (in C: -a pointer parameter like `double *out`). Pass a Dino **variable**, and the function changes +a pointer parameter like `double *out`). Pass a Rex **variable**, and the function changes it. Pass a **list** where the C function wants room for several values (a buffer): -```dino +```rex import "math.h" { modf } import "string.h" { memset } @@ -139,14 +139,14 @@ sqlite3.sqlite3_open("notes.db", db) // db is now open (or still nil if it fai ## Constants -Values from `#define` and `enum` work like Dino constants: `stdio.EOF`, `zlib.Z_OK`, +Values from `#define` and `enum` work like Rex constants: `stdio.EOF`, `zlib.Z_OK`, `raylib.KEY_SPACE`. raylib's colours (`raylib.RED`, `raylib.RAYWHITE`) are struct constants of type `raylib.Color`. ## Linking: where the library's code is The header only describes a library; its code is in a library file that has to be linked -in. Dino asks the system (`pkg-config`) for that, so for most installed libraries +in. Rex asks the system (`pkg-config`) for that, so for most installed libraries `import "raylib.h"` or `import "zlib.h"` is all you need. If a library isn't known to `pkg-config`, name it yourself: for the file `libfoo.so`, write @@ -161,11 +161,11 @@ If it is missing, building stops with a message that says so. [raylib](https://www.raylib.com) is a simple library for games and graphics. With it installed, this opens a window and draws a circle: -```dino +```rex import "raylib.h" func main() { - raylib.InitWindow(800, 450, "Hello from Dino") + raylib.InitWindow(800, 450, "Hello from Rex") raylib.SetTargetFPS(60) var x: f32 = 400.0 for !raylib.WindowShouldClose() { @@ -182,12 +182,12 @@ func main() { ``` A bigger example with bouncing balls is in -[`examples/c/bounce.dino`](../examples/c/bounce.dino). +[`examples/c/bounce.rex`](../examples/c/bounce.rex). ## Your own C code Put a header and its `.c` file next to your program. `import "shapes.h"` reads the header, -and Dino compiles `shapes.c` and builds it into your program. +and Rex compiles `shapes.c` and builds it into your program. ```c // shapes.h @@ -203,7 +203,7 @@ double area(Size s) { return s.w * s.h; } void grow(Size *s, double by) { s->w *= by; s->h *= by; } ``` -```dino +```rex import "shapes.h" func main() { @@ -218,10 +218,10 @@ func main() { ## C++ -C++ code can't be called from C or Dino directly: C++ functions get scrambled ("mangled") +C++ code can't be called from C or Rex directly: C++ functions get scrambled ("mangled") names when compiled, and classes and templates don't exist in C. The usual fix is a small set of plain functions marked `extern "C"`. Write them in a `.cpp` file next to the header, -and Dino compiles it with your C++ compiler (`c++`) and links in the C++ library: +and Rex compiles it with your C++ compiler (`c++`) and links in the C++ library: ```c // counter.h: plain C, also readable by C++ @@ -252,7 +252,7 @@ void counter_free(Counter *c) { delete c; } } ``` -```dino +```rex import "counter.h" func main() { @@ -271,11 +271,11 @@ functions. ## Seeing what a header has -`dino header` lists everything Dino can use from a header, written as Dino. Add a word to +`rex header` lists everything Rex can use from a header, written as Rex. Add a word to only see names that contain it: ```text -dino header zlib.h compress +rex header zlib.h compress ``` ```text import "zlib.h" // use the names below as zlib.name @@ -286,11 +286,11 @@ func compress(dest: []u8 or u8 variable, destLen: []u64 or u64 variable, source: ... ``` -In an editor with Dino support, completion after `zlib.` and hovering a name show the same. +In an editor with Rex support, completion after `zlib.` and hovering a name show the same. ## What doesn't work yet -Dino tells you when you call one of these, and why: +Rex tells you when you call one of these, and why: - functions with a variable number of arguments, like `printf` - functions that take a callback (a function pointer) @@ -299,6 +299,6 @@ Dino tells you when you call one of these, and why: - C macros that take arguments (`#define MAX(a, b) ...`) When you need one of these, write a small function in your own `.c` file that does the C -part, and call that from Dino. +part, and call that from Rex. Next: back to the [overview](README.md) diff --git a/docs/README.md b/docs/README.md index 3df2b74..e24e515 100644 --- a/docs/README.md +++ b/docs/README.md @@ -1,6 +1,6 @@ -# Dino: learn the language +# Rex: learn the language -Dino is a small, fast, modern language. It looks like Go, runs like C, and has no +Rex is a small, fast, modern language. It looks like Go, runs like C, and has no garbage collector, no pointers, and nothing low-level to write. You write plain code; the compiler works out the memory. @@ -25,11 +25,11 @@ These notes teach it from zero. Read them in order, or jump to the ## How to read the examples -Every `dino` block that has a `func main` is a complete program you can save and run. +Every `rex` block that has a `func main` is a complete program you can save and run. The block right after it (marked `text`) shows what it prints. ```` -```dino +```rex func main() { print("hello") } @@ -39,7 +39,7 @@ hello ``` ```` -## The four ideas behind Dino +## The four ideas behind Rex 1. **Values.** `var b = a` makes a real copy. Change `b` and `a` stays the same. There are no hidden aliases, which makes programs easy to reason about. diff --git a/editors/README.md b/editors/README.md index b0ac73f..b7ef2f7 100644 --- a/editors/README.md +++ b/editors/README.md @@ -1,20 +1,20 @@ -# Editor support for Dino +# Editor support for Rex Everything here talks to the compiler itself, so what you see in the editor is exactly what -`dino run` would tell you. +`rex run` would tell you. | You get | How | |---------|-----| | Syntax colours | a grammar file (VS Code, Neovim, Vim) | -| Errors underlined as you type | the language server, `dino lsp` | -| Format the file (and on save) | the same server, using `dino fmt` | +| Errors underlined as you type | the language server, `rex lsp` | +| Format the file (and on save) | the same server, using `rex fmt` | | Outline, go to definition, hover, completion, parameter hints | the same server (reads the file's names; no type checking) | -First put the `dino` program on your `PATH`: +First put the `rex` program on your `PATH`: ```text cargo build --release -cp target/release/dino ~/.local/bin/ # or anywhere on your PATH +cp target/release/rex ~/.local/bin/ # or anywhere on your PATH ``` ## VS Code @@ -24,14 +24,14 @@ The extension is in `editors/vscode/`. ```text cd editors/vscode npm install # downloads the small language-client library -npx @vscode/vsce package # makes dino-0.1.0.vsix -code --install-extension dino-0.1.0.vsix +npx @vscode/vsce package # makes rex-0.1.0.vsix +code --install-extension rex-0.1.0.vsix ``` To try it without installing, open the `editors/vscode` folder in VS Code and press **F5**. -If `dino` is not on your `PATH`, set **Dino: Server Path** in the settings to the full path. -Format-on-save and 4-space indents are switched on for `.dino` files by default. +If `rex` is not on your `PATH`, set **Rex: Server Path** in the settings to the full path. +Format-on-save and 4-space indents are switched on for `.rex` files by default. ## Neovim @@ -40,19 +40,19 @@ Put the `vim/` folder on your runtime path to get file detection and colours, fo ```text mkdir -p ~/.config/nvim/syntax ~/.config/nvim/ftdetect -cp vim/syntax/dino.vim ~/.config/nvim/syntax/ -cp vim/ftdetect/dino.vim ~/.config/nvim/ftdetect/ +cp vim/syntax/rex.vim ~/.config/nvim/syntax/ +cp vim/ftdetect/rex.vim ~/.config/nvim/ftdetect/ ``` Then in `init.lua` (Neovim 0.8 or newer): ```lua vim.api.nvim_create_autocmd("FileType", { - pattern = "dino", + pattern = "rex", callback = function(args) vim.lsp.start({ - name = "dino", - cmd = { "dino", "lsp" }, + name = "rex", + cmd = { "rex", "lsp" }, root_dir = vim.fs.dirname(args.file), }) vim.bo.shiftwidth = 4 @@ -61,7 +61,7 @@ vim.api.nvim_create_autocmd("FileType", { }) -- format when saving vim.api.nvim_create_autocmd("BufWritePre", { - pattern = "*.dino", + pattern = "*.rex", callback = function() vim.lsp.buf.format({ async = false }) end, }) ``` @@ -73,26 +73,26 @@ Plain Vim gets the colours from the same two files (no language server). Add this to `~/.config/helix/languages.toml`: ```toml -[language-server.dino] -command = "dino" +[language-server.rex] +command = "rex" args = ["lsp"] [[language]] -name = "dino" -scope = "source.dino" -file-types = ["dino"] +name = "rex" +scope = "source.rex" +file-types = ["rex"] comment-token = "//" indent = { tab-width = 4, unit = " " } -language-servers = ["dino"] +language-servers = ["rex"] auto-format = true ``` ## Any other editor -Anything that can run a language server works: start `dino lsp` (it speaks the standard -protocol over stdin/stdout) for files ending in `.dino`. It supports diagnostics and +Anything that can run a language server works: start `rex lsp` (it speaks the standard +protocol over stdin/stdout) for files ending in `.rex`. It supports diagnostics and whole-file formatting. The grammar for colours is the TextMate file -`vscode/syntaxes/dino.tmLanguage.json`, which Sublime Text, Zed and many others can read. +`vscode/syntaxes/rex.tmLanguage.json`, which Sublime Text, Zed and many others can read. ## What the server does (and doesn't) do yet @@ -105,7 +105,7 @@ whole-file formatting. The grammar for colours is the TextMate file ## Opcode -Opcode (the C++ editor in `~/Desktop/Porn/Linux/Clean/opcode`) knows Dino out of the box: colours, -`//` comments, snippets, the outline, format with `dino fmt -`, and the language server -(`dino lsp`) for errors, go to definition, hover, completion and parameter hints. It only needs -`dino` on your `PATH` (see the top of this page). +Opcode (the C++ editor in `~/Desktop/Porn/Linux/Clean/opcode`) knows Rex out of the box: colours, +`//` comments, snippets, the outline, format with `rex fmt -`, and the language server +(`rex lsp`) for errors, go to definition, hover, completion and parameter hints. It only needs +`rex` on your `PATH` (see the top of this page). diff --git a/editors/vim/ftdetect/dino.vim b/editors/vim/ftdetect/dino.vim deleted file mode 100644 index d956566..0000000 --- a/editors/vim/ftdetect/dino.vim +++ /dev/null @@ -1 +0,0 @@ -autocmd BufRead,BufNewFile *.dino setfiletype dino diff --git a/editors/vim/ftdetect/rex.vim b/editors/vim/ftdetect/rex.vim new file mode 100644 index 0000000..5062e83 --- /dev/null +++ b/editors/vim/ftdetect/rex.vim @@ -0,0 +1 @@ +autocmd BufRead,BufNewFile *.rex setfiletype rex diff --git a/editors/vim/syntax/dino.vim b/editors/vim/syntax/dino.vim deleted file mode 100644 index 5bbad55..0000000 --- a/editors/vim/syntax/dino.vim +++ /dev/null @@ -1,37 +0,0 @@ -" Vim / Neovim syntax highlighting for Dino -if exists("b:current_syntax") - finish -endif - -syn keyword dinoControl if else for in step match return break continue -syn keyword dinoDeclare func var const import struct enum interface pub -syn keyword dinoModifier shared weak -syn keyword dinoConstant true false nil -syn keyword dinoType int float bool char string error map i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 -syn match dinoTypeName "\<[A-Z][A-Za-z0-9_]*\>" -syn match dinoNumber "\<[0-9][0-9_]*\(\.[0-9][0-9_]*\)\?\>" -syn match dinoCall "\<[a-z_][A-Za-z0-9_]*\ze\s*(" -syn match dinoOperator "=>\|\.\.\|==\|!=\|<=\|>=\|&&\|||\|[-+*/%]=\?\|[<>!?=]" -syn match dinoEscape "\\." contained -syn region dinoInterp matchgroup=dinoInterpEdge start="{" end="}" contained contains=TOP -syn region dinoString start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=dinoEscape,dinoInterp -syn match dinoChar "'\(\\.\|[^'\\]\)'" -syn region dinoComment start="/\*" end="\*/" -syn match dinoComment "//.*$" - -hi def link dinoControl Conditional -hi def link dinoDeclare Keyword -hi def link dinoModifier StorageClass -hi def link dinoConstant Constant -hi def link dinoType Type -hi def link dinoTypeName Type -hi def link dinoNumber Number -hi def link dinoCall Function -hi def link dinoOperator Operator -hi def link dinoEscape SpecialChar -hi def link dinoInterpEdge Delimiter -hi def link dinoString String -hi def link dinoChar Character -hi def link dinoComment Comment - -let b:current_syntax = "dino" diff --git a/editors/vim/syntax/rex.vim b/editors/vim/syntax/rex.vim new file mode 100644 index 0000000..4b11aee --- /dev/null +++ b/editors/vim/syntax/rex.vim @@ -0,0 +1,37 @@ +" Vim / Neovim syntax highlighting for Rex +if exists("b:current_syntax") + finish +endif + +syn keyword rexControl if else for in step match return break continue +syn keyword rexDeclare func var const import struct enum interface pub +syn keyword rexModifier shared weak +syn keyword rexConstant true false nil +syn keyword rexType int float bool char string error map i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 +syn match rexTypeName "\<[A-Z][A-Za-z0-9_]*\>" +syn match rexNumber "\<[0-9][0-9_]*\(\.[0-9][0-9_]*\)\?\>" +syn match rexCall "\<[a-z_][A-Za-z0-9_]*\ze\s*(" +syn match rexOperator "=>\|\.\.\|==\|!=\|<=\|>=\|&&\|||\|[-+*/%]=\?\|[<>!?=]" +syn match rexEscape "\\." contained +syn region rexInterp matchgroup=rexInterpEdge start="{" end="}" contained contains=TOP +syn region rexString start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rexEscape,rexInterp +syn match rexChar "'\(\\.\|[^'\\]\)'" +syn region rexComment start="/\*" end="\*/" +syn match rexComment "//.*$" + +hi def link rexControl Conditional +hi def link rexDeclare Keyword +hi def link rexModifier StorageClass +hi def link rexConstant Constant +hi def link rexType Type +hi def link rexTypeName Type +hi def link rexNumber Number +hi def link rexCall Function +hi def link rexOperator Operator +hi def link rexEscape SpecialChar +hi def link rexInterpEdge Delimiter +hi def link rexString String +hi def link rexChar Character +hi def link rexComment Comment + +let b:current_syntax = "rex" diff --git a/editors/vscode/extension.js b/editors/vscode/extension.js index 90b7ae4..42dd105 100644 --- a/editors/vscode/extension.js +++ b/editors/vscode/extension.js @@ -1,20 +1,20 @@ -// Starts `dino lsp` and connects the editor to it. All the work is done by the compiler. +// Starts `rex lsp` and connects the editor to it. All the work is done by the compiler. const vscode = require('vscode'); const { LanguageClient } = require('vscode-languageclient/node'); let client; function activate() { - const command = vscode.workspace.getConfiguration('dino').get('serverPath') || 'dino'; + const command = vscode.workspace.getConfiguration('rex').get('serverPath') || 'rex'; client = new LanguageClient( - 'dino', - 'Dino Language Server', + 'rex', + 'Rex Language Server', { command, args: ['lsp'] }, - { documentSelector: [{ scheme: 'file', language: 'dino' }] } + { documentSelector: [{ scheme: 'file', language: 'rex' }] } ); client.start().catch((err) => { vscode.window.showErrorMessage( - `Could not start "${command} lsp": ${err.message}. Put the dino program on your PATH or set "dino.serverPath".` + `Could not start "${command} lsp": ${err.message}. Put the rex program on your PATH or set "rex.serverPath".` ); }); } diff --git a/editors/vscode/package.json b/editors/vscode/package.json index b543d06..ac47170 100644 --- a/editors/vscode/package.json +++ b/editors/vscode/package.json @@ -1,43 +1,43 @@ { - "name": "dino", - "displayName": "Dino", - "description": "Syntax highlighting, error checking and formatting for the Dino language", + "name": "rex", + "displayName": "Rex", + "description": "Syntax highlighting, error checking and formatting for the Rex language", "version": "0.1.0", - "publisher": "dino-lang", + "publisher": "rex-lang", "license": "MIT", "engines": { "vscode": "^1.75.0" }, "categories": ["Programming Languages", "Formatters"], - "activationEvents": ["onLanguage:dino"], + "activationEvents": ["onLanguage:rex"], "main": "./extension.js", "dependencies": { "vscode-languageclient": "^9.0.1" }, "contributes": { "languages": [ { - "id": "dino", - "aliases": ["Dino", "dino"], - "extensions": [".dino"], + "id": "rex", + "aliases": ["Rex", "rex"], + "extensions": [".rex"], "configuration": "./language-configuration.json" } ], "grammars": [ { - "language": "dino", - "scopeName": "source.dino", - "path": "./syntaxes/dino.tmLanguage.json" + "language": "rex", + "scopeName": "source.rex", + "path": "./syntaxes/rex.tmLanguage.json" } ], "configuration": { - "title": "Dino", + "title": "Rex", "properties": { - "dino.serverPath": { + "rex.serverPath": { "type": "string", - "default": "dino", - "description": "The `dino` program that provides the language server (it is started as `dino lsp`)." + "default": "rex", + "description": "The `rex` program that provides the language server (it is started as `rex lsp`)." } } }, "configurationDefaults": { - "[dino]": { + "[rex]": { "editor.insertSpaces": true, "editor.tabSize": 4, "editor.formatOnSave": true diff --git a/editors/vscode/syntaxes/dino.tmLanguage.json b/editors/vscode/syntaxes/dino.tmLanguage.json deleted file mode 100644 index 73953b0..0000000 --- a/editors/vscode/syntaxes/dino.tmLanguage.json +++ /dev/null @@ -1,103 +0,0 @@ -{ - "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json", - "name": "Dino", - "scopeName": "source.dino", - "patterns": [ - { "include": "#comments" }, - { "include": "#strings" }, - { "include": "#chars" }, - { "include": "#declarations" }, - { "include": "#keywords" }, - { "include": "#constants" }, - { "include": "#numbers" }, - { "include": "#types" }, - { "include": "#calls" }, - { "include": "#operators" } - ], - "repository": { - "comments": { - "patterns": [ - { "name": "comment.line.double-slash.dino", "match": "//.*$" }, - { "name": "comment.block.dino", "begin": "/\\*", "end": "\\*/" } - ] - }, - "strings": { - "name": "string.quoted.double.dino", - "begin": "\"", - "end": "\"", - "patterns": [ - { "name": "constant.character.escape.dino", "match": "\\\\." }, - { - "name": "meta.interpolation.dino", - "begin": "\\{", - "end": "\\}", - "beginCaptures": { "0": { "name": "punctuation.section.interpolation.begin.dino" } }, - "endCaptures": { "0": { "name": "punctuation.section.interpolation.end.dino" } }, - "patterns": [{ "include": "$self" }] - } - ] - }, - "chars": { - "name": "string.quoted.single.dino", - "match": "'(?:\\\\.|[^'\\\\])'", - "captures": {} - }, - "declarations": { - "patterns": [ - { - "match": "\\b(func)\\s+([A-Za-z_][A-Za-z0-9_]*)", - "captures": { - "1": { "name": "keyword.declaration.function.dino" }, - "2": { "name": "entity.name.function.dino" } - } - }, - { - "match": "\\b(struct|enum|interface)\\s+([A-Za-z_][A-Za-z0-9_]*)", - "captures": { - "1": { "name": "keyword.declaration.type.dino" }, - "2": { "name": "entity.name.type.dino" } - } - } - ] - }, - "keywords": { - "patterns": [ - { "name": "keyword.control.dino", "match": "\\b(if|else|for|in|step|match|return|break|continue)\\b" }, - { "name": "keyword.declaration.dino", "match": "\\b(func|var|const|import|struct|enum|interface|pub)\\b" }, - { "name": "storage.modifier.dino", "match": "\\b(shared|weak)\\b" } - ] - }, - "constants": { - "name": "constant.language.dino", - "match": "\\b(true|false|nil)\\b" - }, - "numbers": { - "name": "constant.numeric.dino", - "match": "\\b[0-9][0-9_]*(?:\\.[0-9][0-9_]*)?\\b" - }, - "types": { - "patterns": [ - { - "name": "support.type.builtin.dino", - "match": "\\b(int|float|bool|char|string|error|map|i8|i16|i32|i64|u8|u16|u32|u64|f32|f64)\\b" - }, - { "name": "entity.name.type.dino", "match": "\\b[A-Z][A-Za-z0-9_]*\\b" } - ] - }, - "calls": { - "name": "entity.name.function.call.dino", - "match": "\\b[a-z_][A-Za-z0-9_]*(?=\\s*\\()" - }, - "operators": { - "patterns": [ - { "name": "keyword.operator.arrow.dino", "match": "=>" }, - { "name": "keyword.operator.range.dino", "match": "\\.\\." }, - { "name": "keyword.operator.comparison.dino", "match": "==|!=|<=|>=|<|>" }, - { "name": "keyword.operator.logical.dino", "match": "&&|\\|\\||!" }, - { "name": "keyword.operator.assignment.dino", "match": "[-+*/%]?=" }, - { "name": "keyword.operator.arithmetic.dino", "match": "[-+*/%]" }, - { "name": "keyword.operator.optional.dino", "match": "\\?" } - ] - } - } -} diff --git a/editors/vscode/syntaxes/rex.tmLanguage.json b/editors/vscode/syntaxes/rex.tmLanguage.json new file mode 100644 index 0000000..3255b32 --- /dev/null +++ b/editors/vscode/syntaxes/rex.tmLanguage.json @@ -0,0 +1,103 @@ +{ + "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json", + "name": "Rex", + "scopeName": "source.rex", + "patterns": [ + { "include": "#comments" }, + { "include": "#strings" }, + { "include": "#chars" }, + { "include": "#declarations" }, + { "include": "#keywords" }, + { "include": "#constants" }, + { "include": "#numbers" }, + { "include": "#types" }, + { "include": "#calls" }, + { "include": "#operators" } + ], + "repository": { + "comments": { + "patterns": [ + { "name": "comment.line.double-slash.rex", "match": "//.*$" }, + { "name": "comment.block.rex", "begin": "/\\*", "end": "\\*/" } + ] + }, + "strings": { + "name": "string.quoted.double.rex", + "begin": "\"", + "end": "\"", + "patterns": [ + { "name": "constant.character.escape.rex", "match": "\\\\." }, + { + "name": "meta.interpolation.rex", + "begin": "\\{", + "end": "\\}", + "beginCaptures": { "0": { "name": "punctuation.section.interpolation.begin.rex" } }, + "endCaptures": { "0": { "name": "punctuation.section.interpolation.end.rex" } }, + "patterns": [{ "include": "$self" }] + } + ] + }, + "chars": { + "name": "string.quoted.single.rex", + "match": "'(?:\\\\.|[^'\\\\])'", + "captures": {} + }, + "declarations": { + "patterns": [ + { + "match": "\\b(func)\\s+([A-Za-z_][A-Za-z0-9_]*)", + "captures": { + "1": { "name": "keyword.declaration.function.rex" }, + "2": { "name": "entity.name.function.rex" } + } + }, + { + "match": "\\b(struct|enum|interface)\\s+([A-Za-z_][A-Za-z0-9_]*)", + "captures": { + "1": { "name": "keyword.declaration.type.rex" }, + "2": { "name": "entity.name.type.rex" } + } + } + ] + }, + "keywords": { + "patterns": [ + { "name": "keyword.control.rex", "match": "\\b(if|else|for|in|step|match|return|break|continue)\\b" }, + { "name": "keyword.declaration.rex", "match": "\\b(func|var|const|import|struct|enum|interface|pub)\\b" }, + { "name": "storage.modifier.rex", "match": "\\b(shared|weak)\\b" } + ] + }, + "constants": { + "name": "constant.language.rex", + "match": "\\b(true|false|nil)\\b" + }, + "numbers": { + "name": "constant.numeric.rex", + "match": "\\b[0-9][0-9_]*(?:\\.[0-9][0-9_]*)?\\b" + }, + "types": { + "patterns": [ + { + "name": "support.type.builtin.rex", + "match": "\\b(int|float|bool|char|string|error|map|i8|i16|i32|i64|u8|u16|u32|u64|f32|f64)\\b" + }, + { "name": "entity.name.type.rex", "match": "\\b[A-Z][A-Za-z0-9_]*\\b" } + ] + }, + "calls": { + "name": "entity.name.function.call.rex", + "match": "\\b[a-z_][A-Za-z0-9_]*(?=\\s*\\()" + }, + "operators": { + "patterns": [ + { "name": "keyword.operator.arrow.rex", "match": "=>" }, + { "name": "keyword.operator.range.rex", "match": "\\.\\." }, + { "name": "keyword.operator.comparison.rex", "match": "==|!=|<=|>=|<|>" }, + { "name": "keyword.operator.logical.rex", "match": "&&|\\|\\||!" }, + { "name": "keyword.operator.assignment.rex", "match": "[-+*/%]?=" }, + { "name": "keyword.operator.arithmetic.rex", "match": "[-+*/%]" }, + { "name": "keyword.operator.optional.rex", "match": "\\?" } + ] + } + } +} diff --git a/examples/01_hello_tool.dino b/examples/01_hello_tool.rex similarity index 100% rename from examples/01_hello_tool.dino rename to examples/01_hello_tool.rex diff --git a/examples/02_game_loop.dino b/examples/02_game_loop.rex similarity index 95% rename from examples/02_game_loop.dino rename to examples/02_game_loop.rex index 64adc17..30fec0d 100644 --- a/examples/02_game_loop.dino +++ b/examples/02_game_loop.rex @@ -21,7 +21,7 @@ struct Player { } func main() { - var win = gfx.open("Dino", 800, 600) + var win = gfx.open("Rex", 800, 600) var player = Player{pos: Vec2{100, 100}, vel: Vec2{200, 150}, size: 32} for win.is_open() { diff --git a/examples/03_shared_app.dino b/examples/03_shared_app.rex similarity index 93% rename from examples/03_shared_app.dino rename to examples/03_shared_app.rex index 23f717a..90e2cc7 100644 --- a/examples/03_shared_app.dino +++ b/examples/03_shared_app.rex @@ -15,7 +15,7 @@ struct Editor { func main() { var doc = shared Document{title: "Notes", text: ""} - var win = ui.window("Dino Notes", 640, 480) + var win = ui.window("Rex Notes", 640, 480) var editor = Editor{doc: doc} win.on_key(func(k: ui.Key) { diff --git a/examples/04_types.dino b/examples/04_types.rex similarity index 100% rename from examples/04_types.dino rename to examples/04_types.rex diff --git a/examples/basics/chars.out b/examples/basics/chars.out index 73f48ca..2115ab7 100644 --- a/examples/basics/chars.out +++ b/examples/basics/chars.out @@ -4,6 +4,6 @@ a true true 97 B a! 1 é 3 😀 h é l 2 -DINO q plus newline other +REX q plus newline other {b: 1, a: 3, n: 2} abc true true true diff --git a/examples/basics/chars.dino b/examples/basics/chars.rex similarity index 94% rename from examples/basics/chars.dino rename to examples/basics/chars.rex index 5c2f28b..2efb70b 100644 --- a/examples/basics/chars.dino +++ b/examples/basics/chars.rex @@ -23,7 +23,7 @@ func main() { for i, ch in "aé😀" { print(i, ch) } print(s[0], s[1], s[3], s[s.len() - 1]) var up = "" - for ch in "dino" { up += string(ch.upper()) } + for ch in "rex" { up += string(ch.upper()) } print(up, 'Q'.lower(), kind('+'), kind('\n'), kind('z')) var counts: map[char, int] = {} for ch in "banana" { counts[ch] += 1 } diff --git a/examples/basics/closures.dino b/examples/basics/closures.rex similarity index 100% rename from examples/basics/closures.dino rename to examples/basics/closures.rex diff --git a/examples/basics/enum_data.dino b/examples/basics/enum_data.rex similarity index 100% rename from examples/basics/enum_data.dino rename to examples/basics/enum_data.rex diff --git a/examples/basics/enums.dino b/examples/basics/enums.rex similarity index 100% rename from examples/basics/enums.dino rename to examples/basics/enums.rex diff --git a/examples/basics/errors.dino b/examples/basics/errors.rex similarity index 100% rename from examples/basics/errors.dino rename to examples/basics/errors.rex diff --git a/examples/basics/fib.dino b/examples/basics/fib.rex similarity index 100% rename from examples/basics/fib.dino rename to examples/basics/fib.rex diff --git a/examples/basics/generic_types.dino b/examples/basics/generic_types.rex similarity index 100% rename from examples/basics/generic_types.dino rename to examples/basics/generic_types.rex diff --git a/examples/basics/hello.dino b/examples/basics/hello.dino deleted file mode 100644 index 204702f..0000000 --- a/examples/basics/hello.dino +++ /dev/null @@ -1,3 +0,0 @@ -func main() { - print("Hello, Dino!") -} diff --git a/examples/basics/hello.out b/examples/basics/hello.out index dfcfd3d..9ef2d2a 100644 --- a/examples/basics/hello.out +++ b/examples/basics/hello.out @@ -1 +1 @@ -Hello, Dino! +Hello, Rex! diff --git a/examples/basics/hello.rex b/examples/basics/hello.rex new file mode 100644 index 0000000..2e41e70 --- /dev/null +++ b/examples/basics/hello.rex @@ -0,0 +1,3 @@ +func main() { + print("Hello, Rex!") +} diff --git a/examples/basics/interface_values.dino b/examples/basics/interface_values.rex similarity index 100% rename from examples/basics/interface_values.dino rename to examples/basics/interface_values.rex diff --git a/examples/basics/interfaces.dino b/examples/basics/interfaces.rex similarity index 100% rename from examples/basics/interfaces.dino rename to examples/basics/interfaces.rex diff --git a/examples/basics/list_values.dino b/examples/basics/list_values.rex similarity index 100% rename from examples/basics/list_values.dino rename to examples/basics/list_values.rex diff --git a/examples/basics/lists.out b/examples/basics/lists.out index d5751c7..8a3b3ad 100644 --- a/examples/basics/lists.out +++ b/examples/basics/lists.out @@ -10,4 +10,4 @@ sq[4] = 16 [] 0 [a, b] 2 items [1.0, 2.5, 3.0] -dino-lang 4 +rex-lang 3 diff --git a/examples/basics/lists.dino b/examples/basics/lists.rex similarity index 97% rename from examples/basics/lists.dino rename to examples/basics/lists.rex index 8923d54..19ff011 100644 --- a/examples/basics/lists.dino +++ b/examples/basics/lists.rex @@ -55,6 +55,6 @@ func main() { var floats: []float = [1, 2.5, 3] print(floats) - var words = ["dino", "lang"] + var words = ["rex", "lang"] print(words[0] + "-" + words[1], words[0].len()) } diff --git a/examples/basics/loops.dino b/examples/basics/loops.rex similarity index 100% rename from examples/basics/loops.dino rename to examples/basics/loops.rex diff --git a/examples/basics/maps.dino b/examples/basics/maps.rex similarity index 100% rename from examples/basics/maps.dino rename to examples/basics/maps.rex diff --git a/examples/basics/numbers.dino b/examples/basics/numbers.rex similarity index 100% rename from examples/basics/numbers.dino rename to examples/basics/numbers.rex diff --git a/examples/basics/optionals.dino b/examples/basics/optionals.rex similarity index 100% rename from examples/basics/optionals.dino rename to examples/basics/optionals.rex diff --git a/examples/basics/order.dino b/examples/basics/order.rex similarity index 100% rename from examples/basics/order.dino rename to examples/basics/order.rex diff --git a/examples/basics/own_flows.dino b/examples/basics/own_flows.rex similarity index 100% rename from examples/basics/own_flows.dino rename to examples/basics/own_flows.rex diff --git a/examples/basics/own_strings.dino b/examples/basics/own_strings.rex similarity index 100% rename from examples/basics/own_strings.dino rename to examples/basics/own_strings.rex diff --git a/examples/basics/own_structs.dino b/examples/basics/own_structs.rex similarity index 100% rename from examples/basics/own_structs.dino rename to examples/basics/own_structs.rex diff --git a/examples/basics/shared.dino b/examples/basics/shared.rex similarity index 100% rename from examples/basics/shared.dino rename to examples/basics/shared.rex diff --git a/examples/basics/sieve.dino b/examples/basics/sieve.rex similarity index 100% rename from examples/basics/sieve.dino rename to examples/basics/sieve.rex diff --git a/examples/basics/sized.dino b/examples/basics/sized.rex similarity index 100% rename from examples/basics/sized.dino rename to examples/basics/sized.rex diff --git a/examples/basics/stdlib.dino b/examples/basics/stdlib.rex similarity index 86% rename from examples/basics/stdlib.dino rename to examples/basics/stdlib.rex index a0e688f..f6d2e99 100644 --- a/examples/basics/stdlib.dino +++ b/examples/basics/stdlib.rex @@ -36,13 +36,13 @@ func main() { time.sleep(0.01) print(time.now() - t0 >= 0.01) - var err4 = os.write_file("/tmp/dino_std_test.txt", "one two\nthree\n\nfour five six\n") + var err4 = os.write_file("/tmp/rex_std_test.txt", "one two\nthree\n\nfour five six\n") print(err4) - var lines, words, e5 = count("/tmp/dino_std_test.txt") + var lines, words, e5 = count("/tmp/rex_std_test.txt") print(lines, words, e5) var l2, w2, e6 = count("/tmp/definitely/not/here.txt") print(l2, w2, e6) - print(os.exists("/tmp/dino_std_test.txt"), os.exists("/nope")) + print(os.exists("/tmp/rex_std_test.txt"), os.exists("/nope")) print(os.args.len(), os.env("HOME_NOPE_X") == nil) var home = os.env("PATH") if home != nil { print(home.len() > 0) } diff --git a/examples/basics/strings.out b/examples/basics/strings.out index 73b095f..991efa0 100644 --- a/examples/basics/strings.out +++ b/examples/basics/strings.out @@ -1,4 +1,4 @@ -Hello, Dino! +Hello, Rex! n is 3, doubled 6, big? true pi is about 3.75 true true false diff --git a/examples/basics/strings.dino b/examples/basics/strings.rex similarity index 94% rename from examples/basics/strings.dino rename to examples/basics/strings.rex index f00ecce..e5797fa 100644 --- a/examples/basics/strings.dino +++ b/examples/basics/strings.rex @@ -3,7 +3,7 @@ func greet(name: string): string { } func main() { - var name = "Dino" + var name = "Rex" print(greet(name)) var n = 3 print("n is {n}, doubled {n * 2}, big? {n > 2}") diff --git a/examples/basics/structs.dino b/examples/basics/structs.rex similarity index 100% rename from examples/basics/structs.dino rename to examples/basics/structs.rex diff --git a/examples/basics/value_semantics.dino b/examples/basics/value_semantics.rex similarity index 100% rename from examples/basics/value_semantics.dino rename to examples/basics/value_semantics.rex diff --git a/examples/c/bounce.dino b/examples/c/bounce.rex similarity index 91% rename from examples/c/bounce.dino rename to examples/c/bounce.rex index 68c6122..9bc5edc 100644 --- a/examples/c/bounce.dino +++ b/examples/c/bounce.rex @@ -1,5 +1,5 @@ // A ball bouncing around a window, drawn with raylib (https://www.raylib.com). -// Needs raylib installed: `dino run bounce.dino`. Space adds a ball, Escape quits. +// Needs raylib installed: `rex run bounce.rex`. Space adds a ball, Escape quits. import "raylib.h" @@ -28,7 +28,7 @@ func new_ball(n: int): Ball { } func main() { - raylib.InitWindow(WIDTH, HEIGHT, "Dino + raylib") + raylib.InitWindow(WIDTH, HEIGHT, "Rex + raylib") raylib.SetTargetFPS(60) var balls = [new_ball(0)] for !raylib.WindowShouldClose() { diff --git a/examples/calc/ast.dino b/examples/calc/ast.rex similarity index 100% rename from examples/calc/ast.dino rename to examples/calc/ast.rex diff --git a/examples/calc/eval.dino b/examples/calc/eval.rex similarity index 100% rename from examples/calc/eval.dino rename to examples/calc/eval.rex diff --git a/examples/calc/main.dino b/examples/calc/main.rex similarity index 100% rename from examples/calc/main.dino rename to examples/calc/main.rex diff --git a/examples/calc/parser.dino b/examples/calc/parser.rex similarity index 100% rename from examples/calc/parser.dino rename to examples/calc/parser.rex diff --git a/examples/calc/token.dino b/examples/calc/token.rex similarity index 100% rename from examples/calc/token.dino rename to examples/calc/token.rex diff --git a/examples/modules/geometry.dino b/examples/modules/geometry.rex similarity index 100% rename from examples/modules/geometry.dino rename to examples/modules/geometry.rex diff --git a/examples/modules/main.dino b/examples/modules/main.rex similarity index 100% rename from examples/modules/main.dino rename to examples/modules/main.rex diff --git a/dino-logo.svg b/rex-logo.svg similarity index 99% rename from dino-logo.svg rename to rex-logo.svg index e324fc4..b87b083 100644 --- a/dino-logo.svg +++ b/rex-logo.svg @@ -29,7 +29,7 @@ - + @@ -136,6 +136,6 @@ - + diff --git a/dino.svg b/rex.svg similarity index 100% rename from dino.svg rename to rex.svg diff --git a/src/cheader.rs b/src/cheader.rs index daf4c55..dfccc0b 100644 --- a/src/cheader.rs +++ b/src/cheader.rs @@ -1,5 +1,5 @@ //! Reads a C header for `import "zlib.h"`: runs the C preprocessor on it, then picks out the -//! functions, structs, constants and pointer types that Dino code can use. +//! functions, structs, constants and pointer types that Rex code can use. //! //! The generated C program includes the header itself, so nothing here has to be exact about //! how C declares things: it only has to know enough to check calls and convert values. @@ -11,21 +11,21 @@ use std::sync::{Mutex, OnceLock}; use crate::types::{Num, Ty}; -/// A C type as Dino sees it. +/// A C type as Rex sees it. #[derive(Debug, Clone, PartialEq)] pub enum CTy { Void, /// A number or `bool` (never `Str`). Num(Ty), - /// `char *` / `const char *`: Dino strings. + /// `char *` / `const char *`: Rex strings. Str, - /// A pointer Dino can only pass around: `SDL_Window *`, `gzFile`, `void *` (`"pointer"`). + /// A pointer Rex can only pass around: `SDL_Window *`, `gzFile`, `void *` (`"pointer"`). Handle(String), - /// A struct passed by value, by its Dino name. + /// A struct passed by value, by its Rex name. Struct(String), /// A pointer to a number or struct: filled in by the function (or only read, if `konst`). Ptr { to: Box, konst: bool }, - /// Something Dino can't pass; the text says what. + /// Something Rex can't pass; the text says what. Unsupported(String), } @@ -34,13 +34,13 @@ pub struct Func { pub name: String, pub params: Vec<(String, CTy)>, pub ret: CTy, - /// Why the function can't be called from Dino, if it can't. + /// Why the function can't be called from Rex, if it can't. pub problem: Option, } #[derive(Debug, Clone)] pub struct Struct { - /// The Dino name (the typedef name if there is one, else the struct tag). + /// The Rex name (the typedef name if there is one, else the struct tag). pub name: String, /// How C spells the type: `Color` or `struct timeval`. pub c: String, @@ -52,7 +52,7 @@ pub enum Value { Int(i64), Float(f64), Str(String), - /// A macro that stands for a struct value, like raylib's `RED`: the struct's Dino name. + /// A macro that stands for a struct value, like raylib's `RED`: the struct's Rex name. Struct(String), } @@ -62,12 +62,12 @@ pub struct Const { pub value: Value, } -/// Everything Dino knows about one header. +/// Everything Rex knows about one header. #[derive(Debug, Clone, Default)] pub struct Lib { /// As written in the import: `zlib.h`, `SDL2/SDL.h`. pub header: String, - /// The default name in Dino code: `zlib`, `SDL`. + /// The default name in Rex code: `zlib`, `SDL`. pub prefix: String, /// Flags for compiling (`-I...`, `-D...`) and for linking (`-l...`). pub cflags: Vec, @@ -77,7 +77,7 @@ pub struct Lib { pub funcs: Vec, pub structs: Vec, pub consts: Vec, - /// Pointer types that can be written as Dino types: `gzFile`, `SDL_Window`. + /// Pointer types that can be written as Rex types: `gzFile`, `SDL_Window`. pub handles: Vec, } @@ -94,7 +94,7 @@ impl Lib { pub fn has_handle(&self, name: &str) -> bool { self.handles.iter().any(|h| h == name) } - /// How a C type reads in Dino. + /// How a C type reads in Rex. pub fn type_text(&self, t: &CTy) -> String { match t { CTy::Void => "nothing".into(), @@ -122,12 +122,12 @@ impl Lib { format!("{}({}){ret}", f.name, params.join(", ")) } - /// One line about a name of the header, for hover and `dino header`. + /// One line about a name of the header, for hover and `rex header`. pub fn describe(&self, name: &str) -> Option { if let Some(f) = self.func(name) { let mut s = format!("func {}", self.signature(f)); if let Some(p) = &f.problem { - s.push_str(&format!("\n(can't be called from Dino: it {p})")); + s.push_str(&format!("\n(can't be called from Rex: it {p})")); } return Some(s); } @@ -150,7 +150,7 @@ impl Lib { None } - /// Every name the header gives Dino, for messages and completion. + /// Every name the header gives Rex, for messages and completion. pub fn names(&self) -> Vec<&str> { let mut v: Vec<&str> = self.funcs.iter().filter(|f| f.problem.is_none()).map(|f| f.name.as_str()).collect(); v.extend(self.structs.iter().map(|s| s.name.as_str())); @@ -160,7 +160,7 @@ impl Lib { } } -/// The name a header gets in Dino code: `SDL2/SDL.h` -> `SDL`, `my-lib.h` -> `my_lib`. +/// The name a header gets in Rex code: `SDL2/SDL.h` -> `SDL`, `my-lib.h` -> `my_lib`. pub fn prefix_of(header: &str) -> String { let file = header.rsplit('/').next().unwrap_or(header); let stem = file.split('.').next().unwrap_or(file); @@ -171,7 +171,7 @@ pub fn prefix_of(header: &str) -> String { out } -/// Read a header. `dir` is the folder of the Dino file that imports it (local headers and their +/// Read a header. `dir` is the folder of the Rex file that imports it (local headers and their /// `.c`/`.cpp` files are found there); `link` is the library named with `link "..."`. pub fn load(header: &str, dir: &Path, link: Option<&str>) -> Result { type Key = (String, PathBuf, Option, Option); @@ -360,7 +360,7 @@ fn lex(text: &str) -> Lexed { let def = def.trim_start(); let name_end = def.find(|c: char| !(c.is_ascii_alphanumeric() || c == '_')).unwrap_or(def.len()); let name = def[..name_end].to_string(); - // function-like macros can't be used from Dino + // function-like macros can't be used from Rex if !def[name_end..].starts_with('(') && !name.is_empty() { let body = lex_line(&def[name_end..], cur); defines.retain(|d| d.0 != name); @@ -399,7 +399,7 @@ fn lex_line(line: &str, file: u32) -> Vec { i += 1; } let word = &line[s..i]; - // `L"..."`, `u8"..."`: wide strings are not for Dino; keep the prefix as a name + // `L"..."`, `u8"..."`: wide strings are not for Rex; keep the prefix as a name out.push(Tok { t: T::Id(word.to_string()), file }); } else if c.is_ascii_digit() || (c == b'.' && b.get(i + 1).map_or(false, |d| d.is_ascii_digit())) { let s = i; @@ -475,7 +475,7 @@ fn lex_line(line: &str, file: u32) -> Vec { // ---------- C declarations ---------- -/// A C type as written, before Dino decides what it can do with it. +/// A C type as written, before Rex decides what it can do with it. #[derive(Debug, Clone, PartialEq)] enum Raw { Void, @@ -496,7 +496,7 @@ enum Raw { struct RawStruct { fields: Option>, - /// Something in the body Dino can't copy field by field (an array, an unnamed member). + /// Something in the body Rex can't copy field by field (an array, an unnamed member). problem: Option, union: bool, } @@ -858,7 +858,7 @@ impl Parser { let Some((base, konst)) = self.specifiers() else { self.pos = start; self.recover(); - problem.get_or_insert("has a field Dino can't read".into()); + problem.get_or_insert("has a field Rex can't read".into()); continue; }; if self.eat(";") { @@ -1086,7 +1086,7 @@ impl Parser { } } - // ---------- from C declarations to what Dino can use ---------- + // ---------- from C declarations to what Rex can use ---------- fn wanted(&self, file: u32) -> bool { let Some(main) = self.main else { return true }; @@ -1145,7 +1145,7 @@ impl Parser { (t, last) } - /// The Dino name of a struct tag: a typedef naming exactly that struct, else the tag. + /// The Rex name of a struct tag: a typedef naming exactly that struct, else the tag. fn struct_name(&self, tag: &str, names: &HashMap) -> String { names.get(tag).cloned().unwrap_or_else(|| tag.to_string()) } @@ -1174,7 +1174,7 @@ impl Parser { if !union && mapped.contains(tag) { CTy::Struct(name) } else { - CTy::Unsupported(format!("passes a `{name}` by value, and Dino can't build that type")) + CTy::Unsupported(format!("passes a `{name}` by value, and Rex can't build that type")) } } Raw::Ptr(inner, konst) => { @@ -1195,7 +1195,7 @@ impl Parser { CTy::Handle(name) } } - Raw::Func { .. } => CTy::Unsupported("takes a callback function, which Dino can't pass yet".into()), + Raw::Func { .. } => CTy::Unsupported("takes a callback function, which Rex can't pass yet".into()), // `sqlite3 **db`: the function hands back a pointer through it Raw::Ptr(..) if typedef.is_none() => match self.convert(inner, mapped, names) { h @ CTy::Handle(_) => CTy::Ptr { to: Box::new(h), konst: *konst }, @@ -1206,12 +1206,12 @@ impl Parser { } Raw::Array(_) => CTy::Unsupported("uses a C array type".into()), Raw::Func { .. } => CTy::Unsupported("uses a function type".into()), - Raw::Named(n) | Raw::Unknown(n) => CTy::Unsupported(format!("uses the C type `{n}`, which Dino doesn't know")), + Raw::Named(n) | Raw::Unknown(n) => CTy::Unsupported(format!("uses the C type `{n}`, which Rex doesn't know")), } } fn finish(mut self, lib: &mut Lib) { - // struct tag -> Dino name: `typedef struct Color {...} Color;` and `typedef struct {...} Color;` + // struct tag -> Rex name: `typedef struct Color {...} Color;` and `typedef struct {...} Color;` let mut names: HashMap = HashMap::new(); for (n, _) in &self.typedef_order { if let Some(Raw::Struct { tag, .. }) = self.typedefs.get(n) { @@ -1222,7 +1222,7 @@ impl Parser { } } } - // which structs Dino can copy field by field (all fields numbers, pointers or such structs) + // which structs Rex can copy field by field (all fields numbers, pointers or such structs) let mut mapped: HashSet = HashSet::new(); loop { let mut changed = false; @@ -1302,7 +1302,7 @@ impl Parser { } } if let CTy::Ptr { .. } = ret { - // a returned pointer to numbers: Dino can only hold on to it + // a returned pointer to numbers: Rex can only hold on to it } let ret = match ret { CTy::Ptr { .. } => CTy::Handle("pointer".into()), @@ -1625,7 +1625,7 @@ mod tests { typedef struct Window Window;\n\ typedef struct gz_s *gzFile;\n\ enum { A = 1, B, C = A << 4 };\n\ - #define NAME \"dino\"\n\ + #define NAME \"rex\"\n\ #define RED (Color){ 255, 0, 0, 255 }\n\ #define FLAG (0x10u | 2)\n\ #define PI 3.5\n\ @@ -1655,7 +1655,7 @@ mod tests { let c = |n: &str| lib.konst(n).map(|c| c.value.clone()); assert_eq!(c("B"), Some(Value::Int(2))); assert_eq!(c("C"), Some(Value::Int(16))); - assert_eq!(c("NAME"), Some(Value::Str("dino".into()))); + assert_eq!(c("NAME"), Some(Value::Str("rex".into()))); assert_eq!(c("RED"), Some(Value::Struct("Color".into()))); assert_eq!(c("FLAG"), Some(Value::Int(0x12))); assert_eq!(c("PI"), Some(Value::Float(3.5))); diff --git a/src/check.rs b/src/check.rs index 165215a..b9f373d 100644 --- a/src/check.rs +++ b/src/check.rs @@ -659,7 +659,7 @@ impl Checker { if module != self.cur_mod && self.private.contains(key) { let short = key.rsplit('.').next().unwrap(); return Err(Diag::new( - format!("`{short}` is private to `{module}`; write `pub` in front of it in {module}.dino to share it"), + format!("`{short}` is private to `{module}`; write `pub` in front of it in {module}.rex to share it"), span, )); } @@ -1165,7 +1165,7 @@ impl Checker { Ok(()) } - /// The Dino type for a C type, if it has one. + /// The Rex type for a C type, if it has one. fn c_type(&self, lib: usize, t: &CTy) -> Option { Some(match t { CTy::Void => Ty::Unit, @@ -1178,7 +1178,7 @@ impl Checker { }) } - /// Structs from C headers become Dino structs (`raylib.Color`), converted at calls. + /// Structs from C headers become Rex structs (`raylib.Color`), converted at calls. fn register_c_structs(&mut self) { for li in 0..self.clibs.len() { let prefix = self.clibs[li].prefix.clone(); @@ -1248,7 +1248,7 @@ impl Checker { return Err(Diag::new(format!("`{}` has no function `{name}`{hint}", l.header), name_span)); }; if let Some(why) = &f.problem { - return Err(Diag::new(format!("`{name}` can't be called from Dino: it {why}"), name_span)); + return Err(Diag::new(format!("`{name}` can't be called from Rex: it {why}"), name_span)); } if args.len() != f.params.len() { let names: Vec = f @@ -1325,7 +1325,7 @@ impl Checker { } CTy::Ptr { to, konst } => { let Some(inner) = self.c_type(lib, to) else { - return Err(Diag::new(format!("{what} has a type Dino can't pass"), a.span)); + return Err(Diag::new(format!("{what} has a type Rex can't pass"), a.span)); }; if is_nil { return null(); @@ -1349,7 +1349,7 @@ impl Checker { let h = self.expr(a, Some(inner))?; if h.ty == Ty::list(inner) { if matches!(inner, Ty::Struct(_)) { - return Err(Diag::new(format!("{what} wants C structs in a row; a Dino list of structs can't be passed"), a.span)); + return Err(Diag::new(format!("{what} wants C structs in a row; a Rex list of structs can't be passed"), a.span)); } return Ok((h, CArg::Buffer)); } @@ -1376,7 +1376,7 @@ impl Checker { } CTy::Num(_) | CTy::Struct(_) => { let want = self.c_type(lib, pt).unwrap(); - // a C `char` takes a Dino character: `'a'` + // a C `char` takes a Rex character: `'a'` if matches!(want, Ty::Num(Num::I8 | Num::U8)) { let h = self.expr(a, Some(want))?; if h.ty == Ty::Char { @@ -1386,7 +1386,7 @@ impl Checker { } Ok((self.expr_as(a, want)?, CArg::Value)) } - CTy::Void | CTy::Unsupported(_) => Err(Diag::new(format!("{what} has a type Dino can't pass"), a.span)), + CTy::Void | CTy::Unsupported(_) => Err(Diag::new(format!("{what} has a type Rex can't pass"), a.span)), } } @@ -2462,7 +2462,7 @@ impl Checker { let owner_mod = module_of(owner); if owner_mod != self.cur_mod && self.private.contains(&format!("{owner}.{field}")) { return Err(Diag::new( - format!("field `{field}` is private to `{owner_mod}`; write `pub` in front of it in {owner_mod}.dino to share it"), + format!("field `{field}` is private to `{owner_mod}`; write `pub` in front of it in {owner_mod}.rex to share it"), span, )); } @@ -3409,7 +3409,7 @@ impl Checker { && self.ifaces.values().any(|i| i.methods.iter().any(|(n, _, _)| n == name)); if owner_mod != self.cur_mod && !via_rule && self.private.contains(&format!("{owner}.{name}")) { return Err(Diag::new( - format!("method `{name}` is private to `{owner_mod}`; write `pub` in front of it in {owner_mod}.dino to share it"), + format!("method `{name}` is private to `{owner_mod}`; write `pub` in front of it in {owner_mod}.rex to share it"), name_span, )); } diff --git a/src/codegen_c.rs b/src/codegen_c.rs index ca26725..67dad14 100644 --- a/src/codegen_c.rs +++ b/src/codegen_c.rs @@ -1,7 +1,7 @@ //! Emits C from the typed tree. //! //! Evaluation order: every call (and every operation that can panic) is stored -//! in a temporary in its own statement, so Dino's left-to-right order holds even +//! in a temporary in its own statement, so Rex's left-to-right order holds even //! though C leaves argument order unspecified. An operand read before a later //! operand that changes things (or may panic) is copied to a temporary first. //! @@ -127,13 +127,13 @@ pub fn generate(p: &HProgram) -> String { } // what building needs, for the driver (one item per line, so paths may contain spaces) for f in &p.c.cflags { - g.out.push_str(&format!("// dino-cflag: {f}\n")); + g.out.push_str(&format!("// rex-cflag: {f}\n")); } for f in &p.c.libs { - g.out.push_str(&format!("// dino-lib: {f}\n")); + g.out.push_str(&format!("// rex-lib: {f}\n")); } for f in &p.c.sources { - g.out.push_str(&format!("// dino-source: {f}\n")); + g.out.push_str(&format!("// rex-source: {f}\n")); } if p.c.headers.is_empty() { g.out.push_str(RUNTIME); @@ -336,10 +336,10 @@ pub fn generate(p: &HProgram) -> String { g.out.push_str(&defs); if main_fails { g.out.push_str( - "int main(int argc, char **argv) {\n dino_set_args(argc, argv);\n dino_err e = d_main();\n if (e.set) {\n fflush(stdout);\n fprintf(stderr, \"error: %.*s\\n\", (int)e.msg.n, e.msg.p);\n dino_err_release(e);\n return 1;\n }\n return 0;\n}\n", + "int main(int argc, char **argv) {\n rex_set_args(argc, argv);\n rex_err e = d_main();\n if (e.set) {\n fflush(stdout);\n fprintf(stderr, \"error: %.*s\\n\", (int)e.msg.n, e.msg.p);\n rex_err_release(e);\n return 1;\n }\n return 0;\n}\n", ); } else { - g.out.push_str("int main(int argc, char **argv) {\n dino_set_args(argc, argv);\n d_main();\n return 0;\n}\n"); + g.out.push_str("int main(int argc, char **argv) {\n rex_set_args(argc, argv);\n d_main();\n return 0;\n}\n"); } g.out } @@ -523,7 +523,7 @@ fn c_ty(t: Ty) -> String { Ty::Struct(name) | Ty::Enum(name) => c_struct(name), Ty::List(_) | Ty::Map(..) | Ty::Opt(_) | Ty::Tuple(_) | Ty::Shared(_) | Ty::Weak(_) | Ty::Func(_) | Ty::Iface(_) => tag(t), Ty::Num(n) => num_c(n).into(), - Ty::Error => "dino_err".into(), + Ty::Error => "rex_err".into(), Ty::CPtr(_) => "void *".into(), Ty::Unit => "void".into(), } @@ -542,7 +542,7 @@ fn num_c(n: Num) -> &'static str { } } -/// Make a Dino name safe to use as part of a C identifier. +/// Make a Rex name safe to use as part of a C identifier. fn mangle(name: &str) -> String { name.chars() .map(|c| if c.is_ascii_alphanumeric() || c == '_' { c.to_string() } else { format!("u{:x}_", c as u32) }) @@ -570,9 +570,9 @@ fn func_cname(owner: Option<&str>, name: &str) -> String { } } -/// A C string literal for `dstr`, as `dino_lit("...", len)`. +/// A C string literal for `dstr`, as `rex_lit("...", len)`. fn str_lit(s: &str) -> String { - let mut out = String::from("dino_lit(\""); + let mut out = String::from("rex_lit(\""); for b in s.bytes() { match b { b'"' => out.push_str("\\\""), @@ -618,17 +618,17 @@ fn is_place(e: &HExpr) -> bool { /// A C expression turning a value of type `ty` (given as C code) into a `dstr`. fn to_str(ty: Ty, c: &str) -> String { match ty { - Ty::Int => format!("dino_i64_str({c})"), - Ty::Float => format!("dino_f64_str({c})"), - Ty::Bool => format!("dino_bool_str({c})"), - Ty::Char => format!("dino_char_str({c})"), - Ty::Str => format!("dino_str_retain({c})"), + Ty::Int => format!("rex_i64_str({c})"), + Ty::Float => format!("rex_f64_str({c})"), + Ty::Bool => format!("rex_bool_str({c})"), + Ty::Char => format!("rex_char_str({c})"), + Ty::Str => format!("rex_str_retain({c})"), Ty::Struct(_) | Ty::Enum(_) | Ty::List(_) | Ty::Map(..) | Ty::Opt(_) | Ty::Shared(_) | Ty::Weak(_) | Ty::Func(_) | Ty::Iface(_) => format!("{}_str({c})", c_ty(ty)), - Ty::Num(Num::U64) => format!("dino_u64_str({c})"), - Ty::Num(Num::F32) => format!("dino_f32_str({c})"), - Ty::Num(_) => format!("dino_i64_str((int64_t)({c}))"), - Ty::Error => format!("dino_err_str({c})"), - Ty::CPtr(_) => format!("dino_ptr_str({c})"), + Ty::Num(Num::U64) => format!("rex_u64_str({c})"), + Ty::Num(Num::F32) => format!("rex_f32_str({c})"), + Ty::Num(_) => format!("rex_i64_str((int64_t)({c}))"), + Ty::Error => format!("rex_err_str({c})"), + Ty::CPtr(_) => format!("rex_ptr_str({c})"), Ty::Tuple(_) => unreachable!("several values can't be turned into text"), Ty::Unit => unreachable!("nothing can't be turned into text"), } @@ -728,8 +728,8 @@ impl Gen { /// The C statement that frees the value in the lvalue `lv`. fn drop_line(&self, ty: Ty, lv: &str) -> String { match ty { - Ty::Str => format!("dino_str_release({lv});"), - Ty::Error => format!("dino_err_release({lv});"), + Ty::Str => format!("rex_str_release({lv});"), + Ty::Error => format!("rex_err_release({lv});"), _ => format!("{}_drop(&({lv}));", c_ty(ty)), } } @@ -780,9 +780,9 @@ impl Gen { if !self.info.needs_copy(ty) { e.to_string() } else if ty == Ty::Str { - format!("dino_str_retain({e})") + format!("rex_str_retain({e})") } else if ty == Ty::Error { - format!("dino_err_retain({e})") + format!("rex_err_retain({e})") } else { format!("{}_copy({e})", c_ty(ty)) } @@ -802,7 +802,7 @@ impl Gen { } /// For a struct from a C header: `S_raylib_Color_to_c` and `S_raylib_Color_from_c`, which copy - /// the fields between Dino's struct and the C one. + /// the fields between Rex's struct and the C one. fn c_struct_conversions(&mut self, s: &HStruct) { let Some(cname) = &s.c else { return }; let c = c_struct(&s.name); @@ -827,7 +827,7 @@ impl Gen { )); } - /// A Dino value as the C function wants it. + /// A Rex value as the C function wants it. fn to_c_value(&self, ty: Ty, v: &str) -> String { match ty { Ty::Struct(n) if self.c_structs.contains_key(n) => format!("{}_to_c({v})", c_struct(n)), @@ -859,7 +859,7 @@ impl Gen { CArg::Str => { let v = vs.next().unwrap(); let t = self.fresh(); - self.line(&format!("char *{t} = dino_cstr({v});")); + self.line(&format!("char *{t} = rex_cstr({v});")); after.push(format!("free({t});")); parts.push(t); } @@ -895,7 +895,7 @@ impl Gen { String::new() } else { let conv = match ty { - Ty::Str => format!("dino_from_cstr({call})"), + Ty::Str => format!("rex_from_cstr({call})"), Ty::Struct(n) if self.c_structs.contains_key(n) => format!("{}_from_c({call})", c_struct(n)), Ty::CPtr(_) => format!("(void *)({call})"), t => format!("({})({call})", c_ty(t)), @@ -924,7 +924,7 @@ impl Gen { self.out.push_str(&format!("static dstr {c}_str({c} v) {{\n")); self.out.push_str(&format!(" dstr parts[] = {{{}}};\n", parts.join(", "))); self.out.push_str(&format!( - " dstr r = dino_cat_n({0}, parts);\n for (int i = 0; i < {0}; i++) dino_str_release(parts[i]);\n return r;\n}}\n\n", + " dstr r = rex_cat_n({0}, parts);\n for (int i = 0; i < {0}; i++) rex_str_release(parts[i]);\n return r;\n}}\n\n", parts.len() )); @@ -984,13 +984,13 @@ impl Gen { } parts.push(str_lit(")")); self.out.push_str(&format!( - " case {i}: {{ dstr parts[] = {{{}}}; dstr r = dino_cat_n({n}, parts); for (int k = 0; k < {n}; k++) dino_str_release(parts[k]); return r; }}\n", + " case {i}: {{ dstr parts[] = {{{}}}; dstr r = rex_cat_n({n}, parts); for (int k = 0; k < {n}; k++) rex_str_release(parts[k]); return r; }}\n", parts.join(", "), n = parts.len() )); } } - self.out.push_str(" }\n return dino_lit(\"?\", 1);\n}\n\n"); + self.out.push_str(" }\n return rex_lit(\"?\", 1);\n}\n\n"); if self.info.needs_copy_named(&e.name) { self.out.push_str(&format!("static {c} {c}_copy({c} v) {{\n {c} r = v;\n switch (v.tag) {{\n")); @@ -1063,7 +1063,7 @@ impl Gen { match w { Ty::Opt(inner) => { out.push_str(&format!( - "static dstr {c}_str({c} v) {{\n if (!v.has) return dino_lit(\"nil\", 3);\n return {};\n}}\n\n", + "static dstr {c}_str({c} v) {{\n if (!v.has) return rex_lit(\"nil\", 3);\n return {};\n}}\n\n", to_str(*inner, "v.v") )); if self.info.needs_copy(*inner) { @@ -1099,7 +1099,7 @@ impl Gen { let methods = &ifaces.iter().find(|(n, _)| n == iname).unwrap().1; let drop_t = if self.info.needs_copy(t) { format!(" {}\n", self.drop_line(t, &format!("*({tc} *)p"))) } else { String::new() }; let mut out = format!( - "static void *{base}_copy(void *p) {{\n {tc} *d = ({tc} *)malloc(sizeof({tc}));\n if (!d) dino_panic(\"out of memory\");\n *d = {};\n return d;\n}}\n\ + "static void *{base}_copy(void *p) {{\n {tc} *d = ({tc} *)malloc(sizeof({tc}));\n if (!d) rex_panic(\"out of memory\");\n *d = {};\n return d;\n}}\n\ static void {base}_drop(void *p) {{\n{drop_t} free(p);\n}}\n\ static dstr {base}_str(void *p) {{\n return {tc}_str(*({tc} *)p);\n}}\n", self.copy_of(t, &format!("*({tc} *)p")) @@ -1141,7 +1141,7 @@ impl Gen { .collect(); out.push_str(&format!( "static const struct VT_{ic} {base}_vt = {{ {} }};\n\ - static {ic} {ic}_from_{tc}({tc} v) {{\n {tc} *b = ({tc} *)malloc(sizeof({tc}));\n if (!b) dino_panic(\"out of memory\");\n *b = v;\n return ({ic}){{ b, &{base}_vt }};\n}}\n\n", + static {ic} {ic}_from_{tc}({tc} v) {{\n {tc} *b = ({tc} *)malloc(sizeof({tc}));\n if (!b) rex_panic(\"out of memory\");\n *b = v;\n return ({ic}){{ b, &{base}_vt }};\n}}\n\n", entries.join(", ") )); out @@ -1179,7 +1179,7 @@ impl Gen { .collect(); self.closure_protos.push_str(&format!( "typedef struct {env} {{ {} }} {env};\n\ - static void *{env}_copy(void *p) {{\n {env} *s = ({env} *)p;\n {env} *d = ({env} *)malloc(sizeof({env}));\n if (!d) dino_panic(\"out of memory\");\n{}\n return d;\n}}\n\ + static void *{env}_copy(void *p) {{\n {env} *s = ({env} *)p;\n {env} *d = ({env} *)malloc(sizeof({env}));\n if (!d) rex_panic(\"out of memory\");\n{}\n return d;\n}}\n\ static void {env}_drop(void *p) {{\n {env} *s = ({env} *)p;\n{}\n free(s);\n}}\n", fields.join(" "), copies.join("\n"), @@ -1216,7 +1216,7 @@ impl Gen { self.stmts(body); self.end_scope(); if ret != Ty::Unit { - self.line("dino_panic(\"reached the end of a function without returning\");"); + self.line("rex_panic(\"reached the end of a function without returning\");"); } self.out.push_str("}\n\n"); let text = std::mem::replace(&mut self.out, saved_out); @@ -1234,7 +1234,7 @@ impl Gen { } else { let t = self.fresh(); self.line(&format!("{env} *{t} = ({env} *)malloc(sizeof({env}));")); - self.line(&format!("if (!{t}) dino_panic(\"out of memory\");")); + self.line(&format!("if (!{t}) rex_panic(\"out of memory\");")); for (i, v) in vs.iter().enumerate() { self.line(&format!("{t}->f{i} = {v};")); } @@ -1272,7 +1272,7 @@ impl Gen { format!( r#"static {c} {c}_new({t} v) {{ {bx} *b = ({bx} *)malloc(sizeof({bx})); - if (!b) dino_panic("out of memory"); + if (!b) rex_panic("out of memory"); b->rc = 1; b->wk = 0; b->v = v; @@ -1296,7 +1296,7 @@ static void {c}_drop({c} *h) {{ }} static {t} *{c}_ref({c} h) {{ - if (!h.p) dino_panic("this `shared` value is empty"); + if (!h.p) rex_panic("this `shared` value is empty"); return &h.p->v; }} @@ -1342,7 +1342,7 @@ static bool {c}_alive({c} w) {{ }} static {t} *{c}_ref({c} w) {{ - if (!{c}_alive(w)) dino_panic("this `weak` value is gone (or was never set)"); + if (!{c}_alive(w)) rex_panic("this `weak` value is gone (or was never set)"); return &w.p->v; }} @@ -1379,9 +1379,9 @@ static dstr {c}_str({c} w) {{ let Ty::Map(k, v) = m else { unreachable!() }; let (c, kt, vt) = (c_ty(m), c_ty(*k), c_ty(*v)); let (hash, eq) = if *k == Ty::Str { - ("dino_hash_str(key)".to_string(), "dino_streq(a, b)".to_string()) + ("rex_hash_str(key)".to_string(), "rex_streq(a, b)".to_string()) } else { - ("dino_hash_i64((int64_t)key)".to_string(), "a == b".to_string()) + ("rex_hash_i64((int64_t)key)".to_string(), "a == b".to_string()) }; let copy_k = self.copy_of(*k, "m.k[i]"); let copy_v = self.copy_of(*v, "m.v[i]"); @@ -1410,7 +1410,7 @@ static void {c}_reindex({c} *m) {{ while (cap < m->len * 2 + 2) cap *= 2; free(m->idx); m->idx = (int64_t *)calloc((size_t)cap, sizeof(int64_t)); - if (!m->idx) dino_panic("out of memory"); + if (!m->idx) rex_panic("out of memory"); m->icap = cap; for (int64_t i = 0; i < m->len; i++) {{ uint64_t h = {c}_hash(m->k[i]) & (uint64_t)(cap - 1); @@ -1437,7 +1437,7 @@ static {vt} *{c}_ptr(const {c} *m, {kt} key) {{ static {vt} *{c}_at(const {c} *m, {kt} key) {{ {vt} *p = {c}_ptr(m, key); - if (!p) dino_panic("that key is not in the map (check with `has` or use `get`)"); + if (!p) rex_panic("that key is not in the map (check with `has` or use `get`)"); return p; }} @@ -1459,10 +1459,10 @@ static void {c}_set({c} *m, {kt} key, {vt} val) {{ if (m->len == m->cap) {{ int64_t cap = m->cap ? m->cap * 2 : 4; {kt} *nk = ({kt} *)realloc(m->k, (size_t)cap * sizeof({kt})); - if (!nk) dino_panic("out of memory"); + if (!nk) rex_panic("out of memory"); m->k = nk; {vt} *nv = ({vt} *)realloc(m->v, (size_t)cap * sizeof({vt})); - if (!nv) dino_panic("out of memory"); + if (!nv) rex_panic("out of memory"); m->v = nv; m->cap = cap; }} @@ -1489,7 +1489,7 @@ static {c} {c}_copy({c} m) {{ if (m.len > 0) {{ r.k = ({kt} *)malloc((size_t)m.len * sizeof({kt})); r.v = ({vt} *)malloc((size_t)m.len * sizeof({vt})); - if (!r.k || !r.v) dino_panic("out of memory"); + if (!r.k || !r.v) rex_panic("out of memory"); r.len = r.cap = m.len; for (int64_t i = 0; i < m.len; i++) {{ r.k[i] = {copy_k}; @@ -1513,18 +1513,18 @@ static void {c}_drop({c} *m) {{ static dstr {c}_str({c} m) {{ dstr *parts = (dstr *)malloc(sizeof(dstr) * (size_t)(m.len * 4 + 2)); - if (!parts) dino_panic("out of memory"); + if (!parts) rex_panic("out of memory"); int k = 0; - parts[k++] = dino_lit("{{", 1); + parts[k++] = rex_lit("{{", 1); for (int64_t i = 0; i < m.len; i++) {{ - if (i > 0) parts[k++] = dino_lit(", ", 2); + if (i > 0) parts[k++] = rex_lit(", ", 2); parts[k++] = {key_str}; - parts[k++] = dino_lit(": ", 2); + parts[k++] = rex_lit(": ", 2); parts[k++] = {val_str}; }} - parts[k++] = dino_lit("}}", 1); - dstr r = dino_cat_n(k, parts); - for (int i = 0; i < k; i++) dino_str_release(parts[i]); + parts[k++] = rex_lit("}}", 1); + dstr r = rex_cat_n(k, parts); + for (int i = 0; i < k; i++) rex_str_release(parts[i]); free(parts); return r; }} @@ -1561,7 +1561,7 @@ static dstr {c}_str({c} m) {{ }; format!( r#"static inline {t} *{c}_at(const {c} *l, int64_t i) {{ - if (i < 0 || i >= l->len) dino_index_panic(i, l->len); + if (i < 0 || i >= l->len) rex_index_panic(i, l->len); return &l->p[i]; }} @@ -1569,7 +1569,7 @@ static void {c}_push({c} *l, {t} v) {{ if (l->len == l->cap) {{ int64_t cap = l->cap ? l->cap * 2 : 4; {t} *p = ({t} *)realloc(l->p, (size_t)cap * sizeof({t})); - if (!p) dino_panic("out of memory"); + if (!p) rex_panic("out of memory"); l->p = p; l->cap = cap; }} @@ -1577,7 +1577,7 @@ static void {c}_push({c} *l, {t} v) {{ }} static {t} {c}_pop({c} *l) {{ - if (l->len == 0) dino_panic("pop from an empty list"); + if (l->len == 0) rex_panic("pop from an empty list"); return l->p[--l->len]; }} @@ -1585,7 +1585,7 @@ static {c} {c}_copy({c} l) {{ {c} r = {{0}}; if (l.len > 0) {{ r.p = ({t} *)malloc((size_t)l.len * sizeof({t})); - if (!r.p) dino_panic("out of memory"); + if (!r.p) rex_panic("out of memory"); r.len = r.cap = l.len; for (int64_t i = 0; i < l.len; i++) r.p[i] = {copy_i}; }} @@ -1599,12 +1599,12 @@ static void {c}_drop({c} *l) {{ }} static {c} {c}_slice({c} l, int64_t lo, int64_t hi) {{ - if (lo < 0 || hi > l.len || lo > hi) dino_slice_panic(lo, hi, l.len); + if (lo < 0 || hi > l.len || lo > hi) rex_slice_panic(lo, hi, l.len); {c} r = {{0}}; if (hi > lo) {{ int64_t n = hi - lo; r.p = ({t} *)malloc((size_t)n * sizeof({t})); - if (!r.p) dino_panic("out of memory"); + if (!r.p) rex_panic("out of memory"); r.len = r.cap = n; for (int64_t i = 0; i < n; i++) r.p[i] = {copy_lo}; }} @@ -1613,16 +1613,16 @@ static {c} {c}_slice({c} l, int64_t lo, int64_t hi) {{ static dstr {c}_str({c} l) {{ dstr *parts = (dstr *)malloc(sizeof(dstr) * (size_t)(l.len * 2 + 2)); - if (!parts) dino_panic("out of memory"); + if (!parts) rex_panic("out of memory"); int k = 0; - parts[k++] = dino_lit("[", 1); + parts[k++] = rex_lit("[", 1); for (int64_t i = 0; i < l.len; i++) {{ - if (i > 0) parts[k++] = dino_lit(", ", 2); + if (i > 0) parts[k++] = rex_lit(", ", 2); parts[k++] = {elem_str}; }} - parts[k++] = dino_lit("]", 1); - dstr r = dino_cat_n(k, parts); - for (int i = 0; i < k; i++) dino_str_release(parts[i]); + parts[k++] = rex_lit("]", 1); + dstr r = rex_cat_n(k, parts); + for (int i = 0; i < k; i++) rex_str_release(parts[i]); free(parts); return r; }} @@ -1676,7 +1676,7 @@ static dstr {c}_str({c} l) {{ self.stmts(&f.body); self.end_scope(); if f.ret != Ty::Unit { - self.line("dino_panic(\"reached the end of a function without returning\");"); + self.line("rex_panic(\"reached the end of a function without returning\");"); } self.indent = 0; self.out.push_str("}\n\n"); @@ -1833,7 +1833,7 @@ static dstr {c}_str({c} l) {{ match &step_v { None => self.line(&format!("for (int64_t {cc} = {cs}; {cc} < {ce}; {cc}++) {{")), Some(step_v) => { - self.line(&format!("if ({step_v} == 0) dino_panic(\"the step of a range can't be 0\");")); + self.line(&format!("if ({step_v} == 0) rex_panic(\"the step of a range can't be 0\");")); self.line(&format!( "for (int64_t {cc} = {cs}; {step_v} > 0 ? {cc} < {ce} : {cc} > {ce}; {cc} += {step_v}) {{" )); @@ -1956,7 +1956,7 @@ static dstr {c}_str({c} l) {{ } else if iter.ty == Ty::Str { let name = local_name(var.id, &var.name); self.line(&format!("uint32_t {name} = 0;")); - self.line(&format!("{w} = dino_utf8_decode({it}.p + {k}, {it}.n - {k}, &{name});")); + self.line(&format!("{w} = rex_utf8_decode({it}.p + {k}, {it}.n - {k}, &{name});")); } else { let elem = format!("{it}.p[{k}]"); // a list or struct element is copied only if the body changes the loop variable @@ -2050,7 +2050,7 @@ static dstr {c}_str({c} l) {{ let idx = self.expr(index); if base.ty == Ty::Str { // a character of a string is a value, not a place - return format!("dino_str_char_at({b}, {idx})"); + return format!("rex_str_char_at({b}, {idx})"); } format!("(*{}_at(&{b}, {idx}))", c_ty(base.ty)) } @@ -2063,7 +2063,7 @@ static dstr {c}_str({c} l) {{ self.line(&format!("{} {t} = {v};", c_ty(inner.ty))); t }; - self.line(&format!("if (!{b}.has) dino_panic(\"used a nil value\");")); + self.line(&format!("if (!{b}.has) rex_panic(\"used a nil value\");")); format!("{b}.v") } _ => self.expr(e), @@ -2135,7 +2135,7 @@ static dstr {c}_str({c} l) {{ HExprKind::MakeError(msg) => { let v = self.expr(msg); self.take(&v); - format!("((dino_err){{ .set = true, .msg = {v} }})") + format!("((rex_err){{ .set = true, .msg = {v} }})") } HExprKind::ToIface(inner) => { let v = self.expr(inner); @@ -2158,7 +2158,7 @@ static dstr {c}_str({c} l) {{ Some(t) => t, None => self.place_str(recv), }; - self.line(&format!("if (!{cs}.data) dino_panic(\"called a method on an empty interface value\");")); + self.line(&format!("if (!{cs}.data) rex_panic(\"called a method on an empty interface value\");")); let mut all = vec![format!("{cs}.data")]; all.extend(vs); self.materialize(e.ty, format!("{cs}.vt->m_{}({})", mangle(method), all.join(", "))) @@ -2179,7 +2179,7 @@ static dstr {c}_str({c} l) {{ Some(t) => t, None => self.place_str(callee), }; - self.line(&format!("if (!{cs}.fn) dino_panic(\"called an empty function value\");")); + self.line(&format!("if (!{cs}.fn) rex_panic(\"called an empty function value\");")); let mut all = vec![format!("{cs}.env")]; all.extend(vs); self.materialize(e.ty, format!("{cs}.fn({})", all.join(", "))) @@ -2330,28 +2330,28 @@ static dstr {c}_str({c} l) {{ let vs = self.seq(&refs); for (i, (a, v)) in args.iter().zip(&vs).enumerate() { if i > 0 { - self.line("dino_print_sp();"); + self.line("rex_print_sp();"); } let stmt = match a.ty { - Ty::Int => format!("dino_print_i64({v});"), - Ty::Float => format!("dino_print_f64({v});"), - Ty::Bool => format!("dino_print_bool({v});"), - Ty::Char => format!("dino_print_char({v});"), - Ty::Str => format!("dino_print_str({v});"), - Ty::Num(Num::U64) => format!("dino_print_u64({v});"), - Ty::Num(Num::F32) => format!("dino_print_f32({v});"), - Ty::Num(_) => format!("dino_print_i64((int64_t)({v}));"), + Ty::Int => format!("rex_print_i64({v});"), + Ty::Float => format!("rex_print_f64({v});"), + Ty::Bool => format!("rex_print_bool({v});"), + Ty::Char => format!("rex_print_char({v});"), + Ty::Str => format!("rex_print_str({v});"), + Ty::Num(Num::U64) => format!("rex_print_u64({v});"), + Ty::Num(Num::F32) => format!("rex_print_f32({v});"), + Ty::Num(_) => format!("rex_print_i64((int64_t)({v}));"), Ty::Struct(_) | Ty::Enum(_) | Ty::List(_) | Ty::Map(..) | Ty::Opt(_) | Ty::Error | Ty::Shared(_) | Ty::Weak(_) | Ty::Func(_) | Ty::Iface(_) | Ty::CPtr(_) => { let t = self.fresh(); self.line(&format!("dstr {t} = {};", to_str(a.ty, v))); self.register_temp(&t, Ty::Str); - format!("dino_print_str({t});") + format!("rex_print_str({t});") } Ty::Tuple(_) | Ty::Unit => unreachable!(), }; self.line(&stmt); } - self.line("dino_print_nl();"); + self.line("rex_print_nl();"); String::new() } HExprKind::Convert(inner) => { @@ -2359,11 +2359,11 @@ static dstr {c}_str({c} l) {{ let to = c_ty(e.ty); match (inner.ty.is_float(), e.ty) { // float to integer: out-of-range values stop at the nearest end, NaN is 0 - (true, Ty::Int) => format!("dino_f2i((double){v})"), - (true, Ty::Num(Num::U64)) => format!("dino_f2u64((double){v})"), + (true, Ty::Int) => format!("rex_f2i((double){v})"), + (true, Ty::Num(Num::U64)) => format!("rex_f2u64((double){v})"), (true, Ty::Num(k)) if !k.is_float() => { let (lo, hi) = k.range(); - format!("(({to})dino_f2i_clamp((double){v}, INT64_C({lo}), INT64_C({hi})))") + format!("(({to})rex_f2i_clamp((double){v}, INT64_C({lo}), INT64_C({hi})))") } // everything else is a plain C conversion (integers wrap) _ => format!("(({to}){v})"), @@ -2398,7 +2398,7 @@ static dstr {c}_str({c} l) {{ }); } let t = self.fresh(); - self.line(&format!("dstr {t} = dino_cat_n({}, (dstr[]){{{}}});", cs.len(), cs.join(", "))); + self.line(&format!("dstr {t} = rex_cat_n({}, (dstr[]){{{}}});", cs.len(), cs.join(", "))); self.register_temp(&t, Ty::Str); t } @@ -2441,7 +2441,7 @@ static dstr {c}_str({c} l) {{ let (t, n, ct) = (self.fresh(), elems.len(), c_ty(*elem)); self.line(&format!("{c} {t} = {{0}};")); self.line(&format!("{t}.p = ({ct} *)malloc({n} * sizeof({ct}));")); - self.line(&format!("if (!{t}.p) dino_panic(\"out of memory\");")); + self.line(&format!("if (!{t}.p) rex_panic(\"out of memory\");")); self.line(&format!("{t}.len = {t}.cap = {n};")); for (i, v) in vs.iter().enumerate() { self.line(&format!("{t}.p[{i}] = {v};")); @@ -2513,7 +2513,7 @@ static dstr {c}_str({c} l) {{ let copy = self.copy_of(et, &format!("{m}.{src}[i]")); self.line(&format!("{lc} {t} = {{0}};")); self.line(&format!( - "if ({m}.len > 0) {{ {t}.p = ({ect} *)malloc((size_t){m}.len * sizeof({ect})); if (!{t}.p) dino_panic(\"out of memory\"); {t}.len = {t}.cap = {m}.len; for (int64_t i = 0; i < {m}.len; i++) {t}.p[i] = {copy}; }}" + "if ({m}.len > 0) {{ {t}.p = ({ect} *)malloc((size_t){m}.len * sizeof({ect})); if (!{t}.p) rex_panic(\"out of memory\"); {t}.len = {t}.cap = {m}.len; for (int64_t i = 0; i < {m}.len; i++) {t}.p[i] = {copy}; }}" )); self.register_temp(&t, e.ty); t @@ -2642,7 +2642,7 @@ static dstr {c}_str({c} l) {{ HPat::Variant { index, .. } => Some(format!("{s}.tag == {index}")), HPat::Int(k) => Some(format!("{s} == INT64_C({k})")), HPat::Bool(b) => Some(format!("{s} == {b}")), - HPat::Str(t) => Some(format!("dino_streq({s}, {})", str_lit(t))), + HPat::Str(t) => Some(format!("rex_streq({s}, {})", str_lit(t))), HPat::CatchAll(_) => None, }; // the last arm needs no test: the checker made sure the arms cover everything @@ -2766,9 +2766,9 @@ static dstr {c}_str({c} l) {{ (BinOp::Div | BinOp::Rem, Ty::Num(k)) if !k.is_float() => { let name = if op == BinOp::Div { "div" } else { "rem" }; let call = if k == Num::U64 { - format!("dino_u{name}({l}, {r})") + format!("rex_u{name}({l}, {r})") } else { - format!("(({})dino_{name}((int64_t){l}, (int64_t){r}))", num_c(k)) + format!("(({})rex_{name}((int64_t){l}, (int64_t){r}))", num_c(k)) }; self.materialize(lhs.ty, call) } @@ -2776,14 +2776,14 @@ static dstr {c}_str({c} l) {{ (BinOp::Add | BinOp::Sub | BinOp::Mul, Ty::Num(k)) if !k.is_float() => { format!("(({})({l} {} {r}))", num_c(k), sym(op)) } - (BinOp::Div, Ty::Int) => self.materialize(Ty::Int, format!("dino_div({l}, {r})")), - (BinOp::Rem, Ty::Int) => self.materialize(Ty::Int, format!("dino_rem({l}, {r})")), + (BinOp::Div, Ty::Int) => self.materialize(Ty::Int, format!("rex_div({l}, {r})")), + (BinOp::Rem, Ty::Int) => self.materialize(Ty::Int, format!("rex_rem({l}, {r})")), (BinOp::Eq | BinOp::Ne, Ty::Enum(_)) => format!("({l}.tag {} {r}.tag)", sym(op)), - (BinOp::Add, Ty::Str) => self.materialize(Ty::Str, format!("dino_cat({l}, {r})")), - (BinOp::Eq, Ty::Str) => format!("dino_streq({l}, {r})"), - (BinOp::Ne, Ty::Str) => format!("(!dino_streq({l}, {r}))"), + (BinOp::Add, Ty::Str) => self.materialize(Ty::Str, format!("rex_cat({l}, {r})")), + (BinOp::Eq, Ty::Str) => format!("rex_streq({l}, {r})"), + (BinOp::Ne, Ty::Str) => format!("(!rex_streq({l}, {r}))"), (BinOp::Lt | BinOp::Gt | BinOp::Le | BinOp::Ge, Ty::Str) => { - format!("(dino_strcmp({l}, {r}) {} 0)", sym(op)) + format!("(rex_strcmp({l}, {r}) {} 0)", sym(op)) } _ => format!("({l} {} {r})", sym(op)), } diff --git a/src/driver.rs b/src/driver.rs index e7425ca..3ffc07c 100644 --- a/src/driver.rs +++ b/src/driver.rs @@ -14,7 +14,7 @@ pub fn load_c_headers(main: &Program, modules: &[(String, Program)], dir: &Path) let mut libs: Vec = Vec::new(); let all = std::iter::once(("", main)).chain(modules.iter().map(|(k, p)| (k.as_str(), p))); for (key, p) in all { - // `import a.b` lives in a/b.dino: its headers are found next to it + // `import a.b` lives in a/b.rex: its headers are found next to it let mut here = dir.to_path_buf(); let parts: Vec<&str> = key.split('.').collect(); for part in &parts[..parts.len().saturating_sub(1)] { @@ -33,7 +33,7 @@ pub fn load_c_headers(main: &Program, modules: &[(String, Program)], dir: &Path) Ok(libs) } -/// Dino source -> C source, for a program in a single file. C headers it imports are looked +/// Rex source -> C source, for a program in a single file. C headers it imports are looked /// for in the current folder and the system's. pub fn compile_to_c(src: &str) -> PResult { let ast = parser::parse(src)?; @@ -78,7 +78,7 @@ pub fn compile_file(path: &str) -> Result { let src = std::fs::read_to_string(path).map_err(|e| format!("error: cannot read {path}: {e}"))?; let dir = Path::new(path).parent().map(Path::to_path_buf).unwrap_or_default(); compile_project(path, &src, |key| { - let file = dir.join(format!("{}.dino", key.replace('.', "/"))); + let file = dir.join(format!("{}.rex", key.replace('.', "/"))); std::fs::read_to_string(&file).ok().map(|s| (file.display().to_string(), s)) }) } @@ -88,7 +88,7 @@ fn unique_name(tag: &str, ext: &str) -> PathBuf { static COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0); let n = COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed); let nanos = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_nanos()).unwrap_or(0); - std::env::temp_dir().join(format!("dino-{}-{}-{}-{}{}", std::process::id(), nanos, n, tag, ext)) + std::env::temp_dir().join(format!("rex-{}-{}-{}-{}{}", std::process::id(), nanos, n, tag, ext)) } /// A path for a throw-away executable. @@ -102,11 +102,11 @@ pub fn build_exe(c_code: &str, out: &Path) -> Result<(), String> { } /// Like `build_exe`, with explicit compiler flags (used by tests to turn on strict warnings). -/// The generated code says which C libraries it needs in `// dino-...:` lines at the top. +/// The generated code says which C libraries it needs in `// rex-...:` lines at the top. pub fn build_exe_with(c_code: &str, out: &Path, flags: &[&str]) -> Result<(), String> { let (mut cflags, mut libs, mut sources) = (Vec::new(), Vec::new(), Vec::new()); - for line in c_code.lines().take_while(|l| l.starts_with("// dino-")) { - let (kind, value) = line["// dino-".len()..].split_once(": ").unwrap_or(("", "")); + for line in c_code.lines().take_while(|l| l.starts_with("// rex-")) { + let (kind, value) = line["// rex-".len()..].split_once(": ").unwrap_or(("", "")); match kind { "cflag" => cflags.push(value.to_string()), "lib" => libs.push(value.to_string()), @@ -173,7 +173,7 @@ pub fn build_exe_with(c_code: &str, out: &Path, flags: &[&str]) -> Result<(), St } else if uses_c { Err(format!("the C compiler rejected the program:\n{err}")) } else { - Err(format!("the C compiler rejected the generated code (this is a bug in Dino):\n{err}")) + Err(format!("the C compiler rejected the generated code (this is a bug in Rex):\n{err}")) } } Ok(_) => Ok(()), diff --git a/src/error.rs b/src/error.rs index 6647757..72e4ce5 100644 --- a/src/error.rs +++ b/src/error.rs @@ -25,7 +25,7 @@ impl Diag { /// Render like: /// ```text /// error: expected `}`, found end of file - /// --> hello.dino:3:10 + /// --> hello.rex:3:10 /// | /// 3 | func main() { /// | ^ diff --git a/src/fmt.rs b/src/fmt.rs index be2b165..c436868 100644 --- a/src/fmt.rs +++ b/src/fmt.rs @@ -1,4 +1,4 @@ -//! The code formatter behind `dino fmt`. +//! The code formatter behind `rex fmt`. //! //! It works on the text, not on the syntax tree, so comments and blank lines survive. It //! never moves a line break: it fixes the indentation, the spaces between tokens and runs of @@ -49,11 +49,11 @@ pub fn format(src: &str) -> Result { // the safety net: the same tokens in, the same tokens out let before = fingerprint(src)?; let after = fingerprint(&out).map_err(|d| { - Diag::new(format!("the formatter produced code that doesn't lex ({}); this is a bug in `dino fmt`", d.msg), d.span) + Diag::new(format!("the formatter produced code that doesn't lex ({}); this is a bug in `rex fmt`", d.msg), d.span) })?; if before != after { return Err(Diag::new( - "the formatter would change the meaning of this file; this is a bug in `dino fmt`, nothing was written", + "the formatter would change the meaning of this file; this is a bug in `rex fmt`, nothing was written", crate::ast::Span::default(), )); } diff --git a/src/hir.rs b/src/hir.rs index 50cd0a0..5ec4247 100644 --- a/src/hir.rs +++ b/src/hir.rs @@ -87,7 +87,7 @@ pub enum HArmBody { pub struct HStruct { pub name: String, pub fields: Vec<(String, Ty)>, - /// For a struct from a C header: how C spells it (`Color`, `struct timeval`). Dino keeps its + /// For a struct from a C header: how C spells it (`Color`, `struct timeval`). Rex keeps its /// own copy of the fields and converts at calls. pub c: Option, } @@ -106,7 +106,7 @@ pub struct CInfo { pub enum CArg { /// As it is (numbers, pointers) or converted (structs). Value, - /// A Dino string as a C string (`const char *`), copied for the call. + /// A Rex string as a C string (`const char *`), copied for the call. Str, /// `nil`: a NULL pointer. Null, diff --git a/src/index.rs b/src/index.rs index e576d5b..5829f64 100644 --- a/src/index.rs +++ b/src/index.rs @@ -1,4 +1,4 @@ -//! A quick map of a Dino file for editors: what it declares, what it imports, and which names +//! A quick map of a Rex file for editors: what it declares, what it imports, and which names //! are visible at a point. It reads the token stream only (not the syntax tree), so it keeps //! working while the code is half typed and has errors in it. diff --git a/src/lexer.rs b/src/lexer.rs index 0e4ead3..40b730e 100644 --- a/src/lexer.rs +++ b/src/lexer.rs @@ -573,14 +573,14 @@ impl Lexer { if self.eat('&') { Tok::AndAnd } else { - return Err(Diag::new("a single `&` is not part of Dino; use `&&` for \"and\"", span)); + return Err(Diag::new("a single `&` is not part of Rex; use `&&` for \"and\"", span)); } } '|' => { if self.eat('|') { Tok::OrOr } else { - return Err(Diag::new("a single `|` is not part of Dino; use `||` for \"or\"", span)); + return Err(Diag::new("a single `|` is not part of Rex; use `||` for \"or\"", span)); } } other => return Err(Diag::new(format!("unexpected character `{other}`"), span)), diff --git a/src/lib.rs b/src/lib.rs index c6b63a8..686910b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,4 @@ -//! The Dino compiler. +//! The Rex compiler. pub mod ast; pub mod check; diff --git a/src/loader.rs b/src/loader.rs index 1f48a0d..2801009 100644 --- a/src/loader.rs +++ b/src/loader.rs @@ -1,5 +1,5 @@ -//! Finds the files a program imports. `import utils` loads `utils.dino` from the -//! folder of the main file; `import a.b` loads `a/b.dino`. +//! Finds the files a program imports. `import utils` loads `utils.rex` from the +//! folder of the main file; `import a.b` loads `a/b.rex`. use crate::ast::{Item, Program}; use crate::error::{Diag, PResult}; @@ -48,7 +48,7 @@ fn load_imports( return Err(Diag::new(format!("circular import: {}", cycle.join(" -> ")), i.span).in_module(from)); } let Some((_, src)) = read(&key) else { - let file = format!("{}.dino", key.replace('.', "/")); + let file = format!("{}.rex", key.replace('.', "/")); return Err(Diag::new( format!( "cannot find module `{key}` (looked for {file} next to your program; built-in modules: {})", diff --git a/src/lsp.rs b/src/lsp.rs index 8d7b877..b629bc8 100644 --- a/src/lsp.rs +++ b/src/lsp.rs @@ -1,4 +1,4 @@ -//! The language server (`dino lsp`): talks to an editor over stdin/stdout and shows the +//! The language server (`rex lsp`): talks to an editor over stdin/stdout and shows the //! compiler's errors while you type, and formats the file on request. use std::collections::HashMap; @@ -81,7 +81,7 @@ impl Server { ("signatureHelpProvider", Json::obj(vec![("triggerCharacters", Json::Arr(vec![Json::str("("), Json::str(",")]))])), ]), ), - ("serverInfo", Json::obj(vec![("name", Json::str("dino"))])), + ("serverInfo", Json::obj(vec![("name", Json::str("rex"))])), ])), "shutdown" => { self.shutdown = true; @@ -171,7 +171,7 @@ impl Server { let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { let here = dir.clone().unwrap_or_default(); driver::diagnose(text, &here, |key| { - let file = dir.as_ref()?.join(format!("{}.dino", key.replace('.', "/"))); + let file = dir.as_ref()?.join(format!("{}.rex", key.replace('.', "/"))); // an import that is open in the editor counts with its unsaved changes for (u, t) in docs { if uri_to_path(u).as_deref() == Some(file.as_path()) { @@ -226,12 +226,12 @@ fn diagnostic(d: &Diag, text: &str) -> Json { Json::obj(vec![ ("range", range(start, end)), ("severity", Json::Num(1.0)), - ("source", Json::str("dino")), + ("source", Json::str("rex")), ("message", Json::str(message)), ]) } -/// `file:///home/me/a%20b.dino` -> `/home/me/a b.dino` +/// `file:///home/me/a%20b.rex` -> `/home/me/a b.rex` fn uri_to_path(uri: &str) -> Option { let rest = uri.strip_prefix("file://")?; let bytes = rest.as_bytes(); @@ -399,7 +399,7 @@ impl Server { /// The source of the module `key` as seen from the file `uri`: open in the editor, or on disk. fn module_source(&self, uri: &str, key: &str) -> Option<(String, String)> { let dir = uri_to_path(uri)?.parent()?.to_path_buf(); - let file = dir.join(format!("{}.dino", key.replace('.', "/"))); + let file = dir.join(format!("{}.rex", key.replace('.', "/"))); let target = path_to_uri(&file); for (u, t) in &self.docs { if uri_to_path(u).as_deref() == Some(file.as_path()) { @@ -629,7 +629,7 @@ impl Server { }; if a > 0 && chars[a - 1] == '.' { let left = word_before(line_text, a - 1); - // a C header: everything Dino can use from it + // a C header: everything Rex can use from it if let Some(imp) = left.as_deref().and_then(|q| ix.imports.iter().find(|i| i.name == q && i.header.is_some())) { if let Some(lib) = self.c_lib(uri, imp) { for n in lib.names() { diff --git a/src/main.rs b/src/main.rs index 69a55aa..51f4014 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,20 +1,20 @@ use std::path::PathBuf; use std::{env, fs, process}; -use dino::{driver, fmt, lexer, lsp, parser}; +use rex::{driver, fmt, lexer, lsp, parser}; fn usage() -> ! { - eprintln!("Dino compiler (work in progress)\n"); + eprintln!("Rex compiler (work in progress)\n"); eprintln!("usage:"); - eprintln!(" dino run [args...] compile and run (args go to the program)"); - eprintln!(" dino build [-o out] compile to an executable"); - eprintln!(" dino emit-c print the generated C code"); - eprintln!(" dino check check for errors without building"); - eprintln!(" dino fmt [--check] .. format code in place (--check only reports; `-` = stdin to stdout)"); - eprintln!(" dino lsp run the language server (for editors)"); - eprintln!(" dino header [name] show what Dino can use from a C header"); - eprintln!(" dino parse print the syntax tree"); - eprintln!(" dino tokens print the tokens"); + eprintln!(" rex run [args...] compile and run (args go to the program)"); + eprintln!(" rex build [-o out] compile to an executable"); + eprintln!(" rex emit-c print the generated C code"); + eprintln!(" rex check check for errors without building"); + eprintln!(" rex fmt [--check] .. format code in place (--check only reports; `-` = stdin to stdout)"); + eprintln!(" rex lsp run the language server (for editors)"); + eprintln!(" rex header [name] show what Rex can use from a C header"); + eprintln!(" rex parse print the syntax tree"); + eprintln!(" rex tokens print the tokens"); process::exit(2); } @@ -23,20 +23,20 @@ fn die(msg: &str) -> ! { process::exit(1); } -/// All `.dino` files at `path` (a file, or a folder searched recursively). -fn dino_files(path: &std::path::Path, out: &mut Vec) { +/// All `.rex` files at `path` (a file, or a folder searched recursively). +fn rex_files(path: &std::path::Path, out: &mut Vec) { if path.is_dir() { let mut entries: Vec = fs::read_dir(path).map(|r| r.filter_map(|e| e.ok().map(|e| e.path())).collect()).unwrap_or_default(); entries.sort(); for e in entries { - dino_files(&e, out); + rex_files(&e, out); } - } else if path.extension().map_or(false, |e| e == "dino") || path.is_file() && out.is_empty() && path.extension().is_none() { + } else if path.extension().map_or(false, |e| e == "rex") || path.is_file() && out.is_empty() && path.extension().is_none() { out.push(path.to_path_buf()); } } -/// `dino header zlib.h [name] [--link z]`: what Dino code can use from a C header. +/// `rex header zlib.h [name] [--link z]`: what Rex code can use from a C header. fn run_header(args: &[String]) -> ! { let mut header: Option<&str> = None; let mut filter: Option<&str> = None; @@ -51,7 +51,7 @@ fn run_header(args: &[String]) -> ! { } let Some(header) = header else { usage() }; let dir = env::current_dir().unwrap_or_default(); - let lib = dino::cheader::load(header, &dir, link).unwrap_or_else(|e| die(&format!("error: {e}"))); + let lib = rex::cheader::load(header, &dir, link).unwrap_or_else(|e| die(&format!("error: {e}"))); let shown = |n: &str| filter.map_or(true, |f| n.to_lowercase().contains(&f.to_lowercase())); let mut text = format!("import \"{header}\" // use the names below as {}.name\n", lib.prefix); if !lib.libs.is_empty() || !lib.cflags.is_empty() { @@ -77,7 +77,7 @@ fn run_header(args: &[String]) -> ! { ); section("constants", lib.consts.iter().filter(|c| shown(&c.name)).map(|c| lib.describe(&c.name).unwrap()).collect()); section( - "functions Dino can't call yet", + "functions Rex can't call yet", lib.funcs .iter() .filter(|f| shown(&f.name)) @@ -89,9 +89,9 @@ fn run_header(args: &[String]) -> ! { process::exit(0); } -/// `dino fmt [--check] files-or-folders...` +/// `rex fmt [--check] files-or-folders...` fn run_fmt(args: &[String]) -> ! { - // `dino fmt -`: text in on stdin, tidy text out on stdout (for editors) + // `rex fmt -`: text in on stdin, tidy text out on stdout (for editors) if args.len() == 1 && args[0] == "-" { let mut src = String::new(); if std::io::Read::read_to_string(&mut std::io::stdin(), &mut src).is_err() { @@ -117,9 +117,9 @@ fn run_fmt(args: &[String]) -> ! { if path.is_file() { files.push(path); } else { - dino_files(&path, &mut files); + rex_files(&path, &mut files); if files.len() == before { - die(&format!("error: no .dino files found at {p}")); + die(&format!("error: no .rex files found at {p}")); } } } @@ -170,7 +170,7 @@ fn main() { let cmd = args[0].as_str(); let path = &args[1]; let mut out: Option = None; - // `dino run file.dino a b c` hands `a b c` to the program; `build` takes `-o` + // `rex run file.rex a b c` hands `a b c` to the program; `build` takes `-o` let mut program_args: Vec = Vec::new(); let mut rest = args[2..].iter(); while let Some(a) = rest.next() { @@ -182,7 +182,7 @@ fn main() { } let src = fs::read_to_string(path).unwrap_or_else(|e| die(&format!("error: cannot read {path}: {e}"))); - let fail = |d: dino::error::Diag| -> ! { die(&d.render(path, &src)) }; + let fail = |d: rex::error::Diag| -> ! { die(&d.render(path, &src)) }; match cmd { "tokens" => match lexer::lex(&src) { diff --git a/src/runtime.c b/src/runtime.c index 7cd91f7..2a67ad1 100644 --- a/src/runtime.c +++ b/src/runtime.c @@ -1,4 +1,4 @@ -/* Dino runtime (generated programs include this verbatim). */ +/* Rex runtime (generated programs include this verbatim). */ #define _POSIX_C_SOURCE 200809L #include #include @@ -14,62 +14,62 @@ (NULL for literals, which live forever). */ typedef struct { const char *p; int64_t n; int64_t *rc; } dstr; -static void dino_panic(const char *msg) { +static void rex_panic(const char *msg) { fflush(stdout); fprintf(stderr, "panic: %s\n", msg); exit(2); } -static void dino_index_panic(int64_t i, int64_t n) { +static void rex_index_panic(int64_t i, int64_t n) { fflush(stdout); fprintf(stderr, "panic: index %lld is out of range (the length is %lld)\n", (long long)i, (long long)n); exit(2); } -static void dino_slice_panic(int64_t lo, int64_t hi, int64_t n) { +static void rex_slice_panic(int64_t lo, int64_t hi, int64_t n) { fflush(stdout); fprintf(stderr, "panic: slice %lld..%lld is out of range (the length is %lld)\n", (long long)lo, (long long)hi, (long long)n); exit(2); } -static inline dstr dino_lit(const char *p, int64_t n) { dstr s = {p, n, NULL}; return s; } +static inline dstr rex_lit(const char *p, int64_t n) { dstr s = {p, n, NULL}; return s; } /* A new heap string of n bytes (plus a trailing 0), counted once. */ -static char *dino_str_alloc(int64_t n, int64_t **rc) { +static char *rex_str_alloc(int64_t n, int64_t **rc) { int64_t *blk = (int64_t *)malloc(sizeof(int64_t) + (size_t)n + 1); - if (!blk) dino_panic("out of memory"); + if (!blk) rex_panic("out of memory"); *blk = 1; *rc = blk; return (char *)(blk + 1); } -static inline dstr dino_str_retain(dstr s) { if (s.rc) ++*s.rc; return s; } -static inline void dino_str_release(dstr s) { if (s.rc && --*s.rc == 0) free(s.rc); } +static inline dstr rex_str_retain(dstr s) { if (s.rc) ++*s.rc; return s; } +static inline void rex_str_release(dstr s) { if (s.rc && --*s.rc == 0) free(s.rc); } -static inline int64_t dino_div(int64_t a, int64_t b) { - if (b == 0) dino_panic("integer division by zero"); +static inline int64_t rex_div(int64_t a, int64_t b) { + if (b == 0) rex_panic("integer division by zero"); if (b == -1) return (int64_t)(0 - (uint64_t)a); return a / b; } -static inline int64_t dino_rem(int64_t a, int64_t b) { - if (b == 0) dino_panic("integer remainder by zero"); +static inline int64_t rex_rem(int64_t a, int64_t b) { + if (b == 0) rex_panic("integer remainder by zero"); if (b == -1) return 0; return a % b; } -static inline int64_t dino_f2i(double x) { +static inline int64_t rex_f2i(double x) { if (x != x) return 0; if (x >= 9223372036854775807.0) return INT64_MAX; if (x <= -9223372036854775808.0) return INT64_MIN; return (int64_t)x; } -static dstr dino_cat_n(int n, const dstr *parts) { +static dstr rex_cat_n(int n, const dstr *parts) { int64_t total = 0; for (int i = 0; i < n; i++) total += parts[i].n; int64_t *rc; - char *buf = dino_str_alloc(total, &rc); + char *buf = rex_str_alloc(total, &rc); int64_t at = 0; for (int i = 0; i < n; i++) { if (parts[i].n) memcpy(buf + at, parts[i].p, (size_t)parts[i].n); @@ -80,18 +80,18 @@ static dstr dino_cat_n(int n, const dstr *parts) { return r; } -static inline dstr dino_cat(dstr a, dstr b) { +static inline dstr rex_cat(dstr a, dstr b) { dstr parts[2] = {a, b}; - return dino_cat_n(2, parts); + return rex_cat_n(2, parts); } -static inline bool dino_streq(dstr a, dstr b) { +static inline bool rex_streq(dstr a, dstr b) { return a.n == b.n && (a.n == 0 || memcmp(a.p, b.p, (size_t)a.n) == 0); } /// Decode the UTF-8 character at `p` (at most `n` bytes left); stores it in `*out` and returns its width in bytes. /// Bytes that aren't valid UTF-8 come out one at a time as U+FFFD. -static int64_t dino_utf8_decode(const char *p, int64_t n, uint32_t *out) { +static int64_t rex_utf8_decode(const char *p, int64_t n, uint32_t *out) { const unsigned char *s = (const unsigned char *)p; if (s[0] < 0x80) { *out = s[0]; return 1; } int64_t w = s[0] >= 0xF0 ? 4 : s[0] >= 0xE0 ? 3 : s[0] >= 0xC0 ? 2 : 0; @@ -106,61 +106,61 @@ static int64_t dino_utf8_decode(const char *p, int64_t n, uint32_t *out) { } /// `s[i]`: the character that starts at byte `i`. -static uint32_t dino_str_char_at(dstr s, int64_t i) { - if (i < 0 || i >= s.n) dino_index_panic(i, s.n); - if (((unsigned char)s.p[i] & 0xC0) == 0x80) dino_panic("that position is in the middle of a character"); +static uint32_t rex_str_char_at(dstr s, int64_t i) { + if (i < 0 || i >= s.n) rex_index_panic(i, s.n); + if (((unsigned char)s.p[i] & 0xC0) == 0x80) rex_panic("that position is in the middle of a character"); uint32_t c; - dino_utf8_decode(s.p + i, s.n - i, &c); + rex_utf8_decode(s.p + i, s.n - i, &c); return c; } -static dstr dino_new_str(const char *src, int64_t n); +static dstr rex_new_str(const char *src, int64_t n); -static dstr dino_char_str(uint32_t c) { +static dstr rex_char_str(uint32_t c) { char b[4]; int n; if (c < 0x80) { b[0] = (char)c; n = 1; } else if (c < 0x800) { b[0] = (char)(0xC0 | (c >> 6)); b[1] = (char)(0x80 | (c & 0x3F)); n = 2; } else if (c < 0x10000) { b[0] = (char)(0xE0 | (c >> 12)); b[1] = (char)(0x80 | ((c >> 6) & 0x3F)); b[2] = (char)(0x80 | (c & 0x3F)); n = 3; } else { b[0] = (char)(0xF0 | (c >> 18)); b[1] = (char)(0x80 | ((c >> 12) & 0x3F)); b[2] = (char)(0x80 | ((c >> 6) & 0x3F)); b[3] = (char)(0x80 | (c & 0x3F)); n = 4; } - return dino_new_str(b, n); + return rex_new_str(b, n); } -static void dino_print_char(uint32_t c) { - dstr s = dino_char_str(c); +static void rex_print_char(uint32_t c) { + dstr s = rex_char_str(c); fwrite(s.p, 1, (size_t)s.n, stdout); if (s.rc && --*s.rc == 0) free(s.rc); } -static bool dino_char_is_digit(uint32_t c) { return c >= '0' && c <= '9'; } -static bool dino_char_is_upper(uint32_t c) { return (c >= 'A' && c <= 'Z') || (c >= 0xC0 && c <= 0xDE && c != 0xD7); } -static bool dino_char_is_lower(uint32_t c) { return (c >= 'a' && c <= 'z') || (c >= 0xDF && c <= 0xFF && c != 0xF7); } -static bool dino_char_is_letter(uint32_t c) { return dino_char_is_upper(c) || dino_char_is_lower(c) || c > 0xFF; } -static bool dino_char_is_alnum(uint32_t c) { return dino_char_is_digit(c) || dino_char_is_letter(c); } -static bool dino_char_is_space(uint32_t c) { return c == ' ' || (c >= '\t' && c <= '\r'); } -static uint32_t dino_char_upper(uint32_t c) { return (c >= 'a' && c <= 'z') ? c - 32 : c; } -static uint32_t dino_char_lower(uint32_t c) { return (c >= 'A' && c <= 'Z') ? c + 32 : c; } +static bool rex_char_is_digit(uint32_t c) { return c >= '0' && c <= '9'; } +static bool rex_char_is_upper(uint32_t c) { return (c >= 'A' && c <= 'Z') || (c >= 0xC0 && c <= 0xDE && c != 0xD7); } +static bool rex_char_is_lower(uint32_t c) { return (c >= 'a' && c <= 'z') || (c >= 0xDF && c <= 0xFF && c != 0xF7); } +static bool rex_char_is_letter(uint32_t c) { return rex_char_is_upper(c) || rex_char_is_lower(c) || c > 0xFF; } +static bool rex_char_is_alnum(uint32_t c) { return rex_char_is_digit(c) || rex_char_is_letter(c); } +static bool rex_char_is_space(uint32_t c) { return c == ' ' || (c >= '\t' && c <= '\r'); } +static uint32_t rex_char_upper(uint32_t c) { return (c >= 'a' && c <= 'z') ? c - 32 : c; } +static uint32_t rex_char_lower(uint32_t c) { return (c >= 'A' && c <= 'Z') ? c + 32 : c; } -static inline uint64_t dino_hash_i64(int64_t v) { +static inline uint64_t rex_hash_i64(int64_t v) { uint64_t x = (uint64_t)v; x ^= x >> 33; x *= 0xff51afd7ed558ccdULL; x ^= x >> 33; x *= 0xc4ceb9fe1a85ec53ULL; x ^= x >> 33; return x; } -static uint64_t dino_hash_str(dstr s) { +static uint64_t rex_hash_str(dstr s) { uint64_t h = 1469598103934665603ULL; for (int64_t i = 0; i < s.n; i++) { h ^= (unsigned char)s.p[i]; h *= 1099511628211ULL; } return h; } -static int dino_strcmp(dstr a, dstr b) { +static int rex_strcmp(dstr a, dstr b) { int64_t m = a.n < b.n ? a.n : b.n; int c = m ? memcmp(a.p, b.p, (size_t)m) : 0; if (c) return c; return a.n < b.n ? -1 : (a.n > b.n ? 1 : 0); } -static int dino_fmt_f64(char *buf, size_t cap, double v) { +static int rex_fmt_f64(char *buf, size_t cap, double v) { int n = snprintf(buf, cap, "%.15g", v); if (!strpbrk(buf, ".eEn")) { /* looks like an integer: show it as a float */ buf[n++] = '.'; @@ -170,61 +170,61 @@ static int dino_fmt_f64(char *buf, size_t cap, double v) { return n; } -static dstr dino_heap_str(const char *tmp, int n) { +static dstr rex_heap_str(const char *tmp, int n) { int64_t *rc; - char *buf = dino_str_alloc(n, &rc); + char *buf = rex_str_alloc(n, &rc); memcpy(buf, tmp, (size_t)n + 1); dstr r = {buf, n, rc}; return r; } -static dstr dino_i64_str(int64_t v) { +static dstr rex_i64_str(int64_t v) { char tmp[32]; int n = snprintf(tmp, sizeof tmp, "%lld", (long long)v); - return dino_heap_str(tmp, n); + return rex_heap_str(tmp, n); } -static dstr dino_f64_str(double v) { +static dstr rex_f64_str(double v) { char tmp[64]; - int n = dino_fmt_f64(tmp, sizeof tmp, v); - return dino_heap_str(tmp, n); + int n = rex_fmt_f64(tmp, sizeof tmp, v); + return rex_heap_str(tmp, n); } -static inline dstr dino_bool_str(bool v) { return v ? dino_lit("true", 4) : dino_lit("false", 5); } +static inline dstr rex_bool_str(bool v) { return v ? rex_lit("true", 4) : rex_lit("false", 5); } -static inline void dino_print_str(dstr s) { if (s.n) fwrite(s.p, 1, (size_t)s.n, stdout); } -static inline void dino_print_i64(int64_t v) { printf("%lld", (long long)v); } -static inline void dino_print_f64(double v) { char tmp[64]; dino_fmt_f64(tmp, sizeof tmp, v); fputs(tmp, stdout); } -static inline void dino_print_bool(bool v) { fputs(v ? "true" : "false", stdout); } -static inline void dino_print_sp(void) { putchar(' '); } -static inline void dino_print_nl(void) { putchar('\n'); } +static inline void rex_print_str(dstr s) { if (s.n) fwrite(s.p, 1, (size_t)s.n, stdout); } +static inline void rex_print_i64(int64_t v) { printf("%lld", (long long)v); } +static inline void rex_print_f64(double v) { char tmp[64]; rex_fmt_f64(tmp, sizeof tmp, v); fputs(tmp, stdout); } +static inline void rex_print_bool(bool v) { fputs(v ? "true" : "false", stdout); } +static inline void rex_print_sp(void) { putchar(' '); } +static inline void rex_print_nl(void) { putchar('\n'); } /* ---- sized numbers ---- */ -static inline int64_t dino_f2i_clamp(double x, int64_t lo, int64_t hi) { +static inline int64_t rex_f2i_clamp(double x, int64_t lo, int64_t hi) { if (x != x) return 0; if (x <= (double)lo) return lo; if (x >= (double)hi) return hi; return (int64_t)x; } -static inline uint64_t dino_f2u64(double x) { +static inline uint64_t rex_f2u64(double x) { if (x != x || x <= 0) return 0; if (x >= 18446744073709551615.0) return UINT64_MAX; return (uint64_t)x; } -static inline uint64_t dino_udiv(uint64_t a, uint64_t b) { - if (b == 0) dino_panic("integer division by zero"); +static inline uint64_t rex_udiv(uint64_t a, uint64_t b) { + if (b == 0) rex_panic("integer division by zero"); return a / b; } -static inline uint64_t dino_urem(uint64_t a, uint64_t b) { - if (b == 0) dino_panic("integer remainder by zero"); +static inline uint64_t rex_urem(uint64_t a, uint64_t b) { + if (b == 0) rex_panic("integer remainder by zero"); return a % b; } /* the shortest text that reads back as the same f32 */ -static int dino_fmt_f32(char *buf, size_t cap, float v) { +static int rex_fmt_f32(char *buf, size_t cap, float v) { int n = 0; for (int p = 1; p <= 9; p++) { n = snprintf(buf, cap, "%.*g", p, (double)v); @@ -238,28 +238,28 @@ static int dino_fmt_f32(char *buf, size_t cap, float v) { return n; } -static dstr dino_f32_str(float v) { +static dstr rex_f32_str(float v) { char tmp[64]; - int n = dino_fmt_f32(tmp, sizeof tmp, v); - return dino_heap_str(tmp, n); + int n = rex_fmt_f32(tmp, sizeof tmp, v); + return rex_heap_str(tmp, n); } -static dstr dino_u64_str(uint64_t v) { +static dstr rex_u64_str(uint64_t v) { char tmp[32]; int n = snprintf(tmp, sizeof tmp, "%llu", (unsigned long long)v); - return dino_heap_str(tmp, n); + return rex_heap_str(tmp, n); } -static inline void dino_print_u64(uint64_t v) { printf("%llu", (unsigned long long)v); } -static inline void dino_print_f32(float v) { char tmp[64]; dino_fmt_f32(tmp, sizeof tmp, v); fputs(tmp, stdout); } +static inline void rex_print_u64(uint64_t v) { printf("%llu", (unsigned long long)v); } +static inline void rex_print_f32(float v) { char tmp[64]; rex_fmt_f32(tmp, sizeof tmp, v); fputs(tmp, stdout); } /* ---- end of runtime ---- */ /* error: nil (set == false) or a message */ -typedef struct { bool set; dstr msg; } dino_err; -static dstr dino_err_str(dino_err e) { return e.set ? dino_str_retain(e.msg) : dino_lit("nil", 3); } -static inline dino_err dino_err_retain(dino_err e) { dino_str_retain(e.msg); return e; } -static inline void dino_err_release(dino_err e) { dino_str_release(e.msg); } +typedef struct { bool set; dstr msg; } rex_err; +static dstr rex_err_str(rex_err e) { return e.set ? rex_str_retain(e.msg) : rex_lit("nil", 3); } +static inline rex_err rex_err_retain(rex_err e) { rex_str_retain(e.msg); return e; } +static inline void rex_err_release(rex_err e) { rex_str_release(e.msg); } /* ---- standard library ---- */ @@ -267,9 +267,9 @@ static inline void dino_err_release(dino_err e) { dino_str_release(e.msg); } the generated code uses this same type for `[]string`. */ typedef struct L_str { dstr *p; int64_t len; int64_t cap; } L_str; -static dstr dino_new_str(const char *src, int64_t n) { +static dstr rex_new_str(const char *src, int64_t n) { int64_t *rc; - char *buf = dino_str_alloc(n, &rc); + char *buf = rex_str_alloc(n, &rc); if (n) memcpy(buf, src, (size_t)n); buf[n] = 0; dstr r = {buf, n, rc}; @@ -278,83 +278,83 @@ static dstr dino_new_str(const char *src, int64_t n) { /* `s[lo..hi]`: a copy of those bytes; out of range panics */ static dstr dstr_slice(dstr s, int64_t lo, int64_t hi) { - if (lo < 0 || hi < lo || hi > s.n) dino_slice_panic(lo, hi, s.n); - return dino_new_str(s.p + lo, hi - lo); + if (lo < 0 || hi < lo || hi > s.n) rex_slice_panic(lo, hi, s.n); + return rex_new_str(s.p + lo, hi - lo); } -static dstr dino_fmt_msg(const char *fmt, dstr a, const char *extra) { +static dstr rex_fmt_msg(const char *fmt, dstr a, const char *extra) { int n = snprintf(NULL, 0, fmt, (int)a.n, a.p, extra); char *tmp = (char *)malloc((size_t)n + 1); - if (!tmp) dino_panic("out of memory"); + if (!tmp) rex_panic("out of memory"); snprintf(tmp, (size_t)n + 1, fmt, (int)a.n, a.p, extra); - dstr r = dino_new_str(tmp, n); + dstr r = rex_new_str(tmp, n); free(tmp); return r; } -static dino_err dino_make_err(dstr msg) { dino_err e = {true, msg}; return e; } +static rex_err rex_make_err(dstr msg) { rex_err e = {true, msg}; return e; } /* a NUL-terminated copy of a string (for file names and the C library) */ -static char *dino_cstr(dstr s) { +static char *rex_cstr(dstr s) { char *c = (char *)malloc((size_t)s.n + 1); - if (!c) dino_panic("out of memory"); + if (!c) rex_panic("out of memory"); if (s.n) memcpy(c, s.p, (size_t)s.n); c[s.n] = 0; return c; } -static void dino_strs_push(L_str *l, dstr s) { +static void rex_strs_push(L_str *l, dstr s) { if (l->len == l->cap) { int64_t cap = l->cap ? l->cap * 2 : 4; dstr *p = (dstr *)realloc(l->p, (size_t)cap * sizeof(dstr)); - if (!p) dino_panic("out of memory"); + if (!p) rex_panic("out of memory"); l->p = p; l->cap = cap; } l->p[l->len++] = s; } -static dstr dino_str_upper(dstr s) { - dstr r = dino_new_str(s.p, s.n); +static dstr rex_str_upper(dstr s) { + dstr r = rex_new_str(s.p, s.n); for (int64_t i = 0; i < r.n; i++) if (r.p[i] >= 'a' && r.p[i] <= 'z') ((char *)r.p)[i] -= 32; return r; } -static dstr dino_str_lower(dstr s) { - dstr r = dino_new_str(s.p, s.n); +static dstr rex_str_lower(dstr s) { + dstr r = rex_new_str(s.p, s.n); for (int64_t i = 0; i < r.n; i++) if (r.p[i] >= 'A' && r.p[i] <= 'Z') ((char *)r.p)[i] += 32; return r; } -static bool dino_is_space(char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\v' || c == '\f'; } +static bool rex_is_space(char c) { return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\v' || c == '\f'; } -static dstr dino_str_trim(dstr s) { +static dstr rex_str_trim(dstr s) { int64_t a = 0, b = s.n; - while (a < b && dino_is_space(s.p[a])) a++; - while (b > a && dino_is_space(s.p[b - 1])) b--; - return dino_new_str(s.p + a, b - a); + while (a < b && rex_is_space(s.p[a])) a++; + while (b > a && rex_is_space(s.p[b - 1])) b--; + return rex_new_str(s.p + a, b - a); } -static int64_t dino_str_index_of(dstr s, dstr sub) { +static int64_t rex_str_index_of(dstr s, dstr sub) { if (sub.n == 0) return 0; for (int64_t i = 0; i + sub.n <= s.n; i++) if (memcmp(s.p + i, sub.p, (size_t)sub.n) == 0) return i; return -1; } -static bool dino_str_contains(dstr s, dstr sub) { return dino_str_index_of(s, sub) >= 0; } -static bool dino_str_starts_with(dstr s, dstr p) { return p.n <= s.n && (p.n == 0 || memcmp(s.p, p.p, (size_t)p.n) == 0); } -static bool dino_str_ends_with(dstr s, dstr p) { return p.n <= s.n && (p.n == 0 || memcmp(s.p + s.n - p.n, p.p, (size_t)p.n) == 0); } +static bool rex_str_contains(dstr s, dstr sub) { return rex_str_index_of(s, sub) >= 0; } +static bool rex_str_starts_with(dstr s, dstr p) { return p.n <= s.n && (p.n == 0 || memcmp(s.p, p.p, (size_t)p.n) == 0); } +static bool rex_str_ends_with(dstr s, dstr p) { return p.n <= s.n && (p.n == 0 || memcmp(s.p + s.n - p.n, p.p, (size_t)p.n) == 0); } -static dstr dino_str_replace(dstr s, dstr from, dstr to) { - if (from.n == 0) return dino_new_str(s.p, s.n); +static dstr rex_str_replace(dstr s, dstr from, dstr to) { + if (from.n == 0) return rex_new_str(s.p, s.n); int64_t count = 0; for (int64_t i = 0; i + from.n <= s.n;) { if (memcmp(s.p + i, from.p, (size_t)from.n) == 0) { count++; i += from.n; } else i++; } int64_t total = s.n + count * (to.n - from.n); int64_t *rc; - char *buf = dino_str_alloc(total, &rc); + char *buf = rex_str_alloc(total, &rc); int64_t at = 0; for (int64_t i = 0; i < s.n;) { if (i + from.n <= s.n && memcmp(s.p + i, from.p, (size_t)from.n) == 0) { @@ -370,24 +370,24 @@ static dstr dino_str_replace(dstr s, dstr from, dstr to) { return r; } -static dstr dino_str_repeat(dstr s, int64_t n) { +static dstr rex_str_repeat(dstr s, int64_t n) { if (n < 0) n = 0; int64_t total = s.n * n; int64_t *rc; - char *buf = dino_str_alloc(total, &rc); + char *buf = rex_str_alloc(total, &rc); for (int64_t i = 0; i < n; i++) if (s.n) memcpy(buf + i * s.n, s.p, (size_t)s.n); buf[total] = 0; dstr r = {buf, total, rc}; return r; } -static L_str dino_str_split(dstr s, dstr sep) { +static L_str rex_str_split(dstr s, dstr sep) { L_str out = {0}; if (sep.n == 0) { /* one piece per character */ for (int64_t i = 0; i < s.n;) { int64_t j = i + 1; while (j < s.n && (s.p[j] & 0xC0) == 0x80) j++; - dino_strs_push(&out, dino_new_str(s.p + i, j - i)); + rex_strs_push(&out, rex_new_str(s.p + i, j - i)); i = j; } return out; @@ -395,41 +395,41 @@ static L_str dino_str_split(dstr s, dstr sep) { int64_t start = 0; for (int64_t i = 0; i + sep.n <= s.n;) { if (memcmp(s.p + i, sep.p, (size_t)sep.n) == 0) { - dino_strs_push(&out, dino_new_str(s.p + start, i - start)); + rex_strs_push(&out, rex_new_str(s.p + start, i - start)); i += sep.n; start = i; } else i++; } - dino_strs_push(&out, dino_new_str(s.p + start, s.n - start)); + rex_strs_push(&out, rex_new_str(s.p + start, s.n - start)); return out; } -static L_str dino_str_lines(dstr s) { +static L_str rex_str_lines(dstr s) { L_str out = {0}; int64_t start = 0; for (int64_t i = 0; i < s.n; i++) { if (s.p[i] == '\n') { int64_t end = i; if (end > start && s.p[end - 1] == '\r') end--; - dino_strs_push(&out, dino_new_str(s.p + start, end - start)); + rex_strs_push(&out, rex_new_str(s.p + start, end - start)); start = i + 1; } } if (start < s.n) { int64_t end = s.n; if (end > start && s.p[end - 1] == '\r') end--; - dino_strs_push(&out, dino_new_str(s.p + start, end - start)); + rex_strs_push(&out, rex_new_str(s.p + start, end - start)); } return out; } -static void dino_str_chars(dstr s, void **p, int64_t *len, int64_t *cap) { +static void rex_str_chars(dstr s, void **p, int64_t *len, int64_t *cap) { uint32_t *out = (uint32_t *)malloc((size_t)(s.n ? s.n : 1) * sizeof(uint32_t)); - if (!out) dino_panic("out of memory"); + if (!out) rex_panic("out of memory"); int64_t n = 0; for (int64_t i = 0; i < s.n;) { uint32_t c; - i += dino_utf8_decode(s.p + i, s.n - i, &c); + i += rex_utf8_decode(s.p + i, s.n - i, &c); out[n++] = c; } *p = out; @@ -437,23 +437,23 @@ static void dino_str_chars(dstr s, void **p, int64_t *len, int64_t *cap) { *cap = s.n ? s.n : 1; } -static L_str dino_str_fields(dstr s) { +static L_str rex_str_fields(dstr s) { L_str out = {0}; int64_t i = 0; while (i < s.n) { - while (i < s.n && dino_is_space(s.p[i])) i++; + while (i < s.n && rex_is_space(s.p[i])) i++; int64_t start = i; - while (i < s.n && !dino_is_space(s.p[i])) i++; - if (i > start) dino_strs_push(&out, dino_new_str(s.p + start, i - start)); + while (i < s.n && !rex_is_space(s.p[i])) i++; + if (i > start) rex_strs_push(&out, rex_new_str(s.p + start, i - start)); } return out; } -static dstr dino_strs_join(L_str l, dstr sep) { +static dstr rex_strs_join(L_str l, dstr sep) { int64_t total = 0; for (int64_t i = 0; i < l.len; i++) total += l.p[i].n + (i ? sep.n : 0); int64_t *rc; - char *buf = dino_str_alloc(total, &rc); + char *buf = rex_str_alloc(total, &rc); int64_t at = 0; for (int64_t i = 0; i < l.len; i++) { if (i && sep.n) { memcpy(buf + at, sep.p, (size_t)sep.n); at += sep.n; } @@ -464,118 +464,118 @@ static dstr dino_strs_join(L_str l, dstr sep) { return r; } -static dino_err dino_str_to_int(dstr s, int64_t *out) { +static rex_err rex_str_to_int(dstr s, int64_t *out) { *out = 0; - char *c = dino_cstr(s); + char *c = rex_cstr(s); char *end = NULL; errno = 0; long long v = strtoll(c, &end, 10); - bool ok = s.n > 0 && *end == 0 && !dino_is_space(c[0]); + bool ok = s.n > 0 && *end == 0 && !rex_is_space(c[0]); int e = errno; free(c); - if (!ok) return dino_make_err(dino_fmt_msg("\"%.*s\" is not a whole number%s", s, "")); - if (e == ERANGE) return dino_make_err(dino_fmt_msg("\"%.*s\" is too big for an int%s", s, "")); + if (!ok) return rex_make_err(rex_fmt_msg("\"%.*s\" is not a whole number%s", s, "")); + if (e == ERANGE) return rex_make_err(rex_fmt_msg("\"%.*s\" is too big for an int%s", s, "")); *out = (int64_t)v; - dino_err none = {0}; + rex_err none = {0}; return none; } -static dino_err dino_str_to_float(dstr s, double *out) { +static rex_err rex_str_to_float(dstr s, double *out) { *out = 0; - char *c = dino_cstr(s); + char *c = rex_cstr(s); char *end = NULL; double v = strtod(c, &end); - bool ok = s.n > 0 && *end == 0 && !dino_is_space(c[0]); + bool ok = s.n > 0 && *end == 0 && !rex_is_space(c[0]); free(c); - if (!ok) return dino_make_err(dino_fmt_msg("\"%.*s\" is not a number%s", s, "")); + if (!ok) return rex_make_err(rex_fmt_msg("\"%.*s\" is not a number%s", s, "")); *out = v; - dino_err none = {0}; + rex_err none = {0}; return none; } -static dino_err dino_os_read_file(dstr path, dstr *out) { +static rex_err rex_os_read_file(dstr path, dstr *out) { dstr empty = {0}; *out = empty; - char *c = dino_cstr(path); + char *c = rex_cstr(path); FILE *f = fopen(c, "rb"); free(c); - if (!f) return dino_make_err(dino_fmt_msg("cannot read \"%.*s\": %s", path, strerror(errno))); + if (!f) return rex_make_err(rex_fmt_msg("cannot read \"%.*s\": %s", path, strerror(errno))); size_t cap = 4096, len = 0; char *buf = (char *)malloc(cap); - if (!buf) dino_panic("out of memory"); + if (!buf) rex_panic("out of memory"); for (;;) { size_t got = fread(buf + len, 1, cap - len, f); len += got; if (len < cap) break; cap *= 2; buf = (char *)realloc(buf, cap); - if (!buf) dino_panic("out of memory"); + if (!buf) rex_panic("out of memory"); } bool bad = ferror(f); fclose(f); if (bad) { free(buf); - return dino_make_err(dino_fmt_msg("cannot read \"%.*s\": %s", path, "read error")); + return rex_make_err(rex_fmt_msg("cannot read \"%.*s\": %s", path, "read error")); } - *out = dino_new_str(buf, (int64_t)len); + *out = rex_new_str(buf, (int64_t)len); free(buf); - dino_err none = {0}; + rex_err none = {0}; return none; } -static dino_err dino_os_write(dstr path, dstr text, const char *mode) { - char *c = dino_cstr(path); +static rex_err rex_os_write(dstr path, dstr text, const char *mode) { + char *c = rex_cstr(path); FILE *f = fopen(c, mode); free(c); - if (!f) return dino_make_err(dino_fmt_msg("cannot write \"%.*s\": %s", path, strerror(errno))); + if (!f) return rex_make_err(rex_fmt_msg("cannot write \"%.*s\": %s", path, strerror(errno))); size_t put = text.n ? fwrite(text.p, 1, (size_t)text.n, f) : 0; int closed = fclose(f); - dino_err none = {0}; - if (put != (size_t)text.n || closed != 0) return dino_make_err(dino_fmt_msg("cannot write \"%.*s\": %s", path, "write error")); + rex_err none = {0}; + if (put != (size_t)text.n || closed != 0) return rex_make_err(rex_fmt_msg("cannot write \"%.*s\": %s", path, "write error")); return none; } -static dino_err dino_os_write_file(dstr path, dstr text) { return dino_os_write(path, text, "wb"); } -static dino_err dino_os_append_file(dstr path, dstr text) { return dino_os_write(path, text, "ab"); } +static rex_err rex_os_write_file(dstr path, dstr text) { return rex_os_write(path, text, "wb"); } +static rex_err rex_os_append_file(dstr path, dstr text) { return rex_os_write(path, text, "ab"); } -static bool dino_os_exists(dstr path) { - char *c = dino_cstr(path); +static bool rex_os_exists(dstr path) { + char *c = rex_cstr(path); bool r = access(c, F_OK) == 0; free(c); return r; } -static int dino_argc; -static char **dino_argv; -static void dino_set_args(int argc, char **argv) { dino_argc = argc; dino_argv = argv; } +static int rex_argc; +static char **rex_argv; +static void rex_set_args(int argc, char **argv) { rex_argc = argc; rex_argv = argv; } -static L_str dino_os_args(void) { +static L_str rex_os_args(void) { L_str out = {0}; - for (int i = 0; i < dino_argc; i++) dino_strs_push(&out, dino_new_str(dino_argv[i], (int64_t)strlen(dino_argv[i]))); + for (int i = 0; i < rex_argc; i++) rex_strs_push(&out, rex_new_str(rex_argv[i], (int64_t)strlen(rex_argv[i]))); return out; } -static void dino_os_exit(int64_t code) { +static void rex_os_exit(int64_t code) { fflush(stdout); exit((int)code); } -static bool dino_os_env(dstr name, dstr *out) { +static bool rex_os_env(dstr name, dstr *out) { dstr empty = {0}; *out = empty; - char *c = dino_cstr(name); + char *c = rex_cstr(name); const char *v = getenv(c); free(c); if (!v) return false; - *out = dino_new_str(v, (int64_t)strlen(v)); + *out = rex_new_str(v, (int64_t)strlen(v)); return true; } -static bool dino_os_read_line(dstr *out) { +static bool rex_os_read_line(dstr *out) { dstr empty = {0}; *out = empty; size_t cap = 128, len = 0; char *buf = (char *)malloc(cap); - if (!buf) dino_panic("out of memory"); + if (!buf) rex_panic("out of memory"); int ch; bool any = false; while ((ch = getchar()) != EOF) { @@ -584,23 +584,23 @@ static bool dino_os_read_line(dstr *out) { if (len + 1 >= cap) { cap *= 2; buf = (char *)realloc(buf, cap); - if (!buf) dino_panic("out of memory"); + if (!buf) rex_panic("out of memory"); } buf[len++] = (char)ch; } if (len > 0 && buf[len - 1] == '\r') len--; - if (any) *out = dino_new_str(buf, (int64_t)len); + if (any) *out = rex_new_str(buf, (int64_t)len); free(buf); return any; } -static double dino_time_now(void) { +static double rex_time_now(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return (double)ts.tv_sec + (double)ts.tv_nsec / 1e9; } -static void dino_time_sleep(double secs) { +static void rex_time_sleep(double secs) { if (secs <= 0) return; fflush(stdout); struct timespec ts; @@ -611,13 +611,13 @@ static void dino_time_sleep(double secs) { /* ---- C libraries ---- */ -static dstr dino_from_cstr(const char *p) { - return p ? dino_new_str(p, (int64_t)strlen(p)) : dino_lit("", 0); +static dstr rex_from_cstr(const char *p) { + return p ? rex_new_str(p, (int64_t)strlen(p)) : rex_lit("", 0); } -static dstr dino_ptr_str(const void *p) { - if (!p) return dino_lit("nil", 3); +static dstr rex_ptr_str(const void *p) { + if (!p) return rex_lit("nil", 3); char b[32]; int n = snprintf(b, sizeof b, "%p", p); - return dino_new_str(b, n); + return rex_new_str(b, n); } diff --git a/src/stdlib.rs b/src/stdlib.rs index 6d04ef1..52add26 100644 --- a/src/stdlib.rs +++ b/src/stdlib.rs @@ -36,13 +36,13 @@ fn with_err(t: Ty) -> Ty { pub fn module_fn(module: &str, name: &str) -> Option { use Ty::*; match (module, name) { - ("os", "read_file") => f("dino_os_read_file", vec![Str], with_err(Str), BuiltinShape::ErrOut), - ("os", "write_file") => plain("dino_os_write_file", vec![Str, Str], Error), - ("os", "append_file") => plain("dino_os_append_file", vec![Str, Str], Error), - ("os", "exists") => plain("dino_os_exists", vec![Str], Bool), - ("os", "exit") => plain("dino_os_exit", vec![Int], Unit), - ("os", "env") => f("dino_os_env", vec![Str], Ty::opt(Str), BuiltinShape::OptOut), - ("os", "read_line") => f("dino_os_read_line", vec![], Ty::opt(Str), BuiltinShape::OptOut), + ("os", "read_file") => f("rex_os_read_file", vec![Str], with_err(Str), BuiltinShape::ErrOut), + ("os", "write_file") => plain("rex_os_write_file", vec![Str, Str], Error), + ("os", "append_file") => plain("rex_os_append_file", vec![Str, Str], Error), + ("os", "exists") => plain("rex_os_exists", vec![Str], Bool), + ("os", "exit") => plain("rex_os_exit", vec![Int], Unit), + ("os", "env") => f("rex_os_env", vec![Str], Ty::opt(Str), BuiltinShape::OptOut), + ("os", "read_line") => f("rex_os_read_line", vec![], Ty::opt(Str), BuiltinShape::OptOut), ("math", "sqrt") => plain("sqrt", vec![Float], Float), ("math", "sin") => plain("sin", vec![Float], Float), @@ -66,8 +66,8 @@ pub fn module_fn(module: &str, name: &str) -> Option { ("math", "max") => f("", vec![], Unit, BuiltinShape::Max), ("math", "abs") => f("", vec![], Unit, BuiltinShape::Abs), - ("time", "now") => plain("dino_time_now", vec![], Float), - ("time", "sleep") => plain("dino_time_sleep", vec![Float], Unit), + ("time", "now") => plain("rex_time_now", vec![], Float), + ("time", "sleep") => plain("rex_time_sleep", vec![Float], Unit), _ => None, } } @@ -82,7 +82,7 @@ pub fn module_value(module: &str, name: &str) -> Option { match (module, name) { ("math", "PI") => Some(ModuleValue::Float(std::f64::consts::PI)), ("math", "E") => Some(ModuleValue::Float(std::f64::consts::E)), - ("os", "args") => plain("dino_os_args", vec![], strings()).map(ModuleValue::Call), + ("os", "args") => plain("rex_os_args", vec![], strings()).map(ModuleValue::Call), _ => None, } } @@ -104,21 +104,21 @@ pub fn module_names(module: &str) -> Vec<&'static str> { pub fn str_method(name: &str) -> Option { use Ty::*; match name { - "upper" => plain("dino_str_upper", vec![Str], Str), - "lower" => plain("dino_str_lower", vec![Str], Str), - "trim" => plain("dino_str_trim", vec![Str], Str), - "contains" => plain("dino_str_contains", vec![Str, Str], Bool), - "starts_with" => plain("dino_str_starts_with", vec![Str, Str], Bool), - "ends_with" => plain("dino_str_ends_with", vec![Str, Str], Bool), - "index_of" => plain("dino_str_index_of", vec![Str, Str], Int), - "replace" => plain("dino_str_replace", vec![Str, Str, Str], Str), - "repeat" => plain("dino_str_repeat", vec![Str, Int], Str), - "split" => plain("dino_str_split", vec![Str, Str], strings()), - "lines" => plain("dino_str_lines", vec![Str], strings()), - "fields" => plain("dino_str_fields", vec![Str], strings()), - "chars" => f("dino_str_chars", vec![Str], Ty::list(Ty::Char), BuiltinShape::ListOut), - "to_int" => f("dino_str_to_int", vec![Str], with_err(Int), BuiltinShape::ErrOut), - "to_float" => f("dino_str_to_float", vec![Str], with_err(Float), BuiltinShape::ErrOut), + "upper" => plain("rex_str_upper", vec![Str], Str), + "lower" => plain("rex_str_lower", vec![Str], Str), + "trim" => plain("rex_str_trim", vec![Str], Str), + "contains" => plain("rex_str_contains", vec![Str, Str], Bool), + "starts_with" => plain("rex_str_starts_with", vec![Str, Str], Bool), + "ends_with" => plain("rex_str_ends_with", vec![Str, Str], Bool), + "index_of" => plain("rex_str_index_of", vec![Str, Str], Int), + "replace" => plain("rex_str_replace", vec![Str, Str, Str], Str), + "repeat" => plain("rex_str_repeat", vec![Str, Int], Str), + "split" => plain("rex_str_split", vec![Str, Str], strings()), + "lines" => plain("rex_str_lines", vec![Str], strings()), + "fields" => plain("rex_str_fields", vec![Str], strings()), + "chars" => f("rex_str_chars", vec![Str], Ty::list(Ty::Char), BuiltinShape::ListOut), + "to_int" => f("rex_str_to_int", vec![Str], with_err(Int), BuiltinShape::ErrOut), + "to_float" => f("rex_str_to_float", vec![Str], with_err(Float), BuiltinShape::ErrOut), _ => None, } } @@ -130,14 +130,14 @@ pub const STR_METHODS: &str = pub fn char_method(name: &str) -> Option { use Ty::*; match name { - "is_digit" => plain("dino_char_is_digit", vec![Char], Bool), - "is_letter" => plain("dino_char_is_letter", vec![Char], Bool), - "is_alnum" => plain("dino_char_is_alnum", vec![Char], Bool), - "is_space" => plain("dino_char_is_space", vec![Char], Bool), - "is_upper" => plain("dino_char_is_upper", vec![Char], Bool), - "is_lower" => plain("dino_char_is_lower", vec![Char], Bool), - "upper" => plain("dino_char_upper", vec![Char], Char), - "lower" => plain("dino_char_lower", vec![Char], Char), + "is_digit" => plain("rex_char_is_digit", vec![Char], Bool), + "is_letter" => plain("rex_char_is_letter", vec![Char], Bool), + "is_alnum" => plain("rex_char_is_alnum", vec![Char], Bool), + "is_space" => plain("rex_char_is_space", vec![Char], Bool), + "is_upper" => plain("rex_char_is_upper", vec![Char], Bool), + "is_lower" => plain("rex_char_is_lower", vec![Char], Bool), + "upper" => plain("rex_char_upper", vec![Char], Char), + "lower" => plain("rex_char_lower", vec![Char], Char), _ => None, } } @@ -147,7 +147,7 @@ pub const CHAR_METHODS: &str = "is_digit, is_letter, is_alnum, is_space, is_uppe /// Methods of `[]string`, besides `len`, `push` and `pop`. pub fn str_list_method(name: &str) -> Option { match name { - "join" => plain("dino_strs_join", vec![strings(), Ty::Str], Ty::Str), + "join" => plain("rex_strs_join", vec![strings(), Ty::Str], Ty::Str), _ => None, } } diff --git a/src/types.rs b/src/types.rs index 0fd65ce..6518626 100644 --- a/src/types.rs +++ b/src/types.rs @@ -85,7 +85,7 @@ pub enum Ty { Iface(&'static str), /// A function value: `func(int, string): bool`. Func(&'static FuncTy), - /// A pointer from a C library that Dino only passes around: `SDL.SDL_Window`, `zlib.gzFile`. + /// A pointer from a C library that Rex only passes around: `SDL.SDL_Window`, `zlib.gzFile`. /// `"pointer"` (C's `void *`) goes with every other pointer type. CPtr(&'static str), /// The "type" of a call that returns nothing. diff --git a/tests/clib.rs b/tests/clib.rs index b3099a9..c35a29a 100644 --- a/tests/clib.rs +++ b/tests/clib.rs @@ -4,13 +4,13 @@ use std::path::PathBuf; use std::process::Command; -use dino::driver; +use rex::driver; /// A fresh folder with the given files in it. fn folder(files: &[(&str, &str)]) -> PathBuf { static N: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0); let n = N.fetch_add(1, std::sync::atomic::Ordering::Relaxed); - let dir = std::env::temp_dir().join(format!("dino-clib-{}-{n}", std::process::id())); + let dir = std::env::temp_dir().join(format!("rex-clib-{}-{n}", std::process::id())); let _ = std::fs::remove_dir_all(&dir); std::fs::create_dir_all(&dir).unwrap(); for (name, text) in files { @@ -19,10 +19,10 @@ fn folder(files: &[(&str, &str)]) -> PathBuf { dir } -/// Compile `main.dino` in a folder with these files and run it; returns what it printed. +/// Compile `main.rex` in a folder with these files and run it; returns what it printed. fn run(files: &[(&str, &str)]) -> String { let dir = folder(files); - let c = driver::compile_file(dir.join("main.dino").to_str().unwrap()).unwrap_or_else(|e| panic!("{e}")); + let c = driver::compile_file(dir.join("main.rex").to_str().unwrap()).unwrap_or_else(|e| panic!("{e}")); let exe = dir.join("prog"); let sanitized = driver::build_exe_with(&c, &exe, &["-std=c11", "-fwrapv", "-w", "-fsanitize=address", "-g"]); if let Err(e) = sanitized { @@ -40,7 +40,7 @@ fn run(files: &[(&str, &str)]) -> String { /// The error message for a program that should not compile. fn error(files: &[(&str, &str)]) -> String { let dir = folder(files); - let r = driver::compile_file(dir.join("main.dino").to_str().unwrap()); + let r = driver::compile_file(dir.join("main.rex").to_str().unwrap()); let _ = std::fs::remove_dir_all(&dir); match r { Ok(_) => panic!("expected an error"), @@ -55,7 +55,7 @@ fn have_pkg(name: &str) -> bool { #[test] fn the_c_library() { let out = run(&[( - "main.dino", + "main.rex", "import \"math.h\" { cbrt, hypot }\nimport \"string.h\"\nimport \"stdlib.h\"\n\n\ func main() {\n print(cbrt(27.0), hypot(3.0, 4.0))\n print(string.strlen(\"héllo\"), stdlib.abs(-4))\n print(stdlib.atoi(\"42abc\") + 1)\n}\n", )]); @@ -149,7 +149,7 @@ shapes.Box{size: shapes.Size{w: 2.0, h: 3.0}, id: 5} 7\n0 10 11\n10\n[97, 98, 99 #[test] fn your_own_c_file() { - let out = run(&[("shapes.h", SHAPES_H), ("shapes.c", SHAPES_C), ("main.dino", SHAPES_MAIN)]); + let out = run(&[("shapes.h", SHAPES_H), ("shapes.c", SHAPES_C), ("main.rex", SHAPES_MAIN)]); assert_eq!(out, SHAPES_OUT); } @@ -178,7 +178,7 @@ const char *counter_name(const Counter *c) { return c->name.c_str(); } void counter_free(Counter *c) { delete c; } } "#; - let out = run(&[("shapes.h", SHAPES_H), ("shapes.cpp", cpp), ("main.dino", SHAPES_MAIN)]); + let out = run(&[("shapes.h", SHAPES_H), ("shapes.cpp", cpp), ("main.rex", SHAPES_MAIN)]); assert_eq!(out, SHAPES_OUT); } @@ -188,7 +188,7 @@ fn picked_names_are_used_bare() { ("shapes.h", SHAPES_H), ("shapes.c", SHAPES_C), ( - "main.dino", + "main.rex", "import \"shapes.h\" { Size, area, MAX_SIDES }\n\nfunc main() {\n var s: Size = Size{1.5, 2.0}\n print(area(s), MAX_SIDES)\n}\n", ), ]); @@ -201,7 +201,7 @@ fn zlib_through_pkg_config() { return; } let out = run(&[( - "main.dino", + "main.rex", r#"import "zlib.h" func main() { @@ -235,7 +235,7 @@ fn sqlite_fills_in_pointer_variables() { return; } let out = run(&[( - "main.dino", + "main.rex", r#"import "sqlite3.h" func main() { @@ -260,7 +260,7 @@ fn raylib_structs_without_a_window() { return; } let out = run(&[( - "main.dino", + "main.rex", "import \"raylib.h\"\n\nfunc main() {\n var c = raylib.Fade(raylib.RED, 0.5)\n print(c, raylib.ColorToInt(raylib.Color{0, 0, 0, 255}))\n var p = raylib.Vector2{1.0, 1.0}\n print(raylib.CheckCollisionPointRec(p, raylib.Rectangle{0.0, 0.0, 2.0, 2.0}))\n}\n", )]); assert_eq!(out, "raylib.Color{r: 230, g: 41, b: 55, a: 127} 255\ntrue\n"); @@ -268,32 +268,32 @@ fn raylib_structs_without_a_window() { #[test] fn errors_name_the_problem() { - let e = error(&[("main.dino", "import \"no_such_header.h\"\n\nfunc main() {}\n")]); + let e = error(&[("main.rex", "import \"no_such_header.h\"\n\nfunc main() {}\n")]); assert!(e.contains("cannot find the C header `no_such_header.h`"), "{e}"); - let e = error(&[("shapes.h", SHAPES_H), ("main.dino", "import \"shapes.h\" { aera }\n\nfunc main() {}\n")]); + let e = error(&[("shapes.h", SHAPES_H), ("main.rex", "import \"shapes.h\" { aera }\n\nfunc main() {}\n")]); assert!(e.contains("`shapes.h` has no `aera` (did you mean `area`?)"), "{e}"); - let e = error(&[("main.dino", "import \"stdio.h\"\n\nfunc main() {\n stdio.printf(\"hi\")\n}\n")]); - assert!(e.contains("`printf` can't be called from Dino: it takes a variable number of arguments"), "{e}"); + let e = error(&[("main.rex", "import \"stdio.h\"\n\nfunc main() {\n stdio.printf(\"hi\")\n}\n")]); + assert!(e.contains("`printf` can't be called from Rex: it takes a variable number of arguments"), "{e}"); - let e = error(&[("shapes.h", SHAPES_H), ("main.dino", "import \"shapes.h\"\n\nfunc main() {\n shapes.grow(shapes.Size{1.0, 1.0}, 2.0)\n}\n")]); + let e = error(&[("shapes.h", SHAPES_H), ("main.rex", "import \"shapes.h\"\n\nfunc main() {\n shapes.grow(shapes.Size{1.0, 1.0}, 2.0)\n}\n")]); assert!(e.contains("`grow` writes into `s`, so it must be a variable"), "{e}"); - let e = error(&[("shapes.h", SHAPES_H), ("main.dino", "import \"shapes.h\"\n\nfunc main() {\n var n = 3\n print(shapes.make_box(n))\n}\n")]); + let e = error(&[("shapes.h", SHAPES_H), ("main.rex", "import \"shapes.h\"\n\nfunc main() {\n var n = 3\n print(shapes.make_box(n))\n}\n")]); assert!(e.contains("expected `i32`, found `int` (convert it with `i32(...)`)"), "{e}"); - let e = error(&[("shapes.h", SHAPES_H), ("main.dino", "import \"shapes.h\"\n\nfunc main() {\n print(shapes.area())\n}\n")]); + let e = error(&[("shapes.h", SHAPES_H), ("main.rex", "import \"shapes.h\"\n\nfunc main() {\n print(shapes.area())\n}\n")]); assert!(e.contains("`area` takes 1 argument (s: shapes.Size), but 0 were given"), "{e}"); } #[test] fn a_missing_library_says_how_to_link() { let dir = folder(&[( - "main.dino", - "import \"math.h\" link \"dino_no_such_lib\"\n\nfunc main() {\n print(math.sqrt(4.0))\n}\n", + "main.rex", + "import \"math.h\" link \"rex_no_such_lib\"\n\nfunc main() {\n print(math.sqrt(4.0))\n}\n", )]); - let c = driver::compile_file(dir.join("main.dino").to_str().unwrap()).unwrap(); + let c = driver::compile_file(dir.join("main.rex").to_str().unwrap()).unwrap(); let e = driver::build_exe(&c, &dir.join("prog")).unwrap_err(); let _ = std::fs::remove_dir_all(&dir); assert!(e.contains("linking with the C library failed") && e.contains("link \"name\""), "{e}"); diff --git a/tests/fmt.rs b/tests/fmt.rs index 53a73fb..3683e87 100644 --- a/tests/fmt.rs +++ b/tests/fmt.rs @@ -1,9 +1,9 @@ -//! Tests of `dino fmt`. +//! Tests of `rex fmt`. -use dino::fmt::format; +use rex::fmt::format; fn fmt(src: &str) -> String { - format(src).unwrap_or_else(|d| panic!("{}", d.render("test.dino", src))) + format(src).unwrap_or_else(|d| panic!("{}", d.render("test.rex", src))) } #[test] @@ -59,12 +59,12 @@ fn broken_code_is_refused() { assert!(format("func main( {").is_err()); } -fn dino_files(dir: &std::path::Path, out: &mut Vec) { +fn rex_files(dir: &std::path::Path, out: &mut Vec) { for e in std::fs::read_dir(dir).unwrap() { let p = e.unwrap().path(); if p.is_dir() { - dino_files(&p, out); - } else if p.extension().map_or(false, |x| x == "dino") { + rex_files(&p, out); + } else if p.extension().map_or(false, |x| x == "rex") { out.push(p); } } @@ -73,12 +73,12 @@ fn dino_files(dir: &std::path::Path, out: &mut Vec) { #[test] fn examples_are_formatted_and_formatting_is_stable() { let mut files = Vec::new(); - dino_files(&std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("examples"), &mut files); + rex_files(&std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("examples"), &mut files); assert!(files.len() > 30); for f in files { let src = std::fs::read_to_string(&f).unwrap(); let once = fmt(&src); - assert_eq!(once, src, "{} is not formatted (run `dino fmt examples`)", f.display()); + assert_eq!(once, src, "{} is not formatted (run `rex fmt examples`)", f.display()); assert_eq!(fmt(&once), once, "formatting {} twice differs", f.display()); } } @@ -91,8 +91,8 @@ fn doc_examples_are_stable() { let p = e.unwrap().path(); let text = std::fs::read_to_string(&p).unwrap(); let mut rest = text.as_str(); - while let Some(start) = rest.find("```dino\n") { - let after = &rest[start + 8..]; + while let Some(start) = rest.find("```rex\n") { + let after = &rest[start + "```rex\n".len()..]; let end = after.find("```").unwrap(); let code = &after[..end]; rest = &after[end + 3..]; diff --git a/tests/lsp.rs b/tests/lsp.rs index 7122bdc..b4b3699 100644 --- a/tests/lsp.rs +++ b/tests/lsp.rs @@ -1,7 +1,7 @@ //! Tests of the language server: feed it editor messages, read what it answers. -use dino::json::{self, Json}; -use dino::lsp; +use rex::json::{self, Json}; +use rex::lsp; fn frame(v: &Json) -> Vec { let body = v.to_string(); @@ -68,7 +68,7 @@ fn initialize_announces_features() { #[test] fn errors_show_up_as_diagnostics() { let src = "func main() {\n var x: int = \"no\"\n}\n"; - let mut msgs = vec![open("file:///tmp/dino-lsp-test/a.dino", src)]; + let mut msgs = vec![open("file:///tmp/rex-lsp-test/a.rex", src)]; msgs.extend(exit_messages()); let (out, _) = talk(msgs); let d = match out[0].path(&["params", "diagnostics"]) { @@ -83,7 +83,7 @@ fn errors_show_up_as_diagnostics() { #[test] fn fixing_the_code_clears_the_diagnostics() { - let uri = "file:///tmp/dino-lsp-test/b.dino"; + let uri = "file:///tmp/rex-lsp-test/b.rex"; let change = notify( "textDocument/didChange", Json::obj(vec![ @@ -102,7 +102,7 @@ fn fixing_the_code_clears_the_diagnostics() { fn error_columns_count_utf16_units() { // the emoji takes two units in the editor's counting let src = "func main() {\n print(\"😀\", nope)\n}\n"; - let mut msgs = vec![open("file:///tmp/dino-lsp-test/c.dino", src)]; + let mut msgs = vec![open("file:///tmp/rex-lsp-test/c.rex", src)]; msgs.extend(exit_messages()); let (out, _) = talk(msgs); let d = match out[0].path(&["params", "diagnostics"]) { @@ -117,7 +117,7 @@ fn error_columns_count_utf16_units() { #[test] fn formatting_returns_the_tidy_text() { - let uri = "file:///tmp/dino-lsp-test/d.dino"; + let uri = "file:///tmp/rex-lsp-test/d.rex"; let fmt_req = request( 2, "textDocument/formatting", @@ -136,10 +136,10 @@ fn formatting_returns_the_tidy_text() { #[test] fn imports_are_read_next_to_the_file() { - let dir = std::env::temp_dir().join(format!("dino-lsp-{}", std::process::id())); + let dir = std::env::temp_dir().join(format!("rex-lsp-{}", std::process::id())); std::fs::create_dir_all(&dir).unwrap(); - std::fs::write(dir.join("util.dino"), "pub func twice(x: int): int { return x * 2 }\n").unwrap(); - let uri = format!("file://{}/main.dino", dir.display()); + std::fs::write(dir.join("util.rex"), "pub func twice(x: int): int { return x * 2 }\n").unwrap(); + let uri = format!("file://{}/main.rex", dir.display()); let src = "import util\nfunc main() {\n print(util.twice(2))\n}\n"; let mut msgs = vec![open(&uri, src)]; msgs.extend(exit_messages()); @@ -159,7 +159,7 @@ fn unknown_requests_get_an_error() { #[test] fn editor_files_are_valid_json() { let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("editors/vscode"); - for f in ["package.json", "language-configuration.json", "syntaxes/dino.tmLanguage.json"] { + for f in ["package.json", "language-configuration.json", "syntaxes/rex.tmLanguage.json"] { let text = std::fs::read_to_string(dir.join(f)).unwrap(); json::parse(&text).unwrap_or_else(|e| panic!("{f}: {e}")); } @@ -177,7 +177,7 @@ fn at(uri: &str, line: i64, ch: i64) -> Json { } fn ask(method: &str, params: Json) -> Json { - let mut msgs = vec![request(1, "initialize", Json::obj(vec![])), open("file:///x/a.dino", SRC), request(2, method, params)]; + let mut msgs = vec![request(1, "initialize", Json::obj(vec![])), open("file:///x/a.rex", SRC), request(2, method, params)]; msgs.extend(exit_messages()); let (out, _) = talk(msgs); out.into_iter().find(|m| m.get("id") == Some(&Json::Num(2.0))).unwrap().get("result").cloned().unwrap_or(Json::Null) @@ -185,40 +185,40 @@ fn ask(method: &str, params: Json) -> Json { #[test] fn outline_lists_top_level_names() { - let r = ask("textDocument/documentSymbol", Json::obj(vec![("textDocument", Json::obj(vec![("uri", Json::str("file:///x/a.dino"))]))])); + let r = ask("textDocument/documentSymbol", Json::obj(vec![("textDocument", Json::obj(vec![("uri", Json::str("file:///x/a.rex"))]))])); let text = r.to_string(); assert!(text.contains("\"add\"") && text.contains("\"P\"") && text.contains("\"main\"") && text.contains("\"x\""), "{text}"); } #[test] fn definition_jumps_to_the_function() { - let r = ask("textDocument/definition", at("file:///x/a.dino", 11, 14)); + let r = ask("textDocument/definition", at("file:///x/a.rex", 11, 14)); assert_eq!(r.path(&["range", "start", "line"]).and_then(Json::as_i64), Some(1), "{r:?}"); } #[test] fn definition_finds_a_local() { - let r = ask("textDocument/definition", at("file:///x/a.dino", 3, 12)); + let r = ask("textDocument/definition", at("file:///x/a.rex", 3, 12)); assert_eq!(r.path(&["range", "start", "line"]).and_then(Json::as_i64), Some(2), "{r:?}"); } #[test] fn hover_shows_the_signature_and_comment() { - let r = ask("textDocument/hover", at("file:///x/a.dino", 11, 14)); + let r = ask("textDocument/hover", at("file:///x/a.rex", 11, 14)); let v = r.path(&["contents", "value"]).and_then(Json::as_str).unwrap_or("").to_string(); assert!(v.contains("func add(a: int, b: int): int") && v.contains("Adds two numbers."), "{v}"); } #[test] fn completion_offers_names_and_keywords() { - let r = ask("textDocument/completion", at("file:///x/a.dino", 12, 4)).to_string(); + let r = ask("textDocument/completion", at("file:///x/a.rex", 12, 4)).to_string(); assert!(r.contains("\"add\"") && r.contains("\"t\"") && r.contains("\"func\"") && r.contains("\"string\""), "{r:?}"); } #[test] fn signature_help_marks_the_parameter() { let src = "func add(a: int, b: int): int {\n return a + b\n}\nfunc main() {\n add(1, \n}\n"; - let mut msgs = vec![request(1, "initialize", Json::obj(vec![])), open("file:///x/b.dino", src), request(2, "textDocument/signatureHelp", at("file:///x/b.dino", 4, 11))]; + let mut msgs = vec![request(1, "initialize", Json::obj(vec![])), open("file:///x/b.rex", src), request(2, "textDocument/signatureHelp", at("file:///x/b.rex", 4, 11))]; msgs.extend(exit_messages()); let (out, _) = talk(msgs); let r = out.into_iter().find(|m| m.get("id") == Some(&Json::Num(2.0))).unwrap().get("result").cloned().unwrap(); @@ -229,10 +229,10 @@ fn signature_help_marks_the_parameter() { // ---------- C headers ---------- fn with_header(src: &str, method: &str, line: i64, ch: i64) -> Json { - let dir = std::env::temp_dir().join(format!("dino-lsp-c-{}-{}", std::process::id(), method.replace('/', "_"))); + let dir = std::env::temp_dir().join(format!("rex-lsp-c-{}-{}", std::process::id(), method.replace('/', "_"))); std::fs::create_dir_all(&dir).unwrap(); std::fs::write(dir.join("geo.h"), "typedef struct { double x, y; } Point;\n#define ORIGIN_NAME \"origin\"\n/* distance */\ndouble dist(Point a, Point b);\nint clamp(int v, int lo, int hi);\n").unwrap(); - let uri = format!("file://{}/main.dino", dir.display()); + let uri = format!("file://{}/main.rex", dir.display()); let mut msgs = vec![request(1, "initialize", Json::obj(vec![])), open(&uri, src), request(2, method, at(&uri, line, ch))]; msgs.extend(exit_messages()); let (out, _) = talk(msgs); diff --git a/tests/parse.rs b/tests/parse.rs index 769a4a2..ec0bc20 100644 --- a/tests/parse.rs +++ b/tests/parse.rs @@ -1,5 +1,5 @@ -use dino::ast::*; -use dino::parser::parse; +use rex::ast::*; +use rex::parser::parse; fn body_of(src: &str) -> Vec { let p = parse(src).unwrap_or_else(|d| panic!("{}", d.render("test", src))); @@ -23,7 +23,7 @@ fn all_examples_parse() { let mut n = 0; for entry in std::fs::read_dir(dir).unwrap() { let path = entry.unwrap().path(); - if path.extension().map_or(false, |e| e == "dino") { + if path.extension().map_or(false, |e| e == "rex") { let src = std::fs::read_to_string(&path).unwrap(); parse(&src).unwrap_or_else(|d| panic!("{}", d.render(path.to_str().unwrap(), &src))); n += 1; @@ -190,7 +190,7 @@ fn semicolons_work() { // ---------- error messages ---------- -fn err(src: &str) -> dino::error::Diag { +fn err(src: &str) -> rex::error::Diag { parse(src).unwrap_err() } @@ -239,8 +239,8 @@ fn error_two_statements_on_one_line() { #[test] fn render_shows_caret() { let src = "func main() {\n var x = \n}"; - let out = err(src).render("t.dino", src); - assert!(out.contains("t.dino:3:1"), "{out}"); + let out = err(src).render("t.rex", src); + assert!(out.contains("t.rex:3:1"), "{out}"); assert!(out.contains("^"), "{out}"); } diff --git a/tests/run.rs b/tests/run.rs index 5203bee..ec90ff9 100644 --- a/tests/run.rs +++ b/tests/run.rs @@ -1,9 +1,9 @@ -//! End-to-end tests: compile Dino programs to C, build them with the system C +//! End-to-end tests: compile Rex programs to C, build them with the system C //! compiler, run them, and compare the output. use std::process::Command; -use dino::driver; +use rex::driver; struct Output { stdout: String, @@ -12,7 +12,7 @@ struct Output { } fn run_source(src: &str) -> Output { - let c = driver::compile_to_c(src).unwrap_or_else(|d| panic!("{}", d.render("test.dino", src))); + let c = driver::compile_to_c(src).unwrap_or_else(|d| panic!("{}", d.render("test.rex", src))); run_c(&c, src) } @@ -52,7 +52,7 @@ fn golden_examples() { let mut n = 0; for entry in std::fs::read_dir(dir).unwrap() { let path = entry.unwrap().path(); - if path.extension().map_or(false, |e| e == "dino") { + if path.extension().map_or(false, |e| e == "rex") { let src = std::fs::read_to_string(&path).unwrap(); let want = std::fs::read_to_string(path.with_extension("out")) .unwrap_or_else(|_| panic!("missing .out file for {}", path.display())); @@ -285,7 +285,7 @@ fn generated_c_is_const_correct() { // wrong, the C compiler would complain about discarding `const`. let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/basics"); for name in ["structs", "value_semantics", "lists", "list_values", "sieve", "enums", "enum_data", "errors", "optionals", "sized", "own_strings", "own_structs", "own_flows"] { - let src = std::fs::read_to_string(format!("{dir}/{name}.dino")).unwrap(); + let src = std::fs::read_to_string(format!("{dir}/{name}.rex")).unwrap(); let c = driver::compile_to_c(&src).unwrap(); let exe = driver::temp_exe(); driver::build_exe_with( @@ -1125,7 +1125,7 @@ fn optional_as_struct_return_through_match() { fn generated_c_for_errors_is_clean() { let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/basics"); for name in ["errors", "optionals", "sized", "own_strings", "own_structs", "own_flows"] { - let src = std::fs::read_to_string(format!("{dir}/{name}.dino")).unwrap(); + let src = std::fs::read_to_string(format!("{dir}/{name}.rex")).unwrap(); let c = driver::compile_to_c(&src).unwrap(); let exe = driver::temp_exe(); driver::build_exe_with(&c, &exe, &["-std=c11", "-Wall", "-Werror=incompatible-pointer-types"]) @@ -1314,8 +1314,8 @@ fn error_float_literal_for_integer_type() { // ---------- modules: `import utils` ---------- fn project_c(main: &str, modules: &[(&str, &str)]) -> Result { - driver::compile_project("main.dino", main, |key| { - modules.iter().find(|(k, _)| *k == key).map(|(k, src)| (format!("{k}.dino"), src.to_string())) + driver::compile_project("main.rex", main, |key| { + modules.iter().find(|(k, _)| *k == key).map(|(k, src)| (format!("{k}.rex"), src.to_string())) }) } @@ -1398,7 +1398,7 @@ fn project_err(main: &str, modules: &[(&str, &str)]) -> String { fn error_private_function() { let e = project_err("import utils\nfunc main() { print(utils.helper()) }", &[("utils", UTILS)]); assert!(e.contains("`helper` is private to `utils`"), "{e}"); - assert!(e.contains("main.dino:2"), "{e}"); + assert!(e.contains("main.rex:2"), "{e}"); } #[test] @@ -1420,20 +1420,20 @@ fn error_private_type() { #[test] fn error_in_module_names_that_file() { let e = project_err("import bad\nfunc main() { print(bad.f()) }", &[("bad", "pub func f(): int { return \"x\" }")]); - assert!(e.contains("bad.dino:1"), "{e}"); + assert!(e.contains("bad.rex:1"), "{e}"); assert!(e.contains("expected `int`"), "{e}"); } #[test] fn error_syntax_error_in_module() { let e = project_err("import bad\nfunc main() {}", &[("bad", "func f( {")]); - assert!(e.contains("bad.dino"), "{e}"); + assert!(e.contains("bad.rex"), "{e}"); } #[test] fn error_missing_module() { let e = project_err("import nope\nfunc main() {}", &[]); - assert!(e.contains("cannot find module `nope`") && e.contains("nope.dino"), "{e}"); + assert!(e.contains("cannot find module `nope`") && e.contains("nope.rex"), "{e}"); } #[test] @@ -1452,7 +1452,7 @@ fn error_unknown_name_in_module() { fn error_module_does_not_see_main_or_other_imports() { // `b` imports nothing, so it can't use `os` let e = project_err("import b\nfunc main() { print(b.f()) }", &[("b", "pub func f(): int { return os.exists(\"x\") }")]); - assert!(e.contains("b.dino"), "{e}"); + assert!(e.contains("b.rex"), "{e}"); } #[test] @@ -1468,7 +1468,7 @@ fn error_private_field() { // ---------- move on last use ---------- fn c_of(src: &str) -> String { - driver::compile_to_c(src).unwrap_or_else(|d| panic!("{}", d.render("test.dino", src))) + driver::compile_to_c(src).unwrap_or_else(|d| panic!("{}", d.render("test.rex", src))) } #[test] @@ -2154,7 +2154,7 @@ fn string_slice_out_of_range_panics() { #[test] fn calc_example_session() { let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/calc"); - let main = format!("{dir}/main.dino"); + let main = format!("{dir}/main.rex"); let c = driver::compile_file(&main).unwrap_or_else(|e| panic!("{e}")); let exe = driver::temp_exe(); driver::build_exe_with(&c, &exe, &["-std=c11", "-fwrapv", "-w", "-fsanitize=address", "-g"]).unwrap(); @@ -2203,8 +2203,8 @@ fn docs_examples_run() { } let text = std::fs::read_to_string(&path).unwrap(); let mut rest = text.as_str(); - while let Some(start) = rest.find("```dino\n") { - let after = &rest[start + 8..]; + while let Some(start) = rest.find("```rex\n") { + let after = &rest[start + "```rex\n".len()..]; let end = after.find("```").unwrap(); let code = &after[..end]; rest = &after[end + 3..];