HG_REPOSITORIES/LPP/INSTRUMENTATION/kicadtools Files · qilib/qicadnetlist.h

PCB Viewer is working but still WIP.

jeandet - - Load All Authors

File last commit:

r3:e85fcd939626 default


                r7:f3cd68e05582

default

Download file

             qicadnetlist.h
        
                    213 lines
            
             | 6.3 KiB
            
                | text/x-c
            
             |
                CLexer
            
             / qilib / qicadnetlist.h
          
                    History
                
                 |
                  Source
                 | Raw
                 |Copy content
                 |Copy permalink

        jeandet
    
Sync

              r1
            
      /*------------------------------------------------------------------------------

      --  This file is a part of the Kicad Tools Software

      --  Copyright (C) 2014, Plasma Physics Laboratory - CNRS

      --

      --  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, write to the Free Software

      --  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

      -------------------------------------------------------------------------------*/

      /*--                  Author : Alexis Jeandet

      --                     Mail : alexis.jeandet@member.fsf.org

      ----------------------------------------------------------------------------*/

        jeandet
    
Sync

              r3
            
      #ifndef QICADNETLIST_H

      #define QICADNETLIST_H

      #include <QString>

      #include <QStringList>

        jeandet
    
First Init, kicad lisp-like files abstract parser done.

              r0
            
      #include <QList>

      #include <QFile>

      #include <parsers/lispLike_driver.h>

        jeandet
    
Sync

              r3
            
      #include <qicadlisplikelexique.h>

        jeandet
    
First Init, kicad lisp-like files abstract parser done.

              r0
            
      namespace QIlib{

        jeandet
    
Sync

              r1
            
        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
      class QIcadNetListDesign : public QIcadAbstractNodeWrapper

        jeandet
    
Sync

              r1
            
      {

      public:

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
          QIcadNetListDesign(QIlib::AbstractNode* node);

          QIcadNetListDesign(){}

        jeandet
    
Sync

              r1
            
          QIcadAbstractNodeWrapper source;

          QIcadAbstractNodeWrapper date;

          QIcadAbstractNodeWrapper tool;

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
          void setNode(QIlib::AbstractNode* node);

        jeandet
    
Sync

              r1
            
      };

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
        jeandet
    
Sync

              r1
            
       /*

        * (comp (ref IC1)

            (value 24L-MOD-8)

            (libsource (lib guan) (part 24L-MOD-8))

            (sheetpath (names /) (tstamps /))

            (tstamp 52533BBE))

      */

      class  QIcadNetListComponent:public QIcadAbstractNodeWrapper

      {

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
          class QIcadNetListLibSource : QIcadAbstractNodeWrapper

          {

          public:

              QIcadNetListLibSource(AbstractNode* node);

              QIcadNetListLibSource(){}

              QIcadAbstractNodeWrapper lib;

              QIcadAbstractNodeWrapper part;

              void setNode(AbstractNode* node);

          };

          class QIcadNetListSheetPath : QIcadAbstractNodeWrapper

          {

          public:

              QIcadNetListSheetPath(AbstractNode* node);

              QIcadNetListSheetPath(){}

              QIcadAbstractNodeWrapper names;

              QIcadAbstractNodeWrapper tstamps;

              void setNode(AbstractNode* node);

          };

        jeandet
    
Sync

              r1
            
      public:

           QIcadNetListComponent(AbstractNode* node);

           QIcadAbstractNodeWrapper ref;

           QIcadAbstractNodeWrapper value;

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
           QIcadNetListLibSource libsource;

           QIcadNetListSheetPath sheetpath;

        jeandet
    
Sync

              r1
            
           QIcadAbstractNodeWrapper tstamp;

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
           void setNode(QIlib::AbstractNode* node);

        jeandet
    
Sync

              r1
            
      };

      /*

      (libparts

          (libpart (lib guan) (part 24L-MOD-8)

            (fields

              (field (name Reference) IC)

              (field (name Value) 24L-MOD-8))

            (pins

              (pin (num 1) (name GND) (type power_in))

              (pin (num 2) (name VCC) (type power_in))

      */

      class QIcadNetListField : QIcadAbstractNodeWrapper

      {

      public:

          QIcadNetListField(AbstractNode* node);

          QIcadAbstractNodeWrapper name;

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
          void setNode(AbstractNode* node);

        jeandet
    
First Init, kicad lisp-like files abstract parser done.

              r0
            
      };

        jeandet
    
Sync

              r1
            
      class QIcadNetListLibPart : QIcadAbstractNodeWrapper

      {

          class QIcadNetListPin : QIcadAbstractNodeWrapper

          {

          public:

              QIcadNetListPin(AbstractNode* node);

              QIcadAbstractNodeWrapper type;

              QIcadAbstractNodeWrapper num;

              QIcadAbstractNodeWrapper name;

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
              void setNode(AbstractNode* node);

        jeandet
    
Sync

              r1
            
          };

      public:

          QIcadNetListLibPart(AbstractNode* node);

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
          QIcadAbstractNodeWrapper lib;

          QIcadAbstractNodeWrapper part;

        jeandet
    
Sync

              r1
            
          QList<QIcadNetListField*> fields;

          QList<QIcadNetListPin*> pins;

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
          void setNode(AbstractNode* node);

          void setFields(QIlib::AbstractNode* node);

          void apendFields(QIlib::AbstractNode* node);

          void setPins(QIlib::AbstractNode* node);

          void apendPins(QIlib::AbstractNode* node);

        jeandet
    
Sync

              r1
            
      };

      /*

      (libraries

          (library (logical guan)

            (uri /home/guan/boards/guan.lib))

          (library (logical device)

            (uri /usr/share/kicad/library/device.lib))

          (library (logical conn)

            (uri /usr/share/kicad/library/conn.lib)))

      */

      class  QIcadNetListLibrary : QIcadAbstractNodeWrapper

      {

      public:

           QIcadNetListLibrary(AbstractNode* node);

           QIcadAbstractNodeWrapper uri;

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
           QIcadAbstractNodeWrapper logical;

           void setNode(AbstractNode* node);

        jeandet
    
Sync

              r1
            
      };

      /*

      (nets

          (net (code 15) (name "")

            (node (ref C4) (pin 1))

            (node (ref U2) (pin 4)))

          (net (code 16) (name GND)

            (node (ref D1) (pin 2))

            (node (ref C1) (pin 2))

            (node (ref IC1) (pin 1))

      */

      class QIcadNetListNet : QIcadAbstractNodeWrapper

      {

          class QIcadNetListNetNode: QIcadAbstractNodeWrapper

          {

          public:

              QIcadNetListNetNode(AbstractNode* node);

              QIcadAbstractNodeWrapper ref;

              QIcadAbstractNodeWrapper pin;

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
              void setNode(AbstractNode* node);

        jeandet
    
Sync

              r1
            
          };

      public:

          QIcadNetListNet(AbstractNode* node);

          QList<QIcadNetListNetNode*> NetNodes;

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
          QIcadAbstractNodeWrapper code;

          QIcadAbstractNodeWrapper name;

          void setNode(AbstractNode* node);

        jeandet
    
Sync

              r1
            
      };

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
      class QIcadNetListRoot : public QIcadAbstractNodeWrapper

      {

      public:

          QIcadNetListRoot(QIlib::AbstractNode* node);

          QIcadNetListDesign design;

          QList<QIcadNetListComponent*> components;

          QList<QIcadNetListLibPart*> libparts;

          QList<QIcadNetListLibrary*> libraries;

          QList<QIcadNetListNet*> nets;

          void setNode(QIlib::AbstractNode* node);

          void setComponents(QIlib::AbstractNode* node);

          void apendComponents(QIlib::AbstractNode* node);

          void setLibParts(QIlib::AbstractNode* node);

          void apendLibParts(QIlib::AbstractNode* node);

          void setLibraries(QIlib::AbstractNode* node);

          void apendLibraries(QIlib::AbstractNode* node);

          void setNets(QIlib::AbstractNode* node);

          void apendNets(QIlib::AbstractNode* node);

      };

        jeandet
    
Sync

              r1
            
        jeandet
    
First Init, kicad lisp-like files abstract parser done.

              r0
            
      class QIcadNetList : private lispLike_Driver

      {

      public:

          QIcadNetList();

          bool parseNetList(const QString& netlist);

        jeandet
    
Sync

              r3
            
      //    QString toString();

        jeandet
    
First Init, kicad lisp-like files abstract parser done.

              r0
            
          QString fileName;

          QString print();

        jeandet
    
Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...

              r2
            
          QIcadNetListRoot* netlistRoot;

        jeandet
    
First Init, kicad lisp-like files abstract parser done.

              r0
            
      private:

          QIlib::AbstractNode* getAbstractNode(const QString& node,int index);

          QIlib::AbstractNode* getAbstractNode(QIlib::AbstractNode* rootNode,const QString& node,int* index);

          void updateConcreteTree();

      };

      }

      #endif // QICADNETLIST_H

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

jeandet Sync	r1	/*------------------------------------------------------------------------------
		-- This file is a part of the Kicad Tools Software
		-- Copyright (C) 2014, Plasma Physics Laboratory - CNRS
		--
		-- 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, write to the Free Software
		-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		-------------------------------------------------------------------------------*/
		/*-- Author : Alexis Jeandet
		-- Mail : alexis.jeandet@member.fsf.org
		----------------------------------------------------------------------------*/
jeandet Sync	r3	#ifndef QICADNETLIST_H
		#define QICADNETLIST_H
		#include <QString>
		#include <QStringList>
jeandet First Init, kicad lisp-like files abstract parser done.	r0	#include <QList>
		#include <QFile>
		#include <parsers/lispLike_driver.h>
jeandet Sync	r3	#include <qicadlisplikelexique.h>
jeandet First Init, kicad lisp-like files abstract parser done.	r0
		namespace QIlib{


jeandet Sync	r1
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	class QIcadNetListDesign : public QIcadAbstractNodeWrapper
jeandet Sync	r1	{
		public:
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	QIcadNetListDesign(QIlib::AbstractNode* node);
		QIcadNetListDesign(){}
jeandet Sync	r1	QIcadAbstractNodeWrapper source;
		QIcadAbstractNodeWrapper date;
		QIcadAbstractNodeWrapper tool;
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	void setNode(QIlib::AbstractNode* node);
jeandet Sync	r1	};


jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2
jeandet Sync	r1	/*
		* (comp (ref IC1)
		(value 24L-MOD-8)
		(libsource (lib guan) (part 24L-MOD-8))
		(sheetpath (names /) (tstamps /))
		(tstamp 52533BBE))
		*/
		class QIcadNetListComponent:public QIcadAbstractNodeWrapper
		{
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	class QIcadNetListLibSource : QIcadAbstractNodeWrapper
		{
		public:
		QIcadNetListLibSource(AbstractNode* node);
		QIcadNetListLibSource(){}
		QIcadAbstractNodeWrapper lib;
		QIcadAbstractNodeWrapper part;
		void setNode(AbstractNode* node);
		};
		class QIcadNetListSheetPath : QIcadAbstractNodeWrapper
		{
		public:
		QIcadNetListSheetPath(AbstractNode* node);
		QIcadNetListSheetPath(){}
		QIcadAbstractNodeWrapper names;
		QIcadAbstractNodeWrapper tstamps;
		void setNode(AbstractNode* node);
		};
jeandet Sync	r1	public:
		QIcadNetListComponent(AbstractNode* node);
		QIcadAbstractNodeWrapper ref;
		QIcadAbstractNodeWrapper value;
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	QIcadNetListLibSource libsource;
		QIcadNetListSheetPath sheetpath;
jeandet Sync	r1	QIcadAbstractNodeWrapper tstamp;
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	void setNode(QIlib::AbstractNode* node);
jeandet Sync	r1	};


		/*
		(libparts
		(libpart (lib guan) (part 24L-MOD-8)
		(fields
		(field (name Reference) IC)
		(field (name Value) 24L-MOD-8))
		(pins
		(pin (num 1) (name GND) (type power_in))
		(pin (num 2) (name VCC) (type power_in))
		*/
		class QIcadNetListField : QIcadAbstractNodeWrapper
		{
		public:
		QIcadNetListField(AbstractNode* node);
		QIcadAbstractNodeWrapper name;
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	void setNode(AbstractNode* node);
jeandet First Init, kicad lisp-like files abstract parser done.	r0	};

jeandet Sync	r1
		class QIcadNetListLibPart : QIcadAbstractNodeWrapper
		{
		class QIcadNetListPin : QIcadAbstractNodeWrapper
		{
		public:
		QIcadNetListPin(AbstractNode* node);
		QIcadAbstractNodeWrapper type;
		QIcadAbstractNodeWrapper num;
		QIcadAbstractNodeWrapper name;
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	void setNode(AbstractNode* node);
jeandet Sync	r1	};
		public:
		QIcadNetListLibPart(AbstractNode* node);
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	QIcadAbstractNodeWrapper lib;
		QIcadAbstractNodeWrapper part;
jeandet Sync	r1	QList<QIcadNetListField*> fields;
		QList<QIcadNetListPin*> pins;
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	void setNode(AbstractNode* node);
		void setFields(QIlib::AbstractNode* node);
		void apendFields(QIlib::AbstractNode* node);
		void setPins(QIlib::AbstractNode* node);
		void apendPins(QIlib::AbstractNode* node);
jeandet Sync	r1	};

		/*
		(libraries
		(library (logical guan)
		(uri /home/guan/boards/guan.lib))
		(library (logical device)
		(uri /usr/share/kicad/library/device.lib))
		(library (logical conn)
		(uri /usr/share/kicad/library/conn.lib)))
		*/

		class QIcadNetListLibrary : QIcadAbstractNodeWrapper
		{
		public:
		QIcadNetListLibrary(AbstractNode* node);
		QIcadAbstractNodeWrapper uri;
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	QIcadAbstractNodeWrapper logical;
		void setNode(AbstractNode* node);
jeandet Sync	r1	};
		/*
		(nets
		(net (code 15) (name "")
		(node (ref C4) (pin 1))
		(node (ref U2) (pin 4)))
		(net (code 16) (name GND)
		(node (ref D1) (pin 2))
		(node (ref C1) (pin 2))
		(node (ref IC1) (pin 1))
		*/

		class QIcadNetListNet : QIcadAbstractNodeWrapper
		{
		class QIcadNetListNetNode: QIcadAbstractNodeWrapper
		{
		public:
		QIcadNetListNetNode(AbstractNode* node);
		QIcadAbstractNodeWrapper ref;
		QIcadAbstractNodeWrapper pin;
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	void setNode(AbstractNode* node);
jeandet Sync	r1	};
		public:
		QIcadNetListNet(AbstractNode* node);
		QList<QIcadNetListNetNode*> NetNodes;
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	QIcadAbstractNodeWrapper code;
		QIcadAbstractNodeWrapper name;
		void setNode(AbstractNode* node);

jeandet Sync	r1	};

jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	class QIcadNetListRoot : public QIcadAbstractNodeWrapper
		{
		public:
		QIcadNetListRoot(QIlib::AbstractNode* node);
		QIcadNetListDesign design;
		QList<QIcadNetListComponent*> components;
		QList<QIcadNetListLibPart*> libparts;
		QList<QIcadNetListLibrary*> libraries;
		QList<QIcadNetListNet*> nets;
		void setNode(QIlib::AbstractNode* node);
		void setComponents(QIlib::AbstractNode* node);
		void apendComponents(QIlib::AbstractNode* node);
		void setLibParts(QIlib::AbstractNode* node);
		void apendLibParts(QIlib::AbstractNode* node);
		void setLibraries(QIlib::AbstractNode* node);
		void apendLibraries(QIlib::AbstractNode* node);
		void setNets(QIlib::AbstractNode* node);
		void apendNets(QIlib::AbstractNode* node);
		};
jeandet Sync	r1

jeandet First Init, kicad lisp-like files abstract parser done.	r0	class QIcadNetList : private lispLike_Driver
		{
		public:
		QIcadNetList();
		bool parseNetList(const QString& netlist);
jeandet Sync	r3	// QString toString();
jeandet First Init, kicad lisp-like files abstract parser done.	r0	QString fileName;
		QString print();
jeandet Netlist parsing and loading ok, get in memory abstract syntax tree and concrete...	r2	QIcadNetListRoot* netlistRoot;
jeandet First Init, kicad lisp-like files abstract parser done.	r0	private:
		QIlib::AbstractNode* getAbstractNode(const QString& node,int index);
		QIlib::AbstractNode* getAbstractNode(QIlib::AbstractNode* rootNode,const QString& node,int* index);
		void updateConcreteTree();
		};
		}
		#endif // QICADNETLIST_H