Compiler Being Uber Picky

I've never encountered this kind of error before and I'm slightly confused about it seeing as how I have almost nine other classes set up in a similar fashion and the compiler is only complaining about this one. The class I'm going to display is a class that handles an MP3 and Sample file in the same class (it has the ability to convert an MP3 file into a Sample on the fly). It is a wrapper for another MP3 library but it's easier to assimilate into my program if I placed it in another class. Anyway, I'll post the actual CPP file below so you can see everything that's there as far as this class goes.

soundTools.cpp Contents:

Code:

---

#include "soundTools.h"

SoundTools::SoundTools(const char *FileName) {
    MP3File = pack_fopen(FileName, F_READ);
    if(!MP3File) {
        allegro_message("Error in loading the MP3 file!");
        MP3Object = NULL;
    }
   
    MP3FileSize  = file_size_ex(FileName);
    MP3FileBuffer = new char[MP3FileSize];
    MP3FileSize  = pack_fread(MP3FileBuffer, MP3FileSize, MP3File);
    pack_fclose(MP3File);
   
    if((MP3Object = almp3_create_mp3(MP3FileBuffer, MP3FileSize)) == NULL) {
        allegro_message("Error in creating MP3 object!");
        MP3Object = NULL;
    }
   
    SampleObject  = NULL;
    Volume        = 255;
    Pan          = 127;
    Speed        = 1000; //used for sample playback as the frequency
    Loop          = false;
    PosFrames    = almp3_get_pos_frames_mp3(MP3Object);
    PosMSecs      = almp3_get_pos_msecs_mp3(MP3Object);
    PosSecs      = almp3_get_pos_secs_mp3(MP3Object);
    PosBytes      = almp3_get_pos_bytes_mp3(MP3Object);
    LenFrames    = almp3_get_length_frames_mp3(MP3Object);
    LenMSecs      = almp3_get_length_msecs_mp3(MP3Object);
    LenSecs      = almp3_get_length_secs_mp3(MP3Object);
    LenBytes      = almp3_get_length_bytes_mp3(MP3Object);
    //MSecsPerFrame = get_msecs_per_frame_mp3(MP3Object);
    Bitrate      = almp3_get_bitrate_mp3(MP3Object);
    Layer        = almp3_get_layer_mp3(MP3Object);
    WavBits      = almp3_get_wave_bits_mp3(MP3Object);
    //WavIsStereo  = static_cast<bool>(almp3_get_wave_is_stereo(MP3Object));
    WavFreq      = almp3_get_wave_freq_mp3(MP3Object);
}

SoundTools::~SoundTools() {
    destroy_sample(SampleObject);
    almp3_destroy_mp3(MP3Object);
    SampleObject = NULL;
    MP3Object    = NULL;
}

void SoundTools::PlayMP3() {
    if(MP3Object != NULL)
        almp3_play_ex_mp3(MP3Object, 32768, Volume, Pan, Speed, static_cast<int>(Loop));
}

void SoundTools::StopMP3() {
    almp3_stop_mp3(MP3Object);
}

void SoundTools::PauseMP3() {
    almp3_stop_mp3(MP3Object);
}

bool SoundTools::PollMP3() {
    if(MP3Object != NULL) {
        int poll = almp3_poll_mp3(MP3Object);
       
        switch(poll) {
        case ALMP3_POLL_PLAYJUSTFINISHED:
        case ALMP3_OK:
            return true;
        case ALMP3_POLL_NOTPLAYING:
        case ALMP3_POLL_FRAMECORRUPT:
        case ALMP3_POLL_INTERNALERROR:
            return false;
        }
    }
}

void SoundTools::UpdateMP3() {
    PosFrames = almp3_get_pos_frames_mp3(MP3Object);
    PosMSecs  = almp3_get_pos_msecs_mp3(MP3Object);
    PosSecs  = almp3_get_pos_secs_mp3(MP3Object);
    PosBytes  = almp3_get_pos_bytes_mp3(MP3Object);
}

void SoundTools::RewindMP3() {
    almp3_rewind_mp3(MP3Object);
}

void SoundTools::AdjustMP3() {
    almp3_adjust_mp3(MP3Object, Volume, Pan, Speed, Loop);
}

void SoundTools::SetVolume(int _Volume) {
    Volume = _Volume;
}

void SoundTools::SetPan(int _Pan) {
    Pan = _Pan;
}

void SoundTools::SetSpeed(int _Speed) {
    Speed = _Speed;
}

void SoundTools::SetLoop(bool _Loop) {
    Loop = _Loop;
}

int SoundTools::GetVolume() {
    return Volume;
}

int SoundTools::GetPan() {
    return Pan;
}

int SoundTools::GetSpeed() {
    return Speed;
}

bool SoundTools::GetLoop() {
    return Loop;
}

/*
bool SoundTools::IsPlayingMP3() {
    almp3_is_playing_mp3(MP3Object)?return true:return false;
}

bool SoundTools::IsLoopingMP3() {
    almp3_is_looping_mp3(MP3Object)?return(true):return(false);
}
*/

void SoundTools::SeekABSMP3(SeekType Type, int Seek) {
    switch(Type) {
        case SEEK_TYPE_FRAMES:
            almp3_seek_abs_frames_mp3(MP3Object, Seek);
            break;
        case SEEK_TYPE_MSECS:
            almp3_seek_abs_msecs_mp3(MP3Object, Seek);
            break;
        case SEEK_TYPE_SECS:
            almp3_seek_abs_secs_mp3(MP3Object, Seek);
            break;
        case SEEK_TYPE_BYTES:
            almp3_seek_abs_bytes_mp3(MP3Object, Seek);
            break;
        default:
            allegro_message("Undefined seek type requested.\nUnable to seek");
            break;
    }
}

void SoundTools::SeekRelMP3(SeekType Type, int Seek) {
    switch(Type) {
        case SEEK_TYPE_FRAMES:
            almp3_seek_rel_frames_mp3(MP3Object, Seek);
            break;
        case SEEK_TYPE_MSECS:
            almp3_seek_rel_msecs_mp3(MP3Object, Seek);
            break;
        case SEEK_TYPE_SECS:
            almp3_seek_rel_secs_mp3(MP3Object, Seek);
            break;
        case SEEK_TYPE_BYTES:
            almp3_seek_rel_bytes_mp3(MP3Object, Seek);
            break;
        default:
            allegro_message("Undefined seek type requested.\nUnable to seek.");
            break;
    }
}

int SoundTools::GetPosMP3(PosType Type) {
    switch(Type) {
        case POS_TYPE_FRAMES:
            return PosFrames;
        case POS_TYPE_MSECS:
            return PosMSecs;
        case POS_TYPE_SECS:
            return PosSecs;
        case POS_TYPE_BYTES:
            return PosBytes;
        default:
            allegro_message("Undefined position type requested.\nUnable to get position.");
            return (-1);
    }
}

int SoundTools::GetLenMP3(LenType Type) {
    switch(Type) {
        case LEN_TYPE_FRAMES:
            return LenFrames;
        case LEN_TYPE_MSECS:
            return LenMSecs;
        case LEN_TYPE_SECS:
            return LenSecs;
        case LEN_TYPE_BYTES:
            return LenBytes;
        default:
            allegro_message("Undefinied length type requested.\nUnable to get length.");
            return (-1);
    }
}

/*
int SoundTools::GetMSecsPerFrameMP3() {
    return MSecsPerFrame;
}
*/

int SoundTools::GetBitrateMP3() {
    return Bitrate;
}

int SoundTools::GetLayerMP3() {
    return Layer;
}

int SoundTools::GetWaveBitsMP3() {
    return WavBits;
}

/*
bool SoundTools::GetWaveIsStereoMP3() {
    return WavIsStereo;
}
*/

int SoundTools::GetWaveFreqMP3() {
    return WavFreq;
}

void SoundTools::ConvMP3ToSample() {
    SampleObject = almp3_create_sample_from_mp3(MP3Object);
}

void SoundTools::PlaySample(int _Volume, int _Pan, int _Freq, int _Loop) {
    if(SampleObject != NULL) {
        play_sample(SampleObject, _Volume, _Pan, _Freq, _Loop);
    }
}

void SoundTools::AdjustSample(int _Volume, int _Pan, int _Freq, int _Loop) {
    if(SampleObject != NULL) {
        adjust_sample(SampleObject, _Volume, _Pan, _Freq, _Loop);
    }
}

void SoundTools::StopSample() {
    stop_sample(SampleObject);
}

---

I know there's a lot there but I figured it best if you saw the entire thing just in case there was something that that I wasn't seeing.

To my error, my compiler complains about line 3 in the soundTools.cpp file. That would be the line that starts the overrided constructor for the SoundTools class. It's throwing me two errors about that line. The first saying that new types may not be defined in a return type and the other is return type specification for constructor invalid. Both of these are puzzling me seeing as how (1) the conrstructor isn't returning anything at all and (2) the constructor has no return type. And the other thing, like I said earlier, I have at least nine other classes coded very similar to this one and this is the only class giving me this error. Is this something that I've done wrong because I'm lost. A major thanks in advance.

Code:

---

int SoundTools::GetPosMP3(PosType Type)
int SoundTools::GetLenMP3(LenType Type)

---

You have no "break;" statements in the switches in those functions.. look at them.

Little things like that cause havoc for most compilers..

chem

An error just after a #include directive is usually a result from something in the header file. My first guess would be missing a semicolon after a class...{...} declaration.