Yggdrasil Seeds : Lavori di software : Language Select : Denullpo, the pointer checker : Denullpo

Denullpo


Come al minimo uso

Includa denullpo.h in ogni fonte di C/C++, ma ha bisogno di setting, altrimenti tutte le macro in denullpo.h divenuto nullo.
Ogni setting è scritto in "#define" di fronte ad incluso denullpo.h.
DENULLPO_TRAP
Se questo è definito, callback di scoperta di errore diviene effettivo.
DENULLPO_SKIP
Se questo è definito, Denullpo scopre errori.
Se né DENULLPO_TRAP né DENULLPO_SKIP è definito, Denullpo non scopre errori.
DENULLPO_4CC
È un valore da indicare che un esempio è valido.
Se questo non è definito, è definito automaticamente ad un valore continuo.
Alla macchia che dovrebbe controllare un cursore, lo dia in un cursore in denullpo().
Quando un cursore è NULL, Denullpo tratta un errore fisso.
Sample Code
/*=== evada accesso ad un cursore NULL con denullpo() ===*/
#include <stdio.h>
/*=== Denullpo ha bisogno di setting prima incluso denullpo.h ===*/
/*=== Lei può rimuovere maneggio di Denullpo quando Lei cambia questa linea in commento. ===*/
#define DENULLPO_SKIP
#include "denullpo.h"

int main(int argc,char *argv[]){
void* p=NULL;
int err=0;

p=malloc(128);
/*=== divide lavorazione da un risultato di controllo di un cursore ===*/
if(denullpo(p)){
/*=== trattando quando è anormale ===*/
fprintf(stderr,"this is nullpo\n");
err=1;
}
else{
/*=== trattando quando è normale ===*/
// :
// :
// :
free(p);
p=NULL;
}
return err;
}


Esamina la validità di esempio

Denullpo può esaminare la validità di esempio aggiungendo un membro per un codice magico ad una classe ed un corpo di struttura.
Classe e struttura di un obiettivo di controllo definiscono un punto di scrittura di un codice magico in DENULLPO_INITCHECKER.
Quando lo creò in esempio, indica quel esempio valido chiamando denullpo_setinit().
E quando lo distrugge in esempio, indica quel esempio nullo chiamando denullpo_setpurge().
Der di Bei Stelle, muoia einen sollte di überprüfen di Zeiger, geben l'es di Sie in einem Zeiger in denullpo2().
Quando un cursore è illegale, Denullpo tratta un errore fisso.
Sample Code
/*=== resista ad una chiamata di metodo di esempio illecito ===*/
#include <stdio.h>
#define DENULLPO_SKIP
#include "denullpo.h"

class FOO{
public:
/*=== definisca un variabile riempire in una corda magica in una classe ===*/
DENULLPO_INITCHECKER;

FOO(){
/*=== riempia in una corda magica che indica che inizializzò ===*/
denullpo_setinit(this);
}

~FOO(){
/*=== riempia in una corda magica che indica che terminò ===*/
denullpo_setpurge(this);
}

void exec(){
/*=== lo tratti come un errore se questo metodo è chiamato da eccetto tra denullpo_setinit() e denullpo_setpurge() ===*/
if(denullpo2())return;
// :
// :
// :
}
};


Callback di scoperta di errore

denullpo() e denullpo2() di solito ritornano immediatamente un risultato quando loro scoprirono un errore.
Quando Lei chiama denullpo_settrap() e callback di set, callback si chiama quando Denullpo scoprì un errore, ed il risultato è riflesso.
DENULLPO_TRAP deve essere definito prima incluso un denullpo.h per convalidare callback.
Sample Code
/*=== perfezioni gestione errori di un cursore illecito ===*/
#include <stdio.h>
/*=== mettendo convalidare callback ===*/
#define DENULLPO_TRAP
#include "denullpo.h"

int err=0;

/*=== trattando quando Denullpo scoprì un errore ===*/
static unsigned __cdecl hook(void *p,eDenullpoReason reason){
fprintf(stderr,"nullpo is hooked\n");
err=1;

/*=== il valore che ritorna appena diviene ritornando valore di denullpo() ===*/
return 1;
}

int main(int argc,char *argv[]){
void* p=NULL;

/*=== mettendo di callback ===*/
denullpo_settrap(hook);

p=malloc(128);
/*=== Se un cursore è NULL, Denullpo esegue callback fisso. ===*/
if(!denullpo(p)){
/*=== trattando quando è normale ===*/
// :
// :
// :
free(p);
p=NULL;
}
return err;
}


Dettagli

Definizioni

eDenullpoReason
Info di errore di cursore dal callback di hDenullpoTrap.
DENULLPO_NULL
Il cursore esaminato è NULL.
DENULLPO_INVALID
L'esempio esaminato è nullo.

Callback dattilografa

unsigned (*hDenullpoTrap)(void* p, eDenullpoReason reason)
Callback quando l'errore è scoperto.
Quando un errore fu scoperto, un set di funzione in denullpo_settrap() è chiamato.
Argomenti
p
cursore di un obiettivo di esame
reason
base di un errore
Valore che ritorna
0
Questo fattore di errore fu risolto.
1
Questo fattore di errore ancora è andato via.

Funzione

hDenullpoTrap denullpo_gettrap()
trovi un callback di scoperta di errore.
Valore che ritorna
il valore di setting
hDenullpoTrap denullpo_settrap(hDenullpoTrap trap)
metta un callback di scoperta di errore.
Argomenti
trap
una funzione per trattare come callback
Valore che ritorna
l'ultimo valore di setting
Note
Questa funzione non è infilata cassaforte.
unsigned denullpo_exectrap(void* p, eDenullpoReason reason)
chiami il callback di scoperta di errore.
Argomenti
p
cursore di un obiettivo di esame
reason
base di un errore
Valore che ritorna
0
Questo fattore di errore fu risolto.
1
Questo fattore di errore ancora è andato via.
unsigned denullpo_getinit(any* p)
trovi un valore di verificatore di esempio
Argomenti
p
esempio di obiettivo
Valore che ritorna
valore di verificatore di esempio
void denullpo_setinit(any* p)
notifichi verificatore di esempio che l'esempio è inizializzato
Argomenti
p
esempio di obiettivo
Note
Lei deve richiedere questa macro ogni esempio per divenire un obiettivo di denullpo2().
void denullpo_setpurge(any* p)
notifichi verificatore di esempio che l'esempio è terminato
Argomenti
p
esempio di obiettivo
Note
Lei deve richiedere questa macro ogni esempio per divenire un obiettivo di denullpo2().
unsigned denullpo_chkinit(any* p)
esamini se l'esempio è inizializzato
Argomenti
p
esempio di obiettivo
Valore che ritorna
0
non l'anormalità
1
anormalità
Note
Lei non chiama di solito direttamente questa macro. Lei chiama denullpo2() così che Denullpo esamina esempio.
int denullpo(any* p)
esamini se un cursore è NULL
Argomenti
p
designi come bersaglio cursore
Valore che ritorna
0
NULL non fu scoperto
1
NULL fu scoperto
Note
La funzione di callback stata chiamata in caso della scoperta di errore se è messo da una funzione di callback in denullpo_settrap().
int denullpo2(any* p)
esamini se un esempio è nullo
Argomenti
p
esempio di obiettivo
Valore che ritorna
0
non l'anormalità
1
anormalità
Note
La funzione di callback stata chiamata in caso della scoperta di errore se è messo da una funzione di callback in denullpo_settrap().
Lei deve chiamare denullpo_setinit() e denullpo_setpurge() ad una posizione adatta così che di questa funzione normalmente si è occupata.

Piano futuro


DSHs PHPlib v0.1.0 (C)2006-9 Denullpo Smasher Hammerson