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
+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..];