chip_lox 0.2.0

(placeholder) mystery, challenges, games, an ide 👁️‍🗨️ 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

chip (chip):
runs byte code, emulates screen, timers, accepts input
  todo: parallelize
  clear separation for
    chip ops
    superchip
    custom just leaving the chip concept behind ops
    is there a way to allow chipLox->chip->rust exports
      or just chipLox->rust
      removing the emulation and using bevy directly.
    for beginners upgrading to their own 'real' projects
      they are sentimental and won't want to lose their 'serious progress'
  bytecode just contains memory data and cpu assuming 0x4 start point
    find format representation for saving memory stack registers counter pointer i delay sound
    use sentinel to indicate end of memory? put non-memory after?
      would these files be incompatible with other emulatorS?
      ensure emulator compatibility
      maybe save state files
      could allow for mutated memory output
      final memory could have a clean compile to output cross-compat memory
  accepts
    binary with chip embedded .clox.exe
    binary repr bytecode .clox.bin (1010110101 (which means 0A A2 F4 F5 B2 1C))
    bytecode (0A A2 F4 F5 B2 1C) .clox.hex
    lox source file (consider ext .clox, not final)
    op/asm source file (consider ext .clox, not final)
    some sort of op code repl?
    some sort of asm repl?
     chip 64, 6502, core wars all versions
     get lang built compile on all of these plus native, then add/replace IR inkject llvm somewhere
  flags:
    cycles (optional N cycles to run then pause)
    verbose (println eery op)
chiplox (chipl | chipc)
generates executables (byte code, binaries, wasm)
  use real words
  repl
  assume no previous knowledge
  domain-specific language
  domain is making pixel games using chip
  standard language provides tools for easier ops
  base language provides minimal functionality
  ideas like
    lox (duh)
    dada
    rust
    lisp
    visual basic
  interesting languages
    logo
    haskell
    smalltalk
    objC/swift
    powershell
    i want to be able to read apl so that i can never look at it again
    what are smt solvers? are those like sudoku?
  for absolute beginners, but could also be more.

chiploxide (chipi | chipo | chipe)
chip game developing environment
  surrounding the empty chipl window,
  click based tool to update keybindings
  click based pixel sprite generation
  live cpu cycle logs
  debugger with pause, run, step in, step over, forward ~N cycles
  base development is completely able to make a chiplox compatible game
  additional libraries for superchip compatible additional ops
  future support for full bevy access, chiplox only ops
  steam
  export exe, linux binary, chip/superChip/loxChip bytecode, wasm w/simple index.html
  import your own lox or rust code, bevy packages
  let beginners play in the basics until they organically discover & outgrow the constraints
blah names whatever
CHIP LOxIDE
CHIPloxIDE
chiploxide


"There's even a cunning trick you can do by placing the address of the previous branch instruction in the most recently emitted branch instruction, creating a linked list of instructions that need to be updated when the label is finally encountered; this allows the label to be referenced in multiple places without requiring any additional storage. But it does require all the emitted code to be in memory at once. You can't write it to disk on-the-fly, for example. Maybe useful for JITs?"

"This question comes up pretty often. I've written a couple of type checkers from toy languages, and I've hacked on a big static analyzer a little. I could be wrong but I believe that part of the reason type checking doesn't get a lot of attention in the literature is that... it actually is pretty easy.

It's obviously more elaborate if you're doing Hindley-Milner style full type inference with unification. But if you're just doing basic static type checking and local type inference, I think the process is essentially:

Walk all of the type declarations so you can find the set of types and their relations.

Walk all of the functions top level variables and constants and calculate their types.

Now walk all of the code bottom up (do a post-order traversal of the AST). When walking a block, keep track of the local variables and their types. When visiting expressions, leaf nodes are either literal expressions with obvious types, or references to variables. When visiting a call node, look up the function being called and type check the call's arguments against the function's parameter signature.

Generics and inference add some—OK a fair amount of—complexity. But a type checker for a first-order type system is about as complex as a pretty printer."


‘To allow both unary and binary minus in a language we may assume that the lexical analyzer translates
them to different operators. '

4. Postjix operator. analogous with a prefix operator.


https://dl.acm.org/doi/10.1145/3446804.3446846

https://www.engr.mun.ca/~theo/Misc/pratt_parsing.htm
And every other pratt parser website on the internet along with dysktra and lr ll blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah



things to and
  bools
  conds
  imports
  draw
  constraints
  types (type parse down, check reverse up)
  make -<numberdata> a neg number not 'unary minus' number
    what is x = --0
  make numbers only cast to string under duress
  if blah then blah else if blah then blah else blah; blah = blah+1++


leftComm[ "=" ] := new Chaining( 10 )
Now let's give "=" some friends

leftComm[ "<" ] := new Chaining( 10 )
leftComm[ "≤" ] := new Chaining( 10 )
leftComm[ ">" ] := new Chaining( 10 )
leftComm[ "≥" ] := new Chaining( 10 )
this is neat, but instead:
new operator(atomicToken)
new operator(atomicToken::Equals, op::LeftRight(10, 9)).chaining(&self)
and then feature flag with operator?

munificent was right, parsers are overrated

http://cs603.cs.ua.edu/lectures/chapter1-intro.pdf
https://github.com/jeanqasaur/learn-programming-languages/blob/master/README.md
https://www.youtube.com/watch?v=Nlqv6NtBXcA&t=1171s
constraint engines???
http://ftp.deas.harvard.edu/techreports/tr-11-05.pdf#toolbar=0

[Function]
1+ number
1- number

(1+ x) is the same as (+ x 1).

(1- x) is the same as (- x 1). Note that the short name may be confusing: (1- x) does not mean 1-x; rather, it means x-1.

Rationale: These are included primarily for compatibility with MacLisp and Lisp Machine Lisp. Some programmers prefer always to write (+ x 1) and (- x 1) instead of (1+ x) and (1- x).
Implementation note: Compiler writers are very strongly encouraged to ensure that (1+ x) and (+ x 1) compile into identical code, and similarly for (1- x) and (- x 1), to avoid pressure on a Lisp programmer to write possibly less clear code for the sake of efficiency. This can easily be done as a source-language transformation.

https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node125.html


start with dcrawford numbers operator


https://rust-unofficial.github.io/patterns/patterns/behavioural/command.html#approach-using-function-pointers


https://rust-unofficial.github.io/patterns/patterns/behavioural/RAII.html#example


hygge a string from structs
kdl parse the string into a struct
obtain the struct with metadata if possible
knuffel derive the kdl structure
parse the struct into rust string, rustc eval as backup