perlapio - Interface d'abstraction des E/S internes a Perl
PerlIO *PerlIO_stdin(void);
PerlIO *PerlIO_stdout(void);
PerlIO *PerlIO_stderr(void);
PerlIO *PerlIO_open(const char *,const char *);
int PerlIO_close(PerlIO *);
int PerlIO_stdoutf(const char *,...)
int PerlIO_puts(PerlIO *,const char *);
int PerlIO_putc(PerlIO *,int);
int PerlIO_write(PerlIO *,const void *,size_t);
int PerlIO_printf(PerlIO *, const char *,...);
int PerlIO_vprintf(PerlIO *, const char *, va_list);
int PerlIO_flush(PerlIO *);
int PerlIO_eof(PerlIO *);
int PerlIO_error(PerlIO *);
void PerlIO_clearerr(PerlIO *);
int PerlIO_getc(PerlIO *);
int PerlIO_ungetc(PerlIO *,int);
int PerlIO_read(PerlIO *,void *,size_t);
int PerlIO_fileno(PerlIO *);
PerlIO *PerlIO_fdopen(int, const char *);
PerlIO *PerlIO_importFILE(FILE *, int flags);
FILE *PerlIO_exportFILE(PerlIO *, int flags);
FILE *PerlIO_findFILE(PerlIO *);
void PerlIO_releaseFILE(PerlIO *,FILE *);
void PerlIO_setlinebuf(PerlIO *);
long PerlIO_tell(PerlIO *);
int PerlIO_seek(PerlIO *,off_t,int);
int PerlIO_getpos(PerlIO *,Fpos_t *)
int PerlIO_setpos(PerlIO *,Fpos_t *)
void PerlIO_rewind(PerlIO *);
int PerlIO_has_base(PerlIO *);
int PerlIO_has_cntptr(PerlIO *);
int PerlIO_fast_gets(PerlIO *);
int PerlIO_canset_cnt(PerlIO *);
char *PerlIO_get_ptr(PerlIO *);
int PerlIO_get_cnt(PerlIO *);
void PerlIO_set_cnt(PerlIO *,int);
void PerlIO_set_ptrcnt(PerlIO *,char *,int);
char *PerlIO_get_base(PerlIO *);
int PerlIO_get_bufsiz(PerlIO *);
Les sources de Perl doivent utiliser les fonctions listées au dessus à la
place de celles définies dans le en-ête stdio.h de l'ANSI C. Les en-têtes de perl les remplace par la mécanisme
d'entré-sortie selectionnés lors de l'execution de Configure en utilisant
des #define.
Ces fonctions sont calquées sur celle de sdio.h, mais pour certaines l'ordre des paramètres a été réorganisé.
Remplace FILE *. Comme FILE * , il doit être traité comme un type opaque (c'est probablement prudent de le considérer comme un pointeur sur quelque chose).
A utiliser à la place de stdin, stdout, stderr. Elles ressemble à des ``appels de fonction'' plutôt qu'à des variables
pour que ce soit plus facile d'en faire des appels de fonction si la
platforme ne peut exporter des données vers des modules chargés, ou si (par
exemple) des ``thread'' différent peuvent avoir des valeurs différentes.
Correspondent à fopen()/fdopen() et utilise les mêmes
arguments.
Equivalenet à fprintf()/vfprintf() .
Equivaleent à printf(). printf est #defined à cette fonction,
donc il est (pour le moment) légal d'utiliser printf(fmt,...) dans les sources perl.
Correspondent à fread () et fwrite (). Attention les arguments sont différents, Il y a seulement un ``compteur'' et le fichier f est en premier.
Correspondent à fputs() et fputc(). Attention les
arguments ont été réorganisé pour que le fichier soit en premier.
Correspond à ungetc(). Attention les arguments ont été
réorganisé pour que le fichier soit en premier.
Correspond à getc().
Correspond à feof().
Correspond à ferror().
Correspond à fileno(), attention sur certaines platformes, la
définition de ``fileno'' peut ne pas correspondre à celle d'Unix.
Correspond à clearerr(), c.a.d., retire les drapeaux 'eof' et
'error' pour le ``flux''.
Correspond à fflush().
Correspond à ftell().
Correspond à fseek().
Correspond à fgetpos() et fsetpos(). Si la
plateforme ne dispose pas ces fonctions, elles sont implémentées à l'aide
de PerlIO_tell() et PerlIO_seek().
Correspond à rewind(). Note : elle peut être définie à l'aide
de PerlIO_seek().
Correspond à tmpfile(), c.a.d., retourne un PerlIO anonyme qui
sera automatiquement effacé lors de sa fermeture.
Il existe un support de la co-existence de PerlIO avec stdio. Evidemment si PerlIO est implémenté à l'aide de stdio, il n'y aucun problème. Mais si perlio est implémenté au-dessus de sfio (par exemple) il doit exister des mécanismes permettant de créer un FILE * qui peut être passé aux fonctions de librairies qui utilisent stdio.
Permet d'obtenir un PerlIO * à partir d'un FILE *. Peut nécessiter plus d'arguments, interface en cours de réécriture.
A partir d'un PerlIO * renvoie un FILE * pouvant être donné à du code devant être compilé et linké avec stdio.h de l'ANSI C.
Le fait qu'un FILE * à été 'exporté' est enregistré, et peut affecté de futures opérations sur le PerlIO * original. PerlIO *.
Retourne un FILE * prédément 'exporté' (s'il existe). Ceci est un bouche trou jusqu'à ce que l'interface soit complétement définie.
L'appel à PerlIO_releaseFILE informe PerlIO que le FILE * ne sera plus utilisé. Il est alors retiré de la liste des FILE * 'exporté', et le PerlIO * associé retrouve son comportement normal.
Correspond à setlinebuf(). Son utilisation est déprécié en
attendant une décision sur son sort. (Le noyau de Perl l'utilise uniquement lors du dump; celà n'a rien à voir avec le vidage automatique $| .)
En plus de l'API utilisateur décrite précédement il existe une interface d'``implémentation'' qui permet à Perl d'accèder aux structures internes de PerlIO. Les appels suivant correspondent aux diverses macros FILE_xxx déterminées par Configure. Cette section n'a d'intérêt que pour ceux qui sont concerné par un descriptif détaillé de comportement du noyau perl ou qui implementent un MAPPING PerlIO.
L'implémentation peut retourner un pointeur vers la position courante dans le ``buffer'' et le nombre d'octets disponibles dans le buffer.
Retourne un pointeur vers le prochain octet à lire du buffer.
Retourne le nombre d'octet restant à lire du buffer.
L'implémentation peut ajuster son idée sur le nombre d'octet dans le buffer.
L'implémentation a toutes les interfaces nécessaire pour permetre au code rapide de perl d'utiliser le mécanisme <FILE> .
PerlIO_fast_gets(f) = PerlIO_has_cntptr(f) && \
PerlIO_canset_cnt(f) && \
`Can set pointer into buffer'
Place le pointeur dans le buffer et remplace le nombre d'octets encore dans le buffer. Doit être utilisé seulement pour positionner le pointeur à l'intérieur de la plage impliquée par un appel précédent à PerlIO_get_ptr et PerlIO_get_cnt.
Obscure - force le nombre d'octets dans le buffer. Déprécié. Utilisé uniquement dans doio.c pour forcer un compteur <-1 à -1. Deviendra peut-être PerlIO_set_empty ou similaire. Cet appel peut eventuellement ne rien faire si ``compteur'' est déduit d'un pointeur et d'une ``limite''.
L'implémentation a un buffer, et peut retourner un pointeur vers celui-ci ainsi que sa taille. Utilisé par perl pour les tests -T / -B. Les autres usages seraient très obscure...
Retourne le début du buffer.
Retourne la taille totale du buffer.
Marc Carmier <carmier@immortels.frmug.org>