HDLGenerator::Case Class Reference

#include <HDLGenerator.hh>

Inheritance diagram for HDLGenerator::Case:

Collaboration diagram for HDLGenerator::Case:

Public Member Functions
	Case ()
	Case (std::string stringCase)
template<typename SS >
Case &	operator<< (SS op)
Case &	operator<< (BinaryLiteral &&rhs)
Case &	operator<< (BinaryLiteral &rhs)
Case &	operator<< (int rhs)
Case &	operator<< (std::string &rhs)
Case &	operator<< (std::string &&rhs)
void	hdl (std::ostream &stream, Language lang, int level) override
Public Member Functions inherited from HDLGenerator::Generatable
	Generatable (std::string name)
virtual	~Generatable ()=default
virtual void	build ()
virtual void	reads (const std::string &var)
virtual void	reads (const LHSValue &var)
virtual void	writes (const std::string &var)
virtual Register &	getRegister (const std::string &var)
virtual bool	hasOption (const std::string &var)
virtual bool	isRegister (const std::string &name)
virtual bool	isVariable (const std::string &name)
virtual bool	isConstant (const std::string &name)
virtual Width	width (const std::string &name)
int	integerWidth (const std::string &name)
virtual WireType	wireType (const std::string &name)
virtual Width	width ()
virtual WireType	wireType () const
virtual void	hdl (std::ostream &stream, Language lang)
virtual void	implementAll (std::ostream &stream, Language lang)
virtual void	implementAll (std::ostream &stream, Language lang, int indent)
template<typename Func >
void	forAll (Func func)
template<typename Type , typename Func >
void	forAll (Func func)
template<class Type >
bool	parentIs ()
template<class Type >
Type *	parentType ()
void	pushComponent (std::shared_ptr< Generatable > c)
template<class Component >
void	addComponent (Component c)
const std::string &	name () const noexcept
void	setParent (Generatable *parent) noexcept
Generatable *	parent () const noexcept

Private Attributes
std::string	stringCase_
std::vector< int >	intCases_
std::vector< BinaryLiteral >	binaryCases_

Detailed Description

Case in a switch-case.

Definition at line 645 of file HDLGenerator.hh.

Constructor & Destructor Documentation

Case() [1/2]

HDLGenerator::Case::Case ( )

inline

Definition at line 647 of file HDLGenerator.hh.

: Generatable("case") {}

Case() [2/2]

HDLGenerator::Case::Case ( std::string  stringCase )

inline

Definition at line 648 of file HDLGenerator.hh.

                                   : Generatable("case"),
                                       stringCase_(stringCase) {}

Member Function Documentation

hdl()

void HDLGenerator::Case::hdl ( std::ostream &  stream, Language  lang, int  level  )

inlineoverridevirtual

Reimplemented from HDLGenerator::Generatable.

Definition at line 683 of file HDLGenerator.hh.

                                                                        {
            if (lang == Language::VHDL) {
                stream << StringTools::indent(level) << "when ";
                if (!stringCase_.empty()) {
                    stream << stringCase_;
                } else if (!intCases_.empty()) {
                    std::string separator = "";
                    for (auto&& c : intCases_) {
                        stream << separator << std::to_string(c);
                        separator = " | ";
                    }
                } else if (!binaryCases_.empty()) {
                    std::string separator = "";
                    for (auto&& c : binaryCases_) {
                        stream << separator;
                        c.hdl(stream, lang);
                        separator = " | ";
                    }
                } else {
                    throw std::runtime_error("Case has no case");
                }
                stream << " =>\n";
                implementAll(stream, lang, level + 1);
            } else if (lang == Language::Verilog) {
                stream << StringTools::indent(level);
                if (!stringCase_.empty()) {
                    stream << stringCase_;
                } else if (!intCases_.empty()) {
                    std::string separator = "";
                    for (auto&& c : intCases_) {
                        stream << separator << std::to_string(c);
                        separator = ", ";
                    }
                } else if (!binaryCases_.empty()) {
                    std::string separator = "";
                    for (auto&& c : binaryCases_) {
                        stream << separator;
                        c.hdl(stream, lang);
                        separator = ", ";
                    }
                } else {
                    throw std::runtime_error("Case has no case");
                }
                stream << ": begin\n";
                implementAll(stream, lang, level + 1);
                stream << StringTools::indent(level) << "end\n";
            } else {
                throw std::runtime_error(__PRETTY_FUNCTION__);
            }
        }

References binaryCases_, HDLGenerator::Generatable::implementAll(), StringTools::indent(), intCases_, stringCase_, HDLGenerator::Verilog, and HDLGenerator::VHDL.

Here is the call graph for this function:

operator<<() [1/6]

Case& HDLGenerator::Case::operator<< ( BinaryLiteral &&  rhs )

inline

Definition at line 658 of file HDLGenerator.hh.

                                              {
            binaryCases_.emplace_back(rhs);
            return *this;
        }

References binaryCases_.

operator<<() [2/6]

Case& HDLGenerator::Case::operator<< ( BinaryLiteral &  rhs )

inline

Definition at line 663 of file HDLGenerator.hh.

                                             {
            binaryCases_.emplace_back(rhs);
            return *this;
        }

References binaryCases_.

operator<<() [3/6]

Case& HDLGenerator::Case::operator<< ( int  rhs )

inline

Definition at line 668 of file HDLGenerator.hh.

                                  {
            intCases_.emplace_back(rhs);
            return *this;
        }

References intCases_.

operator<<() [4/6]

template<typename SS >

Case& HDLGenerator::Case::operator<< ( SS  op )

inline

Definition at line 652 of file HDLGenerator.hh.

                                {
            std::shared_ptr<SequentialStatement> ptr = std::make_shared<SS>(op);
            pushComponent(ptr);
            return *this;
        }

References HDLGenerator::Generatable::pushComponent().

Here is the call graph for this function:

operator<<() [5/6]

Case& HDLGenerator::Case::operator<< ( std::string &&  rhs )

inline

Definition at line 678 of file HDLGenerator.hh.

                                          {
            stringCase_ = rhs;
            return *this;
        }

References stringCase_.

operator<<() [6/6]

Case& HDLGenerator::Case::operator<< ( std::string &  rhs )

inline

Definition at line 673 of file HDLGenerator.hh.

                                         {
            stringCase_ = rhs;
            return *this;
        }

References stringCase_.

Member Data Documentation

binaryCases_

std::vector<BinaryLiteral> HDLGenerator::Case::binaryCases_

private

Definition at line 737 of file HDLGenerator.hh.

Referenced by hdl(), and operator<<().

intCases_

std::vector<int> HDLGenerator::Case::intCases_

private

Definition at line 736 of file HDLGenerator.hh.

Referenced by hdl(), and operator<<().

stringCase_

std::string HDLGenerator::Case::stringCase_

private

Definition at line 735 of file HDLGenerator.hh.

Referenced by hdl(), and operator<<().

---

The documentation for this class was generated from the following file:

• HDLGenerator.hh