CRioMMIndexParser Class Reference

#include <RioMMIndexParser.h>

Static Public Member Functions
static CRioMMIndex *	ParseIndex (FILE *, RioBlock)
static bool	ParseCommand (FILE *, RioMMCommand *, TQueue &, RioBlock *, int *)
Private Types
enum	TokenType {   TK_INVALID, TK_EOF, TK_INTEGER, TK_STRING,   TK_LCBRAC, TK_RCBRAC, TK_LBRAC, TK_RBRAC,   TK_LPAR, TK_RPAR, TK_COMMA, TK_SEMICOL,   TK_VERSION, TK_ARCHIVE, TK_FILE, TK_SLIDE,   TK_OPENURL, TK_COMMAND }
Static Private Member Functions
static void	FilesDeclaration (void)
static void	FileDeclaration (void)
static void	SlidesDeclaration (void)
static void	SlideDeclaration (void)
static void	CommandsDeclaration (void)
static void	CommandDeclaration (void)
static void	ArgumentsDeclaration (void)
static void	ReportError (const char *)
static void	Match (TokenType)
static TokenType	GetToken (void)
static void	InitVars (void)
Static Private Attributes
static const char *	token_name []
static CRioMMIndex *	index
static FILE *	file
static int	line_number
static TokenType	token_type
static char	token_string [256]
static int	token_offset
static int	integer_value
static RioBlock	index_value
static RioBlock	command_index
static bool	quit_on_errors

---

Detailed Description

Definition at line 38 of file RioMMIndexParser.h.

---

Member Enumeration Documentation

enum CRioMMIndexParser::TokenType [private]

Enumerator:

TK_INVALID
TK_EOF
TK_INTEGER
TK_STRING
TK_LCBRAC
TK_RCBRAC
TK_LBRAC
TK_RBRAC
TK_LPAR
TK_RPAR
TK_COMMA
TK_SEMICOL
TK_VERSION
TK_ARCHIVE
TK_FILE
TK_SLIDE
TK_OPENURL
TK_COMMAND

Definition at line 42 of file RioMMIndexParser.h.

                 {
        TK_INVALID,
        TK_EOF,

        TK_INTEGER,
        TK_STRING,

        TK_LCBRAC,
        TK_RCBRAC,

        TK_LBRAC,
        TK_RBRAC,

        TK_LPAR,
        TK_RPAR,

        TK_COMMA,
        TK_SEMICOL,

        TK_VERSION,
        TK_ARCHIVE,
        TK_FILE,
        TK_SLIDE,
        TK_OPENURL,
        TK_COMMAND
    } TokenType;

---

Member Function Documentation

void CRioMMIndexParser::ArgumentsDeclaration

(

void

)

[static, private]

Definition at line 410 of file RioMMIndexParser.cpp.

{
    if( token_type == TK_INTEGER || token_type == TK_STRING )
        Match( token_type );
    else
    {
        /* epsilon */
        return;
    }

    while( token_type == TK_COMMA )
    {
        Match( TK_COMMA );
        if( token_type == TK_INTEGER )
            Match( TK_INTEGER );
        else
            Match( TK_STRING );
    }
}

void CRioMMIndexParser::CommandDeclaration

(

void

)

[static, private]

Definition at line 396 of file RioMMIndexParser.cpp.

{
    Match( TK_LBRAC );
    command_index = integer_value;
    Match( TK_INTEGER );
    Match( TK_RBRAC );

    Match( TK_COMMAND );
    Match( TK_LPAR );
    ArgumentsDeclaration( );
    Match( TK_RPAR );
    Match( TK_SEMICOL );
}

void CRioMMIndexParser::CommandsDeclaration

(

void

)

[static, private]

Definition at line 386 of file RioMMIndexParser.cpp.

{
    if( token_type == TK_LBRAC )
    {
        CommandDeclaration( );
        CommandsDeclaration( );
    }
    else /* epsilon */;
}

void CRioMMIndexParser::FileDeclaration

(

void

)

[static, private]

Definition at line 275 of file RioMMIndexParser.cpp.

{
    TString filename;
    RioBlock position;

    Match( TK_LBRAC );
    position = index_value;
    Match( TK_INTEGER );
    Match( TK_RBRAC );

    if( token_type == TK_OPENURL )
    {
        Match( TK_OPENURL );
        Match( TK_LPAR );
        filename = token_string;
        Match( TK_STRING );
        Match( TK_RPAR );
        Match( TK_SEMICOL );

        #ifdef RIO_DEBUG2
        RioErr << "Inserting URL " << (const char *)filename << " at position "
               << position << endl;
        #endif
        
        if( !index->InsertFile( (const char *)filename, position ) )
        {
            ReportError( "Error trying to insert a new file" );
        }
        if( !index->InsertSlide( 1, -1,
                                 0, position ) )
        {
            ReportError( "Error trying to insert a new slide" );
        }
    }
    else
    {
        Match( TK_FILE );
        Match( TK_LPAR );
        filename = token_string;
        Match( TK_STRING );
        Match( TK_RPAR );
        Match( TK_LCBRAC );

        #ifdef RIO_DEBUG2
        RioErr << "Inserting file " << (const char *)filename << " at position "
               << position << endl;
        #endif
        
        if( !index->InsertFile( (const char *)filename, position ) )
        {
            ReportError( "Error trying to insert a new file" );
        }

        SlideDeclaration( );
        SlidesDeclaration( );

        Match( TK_RCBRAC );
    }
}

void CRioMMIndexParser::FilesDeclaration

(

void

)

[static, private]

Definition at line 265 of file RioMMIndexParser.cpp.

{
    if( token_type == TK_LBRAC )
    {
        FileDeclaration( );
        FilesDeclaration( );
    }
    else /* epsilon */;
}

CRioMMIndexParser::TokenType CRioMMIndexParser::GetToken

(

void

)

[static, private]

Definition at line 113 of file RioMMIndexParser.cpp.

{
    int  i;
    char ch;

    /* Skip spaces */
    do
    {
        ch = fgetc( file );
        if( ch == '\n' )
            line_number++;
    } while( isspace( ch ) );

    token_offset = ftell( file ) - 1;

    if( ch == EOF )
    {
        /* Found END OF FILE */
        token_type = TK_EOF;
    }
    else if( ch == '#' )
    {
        do
        {
            ch = fgetc( file );
        }
        while( ch != '\n' && ch != EOF );

        if( ch == EOF )
        {
            token_offset = ftell( file ) - 1;
            token_type = TK_EOF;
        }
        else
        {
            line_number++;
            token_type = GetToken( );
        }
    }
    else if( isdigit( ch ) )
    {
        /* Found a number */
        /* Copy string to buffer */
        i = 0;
        do
        {
            token_string[ i++ ] = ch;
            ch = fgetc( file );
        }
        while( isdigit( ch ) );

        ungetc( ch, file );
        token_string[ i ] = '\0';
        integer_value = atoi( token_string );
        index_value = strtoul( token_string, NULL, 10 );
        token_type     = TK_INTEGER;
    }
    else if( ch == '"' )
    {
        i = 0;
        ch = fgetc( file );
        while( ch != '"' && ch != EOF )
        {
            token_string[ i++ ] = ch;
            ch = fgetc( file );
        }
        if( ch == '"' )
        {
            token_string[ i ] = '\0';
            token_type = TK_STRING;
        }
        else
        {
            token_type = TK_INVALID;
        }
    }
    else if( isalpha( ch ) )
    {
        /* Found a keyword */
        /* Copy characters */
        i = 0;
        while( isalpha( ch ) || ch == '_' || isdigit( ch ) )
        {
            token_string[ i++ ] = ch;
            ch = fgetc( file );
        }
        ungetc( ch, file );
        token_string[ i ] = '\0';

        /* Check if the word found is a keyword */
        if( strcmp( token_string, "Version" ) == 0 )
        {
            token_type = TK_VERSION;
        }
        else if( strcmp( token_string, "Archive" ) == 0 )
        {
            token_type = TK_ARCHIVE;
        }
        else if( strcmp( token_string, "File" ) == 0 )
        {
            token_type = TK_FILE;
        }
        else if( strcmp( token_string, "Slide" ) == 0 )
        {
            token_type = TK_SLIDE;
        }
        else if( strcmp( token_string, "OpenURL" ) == 0 )
        {
            token_type = TK_OPENURL;
        }
        else
        {
            token_type = TK_COMMAND;
        }
    }
    else
    {
        switch( ch )
        {
            case '(':
                token_type = TK_LPAR;
                break;
            case ')':
                token_type = TK_RPAR;
                break;
            case '{':
                token_type = TK_LCBRAC;
                break;
            case '}':
                token_type = TK_RCBRAC;
                break;
            case '[':
                token_type = TK_LBRAC;
                break;
            case ']':
                token_type = TK_RBRAC;
                break;
            case ',':
                token_type = TK_COMMA;
                break;
            case ';':
                token_type = TK_SEMICOL;
                break;
            default:
                token_type = TK_INVALID;
                break;
        }
    }

    return token_type;
}

void CRioMMIndexParser::InitVars

(

void

)

[static, private]

Definition at line 74 of file RioMMIndexParser.cpp.

{
    token_type        = TK_INVALID;
    token_string[ 0 ] = '\0';
    index             = NULL;
    file              = NULL;
    line_number       = 0;
    command_index     = 0;
    integer_value     = 0;
    token_offset      = -1;
}

void CRioMMIndexParser::Match

(

TokenType

type

)

[static, private]

Definition at line 95 of file RioMMIndexParser.cpp.

{
    if( token_type == type )
    {
        if( GetToken( ) == TK_INVALID )
        {
            ReportError( "Invalid token found in the input" );
        }
    }
    else
    {
        RioErr << "Found "            << token_name[ token_type ]
             << " while expecting " << token_name[ type ]
             << endl;
        ReportError( "Syntax error matching token" );
    }
}

bool CRioMMIndexParser::ParseCommand	(	FILE *	fp,
		RioMMCommand *	command,
		TQueue &	args_queue,
		RioBlock *	idx,
		int *	offset
	)			[static]

Definition at line 498 of file RioMMIndexParser.cpp.

{
    #ifdef RIO_DEBUG2
    RioErr << "[RioMMIndexParser]: Entrou na ParseCommand (file="
           << fp << ",command=" << command << ",queue_size="
           << args_queue.GetSize( ) << ",*idx=" << *idx << ",*offset="
           << *offset << ")" << endl;
    #endif

    InitVars( );

    /* Declare that the program must stop on syntax errors */
    quit_on_errors = false;

    /* Initialize line count */
    line_number = 1;

    /* Initialize file stream */
    file = fp;
    if( file == NULL )
        ReportError( "Invalid file" );
    fseek( file, *offset, SEEK_SET );

    /* Get the first token */
    if( GetToken( ) == TK_INVALID )
    {
        ReportError( "Found invalid token at the beginning of stream" );
        return false;
    }

    /* Commands declaration */
    Match( TK_LBRAC );
    *idx = integer_value;
    Match( TK_INTEGER );
    Match( TK_RBRAC );

    command->name = token_string;
    Match( TK_COMMAND );
    Match( TK_LPAR );

    /* Arguments declaration */
    command->arg_types = 0;
    if( token_type == TK_INTEGER || token_type == TK_STRING )
    {
        if( token_type == TK_INTEGER )
        {
            command->arg_types |= ARG_INT( 0 );
            args_queue.Add( (void *)integer_value );
            Match( TK_INTEGER );
        }
        else
        {
            command->arg_types |= ARG_STRING( 0 );
            args_queue.Add( new TString( token_string ) );
            Match( TK_STRING );
        }

        while( token_type == TK_COMMA )
        {
            Match( TK_COMMA );
            if( token_type == TK_INTEGER )
            {
                command->arg_types |= ARG_INT( args_queue.GetSize( ) );
                args_queue.Add( (void *)integer_value );
                Match( TK_INTEGER );
            }
            else
            {
                command->arg_types |= ARG_STRING( args_queue.GetSize( ) );
                args_queue.Add( new TString( token_string ) );
                Match( TK_STRING );
            }
        }
    }

    command->n_args = args_queue.GetSize( );

    Match( TK_RPAR );
    Match( TK_SEMICOL );

    if( token_type == TK_LBRAC )
    {
        *offset = token_offset;
        Match( TK_LBRAC );
        *idx    = integer_value;
        Match( TK_INTEGER );
        Match( TK_RBRAC );
    }
    else
    {
        *offset = -1;
        *idx    = UINT_MAX;
        
        #ifdef RIO_DEBUG2
        RioErr << "[RioMMIndexParser]: End of commands section found!\n"
               << "                    Expecting to change context next" << endl;
        #endif
    }

    #ifdef RIO_DEBUG2
    RioErr << "[RioMMIndexParser]: Saindo da ParseCommand" << endl;
    #endif
    return true;
}

CRioMMIndex * CRioMMIndexParser::ParseIndex	(	FILE *	fp,
		RioBlock	idcs
	)			[static]

Definition at line 430 of file RioMMIndexParser.cpp.

{
    int major, minor;
    TString archive_name;

    #ifdef RIO_DEBUG2
    RioErr << "[RioMMIndexParser]: Entrei na ParseIndex: fp=" << fp
           << ", idcs=" << idcs << endl;
    #endif

    InitVars( );

    /* Declare that the program must stop on errors */
    quit_on_errors = true;

    /* Initialize line count */
    line_number = 1;

    /* Initialize file stream */
    file = fp;
    if( file == NULL )
        ReportError( "Invalid file" );
    rewind( file );

    /* Get the first token */
    if( GetToken( ) == TK_INVALID )
        ReportError( "Invalid token at the begining of input" );

    /* Version information */
    Match( TK_VERSION );
    Match( TK_LPAR );
    major = integer_value;
    Match( TK_INTEGER );
    Match( TK_COMMA );
    minor = integer_value;
    Match( TK_INTEGER );
    Match( TK_RPAR );
    Match( TK_SEMICOL );

    /* Archive information */
    Match( TK_ARCHIVE );
    Match( TK_LPAR );
    archive_name = token_string;
    Match( TK_STRING );
    Match( TK_RPAR );
    Match( TK_SEMICOL );

    index = new CRioMMIndex( idcs, major, minor, (const char *)archive_name );

    FilesDeclaration( );

    Match( TK_EOF );

    /* Semantic checks */
    if( !index->IsValid( ) )
        ReportError( "Invalid index declaration" );

    rewind( file );

    return index;
}

void CRioMMIndexParser::ReportError

(

const char *

message

)

[static, private]

Definition at line 86 of file RioMMIndexParser.cpp.

{
    RioErr << "Error at line " << line_number << ": " << message << endl;
    if( index )
        delete index;
    if( quit_on_errors )
        exit( -1 );
}

void CRioMMIndexParser::SlideDeclaration

(

void

)

[static, private]

Definition at line 345 of file RioMMIndexParser.cpp.

{
    int slide_number;
    int commands_offset = -1;
    RioBlock first_command_index = 0,
             position;

    Match( TK_LBRAC );
    position = index_value;
    Match( TK_INTEGER );
    Match( TK_RBRAC );

    Match( TK_SLIDE );
    Match( TK_LPAR );
    slide_number = integer_value;
    Match( TK_INTEGER );
    Match( TK_RPAR );
    if( token_type == TK_LCBRAC )
    {
        Match( TK_LCBRAC );
        commands_offset = token_offset;
        CommandDeclaration( );
        first_command_index = command_index;
        CommandsDeclaration( );
        Match( TK_RCBRAC );
    }
    else
        Match( TK_SEMICOL );

    #ifdef RIO_DEBUG2
    RioErr << "Inserting slide " << slide_number << " at position "
           << position << endl;
    #endif
    
    if( !index->InsertSlide( slide_number, commands_offset,
                             first_command_index, position ) )
    {
        ReportError( "Error trying to insert a new slide" );
    }
}

void CRioMMIndexParser::SlidesDeclaration

(

void

)

[static, private]

Definition at line 335 of file RioMMIndexParser.cpp.

{
    if( token_type == TK_LBRAC )
    {
        SlideDeclaration( );
        SlidesDeclaration( );
    }
    else /* epsilon */;
}

---

Field Documentation

RioBlock CRioMMIndexParser::command_index [static, private]

Definition at line 89 of file RioMMIndexParser.h.

FILE * CRioMMIndexParser::file [static, private]

Definition at line 76 of file RioMMIndexParser.h.

CRioMMIndex * CRioMMIndexParser::index [static, private]

Definition at line 73 of file RioMMIndexParser.h.

RioBlock CRioMMIndexParser::index_value [static, private]

Definition at line 86 of file RioMMIndexParser.h.

int CRioMMIndexParser::integer_value [static, private]

Definition at line 85 of file RioMMIndexParser.h.

int CRioMMIndexParser::line_number [static, private]

Definition at line 77 of file RioMMIndexParser.h.

bool CRioMMIndexParser::quit_on_errors [static, private]

Definition at line 90 of file RioMMIndexParser.h.

const char * CRioMMIndexParser::token_name [static, private]

Initial value:

{
    "an invalid token",
    "the end of the file",

    "an integer",
    "a string",

    "'{'",
    "'}'",

    "'['",
    "']'",

    "'('",
    "')'",

    "','",
    "';'",

    "'Version'",
    "'Archive'",
    "'File'",
    "'Slide'",
    "'OpenURL'",
    "a command"
}

Definition at line 70 of file RioMMIndexParser.h.

int CRioMMIndexParser::token_offset [static, private]

Definition at line 82 of file RioMMIndexParser.h.

char CRioMMIndexParser::token_string [static, private]

Definition at line 81 of file RioMMIndexParser.h.

CRioMMIndexParser::TokenType CRioMMIndexParser::token_type [static, private]

Definition at line 80 of file RioMMIndexParser.h.

---

The documentation for this class was generated from the following files:

• RioMMIndexParser.h
• RioMMIndexParser.cpp