The attached patch:
(a) changes to sexpr code format to comply with KiCad style rules
(b) changes 'enum' to 'enum class' in sexpr code for more rigorous
compiler checking
- Cirilo
From ebb6ad6aae0ec0628d988f3e7dc2f8606521b033 Mon Sep 17 00:00:00 2001
From: Cirilo Bernardo <cirilo.berna...@gmail.com>
Date: Thu, 2 Feb 2017 11:20:36 +1100
Subject: [PATCH 1/2] Changed sexpr code formatting to comply with KiCad style
---
utils/kicad2step/sexpr/isexprable.h | 3 +-
utils/kicad2step/sexpr/sexpr.cpp | 266 ++++++++---------
utils/kicad2step/sexpr/sexpr.h | 475 +++++++++++++++++--------------
utils/kicad2step/sexpr/sexpr_exception.h | 5 +-
utils/kicad2step/sexpr/sexpr_parser.cpp | 110 ++++---
utils/kicad2step/sexpr/sexpr_parser.h | 10 +-
6 files changed, 464 insertions(+), 405 deletions(-)
diff --git a/utils/kicad2step/sexpr/isexprable.h b/utils/kicad2step/sexpr/isexprable.h
index a31591b1e..e448c169a 100644
--- a/utils/kicad2step/sexpr/isexprable.h
+++ b/utils/kicad2step/sexpr/isexprable.h
@@ -1,6 +1,5 @@
/*
* Copyright (C) 2016 Mark Roszko <mark.ros...@gmail.com>
- * Copyright (C) 2016 QiEDA Developers
*
* 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
@@ -31,7 +30,7 @@ namespace SEXPR
public:
virtual ~ISEXPRABLE() {}
virtual SEXPR* SerializeSEXPR() const { return nullptr; }
- virtual void DeserializeSEXPR(SEXPR& sexp) {}
+ virtual void DeserializeSEXPR( SEXPR& sexp ) {}
};
}
diff --git a/utils/kicad2step/sexpr/sexpr.cpp b/utils/kicad2step/sexpr/sexpr.cpp
index 2ae4b7b3f..a1c7f30cb 100644
--- a/utils/kicad2step/sexpr/sexpr.cpp
+++ b/utils/kicad2step/sexpr/sexpr.cpp
@@ -1,6 +1,5 @@
/*
* Copyright (C) 2016 Mark Roszko <mark.ros...@gmail.com>
- * Copyright (C) 2016 QiEDA Developers
*
* 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
@@ -25,94 +24,94 @@
namespace SEXPR
{
- SEXPR::SEXPR(SEXPR_TYPE type, size_t lineNumber) :
- m_type(type), m_lineNumber(lineNumber)
+ SEXPR::SEXPR( SEXPR_TYPE aType, size_t aLineNumber ) :
+ m_type( aType ), m_lineNumber( aLineNumber )
{
}
- SEXPR::SEXPR(SEXPR_TYPE type) :
- m_type(type), m_lineNumber(1)
+ SEXPR::SEXPR(SEXPR_TYPE aType) :
+ m_type( aType ), m_lineNumber( 1 )
{
}
SEXPR_VECTOR const * SEXPR::GetChildren() const
{
- if (m_type != SEXPR_TYPE_LIST)
+ if( m_type != SEXPR_TYPE_LIST )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a list type!");
}
- return &static_cast<SEXPR_LIST const *>(this)->m_children;
+ return &static_cast< SEXPR_LIST const * >(this)->m_children;
}
- SEXPR* SEXPR::GetChild(size_t idx) const
+ SEXPR* SEXPR::GetChild( size_t aIndex ) const
{
- if (m_type != SEXPR_TYPE_LIST)
+ if( m_type != SEXPR_TYPE_LIST )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a list type!");
}
- return static_cast<SEXPR_LIST const *>(this)->m_children[idx];
+ return static_cast< SEXPR_LIST const * >(this)->m_children[aIndex];
}
- void SEXPR::AddChild(SEXPR* child)
+ void SEXPR::AddChild( SEXPR* aChild )
{
- if (m_type != SEXPR_TYPE_LIST)
+ if( m_type != SEXPR_TYPE_LIST )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a list type!");
}
- SEXPR_LIST* list = static_cast<SEXPR_LIST *>(this);
+ SEXPR_LIST* list = static_cast< SEXPR_LIST * >( this );
- list->m_children.push_back(child);
+ list->m_children.push_back( aChild );
}
size_t SEXPR::GetNumberOfChildren() const
{
- if (m_type != SEXPR_TYPE_LIST)
+ if( m_type != SEXPR_TYPE_LIST )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a list type!");
}
- return static_cast<SEXPR_LIST const *>(this)->m_children.size();
+ return static_cast< SEXPR_LIST const * >(this)->m_children.size();
}
std::string const & SEXPR::GetString() const
{
- if (m_type != SEXPR_TYPE_ATOM_STRING)
+ if( m_type != SEXPR_TYPE_ATOM_STRING )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a string type!");
}
- return static_cast<SEXPR_STRING const *>(this)->m_value;
+ return static_cast< SEXPR_STRING const * >(this)->m_value;
}
int32_t SEXPR::GetInteger() const
{
- return static_cast<int>(GetLongInteger());
+ return static_cast< int >( GetLongInteger() );
}
int64_t SEXPR::GetLongInteger() const
{
- if (m_type != SEXPR_TYPE_ATOM_INTEGER)
+ if( m_type != SEXPR_TYPE_ATOM_INTEGER )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a integer type!");
}
- return static_cast<SEXPR_INTEGER const *>(this)->m_value;
+ return static_cast< SEXPR_INTEGER const * >(this)->m_value;
}
double SEXPR::GetDouble() const
{
// we may end up parsing "intended" floats/doubles as ints
// so here we allow silent casting back to doubles
- if (m_type == SEXPR_TYPE_ATOM_DOUBLE )
+ if( m_type == SEXPR_TYPE_ATOM_DOUBLE )
{
- return static_cast<SEXPR_DOUBLE const *>(this)->m_value;
+ return static_cast< SEXPR_DOUBLE const * >(this)->m_value;
}
else if( m_type == SEXPR_TYPE_ATOM_INTEGER )
{
- return static_cast<SEXPR_INTEGER const *>(this)->m_value;
+ return static_cast< SEXPR_INTEGER const * >(this)->m_value;
}
else
{
@@ -122,76 +121,78 @@ namespace SEXPR
float SEXPR::GetFloat() const
{
- return static_cast<float>(GetDouble());
+ return static_cast< float >( GetDouble() );
}
std::string const & SEXPR::GetSymbol() const
{
- if (m_type != SEXPR_TYPE_ATOM_SYMBOL)
+ if( m_type != SEXPR_TYPE_ATOM_SYMBOL )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a symbol type!");
}
- return static_cast<SEXPR_SYMBOL const *>(this)->m_value;
+ return static_cast< SEXPR_SYMBOL const * >(this)->m_value;
}
SEXPR_LIST* SEXPR::GetList()
{
- if (m_type != SEXPR_TYPE_LIST)
+ if( m_type != SEXPR_TYPE_LIST )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a list type!");
}
- return static_cast<SEXPR_LIST*>(this);
+ return static_cast< SEXPR_LIST* >(this);
}
- std::string SEXPR::AsString(size_t level)
+ std::string SEXPR::AsString( size_t aLevel )
{
std::string result;
- if (IsList())
+ if( IsList() )
{
- if (level != 0)
+ if( aLevel != 0 )
{
result = "\n";
}
- result.append(level * 4, ' ');
- level++;
+
+ result.append( aLevel* 4, ' ' );
+ aLevel++;
result += "(";
SEXPR_VECTOR const* list = GetChildren();
- for (std::vector<SEXPR *>::const_iterator it = list->begin(); it != list->end(); ++it)
+ for( std::vector<SEXPR *>::const_iterator it = list->begin(); it != list->end(); ++it )
{
- result += (*it)->AsString(level);
- if (it != list->end()-1)
+ result += (*it)->AsString( aLevel );
+
+ if( it != list->end() - 1 )
{
result += " ";
}
}
result += ")";
- level--;
+ aLevel--;
}
- else if (IsString())
+ else if( IsString() )
{
result += "\"" + GetString() + "\"";
}
- else if (IsSymbol())
+ else if( IsSymbol() )
{
result += GetSymbol();
}
- else if (IsInteger())
+ else if( IsInteger() )
{
std::stringstream out;
out << GetInteger();
result += out.str();
}
- else if (IsDouble())
+ else if( IsDouble() )
{
std::stringstream out;
- out << std::setprecision(16) << GetDouble();
+ out << std::setprecision( 16 ) << GetDouble();
result += out.str();
}
@@ -200,7 +201,7 @@ namespace SEXPR
SEXPR_LIST::~SEXPR_LIST()
{
- for (auto child : m_children)
+ for( auto child : m_children )
{
delete child;
}
@@ -208,109 +209,114 @@ namespace SEXPR
m_children.clear();
}
- SEXPR_LIST& operator<< (SEXPR_LIST& list, const ISEXPRABLE& obj)
+ SEXPR_LIST& operator<< ( SEXPR_LIST& list, const ISEXPRABLE& obj )
{
SEXPR* sobj = obj.SerializeSEXPR();
- list.AddChild(sobj);
+ list.AddChild( sobj );
return list;
}
- SEXPR_LIST& operator<< (SEXPR_LIST& list, int64_t value)
+ SEXPR_LIST& operator<< ( SEXPR_LIST& list, int64_t value )
{
- list.AddChild(new SEXPR_INTEGER(value));
+ list.AddChild( new SEXPR_INTEGER( value ) );
return list;
}
- SEXPR_LIST& operator<< (SEXPR_LIST& list, int32_t value)
+ SEXPR_LIST& operator<< ( SEXPR_LIST& list, int32_t value )
{
- list.AddChild(new SEXPR_INTEGER(value));
+ list.AddChild( new SEXPR_INTEGER( value ) );
return list;
}
- SEXPR_LIST& operator<< (SEXPR_LIST& list, float value)
+ SEXPR_LIST& operator<< ( SEXPR_LIST& list, float value )
{
- list.AddChild(new SEXPR_DOUBLE(value));
+ list.AddChild( new SEXPR_DOUBLE( value ) );
return list;
}
- SEXPR_LIST& operator<< (SEXPR_LIST& list, double value)
+ SEXPR_LIST& operator<< ( SEXPR_LIST& list, double value )
{
- list.AddChild(new SEXPR_DOUBLE(value));
+ list.AddChild( new SEXPR_DOUBLE( value ) );
return list;
}
- SEXPR_LIST& operator<< (SEXPR_LIST& list, std::string value)
+ SEXPR_LIST& operator<< ( SEXPR_LIST& list, std::string value )
{
- list.AddChild(new SEXPR_STRING(value));
+ list.AddChild( new SEXPR_STRING( value ) );
return list;
}
- SEXPR_LIST& operator<< (SEXPR_LIST& list, SEXPR* obj)
+ SEXPR_LIST& operator<< ( SEXPR_LIST& list, SEXPR* obj )
{
- list.AddChild(obj);
+ list.AddChild( obj );
return list;
}
- SEXPR_LIST& operator<< (SEXPR_LIST& list, const _OUT_STRING setting)
+ SEXPR_LIST& operator<< ( SEXPR_LIST& list, const _OUT_STRING setting )
{
SEXPR *res;
- if (setting._Symbol)
+
+ if( setting._Symbol )
{
- res = new SEXPR_SYMBOL(setting._String);
+ res = new SEXPR_SYMBOL( setting._String );
}
else
{
- res = new SEXPR_STRING(setting._String);
+ res = new SEXPR_STRING( setting._String );
}
- list.AddChild(res);
+
+ list.AddChild( res );
return list;
}
- SEXPR_LIST& operator>> (SEXPR_LIST& input, ISEXPRABLE& obj)
+ SEXPR_LIST& operator>> ( SEXPR_LIST& input, ISEXPRABLE& obj )
{
- obj.DeserializeSEXPR(input);
+ obj.DeserializeSEXPR( input );
return input;
}
- SEXPR_LIST& operator>> (SEXPR_LIST& input, int32_t& inte)
+ SEXPR_LIST& operator>> ( SEXPR_LIST& input, int32_t& inte )
{
- SEXPR* child = input.GetChild(input.m_inStreamChild);
- if (child->IsInteger())
+ SEXPR* child = input.GetChild( input.m_inStreamChild );
+
+ if( child->IsInteger() )
{
inte = child->GetInteger();
input.m_inStreamChild++;
}
else
{
- throw std::invalid_argument("SEXPR is not a integer type!");
+ throw std::invalid_argument( "SEXPR is not a integer type!" );
}
return input;
}
- SEXPR_LIST& operator>> (SEXPR_LIST& input, std::string& str)
+ SEXPR_LIST& operator>> ( SEXPR_LIST& input, std::string& str )
{
- SEXPR* child = input.GetChild(input.m_inStreamChild);
- if (child->IsString() || child->IsSymbol())
+ SEXPR* child = input.GetChild( input.m_inStreamChild );
+
+ if( child->IsString() || child->IsSymbol() )
{
str = child->GetString();
input.m_inStreamChild++;
}
else
{
- throw std::invalid_argument("SEXPR is not a string type!");
+ throw std::invalid_argument( "SEXPR is not a string type!" );
}
return input;
}
- SEXPR_LIST& operator>> (SEXPR_LIST& input, int64_t& lint)
+ SEXPR_LIST& operator>> ( SEXPR_LIST& input, int64_t& lint )
{
- SEXPR* child = input.GetChild(input.m_inStreamChild);
- if (child->IsInteger())
+ SEXPR* child = input.GetChild( input.m_inStreamChild );
+
+ if( child->IsInteger() )
{
lint = child->GetLongInteger();
input.m_inStreamChild++;
@@ -323,112 +329,115 @@ namespace SEXPR
return input;
}
- SEXPR_LIST& operator>> (SEXPR_LIST& input, float& fl)
+ SEXPR_LIST& operator>> ( SEXPR_LIST& input, float& fl )
{
- SEXPR* child = input.GetChild(input.m_inStreamChild);
- if (child->IsDouble())
+ SEXPR* child = input.GetChild( input.m_inStreamChild );
+ if( child->IsDouble() )
{
fl = child->GetFloat();
input.m_inStreamChild++;
}
else
{
- throw std::invalid_argument("SEXPR is not a float type!");
+ throw std::invalid_argument( "SEXPR is not a float type!" );
}
return input;
}
- SEXPR_LIST& operator>> (SEXPR_LIST& input, double& dbl)
+ SEXPR_LIST& operator>> ( SEXPR_LIST& input, double& dbl )
{
- SEXPR* child = input.GetChild(input.m_inStreamChild);
- if (child->IsDouble())
+ SEXPR* child = input.GetChild( input.m_inStreamChild );
+
+ if( child->IsDouble() )
{
dbl = child->GetDouble();
input.m_inStreamChild++;
}
else
{
- throw std::invalid_argument("SEXPR is not a double type!");
+ throw std::invalid_argument( "SEXPR is not a double type!" );
}
return input;
}
- SEXPR_LIST& operator>> (SEXPR_LIST& input, const _IN_STRING is)
+ SEXPR_LIST& operator>> ( SEXPR_LIST& input, const _IN_STRING is )
{
- SEXPR* child = input.GetChild(input.m_inStreamChild);
- if (is._Symbol)
+ SEXPR* child = input.GetChild( input.m_inStreamChild );
+
+ if( is._Symbol )
{
- if (child->IsSymbol())
+ if( child->IsSymbol() )
{
is._String = child->GetSymbol();
input.m_inStreamChild++;
}
else
{
- throw std::invalid_argument("SEXPR is not a symbol type!");
+ throw std::invalid_argument( "SEXPR is not a symbol type!" );
}
}
else
{
- if (child->IsString())
+ if( child->IsString() )
{
is._String = child->GetString();
input.m_inStreamChild++;
}
else
{
- throw std::invalid_argument("SEXPR is not a string type!");
+ throw std::invalid_argument( "SEXPR is not a string type!" );
}
}
return input;
}
- SEXPR_LIST& operator<< (SEXPR_LIST& list, SEXPR_LIST* list2)
+ SEXPR_LIST& operator<< ( SEXPR_LIST& list, SEXPR_LIST* list2 )
{
- list.AddChild(list2);
+ list.AddChild( list2 );
return list;
}
- size_t SEXPR_LIST::doScan(const SEXPR_SCAN_ARG *args, size_t num_args)
+ size_t SEXPR_LIST::doScan( const SEXPR_SCAN_ARG *args, size_t num_args )
{
size_t i = 0;
- for (i = 0; i < num_args; i++)
+
+ for( i = 0; i < num_args; i++ )
{
- SEXPR* child = GetChild(i);
+ SEXPR* child = GetChild( i );
const SEXPR_SCAN_ARG& arg = args[i];
try
{
- if (arg.type == SEXPR_SCAN_ARG::Type::DOUBLE)
+ if( arg.type == SEXPR_SCAN_ARG::Type::DOUBLE )
{
*arg.u.dbl_value = child->GetDouble();
}
- else if (arg.type == SEXPR_SCAN_ARG::Type::INT)
+ else if( arg.type == SEXPR_SCAN_ARG::Type::INT )
{
*arg.u.dbl_value = child->GetInteger();
}
- else if (arg.type == SEXPR_SCAN_ARG::Type::STRING)
+ else if( arg.type == SEXPR_SCAN_ARG::Type::STRING )
{
- if (child->IsSymbol())
+ if( child->IsSymbol() )
{
*arg.u.str_value = child->GetSymbol();
}
- else if (child->IsString())
+ else if( child->IsString() )
{
*arg.u.str_value = child->GetString();
}
}
- else if (arg.type == SEXPR_SCAN_ARG::Type::LONGINT)
+ else if( arg.type == SEXPR_SCAN_ARG::Type::LONGINT )
{
*arg.u.lint_value = child->GetLongInteger();
}
- else if (arg.type == SEXPR_SCAN_ARG::Type::SEXPR_STRING)
+ else if( arg.type == SEXPR_SCAN_ARG::Type::SEXPR_STRING )
{
- if (arg.u.sexpr_str->_Symbol)
+ if( arg.u.sexpr_str->_Symbol )
{
arg.u.sexpr_str->_String = child->GetSymbol();
}
@@ -438,18 +447,18 @@ namespace SEXPR
}
}
- else if (arg.type == SEXPR_SCAN_ARG::Type::STRING_COMP)
+ else if( arg.type == SEXPR_SCAN_ARG::Type::STRING_COMP )
{
- if (child->IsSymbol())
+ if( child->IsSymbol() )
{
- if (child->GetSymbol() != arg.str_value)
+ if( child->GetSymbol() != arg.str_value )
{
return i;
}
}
- else if (child->IsString())
+ else if( child->IsString() )
{
- if (child->GetString() != arg.str_value)
+ if( child->GetString() != arg.str_value )
{
return i;
}
@@ -457,10 +466,10 @@ namespace SEXPR
}
else
{
- throw std::invalid_argument("unsupported argument type, this shouldn't have happened");
+ throw std::invalid_argument( "unsupported argument type, this shouldn't have happened" );
}
}
- catch (INVALID_TYPE_EXCEPTION)
+ catch( INVALID_TYPE_EXCEPTION )
{
return i;
}
@@ -469,47 +478,48 @@ namespace SEXPR
return i;
}
- void SEXPR_LIST::doAddChildren(const SEXPR_CHILDREN_ARG *args, size_t num_args)
+ void SEXPR_LIST::doAddChildren( const SEXPR_CHILDREN_ARG *args, size_t num_args )
{
size_t i = 0;
- for (i = 0; i < num_args; i++)
+
+ for( i = 0; i < num_args; i++ )
{
const SEXPR_CHILDREN_ARG& arg = args[i];
- if (arg.type == SEXPR_CHILDREN_ARG::Type::DOUBLE)
+ if( arg.type == SEXPR_CHILDREN_ARG::Type::DOUBLE )
{
- AddChild(new SEXPR_DOUBLE(arg.u.dbl_value));
+ AddChild( new SEXPR_DOUBLE( arg.u.dbl_value ) );
}
- else if (arg.type == SEXPR_CHILDREN_ARG::Type::INT)
+ else if( arg.type == SEXPR_CHILDREN_ARG::Type::INT )
{
- AddChild(new SEXPR_INTEGER(arg.u.int_value));
+ AddChild( new SEXPR_INTEGER( arg.u.int_value ) );
}
- else if (arg.type == SEXPR_CHILDREN_ARG::Type::LONGINT)
+ else if( arg.type == SEXPR_CHILDREN_ARG::Type::LONGINT )
{
- AddChild(new SEXPR_INTEGER(arg.u.lint_value));
+ AddChild( new SEXPR_INTEGER( arg.u.lint_value ) );
}
- else if (arg.type == SEXPR_CHILDREN_ARG::Type::STRING)
+ else if( arg.type == SEXPR_CHILDREN_ARG::Type::STRING )
{
- AddChild(new SEXPR_STRING(arg.str_value));
+ AddChild( new SEXPR_STRING( arg.str_value ) );
}
- else if (arg.type == SEXPR_CHILDREN_ARG::Type::SEXPR_ATOM)
+ else if( arg.type == SEXPR_CHILDREN_ARG::Type::SEXPR_ATOM )
{
- AddChild(arg.u.sexpr_ptr);
+ AddChild( arg.u.sexpr_ptr );
}
- else if (arg.type == SEXPR_CHILDREN_ARG::Type::SEXPR_STRING)
+ else if( arg.type == SEXPR_CHILDREN_ARG::Type::SEXPR_STRING )
{
- if (arg.u.symbol)
+ if( arg.u.symbol )
{
- AddChild(new SEXPR_SYMBOL(arg.str_value));
+ AddChild( new SEXPR_SYMBOL( arg.str_value ) );
}
else
{
- AddChild(new SEXPR_STRING(arg.str_value));
+ AddChild( new SEXPR_STRING( arg.str_value ) );
}
}
else
{
- throw std::invalid_argument("unexpected argument type, this shouldn't have happened");
+ throw std::invalid_argument( "unexpected argument type, this shouldn't have happened" );
}
}
}
diff --git a/utils/kicad2step/sexpr/sexpr.h b/utils/kicad2step/sexpr/sexpr.h
index 82ad326b1..d07c8d397 100644
--- a/utils/kicad2step/sexpr/sexpr.h
+++ b/utils/kicad2step/sexpr/sexpr.h
@@ -1,6 +1,5 @@
/*
* Copyright (C) 2016 Mark Roszko <mark.ros...@gmail.com>
- * Copyright (C) 2016 QiEDA Developers
*
* 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
@@ -28,216 +27,270 @@
namespace SEXPR
{
- using std::int32_t;
- using std::int64_t;
-
- enum SEXPR_TYPE
- {
- SEXPR_TYPE_LIST,
- SEXPR_TYPE_ATOM_INTEGER,
- SEXPR_TYPE_ATOM_DOUBLE,
- SEXPR_TYPE_ATOM_STRING,
- SEXPR_TYPE_ATOM_SYMBOL,
- };
-
- typedef std::vector<class SEXPR *> SEXPR_VECTOR;
-
- class SEXPR
- {
- protected:
- SEXPR_TYPE m_type;
- SEXPR(SEXPR_TYPE type, size_t lineNumber);
- SEXPR(SEXPR_TYPE type);
- size_t m_lineNumber;
-
- public:
- virtual ~SEXPR() {};
- bool IsList() const { return m_type == SEXPR_TYPE_LIST; }
- bool IsSymbol() const { return m_type == SEXPR_TYPE_ATOM_SYMBOL; }
- bool IsString() const { return m_type == SEXPR_TYPE_ATOM_STRING; }
- bool IsDouble() const { return m_type == SEXPR_TYPE_ATOM_DOUBLE; }
- bool IsInteger() const { return m_type == SEXPR_TYPE_ATOM_INTEGER; }
- void AddChild(SEXPR* child);
- SEXPR_VECTOR const * GetChildren() const;
- SEXPR * GetChild(size_t idx) const;
- size_t GetNumberOfChildren() const;
- int64_t GetLongInteger() const;
- int32_t GetInteger() const;
- float GetFloat() const;
- double GetDouble() const;
- std::string const & GetString() const;
- std::string const & GetSymbol() const;
- SEXPR_LIST* GetList();
- std::string AsString(size_t level = 0);
- size_t GetLineNumber() { return m_lineNumber; }
- };
-
- struct SEXPR_INTEGER : public SEXPR
- {
- int64_t m_value;
- SEXPR_INTEGER(int64_t value) : SEXPR(SEXPR_TYPE_ATOM_INTEGER), m_value(value) {};
- SEXPR_INTEGER(int64_t value, int lineNumber) : SEXPR(SEXPR_TYPE_ATOM_INTEGER, lineNumber), m_value(value) {};
- };
-
- struct SEXPR_DOUBLE : public SEXPR
- {
- double m_value;
- SEXPR_DOUBLE(double value) : SEXPR(SEXPR_TYPE_ATOM_DOUBLE), m_value(value) {};
- SEXPR_DOUBLE(double value, int lineNumber) : SEXPR(SEXPR_TYPE_ATOM_DOUBLE, lineNumber), m_value(value) {};
- };
-
- struct SEXPR_STRING : public SEXPR
- {
- std::string m_value;
- SEXPR_STRING(std::string value) : SEXPR(SEXPR_TYPE_ATOM_STRING), m_value(value) {};
- SEXPR_STRING(std::string value, int lineNumber) : SEXPR(SEXPR_TYPE_ATOM_STRING, lineNumber), m_value(value) {};
- };
-
- struct SEXPR_SYMBOL : public SEXPR
- {
- std::string m_value;
- SEXPR_SYMBOL(std::string value) : SEXPR(SEXPR_TYPE_ATOM_SYMBOL), m_value(value) {};
- SEXPR_SYMBOL(std::string value, int lineNumber) : SEXPR(SEXPR_TYPE_ATOM_SYMBOL, lineNumber), m_value(value) {};
- };
-
- struct _OUT_STRING
- {
- bool _Symbol;
- const std::string& _String;
- };
-
- inline _OUT_STRING AsSymbol(const std::string& str)
- {
- struct _OUT_STRING ret = { true, str };
- return ret;
- }
-
- inline _OUT_STRING AsString(const std::string& str)
- {
- struct _OUT_STRING ret = { false, str };
- return ret;
- }
-
- struct _IN_STRING
- {
- bool _Symbol;
- std::string& _String;
-
- };
-
- inline _IN_STRING AsSymbol(std::string& str)
- {
- struct _IN_STRING ret = { true, str };
- return ret;
- }
-
- inline _IN_STRING AsString(std::string& str)
- {
- struct _IN_STRING ret = { false, str };
- return ret;
- }
-
- class SEXPR_SCAN_ARG {
- friend class SEXPR_LIST;
- public:
- SEXPR_SCAN_ARG(int32_t* value) : type(INT) { u.int_value = value; }
- SEXPR_SCAN_ARG(int64_t* value) : type(LONGINT) { u.lint_value = value; }
- SEXPR_SCAN_ARG(double* value) : type(DOUBLE) { u.dbl_value = value; }
- SEXPR_SCAN_ARG(std::string* value) : type(STRING) { u.str_value = value; }
- SEXPR_SCAN_ARG(_IN_STRING& value) : type(SEXPR_STRING) { u.sexpr_str = &value; }
- SEXPR_SCAN_ARG(const std::string* value) : type(STRING_COMP) { str_value = *value; }
- SEXPR_SCAN_ARG(std::string value) : type(STRING_COMP) { str_value = value; }
- SEXPR_SCAN_ARG(const char* value) : type(STRING_COMP) { str_value = value; }
-
- private:
- enum Type { INT, DOUBLE, STRING, LONGINT, STRING_COMP, SEXPR_STRING};
- Type type;
- union {
- int64_t* lint_value;
- int32_t* int_value;
- double* dbl_value;
- std::string* str_value;
- _IN_STRING* sexpr_str;
- } u;
-
- std::string str_value;
- };
-
- class SEXPR_CHILDREN_ARG {
- friend class SEXPR_LIST;
- public:
- SEXPR_CHILDREN_ARG(int32_t value) : type(INT) { u.int_value = value; }
- SEXPR_CHILDREN_ARG(int64_t value) : type(LONGINT) { u.lint_value = value; }
- SEXPR_CHILDREN_ARG(double value) : type(DOUBLE) { u.dbl_value = value; }
- SEXPR_CHILDREN_ARG(std::string value) : type(STRING) { str_value = value; }
- SEXPR_CHILDREN_ARG(const char* value) : type(STRING) { str_value = value; }
- SEXPR_CHILDREN_ARG(const _OUT_STRING& value) : type(SEXPR_STRING) { str_value = value._String; u.symbol = value._Symbol; }
- SEXPR_CHILDREN_ARG(SEXPR* ptr) : type(SEXPR_ATOM) { u.sexpr_ptr = ptr; }
-
- private:
- enum Type { INT, DOUBLE, STRING, LONGINT, SEXPR_STRING, SEXPR_ATOM };
- Type type;
- union {
- int64_t lint_value;
- int32_t int_value;
- double dbl_value;
- SEXPR* sexpr_ptr;
- bool symbol;
- } u;
- std::string str_value;
- };
-
- class SEXPR_LIST : public SEXPR
- {
- public:
- SEXPR_LIST() : SEXPR(SEXPR_TYPE_LIST), m_inStreamChild(0) {};
- SEXPR_LIST(int lineNumber) : SEXPR(SEXPR_TYPE_LIST, lineNumber), m_inStreamChild(0) {};
-
- template <typename... Args>
- SEXPR_LIST(const Args&... args) : SEXPR(SEXPR_TYPE_LIST), m_inStreamChild(0)
- {
- AddChildren(args...);
- };
-
- SEXPR_VECTOR m_children;
-
- template <typename... Args>
- size_t Scan(const Args&... args)
- {
- SEXPR_SCAN_ARG arg_array[] = { args... };
- return doScan(arg_array, sizeof...(Args));
- }
-
- template <typename... Args>
- void AddChildren(const Args&... args)
- {
- SEXPR_CHILDREN_ARG arg_array[] = { args... };
- doAddChildren(arg_array, sizeof...(Args));
- }
-
- virtual ~SEXPR_LIST();
-
- friend SEXPR_LIST& operator<< (SEXPR_LIST& list, double value);
- friend SEXPR_LIST& operator<< (SEXPR_LIST& list, float value);
- friend SEXPR_LIST& operator<< (SEXPR_LIST& list, int64_t value);
- friend SEXPR_LIST& operator<< (SEXPR_LIST& list, int32_t value);
- friend SEXPR_LIST& operator<< (SEXPR_LIST& list, std::string value);
- friend SEXPR_LIST& operator<< (SEXPR_LIST& list, const _OUT_STRING setting);
- friend SEXPR_LIST& operator<< (SEXPR_LIST& list, const ISEXPRABLE& obj);
- friend SEXPR_LIST& operator<< (SEXPR_LIST& list, SEXPR_LIST* list2);
- friend SEXPR_LIST& operator<< (SEXPR_LIST& list, SEXPR* obj);
- friend SEXPR_LIST& operator>> (SEXPR_LIST& input, ISEXPRABLE& obj);
- friend SEXPR_LIST& operator>> (SEXPR_LIST& input, std::string& str);
- friend SEXPR_LIST& operator>> (SEXPR_LIST& input, int32_t& inte);
- friend SEXPR_LIST& operator>> (SEXPR_LIST& input, int64_t& inte);
- friend SEXPR_LIST& operator>> (SEXPR_LIST& input, float& inte);
- friend SEXPR_LIST& operator>> (SEXPR_LIST& input, double& inte);
- friend SEXPR_LIST& operator>> (SEXPR_LIST& input, const _IN_STRING is);
- private:
- int m_inStreamChild;
- size_t doScan(const SEXPR_SCAN_ARG *args, size_t num_args);
- void doAddChildren(const SEXPR_CHILDREN_ARG *args, size_t num_args);
- };
+ using std::int32_t;
+ using std::int64_t;
+
+ enum SEXPR_TYPE
+ {
+ SEXPR_TYPE_LIST,
+ SEXPR_TYPE_ATOM_INTEGER,
+ SEXPR_TYPE_ATOM_DOUBLE,
+ SEXPR_TYPE_ATOM_STRING,
+ SEXPR_TYPE_ATOM_SYMBOL,
+ };
+
+ typedef std::vector< class SEXPR * > SEXPR_VECTOR;
+
+ class SEXPR
+ {
+ protected:
+ SEXPR_TYPE m_type;
+ SEXPR( SEXPR_TYPE aType, size_t aLineNumber );
+ SEXPR( SEXPR_TYPE aType );
+ size_t m_lineNumber;
+
+ public:
+ virtual ~SEXPR() {};
+ bool IsList() const { return m_type == SEXPR_TYPE_LIST; }
+ bool IsSymbol() const { return m_type == SEXPR_TYPE_ATOM_SYMBOL; }
+ bool IsString() const { return m_type == SEXPR_TYPE_ATOM_STRING; }
+ bool IsDouble() const { return m_type == SEXPR_TYPE_ATOM_DOUBLE; }
+ bool IsInteger() const { return m_type == SEXPR_TYPE_ATOM_INTEGER; }
+ void AddChild( SEXPR* aChild );
+ SEXPR_VECTOR const * GetChildren() const;
+ SEXPR * GetChild( size_t aIndex ) const;
+ size_t GetNumberOfChildren() const;
+ int64_t GetLongInteger() const;
+ int32_t GetInteger() const;
+ float GetFloat() const;
+ double GetDouble() const;
+ std::string const & GetString() const;
+ std::string const & GetSymbol() const;
+ SEXPR_LIST* GetList();
+ std::string AsString( size_t aLevel = 0);
+ size_t GetLineNumber() { return m_lineNumber; }
+ };
+
+ struct SEXPR_INTEGER : public SEXPR
+ {
+ int64_t m_value;
+
+ SEXPR_INTEGER( int64_t aValue ) :
+ SEXPR( SEXPR_TYPE_ATOM_INTEGER ), m_value( aValue ) {};
+
+ SEXPR_INTEGER( int64_t aValue, int aLineNumber ) :
+ SEXPR( SEXPR_TYPE_ATOM_INTEGER, aLineNumber ), m_value( aValue ) {};
+ };
+
+ struct SEXPR_DOUBLE : public SEXPR
+ {
+ double m_value;
+
+ SEXPR_DOUBLE( double aValue ) :
+ SEXPR( SEXPR_TYPE_ATOM_DOUBLE ), m_value( aValue ) {};
+
+ SEXPR_DOUBLE( double aValue, int aLineNumber ) :
+ SEXPR( SEXPR_TYPE_ATOM_DOUBLE, aLineNumber ), m_value( aValue ) {};
+ };
+
+ struct SEXPR_STRING : public SEXPR
+ {
+ std::string m_value;
+
+ SEXPR_STRING( std::string aValue ) :
+ SEXPR( SEXPR_TYPE_ATOM_STRING ), m_value(aValue) {};
+
+ SEXPR_STRING( std::string aValue, int aLineNumber ) :
+ SEXPR( SEXPR_TYPE_ATOM_STRING, aLineNumber ), m_value( aValue ) {};
+ };
+
+ struct SEXPR_SYMBOL : public SEXPR
+ {
+ std::string m_value;
+
+ SEXPR_SYMBOL( std::string aValue ) :
+ SEXPR( SEXPR_TYPE_ATOM_SYMBOL ), m_value( aValue ) {};
+
+ SEXPR_SYMBOL( std::string aValue, int aLineNumber ) :
+ SEXPR( SEXPR_TYPE_ATOM_SYMBOL, aLineNumber ), m_value( aValue ) {};
+ };
+
+ struct _OUT_STRING
+ {
+ bool _Symbol;
+ const std::string& _String;
+ };
+
+ inline _OUT_STRING AsSymbol( const std::string& aString )
+ {
+ struct _OUT_STRING ret = { true, aString };
+ return ret;
+ }
+
+ inline _OUT_STRING AsString( const std::string& aString )
+ {
+ struct _OUT_STRING ret = { false, aString };
+ return ret;
+ }
+
+ struct _IN_STRING
+ {
+ bool _Symbol;
+ std::string& _String;
+ };
+
+ inline _IN_STRING AsSymbol( std::string& aString )
+ {
+ struct _IN_STRING ret = { true, aString };
+ return ret;
+ }
+
+ inline _IN_STRING AsString( std::string& aString )
+ {
+ struct _IN_STRING ret = { false, aString };
+ return ret;
+ }
+
+ class SEXPR_SCAN_ARG
+ {
+ friend class SEXPR_LIST;
+
+ public:
+ SEXPR_SCAN_ARG( int32_t* aValue ) :
+ type( INT ) { u.int_value = aValue; }
+
+ SEXPR_SCAN_ARG( int64_t* aValue ) :
+ type( LONGINT ) { u.lint_value = aValue; }
+
+ SEXPR_SCAN_ARG( double* aValue ) :
+ type( DOUBLE ) { u.dbl_value = aValue; }
+
+ SEXPR_SCAN_ARG( std::string* aValue ) :
+ type( STRING ) { u.str_value = aValue; }
+
+ SEXPR_SCAN_ARG( _IN_STRING& aValue ) :
+ type( SEXPR_STRING ) { u.sexpr_str = &aValue; }
+
+ SEXPR_SCAN_ARG( const std::string* aValue ) :
+ type( STRING_COMP ) { str_value = *aValue; }
+
+ SEXPR_SCAN_ARG( std::string aValue ) :
+ type( STRING_COMP ) { str_value = aValue; }
+
+ SEXPR_SCAN_ARG( const char* aValue ) :
+ type( STRING_COMP ) { str_value = aValue; }
+
+ private:
+ enum Type { INT, DOUBLE, STRING, LONGINT, STRING_COMP, SEXPR_STRING };
+ Type type;
+
+ union
+ {
+ int64_t* lint_value;
+ int32_t* int_value;
+ double* dbl_value;
+ std::string* str_value;
+ _IN_STRING* sexpr_str;
+ } u;
+
+ std::string str_value;
+ };
+
+ class SEXPR_CHILDREN_ARG
+ {
+ friend class SEXPR_LIST;
+
+ public:
+ SEXPR_CHILDREN_ARG( int32_t aValue ) :
+ type( INT ) { u.int_value = aValue; }
+
+ SEXPR_CHILDREN_ARG( int64_t aValue ) :
+ type( LONGINT ) { u.lint_value = aValue; }
+ SEXPR_CHILDREN_ARG( double aValue ) :
+ type( DOUBLE ) { u.dbl_value = aValue; }
+
+ SEXPR_CHILDREN_ARG( std::string aValue ) :
+ type( STRING ) { str_value = aValue; }
+
+ SEXPR_CHILDREN_ARG( const char* aValue ) :
+ type( STRING ) { str_value = aValue; }
+
+ SEXPR_CHILDREN_ARG( const _OUT_STRING& aValue ) :
+ type( SEXPR_STRING ) { str_value = aValue._String; u.symbol = aValue._Symbol; }
+
+ SEXPR_CHILDREN_ARG( SEXPR* aPointer ) :
+ type( SEXPR_ATOM ) { u.sexpr_ptr = aPointer; }
+
+ private:
+ enum Type { INT, DOUBLE, STRING, LONGINT, SEXPR_STRING, SEXPR_ATOM };
+ Type type;
+
+ union
+ {
+ int64_t lint_value;
+ int32_t int_value;
+ double dbl_value;
+ SEXPR* sexpr_ptr;
+ bool symbol;
+ } u;
+
+ std::string str_value;
+ };
+
+ class SEXPR_LIST : public SEXPR
+ {
+ public:
+ SEXPR_LIST() : SEXPR( SEXPR_TYPE_LIST ), m_inStreamChild( 0 ) {};
+
+ SEXPR_LIST( int aLineNumber ) :
+ SEXPR( SEXPR_TYPE_LIST, aLineNumber), m_inStreamChild( 0 ) {};
+
+ template <typename... Args>
+ SEXPR_LIST( const Args&... args ) : SEXPR( SEXPR_TYPE_LIST ), m_inStreamChild( 0 )
+ {
+ AddChildren(args...);
+ };
+
+ SEXPR_VECTOR m_children;
+
+ template <typename... Args>
+ size_t Scan( const Args&... args )
+ {
+ SEXPR_SCAN_ARG arg_array[] = { args... };
+ return doScan( arg_array, sizeof...( Args ) );
+ }
+
+ template <typename... Args>
+ void AddChildren( const Args&... args )
+ {
+ SEXPR_CHILDREN_ARG arg_array[] = { args... };
+ doAddChildren( arg_array, sizeof...( Args ) );
+ }
+
+ virtual ~SEXPR_LIST();
+
+ friend SEXPR_LIST& operator<< ( SEXPR_LIST& list, double value );
+ friend SEXPR_LIST& operator<< ( SEXPR_LIST& list, float value );
+ friend SEXPR_LIST& operator<< ( SEXPR_LIST& list, int64_t value );
+ friend SEXPR_LIST& operator<< ( SEXPR_LIST& list, int32_t value );
+ friend SEXPR_LIST& operator<< ( SEXPR_LIST& list, std::string value );
+ friend SEXPR_LIST& operator<< ( SEXPR_LIST& list, const _OUT_STRING setting );
+ friend SEXPR_LIST& operator<< ( SEXPR_LIST& list, const ISEXPRABLE& obj );
+ friend SEXPR_LIST& operator<< ( SEXPR_LIST& list, SEXPR_LIST* list2 );
+ friend SEXPR_LIST& operator<< ( SEXPR_LIST& list, SEXPR* obj );
+ friend SEXPR_LIST& operator>> ( SEXPR_LIST& input, ISEXPRABLE& obj );
+ friend SEXPR_LIST& operator>> ( SEXPR_LIST& input, std::string& str );
+ friend SEXPR_LIST& operator>> ( SEXPR_LIST& input, int32_t& inte );
+ friend SEXPR_LIST& operator>> ( SEXPR_LIST& input, int64_t& inte );
+ friend SEXPR_LIST& operator>> ( SEXPR_LIST& input, float& inte );
+ friend SEXPR_LIST& operator>> ( SEXPR_LIST& input, double& inte );
+ friend SEXPR_LIST& operator>> ( SEXPR_LIST& input, const _IN_STRING is );
+
+ private:
+ int m_inStreamChild;
+ size_t doScan( const SEXPR_SCAN_ARG *args, size_t num_args );
+ void doAddChildren( const SEXPR_CHILDREN_ARG *args, size_t num_args );
+ };
}
#endif
diff --git a/utils/kicad2step/sexpr/sexpr_exception.h b/utils/kicad2step/sexpr/sexpr_exception.h
index dc0351d38..4d2992f4d 100644
--- a/utils/kicad2step/sexpr/sexpr_exception.h
+++ b/utils/kicad2step/sexpr/sexpr_exception.h
@@ -1,6 +1,5 @@
/*
* Copyright (C) 2016 Mark Roszko <mark.ros...@gmail.com>
- * Copyright (C) 2016 QiEDA Developers
*
* 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
@@ -27,7 +26,7 @@ namespace SEXPR
class PARSE_EXCEPTION : public std::exception
{
public:
- PARSE_EXCEPTION(const std::string m) :msg(m) {}
+ PARSE_EXCEPTION( const std::string aMessage ) : msg( aMessage ) {}
const char* what() { return msg.c_str(); }
virtual ~PARSE_EXCEPTION() throw() {}
private:
@@ -37,7 +36,7 @@ namespace SEXPR
class INVALID_TYPE_EXCEPTION : public std::exception
{
public:
- INVALID_TYPE_EXCEPTION(const std::string m) :msg(m) {}
+ INVALID_TYPE_EXCEPTION( const std::string aMessage ) : msg( aMessage ) {}
const char* what() { return msg.c_str(); }
virtual ~INVALID_TYPE_EXCEPTION() throw() {}
private:
diff --git a/utils/kicad2step/sexpr/sexpr_parser.cpp b/utils/kicad2step/sexpr/sexpr_parser.cpp
index 5641e3c6b..431cdb9ec 100644
--- a/utils/kicad2step/sexpr/sexpr_parser.cpp
+++ b/utils/kicad2step/sexpr/sexpr_parser.cpp
@@ -1,6 +1,5 @@
/*
* Copyright (C) 2016 Mark Roszko <mark.ros...@gmail.com>
- * Copyright (C) 2016 QiEDA Developers
*
* 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
@@ -30,7 +29,7 @@ namespace SEXPR
{
const std::string PARSER::whitespaceCharacters = " \t\n\r\b\f\v";
- PARSER::PARSER() : m_lineNumber(1)
+ PARSER::PARSER() : m_lineNumber( 1 )
{
}
@@ -38,98 +37,94 @@ namespace SEXPR
{
}
- SEXPR* PARSER::Parse(const std::string &aString)
+ SEXPR* PARSER::Parse( const std::string &aString )
{
std::string::const_iterator it = aString.begin();
- return parseString(aString, it);
+ return parseString( aString, it );
}
- SEXPR* PARSER::ParseFromFile(const std::string &aFileName)
+ SEXPR* PARSER::ParseFromFile( const std::string &aFileName )
{
- std::string str = GetFileContents(aFileName);
+ std::string str = GetFileContents( aFileName );
std::string::const_iterator it = str.begin();
- return parseString(str, it);
+ return parseString( str, it );
}
- std::string PARSER::GetFileContents(const std::string &aFileName)
+ std::string PARSER::GetFileContents( const std::string &aFileName )
{
- std::ifstream file(aFileName.c_str(), std::ios::binary);
+ std::ifstream file( aFileName.c_str(), std::ios::binary );
std::string str;
// Faster than automatic allocation
- file.seekg(0, std::ios::end);
-
+ file.seekg( 0, std::ios::end );
auto length = file.tellg();
- if (length < 0)
+
+ if( length < 0 )
{
- throw PARSE_EXCEPTION("Error occurred attempting to read in file");
+ throw PARSE_EXCEPTION( "Error occurred attempting to read in file" );
}
- str.resize(static_cast<size_t>(length));
- file.seekg(0, std::ios::beg);
+ str.resize( static_cast<size_t>( length ) );
+ file.seekg( 0, std::ios::beg );
- file.read(&str[0], str.length());
+ file.read( &str[0], str.length() );
return str;
}
- SEXPR* PARSER::parseString(const std::string& aString, std::string::const_iterator& it)
+ SEXPR* PARSER::parseString( const std::string& aString, std::string::const_iterator& it )
{
std::string::const_iterator eit = aString.end();
- for (; it != aString.end(); ++it)
+
+ for( ; it != aString.end(); ++it )
{
- if (*it == '\n')
- {
+ if( *it == '\n' )
m_lineNumber++;
- }
- if (whitespaceCharacters.find(*it) != std::string::npos)
+ if( whitespaceCharacters.find(*it) != std::string::npos )
continue;
- if (*it == '(')
+ if( *it == '(' )
{
- std::advance(it, 1);
+ std::advance( it, 1 );
- SEXPR_LIST* list = new SEXPR_LIST(m_lineNumber);
- while (it != aString.end() && *it != ')')
+ SEXPR_LIST* list = new SEXPR_LIST( m_lineNumber );
+ while( it != aString.end() && *it != ')' )
{
//there may be newlines in between atoms of a list, so detect these here
- if (*it == '\n')
- {
+ if( *it == '\n' )
m_lineNumber++;
- }
- if (whitespaceCharacters.find(*it) != std::string::npos)
+ if( whitespaceCharacters.find(*it) != std::string::npos )
{
- std::advance(it, 1);
+ std::advance( it, 1 );
continue;
}
- SEXPR* item = parseString(aString, it);
- list->AddChild(item);
+ SEXPR* item = parseString( aString, it );
+ list->AddChild( item );
}
- if (it != aString.end())
- {
- std::advance(it, 1);
- }
+ if( it != aString.end() )
+ std::advance( it, 1 );
return list;
}
- else if (*it == ')')
+ else if( *it == ')' )
{
return NULL;
}
- else if (*it == '"')
+ else if( *it == '"' )
{
size_t startPos = std::distance(aString.begin(), it) + 1;
size_t closingPos = aString.find_first_of('"', startPos);
- if (closingPos != std::string::npos)
+ if( closingPos != std::string::npos )
{
- SEXPR_STRING* str = new SEXPR_STRING(aString.substr(startPos, closingPos - startPos),m_lineNumber);
- std::advance(it, closingPos - startPos + 2);
+ SEXPR_STRING* str = new SEXPR_STRING(
+ aString.substr( startPos, closingPos - startPos ),m_lineNumber );
+ std::advance( it, closingPos - startPos + 2 );
return str;
}
@@ -140,42 +135,45 @@ namespace SEXPR
}
else
{
- size_t startPos = std::distance(aString.begin(), it);
- size_t closingPos = aString.find_first_of(whitespaceCharacters+"()", startPos);
+ size_t startPos = std::distance( aString.begin(), it );
+ size_t closingPos = aString.find_first_of( whitespaceCharacters + "()", startPos );
- std::string tmp = aString.substr(startPos, closingPos - startPos);
+ std::string tmp = aString.substr( startPos, closingPos - startPos );
- if (closingPos != std::string::npos)
+ if( closingPos != std::string::npos )
{
- if (tmp.find_first_not_of("0123456789.") == std::string::npos ||
- (tmp.size() > 1 && tmp[0] == '-' && tmp.find_first_not_of("0123456789.",1) == std::string::npos)
- )
+ if( tmp.find_first_not_of( "0123456789." ) == std::string::npos ||
+ ( tmp.size() > 1 && tmp[0] == '-'
+ && tmp.find_first_not_of( "0123456789.", 1 ) == std::string::npos ) )
{
SEXPR* res;
- if (tmp.find('.') != std::string::npos)
+
+ if( tmp.find( '.' ) != std::string::npos )
{
- res = new SEXPR_DOUBLE(strtod(tmp.c_str(), NULL), m_lineNumber);
+ res = new SEXPR_DOUBLE( strtod( tmp.c_str(), NULL ), m_lineNumber );
//floating point type
}
else
{
- res = new SEXPR_INTEGER(strtoll(tmp.c_str(), NULL, 0), m_lineNumber);
+ res = new SEXPR_INTEGER(
+ strtoll( tmp.c_str(), NULL, 0 ), m_lineNumber );
}
- std::advance(it, closingPos - startPos);
+
+ std::advance( it, closingPos - startPos );
return res;
}
else
{
- SEXPR_SYMBOL* str = new SEXPR_SYMBOL(tmp, m_lineNumber);
- std::advance(it, closingPos - startPos);
+ SEXPR_SYMBOL* str = new SEXPR_SYMBOL( tmp, m_lineNumber );
+ std::advance( it, closingPos - startPos );
return str;
}
}
else
{
- throw PARSE_EXCEPTION("format error");
+ throw PARSE_EXCEPTION( "format error" );
}
}
}
diff --git a/utils/kicad2step/sexpr/sexpr_parser.h b/utils/kicad2step/sexpr/sexpr_parser.h
index 2d4be3252..8781810a4 100644
--- a/utils/kicad2step/sexpr/sexpr_parser.h
+++ b/utils/kicad2step/sexpr/sexpr_parser.h
@@ -1,6 +1,5 @@
/*
* Copyright (C) 2016 Mark Roszko <mark.ros...@gmail.com>
- * Copyright (C) 2016 QiEDA Developers
*
* 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
@@ -31,11 +30,12 @@ namespace SEXPR
public:
PARSER();
~PARSER();
- SEXPR* Parse(const std::string &aString);
- SEXPR* ParseFromFile(const std::string &filename);
- static std::string GetFileContents(const std::string &filename);
+ SEXPR* Parse( const std::string &aString );
+ SEXPR* ParseFromFile( const std::string &aFilename );
+ static std::string GetFileContents( const std::string &aFilename );
+
private:
- SEXPR* parseString(const std::string& aString, std::string::const_iterator& it);
+ SEXPR* parseString( const std::string& aString, std::string::const_iterator& it );
static const std::string whitespaceCharacters;
int m_lineNumber;
};
--
2.11.0
From e2bc6b14d28ad65df9da649c33013d3eccc0323c Mon Sep 17 00:00:00 2001
From: Cirilo Bernardo <cirilo.berna...@gmail.com>
Date: Thu, 2 Feb 2017 11:33:15 +1100
Subject: [PATCH 2/2] Change 'enum' to 'enum class' in sexpr code
---
utils/kicad2step/sexpr/sexpr.cpp | 20 ++++++------
utils/kicad2step/sexpr/sexpr.h | 70 +++++++++++++++++++++-------------------
2 files changed, 46 insertions(+), 44 deletions(-)
diff --git a/utils/kicad2step/sexpr/sexpr.cpp b/utils/kicad2step/sexpr/sexpr.cpp
index a1c7f30cb..8620ab7fa 100644
--- a/utils/kicad2step/sexpr/sexpr.cpp
+++ b/utils/kicad2step/sexpr/sexpr.cpp
@@ -36,7 +36,7 @@ namespace SEXPR
SEXPR_VECTOR const * SEXPR::GetChildren() const
{
- if( m_type != SEXPR_TYPE_LIST )
+ if( m_type != SEXPR_TYPE::SEXPR_TYPE_LIST )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a list type!");
}
@@ -46,7 +46,7 @@ namespace SEXPR
SEXPR* SEXPR::GetChild( size_t aIndex ) const
{
- if( m_type != SEXPR_TYPE_LIST )
+ if( m_type != SEXPR_TYPE::SEXPR_TYPE_LIST )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a list type!");
}
@@ -56,7 +56,7 @@ namespace SEXPR
void SEXPR::AddChild( SEXPR* aChild )
{
- if( m_type != SEXPR_TYPE_LIST )
+ if( m_type != SEXPR_TYPE::SEXPR_TYPE_LIST )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a list type!");
}
@@ -68,7 +68,7 @@ namespace SEXPR
size_t SEXPR::GetNumberOfChildren() const
{
- if( m_type != SEXPR_TYPE_LIST )
+ if( m_type != SEXPR_TYPE::SEXPR_TYPE_LIST )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a list type!");
}
@@ -78,7 +78,7 @@ namespace SEXPR
std::string const & SEXPR::GetString() const
{
- if( m_type != SEXPR_TYPE_ATOM_STRING )
+ if( m_type != SEXPR_TYPE::SEXPR_TYPE_ATOM_STRING )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a string type!");
}
@@ -93,7 +93,7 @@ namespace SEXPR
int64_t SEXPR::GetLongInteger() const
{
- if( m_type != SEXPR_TYPE_ATOM_INTEGER )
+ if( m_type != SEXPR_TYPE::SEXPR_TYPE_ATOM_INTEGER )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a integer type!");
}
@@ -105,11 +105,11 @@ namespace SEXPR
{
// we may end up parsing "intended" floats/doubles as ints
// so here we allow silent casting back to doubles
- if( m_type == SEXPR_TYPE_ATOM_DOUBLE )
+ if( m_type == SEXPR_TYPE::SEXPR_TYPE_ATOM_DOUBLE )
{
return static_cast< SEXPR_DOUBLE const * >(this)->m_value;
}
- else if( m_type == SEXPR_TYPE_ATOM_INTEGER )
+ else if( m_type == SEXPR_TYPE::SEXPR_TYPE_ATOM_INTEGER )
{
return static_cast< SEXPR_INTEGER const * >(this)->m_value;
}
@@ -126,7 +126,7 @@ namespace SEXPR
std::string const & SEXPR::GetSymbol() const
{
- if( m_type != SEXPR_TYPE_ATOM_SYMBOL )
+ if( m_type != SEXPR_TYPE::SEXPR_TYPE_ATOM_SYMBOL )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a symbol type!");
}
@@ -137,7 +137,7 @@ namespace SEXPR
SEXPR_LIST* SEXPR::GetList()
{
- if( m_type != SEXPR_TYPE_LIST )
+ if( m_type != SEXPR_TYPE::SEXPR_TYPE_LIST )
{
throw INVALID_TYPE_EXCEPTION("SEXPR is not a list type!");
}
diff --git a/utils/kicad2step/sexpr/sexpr.h b/utils/kicad2step/sexpr/sexpr.h
index d07c8d397..d8a2e0aa4 100644
--- a/utils/kicad2step/sexpr/sexpr.h
+++ b/utils/kicad2step/sexpr/sexpr.h
@@ -30,7 +30,7 @@ namespace SEXPR
using std::int32_t;
using std::int64_t;
- enum SEXPR_TYPE
+ enum class SEXPR_TYPE : char
{
SEXPR_TYPE_LIST,
SEXPR_TYPE_ATOM_INTEGER,
@@ -51,11 +51,11 @@ namespace SEXPR
public:
virtual ~SEXPR() {};
- bool IsList() const { return m_type == SEXPR_TYPE_LIST; }
- bool IsSymbol() const { return m_type == SEXPR_TYPE_ATOM_SYMBOL; }
- bool IsString() const { return m_type == SEXPR_TYPE_ATOM_STRING; }
- bool IsDouble() const { return m_type == SEXPR_TYPE_ATOM_DOUBLE; }
- bool IsInteger() const { return m_type == SEXPR_TYPE_ATOM_INTEGER; }
+ bool IsList() const { return m_type == SEXPR_TYPE::SEXPR_TYPE_LIST; }
+ bool IsSymbol() const { return m_type == SEXPR_TYPE::SEXPR_TYPE_ATOM_SYMBOL; }
+ bool IsString() const { return m_type == SEXPR_TYPE::SEXPR_TYPE_ATOM_STRING; }
+ bool IsDouble() const { return m_type == SEXPR_TYPE::SEXPR_TYPE_ATOM_DOUBLE; }
+ bool IsInteger() const { return m_type == SEXPR_TYPE::SEXPR_TYPE_ATOM_INTEGER; }
void AddChild( SEXPR* aChild );
SEXPR_VECTOR const * GetChildren() const;
SEXPR * GetChild( size_t aIndex ) const;
@@ -76,10 +76,10 @@ namespace SEXPR
int64_t m_value;
SEXPR_INTEGER( int64_t aValue ) :
- SEXPR( SEXPR_TYPE_ATOM_INTEGER ), m_value( aValue ) {};
+ SEXPR( SEXPR_TYPE::SEXPR_TYPE_ATOM_INTEGER ), m_value( aValue ) {};
SEXPR_INTEGER( int64_t aValue, int aLineNumber ) :
- SEXPR( SEXPR_TYPE_ATOM_INTEGER, aLineNumber ), m_value( aValue ) {};
+ SEXPR( SEXPR_TYPE::SEXPR_TYPE_ATOM_INTEGER, aLineNumber ), m_value( aValue ) {};
};
struct SEXPR_DOUBLE : public SEXPR
@@ -87,10 +87,10 @@ namespace SEXPR
double m_value;
SEXPR_DOUBLE( double aValue ) :
- SEXPR( SEXPR_TYPE_ATOM_DOUBLE ), m_value( aValue ) {};
+ SEXPR( SEXPR_TYPE::SEXPR_TYPE_ATOM_DOUBLE ), m_value( aValue ) {};
SEXPR_DOUBLE( double aValue, int aLineNumber ) :
- SEXPR( SEXPR_TYPE_ATOM_DOUBLE, aLineNumber ), m_value( aValue ) {};
+ SEXPR( SEXPR_TYPE::SEXPR_TYPE_ATOM_DOUBLE, aLineNumber ), m_value( aValue ) {};
};
struct SEXPR_STRING : public SEXPR
@@ -98,10 +98,10 @@ namespace SEXPR
std::string m_value;
SEXPR_STRING( std::string aValue ) :
- SEXPR( SEXPR_TYPE_ATOM_STRING ), m_value(aValue) {};
+ SEXPR( SEXPR_TYPE::SEXPR_TYPE_ATOM_STRING ), m_value(aValue) {};
SEXPR_STRING( std::string aValue, int aLineNumber ) :
- SEXPR( SEXPR_TYPE_ATOM_STRING, aLineNumber ), m_value( aValue ) {};
+ SEXPR( SEXPR_TYPE::SEXPR_TYPE_ATOM_STRING, aLineNumber ), m_value( aValue ) {};
};
struct SEXPR_SYMBOL : public SEXPR
@@ -109,10 +109,10 @@ namespace SEXPR
std::string m_value;
SEXPR_SYMBOL( std::string aValue ) :
- SEXPR( SEXPR_TYPE_ATOM_SYMBOL ), m_value( aValue ) {};
+ SEXPR( SEXPR_TYPE::SEXPR_TYPE_ATOM_SYMBOL ), m_value( aValue ) {};
SEXPR_SYMBOL( std::string aValue, int aLineNumber ) :
- SEXPR( SEXPR_TYPE_ATOM_SYMBOL, aLineNumber ), m_value( aValue ) {};
+ SEXPR( SEXPR_TYPE::SEXPR_TYPE_ATOM_SYMBOL, aLineNumber ), m_value( aValue ) {};
};
struct _OUT_STRING
@@ -157,31 +157,31 @@ namespace SEXPR
public:
SEXPR_SCAN_ARG( int32_t* aValue ) :
- type( INT ) { u.int_value = aValue; }
+ type( Type::INT ) { u.int_value = aValue; }
SEXPR_SCAN_ARG( int64_t* aValue ) :
- type( LONGINT ) { u.lint_value = aValue; }
+ type( Type::LONGINT ) { u.lint_value = aValue; }
SEXPR_SCAN_ARG( double* aValue ) :
- type( DOUBLE ) { u.dbl_value = aValue; }
+ type( Type::DOUBLE ) { u.dbl_value = aValue; }
SEXPR_SCAN_ARG( std::string* aValue ) :
- type( STRING ) { u.str_value = aValue; }
+ type( Type::STRING ) { u.str_value = aValue; }
SEXPR_SCAN_ARG( _IN_STRING& aValue ) :
- type( SEXPR_STRING ) { u.sexpr_str = &aValue; }
+ type( Type::SEXPR_STRING ) { u.sexpr_str = &aValue; }
SEXPR_SCAN_ARG( const std::string* aValue ) :
- type( STRING_COMP ) { str_value = *aValue; }
+ type( Type::STRING_COMP ) { str_value = *aValue; }
SEXPR_SCAN_ARG( std::string aValue ) :
- type( STRING_COMP ) { str_value = aValue; }
+ type( Type::STRING_COMP ) { str_value = aValue; }
SEXPR_SCAN_ARG( const char* aValue ) :
- type( STRING_COMP ) { str_value = aValue; }
+ type( Type::STRING_COMP ) { str_value = aValue; }
private:
- enum Type { INT, DOUBLE, STRING, LONGINT, STRING_COMP, SEXPR_STRING };
+ enum class Type : char { INT, DOUBLE, STRING, LONGINT, STRING_COMP, SEXPR_STRING };
Type type;
union
@@ -202,27 +202,28 @@ namespace SEXPR
public:
SEXPR_CHILDREN_ARG( int32_t aValue ) :
- type( INT ) { u.int_value = aValue; }
+ type( Type::INT ) { u.int_value = aValue; }
SEXPR_CHILDREN_ARG( int64_t aValue ) :
- type( LONGINT ) { u.lint_value = aValue; }
+ type( Type::LONGINT ) { u.lint_value = aValue; }
+
SEXPR_CHILDREN_ARG( double aValue ) :
- type( DOUBLE ) { u.dbl_value = aValue; }
+ type( Type::DOUBLE ) { u.dbl_value = aValue; }
SEXPR_CHILDREN_ARG( std::string aValue ) :
- type( STRING ) { str_value = aValue; }
+ type( Type::STRING ) { str_value = aValue; }
SEXPR_CHILDREN_ARG( const char* aValue ) :
- type( STRING ) { str_value = aValue; }
+ type( Type::STRING ) { str_value = aValue; }
SEXPR_CHILDREN_ARG( const _OUT_STRING& aValue ) :
- type( SEXPR_STRING ) { str_value = aValue._String; u.symbol = aValue._Symbol; }
+ type( Type::SEXPR_STRING ) { str_value = aValue._String; u.symbol = aValue._Symbol; }
SEXPR_CHILDREN_ARG( SEXPR* aPointer ) :
- type( SEXPR_ATOM ) { u.sexpr_ptr = aPointer; }
+ type( Type::SEXPR_ATOM ) { u.sexpr_ptr = aPointer; }
private:
- enum Type { INT, DOUBLE, STRING, LONGINT, SEXPR_STRING, SEXPR_ATOM };
+ enum class Type : char { INT, DOUBLE, STRING, LONGINT, SEXPR_STRING, SEXPR_ATOM };
Type type;
union
@@ -240,13 +241,14 @@ namespace SEXPR
class SEXPR_LIST : public SEXPR
{
public:
- SEXPR_LIST() : SEXPR( SEXPR_TYPE_LIST ), m_inStreamChild( 0 ) {};
+ SEXPR_LIST() : SEXPR( SEXPR_TYPE::SEXPR_TYPE_LIST ), m_inStreamChild( 0 ) {};
SEXPR_LIST( int aLineNumber ) :
- SEXPR( SEXPR_TYPE_LIST, aLineNumber), m_inStreamChild( 0 ) {};
+ SEXPR( SEXPR_TYPE::SEXPR_TYPE_LIST, aLineNumber), m_inStreamChild( 0 ) {};
template <typename... Args>
- SEXPR_LIST( const Args&... args ) : SEXPR( SEXPR_TYPE_LIST ), m_inStreamChild( 0 )
+ SEXPR_LIST( const Args&... args ) :
+ SEXPR( SEXPR_TYPE::SEXPR_TYPE_LIST ), m_inStreamChild( 0 )
{
AddChildren(args...);
};
--
2.11.0
_______________________________________________
Mailing list: https://launchpad.net/~kicad-developers
Post to : kicad-developers@lists.launchpad.net
Unsubscribe : https://launchpad.net/~kicad-developers
More help : https://help.launchpad.net/ListHelp
