cl_NetlistParser.hpp

Go to the documentation of this file.

/*
 * BELFEM -- The Berkeley Lab Finite Element Framework
 * Copyright (c) 2026, The Regents of the University of California,
 * through Lawrence Berkeley National Laboratory (subject to receipt of any required
 * approvals from the U.S. Dept. of Energy).  All rights reserved.
 *
 * Developers: Christian Messe, Gregory Giard
 *
 * See the top-level LICENSE file for the complete license and disclaimer.
 */
 
#ifndef BELFEM_CL_NETLISTPARSER_HPP
#define BELFEM_CL_NETLISTPARSER_HPP
 
#include "typedefs.hpp"
#include "cl_Cell.hpp"
#include "cl_Map.hpp"
 
namespace belfem
{
    namespace electronics
    {
//-----------------------------------------------------------------------------

        struct NetlistElement
        {
            char                    mType = '?';

            string                  mName;

            Cell< string >          mNodes;

            Cell< string >          mValues;

            Map< string, string >   mKwargs;

            index_t                 mLine = 0;

            string                  mCard;
        };
 
//-----------------------------------------------------------------------------

        struct NetlistModel
        {
            string                  mName;    // case-folded model name
            string                  mType;    // case-folded type token ( "d" )
            Map< string, string >   mKwargs;
            index_t                 mLine = 0;
            string                  mCard;
        };
 
//-----------------------------------------------------------------------------

        struct NetlistControl
        {
            string                  mKeyword; // without the dot ( "tran" )
            Cell< string >          mArgs;
            index_t                 mLine = 0;
            string                  mCard;
        };
 
//-----------------------------------------------------------------------------

        struct NetlistDirective
        {
            string                  mKind;    // case-folded ( "order" )
            Cell< string >          mArgs;    // positional tokens
            Map< string, string >   mKwargs;
            index_t                 mLine = 0;
            string                  mCard;
        };
 
//-----------------------------------------------------------------------------

        class NetlistParser
        {
            string                    mSource;  // path or "<memory>", for errors
            string                    mTitle;
            Cell< NetlistElement >    mElements;
            Cell< NetlistModel >      mModels;
            Cell< NetlistControl >    mControls;
            Cell< NetlistDirective >  mDirectives;
            Cell< string >            mNodeNames; // first appearance, folded
            bool                      mHasEnd = false;
 
//-----------------------------------------------------------------------------
        public:
//-----------------------------------------------------------------------------

            NetlistParser( const string & aPath );

            NetlistParser( const Cell< string > & aLines,
                           const string & aSource = "<memory>" );
 
            ~NetlistParser() = default;
 
//-----------------------------------------------------------------------------
 
            const string &
            title() const
            {
                return mTitle;
            }

            const string &
            source() const
            {
                return mSource;
            }
 
            const Cell< NetlistElement > &
            elements() const
            {
                return mElements;
            }
 
            const Cell< NetlistModel > &
            models() const
            {
                return mModels;
            }
 
            const Cell< NetlistControl > &
            controls() const
            {
                return mControls;
            }
 
            const Cell< NetlistDirective > &
            directives() const
            {
                return mDirectives;
            }

            const Cell< string > &
            node_names() const
            {
                return mNodeNames;
            }

            bool
            has_end() const
            {
                return mHasEnd;
            }
 
//-----------------------------------------------------------------------------
        private:
//-----------------------------------------------------------------------------
 
            void
            parse( const Cell< string > & aLines );

            string
            strip_eol_comment( const string & aLine ) const;

            void
            classify_card( const string & aCard,
                           const index_t aLine );
 
            void
            classify_control_card( const Cell< string > & aTokens,
                                   const string & aCard,
                                   const index_t aLine );
 
            void
            classify_element_card( const Cell< string > & aTokens,
                                   const string & aCard,
                                   const index_t aLine );
 
            void
            parse_directive( const string & aPayload,
                             const index_t aLine );

            void
            tokenize( const string & aCard,
                      Cell< string > & aTokens ) const;

            void
            store_kwarg( const string & aToken,
                         const string & aCard,
                         const index_t aLine,
                         Map< string, string > & aKwargs ) const;

            void
            collect_node( const string & aName );
 
//-----------------------------------------------------------------------------
        };
 
//-----------------------------------------------------------------------------
    }
}
 
#endif //BELFEM_CL_NETLISTPARSER_HPP