1 # The architecture that seems to be crystallizing: the environment has two
   2 # areas: functions and sandbox.
   3 #
   4 # Rendering the environment requires rendering all areas.
   5 # Displaying the cursor requires displaying cursor for the area controlling the cursor.
   6 # Processing events for the environment requires processing events for the area controlling the cursor.
   7 #
   8 # Areas can have dialogs.
   9 # There can also be global dialogs (currently just one: goto function).
  10 # Areas are responsible for rendering their dialogs.
  11 # In practice this results in dialogs encapsulating the state they need to
  12 # decide whether to render.
  13 #
  14 # This will be useful if we add more areas in the future.
  15 
  16 type environment {
  17   screen: (handle screen)
  18   functions: (handle function)
  19   sandboxes: (handle sandbox)
  20   partial-function-name: (handle word)
  21   # at most one of these will be set
  22   cursor-function: (handle function)
  23   cursor-sandbox: (handle sandbox)
  24   #
  25   nrows: int
  26   ncols: int
  27   code-separator-col: int
  28 }
  29 
  30 fn initialize-environment _env: (addr environment) {
  31   var env/esi: (addr environment) <- copy _env
  32   # initialize some predefined function definitions
  33   var functions/eax: (addr handle function) <- get env, functions
  34   create-primitive-functions functions
  35   # initialize first sandbox
  36   var sandbox-ah/ecx: (addr handle sandbox) <- get env, sandboxes
  37   allocate sandbox-ah
  38   var sandbox/eax: (addr sandbox) <- lookup *sandbox-ah
  39   initialize-sandbox sandbox
  40   # initialize cursor sandbox
  41   var cursor-sandbox-ah/eax: (addr handle sandbox) <- get env, cursor-sandbox
  42   copy-object sandbox-ah, cursor-sandbox-ah
  43   # initialize screen
  44   var screen-ah/eax: (addr handle screen) <- get env, screen
  45   var _screen/eax: (addr screen) <- lookup *screen-ah
  46   var screen/edi: (addr screen) <- copy _screen
  47   var nrows/eax: int <- copy 0
  48   var ncols/ecx: int <- copy 0
  49   nrows, ncols <- screen-size screen
  50   var dest/edx: (addr int) <- get env, nrows
  51   copy-to *dest, nrows
  52   dest <- get env, ncols
  53   copy-to *dest, ncols
  54   var repl-col/ecx: int <- copy ncols
  55   repl-col <- shift-right 1
  56   dest <- get env, code-separator-col
  57   copy-to *dest, repl-col
  58 }
  59 
  60 fn initialize-environment-with-fake-screen _self: (addr environment), nrows: int, ncols: int {
  61   var self/esi: (addr environment) <- copy _self
  62   var screen-ah/eax: (addr handle screen) <- get self, screen
  63   allocate screen-ah
  64   var screen-addr/eax: (addr screen) <- lookup *screen-ah
  65   initialize-screen screen-addr, nrows, ncols
  66   initialize-environment self
  67 }
  68 
  69 #############
  70 # Iterate
  71 #############
  72 
  73 fn process _self: (addr environment), key: grapheme {
  74   var self/esi: (addr environment) <- copy _self
  75   var fn-name-ah/eax: (addr handle word) <- get self, partial-function-name
  76   var fn-name/eax: (addr word) <- lookup *fn-name-ah
  77   compare fn-name, 0
  78   {
  79     break-if-=
  80 #?     print-string 0, "processing goto fn\n"
  81     process-goto-dialog self, key
  82     return
  83   }
  84   var function-ah/eax: (addr handle function) <- get self, cursor-function
  85   var function/eax: (addr function) <- lookup *function-ah
  86   compare function, 0
  87   {
  88     break-if-=
  89 #?     print-string 0, "processing function\n"
  90     process-function self, function, key
  91     return
  92   }
  93   var sandbox-ah/eax: (addr handle sandbox) <- get self, cursor-sandbox
  94   var sandbox/eax: (addr sandbox) <- lookup *sandbox-ah
  95   compare sandbox, 0
  96   {
  97     break-if-=
  98 #?     print-string 0, "processing sandbox\n"
  99     process-sandbox self, sandbox, key
 100     return
 101   }
 102 }
 103 
 104 # collect new name in partial-function-name, and move the cursor to function with that name
 105 fn process-goto-dialog _self: (addr environment), key: grapheme {
 106   var self/esi: (addr environment) <- copy _self
 107   var fn-name-ah/edi: (addr handle word) <- get self, partial-function-name
 108   # if 'esc' pressed, cancel goto
 109   compare key, 0x1b/esc
 110   $process-goto-dialog:cancel: {
 111     break-if-!=
 112     clear-object fn-name-ah
 113     return
 114   }
 115   # if 'enter' pressed, location function and set cursor to it
 116   compare key, 0xa/enter
 117   $process-goto-dialog:commit: {
 118     break-if-!=
 119 #?     print-string 0, "jump\n"
 120     var fn-name/eax: (addr word) <- lookup *fn-name-ah
 121     var functions/ecx: (addr handle function) <- get self, functions
 122     var dest/edx: (addr handle function) <- get self, cursor-function
 123     callee functions, fn-name, dest
 124     # we won't clear cursor-sandbox until we start supporting multiple sandboxes
 125     clear-object fn-name-ah
 126     # there shouldn't be any need to clear state for other dialogs in the sandbox
 127     return
 128   }
 129   #
 130   compare key, 0x7f/del  # backspace on Macs
 131   $process-goto-dialog:backspace: {
 132     break-if-!=
 133     # if not at start, delete grapheme before cursor
 134     var fn-name/eax: (addr word) <- lookup *fn-name-ah
 135     var at-start?/eax: boolean <- cursor-at-start? fn-name
 136     compare at-start?, 0/false
 137     {
 138       break-if-!=
 139       var fn-name/eax: (addr word) <- lookup *fn-name-ah
 140       delete-before-cursor fn-name
 141     }
 142     return
 143   }
 144   # otherwise insert key within current word
 145   var print?/eax: boolean <- real-grapheme? key
 146   $process-goto-dialog:real-grapheme: {
 147     compare print?, 0/false
 148     break-if-=
 149     var fn-name/eax: (addr word) <- lookup *fn-name-ah
 150     add-grapheme-to-word fn-name, key
 151     return
 152   }
 153   # silently ignore other hotkeys
 154 }
 155 
 156 fn process-function _self: (addr environment), _function: (addr function), key: grapheme {
 157   var self/esi: (addr environment) <- copy _self
 158   var function/edi: (addr function) <- copy _function
 159   process-function-edit self, function, key
 160 }
 161 
 162 fn process-function-edit _self: (addr environment), _function: (addr function), key: grapheme {
 163   var self/esi: (addr environment) <- copy _self
 164   var function/edi: (addr function) <- copy _function
 165   var cursor-word-ah/ebx: (addr handle word) <- get function, cursor-word
 166   var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah
 167   var cursor-word/ecx: (addr word) <- copy _cursor-word
 168   compare key, 0x445b1b/left-arrow
 169   $process-function-edit:key-left-arrow: {
 170     break-if-!=
 171 #?     print-string 0, "left-arrow\n"
 172     # if not at start, move left within current word
 173     var at-start?/eax: boolean <- cursor-at-start? cursor-word
 174     compare at-start?, 0/false
 175     {
 176       break-if-!=
 177 #?       print-string 0, "cursor left within word\n"
 178       cursor-left cursor-word
 179       return
 180     }
 181     # otherwise move to end of previous word
 182     var prev-word-ah/edx: (addr handle word) <- get cursor-word, prev
 183     var prev-word/eax: (addr word) <- lookup *prev-word-ah
 184     {
 185       compare prev-word, 0
 186       break-if-=
 187 #?       print-string 0, "move to previous word\n"
 188       cursor-to-end prev-word
 189       copy-object prev-word-ah, cursor-word-ah
 190     }
 191     return
 192   }
 193   compare key, 0x435b1b/right-arrow
 194   $process-function-edit:key-right-arrow: {
 195     break-if-!=
 196     # if not at end, move right within current word
 197     var at-end?/eax: boolean <- cursor-at-end? cursor-word
 198     compare at-end?, 0/false
 199     {
 200       break-if-!=
 201       cursor-right cursor-word
 202       return
 203     }
 204     # otherwise, move to the next word
 205     var next-word-ah/edx: (addr handle word) <- get cursor-word, next
 206     var next-word/eax: (addr word) <- lookup *next-word-ah
 207     {
 208       compare next-word, 0
 209       break-if-=
 210       cursor-to-start next-word
 211       copy-object next-word-ah, cursor-word-ah
 212     }
 213     return
 214   }
 215   # word-based motions
 216   compare key, 2/ctrl-b
 217   $process-function-edit:prev-word: {
 218     break-if-!=
 219     # jump to previous word if possible
 220     var prev-word-ah/edx: (addr handle word) <- get cursor-word, prev
 221     var prev-word/eax: (addr word) <- lookup *prev-word-ah
 222     {
 223       compare prev-word, 0
 224       break-if-=
 225       cursor-to-end prev-word
 226       copy-object prev-word-ah, cursor-word-ah
 227     }
 228     return
 229   }
 230   compare key, 6/ctrl-f
 231   $process-function-edit:next-word: {
 232     break-if-!=
 233     # jump to previous word if possible
 234     var next-word-ah/edx: (addr handle word) <- get cursor-word, next
 235     var next-word/eax: (addr word) <- lookup *next-word-ah
 236     {
 237       compare next-word, 0
 238       break-if-=
 239       cursor-to-end next-word
 240       copy-object next-word-ah, cursor-word-ah
 241     }
 242     return
 243   }
 244   # line-based motions
 245   compare key, 1/ctrl-a
 246   $process-function-edit:start-of-line: {
 247     break-if-!=
 248     # move cursor to start of first word
 249     var body-ah/eax: (addr handle line) <- get function, body
 250     var body/eax: (addr line) <- lookup *body-ah
 251     var body-contents-ah/ecx: (addr handle word) <- get body, data
 252     copy-object body-contents-ah, cursor-word-ah
 253     var body-contents/eax: (addr word) <- lookup *body-contents-ah
 254     cursor-to-start body-contents
 255     return
 256   }
 257   compare key, 5/ctrl-e
 258   $process-function-edit:end-of-line: {
 259     break-if-!=
 260     # move cursor to end of final word
 261     var body-ah/eax: (addr handle line) <- get function, body
 262     var body/eax: (addr line) <- lookup *body-ah
 263     var body-contents-ah/ecx: (addr handle word) <- get body, data
 264     copy-object body-contents-ah, cursor-word-ah
 265     final-word cursor-word-ah, cursor-word-ah
 266     var cursor-word/eax: (addr word) <- lookup *cursor-word-ah
 267     cursor-to-end cursor-word
 268     return
 269   }
 270   # bounce to another function
 271   compare key, 7/ctrl-g
 272   $process-function-edit:goto-function: {
 273     break-if-!=
 274     # initialize dialog to name function to jump to
 275     var partial-function-name-ah/eax: (addr handle word) <- get self, partial-function-name
 276     allocate partial-function-name-ah
 277     var partial-function-name/eax: (addr word) <- lookup *partial-function-name-ah
 278     initialize-word partial-function-name
 279     return
 280   }
 281   # bounce to sandbox
 282   compare key, 9/tab
 283   $process-function-edit:goto-sandbox: {
 284     break-if-!=
 285     var function-ah/eax: (addr handle function) <- get self, cursor-function
 286     clear-object function-ah
 287     return
 288   }
 289   # editing the current function
 290   compare key, 0x7f/del  # backspace on Macs
 291   $process-function-edit:backspace: {
 292     break-if-!=
 293     # if not at start of some word, delete grapheme before cursor within current word
 294     var at-start?/eax: boolean <- cursor-at-start? cursor-word
 295     compare at-start?, 0/false
 296     {
 297       break-if-!=
 298       delete-before-cursor cursor-word
 299       return
 300     }
 301     # otherwise delete current word and move to end of prev word
 302     var prev-word-ah/edx: (addr handle word) <- get cursor-word, prev
 303     var prev-word/eax: (addr word) <- lookup *prev-word-ah
 304     {
 305       compare prev-word, 0
 306       break-if-=
 307       cursor-to-end prev-word
 308       delete-next prev-word
 309       copy-object prev-word-ah, cursor-word-ah
 310     }
 311     return
 312   }
 313   compare key, 0x20/space
 314   $process-function-edit:space: {
 315     break-if-!=
 316 #?     print-string 0, "space\n"
 317     # if cursor is at start of word, insert word before
 318     {
 319       var at-start?/eax: boolean <- cursor-at-start? cursor-word
 320       compare at-start?, 0/false
 321       break-if-=
 322       var prev-word-ah/eax: (addr handle word) <- get cursor-word, prev
 323       append-word prev-word-ah
 324       var new-prev-word-ah/eax: (addr handle word) <- get cursor-word, prev
 325       copy-object new-prev-word-ah, cursor-word-ah
 326       return
 327     }
 328     # if start of word is quote and grapheme before cursor is not, just insert it as usual
 329     # TODO: support string escaping
 330     {
 331       var first-grapheme/eax: grapheme <- first-grapheme cursor-word
 332       compare first-grapheme, 0x22/double-quote
 333       break-if-!=
 334       var final-grapheme/eax: grapheme <- grapheme-before-cursor cursor-word
 335       compare final-grapheme, 0x22/double-quote
 336       break-if-=
 337       break $process-function-edit:space
 338     }
 339     # if start of word is '[' and grapheme before cursor is not ']', just insert it as usual
 340     # TODO: support nested arrays
 341     {
 342       var first-grapheme/eax: grapheme <- first-grapheme cursor-word
 343       compare first-grapheme, 0x5b/[
 344       break-if-!=
 345       var final-grapheme/eax: grapheme <- grapheme-before-cursor cursor-word
 346       compare final-grapheme, 0x5d/]
 347       break-if-=
 348       break $process-function-edit:space
 349     }
 350     # otherwise insert word after and move cursor to it for the next key
 351     # (but we'll continue to track the current cursor-word for the rest of this function)
 352     append-word cursor-word-ah
 353     var next-word-ah/eax: (addr handle word) <- get cursor-word, next
 354     copy-object next-word-ah, cursor-word-ah
 355     # if cursor is at end of word, that's all
 356     var at-end?/eax: boolean <- cursor-at-end? cursor-word
 357     compare at-end?, 0/false
 358     {
 359       break-if-=
 360       return
 361     }
 362     # otherwise we're in the middle of a word
 363     # move everything after cursor to the (just created) next word
 364     var next-word-ah/eax: (addr handle word) <- get cursor-word, next
 365     var _next-word/eax: (addr word) <- lookup *next-word-ah
 366     var next-word/ebx: (addr word) <- copy _next-word
 367     {
 368       var at-end?/eax: boolean <- cursor-at-end? cursor-word
 369       compare at-end?, 0/false
 370       break-if-!=
 371       var g/eax: grapheme <- pop-after-cursor cursor-word
 372       add-grapheme-to-word next-word, g
 373       loop
 374     }
 375     cursor-to-start next-word
 376     return
 377   }
 378   # otherwise insert key within current word
 379   var g/edx: grapheme <- copy key
 380   var print?/eax: boolean <- real-grapheme? key
 381   $process-function-edit:real-grapheme: {
 382     compare print?, 0/false
 383     break-if-=
 384     add-grapheme-to-word cursor-word, g
 385     return
 386   }
 387   # silently ignore other hotkeys
 388 }
 389 
 390 fn process-sandbox _self: (addr environment), _sandbox: (addr sandbox), key: grapheme {
 391   var self/esi: (addr environment) <- copy _self
 392   var sandbox/edi: (addr sandbox) <- copy _sandbox
 393   var rename-word-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-cursor-word
 394   var rename-word-mode?/eax: (addr word) <- lookup *rename-word-mode-ah?
 395   compare rename-word-mode?, 0
 396   {
 397     break-if-=
 398 #?     print-string 0, "processing sandbox rename\n"
 399     process-sandbox-rename sandbox, key
 400     return
 401   }
 402   var define-function-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-function
 403   var define-function-mode?/eax: (addr word) <- lookup *define-function-mode-ah?
 404   compare define-function-mode?, 0
 405   {
 406     break-if-=
 407 #?     print-string 0, "processing function definition\n"
 408     var functions/ecx: (addr handle function) <- get self, functions
 409     process-sandbox-define sandbox, functions, key
 410     return
 411   }
 412 #?   print-string 0, "processing sandbox edit\n"
 413   process-sandbox-edit self, sandbox, key
 414 }
 415 
 416 fn process-sandbox-edit _self: (addr environment), _sandbox: (addr sandbox), key: grapheme {
 417   var self/esi: (addr environment) <- copy _self
 418   var sandbox/edi: (addr sandbox) <- copy _sandbox
 419   var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
 420   var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
 421   var cursor-word-ah/ebx: (addr handle word) <- get cursor-call-path, word
 422   var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah
 423   var cursor-word/ecx: (addr word) <- copy _cursor-word
 424   compare key, 0x445b1b/left-arrow
 425   $process-sandbox-edit:key-left-arrow: {
 426     break-if-!=
 427 #?     print-string 0, "left-arrow\n"
 428     # if not at start, move left within current word
 429     var at-start?/eax: boolean <- cursor-at-start? cursor-word
 430     compare at-start?, 0/false
 431     {
 432       break-if-!=
 433 #?       print-string 0, "cursor left within word\n"
 434       cursor-left cursor-word
 435       return
 436     }
 437     # if current word is expanded, move to the rightmost word in its body
 438     {
 439       var cursor-call-path/esi: (addr handle call-path-element) <- get sandbox, cursor-call-path
 440       var expanded-words/edx: (addr handle call-path) <- get sandbox, expanded-words
 441       var curr-word-is-expanded?/eax: boolean <- find-in-call-paths expanded-words, cursor-call-path
 442       compare curr-word-is-expanded?, 0/false
 443       break-if-=
 444       # update cursor-call-path
 445 #?       print-string 0, "curr word is expanded\n"
 446       var self/ecx: (addr environment) <- copy _self
 447       var functions/ecx: (addr handle function) <- get self, functions
 448       var body: (handle line)
 449       var body-ah/eax: (addr handle line) <- address body
 450       function-body functions, cursor-word-ah, body-ah
 451       var body-addr/eax: (addr line) <- lookup *body-ah
 452       var first-word-ah/edx: (addr handle word) <- get body-addr, data
 453       var final-word-h: (handle word)
 454       var final-word-ah/eax: (addr handle word) <- address final-word-h
 455       final-word first-word-ah, final-word-ah
 456       push-to-call-path-element cursor-call-path, final-word-ah
 457       # move cursor to end of word
 458       var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
 459       var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
 460       var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word
 461       var cursor-word/eax: (addr word) <- lookup *cursor-word-ah
 462       cursor-to-end cursor-word
 463       return
 464     }
 465     # if at first word, look for a caller to jump to
 466     $process-sandbox-edit:key-left-arrow-first-word: {
 467       var prev-word-ah/edx: (addr handle word) <- get cursor-word, prev
 468       var prev-word/eax: (addr word) <- lookup *prev-word-ah
 469       compare prev-word, 0
 470       break-if-!=
 471       $process-sandbox-edit:key-left-arrow-first-word-and-caller: {
 472 #?         print-string 0, "return\n"
 473         {
 474           var cursor-call-path-ah/edi: (addr handle call-path-element) <- get sandbox, cursor-call-path
 475           var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
 476           var next-cursor-element-ah/edx: (addr handle call-path-element) <- get cursor-call-path, next
 477           var next-cursor-element/eax: (addr call-path-element) <- lookup *next-cursor-element-ah
 478           compare next-cursor-element, 0
 479           break-if-= $process-sandbox-edit:key-left-arrow-first-word-and-caller
 480           copy-object next-cursor-element-ah, cursor-call-path-ah
 481         }
 482         var cursor-call-path-ah/eax: (addr handle call-path-element) <- get 
<strong>QUOTES_REGEXP</strong> = &lt;_sre.SRE_Pattern object&gt;<br>
<strong>SPECIAL_CHARS_REGEXP</strong> = &lt;_sre.SRE_Pattern object&gt;<br>
<strong>TITLE_REGEXP</strong> = &lt;_sre.SRE_Pattern object&gt;</td></tr></table>
</body></html>