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 (C) 2007-2024 Kicad Developers, see change_log.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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#ifndef DSNLEXER_H_
#define DSNLEXER_H_
 
#include <kicommon.h>
#include <cstdio>
#include <hashtables.h>
#include <string>
#include <vector>
 
#include <richio.h>
 
#ifndef SWIG
struct KICOMMON_API KEYWORD
{
 const char* name; 
 int token; 
};
#endif // SWIG
 
// 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 = -11,
 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;
 }
 
 bool SetCommentsAreTokens( bool val )
 {
 bool old = commentsAreTokens;
 commentsAreTokens = val;
 return old;
 }
 
 wxArrayString* ReadCommentLines();
 
 static bool IsSymbol( 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();
 
 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;
 }
 
 wxString FromUTF8() const
 {
 return wxString::FromUTF8( curText.c_str() );
 }
 
 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;
 }
 
#ifndef SWIG
 
protected:
 void init();
 
 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 ) );
 }
 
 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; 
 
 char stringDelimiter;
 bool space_in_quoted_tokens; 
 
 bool commentsAreTokens; 
 
 int prevTok; 
 int curOffset; 
 
 int curTok; 
 std::string curText; 
 
 const KEYWORD* keywords; 
 unsigned keywordCount; 
 const KEYWORD_MAP* keywordsLookup; 
#endif // SWIG
};
 
#endif // DSNLEXER_H_