fuzzy spec :)
This commit is contained in:
parent
ed8e20f0db
commit
cbc7bff7f7
|
|
@ -0,0 +1,85 @@
|
|||
# i swear this is what fuzzy actually does
|
||||
|
||||
## the stack
|
||||
|
||||
fuzzy works on a 16-bit cell-width, zero-page data stack indexed with the x register, as documented in Garth Wilson's [stack treatise](https://wilsonminesco.com/stacks/virtualstacks.html)
|
||||
|
||||
to push a byte onto the data stack, we just:
|
||||
|
||||
```asm
|
||||
dex ; decrement the stack pointer
|
||||
lda some_value ; load the byte we want on the stack into a
|
||||
sta 0, x ; put the byte on the stack!
|
||||
```
|
||||
|
||||
and to pop a byte off it:
|
||||
|
||||
```asm
|
||||
lda 0, x ; pop the top of stack off into a
|
||||
inx ; increment the stack pointer
|
||||
```
|
||||
|
||||
## types
|
||||
|
||||
these are used in word definitions, and refer to the type of an individual stack cell:
|
||||
|
||||
| type | desc |
|
||||
| ---------------------- | ----------------------------------------------------------- |
|
||||
| **bool** | a boolean value, represented by $0000 or $ffff |
|
||||
| **nat** | an unsigned 16-bit integer |
|
||||
| **int** | a signed 16-bit integer |
|
||||
| **char** | an 8-bit george-ascii character, padded with leading zeroes |
|
||||
| **string** | a 16-bit pointer to a string in memory |
|
||||
| **word** _`dangerous`_ | a 16-bit pointer to a fuzzy word or quotation |
|
||||
|
||||
## operators
|
||||
|
||||
- `!` NOT: applies NOT to tos
|
||||
- `&` AND: pops 2 off the stack and pushes the AND'ed result
|
||||
- `|` OR: pops 2 off the stack and pushes the OR'ed result
|
||||
- `+` add: pops 2 off the stack and pushes the sum
|
||||
- `-` subtract: pops 2 off the stack and pushes the difference
|
||||
- `*` multiply: pops 2 off the stack and pushes the result, truncating if it's >$FFFF
|
||||
- `/` divide: pops 2 off the stack and pushes the remainder and quotient
|
||||
- `=` equality: pushes true/false if the top 2 stack cells do/don't match
|
||||
- `>` greater than: pushes true/false if tos-1 is/isn't greater than tos
|
||||
- `<` less than: pushes true/false if tos-1 is/isn't greater than tos
|
||||
- `#` quote _`dangerous`_: pops tos and pushes a word that produces its value
|
||||
|
||||
### supported types (this will need to be more clearly laid out later)
|
||||
|
||||
| operator | input type | output type | notes |
|
||||
| -------- | ------------------------ | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `!` | `bool`, `nat`, `int` | `bool`, `nat`, `int` | |
|
||||
| `&` | `bool`, `nat`, `int` | `bool`, `nat`, `int` | |
|
||||
| `\|` | `bool`, `nat`, `int` | `bool`, `nat`, `int` | |
|
||||
| `+` | `nat` `nat`, `int` `int` | `nat`, `int` | |
|
||||
| `-` | `nat` `nat`, `int` `int` | `nat`, `int` | subtracting two `nat`s |
|
||||
| `*` | `nat` `nat`, `int` `int` | `nat`, `int` | most products will be truncated, since most 16 bit multiplications result in a >16 bit product, but in practice that shouldn't matter cause we're not doing science |
|
||||
| `/` | `nat` `nat`, `int` `int` | `nat` `nat`, `int` `int` | produces two cells, the quotient and remainder |
|
||||
| `=` | any any | `bool` | equality/order is checked based on stack cell value, not type (e.g. a `word` pointing to $abcd and a `nat` with the value $abcd are equivalent) |
|
||||
| `>` | any any | `bool` | see above |
|
||||
| `<` | any any | `bool` | see above |
|
||||
| `#` | any | `word` | _`dangerous`_ |
|
||||
|
||||
## `danger!`
|
||||
|
||||
the `danger!` keyword marks a word as being _`dangerous`_. certain language features can only be used in dangerous words, such as:
|
||||
|
||||
- inline assembly
|
||||
- quotations
|
||||
- typechecking quotations is a difficult problem & probably too complex too implement on george if we ever want to fully self-host fuzzy
|
||||
- unchecked operator usage
|
||||
- applying `+` to two chars, applying `&` to two strings, etc
|
||||
- this does not mean that _dangerous_ words are untyped! just the type of the result of an operation is asserted to be the word result type
|
||||
- `danger! dangerous_word num num is char: +` can't be used on a `num char` stack, and any words used after `dangerous_word` treat the top of the stack as having a `char` and don't care that it was made with two `num`s
|
||||
|
||||
the program body cannot use any _dangerous_ features. this makes it so that _dangerous_ behavior is contained to specific words.
|
||||
|
||||
## memory layout
|
||||
|
||||
| start | end | use |
|
||||
| ------ | ------ | ---------------------------- |
|
||||
| `$200` | `$300` | |
|
||||
| | | core language implementation |
|
||||
| | | core language implementation |
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
# fuzzy syntax in a well-defined grammar so i don't lose my mind
|
||||
|
||||
## notation
|
||||
|
||||
| notation | meaning |
|
||||
| -------- | --------------------------------------------- |
|
||||
| abc | syntactical production |
|
||||
| : | maps production to children (products?) |
|
||||
| () | groups items |
|
||||
| ʕ·ᴥ·ʔ | any 8-bit georgesci character |
|
||||
| `abc` | exact character(s) |
|
||||
| \x | an escape character |
|
||||
| x? | optional |
|
||||
| x\* | zero or more of x |
|
||||
| x+ | one or more of x |
|
||||
| x+y | y or more of x |
|
||||
| x.y | y repetitions of x |
|
||||
| \| | one or another |
|
||||
| [-] | any characters in range (>=1 ranges accepted) |
|
||||
|
||||
(adapted from the rust reference cause i like how simple they do it)
|
||||
|
||||
## grammar
|
||||
|
||||
the only semantically significant whitespace is \n+2 after a word definition.
|
||||
|
||||
otherwise, assume tokens are delimited by an arbitrary amount of (not \n+2) whitespace, including no whitespace, e.g. the colon in `hello is: "hello"`
|
||||
|
||||
also order is significant! if `value` produced `word` first, it would make reserved words like `true` and `false` parse into word references.
|
||||
|
||||
```syntax
|
||||
george: defs? body
|
||||
|
||||
defs: (def \n+2)*
|
||||
body: values
|
||||
|
||||
def: signature `:` values
|
||||
signature: `danger!`? word typedef
|
||||
|
||||
values: (value | op)*
|
||||
|
||||
typedef: pop? `is` push? effects?
|
||||
|
||||
pop: type*
|
||||
|
||||
push: type*
|
||||
|
||||
effects: effect*
|
||||
|
||||
type: `bool` | `nat` | `int` | `char` | `string` | `word`
|
||||
|
||||
effect: `paint` | `sing` | `store`
|
||||
|
||||
value: bool | num | char | string | word
|
||||
|
||||
op: `!` | `&` | `|` | `+` | `-` | `*` | `/` | `=` | `>` | `<` | `#`
|
||||
|
||||
quote: `[` values `]`
|
||||
|
||||
bool: `true` | `false`
|
||||
|
||||
word: [a-z A-Z]+
|
||||
|
||||
num: hexnum | binarynum
|
||||
|
||||
binarynum: binarydigit+
|
||||
binarydigit: [0-9]
|
||||
hexnum: (`$` hexdigit+)
|
||||
hexdigit: [0-9 a-f A-F]
|
||||
|
||||
char: `'` ʕ·ᴥ·ʔ `'`
|
||||
|
||||
string: `"` ʕ·ᴥ·ʔ* `"`
|
||||
```
|
||||
|
||||
## notes
|
||||
|
||||
fuzzy assumes the source text to be encoded in [georgesci](#), which is nearly ascii-compatible and should only cause minor headaches <3
|
||||
Loading…
Reference in New Issue