Rename the language from Dino to Rex

Files use .rex, the command is rex, and the crate, runtime prefixes,
docs, editor files and examples all use the new name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Your NameandClaude Opus 5.5 committed 2026-11-08 13:51:23 +01:00
1 parent 2f44f09b6a
commit 7cf9727bcd
94 files changed
+858 -858

No files matched your search

Generated
+1 -1
View File
@@ -3,5 +3,5 @@
version = 4
[[package]]
name = "dino"
name = "rex"
version = "0.1.0"
+2 -2
View File
@@ -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]
+20 -20
View File
@@ -1,8 +1,8 @@
<p align="center">
<img src="dino-logo.svg" alt="Dino, the mascot" width="420">
<img src="rex-logo.svg" alt="Rex, the mascot" width="420">
</p>
<h1 align="center">Dino</h1>
<h1 align="center">Rex</h1>
<p align="center">
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
+9 -9
View File
@@ -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] <file|folder>..` (`src/fmt.rs`): text based, so comments and blank lines survive.
- **Formatter** `rex fmt [--check] <file|folder>..` (`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).
+20 -20
View File
@@ -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,
+11 -11
View File
@@ -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"
+4 -4
View File
@@ -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 {
+6 -6
View File
@@ -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 {
+9 -9
View File
@@ -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
+5 -5
View File
@@ -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)
+6 -6
View File
@@ -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")
+4 -4
View File
@@ -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() {
+6 -6
View File
@@ -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
+9 -9
View File
@@ -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() {
+16 -16
View File
@@ -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
+10 -10
View File
@@ -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)
+33 -33
View File
@@ -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)
+5 -5
View File
@@ -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.
+29 -29
View File
@@ -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).
-1
View File
@@ -1 +0,0 @@
autocmd BufRead,BufNewFile *.dino setfiletype dino
+1
View File
@@ -0,0 +1 @@
autocmd BufRead,BufNewFile *.rex setfiletype rex
-37
View File
@@ -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"
+37
View File
@@ -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"
+6 -6
View File
@@ -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".`
);
});
}
+16 -16
View File
@@ -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
@@ -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": "\\?" }
]
}
}
}
+103
View File
@@ -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": "\\?" }
]
}
}
}
File renamed without changes.
@@ -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() {
@@ -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) {
File renamed without changes.
+1 -1
View File
@@ -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
@@ -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 }
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
-3
View File
@@ -1,3 +0,0 @@
func main() {
print("Hello, Dino!")
}
+1 -1
View File
@@ -1 +1 @@
Hello, Dino!
Hello, Rex!
+3
View File
@@ -0,0 +1,3 @@
func main() {
print("Hello, Rex!")
}
File renamed without changes.
File renamed without changes.
File renamed without changes.
+1 -1
View File
@@ -10,4 +10,4 @@ sq[4] = 16
[] 0
[a, b] 2 items
[1.0, 2.5, 3.0]
dino-lang 4
rex-lang 3
@@ -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())
}
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -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) }
+1 -1
View File
@@ -1,4 +1,4 @@
Hello, Dino!
Hello, Rex!
n is 3, doubled 6, big? true
pi is about 3.75
true true false
@@ -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}")
File renamed without changes.
File renamed without changes.
@@ -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() {
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
+2 -2
View File
@@ -29,7 +29,7 @@
<path d="M788.0799999999999 649.88Q806.96 649.88 821.2 657.56Q835.4399999999999 665.24 843.12 677.72V652.44H897.8399999999999V831.0H843.12V805.72Q835.12 818.2 820.88 825.88Q806.64 833.56 787.76 833.56Q766.0 833.56 748.0799999999999 822.2Q730.16 810.84 719.76 789.88Q709.36 768.92 709.36 741.4Q709.36 713.88 719.76 693.0799999999999Q730.16 672.28 748.0799999999999 661.0799999999999Q766.0 649.88 788.0799999999999 649.88ZM804.0799999999999 697.56Q787.76 697.56 776.4 709.24Q765.04 720.92 765.04 741.4Q765.04 761.88 776.4 773.88Q787.76 785.88 804.0799999999999 785.88Q820.4 785.88 831.76 774.04Q843.12 762.2 843.12 741.72Q843.12 721.24 831.76 709.4Q820.4 697.56 804.0799999999999 697.56Z" fill="#000" transform="rotate(2 809.0 719.0)" stroke="#000" stroke-linejoin="round" stroke-width="22"/>
<path d="M1111.12 732.68V837.0H1056.72V740.04Q1056.72 722.12 1047.44 712.2Q1038.1599999999999 702.28 1022.4799999999999 702.28Q1006.8 702.28 997.52 712.2Q988.24 722.12 988.24 740.04V837.0H933.52V658.44H988.24V682.12Q996.56 670.28 1010.64 663.4Q1024.72 656.52 1042.32 656.52Q1073.6799999999998 656.52 1092.3999999999999 676.8399999999999Q1111.12 697.16 1111.12 732.68Z" fill="#000" transform="rotate(-4 1021.5 725.0)" stroke="#000" stroke-linejoin="round" stroke-width="22"/>
<path d="M1268.08 675.72V650.44H1322.8V828.68Q1322.8 853.32 1313.04 873.32Q1303.28 893.32 1283.28 905.1600000000001Q1263.28 917.0 1233.52 917.0Q1193.84 917.0 1169.1999999999998 898.28Q1144.56 879.56 1141.04 847.56H1195.12Q1197.6799999999998 857.8 1207.2799999999997 863.72Q1216.8799999999999 869.64 1230.9599999999998 869.64Q1247.9199999999998 869.64 1258.0 859.88Q1268.08 850.12 1268.08 828.68V803.4Q1260.08 815.88 1246.0 823.72Q1231.9199999999998 831.56 1213.04 831.56Q1190.9599999999998 831.56 1173.04 820.2Q1155.12 808.84 1144.7199999999998 787.88Q1134.32 766.92 1134.32 739.4Q1134.32 711.88 1144.7199999999998 691.0799999999999Q1155.12 670.28 1173.04 659.0799999999999Q1190.9599999999998 647.88 1213.04 647.88Q1231.9199999999998 647.88 1246.1599999999999 655.56Q1260.3999999999999 663.24 1268.08 675.72ZM1229.04 695.56Q1212.7199999999998 695.56 1201.36 707.24Q1190.0 718.92 1190.0 739.4Q1190.0 759.88 1201.36 771.88Q1212.7199999999998 783.88 1229.04 783.88Q1245.36 783.88 1256.7199999999998 772.04Q1268.08 760.2 1268.08 739.72Q1268.08 719.24 1256.7199999999998 707.4Q1245.36 695.56 1229.04 695.56Z" fill="#000" transform="rotate(3 1234.0 717.0)" stroke="#000" stroke-linejoin="round" stroke-width="22"/></clipPath>
<symbol id="ldino" viewBox="0 0 400 420">
<symbol id="lrex" viewBox="0 0 400 420">
<g stroke="#8FD293" stroke-width="12" stroke-linejoin="round" stroke-linecap="round">
<path d="M300,300 C345,300 372,282 384,248 C390,270 378,318 330,345 C318,352 304,352 296,348 Z" fill="#5DB862"/>
@@ -136,6 +136,6 @@
<g clip-path="url(#clipBot)"><rect x="560" y="540" width="800" height="400" fill="url(#spikes)"/></g>
<!-- mascot -->
<use href="#ldino" x="205" y="505" width="400" height="420"/>
<use href="#lrex" x="205" y="505" width="400" height="420"/>
</g>
</svg>

Before

Width:  |  Height:  |  Size: 35 KiB

After

Width:  |  Height:  |  Size: 35 KiB

View File
File renamed without changes.

Before

Width:  |  Height:  |  Size: 3.2 KiB

After

Width:  |  Height:  |  Size: 3.2 KiB

+33 -33
View File
@@ -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<CTy>, 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<String>,
}
#[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<String>,
@@ -77,7 +77,7 @@ pub struct Lib {
pub funcs: Vec<Func>,
pub structs: Vec<Struct>,
pub consts: Vec<Const>,
/// 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<String>,
}
@@ -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<String> {
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<Lib, String> {
type Key = (String, PathBuf, Option<String>, Option<std::time::SystemTime>);
@@ -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<Tok> {
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<Tok> {
// ---------- 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<Vec<(String, Raw)>>,
/// 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<String>,
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, String>) -> 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<String, String> = 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<String> = 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)));
+10 -10
View File
@@ -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<Ty> {
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<String> = 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,
));
}
+100 -100
View File
@@ -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)),
}
+8 -8
View File
@@ -14,7 +14,7 @@ pub fn load_c_headers(main: &Program, modules: &[(String, Program)], dir: &Path)
let mut libs: Vec<cheader::Lib> = 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<String> {
let ast = parser::parse(src)?;
@@ -78,7 +78,7 @@ pub fn compile_file(path: &str) -> Result<String, String> {
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(()),
+1 -1
View File
@@ -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() {
/// | ^
+3 -3
View File
@@ -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<String, Diag> {
// 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(),
));
}
+2 -2
View File
@@ -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<String>,
}
@@ -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,
+1 -1
View File
@@ -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.
+2 -2
View File
@@ -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)),
+1 -1
View File
@@ -1,4 +1,4 @@
//! The Dino compiler.
//! The Rex compiler.
pub mod ast;
pub mod check;
+3 -3
View File
@@ -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: {})",
+7 -7
View File
@@ -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<PathBuf> {
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() {
+24 -24
View File
@@ -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 <file.dino> [args...] compile and run (args go to the program)");
eprintln!(" dino build <file.dino> [-o out] compile to an executable");
eprintln!(" dino emit-c <file.dino> print the generated C code");
eprintln!(" dino check <file.dino> check for errors without building");
eprintln!(" dino fmt [--check] <file|dir>.. format code in place (--check only reports; `-` = stdin to stdout)");
eprintln!(" dino lsp run the language server (for editors)");
eprintln!(" dino header <file.h> [name] show what Dino can use from a C header");
eprintln!(" dino parse <file.dino> print the syntax tree");
eprintln!(" dino tokens <file.dino> print the tokens");
eprintln!(" rex run <file.rex> [args...] compile and run (args go to the program)");
eprintln!(" rex build <file.rex> [-o out] compile to an executable");
eprintln!(" rex emit-c <file.rex> print the generated C code");
eprintln!(" rex check <file.rex> check for errors without building");
eprintln!(" rex fmt [--check] <file|dir>.. format code in place (--check only reports; `-` = stdin to stdout)");
eprintln!(" rex lsp run the language server (for editors)");
eprintln!(" rex header <file.h> [name] show what Rex can use from a C header");
eprintln!(" rex parse <file.rex> print the syntax tree");
eprintln!(" rex tokens <file.rex> 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<PathBuf>) {
/// All `.rex` files at `path` (a file, or a folder searched recursively).
fn rex_files(path: &std::path::Path, out: &mut Vec<PathBuf>) {
if path.is_dir() {
let mut entries: Vec<PathBuf> = 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<PathBuf> = 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<String> = 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) {
+167 -167
View File
@@ -1,4 +1,4 @@
/* Dino runtime (generated programs include this verbatim). */
/* Rex runtime (generated programs include this verbatim). */
#define _POSIX_C_SOURCE 200809L
#include <stdint.h>
#include <math.h>
@@ -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);
}
+34 -34
View File
@@ -36,13 +36,13 @@ fn with_err(t: Ty) -> Ty {
pub fn module_fn(module: &str, name: &str) -> Option<BuiltinFn> {
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<BuiltinFn> {
("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<ModuleValue> {
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<BuiltinFn> {
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<BuiltinFn> {
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<BuiltinFn> {
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,
}
}
+1 -1
View File
@@ -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.
+22 -22
View File
@@ -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}");
+10 -10
View File
@@ -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<std::path::PathBuf>) {
fn rex_files(dir: &std::path::Path, out: &mut Vec<std::path::PathBuf>) {
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<std::path::PathBuf>) {
#[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..];
+19 -19
View File
@@ -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<u8> {
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);
+6 -6
View File
@@ -1,5 +1,5 @@
use dino::ast::*;
use dino::parser::parse;
use rex::ast::*;
use rex::parser::parse;
fn body_of(src: &str) -> Vec<Stmt> {
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}");
}
+17 -17
View File
@@ -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<String, String> {
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..];