chiark - git - mdw - ssr/blob - StraySrc/Libraries/Sapphire/sail/_s/termite

   1 ;
   2 ; termite.s
   3 ;
   4 ; Implementation of Termite specific instructions
   5 ;
   6 ; © 1995 Straylight
   7 ;
   8
   9 ;----- Standard header ------------------------------------------------------
  10
  11                 GET     libs:header
  12                 GET     libs:swis
  13
  14                 GET     libs:stream
  15
  16 ;----- External dependencies ------------------------------------------------
  17
  18                 GET     sh.anchor
  19                 GET     sh.ctrl
  20                 GET     sh.errNum
  21                 GET     sh.error
  22                 GET     sh.express
  23                 GET     sh.getToken
  24                 GET     sh.interp
  25                 GET     sh.stracc
  26                 GET     sh.strBucket
  27                 GET     sh.termscript
  28                 GET     sh.tokens
  29                 GET     sh.upcalls
  30                 GET     sh.var
  31
  32 ;----- Main code ------------------------------------------------------------
  33
  34                 AREA    |TermScript$$Code|,CODE,READONLY
  35
  36 ; --- termite_beep ---
  37
  38                 EXPORT  termite_beep
  39 termite_beep    ROUT
  40
  41                 TCALL   termite_makeBeep        ;Make a beep
  42                 B       interp_next             ;And go for more
  43
  44                 LTORG
  45
  46 ; --- termite_break ---
  47
  48                 EXPORT  termite_break
  49 termite_break   ROUT
  50
  51                 TCALL   termite_sendBreak       ;Send the break
  52                 BL      termite__error          ;Handle possible error
  53                 B       interp_next             ;And go for more
  54
  55                 LTORG
  56
  57 ; --- termite_call ---
  58
  59                 EXPORT  termite_call
  60 termite_call    ROUT
  61
  62                 BL      ctrl_setUpRegs          ;Set up the regs then
  63
  64                 CMP     R10,#vType_integer      ;Is this an integer?
  65                 MOVNE   R0,#err_numNeeded       ;No -- get error number
  66                 BNE     error_report            ;...and report the error
  67
  68                 MOV     R14,PC                  ;Set up return address
  69                 MOV     PC,R9                   ;Execute the code
  70
  71                 LDR     R9,=termite__retned     ;Point to some space
  72                 STMIA   R9!,{R0-R8}             ;Store returned registers
  73                 MOV     R14,PC,LSR #28          ;Get the flags
  74                 STMIA   R9,{R14}                ;Strore the flags too
  75                 LDMFD   R13!,{R7-R12}           ;Load back position info
  76                 LDMFD   R13!,{R0}               ;Load stracc offset
  77                 BL      stracc_free             ;Free any strings I had
  78
  79                 ; --- We have now done the SWI instr ---
  80
  81                 LDR     R0,=termite__retned     ;Point to the returned regs
  82                 BL      ctrl_resolveRegs        ;Do the other half now
  83                 B       interp_next             ;If flags -- return
  84
  85                 LTORG
  86
  87 ; --- termite_chain ---
  88
  89                 EXPORT  termite_chain
  90 termite_chain   ROUT
  91
  92                 ; --- Read a parameter ---
  93
  94                 MOV     R0,#0                   ;Read an rvalue
  95                 BL      express_read            ;Read it then
  96                 BL      express_pop             ;And get it off the stack
  97                 CMP     R1,#vType_string        ;Is this a string?
  98                 MOVNE   R0,#err_strNeeded       ;Nope -- get error number
  99                 BNE     error_report            ;...and report the error
 100
 101                 LDR     R1,tsc_stracc           ;Get the stracc address
 102                 LDR     R1,[R1]
 103                 ADD     R1,R1,R0,LSR #8         ;Point to the string
 104                 AND     R2,R0,#&FF              ;Get the length
 105
 106                 ADR     R0,tsc_misc+8*4         ;Point to the misc buffer
 107                 BL      termite_copyString      ;Copy the string over
 108                 B       tsc_end                 ;End the script, and chain
 109
 110                 LTORG
 111
 112 ; --- termite_close ---
 113
 114                 EXPORT  termite_close
 115 termite_close   ROUT
 116
 117                 MOV     R0,#-1                  ;Close the session
 118                 B       tsc_end                 ;Do that then
 119
 120                 LTORG
 121
 122 ; --- termite_cls ---
 123
 124                 EXPORT  termite_cls
 125 termite_cls     ROUT
 126
 127                 TCALL   termite_clearScreen     ;Clear the screen
 128                 BL      termite__error          ;Handle possible error
 129                 B       interp_next             ;And go for more
 130
 131                 LTORG
 132
 133 ; --- termite_download ---
 134
 135                 EXPORT  termite_download
 136 termite_download ROUT
 137
 138                 MOV     R0,#0                   ;Read an rvalue
 139                 BL      express_read            ;Read it then
 140                 BL      express_pop             ;And get it off the stack
 141                 CMP     R1,#vType_string        ;Is this a string?
 142                 MOVNE   R0,#err_strNeeded       ;Nope -- get error number
 143                 BNE     error_report            ;...and report the error
 144
 145                 ; --- Null terminate this ---
 146
 147                 MOV     R2,R0                   ;Look after the offset
 148                 MOV     R5,#0                   ;Useful, t' be sure
 149                 BL      stracc_ensure           ;Ensure we have space
 150                 STRB    R5,[R0,#0]              ;Terminate the string
 151                 ORR     R0,R1,#1                ;Get the rvalue
 152                 BL      stracc_added            ;Tell stracc about terminator
 153
 154                 ; --- Check for another string ---
 155
 156                 CMP     R9,#','                 ;Do we have a comma?
 157                 MOVNE   R3,#0                   ;No -- use default then
 158                 BNE     %10termite_download     ;...and jump ahead
 159
 160                 BL      getToken                ;Skip over the comma
 161                 MOV     R0,#0                   ;Read an rvalue
 162                 BL      express_read            ;Read it then
 163                 BL      express_pop             ;And get it off the stack
 164                 CMP     R1,#vType_string        ;Is this a string?
 165                 MOVNE   R0,#err_strNeeded       ;Nope -- get error number
 166                 BNE     error_report            ;...and report the error
 167
 168                 ; --- Null terminate this ---
 169
 170                 MOV     R3,R0                   ;Look after the offset
 171                 MOV     R5,#0                   ;Useful, t' be sure
 172                 BL      stracc_ensure           ;Ensure we have space
 173                 STRB    R5,[R0,#0]              ;Terminate the string
 174                 ORR     R0,R1,#1                ;Get the rvalue
 175                 BL      stracc_added            ;Tell stracc about terminator
 176
 177                 ; --- Do the download now ---
 178
 179 10              LDR     R1,tsc_stracc           ;Load stracc address
 180                 MOV     R4,R2                   ;Look after the offet
 181                 ADD     R2,R1,R2                ;Point to protocal name
 182                 CMP     R3,#0                   ;Do we have a filename?
 183                 ADDNE   R3,R1,R3                ;Yes -- point to it then
 184                 TCALL   termite_downLoad        ;Do the download
 185                 BL      termite__error          ;Handle possible error
 186                 MOV     R0,R4                   ;Get offset of protocol name
 187                 BL      stracc_free             ;Free it now
 188                 B       interp_next             ;Do another instruction
 189
 190                 LTORG
 191
 192 ; --- termite_error ---
 193
 194                 EXPORT  termite_error
 195 termite_error   ROUT
 196
 197                 CMP     R9,#tok_on              ;Is this an option?
 198                 CMPNE   R9,#tok_off
 199                 BEQ     %50termite_error        ;Yes -- jump ahead
 200
 201                 ; --- Read a parameter ---
 202
 203                 MOV     R0,#0                   ;Read an rvalue
 204                 BL      express_read            ;Read it then
 205                 BL      express_pop             ;And get it off the stack
 206                 CMP     R1,#vType_string        ;Is this a string?
 207                 MOVNE   R0,#err_strNeeded       ;Nope -- get error number
 208                 BNE     error_report            ;...and report the error
 209
 210                 LDR     R1,tsc_stracc           ;Get the stracc address
 211                 LDR     R1,[R1]
 212                 ADD     R1,R1,R0,LSR #8         ;Point to the string
 213                 AND     R2,R0,#&FF              ;Get the length
 214
 215                 MOV     R5,R0                   ;look after the rvalue
 216                 ADR     R0,tsc_misc             ;Point to the misc buffer
 217                 MOV     R14,#1                  ;A sillu error number
 218                 STR     R14,[R0],#4             ;Store that
 219                 BL      termite_copyString      ;Copy the string over
 220                 ADR     R0,tsc_misc             ;Point to the misc buffer
 221                 B       tsc_error               ;Return the error
 222
 223                 ; --- There was an option ---
 224
 225 50termite_error LDR     R0,tsc_flags            ;Load the flags word
 226                 CMP     R9,#tok_on              ;Turn on the errors?
 227                 ORREQ   R0,R0,#tscFlag_error    ;Yes -- set the bit then
 228                 BICEQ   R0,R0,#tscFlag_error    ;No -- clear it then
 229                 STR     R0,tsc_flags            ;Store the flags back
 230                 BL      getToken                ;Skip over the token
 231                 B       interp_next             ;Do the next one
 232
 233                 LTORG
 234
 235 ; --- termite_exec ---
 236
 237                 EXPORT  termite_exec
 238 termite_exec    ROUT
 239
 240                 ; --- Read a parameter ---
 241
 242                 MOV     R0,#0                   ;Read an rvalue
 243                 BL      express_read            ;Read it then
 244                 BL      express_pop             ;And get it off the stack
 245                 CMP     R1,#vType_string        ;Is this a string?
 246                 MOVNE   R0,#err_strNeeded       ;Nope -- get error number
 247                 BNE     error_report            ;...and report the error
 248
 249                 LDR     R1,tsc_stracc           ;Get the stracc address
 250                 LDR     R1,[R1]
 251                 ADD     R1,R1,R0,LSR #8         ;Point to the string
 252                 AND     R2,R0,#&FF              ;Get the length
 253
 254                 MOV     R5,R0                   ;look after the rvalue
 255                 ADR     R0,tsc_misc+8*4         ;Point to the misc buffer
 256                 BL      termite_copyString      ;Copy the string over
 257                 MOV     R0,R5                   ;Get the rvalue
 258                 BL      stracc_free             ;Free the string from stracc
 259                 ADR     R0,tsc_misc+8*4         ;Point to the misc buffer
 260                 ORR     R0,R0,#(1<<30)          ;Make this into an exec
 261                 BL      tsc_end                 ;Exec new script
 262                 B       interp_next             ;Continue happily
 263
 264                 LTORG
 265
 266 ; --- termite_finish ---
 267
 268                 EXPORT  termite_finish
 269 termite_finish  ROUT
 270
 271                 TCALL   termite_finishSession   ;Finish the session
 272                 B       interp_next             ;And go round for more
 273
 274                 LTORG
 275
 276 ; --- termite_hangup ---
 277
 278                 EXPORT  termite_hangup
 279 termite_hangup  ROUT
 280
 281                 TCALL   termite_dropCarrier     ;Hang up the modem
 282                 B       interp_next             ;And go for more
 283
 284                 LTORG
 285
 286 ; --- termite_lclear ---
 287
 288                 EXPORT  termite_lclear
 289 termite_lclear  ROUT
 290
 291                 TCALL   termite_clearLocal      ;Clear the buffer
 292                 B       interp_next             ;And go for more
 293
 294                 LTORG
 295
 296 ; --- termite_lecho ---
 297
 298                 EXPORT  termite_lecho
 299 termite_lecho   ROUT
 300
 301                 CMP     R9,#tok_off             ;Is this an option thingy?
 302                 CMPNE   R9,#tok_local
 303                 CMPNE   R9,#tok_remote
 304                 CMPNE   R9,#tok_both
 305                 BEQ     %50termite_lecho        ;Yes -- deal seperately
 306
 307                 ; --- Just echo the result to the screen then ---
 308
 309                 MOV     R0,#0                   ;Read an rvalue
 310                 BL      express_read            ;Read the next expression
 311                 BL      express_pop             ;Get the value in R0,R1
 312                 CMP     R1,#vType_integer       ;Is this an integer?
 313                 BEQ     %10termite_lecho        ;Yes -- jump ahead
 314                 CMP     R1,#vType_string        ;Or a string?
 315                 MOVNE   R0,#err_arrayBad
 316                 BNE     error_report
 317
 318                 ; --- Display a string ---
 319
 320                 LDR     R2,tsc_stracc           ;Get the stracc address
 321                 LDR     R2,[R2]
 322                 ADD     R2,R2,R0,LSR #8         ;Point to the string
 323                 AND     R3,R0,#&FF              ;Get the length
 324                 BL      termite__doSpool        ;Maybe spool this lot
 325                 TCALL   termite_sendLocal       ;Write out the message
 326                 BL      termite__error          ;Handle possible error
 327                 BL      stracc_free             ;Free the string from stracc
 328                 B       %20termite_lecho        ;Jump ahead
 329
 330                 ; --- Display an integer on the screen ---
 331
 332 10termite_lecho ADR     R1,tsc_misc             ;Point to a nice buffer
 333                 MOV     R2,#256                 ;The buffer is big
 334                 SWI     OS_ConvertInteger4      ;Convert the number to a str
 335                 SUB     R3,R1,R0                ;Get the length
 336                 MOV     R2,R0                   ;Point at the block
 337                 BL      termite__doSpool        ;Maybe spool this lot
 338                 TCALL   termite_sendLocal       ;Write out the message
 339                 BL      termite__error          ;Handle possible error
 340
 341                 ; --- Maybe write out the return char ---
 342
 343 20termite_lecho CMP     R9,#';'                 ;Is there a semicolon now?
 344                 BLEQ    getToken                ;Yes -- get a token
 345                 BEQ     interp_next             ;...read another instr
 346
 347                 LDR     R2,tsc_bucket           ;Get the bucket anchor
 348                 LDR     R2,[R2]
 349                 LDR     R0,tsc_lnewline         ;Load the newline offset
 350                 CMP     R0,#0                   ;Is there one?
 351                 BEQ     interp_next             ;No -- stop here then
 352                 ADD     R2,R2,R0                ;Point to the string
 353                 LDRB    R3,[R2,#-1]             ;Load out the length
 354                 BL      termite__doSpool        ;Maybe spool this lot
 355                 TCALL   termite_sendLocal       ;Write out the terminator
 356                 BL      termite__error          ;Handle possible error
 357                 B       interp_next             ;And read another instruction
 358
 359                 ; --- Handle the options ---
 360
 361 50termite_lecho LDR     R0,tsc_flags            ;Load the flags word
 362                 BIC     R0,R0,#tscFlag_echoLR+tscFlag_echoLL
 363                 CMP     R9,#tok_local           ;Do we require local echoing?
 364                 CMPNE   R9,#tok_both
 365                 ORREQ   R0,R0,#tscFlag_echoLL   ;Yes -- set the flag
 366                 CMP     R9,#tok_remote          ;Do we require remote echos?
 367                 CMPNE   R9,#tok_both
 368                 ORREQ   R0,R0,#tscFlag_echoLR   ;Yes -- set the flag
 369                 STR     R0,tsc_flags            ;Store back the flags word
 370                 BL      getToken                ;Get another token
 371
 372                 B       interp_next             ;Keep on going then!
 373
 374                 LTORG
 375
 376 ; -- termite_linput ---
 377
 378                 EXPORT  termite_linput
 379 termite_linput  ROUT
 380
 381                 MOV     R0,#1                   ;Read an lvalue
 382                 BL      express_read            ;Read it in
 383
 384                 ; --- Now enter a string reading loop ---
 385
 386                 BL      stracc_ensure           ;Make sure that there's room
 387                 MOV     R2,R0                   ;Look after address
 388                 MOV     R4,R0                   ;Twice
 389                 MOV     R5,#0                   ;The length so far
 390                 MOV     R3,#1                   ;Length of buffer to echo
 391
 392 00
 393                 TCALL   termite_readLocal       ;Read a byte from the buffer
 394                 CMP     R0,#-1                  ;Was there one?
 395                 BLEQ    tsc_wait                ;No -- wait for it then
 396                 LDREQ   R2,tsc_stracc
 397                 LDREQ   R2,[R2]
 398                 ADDEQ   R2,R2,R1,LSR #8
 399                 ADDEQ   R2,R2,R5
 400                 BEQ     %b00
 401                 CMP     R0,#127                 ;Is this a delete?
 402                 CMPNE   R0,#8
 403                 BEQ     %f05                    ;Yes -- deal with that then
 404                 CMP     R0,#32                  ;Was it valid?
 405                 STRGEB  R0,[R2,#0]              ;Yes -- store the byte
 406                 BLGE    termite_doLEcho         ;Echo the buffer
 407                 ADDGE   R2,R2,#1                ;Increment the pointer
 408                 ADDGE   R5,R5,#1                ;Increment the length
 409                 CMP     R0,#13                  ;Are we finished?
 410                 CMPNE   R5,#256
 411                 BLT     %b00                    ;No -- get some more then
 412                 B       %f10                    ;Finished -- jump ahead
 413
 414                 ; --- Do a delete operation ---
 415
 416 05              CMP     R5,#0                   ;Is the buffer empty?
 417                 BLE     %b00                    ;Yes -- do nothing
 418                 MOV     R14,#8                  ;Get a backspace
 419                 STRB    R14,[R2,#0]             ;Store it...
 420                 STRB    R14,[R2,#2]             ;In two places
 421                 MOV     R14,#32                 ;And a space too
 422                 STRB    R14,[R2,#1]             ;Put that in the middle
 423                 MOV     R3,#3                   ;Send 3 characters
 424                 BLGE    termite_doLEcho         ;Echo the buffer
 425                 SUB     R2,R2,#1                ;Reduce the address
 426                 SUB     R5,R5,#1                ;And the number of chars
 427                 MOV     R3,#1                   ;Put R3 back to 1
 428                 B       %b00                    ;Join main loop again
 429
 430                 ; --- We have finished reading the string ---
 431
 432 10              ORR     R0,R1,R5                ;Get the rvalue
 433                 MOV     R1,#vType_string        ;This is a string
 434                 BL      stracc_added            ;Tell stracc about this
 435                 MOV     R3,R1                   ;Move these up a little
 436                 MOV     R2,R0
 437                 BL      express_pop             ;Get my lvalue off
 438                 BL      ctrl_store              ;Store this away
 439                 B       interp_next             ;Do another command
 440
 441                 LTORG
 442
 443 ; --- termite_lnewline ---
 444
 445                 EXPORT  termite_lnewline
 446 termite_lnewline ROUT
 447
 448                 CMP     R9,#'='                 ;Next char must be `='
 449                 MOVNE   R0,#err_expEq           ;If it isn't, moan
 450                 BNE     error_report
 451                 BL      getToken                ;Skip past the equals sign
 452
 453                 LDR     R0,tsc_lnewline         ;Get existing offset
 454                 BL      strBucket_free          ;Free it
 455                 MOV     R0,#0                   ;Prepare to read rvalue
 456                 BL      express_read            ;Read it then
 457                 BL      express_pop             ;Pop it off the stack
 458                 CMP     R1,#vType_string        ;Is it a string?
 459                 MOVNE   R0,#err_strNeeded       ;No -- get error number
 460                 BNE     error_report            ;And report the error
 461                 BL      termite__storeStr       ;Store in the bucket
 462                 STR     R0,tsc_lnewline         ;Store the new offset
 463                 B       interp_next             ;And do the next instruction
 464
 465 ; --- termite_log ---
 466
 467                 EXPORT  termite_log
 468 termite_log     ROUT
 469
 470                 ; --- Load the first parameter ---
 471
 472                 MOV     R0,#0                   ;Read an rvalue
 473                 BL      express_read            ;Read it then
 474                 BL      express_pop             ;And get it off the stack
 475                 CMP     R1,#vType_string        ;Is this a string?
 476                 MOVNE   R0,#err_strNeeded       ;Nope -- get error number
 477                 BNE     error_report            ;...and report the error
 478
 479                 LDR     R1,tsc_stracc           ;Get the stracc address
 480                 LDR     R1,[R1]
 481                 ADD     R1,R1,R0,LSR #8         ;Point to the string
 482                 AND     R2,R0,#&FF              ;Get the length
 483
 484                 MOV     R5,R0                   ;Look after the rvalue
 485                 ADR     R0,tsc_misc             ;Point to the misc buffer
 486                 BL      termite_copyString      ;Copy the string over
 487                 TCALL   termite_logFileAdd      ;Add the string to the log
 488                 BL      termite__error          ;Handle possible error
 489                 MOV     R0,R5                   ;Get the rvalue back
 490                 BL      stracc_free             ;Free it from stracc
 491                 B       interp_next             ;Return to main loop
 492
 493                 LTORG
 494
 495 ; --- termite_newsession ---
 496
 497                 EXPORT  termite_newsession
 498 termite_newsession ROUT
 499
 500                 ; --- Read the base name ---
 501
 502                 MOV     R0,#0                   ;Read an rvalue
 503                 BL      express_read            ;Read it then
 504                 BL      express_pop             ;Get the rvalue
 505                 CMP     R1,#vType_string        ;Is it a string?
 506                 MOVNE   R0,#err_numNeeded       ;No -- get the error number
 507                 BNE     error_report            ;And report the error
 508
 509                 ; --- NULL terminate it ---
 510                 ;
 511                 ; We rely on the fact that there can't be anything else
 512                 ; after this string.  It is also important that we remember
 513                 ; the stracc offset of this string, so that all the strings
 514                 ; can be removed from stracc in one go.
 515
 516                 MOV     R3,R1                   ;Look after the offset
 517                 MOV     R5,#0                   ;Useful, t' be sure
 518                 BL      stracc_ensure           ;Ensure we have space
 519                 STRB    R5,[R0,#0]              ;Terminate the string
 520                 ORR     R0,R1,#1                ;Get the rvalue
 521                 BL      stracc_added            ;Tell stracc about terminator
 522
 523                 ; --- Read the sub-style name ---
 524
 525                 MOV     R0,#0                   ;Read an rvalue
 526                 BL      express_read            ;Read it then
 527                 BL      express_pop             ;Get the rvalue
 528                 CMP     R1,#vType_string        ;Is it a string?
 529                 MOVNE   R0,#err_numNeeded       ;No -- get the error number
 530                 BNE     error_report            ;And report the error
 531
 532                 ; --- NULL terminate it ---
 533
 534                 MOV     R6,R1                   ;Look after the offset
 535                 BL      stracc_ensure           ;Ensure we have space
 536                 STRB    R5,[R0,#0]              ;Terminate the string
 537                 ADD     R4,R1,#(1<<8)           ;The next string will go here
 538                 ORR     R0,R1,#1                ;Get the rvalue
 539                 BL      stracc_added            ;Tell stracc about terminator
 540
 541                 ; --- Now we keep on adding strings to the list ---
 542
 543 05              CMP     R9,#','                 ;Do we have a comma?
 544                 BNE     %50termite_newsession   ;No -- do the deed then
 545                 BL      getToken                ;Skip over the comma
 546
 547                 MOV     R0,#0                   ;Read an rvalue
 548                 BL      express_read            ;Read it then
 549                 BL      express_pop             ;Pop off the string
 550                 CMP     R1,#vType_dimStr        ;Is this a string array?
 551                 BEQ     %10termite_newsession   ;Yes -- jump ahead
 552                 CMP     R1,#vType_string        ;Is it a string?
 553                 MOVNE   R0,#err_strNeeded       ;No -- get the error number
 554                 BNE     error_report            ;And report the error
 555
 556                 ; --- We have a string then ---
 557
 558                 CMP     R0,#0                   ;Does it have a length?
 559                 BEQ     %05termite_newsession   ;No -- find another one then
 560                 BL      stracc_ensure           ;Ensure we have space
 561                 STRB    R5,[R0,#0]              ;Terminate the string
 562                 ORR     R0,R1,#1                ;Get the rvalue
 563                 BL      stracc_added            ;Tell stracc about terminator
 564                 B       %05termite_newsession   ;Find another string
 565
 566                 ; --- We have a string array ---
 567
 568 10              MOV     R3,R0                   ;Look after rvalue
 569                 MOV     R2,#0                   ;Start from the beginning
 570 15              MOV     R1,R3                   ;Put it in R1
 571                 BL      termite__enumArray      ;Get an element
 572                 BCC     %05termite_newsession   ;No more, get another string
 573                 ANDS    R14,R0,#&FF             ;Get the length
 574                 BEQ     %15termite_newsession   ;Zero -- get another one then
 575                 BL      stracc_ensure           ;Ensure we have space
 576                 STRB    R5,[R0,#0]              ;Terminate the string
 577                 ORR     R0,R1,#1                ;Get the rvalue
 578                 BL      stracc_added            ;Tell stracc about terminator
 579                 B       %15termite_newsession   ;Find another element
 580
 581                 ; --- All the strings are in stracc now ---
 582                 ;
 583                 ; First, we terminate the list
 584
 585 50              BL      stracc_ensure           ;Ensure we have space
 586                 STRB    R5,[R0,#0]              ;Terminate the string
 587                 ORR     R0,R1,#1                ;Get the rvalue
 588                 BL      stracc_added            ;Tell stracc about terminator
 589
 590                 ; --- Now, point to the strings ---
 591
 592                 LDR     R5,tsc_stracc           ;Load stracc anchor
 593                 LDR     R5,[R5]
 594                 ADD     R0,R5,R3,LSR #8         ;Point to the base name
 595                 ADD     R1,R5,R6,LSR #8         ;Point to the sub-style
 596                 ADD     R2,R5,R4,LSR #8         ;Point to strings
 597
 598                 TCALL   termite_newSession      ;Open the session
 599                 BL      termite__error          ;Handle possible error
 600
 601                 MOV     R0,R3                   ;Put the offset in R0
 602                 BL      stracc_free             ;Free all those strings!
 603                 B       interp_next             ;Do the next instruction
 604
 605                 LTORG
 606
 607 ; --- termite_oscli ---
 608
 609                 EXPORT  termite_oscli
 610 termite_oscli   ROUT
 611
 612                 ; --- Read a parameter ---
 613
 614                 MOV     R0,#0                   ;Read an rvalue
 615                 BL      express_read            ;Read it then
 616                 BL      express_pop             ;And get it off the stack
 617                 CMP     R1,#vType_string        ;Is this a string?
 618                 MOVNE   R0,#err_strNeeded       ;Nope -- get error number
 619                 BNE     error_report            ;...and report the error
 620
 621                 LDR     R1,tsc_stracc           ;Get the stracc address
 622                 LDR     R1,[R1]
 623                 ADD     R1,R1,R0,LSR #8         ;Point to the string
 624                 AND     R2,R0,#&FF              ;Get the length
 625
 626                 MOV     R5,R0                   ;look after the rvalue
 627                 ADR     R0,tsc_misc             ;Point to the misc buffer
 628                 BL      termite_copyString      ;Copy the string over
 629                 SWI     Wimp_StartTask          ;Do the command
 630                 MOV     R0,R5                   ;Get the rvalue back
 631                 BL      stracc_free             ;Free the string from stracc
 632                 B       interp_next             ;Continue happily
 633
 634                 LTORG
 635
 636 ; --- termite_rclear ---
 637
 638                 EXPORT  termite_rclear
 639 termite_rclear  ROUT
 640
 641                 TCALL   termite_clearRemote     ;Clear the buffer
 642                 B       interp_next             ;And go for more
 643
 644                 LTORG
 645
 646 ; --- termite_recho ---
 647
 648                 EXPORT  termite_recho
 649 termite_recho   ROUT
 650
 651                 CMP     R9,#tok_off             ;Is this an option thingy?
 652                 CMPNE   R9,#tok_local
 653                 CMPNE   R9,#tok_remote
 654                 CMPNE   R9,#tok_both
 655                 BEQ     %50termite_recho        ;Yes -- deal seperately
 656
 657                 ; --- Just echo the result to the screen then ---
 658
 659                 MOV     R0,#0                   ;Read an rvalue
 660                 BL      express_read            ;Read the next expression
 661                 BL      express_pop             ;Get the value in R0,R1
 662                 CMP     R1,#vType_integer       ;Is this an integer?
 663                 BEQ     %10termite_recho        ;Yes -- jump ahead
 664                 CMP     R1,#vType_string        ;Or a string?
 665                 MOVNE   R0,#err_arrayBad
 666                 BNE     error_report
 667
 668                 ; --- Display a string ---
 669
 670                 LDR     R2,tsc_stracc           ;Get the stracc address
 671                 LDR     R2,[R2]
 672                 ADD     R2,R2,R0,LSR #8         ;Point to the string
 673                 AND     R3,R0,#&FF              ;Get the length
 674                 TCALL   termite_sendRemote      ;Write out the message
 675                 BL      termite__error          ;Handle possible error
 676                 BL      stracc_free             ;Free the string from stracc
 677                 B       %20termite_recho        ;Maybe write out return char
 678
 679                 ; --- Display an integer on the screen ---
 680
 681 10termite_recho ADR     R1,tsc_misc             ;Point to a nice buffer
 682                 MOV     R2,#256                 ;The buffer is big
 683                 SWI     OS_ConvertInteger4      ;Convert the number to a str
 684                 SUB     R3,R1,R0                ;Get the length
 685                 MOV     R2,R0                   ;Point at the block
 686                 TCALL   termite_sendRemote      ;Write out the message
 687                 BL      termite__error          ;Handle possible error
 688
 689                 ; --- Maybe write out the return char ---
 690
 691 20termite_recho CMP     R9,#';'                 ;Is there a semicolon now?
 692                 BLEQ    getToken                ;Yes -- get a token
 693                 BEQ     interp_next             ;...read another instr
 694
 695                 LDR     R2,tsc_bucket           ;Get the bucket anchor
 696                 LDR     R2,[R2]
 697                 LDR     R0,tsc_rnewline         ;Load the newline offset
 698                 CMP     R0,#0                   ;Is there one?
 699                 BEQ     interp_next             ;No -- stop here then
 700                 ADD     R2,R2,R0                ;Point to the string
 701                 LDRB    R3,[R2,#-1]             ;Load out the length
 702                 TCALL   termite_sendRemote      ;Write out the terminator
 703                 BL      termite__error          ;Handle possible error
 704                 B       interp_next             ;And read another instruction
 705
 706                 ; --- Handle the options ---
 707
 708 50termite_recho LDR     R0,tsc_flags            ;Load the flags word
 709                 BIC     R0,R0,#tscFlag_echoRR+tscFlag_echoRL
 710                 CMP     R9,#tok_local           ;Do we require local echoing?
 711                 CMPNE   R9,#tok_both
 712                 ORREQ   R0,R0,#tscFlag_echoRL   ;Yes -- set the flag
 713                 CMP     R9,#tok_remote          ;Do we require remote echos?
 714                 CMPNE   R9,#tok_both
 715                 ORREQ   R0,R0,#tscFlag_echoRR   ;Yes -- set the flag
 716                 STR     R0,tsc_flags            ;Store back the flags word
 717                 BL      getToken                ;Get another token
 718
 719                 B       interp_next             ;Keep on going then!
 720
 721                 LTORG
 722
 723 ; --- termite_report ---
 724
 725                 EXPORT  termite_report
 726 termite_report  ROUT
 727
 728                 ; --- Read a parameter ---
 729
 730                 MOV     R0,#0                   ;Read an rvalue
 731                 BL      express_read            ;Read it then
 732                 BL      express_pop             ;And get it off the stack
 733                 CMP     R1,#vType_string        ;Is this a string?
 734                 MOVNE   R0,#err_strNeeded       ;Nope -- get error number
 735                 BNE     error_report            ;...and report the error
 736
 737                 LDR     R1,tsc_stracc           ;Get the stracc address
 738                 LDR     R1,[R1]
 739                 ADD     R1,R1,R0,LSR #8         ;Point to the string
 740                 AND     R2,R0,#&FF              ;Get the length
 741
 742                 MOV     R5,R0                   ;look after the rvalue
 743                 ADR     R0,tsc_misc             ;Point to the misc buffer
 744                 BL      termite_copyString      ;Copy the string over
 745                 TCALL   termite_printMessage    ;Report the message
 746                 MOV     R0,R5                   ;Get the rvalue back
 747                 BL      stracc_free             ;Free the string from stracc
 748                 B       interp_next             ;Continue happily
 749
 750                 LTORG
 751
 752 ; --- termite_rinput ---
 753
 754                 EXPORT  termite_rinput
 755 termite_rinput  ROUT
 756
 757                 MOV     R0,#1                   ;Read an lvalue
 758                 BL      express_read            ;Read it in
 759
 760                 ; --- Now enter a string reading loop ---
 761
 762                 BL      stracc_ensure           ;Make sure that there's room
 763                 MOV     R2,R0                   ;Look after address
 764                 MOV     R4,R0                   ;Twice
 765                 MOV     R5,#0                   ;The length so far
 766                 MOV     R3,#1                   ;Length of buffer to echo
 767
 768 00
 769                 TCALL   termite_checkCarrier    ;Get current carrier state
 770                 CMP     R0,#0                   ;Is there one?
 771                 MOVEQ   R0,#0                   ;No, return ""
 772                 BEQ     %90termite_rinput       ;And jump ahead
 773
 774                 TCALL   termite_readRemote      ;Read a byte from the buffer
 775                 CMP     R0,#-1                  ;Was there one?
 776                 BLEQ    tsc_wait                ;No -- wait for it then
 777                 LDREQ   R2,tsc_stracc
 778                 LDREQ   R2,[R2]
 779                 ADDEQ   R2,R2,R1,LSR #8
 780                 ADDEQ   R2,R2,R5
 781                 BEQ     %b00
 782                 CMP     R0,#127                 ;Is this a delete?
 783                 CMPNE   R0,#8
 784                 BEQ     %f05                    ;Yes -- deal with that then
 785                 CMP     R0,#32                  ;Was it valid?
 786                 STRGEB  R0,[R2,#0]              ;Yes -- store the byte
 787                 BLGE    termite_doREcho         ;Echo the buffer
 788                 ADDGE   R2,R2,#1                ;Increment the pointer
 789                 ADDGE   R5,R5,#1                ;Increment the length
 790                 CMP     R0,#13                  ;Are we finished?
 791                 CMPNE   R5,#256
 792                 BLT     %b00                    ;No -- get some more then
 793                 B       %f10                    ;Finished -- jump ahead
 794
 795                 ; --- Do a delete operation ---
 796
 797 05              CMP     R5,#0                   ;Is the buffer empty?
 798                 BLE     %b00                    ;Yes -- do nothing
 799                 MOV     R14,#8                  ;Get a backspace
 800                 STRB    R14,[R2,#0]             ;Store it...
 801                 STRB    R14,[R2,#2]             ;In two places
 802                 MOV     R14,#32                 ;And a space too
 803                 STRB    R14,[R2,#1]             ;Put that in the middle
 804                 MOV     R3,#3                   ;Send 3 characters
 805                 BLGE    termite_doREcho         ;Echo the buffer
 806                 SUB     R2,R2,#1                ;Reduce the address
 807                 SUB     R5,R5,#1                ;And the number of chars
 808                 MOV     R3,#1                   ;Put R3 back to 1
 809                 B       %b00                    ;Join main loop again
 810
 811                 ; --- We have finished reading the string ---
 812
 813 10              ORR     R0,R1,R5                ;Get the rvalue
 814 90              MOV     R1,#vType_string        ;This is a string
 815                 BL      stracc_added            ;Tell stracc about this
 816                 MOV     R3,R1                   ;Move these up a little
 817                 MOV     R2,R0
 818                 BL      express_pop             ;Get my lvalue off
 819                 BL      ctrl_store              ;Store this away
 820                 B       interp_next             ;Do another command
 821
 822                 LTORG
 823
 824 ; --- termite_rnewline ---
 825
 826                 EXPORT  termite_rnewline
 827 termite_rnewline ROUT
 828
 829                 CMP     R9,#'='                 ;Next char must be `='
 830                 MOVNE   R0,#err_expEq           ;If it isn't, moan
 831                 BNE     error_report
 832                 BL      getToken                ;Skip past the equals sign
 833
 834                 LDR     R0,tsc_rnewline         ;Get existing offset
 835                 BL      strBucket_free          ;Free it
 836                 MOV     R0,#0                   ;Prepare to read rvalue
 837                 BL      express_read            ;Read it then
 838                 BL      express_pop             ;Pop it off the stack
 839                 CMP     R1,#vType_string        ;Is it a string?
 840                 MOVNE   R0,#err_strNeeded       ;No -- get error number
 841                 BNE     error_report            ;And report the error
 842                 BL      termite__storeStr       ;Store inthe bucket
 843                 STR     R0,tsc_rnewline         ;Store the new offset
 844                 B       interp_next             ;And do the next instruction
 845
 846 ; --- termite_spool ---
 847
 848                 EXPORT  termite_spool
 849 termite_spool   ROUT
 850
 851                 CMP     R9,#10                  ;Is this a newline?
 852                 CMPNE   R9,#':'                 ;Or a colon
 853                 CMPNE   R9,#&FF                 ;Or the end of the file?
 854                 CMPNE   R9,#tok_else            ;Or an else
 855                 BEQ     %50                     ;Yes -- turn off spooling
 856
 857                 ; --- Turn on spooling ---
 858                 ;
 859                 ; Ooh, spooling, I really dig you.
 860
 861                 MOV     R0,#0                   ;Read an rvalue
 862                 BL      express_read            ;Read the expression
 863                 BL      express_pop             ;Pop the result
 864                 CMP     R1,#vType_string        ;Do we have a string?
 865                 MOVNE   R0,#err_strNeeded       ;No -- moan at thick user
 866                 BNE     error_report            ;Do that then
 867
 868                 ; --- Copy the string to the misc buffer ---
 869
 870                 LDR     R1,tsc_stracc           ;Find the stracc buffer
 871                 LDR     R1,[R1,#0]              ;Load the pointer out
 872                 MOV     R2,R0                   ;Look after the rvalue
 873                 ADD     R0,R1,R0,LSR #8         ;Find the string base
 874                 AND     R1,R2,#&FF              ;And get the length
 875                 ADR     R3,tsc_misc             ;Point to destination buffer
 876 00              LDRB    R14,[R0],#1             ;Load byte from string
 877                 STRB    R14,[R3],#1             ;Store in destination
 878                 SUBS    R1,R1,#1                ;Decrement the counter
 879                 BGT     %b00                    ;And carry on going
 880                 MOV     R14,#0                  ;Terminate the string
 881                 STRB    R14,[R3],#1             ;Stick that on the end
 882
 883                 MOV     R0,R2                   ;Find the string rvalue
 884                 BL      stracc_free             ;Remove it from stracc
 885
 886                 ; --- Make sure we're not spooling right now ---
 887
 888                 LDR     R1,tsc_spool            ;Load the current handle
 889                 CMP     R1,#0                   ;Are we spooling?
 890                 MOVNE   R0,#0                   ;Yes -- close current file
 891                 SWINE   XOS_Find                ;So do that then
 892
 893                 ; --- Now open the file ---
 894
 895                 MOV     R0,#&8F                 ;Give me lots of errors
 896                 ADR     R1,tsc_misc             ;Point to the buffer
 897                 SWI     XOS_Find                ;Find a file handle for it
 898                 BVS     error_reportReal        ;If failed, report the error
 899                 STR     R0,tsc_spool            ;Save the file handle
 900                 B       interp_next             ;Now do another instruction
 901
 902                 ; --- Close the current file ---
 903
 904 50termite_spool LDR     R1,tsc_spool            ;Load the current handle
 905                 CMP     R1,#0                   ;Are we spooling?
 906                 MOVNE   R0,#0                   ;Yes -- close current file
 907                 SWINE   XOS_Find                ;So do that then
 908                 BVS     error_reportReal
 909                 MOV     R14,#0                  ;Get a zero value
 910                 STR     R14,tsc_spool           ;Clear the file handle
 911                 B       interp_next             ;Now do another instruction
 912
 913                 LTORG
 914
 915 ; --- termite_syscall ---
 916
 917                 EXPORT  termite_syscall
 918 termite_syscall ROUT
 919
 920                 BL      ctrl_setUpRegs          ;Set up the regs then
 921
 922                 CMP     R10,#vType_string       ;Is this a string?
 923                 LDREQ   R14,tsc_stracc          ;Yes -- load the stracc addr#
 924                 LDREQ   R14,[R14]               ;Grrrr...
 925                 ADDEQ   R9,R14,R9,LSR #8        ;Point to the string
 926                 MOVEQ   R14,PC                  ;Yes -- set up return address
 927                 ADDEQ   PC,R11,#termite_sysNumString
 928                 BVS     error_reportReal        ;Report possible error
 929                 CMPNE   R10,#vType_integer      ;Is this an integer?
 930                 MOVNE   R0,#err_arrayBad        ;No -- get error number
 931                 BNE     error_report            ;...and report the error
 932
 933                 TCALL   termite_sysCall         ;Call the call then!
 934
 935                 ADR     R10,termite__retned     ;Point to some space
 936                 STMIA   R10!,{R0-R8}            ;Store returned registers
 937                 MOV     R14,PC,LSR #28          ;Get the flags
 938                 STMIA   R10!,{R14}              ;Strore the flags too
 939
 940                 ; --- Convert the string if needed ---
 941
 942                 LDMFD   R13!,{R7-R12}           ;Load back position info
 943                 LDMFD   R13!,{R0}               ;Load stracc offset
 944                 BL      stracc_free             ;Free any strings I had
 945
 946                 ; --- We have now done the SYSCALL instr ---
 947
 948                 ADR     R0,termite__retned      ;Point to the returned regs
 949                 BL      ctrl_resolveRegs        ;Do the other half now
 950                 B       interp_next             ;No error -- happy
 951
 952 termite__retned DCD     0,0,0,0,0,0,0,0,0,0,0   ;For SYSCALL, CALL
 953
 954                 LTORG
 955
 956 ; --- termite_upload ---
 957
 958                 EXPORT  termite_upload
 959 termite_upload  ROUT
 960
 961                 ; --- Read the protocol name ---
 962
 963                 MOV     R0,#0                   ;Read an rvalue
 964                 BL      express_read            ;Read it then
 965                 BL      express_pop             ;Get the rvalue
 966                 CMP     R1,#vType_string        ;Is it a string?
 967                 MOVNE   R0,#err_numNeeded       ;No -- get the error number
 968                 BNE     error_report            ;And report the error
 969
 970                 ; --- NULL terminate it ---
 971                 ;
 972                 ; We rely on the fact that there can't be anything else
 973                 ; after this string.  It is also important that we remember
 974                 ; the stracc offset of this string, so that all the strings
 975                 ; can be removed from stracc in one go.
 976
 977
 978                 MOV     R3,R1                   ;Look after the offset
 979                 MOV     R5,#0                   ;Useful, t' be sure
 980                 BL      stracc_ensure           ;Ensure we have space
 981                 STRB    R5,[R0,#0]              ;Terminate the string
 982                 ADD     R4,R1,#(1<<8)           ;The next string will go here
 983                 ORR     R0,R1,#1                ;Get the rvalue
 984                 BL      stracc_added            ;Tell stracc about terminator
 985
 986                 ; --- Now we keep on adding strings to the list ---
 987
 988 05              CMP     R9,#','                 ;Do we have a comma?
 989                 BNE     %50termite_upload       ;No -- do the deed then
 990                 BL      getToken                ;Skip over the comma
 991
 992                 MOV     R0,#0                   ;Read an rvalue
 993                 BL      express_read            ;Read it then
 994                 BL      express_pop             ;Pop off the string
 995                 CMP     R1,#vType_dimStr        ;Is this a string array?
 996                 BEQ     %10termite_upload       ;Yes -- jump ahead
 997                 CMP     R1,#vType_string        ;Is it a string?
 998                 MOVNE   R0,#err_strNeeded       ;No -- get the error number
 999                 BNE     error_report            ;And report the error
1000
1001                 ; --- We have a string then ---
1002
1003                 CMP     R0,#0                   ;Does it have a length?
1004                 BEQ     %05termite_upload       ;No -- find another one then
1005                 BL      stracc_ensure           ;Ensure we have space
1006                 STRB    R5,[R0,#0]              ;Terminate the string
1007                 ORR     R0,R1,#1                ;Get the rvalue
1008                 BL      stracc_added            ;Tell stracc about terminator
1009                 B       %05termite_upload       ;Find another string
1010
1011                 ; --- We have a string array ---
1012
1013 10              MOV     R3,R0                   ;Look after rvalue
1014                 MOV     R2,#0                   ;Start from the beginning
1015 15              MOV     R1,R3                   ;Put it in R1
1016                 BL      termite__enumArray      ;Get an element
1017                 BCC     %05termite_upload       ;No more, get another string
1018                 ANDS    R14,R0,#&FF             ;Get the length
1019                 BEQ     %15termite_upload       ;Zero -- get another one then
1020                 BL      stracc_ensure           ;Ensure we have space
1021                 STRB    R5,[R0,#0]              ;Terminate the string
1022                 ORR     R0,R1,#1                ;Get the rvalue
1023                 BL      stracc_added            ;Tell stracc about terminator
1024                 B       %15termite_upload       ;Find another element
1025
1026                 ; --- All the strings are in stracc now ---
1027                 ;
1028                 ; First, we terminate the list
1029
1030 50              BL      stracc_ensure           ;Ensure we have space
1031                 STRB    R5,[R0,#0]              ;Terminate the string
1032                 ORR     R0,R1,#1                ;Get the rvalue
1033                 BL      stracc_added            ;Tell stracc about terminator
1034
1035                 ; --- Now, point to the strings ---
1036
1037                 LDR     R1,tsc_stracc           ;Load stracc anchor
1038                 LDR     R1,[R1]
1039                 MOV     R5,R3                   ;Look after offset
1040                 ADD     R2,R1,R3,LSR #8         ;Point to the protocol name
1041                 ADD     R3,R1,R4,LSR #8         ;Point to files to upload
1042
1043                 TCALL   termite_upLoad          ;Upload the files
1044                 BL      termite__error          ;Handle possible error
1045
1046                 MOV     R0,R5                   ;Put the offset in R0
1047                 BL      stracc_free             ;Free all those strings!
1048                 B       interp_next             ;Do the next instruction
1049
1050                 LTORG
1051
1052 ; --- termite_wait ---
1053
1054                 EXPORT  termite_wait
1055 termite_wait    ROUT
1056
1057                 ; --- Read a parameter ---
1058
1059                 MOV     R0,#0                   ;Read an rvalue
1060                 BL      express_read            ;Read it then
1061                 BL      express_pop             ;And get it off the stack
1062                 CMP     R1,#vType_integer       ;Is this an integer
1063                 MOVNE   R0,#err_numNeeded       ;Nope -- get error number
1064                 BNE     error_report            ;...and report the error
1065
1066                 MOV     R1,R0                   ;Remember this time
1067                 SWI     OS_ReadMonotonicTime    ;Read the current time
1068                 ADD     R1,R1,R0                ;Return after this time
1069
1070                 ; --- Now enter a waiting loop ---
1071
1072 00              SWI     OS_ReadMonotonicTime    ;Read the current time
1073                 CMP     R0,R1                   ;Have we finished waiting?
1074                 BLCC    tsc_wait                ;No -- wait some more
1075                 BCC     %b00                    ;...and keep on looping
1076
1077                 B       interp_next             ;Go round for next command
1078
1079                 LTORG
1080
1081 ; --- termite_watchfor ---
1082
1083                 EXPORT  termite_watchfor
1084 termite_watchfor ROUT
1085
1086                 ; --- See if we are ending the WATCHFOR ---
1087
1088                 CMP     R9,#tok_end             ;Are we ending it?
1089                 BEQ     %70termite_watchfor     ;Yes -- jump ahead
1090
1091                 ; --- First, we must set up strings ---
1092                 ;
1093                 ; We actually store the strings in the strBucket.
1094                 ; In the string list, we have a word for the pointer into
1095                 ; the string list, and a byte for the match position so far.
1096
1097                 MOV     R5,#0                   ;Number so far
1098                 ADR     R3,tsc_wForStrings      ;Point to the block
1099                 MOV     R4,#0                   ;For the match position
1100                 STR     R5,tsc_wForState        ;Reset the state to 0
1101
1102 10              CMP     R5,#32                  ;Are we at the maximum?
1103                 MOVGE   R0,#err_WFTooMany       ;Yes -- get error number
1104                 BEQ     error_report            ;And report the error
1105
1106                 ; --- Now read the strings one at a time ---
1107
1108                 MOV     R0,#0                   ;Read an rvalue
1109                 BL      express_read            ;Read it then
1110                 BL      express_pop             ;Pop off this value
1111                 CMP     R1,#vType_dimStr        ;Is this a string array?
1112                 BNE     %19termite_watchfor     ;No -- jump ahead
1113
1114                 ; --- We have a string array ---
1115
1116                 MOV     R1,R0                   ;Put the array in R1
1117                 MOV     R2,#0                   ;Start from the beginning
1118 00              BL      termite__enumArray      ;Get the next string
1119                 BCC     %15termite_watchfor     ;No more -- jump ahead
1120                 BL      termite__storeStr       ;Store the string
1121                 CMP     R9,#&7e                 ;Are we case insensitive?
1122                 ORREQ   R0,R0,#(1<<31)          ;Yes -- set the flag
1123                 STMIA   R3!,{R0,R4}             ;Store information
1124                 ADD     R5,R5,#1                ;Increment the counter
1125                 B       %b00                    ;And keep doing this
1126
1127                 ; --- The array has finished ---
1128
1129 15              CMP     R9,#&7e                 ;Should we skip a token?
1130                 BLEQ    getToken                ;Yes - do that then
1131                 B       %25termite_watchfor     ;Jump ahead a little
1132
1133                 ; --- See if it's a string then ---
1134
1135 19              CMP     R1,#vType_string        ;Is it a string?
1136                 MOVNE   R0,#err_strNeeded       ;No -- get the error
1137                 BNE     error_report            ;And then report it
1138
1139                 ; --- We have a string in stracc ---
1140
1141                 CMP     R9,#&7e                 ;Case insensitive? (#'~')
1142                 BLEQ    getToken                ;Yes -- skip over it
1143 20              BL      termite__storeStr       ;Put it in the bucket
1144                 ORREQ   R0,R0,#(1<<31)          ;Set the top bit for insens
1145                 STMIA   R3!,{R0,R4}             ;Store inforamtion
1146                 ADD     R5,R5,#1                ;Increment the counter
1147
1148                 ; --- Do any more we have ---
1149
1150 25              CMP     R9,#','                 ;Do we have a comma
1151                 BLEQ    getToken                ;Yes -- skip over it
1152                 BEQ     %10termite_watchfor     ;...and then go round
1153                 STR     R5,tsc_wForNumber       ;Store the number of strings
1154
1155                 ; --- Now we must check the ring buffer ---
1156                 ;
1157                 ; We keep taking bytes off until either a match is achieved,
1158                 ; we have read 255 chars or there are no more in the
1159                 ; buffer.  In any case we then on the buffer.
1160                 ; If we have 255 chars we simply start all over again.
1161
1162                 ADR     R2,tsc_misc             ;Point to the buffer
1163                 MOV     R3,#0                   ;Number read so far
1164 00
1165                 TCALL   termite_readRemote      ;Get a byte
1166                 CMP     R0,#-1                  ;Was there a byte?
1167                 BEQ     %50termite_watchfor     ;No -- jump ahead
1168                 ADD     R3,R3,#1                ;Increment the count
1169                 STRB    R0,[R2],#1              ;Store it in the buffer
1170                 BL      termite__checkWF        ;Does this make a match?
1171                 BCS     %50termite_watchfor     ;Yes -- jump ahead
1172                 CMP     R3,#255                 ;Have we had 255 bytes now?
1173                 BNE     %b00                    ;No -- keep on going then
1174
1175                 ; --- Send on the buffer ---
1176
1177                 ADR     R2,tsc_misc             ;Point to the buffer
1178                 BL      termite_doREcho         ;Echo it appropriately
1179                 MOV     R3,#0                   ;Reset the count to 0
1180                 B       %b00                    ;And start all over again
1181
1182                 ; --- We have stopped reading bytes ---
1183                 ;
1184                 ; Either we ran out of bytes, or we got a match,
1185                 ; for either case we do the same thing
1186
1187 50              ADR     R2,tsc_misc             ;Point to the buffer
1188                 BL      termite_doREcho         ;Echo it appropriately
1189                 B       interp_next             ;Do the next instruction
1190
1191                 ; --- We are ending the watchfor ---
1192
1193 70              BL      getToken                ;Gobble up the END
1194                 BL      termite__endWF          ;End the WATCHFOR
1195                 B       interp_next             ;Do the next command
1196
1197                 LTORG
1198
1199 ; --- termite__endWF ---
1200 ;
1201 ; On entry:     --
1202 ;
1203 ; On exit:      --
1204 ;
1205 ; Use:          Ends a WATCHFOR condition.
1206
1207 termite__endWF  ROUT
1208
1209                 STMFD   R13!,{R0-R3,R14}        ;Stack some regsiters
1210                 ADR     R1,tsc_wForStrings      ;Point to the string list
1211                 LDR     R2,tsc_wForNumber       ;Get the number of strings
1212                 CMP     R2,#0                   ;Are there any?
1213                 BEQ     %f05                    ;No -- jump ahead then
1214                 MOV     R3,R2,LSL #3            ;Multiply by 8
1215                 ADD     R1,R1,R3                ;Point just past the last one
1216 00              LDR     R0,[R1,#-8]!            ;Load out an offset
1217                 BIC     R0,R0,#(1<<31)          ;Clear the flag
1218                 BL      strBucket_free          ;Remove the string
1219                 SUBS    R2,R2,#1                ;Reduce the count
1220                 BGT     %b00                    ;And free the rest
1221
1222 05              STR     R2,tsc_wForNumber       ;Make that clear
1223                 LDMFD   R13!,{R0-R3,PC}^        ;Return to caller
1224
1225                 LTORG
1226
1227 ; --- termite__checkWF ---
1228 ;
1229 ; On entry:     R0 == byte to check
1230 ;
1231 ; On exit:      CS if that byte caused a match,
1232 ;               CC otherwise
1233 ;
1234 ; Use:          Tests all the strings in the WATCHFOR list, to see if
1235 ;               the character caused a match.  If it did, then WATCH
1236 ;               is set.
1237
1238 termite__checkWF ROUT
1239
1240                 STMFD   R13!,{R0-R9,R14}        ;Stack registers
1241                 LDR     R1,tsc_bucket           ;Load the bucket anchor
1242                 LDR     R1,[R1,#0]              ;Point to it
1243                 ADR     R2,tsc_wForStrings      ;Point to the strings
1244                 LDR     R3,tsc_wForNumber       ;Load the number of strings
1245
1246                 ; --- Get the information on the string ---
1247
1248 00              LDR     R7,[R2],#4              ;Load the offset
1249                 CMP     R7,#0                   ;Is this one blank?
1250                 ADDEQ   R2,R2,#4                ;Yes -- skip over position
1251                 BEQ     %10termite__checkWF     ;Zero length -- ignore
1252                 BICS    R4,R7,#(1<<31)          ;Clear the 'insens' bit
1253                 LDR     R5,[R2],#4              ;Load position so far
1254                 ADD     R4,R1,R4                ;Point to the string
1255                 LDRB    R6,[R4,#-1]             ;Load the string length
1256                 ADD     R4,R4,R5                ;Point to the character
1257
1258                 ; --- Now do the comparison ---
1259
1260 02              LDRB    R14,[R4,#0]             ;Load the next byte
1261                 MOV     R9,R0                   ;Put byte to comapre in R8
1262                 TST     R7,#(1<<31)             ;Case insensitive?
1263                 ORRNE   R9,R9,#32               ;Yes -- make lower case
1264                 ORRNE   R14,R14,#32             ;Both of them
1265                 CMP     R9,R14                  ;Are they the same?
1266                 BEQ     %05termite__checkWF     ;Yes -- jump ahead
1267                 CMP     R5,#0                   ;Was that the first char?
1268                 SUB     R4,R4,R5                ;Point to the string start
1269                 MOV     R5,#0                   ;Put it back to 0
1270                 BNE     %02termite__checkWF     ;No --  test first char
1271                 STR     R5,[R2,#-4]             ;...store that back
1272                 B       %10termite__checkWF     ;...jump ahead
1273
1274                 ; --- The characters matched ---
1275
1276 05              ADD     R5,R5,#1                ;Increment position
1277                 CMP     R5,R6                   ;Has the string been done?
1278                 BEQ     %20termite__checkWF     ;Yes -- we jump ahead then
1279                 STR     R5,[R2,#-4]             ;Store the new position
1280
1281                 ; --- Move onto the next string ---
1282
1283 10              SUBS    R3,R3,#1                ;Decrement the string count
1284                 BGT     %00termite__checkWF     ;And keep on looking
1285                 LDMFD   R13!,{R0-R9,R14}        ;Load back registers
1286                 BICS    PC,R14,#C_flag          ;And return to caller
1287
1288                 ; --- We found a matching string ---
1289
1290 20              LDR     R14,tsc_wForNumber      ;Get teh number of strings
1291                 SUB     R14,R14,R3              ;Get index-1
1292                 ADD     R14,R14,#1              ;Get the index
1293                 STR     R14,tsc_wForState       ;Store as the state
1294                 BL      termite__endWF          ;End the current watchfor
1295                 LDMFD   R13!,{R0-R9,R14}        ;Load back registers
1296                 ORRS    PC,R14,#C_flag          ;And return to caller
1297
1298                 LTORG
1299
1300 ; --- termite_remoteInput ---
1301 ;
1302 ; On entry:     R0 == handle of script
1303 ;               R2 == buffer containing bytes read
1304 ;               R3 == number of bytes in buffer
1305 ;               R11 == upcall block
1306 ;
1307 ; On exit:      R2 == new buffer containing bytes to put into ring buffer
1308 ;               R3 == number of bytes in this buffer
1309 ;
1310 ; Use:          If we are not doing a watchfor, then this call will return
1311 ;               immediately, resulting in all the buffer being sent
1312 ;               to the ring buffer.
1313 ;               If we are in a watchfor, then all data received, up until
1314 ;               a match, is echoed immediatley, and not sent to the buffer.
1315
1316                 EXPORT  termite_remoteInput
1317 termite_remoteInput ROUT
1318
1319                 STMFD   R13!,{R14}              ;Stack the link register
1320                 LDR     R14,[R0,#:INDEX:tsc_wForNumber]
1321                 CMP     R14,#0                  ;Are we in a WATCHFOR?
1322                 LDMEQFD R13!,{PC}^              ;No -- return AQAP then
1323
1324                 STMFD   R13!,{R0,R4,R5,R12}     ;Stack some more registers
1325                 MOV     R12,R0                  ;Put workspace in R12
1326                 MOV     R4,R2                   ;Look after buffer address
1327                 MOV     R5,R3                   ;Remember number of bytes
1328
1329                 ; --- Scan the buffer ---
1330
1331 00              LDRB    R0,[R4],#1              ;Load a byte
1332                 SUB     R5,R5,#1                ;Reduce the count
1333                 BL      termite__checkWF        ;Does this cause a match
1334                 BCS     %10termite_remoteInput  ;We have a match
1335                 CMP     R5,#0                   ;Have we finished?
1336                 BGT     %b00                    ;More to go -- loop
1337
1338                 ; -- Send this buffer then ---
1339
1340                 BL      termite_doREcho         ;Send the buffer
1341                 MOV     R3,#0                   ;Put nothing in the buffer
1342                 B       %90termite_remoteInput  ;And return to caller
1343
1344                 ; --- We got a match ---
1345
1346 10              SUB     R3,R3,R5                ;Get number to send
1347                 BL      termite_doREcho         ;Send the buffer
1348                 MOV     R3,R5                   ;Get bytes left
1349                 MOV     R2,R4                   ;Point to rest of buffer
1350
1351 90              LDMFD   R13!,{R0,R4,R5,R12,PC}^ ;Return to caller
1352
1353                 LTORG
1354
1355 ;----- Utility routines -----------------------------------------------------
1356
1357 ; --- termite_copyString ---
1358 ;
1359 ; On entry:     R0 == buffer to copy string to
1360 ;               R1 == point to the string
1361 ;               R2 == length of string to copy
1362 ;
1363 ; On exit:      --
1364 ;
1365 ; Use:          Copies the string into the buffer.
1366
1367                 EXPORT  termite_copyString
1368 termite_copyString ROUT
1369
1370                 STMFD   R13!,{R0-R2,R14}        ;Stack registers
1371                 CMP     R2,#0                   ;Is this a short string?
1372 00              LDRGTB  R14,[R1],#1             ;Load a character
1373                 STRGTB  R14,[R0],#1             ;And then store it
1374                 SUBS    R2,R2,#1                ;Reduce the count
1375                 BGT     %b00                    ;And keep on goin'
1376                 MOV     R14,#0                  ;Get a terminator
1377                 STRB    R14,[R0],#1             ;Store the byte and return
1378                 LDMFD   R13!,{R0-R2,PC}^        ;Return to caller
1379
1380                 LTORG
1381
1382 ; --- termite_doLEcho ---
1383 ;
1384 ; On entry:     R2 == pointer to the buffer
1385 ;               R3 == number of bytes to send
1386 ;
1387 ; On exit:      --
1388 ;
1389 ; Use:          Echos the buffer to local and remote according to the
1390 ;               current flags, assuming the buffer came from the local input
1391
1392                 EXPORT  termite_doLEcho
1393 termite_doLEcho ROUT
1394
1395                 STMFD   R13!,{R0,R3,R14}        ;Stack some registers
1396                 LDR     R0,tsc_flags            ;Load the flags word
1397                 TST     R0,#tscFlag_echoLR      ;Should we echo to remote?
1398                 MOVNE   R14,PC                  ;Yes -- set up return address
1399                 ADDNE   PC,R11,#termite_sendRemote ;...and send the bytes
1400                 TST     R0,#tscFlag_echoLL      ;Should we echo to local?
1401                 BLNE    termite__doSpool        ;Yes -- check for spooling
1402                 MOVNE   R14,PC                  ;Yes -- set up return address
1403                 ADDNE   PC,R11,#termite_sendLocal ;...and send the bytes
1404                 LDMFD   R13!,{R0,R3,PC}^        ;Return to caller
1405
1406                 LTORG
1407
1408 ; --- termite_doREcho ---
1409 ;
1410 ; On entry:     R2 == pointer to the buffer
1411 ;               R3 == number of bytes to send
1412 ;
1413 ; On exit:      --
1414 ;
1415 ; Use:          Echos the buffer to local and remote according to the
1416 ;               current flags, assuming the buffer came from remote input
1417
1418                 EXPORT  termite_doREcho
1419 termite_doREcho ROUT
1420
1421                 STMFD   R13!,{R0,R3,R14}        ;Stack some registers
1422                 LDR     R0,tsc_flags            ;Load the flags word
1423                 TST     R0,#tscFlag_echoRR      ;Should we echo to remote?
1424                 MOVNE   R14,PC                  ;Yes -- set up return address
1425                 ADDNE   PC,R11,#termite_sendRemote ;...and send the bytes
1426                 TST     R0,#tscFlag_echoRL      ;Should we echo to local?
1427                 BLNE    termite__doSpool        ;Yes -- check for spooling
1428                 MOVNE   R14,PC                  ;Yes -- set up return address
1429                 ADDNE   PC,R11,#termite_sendLocal ;...and send the bytes
1430                 LDMFD   R13!,{R0,R3,PC}^        ;Return to caller
1431
1432                 LTORG
1433
1434 ; --- termite__doSpool ---
1435 ;
1436 ; On entry:     R2 == pointer to data to spool
1437 ;               R3 == size of the data
1438 ;
1439 ; On exit:      --
1440 ;
1441 ; Use:          Maybe writes the data to the current spool file.
1442
1443 termite__doSpool ROUT
1444
1445                 STMFD   R13!,{R0-R4,R14}        ;Save some registers
1446                 LDR     R1,tsc_spool            ;Load the spool handle
1447                 CMP     R1,#0                   ;Is spooling enabled?
1448                 MOVNE   R0,#2                   ;Yes -- write to the file
1449                 SWINE   XOS_GBPB                ;Do the write
1450                 LDMFD   R13!,{R0-R4,PC}^        ;And return to caller
1451
1452                 LTORG
1453
1454 ; --- termite__storeStr ---
1455 ;
1456 ; On entry:     R0 == rvalue of string
1457 ;
1458 ; On exit:      R0 == offset into bucket of string
1459 ;
1460 ; Use:          Puts the string in stracc, into the string bucket.
1461
1462 termite__storeStr ROUT
1463
1464                 STMFD   R13!,{R1-R4,R14}        ;Stack some registers
1465                 MOV     R2,R0                   ;Put the string in R2
1466                 MOV     R4,R0                   ;And in R4
1467                 ANDS    R0,R2,#&FF              ;Get the length
1468                 MOVEQ   R0,#0                   ;Zero length, get a zero
1469                 BEQ     %90termite__storeStr    ;And return to caller
1470                 BL      strBucket_alloc         ;Allocate the bucket
1471                 LDR     R3,tsc_stracc           ;Load the bucket anchor
1472                 LDR     R3,[R3]                 ;This is getting annoying
1473                 ADD     R3,R3,R2,LSR #8         ;Point to the string
1474                 AND     R2,R2,#&FF              ;Get the length
1475 00              LDRB    R14,[R3],#1             ;Load a character
1476                 STRB    R14,[R0],#1             ;Copy it over
1477                 SUBS    R2,R2,#1                ;Reduce the counter
1478                 BGT     %b00                    ;Keep on looping
1479                 MOV     R0,R4                   ;Put the rvalue in R0
1480                 BL      stracc_free             ;Remove it from stracc
1481                 MOV     R0,R1                   ;Return offset in R0
1482
1483 90              LDMFD   R13!,{R1-R4,PC}^        ;Return to caller
1484
1485                 LTORG
1486
1487 ; --- termite__enumArray ---
1488 ;
1489 ; On entry:     R1 == offset of array definition
1490 ;               R2 == item to read next
1491 ;
1492 ; On exit:      CS if item found, and
1493 ;                 R0 == rvalue of item
1494 ;                 R2 == updated
1495 ;               CC otherwise
1496 ;
1497 ; Use:          Goes through an string array, returning each item.
1498
1499 termite__enumArray ROUT
1500
1501                 STMFD   R13!,{R1,R3,R4,R14}     ;Stack registers
1502                 LDR     R3,tsc_varTree          ;Point at the tree
1503                 LDR     R3,[R3]
1504                 ADD     R0,R3,R1                ;Point at the array
1505                 MOV     R4,R2                   ;Remember the count
1506                 LDR     R14,[R0,#8]             ;Load number of items
1507                 CMP     R2,R14                  ;Have we finished?
1508                 BEQ     %95termite__enumArray   ;Yes -- return then
1509
1510                 LDR     R14,[R0,#4]             ;Load number of subscripts
1511                 ADD     R0,R0,#12               ;Point to them
1512                 ADD     R0,R0,R14,LSL #2        ;Point past them
1513                 ADD     R0,R0,R2,LSL #2         ;Point at the item
1514                 SUB     R0,R0,R3                ;Make that an offset
1515                 MOV     R1,#vType_lvString      ;The item is a string
1516                 BL      ctrl_load               ;Load it out
1517                 MOV     R0,R2                   ;Put the rvalue in R0
1518                 ADD     R2,R4,#1                ;Increment the item pos
1519
1520                 LDMFD   R13!,{R1,R3,R4,R14}     ;Load back registers
1521                 ORRS    PC,R14,#C_flag          ;And return success
1522
1523 95              LDMFD   R13!,{R1,R3,R4,R14}     ;Load back registers
1524                 BICS    PC,R14,#C_flag          ;And return failure
1525
1526                 LTORG
1527
1528 ; --- termite__error ---
1529 ;
1530 ; On entry:     V flag and R0 determine error condition
1531 ;
1532 ; On exit:      --
1533 ;
1534 ; Use:          This call will generate an error, if ERROR ON has been
1535 ;               done, or set the ERROR$ variable otherwise.
1536
1537 termite__error  ROUT
1538
1539                 STMFD   R13!,{R0-R2,R14}        ;Save regiters
1540                 LDR     R1,tsc_flags            ;Load the fags word
1541                 BVS     %50termite__error       ;Jump ahead if there's an err
1542
1543                 ; --- There was no error ---
1544
1545                 TST     R1,#tscFlag_error       ;Do we generate errors?
1546                 BNE     %90termite__error       ;Yes -- just return then
1547
1548                 ; --- Put a NULL string into ERROR$ ---
1549
1550                 LDR     R0,tsc_errorS           ;Get the exesting offset
1551                 BL      strBucket_free          ;Free it
1552                 MOV     R0,#0                   ;Get a 0 length string
1553                 STR     R0,tsc_errorS           ;Save that away
1554                 B       %90termite__error       ;Return to caller
1555
1556                 ; --- There was an error ---
1557
1558 50              TST     R1,#tscFlag_error       ;Do we generate errors?
1559                 BNE     error_reportReal        ;Yes -- report the error then
1560
1561                 ; --- Copy the string into ERROR$ ---
1562
1563                 ADD     R2,R0,#4                ;Put string pointer in R2
1564                 LDR     R0,tsc_errorS           ;Get the exesting offset
1565                 BL      strBucket_free          ;Free it
1566                 MOV     R1,R2                   ;Point to the string
1567                 MOV     R0,#0                   ;Current sting length
1568 00              LDRB    R14,[R1],#1             ;Load a byte
1569                 CMP     R14,#0                  ;Is it a NULL one?
1570                 ADDNE   R0,R0,#1                ;No -- increment the length
1571                 BNE     %b00                    ;And keep on going
1572
1573                 ; --- Now copy over the string ---
1574
1575                 BL      strBucket_alloc         ;We need this much room
1576                 STR     R1,tsc_errorS           ;Store this offset away
1577 00              LDRB    R14,[R2],#1             ;Load a byte from string
1578                 CMP     R14,#0                  ;Is this the end?
1579                 STRNE   R14,[R0],#1             ;No -- store in ERROR$
1580                 BNE     %b00                    ;And keep doing this
1581
1582                 ; --- Return to caller ---
1583
1584 90              LDMFD   R13!,{R0-R2,PC}^        ;Return to caller
1585
1586                 LTORG
1587
1588 ;----- That's all, folks ----------------------------------------------------
1589
1590                 END