perlclib - Online în cloud

PROGRAM:

NUME

perlclib - înlocuiri interne pentru funcțiile standard de bibliotecă C

DESCRIERE

Un lucru pe care ar trebui să-l remarce portarii Perl este că perl nu tinde să folosească atât de mult din C
bibliotecă standard intern; veți vedea foarte puțină folosire, de exemplu, a ctip.h
funcții acolo. Acest lucru se datorează faptului că Perl tinde să reimplementeze sau să abstragă biblioteca standard
funcții, astfel încât să știm exact cum vor funcționa.

Acesta este un card de referință pentru persoanele care sunt familiarizate cu biblioteca C și care doresc să o facă
lucrurile în modul Perl; pentru a le spune ce funcții ar trebui să folosească în loc de altele
funcții C normale.

Convenții
În următoarele tabele:

„t”
este un tip.

„p”
este un indicator.

„n”
este un număr.

„s”
este o sfoară.

„sv”, „av”, „hv”, etc reprezintă variabile de tipul lor.

Fișier Operațiuni
In loc de stdio.h funcții, ar trebui să utilizați stratul de abstractizare Perl. In loc de
Tipuri „FILE*”, trebuie să gestionați tipurile „PerlIO*”. Nu uita asta cu noul
Tipurile „FILE*” de abstractizare I/O stratificată PerlIO pot să nu fie nici măcar disponibile. Vezi și
documentația „perlapio” pentru mai multe informații despre următoarele funcții:

În loc de: Utilizați:

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

fopen(fn, mod) PerlIO_open(fn, mod)
freeopen(fn, mod, stream) PerlIO_reopen(fn, mode, perlio) (Dep-
retras)
fflush(flux) PerlIO_flush(perlio)
fclose(stream) PerlIO_close(perlio)

Fișier Intrare si producție
În loc de: Utilizați:

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

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

Rețineți că echivalentele PerlIO ale „fread” și „fwrite” sunt ușor diferite de
Omologul bibliotecii C:

fread(p, dimensiune, n, flux) PerlIO_read(perlio, buf, numbytes)
fwrite(p, dimensiune, n, flux) PerlIO_write(perlio, buf, numbytes)

fputs(s, stream) PerlIO_puts(perlio, s)

Nu există echivalent cu „fgets”; ar trebui să folosiți „sv_gets” în schimb:

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

Fișier Poziționarea
În loc de: Utilizați:

feof(stream) PerlIO_eof(perlio)
fseek(flux, n, de unde) PerlIO_seek(perlio, n, de unde)
rewind(stream) PerlIO_wind(perlio)

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

ferror(stream) PerlIO_error(perlio)
clearerr(stream) PerlIO_clearerr(perlio)

Memorie Management si Şir Manipularea
În loc de: Utilizați:

t* p = malloc(n) Newx(p, n, t)
t* p = calloc(n, s) Newxz(p, n, t)
p = realloc(p, n) Renew(p, n, t)
memcpy(dst, src, n) Copiere(src, dst, n, t)
memmove(dst, src, n) Mutare(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)
gratuit(p) Safefree(p)

strdup(p) savepv(p)
strndup(p, n) savepvn(p, n) (Hei, strndup nu
exista!)

strstr(mare, mic) instr(mare, mic)
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)

Observați ordinea diferită a argumentelor pentru „Copiere” și „Mutare” față de cea folosită în „memcpy” și
„memmove”.

De cele mai multe ori, totuși, veți dori să aveți de-a face cu SV-uri intern în loc de brut
șiruri de caractere „char *”:

strlen(e) 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, ...)

Rețineți, de asemenea, existența „sv_catpvf” și „sv_vcatpvfn”, combinând concatenarea cu
formatare.

Uneori, în loc să reduceți la zero heap-ul alocat utilizând Newxz() ar trebui să luați în considerare
„otrăvirea” datelor. Aceasta înseamnă să scrieți un model de pic în el care ar trebui să fie ilegal ca
indicatori (și numere în virgulă mobilă) și, de asemenea, sperăm că sunt destul de surprinzătoare ca numere întregi,
astfel încât orice cod care încearcă să folosească datele fără să se pregătească se va rupe mai devreme
decât mai târziu. Otrăvirea se poate face folosind Otravă() macro-uri, care au argumente similare
la Zero():

PoisonWith(dst, n, t, b) memorie de mâzgălire cu octetul b
PoisonNew(dst, n, t) egal cu PoisonWith(dst, n, t, 0xAB)
PoisonFree(dst, n, t) egal cu PoisonWith(dst, n, t, 0xEF)
Poison(dst, n, t) egal cu PoisonFree(dst, n, t)

Caracter Clasă Teste
Există mai multe tipuri de teste de clasă de caractere pe care Perl le implementează. Singurii
descrise aici sunt cele care corespund direct cu funcțiile bibliotecii C care operează
Caractere pe 8 biți, dar există echivalente care operează pe caractere largi și UTF-8
șiruri de caractere codificate. Toate sunt descrise mai pe deplin în „Clasificarea caracterelor” în perlapi
și „Schimbarea caracterelor majuscule” în perlapi.

Rutinele bibliotecii C enumerate în tabelul de mai jos returnează valori bazate pe curent
local. Utilizați intrările din ultima coloană pentru acea funcționalitate. Celelalte doua
coloanele presupun întotdeauna o locație POSIX (sau C). Intrările din coloana ASCII sunt numai
semnificativ pentru intrările ASCII, returnând FALSE pentru orice altceva. Folosiți-le numai când dvs
ști asta vrei tu. Intrările din coloana Latin1 presupun că non-ASCII
Caracterele pe 8 biți sunt așa cum le definește Unicode, la fel ca ISO-8859-1, adesea numite latină
1.

În loc de: Utilizați pentru ASCII: Folosiți pentru Latin1: Folosiți pentru local:

isalnum(c) esteALPHANUMERIC(c) esteALPHANUMERIC_L1(c) esteALPHANUMERIC_LC(c)
isalpha(c) isALPHA(c) isALPHA_L1(c) isALPHA_LC(u )
isascii(c) isASCII(c) isASCII_LC(c)
isblank(c) isBLANK(c) isBLANK_L1(c) isBLANK_LC(c)
iscntrl(c) isCNTRL(c) isCNTRL_L1(c) isCNTRL_LC(c)
isdigit(c) esteDIGIT(c) esteDIGIT_L1(c) esteDIGIT_LC(c)
isgraph(c) esteGRAPH(c) esteGRAPH_L1(c) esteGRAPH_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)
isspace(c) isSPACE(c) isSPACE_L1(c) isSPACE_LC(c)
isupper(c) isUPPER(c) isUPPER_L1(c) isUPPER_LC(c)
isxdigit(c) isXDIGIT(c) isXDIGIT_L1(c) isXDIGIT_LC(c)

mai jos(c) la LOWER(c) la LOWER_L1(c) la LOWER_LC(c)
toupper(c) toUPPER(c) toUPPER_LC(c)

Pentru a sublinia faptul că operați numai pe caractere ASCII, puteți adăuga „_A” la fiecare
dintre macrocomenzile din coloana ASCII: „isALPHA_A”, „isDIGIT_A” și așa mai departe.

(Nu există nicio intrare în coloana Latin1 pentru „isascii”, chiar dacă există un
„isASCII_L1”, care este identic cu „isASCII”; numele din urmă este mai clar. Nu este
intrare în coloana Latin1 pentru „toupper” deoarece rezultatul poate fi non-Latin1. Aveți
pentru a utiliza „toUPPER_uni”, așa cum este descris în „Schimbarea majusculelor de caractere” în perlapi.)

stdlib.h funcții
În loc de: Utilizați:

atof(e) Atof(e)
atoi(s) grok_atoUV(s, &uv, &e)
atol(i) grok_atoUV(s, &uv, &e)
strtod(s, &p) Nimic. Doar nu-l folosi.
strtol(s, &p, n) grok_atoUV(s, &uv, &e)
strtoul(s, &p, n) grok_atoUV(s, &uv, &e)

Utilizarea obișnuită este de a efectua verificări ale intervalului pe „uv” înainte de a arunca:

int i; UV UV; char* end_ptr;
if (grok_atoUV(input, &uv, &end_ptr)
&& uv <= INT_MAX)
i = (int)uv;
... /* continuă analiza de la end_ptr */
} Else {
... /* eroare de analiză: nu este un întreg zecimal în intervalul 0 .. MAX_IV */
}

Observați, de asemenea, funcțiile „grok_bin”, „grok_hex” și „grok_oct” din numeric.c pentru
conversia şirurilor reprezentând numere din bazele respective în „NV”. Rețineți că
grok_atoUV() nu se ocupă de intrări negative sau spații albe de început (fiind intenționat
strict).

Rețineți că strtol() si strtoul() poate fi deghizat ca Strtol(), Strtoul(), Atol(), Atoul().
Evită-le și pe acestea.

În teorie, „Strtol” și „Strtoul” ar putea să nu fie definite dacă mașina perl este construită
nu are de fapt strtol și strtoul. Dar deoarece acele două funcții fac parte din 2
Specificațiile ANSI C bănuim că le veți găsi peste tot până acum.

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

ieșire(n) my_exit(n)
sistem(e) Nu. Uită-te la pp_system sau folosește my_popen.

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

Diverse funcții
Nici măcar nu ar trebui vrea să utilizeze setjmp.h funcții, dar dacă credeți că o faceți, utilizați
„JMPENV” se adaugă domeniul de aplicare.h in schimb.

Pentru "signal"/"sigaction", utilizați "rsignal(signo, handler)".

Utilizați perlclib online folosind serviciile onworks.net