Programmer 7500

home *** CD-ROM | disk | FTP | other *** search

/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / TPFAST40.ZIP / TPFSTR.ASM < prev next >

Wrap

Assembly Source File | 1991-11-14 | 51.2 KB | 938 lines

; _______________________________________________________________ ; | | ; | CopyRight (c) 1989,1990 Steven Lutrov | ; |_______________________________________________________________|____ ; | | | ; | program title : faststr.asm | | ___ ; | author : Steven Lutrov | | | ; | revision : 4.00 | | | ; | date : 1991-11-01 | | | ; | language : turbo assembler | | | ; | | | | ; | description : assembly functions for string manipulation. | | | ; | : tested on turbo pascal 5.0 & 5.5 | | | ; | | | | ; |_______________________________________________________________| | | ; | | | ; |________________________________________________________________| | ; | | ; |_________________________________________________________________| ; code segment word public assume cs:code,ds:data public changechar,compare,stringend,deletechar,deleteleft,deleteright public leftend,lowercase,overwrite,padcentre,padends,padleft,padright public replace,rightend,seekstring,stringof,uppercase,wordcount ;------------------------------------------------------------------------------- ;procedure changechar(var strx: stype; search,replace :char); ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; changechar proc far push bp ;save bp mov bp,sp ;set up stack frame mov TPFError,0 ;assume char found les di,dword ptr[bp+10] ;es:di pts to strx sub dx,dx ;flags that a char found mov al,[bp+6] ;get replacement char mov ah,[bp+8] ;search character sub cx,cx ;clear cx mov cl,es:[di] ;get string length jcxz changechar3 ;quit if null string changechar1: inc di ;forward string ptr cmp es:[di],ah ;search char? jne changechar2 ;jump ahead if not mov es:[di],al ;else change char inc dx ;flag that a char found changechar2: loop changechar1 ;go do next char or dx,dx ;test if char found jnz changechar4 ;jump ahead if so changechar3: inc TPFError ;else 1 = char not found changechar4: pop bp ;restore bp and quit ret 8 changechar endp ;------------------------------------------------------------------------------- ;function compare(strg1,strg2: stype): boolean; ;------------------------------------------------------------------------------- ; compare proc far mov bx,sp ;bx pts to stack push ds ;save turbo's ds les di,ss:dword ptr[bx+8] ;es:di pts to strg1 lds si,ss:dword ptr[bx+4] ;ds:si pts to strg2 sub cx,cx ;clear cx mov cl,[si] ;get strg2 length cmp cl,es:[di] ;equal to strg1 length? jne compare6 ;quit if not jcxz compare5 ;quit if both null compare1: inc di ;forward strg1 ptr inc si ;forward strg2 ptr mov al,[si] ;get strg2 char cmp al,es:[di] ;compare to strg1 char je compare4 ;loop if equal cmp al,122 ;above lower case vals? ja compare6 ;quit if so cmp al,97 ;lower case char? jnae compare2 ;jump ahead if not sub al,32 ;make lower case jmp short compare3 ;go test it compare2: cmp al,90 ;above upper case vals? ja compare6 ;quit if so cmp al,65 ;upper case char? jnae compare6 ;quit if not add al,32 ;make lower case compare3: cmp al,es:[di] ;compare to strg1 char jne compare6 ;quit if not equal compare4: loop compare1 ;go do next char compare5: mov al,1 ;return true jmp short compare7 ;jump ahead compare6: mov al,0 ;return false compare7: pop ds ;restore ds and quit ret 8 compare endp ;------------------------------------------------------------------------------- ;function stringend(strx: stype; numberchars :integer): stype; ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; stringend proc far push bp ;save bp mov bp,sp ;set up stack frame push ds ;save ds les di,dword ptr[bp+12] ;es:di pts to return strx lds si,dword ptr[bp+8] ;ds:si pts to source strx sub cx,cx ;clear cx mov es:[di],cl ;return null string if error mov cl,[bp+6] ;get numberchars (255 max) sub bx,bx ;clear bx mov bl,[si] ;strx length in bx mov dl,1 ;1 = null string or bl,bl ;test for null string jz stringend3 ;quit routine if null dec dl ;0 = no error cmp cx,bx ;numberchars < length? jbe stringend1 ;jump ahead if so mov cx,bx ;else return whole string mov dl,2 ;2 = numberchars greater than length stringend1: mov es:[di],cl ;return strx descriptor sub bx,cx ;length minus numberchars inc di ;forward return strx ptr to first char inc si ;save for source strx add si,bx ;add starting offset to source stringend2: cld ;direction forward rep movsb ;move the portion of the string stringend3: pop ds ;restore ds mov TPFError,dl ;set TPFError pop bp ;restore bp and quit ret 6 stringend endp ;------------------------------------------------------------------------------- ;procedure deletechar(var strx: stype; ch :char); ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; ; deletechar proc far cld ;set direction flag mov TPFError,1 ;1 = char not found push bp ;save bp push ds ;save ds mov bp,sp ;set up stack frame les di,dword ptr [bp+10] ;get string address mov al,[bp+8] ;get char to delete sub bp,bp ;use bp as TPFError flag push es ;push es... pop ds ;...then copy into ds mov bx,di ;bx will pt to descriptor sub cx,cx ;clear cx mov cl,es:[di] ;get string length jcxz deletechar3 ;quit if null string inc di ;pt di to start of string mov si,di ;copy into si cld ;direction forward in movsb deletechar1: cmp [si],al ;check for the character je deletechar2 ;jump if char found movsb ;move the char loop deletechar1 ;go check next char jmp short deletechar3 ;finished deletechar2: inc si ;forward source ptr dec byte ptr[bx] ;decrease string descriptor inc bp ;flag that char found loop deletechar1 ;go check next char deletechar3: pop ds ;restore ds or bp,bp ;test bp for zero jz deletechar4 ;jump if no match found dec TPFError ;else TPFError = 0 deletechar4: pop bp ;restore bp and quit ret 6 deletechar endp ;------------------------------------------------------------------------------- ;procedure deleteleft(var strx: stype; border :char); ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; deleteleft proc far mov TPFError,0 ;assume no error push ds ;ds is changed push bp ;save bp mov bp,sp ;set up stack frame les di,dword ptr [bp+10] ;es:di pts to string lds si,dword ptr [bp+10] ;so does ds:si mov si,di ;keep si at descriptor mov al,[bp+8] ;get the border character pop bp ;restore bp sub cx,cx ;clear cx mov cl,es:[di] ;string length in cx jcxz deleteleft1 ;quit if null mov bx,cx ;copy of string length in bx inc di ;pt to first byte of string cld ;direction forward repne scasb ;look for the border character jnz deleteleft1 ;quit if can't find char mov dx,di ;copy of di to dx dec dx ;point to char before sub dx,si ;number characters to delete dec dx ;don't delete border char mov cx,bx ;old string length sub cx,dx ;new string length mov [si],cl ;set new string length inc si ;point si to start of string xchg di,si ;reverse pointers for movsb dec si ;don't remove border char rep movsb ;move the characters pop ds ;restore ds ret 6 ;quit deleteleft1: pop ds ;---error case: inc TPFError ;1 = null string or char not found ret 6 ;quit deleteleft endp ;------------------------------------------------------------------------------- ;procedure deleteright(var strx: stype; border :char); ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; deleteright proc far push bp ;save bp mov bp,sp ;set up stack frame les di,dword ptr [bp+8] ;load string address mov si,di ;keep si at descriptor mov al,[bp+6] ;get the border character sub cx,cx ;clear cx mov TPFError,1 ;1 = null string mov cl,es:[di] ;string length in cx jcxz deleteright3 ;quit if null add di,cx ;point di to end of string deleteright1: cmp [di],al ;test for the border char je deleteright2 ;if found, jump ahead dec di ;else, point to next char loop deleteright1 ;go test next char jmp short deleteright3 ;char not found deleteright2: mov es:[si],cl ;set new string length dec TPFError ;no error deleteright3: pop bp ;restore bp and quit ret 6 deleteright endp ;------------------------------------------------------------------------------- ;function leftend(var strx: stype; border :char): stype; ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; leftend proc far mov dl,1 ;1 = border char not found push bp ;save bp mov bp,sp ;set up stack frame push ds ;save ds les di,dword ptr[bp+8] ;es:di pts to strx sub cx,cx ;clear cx mov cl,es:[di] ;string length to cx jcxz leftend2 ;quit if zero inc di ;pt to 1st byte of strx mov bx,di ;copy start position cld ;direction forward mov al,[bp+6] ;border character repne scasb ;search for the character jnz leftend1 ;not found, skip ptr dec dec di ;pull back ptr dec dl ;TPFError = 0, no error leftend1: sub di,bx ;distance to char mov cx,di ;use as counter mov ax,es ;transfer es... mov ds,ax ;to ds mov si,bx ;now ds:si pts to start of strx leftend2: les di,dword ptr[bp+12] ;now es:di pts to return string mov es:[di],cl ;set return descriptor jcxz leftend3 ;jump ahead if null strx inc di ;forward ptr rep movsb ;move the string leftend3: pop ds ;restore ds mov TPFError,dl ;set TPFError pop bp ;restore bp and quit ret 6 leftend endp ;------------------------------------------------------------------------------- ;procedure lowercase(var strx: stype); ;------------------------------------------------------------------------------- ; lowercase proc far mov bx,sp ;bx points to stack les di,ss:dword ptr[bx+4] ;es:di pts to string sub cx,cx ;clear cx mov cl,es:[di] ;get string length jcxz lowercase3 ;quit if null lowercase1: inc di ;pt to next char of strx cmp es :byte ptr [di],'Z' ;test high char ja lowercase2 ;skip ahead if above cmp es :byte ptr [di],'A' ;test low char jb lowercase2 ;skip ahead if below add es :byte ptr [di],32 ;change the char lowercase2: loop lowercase1 ;go test next character lowercase3: ret 4 lowercase endp ;------------------------------------------------------------------------------- ;procedure overwrite(var strx: stype; substrg: stype; position :integer); ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; overwrite proc far mov TPFError,0 ;assume no error push bp ;save bp mov bp,sp ;set up stack frame push ds ;ds is changed les di,dword ptr [bp+12] ;es:di pts to strx mov bx,di ;bx points to strx sub cx,cx ;clear cx mov cl,[bp+6] ;position in cx jcxz overwrite2 ;quit if zero cmp cl,es:[di] ;is position within strx? ja overwrite2 ;quit if not mov dx,cx ;keep for error check add di,cx ;add to string ptr lds si,dword ptr [bp+8] ;ds:si pts to substring mov cl,[si] ;get the string descriptor jcxz overwrite2 ;quit if null add dx,cx ;dx = substr endchar + 1 sub dl,es:[bx] ;subtract string length cmp dl,1 ;will substring fit? jg overwrite3 ;if not, quit routine overwrite1: inc si ;pt to next substrg char mov dl,[si] ;get the char mov es:[di],dl ;insert into the string inc di ;pt to next char of strx loop overwrite1 ;go do next character pop ds ;restore ds jmp short overwrite5 ;terminate without error overwrite2: mov al,1 ;1 = position not in string jmp short overwrite4 ;jump ahead overwrite3: mov al,2 ;2 = substring won't fit overwrite4: pop ds ;restore ds mov TPFError,al ;set TPFError overwrite5: pop bp ;restore bp and quit ret 10 overwrite endp ;------------------------------------------------------------------------------- ;procedure padcentre(var strx: stype; ch :char; position,length :integer); ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; padcentre proc far push bp ;save bp mov bp,sp ;set up stack frame mov TPFError,1 ;1 = error les di,dword ptr[bp+12] ;es:di pts to strx mov si,di ;copy in si sub dx,dx ;clear dx mov dl,[bp+6] ;new strx length in dx (255 max) or dx,dx ;test for zero length jz padcentre6 ;quit if zero mov bx,dx ;copy of length in bx sub cx,cx ;clear cx mov cl,es:[di] ;get current strx length cmp cx,dx ;compare to new length jae padcentre6 ;quit if longer mov es:[di],dl ;set new strx length sub dx,cx ;dx = number pad chars sub ax,ax ;clear ax mov al,[bp+8] ;get position or ax,ax ;test for 0 jnz padcentre1 ;jump if not 0 inc ax ;else make 1 padcentre1: cmp ax,cx ;past end of string? jna padcentre2 ;jump ahead if not add di,cx ;offset to end of strx jmp short padcentre4 ;go write pad chars padcentre2: add si,bx ;add to target add di,bx ;add to source sub di,dx ;source minus number pad chars sub cx,ax ;subtract from strx len inc cx ;ax pts from 0, adjust padcentre3: mov al,es:[di] ;get a char mov es:[si],al ;shift it upwards dec di ;pull back source ptr dec si ;target ptr too loop padcentre3 ;do next char padcentre4: mov cx,dx ;number pad characters mov al,[bp+10] ;get pad character padcentre5: inc di ;forward ptr mov es:[di],al ;write pad character loop padcentre5 ;go do the next dec TPFError ;0 = no error padcentre6: pop bp ;restore bp and quit ret 10 padcentre endp ;------------------------------------------------------------------------------- ;procedure padends(var strx: stype; ch :char; length :integer); ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; padends proc far push bp ;save bp mov bp,sp ;set up stack frame mov TPFError,1 ;1 = error les di,dword ptr[bp+10] ;es:di pts to strx mov si,di ;copy in si sub dx,dx ;clear dx mov dl,[bp+6] ;new strx length in dx or dx,dx ;test for zero length jz padends7 ;quit if zero sub cx,cx ;clear cx mov cl,es:[di] ;get strx length cmp cx,dx ;is strx gt new length jae padends7 ;quit if true mov es:[di],dl ;set new strx length push di ;copy of start of string sub dx,cx ;dx = number pad chars mov bx,dx ;copy to bx shr bx,1 ;chars div 2 sub dx,bx ;dx is same or 1 larger add di,cx ;pt to end of strx add si,dx ;offset for upward shift add si,cx ;plus string length or cx,cx ;test for null string jnz padends1 ;jump ahead if not null sub bx,bx ; mov bl,[bp+6] ;otherwise set at right padding jmp short padends3 ;jump to rightside padding padends1: push si ;save end position padends2: mov al,es:[di] ;get a char mov es:[si],al ;shift it dec di ;dec source ptr dec si ;dec target ptr loop padends2 ;go do next pop si ;restore end position padends3: mov al,[bp+8] ;get the pad char mov cx,bx ;number to pad on right jcxz padends5 ;jump ahead if zero padends4: inc si ;forward ptr mov es:[si],al ;write pad char on right loop padends4 ;go do next padends5: pop di ;di pts to bottom of strx mov cx,dx ;number pad chars on left or cx,cx ;test for zero jz padends7 ;quit if zero padends6: inc di ;forward ptr mov es:[di],al ;write pad char on left loop padends6 ;go do next dec TPFError ;0 = no error padends7: pop bp ;restore bp and quit ret 8 padends endp ;------------------------------------------------------------------------------- ;procedure padleft(var strx: stype; ch :char; length :integer); ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; padleft proc far push bp ;save bp mov bp,sp ;set up stack frame mov TPFError,1 ;1 = error push ds ;save ds les di,dword ptr[bp+10] ;get string address push es ;push es... pop ds ;...then load into ds sub cx,cx ;clear cx mov cl,es:[di] ;string length in cl mov bx,[bp+6] ;new string length in bl dec bx ;dec bx for test cmp bx,254 ;in range? ja padleft2 ;quit if not inc bx ;readjust cmp cl,bl ;compare the two lengths jae padleft2 ;quit if old len >= new mov es:[di],bl ;set new string length mov si,di ;pt si to descriptor add si,cx ;now pt si to string end add di,bx ;pt di to new string end sub bx,cx ;number of spaces to pad std ;set direction flag rep movsb ;move old string right mov cx,bx ;spaces to pad in cx mov al,[bp+8] ;get pad character padleft1: mov [di],al ;insert pad char dec di ;move to next position loop padleft1 ;go do next char pop ds ;restore ds dec TPFError ;0 = no error jmp short padleft3 ;jump ahead and quit padleft2: pop ds ;exit with error padleft3: pop bp ;restore bp and quit ret 8 padleft endp ;------------------------------------------------------------------------------- ;procedure padright(var strx: stype; ch :char; length :integer); ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; padright proc far push bp ;save bp mov bp,sp ;set up stack frame mov TPFError,1 ;1 = error les di,dword ptr[bp+10] ;get string address sub cx,cx ;clear cx mov cl,es:[di] ;string length in cl mov bx,[bp+6] ;new string length dec bx ;dec bx for test cmp bx,254 ;in range? ja padright2 ;quit if not inc bx ;readjust cmp cl,bl ;compare the two lengths jae padright2 ;quit if old len>=new len mov es:[di],bl ;set new string length add di,cx ;point di to end of strx sub bx,cx ;sub old len from new len mov cx,bx ;use as counter mov al,[bp+8] ;get pad character padright1: inc di ;increment pointer mov es:[di],al ;insert a pad char loop padright1 ;go do next char dec TPFError ;0 = no error padright2: pop bp ;restore bp and quit ret 8 padright endp ;------------------------------------------------------------------------------- ;procedure replace(var strx: stype; substrg: stype; position,chars :integer); ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; replace proc far push bp ;save bp mov bp,sp ;set up stack frame push ds ;save ds too mov TPFError,1 ;1 = error has occured les di,dword ptr[bp+14] ;es:di pts to strx sub cx,cx ;clear cx mov byte ptr[bp+7],cl ;use byte as if word mov cl,es:[di] ;get strx length or cx,cx ;test for null string jnz replace2 ;jump ahead if not replace1: jmp replace9 ;else quit routine replace2: sub bx,bx ;clear bx mov bl,[bp+8] ;position to bx or bx,bx ;position 0? jz replace1 ;quit if zero cmp bx,cx ;within strx? jnbe replace1 ;quit if not lds si,dword ptr[bp+10] ;ds:si pts to substrg sub dx,dx ;clear dx mov dl,[si] ;substring length or dx,dx ;test for null jz replace1 ;quit if null mov ax,cx ;strx length sub ax,bx ;minus position inc ax ;number deletable chars cmp ax,[bp+6] ;cmp to num chars to del jb replace9 ;quit if not enough chars mov ax,[bp+6] ;chars to delete cmp ax,dx ;num chars del/replace ja replace3 ;must shift chars down jb replace5 ;must shift chars up add di,bx ;no shift, di to overlay jmp short replace7 ;no write substring replace3: sub ax,dx ;strx shortened this much sub cx,ax ;new string length mov es:[di],cl ;set descriptor add di,bx ;pt to substrg position mov si,di ;copy to si add si,dx ;pt to end of substrg + 1 sub cx,bx ;chars following substrg inc cx ;adjust mov bx,si ;end of substring pos add bx,ax ;forward to shift point replace4: mov al,es:[bx] ;get a char mov es:[si],al ;move it downward inc si ;inc target ptr inc bx ;inc source ptr loop replace4 ;loop till finished jmp short replace7 ;go write substring replace5: neg ax ;dx minus ax in ax add ax,dx ;ax = increased strx len add cx,ax ;new length mov es:[di],cl ;set descriptor mov si,di ;si pts to start of strx add di,bx ;point di to substrg pos add si,cx ;si pts to end of strx mov bx,si ;copy to bx sub bx,ax ;move to shift point sub cx,[bp+8] ;length minus position dec cx ;adjust jcxz replace7 ;boundary case replace6: mov al,es:[bx] ;get a character mov es:[si],al ;move it upwards dec si ;dec target ptr dec bx ;get source ptr loop replace6 ;loop till finished replace7: lds si,dword ptr[bp+10] ;point ds:si back to substrg inc si ;forward si to first char replace8: mov cl,[si] ;get char from substring mov es:[di],cl ;move to strx inc si ;forward source ptr inc di ;forward target ptr dec dx ;dec substring ctr jnz replace8 ;loop till finished pop ds ;restore ds dec TPFError ;0 = no error jmp short replace10 ;jump ahead replace9: pop ds ;terminate with error replace10: pop bp ;restore bp and quit ret 12 replace endp ;------------------------------------------------------------------------------- ;function rightend(var strx: stype; border :char): stype; ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; rightend proc far push bp ;save bp mov bp,sp ;set up stack frame push ds ;save ds mov dl,1 ;1 = border char not found les di,dword ptr[bp+8] ;es:di pts to strx sub cx,cx ;clear cx mov cl,es:[di] ;string length to cx jcxz rightend2 ;quit if zero add di,cx ;pt to last byte of strx mov si,di ;copy start position std ;direction flag backward mov al,[bp+6] ;border character repne scasb ;search for the character jnz rightend1 ;skip inc if not found inc di ;discard border char dec dl ;TPFError = 0, no error rightend1: inc di ;step pointer back sub si,di ;figure number characters inc si ;adjust mov cx,si ;use as counter mov ax,es ;transfer es... mov ds,ax ;to ds mov si,di ;ds:si pts to strx rightend2: les di,dword ptr[bp+12] ;now es:di pts to return string mov es:[di],cl ;set return descriptor jcxz rightend3 ;jump ahead if null strx inc di ;forward ptr cld ;direction flag forward rep movsb ;move the string rightend3: pop ds ;restore ds mov TPFError,dl ;set TPFError pop bp ;restore bp and quit ret 6 rightend endp ;------------------------------------------------------------------------------- ;function seekstring(strx,substrg: stype; startpt :integer) :integer; ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; ; seekstring proc far push bp ;save bp mov bp,sp ;set up stack frame push ds ;save turbo's ds lds si,dword ptr[bp+12] ;ds:si pts to strx les di,dword ptr[bp+8] ;ds:di pts to substrg sub cx,cx ;clear cx mov cl,[bp+6] ;get startpt mov bp,1 ;1 = startpt out of range jcxz seekstring11 ;quit if zero mov dl,es:[di] ;substr length in dl inc di ;di pts 1st chr of substr inc bp ;2 = substrg is null or dl,dl ;substr length non-zero? jnz seekstring21 ;continue if so seekstring11: jmp seekstring1 ;error: quit routine seekstring21: mov dh,[si] ;strx length in dh dec bp ;1 = strx is null or dh,dh ;test for null jz seekstring11 ;quit if null mov bl,cl ;startpt add bl,dl ;substrg length dec bl ;adjust cmp bl,dh ;compare to strx length ja seekstring11 ;quit if out of range mov bp,0 ;0 = no error mov bl,cl ;startpt to pos counter dec bl ;adjust sub dh,cl ;sub from search len inc dh ;adjust add si,cx ;begin search at startpt seekstring31: mov al,es:[di] ;get char from of substr mov ah,al ;copy in ah cmp al,97 ;low end of lower case jb seekstring41 ;jump if below cmp al,122 ;upper end of lower case ja seekstring51 ;neither upper nor lower sub ah,32 ;make ah upper case jmp short seekstring51 ;go test both seekstring41: cmp al,65 ;low end of upper case jb seekstring51 ;neither upper nor lower cmp al,90 ;high end of upper case ja seekstring51 ;neither upper nor lower add ah,32 ;make ah lower case seekstring51: inc bl ;inc strx pos counter or dh,dh ;counter = zero? jz seekstring111 ;quit if so dec dh ;dec length counter mov bh,[si] ;get char from strx cmp bh,al ;test for match je seekstring61 ;jump if found cmp bh,ah ;2nd test for match je seekstring61 ;jump if found inc si ;forward strx ptr jmp short seekstring51 ;go check next char seekstring61: cmp dl,1 ;single char substring? je seekstring1 ;if so, not a match sub cx,cx ;clear cx mov cl,dl ;cx = substr length dec cl ;1st char already matched push si ;save strx position push di ;save substr position seekstring71: inc si ;pt to nxt char of strx inc di ;pt to nxt char of substr mov al,es:[di] ;get char from of substr mov ah,al ;copy in ah cmp al,97 ;low end of lower case jb seekstring81 ;jump if below cmp al,122 ;upper end of lower case ja seekstring91 ;neither upper nor lower sub ah,32 ;make ah upper case jmp short seekstring91 ;go test both seekstring81: cmp al,65 ;low end of upper case jb seekstring91 ;neither upper nor lower cmp al,90 ;high end of upper case ja seekstring91 ;neither upper nor lower add ah,32 ;make ah lower case seekstring91: mov bh,[si] ;get char from strx cmp bh,al ;test for match je seekstring101 ;jump if found cmp bh,ah ;2nd test for match je seekstring101 ;jump if found pop di ;match not made pop si ;restore prior ptrs inc si ;forward strx ptr jmp short seekstring31 ;resume search for 1st ch seekstring101: loop seekstring71 ;go compare next char pop di ;substring found! pop si ;balance stack jmp short seekstring1 ;go set return value seekstring111: sub bl,bl ;return 0 seekstring1: sub bh,bh ;return in bl, clear bh mov ax,bx ;set return value pop ds ;restore ds mov bx,bp ;get return value mov TPFError,bl ;set TPFError pop bp ;restore bp and quit ret 10 seekstring endp ;------------------------------------------------------------------------------- ;function stringof(substrg: stype; length :integer): stype; ;------------------------------------------------------------------------------- ; data segment extrn TPFError :byte data ends ; stringof proc far push bp ;save bp mov bp,sp ;set up stack frame mov TPFError,1 ;1 = error push ds ;save ds les di,dword ptr[bp+12] ;es:di pts to return string lds si,dword ptr[bp+8] ;ds:si pts to substring mov byte ptr es:[di],0 ;return null string if error mov cx,[bp+6] ;return string length jcxz stringof3 ;quit if null sub ch,ch ;255 max mov dl,[si] ;get substring length mov dh,dl ;copy in dh or dl,dl ;test for zero length jz stringof3 ;quit if zero mov es:[di],cl ;set return strx descriptor mov bx,si ;copy strx start point stringof1: inc di ;forward ret strx ptr inc si ;forward strx ptr mov al,[si] ;get character mov es:[di],al ;write character dec cx ;finished yet? jz stringof2 ;quit if so dec dl ;end of strx yet? jnz stringof1 ;loop if not mov dl,dh ;renew strx counter mov si,bx ;si back to start of strx jmp short stringof1 ;go start strx again stringof2: pop ds ;restore ds dec TPFError ;0 = no error jmp short stringof4 ;jump ahead stringof3: pop ds ;terminate with error stringof4: pop bp ;restore bp and quit ret 6 stringof endp ;------------------------------------------------------------------------------- ;procedure uppercase(var strx: stype); ;------------------------------------------------------------------------------- ; uppercase proc far mov bx,sp ;bx points to stack les di,ss:dword ptr[bx+4] ;es:di pts to string sub cx,cx ;clear cx mov cl,es:[di] ;get string length jcxz uppercase3 ;quit if null uppercase1: inc di ;pt to next char of strx cmp es :byte ptr [di],'z' ;test high char ja uppercase2 ;skip ahead if above cmp es :byte ptr [di],'a' ;test low char jb uppercase2 ;skip ahead if below sub es :byte ptr [di],32 ;change the char uppercase2: loop uppercase1 ;go test next character uppercase3: ret 4 uppercase endp ;=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- ;function wordcount(strx: stype) :integer; ; ; wordcount proc far mov bx,sp ;bx points to stack les di,ss:dword ptr[bx+4] ;point es:di to string sub dx,dx ;clear dx as counter mov cx,dx ;clear cx mov cl,es:[di] ;get string descriptor mov al,32 ;al holds space char wordcount1: jcxz wordcount3 ;jump ahead at eol inc di ;forward pointer dec cx ;dec strx counter cmp es:[di],al ;char a space? je wordcount1 ;loop if so inc dx ;word starts -- inc ctr wordcount2: jcxz wordcount3 ;jump ahead at eol inc di ;forward pointer dec cx ;dec strx counter cmp es:[di],al ;char a space? je wordcount1 ;back to spc loop if so jmp short wordcount2 ;else next word char wordcount3: mov ax,dx ;set return value ret 4 wordcount endp code ends end