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

   1 ;
   2 ; xfer.load.s
   3 ;
   4 ; Loading and importing of files (MDW)
   5 ;
   6 ; © 1994 Straylight
   7 ;
   8
   9 ;----- Standard header ------------------------------------------------------
  10
  11                 GET     libs:swis
  12                 GET     libs:header
  13
  14 ;----- External dependencies ------------------------------------------------
  15
  16                 GET     sapphire:alloc
  17                 GET     sapphire:event
  18                 GET     sapphire:fastMove
  19                 GET     sapphire:flex
  20                 GET     sapphire:msgs
  21                 GET     sapphire:sapphire
  22                 GET     sapphire:string
  23                 GET     sapphire:wimp
  24                 GET     sapphire:win
  25
  26 ;----- Main code ------------------------------------------------------------
  27
  28                 AREA    |Sapphire$$Code|,CODE,READONLY
  29
  30 ; --- load ---
  31 ;
  32 ; On entry:     R0 == pointer to entry point block
  33 ;               R1 == value of R10 to pass to entry points
  34 ;               R2 == value of R12 to pass to entry points
  35 ;
  36 ; On exit:      --
  37 ;
  38 ; Use:          Attempts to load a file after receipt of a Message_DataSave,
  39 ;               Message_DataLoad or Message_DataOpen.  If user entries for
  40 ;               RAM transfer are provided, this is attempted, although the
  41 ;               entries must also be aware that file transfer may be
  42 ;               required.
  43
  44                 EXPORT  load
  45 load            ROUT
  46
  47                 STMFD   R13!,{R0-R6,R10,R12,R14} ;Save a load of registers
  48                 WSPACE  load__wSpace            ;Locate my workspace address
  49
  50                 ; --- Save the handler information ---
  51
  52                 ADR     R14,load__entries       ;Point to my entry info
  53                 STMIA   R14,{R0-R2}             ;And save the handler info
  54
  55                 ; --- Read the current message ---
  56
  57                 BL      event_last              ;Read the actual last event
  58                 CMP     R0,#17                  ;Is it a normal message?
  59                 CMPNE   R0,#18                  ;Or a bouncy one?
  60                 BNE     %90load                 ;Neither -- ignore it then
  61
  62                 LDR     R0,[R1,#16]             ;Load the message action
  63                 CMP     R0,#1                   ;Is it a Message_DataSave?
  64                 BEQ     %20load                 ;Yes -- handle it then
  65                 CMP     R0,#3                   ;Is it a Message_DataLoad?
  66                 BEQ     %50load                 ;Yes -- deal with that
  67                 CMP     R0,#5                   ;Is it a Message_DataOpen?
  68                 BEQ     %60load                 ;Yes -- deal with that too
  69                 B       %90load                 ;Otherwise ignore it
  70
  71                 ; --- Deal with a Message_DataSave ---
  72                 ;
  73                 ; First, set up all the data in my workspace.
  74
  75 20load          MOV     R6,R1                   ;Keep the message pointer
  76                 ADR     R0,load__message        ;Point to my message buffer
  77                 LDR     R2,[R6,#0]              ;Get the message block size
  78                 BL      fastMove                ;Copy it over nicely
  79
  80                 ; --- Find out if he can do RAM transfer ---
  81
  82                 LDR     R5,load__entries        ;Find his handler block
  83                 LDR     R14,[R5,#lEntry__initBuf] ;Point to his initBuf entry
  84                 CMP     R14,#0                  ;Is it defined?
  85                 BEQ     %40load                 ;No -- just do scrap xfer
  86
  87                 ; --- Set up for RAM transfer ---
  88
  89                 ADR     R0,load__name           ;Point to the leafname
  90                 LDR     R1,[R6,#36]             ;Load the estimated size
  91                 MOV     R2,#0                   ;Pass a zero buffer handle
  92                 ADR     R14,load__R10           ;Point to his R10/R12 values
  93                 LDMIA   R14,{R10,R12}           ;Load them out ready
  94                 ADDS    R0,R0,#0                ;Clear lots of flags
  95                 MOV     R14,PC                  ;Set up a return address
  96                 ADD     PC,R5,#lEntry__initBuf  ;Make him give me a buffer
  97                 WSPACE  load__wSpace            ;Get my workspace back again
  98                 STR     R10,load__R10           ;Save his returned R10 value
  99                 BLVS    load__finish            ;If it failed, tidy it up
 100                 BVS     %90load                 ;And return right now
 101                 ADR     R14,load__buffStart     ;Point to the buffer info
 102                 STMIA   R14,{R0-R2}             ;And save the buffer stuff
 103                 MOV     R14,#0                  ;We've not read any data yet
 104                 STR     R14,load__totalSize     ;So zero the total size
 105
 106                 ; --- Build the Message_RAMFetch ---
 107
 108                 MOV     R14,#28                 ;Size of a RAMFetch message
 109                 STR     R14,[R11,#0]            ;Store it in the scratchpad
 110                 ADD     R14,R11,#12             ;Point to your_ref word
 111                 MOV     R2,R0                   ;Point to the buffer start
 112                 MOV     R3,R1                   ;And get the buffer size
 113                 LDR     R0,[R6,#8]              ;Load his reference number
 114                 MOV     R1,#6                   ;The RAMFetch message code
 115                 STMIA   R14,{R0-R3}             ;Save all that lot away
 116                 MOV     R0,#18                  ;Make it bounce if ignored
 117                 MOV     R1,R11                  ;Point to my message block
 118                 LDR     R2,[R6,#4]              ;Load his task handle
 119                 SWI     Wimp_SendMessage        ;And send along his message
 120
 121                 ; --- Set everything up for the acknowledgement ---
 122
 123                 MOV     R14,#lState__test       ;We're seeing if he'll cope
 124                 STR     R14,load__state         ;So save this state info
 125
 126                 ADR     R0,load__unknown        ;Point to my unknown handler
 127                 MOV     R1,#0                   ;Nothing interesting in R4
 128                 MOV     R2,#0                   ;Nothing interesting in R10
 129                 MOV     R3,R12                  ;Pass workspace in R12
 130                 BL      win_unknownHandler      ;Register my unknown handler
 131                 B       %90load                 ;And finish everything off
 132
 133                 ; --- Set up scrap transfer ---
 134
 135 40load          BL      load__doScrap           ;Start scrap transfer going
 136                 B       %90load                 ;And finish everything off
 137
 138                 ; --- Handle a Message_DataLoad ---
 139                 ;
 140                 ; If this is *not* a reply to a Message_DataSaveAck then we
 141                 ; should clear all the associated data from out message
 142                 ; cache.
 143
 144 50load          LDR     R14,[R1,#12]            ;Load message's your_ref
 145                 CMP     R14,#0                  ;Is this a new message?
 146                 BNE     %70load                 ;No -- don't do setting up
 147
 148                 ; --- Handle a new Message_DataLoad or Message_DataOpen ---
 149                 ;
 150                 ; First, copy all the message data over
 151
 152 60load          ADR     R0,load__message        ;Point to my message buffer
 153                 LDR     R2,[R1,#0]              ;Get the message block size
 154                 BL      fastMove                ;Copy it over nicely
 155
 156                 ; --- Remember we're doing file transfer ---
 157
 158                 MOV     R14,#lState__file       ;This is file transfer
 159                 STR     R14,load__state         ;Save this state value
 160
 161                 ; --- Send an immediate acknowledgement ---
 162                 ;
 163                 ; For a Message_DataOpen, this is very important -- if we
 164                 ; don't, and the application dies, we then get started all
 165                 ; over again from the command line, and probably die again
 166                 ; if it's a duff file.  For a Message_DataLoad it doesn't
 167                 ; matter too much, although I suspect we should really send
 168                 ; the acknowledgement after we loaded the file.
 169
 170 70load          MOV     R6,R1                   ;Keep the message pointer
 171                 ADD     R0,R11,#20              ;Copy to the scratchpad
 172                 ADD     R1,R6,#20               ;Point to the message data
 173                 LDR     R2,[R6,#0]              ;Get the message block size
 174                 SUB     R2,R2,#20               ;Subtract the bit not copied
 175                 BL      fastMove                ;Copy it over nicely
 176
 177                 LDR     R14,[R6,#0]             ;Load the message size word
 178                 STR     R14,[R11,#0]            ;Save it in my dummy message
 179                 LDR     R0,[R6,#8]              ;Load his my_ref field
 180                 MOV     R1,#4                   ;This is Message_DataLoadAck
 181                 ADD     R14,R11,#12             ;Point to the your_ref field
 182                 STMIA   R14,{R0,R1}             ;Save them in there
 183
 184                 MOV     R0,#17                  ;Don't want acknowledgement
 185                 MOV     R1,R11                  ;Point to the message block
 186                 LDR     R2,[R6,#4]              ;Get his task handle ready
 187                 SWI     Wimp_SendMessage        ;And acknowledge his message
 188
 189                 ; --- Tell the client to load the file ---
 190
 191                 ADR     R0,load__name           ;Point to apparent filename
 192                 ADD     R1,R6,#44               ;Point to filename to load
 193                 LDR     R2,load__state          ;Load state (safeness flag)
 194                 ADR     R14,load__entries       ;Point to the entry data
 195                 LDMIA   R14,{R5,R10,R12}        ;Load the important stuff
 196                 ADDS    R0,R0,#0                ;Clear C and V flags
 197                 MOV     R14,PC                  ;Set up his return address
 198                 ADD     PC,R5,#lEntry__file     ;Tell him to load the file
 199                 WSPACE  load__wSpace            ;Find my workspace again
 200                 STR     R10,load__R10           ;Save the new R10 value
 201                 BL      load__finish            ;Send a completed message
 202
 203                 ; --- Now delete the Wimp$Scrap file if we need to ---
 204
 205                 CMP     R2,#0                   ;Is the file `safe'?
 206                 BNE     %90load                 ;Yes -- then do nothing
 207                 MOV     R0,#27                  ;Wipe files please
 208                 ADD     R1,R6,#44               ;Point to the filename
 209                 MOV     R3,#&3                  ;No confirm, recurse
 210                 SWI     XOS_FSControl           ;Do the Wipe job
 211
 212                 ; --- We finished at last! ---
 213
 214 90load          LDMFD   R13!,{R0-R6,R10,R12,PC}^ ;Return to caller
 215
 216                 LTORG
 217
 218 ; --- load__doScrap ---
 219 ;
 220 ; On entry:     --
 221 ;
 222 ; On exit:      --
 223 ;
 224 ; Use:          Sets everything up for Wimp$Scrap-type data transfer.
 225
 226 load__doScrap   ROUT
 227
 228                 STMFD   R13!,{R0-R4,R14}        ;Save some registers
 229
 230                 ; --- First, ensure the variable <Wimp$Scrap> exists ---
 231
 232                 ADR     R0,load__wimpScrap      ;Point to my variable name
 233                 MOV     R1,R11                  ;Point to a convenient buffer
 234                 MOV     R2,#256                 ;Get the buffer size
 235                 MOV     R3,#0                   ;This is the first call
 236                 MOV     R4,#0                   ;Don't expand or anything
 237                 SWI     XOS_ReadVarVal          ;Read the variable value
 238                 BLVS    load__finish            ;If it failed, abort now
 239                 BVS     %90load__doScrap        ;And return to caller
 240
 241                 ; --- Build the message and send it ---
 242
 243                 ADD     R0,R11,#20              ;Point at scratch msg data
 244                 ADR     R1,load__message+20     ;And the saved bits of data
 245                 MOV     R2,#24                  ;All up to the filename
 246                 BL      fastMove                ;Copy all that lot over
 247
 248                 MOV     R14,#60                 ;The size of this message
 249                 STR     R14,[R11,#0]            ;Store it in the right place
 250                 LDR     R0,load__message+8      ;Load the message's my_ref
 251                 MOV     R1,#2                   ;This is Message_DataSaveAck
 252                 ADD     R14,R11,#12             ;Point to your_ref
 253                 STMIA   R14,{R0,R1}             ;Save your_ref and action
 254
 255                 ADD     R0,R11,#44              ;Point to the filename area
 256                 ADR     R1,load__scrapVar       ;Point to the variable name
 257                 BL      str_cpy                 ;Copy the string over
 258
 259                 MOV     R14,#-1                 ;Say that the data's not safe
 260                 STR     R14,[R11,#36]           ;Save -1 as estimated size
 261                 MOV     R0,#17                  ;This should be send normal
 262                 MOV     R1,R11                  ;Point at my message
 263                 LDR     R2,load__message+4      ;Load his task handle
 264                 SWI     Wimp_SendMessage        ;Send the message back
 265
 266                 ; --- Now remember we're doing scrap transfer ---
 267
 268                 MOV     R14,#lState__scrap      ;Get the right state number
 269                 STR     R14,load__state         ;And save it away nicely
 270
 271                 ; --- That's it -- we're done ---
 272
 273 90load__doScrap LDMFD   R13!,{R0-R4,PC}^        ;Return to caller
 274
 275 load__wimpScrap DCB     "Wimp$Scrap",0
 276 load__scrapVar  DCB     "<Wimp$Scrap>",0
 277
 278                 LTORG
 279
 280 ; --- load__unknown ---
 281 ;
 282 ; On entry:     R0 == an event code
 283 ;               R1 == pointer to event data
 284 ;
 285 ; On exit:      CS if we handled the event, CC otherwise
 286 ;
 287 ; Use:          Handles unknown events (i.e. user messages) during a RAM
 288 ;               transfer.
 289
 290 load__unknown   ROUT
 291
 292                 CMP     R0,#17                  ;Is it a user message?
 293                 CMPNE   R0,#18                  ;Or a bouncy user message?
 294                 BEQ     %00load__unknown        ;Yes -- handle it then
 295                 CMP     R0,#19                  ;Is it a bounced message?
 296                 BEQ     %60load__unknown        ;Yes -- deal with that
 297                 MOVS    PC,R14                  ;Nothing we could do about it
 298
 299                 ; --- Deal with a message ---
 300
 301 00load__unknown STMFD   R13!,{R14}              ;Save a register
 302                 LDR     R14,[R1,#16]            ;Load the message code
 303                 CMP     R14,#7                  ;Is it a Message_RAMTransmit?
 304                 LDMNEFD R13!,{PC}^              ;No -- ignore it then
 305
 306                 ; --- Data transfer is go ---
 307
 308                 STMFD   R13!,{R0-R6,R10}        ;Save loads of registers
 309                 MOV     R6,R1                   ;Look after the message ptr
 310                 MOV     R14,#lState__ram        ;We're doing RAM transfer now
 311                 STR     R14,load__state         ;So save this state away
 312
 313                 ; --- Have we finished data transfer yet? ---
 314
 315                 ADR     R14,load__buffStart     ;Point to the buffer info
 316                 LDMIA   R14,{R0-R2}             ;Load all the buffer stuff
 317                 LDR     R3,[R6,#24]             ;How much has he sent?
 318                 LDR     R4,load__totalSize      ;Load the total so far
 319                 ADD     R4,R4,R3                ;Add on this new size
 320                 STR     R4,load__totalSize      ;And save back the new total
 321                 CMP     R1,R3                   ;Has he sent enough data?
 322                 BNE     %30load__unknown        ;No -- then it's all over
 323
 324                 ; --- Get some more buffer space ---
 325
 326                 ADR     R14,load__entries       ;Point at his entry info
 327                 LDMIA   R14,{R5,R10,R12}        ;Load all his info out
 328                 ADDS    R0,R0,#0                ;Clear C and V flags
 329                 MOV     R14,PC                  ;Set up the return address
 330                 ADD     PC,R5,#lEntry__extend   ;Extend your buffer please
 331                 WSPACE  load__wSpace            ;Find my workspace again
 332                 BVS     %40load__unknown        ;If it failed, kill buffer
 333                 ADR     R14,load__buffStart     ;Point to the buffer info
 334                 STMIA   R14,{R0-R2}             ;Save the buffer info again
 335
 336                 ; --- Send another RAMFetch along ---
 337
 338                 MOV     R14,#28                 ;Size of a RAMFetch message
 339                 STR     R14,[R11,#0]            ;Store it in the scratchpad
 340                 ADD     R14,R11,#12             ;Point to your_ref word
 341                 MOV     R2,R0                   ;Point to the buffer start
 342                 MOV     R3,R1                   ;And get the buffer size
 343                 LDR     R0,[R6,#8]              ;Load his reference number
 344                 MOV     R1,#6                   ;The RAMFetch message code
 345                 STMIA   R14,{R0-R3}             ;Save all that lot away
 346                 MOV     R0,#18                  ;Make it bounce if ignored
 347                 MOV     R1,R11                  ;Point to my message block
 348                 LDR     R2,[R6,#4]              ;Load his task handle
 349                 SWI     Wimp_SendMessage        ;And send along his message
 350                 B       %50load__unknown        ;Finish off everything
 351
 352                 ; --- Tell the client to wrap things up ---
 353
 354 30load__unknown ADR     R0,load__name           ;Point to the `filename'
 355                 MOV     R1,R4                   ;Get the total data size
 356                 ADR     R14,load__entries       ;Point at his entry info
 357                 LDMIA   R14,{R5,R10,R12}        ;Load all his info out
 358                 ADDS    R0,R0,#0                ;Clear C and V flags
 359                 MOV     R14,PC                  ;Set up the return address
 360                 ADD     PC,R5,#lEntry__doneBuf  ;Tidy up your buffer please
 361                 WSPACE  load__wSpace            ;Find my workspace again
 362                 BVS     %40load__unknown        ;If it failed, tidy up
 363                 BL      load__finish            ;It's all over now
 364
 365                 ; --- Unattach this unknown handler ---
 366
 367                 ADR     R0,load__unknown        ;Point to my unknown handler
 368                 MOV     R1,#0                   ;Nothing interesting in R4
 369                 MOV     R2,#0                   ;Nothing interesting in R10
 370                 MOV     R3,R12                  ;Pass workspace in R12
 371                 BL      win_removeUnknownHandler ;Unattach the handler
 372                 B       %50load__unknown        ;And return nicely
 373
 374                 ; --- Tidy up after buffer extension failed ---
 375
 376 40load__unknown MOV     R4,R0                   ;Look after the error pointer
 377                 ADR     R14,load__buffStart     ;Point to the buffer info
 378                 LDMIA   R14,{R0-R2}             ;Load it all out
 379                 LDR     R12,load__R12           ;Find the client's R12
 380                 MOV     R14,PC                  ;Set up a return address
 381                 ADD     PC,R5,#lEntry__killBuf  ;Destroy the buffer
 382                 WSPACE  load__wSpace            ;Find my workspace again
 383                 MOV     R14,#V_flag             ;Get the V bit position
 384                 TEQVCP  R14,PC                  ;If clear, set it again
 385                 MOV     R0,R4                   ;Point at the error again
 386                 BL      load__finish            ;Report the error
 387
 388                 ; --- We don't need the unknown handler any more ---
 389
 390                 ADR     R0,load__unknown        ;Point to my unknown handler
 391                 MOV     R1,#0                   ;Nothing interesting in R4
 392                 MOV     R2,#0                   ;Nothing interesting in R10
 393                 MOV     R3,R12                  ;Pass workspace in R12
 394                 BL      win_removeUnknownHandler ;Unattach the handler
 395
 396                 ; --- Return to caller ---
 397
 398 50load__unknown LDMFD   R13!,{R0-R6,R10,R14}    ;Unstack all the registers
 399                 ORRS    PC,R14,#C_flag          ;And claim the event
 400
 401                 ; --- Handle a bounced message ---
 402
 403 60load__unknown STMFD   R13!,{R14}              ;Save a register
 404                 LDR     R14,[R1,#16]            ;Load the message action
 405                 CMP     R14,#6                  ;Is it one of my RAMFetches?
 406                 LDMNEFD R13!,{PC}^              ;No -- ignore it then
 407
 408                 ; --- My RAMFetch bounced! ---
 409
 410                 LDR     R14,load__state         ;Get my current state?
 411                 CMP     R14,#lState__test       ;Was I just testing the water
 412                 BLEQ    load__doScrap           ;Yes -- set up for scrap xfer
 413
 414                 ; --- Shut down the data transfer ---
 415
 416                 STMFD   R13!,{R0-R3,R10}        ;Save some more registers
 417                 ADR     R14,load__buffStart     ;Point to the buffer info
 418                 LDMIA   R14,{R0-R2}             ;Load it all out
 419                 ADR     R14,load__entries       ;Point to entry information
 420                 LDMIA   R14,{R3,R10,R12}        ;Load all the stuff out
 421                 MOV     R14,PC                  ;Set up a return address
 422                 ADD     PC,R3,#lEntry__killBuf  ;Destroy the buffer
 423                 WSPACE  load__wSpace            ;Find my workspace again
 424                 MOV     R14,#V_flag             ;Get the V bit position
 425                 TEQVCP  R14,PC                  ;If clear, set it again
 426                 MOV     R0,#0                   ;Don't report any errors
 427                 BL      load__finish            ;Report the error
 428
 429                 ; --- We don't need the unknown handler any more ---
 430
 431                 ADR     R0,load__unknown        ;Point to my unknown handler
 432                 MOV     R1,#0                   ;Nothing interesting in R4
 433                 MOV     R2,#0                   ;Nothing interesting in R10
 434                 MOV     R3,R12                  ;Pass workspace in R12
 435                 BL      win_removeUnknownHandler ;Unattach the handler
 436
 437                 LDMFD   R13!,{R0-R3,R10,R14}    ;Unstack all the registers
 438                 ORRS    PC,R14,#C_flag          ;And return with C set
 439
 440                 LTORG
 441
 442 ; --- load__finish ---
 443 ;
 444 ; On entry:     VS and R0 points to error, or VC
 445 ;
 446 ; On exit:      R10 corrupted
 447 ;
 448 ; Use:          Calls the appropriate client routine for finishing off
 449 ;               a load operation.
 450
 451 load__finish    ROUT
 452
 453                 STMFD   R13!,{R0-R2,R12,R14}    ;Save some registers
 454                 MOVVS   R1,#1                   ;If error, set button count
 455                 ADRVC   R0,load__name           ;Point to apparent name
 456                 LDRVC   R1,load__state          ;And load my state
 457                 AND     R1,R1,#1                ;Leave only safeness flag
 458                 ADR     R14,load__entries       ;Point to the entry points
 459                 LDMIA   R14,{R2,R10,R12}        ;Load the entry info
 460                 ADDVS   R2,R2,#4                ;If error, call fail entry
 461                 MOV     R14,PC                  ;Set up the return address
 462                 ADD     PC,R2,#lEntry__done     ;Call the correct entry pt
 463                 LDMFD   R13!,{R0-R2,R12,PC}^    ;Return to caller
 464
 465                 LTORG
 466
 467 ; --- load_initBuf ---
 468 ;
 469 ; On entry:     R1 == estimated file size
 470 ;               R2 == pointer to flex anchor (unallocated)
 471 ;
 472 ; On exit:      R0 == pointer to buffer start
 473 ;               R1 == buffer size
 474 ;               May return an error
 475 ;
 476 ; Use:          Initialises a flex block for use as a RAM transfer buffer.
 477 ;               This routine is suitable for use as the initBuf routine for
 478 ;               RAM transfer loading.
 479
 480                 EXPORT  load_initBuf
 481 load_initBuf    ROUT
 482
 483                 STMFD   R13!,{R14}              ;Save some registers
 484                 MOV     R0,R2                   ;Point to caller's anchor
 485                 BL      flex_alloc              ;Try to allocate the buffer
 486                 MOVCS   R1,#4096                ;Otherwise assume 4K size
 487                 BLCS    flex_alloc              ;And try again...
 488                 BLCS    alloc_error             ;If it failed, get an error
 489                 LDRCC   R0,[R0,#0]              ;Otherwise load buffer start
 490                 LDMFD   R13!,{R14}              ;Restore the link register
 491                 BICCCS  PC,R14,#V_flag          ;If no error, clear V on exit
 492                 ORRCSS  PC,R14,#V_flag          ;Otherwise set it
 493
 494                 LTORG
 495
 496 ; --- load_killBuf ---
 497 ;
 498 ; On entry:     R2 == pointer to flex anchor
 499 ;
 500 ; On exit:      --
 501 ;
 502 ; Use:          Frees a flex block.  This routine should be used to free
 503 ;               the buffer used for RAM transfer.
 504
 505                 EXPORT  load_killBuf
 506 load_killBuf    ROUT
 507
 508                 STMFD   R13!,{R0,R14}           ;Save some registers
 509                 MOV     R0,R2                   ;Point to the flex anchor
 510                 BL      flex_free               ;Free the block
 511                 MOV     R14,#0                  ;Get a zero word
 512                 STR     R14,[R2,#0]             ;Write this over the anchor
 513                 LDMFD   R13!,{R0,PC}^           ;Return to caller
 514
 515                 LTORG
 516
 517 ; --- load_extendBuf ---
 518 ;
 519 ; On entry:     R0 == pointer to previous buffer
 520 ;               R1 == size of previous buffer
 521 ;               R2 == pointer to flex anchor
 522 ;
 523 ; On exit:      R0 == pointer to a new buffer
 524 ;               R1 == size of the new buffer
 525 ;               May return an error
 526 ;
 527 ; Use:          Extends the flex block if it was initially too small.
 528 ;               This routine is designed to be used as the extend routine
 529 ;               during RAM transfer.
 530
 531                 EXPORT  load_extendBuf
 532 load_extendBuf  ROUT
 533
 534                 STMFD   R13!,{R3,R14}           ;Save some registers
 535                 MOV     R0,R2                   ;Point to the flex anchor
 536                 BL      flex_size               ;Read the block's size
 537                 MOV     R3,R0                   ;Look after the size
 538                 MOV     R0,R2                   ;Point to the flex anchor
 539                 ADD     R1,R3,#&1000            ;Extend buffer by 4K
 540                 BL      flex_extend             ;Make more space for loading
 541                 BLCS    alloc_error             ;If it failed, get an error
 542                 LDRCC   R0,[R2,#0]              ;Otherwise load the anchor
 543                 ADDCC   R0,R0,R3                ;And add the old size
 544                 MOVCC   R1,#&1000               ;Get the buffer size
 545                 LDMFD   R13!,{R3,R14}           ;Restore the registers
 546                 BICCCS  PC,R14,#V_flag          ;If no error, clear V on exit
 547                 ORRCSS  PC,R14,#V_flag          ;Otherwise set it
 548
 549                 LTORG
 550
 551 ; --- load_doneBuf ---
 552 ;
 553 ; On entry:     R1 == actual size of data
 554 ;               R2 == pointer to flex anchor
 555 ;
 556 ; On exit:      --
 557 ;
 558 ; Use:          Sets the block into which the data has been loaded to the
 559 ;               correct exact size.
 560
 561                 EXPORT  load_doneBuf
 562 load_doneBuf    ROUT
 563
 564                 STMFD   R13!,{R0,R14}           ;Save some registers
 565                 MOV     R0,R2                   ;Point to the anchor
 566                 BL      flex_extend             ;Set the block's correct size
 567                 LDMFD   R13!,{R0,PC}^           ;Return to caller
 568
 569                 LTORG
 570
 571 ; --- load_file ---
 572 ;
 573 ; On entry:     R1 == pointer to filename to load
 574 ;               R2 == pointer to flex anchor
 575 ;
 576 ; On exit:      R0 == size of file loaded
 577 ;               May return an error
 578 ;
 579 ; Use:          Loads a named file into a flex block for your delectation.
 580
 581                 EXPORT  load_file
 582 load_file       ROUT
 583
 584                 STMFD   R13!,{R0-R6,R14}        ;Save some registers
 585                 MOV     R6,R2                   ;Keep the flex anchor safe
 586
 587                 ; --- Find the file information ---
 588
 589                 MOV     R0,#17                  ;Read file information
 590                 SWI     XOS_File                ;Find the file's size
 591                 BVS     %90load_file            ;If it failed, handle error
 592                 TST     R0,#1                   ;Is the object a file?
 593                 BEQ     %80load_file            ;No -- get an error for it
 594                 STR     R4,[R13,#0]             ;Save the file size in R0
 595
 596                 ; --- Allocate the flex block ---
 597
 598                 MOV     R1,R4                   ;Get the object size in R1
 599                 MOV     R0,R6                   ;Point to caller's anchor
 600                 BL      flex_alloc              ;Try to allocate the block
 601                 BLCS    alloc_error             ;No memory -- get the message
 602                 BCS     %90load_file            ;If it failed, handle error
 603
 604                 ; --- Load file into the flex block ---
 605
 606                 MOV     R0,#16                  ;Load the file
 607                 LDR     R1,[R13,#4]             ;Load the filename address
 608                 LDR     R2,[R6,#0]              ;Load the flex anchor
 609                 MOV     R3,#0                   ;Load into my buffer please
 610                 SWI     XOS_File                ;Try to do the load op
 611                 BVS     %85load_file            ;If it failed, tidy up
 612                 LDMFD   R13!,{R0-R6,R14}        ;Unstack registers
 613                 BICS    PC,R14,#V_flag          ;And return with no error
 614
 615                 ; --- We found a bad object type ---
 616
 617 80load_file     MOV     R2,R0                   ;Get object type in R2
 618                 MOV     R0,#19                  ;Get the error message
 619                 SWI     XOS_File                ;Return pointer in R0
 620                 B       %90load_file            ;Handle error in usual way
 621
 622                 ; --- Tidy up after various errors ---
 623
 624 85load_file     MOV     R1,R0                   ;Look after the error pointer
 625                 MOV     R0,R6                   ;Point to the flex anchor
 626                 BL      flex_free               ;Free up all tht memory
 627                 MOV     R14,#0                  ;Get a zero word
 628                 STR     R14,[R6,#0]             ;And zero out the anchor
 629                 MOV     R0,R1                   ;Restore the error pointer
 630
 631 90load_file     ADD     R13,R13,#4              ;Don't restore R0 on exit
 632                 LDMFD   R13!,{R1-R6,R14}        ;Unstack registers
 633                 ORRS    PC,R14,#V_flag          ;And return with the error
 634
 635                 LTORG
 636
 637 load__wSpace    DCD     0
 638
 639 ;----- User entry points ----------------------------------------------------
 640
 641                 ^       0
 642
 643 lEntry__initBuf #       4                       ;Create a load buffer
 644                                                 ;On entry:
 645                                                 ;  R0 == ptr to `filename'
 646                                                 ;  R1 == estimated file size
 647                                                 ;  R2 == 0
 648                                                 ;On exit:
 649                                                 ;  R0 == ptr to buffer start
 650                                                 ;  R1 == ptr to buffer end
 651                                                 ;  R2 == buffer `handle'
 652                                                 ;  R10 may be updated
 653
 654 lEntry__killBuf #       4                       ;Destroy the load buffer
 655                                                 ;On entry:
 656                                                 ;  R0 == ptr to buffer start
 657                                                 ;  R1 == ptr to buffer end
 658                                                 ;  R2 == buffer `handle'
 659                                                 ;On exit:
 660                                                 ;  --
 661
 662 lEntry__extend  #       4                       ;Extend the load buffer
 663                                                 ;On entry:
 664                                                 ;  R0 == ptr to buffer start
 665                                                 ;  R1 == ptr to buffer end
 666                                                 ;  R2 == buffer `handle'
 667                                                 ;On exit:
 668                                                 ;  R0-R2 updated
 669
 670 lEntry__doneBuf #       4                       ;All data is now loaded
 671                                                 ;On entry:
 672                                                 ;  R0 == ptr to `filename'
 673                                                 ;  R1 == total size of data
 674                                                 ;  R2 == buffer `handle'
 675                                                 ;On exit:
 676                                                 ;  --
 677
 678 lEntry__file    #       4                       ;Load data from a file
 679                                                 ;On entry:
 680                                                 ;  R0 == ptr to `filename'
 681                                                 ;  R1 == file to load
 682                                                 ;  R2 == 0 if file unsafe
 683                                                 ;On exit:
 684                                                 ;  R10 may be updated
 685
 686 lEntry__done    #       4                       ;Completed loading
 687                                                 ;On entry:
 688                                                 ;  R0 == ptr to `filename'
 689                                                 ;  R1 == safeness indicator
 690                                                 ;On exit:
 691                                                 ;  --
 692
 693 lEntry__failed  #       4                       ;Failed to load file
 694                                                 ;On entry:
 695                                                 ;  R0 == pointer to error
 696                                                 ;  R1 == 1
 697                                                 ;On exit:
 698                                                 ;  --
 699
 700 ; --- Explanation ---
 701 ;
 702 ; Loading is several orders of magnitude harder than saving, at a guess.
 703 ; I've tried to make it fairly straightforward here -- there are a few
 704 ; standard routines provided for simple things like loading into a flex
 705 ; block, and a coroutine-based system for unified RAM/file transfer is
 706 ; available.
 707 ;
 708 ; Like saving, loading is based around a table of branch instructions which
 709 ; perform application-specific actions during the load operation.  All the
 710 ; message passing protocol is hidden away, and all you have to do is write
 711 ; the entries for the table.
 712 ;
 713 ; If you want to support RAM-transfer, you must provide three buffer
 714 ; handling routines:
 715 ;
 716 ; * initBuf is called when load is attempting to start a RAM transfer with
 717 ;   the saving application.  It should create a buffer of appropriate size
 718 ;   (possibly based on the estimated file size already given).  You can
 719 ;   declare a buffer handle at this point, which is passed to all other
 720 ;   routines that need to deal with the buffer.  It may return an error.
 721 ;
 722 ;   If you can't handle RAM transfer, you should replace the branch
 723 ;   instruction here with a null word.
 724 ;
 725 ; * extend is called if the previous buffer was filled and there is more
 726 ;   data to come.  The address of the previous buffer is returned to you,
 727 ;   so either you can process it there and then, or extend the buffer in
 728 ;   some way.  You just have to return a new area of memory to fill with
 729 ;   data.  It may return an error.
 730 ;
 731 ; * doneBuf is called when all the data has been loaded, so that the buffer
 732 ;   can be set to the exact right size.
 733 ;
 734 ; * killBuf is called if the attempt to load via RAM transfer failed and
 735 ;   the buffer has to be destroyed.  It is always called whenever there is
 736 ;   a fault during RAM transfer, even if one of your other entry points
 737 ;   raised the error.
 738 ;
 739 ; * file is called if you have to load a file from the filing system, either
 740 ;   because RAM transfer failed or because you received a direct load from
 741 ;   the Filer.  It may return an error.
 742 ;
 743 ; * done is called when the data transfer is successfully completed.
 744 ;
 745 ; * failed is called when the data transfer fails due to an error.
 746
 747 ;----- Workspace ------------------------------------------------------------
 748
 749                 ^       0,R12
 750 load__wStart    #       0
 751
 752 load__state     #       4                       ;The current state (1 byte)
 753
 754 load__entries   #       4                       ;Pointer to entry pt block
 755 load__R10       #       4                       ;Client's R10 value
 756 load__R12       #       4                       ;Client's R12 value
 757
 758 load__buffStart #       4                       ;The buffer's start address
 759 load__buffSize  #       4                       ;And its size
 760 load__buffHnd   #       4                       ;Client's buffer handle
 761
 762 load__totalSize #       4                       ;How much data we've received
 763
 764 load__message   #       44                      ;The original load/save msg
 765 load__name      #       212                     ;The file's apparent name
 766
 767 load__wSize     EQU     {VAR}-load__wStart
 768
 769                 ; --- States ---
 770                 ;
 771                 ; These have been carefully arranged so that we can return
 772                 ; the safeness flag to various routines.  If we only
 773                 ; consider files, then the state /is/ the safeness flag.
 774                 ; Otherwise we only use the bottom bit of the state.
 775
 776 lState__scrap   EQU     0                       ;We're doing scrap transfer
 777 lState__file    EQU     1                       ;We're loading from a file
 778 lState__test    EQU     2                       ;We're testing RAM transfer
 779 lState__ram     EQU     4                       ;We're doing RAM transfer
 780
 781                 AREA    |Sapphire$$LibData|,CODE,READONLY
 782
 783                 DCD     load__wSize
 784                 DCD     load__wSpace
 785                 DCD     256
 786                 DCD     0
 787
 788 ;----- That's all, folks ----------------------------------------------------
 789
 790                 END