chiark - git - mdw - ssr/blob - StraySrc/Libraries/Sapphire/xfer/s/xload

   1 ;
   2 ; xfer.xload.s
   3 ;
   4 ; Simplified loading with coroutines (MDW)
   5 ;
   6 ; © 1994 Straylight
   7 ;
   8
   9 ;----- Standard header ------------------------------------------------------
  10
  11                 GET     libs:header
  12                 GET     libs:swis
  13
  14 ;----- External dependencies ------------------------------------------------
  15
  16                 GET     sapphire:alloc
  17                 GET     sapphire:coRoutine
  18                 GET     sapphire:fastMove
  19                 GET     sapphire:sapphire
  20
  21 ;----- How it all works -----------------------------------------------------
  22 ;
  23 ; xload attempts to unify the various loading routines you have to supply,
  24 ; by providing a single interface.
  25 ;
  26 ; There are several main routines, xload_file, xload_initBuf,
  27 ; xload_killBuf, xload_extend and xload_doneBuf, which are called from
  28 ; the main load branch table.
  29 ;
  30 ; Loading of data is done with the call xload_block.  This just reads
  31 ; a block of data somehow.  All the other routines are special interfaces to
  32 ; xload_block.
  33
  34 ;----- How the error handling works -----------------------------------------
  35 ;
  36 ; The really tricky bit is passing of errors during a RAM transfer.
  37 ; Errors can be returned at two places -- in the user code (e.g. running out
  38 ; of memory) and by load's message handling if the receiver dies.  All
  39 ; errors must be handled by user code, to release claimed memory etc.
  40 ;
  41 ; The error gets passed along a path like this:
  42 ;
  43 ; Error created by user code
  44 ;
  45 ; user code --> xload__startCo --> xload_failed
  46 ;
  47 ; Error created by remote receiver
  48 ;
  49 ; xload_failed --> xload__read --> user code --> xload__startCo
  50
  51 ;----- Main code ------------------------------------------------------------
  52
  53                 AREA    |Sapphire$$Code|,CODE,READONLY
  54
  55 ; --- xload_file ---
  56 ;
  57 ; On entry:     R0 == pointer to loader routine
  58 ;               R1 == R10 value to pass to loader
  59 ;               R2 == R12 value to pass to loader
  60 ;               R3 == pointer to leafname of file (passed to loader in R0)
  61 ;               R4 == pointer to filename to load from
  62 ;               R5 == whether the file is safe (passed to loader in R1)
  63 ;
  64 ; On exit:      May return an error
  65 ;
  66 ; Use:          Calls a generalised loader routine to read data from a file.
  67
  68                 EXPORT  xload_file
  69 xload_file      ROUT
  70
  71                 STMFD   R13!,{R0-R5,R10,R12,R14} ;Save lots of registers
  72                 WSPACE  xload__wSpace           ;Find my workspace address
  73
  74                 ; --- First, try to allocate a buffer ---
  75
  76                 BL      xload__setBuff          ;Allocate the buffer nicely
  77                 BVS     %99xload_file           ;If we couldn't, tidy up
  78
  79                 ; --- Set up the file for writing ---
  80
  81                 MOV     R1,R4                   ;Point at the file name
  82                 MOV     R0,#&4F                 ;Lots of errors, no path
  83                 SWI     XOS_Find                ;Try to open the file
  84                 BVS     %98xload_file           ;Tidy up if it wouldn't open
  85                 STR     R0,xload__file          ;Save the file handle away
  86
  87                 ; --- Set up flags and let rip ---
  88
  89                 LDR     R14,xload__flags        ;Load my current flags word
  90                 AND     R14,R14,#xlFlag__inited ;Only leave inited flag
  91                 STR     R14,xload__flags        ;Save the flags back again
  92
  93                 MOV     R14,#0                  ;Nothing read yet
  94                 STR     R14,xload__buffUsed     ;So clear buffer size
  95
  96                 LDMIA   R13,{R2,R10,R12,R14}    ;Load the arguments out
  97                 MOV     R0,R14                  ;Get the leafname in R0
  98                 ADDS    R1,R1,#0                ;Clear overflow and carry
  99                 LDR     R1,[R13,#16]            ;Load the safeness flag
 100                 MOV     R14,PC                  ;Set up the return address
 101                 MOV     PC,R2                   ;And call the saver routine
 102                 WSPACE  xload__wSpace           ;Restore my workspace ptr
 103                 BVS     %97xload_file           ;Tidy up if it failed
 104
 105                 ; --- Close the file ---
 106
 107                 MOV     R0,#0                   ;Close an open file
 108                 LDR     R1,xload__file          ;Get the file handle ready
 109                 SWI     OS_Find                 ;Close it
 110
 111                 ; --- Get rid of the buffer and return ---
 112
 113                 BL      xload__loseBuff         ;Free up the buffer space
 114                 LDMFD   R13!,{R0-R5,R10,R12,R14} ;Unstack all the registers
 115                 BICS    PC,R14,#V_flag          ;And return to caller
 116
 117                 ; --- Tidy up after various catastrophes ---
 118
 119 97xload_file    MOV     R10,R0                  ;Keep the error pointer
 120                 MOV     R0,#0                   ;Close an open file
 121                 LDR     R1,xload__file          ;Get the file handle ready
 122                 SWI     OS_Find                 ;Close it
 123                 MOV     R0,R10                  ;Restore the error pointer
 124
 125 98xload_file    BL      xload__loseBuff         ;Free up the buffer space
 126
 127 99xload_file    ADD     R13,R13,#4              ;Don't restore R0 on exit
 128                 LDMFD   R13!,{R1-R5,R10,R12,R14} ;Unstack all the registers
 129                 ORRS    PC,R14,#V_flag          ;And return to caller
 130
 131 ; --- xload_initBuf ---
 132 ;
 133 ; On entry:     R0 == pointer to loader routine
 134 ;               R1 == R10 value to pass to loader
 135 ;               R2 == R12 value to pass to loader
 136 ;               R3 == pointer to leafname of file (passed to loader in R0)
 137 ;
 138 ; On exit:      R0 == pointer to load buffer
 139 ;               R1 == size of load buffer
 140 ;               May return an error
 141 ;
 142 ; Use:          Starts a RAM transfer and starts up a generalised load
 143 ;               routine.
 144
 145                 EXPORT  xload_initBuf
 146 xload_initBuf   ROUT
 147
 148                 STMFD   R13!,{R0-R3,R12,R14}    ;Save some registers
 149                 WSPACE  xload__wSpace           ;Load my workspace address
 150
 151                 ; --- Firstly, allocate the buffer ---
 152
 153                 BL      xload__setBuff          ;Create the load buffer
 154                 ADDVS   R13,R13,#8              ;If failed, unstack R0,R1
 155                 BVS     %99xload_initBuf        ;And then return error
 156
 157                 ; --- Now create the coroutine ---
 158
 159                 ADR     R0,xload__startCo       ;Point to the coroutine
 160                 MOV     R1,R13                  ;Point to saved corout info
 161                 MOV     R2,R12                  ;Pass my workspace in R12
 162                 MOV     R3,#0                   ;Default stack size please
 163                 BL      coRout_create           ;Try to create the coroutine
 164                 ADDVS   R13,R13,#8              ;Don't return R0,R1
 165                 BVS     %98xload_initBuf        ;If it failed, tidy up
 166                 STR     R0,xload__coRout        ;Save the couroutine handle
 167
 168                 ; --- Let xload__startCo save coroutine info ---
 169
 170                 BL      coRout_switch           ;Switch to it quickly
 171                 ADD     R13,R13,#8              ;Don't return R0,R1
 172
 173                 ; --- Set up flags and bits of workspace ---
 174
 175                 LDR     R14,xload__flags        ;Load my flags word
 176                 AND     R14,R14,#xlFlag__inited ;Clear all but initialised
 177                 ORR     R14,R14,#xlFlag__ramTran ;We're doing RAM transfer
 178                 STR     R14,xload__flags        ;Save the flags back
 179                 MOV     R14,#0                  ;No data RAMmed in yet
 180                 STR     R14,xload__rammed       ;So save this information
 181
 182                 ; --- Return the buffer information ---
 183
 184                 ADR     R14,xload__buffer       ;Find my buffer info
 185                 LDMIA   R14,{R0,R1}             ;Load address and size
 186                 LDMFD   R13!,{R2,R3,R12,R14}    ;Unstack my registers
 187                 BICS    PC,R14,#V_flag          ;And return no error
 188
 189                 ; --- Things went wrong ---
 190
 191 98xload_initBuf BL      xload__loseBuff         ;Get rid of transfer buffer
 192 99xload_initBuf LDMFD   R13!,{R2,R3,R12,R14}    ;Unstack my registers
 193                 ORRS    PC,R14,#V_flag          ;And return the error
 194
 195                 LTORG
 196
 197 ; --- xload__startCo ---
 198 ;
 199 ; On entry:     R0 == my coroutine handle
 200 ;               R10 == pointer to block containing (routine,R10,R12,leafname)
 201 ;               R12 == my workspace
 202 ;
 203 ; On exit:      Returns through coRout_end
 204 ;
 205 ; Use:          Starts the coroutine for sending data by RAM transfer.  It
 206 ;               handles errors reported by it, and terminates the transfer
 207 ;               properly.
 208 ;
 209 ;               The information about the real client is stored on the
 210 ;               main routine's stack.  Before it returns, therefore, we
 211 ;               need to load it from there and save it somewhere so that
 212 ;               it will be safe when we start the coroutine properly from
 213 ;               xload_extend.  Therefore we actually start from xload_initBuf
 214 ;               and save the information on the coroutine's stack, and
 215 ;               switch back quickly.
 216
 217 xload__startCo  ROUT
 218
 219                 LDMIA   R10,{R0-R3}             ;Load the caller's registers
 220                 STMFD   R13!,{R0-R3}            ;Save them on our stack
 221                 MOV     R0,#0                   ;Return to main routine
 222                 BL      coRout_switch           ;Switch back please
 223
 224                 LDR     R14,xload__flags        ;Load my flags word
 225                 ORR     R14,R14,#xlFlag__started ;Coroutine has started now
 226                 STR     R14,xload__flags        ;Save flags back again
 227
 228                 LDMFD   R13!,{R2,R10,R12,R14}   ;Load client's workspace
 229                 MOV     R0,R14                  ;Pass leafname in R0
 230                 MOV     R1,#0                   ;File is not safe
 231                 MOV     R14,PC                  ;Set up a return address
 232                 MOV     PC,R2                   ;And call the saver routine
 233                 BVS     %90xload__startCo       ;If it failed, report error
 234
 235                 MOV     R14,#0                  ;A nice zero value
 236                 WSPACE  xload__wSpace           ;Load my workspace pointer
 237                 STR     R14,xload__coRout       ;Write over the coroutine
 238                 LDR     R0,xload__buffer        ;Load the buffer address
 239                 MOV     R1,#xload__buffSize     ;Get the current buffer size
 240                 ADR     R14,xload__start        ;Point to load area
 241                 STMIA   R14,{R0,R1}             ;Save the data in there
 242                 B       coRout_end              ;Terminate coroutine
 243
 244                 ; --- Handle its return values ---
 245
 246 90
 247                 WSPACE  xload__wSpace           ;Locate my workspace address
 248                 LDR     R14,xload__flags        ;Load the flags word
 249
 250                 ORR     R14,R14,#xlFlag__error  ;Set the main error flag
 251                 STR     R14,xload__flags        ;Save the flags back again
 252                 STR     R0,xload__error         ;And save the error pointer
 253                 B       coRout_end              ;And finish the coroutine
 254
 255                 LTORG
 256
 257 ; --- xload_killBuf ---
 258 ;
 259 ; On entry:     --
 260 ;
 261 ; On exit:      --
 262 ;
 263 ; Use:          Does a buffer destroy for a failed load operation.
 264
 265                 EXPORT  xload_killBuf
 266 xload_killBuf   ROUT
 267
 268                 STMFD   R13!,{R0,R12,R14}       ;Save some registers
 269                 WSPACE  xload__wSpace           ;Find my workspace address
 270                 LDR     R14,xload__flags        ;Load my flags word
 271                 TST     R14,#xlFlag__started    ;Has the coroutine started?
 272                 LDMNEFD R13!,{R0,R12,PC}^       ;Yes -- this is an error then
 273
 274                 ; --- Destroy the buffer and the coroutine ---
 275
 276                 BL      xload__loseBuff         ;Get rid of the load buffer
 277                 LDR     R0,xload__coRout        ;Load the coroutine handle
 278                 BL      coRout_destroy          ;Destroy the coroutine
 279                 LDMFD   R13!,{R0,R12,PC}^       ;Return to caller
 280
 281                 LTORG
 282
 283 ; --- xload_extend ---
 284 ;
 285 ; On entry:     R1 == size of last buffer used for receiving
 286 ;
 287 ; On exit:      R0 == pointer to new buffer
 288 ;               R1 == size of new buffer
 289 ;               May return an error
 290 ;
 291 ; Use:          Performs a buffer extent operation during an xload RAM
 292 ;               transfer.
 293
 294                 EXPORT  xload_extend
 295 xload_extend    ROUT
 296
 297                 STMFD   R13!,{R12,R14}          ;Save some registers
 298                 WSPACE  xload__wSpace           ;Find my workspace address
 299
 300                 ; --- Bump the amount of data received ---
 301
 302                 LDR     R14,xload__rammed       ;Find how much was sent
 303                 ADD     R14,R14,R1              ;Add size of last buffer
 304                 STR     R14,xload__rammed       ;And save the size back
 305
 306                 ; --- Let the coroutine do some loading ---
 307
 308                 BL      xload__resume           ;Let the coroutine run a bit
 309                 LDR     R14,xload__flags        ;Load the coroutine's flags
 310                 TST     R14,#xlFlag__error      ;Has it returned an error?
 311                 BNE     %90xload_extend         ;Yes -- then return it
 312
 313                 ; --- Get the next buffer to send from xload__read ---
 314
 315                 ADR     R14,xload__start        ;Point to buffer data
 316                 LDMIA   R14,{R0,R1}             ;Load the buffer data
 317                 LDMFD   R13!,{R12,R14}          ;Unstack the registers
 318                 BICS    PC,R14,#V_flag          ;And don't return an error
 319
 320                 ; --- Client had a wee problem ---
 321
 322 90xload_extend  LDR     R0,xload__error         ;Load the error pointer
 323                 LDMFD   R13!,{R12,R14}          ;Unstack the registers
 324                 ORRS    PC,R14,#V_flag          ;And return the error
 325
 326                 LTORG
 327
 328 ; --- xload_doneBuf ---
 329 ;
 330 ; On entry:     R1 == total size of data received
 331 ;
 332 ; On exit:      R0 corrupted
 333 ;               May return an error
 334 ;
 335 ; Use:          Handles the last bufferful of a RAM load.
 336
 337                 EXPORT  xload_doneBuf
 338 xload_doneBuf   ROUT
 339
 340                 STMFD   R13!,{R12,R14}          ;Save some registers
 341                 WSPACE  xload__wSpace           ;Find my workspace address
 342
 343                 ; --- Work out how much of the last buffer was sent ---
 344
 345                 LDR     R14,xload__rammed       ;Find how much was sent
 346                 SUB     R0,R1,R14               ;How much of last buffer?
 347                 STR     R0,xload__length        ;And save the size back
 348                 LDR     R14,xload__flags        ;Load the flags word
 349                 ORR     R14,R14,#xlFlag__finish ;Set the finished flag
 350                 STR     R14,xload__flags        ;Save the flags back again
 351                 TST     R14,#xlFlag__started    ;Has the coroutine started?
 352                 STREQ   R0,xload__buffUsed      ;No -- set buffer size
 353
 354                 ; --- Now let the coroutine finish off ---
 355
 356                 BL      xload__resume           ;Let the coroutine run a bit
 357                 LDR     R14,xload__flags        ;Load the coroutine's flags
 358                 TST     R14,#xlFlag__error      ;Has it returned an error?
 359                 BNE     %90xload_doneBuf        ;Yes -- then return it
 360
 361                 ; --- Return to caller ---
 362
 363                 BL      xload__loseBuff         ;Don't want this any more
 364                 LDMFD   R13!,{R12,R14}          ;Unstack the registers
 365                 BICS    PC,R14,#V_flag          ;Don't return an error
 366
 367                 ; --- Coroutine hit a wee problem ---
 368
 369 90xload_doneBuf LDR     R0,xload__error         ;Load the error pointer
 370                 LDMFD   R13!,{R12,R14}          ;Unstack the registers
 371                 ORRS    PC,R14,#V_flag          ;And return the error
 372
 373                 LTORG
 374
 375 ; --- xload_done ---
 376 ;
 377 ; On entry:     --
 378 ;
 379 ; On exit:      --
 380 ;
 381 ; Use:          Tidies up after a successful load job.
 382
 383                 EXPORT  xload_done
 384 xload_done      ROUT
 385
 386                 MOVS    PC,R14                  ;Nothing to do here
 387
 388 ; --- xload_failed ---
 389 ;
 390 ; On entry:     R0 == pointer to error block
 391 ;
 392 ; On exit:      --
 393 ;
 394 ; Use:          Tidies up a RAM transfer after an error.
 395
 396                 EXPORT  xload_failed
 397 xload_failed    ROUT
 398
 399                 STMFD   R13!,{R12,R14}          ;Save some registers
 400                 WSPACE  xload__wSpace           ;Find my workspace
 401                 LDR     R14,xload__flags        ;Load my flags word
 402                 TST     R14,#xlFlag__ramTran    ;Are we using RAM transfer?
 403                 LDMEQFD R13!,{R12,PC}^          ;No -- return right now then
 404
 405                 ; --- Find out if the user has seen the error yet ---
 406
 407                 STMFD   R13!,{R0}               ;Save some more registers
 408                 TST     R14,#xlFlag__error      ;Has he seen the error?
 409                 BNE     %30xload_failed         ;Yes -- then don't switch
 410
 411                 ; --- Get xload__write to return an error ---
 412
 413                 ORR     R14,R14,#xlFlag__error  ;Set the error flag
 414                 STR     R0,xload__error         ;And save the error pointer
 415                 BL      xload__resume           ;Let the coroutine run a bit
 416
 417                 ; --- Now tidy everything up ---
 418                 ;
 419                 ; The coroutine should have killed itself by now
 420
 421 30xload_failed  BL      xload__loseBuff         ;Kill off the data buffer
 422                 LDMFD   R13!,{R0,R12,PC}^       ;Return to caller
 423
 424                 LTORG
 425
 426 ; --- xload__resume ---
 427 ;
 428 ; On entry:     --
 429 ;
 430 ; On exit:      --
 431 ;
 432 ; Use:          Lets the coroutine run for a bit.
 433
 434 xload__resume   ROUT
 435
 436                 STMFD   R13!,{R0,R1,R14}        ;Save some registers
 437                 LDR     R0,xload__coRout        ;Load the coroutine handle
 438                 CMP     R0,#0                   ;Has it finished yet?
 439                 BLNE    coRout_switch           ;No -- run it a bit more then
 440                 LDMNEFD R13!,{R0,R1,PC}^        ;And return to caller
 441
 442                 LDR     R0,xload__buffer        ;Load the buffer address
 443                 MOV     R1,#xload__buffSize     ;Get the current buffer size
 444                 ADR     R14,xload__start        ;Point to load area
 445                 STMIA   R14,{R0,R1}             ;Save the data in there
 446                 LDMFD   R13!,{R0,R1,PC}^        ;Return to caller
 447
 448                 LTORG
 449
 450 ; --- xload__setBuff ---
 451 ;
 452 ; On entry:     --
 453 ;
 454 ; On exit:      May return an error
 455 ;
 456 ; Use:          Sets up the buffer for a data transfer.
 457
 458 xload__setBuff  ROUT
 459
 460                 STMFD   R13!,{R0-R3,R14}        ;Save some registers
 461
 462                 ; --- Allocate the buffer memory ---
 463
 464                 MOV     R0,#xload__buffSize     ;Get the buffer size
 465                 BL      alloc                   ;Try to allocate the buffer
 466                 BLCS    alloc_error             ;Get an error if it failed
 467                 BCS     %90xload__setBuff       ;And tidy things up
 468
 469                 ; --- Set up los of variables ---
 470
 471                 ADR     R14,xload__buffer       ;Point at the buffer info
 472                 MOV     R1,#xload__buffSize     ;No buffer used yet
 473                 MOV     R2,#0                   ;Start buffer from beginning
 474                 MOV     R3,#0                   ;No data sent yet either
 475                 STMIA   R14,{R0-R3}             ;Save these values away
 476                 LDMFD   R13!,{R0-R3,R14}        ;Restore all the registers
 477                 BICS    PC,R14,#V_flag          ;And return with V clear
 478
 479                 ; --- Report an error ---
 480
 481 90              ADD     R13,R13,#4              ;Don't restore R0 on exit
 482                 LDMFD   R13!,{R1-R3,R14}        ;Restore all the registers
 483                 ORRS    PC,R14,#V_flag          ;And return with V set
 484
 485                 LTORG
 486
 487 ; --- xload__loseBuff ---
 488 ;
 489 ; On entry:     --
 490 ;
 491 ; On exit:      --
 492 ;
 493 ; Use:          Kills off the buffer.
 494
 495 xload__loseBuff ROUT
 496
 497                 STMFD   R13!,{R0,R14}           ;Save some registers
 498                 LDR     R0,xload__buffer        ;Load the buffer address
 499                 BL      free                    ;Free the buffer
 500                 LDR     R14,xload__flags        ;Load my current flags word
 501                 AND     R14,R14,#xlFlag__inited ;Only leave inited flag
 502                 STR     R14,xload__flags        ;Save the flags back again
 503                 LDMFD   R13!,{R0,PC}^           ;And return to caller
 504
 505                 LTORG
 506
 507 ; --- xload_byte ---
 508 ;
 509 ; On entry:     --
 510 ;
 511 ; On exit:      CC if data read OK, and
 512 ;                 R0 == byte read
 513 ;               else CC if end-of-file, and
 514 ;                 R0 corrupted
 515 ;               May return an error
 516 ;
 517 ; Use:          Reads a byte from the current input.
 518
 519                 EXPORT  xload_byte
 520 xload_byte      ROUT
 521
 522                 STMFD   R13!,{R0-R2,R14}        ;Save some registers
 523                 MOV     R0,R13                  ;Overwrite saved R0
 524                 MOV     R1,#1                   ;Just read one byte
 525                 BL      xload_block             ;Read it onto the stack
 526                 STRVS   R0,[R13,#0]             ;If error, store pointer
 527                 LDR     R0,[R13],#4             ;Load the byte/error pointer
 528                 ANDVC   R0,R0,#&FF              ;If byte/EOF, kill other bits
 529                 LDMFD   R13!,{R1,R2,PC}         ;And return to caller
 530
 531                 LTORG
 532
 533 ; --- xload_word ---
 534 ;
 535 ; On entry:     --
 536 ;
 537 ; On exit:      CC if data read OK, and
 538 ;                 R0 == word read
 539 ;               else CS if end-of-file and
 540 ;                 R0 corrupted
 541 ;               May return an error
 542 ;
 543 ; Use:          Reads a word from the current input.
 544
 545                 EXPORT  xload_word
 546 xload_word      ROUT
 547
 548                 STMFD   R13!,{R0-R2,R14}        ;Save some registers
 549                 MOV     R0,R13                  ;Overwrite saved R0
 550                 MOV     R1,#4                   ;Just read one word
 551                 BL      xload_block             ;Read it onto the stack
 552                 STRVS   R0,[R13,#0]             ;If error, store pointer
 553                 LDR     R0,[R13],#4             ;Load the byte/error pointer
 554                 LDMFD   R13!,{R1,R2,PC}         ;And return to caller
 555
 556                 LTORG
 557
 558 ; --- xload_block ---
 559 ;
 560 ; On entry:     R0 == pointer to buffer to read
 561 ;               R1 == size of buffer to read
 562 ;
 563 ; On exit:      R0, R1 preserved
 564 ;               R2 == number of bytes read
 565 ;               CC if more data available, CS for end-of-file
 566 ;               May return an error
 567 ;
 568 ; Use:          Reads in a block of data.  Data is buffered, so this is
 569 ;               fairly quick for reading small objects.  Large data blocks
 570 ;               are read directly to avoid buffering overhead.
 571
 572                 EXPORT  xload_block
 573 xload_block     ROUT
 574
 575                 CMP     R1,#0                   ;Is there anything there?
 576                 MOVEQ   R2,#0                   ;Nothing read yet
 577                 BICEQS  PC,R14,#V_flag          ;No -- return with no error
 578
 579                 STMFD   R13!,{R0,R1,R3-R8,R12,R14} ;Save a load of registers
 580                 WSPACE  xload__wSpace           ;Load my workspace address
 581                 MOV     R6,R0                   ;Keep his buffer address
 582                 MOV     R7,R1                   ;Look after his buffer size
 583                 MOV     R8,#0                   ;No data copied yet
 584
 585                 ; --- First, try to read from the buffer ---
 586
 587                 ADR     R14,xload__buffer       ;Point to the buff info
 588                 LDMIA   R14,{R3-R5}             ;Load the buffer stuff
 589 00xload_block   SUBS    R14,R4,R5               ;Find out how much there is
 590                 BEQ     %20xload_block          ;No -- skip ahead then
 591
 592                 ; --- Read as much as we need from buffer ---
 593
 594                 CMP     R7,R14                  ;Is there enough there?
 595                 MOVLT   R2,R7                   ;Yes -- get as much as we can
 596                 MOVGE   R2,R14                  ;Otherwise empty the buffer
 597                 ADD     R1,R3,R5                ;Get the correct address
 598                 MOV     R0,R6                   ;Point at his buffer
 599                 BL      fastMove                ;Copy the data across nicely
 600
 601                 ; --- Reset the buffer arguments ---
 602
 603                 ADD     R5,R5,R2                ;Add on the offset now
 604                 ADD     R6,R6,R2                ;Bump up his buffer address
 605                 SUBS    R7,R7,R2                ;And decrease the size
 606                 ADD     R8,R8,R2                ;Bump amount of data read
 607                 BEQ     %90xload_block          ;If no more to do, return
 608
 609                 ; --- Buffer was empty ---
 610                 ;
 611                 ; If he wants more than a buffer full, we should just read
 612                 ; directly into his buffer.  Otherwise we fill the buffer
 613                 ; and loop back again to copy data.
 614
 615 20xload_block   CMP     R7,#xload__buffSize     ;Does he want more?
 616                 BGE     %50xload_block          ;Yes -- skip ahead then
 617
 618                 MOV     R0,R3                   ;Point to the buffer
 619                 MOV     R1,#xload__buffSize     ;Get the buffer size
 620                 BL      xload__read             ;Read data into the buffer
 621                 BVS     %95xload_block          ;If it failed, return error
 622                 MOVS    R4,R2                   ;Get the new buffer size
 623                 MOV     R5,#0                   ;Haven't started on it yet
 624                 BNE     %00xload_block          ;If anything read, go round
 625                 B       %90xload_block          ;Otherwise we'd better stop
 626
 627                 ; --- Read data into his big buffer ---
 628
 629 50xload_block   MOV     R0,R6                   ;Point to his buffer
 630                 MOV     R1,R7                   ;And get his buffer size
 631                 BL      xload__read             ;Read data into the buffer
 632                 BVS     %95xload_block          ;If it failed, return error
 633                 ADD     R8,R8,R2                ;Bump by amount read
 634
 635                 ; --- Everything went OK ---
 636
 637 90xload_block   ADR     R14,xload__buffUsed     ;Point to the buff info
 638                 STMIA   R14,{R4,R5}             ;Store new offsets
 639                 MOV     R2,R8                   ;Get amount of data read
 640
 641                 LDR     R14,xload__total        ;Load the total data read
 642                 ADD     R14,R14,R8              ;Add new amount read
 643                 STR     R14,xload__total        ;And save back the new total
 644
 645                 LDR     R14,xload__flags        ;Load the flags word
 646                 LDR     R1,[R13,#4]             ;Load amount he wanted
 647                 CMP     R1,R2                   ;Did we read it all?
 648                 ORRGT   R14,R14,#xlFlag__finish ;No -- set eof flag then
 649                 STRGT   R14,xload__flags        ;Save the flags back
 650
 651                 LDMFD   R13!,{R0,R1,R3-R8,R12,R14} ;Unstack loads of regs
 652                 BIC     R14,R14,#V_flag         ;Clear error indicator
 653                 ORRGTS  PC,R14,#C_flag          ;Set Carry on exit if EOF
 654                 BICLES  PC,R14,#C_flag          ;Otherwise clear it
 655
 656                 ; --- We had an error ---
 657
 658 95xload_block   ADD     R13,R13,#4              ;Don't restore R0 on exit
 659                 LDMFD   R13!,{R1,R3-R8,R12,R14} ;Unstack loads of regs
 660                 ORRS    PC,R14,#V_flag          ;Return the error condition
 661
 662                 LTORG
 663
 664 ; --- xload__read ---
 665 ;
 666 ; On entry:     R0 == pointer to buffer to read
 667 ;               R1 == size of buffer to read
 668 ;
 669 ; On exit:      May return an error
 670 ;               R2 == actual amount of data read
 671 ;
 672 ; Use:          Reads a block of data from the input stream.
 673
 674 xload__read     ROUT
 675
 676                 BIC     R14,R14,#V_flag         ;Clear error indicator
 677                 MOV     R2,#0                   ;Nothing read yet
 678                 CMP     R1,#0                   ;Is there anything there?
 679                 MOVEQS  PC,R14                  ;No -- return with no error
 680
 681                 STMFD   R13!,{R14}              ;Save some registers
 682                 LDR     R14,xload__flags        ;Find my flags word
 683                 TST     R14,#xlFlag__finish     ;Is the transfer over?
 684                 LDMNEFD R13!,{PC}^              ;Yes -- return right now
 685                 TST     R14,#xlFlag__ramTran    ;Am I using RAM transfer?
 686                 BNE     %50xload__read          ;Yes -- do that then
 687
 688                 ; --- Use OS_HeebieJeebie to read the data ---
 689
 690                 STMFD   R13!,{R0,R1,R3,R4}      ;Save some more registers
 691                 MOV     R2,R0                   ;Point to the user's buffer
 692                 MOV     R3,R1                   ;And get the buffer size
 693                 LDR     R1,xload__file          ;Get the file's handle
 694                 MOV     R0,#4                   ;Read at current position
 695                 SWI     XOS_GBPB                ;Read the data in nicely
 696                 STRVS   R0,[R13,#0]             ;If error, save error ptr
 697                 LDRVC   R1,[R13,#4]             ;Load number of bytes wanted
 698                 SUBVC   R2,R1,R3                ;Get number actually read
 699                 LDMFD   R13!,{R0,R1,R3,R4,R14}  ;Unstack the registers
 700                 ORRVSS  PC,R14,#V_flag          ;Return V set as required
 701                 BICVCS  PC,R14,#V_flag
 702
 703                 ; --- Get the main coroutine to read the buffer ---
 704
 705 50xload__read   STMFD   R13!,{R0}               ;Save another register
 706                 ADR     R14,xload__start        ;Point to the buffer info
 707                 STMIA   R14,{R0,R1}             ;Save for main coroutine
 708                 MOV     R0,#0                   ;Get magic coroutine handle
 709                 BL      coRout_switch           ;And switch to main code
 710                 LDR     R2,xload__length        ;Read data size read
 711                 LDR     R14,xload__flags        ;Reload the flags
 712                 TST     R14,#xlFlag__error      ;Was there a problem?
 713                 LDMFD   R13!,{R0,R14}           ;Restore the registers
 714                 BICEQS  PC,R14,#V_flag          ;No -- just clear V then
 715                 LDRNE   R0,xload__error         ;Otherwise load error pointer
 716                 ORRNES  PC,R14,#V_flag          ;And return with V set
 717
 718                 LTORG
 719
 720 xload__wSpace   DCD     0
 721
 722 ;----- Constants ------------------------------------------------------------
 723
 724 xload__buffSize EQU     1024                    ;1K buffer should be enough
 725
 726 ;----- Workspace ------------------------------------------------------------
 727
 728                 ^       0,R12
 729 xload__wStart   #       0
 730
 731 xload__flags    #       4                       ;Various run-time flags
 732 xload__coRout   #       0                       ;The load coroutine handle
 733 xload__file     #       4                       ;The load file handle
 734 xload__buffer   #       4                       ;Pointer to my 1K buffer
 735 xload__buffUsed #       4                       ;Amount of data in buffer
 736 xload__buffOff  #       4                       ;Offset reading from buffer
 737 xload__total    #       4                       ;How much data read so far
 738 xload__error    #       0                       ;Error pointer from corout
 739 xload__start    #       4                       ;Start of buffer to send
 740 xload__length   #       4                       ;Size of next buffer to send
 741 xload__rammed   #       4                       ;Data RAMFetched so far
 742
 743 xload__wSize    EQU     {VAR}-xload__wStart
 744
 745 xlFlag__inited  EQU     (1<<0)                  ;Are we initialised already?
 746 xlFlag__ramTran EQU     (1<<1)                  ;Are we doing RAM transfer?
 747 xlFlag__finish  EQU     (1<<2)                  ;This is the very last block
 748 xlFlag__error   EQU     (1<<3)                  ;Should return an error
 749 xlFlag__started EQU     (1<<4)                  ;Coroutine has started
 750
 751                 AREA    |Sapphire$$LibData|,CODE,READONLY
 752
 753                 DCD     xload__wSize
 754                 DCD     xload__wSpace
 755                 DCD     0
 756                 DCD     0
 757
 758 ;----- That's all, folks ----------------------------------------------------
 759
 760                 END