summary refs log tree commit diff stats
path: root/compiler/vmdef.nim
blob: 5395d4bad4d0f9c8a654b8a528b60ee5ac3db0fa (plain) (blame)
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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
#
#
#           The Nim Compiler
#        (c) Copyright 2013 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

## This module contains the type definitions for the new evaluation engine.
## An instruction is 1-3 int32s in memory, it is a register based VM.

import ast, passes, msgs, idents, intsets

const
  byteExcess* = 128 # we use excess-K for immediates
  wordExcess* = 32768

  MaxLoopIterations* = 1500_000 # max iterations of all loops


type
  TRegister* = range[0..255]
  TDest* = range[-1 .. 255]
  TInstr* = distinct uint32

  TOpcode* = enum
    opcEof,         # end of code
    opcRet,         # return
    opcYldYoid,     # yield with no value
    opcYldVal,      # yield with a value

    opcAsgnInt,
    opcAsgnStr,
    opcAsgnFloat,
    opcAsgnRef,
    opcAsgnComplex,
    opcRegToNode,
    opcNodeToReg,

    opcLdArr,  # a = b[c]
    opcWrArr,  # a[b] = c
    opcLdObj,  # a = b.c
    opcWrObj,  # a.b = c
    opcAddrReg,
    opcAddrNode,
    opcLdDeref,
    opcWrDeref,
    opcWrStrIdx,
    opcLdStrIdx, # a = b[c]

    opcAddInt,
    opcAddImmInt,
    opcSubInt,
    opcSubImmInt,
    opcLenSeq,
    opcLenStr,

    opcIncl, opcInclRange, opcExcl, opcCard, opcMulInt, opcDivInt, opcModInt,
    opcAddFloat, opcSubFloat, opcMulFloat, opcDivFloat, opcShrInt, opcShlInt,
    opcBitandInt, opcBitorInt, opcBitxorInt, opcAddu, opcSubu, opcMulu,
    opcDivu, opcModu, opcEqInt, opcLeInt, opcLtInt, opcEqFloat,
    opcLeFloat, opcLtFloat, opcLeu, opcLtu,
    opcEqRef, opcEqNimrodNode, opcSameNodeType,
    opcXor, opcNot, opcUnaryMinusInt, opcUnaryMinusFloat, opcBitnotInt,
    opcEqStr, opcLeStr, opcLtStr, opcEqSet, opcLeSet, opcLtSet,
    opcMulSet, opcPlusSet, opcMinusSet, opcSymdiffSet, opcConcatStr,
    opcContainsSet, opcRepr, opcSetLenStr, opcSetLenSeq,
    opcIsNil, opcOf, opcIs,
    opcSubStr, opcParseFloat, opcConv, opcCast,
    opcQuit, opcReset,
    opcNarrowS, opcNarrowU,

    opcAddStrCh,
    opcAddStrStr,
    opcAddSeqElem,
    opcRangeChck,

    opcNAdd,
    opcNAddMultiple,
    opcNKind,
    opcNIntVal,
    opcNFloatVal,
    opcNSymbol,
    opcNIdent,
    opcNGetType,
    opcNStrVal,

    opcNSetIntVal,
    opcNSetFloatVal, opcNSetSymbol, opcNSetIdent, opcNSetType, opcNSetStrVal,
    opcNNewNimNode, opcNCopyNimNode, opcNCopyNimTree, opcNDel, opcGenSym,

    opcSlurp,
    opcGorge,
    opcParseExprToAst,
    opcParseStmtToAst,
    opcQueryErrorFlag,
    opcNError,
    opcNWarning,
    opcNHint,
    opcNGetLine, opcNGetColumn, opcNGetFile,
    opcEqIdent,
    opcStrToIdent,
    opcIdentToStr,
    opcGetImpl,

    opcEcho,
    opcIndCall, # dest = call regStart, n; where regStart = fn, arg1, ...
    opcIndCallAsgn, # dest = call regStart, n; where regStart = fn, arg1, ...

    opcRaise,
    opcNChild,
    opcNSetChild,
    opcCallSite,
    opcNewStr,

    opcTJmp,  # jump Bx if A != 0
    opcFJmp,  # jump Bx if A == 0
    opcJmp,   # jump Bx
    opcJmpBack, # jump Bx; resulting from a while loop
    opcBranch,  # branch for 'case'
    opcTry,
    opcExcept,
    opcFinally,
    opcFinallyEnd,
    opcNew,
    opcNewSeq,
    opcLdNull,    # dest = nullvalue(types[Bx])
    opcLdNullReg,
    opcLdConst,   # dest = constants[Bx]
    opcAsgnConst, # dest = copy(constants[Bx])
    opcLdGlobal,  # dest = globals[Bx]
    opcLdGlobalAddr, # dest = addr(globals[Bx])

    opcLdImmInt,  # dest = immediate value
    opcNBindSym,
    opcSetType,   # dest.typ = types[Bx]
    opcTypeTrait,
    opcMarshalLoad, opcMarshalStore,
    opcToNarrowInt

  TBlock* = object
    label*: PSym
    fixups*: seq[TPosition]

  TEvalMode* = enum           ## reason for evaluation
    emRepl,                   ## evaluate because in REPL mode
    emConst,                  ## evaluate for 'const' according to spec
    emOptimize,               ## evaluate for optimization purposes (same as
                              ## emConst?)
    emStaticExpr,             ## evaluate for enforced compile time eval
                              ## ('static' context)
    emStaticStmt              ## 'static' as an expression

  TSandboxFlag* = enum        ## what the evaluation engine should allow
    allowCast,                ## allow unsafe language feature: 'cast'
    allowFFI,                 ## allow the FFI
    allowInfiniteLoops        ## allow endless loops
  TSandboxFlags* = set[TSandboxFlag]

  TSlotKind* = enum   # We try to re-use slots in a smart way to
                      # minimize allocations; however the VM supports arbitrary
                      # temporary slot usage. This is required for the parameter
                      # passing implementation.
    slotEmpty,        # slot is unused
    slotFixedVar,     # slot is used for a fixed var/result (requires copy then)
    slotFixedLet,     # slot is used for a fixed param/let
    slotTempUnknown,  # slot but type unknown (argument of proc call)
    slotTempInt,      # some temporary int
    slotTempFloat,    # some temporary float
    slotTempStr,      # some temporary string
    slotTempComplex,  # some complex temporary (s.node field is used)
    slotTempPerm      # slot is temporary but permanent (hack)

  PProc* = ref object
    blocks*: seq[TBlock]    # blocks; temp data structure
    sym*: PSym
    slots*: array[TRegister, tuple[inUse: bool, kind: TSlotKind]]
    maxSlots*: int

  VmArgs* = object
    ra*, rb*, rc*: Natural
    slots*: pointer
    currentException*: PNode
    currentLineInfo*: TLineInfo
  VmCallback* = proc (args: VmArgs) {.closure.}

  PCtx* = ref TCtx
  TCtx* = object of passes.TPassContext # code gen context
    code*: seq[TInstr]
    debug*: seq[TLineInfo]  # line info for every instruction; kept separate
                            # to not slow down interpretation
    globals*: PNode         #
    constants*: PNode       # constant data
    types*: seq[PType]      # some instructions reference types (e.g. 'except')
    currentExceptionA*, currentExceptionB*: PNode
    exceptionInstr*: int # index of instruction that raised the exception
    prc*: PProc
    module*: PSym
    callsite*: PNode
    mode*: TEvalMode
    features*: TSandboxFlags
    traceActive*: bool
    loopIterations*: int
    comesFromHeuristic*: TLineInfo # Heuristic for better macro stack traces
    callbacks*: seq[tuple[key: string, value: VmCallback]]
    errorFlag*: string
    cache*: IdentCache

  TPosition* = distinct int

  PEvalContext* = PCtx

proc newCtx*(module: PSym; cache: IdentCache): PCtx =
  PCtx(code: @[], debug: @[],
    globals: newNode(nkStmtListExpr), constants: newNode(nkStmtList), types: @[],
    prc: PProc(blocks: @[]), module: module, loopIterations: MaxLoopIterations,
    comesFromHeuristic: unknownLineInfo(), callbacks: @[], errorFlag: "",
    cache: cache)

proc refresh*(c: PCtx, module: PSym) =
  c.module = module
  c.prc = PProc(blocks: @[])
  c.loopIterations = MaxLoopIterations

proc registerCallback*(c: PCtx; name: string; callback: VmCallback) =
  c.callbacks.add((name, callback))

const
  firstABxInstr* = opcTJmp
  largeInstrs* = { # instructions which use 2 int32s instead of 1:
    opcSubStr, opcConv, opcCast, opcNewSeq, opcOf,
    opcMarshalLoad, opcMarshalStore}
  slotSomeTemp* = slotTempUnknown
  relativeJumps* = {opcTJmp, opcFJmp, opcJmp, opcJmpBack}

# flag is used to signal opcSeqLen if node is NimNode.
const nimNodeFlag* = 16

template opcode*(x: TInstr): TOpcode = TOpcode(x.uint32 and 0xff'u32)
template regA*(x: TInstr): TRegister = TRegister(x.uint32 shr 8'u32 and 0xff'u32)
template regB*(x: TInstr): TRegister = TRegister(x.uint32 shr 16'u32 and 0xff'u32)
template regC*(x: TInstr): TRegister = TRegister(x.uint32 shr 24'u32)
template regBx*(x: TInstr): int = (x.uint32 shr 16'u32).int

template jmpDiff*(x: TInstr): int = regBx(x) - wordExcess
"nv">offset legal?:boolean <- greater-or-equal row, 0 return-unless legal? legal? <- lesser-than row, height return-unless legal? column:number <- get *screen, cursor-column:offset legal? <- greater-or-equal column, 0 return-unless legal? legal? <- lesser-than column, width return-unless legal? #? $print [print-character (], row, [, ], column, [): ], c, 10/newline # special-case: newline { newline?:boolean <- equal c, 10/newline break-unless newline? { # unless cursor is already at bottom bottom:number <- subtract height, 1 at-bottom?:boolean <- greater-or-equal row, bottom break-if at-bottom? # move it to the next row column <- copy 0 *screen <- put *screen, cursor-column:offset, column row <- add row, 1 *screen <- put *screen, cursor-row:offset, row } return } # save character in fake screen index:number <- multiply row, width index <- add index, column buf:address:array:screen-cell <- get *screen, data:offset len:number <- length *buf # special-case: backspace { backspace?:boolean <- equal c, 8 break-unless backspace? { # unless cursor is already at left margin at-left?:boolean <- lesser-or-equal column, 0 break-if at-left? # clear previous location column <- subtract column, 1 *screen <- put *screen, cursor-column:offset, column index <- subtract index, 1 cursor:screen-cell <- merge 32/space, 7/white *buf <- put-index *buf, index, cursor } return } cursor:screen-cell <- merge c, color *buf <- put-index *buf, index, cursor # increment column unless it's already all the way to the right { right:number <- subtract width, 1 at-right?:boolean <- greater-or-equal column, right break-if at-right? column <- add column, 1 *screen <- put *screen, cursor-column:offset, column } return } # otherwise, real screen print-character-to-display c, color, bg-color ] scenario print-character-at-top-left [ run [ local-scope fake-screen:address:screen <- new-fake-screen 3/width, 2/height a:character <- copy 97/a fake-screen <- print fake-screen, a:character cell:address:array:screen-cell <- get *fake-screen, data:offset 1:array:screen-cell/raw <- copy *cell ] memory-should-contain [ 1 <- 6 # width*height 2 <- 97 # 'a' 3 <- 7 # white # rest of screen is empty 4 <- 0 ] ] scenario print-character-in-color [ run [ local-scope fake-screen:address:screen <- new-fake-screen 3/width, 2/height a:character <- copy 97/a fake-screen <- print fake-screen, a:character, 1/red cell:address:array:screen-cell <- get *fake-screen, data:offset 1:array:screen-cell/raw <- copy *cell ] memory-should-contain [ 1 <- 6 # width*height 2 <- 97 # 'a' 3 <- 1 # red # rest of screen is empty 4 <- 0 ] ] scenario print-backspace-character [ run [ local-scope fake-screen:address:screen <- new-fake-screen 3/width, 2/height a:character <- copy 97/a fake-screen <- print fake-screen, a backspace:character <- copy 8/backspace fake-screen <- print fake-screen, backspace 10:number/raw <- get *fake-screen, cursor-column:offset cell:address:array:screen-cell <- get *fake-screen, data:offset 11:array:screen-cell/raw <- copy *cell ] memory-should-contain [ 10 <- 0 # cursor column 11 <- 6 # width*height 12 <- 32 # space, not 'a' 13 <- 7 # white # rest of screen is empty 14 <- 0 ] ] scenario print-extra-backspace-character [ run [ local-scope fake-screen:address:screen <- new-fake-screen 3/width, 2/height a:character <- copy 97/a fake-screen <- print fake-screen, a backspace:character <- copy 8/backspace fake-screen <- print fake-screen, backspace fake-screen <- print fake-screen, backspace 1:number/raw <- get *fake-screen, cursor-column:offset cell:address:array:screen-cell <- get *fake-screen, data:offset 3:array:screen-cell/raw <- copy *cell ] memory-should-contain [ 1 <- 0 # cursor column 3 <- 6 # width*height 4 <- 32 # space, not 'a' 5 <- 7 # white # rest of screen is empty 6 <- 0 ] ] scenario print-character-at-right-margin [ run [ local-scope fake-screen:address:screen <- new-fake-screen 2/width, 2/height a:character <- copy 97/a fake-screen <- print fake-screen, a b:character <- copy 98/b fake-screen <- print fake-screen, b c:character <- copy 99/c fake-screen <- print fake-screen, c 10:number/raw <- get *fake-screen, cursor-column:offset cell:address:array:screen-cell <- get *fake-screen, data:offset 11:array:screen-cell/raw <- copy *cell ] memory-should-contain [ 10 <- 1 # cursor column 11 <- 4 # width*height 12 <- 97 # 'a' 13 <- 7 # white 14 <- 99 # 'c' over 'b' 15 <- 7 # white # rest of screen is empty 16 <- 0 ] ] scenario print-newline-character [ run [ local-scope fake-screen:address:screen <- new-fake-screen 3/width, 2/height newline:character <- copy 10/newline a:character <- copy 97/a fake-screen <- print fake-screen, a fake-screen <- print fake-screen, newline 10:number/raw <- get *fake-screen, cursor-row:offset 11:number/raw <- get *fake-screen, cursor-column:offset cell:address:array:screen-cell <- get *fake-screen, data:offset 12:array:screen-cell/raw <- copy *cell ] memory-should-contain [ 10 <- 1 # cursor row 11 <- 0 # cursor column 12 <- 6 # width*height 13 <- 97 # 'a' 14 <- 7 # white # rest of screen is empty 15 <- 0 ] ] scenario print-newline-at-bottom-line [ run [ local-scope fake-screen:address:screen <- new-fake-screen 3/width, 2/height newline:character <- copy 10/newline fake-screen <- print fake-screen, newline fake-screen <- print fake-screen, newline fake-screen <- print fake-screen, newline 10:number/raw <- get *fake-screen, cursor-row:offset 11:number/raw <- get *fake-screen, cursor-column:offset ] memory-should-contain [ 10 <- 1 # cursor row 11 <- 0 # cursor column ] ] scenario print-character-at-bottom-right [ run [ local-scope fake-screen:address:screen <- new-fake-screen 2/width, 2/height newline:character <- copy 10/newline fake-screen <- print fake-screen, newline a:character <- copy 97/a fake-screen <- print fake-screen, a b:character <- copy 98/b fake-screen <- print fake-screen, b c:character <- copy 99/c fake-screen <- print fake-screen, c fake-screen <- print fake-screen, newline d:character <- copy 100/d fake-screen <- print fake-screen, d 10:number/raw <- get *fake-screen, cursor-row:offset 11:number/raw <- get *fake-screen, cursor-column:offset cell:address:array:screen-cell <- get *fake-screen, data:offset 20:array:screen-cell/raw <- copy *cell ] memory-should-contain [ 10 <- 1 # cursor row 11 <- 1 # cursor column 20 <- 4 # width*height 21 <- 0 # unused 22 <- 7 # white 23 <- 0 # unused 24 <- 7 # white 25 <- 97 # 'a' 26 <- 7 # white 27 <- 100 # 'd' over 'b' and 'c' and newline 28 <- 7 # white # rest of screen is empty 29 <- 0 ] ] def clear-line screen:address:screen -> screen:address:screen [ local-scope load-ingredients space:character <- copy 0/nul # if x exists, clear line in fake screen { break-unless screen width:number <- get *screen, num-columns:offset column:number <- get *screen, cursor-column:offset original-column:number <- copy column # space over the entire line { right:number <- subtract width, 1 done?:boolean <- greater-or-equal column, right break-if done? print screen, space column <- add column, 1 loop } # now back to where the cursor was *screen <- put *screen, cursor-column:offset, original-column return } # otherwise, real screen clear-line-on-display ] def clear-line-until screen:address:screen, right:number/inclusive -> screen:address:screen [ local-scope load-ingredients _, column:number <- cursor-position screen space:character <- copy 32/space bg-color:number, bg-color-found?:boolean <- next-ingredient { # default bg-color to black break-if bg-color-found? bg-color <- copy 0/black } { done?:boolean <- greater-than column, right break-if done? screen <- print screen, space, 7/white, bg-color # foreground color is mostly unused except if the cursor shows up at this cell column <- add column, 1 loop } ] def cursor-position screen:address:screen -> row:number, column:number [ local-scope load-ingredients # if x exists, lookup cursor in fake screen { break-unless screen row:number <- get *screen, cursor-row:offset column:number <- get *screen, cursor-column:offset return } row, column <- cursor-position-on-display ] def move-cursor screen:address:screen, new-row:number, new-column:number -> screen:address:screen [ local-scope load-ingredients # if x exists, move cursor in fake screen { break-unless screen *screen <- put *screen, cursor-row:offset, new-row *screen <- put *screen, cursor-column:offset, new-column return } # otherwise, real screen move-cursor-on-display new-row, new-column ] scenario clear-line-erases-printed-characters [ run [ local-scope fake-screen:address:screen <- new-fake-screen 3/width, 2/height # print a character a:character <- copy 97/a fake-screen <- print fake-screen, a # move cursor to start of line fake-screen <- move-cursor fake-screen, 0/row, 0/column # clear line fake-screen <- clear-line fake-screen cell:address:array:screen-cell <- get *fake-screen, data:offset 10:array:screen-cell/raw <- copy *cell ] # screen should be blank memory-should-contain [ 10 <- 6 # width*height 11 <- 0 12 <- 7 13 <- 0 14 <- 7 15 <- 0 16 <- 7 17 <- 0 18 <- 7 19 <- 0 20 <- 7 21 <- 0 22 <- 7 ] ] def cursor-down screen:address:screen -> screen:address:screen [ local-scope load-ingredients # if x exists, move cursor in fake screen { break-unless screen { # increment row unless it's already all the way down height:number <- get *screen, num-rows:offset row:number <- get *screen, cursor-row:offset max:number <- subtract height, 1 at-bottom?:boolean <- greater-or-equal row, max break-if at-bottom? row <- add row, 1 *screen <- put *screen, cursor-row:offset, row } return } # otherwise, real screen move-cursor-down-on-display ] def cursor-up screen:address:screen -> screen:address:screen [ local-scope load-ingredients # if x exists, move cursor in fake screen { break-unless screen { # decrement row unless it's already all the way up row:number <- get *screen, cursor-row:offset at-top?:boolean <- lesser-or-equal row, 0 break-if at-top? row <- subtract row, 1 *screen <- put *screen, cursor-row:offset, row } return } # otherwise, real screen move-cursor-up-on-display ] def cursor-right screen:address:screen -> screen:address:screen [ local-scope load-ingredients # if x exists, move cursor in fake screen { break-unless screen { # increment column unless it's already all the way to the right width:number <- get *screen, num-columns:offset column:number <- get *screen, cursor-column:offset max:number <- subtract width, 1 at-bottom?:boolean <- greater-or-equal column, max break-if at-bottom? column <- add column, 1 *screen <- put *screen, cursor-column:offset, column } return } # otherwise, real screen move-cursor-right-on-display ] def cursor-left screen:address:screen -> screen:address:screen [ local-scope load-ingredients # if x exists, move cursor in fake screen { break-unless screen { # decrement column unless it's already all the way to the left column:number <- get *screen, cursor-column:offset at-top?:boolean <- lesser-or-equal column, 0 break-if at-top? column <- subtract column, 1 *screen <- put *screen, cursor-column:offset, column } return } # otherwise, real screen move-cursor-left-on-display ] def cursor-to-start-of-line screen:address:screen -> screen:address:screen [ local-scope load-ingredients row:number <- cursor-position screen column:number <- copy 0 screen <- move-cursor screen, row, column ] def cursor-to-next-line screen:address:screen -> screen:address:screen [ local-scope load-ingredients screen <- cursor-down screen screen <- cursor-to-start-of-line screen ] def move-cursor-to-column screen:address:screen, column:number -> screen:address:screen [ local-scope load-ingredients row:number, _ <- cursor-position screen move-cursor screen, row, column ] def screen-width screen:address:screen -> width:number [ local-scope load-ingredients # if x exists, move cursor in fake screen { break-unless screen width <- get *screen, num-columns:offset return } # otherwise, real screen width <- display-width ] def screen-height screen:address:screen -> height:number [ local-scope load-ingredients # if x exists, move cursor in fake screen { break-unless screen height <- get *screen, num-rows:offset return } # otherwise, real screen height <- display-height ] def hide-cursor screen:address:screen -> screen:address:screen [ local-scope load-ingredients # if x exists (not real display), do nothing { break-unless screen return } # otherwise, real screen hide-cursor-on-display ] def show-cursor screen:address:screen -> screen:address:screen [ local-scope load-ingredients # if x exists (not real display), do nothing { break-unless screen return } # otherwise, real screen show-cursor-on-display ] def hide-screen screen:address:screen -> screen:address:screen [ local-scope load-ingredients # if x exists (not real display), do nothing # todo: help test this { break-unless screen return } # otherwise, real screen hide-display ] def show-screen screen:address:screen -> screen:address:screen [ local-scope load-ingredients # if x exists (not real display), do nothing # todo: help test this { break-unless screen return } # otherwise, real screen show-display ] def print screen:address:screen, s:address:array:character -> screen:address:screen [ local-scope load-ingredients color:number, color-found?:boolean <- next-ingredient { # default color to white break-if color-found? color <- copy 7/white } bg-color:number, bg-color-found?:boolean <- next-ingredient { # default bg-color to black break-if bg-color-found? bg-color <- copy 0/black } len:number <- length *s i:number <- copy 0 { done?:boolean <- greater-or-equal i, len break-if done? c:character <- index *s, i print screen, c, color, bg-color i <- add i, 1 loop } ] scenario print-text-stops-at-right-margin [ run [ local-scope fake-screen:address:screen <- new-fake-screen 3/width, 2/height s:address:array:character <- new [abcd] fake-screen <- print fake-screen, s:address:array:character cell:address:array:screen-cell <- get *fake-screen, data:offset 10:array:screen-cell/raw <- copy *cell ] memory-should-contain [ 10 <- 6 # width*height 11 <- 97 # 'a' 12 <- 7 # white 13 <- 98 # 'b' 14 <- 7 # white 15 <- 100 # 'd' overwrites 'c' 16 <- 7 # white # rest of screen is empty 17 <- 0 ] ] def print-integer screen:address:screen, n:number -> screen:address:screen [ local-scope load-ingredients color:number, color-found?:boolean <- next-ingredient { # default color to white break-if color-found? color <- copy 7/white } bg-color:number, bg-color-found?:boolean <- next-ingredient { # default bg-color to black break-if bg-color-found? bg-color <- copy 0/black } # todo: other bases besides decimal s:address:array:character <- to-text n screen <- print screen, s, color, bg-color ] # for now, we can only print integers def print screen:address:screen, n:number -> screen:address:screen [ local-scope load-ingredients color:number, color-found?:boolean <- next-ingredient { # default color to white break-if color-found? color <- copy 7/white } bg-color:number, bg-color-found?:boolean <- next-ingredient { # default bg-color to black break-if bg-color-found? bg-color <- copy 0/black } screen <- print-integer screen, n, color, bg-color ] # addresses def print screen:address:screen, n:address:_elem -> screen:address:screen [ local-scope load-ingredients color:number, color-found?:boolean <- next-ingredient { # default color to white break-if color-found? color <- copy 7/white } bg-color:number, bg-color-found?:boolean <- next-ingredient { # default bg-color to black break-if bg-color-found? bg-color <- copy 0/black } n2:number <- copy n screen <- print-integer screen, n2, color, bg-color ]