00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
#include <string.h>
00040
#include <stdlib.h>
00041
#include "idsig.h"
00042
#include "iderr.h"
00043
#include "idprint.h"
00044
00045 void _IdSigFree(PSIGNAL * pi)
00046 {
00047
if (*pi) {
00048
if (
_IdSigPrivate(*pi)->_message)
00049 free((
_IdSigPrivate(*pi)->_message));
00050
_IdSigPrivate(*pi)->_message = 0;
00051 if (
_IdSigPrivate(*pi)->_fichier)
00052 free((
_IdSigPrivate(*pi)->_fichier));
00053
_IdSigPrivate(*pi)->_fichier = 0;
00054 free(
_IdSigPrivate(*pi));
00055 *pi = 0;
00056 }
00057 }
00058
00059
00079
PSIGNAL
00080 IdSigAlloc(
int sx,
int ty)
00081 {
00082
PRIVATE_SIGNAL *si;
00083
PSIGNAL pi;
00084
00085
if (!(ty &
IDO_TYPE) ==
SIG) {
00086
IdErrPrintf
00087 (
"Allocation impossible. Objet de type incompatible.");
00088
IdErrno =
IDERR_WRONG_TYPE;
00089
return ((
PSIGNAL) 0);
00090 }
00091
00092 si =
00093 (
PRIVATE_SIGNAL *) calloc(1,
sizeof(
PRIVATE_SIGNAL) +
00094 sx *
IdTypeSize(ty));
00095
if (si) {
00096 si->
DimX = sx;
00097 si->
Type = ty;
00098 si->
_fichier = 0;
00099 si->
_message = 0;
00100 pi = (
PSIGNAL) & (si[1]);
00101 }
else {
00102
IdErrPrintf
00103 (
"Echec d'allocation de signal. Memoire saturee.");
00104
IdErrno =
IDERR_ALLOC_SIG;
00105
return ((
PSIGNAL) 0);
00106 }
00107
return (pi);
00108 }
00109
00121
PSIGNAL
00122 IdSigVecteurToSignal(
void *vecteur,
int ty,
int ox,
int lx)
00123 {
00124
PRIVATE_SIGNAL *si;
00125
PSIGNAL pi;
00126
00127
if (!(ty &
IDO_TYPE) ==
SIG) {
00128
IdErrPrintf
00129 (
"Allocation impossible. Objet de type (%x) incompatible.",
00130 ty);
00131
return ((
PSIGNAL) 0);
00132 }
00133
00134 si =
00135 (
PRIVATE_SIGNAL *) calloc(1,
sizeof(
PRIVATE_SIGNAL) +
00136 lx *
IdTypeSize(ty));
00137
if (si) {
00138 si->
DimX = lx;
00139 si->
Type = ty;
00140 pi = (
PSIGNAL) & (si[1]);
00141 memcpy(&si[1], ((
char *) vecteur) + ox *
IdTypeSize(ty),
00142 lx *
IdTypeSize(ty));
00143 }
else {
00144
IdErrPrintf
00145 (
"Echec d'allocation de signal. Memoire saturee.");
00146
return ((
PSIGNAL) 0);
00147 }
00148
return (pi);
00149 }
00150
00171
PSIGNAL
00172 IdSigModifLongueur(PSIGNAL sig,
int nouvLong)
00173 {
00174
PRIVATE_SIGNAL *si;
00175
PSIGNAL pi;
00176
00177
if (
IdLibidoType(sig) !=
SIG) {
00178
IdErrPrintf
00179 (
"Modif Longueur impossible. Objet non Signal.");
00180
return ((
PSIGNAL) 0);
00181 }
00182
00183 si = (
PRIVATE_SIGNAL *) realloc(
00184 (
void *) (
_IdSigPrivate(sig)),
00185
sizeof(
PRIVATE_SIGNAL) +
00186 nouvLong *
IdSizeOfType(sig)
00187 );
00188
00189
if (si) {
00190 si->
DimX = nouvLong;
00191 pi = (
PSIGNAL) & (si[1]);
00192 }
else {
00193
IdErrPrintf
00194 (
"Echec Modif Longueur signal. Memoire saturee.");
00195
return ((
PSIGNAL) 0);
00196 }
00197
00198
return (pi);
00199 }