cue_parser.cpp File Reference

Go to the source code of this file.

Functions
static void	g_parse_cue (const char *p_cuesheet, cue_parser_callback &p_callback)
static void	g_parse_cue_line (const char *p_line, t_size p_line_length, cue_parser_callback &p_callback)
static bool	is_linebreak (char c)
static bool	is_numeric (char c)
static bool	is_spacing (char c)
static void	validate_file_type (const char *p_type, t_size p_type_length)

Function Documentation

static void g_parse_cue ( const char *  p_cuesheet, cue_parser_callback &  p_callback  )

static

Definition at line 594 of file cue_parser.cpp.

{
    const char * parseptr = p_cuesheet;
    t_size lineidx = 1;
    while(*parseptr)
    {
        while(is_spacing(*parseptr)) parseptr++;
        if (*parseptr)
        {
            t_size length = 0;
            while(parseptr[length] && !is_linebreak(parseptr[length])) length++;
            if (length > 0) {
                try {
                    g_parse_cue_line(parseptr,length,p_callback);
                } catch(exception_cue const & e) {//rethrow with line info
                    pfc::throw_exception_with_message< exception_cue > (PFC_string_formatter() << e.what() << " (line " << (unsigned)lineidx << ")");
                }
            }
            parseptr += length;
            while(is_linebreak(*parseptr)) {
                if (*parseptr == '\n') lineidx++;
                parseptr++;
            }
        }
    }
}

static void g_parse_cue_line ( const char *  p_line, t_size  p_line_length, cue_parser_callback &  p_callback  )

static

Definition at line 380 of file cue_parser.cpp.

{
    t_size ptr = 0;
    while(ptr < p_line_length && !is_spacing(p_line[ptr])) ptr++;
    if (!stricmp_utf8_ex(p_line,ptr,"file",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        t_size file_base,file_length, type_base,type_length;
        
        if (p_line[ptr] == '\"')
        {
            ptr++;
            file_base = ptr;
            while(ptr < p_line_length && p_line[ptr] != '\"') ptr++;
            if (ptr == p_line_length) pfc::throw_exception_with_message< exception_cue > ("invalid FILE syntax");
            file_length = ptr - file_base;
            ptr++;
            while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        }
        else
        {
            file_base = ptr;
            while(ptr < p_line_length && !is_spacing(p_line[ptr])) ptr++;
            file_length = ptr - file_base;
            while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        }

        type_base = ptr;
        while(ptr < p_line_length && !is_spacing(p_line[ptr])) ptr++;
        type_length = ptr - type_base;
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;

        if (ptr != p_line_length || file_length == 0 || type_length == 0) pfc::throw_exception_with_message< exception_cue > ("invalid FILE syntax");

        p_callback.on_file(p_line + file_base, file_length, p_line + type_base, type_length);
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"track",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;

        t_size track_base = ptr, track_length;
        while(ptr < p_line_length && !is_spacing(p_line[ptr]))
        {
            if (!is_numeric(p_line[ptr])) pfc::throw_exception_with_message< exception_cue > ("invalid TRACK syntax");
            ptr++;
        }
        track_length = ptr - track_base;
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        
        t_size type_base = ptr, type_length;
        while(ptr < p_line_length && !is_spacing(p_line[ptr])) ptr++;
        type_length = ptr - type_base;

        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        if (ptr != p_line_length || type_length == 0) pfc::throw_exception_with_message< exception_cue > ("invalid TRACK syntax");
        unsigned track = pfc::atoui_ex(p_line+track_base,track_length);
        if (track < 1 || track > 99) pfc::throw_exception_with_message< exception_cue > ("invalid track number");

        p_callback.on_track(track,p_line + type_base, type_length);
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"index",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;

        t_size index_base,index_length, time_base,time_length;
        index_base = ptr;
        while(ptr < p_line_length && !is_spacing(p_line[ptr]))
        {
            if (!is_numeric(p_line[ptr])) pfc::throw_exception_with_message< exception_cue > ("invalid INDEX syntax" );
            ptr++;
        }
        index_length = ptr - index_base;
        
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        time_base = ptr;
        while(ptr < p_line_length && !is_spacing(p_line[ptr]))
        {
            if (!is_numeric(p_line[ptr]) && p_line[ptr] != ':')
                pfc::throw_exception_with_message< exception_cue > ("invalid INDEX syntax");
            ptr++;
        }
        time_length = ptr - time_base;

        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        
        if (ptr != p_line_length || index_length == 0 || time_length == 0)
            pfc::throw_exception_with_message< exception_cue > ("invalid INDEX syntax");

        unsigned index = pfc::atoui_ex(p_line+index_base,index_length);
        if (index > 99) pfc::throw_exception_with_message< exception_cue > ("invalid INDEX syntax");
        unsigned time = cuesheet_parse_index_time_ticks_e(p_line + time_base,time_length);
        
        p_callback.on_index(index,time);
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"pregap",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;

        t_size time_base, time_length;
        time_base = ptr;
        while(ptr < p_line_length && !is_spacing(p_line[ptr]))
        {
            if (!is_numeric(p_line[ptr]) && p_line[ptr] != ':')
                pfc::throw_exception_with_message< exception_cue > ("invalid PREGAP syntax");
            ptr++;
        }
        time_length = ptr - time_base;

        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        
        if (ptr != p_line_length || time_length == 0)
            pfc::throw_exception_with_message< exception_cue > ("invalid PREGAP syntax");

        unsigned time = cuesheet_parse_index_time_ticks_e(p_line + time_base,time_length);
        
        p_callback.on_pregap(time);
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"title",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        if (ptr == p_line_length) pfc::throw_exception_with_message< exception_cue > ("invalid TITLE syntax");
        if (p_line[ptr] == '\"')
        {
            ptr++;
            t_size base = ptr;
            while(ptr < p_line_length && p_line[ptr] != '\"') ptr++;
            if (ptr == p_line_length) pfc::throw_exception_with_message< exception_cue > ("invalid TITLE syntax");
            t_size length = ptr-base;
            ptr++;
            while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
            if (ptr != p_line_length) pfc::throw_exception_with_message< exception_cue > ("invalid TITLE syntax");
            p_callback.on_title(p_line+base,length);
        }
        else
        {
            p_callback.on_title(p_line+ptr,p_line_length-ptr);
        }
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"performer",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        if (ptr == p_line_length) pfc::throw_exception_with_message< exception_cue > ("invalid PERFORMER syntax");
        if (p_line[ptr] == '\"')
        {
            ptr++;
            t_size base = ptr;
            while(ptr < p_line_length && p_line[ptr] != '\"') ptr++;
            if (ptr == p_line_length) pfc::throw_exception_with_message< exception_cue > ("invalid PERFORMER syntax");
            t_size length = ptr-base;
            ptr++;
            while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
            if (ptr != p_line_length) pfc::throw_exception_with_message< exception_cue > ("invalid PERFORMER syntax");
            p_callback.on_performer(p_line+base,length);
        }
        else
        {
            p_callback.on_performer(p_line+ptr,p_line_length-ptr);
        }
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"songwriter",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        if (ptr == p_line_length) pfc::throw_exception_with_message< exception_cue > ("invalid SONGWRITER syntax");
        if (p_line[ptr] == '\"')
        {
            ptr++;
            t_size base = ptr;
            while(ptr < p_line_length && p_line[ptr] != '\"') ptr++;
            if (ptr == p_line_length) pfc::throw_exception_with_message< exception_cue > ("invalid SONGWRITER syntax");
            t_size length = ptr-base;
            ptr++;
            while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
            if (ptr != p_line_length) pfc::throw_exception_with_message< exception_cue > ("invalid SONGWRITER syntax");
            p_callback.on_songwriter(p_line+base,length);
        }
        else
        {
            p_callback.on_songwriter(p_line+ptr,p_line_length-ptr);
        }
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"isrc",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        t_size length = p_line_length - ptr;
        if (length == 0) pfc::throw_exception_with_message< exception_cue > ("invalid ISRC syntax");
        p_callback.on_isrc(p_line+ptr,length);
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"catalog",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        t_size length = p_line_length - ptr;
        if (length == 0) pfc::throw_exception_with_message< exception_cue > ("invalid CATALOG syntax");
        p_callback.on_catalog(p_line+ptr,length);
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"flags",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        if (ptr < p_line_length)
            p_callback.on_flags(p_line + ptr, p_line_length - ptr);
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"rem",pfc_infinite))
    {
        while(ptr < p_line_length && is_spacing(p_line[ptr])) ptr++;
        if (ptr < p_line_length)
            p_callback.on_comment(p_line + ptr, p_line_length - ptr);
    }
    else if (!stricmp_utf8_ex(p_line,ptr,"postgap",pfc_infinite)) {
        pfc::throw_exception_with_message< exception_cue > ("POSTGAP is not supported");
    } else if (!stricmp_utf8_ex(p_line,ptr,"cdtextfile",pfc_infinite)) {
        //do nothing
    }
    else pfc::throw_exception_with_message< exception_cue > ("unknown cuesheet item");
}

static bool is_linebreak ( char  c )

static

Definition at line 15 of file cue_parser.cpp.

{
    return c == '\n' || c == '\r';
}

static bool is_numeric ( char  c )

static

Definition at line 7 of file cue_parser.cpp.

{return c>='0' && c<='9';}

static bool is_spacing ( char  c )

static

Definition at line 10 of file cue_parser.cpp.

{
    return c == ' ' || c == '\t';
}

static void validate_file_type ( const char *  p_type, t_size  p_type_length  )

static

Definition at line 20 of file cue_parser.cpp.

                                                                         {
    if (
        //standard types
        stricmp_utf8_ex(p_type,p_type_length,"WAVE",pfc_infinite) != 0 && 
        stricmp_utf8_ex(p_type,p_type_length,"MP3",pfc_infinite) != 0 && 
        stricmp_utf8_ex(p_type,p_type_length,"AIFF",pfc_infinite) != 0 && 
        //common user-entered types
        stricmp_utf8_ex(p_type,p_type_length,"APE",pfc_infinite) != 0 && 
        stricmp_utf8_ex(p_type,p_type_length,"FLAC",pfc_infinite) != 0 &&
        stricmp_utf8_ex(p_type,p_type_length,"WV",pfc_infinite) != 0 &&
        stricmp_utf8_ex(p_type,p_type_length,"WAVPACK",pfc_infinite) != 0
        )
        pfc::throw_exception_with_message< exception_cue >(PFC_string_formatter() << "expected WAVE, MP3 or AIFF, got : \"" << pfc::string_part(p_type,p_type_length) << "\"");
}