Annotation of qemu/roms/SLOF/slof/fs/packages/iso-9660.fs, revision 1.1.1.1

1.1       root        1: \ *****************************************************************************
                      2: \ * Copyright (c) 2004, 2008 IBM Corporation
                      3: \ * All rights reserved.
                      4: \ * This program and the accompanying materials
                      5: \ * are made available under the terms of the BSD License
                      6: \ * which accompanies this distribution, and is available at
                      7: \ * http://www.opensource.org/licenses/bsd-license.php
                      8: \ *
                      9: \ * Contributors:
                     10: \ *     IBM Corporation - initial implementation
                     11: \ ****************************************************************************/
                     12: 
                     13: 
                     14: s" iso-9660" device-name
                     15: 
                     16: 
                     17: 0 VALUE iso-debug-flag
                     18: 
                     19: \ Method for code clean up - For release version of code iso-debug-flag is
                     20: \ cleared  and for debugging it is set
                     21: 
                     22: : iso-debug-print ( str len -- )  iso-debug-flag IF type cr ELSE 2drop THEN  ;
                     23: 
                     24: 
                     25: \ --------------------------------------------------------
                     26: \ GLOBAL  VARIABLES
                     27: \ --------------------------------------------------------
                     28: 
                     29: 
                     30: 0 VALUE  path-tbl-size
                     31: 0 VALUE  path-tbl-addr
                     32: 0 VALUE  root-dir-size
                     33: 0 VALUE  vol-size
                     34: 0 VALUE  logical-blk-size
                     35: 0 VALUE  path-table
                     36: 0 VALUE  count
                     37: 
                     38: 
                     39: \ INSTANCE VARIABLES
                     40: 
                     41: 
                     42: INSTANCE VARIABLE dir-addr
                     43: INSTANCE VARIABLE data-buff
                     44: INSTANCE VARIABLE #data
                     45: INSTANCE VARIABLE ptable
                     46: INSTANCE VARIABLE file-loc
                     47: INSTANCE VARIABLE file-size
                     48: INSTANCE VARIABLE cur-file-offset
                     49: INSTANCE VARIABLE self
                     50: INSTANCE VARIABLE index
                     51: 
                     52: 
                     53: \ --------------------------------------------------------
                     54: \ COLON DEFINITIONS
                     55: \ --------------------------------------------------------
                     56: 
                     57: 
                     58: \ This method is used to seek to the required position
                     59: \ Which calls seek of disk-label
                     60: 
                     61: : seek  ( pos.lo pos.hi -- status )  s" seek" $call-parent  ;
                     62: 
                     63: 
                     64: \ This method is used to read the contents of disk
                     65: \ it calls read of disk-label
                     66: 
                     67: 
                     68:  : read  ( addr len -- actual )  s" read" $call-parent  ;
                     69: 
                     70: 
                     71: \ This method releases the memory used as  scratch pad buffer.
                     72: 
                     73: : free-data ( -- )
                     74:    data-buff @                              ( data-buff )
                     75:    ?DUP  IF  #data @  free-mem  0 data-buff ! THEN
                     76: ;
                     77: 
                     78: 
                     79: \ This method will release the previous allocated scratch pad buffer and
                     80: \ allocates a fresh buffer and copies the required number of bytes from the
                     81: \ media in to it.
                     82: 
                     83: : read-data ( offset size -- )
                     84:    free-data  DUP                     ( offset size size )
                     85:    #data !  alloc-mem   data-buff !   (  offset )
                     86:    xlsplit                            ( pos.lo pos.hi )
                     87:    seek   -2 and ABORT" seek failed."
                     88:    data-buff  @  #data @  read        ( actual )
                     89:    #data @  <> ABORT" read failed."
                     90: ;
                     91: 
                     92: 
                     93: \ This method extracts the information required from primary volume
                     94: \ descriptor and stores the required information in the global variables
                     95: 
                     96: : extract-vol-info  (  --  )
                     97:    10  800 * 800 read-data
                     98:    data-buff @  88  + l@-be  to path-tbl-size   \ read path table size
                     99:    data-buff @  94  + l@-be  to path-tbl-addr   \ read big-endian  path table
                    100:    data-buff @  a2  + l@-be   dir-addr !        \ gather of root directory info
                    101:    data-buff @  0aa + l@-be  to root-dir-size   \ get volume info
                    102:    data-buff @  54  + l@-be  to vol-size        \ size in blocks
                    103:    data-buff @  82  + l@-be  to logical-blk-size
                    104:    path-tbl-size alloc-mem dup  TO path-table path-tbl-size erase
                    105:    path-tbl-addr 800 *  xlsplit seek  drop
                    106:    path-table  path-tbl-size  read  drop     \ pathtable in-system-memory copy
                    107: ;
                    108: 
                    109: 
                    110: \ This method coverts the iso file name to user readble form
                    111: 
                    112: : file-name  ( str len --  str' len' )
                    113:    2dup  [char] ; findchar  IF
                    114:       ( str len offset )
                    115:       nip                 \ Omit the trailing ";1" revision of ISO9660 file name
                    116:       2dup + 1-           ( str newlen endptr )
                    117:       c@ [CHAR] . = IF
                    118:          1-               ( str len' )    \ Remove trailing dot
                    119:       THEN
                    120:    THEN
                    121: ;
                    122: 
                    123: 
                    124: \ triplicates top stack element
                    125: 
                    126: : dup3  ( num  -- num num num ) dup dup dup  ;
                    127: 
                    128: 
                    129: \ This method is used for traversing records of path table. If the
                    130: \ file identifier length is odd 1 byte padding is done else not.
                    131: 
                    132: : get-next-record  ( rec-addr -- next-rec-offset )
                    133:    dup3               ( rec-addr rec-addr rec-addr rec-addr )
                    134:    self @ 1 +  self ! ( rec-addr rec-addr rec-addr rec-addr )
                    135:    c@  1 AND  IF      ( rec-addr rec-addr rec-addr )
                    136:       c@ +  9         ( rec-addr rec-addr' rec-len )
                    137:    ELSE
                    138:       c@ +  8         ( rec-addr rec-addr' rec-len )
                    139:    THEN
                    140:    + swap  -          ( next-rec-offset )
                    141: ;
                    142: 
                    143: 
                    144: \  This method does search of given directory name in the path table
                    145: \ and returns true  if finds a match else  false.
                    146: 
                    147: : path-table-search ( str len -- TRUE | FALSE )
                    148:    path-table path-tbl-size +  path-table ptable @ +  DO ( str len )
                    149:       2dup  I 6 + w@-be index @ =                        ( str len str len )
                    150:       -rot  I 8 +  I c@  string=ci and  IF               ( str len )
                    151:          s" Directory Matched!!  "   iso-debug-print     ( str len )
                    152:          self @   index !                                ( str len )
                    153:          I 2 + l@-be   dir-addr ! I  dup                 ( str len rec-addr )
                    154:          get-next-record + path-table -   ptable !       ( str len )
                    155:          2drop  TRUE UNLOOP EXIT                         ( TRUE )
                    156:       THEN
                    157:       I get-next-record                           ( str len next-rec-offset )
                    158:    +LOOP
                    159:    2drop
                    160:    FALSE                                          ( FALSE )
                    161:    s" Invalid path / directory "  iso-debug-print
                    162: ;
                    163: 
                    164: 
                    165: \ METHOD for searching for a file with in a direcotory
                    166: 
                    167: : search-file-dir ( str len  -- TRUE | FALSE )
                    168:    dir-addr @  800 *  dir-addr !             ( str len )
                    169:    dir-addr @ 100 read-data                  ( str len )
                    170:    data-buff @  0e + l@-be  dup >r           ( str len rec-len )
                    171:    100 >  IF                                 ( str len )
                    172:       s" size dir record"  iso-debug-print   ( str len )
                    173:       dir-addr @ r@  read-data               ( str len )
                    174:    THEN
                    175:    r> data-buff @  + data-buff @  DO         ( str len )
                    176:       I 19 + c@  2 and 0=  IF                ( str len )
                    177:          2dup                                ( str len  str len )
                    178:          I 21 + I 20 + c@                    ( str len  str len  str' len' )
                    179:          file-name  string=ci  IF            ( str len )
                    180:             s" File found!"  iso-debug-print ( str len )
                    181:             I 6 + l@-be 800 *                ( str len file-loc )
                    182:             file-loc !                       ( str len )
                    183:             I 0e + l@-be  file-size !        ( str len )
                    184:             2drop
                    185:             TRUE                             ( TRUE )
                    186:             UNLOOP
                    187:             EXIT
                    188:          THEN
                    189:       THEN
                    190:       I c@ dup 0=  IF                        ( str len len )
                    191:          s" file not found"   iso-debug-print
                    192:          drop  2drop FALSE                   ( FALSE )
                    193:          UNLOOP
                    194:          EXIT
                    195:       THEN
                    196:    +LOOP
                    197:    2drop
                    198:    FALSE                                     ( FALSE )
                    199:    s" file not found"   iso-debug-print
                    200: ;
                    201: 
                    202: 
                    203: \ This method splits the given absolute path in to directories from root and
                    204: \ calls search-path-table. when string reaches to state when it can not be
                    205: \ split i.e., end of the path, calls search-file-dir is made to search for
                    206: \ file .
                    207: 
                    208: : search-path ( str len -- FALSE|TRUE )
                    209:    0  ptable !
                    210:    1  self !
                    211:    1  index !
                    212:    dup                                             ( str len len )
                    213:    0=  IF
                    214:       3drop FALSE                                  ( FALSE )
                    215:       s"  Empty path name "  iso-debug-print  EXIT ( FALSE )
                    216:    THEN
                    217:    OVER c@                                         ( str len char )
                    218:    [char] \ =  IF                                  ( str len )
                    219:       swap 1 + swap 1 -  BEGIN                     ( str len )
                    220:          [char] \  split                           ( str len  str' len ' )
                    221:          dup 0 =   IF                              ( str len  str' len ' )
                    222:             2drop search-file-dir EXIT             ( TRUE | FALSE )
                    223:          ELSE
                    224:             2swap path-table-search  invert  IF    ( str' len ' )
                    225:                2drop FALSE  EXIT                   ( FALSE )
                    226:             THEN
                    227:          THEN
                    228:       AGAIN
                    229:    ELSE   BEGIN
                    230:       [char] \  split   dup 0 =   IF               ( str len str' len' )
                    231:          2drop search-file-dir EXIT                ( TRUE | FALSE )
                    232:       ELSE
                    233:          2swap path-table-search  invert  IF       ( str' len ' )
                    234:             2drop FALSE  EXIT                      ( FALSE )
                    235:             THEN
                    236:          THEN
                    237:       AGAIN
                    238:    THEN
                    239: ;
                    240: 
                    241: 
                    242: \ this method will seek and read the file in to the given memory location
                    243: 
                    244: 0 VALUE loc
                    245: : load ( addr -- len )
                    246:    dup to loc                     ( addr )
                    247:    file-loc @  xlsplit seek drop
                    248:    file-size @  read              ( file-size )
                    249:    iso-debug-flag IF s" Bytes returned from read:" type dup . cr THEN
                    250:    dup file-size @  <> ABORT" read failed!"
                    251: ;
                    252: 
                    253: 
                    254: 
                    255: \ memory used by the file system will be freed
                    256: 
                    257: : close ( -- )
                    258:    free-data   count 1 - dup to count  0 =  IF
                    259:       path-table path-tbl-size free-mem
                    260:       0 TO path-table
                    261:    THEN
                    262: ;
                    263: 
                    264: 
                    265: \ open method of the file system
                    266: 
                    267: : open ( -- TRUE | FALSE )
                    268:    0 data-buff !
                    269:    0 #data !
                    270:    0 ptable !
                    271:    0 file-loc !
                    272:    0 file-size !
                    273:    0 cur-file-offset !
                    274:    1 self !
                    275:    1 index !
                    276:    count 0 =  IF
                    277:       s" extract-vol-info called "   iso-debug-print
                    278:       extract-vol-info
                    279:    THEN
                    280:    count  1 + to count
                    281:    my-args search-path  IF
                    282:       file-loc @  xlsplit seek drop
                    283:       TRUE    ( TRUE )
                    284:    ELSE
                    285:       close
                    286:       FALSE   ( FALSE )
                    287:    THEN
                    288:    0 cur-file-offset !
                    289:    s" opened ISO9660 package" iso-debug-print
                    290: ;
                    291: 
                    292: 
                    293: \ public seek method
                    294: 
                    295: : seek ( pos.lo pos.hi -- status )
                    296:    lxjoin dup  cur-file-offset !  ( offset )
                    297:    file-loc @  + xlsplit          ( pos.lo pos.hi )
                    298:    s" seek" $call-parent          ( status )
                    299: ;
                    300: 
                    301: 
                    302: \ public read method
                    303: 
                    304:  : read ( addr len -- actual )
                    305:     file-size @ cur-file-offset @ -             ( addr len remainder-of-file )
                    306:     min                                         ( addr len|remainder-of-file )
                    307:     s" read" $call-parent                       ( actual )
                    308:     dup cur-file-offset @ +  cur-file-offset !  ( actual )
                    309:     cur-file-offset @                           ( offset actual )
                    310:     xlsplit seek drop                           ( actual )
                    311: ;
                    312: 

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.