chiark - git - mdw - ssr/blob - StraySrc/Libraries/Quartz/s/string

   1 ;
   2 ; string.s
   3 ;
   4 ; String handling routines (control terminated) (TMA)
   5 ;
   6 ; © 1994-1998 Straylight
   7 ;
   8
   9 ;----- Licensing note -------------------------------------------------------
  10 ;
  11 ; This file is part of Straylight's Quartz library.
  12 ;
  13 ; Quartz is free software; you can redistribute it and/or modify
  14 ; it under the terms of the GNU General Public License as published by
  15 ; the Free Software Foundation; either version 2, or (at your option)
  16 ; any later version.
  17 ;
  18 ; Quartz is distributed in the hope that it will be useful,
  19 ; but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 ; GNU General Public License for more details.
  22 ;
  23 ; You should have received a copy of the GNU General Public License
  24 ; along with Quartz.  If not, write to the Free Software Foundation,
  25 ; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26
  27 ;----- Standard header ------------------------------------------------------
  28
  29                 GET     libs:swis
  30                 GET     libs:header
  31
  32 ;----- External dependencies ------------------------------------------------
  33 ;
  34 ; None.
  35
  36 ;----- Main code ------------------------------------------------------------
  37 ;
  38 ; No string routine corrupts the scratchpad.
  39
  40                 AREA    |Quartz$$Code|,CODE,READONLY
  41
  42 ; --- str_cpy ---
  43 ;
  44 ; On entry:     R0 == destination string
  45 ;               R1 == source string
  46 ;
  47 ; On exit:      R0 == pointer to terminator of destination
  48 ;
  49 ; Use:          Copies a string from one block to another.  It leaves the
  50 ;               destination pointer at the end of the string so that any
  51 ;               subsequent copies concatenate other bits on the same string.
  52 ;               Single characters can of course be appended with
  53 ;
  54 ;                       MOV     Rx,#&cc
  55 ;                       STRB    Rx,[R0],#1
  56
  57                 EXPORT  str_cpy
  58 str_cpy         ROUT
  59
  60                 STMFD   R13!,{R1,R14}           ;Keep return address safe
  61 00str_cpy       LDRB    R14,[R1],#1             ;Get a byte from source
  62                 CMP     R14,#' '                ;Is it a control character
  63                 MOVLT   R14,#0                  ;Yes -- translate to a 0
  64                 STRB    R14,[R0],#1             ;Store in destination
  65                 BGE     %00str_cpy              ;No -- copy another byte
  66                 SUB     R0,R0,#1                ;Point back at terminator
  67                 LDMFD   R13!,{R1,PC}^           ;Return to caller
  68
  69                 LTORG
  70
  71 ; --- str_qcpy ---
  72 ;
  73 ; On entry:     R0 == destination pointer
  74 ;               R1 == source pointer
  75 ;
  76 ; On exit:      R0 == pointer to terminator of destination
  77 ;
  78 ; Use:          This copies the source string to the destination. It is
  79 ;               much faster than str_cpy if boths the string are word
  80 ;               aligned. Note that it only works with NULL terminated
  81 ;               strings.
  82
  83                 EXPORT  str_qcpy
  84 str_qcpy        ROUT
  85
  86                 STMFD   R13!,{R1-R5,R14}        ;Stack some registers
  87
  88                 ; --- Are both strings word aligned? ---
  89
  90                 ORR     R2,R0,R1                ;OR them together
  91                 ANDS    R2,R2,#3                ;Is bit 0 or 1 set?
  92                 BNE     %10str_qcpy             ;Yes, do non-word aligned cpy
  93
  94                 ; --- Set up bit structures ---
  95
  96                 MOV     R3,#&01                 ;Set bit 0
  97                 ADD     R3,R3,#&100             ;Set bits 0 and 8
  98                 ADD     R3,R3,R3,ROR #16        ;Set LSB of each byte in word
  99
 100                 MOV     R4,#&80                 ;Set bit 7
 101                 ADD     R4,R4,#&8000            ;Set bit 15
 102                 ADD     R4,R4,R4,ROR #16        ;Set MSB of each byte in word
 103
 104                 ; --- Branch to word loading routine ---
 105
 106                 B       %02str_qcpy             ;Branch ahead
 107
 108                 ; --- Copy the loaded word ---
 109
 110 01str_qcpy      STR     R2,[R0],#4              ;Store word
 111
 112                 ; --- Load a word, and check if any byte in it is 0 ---
 113                 ;
 114                 ; The algorithm is actually quite simple. By looking at
 115                 ; each byte in the word being loaded individually,
 116                 ; if we subtract 1 from it, the MSB of that byte is set
 117                 ; if the byte was 0 to start with (ie. it becomes -1).
 118                 ; However, the MSB may also be set if it was set to
 119                 ; start with. If this is the case then we clear it
 120                 ; after the subtract operation.
 121                 ;
 122                 ; This is why R3 is set up as it is. R4 can then be used
 123                 ; to see if any of MSB is set -- if so, then at least
 124                 ; one of the bytes was initially 0 :-)
 125
 126 02str_qcpy      LDR     R2,[R1],#4              ;Load a word
 127                 SUB     R5,R2,R3                ;Subtract 1 from each byte
 128                 BIC     R5,R5,R2                ;Clear MSB(s) if set in R2
 129                 ANDS    R5,R5,R4                ;Are any MSBs set
 130                 BEQ     %02str_qcpy             ;No, try another 4 bytes
 131
 132                 ; --- Now do the remaining bytes ---
 133
 134 03str_qcpy      STRB    R2,[R0],#1              ;Store a byte
 135                 ANDS    R2,R2,#&FF              ;Clear the first byte
 136                 SUBEQ   R0,R0,#1                ;Point to NULL byte if finshd
 137                 LDMEQIA R13!,{R1-R5,PC}^        ;And return to caller
 138                 MOV     R2,R2,ASR #8            ;Prepare next byte
 139                 B       %03str_qcpy             ;Copy what's left
 140
 141                 ; --- Do a non-word aligned copy ---
 142
 143 10str_qcpy      LDRB    R2,[R1],#1              ;Get a byte
 144                 STRB    R2,[R0],#1              ;Store it in destination
 145                 CMP     R2,#0                   ;Is it a terminator
 146                 BNE     %10str_qcpy             ;No -- keep copying
 147                 SUB     R0,R0,#1                ;Point to NULL
 148                 LDMFD   R13!,{R1-R5,PC}^
 149
 150                 LTORG
 151
 152 ; --- str_len ---
 153 ;
 154 ; On entry:     R0 == pointer to string
 155 ;
 156 ; On exit:      R0 == length of the string
 157 ;
 158 ; Use:          Calculates the length of a string.
 159
 160                 EXPORT  str_len
 161 str_len         ROUT
 162
 163                 STMFD   R13!,{R1,R14}           ;Save some registers
 164                 MOV     R14,R0                  ;Point to the string
 165                 MOV     R0,#0                   ;Current length is 0
 166 00str_len       LDRB    R1,[R14],#1             ;Get a byte from the string
 167                 CMP     R1,#' '                 ;Is it the end yet?
 168                 LDMLTFD R13!,{R1,PC}^           ;Yes -- return
 169                 ADD     R0,R0,#1                ;Bump the length counter
 170                 B       %00str_len              ;And go back for more
 171
 172                 LTORG
 173
 174 ; --- str_cmp ---
 175 ;
 176 ; On entry:     R0 == pointer to string A
 177 ;               R1 == pointer to string B
 178 ;
 179 ; On exit:      Flags as appropriate
 180 ;
 181 ; Use:          Case-sensitively compares two strings.  You can use the
 182 ;               normal ARM condition codes after the compare, so you can
 183 ;               treat this as a normal CMP type thing (except the arguments
 184 ;               must be in R0 and R1, and it mangles R14).
 185
 186                 EXPORT  str_cmp
 187 str_cmp         ROUT
 188
 189                 STMFD   R13!,{R0,R1,R3-R5,R14}
 190 00str_cmp       LDRB    R3,[R0],#1              ;Get a character from A
 191                 LDRB    R4,[R1],#1              ;And one from B
 192                 CMP     R3,#&20                 ;Is that the end of A?
 193                 MOVLT   R3,#0                   ;Yes -- pretend it's null
 194                 CMP     R4,#&20                 ;Is that the end of B?
 195                 MOVLT   R4,#0                   ;Yes -- pretend it's null
 196                 CMP     R3,R4                   ;How do they match up?
 197                 LDMNEFD R13!,{R0,R1,R3-R5,PC}   ;If NE, return condition
 198                 CMP     R3,#0                   ;Is this the end?
 199                 BNE     %00str_cmp              ;No -- loop again
 200                 LDMFD   R13!,{R0,R1,R3-R5,PC}   ;Return to caller
 201
 202 ; --- str_icmp ---
 203 ;
 204 ; On entry:     R0 == pointer to string A
 205 ;               R1 == pointer to string B
 206 ;
 207 ; On exit:      Flags as appropriate
 208 ;
 209 ; Use:          As for str_cmp above, but case-insensitive.
 210
 211                 EXPORT  str_icmp
 212 str_icmp        ROUT
 213
 214                 STMFD   R13!,{R0,R1,R3-R5,R14}
 215                 ADR     R5,str__caseTable       ;Point to upper-case table
 216 00str_icmp      LDRB    R3,[R0],#1              ;Get a character from A
 217                 LDRB    R4,[R1],#1              ;And one from B
 218                 LDRB    R3,[R5,R3]              ;If so, convert using table
 219                 LDRB    R4,[R5,R4]              ;(both characters)
 220                 CMP     R3,R4                   ;How do they match up?
 221                 LDMNEFD R13!,{R0,R1,R3-R5,PC}   ;If NE, return condition
 222                 CMP     R3,#0                   ;Is this the end?
 223                 BNE     %00str_icmp             ;No -- loop again
 224                 LDMFD   R13!,{R0,R1,R3-R5,PC}   ;Return to caller
 225
 226 str__caseTable  DCB     &00,&00,&00,&00,&00,&00,&00,&00
 227                 DCB     &00,&00,&00,&00,&00,&00,&00,&00
 228                 DCB     &00,&00,&00,&00,&00,&00,&00,&00
 229                 DCB     &00,&00,&00,&00,&00,&00,&00,&00
 230                 DCB     &20,&21,&22,&23,&24,&25,&26,&27
 231                 DCB     &28,&29,&2A,&2B,&2C,&2D,&2E,&2F
 232                 DCB     &30,&31,&32,&33,&34,&35,&36,&37
 233                 DCB     &38,&39,&3A,&3B,&3C,&3D,&3E,&3F
 234                 DCB     &40,&41,&42,&43,&44,&45,&46,&47
 235                 DCB     &48,&49,&4A,&4B,&4C,&4D,&4E,&4F
 236                 DCB     &50,&51,&52,&53,&54,&55,&56,&57
 237                 DCB     &58,&59,&5A,&5B,&5C,&5D,&5E,&5F
 238                 DCB     &60,&41,&42,&43,&44,&45,&46,&47
 239                 DCB     &48,&49,&4A,&4B,&4C,&4D,&4E,&4F
 240                 DCB     &50,&51,&52,&53,&54,&55,&56,&57
 241                 DCB     &58,&59,&5A,&7B,&7C,&7D,&7E,&7F
 242                 DCB     &80,&81,&82,&83,&84,&85,&86,&87
 243                 DCB     &88,&89,&8A,&8B,&8C,&8D,&8E,&8F
 244                 DCB     &90,&91,&92,&93,&94,&95,&96,&97
 245                 DCB     &98,&99,&9A,&9B,&9C,&9D,&9E,&9F
 246                 DCB     &A0,&A1,&A2,&A3,&A4,&A5,&A6,&A7
 247                 DCB     &A8,&A9,&AA,&AB,&AC,&AD,&AE,&AF
 248                 DCB     &B0,&B1,&B2,&B3,&B4,&B5,&B6,&B7
 249                 DCB     &B8,&B9,&BA,&BB,&BC,&BD,&BE,&BF
 250                 DCB     &C0,&C1,&C2,&C3,&C4,&C5,&C6,&C7
 251                 DCB     &C8,&C9,&CA,&CB,&CC,&CD,&CE,&CF
 252                 DCB     &D0,&D1,&D2,&D3,&D4,&D5,&D6,&D7
 253                 DCB     &D8,&D9,&DA,&DB,&DC,&DD,&DE,&DF
 254                 DCB     &E0,&E1,&E2,&E3,&E4,&E5,&E6,&E7
 255                 DCB     &E8,&E9,&EA,&EB,&EC,&ED,&EE,&EF
 256                 DCB     &F0,&F1,&F2,&F3,&F4,&F5,&F6,&F7
 257                 DCB     &F8,&F9,&FA,&FB,&FC,&FD,&FE,&FF
 258
 259                 LTORG
 260
 261 ; --- str_subst ---
 262 ;
 263 ; On entry:     R0 == Pointer to skeleton
 264 ;               R1 == Pointer to output buffer
 265 ;               R2-R11 == Pointer to filler strings (optional)
 266 ;
 267 ; On exit:      R0 == Pointer to start of buffer
 268 ;               R1 == Pointer to terminating null
 269 ;
 270 ; Use:          Performs string substitution, filling in a skeleton string
 271 ;               containing placeholders with `filler' strings.  The
 272 ;               placeholders are actually rather powerful.  The syntax of
 273 ;               these is as follows:
 274 ;
 275 ;                       `%' [<type>] <digit>
 276 ;
 277 ;               (spaces are for clarity -- in fact you must not include
 278 ;               spaces in the format string.)
 279 ;
 280 ;               <digit> is any charater between `0' and `9'.  It refers to
 281 ;               registers R2-R11 (so `0' means R2, `5' is R7 etc.)  How the
 282 ;               value is interpreted is determined by <type>.
 283 ;
 284 ;               <type> is one of:
 285 ;
 286 ;               s       String.  This is the default.  The register is
 287 ;                       considered to be a pointer to an ASCII string
 288 ;                       (control terminated).
 289 ;
 290 ;               i       Integer.  The (signed) decimal representation is
 291 ;                       inserted.  Leading zeros are suppressed.
 292 ;
 293 ;               x       Hex fullword.  The hexadecimal representation of the
 294 ;                       register is inserted.  Leading zeros are included.
 295 ;
 296 ;               b       Hex byte.  The hexadecimal representation of the
 297 ;                       least significant byte is inserted.  Leading zeros
 298 ;                       are included.
 299 ;
 300 ;               c       Character.  The ASCII character corresponding to the
 301 ;                       least significant byte is inserted.
 302
 303                 EXPORT  str_subst
 304 str_subst       ROUT
 305
 306                 STMFD   R13!,{R1-R11,R14}
 307
 308                 ; --- Move arguments into more amenable registers ---
 309
 310                 MOV     R11,R0                  ;Pointer to skeleton string
 311
 312                 ; --- Main `get a character' loop ---
 313
 314 00str_subst     LDRB    R14,[R11],#1            ;Get an input character
 315                 CMP     R14,#'%'                ;Is it a `%' sign?
 316                 BEQ     %01str_subst            ;Yes -- deal with it
 317 02str_subst     CMP     R14,#&20                ;Is it the end of input?
 318                 MOVLT   R14,#0                  ;Yes -- null terminate it
 319                 STRB    R14,[R1],#1             ;Not special, so store it
 320                 BGE     %00str_subst            ;No -- get another one
 321                 SUB     R1,R1,#1                ;Point to null terminator
 322                 LDMFD   R13!,{R0,R2-R11,PC}^    ;And return to caller
 323
 324                 ; --- Found a `%' sign, so find out what to substitute ---
 325
 326 01str_subst     LDRB    R14,[R11],#1            ;Get the next character
 327
 328                 ; --- Now find out what we're substituting ---
 329
 330                 ORR     R9,R14,#&20             ;Convert it to lowercase
 331                 CMP     R9,#'s'                 ;Is it a string?
 332                 CMPNE   R9,#'i'                 ;Or an integer?
 333                 CMPNE   R9,#'x'                 ;Or a fullword hex number?
 334                 CMPNE   R9,#'b'                 ;Or a single byte in hex?
 335                 CMPNE   R9,#'c'                 ;Or an ASCII character?
 336                 LDREQB  R14,[R11],#1            ;And get another character
 337
 338                 ; --- Now find which filler it is ---
 339
 340                 CMP     R14,#'0'                ;Is it a digit?
 341                 BLT     %02str_subst            ;No -- just ignore the `%'
 342                 CMP     R14,#'9'                ;Make sure it's small enough
 343                 BGT     %02str_subst            ;No -- just ignore the `%'
 344                 SUB     R14,R14,#'0'-1          ;Convert to binary (1..10)
 345                 LDR     R0,[R13,R14,LSL #2]     ;Load appropriate register
 346
 347                 ; --- Now find out how to substitute this argument ---
 348
 349                 MOV     R2,#256                 ;Buffer size -- saves space
 350
 351                 CMP     R9,#'s'                 ;Is it meant to be a string?
 352                 BEQ     %03str_subst            ;Yes -- a quick copy loop
 353                 CMP     R9,#'i'                 ;A decimal integer?
 354                 BEQ     %04str_subst            ;Yes -- go ahead to convert
 355                 CMP     R9,#'x'                 ;A hex fullword?
 356                 BEQ     %05str_subst            ;Yes -- convert that
 357                 CMP     R9,#'b'                 ;A hex byte?
 358                 BEQ     %06str_subst            ;Yes -- convert that
 359                 CMP     R9,#'c'                 ;A character?
 360                 BEQ     %07str_subst            ;Yes -- convert that
 361
 362                 ; --- String substitution copy-loop ---
 363
 364 03str_subst     LDRB    R14,[R0],#1             ;Get an input byte
 365                 CMP     R14,#&20                ;Is it the end of the string?
 366                 BLT     %00str_subst            ;Yes -- read main string
 367                 STRB    R14,[R1],#1             ;No -- store it in output
 368                 B       %03str_subst            ;... and get another one
 369
 370                 ; --- Decimal integer conversion ---
 371
 372 04str_subst     SWI     OS_ConvertInteger4      ;Convert and update nicely
 373                 B       %00str_subst            ;And rejoin the main loop
 374
 375                 ; --- Hexadecimal fullword conversion ---
 376
 377 05str_subst     SWI     OS_ConvertHex8          ;Convert and update nicely
 378                 B       %00str_subst            ;And rejoin the main loop
 379
 380                 ; --- Hexadecimal byte conversion ---
 381
 382 06str_subst     SWI     OS_ConvertHex2          ;Convert and update nicely
 383                 B       %00str_subst            ;And rejoin the main loop
 384
 385                 ; --- ASCII character conversion ---
 386
 387 07str_subst     STRB    R0,[R1],#1              ;Store the byte in
 388                 B       %00str_subst            ;And rejoin the main loop
 389
 390                 LTORG
 391
 392 ; --- str_error ---
 393 ;
 394 ; On entry:     R0 == Pointer to skeleton
 395 ;               R2-R11 == Pointers to fillin strings
 396 ;
 397 ; On exit:      R0 == Pointer to error in buffer
 398 ;               R1 == Pointer to terminator
 399 ;
 400 ; Use:          Fills in an error skeleton (like a substitution skeleton in
 401 ;               str_subst above with an error number on the front) and
 402 ;               returns a pointer to it.  The buffer used is found by calling
 403 ;               str_buffer (see below), so you can safely use the result of
 404 ;               one call as a filler string for the next.
 405 ;
 406 ;               Filler strings may be held in the scratchpad.
 407
 408                 EXPORT  str_error
 409 str_error       ROUT
 410
 411                 STMFD   R13!,{R14}              ;Store the link register
 412                 BL      str_buffer              ;Find a spare buffer
 413                 LDR     R14,[R0],#4             ;Get the error number
 414                 STR     R14,[R1],#4             ;Output it too
 415                 BL      str_subst               ;Do the string substitution
 416                 SUB     R0,R0,#4                ;Point to the error start
 417                 LDMFD   R13!,{PC}^              ;Return to caller
 418
 419                 LTORG
 420
 421 str__wSpace     DCD     0                       ;Pointer to error buffer
 422
 423 ; ---- str_buffer ---
 424 ;
 425 ; On entry:     --
 426 ;
 427 ; On exit:      R1 == pointer to the next free buffer
 428 ;
 429 ; Use:          Returns a pointer to a 256-byte buffer.  There are at present
 430 ;               2 buffers, which are returned alternately.
 431
 432                 EXPORT  str_buffer
 433 str_buffer      ROUT
 434
 435                 STMFD   R13!,{R14}              ;Save a work register
 436
 437                 ; --- Work out which buffer to use ---
 438                 ;
 439                 ; This uses some vaguely clever tricks, so watch out  [mdw]
 440                 ; In fact, the C compiler used exactly the same tricks when
 441                 ; tried `return (buffer+256*(count^=1))'.
 442
 443                 LDR     R14,str__wSpace         ;Find the workspace
 444                 LDR     R1,[R14,#0]             ;Get the current buffer
 445                 EOR     R1,R1,#1                ;Toggle the buffer number
 446                 STR     R1,[R14],#4             ;Store the new one back
 447                 ADD     R1,R14,R1,LSL #8        ;Point to correct buffer
 448                 LDMFD   R13!,{PC}^              ;Return to caller
 449
 450                 LTORG
 451
 452 ;----- Workspace ------------------------------------------------------------
 453
 454 str__buffers    EQU     2                       ;Use two buffers for now
 455
 456                 ^       0                       ;Don't tie it to R12
 457 str__wStart     #       0
 458
 459 str__buffNum    #       4
 460 str__buffer     #       256*str__buffers        ;The number of buffers I want
 461
 462 str__wSize      EQU     {VAR}-str__wStart
 463
 464                 AREA    |Quartz$$Table|,CODE,READONLY
 465
 466                 DCD     str__wSize              ;For the error buffer
 467                 DCD     str__wSpace             ;Pointer to the pointer
 468                 DCD     0                       ;No initialisation
 469                 DCD     0                       ;No finalisation
 470
 471 ;----- That's all folks -----------------------------------------------------
 472
 473                 END