perlclib - En ligne dans le Cloud

PROGRAMME:

Nom

perlclib - Remplacements internes pour les fonctions de bibliothèque C standard

DESCRIPTION

Une chose que les porteurs de Perl devraient noter est que perl n'a pas tendance à utiliser autant de C
bibliothèque standard en interne ; vous verrez très peu d'utilisation, par exemple, du ctype.h
fonctions là-dedans. C'est parce que Perl a tendance à réimplémenter ou à abstraire la bibliothèque standard
fonctions, afin que nous sachions exactement comment ils vont fonctionner.

Ceci est une carte de référence pour les personnes qui connaissent la bibliothèque C et qui veulent faire
les choses à la manière de Perl ; pour leur dire quelles fonctions ils doivent utiliser au lieu des plus
fonctions C normales.

Conventions
Dans les tableaux suivants :

"t"
est un genre.

"p"
est un pointeur.

"n"
est un nombre.

"s"
est une chaîne.

"sv", "av", "hv", etc. représentent des variables de leurs types respectifs.

Fichier Opérations
À la place du stdio.h fonctions, vous devez utiliser la couche d'abstraction Perl. À la place de
types "FILE*", vous devez gérer les types "PerlIO*". N'oubliez pas qu'avec le nouveau
Les types "FILE*" d'abstraction d'E/S en couches PerlIO peuvent même ne pas être disponibles. Voir aussi le
documentation "perlapio" pour plus d'informations sur les fonctions suivantes :

Au lieu de : Utiliser :

stdin PerlIO_stdin()
sortie standard PerlIO_stdout()
stderr PerlIO_stderr()

fopen(fn, mode) PerlIO_open(fn, mode)
freopen(fn, mode, stream) PerlIO_reopen(fn, mode, perlio) (Dep-
rapporté)
fflush(flux) PerlIO_flush(perlio)
fclose(flux) PerlIO_close(perlio)

Fichier Entrée et Sortie
Au lieu de : Utiliser :

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

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

Notez que les équivalents PerlIO de "fread" et "fwrite" sont légèrement différents de leur
homologues de la bibliothèque C :

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

fputs(s, flux) PerlIO_puts(perlio, s)

Il n'y a pas d'équivalent à "fgets" ; on devrait utiliser "sv_gets" à la place :

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

Fichier placement
Au lieu de : Utiliser :

feof(flux) PerlIO_eof(perlio)
fseek(stream, n, d'où) PerlIO_seek(perlio, n, d'où)
rembobiner (flux) PerlIO_rewind (perlio)

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

ferror(flux) PerlIO_error(perlio)
clearerr(flux) PerlIO_clearerr(perlio)

Mémoire Management et Chaîne Maniabilité
Au lieu de : Utiliser :

t* p = malloc(n) Nouveaux(p, n, t)
t* p = calloc(n, s) Nouveauxz(p, n, t)
p = realloc(p, n) Renouveler(p, n, t)
memcpy(dst, src, n) Copie(src, dst, n, t)
memmove(dst, src, n) Déplacer(src, dst, n, t)
memcpy(dst, src, sizeof(t)) StructCopy(src, dst, t)
memset(dst, 0, n * sizeof(t)) Zéro(dst, n, t)
memzero(dst, 0) Zéro(dst, n, car)
gratuit(p) Safefree(p)

strdup(p) savepv(p)
strndup(p, n) savepvn(p, n) (Hé, strndup ne
exister!)

strstr(grand, petit) instr(grand, petit)
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)

Notez l'ordre différent des arguments pour "Copier" et "Déplacer" par rapport à "memcpy" et
"memmove".

La plupart du temps, cependant, vous voudrez traiter avec des SV en interne plutôt que bruts
Chaînes "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, ...)

Notez également l'existence de "sv_catpvf" et "sv_vcatpvfn", combinant la concaténation avec
formatage.

Parfois, au lieu de remettre à zéro le tas alloué en utilisant Nouveauxz() tu devrais considérer
« empoisonner » les données. Cela signifie y écrire un motif binaire qui devrait être illégal car
pointeurs (et nombres à virgule flottante), et aussi, espérons-le, assez surprenants en tant qu'entiers,
de sorte que tout code tentant d'utiliser les données sans prévoyance se brisera plus tôt plutôt
que plus tard. L'empoisonnement peut être fait en utilisant le Poison() macros, qui ont des arguments similaires
à Zéro():

PoisonWith(dst, n, t, b) griffonner la mémoire avec l'octet b
PoisonNew(dst, n, t) égal à PoisonWith(dst, n, t, 0xAB)
PoisonFree(dst, n, t) égal à PoisonWith(dst, n, t, 0xEF)
Poison(dst, n, t) égal à PoisonFree(dst, n, t)

Personnage Classe Tests
Il existe plusieurs types de tests de classes de caractères que Perl implémente. Les seuls
décrites ici sont celles qui correspondent directement aux fonctions de la bibliothèque C qui opèrent sur
Caractères 8 bits, mais il existe des équivalents qui fonctionnent sur les caractères larges, et UTF-8
chaînes encodées. Tous sont décrits plus en détail dans "Classification des caractères" dans perlapi
et "Changement de casse de caractère" dans perlapi.

Les routines de la bibliothèque C répertoriées dans le tableau ci-dessous renvoient des valeurs basées sur le
lieu. Utilisez les entrées de la dernière colonne pour cette fonctionnalité. Les deux autres
les colonnes supposent toujours une locale POSIX (ou C). Les entrées de la colonne ASCII sont uniquement
significatif pour les entrées ASCII, renvoyant FALSE pour tout le reste. Utilisez-les uniquement lorsque vous
savoir c'est ce que tu veux. Les entrées de la colonne Latin1 supposent que le non-ASCII
Les caractères 8 bits sont, tels que définis par Unicode, les mêmes que ISO-8859-1, souvent appelés latins
1.

Au lieu de : à utiliser pour ASCII : à utiliser pour Latin1 : à utiliser pour les paramètres régionaux :

estalnum(c) estALPHANUMERIC(c) estALPHANUMERIC_L1(c) estALPHANUMERIC_LC(c)
isalpha(c) isALPHA(c) isALPHA_L1(c) isALPHA_LC(u )
isascii(c) estASCII(c) estASCII_LC(c)
estBLANK(c) estBLANK(c) estBLANK_L1(c) estBLANK_LC(c)
iscntrl(c) estCNTRL(c) estCNTRL_L1(c) estCNTRL_LC(c)
ischiffre(c) isDIGIT(c) isDIGIT_L1(c) isDIGIT_LC(c)
isgraph(c) isGRAPH(c) isGRAPH_L1(c) isGRAPH_LC(c)
estinférieur(c) estinférieur(c) estinférieur_L1(c) estinférieur_LC(c)
isprint(c) isPRINT(c) isPRINT_L1(c) isPRINT_LC(c)
ispunct(c) isPUNCT(c) isPUNCT_L1(c) isPUNCT_LC(c)
estespace(c) estESPACE(c) estESPACE_L1(c) estESPACE_LC(c)
isupper(c) isUPPER(c) isUPPER_L1(c) isUPPER_LC(c)
isxchiffre(c) isXDIGIT(c) isXDIGIT_L1(c) isXDIGIT_LC(c)

vers INFÉRIEUR(c) vers INFÉRIEUR(c) vers INFÉRIEUR_L1(c) vers INFÉRIEUR_LC(c)
toupper(c) àUPPER(c) àUPPER_LC(c)

Pour souligner que vous n'utilisez que des caractères ASCII, vous pouvez ajouter "_A" à chaque
des macros dans la colonne ASCII : "isALPHA_A", "isDIGIT_A", et ainsi de suite.

(Il n'y a pas d'entrée dans la colonne Latin1 pour "isascii" même s'il y a un
"isASCII_L1", qui est identique à "isASCII" ; ce dernier nom est plus clair. Il n'y a pas
entrée dans la colonne Latin1 pour « toupper » car le résultat peut être non-Latin1. Tu as
pour utiliser "toUPPER_uni", comme décrit dans "Changement de casse de caractère" dans perlapi.)

stdlib.h fonctions
Au lieu de : Utiliser :

Atof(s) Atof(s)
atoi(s) grok_atoUV(s, &uv, &e)
atol(s) grok_atoUV(s, &uv, &e)
strtod(s, &p) Rien. Ne l'utilisez pas.
strtol(s, &p, n) grok_atoUV(s, &uv, &e)
strtoul(s, &p, n) grok_atoUV(s, &uv, &e)

L'utilisation typique consiste à effectuer des vérifications de portée sur "uv" avant de lancer :

int je; UV UV; char* end_ptr;
if (grok_atoUV(entrée, &uv, &end_ptr)
&& uv <= INT_MAX)
i = (int)uv ;
... /* continue l'analyse depuis end_ptr */
} Else {
... /* erreur d'analyse : pas un entier décimal dans la plage 0 .. MAX_IV */
}

Notez également les fonctions "grok_bin", "grok_hex" et "grok_oct" dans numérique.c pour
convertir des chaînes représentant des nombres dans les bases respectives en "NV". Noter que
grok_atoUV() ne gère pas les entrées négatives ou les espaces de début (étant délibérément
stricte).

Notez que strtol() et stroul() peut être déguisé en Strtol(), Strtoul(), Atole(), Atoul().
Évitez ceux-là aussi.

En théorie "Strtol" et "Strtoul" peuvent ne pas être définis si la machine est construite sur perl
n'a pas réellement strtol et strtoul. Mais comme ces 2 fonctions font partie du 1989
Spécifications ANSI C, nous pensons que vous les trouverez partout maintenant.

int rand() double Drand01()
srand(n) { seedDrand01((Rand_seed_t)n);
PL_srand_callé = VRAI ; }

exit(n) ma_sortie(n)
système(s) Ne le faites pas. Regardez pp_system ou utilisez my_popen.

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

Divers fonctions
Tu ne devrais même pas souhaitez à utiliser setjmp.h fonctions, mais si vous pensez que c'est le cas, utilisez le
Pile "JMPENV" dans portée.h à la place.

Pour "signal"/"sigaction", utilisez "rsignal(signo, handler)".

Utiliser perlclib en ligne en utilisant les services onworks.net