{{
Modified Tiny Basic for use with Propeller Demo Board and Hydra.
Original Tiny Basic written by Tomas Rokicki & Radical Eye Software.

Copyright (c) 2008 Michael Green.  See end of file for terms of use.
}}

'' Note: There are three places in the next 50 lines where there are
''       pairs of lines with one commented out.  One is marked TV
''       and the other is marked VGA.  All three places should have
''       the appropriate line commented out for the display being used.
''       The combination of Hydra and VGA is not supported because the
''       I/O pins used for the SD card and the VGA display conflict.


{{ ---------------------------------------------------------------------------------------------------------

Hive-Computer-Projekt

Name            : FemtoBasic
Chip            : Regnatix-Code 
Version         : 0.1
Dateien         :

Beschreibung    : Modifiziertes FemtoBasic für den Hive. 

Eigenschaften   : 

Logbuch         :

29.04.2009      - erste an ios angepasste version
                - eeprom-zugriff deaktiviert
                
                

Notizen:


 --------------------------------------------------------------------------------------------------------- }}

obj
  ios   : "reg-ios"
  
con

_CLKMODE     = XTAL1 + PLL16X
_XINFREQ     = 5_000_000

   version   = 3                       ' Major version
   release   = 006                     ' Minor release
   testLevel = 0                       ' Test change level
   
'  progsize  = 8192                    ' Space reserved for program
   progsize  = $3FFF
   _stack    = 100                     ' Roughly 4 nested expressions
   _free     = (progsize + 12) / 4

   bspKey    = $C8                     ' PS/2 keyboard backspace key
   breakKey  = $CB                     ' PS/2 keyboard escape key
   backspace = 8
   fReturn   = 13
   fLinefeed = 10
   fEof      = $FF
      
   maxstack  = 20                      ' Maximum stack depth
   linelen   = 256                     ' Maximum input line length
   quote     = 34                      ' Double quote
   caseBit   = !32                     ' Uppercase/Lowercase bit
'  userPtr   = $7FEC                   ' Pointer to program memory
   userPtr   = $4000
   
var
   long sp, tp, eop, nextlineloc, rv, curlineno, pauseTime
   long vars[26], stack[maxstack], control[2]
   long forStep[26], forLimit[26], forLoop[26]
   long ioControl[2]
   word outputs
   byte tline[linelen], tailLine[linelen], inVars[26], fileOpened

dat
   tok0  byte "IF", 0
   tok1  byte "THEN", 0
   tok2  byte "INPUT", 0    ' INPUT {"<prompt>";} <var> {,<var>}
   tok3  byte "PRINT", 0    ' PRINT {USING "<format>";} ...
   tok4  byte "GOTO", 0
   tok5  byte "GOSUB", 0
   tok6  byte "RETURN", 0
   tok7  byte "REM", 0
   tok8  byte "NEW", 0
   tok9  byte "LIST", 0
   tok10 byte "RUN", 0
   tok11 byte "RND", 0
   tok12 byte "OPEN", 0     ' OPEN " <file> ",<mode>
   tok13 byte "READ", 0     ' READ <var> {,<var>}
   tok14 byte "WRITE", 0    ' WRITE {USING "<format>";} ...
   tok15 byte "CLOSE", 0    ' CLOSE
   tok16 byte "DELETE", 0   ' DELETE " <file> "
   tok17 byte "RENAME", 0   ' RENAME " <file> "," <file> "
   tok18 byte "FILES", 0    ' FILES
   tok19 byte "SAVE", 0     ' SAVE or SAVE [<expr>] or SAVE "<file>"
   tok20 byte "LOAD", 0     ' LOAD or LOAD [<expr>] or LOAD "<file>"
   tok21 byte "NOT" ,0      ' NOT <logical>
   tok22 byte "AND" ,0      ' <logical> AND <logical>
   tok23 byte "OR", 0       ' <logical> OR <logical>
   tok24 byte "SHL", 0      ' <expr> SHL <expr>
   tok25 byte "SHR", 0      ' <expr> SHR <expr>
   tok26 byte "FOR", 0      ' FOR <var> = <expr> TO <expr>
   tok27 byte "TO", 0
   tok28 byte "STEP", 0     '  optional STEP <expr>
   tok29 byte "NEXT", 0     ' NEXT <var>
   tok30 byte "INA", 0      ' INA [ <expr> ]
   tok31 byte "OUTA", 0     ' OUTA [ <expr> ] = <expr>
   tok32 byte "PAUSE", 0    ' PAUSE <time ms> {,<time us>}
   tok33 byte "USING", 0    ' PRINT USING "<format>"; ...
   tok34 byte "ROL", 0      ' <expr> ROL <expr>
   tok35 byte "ROR", 0      ' <expr> ROR <expr>
   tok36 byte "SAR", 0      ' <expr> SAR <expr>
   tok37 byte "REV", 0      ' <expr> REV <expr>
   tok38 byte "BYTE", 0     ' BYTE [ <expr> ]
   tok39 byte "WORD", 0     ' WORD [ <expr> ]
   tok40 byte "LONG", 0     ' LONG [ <expr> ]
   tok41 byte "CNT", 0
   tok42 byte "PHSA", 0
   tok43 byte "PHSB", 0
   tok44 byte "FRQA", 0
   tok45 byte "FRQB", 0
   tok46 byte "CTRA", 0
   tok47 byte "CTRB", 0
   tok48 byte "DISPLAY", 0  ' DISPLAY <expr> {,<expr>}
   tok49 byte "KEYCODE", 0  ' KEYCODE
   tok50 byte "LET", 0
   tok51 byte "STOP", 0
   tok52 byte "END", 0
   tok53 byte "EEPROM", 0   ' EEPROM[ <expr> ]
   tok54 byte "FILE", 0     ' FILE
   tok55 byte "MEM", 0      ' MEM
   tok56 byte "SPIN", 0     ' SPIN [<expr>] or SPIN "<file>"
   tok57 byte "COPY", 0     ' COPY [<expr>],"<file>" or COPY "<file>",[<expr>] or
                            ' COPY [<expr>],<expr> where <expr> are different
   tok58 byte "DUMP", 0     ' DUMP <expr>,<expr> or DUMP [<expr>],<expr>

   toks  word @tok0, @tok1, @tok2, @tok3, @tok4, @tok5, @tok6, @tok7
         word @tok8, @tok9, @tok10, @tok11, @tok12, @tok13, @tok14, @tok15
         word @tok16, @tok17, @tok18, @tok19, @tok20, @tok21, @tok22, @tok23
         word @tok24, @tok25, @tok26, @tok27, @tok28, @tok29, @tok30, @tok31
         word @tok32, @tok33, @tok34, @tok35, @tok36, @tok37, @tok38, @tok39
         word @tok40, @tok41, @tok42, @tok43, @tok44, @tok45, @tok46, @tok47
         word @tok48, @tok49, @tok50, @tok51, @tok52, @tok53, @tok54, @tok55
         word @tok56, @tok57, @tok58
   tokx  word

   syn   byte "Syntax Error", 0
   ln    byte "Invalid Line Number", 0

   ver   byte "▶Hive: FemtoBasic • 18-09-2010-dr235",13,0

PUB main | err, s

  ios.start

' code für test im ram, sollte bei bin-datei auskommentiert werden
'  ios.startram

' clear the program space and variables, then read a line and interpret it.
   pauseTime := 0
   outputs := 0
   fileOpened := 0
   long[userPtr] := userPtr - progsize            ' Allocate memory
   waitcnt(clkfreq + cnt)                         ' wozu das?
   ios.screeninit(@ver,1)
   clearall
   s := 0
   curlineno := -1

   repeat
      err := \doline(s)         ' eine kommandozeile verarbeiten
      s := 0
      if err                    ' fehler?
         showError(err)

pri doline(s) | c                 ' Execute the string in s or wait for input
   curlineno := -1

   if ios.keystat > 0             ' Was the "break key" pressed?
      if ios.key == ios#CHAR_ESC  ' escape?
        nextlineloc := eop-2      ' Stop the program

   if nextlineloc < eop-2
      curlineno := wordat(nextlineloc)
      tp := nextlineloc + 2
      nextlineloc := tp + strsize(tp) + 1
      texec
   else
      pauseTime := 0
      outputs := 0
      if s
         bytemove(tp:=@tline,s,strsize(s)+1)
      else
         putlinet(string("OK"))
         getline
      c := spaces
      if "0" =< c and c =< "9"
         insertline
         nextlineloc := eop - 2
      else
         tokenize
         if spaces
            texec

PRI showError(err)
   if curlineno => 0
      ios.print(string("IN LINE "))
      ios.printdec(curlineno)
      ios.printchar(" ")
   if err < 0
      ios.print(string("SD card "))
      ios.printdec(err)
      ios.printnl
   else
      putlinet(err)
   nextlineloc := eop - 2

PRI getline | i, c

   i := 0
   repeat
      c := ios.keywait
      if c == ios#CHAR_BS
         if i > 0
            ios.printctrl(ios#CHAR_TER_BS)
            i--
      elseif c == fReturn
         ios.printchar(c)
         tline[i] := 0
         tp := @tline
         return
      elseif i < linelen-1
         ios.printchar(c)
         tline[i++] := c

pri putlinet(s) | c, ntoks
   ntoks := (@tokx - @toks) / 2
   repeat while c := byte[s++]
      if c => 128
         if (c -= 128) < ntoks
            ios.print(@@toks[c])
            if c <> 7   ' REM
               ios.printchar(" ")
         else
            ios.printchar("{")
            ios.printdec(c)
            ios.printchar("}")
      else
         ios.printchar(c)
   ios.printchar(fReturn)

pri spaces | c
   repeat
      c := byte[tp]
      if c == 0 or c > " "
         return c
      tp++

pri skipspaces
   if byte[tp]
      tp++
   return spaces

pri parseliteral | r, c
   r := 0
   repeat
      c := byte[tp]
      if c < "0" or c > "9"
         return r
      r := r * 10 + c - "0"
      tp++

pri movprog(at, delta)
   if eop + delta + 2 - long[userPtr] > progsize
      abort string("NO MEMORY")
   bytemove(at+delta, at, eop-at)
   eop += delta

pri fixvar(c)
   if c => "a"
      c -= 32
   return c - "A"

pri isvar(c)
   c := fixvar(c)
   return c => 0 and c < 26

pri tokenize | tok, c, at, put, state, i, j, ntoks
   ntoks := (@tokx - @toks) / 2
   at := tp
   put := tp
   state := 0
   repeat while c := byte[at]
      if c == quote
         if state == "Q"
            state := 0
         elseif state == 0
            state := "Q"
      if state == 0
         repeat i from 0 to ntoks-1
            tok := @@toks[i]
            j := 0
            repeat while byte[tok] and ((byte[tok] ^ byte[j+at]) & caseBit) == 0
               j++
               tok++
            if byte[tok] == 0 and not isvar(byte[j+at])
               byte[put++] := 128 + i
               at += j
               if i == 7
                  state := "R"
               else
                  repeat while byte[at] == " "
                     at++
                  state := "F"
               quit
         if state == "F"
            state := 0
         else
            byte[put++] := byte[at++]
      else
         byte[put++] := byte[at++]
   byte[put] := 0

pri wordat(loc)
   return (byte[loc]<<8)+byte[loc+1]

pri findline(lineno) | at
   at := long[userPtr]
   repeat while wordat(at) < lineno
      at += 3 + strsize(at+2)
   return at

pri insertline | lineno, fc, loc, locat, newlen, oldlen
   lineno := parseliteral
   if lineno < 0 or lineno => 65535
      abort @ln
   tokenize
   fc := spaces
   loc := findline(lineno)
   locat := wordat(loc)
   newlen := 3 + strsize(tp)
   if locat == lineno
      oldlen := 3 + strsize(loc+2)
      if fc == 0
         movprog(loc+oldlen, -oldlen)
      else
         movprog(loc+oldlen, newlen-oldlen)
   elseif fc
      movprog(loc, newlen)
   if fc
      byte[loc] := lineno >> 8
      byte[loc+1] := lineno
      bytemove(loc+2, tp, newlen-2)

pri clearvars
   bytefill(@vars, 0, 26)
   pauseTime := 0
   nextlineloc := long[userPtr]
   sp := 0

pri newprog
   byte[long[userPtr]][0] := 255
   byte[long[userPtr]][1] := 255
   byte[long[userPtr]][2] := 0
   eop := long[userPtr] + 2
   nextlineloc := eop - 2
   sp := 0

pri clearall
   newprog
   clearvars

pri pushstack
   if sp => constant(maxstack-1)
      abort string("RECURSION ERROR")
   stack[sp++] := nextlineloc

pri getAddress(delim) | t
   if spaces <> "["
      abort @syn
   skipspaces
   result := expr
   if delim == "." and (result < 0 or result > 31)
      abort string("Invalid pin number")
   if delim == "." or delim == ","
      if spaces == delim
         if delim == "."             ' Handle the form <expr>..<expr>
            if byte[++tp] <> "."
               abort @syn
            result <<= 8
            skipspaces
            t := expr
            if t < 0 or t > 31
               abort string("Invalid pin number")
            result |= t | $10000
         else                        ' Handle the form <expr>,<expr>
            if result & 1 or result < 0 or result > 31
               abort string("Invalid pin number")
            skipspaces
            result := (result << 18) | (expr & $7FFFF)
      elseif delim == ","
         result := (result & $7FFFF)
   if spaces <> "]"
      abort @syn
   tp++

pri factor | tok, t, i
   tok := spaces
   tp++
   case tok
      "(":
         t := expr
         if spaces <> ")"
            abort @syn
         tp++
         return t
      "a".."z","A".."Z":
         return vars[fixvar(tok)]
      158: ' INA [ <expr>{..<expr>} ]
         t := getAddress(".")
         if t > $FFFF
           tok := t & $FF
           t := (t >> 8) & $FF
           repeat i from t to tok
              outputs &= ! |< i
           dira[t..tok]~
           return ina[t..tok]
         else
           outputs &= ! |< t
           dira[t]~
           return ina[t]
      166: ' BYTE [ <expr> ]
         return byte[getAddress(" ")]
      167: ' WORD [ <expr> ]
         return word[getAddress(" ")]
      168: ' LONG [ <expr> ]
         return long[getAddress(" ")]
      181: ' EEPROM [ <expr> ]
           ' code ausgefügt
         return
      182: ' FILE
         return ios.sdgetc
      183: ' MEM
         return progsize - (eop - long[userPtr] )
      169: ' CNT
         return CNT
      170: ' PHSA
         return PHSA
      171: ' PHSB
         return PHSB
      172: ' FRQA
         return FRQA
      173: ' FRQB
         return FRQB
      174: ' CTRA
         return CTRA
      175: ' CTRB
         return CTRB
      177: ' KEYCODE
         return ios.keywait
      139: ' RND <factor>
         return (rv? >> 1) ** (factor << 1)
      "-":
         return - factor
      "!":
         return ! factor
      "$", "%", quote, "0".."9":
         --tp
         return getAnyNumber
      other:
         abort(@syn)

pri shifts | tok, t
   t := factor
   tok := spaces
   if tok == 152 ' SHL
      tp++
      return t << factor
   elseif tok == 153 ' SHR
      tp++
      return t >> factor
   elseif tok == 162 ' ROL
      tp++
      return t <- factor
   elseif tok == 163 ' ROR
      tp++
      return t -> factor
   elseif tok == 164 ' SAR
      tp++
      return t ~> factor
   elseif tok == 165 ' REV
      tp++
      return t >< factor
   else
      return t

pri bitFactor | tok, t
   t := shifts
   repeat
      tok := spaces
      if tok == "&"
         tp++
         t &= shifts
      else
         return t

pri bitTerm | tok, t
   t := bitFactor
   repeat
      tok := spaces
      if tok == "|"
         tp++
         t |= bitFactor
      elseif tok == "^"
         tp++
         t ^= bitFactor
      else
         return t

pri term | tok, t
   t := bitTerm
   repeat
      tok := spaces
     if tok == "*"
        tp++
        t *= bitTerm
     elseif tok == "/"
        if byte[++tp] == "/"
           tp++
           t //= bitTerm
        else
           t / =bitTerm
     else
        return t

pri arithExpr | tok, t
   t := term
   repeat
      tok := spaces
      if tok == "+"
         tp++
         t += term
      elseif tok == "-"
         tp++
         t -= term
      else
         return t

pri compare | op, a, b, c
   a := arithExpr
   op := 0
   spaces
   repeat
      c := byte[tp]
      case c
         "<": op |= 1
              tp++
         ">": op |= 2
              tp++
         "=": op |= 4
              tp++
         other: quit
   case op
      0: return a
      1: return a < arithExpr
      2: return a > arithExpr 
      3: return a <> arithExpr
      4: return a == arithExpr
      5: return a =< arithExpr
      6: return a => arithExpr
      7: abort string("Invalid comparison")

pri logicNot | tok
   tok := spaces
   if tok == 149 ' NOT
      tp++
      return not compare
   return compare

pri logicAnd | t, tok
   t := logicNot
   repeat
      tok := spaces
      if tok == 150 ' AND
         tp++
         t := t and logicNot
      else
         return t

pri expr | tok, t
   t := logicAnd
   repeat
      tok := spaces
      if tok == 151 ' OR
         tp++
         t := t or logicAnd
      else
         return t

pri specialExpr
   if spaces <> "="
      abort @syn
   skipspaces
   return expr

pri scanFilename(f) | c, chars
   chars := 0
   tp++ ' skip past initial quote
   repeat while (c := byte[tp++]) <> quote
      if chars++ < 31
         byte[f++] := c
   byte[f] := 0

pri texec | ht, nt, restart, thisLine, uS, a,b,c,d, f0,f1,f2,f3,f4,f5,f6,f7
   uS := clkfreq / 1_000_000
   thisLine := tp - 2
   restart := 1
   repeat while restart
      restart := 0
      ht := spaces
      if ht == 0
         return
      nt := skipspaces
      if isvar(ht) and nt == "="
         tp++
         vars[fixvar(ht)] := expr
      elseif ht => 128
         case ht
            128: ' THEN
               a := expr
               if spaces <> 129
                  abort string("MISSING THEN")
               skipspaces
               if not a
                  return
               restart := 1
            130: ' INPUT {"<prompt>";} <var> {, <var>}
               if nt == quote
                  c := byte[++tp]
                  repeat while c <> quote and c
                     ios.printchar(c)
                     c := byte[++tp]
                  if c <> quote
                     abort @syn
                  if skipspaces <> ";"
                     abort @syn
                  nt := skipspaces
               if not isvar(nt)
                  abort @syn
               b := 0
               inVars[b++] := fixvar(nt)
               repeat while skipspaces == ","
                  nt := skipspaces
                  if not isvar(nt) or b == 26
                     abort @syn
                  inVars[b++] := fixvar(nt)
               getline
               tokenize
               repeat a from 1 to b
                  vars[inVars[a-1]] := expr
                  if a < b
                     if spaces == ","
                        skipspaces
            131: ' PRINT
               a := 0
               repeat
                  nt := spaces
                  if nt == 0 or nt == ":"
                     quit
                  if nt == quote
                     tp++
                     repeat
                        c := byte[tp++]
                        if c == 0 or c == quote
                           quit
                        ios.printchar(c)
                        a++
                  else
                     d~
                     if (b := expr) < 0
                        -b
                        ios.printchar("-")
                        a++
                     c := 1_000_000_000
                     repeat 10
                        if b => c
                           ios.printchar(b / c + "0")
                           a++
                           b //= c
                           d~~
                        elseif d or c == 1
                           ios.printchar("0")
                           a++
                        c /= 10
                  nt := spaces
                  if nt == ";"
                     tp++
                  elseif nt == ","
                     ios.printchar(" ")
                     a++
                     repeat while a & 7
                        ios.printchar(" ")
                        a++
                     tp++
                  elseif nt == 0 or nt == ":"
                     ios.printchar(fReturn)
                     quit
                  else
                     abort @syn
            132, 133: ' GOTO, GOSUB
               a := expr
               if a < 0 or a => 65535
                  abort @ln
               b := findline(a)
               if wordat(b) <> a
                  abort @ln
               if ht == 133
                  pushstack
               nextlineloc := b 
            134: ' RETURN
               if sp == 0
                  abort string("INVALID RETURN")
               nextlineloc := stack[--sp]
            135: ' REM
               repeat while skipspaces
            136: ' NEW
               clearall
            137: ' LIST {<expr> {,<expr>}}
               b := 0                ' Default line range
               c := 65535
               if spaces <> 0        ' At least one parameter
                  b := c := expr
                  if spaces == ","
                     skipspaces
                     c := expr
               a := long[userPtr]
               repeat while a+2 < eop
                  d := wordat(a)
                  if d => b and d =< c
                     ios.printdec(d)
                     ios.printchar(" ")
                     putlinet(a+2)
                  a += 3 + strsize(a+2)
            138: ' RUN
                  clearvars
            140: ' OPEN " <file> ", R/W/A
               if spaces <> quote
                  abort @syn
               scanFilename(@f0)
               if spaces <> ","
                  abort @syn
               case skipspaces
                  "A", "a": d := "a"
                  "W", "w": d := "w"
                  "R", "r": d := "r"
                  other: abort string("Invalid open file mode")
               tp++
               if ios.sdmount < 0
                  abort string("Can't mount SD card")
               if ios.sdopen(d,@f0)
                  abort string("Can't open file")
               fileOpened := true
            141: ' READ <var> {, <var> }
               if not isvar(nt)
                  abort @syn
               d := 0
               inVars[d++] := fixvar(nt)
               repeat while skipspaces == ","
                  nt := skipspaces
                  if not isvar(nt) or d == 26
                     abort @syn
                  inVars[d++] := fixvar(nt)
               a := 0
               repeat
                  c := ios.sdgetc
                  if c < 0
                     abort string("Can't read file")
                  elseif c == fReturn or c == fEof
                     tline[a] := 0
                     tp := @tline
                     quit
                  elseif c == fLinefeed
                     next
                  elseif a < linelen-1
                     tline[a++] := c
               tokenize
               repeat a from 1 to d
                  vars[inVars[a-1]] := expr
                  if a < d
                     if spaces == ","
                        skipspaces
            142: ' WRITE ...
               d := 0 ' record column
               repeat
                  nt := spaces
                  if nt == 0 or nt == ":"
                     quit
                  if nt == quote
                     tp++
                     repeat
                        c := byte[tp++]
                        if c == 0 or c == quote
                           quit
                        ios.sdputc(c)
                        d++
                  else
                     a := expr
                     if a < 0
                        -a
                        ios.sdputc("-")
                     b := 1_000_000_000
                     c := false
                     repeat 10
                        if a => b
                           ios.sdputc(a / b + "0")
                           a //= b
                           c := true
                        elseif c or b == 1
                           ios.sdputc("0")
                        b /= 10
                  nt := spaces
                  if nt == ";"
                     tp++
                  elseif nt == ","
                     ios.sdputc(" ")
                     d++
                     repeat while d & 7
                        ios.sdputc(" ")
                        d++
                     tp++
                  elseif nt == 0 or nt == ":"
                     ios.sdputc(fReturn)
                     ios.sdputc(fLinefeed)
                     quit
                  else
                     abort @syn
            143: ' CLOSE
               fileOpened := false
               if ios.sdclose < 0
                  abort string("Error closing file")
               ios.sdunmount
            144: ' DELETE " <file> "
               if spaces <> quote
                  abort @syn
               scanFilename(@f0)
               if ios.sdmount < 0
                  abort string("Can't mount SD card")
               if ios.sdopen("d",@f0)
                  abort string("Can't delete file")
               if ios.sdclose < 0
                  abort string("Error deleting file")
               ios.sdunmount
            145: ' RENAME " <file> "," <file> "
               if spaces <> quote
                  abort @syn
               scanFilename(@f0)
               if spaces <> ","
                  abort @syn
               if skipspaces <> quote
                  abort @syn
               scanFilename(@f0)
               abort string("Rename not implemented")
               
            146: ' FILES
               h_dir
               
            147: ' SAVE or SAVE "<filename>"
               if (nt := spaces) == quote
                  scanFilename(@f0)
                  if ios.sdmount < 0
                     abort string("Can't mount SD card")
                  if ios.sdopen("w",@f0)
                     abort string("Can't create file")
                  processSave
                  if ios.sdclose < 0
                     abort string("Error closing file")
                  ios.sdunmount
                 
            148: ' LOAD or LOAD "<filename>"
               if (nt := spaces) == quote
                  scanFilename(@f0)
                  if ios.sdmount < 0
                     abort string("Can't mount SD card")
                  if ios.sdopen("r",@f0)         ' Open requested file
                     abort string("Can't open file")
                  bytemove(@tailLine,tp,strsize(tp)+1)
                  newprog
                  processLoad
                  tp := @tailLine                ' Scan command tail after load
                  if ios.sdclose < 0
                     abort string("Error closing file")
                  ios.sdunmount

            154: ' FOR <var> = <expr> TO <expr> {STEP <expr>}
               ht := spaces
               if ht == 0
                  abort @syn
               nt := skipspaces
               if not isvar(ht) or nt <> "="
                  abort @syn
               a := fixvar(ht)
               skipspaces
               vars[a] := expr
               if spaces <> 155 ' TO             ' Save FOR limit
                  abort @syn
               skipspaces
               forLimit[a] := expr
               if spaces == 156 ' STEP           ' Save step size
                  skipspaces
                  forStep[a] := expr
               else
                  forStep[a] := 1                ' Default step is 1
               if spaces
                  abort @syn
               forLoop[a] := nextlineloc         ' Save address of line
               if forStep[a] < 0                 '  following the FOR
                  b := vars[a] => forLimit[a]
               else                              ' Initially past the limit?
                  b := vars[a] =< forLimit[a]
               if not b                          ' Search for matching NEXT 
                  repeat while nextlineloc < eop-2
                     curlineno := wordat(nextlineloc)
                     tp := nextlineloc + 2
                     nextlineloc := tp + strsize(tp) + 1
                     if spaces == 157            ' NEXT <var>
                        nt := skipspaces         ' Variable has to agree
                        if not isvar(nt)
                           abort @syn
                        if fixvar(nt) == a       ' If match, continue after
                           quit                  '  the matching NEXT
            157: ' NEXT <var>
               nt := spaces
               if not isvar(nt)
                  abort @syn
               a := fixvar(nt)
               vars[a] += forStep[a]             ' Increment or decrement the
               if forStep[a] < 0                 '  FOR variable and check for
                  b := vars[a] => forLimit[a]
               else                              '  the limit value
                  b := vars[a] =< forLimit[a]
               if b                              ' If continuing loop, go to
                  nextlineloc := forLoop[a]      '  statement after FOR
               tp++
            159: ' OUTA [ <expr>{..<expr>} ] = <expr>
               a := getAddress(".")
               if a > $FFFF
                  b := a & $FF
                  a := (a >> 8) & $FF
                  outa[a..b] := specialExpr
                  dira[a..b]~~
                  repeat c from a to b
                     outputs |= |< c
               else
                  outa[a] := specialExpr
                  dira[a]~~
                  outputs |= |< a
            160: ' PAUSE <expr> {,<expr>}
               if pauseTime == 0                 ' If no active pause time, set it
                  spaces                         '  with a minimum time of 50us
                  pauseTime := expr * 1000
                  if spaces == ","               ' First (or only) value is in ms
                     skipspaces
                     pauseTime += expr           ' Second value is in us
                  pauseTime #>= 50
               if pauseTime < 10_050             ' Normally pause at most 10ms at a time,
                  waitcnt(pauseTime * uS + cnt)  '  but, if that would leave < 50us,
                  pauseTime := 0                 '   pause the whole amount now
               else                             
                  a := pauseTime <# 10_000     
                  waitcnt(a * uS + cnt)          ' Otherwise, pause at most 10ms and
                  nextlineloc := thisLine        '  re-execute the PAUSE for the rest
                  pauseTime -= 10_000
            166: ' BYTE [ <expr> ] = <expr>
               a := getAddress(" ")
               byte[a] := specialExpr
            167: ' WORD [ <expr> ] = <expr>
               a := getAddress(" ")
               word[a] := specialExpr
            168: ' LONG [ <expr> ] = <expr>
               a := getAddress(" ")
               long[a] := specialExpr
            170: ' PHSA =
               PHSA := specialExpr
            171: ' PHSB =
               PHSB := specialExpr
            172: ' FRQA =
               FRQA := specialExpr
            173: ' FRQB =
               FRQB := specialExpr
            174: ' CTRA =
               CTRA := specialExpr
            175: ' CTRB =
               CTRB := specialExpr
            176: ' DISPLAY <expr> {,<expr>}
               spaces
               ios.printchar(expr)
               repeat while spaces == ","
                  skipspaces
                  ios.printchar(expr)
            178: ' LET <var> = <expr>
               nt := spaces
               if not isvar(nt)
                  abort @syn
               tp++
               vars[fixvar(nt)] := specialExpr
            179: ' STOP
               nextlineloc := eop-2
               return
            180: ' END
               nextlineloc := eop-2
               return
            181: ' EEPROM [ <expr> ] = <expr>
                 ' code ausgefügt
               ios.print(@msg0)
               
            182: ' FILE = <expr>
               if ios.sdputc(specialExpr) < 0
                  abort string("SDCARD write error")
            184: ' SPIN [{<expr>,}<expr>] or "<file>"
               if spaces == quote
                  scanFilename(@f0)
                  ios.ldbin(@f0)

            185: ' COPY [<expr>],"<file>" or COPY "<file>",[<expr>] or
                 ' COPY [<expr>],[<expr>] where <expr> are different
                 ' code ausgefügt
               ios.print(@msg0)

           186: ' DUMP <expr>,<expr> or DUMP [<expr>],<expr>
               if spaces == "["
                  c := getAddress(",")
                  a := c & $F80000
                  b := c & $07FFFF
               else
                  a := -1
                  b := expr
               if spaces <> ","
                  abort @syn
               skipspaces
               dumpMemory(a,b,expr)
      else                                   
         abort(@syn)
      if spaces == ":"
         restart := 1
         tp++


PRI processLoad : c | a
   repeat
      a := 0
      repeat
         c := ios.sdgetc
         if c == fReturn or c == fEof
            tline[a] := 0
            tp := @tline
            quit
         elseif c == fLinefeed
            next
         elseif c < 0
            quit
         elseif a < linelen-1
            tline[a++] := c
      if ios.sdeof and tline[0] == 0
         quit
      if c < 0
         abort string("Error while loading file")
      tp := @tline
      a := spaces
      if "0" =< a and a =< "9"
         insertline
         nextlineloc := eop - 2
      else
         if a <> 0
            abort string("Missing line number in file")

PRI processSave | a, c, d, ntoks
   ntoks := (@tokx - @toks) / 2
   a := long[userPtr]
   repeat while a+2 < eop
      d := wordat(a)
      ios.sddec(d)
      ios.sdputc(" ")
      d := a + 2
      repeat while c := byte[d++]
         if c => 128
            if (c -= 128) < ntoks
               ios.sdputstr(@@toks[c])
               if c <> 7   ' REM
                  ios.sdputc(" ")
            else
               ios.sdputc("{")
               ios.sddec(c)
               ios.sdputc("}")
         else
            ios.sdputc(c)
      ios.sdputc(fReturn)
      ios.sdputc(fLinefeed)
      a += 3 + strsize(a+2)

PRI getAnyNumber | c, t
   case c := byte[tp]
      quote:
         if result := byte[++tp]
            if byte[++tp] == quote
              tp++
            else
               abort string("missing closing quote")
         else
            abort string("end of line in string")
      "$":
         c := byte[++tp]
         if (t := hexDigit(c)) < 0
            abort string("invalid hex character")
         result := t
         c := byte[++tp]
         repeat until (t := hexDigit(c)) < 0
            result := result << 4 | t
            c := byte[++tp]
      "%":
         c := byte[++tp]
         if not (c == "0" or c == "1")
            abort string("invalid binary character")
         result := c - "0"
         c := byte[++tp]
         repeat while c == "0" or c == "1"
            result := result << 1 | (c - "0")
            c := byte[++tp]
      "0".."9":
         result := c - "0"
         c := byte[++tp]
         repeat while c => "0" and c =< "9"
            result := result * 10 + c - "0"
            c := byte[++tp]
      other:
        abort string("invalid literal value")

PRI hexDigit(c)
'' Convert hexadecimal character to the corresponding value or -1 if invalid.
   if c => "0" and c =< "9"
      return c - "0"
   if c => "A" and c =< "F"
      return c - "A" + 10
   if c => "a" and c =< "f"
      return c - "a" + 10
   return -1

PUB dumpMemory(pin,addr,size) | i, c, p, first, buf0, buf1, buf2
'' This routine dumps a portion of the RAM/ROM to the display (pin == -1).
'' If pin is not -1, it is an EEPROM address in the form required by the
'' I2C routines in i2cSpiInit.  The specified address is or'd with this.
'' The format is 8 bytes wide with hexadecimal and ASCII.
   addr &= $7FFFF
   first := true
   p := addr & $7FFF8
   repeat while p < (addr + size)
      if first
         ios.printhex(addr,5)
         first := false
      else
         ios.printhex(p,5)
      ios.printchar(":")
      repeat i from 0 to 7
         byte[@buf0][i] := " "
         if p => addr and p < (addr + size)
            c := byte[p]
            ios.printhex(c,2)
            if c => " " and c =< "~"
               byte[@buf0][i] := c
         else
            ios.printchar(" ")
            ios.printchar(" ")
         ios.printchar(" ")
         p++
      buf2 := 0
      ios.printchar("|")
      ios.print(@buf0)
      ios.printchar("|")
      ios.printchar(fReturn)

PUB h_dir | stradr,n,wflag,c,i,len,mflag                          'hive: verzeichnis anzeigen
{{h_dir - anzeige verzeichnis}}
  wflag := 1
  mflag := 1
  ios.sdmount                                           'medium mounten
  ios.sddir                                             'kommando: verzeichnis öffnen
  n := 1
  c := 0                                                'spalten
  i := 0                                                'dateizähler
  repeat                                                'wiederhole bis verzeichnisende
    stradr := ios.sdnext                                'einen eintrag holen
    if stradr <> 0                                      'ist eintrag gültig?
      i++
      len := strsize(stradr)
      n++
      ios.print(stradr)
      if wflag == 1
        c++
        ios.printtab
      if (wflag == 0 OR c == 3)
         ios.printnl
         c := 0
      if mflag == 1 AND i == 20
         ios.printnl
         ios.print(@wait1)
         if ios.keywait == "q"
            return
         ios.printnl
         i := 0
  while stradr <> 0                                     'wiederholen solange stradr <> 0
  if wflag == 1
    ios.printnl
  ios.printdec(--n)
  ios.print(string(" Datei(en)"))
  ios.printnl
  ios.sdunmount                                         'medium unmounten

DAT
wait1         byte  "<WEITER? */q:>",0
msg0          byte  "Funktion nicht implementiert!",0


{{
                            TERMS OF USE: MIT License

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
}}