dsnlexer.h

Go to the documentation of this file.

/*
 * This program source code file is part of KICAD, a free EDA CAD application.
 *
 * Copyright (C) 2007-2010 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef DSNLEXER_H_
#define DSNLEXER_H_
 
#include <kicommon.h>
#include <cstdio>
#include <hashtables.h>
#include <string>
#include <vector>
 
#include <richio.h>

struct KICOMMON_API KEYWORD
{
    const char* name;       
    int         token;      
};
 
// something like this macro can be used to help initialize a KEYWORD table.
// see SPECCTRA_DB::keywords[] as an example.
 
//#define TOKDEF(x)    { #x, T_##x }
 

enum DSN_SYNTAX_T
{
    DSN_NONE         = -12,
    DSN_BAR          = -11, // Also called pipe '|'
    DSN_COMMENT      = -10,
    DSN_STRING_QUOTE = -9,
    DSN_QUOTE_DEF    = -8,
    DSN_DASH         = -7,
    DSN_SYMBOL       = -6,
    DSN_NUMBER       = -5,
    DSN_RIGHT        = -4,  // right bracket, ')'
    DSN_LEFT         = -3,  // left bracket, '('
    DSN_STRING       = -2,  // a quoted string, stripped of the quotes
    DSN_EOF          = -1   // special case for end of file
};
 

class KICOMMON_API DSNLEXER
{
public:
    DSNLEXER( const KEYWORD* aKeywordTable, unsigned aKeywordCount, const KEYWORD_MAP* aKeywordMap,
              FILE* aFile, const wxString& aFileName );

    DSNLEXER( const KEYWORD* aKeywordTable, unsigned aKeywordCount, const KEYWORD_MAP* aKeywordMap,
              const std::string& aSExpression, const wxString& aSource = wxEmptyString );

    DSNLEXER( const std::string& aSExpression, const wxString& aSource = wxEmptyString );

    DSNLEXER( const KEYWORD* aKeywordTable, unsigned aKeywordCount, const KEYWORD_MAP* aKeywordMap,
              LINE_READER* aLineReader = nullptr );
 
    virtual ~DSNLEXER();

    void InitParserState();

    bool SyncLineReaderWith( DSNLEXER& aLexer );

    void SetSpecctraMode( bool aMode );

    void PushReader( LINE_READER* aLineReader );

    LINE_READER* PopReader();

    int NextTok();

    int NeedSYMBOL();

    int NeedSYMBOLorNUMBER();

    int NeedNUMBER( const char* aExpectation );

    int CurTok() const
    {
        return curTok;
    }

    int PrevTok() const
    {
        return prevTok;
    }

    int GetCurStrAsToken() const
    {
        return findToken( curText );
    }

    char SetStringDelimiter( char aStringDelimiter )
    {
        char old = stringDelimiter;
 
        if( specctraMode )
            stringDelimiter = aStringDelimiter;
 
        return old;
    }

    bool SetSpaceInQuotedTokens( bool val )
    {
        bool old = space_in_quoted_tokens;
 
        if( specctraMode )
            space_in_quoted_tokens = val;
 
        return old;
    }
 
    void SetKnowsBar( bool knowsBar = true )
    {
        // This is used to control whether the lexer knows about the DSN_BAR token.
        // If it does not, then it will not return a DSN_BAR token, but rather
        // treat it as a string.
        // This is used to support the KiCad legacy format, which does not have a DSN_BAR
        m_knowsBar = knowsBar;
    }

    bool SetCommentsAreTokens( bool val )
    {
        bool old = commentsAreTokens;
        commentsAreTokens = val;
        return old;
    }

    wxArrayString* ReadCommentLines();

    static bool IsSymbol( int aTok );
 
    static bool IsNumber( int aTok );

    void Expecting( int aTok ) const;

    void Expecting( const char* aTokenList ) const;

    void Unexpected( int aTok ) const;

    void Unexpected( const char* aToken ) const;

    void Duplicate( int aTok );

    void NeedLEFT();

    void NeedRIGHT();

    void NeedBAR();

    const char* GetTokenText( int aTok ) const;

    wxString GetTokenString( int aTok ) const;
 
    static const char* Syntax( int aTok );

    const char* CurText() const
    {
        return curText.c_str();
    }

    const std::string& CurStr() const
    {
        return curText;
    }
 
    const std::string& CurSeparator() const
    {
        return curSeparator;
    }

    wxString FromUTF8() const
    {
        return wxString::FromUTF8( curText );
    }

    int CurLineNumber() const
    {
        return reader->LineNumber();
    }

    const char* CurLine() const
    {
        return (const char*)(*reader);
    }

    const wxString& CurSource() const
    {
        return reader->GetSource();
    }

    int CurOffset() const
    {
        return curOffset + 1;
    }
 
protected:
    void init();
 
    inline bool isSep( char cc );
 
    int readLine()
    {
        if( reader )
        {
            reader->ReadLine();
 
            unsigned len = reader->Length();
 
            // start may have changed in ReadLine(), which can resize and
            // relocate reader's line buffer.
            start = reader->Line();
 
            next  = start;
            limit = next + len;
 
            return len;
        }
        return 0;
    }

    int findToken( const std::string& aToken ) const;
 
    bool isStringTerminator( char cc ) const
    {
        if( !space_in_quoted_tokens && cc == ' ' )
            return true;
 
        if( cc == stringDelimiter )
            return true;
 
        return false;
    }

    double parseDouble();
 
    double parseDouble( const char* aExpected )
    {
        NeedNUMBER( aExpected );
        return parseDouble();
    }
 
    template <typename T>
    inline double parseDouble( T aToken )
    {
        return parseDouble( GetTokenText( aToken ) );
    }
 
protected:
    bool                iOwnReaders;            
    const char*         start;
    const char*         next;
    const char*         limit;
    char                dummy[1];               
 
    typedef std::vector<LINE_READER*>  READER_STACK;
 
    READER_STACK        readerStack;            

    LINE_READER*        reader;
 
    bool                specctraMode;           
    bool                m_knowsBar;             
 
    char                stringDelimiter;
    bool                space_in_quoted_tokens; 
 
    bool                commentsAreTokens;      
 
    int                 prevTok;                
    int                 curOffset;              
 
    int                 curTok;                 
    std::string         curText;                
    std::string         curSeparator;           
 
    const KEYWORD*      keywords;               
    unsigned            keywordCount;           
    const KEYWORD_MAP*  keywordsLookup;         
};
 
#endif  // DSNLEXER_H_