cparser.h

Go to the documentation of this file.

/*! \file wx/docview/cparser.h
    \brief simple parser for keyword like commands.

    The parser a2dCommandParser is for a line of words in a Tcl like fashion. A line can be multiple
    text lines by placing \ at the end of a text line. This makes this parser suitable for placing 
    big polygons having many points in one command line.
    This parser is used by a2dCsPlWrapper
    to function as a command wrapper for  a a2dDocumentCommandProcessor. In the a2dIOHandlerKeyIn 
    loader for the KEY format it is used too.
    Along with this come some clases to read from files a2dFileLineParser 
    or to evaluate a command line a2dEvalCommandString.

    \author Klaas Holwerda
    \date Created 16/09/03

    Copyright: 2000-2004 (c) Klaas Holwerda

    Licence: wxWidgets licence

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

#ifndef _WXCPARSER_H
#define _WXCPARSER_H

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include "wx/defs.h"
#include <ctype.h>

#include <stdio.h>
#include <stdlib.h>

#include <wx/stream.h>
#include <wx/mstream.h>
#include <wx/wfstream.h>
#include <wx/string.h>

#include "wx/general/gen.h"
#include "wx/docview/doccom.h"
#include "wx/docview/docviewref.h"
#include "wx/xmlparse/genxmlpars.h"

//! Command parser error
/*!
*/
class A2DDOCVIEWDLLEXP a2dCommand_Error
{

public:
    a2dCommand_Error( const wxString& message = wxT(""), const wxString& header = wxT("") );
    a2dCommand_Error( const a2dCommand_Error& a );

    wxString& GetMessage() { return m_message; }
    wxString& GetHeader(){ return m_header; }

protected:
    wxString m_message;
    wxString m_header;

};

//!base class used to parse command
/*! strings according to the BNF below.

    This parser, parses a string that can contain linefeeds/return (\n).
    So the commands can spread over multiple line in files.
    Commands are seperated by [;] or [\n] or [\0].
    But the last two only if it is really the end of the command, and not in 
    one of the word parts that may contain these characters also.
    The characters between ["] ["] may contain alias and variable references,
    while in between [{] [}] will result in exactly what is literal there, also when 
    there are [$] or [%].

    examples: 
    
      -# %{variable1}${variable2}default/config/
      -# {1.0 um} 
      -# {<none specified>} 
      -# {   TEXT; LAYER 0; \
             TEXTTYPE 0; PRESENTATION 0,2,1; STRANS 0,0,0; MAG 400; \
                XY 1; \
                X   10000.000; Y  32900.000; \
             STRING "correction factor: %aap um"; \
             ENDEL;} 
      -#  #some comment \
 
      -#  {Save GDS-II file} SAVE {GDSII file (*.cal)|*.cal| GDS \
          file (*.db)|*.db|ALL (*.*)|*.*} %{file_path} %{file_ext} curfile


    \sa a2dEvalCommandString
    \sa a2dFileLineParser

\verbatim

Below you can see the Bachus Naur representation of the parser:

<commands>      ::= [<blanks>] { <command> }* 

<command>       ::= [<blanks>] {<comment> | {<word> {<blanks> | <endcommand}}* }*

<endcommand>    ::= {';' | '\n' | '\0' }

<word>          ::= { <integer> | <real> | <quotedstring> | <bracedstring> | <multipartword> }

<quotedstring>  ::= ('"') {CHAR | '\"' | '\\n' | aliasref | envref }* ('"')

<bracedstring>  ::= ('{') {CHAR | '\{' | '\}' | '\\n'}* ('}')

<multipartword> ::= { <aliasref> | <envref> | {CHAR | '\\n'}* }*

<aliasref>      ::= ('%') { <name> <blank> | ('{') <name> ('}') }

<envref>        ::= ('$') { <name> <blank> | ('{') <name> ('}') }

<name>          ::= { LETTER | DIGIT | UNDERSCORE | MINUS }*

<blanks>        ::= { TAB | SPACE | '\\n'}*

<comment>       ::= # {CHAR}* ('\0')

note:
    [ ] entity CAN occur zero or more times
    ( ) entity MUST occur
    { } pick one of the entities within the braces
    { }*    entities within the braces CAN occur zero ore more times
    { }+    entities within the braces MUST occur one ore more times
     |      OR
\endverbatim
*/
class A2DDOCVIEWDLLEXP a2dCommandParser
{
public:

    a2dCommandParser();

    virtual ~a2dCommandParser();

    //!read one command from the buffer
    bool GetCommand();

    //!flush command buffer
    bool FlushArg();

    //!get the error message if parsing went wrong
    wxString GetErrorMes();

    wxUint32 GetLineNumber() { return m_linenumber; }
    
    //!get environment variable
    bool GetEnv(const wxString& envname, wxString& envstring);

    //!list of command arguments found
    a2dVariablesArray& GetArgumentList() { return m_argumentlist; }

    //! return the item at positions i
    /*!
        If called beyond the number of items available, an empty string is returned.
    */
    wxString GetItem( int i);

    //! return the property at positions i
    /*!
        If called beyond the number of items available, NULL is returned.
    */
    a2dNamedProperty* GetProperty( int i);

    //! return the total number of parsed items
    int GetCount() { return m_argumentlist.GetCount(); }

    //! return the next property as string. 
    /*!
        After a FlushArg(), every call to GetNextItem() returns the next item in the parsed command.
        If called beyond the number of items available, an empty string is returned.
    */
    wxString GetNextItem();

    //! return a pointer to the next property in the list
    a2dNamedProperty* GetNextProp(); 

    //! get the next property as bool
    bool GetNextItemBool();

    //! get the next property as int
    int GetNextItemInt();

    //! get the next property as double
    double GetNextItemDouble();

    //! return if the internal iterates on items has reached the end.
    /*!
        To next if more calls to GetNextItem() will return a real item.   
    */
    bool HasMoreItems() { return m_item < m_argumentlist.GetCount(); }

    //!get the parses command
    wxString GetCommandParsed();

protected:

    bool Blanks();
    bool Word();
    bool Number( const wxString& number );
    bool MultiPartWord();
    bool QuotedString();
    bool BracedString();
    bool Comment();
    bool VarRef( wxChar type);
    bool Name();

    //to make derived classes work
    virtual wxChar PeekNextC()=0;
    virtual void IncC()=0;

    wxChar a;
    a2dVariablesHash m_aliaslist;

    a2dVariablesArray m_argumentlist;

    wxString m_commandsofar;

    wxString m_error_mes;
    wxString m_b;
    wxString m_varref;

    int m_item;

    //!last read line in DATA
    wxUint32 m_linenumber;
};


//!used to parse command strings and evaluate the aliases in it.
/*!
    At the same time the parameters are stores into a list
    \see a2dCommandParser
*/
class A2DDOCVIEWDLLEXP a2dEvalCommandString : public a2dCommandParser, public wxMemoryInputStream
{

public:

    a2dEvalCommandString( const wxString& commandString, a2dVariablesHash& aliaslist );

    ~a2dEvalCommandString();

    bool ParseNextCommand();

    const wxString& GetEvaluatedString() const { return m_evaluated; }

    void Reset(); 

    void ResetEvaluatedString();

protected:

    void IncC();
    wxChar PeekNextC();

private:

    int m_linenumber;
    const wxChar* m_commands;
    const wxChar* m_c;

    wxString m_evaluated;
};

//!used to parse command strings comming from files
/*!
*/
class A2DDOCVIEWDLLEXP a2dFileLineParser : public a2dCommandParser , public wxFileInputStream
{
public:

    //! constructor
    a2dFileLineParser( const wxString& the_file, a2dVariablesHash& aliaslist );

    //! destructor
    ~a2dFileLineParser();

    //!read a command, if not the required one, it is stored
    bool ReadItem( const wxString& type );

    //!current line number
    int GetLineNumber() { return m_linenumber; }

    //!get opened file
    wxString& GetFileName(){return m_line_file;}

    //!start from beginning of the file
    void Reset();

    //!parse the next command
    bool ParseNextCommand();

    wxString& LastReadCommand() { return m_keyword; }

protected:
    //!reading characters from the file
    void IncC();

    //!peek at next character
    wxChar PeekNextC();

    //!current line number
    int m_linenumber;

    //! holds the filename from the layer file
    wxString m_line_file;

    //!last read command
    wxString m_keyword;

    //!is the last command stored
    bool m_back;
};


#endif

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