{{
┌──────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ Autor: Ingo Kripahle                                                                                 │
│ Copyright (c) 2010 Ingo Kripahle                                                                     │
│ See end of file for terms of use.                                                                    │
│ Die Nutzungsbedingungen befinden sich am Ende der Datei                                              │
└──────────────────────────────────────────────────────────────────────────────────────────────────────┘

Informationen   : hive-project.de
Kontakt         : drohne235@googlemail.com
System          : TriOS
Name            : eram-tool
Chip            : Regnatix
Typ             : Programm
Version         :
Subversion      :

Logbuch         :

Kommandoliste:

Notizen:



}}

OBJ
        num: "glob-numbers"
        ios: "reg-ios"
        
CON

_CLKMODE     = XTAL1 + PLL16X
_XINFREQ     = 5_000_000

OS_TIBLEN       = 64                                    'gr??e des inputbuffers
ERAM            = 1024 * 512 * 2                        'gr??e eram
HRAM            = 1024 * 32                             'gr??e hram

RMON_ZEILEN     = 16                                    'speichermonitor - angezeigte zeilen
RMON_BYTES      = 8                                     'speichermonitor - zeichen pro byte

VAR
'systemvariablen
  byte  tib[OS_TIBLEN]          'tastatur-input-buffer
  byte  cmdstr[OS_TIBLEN]       'kommandostring f?r interpreter
  byte  token1[OS_TIBLEN]       'parameterstring 1 für interpreter
  byte  token2[OS_TIBLEN]       'parameterstring 2 für interpreter
  byte  tibpos                  'aktuelle position im tib
  long  ppos                    'puffer für adresse
  long  pcnt                    'puffer für zeilenzahl

PUB main | wflag

  ios.start                                             'ios initialisieren
'  ios.startram
  ios.printnl
  repeat
    os_cmdinput                                         'kommandoeingabe
    os_cmdint                                           'kommandozeileninterpreter
  
PUB os_cmdinput | charc                                 'sys: stringeingabe eine zeile
''funktionsgruppe               : sys
''funktion                      : stringeingabe eine zeile
''eingabe                       : -
''ausgabe                       : -
''variablen                     : tib     - eingabepuffer zur string
''                              : tibpos  - aktuelle position im tib

  ios.print(@prompt2)
  tibpos := 0                                           'tibposition auf anfang setzen
  repeat until (charc := ios.keywait) == $0D            'tasten einlesen bis return
    if (tibpos + 1) < OS_TIBLEN                         'zeile noch nicht zu lang?
      case charc
        ios#CHAR_BS:                                    'backspace
          if tibpos > 0                                 'noch nicht anfang der zeile erreeicht?
            tib[tibpos--] := 0                          'ein zeichen aus puffer entfernen
            ios.printbs                                 'steuerzeichen an terminal senden
        other:                                          'zeicheneingabe
          tib[tibpos++] := charc                        'zeichen speichern
          ios.printchar(charc)                          'zeichen ausgeben
  ios.printnl
  tib[tibpos] := 0                                      'string abschließen
  tibpos := charc := 0                                  'werte rücksetzen

PUB os_nxtoken1: stradr                                 'sys: token 1 von tib einlesen
''funktionsgruppe               : sys
''funktion                      : nächsten token im eingabestring suchen und stringzeiger übergeben
''eingabe                       : -
''ausgabe                       : stradr  - adresse auf einen string mit dem gefundenen token
''variablen                     : tib     - eingabepuffer zur string
''                              : tibpos  - aktuelle position im tib
''                              : token   - tokenstring

  stradr := os_tokenize(@token1)

PUB os_nxtoken2: stradr                                 'sys: token 2 von tib einlesen
''funktionsgruppe               : sys
''funktion                      : nächsten token im eingabestring suchen und stringzeiger übergeben
''eingabe                       : -
''ausgabe                       : stradr  - adresse auf einen string mit dem gefundenen token
''variablen                     : tib     - eingabepuffer zur string
''                              : tibpos  - aktuelle position im tib
''                              : token   - tokenstring

  stradr := os_tokenize(@token2)

PUB os_tokenize(token):stradr | i                       'sys: liest nächsten token aus tib

  i := 0
  if tib[tibpos] <> 0                                   'abbruch bei leerem string
    repeat until tib[tibpos] > ios#CHAR_SPACE           'führende leerzeichen ausbenden
      tibpos++
    repeat until (tib[tibpos] == ios#CHAR_SPACE) or (tib[tibpos] == 0) 'wiederholen bis leerzeichen oder stringende
      byte[token][i] := tib[tibpos]
      tibpos++
      i++
  else
    token := 0
  byte[token][i] := 0
  stradr := token

PUB os_nextpos: tibpos2                                 'sys: setzt zeiger auf nächste position
''funktionsgruppe               : sys
''funktion                      : tibpos auf nächstes token setzen
''eingabe                       : -
''ausgabe                       : tibpos2 - position des nächsten tokens in tib
''variablen                     : tib     - eingabepuffer zur string
''                              : tibpos  - aktuelle position im tib

  if tib[tibpos] <> 0
    repeat until tib[tibpos] > ios#CHAR_SPACE               'führende leerzeichen ausbenden
      tibpos++
  return tibpos

PUB os_cmdint                                           'sys: kommandointerpreter
''funktionsgruppe               : sys
''funktion                      : kommandointerpreter; zeichenkette ab tibpos wird als kommando interpretiert
''                              : tibpos wird auf position hinter token gesetzt
''eingabe                       : -
''ausgabe                       : -
''variablen                     : tib     - eingabepuffer zur string
''                              : tibpos  - aktuelle position im tib

  repeat                                                'kommandostring kopieren
    cmdstr[tibpos] := tib[tibpos]
    tibpos++
  until (tib[tibpos] == ios#CHAR_SPACE) or (tib[tibpos] == 0) 'wiederholen bis leerzeichen oder stringende
  cmdstr[tibpos] := 0                                   'kommandostring abschließen
  os_cmdexec(@cmdstr)                                   'interpreter aufrufen
  tibpos := 0                                           'tastaturpuffer zurücksetzen
  tib[0] := 0

PUB os_cmdexec(stradr)                                  'sys: kommando im ?bergebenen string wird als kommando interpretiert
{{os_smdexec - das kommando im ?bergebenen string wird als kommando interpretiert
  stradr: adresse einer stringvariable die ein kommando enth?lt}}
  if strcomp(stradr,string("help"))                     'help
    ios.print(string("help: man eram"))
  elseif strcomp(stradr,string("d"))                    'd display - speicheranzeige
    ram_disp
  elseif strcomp(stradr,string("dl"))                   'd display long - speicheranzeige
    ram_displong
  elseif strcomp(stradr,string("n"))                    'n next - anzeige fortsetzen
    ram_next
  elseif strcomp(stradr,string("m"))                    'm modify - speicher modifizieren
    ram_mod
  elseif strcomp(stradr,string("l"))                    'l modify - long
    ram_lmod
  elseif strcomp(stradr,string("info"))
    ram_info
  elseif strcomp(stradr,string("f"))
    ram_fill
  elseif strcomp(stradr,string("fu"))                   'fill im userbereich
    ram_fillusr
  elseif strcomp(stradr,string("rbas"))
    ram_setrbas
  elseif strcomp(stradr,string("sysvar"))
    ram_sysvar
  elseif strcomp(stradr,string("load"))                 'load -
    ram_load
  elseif strcomp(stradr,string("cls"))                  'cls -
    ios.printcls
  elseif strcomp(stradr,string("bye"))                  'bye
    ios.stop
  elseif strcomp(stradr,string("xinit"))                'rdisk initialisieren
    rd_init
  elseif strcomp(stradr,string("xnew"))                 'neue ram-datei erstellen
    rd_new
  elseif strcomp(stradr,string("xhead"))                'header der dateien anzeigen
    rd_header
  elseif strcomp(stradr,string("xdel"))                 'ram-datei löschen
    rd_del
  elseif strcomp(stradr,string("xren"))                 'ram- datei umbenennen
    rd_rename
  elseif strcomp(stradr,string("xdir"))                 'ram-dateien liste anzeigen
    rd_dir
  elseif strcomp(stradr,string("xftab"))                'tabelle geöffnete dateien anzeigen
    rd_ftab
  elseif strcomp(stradr,string("xopen"))                'ram-datei öffnen
    rd_open
  elseif strcomp(stradr,string("xsave"))                'ram-datei auf sd speichern
    rd_save
  elseif strcomp(stradr,string("xclose"))               'ram-datei schliessen
    rd_close
  elseif strcomp(stradr,string("xseek"))                'dateizeiger setzen
    rd_seek
  elseif strcomp(stradr,string("xput"))                 'wert in geöffnete datei schreiben
    rd_put
  elseif strcomp(stradr,string("xget"))                 'wert aus geöffneter datei lesen
    rd_get
  elseif strcomp(stradr,string("xwrite"))               'wert an def. adresse in datei schreiben
    rd_write
  elseif strcomp(stradr,string("xread"))                'wert von def. adresse aus datei lesen
    rd_read
  elseif strcomp(stradr,string("xload"))                'ram-datei von sd laden
    rd_load
  elseif strcomp(stradr,string("xtype"))                'ram-datei (text) ausgeben
    rd_type
  elseif strcomp(stradr,string("debug"))
    debug
  else                                                  'kommando nicht gefunden
      ios.print(stradr)
      ios.print(@prompt3)
      ios.printnl

PRI debug

  ios.rd_init
  ios.rd_newfile(string("d1"),8)
  ios.rd_newfile(string("d2"),8)
  ios.rd_newfile(string("d3"),8)
  ios.rd_newfile(string("d4"),8)
  ios.rd_newfile(string("d5"),8)
  rd_dir


PRI rd_type | stradr,len,fnr                            'rd: text ausgeben

  stradr := os_nxtoken1                                 'dateinamen von kommandozeile holen
  fnr := ios.rd_open(stradr)                            'datei öffnen
  ifnot fnr == -1
    len := ios.rd_len(fnr)
    ios.rd_seek(fnr,0)
    repeat len
      ios.printchar(ios.rd_get(fnr))
    ios.rd_close(fnr)


PRI rd_load | stradr,len,fnr                            'rd: datei in ramdisk laden

  stradr := os_nxtoken1                                 'dateinamen von kommandozeile holen
  ifnot os_error(ios.sdopen("r",stradr))                'datei öffnen
    len := ios.sdfattrib(ios#F_SIZE)
    ios.rd_newfile(stradr,len)                          'datei erzeugen
    fnr := ios.rd_open(stradr)
    ios.rd_seek(fnr,0)
    repeat len                                          'datei einlesen
      ios.rd_put(fnr,ios.sdgetc)
    ios.sdclose
    ios.rd_close(fnr)

PRI rd_save | stradr, fnr, len                          'rd: datei aus ramdisk speichern

  stradr := os_nxtoken1
  fnr := ios.rd_open(stradr)
  ifnot fnr == -1
    len := ios.rd_len(fnr)
    ifnot os_error(ios.sdnewfile(stradr))
      ifnot os_error(ios.sdopen("W",stradr))
        ios.print(string("Schreibe Datei..."))
        repeat len
          ios.sdputc(ios.rd_get(fnr))
        ios.sdclose
        ios.print(string(" ok"))
        ios.printnl
    ios.rd_close(fnr)

PRI rd_rename

  os_error(ios.rd_rename(os_nxtoken1,os_nxtoken2))


PRI rd_seek | fnr,wert                                  'rd: dateizeiger setzen

  fnr   := num.FromStr(os_nxtoken1,num#HEX)
  wert  := num.FromStr(os_nxtoken1,num#HEX)
  ios.rd_seek(fnr,wert)

PRI rd_put | fnr,wert,chars                             'rd: werte ausgeben

  fnr   := num.FromStr(os_nxtoken1,num#HEX)
  wert  := num.FromStr(os_nxtoken1,num#HEX)
  chars := num.FromStr(os_nxtoken1,num#HEX)

  repeat chars
    ios.rd_put(fnr,wert)

PRI rd_get | fnr,chars,i,j                              'rd: werte einlesen

  fnr   := num.FromStr(os_nxtoken1,num#HEX)
  chars := num.FromStr(os_nxtoken1,num#HEX)

  i := j := 0
  repeat chars
    ifnot i
      ios.printnl
      ios.printhex(j,4)
      ios.printchar(":")
    ios.printhex(ios.rd_get(fnr),2)
    ios.printchar(" ")
    if i++ == 7
      i := 0
    j++
  ios.printnl

PRI rd_write | fnr,adr,wert                             'rd: wert schreiben

  fnr   := num.FromStr(os_nxtoken1,num#HEX)
  adr   := num.FromStr(os_nxtoken1,num#HEX)
  wert  := num.FromStr(os_nxtoken1,num#HEX)

  ios.rd_wrbyte(fnr,wert,adr)

PRI rd_read | fnr,adr                                   'rd: wert lesen

  fnr   := num.FromStr(os_nxtoken1,num#HEX)
  adr   := num.FromStr(os_nxtoken1,num#HEX)

  ios.printhex(ios.rd_rdbyte(fnr,adr),2)
  ios.printnl


PRI rd_close                                            'rd: datei schliessen

  ios.rd_close(num.FromStr(os_nxtoken1,num#HEX))

PRI rd_open                                             'rd: datei öffnen

  ifnot ios.rd_open(os_nxtoken1)
    os_error(5)

PRI rd_ftab | i                                         'rd: anzeige ftab

  i := 0
  repeat ios#FILES
    ios.printnl
    ios.printhex(i,2)
    ios.printchar(":")
    ios.printhex(ios.rd_getftab(i*3+0),6)
    ios.printchar(" ")
    ios.printhex(ios.rd_getftab(i*3+1),6)
    ios.printchar(" ")
    ios.printhex(ios.rd_getftab(i*3+2),6)
    ifnot i
      ios.print(string(" user"))
    i++
  ios.printnl

PRI rd_del | adr                                        'rd: datei löschen

  os_error(ios.rd_del(os_nxtoken1))

PRI rd_dir | stradr,len                                 'rd: dir anzeigen

if ios.ram_rdbyte(ios#sysmod,ios#RAMDRV)
  ios.rd_dir
  repeat
    len := ios.rd_dlen
    stradr := ios.rd_next
    if stradr
      ios.print(stradr)
      ios.printtab
      ios.printdec(len)
      ios.printnl
  until stradr == 0
else
  os_error(1)

PRI rd_header|hp,nx,len,i                               'rd: header

  hp := ios#STARTRD
  repeat
    nx  := ios.ram_rdlong(ios#sysmod,hp)
    len := ios.ram_rdlong(ios#sysmod,hp+4)
    ios.print(string("[adr-header] = $"))
    ios.printhex(hp,8)
    ios.printnl
    ios.print(string("[adr-next  ] = $"))
    ios.printhex(nx,8)
    ios.printnl
    ios.print(string("[len       ] = $"))
    ios.printhex(len,8)
    ios.printchar(" ")
    ios.printdec(len)
    ios.printnl
    ios.print(string("[name      ] = "))
    i := 0
    repeat 12
      ios.printchar(ios.ram_rdbyte(ios#sysmod,hp+8+i++))
    hp := nx
    ios.print(string(" <*/q> : "))
    if ios.keywait == "q"
      quit
    ios.printnl
  until nx == 0
    ios.printnl

PRI rd_new                                              'rd: new file

  ios.rd_newfile(os_nxtoken1,num.FromStr(os_nxtoken2,num#DEC))

PRI rd_init                                             'rd: rdisk initialisieren

  ios.rd_init

PRI ram_sysvar | i                                      'ram: systemvariablen anzeigen

  ios.print(string("LOADERPTR     = "))
  ios.printchar("[")
  ios.printhex(ios#LOADERPTR,6)
  ios.print(string("] : "))
  ios.printhex(ios.ram_rdlong(0,ios#LOADERPTR),6)
  ios.printnl
  ios.print(string("MAGIC         = "))
  ios.printchar("[")
  ios.printhex(ios#MAGIC,6)
  ios.print(string("] : "))
  ios.printhex(ios.ram_rdbyte(0,ios#MAGIC),6)
  ios.printnl
  ios.print(string("SIFLAG        = "))
  ios.printchar("[")
  ios.printhex(ios#SIFLAG,6)
  ios.print(string("] : "))
  ios.printhex(ios.ram_rdbyte(0,ios#SIFLAG),6)
  ios.printnl
  ios.print(string("BELDRIVE      =  "))
  i := ios#BELDRIVE
  repeat 12
    ios.printchar(ios.ram_rdbyte(0,i++))
  ios.printnl
  ios.print(string("PARAM         =  "))
  i := ios#PARAM
  repeat 32
    ios.printchar(ios.ram_rdbyte(0,i++))
  ios.printnl
  ios.print(string("RAMEND        = "))
  ios.printchar("[")
  ios.printhex(ios#RAMEND,6)
  ios.print(string("] : "))
  ios.printhex(ios.ram_getend,6)
  ios.printnl
  ios.print(string("RAMBAS        = "))
  ios.printchar("[")
  ios.printhex(ios#RAMBAS,6)
  ios.print(string("] : "))
  ios.printhex(ios.ram_getbas,6)
  ios.printnl


PRI ram_setrbas                                         'ram: basisadresse setzen

  ios.ram_setbas(num.FromStr(os_nxtoken1,num#HEX))

PRI ram_fill | adr,len,wert                             'ram: speicherbereich füllen

  adr  := ram_symbols
  len  := num.FromStr(os_nxtoken1,num#HEX)
  wert := num.FromStr(os_nxtoken1,num#HEX)

  repeat len
    ios.ram_wrbyte(ios#sysmod,wert,adr++)

PRI ram_fillusr | adr,len,wert                          'ram: speicherbereich füllen

  adr  := ram_symbols
  len  := num.FromStr(os_nxtoken1,num#HEX)
  wert := num.FromStr(os_nxtoken1,num#HEX)

  repeat len
    ios.ram_wrbyte(ios#usrmod,wert,adr++)

PRI ram_info                                            'ram: infos anzeigen
  ios.print(string("RBAS : $"))
  ios.printhex(ios.ram_getbas,6)
  ios.print(string(" REND : $"))
  ios.printhex(ios.ram_getend,6)
  ios.print(string(" RLEN : $"))
  ios.printhex(ios.ram_getend - ios.ram_getbas,6)
  ios.print(string(" RDRV : $"))
  ios.printhex(ios.ram_rdbyte(ios#sysmod,ios#RAMDRV),2)
  ios.printnl

PRI ram_mod | wert,adresse,stradr                       'ram: rambereich beschreiben
{{rmodify <adr b1 b2 b3 ...> - rambereich beschreiben, adresse und werte
  folgen auf kommandozeile}}

  adresse := ram_symbols                                'adresse von kommandozeile holen
  repeat
    if (stradr := os_nxtoken1)
      wert := num.FromStr(stradr,num#HEX)               'nächstes byte von kommandozeile holen
      ios.ram_wrbyte(0,wert,adresse++)                  'wert in eram schreiben
  until stradr == 0                                     'keine parameter mehr?

PRI ram_lmod | wert,adresse,stradr                      'ram: rambereich beschreiben (long)
{{rmodify <adr l1 l2 l3 ...> - rambereich beschreiben, adresse und werte
  folgen auf kommandozeile}}

  adresse := ram_symbols                                'adresse von kommandozeile holen
  repeat
    if (stradr := os_nxtoken1)
      wert := num.FromStr(stradr,num#HEX)               'nächstes byte von kommandozeile holen
      ios.ram_wrlong(0,wert,adresse)                    'long in eram schreiben
      adresse := adresse + 4
  until stradr == 0                                     'keine parameter mehr?

PRI ram_disp | adresse,zeilen,sadr                      'ram: rambereich anzeigen
{{rdisplay <adr anz> - rambereich anzeigen, adresse und zeilenzahl folgt auf kommandozeile}}

  adresse := ram_symbols

  zeilen := num.FromStr(os_nxtoken1,num#HEX)            'zeilenzahl von kommandozeile holen
  if zeilen == 0
    zeilen := RMON_ZEILEN
  ram_print(adresse,zeilen)

PRI ram_symbols:adresse | sadr                          'ram: adresse auflösen

  sadr := os_nxtoken1
  if strcomp(sadr,string("bas"))
    adresse := ios.ram_getbas
  elseif strcomp(sadr,string("end"))
    adresse := ios.ram_getend
  elseif strcomp(sadr,string("sys"))
    adresse := ios.ram_getend + 1
  elseif strcomp(sadr,string("rd:"))
    adresse := ios.rd_searchdat(os_nxtoken1)
  else
    adresse := num.FromStr(sadr,num#HEX)                  'adresse von kommandozeile holen


PRI ram_displong | sadr,adresse,wert                    'ram: rambereich als long anzeigen

  adresse := ram_symbols

  repeat
    ios.printnl
    if (adresse => ios.ram_getbas) & (adresse =< ios.ram_getend)
      ios.setcolor(2)
      ios.printhex(adresse - ios.ram_getbas,6)
      ios.setcolor(0)
    else
      ios.print(string("------"))
    ios.printchar("-")
    ios.printhex(adresse,6)                             'adresse ausgeben
    ios.printchar(" ")

    wert := ios.ram_rdlong(0,adresse)
    ios.printhex(wert,6)
    ios.printchar(":")
    ios.printbin(wert,32)
    ios.print(string(" <*/q> : "))
    adresse += 4
  until ios.keywait == "q"
  ios.printnl

PRI ram_next                                            'ram: anzeige fortsetzen
  ram_print(ppos,pcnt)

PRI ram_print(adresse,zeilen)|wert,pbas,pend            'ram: ausgabe

  pbas := ios.ram_getbas                                'rbas vom system sichern
  pend := ios.ram_getend
  repeat zeilen                                         'zeilen
    if (adresse => pbas) & (adresse =< pend)
      ios.setcolor(2)
      ios.printhex(adresse-pbas,6)
      ios.setcolor(0)
    else
      ios.print(string("------"))
    ios.printchar("-")
    ios.printhex(adresse,6)                             'adresse ausgeben
    ios.printchar(ios#CHAR_SPACE)                        
    repeat RMON_BYTES                                   'hexwerte ausgeben
      wert := ios.ram_rdbyte(0,adresse++)
      ios.printhex(wert,2)                              'byte ausgeben
      ios.printchar(":")
    adresse := adresse - rmon_bytes                      
    ios.printchar(ios#CHAR_SPACE)                        
    repeat RMON_BYTES                                   'zeichen ausgeben
      wert := ios.ram_rdbyte(0,adresse++)
      if wert < $20                                      
        wert := 46                                       
      ios.printchar(wert)                               'byte ausgeben
    ios.printchar($0D)
  ppos := adresse
  pcnt := zeilen

PRI ram_load | adr,len,stradr,status,char,i             'ram: lade datei nach eramadr
{{sdload - adr len dateiname   lade datei nach eram-adr}}

  adr    := num.FromStr(os_nxtoken1,num#HEX)            'adresse von kommandozeile holen
  len    := num.FromStr(os_nxtoken1,num#HEX)            'l?nge von kommandozeile holen
  stradr := os_nxtoken1                                 'dateinamen von kommandozeile holen
  status := ios.sdopen("r",stradr)                      'datei ?ffnen
  if status > 0
    ios.print(string("Status : "))
    ios.printdec(status)
    ios.printnl
  if status == 0
    repeat i from 0 to len
      char := ios.sdgetc
      ios.ram_wrbyte(0,char,adr + i)
    ios.sdclose
      


PUB os_error(err):error                                 'sys: fehlerausgabe

  if err
    ios.printnl
    ios.print(@err_s1)
    ios.printdec(err)
    ios.print(string(" : $"))
    ios.printhex(err,2)
    ios.printnl
    ios.print(@err_s2)
    case err
      0: ios.print(@err0)
      1: ios.print(@err1)
      2: ios.print(@err2)
      3: ios.print(@err3)
      4: ios.print(@err4)
      5: ios.print(@err5)
      6: ios.print(@err6)
      7: ios.print(@err7)
      8: ios.print(@err8)
      9: ios.print(@err9)
      10: ios.print(@err10)
      11: ios.print(@err11)
      12: ios.print(@err12)
      13: ios.print(@err13)
      14: ios.print(@err14)
      15: ios.print(@err15)
      16: ios.print(@err16)
      17: ios.print(@err17)
      18: ios.print(@err18)
      19: ios.print(@err19)
      20: ios.print(@err20)
      OTHER: ios.print(@errx)
    ios.printnl
  error := err

DAT
prompt1       byte  "ok ", $0d, 0
prompt2       byte  ": ", 0
prompt3       byte  "? ",0
wait1         byte  "<WEITER? */q:>",0

err_s1  byte "Fehlernummer : ",0
err_s2  byte "Fehler       : ",0

err0    byte "no error",0
err1    byte "fsys unmounted",0
err2    byte "fsys corrupted",0
err3    byte "fsys unsupported",0
err4    byte "not found",0
err5    byte "file not found",0
err6    byte "dir not found",0
err7    byte "file read only",0
err8    byte "end of file",0
err9    byte "end of directory",0
err10   byte "end of root",0
err11   byte "dir is full",0
err12   byte "dir is not empty",0
err13   byte "checksum error",0
err14   byte "reboot error",0
err15   byte "bpb corrupt",0
err16   byte "fsi corrupt",0
err17   byte "dir already exist",0
err18   byte "file already exist",0
err19   byte "out of disk free space",0
err20   byte "disk io error",0
err21   byte "command not found",0
errx    byte "undefined",0