moule2005 a écrit 12 commentaires

et avec fonctions inline.. ca donnerait quoi??

je ne vois vraiment en quoi ca pose probleme: le fichier en question cxx a cette tete (que le debut car la suite est du meme type)


#include "CTTSMrcpClient.hxx"



CTTSMrcpClient::CTTSMrcpClient(PCVoiceAppInfo info) : CTTSAbstract( PAppInfo)
{

rtpPortNumber = getPortNumber();

response = 0;

savedMsg = 0;

contentId = 100;

isSpeaking = false;

myShutdown = false;

/** Cr?tion du parseur de message MRCP */
parser = new MrcpMsgParser() ;

/** Cr?tion de la pile rtsp */
cttsRtsp = new CTTSRtsp(rtpPort);

}


CTTSMrcpClient::~CTTSMrcpClient()
{

}

/**
* La fonction init se contente de renvoyer les param?res de connection
* ?la pile rtsp
*/
int
CTTSMrcpClient::Init(const char* szInitString = NULL);
{

/** szInitString est de la forme :
* - serveurMrcpMachine (localhost)
* - port (8554)
* - serveurMrcpNom (mediaServer)
* - cheminRessource (/media/synthetizer/)
* la syntaxe est serveurMrcpMachine:port:serveurMrcpNom:cheminRessource
*/
int res = cttsRtsp->Init( szInitString );

/** res == 0 signifie que le client s'est connect?et qu'il a ouvert une session rtsp */
if ( res != 0 ) return res;

}


int
CTTSMrcpClient::Shutdown(void);
{


}


/**
* GET-PARAMS id MRCP/1.0
* Voice-rate:
*/
int
CTTSMrcpClient::GetSpeed(int &Speed);
{

char buffer[BUFFER_PARAM] ;
buffer[0] = '\0';

sprintf(buffer,"GET-PARAMS %d MRCP/1.0\r\nVoice-rate:\r\n\r\n",contentId++);

/* Envoi de la requ?e au serveur MRCP */
int res = cttsRtsp->WriteData( buffer,strlen( buffer ) );
if ( res != 0 ) return res;

//R?eption du message
int len = 0;
res = cttsRtsp->ReadData(buffer,len);
if ( res != 0 ) return res;










et au final ca me donne comme erreur:
CTTSMrcpClient.cxx:7:30: CTTSMrcpClient.hxx: Aucun fichier ou répertoire de ce type
CTTSMrcpClient.cxx:11: erreur de syntaxes avantle jeton « :: »
CTTSMrcpClient.cxx:16: ISO C++ interdit la déclaration de « response » sans
type
CTTSMrcpClient.cxx:18: ISO C++ interdit la déclaration de « savedMsg » sans
type
CTTSMrcpClient.cxx:20: ISO C++ interdit la déclaration de « contentId » sans
type
CTTSMrcpClient.cxx:22: ISO C++ interdit la déclaration de « isSpeaking »
sans type
CTTSMrcpClient.cxx:24: ISO C++ interdit la déclaration de « myShutdown »
sans type
CTTSMrcpClient.cxx:27: ISO C++ interdit la déclaration de « parser » sans
type
CTTSMrcpClient.cxx:27: erreur d'analyse syntaxique avantle jeton « ( »
CTTSMrcpClient.cxx:30: ISO C++ interdit la déclaration de « cttsRtsp » sans
type
CTTSMrcpClient.cxx:30: erreur d'analyse syntaxique avantle jeton « ( »
CTTSMrcpClient.cxx:35: erreur de syntaxes avantle jeton « :: »
CTTSMrcpClient.cxx:45: erreur de syntaxes avantle jeton « :: »
CTTSMrcpClient.cxx:64: erreur de syntaxes avantle jeton « :: »
CTTSMrcpClient.cxx:76: erreur de syntaxes avantle jeton « :: »
CTTSMrcpClient.cxx:80: ISO C++ interdit la déclaration de « buffer » sans
type
CTTSMrcpClient.cxx:80: initialiseur invalide
CTTSMrcpClient.cxx:82: ISO C++ interdit la déclaration de « sprintf » sans
type
CTTSMrcpClient.cxx:82: liste d'initaliseurs a été traité comme une
expression composée
CTTSMrcpClient.cxx:85: l'opérande de base de «->» n'est pas un pointeur
CTTSMrcpClient.cxx:85: « strlen » n'a pas été déclaré dans cet horizon
CTTSMrcpClient.cxx:86: erreur d'analyse syntaxique avant « if »
CTTSMrcpClient.cxx:90: ISO C++ interdit la déclaration de « res » sans type
CTTSMrcpClient.cxx:90: redefinition of `int res'
CTTSMrcpClient.cxx:85: «int res» précédemment défini ici
CTTSMrcpClient.cxx:90: l'opérande de base de «->» n'est pas un pointeur
CTTSMrcpClient.cxx:91: erreur d'analyse syntaxique avant « if »
CTTSMrcpClient.cxx:99: « MrcpMsg » n'a pas été déclaré dans cet horizon
CTTSMrcpClient.cxx:99: « Sptr » est utilisé comme type, mais n'est pas
défini comme type.



==>je suis a peu prés d'accord sur le fait qu'il ne trouve pas le .hxx mais le reste....!
merci

pointer vers le code incriminé..? (je me remets au dev.. eheh!)

merci, effectivement, ca fonstionne mieux, allez une autre:


ca ressemble a une precedente mais au final je n'arrive pas a resoudre le probleme avec la methode!!!!


"
g++ --thread -o bin.debug.Linux.i686/MrcpClient obj.debug.Linux.i686/MrcpClient.o obj.debug.Linux.i686/CTTSAbstract.o obj.debug.Linux.i686/CircularBuffer.o obj.debug.Linux.i686/TtsSimpleClientMrcp.o -L../vocal-1.4.0/build/../../TtsSimpleClientMrcp/wave/bin/ -L../vocal-1.4.0/build/../rtsp/rtspstack/obj.debug.Linux.i686 -L../vocal-1.4.0/build/../rtp/obj.debug.Linux.i686 -L../vocal-1.4.0/build/../sdp/obj.debug.Linux.i686 -L../vocal-1.4.0/build/../util/obj.debug.Linux.i686 -L../vocal-1.4.0/build/../../StackMrcp/obj.debug.Linux.i686 -lwave -lrtsp -lrtp -lsdp -lpthread -lutil -lmrcpstack -Wl,-Bstatic -lstdc++ -Wl,-Bdynamic
/usr/bin/ld: ne peut trouver -lwave
collect2: ld a retourné 1 code d'état d'exécution
make: *** [bin.debug.Linux.i686/MrcpClient] Erreur 1

"


voila voila

et voila encore une:
je recupere ca en compilant un cxx:
"
src/TtsSimpleClientMrcp.cxx:643: argument par défaut donné pour le paramètre
3 de «int TtsSimpleClientMrcp::Speak2Wave(const char*, char*, TTSTextType =
TT_Text)»
include/TtsSimpleClientMrcp.hxx:117: après la déclaration précédente dans
«int TtsSimpleClientMrcp::Speak2Wave(const char*, char*, TTSTextType =
TT_Text)»
make: *** [obj.debug.Linux.i686/TtsSimpleClientMrcp.o] Erreur 1
"

nota, a l'origine je l'avais ecrit et dev sous win (cygwin) est ce que cela pourrait poser probleme, je ne vois pas de probleme de portage
Merci

Merci.... ca fonctionne, jusqu'a la prochaine erreur...!!!

Personne n'a d'idées.....?

Toujours pas resolu malgré pas mal d'essais. en makant le module lié a cette lib (make file:
vpath %.cpp ./src
vpath %.h ./include

CC=gcc-2
CXX=G++-2
CFLAGS+= -mno-cygwin -l ./include -l ../Syc-3.0A/include -Wall
CXXFLAGS+= -mno-cygwin -l ./include -l ../Syc-3.0A/include -Wall

ALL: libttscvox.dll

CTTSCvox.o : CTTSCvox.cpp CTTSAbstract.h CTTSCvox.h

libttscvox.dll : CTTSCvox.o
$(CXX) -shared $(CXXFLAGS) $< -o $@ -l../Syc-3.0A/lib/ -lcvox

------------------------------------------------------------------
voila ce que j'obtiens:

G++-2 -mno-cygwin -l ./include -l ../Syc-3.0A/include -Wall -c -o CTTSCvox.o ./src/CTTSCvox.cpp
make: G++-2 : Commande introuvable
make: *** [CTTSCvox.o] Erreur 127


------------------------------------------------------------
pour un cpp:
/*
* $Id$
*
* $Log$
*
*/

#include "CTTSCvox.h"
#include <iostream.h>
#include <stdlib.h>


extern "C" PCTTSAbstract NewCTTSAbstract(PCVoiceAppInfo info)
{
return new TTSCVOX(info) ;
}


extern "C" void DeleteCTTSAbstract(PCTTSAbstract ptr)
{
delete ptr;
}

extern "C" int ConfigureCTTSAbstract(PCVoiceAppInfo)
{

return 1;
}

extern "C" int InitCTTSAbstract(PCVoiceAppInfo)
{

return 1;
}

extern "C" int ShutdownCTTSAbstract(PCVoiceAppInfo)
{

return 1;
}


static void
callback_buffer(CVOX_ENGINE engine, cvox_int32 position, void *arg,
cvox_bool begin, cvox_int32 bufferNumber) {
TTSCVOX* ptr = (TTSCVOX* ) arg;
ptr->callback_buffer(engine,position, begin, bufferNumber) ;

}


static cvox_uint16
callback_out (CVOX_ENGINE engine,void *arg, void* address,
cvox_int32 length, void **nextbuffer, cvox_int32 *nextsize) {

TTSCVOX* ptr = (TTSCVOX* ) arg;
return ptr->callback_out(engine, address, length, nextbuffer, nextsize) ;

}


static void run_cvox_engine(void* eng)
{
CVOX_ENGINE *engine = (CVOX_ENGINE*) eng ;
cvox_Execute(*engine);
}


TTSCVOX::TTSCVOX(PCVoiceAppInfo PAppInfo) : CTTSAbstract( PAppInfo)
{
isSpeaking = false;
isRunning = false;
tabStruct = NULL;
}


TTSCVOX::~TTSCVOX()
{
if (isRunning)
{
cvox_Stop(engine);
ret = cvox_DeleteEngine(engine);
TestReturnCode("cvox_Delete()", ret);
//for (int i = 0 ; i < nbVoice ; i++) {
//tabStruct[i];
//}
delete tabStruct;
}
}


int
TTSCVOX::SetTTSClalback(TTSCallback func, void* ptUser)
{
m_func = func;
m_ptUser = ptUser;
return 1;
}

int
TTSCVOX::UnsetTTSCallback()
{
m_func = NULL;
m_ptUser = NULL;
return 1;
}


int
TTSCVOX::Init(const char* szInitString ) {

//There are nothing here to szInitString
memset(&data_in, 0, sizeof(CVOX_IO_DATA));
memset(&data_out, 0, sizeof(CVOX_IO_DATA));

data_out.writeRawCB = ::callback_out;
data_out.arg = this;
data_out.synchro.bufferCB = ::callback_buffer;
data_out.synchro.arg = this;
data_out.coding = CVOX_PCM_SWAP;

data_in.parsing = CVOX_SSML_20;

ret = cvox_NewEngine((char*)szInitString, "", &engine);
TestReturnCode("cvox_NewEngine()", ret);

ret = cvox_Connect(engine,CVOX_INPUT, CVOX_FUNCTIONAL_IO, &data_in) ;
TestReturnCode("cvox_Connect(IN)", ret);

ret = cvox_Connect(engine,CVOX_OUTPUT, CVOX_RAW_IO,&data_out) ;
TestReturnCode("cvox_Connect(OUT)", ret);


xthr_run(&inputTHR,::run_cvox_engine, &engine);

/** add its number to fifo */

cvox_WaitRunning(engine);

isRunning = true;

CVOX_ENGINE_INFO info;

ret = cvox_GetEngineInfo(engine,&info);
nbVoice = info.numberOfVoice;
tabStruct = new CVOX_VOICE_INFO[nbVoice] ;

CVOX_VOICE_INFO voiceInfo;

for (int rank = 0 ; rank < nbVoice ;rank++) {
cvox_GetVoiceInfo(engine,rank,&voiceInfo) ;
tabStruct[rank] = voiceInfo;
}

return 1;
}

int
TTSCVOX::Shutdown()
{
return 1;
}


cvox_uint16
TTSCVOX::callback_out (CVOX_ENGINE engine, void* address,
cvox_int32 length, void **nextbuffer, cvox_int32 *nextsize) {

m_func (m_ptUser, (char*) address, (size_t)length);

return (CVOX_CB_OK);
}

void
TTSCVOX::callback_buffer(CVOX_ENGINE engine, cvox_int32 position, cvox_bool begin, cvox_int32 bufferNumber) {

static unsigned char max = 170, min = 42;

if (begin) {
m_func (m_ptUser, (char*) &max, 1);

}
else
{
m_func (m_ptUser, (char*) &min, 1);
m_func (m_ptUser, (char*) &min, 0);
isSpeaking = false;
}
}

void
TTSCVOX::TestReturnCode(char *function, cvox_uint16 ret)
{
char *code = 0;
switch (ret) {
case CVOX_OK:
break;
case CVOX_BAD_ENGINE:
code = "bad engine";
break;
case CVOX_FORBIDDEN_CALL:
code = "forbidden call";
break;
case CVOX_BAD_PARAMETER:
code = "bad parameter";
break;
case CVOX_INTERNAL_ERROR:
code = "internal error";
break;
case CVOX_PARSING_ERROR:
code = "parsing error";
break;
}
if (code) {
fprintf(stderr, "Error. %s returned \"%s\"\n", function, code);
exit(1);
}
}


int
TTSCVOX::GetSpeed(int &Speed) {

CVOX_ENGINE_INFO* voiceInfo;
cvox_GetEngineInfo(engine,voiceInfo);
Speed = (int) (voiceInfo->rate_info).rate;
return 1;
}

int
TTSCVOX::GetSpeed(TTSSpeed &Speed) {

CVOX_ENGINE_INFO* voiceInfo;
cvox_GetEngineInfo(engine,voiceInfo);
int speed = (int) (voiceInfo->rate_info).rate;
if (speed <= 100) {
Speed = SPEED_LOW;
return 1;
}
if (speed <= 180) {
Speed = SPEED_MEDIUM;
return 1;
}
if (speed > 180) {
Speed = SPEED_HIGHT;
return 1;
}
return 0;
}

int
TTSCVOX::GetPitch(int &Pitch) {

CVOX_ENGINE_INFO* voiceInfo;
cvox_GetEngineInfo(engine,voiceInfo);
Pitch = (int) (voiceInfo->pitch_info).range;
return 1;
}

int
TTSCVOX::GetPitch(TTSPitch &Pitch) {

CVOX_ENGINE_INFO* voiceInfo;
cvox_GetEngineInfo(engine,voiceInfo);
int pitch = (int) (voiceInfo->pitch_info).range;

if (pitch <= 80) {
Pitch = PITCH_LOW;
return 1;
}
if (pitch <= 160) {
Pitch = PITCH_MEDIUM;
return 1;
}
if (pitch > 160) {
Pitch = PITCH_HIGHT;
return 1;
}
return 0;
}

int
TTSCVOX::GetVolume(int &Volume) {

CVOX_ENGINE_INFO* voiceInfo;
cvox_GetEngineInfo(engine,voiceInfo);
Volume = (int) voiceInfo->gain;
return 1;
}

int
TTSCVOX::GetVolume(TTSVolume &Volume) {

CVOX_ENGINE_INFO* voiceInfo;
cvox_GetEngineInfo(engine,voiceInfo);
int volume = (int) voiceInfo->gain;

if (volume == -24) {
Volume = VOLUME_SILENT;
return 1;
}

if (volume <= 3) {
Volume = VOLUME_SOFT;
return 1;
}

if (volume <= 9) {
Volume = VOLUME_MEDIUM;
return 1;
}

if (volume > 9) {
Volume = VOLUME_LOUD;
return 1;
}
return 0;
}


int
TTSCVOX::GetSex(TTSSex &Sex) {

CVOX_ENGINE_INFO* engineInfo;
cvox_GetEngineInfo(engine,engineInfo);
int rank = (int) engineInfo->currentVoice;

CVOX_VOICE_INFO* voiceInfo;
cvox_GetVoiceInfo(engine,rank,voiceInfo);
int sex = (int) voiceInfo->sex;

if (sex == 0) {
Sex = SEX_MALE;
return 1;
}

if (sex == 1) {
Sex = SEX_FEMALE;
return 1;
}

if (sex == 2) {
Sex = SEX_NEUTRAL;
return 1;
}
return 0;
}


int
TTSCVOX::GetVoice(char* Buffer, size_t MaxLen) {

CVOX_ENGINE_INFO* engineInfo;
cvox_GetEngineInfo(engine,engineInfo);
int rank = (int) engineInfo->currentVoice;

CVOX_VOICE_INFO* voiceInfo;
cvox_GetVoiceInfo(engine,rank,voiceInfo);
Buffer = voiceInfo->name;
return 1;
}


int
TTSCVOX::SetSpeed(int NewSpeed) {
if (NewSpeed >= 0 && NewSpeed < 3000) {
cvox_SetParam(engine,CVOX_RATE_PARAM,NewSpeed,0);
return 1;
}
return 0;
}

int
TTSCVOX::SetSpeed(TTSSpeed NewSpeed) {

switch (NewSpeed) {

case SPEED_DEFAULT:
cvox_SetParam(engine,CVOX_RATE_PARAM,CVOX_RESET_PARAM,0);
break;
case SPEED_LOW:
cvox_SetParam(engine,CVOX_RATE_PARAM,50,0);
break;
case SPEED_MEDIUM:
cvox_SetParam(engine,CVOX_RATE_PARAM,135,0);
break;
case SPEED_HIGHT:
cvox_SetParam(engine,CVOX_RATE_PARAM,200,0);
break;
default: return 0;
}
return 1;
}

int
TTSCVOX::SetPitch(int NewPitch) {
if ( NewPitch >= 0 && NewPitch < 300) {
cvox_SetParam(engine,CVOX_PITCH_MIN_PARAM,NewPitch,0);
return 1;
}
return 0;
}

int
TTSCVOX::SetPitch(TTSPitch NewPitch) {

switch ( NewPitch ) {

case PITCH_DEFAULT:
cvox_SetParam(engine,CVOX_PITCH_RANGE_PARAM,CVOX_RESET_PARAM,0);
break;
case PITCH_LOW:
cvox_SetParam(engine,CVOX_PITCH_RANGE_PARAM,50,0);
break;
case PITCH_MEDIUM:
cvox_SetParam(engine,CVOX_PITCH_RANGE_PARAM,135,0);
break;
case PITCH_HIGHT:
cvox_SetParam(engine,CVOX_PITCH_RANGE_PARAM,200,0);
break;
default: return 0;
}
return 1;
}

int
TTSCVOX::SetVolume(int NewVolume) {
if (NewVolume >= -24 && NewVolume < 12) {
cvox_SetParam(engine,CVOX_VOLUME_PARAM,NewVolume,0);
return 1;
}
return 0;
}

int
TTSCVOX::SetVolume(TTSVolume NewVolume) {

switch(NewVolume) {

case VOLUME_DEFAULT:
cvox_SetParam(engine,CVOX_VOLUME_PARAM,CVOX_RESET_PARAM,0);
break;
case VOLUME_SILENT:
cvox_SetParam(engine,CVOX_VOLUME_PARAM,-24,0);
break;
case VOLUME_SOFT:
cvox_SetParam(engine,CVOX_VOLUME_PARAM,0,0);
break;
case VOLUME_MEDIUM:
cvox_SetParam(engine,CVOX_VOLUME_PARAM,6,0);
break;
case VOLUME_LOUD:
cvox_SetParam(engine,CVOX_VOLUME_PARAM,12,0);
break;
default: return 0;

}
return 1;
}

int
TTSCVOX::SetLanguage(TTSLanguage NewLanguage)
{
switch(NewLanguage) {

case LANGUAGE_FRENCH:
for (int i = 0; i < nbVoice ; i++)
{
CVOX_VOICE_INFO voiceInfo;
voiceInfo = tabStruct[i];
if (CVOX_FRENCH == voiceInfo.language) cvox_SetParam(engine,CVOX_VOICE_ID_PARAM,i,0);
}
break;
case LANGUAGE_GERMAN:
for (int i = 0; i < nbVoice ; i++)
{
CVOX_VOICE_INFO voiceInfo;
voiceInfo = tabStruct[i];
if (CVOX_GERMAN == voiceInfo.language) cvox_SetParam(engine,CVOX_VOICE_ID_PARAM,i,0);
}
break;
case LANGUAGE_SPANISH:
for (int i = 0; i < nbVoice ; i++)
{
CVOX_VOICE_INFO voiceInfo;
voiceInfo = tabStruct[i];
if (CVOX_SPANISH == voiceInfo.language) cvox_SetParam(engine,CVOX_VOICE_ID_PARAM,i,0);
}
break;
case LANGUAGE_RUSSIAN:
for (int i = 0; i < nbVoice ; i++)
{
CVOX_VOICE_INFO voiceInfo;
voiceInfo = tabStruct[i];
if (CVOX_RUSSIAN == voiceInfo.language) cvox_SetParam(engine,CVOX_VOICE_ID_PARAM,i,0);
}
break;
default: return 0;
}
return 1;
}

int
TTSCVOX::SetSex(TTSSex NewSex)
{

switch ( NewSex ) {

case SEX_MALE:
for (int i = 0; i < nbVoice ; i++)
{
CVOX_VOICE_INFO voiceInfo;
voiceInfo = tabStruct[i];
if (CVOX_MALE == voiceInfo.sex) cvox_SetParam(engine,CVOX_VOICE_ID_PARAM,i,0);
}
break;
case SEX_FEMALE:
for (int i = 0; i < nbVoice ; i++)
{
CVOX_VOICE_INFO voiceInfo;
voiceInfo = tabStruct[i];
if (CVOX_FEMALE == voiceInfo.sex) cvox_SetParam(engine,CVOX_VOICE_ID_PARAM,i,0);
}
break;
case SEX_NEUTRAL:
for (int i = 0; i < nbVoice ; i++)
{
CVOX_VOICE_INFO voiceInfo;
voiceInfo = tabStruct[i];
if (CVOX_UNKNOWN_SEX == voiceInfo.sex) cvox_SetParam(engine,CVOX_VOICE_ID_PARAM,i,0);
}
break;
default: return 0;
}
return 1;
}

int
TTSCVOX::SetVoice(const char* szNewVoice) {
//V?ifier que la voix existe
for (int i = 0; i < nbVoice ; i++)
{
CVOX_VOICE_INFO voiceInfo;
voiceInfo = tabStruct[i];
if (strcmp(szNewVoice,voiceInfo.name) == 0) {
cvox_SetParam(engine,CVOX_VOICE_NAME_PARAM,0,szNewVoice);
return 1;
}
}
return 0;
}

bool
TTSCVOX::IsSpeaking() {
return (isSpeaking);
}

int
TTSCVOX::Speak2Wave(const char* szPhrase, char* szFileName, TTSTextType Type = TT_Text) {
cvox_GiveText( engine, szPhrase, strlen(szPhrase) );
cvox_Flush(engine);
return 1;
}

int
TTSCVOX::translateSex(const char* sex)
{
if (sex == 0) return -1;
if (strcmp(sex,"male") == 0) return CVOX_MALE;
if (strcmp(sex,"female") == 0) return CVOX_FEMALE;
return -1;
}

int
TTSCVOX::translateMedian(const char* median)
{
int medianInt = atoi(median);
if (medianInt < 0 ) return 0;
if (medianInt > 100) return 100;
return medianInt;
}


voila........!

ouai je ne sais pourquoi le thread a été effacer.. , j'ai essayé en namespace... et ca ne fonctionnait pas et vue que je suis assez pressé j'ai fait au plus simple pour que ca tourne. (mais c vrai que des static partout c pas formidable!

J'ai trouvé!! en rajoutant une petite condition, ca fonctionne:
static vmutex_t local;

static
void safe()
{
vmutex_init(&local);
}

Mutex::Mutex()
{
static pthread_once_t initialized = PTHREAD_ONCE_INIT;
pthread_once(&initialized, safe);

vmutex_lock(&local);
ReturnCode rc = vmutex_init(&myId);
assert( rc != EINVAL);
assert( rc != EBUSY);
assert( rc != ENOMEM);
assert( rc != EAGAIN);

assert( rc == SUCCESS );
vmutex_unlock(&local);
}


Merci a tous pour votre aide!!! a la prochaine!

Version g++: 3.2.2 20030222


Sinon:
----------------------------------------------------------
MUTEX.HXX:

#if !defined(VOCAL_MUTEX_HXX)
#define VOCAL_MUTEX_HXX

static const char* const Mutex_hxx_Version =
"$Id: Mutex.hxx,v 1.2 2001/03/23 20:22:41 icahoon Exp $";


#include "global.h"
#include "vthread.h"
#include "Lockable.hxx"


/** Infrastructure common to VOCAL.
*/
namespace Vocal
{


/** Infrastructure common to VOCAL to create and manage threads.
*/
namespace Threads
{


/** Defines a simple mutex class which provides 'fast' mutex functionality,
* meaning that if the calling thread already has the mutex locked, a call
* to lock will block the thread forever.
*/
class Mutex : public Lockable
{
public:

/** Create a VMutex object initialized with operating system
* dependent defaults (if any).
*/
Mutex();


/**
** Delete a VMutex object
*/
virtual ~Mutex();


/** Lock the mutex. If the mutex is currently unlocked, it
* becomes locked and owned by the calling thread, and
* lock returns immediately. If the mutex is already locked by
* another thread, lock suspends the calling thread until the
* mutex is unlocked. If the mutex is already locked by the calling
* thread, the calling thread blocks forever.
*/
virtual void lock();


/** Unlock the mutex. The mutex is assumed to be locked and owned
* by the calling thread, meaning that a call to unlock always
* returns it to the unlocked state.
*/
virtual void unlock();


/** Returns the operating system dependent unique id of the mutex.
*/
vmutex_t * getId() const;

private:

mutable vmutex_t myId ;

};

} // namespace Threads
} // namespace Vocal


#endif // !defined(VOCAL_MUTEX_HXX)

----------------------------------------------------------------------------------
MUTEX.CXX

static const char* const Mutex_cxx_Version =
"$Id: Mutex.cxx,v 1.2 2001/08/10 04:02:08 icahoon Exp $";



#include "Mutex.hxx"
#include "global.h"
#include
#include
#include



using Vocal::Threads::Mutex;
using Vocal::ReturnCode;
using Vocal::SUCCESS;


Mutex::Mutex()
{

myId = PTHREAD_MUTEX_INITIALIZER ;
ReturnCode rc = vmutex_init(&myId);
assert( rc != EINVAL);
assert( rc != EBUSY);
assert( rc != ENOMEM);
assert( rc != EAGAIN);
assert( rc == SUCCESS );
}


Mutex::~Mutex ()
{

ReturnCode rc = vmutex_destroy(&myId);
assert( rc != EBUSY ); // currently locked
assert( rc == SUCCESS );

}


void
Mutex::lock()
{
ReturnCode rc = vmutex_lock(&myId);
assert( rc != EINVAL );
assert( rc != EDEADLK );
assert( rc == SUCCESS );

}


void
Mutex::unlock()
{
ReturnCode rc = vmutex_unlock(&myId);
assert( rc != EINVAL );
assert( rc != EPERM );
assert( rc == SUCCESS );
}


vmutex_t *
Mutex::getId() const
{
return ( &myId );
}

--------------------------------------------------------------------------
GLOBAL.H

#ifndef GLOBAL_H_
#define GLOBAL_H_

$Id: global.h,v 1.8 2001/08/16 20:07:16 icahoon Exp $
*/


#ifdef USE_DMALLOC
#include <dmalloc.h>
#endif

#ifdef __sgi
#include <pthread.h>
#include
#endif

#ifdef __cplusplus
namespace std {
};
using namespace std;
#endif

/* this is used to turn of unused warnings in GCC */

#ifdef __GNUC__
#define UNUSED_VARIABLE __attribute__((__unused__))
#else
#define UNUSED_VARIABLE
#endif

#if defined(WIN32)

#if _MSC_VER > 1000
#pragma once
#endif /* _MSC_VER > 1000 */

#pragma warning(disable : 4786)

#define WIN32_LEAN_AND_MEAN

#include <winsock2.h>
#include <direct.h>
#include
#include
#include
#include <process.h>

#define srandom srand
#define random rand

#define strcasecmp stricmp
#define strncasecmp strnicmp

#define EWOULDBLOCK WSAEWOULDBLOCK
#define EINPROGRESS WSAEINPROGRESS
#define EALREADY WSAEALREADY
#define ENOTSOCK WSAENOTSOCK
#define EDESTADDRREQ WSAEDESTADDRREQ
#define EMSGSIZE WSAEMSGSIZE
#define EPROTOTYPE WSAEPROTOTYPE
#define ENOPROTOOPT WSAENOPROTOOPT
#define EPROTONOSUPPORT WSAEPROTONOSUPPORT
#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
#define EOPNOTSUPP WSAEOPNOTSUPP
#define EPFNOSUPPORT WSAEPFNOSUPPORT
#define EAFNOSUPPORT WSAEAFNOSUPPORT
#define EADDRINUSE WSAEADDRINUSE
#define EADDRNOTAVAIL WSAEADDRNOTAVAIL
#define ENETDOWN WSAENETDOWN
#define ENETUNREACH WSAENETUNREACH
#define ENETRESET WSAENETRESET
#define ECONNABORTED WSAECONNABORTED
#define ECONNRESET WSAECONNRESET
#define ENOBUFS WSAENOBUFS
#define EISCONN WSAEISCONN
#define ENOTCONN WSAENOTCONN
#define ESHUTDOWN WSAESHUTDOWN
#define ETOOMANYREFS WSAETOOMANYREFS
#define ETIMEDOUT WSAETIMEDOUT
#define ECONNREFUSED WSAECONNREFUSED
#define ELOOP WSAELOOP
#define EHOSTDOWN WSAEHOSTDOWN
#define EHOSTUNREACH WSAEHOSTUNREACH
#define EPROCLIM WSAEPROCLIM
#define EUSERS WSAEUSERS
#define EDQUOT WSAEDQUOT
#define ESTALE WSAESTALE
#define EREMOTE WSAEREMOTE

#if !defined(MAXHOSTNAMELEN)
#define MAXHOSTNAMELEN 256
#endif /* !defined(MAXHOSTNAMELEN) */

typedef int sigset_t;
typedef int siginfo_t;
typedef int pid_t;
typedef unsigned long int in_addr_t;
typedef long off_t;

struct pollfd
{
int fd;
short int events;
short int revents;
};

#define POLLIN 0x001
#define POLLPRI 0x002
#define POLLOUT 0x004
#define POLLERR 0x008
#define POLLHUP 0x010
#define POLLNVAL 0x020

#define getcwd _getcwd

#endif /* defined(WIN32) */

#endif /* GLOBAL_H_ */


Voila, je n'arrive tjrs pas a voir ou pourrait etre le probleme!

voila:
static const char* const Mutex_cxx_Version =
"$Id: Mutex.cxx,v 1.2 2001/08/10 04:02:08 icahoon Exp $";



#include "Mutex.hxx"
#include "global.h"
#include
#include
#include



using Vocal::Threads::Mutex;
using Vocal::ReturnCode;
using Vocal::SUCCESS;


Mutex::Mutex()
{

myId = PTHREAD_MUTEX_INITIALIZER ;
ReturnCode rc = vmutex_init(&myId);
assert( rc != EINVAL);
assert( rc != EBUSY);
assert( rc != ENOMEM);
assert( rc != EAGAIN);
assert( rc == SUCCESS );
}


Mutex::~Mutex ()
{

ReturnCode rc = vmutex_destroy(&myId);
assert( rc != EBUSY ); // currently locked
assert( rc == SUCCESS );

}

on ne voit pas d'erreur de syntaxe... !!?