dal 2015 - visita n. 566
TpuStr
TpuStr

 

TpuStr

Le Procedure/Funzioni TPUSTR per TurboPASCAL (4.0÷7.0) aggiungono delle efficaci primitive per la gestione delle stringhe. Le TPUSTR sono caratterizzate dalla iniziale X (eXtended).
Queste procedure vengono costruite tramite la unit TPUSTR.PAS integrata dal file interface TPUSTR.INT e dal file implementation TPUSTR.IMP.

Sezioni Esterne in PascalSezioni Esterne in Assembly
  • Nessuna


Documentazione


Function XCharCountSt(Ch: Char; St: String): Integer;
Legge il numero di ricorrenze del carattere Ch all'interno della
stringa St, se Ch non esiste restituisce 0.
Es.: I:=XCharCountSt('A','FARFALLA');
restituisce I=3

Function XCharCountPtr(Ch: Char; Var Pt; L: Word): Integer;
Legge il numero di ricorrenze del carattere Ch all'interno dell'area
puntata da Pt ed estesa L byte, se Ch non esiste restituisce 0.
Es.: I:=XCharCountPtr(Ch,Ptr,L);

Function XCharPos(Ch: Char; St: String): Integer;
Legge la posizione del carattere Ch all'interno della stringa St, se
Ch non esiste restituisce 0. Analoga alla Pos(Q,St) del TurboPascal, ma
più veloce.
Aumenta l'efficienza se utilizzata al posto di XPos.
Es.: I:=XCharPos('R','VERDERAME');
restituisce I=3

Function XPos(Q,St: String): Integer;
Legge la posizione della stringa Q all'interno della stringa St, se
Q non esiste restituisce 0. Analoga alla Pos(Q,S) del TurboPascal, ma
più veloce.
Es.: I:=XPos('xyz','ABCDxyzEFG');
restituisce I=5

Function XMegaPos(Q: String; Var MSt): Integer;
Legge la posizione della stringa Q all'interno della Megastringa MStL,
se esiste, altrimenti restituisce 0.
Es.: I:=XMegaPos(Q,MStL);

Function XSearch(Q: String; Pseg,Pofs,L: Word): Word;
Legge la posizione della stringa Q all'interno dell'area puntata da
Pseg:Pofs ed estesa L byte, se Q non esiste restituisce 0.
Es.: I:=XSearch(Q,Pseg,Pofs,Len);

Function XScanText(C: Word; P: Pointer; L: Word): Word;
Cerca nell'area puntata da P e lunga L byte una zona di Testo caratteriz-
zata dalla presenza di C caratteri alfanumerici consecutivi.
Es.: W:=XScanText(5,Ptr,Len);

Function XScanNoText(C: Word; P: Pointer; L: Word): Word;
Cerca nell'area puntata da P e lunga L byte una zona di Non-Testo cara-
tterizzata dalla assenza di C caratteri alfanumerici consecutivi.
Es.: W:=XScanNoText(10,Ptr,Len);

Function XInstr(P: Byte; Q,St: String): Integer;
Cerca la stringa Q all'interno della stringa St, cominciando la ricer-
ca dalla posizione P, se esiste, altrimenti restituisce 0.
Analoga alla INSTR del BASIC.
Es.: I:=XInstr(P,Q,St);

Function XCompress(St: String): String;
Comprime la Stringa St col metodo "Run Length Encoding". Il caratte-
re di controllo usato è FFh che quindi non deve essere presente in St.
Es.: Xt:=XCompress(St);

Function XDeCompress(St: String): String;
Complementare di XCompress.
Es.: Xt:=XDeCompress(St);

Function XCripto(St: String; C: Byte): String;
Crittografa con chiave C la stringa St.
Obsoleta, utilizzare XCriptoDe.
Es.: Xt:=XCripto(St,C);

Function XDeCripto(St: String; C: Byte): String;
Decrittografa con chiave C la stringa St.
Obsoleta, utilizzare XCriptoDe.
Es.: Xt:=XDeCripto(St,C);

Function XCriptoDe(St: String; C: String): String;
Crittografa/Decrittografa con chiave C la stringa St. Da preferire alla
coppia XCripto-XDeCripto nelle nuove applicazioni. Se il testo da crit-
tografare è prevalentemente minuscolo evitare una chiave con caratteri
minuscoli e viceversa. Due applicazioni successive di XCriptoDe ripri-
stinano la stringa originaria.
Es.: Xt:=XCriptoDe('Prova di Crittografia','SEGRETO');
restituisce: W!*13e0&'C7.&1;(u2#.3
Xt:=XCriptoDe('W!*13e0&'C7.&1;(u2#.3','SEGRETO');
restituisce: Prova di Crittografia

Function XTab(St: String; N: Byte): String;
Inserisce i caratteri TAB in St.
Es.: Xt:=XTab(St);

Function XDeTab(St: String; N: Byte): String;
Complementare di XTab.
Es.: Xt:=XDeTab(St,8);

Function XMerge(Q,St: String; P: Byte): String;
Sovrappone la stringa Q sulla stringa St dalla posizione P in avanti.
Se P <= 0, St rimane inalterata.
Es.: Xt:=XMerge('argento','VERDERAME',6);
restituisce Xt='VERDEargento'

Function XMergeCut(Q,St: String; P: Byte): String;
Sovrappone la stringa Q sulla stringa St dalla posizione P in avanti.
Se Q è troppo lunga si sovrappone su St solo quella prima parte
di Q che vi può essere contenuta. Se P <= 0, St rimane inalterata.
Es.: Xt:=XMergeCut('argento','VERDERAME',6);
restituisce Xt='VERDEarge'

Function XNoChar(Ch: Char; St: String): String;
Elimina dalla stringa St i caratteri Ch.
Es.: Xt:=XNoChar('a','Farfalla');
restituisce Xt='Frfll'

Function XNoCharCo(Ch: Char; St: String): String;
Elimina i caratteri Ch in Coda a St.
Es.: Xt:=XNoCharCo('a','Farfallaaaaaaa');
restituisce Xt='Farfall'

Function XNoCharTe(Ch: Char; St: String): String;
Elimina i caratteri Ch in Testa a St.
Es.: Xt:=XNoCharTe('0','0005675');
restituisce Xt='5675'

Function XNoCharSet(Q,St: String): String;
Elimina dalla stringa St tutti i caratteri contenuti nella stringa Q.
Es.: Xt:=XNoCharSet('abcd','Roma caput mundi');
restituisce Xt='Rom put muni'

Function XYesCharSet(Q,St: String): String;
Elimina dalla stringa St i caratteri diversi da quelli contenuti nella
stringa Q.
Es.: Xt:=XYesCharSet('abcd','Roma caput mundi');
restituisce Xt='a ca d'

Function XLFill(Ch: Char; St: String; N: Byte): String;
Premette alla stringa St tanti caratteri Ch per una lunghezza comples-
siva N. Se Length(St) >= N, St rimane inalterata.
Es.: Xt:=XLFill(Ch,St,N);

Function XRFill(Ch: Char; St: String; N: Byte): String;
Accoda alla stringa St tanti caratteri Ch per una lunghezza complessiva
N. Se Length(St) >= N, St rimane inalterata.
Es.: Xt:=XRFill('x','ARCOBALENO',15);
restituisce Xt='ARCOBALENOxxxxx'

Function XNoSpace(St: String): String;
Elimina i caratteri spazio Inclusi in St.
Es.: Xt:=XNoSpace(' Roma caput mundi ');
restituisce Xt='Romacaputmundi'
* char far *XNoSpace(char far *St);

Function XNoSpaceCo(St: String): String;
Elimina i caratteri spazio in Coda a St.
Es.: Xt:=XNoSpaceCo(' Roma caput mundi ');
restituisce Xt=' Roma caput mundi'
* char far *XNoSpaceCo(char far *St);

Function XNoSpaceTe(St: String): String;
Elimina i caratteri spazio in Testa a St.
Es.: Xt:=XNoSpaceTe(' Roma caput mundi ');
restituisce Xt='Roma caput mundi '
* char far *XNoSpaceTe(char far *St);

Function XMonoSpa(St: String, T: Byte): String;
Riduce a uno gli spazi consecutivi in St. Se T=0 vengono eliminati
tutti gli spazi di testa e di coda.
Es.: Xt:=XMonoSpa(' Il canto delle sirene ',1);
restituisce Xt=' Il canto delle sirene '
Es.: Xt:=XMonoSpa(' Il canto delle sirene ',0);
restituisce Xt='Il canto delle sirene'

Function XPack(St: String): String;
Elimina i caratteri spazio e converte St in maiuscole.
Es.: Xt:=XPack(' Roma caput mundi ');
restituisce Xt='ROMACAPUTMUNDI'

Function XLSet(St: String; N: Byte): String;
Accoda alla stringa St tanti spazi fino a raggiungere una lunghezza
complessiva N. Se Length(St) > N ricopia i primi N caratteri di St,
tagliando la coda.
Es.: Xt:=XLSet('Arcobaleno',15);
restituisce Xt='Arcobaleno '

Function XRSet(St: String; N: Byte): String;
Inserisce prima della stringa St tanti spazi fino a raggiungere una
lunghezza complessiva N. Se Length(St) > N ricopia gli ultimi N ca-
ratteri di St, tagliando la testa.
Es.: Xt:=XRSet('Arcobaleno',15);
restituisce Xt=' Arcobaleno'

Function XLeftS(St: String; N: Byte): String;
Restituisce la parte sinistra di St (primi N caratteri).
Analaga alla LEFT$ del BASIC.
Es.: Xt:=XLeftS(St,N);

Function XRightS(St: String; N: Byte): String;
Restituisce la parte destra di St (ultimi N caratteri).
Analaga alla RIGHT$ del BASIC.
Es.: Xt:=XRightS('ARCOBALENO',6);
restituisce Xt='BALENO'

Function XString(N: Integer; Ch: Char): String;
Genera una stringa di N caratteri Ch.
Es.: Xt:=XString(10,'z');
restituisce Xt='zzzzzzzzzz'

Function XCenterStr(St: String; F: Byte): String;
Centra la stringa St, lunga L byte, in un campo ampio F byte. La fun-
zione premette a St (F-L)/2 spazi.
St resta inalterata nei seguenti casi:
- Length(St) = 0
- Length(St) >= F
- L + (F-L)/2 > 255 .
Es.: Xt:=XCenterStr('ARCOBALENO',20);
restituisce Xt=' ARCOBALENO'

Function XSpaceStr(St: String): String;
Alterna con spazi i caratteri della stringa St.
St resta inalterata nei seguenti casi:
- Length(St) = 0
- Length(St) > 128.
Es.: Xt:=XSpaceStr('MILANO');
restituisce Xt='M I L A N O'

Function XChange(St: String; Ch,NCh: Char): String;
Scambia in St tutti i caratteri Ch con NCh e viceversa.
Si noti la differenza con XStrip.
Es.: Xt:=XChange('122234567778','2','7');
restituisce Xt='177734562228'
Xt:=XStrip('122234567778','2','7');
restituisce Xt='177734567778'

Function XStrip(St: String; Ch,NCh: Char): String;
Cambia in St tutti i caratteri Ch con NCh.
Vedi anche XChange.
Es.: Xt:=XStrip('FARFALLA','A','a');
restituisce Xt='FaRFaLLa'

Function XStSubst(QSt,PSt: String; Var St: String): Boolean;
Cambia in St la prima occorrenza di QSt con PSt, restituisce TRUE
se è avvenuta la sostituzione altrimenti FALSE.
Es.: B:=XStSubst('ABC','xyzkc',St);

Function XSwapS(St: String; X,Y: Byte): String;
Scambia di posto in St i caratteri aventi le posizioni X e Y.
Es.: Xt:=XSwapS('ABCDEFG',2,3);
restituisce Xt='ACBDEFG'

Function XMirror(St: String): String;
Riflette la stringa St: l'ultimo carattere diviene il primo, il pe-
nultimo il secondo e così via.
Es.: Xt:=XMirror('ARCOBALENO');
restituisce Xt='ONELABOCRA'

Function XUpCase(St: String): String;
Converte in Maiuscole i caratteri di St.
Es.: Xt:=XUpCase('Milano');
restituisce Xt='MILANO'
* char far *XUpCase(char far *St);

Function XUpCaseW(St: String,F: Byte): String;
Converte in Maiuscole le iniziali delle parole di St.
Se F=0 le uniche maiuscole presenti in uscita saranno le iniziali.
Es.: Xt:=XUpCaseW('MILANO torino',0);
restituisce Xt='Milano Torino'
Xt:=XUpCaseW('MILANO torino',1);
restituisce Xt='MILANO Torino'

Function XLoCase(St: String): String;
Converte in Minuscole i caratteri di St.
Es.: Xt:=XLoCase('CAVALLO');
restituisce Xt='cavallo'
* char far *XLoCase(char far *St);

Function XUpLoCase(St: String): String;
Scambia in St le maiuscole in minuscole e viceversa.
Es.: Xt:=XUpLoCase('Roma');
restituisce Xt='rOMA'

Function XNotStr(St: String): String;
Applica ai caratteri di St l'operatore NOT.
Es.: Xt:=XNotStr('MILANO');
restituisce Xt='#+|'##'

Function XRotStrR(St: String): String;
Ruota Circolarmente verso Destra la stringa St.
Es.: Xt:=XRotStrR('GENOVA');
restituisce Xt='AGENOV'

Function XRotStrL(St: String): String;
Ruota Circolarmente verso Sinistra la stringa St.
Es.: Xt:=XRotStrR('GENOVA');
restituisce Xt='ENOVAG'

Function XStNumDot(St: String; F: Byte): String;
Inserisce in una stringa numerica i punti di separazione ogni 3 cifre.
Se il flag F vale 0 la parte decimale della stringa viene completata
con zeri fino al raggiungimento di una terzina di cifre.
Es.: Xt:=XStNumDot('1234567,2145',1);
restituisce Xt='1.234.567,214.5'
Xt:=XStNumDot('1234567,2145',0);
restituisce Xt='1.234.567,214.500'
Nota: La funzione complementare si ottiene utilizzando XNoChar(Ch,St).

Function XIntStr(Num: LongInt): String;
Converte l'intero Num (Byte, Integer, LongInt) in una stringa. Versione
Funzione della Procedura Standard Str.
Es.: St:=XIntStr(I);

Function XRealStr(Num: Real; I,D: Byte): String;
Converte il Real Num in una stringa. I e D sono le dimensioni del campo
Intero e del campo Decimale, se sono entrambe nulle viene attivata la
notazione scientifica. Versione Funzione della Procedura Str.
Es.: St:=XRealStr(R,I,D);

Function XHexStr(Var N; K: Word): String;
Converte il numero N (formato da K byte) in una stringa di 2*K caratte-
ri Hex.
Es.: Xt:=XHexStr(N,K);

Function XHexStrB(B: Byte): String;
Converte il numero N (byte) in una stringa di 2 caratteri Hex.
Es.: Xt:=XHexStrB(157);
restituisce Xt='9D'

Function XHexStrW(W: Word): String;
Converte la word W in una stringa di 4 caratteri.
Es.: St:=XHexStrW(W);

Function XHexStrD(D: LongInt): String;
Converte il LongInt D in una stringa di 8 caratteri.
Es.: St:=XHexStrD(L);

Function XWordCount(St: String): Word;
Conta il numero di parole contenute nella stringa St. L'elemento sepa-
ratore è lo spazio.
Es.: W:=XWordCount('Bella, la primavera'); restituisce W=3

Procedure XStrAsciiz(St: String; Var V);
Trasforma la stringa Pascal St in una ASCIIZ collocata in V.
Es.: XStrAsciiz('Pippo'; Var V);
pone in V l'equivalente Assembler di DB "Pippo",0

Procedure XStrAsciiz32(St: String; Var V);
Trasforma la stringa Pascal St in una ASCIIZ collocata in V,
V sarà sempre portata a 32 byte con l'aggiunta di Zeri.
La stringa in input sarà troncata al 31mo carattere, se più lunga.
Es.: XStrAsciiz('Pippo'; Var V);
pone in V l'equivalente Assembler di DB "Pippo",27 DUP(0)

Function XAsciizStr(Var V): String;
Trasforma la stringa ASCIIZ collocata in V in una stringa Pascal.
Es.: St:=XAsciizStr(V);
Se V è l'equivalente Assembler di DB "Pippo",0
rende St:='Pippo'

Function XSillaba(St: String): String;
Restituisce la stringa St (di una parola) divisa in sillabe separate
da un trattino.
Es.: St:=XSillaba('Lapislazzulo');
rende St:='La-pi-slaz-zu-lo'

Function XStrType(S: String; C: TP_CharSet): boolean;
Restituisce TRUE se tutti caratteri di S appartengono a C.
TP_CharSet è un tipo predefinito dalla unit TPUSTR come "Set of Char".
Risultano pure predefiniti i seguenti set:
TP_UpAlpha := ['A'..'Z'] ;
TP_LoAlpha := ['a'..'z'] ;
TP_Alpha := ['A'..'Z','a'..'z'] ;
TP_Numeric := ['0'..'9','+','-','/','*','.'] ;
TP_Digit := ['0'..'9'] ;
Es.: XStrType('Lapislazzulo',TP_Alpha) restituisce TRUE.

Function XN2Str(N: Real; W,D: Integer): String;
Converte il numero reale N in una stringa che rappresenta il valore,
in accordo ai parametri di formattazione W (width) e D (decimals).
L'effetto è identico a quello della chiamata a Write con gli stessi
parametri, eccetto che la stringa risultante viene restituita.
Es.: XN2Str(3.14159,5,2) restituisce ' 3.14'

Function XBeforeSt(Src, Tgt: String): String;
Restituisce la parte di stringa Src che precede Tgt all'interno della
stessa Src.
Es.: XBeforeSt('Arcobaleno','baleno') restituisce 'Arco'

Function XAfterSt(src, tgt: String): String;
Restituisce la parte di stringa Src che segue Tgt all'interno della
stessa Src.
Es.: XAfterSt('Arcobaleno','Arco') restituisce 'baleno'

Function XGetPathSt(St: String): String;
Restituisce la parte di St che simboleggia un path.
Es.: XGetPathSt('C:\WORK\PROVA.PAS') restituisce 'C:\WORK\'


Function XParseSt(Var Src: String; Sep: String): String;
Esegue il seguente lavoro:
XParseSt:=XBeforeSt(Src,Sep); Src:=XAfterSt(Src,Sep);

Function XStrValue(ExpLine: String; var Error: boolean): Real;
Restituisce il risultato numerico dell'espressione ExpLine.
Es.: R:=XStrValue('4*5+12',Err); da R=32.0 ed Err=False


TpuBase
TpuBit
TpuCrono
TpuFile
TpuModeX
TpuStr



Chi è pietoso contro i crudeli finisce con l'essere crudele contro i pietosi.
Talmud

Valid CSS!
pagina generata in 0.001 secondi