From 9112455cf661a2173edf11ef57e29935a1f4e9a8 Mon Sep 17 00:00:00 2001 From: Cliff Click Date: Sat, 10 May 2025 08:59:31 -0700 Subject: Update README.md --- chapter22/README.md | 90 ++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 75 insertions(+), 15 deletions(-) diff --git a/chapter22/README.md b/chapter22/README.md index c7ff50f6..7482fc70 100644 --- a/chapter22/README.md +++ b/chapter22/README.md @@ -1,8 +1,30 @@ # Chapter 22: A Hello, World! It's high time for strings and printing! In this chapter we look at what it -takes to make a basic string - not really a full fledged String class, that will -wait for another chapter. +takes to make a basic string - not really a full fledged String class, that +will wait for another chapter. + +```java +sys.io.p("Hello, World!"); +``` + +Yeah! A 1-liner `Hello, World`! + +Let's break it down. + +- `sys`: is Just A Variable Name. Like other variables, it is looked up in the + current scope... which looks completely empty. Every Simple program now starts + with the `sys` variable in-scope. `sys` itself a normal `struct` + and is defined in `src/main/java/com/seaofnodes/simple/sys/sys.smp`. +- `sys.io.p`: lookup the `io` field in `sys` struct, which yields the `sys.io` + struct; then a lookup of `p` (short for "print") in the `sys.io` struct. + This returns a function. +- `p("Hello, World!")`: call the function just loaded from the `p` field, with + `"Hello, World!"` as a string argument. +- `"Hello, World!"`: New syntax that yields a constant array of `u8` (chars). + The array is otherwise a normal range-checked array, with a leading `#` + length field. The array backing data eventually ends up in the *constant + pool*, and from there in an ELF file's RODATA section. You can also read [this chapter](https://github.com/SeaOfNodes/Simple/tree/linear-chapter21) in a linear Git revision history on the [linear](https://github.com/SeaOfNodes/Simple/tree/linear) branch and [compare](https://github.com/SeaOfNodes/Simple/compare/linear-chapter20...linear-chapter21) it to the previous chapter. @@ -26,12 +48,16 @@ struct Outer { Any final field set in the declaration (as opposed to the constructor) is automatically a "static" field - it is final for all instances, and does not need to be stored in each instances. Instead one copy is kept in a global -space (not really a *class* object yet) and loaded from there. +space (not really a *class* object yet) and loaded from there. In this example: -- Instances of the `Outer` class have a single `int` field `out`. -- Instances of the `Inner` class have a single `int` field `in`. -- There exists a `Outer.Inner.pi` field in a global space, with value `3.14`. +- Instances of the `Outer` struct have a single `int` field `out`. +- Instances of the `Inner` struct have a single `int` field `in`. +- There exists a `Outer.Inner.pi` field in a global space with value `3.14`. + +The `sys` struct is another example, with nested `libc` and `io` structs at +least. All the fields in these structs are all final, hence static. + ## FFI and I/O Calls @@ -52,9 +78,9 @@ name `write` has to be unique when linking. ## Auto-Import and the "sys." namespace -The `sys` import will eventually include libc bindings, and any default library -code including printing support, and probably collections. As of this chapter -it includes minimal libc bindings and an easy print: +The `sys` struct includes `libc` bindings, and any default library code +including e.g. printing support and collections. As of this chapter it +includes minimal libc bindings and an easy print: ```java // top-level default import @@ -97,16 +123,17 @@ You can now cast a pointer to an i64, although not the other way around. For arrays, this cast is to the array *base* skipping the `#` length field, and is suitable for passing to external "C" calls. For structs, this is just the -struct base. +struct base. This is used to pass a length-checked Simple array to the libc +`write` call in the above `sys.io.p` function. ## Arrays of Constants and Constant Arrays The Simple type system now supports the notion of a "constant array" - an array of fixed constants, stored in the ELF file in the RODATA section. Currently we -only support strings at the parser level: "Hello, World!" makes a `u8[13]` +only support strings at the parser level: `"Hello, World!"` makes a `u8[13]` array containing 13 ASCII bytes; like all arrays it has a length and will be -range-checked in the future. +range-checked at some point. A constant version of a non-constant array can be assigned using the `u8[~]` syntax. @@ -119,10 +146,10 @@ i32[] is = new i32[N]; for( int i=0; i +val sum = { i32[~] nums -> // Notice the [~] signature marking nums as immutable int sum = 0; - for( int i=0; i