cparser.cpp

Go to the documentation of this file.

/*! \file docview/src/cparser.cpp
    \brief Docview classes General command parser, See header
    \author Klaas Holwerda
    \date Created 16/09/03

    Copyright: (c)

    Licence: wxWidgets licence

    RCS-ID: $Id: cparser.cpp,v 1.64 2008/07/19 18:29:46 titato Exp $
*/

#include "docviewprec.h"

#include "wx/docview/cparser.h"

// ----------------------------------------------------------------------------
// template instantiations
// ----------------------------------------------------------------------------

//#include "wx/general/id.inl"

//----------------------------------------------------------------------------
// template instanitiations
//----------------------------------------------------------------------------


a2dCommand_Error::a2dCommand_Error( const wxString& message, const wxString& header )
{
    m_message = message;
    m_header = header;
}

a2dCommand_Error::a2dCommand_Error(const a2dCommand_Error& a)
{
    m_message = a.m_message;
    m_header = a.m_header;
}

#define LINELENGTH 200
// constructor
a2dCommandParser::a2dCommandParser()
{
    m_error_mes.Clear();
    m_error_mes.Alloc(LINELENGTH);
    m_commandsofar.Clear();
    m_commandsofar.Alloc(LINELENGTH);
    m_b.Clear();
    m_b.Alloc(LINELENGTH);
    m_varref.Clear();
    m_varref.Alloc(LINELENGTH);
    FlushArg();
    m_linenumber=0;
}

a2dCommandParser::~a2dCommandParser()
{
    FlushArg();
}

wxString a2dCommandParser::GetCommandParsed()
{
    return m_commandsofar;
}

bool a2dCommandParser::FlushArg()
{
    m_commandsofar.Empty();
    m_argumentlist.DeleteAll();
    m_item = 0;

    return true;
}

wxString a2dCommandParser::GetItem( int i) 
{
    static wxString non = wxT("");
    if ( i < m_argumentlist.GetCount() )
        return m_argumentlist.GetVariableAsString(i); 
    return non;
}

a2dNamedProperty* a2dCommandParser::GetProperty( int i)
{
    return const_cast<a2dNamedProperty*>( &(m_argumentlist.GetVariable(i)) ); 
}

wxString a2dCommandParser::GetNextItem() 
{ 
    static wxString non = wxT("");
    if ( m_item < m_argumentlist.GetCount() )
        return m_argumentlist.GetVariableAsString( m_item++ );
    m_item++;
    return non;
}

a2dNamedProperty* a2dCommandParser::GetNextProp() 
{ 
    if ( m_item < m_argumentlist.GetCount() )
        return const_cast<a2dNamedProperty*>( &(m_argumentlist.GetVariable( m_item++ )) );
    m_item++;
    return NULL;
}

bool a2dCommandParser::GetNextItemBool()
{
    if ( GetNextItem().IsSameAs( wxT("true"), false) )
        return true;

    return false;
}

int a2dCommandParser::GetNextItemInt()
{
    a2dNamedProperty* prop = GetNextProp();
    if ( prop )
    {
        if ( wxDynamicCast( prop, a2dInt32Property ) == 0 )
        {
            a2dGeneralGlobals->ReportErrorF( a2dError_CommandError, _("Not derived from a2dInt32Property") );
            return 0;
        }
        return wxStaticCast( prop, a2dInt32Property )->GetValue();
    }
    return 0;
}

double a2dCommandParser::GetNextItemDouble()
{
    a2dNamedProperty* prop = GetNextProp();
    if ( prop )
    {
        if ( wxDynamicCast( prop, a2dDoubleProperty ) == 0 )
        {
            a2dGeneralGlobals->ReportErrorF( a2dError_CommandError, _("Not derived from a2dDoubleProperty") );
            return 0;
        }
        return wxStaticCast( prop, a2dDoubleProperty)->GetValue();
    }
    return 0;
}

bool a2dCommandParser::GetCommand()
{
    m_error_mes.Empty();
    m_commandsofar.Empty();

    if (!m_linenumber)  //the very first lien will be parsed
        m_linenumber++;

    IncC(); //get the first character;
    while(a == wxT('\n') ) //skip empty command
    {
        m_commandsofar.Empty();
        IncC();
        m_linenumber++;
    }

    Blanks();

    if (a == wxT('\0') ) //end of file no error will be set
        return false;

    else if (a == wxT('#') )    
    {
        Comment();      //it is comment
        if ( a == wxT('\0') || a == wxT('\n')  )
            m_linenumber++;
    }
    else
    {
        while (Word())      //is there a command (being several words)
        {
            bool found = Blanks();
            if ( !found && !( a == wxT('\0') || a == wxT('\n') || a == wxT(';')) ) //whitespace needed
            {
                m_error_mes = wxT(" whitespace expected or end command missing");
                return false;
            }
            if( a == wxT('\0') || a == wxT('\n') || a == wxT(';') ) //end of m_command ?
                break;
        }

        if ( m_error_mes.Len() )
             return false;

        // <endcommand>   ::= '\0' | ';'
        if( a != wxT('\0') && a != wxT('\n') && a != wxT(';') ) //not at end of m_command
        {
            m_error_mes = wxT("; or EOL expected");
            return false;
        }
        if ( a == wxT('\0') || a == wxT('\n')  )
            m_linenumber++;
    }
    //if last character is \n skip it here
    if  (a == wxT('\n') )
        m_commandsofar.RemoveLast();
    return true;
}

// <word> ::=  { <integer> | <real> | <quotedstring> | <bracedstring> | <multipartword> }
bool a2dCommandParser::Word()
{
    Blanks();
    m_b.Empty();

    if (a == wxT('"') )
    {
        if (!QuotedString())
            return false;
        if (!m_b.IsEmpty())
        {
            m_argumentlist.AppendVariableString( m_b );
        }
    }
    else if (a == wxT('{') )
    {
        if (!BracedString())
            return false;
        if (!m_b.IsEmpty())
        {
            m_argumentlist.AppendVariableString( m_b );
        }
    }
    else
    {
        if ( !MultiPartWord())
            return false;

        if ( !m_b.IsEmpty() && !Number( m_b ) )
        {
            m_argumentlist.AppendVariableString( m_b );
        }
    }

    return true;
}

bool a2dCommandParser::Number( const wxString& number )
{
    wxString numstr;
    bool integer = true;
    
    const wxChar* a = number.GetData();
 
    if ( !( isdigit(*a) || *a == wxT('+') || *a == wxT('-') ) )
        return false;   // not a number

    numstr += *a;
    a++;

    while( isdigit(*a) )
    {
        numstr += *a;
        a++;
    }

    if( *a == wxT('.') || *a == wxT('e') )
    {
        integer = false;
        numstr += *a;
        a++;
        if ( !( isdigit(*a) || *a == wxT('+') || *a == wxT('-') ) )
        {
            return false;   // invalid number
        }
        numstr += *a;
        a++;

        while( isdigit(*a) )
        {
            numstr += *a;
            a++;
        }

        // -.5E-01 OR .74E01 etc.
        if ( *a == wxT('e') || *a == wxT('E')  )
        {
            numstr += *a;
            a++;
            if ( !( isdigit(*a) || *a == wxT('+') || *a == wxT('-') ) )
            {
                return false;   // invalid number
            }
            numstr += *a;
            a++;
            while( isdigit(*a) )
            {
                numstr += *a;
                a++;
            }
        }
    }

    if( *a != wxT(' ') && *a != wxT('\0') )
        return false;

    if ( integer )
    {
        long aint;
        numstr.ToLong( &aint , 10 ); 

        m_argumentlist.AppendVariableInt( aint );
    }
    else
    {
        double real;
        numstr.ToDouble( &real );

        wxString argname;
        argname.Printf( wxT("%d"), m_argumentlist.GetCount() );
        m_argumentlist.AppendVariableDouble( real );
    }

    return true;    // number is validated
}

//<multipartword>   ::=  { <aliasref> | <envref> | {CHAR}* }*
bool a2dCommandParser::MultiPartWord()
{
    while( a != wxT(' ') && a != wxT('\t') && a != wxT('\0') && a != wxT('\n') && a != wxT(';') )
    {
        if (a == wxT('\\') ) //take the next character
        {   IncC();
            if ( a == wxT('\n') )
                IncC(); //treat it as if it was a space

            if ( a == wxT(' ') || a == wxT('\t') || a == wxT('\0') || a == wxT(';') )
                break; //treat it as word seperator

            //all other backslash character take them
            m_b += a;
            IncC();
            continue;
        }

        if ( (a == wxT('$') ) || ( a == wxT('%') ))
        {
             if (!VarRef(a))
                return false;
             continue;
        }

        //all other characters
        m_b += a;
        IncC();
    }
    return true;
}


//  <comment>       ::= # {CHAR}*
bool a2dCommandParser::Comment()
{
    if( a != wxT('#') ) //quote must be there
    {
        m_error_mes = wxT("wrong comment");
        return false;
    }
    m_b.Empty();

    m_b += a;
    IncC();

    while( a!= wxT('\0') )
    {
        if (a== wxT('\\') )
        {
            IncC();
            if (a == wxT('\n') )
            {
                m_b += wxT(' ');
                IncC();
                continue;
            }
        } 
        if (a == wxT('\n') )
             break; //end of comment

        m_b += a;
        IncC();
    }

    m_argumentlist.AppendVariableString( m_b );
    return true;
}


// strips all the spaces and tabs from the left of the string
//  <blanks>            ::= { TAB | SPACE }*
bool a2dCommandParser::Blanks()
{
    int i=0;
    // delete blanks at the beginning
    while ( a == wxT(' ') || a == wxT('\t') || a == wxT('\\') || a ==0xd  )
    {  
        if ( a == wxT('\\') )
        {
          if (PeekNextC()!= wxT('\n') )
              break;
          else
              IncC(); i++;
        }
        IncC(); i++;
    }

    return (i != 0);
}


wxString    a2dCommandParser::GetErrorMes()
{
    return m_error_mes;
}

//  <name>          ::= { LETTER | DIGIT | UNDERSCORE | MINUS }*
// Check Name specification
bool a2dCommandParser::Name()
{
    m_varref.Empty();
    if ( !( isalnum(a) || a == wxT('_') ||  a == wxT('-') ) )
    {
        m_error_mes = wxT("wrong name");
        return false;   // invalid name (begin char)
    }
    m_varref += a;
    IncC();
    while( isalnum(a) || a == wxT('_') )
    {
        m_varref+=a;
        IncC();
    }
    return true;    // name is validated
}


// Get Alias value
// <aliasref>           ::= ('%') { <name> <blank> | ('{') <name> ('}') }
// Get Environment string
//  <envstring>     ::= ('$') { <name> <blank> | ('{') <name> ('}') }
bool a2dCommandParser::VarRef( wxChar type)
{
    if( a != type ) // '$' or '%' must be there
    {
        m_error_mes = wxT("wrong environment $ or % missing");
        return false;
    }

    IncC();
    if( a == wxT('{') ) // brace could be there
    {
        IncC();
        if( !Name() )
            return false; // error, wrong alias name
        if( a != '}' ) // brace must be there
        {
            m_error_mes = wxT("wrong environment name, end brace missing");
            return false; // error, wrong alias, endbrace missing or wrong name
        }
        IncC();
    }
    else
    {
        if( !Name() )
            return false; // error, wrong alias name
    }

    wxString evaluated;
    if (type == wxT('$') )
    {
        if( !GetEnv(m_varref, evaluated) )
        {
            m_error_mes = wxT("wrong environment Variable, environment does not exist");
            return false;// error, alias does not exist
        }
    }
    else
    {
        const a2dNamedProperty *prop = m_aliaslist.GetVariable( m_varref );
        if( !prop )
        {
            m_error_mes = wxT("wrong Variable name, Variable does not exist");
            return false;// error, alias does not exist
        }

        evaluated = prop->StringValueRepresentation();
    }

    m_b += evaluated;
    return true;
}

//<quotedstring>        ::= ('"') {CHAR | '\"' | '\\n' | aliasref | envref }* ('"')
bool a2dCommandParser::QuotedString()
{
    if( a != wxT('"') ) //quote must be there
    {
        m_error_mes = wxT("wrong quotedstring, begin quote missing");
        return false;
    }
    IncC();

    while( a != wxT('"') && a != wxT('\0') )
    {
        if (a == wxT('\\') ) //take the next character
        {   IncC();
            if (a == wxT('\0') )
            break; //error handled later

            m_b+=a;
            IncC();
            continue;
        }

        if ( (a == wxT('$')) || (a == wxT('%')))
        {
            if (!VarRef(a))
                return false;
            continue;
        }

        //all other characters
        m_b += a;
        IncC();
    }

    if( a != wxT('"') ) //quote must be there
    {
        m_error_mes = wxT("wrong quotedstring, end quote missing");
        return false;
    }
    IncC();

    return true;
}


//<bracedstring>        ::= ('{') {CHAR | '\{' | '\}' | '\\n'}* ('}')
bool a2dCommandParser::BracedString()
{
    if( a != wxT('{') ) //quote must be there
    {
        m_error_mes = wxT("wrong bracedstring, begin brace missing");
        return false;
    }

    IncC();

    int brnr=0;
    while( (a != wxT('}') || brnr) && a != wxT('\0') )
    {
        if (a == '\\') //take the next character
        {   IncC();
            if (a == wxT('\0') )
                break; //error handled later

            m_b += a;
            IncC();
            continue;
        }

        //nested braces are allowed
        if (a == wxT('{') ) //nested brace
            brnr++;

        if (a == wxT('}') ) //nested brace
            brnr--;

        //all other characters
        m_b += a;
        IncC();
    }

    if( a != wxT('}') ) //quote must be there
    {
        m_error_mes = wxT("wrong bracedstring, end brace missing");
        return false;
    }
    IncC();

    return true;
}

// Set of Get functions for handling Environment Variables
bool a2dCommandParser::GetEnv(const wxString& envname, wxString& envstring)
{
    if (envname.Len()==0)
        return false;   // A name is needed

    if( !wxGetEnv( envname, &envstring ) )
        return false;   // Environment name not found

    return true;
}

a2dEvalCommandString::a2dEvalCommandString( const wxString& commandString, a2dVariablesHash& aliaslist)
    : wxMemoryInputStream( commandString.c_str(), commandString.Len() )
{
    m_aliaslist = aliaslist;
    m_linenumber=0;
    m_commands = commandString.c_str();
    m_c=0;
    a = wxT(' ');
}

// frees all the dynamic data
a2dEvalCommandString::~a2dEvalCommandString()
{
}

void a2dEvalCommandString::IncC()
{
    if (m_c == 0) //get first character from buffer
    {
        m_linenumber++;
        m_c = m_commands;
    }
    else
    {    
        if (*m_c != wxT('\0') )
            m_c++;
    }
    a = *m_c;
}

wxChar a2dEvalCommandString::PeekNextC()
{
    wxChar p = wxT('\0');
    if (m_c == 0) //get first character from buffer
        p = *m_commands;
    else
    {   
        if (*m_c != wxT('\0') )
        {
            m_c++;
            p =* m_c--;
        }
    }
    return p;
}

void a2dEvalCommandString::Reset()
{
    FlushArg();
    m_c = 0;
    SeekI(0);

    m_evaluated.Clear();
}

void a2dEvalCommandString::ResetEvaluatedString()
{
    m_evaluated.Clear();
}

bool a2dEvalCommandString::ParseNextCommand()
{
    FlushArg();
    try
    {
        if( !GetCommand() )
        {
            if ( GetErrorMes().Len() )
            {
               wxString buffer;
               buffer.Printf( _T("Could not Parse line %d: \n %s \n Error: %s"),
                     m_linenumber, m_commands, GetErrorMes().c_str() );

               throw a2dCommand_Error( buffer, wxT("Command Parsing Error") );
            }
        }

        //copy it to the string as words seperated by spaced
        int i;
        for ( i = 0; i < m_argumentlist.GetCount(); i++ )
        {
            if ( i == 0 )
                m_evaluated += m_argumentlist.GetVariableAsString( i );
            else
                m_evaluated += wxT(" ") + m_argumentlist.GetVariableAsString( i );
        }
    }
    catch (a2dCommand_Error& error) // error from the parser: process here
    {
        m_error_mes = error.GetMessage();
        return false;
    }

    return true;
}



// contructor
a2dFileLineParser::a2dFileLineParser( const wxString& the_file, a2dVariablesHash& aliaslist )
    : wxFileInputStream( the_file )
{

    m_line_file = the_file;
    m_aliaslist = aliaslist;

    // if opening fails throw an error class
    if (!Ok())
    {
        wxString errbuf;
        errbuf.Printf( _T("Cannot open file %s!"), m_line_file.c_str() );
        throw a2dCommand_Error( errbuf, wxT("Parser: File Error") );
    }

    m_linenumber=0;
    m_keyword = wxT("");
    m_back = false;
    a = wxT(' ');
}

// destructor
a2dFileLineParser::~a2dFileLineParser()
{
}

// reset
void a2dFileLineParser::Reset()
{
    m_file->Seek(0);
    m_linenumber=0;
    m_keyword = wxT("");
    m_back=false;
    a = wxT(' ');
    m_commandsofar.Clear();
}

void a2dFileLineParser::IncC()
{
    a = (char) GetC();
    if (Eof())
        a = wxT('\0');
    if (a == wxChar(EOF) )
        a = wxT('\0');
    if (a == wxT('\r') )
        a = wxT(' ');

    m_commandsofar+=a;
}

wxChar a2dFileLineParser::PeekNextC()
{
    wxChar p = (wxChar) Peek();
    return p;
}


// ReadItem (parser) --------------------------------------------------------
bool a2dFileLineParser::ReadItem( const wxString& type )
{
//  <item>      ::= KEYWORD VALUE
    if (m_back)
    {
        if (! m_keyword.CmpNoCase(type))
            m_back = false;
        else
            m_back = true;
        return bool(!m_back);
    }

    bool Next=true;
    do
    {
        FlushArg();
        if( !GetCommand() )
        {
            if ( !GetErrorMes().IsEmpty() )
            {
                m_commandsofar.Printf(_T("Could not Parse line %d: \n Error: %s"),
                m_linenumber, GetErrorMes().c_str() );

                throw a2dCommand_Error( m_commandsofar, wxT("Command Parsing Error") );
            }
            return false;
        }
        if ( !m_argumentlist.GetCount() )
            Next=true;
        else if ( m_argumentlist.GetVariableAsString( 0 ).GetChar( 0 ) == wxT('#') ) //it is comment read next are empty line
            Next=true;
        else
            Next=false;
   }
   while (Next);

   m_linenumber++;
   m_keyword = m_argumentlist.GetVariableAsString( 0 );

   if ( !m_keyword.CmpNoCase( type ) )
      m_back = false;
   else
      m_back = true;
   return bool(!m_back);
}

bool a2dFileLineParser::ParseNextCommand()
{
    FlushArg();
    if( !GetCommand() )
    {
        if ( !GetErrorMes().IsEmpty() )
        {
            m_commandsofar.Printf( _T("Could not Parse line %d: \n Error: %s"),
            m_linenumber, GetErrorMes().c_str() );
            throw a2dCommand_Error( m_commandsofar, wxT("Command Parsing Error") );
        }
        return false;
    }
    return true;
}

cparser.cpp Source File -- Tue Aug 31 17:56:25 2010 -- 31 Aug 2010 -- 1.5.5 -- wxArt2D -- . -- Reference Documentation