1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
#ifndef __EXCEPTIONS_H__
#define __EXCEPTIONS_H__
#ifdef __cplusplus
#include <stdio.h>
#include <unistd.h>
#include <stddef.h>
#include <string.h>
/*
* Gère les exceptions du système. Le programme principal devrait tenter
* de les récupérer afin de les afficher.
* GeneralExecption: exception de base. Construite sur une string.
* MemoryException: plus assez de mémoire. Construit une string sur la taille mémoire
* qui a fait défaut.
* IOException: erreur de lecture/écriture. Construite sur le nombre d'octets
* et sur l'opération qui a générée l'erreur.
* IOGeneral: erreur générale sur une opération IO (erreur à l'ouverture notemment)
* IOInternal: erreur interne du programme. En particulier, le programme
* a voulu lire ou écrire alors que le Handle n'était pas prévu pour.
*
* Nous définissons les fonctions xmalloc, xfree et xstrdup. Elles devraient être
* utilisées en lieu et place des fonctions malloc, free et strdup. La fonction realloc
* étant désapréciée, elle n'est pas surchargée.
*/
// Impossible de surcharger free(void *). Les compilateurs
// refuseront de passer un char * par exemple.
#ifdef OVER_FREE
#define free(p) xfree((void*)p)
#else
#include <stdlib.h>
#endif
class GeneralException;
char * xstrdup(const char *);
void * xmalloc(size_t) throw (GeneralException);
void xfree(void *&);
void * xrealloc(void *, size_t);
int xpipe(int *, int = 0) throw (GeneralException);
// On prédéfinit la classe String, pour éviter
// les deadlocks de compilation...
class String;
class Base {
public:
static char * strdup(const char * s) {
return xstrdup(s);
}
static void * malloc(ssize_t s) {
return xmalloc(s);
}
static void * realloc(void * p, size_t s) {
return xrealloc(p, s);
}
static void * calloc(size_t n, size_t s) {
return xmalloc(n * s);
}
void * operator new(size_t s) {
return xmalloc(s);
}
void * operator new(size_t s, void * p) {
return memset(p, 0, s);
}
void operator delete(void * p) {
xfree(p);
}
static void free(void *& p) {
xfree(p);
}
static void free(char *& p) {
xfree((void *) p);
}
static int pipe(int * p, int flag = 0) {
return xpipe(p);
}
};
class GeneralException : public Base {
public:
GeneralException(String);
GeneralException(const GeneralException &);
~GeneralException();
char * GetMsg();
protected:
GeneralException();
char * msg;
static char t[BUFSIZ];
};
class MemoryException : public GeneralException {
public:
MemoryException(ssize_t);
};
enum op_t {
IO_WRITE = 1,
IO_READ
};
class IOGeneral : public GeneralException {
public:
IOGeneral(String);
protected:
IOGeneral();
};
class IOException : public IOGeneral {
public:
IOException(String, op_t, ssize_t);
};
class IOAgain : public IOGeneral {
public:
IOAgain();
};
class TaskSwitch : public GeneralException {
public:
TaskSwitch();
};
#include <String.h>
#else
#error This only works with a C++ compiler
#endif
#endif
|
