perlclib - Online nel cloud

PROGRAMMA:

NOME

perlclib - Sostituzioni interne per le funzioni standard della libreria C

DESCRIZIONE

Una cosa che i porter Perl dovrebbero notare è che perl non tende a usare molto il C
libreria standard internamente; vedrai un utilizzo molto limitato, ad esempio, di ctype.h
funzioni presenti. Questo perché Perl tende a reimplementare o astrarre la libreria standard
funzioni, in modo da sapere esattamente come funzioneranno.

Questa è una scheda di riferimento per le persone che hanno familiarità con la libreria C e che vogliono fare
le cose nel modo Perl; per dire loro quali funzioni dovrebbero usare invece di quelle più
normali funzioni C.

convenzioni
Nelle tabelle seguenti:

"T"
è un tipo.

"p"
è un puntatore.

"n"
è un numero

"S"
è una stringa.

"sv", "av", "hv", ecc. rappresentano variabili dei rispettivi tipi.

Compila il Operazioni
Invece del stdio. h funzioni, dovresti usare il livello di astrazione Perl. Invece di
Per i tipi "FILE*", è necessario gestire i tipi "PerlIO*". Non dimenticare che con il nuovo
I tipi "FILE*" di astrazione I/O a strati di PerlIO potrebbero non essere nemmeno disponibili. Vedere anche
Documentazione "perlapio" per maggiori informazioni sulle seguenti funzioni:

Invece di: Usa:

stdin PerlIO_stdin()
stdout PerlIO_stdout()
stderr PerlIO_stderr()

fopen(fn, modalità) PerlIO_open(fn, modalità)
freopen(fn, mode, stream) PerlIO_reopen(fn, mode, perlio) (Dipende-
(riportato)
fflush(flusso) PerlIO_flush(perlio)
fclose(flusso) PerlIO_close(perlio)

Compila il Ingresso e Uscita
Invece di: Usa:

fprintf(stream, fmt, ...) PerlIO_printf(perlio, fmt, ...)

[f]getc(flusso) PerlIO_getc(perlio)
[f]putc(flusso, n) PerlIO_putc(perlio, n)
ungetc(n, flusso) PerlIO_ungetc(perlio, n)

Si noti che gli equivalenti PerlIO di "fread" e "fwrite" sono leggermente diversi dai loro
Controparti della libreria C:

fread(p, dimensione, n, flusso) PerlIO_read(perlio, buf, numbytes)
fwrite(p, dimensione, n, flusso) PerlIO_write(perlio, buf, numbytes)

fputs(s, flusso) PerlIO_puts(perlio, s)

Non esiste un equivalente di "fgets"; al suo posto si dovrebbe usare "sv_gets":

fgets(s, n, stream) sv_gets(sv, perlio, append)

Compila il Posizionamento
Invece di: Usa:

feof(flusso) PerlIO_eof(perlio)
fseek(flusso, n, da dove) PerlIO_seek(perlio, n, da dove)
riavvolgi(flusso) PerlIO_rewind(perlio)

fgetpos(stream, p) PerlIO_getpos(perlio, sv)
fsetpos(stream, p) PerlIO_setpos(perlio, sv)

ferror(flusso) PerlIO_error(perlio)
clearerr(flusso) PerlIO_clearerr(perlio)

Memorie Management e Corda Manovrabilità
Invece di: Usa:

t* p = malloc(n) Newx(p, n, t)
t* p = calloc(n, s) Newxz(p, n, t)
p = realloc(p, n) Rinnova(p, n, t)
memcpy(dst, src, n) Copia(src, dst, n, t)
memmove(dst, src, n) Sposta(src, dst, n, t)
memcpy(dst, src, sizeof(t)) StructCopy(src, dst, t)
memset(dst, 0, n * sizeof(t)) Zero(dst, n, t)
memzero(dst, 0) Zero(dst, n, char)
libero(p) Sicuro(p)

strdup(p) savepv(p)
strndup(p, n) savepvn(p, n) (Ehi, strndup non
esistere!)

strstr(grande, piccolo) instr(grande, piccolo)
strcmp(s1, s2) strLE(s1, s2) / strEQ(s1, s2)
/ strGT(s1,s2)
strncmp(s1, s2, n) strnNE(s1, s2, n) / strnEQ(s1, s2, n)

memcmp(p1, p2, n) memNE(p1, p2, n)
!memcmp(p1, p2, n) memEQ(p1, p2, n)

Notare il diverso ordine degli argomenti per "Copia" e "Sposta" rispetto a quelli utilizzati in "memcpy" e
"memmove".

Nella maggior parte dei casi, però, vorrai gestire gli SV internamente invece che in modo grezzo
stringhe "char *":

strlen(s) sv_len(sv)
strcpy(dt, src) sv_setpv(sv, s)
strncpy(dt, src, n) sv_setpvn(sv, s, n)
strcat(dt, src) sv_catpv(sv, s)
strncat(dt, src) sv_catpvn(sv, s)
sprintf(s, fmt, ...) sv_setpvf(sv, fmt, ...)

Si noti inoltre l'esistenza di "sv_catpvf" e "sv_vcatpvfn", che combinano la concatenazione con
formattazione.

A volte invece di azzerare l'heap allocato utilizzando Nuovoxz() dovresti considerare
"avvelenamento" dei dati. Ciò significa scrivere uno schema di bit al suo interno che dovrebbe essere illegale in quanto
puntatori (e numeri in virgola mobile), e anche, si spera, abbastanza sorprendenti come numeri interi,
in modo che qualsiasi codice che tenti di utilizzare i dati senza previdenza si interrompa prima piuttosto che
più tardi. L'avvelenamento può essere fatto usando il Veleno() macro, che hanno argomenti simili
a Zero():

PoisonWith(dst, n, t, b) scarabocchia la memoria con il byte b
PoisonNew(dst, n, t) uguale a PoisonWith(dst, n, t, 0xAB)
PoisonFree(dst, n, t) uguale a PoisonWith(dst, n, t, 0xEF)
Poison(dst, n, t) uguale a PoisonFree(dst, n, t)

Carattere Classe Test
Esistono diversi tipi di test di classi di caratteri implementati da Perl. Gli unici
qui descritti sono quelli che corrispondono direttamente alle funzioni della libreria C che operano su
Caratteri a 8 bit, ma esistono equivalenti che operano su caratteri larghi e UTF-8
stringhe codificate. Sono tutte descritte più dettagliatamente in "Classificazione dei caratteri" in perlapi
e "Cambio maiuscole/minuscole" in perlapi.

Le routine della libreria C elencate nella tabella sottostante restituiscono valori in base alla corrente
locale. Utilizzare le voci nella colonna finale per quella funzionalità. Le altre due
le colonne presuppongono sempre un locale POSIX (o C). Le voci nella colonna ASCII sono solo
significativo per gli input ASCII, restituendo FALSE per qualsiasi altro. Utilizzali solo quando
sapere questo è ciò che desideri. Le voci nella colonna Latin1 presuppongono che il codice non ASCII
I caratteri a 8 bit sono, come li definisce Unicode, gli stessi di ISO-8859-1, spesso chiamati latini
1.

Invece di: Usa per ASCII: Usa per Latin1: Usa per locale:

isalnum(c) isALPHANUMERIC(c) isALPHANUMERIC_L1(c) isALPHANUMERIC_LC(c)
isalpha(c) isALPHA(c) isALPHA_L1(c) isALPHA_LC(u )
isascii(c) isASCII(c) isASCII_LC(c)
è vuoto(c) è vuoto(c) è vuoto_L1(c) è vuoto_LC(c)
iscntrl(c) èCNTRL(c) èCNTRL_L1(c) èCNTRL_LC(c)
èdigit(c) èDIGIT(c) èDIGIT_L1(c) èDIGIT_LC(c)
isgraph(c) isGRAPH(c) isGRAPH_L1(c) isGRAPH_LC(c)
islower(c) isLOWER(c) isLOWER_L1(c) isLOWER_LC(c)
isprint(c) isPRINT(c) isPRINT_L1(c) isPRINT_LC(c)
ispunct(c) isPUNCT(c) isPUNCT_L1(c) isPUNCT_LC(c)
èspazio(c) èSPACE(c) èSPACE_L1(c) èSPACE_LC(c)
isupper(c) èUPPER(c) èUPPER_L1(c) èUPPER_LC(c)
isxdigit(c) isXDIGIT(c) isXDIGIT_L1(c) isXDIGIT_LC(c)

tolower(c) toLOWER(c) toLOWER_L1(c) toLOWER_LC(c)
toupper(c) toUPPER(c) toUPPER_LC(c)

Per sottolineare che stai operando solo su caratteri ASCII, puoi aggiungere "_A" a ciascuno
delle macro nella colonna ASCII: "isALPHA_A", "isDIGIT_A" e così via.

(Non c'è alcuna voce nella colonna Latin1 per "isascii" anche se c'è un
"isASCII_L1", che è identico a "isASCII"; quest'ultimo nome è più chiaro. Non c'è
voce nella colonna Latin1 per "toupper" perché il risultato può essere non-Latin1. Hai
per usare "toUPPER_uni", come descritto in "Cambio maiuscole/minuscole" in perlapi.)

stdlib.h funzioni
Invece di: Usa:

atof(s) Atof(s)
atoi(s) grok_atoUV(s, &uv, &e)
atol(s) grok_atoUV(s, &uv, &e)
strtod(s, &p) Niente. Semplicemente non usarlo.
strtol(s, &p, n) grok_atoUV(s, &uv, &e)
strtoul(s, &p, n) grok_atoUV(s, &uv, &e)

L'uso tipico è quello di effettuare controlli della distanza su "uv" prima del lancio:

int i; UV uv; char* end_ptr;
se (grok_atoUV(input, &uv, &end_ptr)
&& uv <= INT_MAX)
i = (int)uv;
... /* continua l'analisi da end_ptr */
} Else {
... /* errore di analisi: non è un numero intero decimale nell'intervallo 0 .. MAX_IV */
}

Notare anche le funzioni "grok_bin", "grok_hex" e "grok_oct" in numerico.c da
convertendo le stringhe che rappresentano i numeri nelle rispettive basi in "NV". Nota che
grok_atoUV() non gestisce input negativi o spazi iniziali (essendo intenzionalmente
rigoroso).

Si noti che strtolo() e strtul() may be disguised as Strol(), Stroul(), atollo(), Atolo().
Evitate anche quelli.

In teoria "Strtol" e "Strtoul" potrebbero non essere definiti se la macchina Perl è costruita su
in realtà non ha strtol e strtoul. Ma poiché queste due funzioni fanno parte del 2
Sospettiamo che ormai troverete le specifiche ANSI C ovunque.

int rand() double Drand01()
srand(n) { seedDrand01((Rand_seed_t)n);
PL_srand_called = VERO; }

uscita(n) mia_uscita(n)
sistema(i) Non farlo. Guarda pp_system o usa my_popen.

getenv(s) PerlEnv_getenv(s)
setenv(s, val) my_setenv(s, val)

Miscellanea funzioni
Non dovresti nemmeno volere usare setjmp.h funzioni, ma se pensi di farlo, usa il
Stack "JMPENV" in ambito.h anziché.

Per "signal"/"sigaction", utilizzare "rsignal(signo, handler)".

Utilizzare perlclib online utilizzando i servizi onworks.net