home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / T-Pascal.70 / SOURCE.ZIP / STRINGS.PAS < prev    next >
Pascal/Delphi Source File  |  1992-10-30  |  11KB  |  563 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Turbo Pascal Runtime Library                    }
  5. {       String Handling Unit                            }
  6. {                                                       }
  7. {       Copyright (C) 1990,92 Borland International     }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. unit Strings;
  12.  
  13. {$S-}
  14.  
  15. interface
  16.  
  17. { StrLen returns the number of characters in Str, not counting  }
  18. { the null terminator.                                          }
  19.  
  20. function StrLen(Str: PChar): Word;
  21.  
  22. { StrEnd returns a pointer to the null character that           }
  23. { terminates Str.                                               }
  24.  
  25. function StrEnd(Str: PChar): PChar;
  26.  
  27. { StrMove copies exactly Count characters from Source to Dest   }
  28. { and returns Dest. Source and Dest may overlap.                }
  29.  
  30. function StrMove(Dest, Source: PChar; Count: Word): PChar;
  31.  
  32. { StrCopy copies Source to Dest and returns Dest.               }
  33.  
  34. function StrCopy(Dest, Source: PChar): PChar;
  35.  
  36. { StrECopy copies Source to Dest and returns StrEnd(Dest).      }
  37.  
  38. function StrECopy(Dest, Source: PChar): PChar;
  39.  
  40. { StrLCopy copies at most MaxLen characters from Source to Dest }
  41. { and returns Dest.                                             }
  42.  
  43. function StrLCopy(Dest, Source: PChar; MaxLen: Word): PChar;
  44.  
  45. { StrPCopy copies the Pascal style string Source into Dest and  }
  46. { returns Dest.                                                 }
  47.  
  48. function StrPCopy(Dest: PChar; Source: String): PChar;
  49.  
  50. { StrCat appends a copy of Source to the end of Dest and        }
  51. { returns Dest.                                                 }
  52.  
  53. function StrCat(Dest, Source: PChar): PChar;
  54.  
  55. { StrLCat appends at most MaxLen - StrLen(Dest) characters from }
  56. { Source to the end of Dest, and returns Dest.                  }
  57.  
  58. function StrLCat(Dest, Source: PChar; MaxLen: Word): PChar;
  59.  
  60. { StrComp compares Str1 to Str2. The return value is less than  }
  61. { 0 if Str1 < Str2, 0 if Str1 = Str2, or greater than 0 if      }
  62. { Str1 > Str2.                                                  }
  63.  
  64. function StrComp(Str1, Str2: PChar): Integer;
  65.  
  66. { StrIComp compares Str1 to Str2, without case sensitivity. The }
  67. { return value is the same as StrComp.                          }
  68.  
  69. function StrIComp(Str1, Str2: PChar): Integer;
  70.  
  71. { StrLComp compares Str1 to Str2, for a maximum length of       }
  72. { MaxLen characters. The return value is the same as StrComp.   }
  73.  
  74. function StrLComp(Str1, Str2: PChar; MaxLen: Word): Integer;
  75.  
  76. { StrLIComp compares Str1 to Str2, for a maximum length of      }
  77. { MaxLen characters, without case sensitivity. The return value }
  78. { is the same as StrComp.                                       }
  79.  
  80. function StrLIComp(Str1, Str2: PChar; MaxLen: Word): Integer;
  81.  
  82. { StrScan returns a pointer to the first occurrence of Chr in   }
  83. { Str. If Chr does not occur in Str, StrScan returns NIL. The   }
  84. { null terminator is considered to be part of the string.       }
  85.  
  86. function StrScan(Str: PChar; Chr: Char): PChar;
  87.  
  88. { StrRScan returns a pointer to the last occurrence of Chr in   }
  89. { Str. If Chr does not occur in Str, StrRScan returns NIL. The  }
  90. { null terminator is considered to be part of the string.       }
  91.  
  92. function StrRScan(Str: PChar; Chr: Char): PChar;
  93.  
  94. { StrPos returns a pointer to the first occurrence of Str2 in   }
  95. { Str1. If Str2 does not occur in Str1, StrPos returns NIL.     }
  96.  
  97. function StrPos(Str1, Str2: PChar): PChar;
  98.  
  99. { StrUpper converts Str to upper case and returns Str.          }
  100.  
  101. function StrUpper(Str: PChar): PChar;
  102.  
  103. { StrLower converts Str to lower case and returns Str.          }
  104.  
  105. function StrLower(Str: PChar): PChar;
  106.  
  107. { StrPas converts Str to a Pascal style string.                 }
  108.  
  109. function StrPas(Str: PChar): String;
  110.  
  111. { StrNew allocates a copy of Str on the heap. If Str is NIL or  }
  112. { points to an empty string, StrNew returns NIL and doesn't     }
  113. { allocate any heap space. Otherwise, StrNew makes a duplicate  }
  114. { of Str, obtaining space with a call to the GetMem standard    }
  115. { procedure, and returns a pointer to the duplicated string.    }
  116. { The allocated space is StrLen(Str) + 1 bytes long.            }
  117.  
  118. function StrNew(Str: PChar): PChar;
  119.  
  120. { StrDispose disposes a string that was previously allocated    }
  121. { with StrNew. If Str is NIL, StrDispose does nothing.          }
  122.  
  123. procedure StrDispose(Str: PChar);
  124.  
  125. implementation
  126.  
  127. {$W-}
  128.  
  129. function StrLen(Str: PChar): Word; assembler;
  130. asm
  131.     CLD
  132.     LES    DI,Str
  133.     MOV    CX,0FFFFH
  134.     XOR    AL,AL
  135.     REPNE    SCASB
  136.     MOV    AX,0FFFEH
  137.     SUB    AX,CX
  138. end;
  139.  
  140. function StrEnd(Str: PChar): PChar; assembler;
  141. asm
  142.     CLD
  143.     LES    DI,Str
  144.     MOV    CX,0FFFFH
  145.     XOR    AL,AL
  146.     REPNE    SCASB
  147.     MOV    AX,DI
  148.     MOV    DX,ES
  149.     DEC    AX
  150. end;
  151.  
  152. function StrMove(Dest, Source: PChar; Count: Word): PChar; assembler;
  153. asm
  154.     PUSH    DS
  155.     CLD
  156.     LDS    SI,Source
  157.     LES    DI,Dest
  158.     MOV    AX,DI
  159.     MOV    DX,ES
  160.     MOV    CX,Count
  161.     CMP    SI,DI
  162.     JAE    @@1
  163.     STD
  164.     ADD    SI,CX
  165.     ADD    DI,CX
  166.     DEC    SI
  167.     DEC    DI
  168. @@1:    REP    MOVSB
  169.     CLD
  170.     POP    DS
  171. end;
  172.  
  173. function StrCopy(Dest, Source: PChar): PChar; assembler;
  174. asm
  175.     PUSH    DS
  176.     CLD
  177.     LES    DI,Source
  178.     MOV    CX,0FFFFH
  179.     XOR    AL,AL
  180.     REPNE    SCASB
  181.     NOT    CX
  182.     LDS    SI,Source
  183.     LES    DI,Dest
  184.     MOV    AX,DI
  185.     MOV    DX,ES
  186.     REP    MOVSB
  187.     POP    DS
  188. end;
  189.  
  190. function StrECopy(Dest, Source: PChar): PChar; assembler;
  191. asm
  192.     PUSH    DS
  193.     CLD
  194.     LES    DI,Source
  195.     MOV    CX,0FFFFH
  196.     XOR    AL,AL
  197.     REPNE    SCASB
  198.     NOT    CX
  199.     LDS    SI,Source
  200.     LES    DI,Dest
  201.     REP    MOVSB
  202.     MOV    AX,DI
  203.     MOV    DX,ES
  204.     DEC    AX
  205.     POP    DS
  206. end;
  207.  
  208. function StrLCopy(Dest, Source: PChar; MaxLen: Word): PChar; assembler;
  209. asm
  210.     PUSH    DS
  211.     CLD
  212.     LES    DI,Source
  213.     MOV    CX,MaxLen
  214.     MOV    BX,CX
  215.     XOR    AL,AL
  216.     REPNE    SCASB
  217.     SUB    BX,CX
  218.     MOV    CX,BX
  219.     LDS    SI,Source
  220.     LES    DI,Dest
  221.     MOV    BX,DI
  222.     MOV    DX,ES
  223.     REP    MOVSB
  224.     STOSB
  225.     XCHG    AX,BX
  226.     POP    DS
  227. end;
  228.  
  229. function StrPCopy(Dest: PChar; Source: String): PChar; assembler;
  230. asm
  231.     PUSH    DS
  232.     CLD
  233.     LDS    SI,Source
  234.     LES    DI,Dest
  235.     MOV    BX,DI
  236.     MOV    DX,ES
  237.     LODSB
  238.     XOR    AH,AH
  239.     XCHG    AX,CX
  240.     REP    MOVSB
  241.     XOR    AL,AL
  242.     STOSB
  243.     XCHG    AX,BX
  244.     POP    DS
  245. end;
  246.  
  247. function StrCat(Dest, Source: PChar): PChar; assembler;
  248. asm
  249.     PUSH    Dest.Word[2]
  250.     PUSH    Dest.Word[0]
  251.     PUSH    CS
  252.     CALL    NEAR PTR StrEnd
  253.     PUSH    DX
  254.     PUSH    AX
  255.     PUSH    Source.Word[2]
  256.     PUSH    Source.Word[0]
  257.     PUSH    CS
  258.     CALL    NEAR PTR StrCopy
  259.     MOV    AX,Dest.Word[0]
  260.     MOV    DX,Dest.Word[2]
  261. end;
  262.  
  263. function StrLCat(Dest, Source: PChar; MaxLen: Word): PChar; assembler;
  264. asm
  265.     PUSH    Dest.Word[2]
  266.     PUSH    Dest.Word[0]
  267.     PUSH    CS
  268.     CALL    NEAR PTR StrEnd
  269.     MOV    CX,Dest.Word[0]
  270.     ADD    CX,MaxLen
  271.     SUB    CX,AX
  272.     JBE    @@1
  273.     PUSH    DX
  274.     PUSH    AX
  275.     PUSH    Source.Word[2]
  276.     PUSH    Source.Word[0]
  277.     PUSH    CX
  278.     PUSH    CS
  279.     CALL    NEAR PTR StrLCopy
  280. @@1:    MOV    AX,Dest.Word[0]
  281.     MOV    DX,Dest.Word[2]
  282. end;
  283.  
  284. function StrComp(Str1, Str2: PChar): Integer; assembler;
  285. asm
  286.     PUSH    DS
  287.     CLD
  288.     LES    DI,Str2
  289.     MOV    SI,DI
  290.     MOV    CX,0FFFFH
  291.     XOR    AX,AX
  292.     CWD
  293.     REPNE    SCASB
  294.     NOT    CX
  295.     MOV    DI,SI
  296.     LDS    SI,Str1
  297.     REPE    CMPSB
  298.     MOV    AL,DS:[SI-1]
  299.     MOV    DL,ES:[DI-1]
  300.     SUB    AX,DX
  301.     POP    DS
  302. end;
  303.  
  304. function StrIComp(Str1, Str2: PChar): Integer; assembler;
  305. asm
  306.     PUSH    DS
  307.     CLD
  308.     LES    DI,Str2
  309.     MOV    SI,DI
  310.     MOV    CX,0FFFFH
  311.     XOR    AX,AX
  312.     CWD
  313.     REPNE    SCASB
  314.     NOT    CX
  315.     MOV    DI,SI
  316.     LDS    SI,Str1
  317. @@1:    REPE    CMPSB
  318.     JE    @@4
  319.     MOV    AL,DS:[SI-1]
  320.     CMP    AL,'a'
  321.     JB    @@2
  322.     CMP    AL,'z'
  323.     JA    @@2
  324.     SUB    AL,20H
  325. @@2:    MOV    DL,ES:[DI-1]
  326.     CMP    DL,'a'
  327.     JB    @@3
  328.     CMP    DL,'z'
  329.     JA    @@3
  330.     SUB    DL,20H
  331. @@3:    SUB    AX,DX
  332.     JE    @@1
  333. @@4:    POP    DS
  334. end;
  335.  
  336. function StrLComp(Str1, Str2: PChar; MaxLen: Word): Integer; assembler;
  337. asm
  338.     PUSH    DS
  339.     CLD
  340.     LES    DI,Str2
  341.     MOV    SI,DI
  342.     MOV    AX,MaxLen
  343.     MOV    CX,AX
  344.     JCXZ    @@1
  345.     XCHG    AX,BX
  346.     XOR    AX,AX
  347.     CWD
  348.     REPNE    SCASB
  349.     SUB    BX,CX
  350.     MOV    CX,BX
  351.     MOV    DI,SI
  352.     LDS    SI,Str1
  353.     REPE    CMPSB
  354.     MOV    AL,DS:[SI-1]
  355.     MOV    DL,ES:[DI-1]
  356.     SUB    AX,DX
  357. @@1:    POP    DS
  358. end;
  359.  
  360. function StrLIComp(Str1, Str2: PChar; MaxLen: Word): Integer; assembler;
  361. asm
  362.     PUSH    DS
  363.     CLD
  364.     LES    DI,Str2
  365.     MOV    SI,DI
  366.     MOV    AX,MaxLen
  367.     MOV    CX,AX
  368.     JCXZ    @@4
  369.     XCHG    AX,BX
  370.     XOR    AX,AX
  371.     CWD
  372.     REPNE    SCASB
  373.     SUB    BX,CX
  374.     MOV    CX,BX
  375.     MOV    DI,SI
  376.     LDS    SI,Str1
  377. @@1:    REPE    CMPSB
  378.     JE    @@4
  379.     MOV    AL,DS:[SI-1]
  380.     CMP    AL,'a'
  381.     JB    @@2
  382.     CMP    AL,'z'
  383.     JA    @@2
  384.     SUB    AL,20H
  385. @@2:    MOV    DL,ES:[DI-1]
  386.     CMP    DL,'a'
  387.     JB    @@3
  388.     CMP    DL,'z'
  389.     JA    @@3
  390.     SUB    DL,20H
  391. @@3:    SUB    AX,DX
  392.     JE    @@1
  393. @@4:    POP    DS
  394. end;
  395.  
  396. function StrScan(Str: PChar; Chr: Char): PChar; assembler;
  397. asm
  398.     CLD
  399.     LES    DI,Str
  400.     MOV    SI,DI
  401.     MOV    CX,0FFFFH
  402.     XOR    AL,AL
  403.     REPNE    SCASB
  404.     NOT    CX
  405.     MOV    DI,SI
  406.     MOV    AL,Chr
  407.     REPNE    SCASB
  408.     MOV    AX,0
  409.     CWD
  410.     JNE    @@1
  411.     MOV    AX,DI
  412.     MOV    DX,ES
  413.     DEC    AX
  414. @@1:
  415. end;
  416.  
  417. function StrRScan(Str: PChar; Chr: Char): PChar; assembler;
  418. asm
  419.     CLD
  420.     LES    DI,Str
  421.     MOV    CX,0FFFFH
  422.     XOR    AL,AL
  423.     REPNE    SCASB
  424.     NOT    CX
  425.     STD
  426.     DEC    DI
  427.     MOV    AL,Chr
  428.     REPNE    SCASB
  429.     MOV    AX,0
  430.     CWD
  431.     JNE    @@1
  432.     MOV    AX,DI
  433.     MOV    DX,ES
  434.     INC    AX
  435. @@1:    CLD
  436. end;
  437.  
  438. function StrPos(Str1, Str2: PChar): PChar; assembler;
  439. asm
  440.     PUSH    DS
  441.     CLD
  442.     XOR    AL,AL
  443.     LES    DI,Str2
  444.     MOV    CX,0FFFFH
  445.     REPNE    SCASB
  446.     NOT    CX
  447.     DEC    CX
  448.     JE    @@2
  449.     MOV    DX,CX
  450.     MOV    BX,ES
  451.     MOV    DS,BX
  452.     LES    DI,Str1
  453.     MOV    BX,DI
  454.     MOV    CX,0FFFFH
  455.     REPNE    SCASB
  456.     NOT    CX
  457.     SUB    CX,DX
  458.     JBE    @@2
  459.     MOV    DI,BX
  460. @@1:    MOV    SI,Str2.Word[0]
  461.     LODSB
  462.     REPNE    SCASB
  463.     JNE    @@2
  464.     MOV    AX,CX
  465.     MOV    BX,DI
  466.     MOV    CX,DX
  467.     DEC    CX
  468.     REPE    CMPSB
  469.     MOV    CX,AX
  470.     MOV    DI,BX
  471.     JNE    @@1
  472.     MOV    AX,DI
  473.     MOV    DX,ES
  474.     DEC    AX
  475.     JMP    @@3
  476. @@2:    XOR    AX,AX
  477.     MOV    DX,AX
  478. @@3:    POP    DS
  479. end;
  480.  
  481. function StrUpper(Str: PChar): PChar; assembler;
  482. asm
  483.     PUSH    DS
  484.     CLD
  485.     LDS    SI,Str
  486.     MOV    BX,SI
  487.     MOV    DX,DS
  488. @@1:    LODSB
  489.     OR    AL,AL
  490.     JE    @@2
  491.     CMP    AL,'a'
  492.     JB    @@1
  493.     CMP    AL,'z'
  494.     JA    @@1
  495.     SUB    AL,20H
  496.     MOV    [SI-1],AL
  497.     JMP    @@1
  498. @@2:    XCHG    AX,BX
  499.     POP    DS
  500. end;
  501.  
  502. function StrLower(Str: PChar): PChar; assembler;
  503. asm
  504.     PUSH    DS
  505.     CLD
  506.     LDS    SI,Str
  507.     MOV    BX,SI
  508.     MOV    DX,DS
  509. @@1:    LODSB
  510.     OR    AL,AL
  511.     JE    @@2
  512.     CMP    AL,'A'
  513.     JB    @@1
  514.     CMP    AL,'Z'
  515.     JA    @@1
  516.     ADD    AL,20H
  517.     MOV    [SI-1],AL
  518.     JMP    @@1
  519. @@2:    XCHG    AX,BX
  520.     POP    DS
  521. end;
  522.  
  523. function StrPas(Str: PChar): String; assembler;
  524. asm
  525.     PUSH    DS
  526.     CLD
  527.     LES    DI,Str
  528.     MOV    CX,0FFFFH
  529.     XOR    AL,AL
  530.     REPNE    SCASB
  531.     NOT    CX
  532.     DEC    CX
  533.     LDS    SI,Str
  534.     LES    DI,@Result
  535.     MOV    AL,CL
  536.     STOSB
  537.     REP    MOVSB
  538.     POP    DS
  539. end;
  540.  
  541. {$W+}
  542.  
  543. function StrNew(Str: PChar): PChar;
  544. var
  545.   L: Word;
  546.   P: PChar;
  547. begin
  548.   StrNew := nil;
  549.   if (Str <> nil) and (Str^ <> #0) then
  550.   begin
  551.     L := StrLen(Str) + 1;
  552.     GetMem(P, L);
  553.     if P <> nil then StrNew := StrMove(P, Str, L);
  554.   end;
  555. end;
  556.  
  557. procedure StrDispose(Str: PChar);
  558. begin
  559.   if Str <> nil then FreeMem(Str, StrLen(Str) + 1);
  560. end;
  561.  
  562. end.
  563.