mirror of
https://github.com/Nexoniarz/Finch.git
synced 2026-11-03 00:44:27 +00:00
Rename the Finch file extension from .fn to .fch
.fn is already used by other tools (e.g. Fennel). Modules are now looked up as name.fch; a leftover name.fn gets a clear message telling you to rename it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Nexoniarz
parent
01c5badc3e
commit
f897fb3140
92 changed files with 160 additions and 144 deletions
|
|
@ -92,11 +92,11 @@ fn main() {
|
|||
}
|
||||
```
|
||||
|
||||
3. Save it in the `Finch` folder as **`hello.fn`**. The `.fn` at the end tells everyone it is a Finch program.
|
||||
3. Save it in the `Finch` folder as **`hello.fch`**. The `.fch` at the end tells everyone it is a Finch program.
|
||||
4. In the Terminal, type:
|
||||
|
||||
```sh
|
||||
./build/finch run hello.fn
|
||||
./build/finch run hello.fch
|
||||
```
|
||||
|
||||
You will see:
|
||||
|
|
@ -652,14 +652,14 @@ fn main() {
|
|||
```
|
||||
|
||||
```
|
||||
hello.fn:3:11: error: there is no variable named 'agee'
|
||||
hello.fch:3:11: error: there is no variable named 'agee'
|
||||
3 | print(agee)
|
||||
| ^
|
||||
```
|
||||
|
||||
How to read it:
|
||||
|
||||
- `hello.fn` is the file,
|
||||
- `hello.fch` is the file,
|
||||
- `3` is the **line** number,
|
||||
- `11` is how far into the line (the **column**),
|
||||
- then the explanation, and the line itself with a `^` pointing at the problem.
|
||||
|
|
@ -816,7 +816,7 @@ fn main() {
|
|||
}
|
||||
```
|
||||
|
||||
`return` inside `main` ends the program. (A version with a random number is in `examples/guess.fn`.)
|
||||
`return` inside `main` ends the program. (A version with a random number is in `examples/guess.fch`.)
|
||||
</details>
|
||||
|
||||
### Project 7: Class average
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ Finch is a single-pass front end in front of LLVM: type checking and IR generati
|
|||
over the AST, with no intermediate representation of its own.
|
||||
|
||||
```
|
||||
main.fn ──► Loader::load() ── lex() ── parse() ──► Program (+ each imported module, recursively)
|
||||
main.fch ──► Loader::load() ── lex() ── parse() ──► Program (+ each imported module, recursively)
|
||||
│
|
||||
all `import "x.h"` ──► importHeaders() (libclang) ──► CImports
|
||||
│
|
||||
|
|
@ -100,7 +100,7 @@ Design decisions that shape the rest:
|
|||
| `src/abi.cpp` | 310 | System V x86-64 classification, C calls with structs by value, C-callable thunks |
|
||||
| `src/main.cpp` | 390 | Driver: CLI, loader, target machine, O2, object emission, runtime cache, linking, link-error advice, `run` |
|
||||
| `runtime/finch_rt.c` | 440 | The runtime library (§12) |
|
||||
| `boot/*.fn` | 3080 | The self-hosted compiler (§17) |
|
||||
| `boot/*.fch` | 3080 | The self-hosted compiler (§17) |
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -198,7 +198,7 @@ All nodes are in `src/ast.h`: small class hierarchies with an explicit `kind`, d
|
|||
| `Member` | `MemberExpr` | `obj`, `field` (`.x`, `.len`, `.ptr`, `.value`) |
|
||||
| `Index` | `IndexExpr` | `obj`, `index` |
|
||||
| `ArrayLit` | `ArrayLitExpr` | `elems` |
|
||||
| `Method` | `MethodExpr` | `obj`, `name`, `args`, `argNames`; also `module.fn(...)` |
|
||||
| `Method` | `MethodExpr` | `obj`, `name`, `args`, `argNames`; also `module.fch(...)` |
|
||||
|
||||
| StmtKind | Node |
|
||||
|---|---|
|
||||
|
|
@ -236,7 +236,7 @@ Equality is structural; two `Struct`s are equal iff they share `info`.
|
|||
|
||||
`Loader::load(path, module, from)` in `main.cpp` reads a file, appends it to `g_files` (positions carry
|
||||
the file index in `Pos::file`), lexes and parses it, then loads each `import name` that wasn't seen yet:
|
||||
`name.fn` next to the importing file, or in a `FINCH_PATH` folder. The result is a `std::vector<Program>`,
|
||||
`name.fch` next to the importing file, or in a `FINCH_PATH` folder. The result is a `std::vector<Program>`,
|
||||
main file first. Cycles are fine: a module is marked loaded before its own imports are followed.
|
||||
|
||||
All files become **one LLVM module**. Each Finch module has a `ModuleScope` (functions, structs, the set
|
||||
|
|
@ -597,7 +597,7 @@ string building (`concat`, `from_int/uint/float/char/bool`, `sub`, `trim`, `uppe
|
|||
### 13.1 Importing headers
|
||||
|
||||
`importHeaders(imports, dirs)` parses each `import "x.h"` as its own translation unit from an in-memory
|
||||
`#include "x.h"`, with `-x c -std=gnu11`, `-I` for every `.fn` file's folder, and `-isystem` for each
|
||||
`#include "x.h"`, with `-x c -std=gnu11`, `-I` for every `.fch` file's folder, and `-isystem` for each
|
||||
directory the system C compiler searches (read from `$CC -E -v -x c /dev/null`, which is what makes it work
|
||||
on NixOS). `gnu11` because glibc hides `M_PI` and friends in strict ISO mode.
|
||||
|
||||
|
|
@ -647,7 +647,7 @@ type and attributes, and rebuilds struct results the same way.
|
|||
struct parameters from registers or `byval` memory, calls the Finch function and lowers its result. Only
|
||||
C-compatible signatures are accepted.
|
||||
|
||||
`tests/run/c_structs.fn` exercises `{float,float}`, `{float,float,float}`, `{u8×4}`, `{double,int}`,
|
||||
`tests/run/c_structs.fch` exercises `{float,float}`, `{float,float,float}`, `{u8×4}`, `{double,int}`,
|
||||
`{i64,i64}`, a 24-byte struct, a struct with a `char[8]`, nested structs, register exhaustion with 13
|
||||
struct arguments, and callbacks taking and returning structs, against a C library compiled with
|
||||
`link "abi.c"`. The results match the same calls made from C.
|
||||
|
|
@ -655,7 +655,7 @@ struct arguments, and callbacks taking and returning structs, against a C librar
|
|||
### 13.4 Linking C code
|
||||
|
||||
`link "name"` tries `pkg-config --libs name`, then `-lname`. `link "file.c"` compiles the file (relative
|
||||
to the `.fn` file) with `$CC -O2 -fPIC -c` into a temporary object; `.o` and `.a` files are passed
|
||||
to the `.fch` file) with `$CC -O2 -fPIC -c` into a temporary object; `.o` and `.a` files are passed
|
||||
through. When linking fails, `linkFailed()` maps undefined symbols back to the header that declared them
|
||||
and prints the `link` line to add.
|
||||
|
||||
|
|
@ -666,7 +666,7 @@ and prints the `link` line to add.
|
|||
- **Target:** `sys::getDefaultTargetTriple()`, CPU `generic`, `Reloc::PIC_`. The data layout is set on the
|
||||
module before any IR is built (alignment of loads/stores depends on it).
|
||||
- **Optimization:** `PassBuilder::buildPerModuleDefaultPipeline(O2)`: clang's `-O2` middle end. `-O0`
|
||||
skips it (`finch ir file.fn -O0` shows `Codegen`'s raw output).
|
||||
skips it (`finch ir file.fch -O0` shows `Codegen`'s raw output).
|
||||
- **Emission:** legacy `PassManager` + `addPassesToEmitFile(ObjectFile)`.
|
||||
- **Linking:** `$CC prog.o rt.o [user objects] -lm [libs]`. On Nix the cc wrapper turns `-L` paths into
|
||||
`RPATH`, so programs run without `LD_LIBRARY_PATH`.
|
||||
|
|
@ -707,11 +707,11 @@ there's an obvious fix, how to fix it. There are no warnings. An LLVM verifier f
|
|||
|
||||
| File | Contents |
|
||||
|---|---|
|
||||
| `boot/lexer.fn` | the lexer (tokens are `{kind, text, line, col, nl}`; kinds are words, keywords and operators are their own kind) |
|
||||
| `boot/ast.fn` | `Type` (`kind`, `elem` as a 0/1-element array, `name`, `module`), one generic `Node` for everything, `Program` |
|
||||
| `boot/parser.fn` | the same grammar and newline rules as the C++ parser, precedence climbing for binary operators |
|
||||
| `boot/gen.fn` | type checker + **textual LLVM IR** generator: scopes, places, coercions, copies, helpers, printing, runtime checks, array/str methods |
|
||||
| `boot/main.fn` | loader for modules and the driver: writes `.ll`, runs `clang -O2 file.ll runtime/finch_rt.c` |
|
||||
| `boot/lexer.fch` | the lexer (tokens are `{kind, text, line, col, nl}`; kinds are words, keywords and operators are their own kind) |
|
||||
| `boot/ast.fch` | `Type` (`kind`, `elem` as a 0/1-element array, `name`, `module`), one generic `Node` for everything, `Program` |
|
||||
| `boot/parser.fch` | the same grammar and newline rules as the C++ parser, precedence climbing for binary operators |
|
||||
| `boot/gen.fch` | type checker + **textual LLVM IR** generator: scopes, places, coercions, copies, helpers, printing, runtime checks, array/str methods |
|
||||
| `boot/main.fch` | loader for modules and the driver: writes `.ll`, runs `clang -O2 file.ll runtime/finch_rt.c` |
|
||||
|
||||
It supports the core language: `int float bool char str`, `[]T`, structs (defaults, named/positional
|
||||
constructors), `ptr[T]`/`addr`/`new`/`free`/`null`, all statements except `defer`, modules, and the
|
||||
|
|
@ -753,9 +753,9 @@ with the expected one. It takes about 2.3 s for the self-hosted compiler to comp
|
|||
|
||||
## 19. Testing
|
||||
|
||||
- `tests/run.sh`: every `tests/run/*.fn` with `fn main` must print exactly its `.out` (stdin from `.in`
|
||||
if present); files without `main` are modules or helpers. Every `tests/fail/*.fn` must fail with the text
|
||||
from its `// expect:` line. Currently **58 passed, 0 failed**.
|
||||
- `tests/run.sh`: every `tests/run/*.fch` with `fn main` must print exactly its `.out` (stdin from `.in`
|
||||
if present); files without `main` are modules or helpers. Every `tests/fail/*.fch` must fail with the text
|
||||
from its `// expect:` line. Currently **59 passed, 0 failed**.
|
||||
- `MEMCHECK=1 tests/run.sh`: the same, plus valgrind on every program (no leaks, no invalid access).
|
||||
- `tests/boot.sh`: the self-hosting fixpoint and the subset run (§17).
|
||||
|
||||
|
|
@ -787,7 +787,7 @@ with the expected one. It takes about 2.3 s for the self-hosted compiler to comp
|
|||
|
||||
| Function | Does |
|
||||
|---|---|
|
||||
| `Loader::load` / `findModule` | read, lex, parse a file and recursively its modules / locate `name.fn` |
|
||||
| `Loader::load` / `findModule` | read, lex, parse a file and recursively its modules / locate `name.fch` |
|
||||
| `hostMachine`, `optimize`, `emitObject` | target machine, O2 pipeline, object file |
|
||||
| `runtimeObject` | compile and cache the runtime |
|
||||
| `capture`, `libFlags`, `link` | run a command / pkg-config or `-l` / the link step, compiling `link "x.c"` files |
|
||||
|
|
@ -858,7 +858,7 @@ with the expected one. It takes about 2.3 s for the self-hosted compiler to comp
|
|||
|
||||
**A built-in function:** add the name to `isBuiltin()`, handle it in `call()`, implement it (in IR, or as
|
||||
a runtime function declared in `rt()`'s table), add `tests/run/` and `tests/fail/` cases. If it should
|
||||
exist in the self-hosted compiler too, add it to `boot/gen.fn`'s `call()` and `runtimeDecls()`.
|
||||
exist in the self-hosted compiler too, add it to `boot/gen.fch`'s `call()` and `runtimeDecls()`.
|
||||
|
||||
**An array or str method:** add a branch in `arrayMethod()` or the str part of `method()`; if it changes
|
||||
the array, add its name to the `changing` sets in `method()` and `mutatesExpr()`, so borrowing stays correct.
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ compiler works inside. For that, see the [guide for engineers](for-engineers.md)
|
|||
|
||||
## 1. What Finch is
|
||||
|
||||
Finch is a **compiled** programming language. The `finch` tool translates your `.fn`
|
||||
Finch is a **compiled** programming language. The `finch` tool translates your `.fch`
|
||||
file into a real program (a native executable, like the ones made from C), using the
|
||||
**LLVM** compiler toolkit, the same backend that powers clang, Rust and Swift.
|
||||
|
||||
|
|
@ -106,9 +106,9 @@ Finch's small runtime library, which is kept in `~/.cache/finch`. Set `CC` to us
|
|||
## 3. The finch command
|
||||
|
||||
```
|
||||
finch run <file.fn> [args...] compile and run right away
|
||||
finch build <file.fn> [-o name] compile into a program (default name: the file's name)
|
||||
finch ir <file.fn> print the LLVM IR (for the curious)
|
||||
finch run <file.fch> [args...] compile and run right away
|
||||
finch build <file.fch> [-o name] compile into a program (default name: the file's name)
|
||||
finch ir <file.fch> print the LLVM IR (for the curious)
|
||||
finch version show the version
|
||||
|
||||
options:
|
||||
|
|
@ -120,10 +120,10 @@ options:
|
|||
Examples:
|
||||
|
||||
```sh
|
||||
finch run hello.fn # prints the output
|
||||
finch run tool.fn input.txt -v # arguments after the file go to the program
|
||||
finch build game.fn -o mygame # creates ./mygame
|
||||
finch build game.fn -g -O0 # a build for the debugger
|
||||
finch run hello.fch # prints the output
|
||||
finch run tool.fch input.txt -v # arguments after the file go to the program
|
||||
finch build game.fch -o mygame # creates ./mygame
|
||||
finch build game.fch -g -O0 # a build for the debugger
|
||||
```
|
||||
|
||||
`finch run` passes on your program's exit code. If the program crashes, it says how
|
||||
|
|
@ -139,7 +139,7 @@ finch build game.fn -g -O0 # a build for the debugger
|
|||
several lines */
|
||||
|
||||
import "math.h" // C headers (optional), at the top
|
||||
import shapes // Finch modules (optional): shapes.fn next to this file
|
||||
import shapes // Finch modules (optional): shapes.fch next to this file
|
||||
link "m" // C libraries or C files to link (optional)
|
||||
|
||||
struct Point { // your own types
|
||||
|
|
@ -502,11 +502,11 @@ Using `.value`, `.field` or `[i]` on a `null` pointer **stops the program** with
|
|||
|
||||
## 16. Modules
|
||||
|
||||
Split a program into files. `import shapes` loads `shapes.fn` from the same folder (or from a
|
||||
Split a program into files. `import shapes` loads `shapes.fch` from the same folder (or from a
|
||||
folder listed in the `FINCH_PATH` environment variable, separated by `:`).
|
||||
|
||||
```c
|
||||
// shapes.fn
|
||||
// shapes.fch
|
||||
struct Box {
|
||||
float w
|
||||
float h
|
||||
|
|
@ -518,7 +518,7 @@ fn area(Box b) -> float {
|
|||
```
|
||||
|
||||
```c
|
||||
// main.fn
|
||||
// main.fch
|
||||
import shapes
|
||||
|
||||
fn main() {
|
||||
|
|
@ -540,7 +540,7 @@ fn main() {
|
|||
```c
|
||||
import "stdio.h"
|
||||
import "GLFW/glfw3.h" // a path inside the system include folders
|
||||
import "mylib.h" // a header next to your .fn file
|
||||
import "mylib.h" // a header next to your .fch file
|
||||
```
|
||||
|
||||
Finch reads the header with **libclang** (clang's C parser) and makes these usable:
|
||||
|
|
@ -554,7 +554,7 @@ Finch reads the header with **libclang** (clang's C parser) and makes these usab
|
|||
|
||||
```c
|
||||
link "glfw" // uses libglfw.so (pkg-config is asked first, if installed)
|
||||
link "helpers.c" // compile and link your own C file (next to the .fn file)
|
||||
link "helpers.c" // compile and link your own C file (next to the .fch file)
|
||||
link "prebuilt.a" // or an object file / static library
|
||||
```
|
||||
|
||||
|
|
@ -617,7 +617,7 @@ Its parameters must be C types (numbers, pointers, C structs).
|
|||
### Compile errors
|
||||
|
||||
```
|
||||
game.fn:12:9: error: 'score' must be int, but this is str
|
||||
game.fch:12:9: error: 'score' must be int, but this is str
|
||||
12 | score = "high"
|
||||
| ^
|
||||
```
|
||||
|
|
@ -643,9 +643,9 @@ Instead of undefined behavior (as in C), Finch stops with a message and exit cod
|
|||
## 19. Debugging
|
||||
|
||||
```sh
|
||||
finch build game.fn -g -O0 -o game
|
||||
finch build game.fch -g -O0 -o game
|
||||
gdb ./game
|
||||
(gdb) break game.fn:12
|
||||
(gdb) break game.fch:12
|
||||
(gdb) run
|
||||
(gdb) bt # where are we, through which functions
|
||||
(gdb) info locals # all variables
|
||||
|
|
@ -665,7 +665,7 @@ visible; without it the optimizer may remove some.
|
|||
| `… come from "x.h", but its library isn't linked` | Add `link "name"` at the top of the file. |
|
||||
| `the library 'x' wasn't found` | Not installed, or a wrong name. On Nix, add it to `shell.nix` and run inside `nix-shell`. |
|
||||
| `the C function 'f' can't be used from Finch yet` | It uses a union, bit fields or another unsupported type by value. Look for a variant that takes pointers. |
|
||||
| `can't find the module 'x'` | Put `x.fn` next to the importing file, or set `FINCH_PATH`. |
|
||||
| `can't find the module 'x'` | Put `x.fch` next to the importing file, or set `FINCH_PATH`. |
|
||||
| `couldn't build the Finch runtime` | No working C compiler. Install gcc or clang, or set `CC`. |
|
||||
| A library is not found when the program starts | It was linked from a folder the system doesn't search. Run inside the same `nix-shell`, or install it system-wide. |
|
||||
| `clang` inside `nix-shell` can't find `stdio.h` | You have an old `shell.nix`: `llvmPackages.clang` must be listed before `llvmPackages.libclang`. |
|
||||
|
|
@ -692,7 +692,7 @@ Finch/
|
|||
```
|
||||
|
||||
```sh
|
||||
tests/run.sh # → 58 passed, 0 failed
|
||||
tests/run.sh # → 59 passed, 0 failed
|
||||
MEMCHECK=1 tests/run.sh # the same under valgrind: no leaks, no bad memory access
|
||||
tests/boot.sh # the self-hosting check (needs clang)
|
||||
```
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ Finch to jednoprzebiegowy front-end przed LLVM: sprawdzanie typów i generowanie
|
|||
po AST, bez własnej reprezentacji pośredniej.
|
||||
|
||||
```
|
||||
main.fn ──► Loader::load() ── lex() ── parse() ──► Program (+ każdy importowany moduł, rekurencyjnie)
|
||||
main.fch ──► Loader::load() ── lex() ── parse() ──► Program (+ każdy importowany moduł, rekurencyjnie)
|
||||
│
|
||||
wszystkie `import "x.h"` ──► importHeaders() (libclang) ──► CImports
|
||||
│
|
||||
|
|
@ -100,7 +100,7 @@ Decyzje, które kształtują resztę:
|
|||
| `src/abi.cpp` | 310 | Klasyfikacja System V x86-64, wywołania C ze strukturami przez wartość, wrappery wywoływalne z C |
|
||||
| `src/main.cpp` | 390 | Sterownik: CLI, ładowanie, maszyna docelowa, O2, emisja, cache runtime'u, linkowanie, porady przy błędach linkera, `run` |
|
||||
| `runtime/finch_rt.c` | 440 | Biblioteka uruchomieniowa (§12) |
|
||||
| `boot/*.fn` | 3080 | Kompilator samohostujący (§17) |
|
||||
| `boot/*.fch` | 3080 | Kompilator samohostujący (§17) |
|
||||
|
||||
---
|
||||
|
||||
|
|
@ -199,7 +199,7 @@ Wszystkie węzły są w `src/ast.h`: małe hierarchie klas z jawnym `kind`, rozg
|
|||
| `Member` | `MemberExpr` | `obj`, `field` (`.x`, `.len`, `.ptr`, `.value`) |
|
||||
| `Index` | `IndexExpr` | `obj`, `index` |
|
||||
| `ArrayLit` | `ArrayLitExpr` | `elems` |
|
||||
| `Method` | `MethodExpr` | `obj`, `name`, `args`, `argNames`; także `modul.fn(...)` |
|
||||
| `Method` | `MethodExpr` | `obj`, `name`, `args`, `argNames`; także `modul.fch(...)` |
|
||||
|
||||
| StmtKind | Węzeł |
|
||||
|---|---|
|
||||
|
|
@ -236,7 +236,7 @@ Równość jest strukturalna; dwa `Struct` są równe, gdy mają to samo `info`.
|
|||
|
||||
`Loader::load(path, module, from)` w `main.cpp` czyta plik, dopisuje go do `g_files` (pozycje niosą
|
||||
indeks pliku w `Pos::file`), leksuje go i parsuje, a potem wczytuje każdy jeszcze niewidziany `import nazwa`:
|
||||
`nazwa.fn` obok importującego pliku albo w folderze z `FINCH_PATH`. Wynik to `std::vector<Program>`,
|
||||
`nazwa.fch` obok importującego pliku albo w folderze z `FINCH_PATH`. Wynik to `std::vector<Program>`,
|
||||
z głównym plikiem na początku. Cykle nie przeszkadzają: moduł jest oznaczany jako wczytany, zanim
|
||||
zaczniemy podążać za jego importami.
|
||||
|
||||
|
|
@ -605,7 +605,7 @@ własność (`copy`, `own`, `drop`, `from_c`), tablice (`reserve`, `make`, `resi
|
|||
### 13.1 Import nagłówków
|
||||
|
||||
`importHeaders(imports, dirs)` parsuje każdy `import "x.h"` jako osobną jednostkę translacji z pliku
|
||||
w pamięci `#include "x.h"`, z `-x c -std=gnu11`, `-I` dla folderu każdego pliku `.fn` i `-isystem` dla
|
||||
w pamięci `#include "x.h"`, z `-x c -std=gnu11`, `-I` dla folderu każdego pliku `.fch` i `-isystem` dla
|
||||
każdego katalogu przeszukiwanego przez systemowy kompilator C (odczytanego z `$CC -E -v -x c /dev/null`,
|
||||
dzięki czemu działa to na NixOS). `gnu11`, bo glibc w trybie ścisłego ISO ukrywa `M_PI` i podobne.
|
||||
|
||||
|
|
@ -657,7 +657,7 @@ i atrybutami, a wyniki-struktury odbudowuje w ten sam sposób.
|
|||
`cThunk(fn)` to odwrotność dla `addr(fn)`: wewnętrzna funkcja z sygnaturą C, która składa parametry-struktury
|
||||
z rejestrów albo pamięci `byval`, woła funkcję Fincha i obniża jej wynik. Akceptowane są tylko sygnatury zgodne z C.
|
||||
|
||||
`tests/run/c_structs.fn` sprawdza `{float,float}`, `{float,float,float}`, `{u8×4}`, `{double,int}`,
|
||||
`tests/run/c_structs.fch` sprawdza `{float,float}`, `{float,float,float}`, `{u8×4}`, `{double,int}`,
|
||||
`{i64,i64}`, strukturę 24-bajtową, strukturę z `char[8]`, zagnieżdżone struktury, wyczerpanie rejestrów
|
||||
przy 13 argumentach-strukturach oraz wywołania zwrotne przyjmujące i zwracające struktury, na bibliotece C
|
||||
kompilowanej przez `link "abi.c"`. Wyniki zgadzają się z tymi samymi wywołaniami zrobionymi z C.
|
||||
|
|
@ -665,7 +665,7 @@ kompilowanej przez `link "abi.c"`. Wyniki zgadzają się z tymi samymi wywołani
|
|||
### 13.4 Linkowanie kodu C
|
||||
|
||||
`link "nazwa"` próbuje `pkg-config --libs nazwa`, a potem `-lnazwa`. `link "plik.c"` kompiluje plik
|
||||
(względem pliku `.fn`) przez `$CC -O2 -fPIC -c` do tymczasowego obiektu; pliki `.o` i `.a` przechodzą
|
||||
(względem pliku `.fch`) przez `$CC -O2 -fPIC -c` do tymczasowego obiektu; pliki `.o` i `.a` przechodzą
|
||||
bez zmian. Gdy linkowanie się nie uda, `linkFailed()` mapuje niezdefiniowane symbole na nagłówek, który
|
||||
je zadeklarował, i wypisuje linijkę `link` do dopisania.
|
||||
|
||||
|
|
@ -676,7 +676,7 @@ je zadeklarował, i wypisuje linijkę `link` do dopisania.
|
|||
- **Cel:** `sys::getDefaultTargetTriple()`, CPU `generic`, `Reloc::PIC_`. Data layout jest ustawiany na
|
||||
module, zanim powstanie jakikolwiek IR (od niego zależy wyrównanie loadów i store'ów).
|
||||
- **Optymalizacja:** `PassBuilder::buildPerModuleDefaultPipeline(O2)`: środkowa część `-O2` z clanga.
|
||||
`-O0` ją pomija (`finch ir plik.fn -O0` pokazuje surowe wyjście `Codegen`).
|
||||
`-O0` ją pomija (`finch ir plik.fch -O0` pokazuje surowe wyjście `Codegen`).
|
||||
- **Emisja:** stary `PassManager` + `addPassesToEmitFile(ObjectFile)`.
|
||||
- **Linkowanie:** `$CC prog.o rt.o [obiekty użytkownika] -lm [biblioteki]`. Na Niksie wrapper cc zamienia
|
||||
ścieżki `-L` na `RPATH`, więc programy działają bez `LD_LIBRARY_PATH`.
|
||||
|
|
@ -717,11 +717,11 @@ wypisuje `internal compiler error (please report)` i kończy proces z kodem 2.
|
|||
|
||||
| Plik | Zawartość |
|
||||
|---|---|
|
||||
| `boot/lexer.fn` | lekser (tokeny to `{kind, text, line, col, nl}`; rodzaje to słowa, a słowa kluczowe i operatory są swoim własnym rodzajem) |
|
||||
| `boot/ast.fn` | `Type` (`kind`, `elem` jako tablica 0/1 elementów, `name`, `module`), jeden ogólny `Node` na wszystko, `Program` |
|
||||
| `boot/parser.fn` | ta sama gramatyka i reguły nowych linii co parser C++, wspinanie się po priorytetach dla operatorów binarnych |
|
||||
| `boot/gen.fn` | sprawdzanie typów + generator **tekstowego LLVM IR**: zasięgi, miejsca, konwersje, kopie, helpery, wypisywanie, kontrole, metody tablic i tekstów |
|
||||
| `boot/main.fn` | ładowanie modułów i sterownik: zapisuje `.ll`, uruchamia `clang -O2 plik.ll runtime/finch_rt.c` |
|
||||
| `boot/lexer.fch` | lekser (tokeny to `{kind, text, line, col, nl}`; rodzaje to słowa, a słowa kluczowe i operatory są swoim własnym rodzajem) |
|
||||
| `boot/ast.fch` | `Type` (`kind`, `elem` jako tablica 0/1 elementów, `name`, `module`), jeden ogólny `Node` na wszystko, `Program` |
|
||||
| `boot/parser.fch` | ta sama gramatyka i reguły nowych linii co parser C++, wspinanie się po priorytetach dla operatorów binarnych |
|
||||
| `boot/gen.fch` | sprawdzanie typów + generator **tekstowego LLVM IR**: zasięgi, miejsca, konwersje, kopie, helpery, wypisywanie, kontrole, metody tablic i tekstów |
|
||||
| `boot/main.fch` | ładowanie modułów i sterownik: zapisuje `.ll`, uruchamia `clang -O2 plik.ll runtime/finch_rt.c` |
|
||||
|
||||
Obsługuje rdzeń języka: `int float bool char str`, `[]T`, struktury (wartości domyślne, konstruktory po
|
||||
nazwie i po kolei), `ptr[T]`/`addr`/`new`/`free`/`null`, wszystkie instrukcje poza `defer`, moduły oraz
|
||||
|
|
@ -763,9 +763,9 @@ wynik z oczekiwanym. Kompilacja samego siebie zajmuje kompilatorowi samohostują
|
|||
|
||||
## 19. Testy
|
||||
|
||||
- `tests/run.sh`: każdy `tests/run/*.fn` z `fn main` musi wypisać dokładnie swój `.out` (stdin z `.in`, jeśli
|
||||
jest); pliki bez `main` to moduły albo pliki pomocnicze. Każdy `tests/fail/*.fn` musi się nie udać z tekstem
|
||||
z linijki `// expect:`. Obecnie **58 passed, 0 failed**.
|
||||
- `tests/run.sh`: każdy `tests/run/*.fch` z `fn main` musi wypisać dokładnie swój `.out` (stdin z `.in`, jeśli
|
||||
jest); pliki bez `main` to moduły albo pliki pomocnicze. Każdy `tests/fail/*.fch` musi się nie udać z tekstem
|
||||
z linijki `// expect:`. Obecnie **59 passed, 0 failed**.
|
||||
- `MEMCHECK=1 tests/run.sh`: to samo plus valgrind na każdym programie (bez wycieków i złych dostępów).
|
||||
- `tests/boot.sh`: punkt stały samohostowania i przebieg na podzbiorze (§17).
|
||||
|
||||
|
|
@ -797,7 +797,7 @@ wynik z oczekiwanym. Kompilacja samego siebie zajmuje kompilatorowi samohostują
|
|||
|
||||
| Funkcja | Robi |
|
||||
|---|---|
|
||||
| `Loader::load` / `findModule` | czyta, leksuje i parsuje plik oraz rekurencyjnie jego moduły / szuka `nazwa.fn` |
|
||||
| `Loader::load` / `findModule` | czyta, leksuje i parsuje plik oraz rekurencyjnie jego moduły / szuka `nazwa.fch` |
|
||||
| `hostMachine`, `optimize`, `emitObject` | maszyna docelowa, potok O2, plik obiektowy |
|
||||
| `runtimeObject` | kompiluje runtime i trzyma go w cache |
|
||||
| `capture`, `libFlags`, `link` | uruchamia polecenie / pkg-config albo `-l` / linkowanie, z kompilacją plików z `link "x.c"` |
|
||||
|
|
@ -868,7 +868,7 @@ wynik z oczekiwanym. Kompilacja samego siebie zajmuje kompilatorowi samohostują
|
|||
|
||||
**Funkcja wbudowana:** dodaj nazwę do `isBuiltin()`, obsłuż ją w `call()`, zaimplementuj (w IR albo jako
|
||||
funkcję runtime'u zadeklarowaną w tabeli `rt()`), dodaj przypadki w `tests/run/` i `tests/fail/`. Jeśli ma
|
||||
istnieć też w kompilatorze samohostującym, dodaj ją do `call()` i `runtimeDecls()` w `boot/gen.fn`.
|
||||
istnieć też w kompilatorze samohostującym, dodaj ją do `call()` i `runtimeDecls()` w `boot/gen.fch`.
|
||||
|
||||
**Metoda tablicy albo tekstu:** dodaj gałąź w `arrayMethod()` albo w części `str` w `method()`; jeśli
|
||||
zmienia tablicę, dopisz jej nazwę do zbiorów `changing` w `method()` i `mutatesExpr()`, żeby pożyczanie
|
||||
|
|
|
|||
|
|
@ -92,11 +92,11 @@ fn main() {
|
|||
}
|
||||
```
|
||||
|
||||
3. Zapisz plik w folderze `Finch` pod nazwą **`czesc.fn`**. Końcówka `.fn` mówi, że to program w Finchu.
|
||||
3. Zapisz plik w folderze `Finch` pod nazwą **`czesc.fch`**. Końcówka `.fch` mówi, że to program w Finchu.
|
||||
4. W Terminalu wpisz:
|
||||
|
||||
```sh
|
||||
./build/finch run czesc.fn
|
||||
./build/finch run czesc.fch
|
||||
```
|
||||
|
||||
Zobaczysz:
|
||||
|
|
@ -659,14 +659,14 @@ fn main() {
|
|||
```
|
||||
|
||||
```
|
||||
czesc.fn:3:11: error: there is no variable named 'wiekk'
|
||||
czesc.fch:3:11: error: there is no variable named 'wiekk'
|
||||
3 | print(wiekk)
|
||||
| ^
|
||||
```
|
||||
|
||||
Jak to czytać:
|
||||
|
||||
- `czesc.fn` to plik,
|
||||
- `czesc.fch` to plik,
|
||||
- `3` to numer **linijki**,
|
||||
- `11` to który znak w linijce (**kolumna**),
|
||||
- potem wyjaśnienie, a pod nim ta linijka ze strzałką `^` wskazującą problem.
|
||||
|
|
@ -823,7 +823,7 @@ fn main() {
|
|||
}
|
||||
```
|
||||
|
||||
`return` w `main` kończy program. (Wersja z losową liczbą jest w `examples/guess.fn`.)
|
||||
`return` w `main` kończy program. (Wersja z losową liczbą jest w `examples/guess.fch`.)
|
||||
</details>
|
||||
|
||||
### Projekt 7: Średnia ocen
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ kompilator działa w środku. Do tego służy [przewodnik dla inżynierów](dla-
|
|||
|
||||
## 1. Czym jest Finch
|
||||
|
||||
Finch to język **kompilowany**. Narzędzie `finch` tłumaczy plik `.fn` na prawdziwy program
|
||||
Finch to język **kompilowany**. Narzędzie `finch` tłumaczy plik `.fch` na prawdziwy program
|
||||
(natywny plik wykonywalny, taki jak te z C). Korzysta przy tym z **LLVM**, tego samego zaplecza
|
||||
kompilatorów, na którym działają clang, Rust i Swift.
|
||||
|
||||
|
|
@ -107,9 +107,9 @@ Inny kompilator wskażesz zmienną `CC`.
|
|||
## 3. Polecenie finch
|
||||
|
||||
```
|
||||
finch run <plik.fn> [argumenty...] skompiluj i od razu uruchom
|
||||
finch build <plik.fn> [-o nazwa] skompiluj do programu (domyślna nazwa: nazwa pliku)
|
||||
finch ir <plik.fn> pokaż LLVM IR (dla ciekawskich)
|
||||
finch run <plik.fch> [argumenty...] skompiluj i od razu uruchom
|
||||
finch build <plik.fch> [-o nazwa] skompiluj do programu (domyślna nazwa: nazwa pliku)
|
||||
finch ir <plik.fch> pokaż LLVM IR (dla ciekawskich)
|
||||
finch version pokaż wersję
|
||||
|
||||
opcje:
|
||||
|
|
@ -121,10 +121,10 @@ opcje:
|
|||
Przykłady:
|
||||
|
||||
```sh
|
||||
finch run hello.fn # wypisuje wynik
|
||||
finch run narzedzie.fn dane.txt -v # argumenty po nazwie pliku trafiają do programu
|
||||
finch build gra.fn -o mojagra # tworzy ./mojagra
|
||||
finch build gra.fn -g -O0 # wersja dla debuggera
|
||||
finch run hello.fch # wypisuje wynik
|
||||
finch run narzedzie.fch dane.txt -v # argumenty po nazwie pliku trafiają do programu
|
||||
finch build gra.fch -o mojagra # tworzy ./mojagra
|
||||
finch build gra.fch -g -O0 # wersja dla debuggera
|
||||
```
|
||||
|
||||
`finch run` przekazuje dalej kod wyjścia programu. Jeśli program się wysypie, powie jak
|
||||
|
|
@ -140,7 +140,7 @@ finch build gra.fn -g -O0 # wersja dla debuggera
|
|||
kilka linijek */
|
||||
|
||||
import "math.h" // nagłówki C (opcjonalne), na górze
|
||||
import ksztalty // moduły Fincha (opcjonalne): ksztalty.fn obok tego pliku
|
||||
import ksztalty // moduły Fincha (opcjonalne): ksztalty.fch obok tego pliku
|
||||
link "m" // biblioteki albo pliki C do dolinkowania (opcjonalne)
|
||||
|
||||
struct Punkt { // własne typy
|
||||
|
|
@ -503,11 +503,11 @@ Użycie `.value`, `.pole` albo `[i]` na wskaźniku `null` **zatrzymuje program**
|
|||
|
||||
## 16. Moduły
|
||||
|
||||
Program możesz podzielić na pliki. `import ksztalty` wczytuje `ksztalty.fn` z tego samego folderu
|
||||
Program możesz podzielić na pliki. `import ksztalty` wczytuje `ksztalty.fch` z tego samego folderu
|
||||
(albo z folderu wymienionego w zmiennej środowiskowej `FINCH_PATH`, rozdzielonych `:`).
|
||||
|
||||
```c
|
||||
// ksztalty.fn
|
||||
// ksztalty.fch
|
||||
struct Pudlo {
|
||||
float w
|
||||
float h
|
||||
|
|
@ -519,7 +519,7 @@ fn pole(Pudlo p) -> float {
|
|||
```
|
||||
|
||||
```c
|
||||
// main.fn
|
||||
// main.fch
|
||||
import ksztalty
|
||||
|
||||
fn main() {
|
||||
|
|
@ -541,7 +541,7 @@ fn main() {
|
|||
```c
|
||||
import "stdio.h"
|
||||
import "GLFW/glfw3.h" // ścieżka w systemowych katalogach nagłówków
|
||||
import "mojalib.h" // nagłówek obok twojego pliku .fn
|
||||
import "mojalib.h" // nagłówek obok twojego pliku .fch
|
||||
```
|
||||
|
||||
Finch czyta nagłówek przez **libclang** (parser C z clanga) i udostępnia:
|
||||
|
|
@ -555,7 +555,7 @@ Finch czyta nagłówek przez **libclang** (parser C z clanga) i udostępnia:
|
|||
|
||||
```c
|
||||
link "glfw" // używa libglfw.so (najpierw pyta pkg-config, jeśli jest)
|
||||
link "pomocnicze.c" // skompiluj i dołącz własny plik C (obok pliku .fn)
|
||||
link "pomocnicze.c" // skompiluj i dołącz własny plik C (obok pliku .fch)
|
||||
link "gotowe.a" // albo plik obiektowy / bibliotekę statyczną
|
||||
```
|
||||
|
||||
|
|
@ -618,7 +618,7 @@ Jej parametry muszą być typami C (liczby, wskaźniki, struktury C).
|
|||
### Błędy kompilacji
|
||||
|
||||
```
|
||||
gra.fn:12:9: error: 'wynik' must be int, but this is str
|
||||
gra.fch:12:9: error: 'wynik' must be int, but this is str
|
||||
12 | wynik = "wysoki"
|
||||
| ^
|
||||
```
|
||||
|
|
@ -645,9 +645,9 @@ Zamiast niezdefiniowanego zachowania (jak w C) Finch zatrzymuje się z komunikat
|
|||
## 19. Debugowanie
|
||||
|
||||
```sh
|
||||
finch build gra.fn -g -O0 -o gra
|
||||
finch build gra.fch -g -O0 -o gra
|
||||
gdb ./gra
|
||||
(gdb) break gra.fn:12
|
||||
(gdb) break gra.fch:12
|
||||
(gdb) run
|
||||
(gdb) bt # gdzie jesteśmy, przez które funkcje
|
||||
(gdb) info locals # wszystkie zmienne
|
||||
|
|
@ -667,7 +667,7 @@ zmienne widoczne; bez niego optymalizator może część z nich usunąć.
|
|||
| `… come from "x.h", but its library isn't linked` | Dopisz `link "nazwa"` na górze pliku. |
|
||||
| `the library 'x' wasn't found` | Nie jest zainstalowana albo nazwa jest zła. Na Niksie dopisz ją do `shell.nix` i pracuj w `nix-shell`. |
|
||||
| `the C function 'f' can't be used from Finch yet` | Używa unii, pól bitowych albo innego nieobsługiwanego typu przez wartość. Poszukaj wariantu ze wskaźnikami. |
|
||||
| `can't find the module 'x'` | Połóż `x.fn` obok importującego pliku albo ustaw `FINCH_PATH`. |
|
||||
| `can't find the module 'x'` | Połóż `x.fch` obok importującego pliku albo ustaw `FINCH_PATH`. |
|
||||
| `couldn't build the Finch runtime` | Brak działającego kompilatora C. Zainstaluj gcc lub clang albo ustaw `CC`. |
|
||||
| Biblioteka nie znajduje się przy starcie programu | Zlinkowano ją z folderu, którego system nie przeszukuje. Uruchamiaj w tym samym `nix-shell` albo zainstaluj ją systemowo. |
|
||||
| `clang` w `nix-shell` nie widzi `stdio.h` | Masz stary `shell.nix`: `llvmPackages.clang` musi być przed `llvmPackages.libclang`. |
|
||||
|
|
@ -694,7 +694,7 @@ Finch/
|
|||
```
|
||||
|
||||
```sh
|
||||
tests/run.sh # → 58 passed, 0 failed
|
||||
tests/run.sh # → 59 passed, 0 failed
|
||||
MEMCHECK=1 tests/run.sh # to samo pod valgrindem: bez wycieków i złych dostępów do pamięci
|
||||
tests/boot.sh # sprawdzenie samohostowania (wymaga clanga)
|
||||
```
|
||||
|
|
|
|||
Loading…
Reference in a new issue