luke
/
iverilog
mirror of https://github.com/steveicarus/iverilog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

More cppcheck updates

This commit is contained in:
Cary R 2025-10-13 13:14:57 -07:00
parent 929fbf3507
commit 08c8ee081a
53 changed files with 941 additions and 725 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
AStatement.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_AStatement_H #ifndef IVL_AStatement_H
#define IVL_AStatement_H #define IVL_AStatement_H
/* /*
* Copyright (c) 2008-2021 Stephen Williams (steve@icarus.com) * Copyright (c) 2008-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -40,10 +40,10 @@ class AContrib : public Statement {
public: public:
AContrib(PExpr*lval, PExpr*rval); AContrib(PExpr*lval, PExpr*rval);
~AContrib(); ~AContrib() override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
private: private:
PExpr*lval_; PExpr*lval_;
@ -61,7 +61,7 @@ class AProcess : public LineInfo {
AProcess(ivl_process_type_t t, Statement*st) AProcess(ivl_process_type_t t, Statement*st)
: type_(t), statement_(st) { } : type_(t), statement_(st) { }
~AProcess(); ~AProcess() override;
bool elaborate(Design*des, NetScope*scope) const; bool elaborate(Design*des, NetScope*scope) const;

2
Makefile.in
View File

@ -184,6 +184,8 @@ endif
cppcheck: $(O:.o=.cc) $(srcdir)/dosify.c $(srcdir)/version.c cppcheck: $(O:.o=.cc) $(srcdir)/dosify.c $(srcdir)/version.c
cppcheck --enable=all --std=c99 --std=c++11 -f \ cppcheck --enable=all --std=c99 --std=c++11 -f \
--check-level=exhaustive \
--suppressions-list=$(srcdir)/cppcheck-global.sup \
--suppressions-list=$(srcdir)/cppcheck.sup \ --suppressions-list=$(srcdir)/cppcheck.sup \
-UYYPARSE_PARAM -UYYPRINT -Ushort -Usize_t -Uyyoverflow \ -UYYPARSE_PARAM -UYYPRINT -Ushort -Usize_t -Uyyoverflow \
-UYYTYPE_INT8 -UYYTYPE_INT16 -UYYTYPE_UINT8 -UYYTYPE_UINT16 \ -UYYTYPE_INT8 -UYYTYPE_INT16 -UYYTYPE_UINT8 -UYYTYPE_UINT16 \

6
Module.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_Module_H #ifndef IVL_Module_H
#define IVL_Module_H #define IVL_Module_H
/* /*
* Copyright (c) 1998-2021 Stephen Williams (steve@icarus.com) * Copyright (c) 1998-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -74,7 +74,7 @@ class Module : public PScopeExtra, public PNamedItem {
/* The name passed here is the module name, not the instance /* The name passed here is the module name, not the instance
name. This name must be a permallocated string. */ name. This name must be a permallocated string. */
explicit Module(LexicalScope*parent, perm_string name); explicit Module(LexicalScope*parent, perm_string name);
~Module(); ~Module() override;
/* Initially false. This is set to true if the module has been /* Initially false. This is set to true if the module has been
declared as a library module. This makes the module declared as a library module. This makes the module
@ -167,7 +167,7 @@ class Module : public PScopeExtra, public PNamedItem {
bool elaborate_sig(Design*, NetScope*scope) const; bool elaborate_sig(Design*, NetScope*scope) const;
SymbolType symbol_type() const; SymbolType symbol_type() const override;
bool can_be_toplevel() const; bool can_be_toplevel() const;

250
PExpr.h
View File

@ -60,7 +60,7 @@ class PExpr : public LineInfo {
static const char*width_mode_name(width_mode_t mode); static const char*width_mode_name(width_mode_t mode);
PExpr(); PExpr();
virtual ~PExpr(); virtual ~PExpr() override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const;
@ -204,17 +204,17 @@ class PEAssignPattern : public PExpr {
public: public:
explicit PEAssignPattern(); explicit PEAssignPattern();
explicit PEAssignPattern(const std::list<PExpr*>&p); explicit PEAssignPattern(const std::list<PExpr*>&p);
~PEAssignPattern(); ~PEAssignPattern() override;
void dump(std::ostream&) const; void dump(std::ostream&) const override;
virtual unsigned test_width(Design*des, NetScope*scope, width_mode_t&mode); virtual unsigned test_width(Design*des, NetScope*scope, width_mode_t&mode) override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
private: private:
NetExpr* elaborate_expr_packed_(Design *des, NetScope *scope, NetExpr* elaborate_expr_packed_(Design *des, NetScope *scope,
ivl_variable_type_t base_type, ivl_variable_type_t base_type,
@ -242,35 +242,35 @@ class PEConcat : public PExpr {
public: public:
explicit PEConcat(const std::list<PExpr*>&p, PExpr*r =0); explicit PEConcat(const std::list<PExpr*>&p, PExpr*r =0);
~PEConcat(); ~PEConcat() override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type); virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type) override;
virtual bool has_aa_term(Design*des, NetScope*scope) const; virtual bool has_aa_term(Design*des, NetScope*scope) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetNet* elaborate_lnet(Design*des, NetScope*scope, virtual NetNet* elaborate_lnet(Design*des, NetScope*scope,
bool var_allowed_in_sv) const; bool var_allowed_in_sv) const override;
virtual NetNet* elaborate_bi_net(Design*des, NetScope*scope, virtual NetNet* elaborate_bi_net(Design*des, NetScope*scope,
bool var_allowed_in_sv) const; bool var_allowed_in_sv) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*, virtual NetExpr*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
virtual NetAssign_* elaborate_lval(Design*des, virtual NetAssign_* elaborate_lval(Design*des,
NetScope*scope, NetScope*scope,
bool is_cassign, bool is_cassign,
bool is_force, bool is_force,
bool is_init = false) const; bool is_init = false) const override;
virtual bool is_collapsible_net(Design*des, NetScope*scope, virtual bool is_collapsible_net(Design*des, NetScope*scope,
NetNet::PortType port_type) const; NetNet::PortType port_type) const override;
private: private:
NetNet* elaborate_lnet_common_(Design*des, NetScope*scope, NetNet* elaborate_lnet_common_(Design*des, NetScope*scope,
bool bidirectional_flag, bool bidirectional_flag,
@ -299,14 +299,14 @@ class PEEvent : public PExpr {
// Use this constructor to create events based on edges or levels. // Use this constructor to create events based on edges or levels.
PEEvent(edge_t t, PExpr*e); PEEvent(edge_t t, PExpr*e);
~PEEvent(); ~PEEvent() override;
edge_t type() const; edge_t type() const;
PExpr* expr() const; PExpr* expr() const;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual bool has_aa_term(Design*des, NetScope*scope) const; virtual bool has_aa_term(Design*des, NetScope*scope) const override;
private: private:
edge_t type_; edge_t type_;
@ -320,19 +320,19 @@ class PEFNumber : public PExpr {
public: public:
explicit PEFNumber(verireal*vp); explicit PEFNumber(verireal*vp);
~PEFNumber(); ~PEFNumber() override;
const verireal& value() const; const verireal& value() const;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*, virtual NetExpr*elaborate_expr(Design*des, NetScope*,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*, virtual NetExpr*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
private: private:
verireal*value_; verireal*value_;
@ -344,38 +344,38 @@ class PEIdent : public PExpr {
explicit PEIdent(perm_string, unsigned lexical_pos, bool no_implicit_sig=false); explicit PEIdent(perm_string, unsigned lexical_pos, bool no_implicit_sig=false);
explicit PEIdent(PPackage*pkg, const pform_name_t&name, unsigned lexical_pos); explicit PEIdent(PPackage*pkg, const pform_name_t&name, unsigned lexical_pos);
explicit PEIdent(const pform_name_t&, unsigned lexical_pos); explicit PEIdent(const pform_name_t&, unsigned lexical_pos);
~PEIdent(); ~PEIdent() override;
// Add another name to the string of hierarchy that is the // Add another name to the string of hierarchy that is the
// current identifier. // current identifier.
void append_name(perm_string); void append_name(perm_string);
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type); virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type) override;
virtual bool has_aa_term(Design*des, NetScope*scope) const; virtual bool has_aa_term(Design*des, NetScope*scope) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
// Identifiers are allowed (with restrictions) is assign l-values. // Identifiers are allowed (with restrictions) is assign l-values.
virtual NetNet* elaborate_lnet(Design*des, NetScope*scope, bool var_allowed_in_sv) const; virtual NetNet* elaborate_lnet(Design*des, NetScope*scope, bool var_allowed_in_sv) const override;
virtual NetNet* elaborate_bi_net(Design*des, NetScope*scope, bool var_allowed_in_sv) const; virtual NetNet* elaborate_bi_net(Design*des, NetScope*scope, bool var_allowed_in_sv) const override;
// Identifiers are also allowed as procedural assignment l-values. // Identifiers are also allowed as procedural assignment l-values.
virtual NetAssign_* elaborate_lval(Design*des, virtual NetAssign_* elaborate_lval(Design*des,
NetScope*scope, NetScope*scope,
bool is_cassign, bool is_cassign,
bool is_force, bool is_force,
bool is_init = false) const; bool is_init = false) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*, virtual NetExpr*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
// Elaborate the PEIdent as a port to a module. This method // Elaborate the PEIdent as a port to a module. This method
// only applies to Ident expressions. // only applies to Ident expressions.
@ -387,7 +387,7 @@ class PEIdent : public PExpr {
NetNet* elaborate_unpacked_net(Design*des, NetScope*sc) const; NetNet* elaborate_unpacked_net(Design*des, NetScope*sc) const;
virtual bool is_collapsible_net(Design*des, NetScope*scope, virtual bool is_collapsible_net(Design*des, NetScope*scope,
NetNet::PortType port_type) const; NetNet::PortType port_type) const override;
const pform_scoped_name_t& path() const { return path_; } const pform_scoped_name_t& path() const { return path_; }
@ -562,16 +562,16 @@ class PENewArray : public PExpr {
public: public:
explicit PENewArray (PExpr*s, PExpr*i); explicit PENewArray (PExpr*s, PExpr*i);
~PENewArray(); ~PENewArray() override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*, virtual NetExpr*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
private: private:
PExpr*size_; PExpr*size_;
@ -587,18 +587,18 @@ class PENewClass : public PExpr {
explicit PENewClass (const std::list<named_pexpr_t> &p, explicit PENewClass (const std::list<named_pexpr_t> &p,
data_type_t *class_type = nullptr); data_type_t *class_type = nullptr);
~PENewClass(); ~PENewClass() override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
// Class objects don't have a useful width, but the expression // Class objects don't have a useful width, but the expression
// is IVL_VT_CLASS. // is IVL_VT_CLASS.
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
// Note that class (new) expressions only appear in context // Note that class (new) expressions only appear in context
// that uses this form of the elaborate_expr method. In fact, // that uses this form of the elaborate_expr method. In fact,
// the type argument is going to be a netclass_t object. // the type argument is going to be a netclass_t object.
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
private: private:
NetExpr* elaborate_expr_constructor_(Design*des, NetScope*scope, NetExpr* elaborate_expr_constructor_(Design*des, NetScope*scope,
@ -613,18 +613,18 @@ class PENewClass : public PExpr {
class PENewCopy : public PExpr { class PENewCopy : public PExpr {
public: public:
explicit PENewCopy(PExpr*src); explicit PENewCopy(PExpr*src);
~PENewCopy(); ~PENewCopy() override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
// Class objects don't have a useful width, but the expression // Class objects don't have a useful width, but the expression
// is IVL_VT_CLASS. // is IVL_VT_CLASS.
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
// Note that class (new) expressions only appear in context // Note that class (new) expressions only appear in context
// that uses this form of the elaborate_expr method. In fact, // that uses this form of the elaborate_expr method. In fact,
// the type argument is going to be a netclass_t object. // the type argument is going to be a netclass_t object.
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
private: private:
PExpr*src_; PExpr*src_;
@ -633,39 +633,39 @@ class PENewCopy : public PExpr {
class PENull : public PExpr { class PENull : public PExpr {
public: public:
explicit PENull(); explicit PENull();
~PENull(); ~PENull() override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*, virtual NetExpr*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
}; };
class PENumber : public PExpr { class PENumber : public PExpr {
public: public:
explicit PENumber(verinum*vp); explicit PENumber(verinum*vp);
~PENumber(); ~PENumber() override;
const verinum& value() const; const verinum& value() const;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetExpr *elaborate_expr(Design*des, NetScope*scope, virtual NetExpr *elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
virtual NetEConst*elaborate_expr(Design*des, NetScope*, virtual NetEConst*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid, unsigned) const; unsigned expr_wid, unsigned) const override;
virtual NetAssign_* elaborate_lval(Design*des, virtual NetAssign_* elaborate_lval(Design*des,
NetScope*scope, NetScope*scope,
bool is_cassign, bool is_cassign,
bool is_force, bool is_force,
bool is_init = false) const; bool is_init = false) const override;
private: private:
verinum*const value_; verinum*const value_;
@ -682,19 +682,19 @@ class PEString : public PExpr {
public: public:
explicit PEString(char*s); explicit PEString(char*s);
~PEString(); ~PEString() override;
std::string value() const; std::string value() const;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetEConst*elaborate_expr(Design*des, NetScope*scope, virtual NetEConst*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
virtual NetEConst*elaborate_expr(Design*des, NetScope*, virtual NetEConst*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid, unsigned) const; unsigned expr_wid, unsigned) const override;
private: private:
char*text_; char*text_;
@ -703,13 +703,13 @@ class PEString : public PExpr {
class PETypename : public PExpr { class PETypename : public PExpr {
public: public:
explicit PETypename(data_type_t*data_type); explicit PETypename(data_type_t*data_type);
~PETypename(); ~PETypename() override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
inline data_type_t* get_type() const { return data_type_; } inline data_type_t* get_type() const { return data_type_; }
@ -721,20 +721,20 @@ class PEUnary : public PExpr {
public: public:
explicit PEUnary(char op, PExpr*ex); explicit PEUnary(char op, PExpr*ex);
~PEUnary(); ~PEUnary() override;
virtual void dump(std::ostream&out) const; virtual void dump(std::ostream&out) const override;
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type); virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type) override;
virtual bool has_aa_term(Design*des, NetScope*scope) const; virtual bool has_aa_term(Design*des, NetScope*scope) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*, virtual NetExpr*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
public: public:
inline char get_op() const { return op_; } inline char get_op() const { return op_; }
@ -752,20 +752,20 @@ class PEBinary : public PExpr {
public: public:
explicit PEBinary(char op, PExpr*l, PExpr*r); explicit PEBinary(char op, PExpr*l, PExpr*r);
~PEBinary(); ~PEBinary() override;
virtual void dump(std::ostream&out) const; virtual void dump(std::ostream&out) const override;
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type); virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type) override;
virtual bool has_aa_term(Design*des, NetScope*scope) const; virtual bool has_aa_term(Design*des, NetScope*scope) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*, virtual NetExpr*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
protected: protected:
char op_; char op_;
@ -796,13 +796,13 @@ class PEBComp : public PEBinary {
public: public:
explicit PEBComp(char op, PExpr*l, PExpr*r); explicit PEBComp(char op, PExpr*l, PExpr*r);
~PEBComp(); ~PEBComp() override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
NetExpr* elaborate_expr(Design*des, NetScope*scope, NetExpr* elaborate_expr(Design*des, NetScope*scope,
unsigned expr_wid, unsigned flags) const; unsigned expr_wid, unsigned flags) const override;
private: private:
unsigned l_width_; unsigned l_width_;
@ -816,13 +816,13 @@ class PEBLogic : public PEBinary {
public: public:
explicit PEBLogic(char op, PExpr*l, PExpr*r); explicit PEBLogic(char op, PExpr*l, PExpr*r);
~PEBLogic(); ~PEBLogic() override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
NetExpr* elaborate_expr(Design*des, NetScope*scope, NetExpr* elaborate_expr(Design*des, NetScope*scope,
unsigned expr_wid, unsigned flags) const; unsigned expr_wid, unsigned flags) const override;
}; };
/* /*
@ -834,38 +834,38 @@ class PEBLeftWidth : public PEBinary {
public: public:
explicit PEBLeftWidth(char op, PExpr*l, PExpr*r); explicit PEBLeftWidth(char op, PExpr*l, PExpr*r);
~PEBLeftWidth() =0; ~PEBLeftWidth() override =0;
virtual NetExpr*elaborate_expr_leaf(Design*des, NetExpr*lp, NetExpr*rp, virtual NetExpr*elaborate_expr_leaf(Design*des, NetExpr*lp, NetExpr*rp,
unsigned expr_wid) const =0; unsigned expr_wid) const =0;
protected: protected:
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
}; };
class PEBPower : public PEBLeftWidth { class PEBPower : public PEBLeftWidth {
public: public:
explicit PEBPower(char op, PExpr*l, PExpr*r); explicit PEBPower(char op, PExpr*l, PExpr*r);
~PEBPower(); ~PEBPower() override;
NetExpr*elaborate_expr_leaf(Design*des, NetExpr*lp, NetExpr*rp, NetExpr*elaborate_expr_leaf(Design*des, NetExpr*lp, NetExpr*rp,
unsigned expr_wid) const; unsigned expr_wid) const override;
}; };
class PEBShift : public PEBLeftWidth { class PEBShift : public PEBLeftWidth {
public: public:
explicit PEBShift(char op, PExpr*l, PExpr*r); explicit PEBShift(char op, PExpr*l, PExpr*r);
~PEBShift(); ~PEBShift() override;
NetExpr*elaborate_expr_leaf(Design*des, NetExpr*lp, NetExpr*rp, NetExpr*elaborate_expr_leaf(Design*des, NetExpr*lp, NetExpr*rp,
unsigned expr_wid) const; unsigned expr_wid) const override;
}; };
/* /*
@ -876,20 +876,20 @@ class PETernary : public PExpr {
public: public:
explicit PETernary(PExpr*e, PExpr*t, PExpr*f); explicit PETernary(PExpr*e, PExpr*t, PExpr*f);
~PETernary(); ~PETernary() override;
virtual void dump(std::ostream&out) const; virtual void dump(std::ostream&out) const override;
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type); virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type) override;
virtual bool has_aa_term(Design*des, NetScope*scope) const; virtual bool has_aa_term(Design*des, NetScope*scope) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*, virtual NetExpr*elaborate_expr(Design*des, NetScope*,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
private: private:
NetExpr* elab_and_eval_alternative_(Design*des, NetScope*scope, NetExpr* elab_and_eval_alternative_(Design*des, NetScope*scope,
@ -924,22 +924,22 @@ class PECallFunction : public PExpr {
explicit PECallFunction(const pform_name_t &n, const std::list<named_pexpr_t> &parms); explicit PECallFunction(const pform_name_t &n, const std::list<named_pexpr_t> &parms);
explicit PECallFunction(perm_string n, const std::list<named_pexpr_t> &parms); explicit PECallFunction(perm_string n, const std::list<named_pexpr_t> &parms);
~PECallFunction(); ~PECallFunction() override;
virtual void dump(std::ostream &) const; virtual void dump(std::ostream &) const override;
virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type); virtual void declare_implicit_nets(LexicalScope*scope, NetNet::Type type) override;
virtual bool has_aa_term(Design*des, NetScope*scope) const; virtual bool has_aa_term(Design*des, NetScope*scope) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
unsigned expr_wid, unsigned flags) const; unsigned expr_wid, unsigned flags) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
private: private:
pform_scoped_name_t path_; pform_scoped_name_t path_;
@ -991,18 +991,18 @@ class PECastSize : public PExpr {
public: public:
explicit PECastSize(PExpr*size, PExpr*base); explicit PECastSize(PExpr*size, PExpr*base);
~PECastSize(); ~PECastSize() override;
void dump(std::ostream &out) const; void dump(std::ostream &out) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
virtual bool has_aa_term(Design *des, NetScope *scope) const; virtual bool has_aa_term(Design *des, NetScope *scope) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
private: private:
PExpr* size_; PExpr* size_;
@ -1016,20 +1016,20 @@ class PECastType : public PExpr {
public: public:
explicit PECastType(data_type_t*target, PExpr*base); explicit PECastType(data_type_t*target, PExpr*base);
~PECastType(); ~PECastType() override;
void dump(std::ostream &out) const; void dump(std::ostream &out) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
ivl_type_t type, unsigned flags) const; ivl_type_t type, unsigned flags) const override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
unsigned expr_wid, unsigned flags) const; unsigned expr_wid, unsigned flags) const override;
virtual bool has_aa_term(Design *des, NetScope *scope) const; virtual bool has_aa_term(Design *des, NetScope *scope) const override;
virtual unsigned test_width(Design*des, NetScope*scope, virtual unsigned test_width(Design*des, NetScope*scope,
width_mode_t&mode); width_mode_t&mode) override;
private: private:
data_type_t* target_; data_type_t* target_;
@ -1044,16 +1044,16 @@ class PECastSign : public PExpr {
public: public:
explicit PECastSign(bool signed_flag, PExpr *base); explicit PECastSign(bool signed_flag, PExpr *base);
~PECastSign() = default; ~PECastSign() override = default;
void dump(std::ostream &out) const; void dump(std::ostream &out) const override;
NetExpr* elaborate_expr(Design *des, NetScope *scope, NetExpr* elaborate_expr(Design *des, NetScope *scope,
unsigned expr_wid, unsigned flags) const; unsigned expr_wid, unsigned flags) const override;
virtual bool has_aa_term(Design *des, NetScope *scope) const; virtual bool has_aa_term(Design *des, NetScope *scope) const override;
unsigned test_width(Design *des, NetScope *scope, width_mode_t &mode); unsigned test_width(Design *des, NetScope *scope, width_mode_t &mode) override;
private: private:
std::unique_ptr<PExpr> base_; std::unique_ptr<PExpr> base_;
@ -1067,11 +1067,11 @@ class PEVoid : public PExpr {
public: public:
explicit PEVoid(); explicit PEVoid();
~PEVoid(); ~PEVoid() override;
virtual NetExpr*elaborate_expr(Design*des, NetScope*scope, virtual NetExpr*elaborate_expr(Design*des, NetScope*scope,
unsigned expr_wid, unsigned expr_wid,
unsigned flags) const; unsigned flags) const override;
}; };
#endif /* IVL_PExpr_H */ #endif /* IVL_PExpr_H */

32
PGate.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_PGate_H #ifndef IVL_PGate_H
#define IVL_PGate_H #define IVL_PGate_H
/* /*
* Copyright (c) 1998-2021 Stephen Williams (steve@icarus.com) * Copyright (c) 1998-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -57,7 +57,7 @@ class PGate : public PNamedItem {
explicit PGate(perm_string name, std::list<PExpr*>*pins); explicit PGate(perm_string name, std::list<PExpr*>*pins);
virtual ~PGate(); virtual ~PGate() override;
void set_ranges(std::list<pform_range_t>*ranges); void set_ranges(std::list<pform_range_t>*ranges);
bool is_array() const { return ranges_ != 0; } bool is_array() const { return ranges_ != 0; }
@ -90,7 +90,7 @@ class PGate : public PNamedItem {
virtual void elaborate_scope(Design*des, NetScope*sc) const; virtual void elaborate_scope(Design*des, NetScope*sc) const;
virtual bool elaborate_sig(Design*des, NetScope*scope) const; virtual bool elaborate_sig(Design*des, NetScope*scope) const;
SymbolType symbol_type() const; SymbolType symbol_type() const override;
protected: protected:
const std::vector<PExpr*>& get_pins() const { return pins_; } const std::vector<PExpr*>& get_pins() const { return pins_; }
@ -127,11 +127,11 @@ class PGAssign : public PGate {
public: public:
explicit PGAssign(std::list<PExpr*>*pins); explicit PGAssign(std::list<PExpr*>*pins);
explicit PGAssign(std::list<PExpr*>*pins, std::list<PExpr*>*dels); explicit PGAssign(std::list<PExpr*>*pins, std::list<PExpr*>*dels);
~PGAssign(); ~PGAssign() override;
void dump(std::ostream&out, unsigned ind =4) const; void dump(std::ostream&out, unsigned ind =4) const override;
virtual void elaborate(Design*des, NetScope*scope) const; virtual void elaborate(Design*des, NetScope*scope) const override;
virtual bool elaborate_sig(Design*des, NetScope*scope) const; virtual bool elaborate_sig(Design*des, NetScope*scope) const override;
private: private:
void elaborate_unpacked_array_(Design*des, NetScope*scope, NetNet*lval) const; void elaborate_unpacked_array_(Design*des, NetScope*scope, NetNet*lval) const;
@ -163,14 +163,14 @@ class PGBuiltin : public PGate {
explicit PGBuiltin(Type t, perm_string name, explicit PGBuiltin(Type t, perm_string name,
std::list<PExpr*>*pins, std::list<PExpr*>*pins,
PExpr*del); PExpr*del);
~PGBuiltin(); ~PGBuiltin() override;
Type type() const { return type_; } Type type() const { return type_; }
const char * gate_name() const; const char * gate_name() const;
virtual void dump(std::ostream&out, unsigned ind =4) const; virtual void dump(std::ostream&out, unsigned ind =4) const override;
virtual void elaborate(Design*, NetScope*scope) const; virtual void elaborate(Design*, NetScope*scope) const override;
virtual bool elaborate_sig(Design*des, NetScope*scope) const; virtual bool elaborate_sig(Design*des, NetScope*scope) const override;
private: private:
void calculate_gate_and_lval_count_(unsigned&gate_count, void calculate_gate_and_lval_count_(unsigned&gate_count,
@ -210,7 +210,7 @@ class PGModule : public PGate {
// constructor. // constructor.
explicit PGModule(Module*type, perm_string name); explicit PGModule(Module*type, perm_string name);
~PGModule(); ~PGModule() override;
// Parameter overrides can come as an ordered list, or a set // Parameter overrides can come as an ordered list, or a set
// of named expressions. // of named expressions.
@ -219,10 +219,10 @@ class PGModule : public PGate {
std::map<perm_string,PExpr*> attributes; std::map<perm_string,PExpr*> attributes;
virtual void dump(std::ostream&out, unsigned ind =4) const; virtual void dump(std::ostream&out, unsigned ind =4) const override;
virtual void elaborate(Design*, NetScope*scope) const; virtual void elaborate(Design*, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*sc) const; virtual void elaborate_scope(Design*des, NetScope*sc) const override;
virtual bool elaborate_sig(Design*des, NetScope*scope) const; virtual bool elaborate_sig(Design*des, NetScope*scope) const override;
// This returns the module name of this module. It is a // This returns the module name of this module. It is a
// permallocated string. // permallocated string.

6
PGenerate.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_PGenerate_H #ifndef IVL_PGenerate_H
#define IVL_PGenerate_H #define IVL_PGenerate_H
/* /*
* Copyright (c) 2006-2021 Stephen Williams (steve@icarus.com) * Copyright (c) 2006-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -54,7 +54,7 @@ class PGenerate : public PNamedItem, public LexicalScope {
public: public:
explicit PGenerate(LexicalScope*parent, unsigned id_number); explicit PGenerate(LexicalScope*parent, unsigned id_number);
~PGenerate(); ~PGenerate() override;
// Generate schemes have an ID number, for when the scope is // Generate schemes have an ID number, for when the scope is
// implicit. // implicit.
@ -112,7 +112,7 @@ class PGenerate : public PNamedItem, public LexicalScope {
void dump(std::ostream&out, unsigned indent) const; void dump(std::ostream&out, unsigned indent) const;
SymbolType symbol_type() const; SymbolType symbol_type() const override;
private: private:
void check_for_valid_genvar_value_(long value); void check_for_valid_genvar_value_(long value);

34
PTask.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_PTask_H #ifndef IVL_PTask_H
#define IVL_PTask_H #define IVL_PTask_H
/* /*
* Copyright (c) 1999-2021 Stephen Williams (steve@icarus.com) * Copyright (c) 1999-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -39,9 +39,9 @@ class PTaskFunc : public PScope, public PNamedItem {
public: public:
PTaskFunc(perm_string name, LexicalScope*parent); PTaskFunc(perm_string name, LexicalScope*parent);
~PTaskFunc(); ~PTaskFunc() override;
bool var_init_needs_explicit_lifetime() const; bool var_init_needs_explicit_lifetime() const override;
void set_ports(std::vector<pform_tf_port_t>*p); void set_ports(std::vector<pform_tf_port_t>*p);
@ -80,7 +80,7 @@ class PTask : public PTaskFunc {
public: public:
explicit PTask(perm_string name, LexicalScope*parent, bool is_auto); explicit PTask(perm_string name, LexicalScope*parent, bool is_auto);
~PTask(); ~PTask() override;
void set_statement(Statement *s); void set_statement(Statement *s);
@ -91,16 +91,16 @@ class PTask : public PTaskFunc {
void elaborate_scope(Design*des, NetScope*scope) const; void elaborate_scope(Design*des, NetScope*scope) const;
// Bind the ports to the regs that are the ports. // Bind the ports to the regs that are the ports.
void elaborate_sig(Design*des, NetScope*scope) const; void elaborate_sig(Design*des, NetScope*scope) const override;
// Elaborate the statement to finish off the task definition. // Elaborate the statement to finish off the task definition.
void elaborate(Design*des, NetScope*scope) const; void elaborate(Design*des, NetScope*scope) const override;
bool is_auto() const { return is_auto_; }; bool is_auto() const { return is_auto_; };
void dump(std::ostream&, unsigned) const; void dump(std::ostream&, unsigned) const override;
SymbolType symbol_type() const; SymbolType symbol_type() const override;
private: private:
Statement*statement_; Statement*statement_;
@ -122,7 +122,7 @@ class PFunction : public PTaskFunc {
public: public:
explicit PFunction(perm_string name, LexicalScope*parent, bool is_auto); explicit PFunction(perm_string name, LexicalScope*parent, bool is_auto);
~PFunction(); ~PFunction() override;
void set_statement(Statement *s); void set_statement(Statement *s);
void set_return(data_type_t*t); void set_return(data_type_t*t);
@ -142,16 +142,16 @@ class PFunction : public PTaskFunc {
void elaborate_scope(Design*des, NetScope*scope) const; void elaborate_scope(Design*des, NetScope*scope) const;
/* elaborate the ports and return value. */ /* elaborate the ports and return value. */
void elaborate_sig(Design *des, NetScope*) const; void elaborate_sig(Design *des, NetScope*) const override;
/* Elaborate the behavioral statement. */ /* Elaborate the behavioral statement. */
void elaborate(Design *des, NetScope*) const; void elaborate(Design *des, NetScope*) const override;
bool is_auto() const { return is_auto_; }; bool is_auto() const { return is_auto_; };
void dump(std::ostream&, unsigned) const; void dump(std::ostream&, unsigned) const override;
SymbolType symbol_type() const; SymbolType symbol_type() const override;
private: private:
data_type_t* return_type_; data_type_t* return_type_;
@ -174,12 +174,12 @@ class PLet : public PTaskFunc {
// FIXME: Should the port list be a vector. Check once implemented completely // FIXME: Should the port list be a vector. Check once implemented completely
explicit PLet(perm_string name, LexicalScope*parent, explicit PLet(perm_string name, LexicalScope*parent,
std::list<let_port_t*>*ports, PExpr*expr); std::list<let_port_t*>*ports, PExpr*expr);
~PLet(); ~PLet() override;
void elaborate_sig(Design*des, NetScope*scope) const { (void)des; (void)scope; } void elaborate_sig(Design*des, NetScope*scope) const override { (void)des; (void)scope; }
void elaborate(Design*des, NetScope*scope) const { (void)des; (void)scope; } void elaborate(Design*des, NetScope*scope) const override { (void)des; (void)scope; }
void dump(std::ostream&, unsigned) const; void dump(std::ostream&, unsigned) const override;
private: private:
std::list<let_port_t*>*ports_; std::list<let_port_t*>*ports_;

8
PTimingCheck.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_PTimingCheck_H #ifndef IVL_PTimingCheck_H
#define IVL_PTimingCheck_H #define IVL_PTimingCheck_H
/* /*
* Copyright (c) 2006-2023 Stephen Williams <steve@icarus.com> * Copyright (c) 2006-2025 Stephen Williams <steve@icarus.com>
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -52,7 +52,7 @@ class PTimingCheck : public LineInfo {
}; };
PTimingCheck() { } PTimingCheck() { }
virtual ~PTimingCheck() { } virtual ~PTimingCheck() override { }
virtual void elaborate(class Design*des, class NetScope*scope) const = 0; virtual void elaborate(class Design*des, class NetScope*scope) const = 0;
@ -76,7 +76,7 @@ class PRecRem : public PTimingCheck {
pform_name_t* delayed_reference, pform_name_t* delayed_reference,
pform_name_t* delayed_data); pform_name_t* delayed_data);
~PRecRem(); ~PRecRem() override;
void elaborate(class Design*des, class NetScope*scope) const override; void elaborate(class Design*des, class NetScope*scope) const override;
@ -114,7 +114,7 @@ class PSetupHold : public PTimingCheck {
pform_name_t* delayed_reference, pform_name_t* delayed_reference,
pform_name_t* delayed_data); pform_name_t* delayed_data);
~PSetupHold(); ~PSetupHold() override;
void elaborate(class Design*des, class NetScope*scope) const override; void elaborate(class Design*des, class NetScope*scope) const override;

4
PWire.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_PWire_H #ifndef IVL_PWire_H
#define IVL_PWire_H #define IVL_PWire_H
/* /*
* Copyright (c) 1998-2024 Stephen Williams (steve@icarus.com) * Copyright (c) 1998-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -93,7 +93,7 @@ class PWire : public PNamedItem {
NetNet* elaborate_sig(Design*, NetScope*scope); NetNet* elaborate_sig(Design*, NetScope*scope);
SymbolType symbol_type() const; SymbolType symbol_type() const override;
bool is_net() const { return net_set_; }; bool is_net() const { return net_set_; };
bool is_port() const { return port_set_; }; bool is_port() const { return port_set_; };

204
Statement.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_Statement_H #ifndef IVL_Statement_H
#define IVL_Statement_H #define IVL_Statement_H
/* /*
* Copyright (c) 1998-2024 Stephen Williams (steve@icarus.com) * Copyright (c) 1998-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -53,7 +53,7 @@ class PProcess : public LineInfo {
PProcess(ivl_process_type_t t, Statement*st) PProcess(ivl_process_type_t t, Statement*st)
: type_(t), statement_(st) { } : type_(t), statement_(st) { }
virtual ~PProcess(); virtual ~PProcess() override;
bool elaborate(Design*des, NetScope*scope) const; bool elaborate(Design*des, NetScope*scope) const;
@ -78,7 +78,7 @@ class Statement : virtual public LineInfo {
public: public:
Statement() { } Statement() { }
virtual ~Statement() =0; virtual ~Statement() override =0;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const;
@ -99,7 +99,7 @@ class PAssign_ : public Statement {
bool is_init = false); bool is_init = false);
explicit PAssign_(PExpr*lval, PExpr*de, PExpr*ex); explicit PAssign_(PExpr*lval, PExpr*de, PExpr*ex);
explicit PAssign_(PExpr*lval, PExpr*cnt, PEventStatement*de, PExpr*ex); explicit PAssign_(PExpr*lval, PExpr*cnt, PEventStatement*de, PExpr*ex);
virtual ~PAssign_() =0; virtual ~PAssign_() override =0;
const PExpr* lval() const { return lval_; } const PExpr* lval() const { return lval_; }
PExpr* rval() const { return rval_; } PExpr* rval() const { return rval_; }
@ -139,10 +139,10 @@ class PAssign : public PAssign_ {
explicit PAssign(PExpr*lval, PExpr*de, PExpr*ex); explicit PAssign(PExpr*lval, PExpr*de, PExpr*ex);
explicit PAssign(PExpr*lval, PExpr*cnt, PEventStatement*de, PExpr*ex); explicit PAssign(PExpr*lval, PExpr*cnt, PEventStatement*de, PExpr*ex);
explicit PAssign(PExpr*lval, PExpr*ex, bool is_constant, bool is_init); explicit PAssign(PExpr*lval, PExpr*ex, bool is_constant, bool is_init);
~PAssign(); ~PAssign() override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
private: private:
NetProc* elaborate_compressed_(Design*des, NetScope*scope) const; NetProc* elaborate_compressed_(Design*des, NetScope*scope) const;
@ -155,10 +155,10 @@ class PAssignNB : public PAssign_ {
explicit PAssignNB(PExpr*lval, PExpr*ex); explicit PAssignNB(PExpr*lval, PExpr*ex);
explicit PAssignNB(PExpr*lval, PExpr*de, PExpr*ex); explicit PAssignNB(PExpr*lval, PExpr*de, PExpr*ex);
explicit PAssignNB(PExpr*lval, PExpr*cnt, PEventStatement*de, PExpr*ex); explicit PAssignNB(PExpr*lval, PExpr*cnt, PEventStatement*de, PExpr*ex);
~PAssignNB(); ~PAssignNB() override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
private: private:
NetProc*assign_to_memory_(class NetMemory*, PExpr*, NetProc*assign_to_memory_(class NetMemory*, PExpr*,
@ -181,11 +181,11 @@ class PBlock : public PScope, public Statement, public PNamedItem {
explicit PBlock(perm_string n, LexicalScope*parent, BL_TYPE t); explicit PBlock(perm_string n, LexicalScope*parent, BL_TYPE t);
// If it doesn't have a name, it's not a scope // If it doesn't have a name, it's not a scope
explicit PBlock(BL_TYPE t); explicit PBlock(BL_TYPE t);
~PBlock(); ~PBlock() override;
BL_TYPE bl_type() const { return bl_type_; } BL_TYPE bl_type() const { return bl_type_; }
bool var_init_needs_explicit_lifetime() const; bool var_init_needs_explicit_lifetime() const override;
// This is only used if this block is the statement list for a // This is only used if this block is the statement list for a
// constructor. We look for a PChainConstructor as the first // constructor. We look for a PChainConstructor as the first
@ -202,12 +202,12 @@ class PBlock : public PScope, public Statement, public PNamedItem {
// block. // block.
void push_statement_front(Statement*that); void push_statement_front(Statement*that);
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
SymbolType symbol_type() const; SymbolType symbol_type() const override;
private: private:
BL_TYPE bl_type_; BL_TYPE bl_type_;
@ -216,8 +216,8 @@ class PBlock : public PScope, public Statement, public PNamedItem {
class PBreak : public Statement { class PBreak : public Statement {
public: public:
void dump(std::ostream&out, unsigned ind) const; void dump(std::ostream&out, unsigned ind) const override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
}; };
class PCallTask : public Statement { class PCallTask : public Statement {
@ -226,12 +226,12 @@ class PCallTask : public Statement {
explicit PCallTask(PPackage *pkg, const pform_name_t &n, const std::list<named_pexpr_t> &parms); explicit PCallTask(PPackage *pkg, const pform_name_t &n, const std::list<named_pexpr_t> &parms);
explicit PCallTask(const pform_name_t &n, const std::list<named_pexpr_t> &parms); explicit PCallTask(const pform_name_t &n, const std::list<named_pexpr_t> &parms);
explicit PCallTask(perm_string n, const std::list<named_pexpr_t> &parms); explicit PCallTask(perm_string n, const std::list<named_pexpr_t> &parms);
~PCallTask(); ~PCallTask() override;
const pform_name_t& path() const; const pform_name_t& path() const;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
bool elaborate_elab(Design*des, NetScope*scope) const; bool elaborate_elab(Design*des, NetScope*scope) const;
@ -282,12 +282,12 @@ class PCase : public Statement {
}; };
PCase(ivl_case_quality_t, NetCase::TYPE, PExpr*ex, std::vector<Item*>*); PCase(ivl_case_quality_t, NetCase::TYPE, PExpr*ex, std::vector<Item*>*);
~PCase(); ~PCase() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
ivl_case_quality_t quality_; ivl_case_quality_t quality_;
@ -305,10 +305,10 @@ class PCAssign : public Statement {
public: public:
explicit PCAssign(PExpr*l, PExpr*r); explicit PCAssign(PExpr*l, PExpr*r);
~PCAssign(); ~PCAssign() override;
virtual NetCAssign* elaborate(Design*des, NetScope*scope) const; virtual NetCAssign* elaborate(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
PExpr*lval_; PExpr*lval_;
@ -324,10 +324,10 @@ class PChainConstructor : public Statement {
public: public:
explicit PChainConstructor(const std::list<named_pexpr_t> &parms); explicit PChainConstructor(const std::list<named_pexpr_t> &parms);
explicit PChainConstructor(const std::vector<named_pexpr_t> &parms); explicit PChainConstructor(const std::vector<named_pexpr_t> &parms);
~PChainConstructor(); ~PChainConstructor() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
inline const std::vector<named_pexpr_t>& chain_args(void) const inline const std::vector<named_pexpr_t>& chain_args(void) const
{ return parms_; } { return parms_; }
@ -340,12 +340,12 @@ class PCondit : public Statement {
public: public:
PCondit(PExpr*ex, Statement*i, Statement*e); PCondit(PExpr*ex, Statement*i, Statement*e);
~PCondit(); ~PCondit() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
PExpr*expr_; PExpr*expr_;
@ -360,18 +360,18 @@ class PCondit : public Statement {
class PContinue : public Statement { class PContinue : public Statement {
public: public:
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
}; };
class PDeassign : public Statement { class PDeassign : public Statement {
public: public:
explicit PDeassign(PExpr*l); explicit PDeassign(PExpr*l);
~PDeassign(); ~PDeassign() override;
virtual NetDeassign* elaborate(Design*des, NetScope*scope) const; virtual NetDeassign* elaborate(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
PExpr*lval_; PExpr*lval_;
@ -381,12 +381,12 @@ class PDelayStatement : public Statement {
public: public:
PDelayStatement(PExpr*d, Statement*st); PDelayStatement(PExpr*d, Statement*st);
~PDelayStatement(); ~PDelayStatement() override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
private: private:
PExpr*delay_; PExpr*delay_;
@ -401,10 +401,10 @@ class PDisable : public Statement {
public: public:
explicit PDisable(const pform_name_t&sc); explicit PDisable(const pform_name_t&sc);
~PDisable(); ~PDisable() override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
private: private:
pform_name_t scope_; pform_name_t scope_;
@ -414,12 +414,12 @@ class PDoWhile : public Statement {
public: public:
PDoWhile(PExpr*ex, Statement*st); PDoWhile(PExpr*ex, Statement*st);
~PDoWhile(); ~PDoWhile() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
PExpr*cond_; PExpr*cond_;
@ -444,17 +444,17 @@ class PEventStatement : public Statement {
// from functions added and outputs removed for always_comb/latch. // from functions added and outputs removed for always_comb/latch.
explicit PEventStatement(bool always_sens = false); explicit PEventStatement(bool always_sens = false);
~PEventStatement(); ~PEventStatement() override;
void set_statement(Statement*st); void set_statement(Statement*st);
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
// Call this with a NULL statement only. It is used to print // Call this with a NULL statement only. It is used to print
// the event expression for inter-assignment event controls. // the event expression for inter-assignment event controls.
virtual void dump_inline(std::ostream&out) const; virtual void dump_inline(std::ostream&out) const;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
bool has_aa_term(Design*des, NetScope*scope); bool has_aa_term(Design*des, NetScope*scope);
@ -477,10 +477,10 @@ class PForce : public Statement {
public: public:
explicit PForce(PExpr*l, PExpr*r); explicit PForce(PExpr*l, PExpr*r);
~PForce(); ~PForce() override;
virtual NetForce* elaborate(Design*des, NetScope*scope) const; virtual NetForce* elaborate(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
PExpr*lval_; PExpr*lval_;
@ -490,12 +490,12 @@ class PForce : public Statement {
class PForeach : public Statement { class PForeach : public Statement {
public: public:
explicit PForeach(perm_string var, const std::list<perm_string>&ix, Statement*stmt); explicit PForeach(perm_string var, const std::list<perm_string>&ix, Statement*stmt);
~PForeach(); ~PForeach() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
NetProc* elaborate_static_array_(Design*des, NetScope*scope, NetProc* elaborate_static_array_(Design*des, NetScope*scope,
@ -510,12 +510,12 @@ class PForeach : public Statement {
class PForever : public Statement { class PForever : public Statement {
public: public:
explicit PForever(Statement*s); explicit PForever(Statement*s);
~PForever(); ~PForever() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
Statement*statement_; Statement*statement_;
@ -526,12 +526,12 @@ class PForStatement : public Statement {
public: public:
PForStatement(PExpr*n1, PExpr*e1, PExpr*cond, PForStatement(PExpr*n1, PExpr*e1, PExpr*cond,
Statement*step, Statement*body); Statement*step, Statement*body);
~PForStatement(); ~PForStatement() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
PExpr* name1_; PExpr* name1_;
@ -548,18 +548,18 @@ class PNoop : public Statement {
public: public:
PNoop() { } PNoop() { }
~PNoop() { } ~PNoop() override { }
}; };
class PRepeat : public Statement { class PRepeat : public Statement {
public: public:
explicit PRepeat(PExpr*expr, Statement*s); explicit PRepeat(PExpr*expr, Statement*s);
~PRepeat(); ~PRepeat() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
PExpr*expr_; PExpr*expr_;
@ -570,10 +570,10 @@ class PRelease : public Statement {
public: public:
explicit PRelease(PExpr*l); explicit PRelease(PExpr*l);
~PRelease(); ~PRelease() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
PExpr*lval_; PExpr*lval_;
@ -583,10 +583,10 @@ class PReturn : public Statement {
public: public:
explicit PReturn(PExpr*e); explicit PReturn(PExpr*e);
~PReturn(); ~PReturn() override;
NetProc* elaborate(Design*des, NetScope*scope) const; NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
PExpr*expr_; PExpr*expr_;
@ -600,10 +600,10 @@ class PTrigger : public Statement {
public: public:
explicit PTrigger(PPackage*pkg, const pform_name_t&ev, unsigned lexical_pos); explicit PTrigger(PPackage*pkg, const pform_name_t&ev, unsigned lexical_pos);
~PTrigger(); ~PTrigger() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
pform_scoped_name_t event_; pform_scoped_name_t event_;
@ -613,10 +613,10 @@ class PTrigger : public Statement {
class PNBTrigger : public Statement { class PNBTrigger : public Statement {
public: public:
explicit PNBTrigger(const pform_name_t&ev, unsigned lexical_pos, PExpr*dly); explicit PNBTrigger(const pform_name_t&ev, unsigned lexical_pos, PExpr*dly);
~PNBTrigger(); ~PNBTrigger() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
pform_name_t event_; pform_name_t event_;
@ -628,12 +628,12 @@ class PWhile : public Statement {
public: public:
PWhile(PExpr*ex, Statement*st); PWhile(PExpr*ex, Statement*st);
~PWhile(); ~PWhile() override;
virtual NetProc* elaborate(Design*des, NetScope*scope) const; virtual NetProc* elaborate(Design*des, NetScope*scope) const override;
virtual void elaborate_scope(Design*des, NetScope*scope) const; virtual void elaborate_scope(Design*des, NetScope*scope) const override;
virtual void elaborate_sig(Design*des, NetScope*scope) const; virtual void elaborate_sig(Design*des, NetScope*scope) const override;
virtual void dump(std::ostream&out, unsigned ind) const; virtual void dump(std::ostream&out, unsigned ind) const override;
private: private:
PExpr*cond_; PExpr*cond_;

6
cadpli/Makefile.in
View File

@ -59,7 +59,11 @@ distclean: clean
rm -f Makefile config.log rm -f Makefile config.log
cppcheck: $(O:.o=.c) cppcheck: $(O:.o=.c)
cppcheck --enable=all --std=c99 --std=c++11 -f $(INCLUDE_PATH) $^ cppcheck --enable=all --std=c99 --std=c++11 -f \
--check-level=exhaustive \
--suppressions-list=$(srcdir)/../cppcheck-global.sup \
--suppressions-list=$(srcdir)/cppcheck.sup \
$(INCLUDE_PATH) $^
Makefile: $(srcdir)/Makefile.in ../config.status Makefile: $(srcdir)/Makefile.in ../config.status
cd ..; ./config.status --file=cadpli/$@ cd ..; ./config.status --file=cadpli/$@

7
cadpli/cppcheck.sup Normal file
View File

@ -0,0 +1,7 @@
// We use guarded memory allocation routines, but cppcheck is not
// noticing this so it is complaining we could return a NULL value.
nullPointerOutOfMemory:cadpli.c:53
nullPointerOutOfMemory:cadpli.c:54
// Unused function
unusedFunction:ivl_dlfcn.h:73

14
discipline.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_discipline_H #ifndef IVL_discipline_H
#define IVL_discipline_H #define IVL_discipline_H
/* /*
* Copyright (c) 2008-2021 Stephen Williams (steve@icarus.com) * Copyright (c) 2008-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -36,7 +36,7 @@ extern std::ostream& operator << (std::ostream&, ivl_dis_domain_t);
class ivl_nature_s : public LineInfo { class ivl_nature_s : public LineInfo {
public: public:
explicit ivl_nature_s(perm_string name, perm_string access); explicit ivl_nature_s(perm_string name, perm_string access);
~ivl_nature_s(); ~ivl_nature_s() override;
perm_string name() const { return name_; } perm_string name() const { return name_; }
// Identifier for the access function for this nature // Identifier for the access function for this nature
@ -51,12 +51,12 @@ class ivl_discipline_s : public LineInfo {
public: public:
explicit ivl_discipline_s (perm_string name, ivl_dis_domain_t dom, explicit ivl_discipline_s (perm_string name, ivl_dis_domain_t dom,
ivl_nature_t pot, ivl_nature_t flow); ivl_nature_t pot, ivl_nature_t flow);
~ivl_discipline_s(); ~ivl_discipline_s() override;
perm_string name() const { return name_; } perm_string name() const { return name_; }
ivl_dis_domain_t domain() const { return domain_; } ivl_dis_domain_t domain() const { return domain_; }
ivl_nature_t potential() const { return potential_; } ivl_nature_t potential() const { return potential_; }
ivl_nature_t flow() const { return flow_; } ivl_nature_t flow() const { return flow_; }
private: private:
perm_string name_; perm_string name_;

5
driver-vpi/Makefile.in
View File

@ -66,7 +66,10 @@ distclean: clean
rm -f Makefile config.log rm -f Makefile config.log
cppcheck: main.c cppcheck: main.c
cppcheck --enable=all --std=c99 --std=c++11 -f $(INCLUDE_PATH) $^ cppcheck --enable=all --std=c99 --std=c++11 -f \
--check-level=exhaustive \
--suppressions-list=$(srcdir)/../cppcheck-global.sup \
$(INCLUDE_PATH) $^
Makefile: $(srcdir)/Makefile.in ../config.status Makefile: $(srcdir)/Makefile.in ../config.status
cd ..; ./config.status --file=driver-vpi/$@ cd ..; ./config.status --file=driver-vpi/$@

20
ivl_alloc.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_ivl_alloc_H #ifndef IVL_ivl_alloc_H
#define IVL_ivl_alloc_H #define IVL_ivl_alloc_H
/* /*
* Copyright (C) 2010-2014 Cary R. (cygcary@yahoo.com) * Copyright (C) 2010-2025 Cary R. (cygcary@yahoo.com)
* *
* This program is free software; you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
@ -21,12 +21,30 @@
#ifdef __cplusplus #ifdef __cplusplus
# include <cstdlib> # include <cstdlib>
# include <cstdio> # include <cstdio>
# include <cstring>
#else #else
# include <stdlib.h> # include <stdlib.h>
# include <stdio.h> # include <stdio.h>
# include <string.h>
#endif #endif
#if defined(__GNUC__) #if defined(__GNUC__)
/*
* Define a safer version of strdup().
*/
#define strdup(__ivl_str) \
({ \
char *__ivl_rtn = strdup(__ivl_str); \
/* If we run out of memory then exit with a message. */ \
if (__ivl_rtn == NULL) { \
fprintf(stderr, "%s:%d: Error: strdup() ran out of memory.\n", \
__FILE__, __LINE__); \
exit(1); \
} \
__ivl_rtn; \
})
/* /*
* Define a safer version of malloc(). * Define a safer version of malloc().
*/ */

5
ivlpp/Makefile.in
View File

@ -60,7 +60,10 @@ distclean: clean
rm -f Makefile config.log rm -f Makefile config.log
cppcheck: $(O:.o=.c) cppcheck: $(O:.o=.c)
cppcheck --enable=all --std=c99 --std=c++11 -f $(INCLUDE_PATH) $^ cppcheck --enable=all --std=c99 --std=c++11 -f \
--check-level=exhaustive \
--suppressions-list=$(srcdir)/../cppcheck-global.sup \
$(INCLUDE_PATH) $^
Makefile: $(srcdir)/Makefile.in ../config.status Makefile: $(srcdir)/Makefile.in ../config.status
cd ..; ./config.status --file=ivlpp/$@ cd ..; ./config.status --file=ivlpp/$@

2
ivlpp/main.c
View File

@ -73,7 +73,7 @@ unsigned vhdlpp_libdir_cnt = 0;
static char**source_list = 0; static char**source_list = 0;
static unsigned source_cnt = 0; static unsigned source_cnt = 0;
void add_source_file(const char*name) static void add_source_file(const char*name)
{ {
if (source_list == 0) { if (source_list == 0) {
source_list = calloc(2, sizeof(char*)); source_list = calloc(2, sizeof(char*));

2
libveriuser/Makefile.in
View File

@ -77,6 +77,8 @@ distclean: clean
cppcheck: $(O:.o=.c) cppcheck: $(O:.o=.c)
cppcheck --enable=all --std=c99 --std=c++11 -f \ cppcheck --enable=all --std=c99 --std=c++11 -f \
--check-level=exhaustive \
--suppressions-list=$(srcdir)/../cppcheck-global.sup \
--suppressions-list=$(srcdir)/cppcheck.sup \ --suppressions-list=$(srcdir)/cppcheck.sup \
--relative-paths=$(srcdir) $(INCLUDE_PATH) $^ --relative-paths=$(srcdir) $(INCLUDE_PATH) $^

4
libveriuser/a_handle_object.c
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2003-2020 Stephen Williams (steve@icarus.com) * Copyright (c) 2003-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -38,7 +38,7 @@ handle acc_handle_object(const char*name)
char* acc_set_scope(handle ref, ...) char* acc_set_scope(handle ref, ...)
{ {
char*name; const char*name;
search_scope = ref; search_scope = ref;
name = acc_fetch_fullname(search_scope); name = acc_fetch_fullname(search_scope);

16
libveriuser/cppcheck.sup
View File

@ -1,3 +1,19 @@
// We use guarded memory allocation routines, but cppcheck is not
// noticing this so it is complaining we could return a NULL value.
nullPointerOutOfMemory:workarea.c:53 // calloc @ 52
nullPointerOutOfMemory:workarea.c:54 // calloc @ 52
nullPointerOutOfMemory:workarea.c:55 // calloc @ 52
nullPointerOutOfMemory:veriusertfs.c:61 // calloc @ 70
nullPointerOutOfMemory:veriusertfs.c:62 // calloc @ 70
nullPointerOutOfMemory:veriusertfs.c:63 // calloc @ 70
nullPointerOutOfMemory:a_vcl.c:167 // strdup @ 166
nullPointerOutOfMemory:a_vcl.c:168 // strdup @ 166
nullPointerOutOfMemory:a_vcl.c:169 // strdup @ 166
nullPointerOutOfMemory:a_vcl.c:170 // strdup @ 166
nullPointerOutOfMemory:a_vcl.c:171 // strdup @ 166
nullPointerOutOfMemory:a_vcl.c:180 // strdup @ 166
memleakOnRealloc:veriusertfs.c:66
// These are the functions that the runtime exports. // These are the functions that the runtime exports.
// The ACC functions. // The ACC functions.

7
libveriuser/mc_scan_plusargs.c
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2002-2013 Michael Ruff (mruff at chiaro.com) * Copyright (c) 2002-2025 Michael Ruff (mruff at chiaro.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -24,7 +24,7 @@
/* /*
* mc_scan_plusargs implemented using VPI interface * mc_scan_plusargs implemented using VPI interface
*/ */
char *mc_scan_plusargs(char *plusarg) char *mc_scan_plusargs(const char *plusarg)
{ {
int argc, diff; int argc, diff;
char **argv; char **argv;
@ -37,7 +37,8 @@ char *mc_scan_plusargs(char *plusarg)
/* for each argument */ /* for each argument */
argv = vpi_vlog_info.argv; argv = vpi_vlog_info.argv;
for (argc = 0; argc < vpi_vlog_info.argc; argc++, argv++) { for (argc = 0; argc < vpi_vlog_info.argc; argc++, argv++) {
char *a, *p; char *a;
const char *p;
a = *argv; a = *argv;
p = plusarg; p = plusarg;

27
main.cc
View File

@ -95,7 +95,10 @@ static void signals_handler(int sig)
unsigned flag_errors = 0; unsigned flag_errors = 0;
static unsigned long pre_process_fail_count = 0; static unsigned long pre_process_fail_count = 0;
const char*basedir = strdup("."); // We have to wrap the strdup() so that the define expands correctly.
static char* init_basedir(void)
{ return strdup("."); }
const char*basedir = init_basedir();
/* /*
* These are the language support control flags. These support which * These are the language support control flags. These support which
@ -130,10 +133,10 @@ void add_vpi_module(const char*name)
vpi_module_list = strdup(name); vpi_module_list = strdup(name);
} else { } else {
char*tmp = (char*)realloc(vpi_module_list, char*tmp = static_cast<char*>(realloc(vpi_module_list,
strlen(vpi_module_list) strlen(vpi_module_list)
+ strlen(name) + strlen(name)
+ 2); + 2));
strcat(tmp, ","); strcat(tmp, ",");
strcat(tmp, name); strcat(tmp, name);
vpi_module_list = tmp; vpi_module_list = tmp;
@ -647,7 +650,7 @@ static void read_iconfig_file(const char*ipath)
} }
if (strcmp(buf, "basedir") == 0) { if (strcmp(buf, "basedir") == 0) {
free((void *)basedir); free(static_cast<void*>(const_cast<char *>(basedir)));
basedir = strdup(cp); basedir = strdup(cp);
} else if (strcmp(buf, "debug") == 0) { } else if (strcmp(buf, "debug") == 0) {
@ -715,7 +718,7 @@ static void read_iconfig_file(const char*ipath)
add_vpi_module(cp); add_vpi_module(cp);
} else if (strcmp(buf, "out") == 0) { } else if (strcmp(buf, "out") == 0) {
free((void *)flags["-o"]); free(reinterpret_cast<void*>(const_cast<char*>(flags["-o"])));
flags["-o"] = strdup(cp); flags["-o"] = strdup(cp);
} else if (strcmp(buf, "sys_func") == 0) { } else if (strcmp(buf, "sys_func") == 0) {
@ -861,7 +864,7 @@ static void read_sources_file(const char*path)
extern Design* elaborate(list <perm_string> root); extern Design* elaborate(list <perm_string> root);
#if defined(HAVE_TIMES) #if defined(HAVE_TIMES)
static double cycles_diff(struct tms *a, struct tms *b) static double cycles_diff(const struct tms *a, const struct tms *b)
{ {
clock_t aa = a->tms_utime clock_t aa = a->tms_utime
+ a->tms_stime + a->tms_stime
@ -892,13 +895,13 @@ static void EOC_cleanup(void)
} }
library_suff.clear(); library_suff.clear();
free((void *) basedir); free(reinterpret_cast<void*>(const_cast<char*>(basedir)));
free(ivlpp_string); free(ivlpp_string);
free(depfile_name); free(depfile_name);
for (map<string, const char*>::iterator flg = flags.begin() ; for (map<string, const char*>::iterator flg = flags.begin() ;
flg != flags.end() ; ++ flg ) { flg != flags.end() ; ++ flg ) {
free((void *)flg->second); free(reinterpret_cast<void*>(const_cast<char*>(flg->second)));
} }
flags.clear(); flags.clear();
@ -1397,7 +1400,7 @@ static void find_module_mention(map<perm_string,bool>&check_map, Module*mod)
list<PGate*> gates = mod->get_gates(); list<PGate*> gates = mod->get_gates();
list<PGate*>::const_iterator gate; list<PGate*>::const_iterator gate;
for (gate = gates.begin(); gate != gates.end(); ++ gate ) { for (gate = gates.begin(); gate != gates.end(); ++ gate ) {
PGModule*tmp = dynamic_cast<PGModule*>(*gate); const PGModule*tmp = dynamic_cast<PGModule*>(*gate);
if (tmp) { if (tmp) {
// Note that this module has been instantiated // Note that this module has been instantiated
check_map[tmp->get_type()] = true; check_map[tmp->get_type()] = true;
@ -1415,7 +1418,7 @@ static void find_module_mention(map<perm_string,bool>&check_map, PGenerate*schm)
{ {
list<PGate*>::const_iterator gate; list<PGate*>::const_iterator gate;
for (gate = schm->gates.begin(); gate != schm->gates.end(); ++ gate ) { for (gate = schm->gates.begin(); gate != schm->gates.end(); ++ gate ) {
PGModule*tmp = dynamic_cast<PGModule*>(*gate); const PGModule*tmp = dynamic_cast<PGModule*>(*gate);
if (tmp) { if (tmp) {
// Note that this module has been instantiated // Note that this module has been instantiated
check_map[tmp->get_type()] = true; check_map[tmp->get_type()] = true;

338
netlist.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_netlist_H #ifndef IVL_netlist_H
#define IVL_netlist_H #define IVL_netlist_H
/* /*
* Copyright (c) 1998-2024 Stephen Williams (steve@icarus.com) * Copyright (c) 1998-2025 Stephen Williams (steve@icarus.com)
* Copyright CERN 2013 / Stephen Williams (steve@icarus.com) * Copyright CERN 2013 / Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
@ -4011,18 +4011,18 @@ class NetEAccess : public NetExpr {
public: public:
explicit NetEAccess(NetBranch*br, ivl_nature_t nat); explicit NetEAccess(NetBranch*br, ivl_nature_t nat);
~NetEAccess(); ~NetEAccess() override;
ivl_nature_t get_nature() const { return nature_; } ivl_nature_t get_nature() const { return nature_; }
NetBranch* get_branch() const { return branch_; } NetBranch* get_branch() const { return branch_; }
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual NetEAccess*dup_expr() const; virtual NetEAccess*dup_expr() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
private: private:
NetBranch*branch_; NetBranch*branch_;
@ -4038,19 +4038,19 @@ class NetUTask : public NetProc {
public: public:
explicit NetUTask(NetScope*); explicit NetUTask(NetScope*);
~NetUTask(); ~NetUTask() override;
const std::string name() const; const std::string name() const;
const NetScope* task() const; const NetScope* task() const;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void nex_output(NexusSet&); virtual void nex_output(NexusSet&) override;
virtual bool emit_proc(struct target_t*) const; virtual bool emit_proc(struct target_t*) const override;
virtual void dump(std::ostream&, unsigned ind) const; virtual void dump(std::ostream&, unsigned ind) const override;
virtual DelayType delay_type(bool print_delay=false) const; virtual DelayType delay_type(bool print_delay=false) const override;
virtual bool check_synth(ivl_process_type_t pr_type, const NetScope*scope) const; virtual bool check_synth(ivl_process_type_t pr_type, const NetScope*scope) const override;
private: private:
NetScope*task_; NetScope*task_;
@ -4072,14 +4072,14 @@ class NetWhile : public NetProc {
void emit_proc_recurse(struct target_t*) const; void emit_proc_recurse(struct target_t*) const;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void nex_output(NexusSet&); virtual void nex_output(NexusSet&) override;
virtual bool emit_proc(struct target_t*) const; virtual bool emit_proc(struct target_t*) const override;
virtual void dump(std::ostream&, unsigned ind) const; virtual void dump(std::ostream&, unsigned ind) const override;
virtual DelayType delay_type(bool print_delay=false) const; virtual DelayType delay_type(bool print_delay=false) const override;
virtual bool check_synth(ivl_process_type_t pr_type, const NetScope*scope) const; virtual bool check_synth(ivl_process_type_t pr_type, const NetScope*scope) const override;
virtual bool evaluate_function(const LineInfo&loc, virtual bool evaluate_function(const LineInfo&loc,
std::map<perm_string,LocalVar>&ctx) const; std::map<perm_string,LocalVar>&ctx) const override;
private: private:
NetExpr*cond_; NetExpr*cond_;
@ -4096,7 +4096,7 @@ class NetProcTop : public LineInfo, public Attrib {
public: public:
NetProcTop(NetScope*s, ivl_process_type_t t, class NetProc*st); NetProcTop(NetScope*s, ivl_process_type_t t, class NetProc*st);
~NetProcTop(); ~NetProcTop() override;
ivl_process_type_t type() const { return type_; } ivl_process_type_t type() const { return type_; }
NetProc*statement(); NetProc*statement();
@ -4141,7 +4141,7 @@ class NetAnalogTop : public LineInfo, public Attrib {
public: public:
NetAnalogTop(NetScope*scope, ivl_process_type_t t, NetProc*st); NetAnalogTop(NetScope*scope, ivl_process_type_t t, NetProc*st);
~NetAnalogTop(); ~NetAnalogTop() override;
ivl_process_type_t type() const { return type_; } ivl_process_type_t type() const { return type_; }
@ -4200,7 +4200,7 @@ class NetEBinary : public NetExpr {
public: public:
NetEBinary(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag); NetEBinary(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag);
~NetEBinary(); ~NetEBinary() override;
const NetExpr*left() const { return left_; } const NetExpr*left() const { return left_; }
const NetExpr*right() const { return right_; } const NetExpr*right() const { return right_; }
@ -4210,17 +4210,17 @@ class NetEBinary : public NetExpr {
// A binary expression node only has a definite // A binary expression node only has a definite
// self-determinable width if the operands both have definite // self-determinable width if the operands both have definite
// widths. // widths.
virtual bool has_width() const; virtual bool has_width() const override;
virtual NetEBinary* dup_expr() const; virtual NetEBinary* dup_expr() const override;
virtual NetExpr* eval_tree(); virtual NetExpr* eval_tree() override;
virtual NetExpr* evaluate_function(const LineInfo&loc, virtual NetExpr* evaluate_function(const LineInfo&loc,
std::map<perm_string,LocalVar>&ctx) const; std::map<perm_string,LocalVar>&ctx) const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
protected: protected:
char op_; char op_;
@ -4241,16 +4241,16 @@ class NetEBAdd : public NetEBinary {
public: public:
NetEBAdd(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag); NetEBAdd(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag);
~NetEBAdd(); ~NetEBAdd() override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual NetEBAdd* dup_expr() const; virtual NetEBAdd* dup_expr() const override;
virtual NetExpr* eval_tree(); virtual NetExpr* eval_tree() override;
virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override;
private: private:
virtual NetExpr* eval_arguments_(const NetExpr*l, const NetExpr*r) const; virtual NetExpr* eval_arguments_(const NetExpr*l, const NetExpr*r) const override;
NetECReal* eval_tree_real_(const NetExpr*l, const NetExpr*r) const; NetECReal* eval_tree_real_(const NetExpr*l, const NetExpr*r) const;
}; };
@ -4263,15 +4263,15 @@ class NetEBDiv : public NetEBinary {
public: public:
NetEBDiv(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag); NetEBDiv(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag);
~NetEBDiv(); ~NetEBDiv() override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual NetEBDiv* dup_expr() const; virtual NetEBDiv* dup_expr() const override;
virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override;
private: private:
virtual NetExpr* eval_arguments_(const NetExpr*l, const NetExpr*r) const; virtual NetExpr* eval_arguments_(const NetExpr*l, const NetExpr*r) const override;
NetExpr* eval_tree_real_(const NetExpr*l, const NetExpr*r) const; NetExpr* eval_tree_real_(const NetExpr*l, const NetExpr*r) const;
}; };
@ -4293,7 +4293,7 @@ class NetEBBits : public NetEBinary {
public: public:
NetEBBits(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag); NetEBBits(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag);
~NetEBBits(); ~NetEBBits() override;
virtual NetEBBits* dup_expr() const override; virtual NetEBBits* dup_expr() const override;
virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override; virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override;
@ -4322,18 +4322,18 @@ class NetEBComp : public NetEBinary {
public: public:
NetEBComp(char op, NetExpr*l, NetExpr*r); NetEBComp(char op, NetExpr*l, NetExpr*r);
~NetEBComp(); ~NetEBComp() override;
/* A compare expression has a definite width. */ /* A compare expression has a definite width. */
virtual bool has_width() const; virtual bool has_width() const override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual NetEBComp* dup_expr() const; virtual NetEBComp* dup_expr() const override;
virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override;
private: private:
NetEConst* must_be_leeq_(const NetExpr*le, const verinum&rv, bool eq_flag) const; NetEConst* must_be_leeq_(const NetExpr*le, const verinum&rv, bool eq_flag) const;
virtual NetEConst*eval_arguments_(const NetExpr*le, const NetExpr*re) const; virtual NetEConst*eval_arguments_(const NetExpr*le, const NetExpr*re) const override;
NetEConst*eval_eqeq_(bool ne_flag, const NetExpr*le, const NetExpr*re) const; NetEConst*eval_eqeq_(bool ne_flag, const NetExpr*le, const NetExpr*re) const;
NetEConst*eval_eqeq_real_(bool ne_flag, const NetExpr*le, const NetExpr*re) const; NetEConst*eval_eqeq_real_(bool ne_flag, const NetExpr*le, const NetExpr*re) const;
NetEConst*eval_less_(const NetExpr*le, const NetExpr*re) const; NetEConst*eval_less_(const NetExpr*le, const NetExpr*re) const;
@ -4378,12 +4378,12 @@ class NetEBMinMax : public NetEBinary {
public: public:
NetEBMinMax(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag); NetEBMinMax(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag);
~NetEBMinMax(); ~NetEBMinMax() override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
private: private:
virtual NetExpr* eval_arguments_(const NetExpr*l, const NetExpr*r) const; virtual NetExpr* eval_arguments_(const NetExpr*l, const NetExpr*r) const override;
NetExpr* eval_tree_real_(const NetExpr*l, const NetExpr*r) const; NetExpr* eval_tree_real_(const NetExpr*l, const NetExpr*r) const;
}; };
@ -4394,15 +4394,15 @@ class NetEBMult : public NetEBinary {
public: public:
NetEBMult(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag); NetEBMult(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag);
~NetEBMult(); ~NetEBMult() override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual NetEBMult* dup_expr() const; virtual NetEBMult* dup_expr() const override;
virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override;
private: private:
virtual NetExpr* eval_arguments_(const NetExpr*l, const NetExpr*r) const; virtual NetExpr* eval_arguments_(const NetExpr*l, const NetExpr*r) const override;
NetExpr* eval_tree_real_(const NetExpr*l, const NetExpr*r) const; NetExpr* eval_tree_real_(const NetExpr*l, const NetExpr*r) const;
}; };
@ -4413,15 +4413,15 @@ class NetEBPow : public NetEBinary {
public: public:
NetEBPow(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag); NetEBPow(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag);
~NetEBPow(); ~NetEBPow() override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual NetEBPow* dup_expr() const; virtual NetEBPow* dup_expr() const override;
virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override;
private: private:
virtual NetExpr* eval_arguments_(const NetExpr*l, const NetExpr*r) const; virtual NetExpr* eval_arguments_(const NetExpr*l, const NetExpr*r) const override;
NetExpr* eval_tree_real_(const NetExpr*l, const NetExpr*r) const; NetExpr* eval_tree_real_(const NetExpr*l, const NetExpr*r) const;
}; };
@ -4437,7 +4437,7 @@ class NetEBShift : public NetEBinary {
public: public:
NetEBShift(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag); NetEBShift(char op, NetExpr*l, NetExpr*r, unsigned wid, bool signed_flag);
~NetEBShift(); ~NetEBShift() override;
// A shift expression only needs the left expression to have a // A shift expression only needs the left expression to have a
// definite width to give the expression a definite width. // definite width to give the expression a definite width.
@ -4466,7 +4466,7 @@ class NetEConcat : public NetExpr {
public: public:
NetEConcat(unsigned cnt, unsigned repeat, ivl_variable_type_t vt); NetEConcat(unsigned cnt, unsigned repeat, ivl_variable_type_t vt);
~NetEConcat(); ~NetEConcat() override;
// Manipulate the parameters. // Manipulate the parameters.
void set(unsigned idx, NetExpr*e); void set(unsigned idx, NetExpr*e);
@ -4475,16 +4475,16 @@ class NetEConcat : public NetExpr {
unsigned nparms() const { return parms_.size() ; } unsigned nparms() const { return parms_.size() ; }
NetExpr* parm(unsigned idx) const { return parms_[idx]; } NetExpr* parm(unsigned idx) const { return parms_[idx]; }
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual NetEConcat* dup_expr() const; virtual NetEConcat* dup_expr() const override;
virtual NetEConst* eval_tree(); virtual NetEConst* eval_tree() override;
virtual NetExpr* evaluate_function(const LineInfo&loc, virtual NetExpr* evaluate_function(const LineInfo&loc,
std::map<perm_string,LocalVar>&ctx) const; std::map<perm_string,LocalVar>&ctx) const override;
virtual NetNet*synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet*synthesize(Design*, NetScope*scope, NetExpr*root) override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
private: private:
std::vector<NetExpr*>parms_; std::vector<NetExpr*>parms_;
@ -4520,7 +4520,7 @@ class NetESelect : public NetExpr {
ivl_select_type_t sel_type = IVL_SEL_OTHER); ivl_select_type_t sel_type = IVL_SEL_OTHER);
NetESelect(NetExpr*exp, NetExpr*base, unsigned wid, NetESelect(NetExpr*exp, NetExpr*base, unsigned wid,
ivl_type_t use_type); ivl_type_t use_type);
~NetESelect(); ~NetESelect() override;
const NetExpr*sub_expr() const; const NetExpr*sub_expr() const;
const NetExpr*select() const; const NetExpr*select() const;
@ -4529,17 +4529,17 @@ class NetESelect : public NetExpr {
// The type of a bit/part select is the base type of the // The type of a bit/part select is the base type of the
// sub-expression. The type of an array/member select is // sub-expression. The type of an array/member select is
// the base type of the element/member. // the base type of the element/member.
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual NetEConst* eval_tree(); virtual NetEConst* eval_tree() override;
virtual NetExpr*evaluate_function(const LineInfo&loc, virtual NetExpr*evaluate_function(const LineInfo&loc,
std::map<perm_string,LocalVar>&ctx) const; std::map<perm_string,LocalVar>&ctx) const override;
virtual NetESelect* dup_expr() const; virtual NetESelect* dup_expr() const;
virtual NetNet*synthesize(Design*des, NetScope*scope, NetExpr*root); virtual NetNet*synthesize(Design*des, NetScope*scope, NetExpr*root) override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
private: private:
NetExpr*expr_; NetExpr*expr_;
@ -4554,16 +4554,16 @@ class NetEEvent : public NetExpr {
public: public:
explicit NetEEvent(NetEvent*); explicit NetEEvent(NetEvent*);
~NetEEvent(); ~NetEEvent() override;
const NetEvent* event() const; const NetEvent* event() const;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual NetEEvent* dup_expr() const; virtual NetEEvent* dup_expr() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void dump(std::ostream&os) const; virtual void dump(std::ostream&os) const override;
private: private:
NetEvent*event_; NetEvent*event_;
@ -4578,16 +4578,16 @@ class NetENetenum : public NetExpr {
public: public:
explicit NetENetenum(const netenum_t*); explicit NetENetenum(const netenum_t*);
~NetENetenum(); ~NetENetenum() override;
const netenum_t* netenum() const; const netenum_t* netenum() const;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual NetENetenum* dup_expr() const; virtual NetENetenum* dup_expr() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void dump(std::ostream&os) const; virtual void dump(std::ostream&os) const override;
private: private:
const netenum_t*netenum_; const netenum_t*netenum_;
@ -4599,19 +4599,19 @@ class NetENew : public NetExpr {
explicit NetENew(ivl_type_t); explicit NetENew(ivl_type_t);
// dynamic array of objects. // dynamic array of objects.
explicit NetENew(ivl_type_t, NetExpr*size, NetExpr* init_val=0); explicit NetENew(ivl_type_t, NetExpr*size, NetExpr* init_val=0);
~NetENew(); ~NetENew() override;
inline const NetExpr*size_expr() const { return size_; } inline const NetExpr*size_expr() const { return size_; }
inline const NetExpr*init_expr() const { return init_val_; } inline const NetExpr*init_expr() const { return init_val_; }
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual NetENew* dup_expr() const; virtual NetENew* dup_expr() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void dump(std::ostream&os) const; virtual void dump(std::ostream&os) const override;
private: private:
NetExpr*size_; NetExpr*size_;
@ -4626,14 +4626,14 @@ class NetENull : public NetExpr {
public: public:
NetENull(); NetENull();
~NetENull(); ~NetENull() override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual NetENull* dup_expr() const; virtual NetENull* dup_expr() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void dump(std::ostream&os) const; virtual void dump(std::ostream&os) const override;
}; };
/* /*
@ -4647,19 +4647,19 @@ class NetENull : public NetExpr {
class NetEProperty : public NetExpr { class NetEProperty : public NetExpr {
public: public:
NetEProperty(NetNet*n, size_t pidx_, NetExpr*canon_index =0); NetEProperty(NetNet*n, size_t pidx_, NetExpr*canon_index =0);
~NetEProperty(); ~NetEProperty() override;
inline const NetNet* get_sig() const { return net_; } inline const NetNet* get_sig() const { return net_; }
inline size_t property_idx() const { return pidx_; } inline size_t property_idx() const { return pidx_; }
inline const NetExpr*get_index() const { return index_; } inline const NetExpr*get_index() const { return index_; }
public: // Overridden methods public: // Overridden methods
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual NetEProperty* dup_expr() const; virtual NetEProperty* dup_expr() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void dump(std::ostream&os) const; virtual void dump(std::ostream&os) const override;
private: private:
NetNet*net_; NetNet*net_;
@ -4676,16 +4676,16 @@ class NetEScope : public NetExpr {
public: public:
explicit NetEScope(NetScope*); explicit NetEScope(NetScope*);
~NetEScope(); ~NetEScope() override;
const NetScope* scope() const; const NetScope* scope() const;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual NetEScope* dup_expr() const; virtual NetEScope* dup_expr() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void dump(std::ostream&os) const; virtual void dump(std::ostream&os) const override;
private: private:
NetScope*scope_; NetScope*scope_;
@ -4702,7 +4702,7 @@ class NetESFunc : public NetExpr {
NetESFunc(const char*name, ivl_variable_type_t t, NetESFunc(const char*name, ivl_variable_type_t t,
unsigned width, unsigned nprms, bool is_overridden =false); unsigned width, unsigned nprms, bool is_overridden =false);
NetESFunc(const char*name, ivl_type_t rtype, unsigned nprms); NetESFunc(const char*name, ivl_type_t rtype, unsigned nprms);
~NetESFunc(); ~NetESFunc() override;
const char* name() const; const char* name() const;
@ -4711,18 +4711,18 @@ class NetESFunc : public NetExpr {
NetExpr* parm(unsigned idx); NetExpr* parm(unsigned idx);
const NetExpr* parm(unsigned idx) const; const NetExpr* parm(unsigned idx) const;
virtual NetExpr* eval_tree(); virtual NetExpr* eval_tree() override;
virtual NetExpr* evaluate_function(const LineInfo&loc, virtual NetExpr* evaluate_function(const LineInfo&loc,
std::map<perm_string,LocalVar>&ctx) const; std::map<perm_string,LocalVar>&ctx) const override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual NetESFunc*dup_expr() const; virtual NetESFunc*dup_expr() const override;
virtual NetNet*synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet*synthesize(Design*, NetScope*scope, NetExpr*root) override;
private: private:
/* Use the 32 bit ID as follows: /* Use the 32 bit ID as follows:
@ -4844,16 +4844,16 @@ class NetEShallowCopy : public NetExpr {
public: public:
// Make a shallow copy from arg2 into arg1. // Make a shallow copy from arg2 into arg1.
explicit NetEShallowCopy(NetExpr*arg1, NetExpr*arg2); explicit NetEShallowCopy(NetExpr*arg1, NetExpr*arg2);
~NetEShallowCopy(); ~NetEShallowCopy() override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual NetEShallowCopy* dup_expr() const; virtual NetEShallowCopy* dup_expr() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void dump(std::ostream&os) const; virtual void dump(std::ostream&os) const override;
void expr_scan_oper1(struct expr_scan_t*) const; void expr_scan_oper1(struct expr_scan_t*) const;
void expr_scan_oper2(struct expr_scan_t*) const; void expr_scan_oper2(struct expr_scan_t*) const;
@ -4872,24 +4872,24 @@ class NetETernary : public NetExpr {
public: public:
NetETernary(NetExpr*c, NetExpr*t, NetExpr*f, unsigned wid, bool signed_flag); NetETernary(NetExpr*c, NetExpr*t, NetExpr*f, unsigned wid, bool signed_flag);
~NetETernary(); ~NetETernary() override;
const netenum_t* enumeration() const; const netenum_t* enumeration() const override;
const NetExpr*cond_expr() const; const NetExpr*cond_expr() const;
const NetExpr*true_expr() const; const NetExpr*true_expr() const;
const NetExpr*false_expr() const; const NetExpr*false_expr() const;
virtual NetETernary* dup_expr() const; virtual NetETernary* dup_expr() const override;
virtual NetExpr* eval_tree(); virtual NetExpr* eval_tree() override;
virtual NetExpr*evaluate_function(const LineInfo&loc, virtual NetExpr*evaluate_function(const LineInfo&loc,
std::map<perm_string,LocalVar>&ctx) const; std::map<perm_string,LocalVar>&ctx) const override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
virtual NetNet*synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet*synthesize(Design*, NetScope*scope, NetExpr*root) override;
public: public:
static bool test_operand_compat(ivl_variable_type_t tru, ivl_variable_type_t fal); static bool test_operand_compat(ivl_variable_type_t tru, ivl_variable_type_t fal);
@ -4929,22 +4929,22 @@ class NetEUnary : public NetExpr {
public: public:
NetEUnary(char op, NetExpr*ex, unsigned wid, bool signed_flag); NetEUnary(char op, NetExpr*ex, unsigned wid, bool signed_flag);
~NetEUnary(); ~NetEUnary() override;
char op() const { return op_; } char op() const { return op_; }
const NetExpr* expr() const { return expr_; } const NetExpr* expr() const { return expr_; }
virtual NetEUnary* dup_expr() const; virtual NetEUnary* dup_expr() const override;
virtual NetExpr* eval_tree(); virtual NetExpr* eval_tree() override;
virtual NetExpr* evaluate_function(const LineInfo&loc, virtual NetExpr* evaluate_function(const LineInfo&loc,
std::map<perm_string,LocalVar>&ctx) const; std::map<perm_string,LocalVar>&ctx) const override;
virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false, virtual NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
protected: protected:
char op_; char op_;
@ -4959,42 +4959,42 @@ class NetEUBits : public NetEUnary {
public: public:
NetEUBits(char op, NetExpr*ex, unsigned wid, bool signed_flag); NetEUBits(char op, NetExpr*ex, unsigned wid, bool signed_flag);
~NetEUBits(); ~NetEUBits() override;
virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override;
virtual NetEUBits* dup_expr() const; virtual NetEUBits* dup_expr() const override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
}; };
class NetEUReduce : public NetEUnary { class NetEUReduce : public NetEUnary {
public: public:
NetEUReduce(char op, NetExpr*ex); NetEUReduce(char op, NetExpr*ex);
~NetEUReduce(); ~NetEUReduce() override;
virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override;
virtual NetEUReduce* dup_expr() const; virtual NetEUReduce* dup_expr() const override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
private: private:
virtual NetEConst* eval_arguments_(const NetExpr*ex) const; virtual NetEConst* eval_arguments_(const NetExpr*ex) const override;
virtual NetEConst* eval_tree_real_(const NetExpr*ex) const; virtual NetEConst* eval_tree_real_(const NetExpr*ex) const override;
}; };
class NetECast : public NetEUnary { class NetECast : public NetEUnary {
public: public:
NetECast(char op, NetExpr*ex, unsigned wid, bool signed_flag); NetECast(char op, NetExpr*ex, unsigned wid, bool signed_flag);
~NetECast(); ~NetECast() override;
virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root); virtual NetNet* synthesize(Design*, NetScope*scope, NetExpr*root) override;
virtual NetECast* dup_expr() const; virtual NetECast* dup_expr() const override;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
private: private:
virtual NetExpr* eval_arguments_(const NetExpr*ex) const; virtual NetExpr* eval_arguments_(const NetExpr*ex) const override;
}; };
/* /*
@ -5012,19 +5012,19 @@ class NetESignal : public NetExpr {
public: public:
explicit NetESignal(NetNet*n); explicit NetESignal(NetNet*n);
NetESignal(NetNet*n, NetExpr*word_index); NetESignal(NetNet*n, NetExpr*word_index);
~NetESignal(); ~NetESignal() override;
perm_string name() const; perm_string name() const;
virtual NetESignal* dup_expr() const; virtual NetESignal* dup_expr() const override;
NetNet* synthesize(Design*des, NetScope*scope, NetExpr*root); NetNet* synthesize(Design*des, NetScope*scope, NetExpr*root) override;
NexusSet* nex_input(bool rem_out = true, bool always_sens = false, NexusSet* nex_input(bool rem_out = true, bool always_sens = false,
bool nested_func = false) const; bool nested_func = false) const override;
NexusSet* nex_input_base(bool rem_out, bool always_sens, bool nested_func, NexusSet* nex_input_base(bool rem_out, bool always_sens, bool nested_func,
unsigned base, unsigned width) const; unsigned base, unsigned width) const;
virtual NetExpr*evaluate_function(const LineInfo&loc, virtual NetExpr*evaluate_function(const LineInfo&loc,
std::map<perm_string,LocalVar>&ctx) const; std::map<perm_string,LocalVar>&ctx) const override;
// This is the expression for selecting an array word, if this // This is the expression for selecting an array word, if this
// signal refers to an array. // signal refers to an array.
@ -5039,10 +5039,10 @@ class NetESignal : public NetExpr {
long msi() const; long msi() const;
long lsi() const; long lsi() const;
virtual ivl_variable_type_t expr_type() const; virtual ivl_variable_type_t expr_type() const override;
virtual void expr_scan(struct expr_scan_t*) const; virtual void expr_scan(struct expr_scan_t*) const override;
virtual void dump(std::ostream&) const; virtual void dump(std::ostream&) const override;
private: private:
NetNet*net_; NetNet*net_;

188
t-dll.h
View File

@ -1,7 +1,7 @@
#ifndef IVL_t_dll_H #ifndef IVL_t_dll_H
#define IVL_t_dll_H #define IVL_t_dll_H
/* /*
* Copyright (c) 2000-2021 Stephen Williams (steve@icarus.com) * Copyright (c) 2000-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -53,52 +53,52 @@ struct dll_target : public target_t, public expr_scan_t {
// version of a loadable target code generator. // version of a loadable target code generator.
void test_version(const char*target_name); void test_version(const char*target_name);
bool start_design(const Design*); bool start_design(const Design*) override;
int end_design(const Design*); int end_design(const Design*) override;
bool bufz(const NetBUFZ*); bool bufz(const NetBUFZ*) override;
bool branch(const NetBranch*); bool branch(const NetBranch*) override;
bool class_type(const NetScope*, netclass_t*); bool class_type(const NetScope*, netclass_t*) override;
bool enumeration(const NetScope*, netenum_t*); bool enumeration(const NetScope*, netenum_t*) override;
void event(const NetEvent*); void event(const NetEvent*) override;
void logic(const NetLogic*); void logic(const NetLogic*) override;
bool tran(const NetTran*); bool tran(const NetTran*) override;
bool ureduce(const NetUReduce*); bool ureduce(const NetUReduce*) override;
void net_case_cmp(const NetCaseCmp*); void net_case_cmp(const NetCaseCmp*) override;
void udp(const NetUDP*); void udp(const NetUDP*) override;
void lpm_abs(const NetAbs*); void lpm_abs(const NetAbs*) override;
void lpm_add_sub(const NetAddSub*); void lpm_add_sub(const NetAddSub*) override;
bool lpm_array_dq(const NetArrayDq*); bool lpm_array_dq(const NetArrayDq*) override;
bool lpm_cast_int2(const NetCastInt2*); bool lpm_cast_int2(const NetCastInt2*) override;
bool lpm_cast_int4(const NetCastInt4*); bool lpm_cast_int4(const NetCastInt4*) override;
bool lpm_cast_real(const NetCastReal*); bool lpm_cast_real(const NetCastReal*) override;
void lpm_clshift(const NetCLShift*); void lpm_clshift(const NetCLShift*) override;
void lpm_compare(const NetCompare*); void lpm_compare(const NetCompare*) override;
void lpm_divide(const NetDivide*); void lpm_divide(const NetDivide*) override;
void lpm_ff(const NetFF*); void lpm_ff(const NetFF*) override;
void lpm_latch(const NetLatch*); void lpm_latch(const NetLatch*) override;
void lpm_modulo(const NetModulo*); void lpm_modulo(const NetModulo*) override;
void lpm_mult(const NetMult*); void lpm_mult(const NetMult*) override;
void lpm_mux(const NetMux*); void lpm_mux(const NetMux*) override;
void lpm_pow(const NetPow*); void lpm_pow(const NetPow*) override;
bool concat(const NetConcat*); bool concat(const NetConcat*) override;
bool part_select(const NetPartSelect*); bool part_select(const NetPartSelect*) override;
bool replicate(const NetReplicate*); bool replicate(const NetReplicate*) override;
void net_assign(const NetAssign_*) const; void net_assign(const NetAssign_*) const;
bool net_sysfunction(const NetSysFunc*); bool net_sysfunction(const NetSysFunc*) override;
bool net_function(const NetUserFunc*); bool net_function(const NetUserFunc*) override;
bool net_const(const NetConst*); bool net_const(const NetConst*) override;
bool net_literal(const NetLiteral*); bool net_literal(const NetLiteral*) override;
void net_probe(const NetEvProbe*); void net_probe(const NetEvProbe*) override;
bool sign_extend(const NetSignExtend*); bool sign_extend(const NetSignExtend*) override;
bool substitute(const NetSubstitute*); bool substitute(const NetSubstitute*) override;
bool process(const NetProcTop*); bool process(const NetProcTop*) override;
bool process(const NetAnalogTop*); bool process(const NetAnalogTop*) override;
void scope(const NetScope*); void scope(const NetScope*) override;
void convert_module_ports(const NetScope*); void convert_module_ports(const NetScope*) override;
void signal(const NetNet*); void signal(const NetNet*) override;
bool signal_paths(const NetNet*); bool signal_paths(const NetNet*) override;
ivl_dll_t dll_; ivl_dll_t dll_;
ivl_design_s des_; ivl_design_s des_;
@ -109,59 +109,59 @@ struct dll_target : public target_t, public expr_scan_t {
/* These methods and members are used for forming the /* These methods and members are used for forming the
statements of a thread. */ statements of a thread. */
struct ivl_statement_s*stmt_cur_; struct ivl_statement_s*stmt_cur_;
void proc_alloc(const NetAlloc*); void proc_alloc(const NetAlloc*) override;
bool proc_assign(const NetAssign*); bool proc_assign(const NetAssign*) override;
void proc_assign_nb(const NetAssignNB*); void proc_assign_nb(const NetAssignNB*) override;
bool proc_block(const NetBlock*); bool proc_block(const NetBlock*) override;
bool proc_break(const NetBreak*); bool proc_break(const NetBreak*) override;
void proc_case(const NetCase*); void proc_case(const NetCase*) override;
bool proc_cassign(const NetCAssign*); bool proc_cassign(const NetCAssign*) override;
bool proc_condit(const NetCondit*); bool proc_condit(const NetCondit*) override;
bool proc_continue(const NetContinue*); bool proc_continue(const NetContinue*) override;
bool proc_contribution(const NetContribution*); bool proc_contribution(const NetContribution*) override;
bool proc_deassign(const NetDeassign*); bool proc_deassign(const NetDeassign*) override;
bool proc_delay(const NetPDelay*); bool proc_delay(const NetPDelay*) override;
bool proc_disable(const NetDisable*); bool proc_disable(const NetDisable*) override;
void proc_do_while(const NetDoWhile*); void proc_do_while(const NetDoWhile*) override;
bool proc_force(const NetForce*); bool proc_force(const NetForce*) override;
void proc_forever(const NetForever*); void proc_forever(const NetForever*) override;
bool proc_forloop(const NetForLoop*); bool proc_forloop(const NetForLoop*) override;
void proc_free(const NetFree*); void proc_free(const NetFree*) override;
bool proc_release(const NetRelease*); bool proc_release(const NetRelease*) override;
void proc_repeat(const NetRepeat*); void proc_repeat(const NetRepeat*) override;
void proc_stask(const NetSTask*); void proc_stask(const NetSTask*) override;
bool proc_trigger(const NetEvTrig*); bool proc_trigger(const NetEvTrig*) override;
bool proc_nb_trigger(const NetEvNBTrig*); bool proc_nb_trigger(const NetEvNBTrig*) override;
void proc_utask(const NetUTask*); void proc_utask(const NetUTask*) override;
bool proc_wait(const NetEvWait*); bool proc_wait(const NetEvWait*) override;
void proc_while(const NetWhile*); void proc_while(const NetWhile*) override;
bool func_def(const NetScope*); bool func_def(const NetScope*) override;
void task_def(const NetScope*); void task_def(const NetScope*) override;
struct ivl_expr_s*expr_; struct ivl_expr_s*expr_;
void expr_access_func(const NetEAccess*); void expr_access_func(const NetEAccess*) override;
void expr_array_pattern(const NetEArrayPattern*); void expr_array_pattern(const NetEArrayPattern*) override;
void expr_binary(const NetEBinary*); void expr_binary(const NetEBinary*) override;
void expr_concat(const NetEConcat*); void expr_concat(const NetEConcat*) override;
void expr_const(const NetEConst*); void expr_const(const NetEConst*) override;
void expr_creal(const NetECReal*); void expr_creal(const NetECReal*) override;
void expr_last(const NetELast*); void expr_last(const NetELast*) override;
void expr_new(const NetENew*); void expr_new(const NetENew*) override;
void expr_null(const NetENull*); void expr_null(const NetENull*) override;
void expr_param(const NetEConstParam*); void expr_param(const NetEConstParam*) override;
void expr_property(const NetEProperty*); void expr_property(const NetEProperty*) override;
void expr_rparam(const NetECRealParam*); void expr_rparam(const NetECRealParam*) override;
void expr_event(const NetEEvent*); void expr_event(const NetEEvent*) override;
void expr_scope(const NetEScope*); void expr_scope(const NetEScope*) override;
void expr_scopy(const NetEShallowCopy*); void expr_scopy(const NetEShallowCopy*) override;
void expr_netenum(const NetENetenum*); void expr_netenum(const NetENetenum*) override;
void expr_select(const NetESelect*); void expr_select(const NetESelect*) override;
void expr_sfunc(const NetESFunc*); void expr_sfunc(const NetESFunc*) override;
void expr_ternary(const NetETernary*); void expr_ternary(const NetETernary*) override;
void expr_ufunc(const NetEUFunc*); void expr_ufunc(const NetEUFunc*) override;
void expr_unary(const NetEUnary*); void expr_unary(const NetEUnary*) override;
void expr_signal(const NetESignal*); void expr_signal(const NetESignal*) override;
ivl_scope_t lookup_scope_(const NetScope*scope); ivl_scope_t lookup_scope_(const NetScope*scope);

6
tgt-stub/cppcheck.sup
View File

@ -1,3 +1,9 @@
// We use guarded memory allocation routines, but cppcheck is not
// noticing this so it is complaining we could return a NULL value.
nullPointerOutOfMemory:stub.c:70 // calloc @ 69
nullPointerOutOfMemory:stub.c:71 // calloc @ 69
nullPointerOutOfMemory:stub.c:79 // calloc @ 78
// These are the global access functions called from the compiler so they // These are the global access functions called from the compiler so they
// are not used here. // are not used here.

2
tgt-verilog/Makefile.in
View File

@ -56,6 +56,8 @@ distclean: clean
cppcheck: $(O:.o=.c) cppcheck: $(O:.o=.c)
cppcheck --enable=all --std=c99 --std=c++11 -f \ cppcheck --enable=all --std=c99 --std=c++11 -f \
--check-level=exhaustive \
--suppressions-list=$(srcdir)/../cppcheck-global.sup \
--suppressions-list=$(srcdir)/cppcheck.sup \ --suppressions-list=$(srcdir)/cppcheck.sup \
--relative-paths=$(srcdir) $(INCLUDE_PATH) $^ --relative-paths=$(srcdir) $(INCLUDE_PATH) $^

25
tgt-vlog95/cppcheck.sup
View File

@ -1,3 +1,28 @@
// We use guarded memory allocation routines, but cppcheck is not
// noticing this so it is complaining we could return a NULL value.
nullPointerOutOfMemory:logic_lpm.c:2143 // strdup @ 2140
nullPointerOutOfMemory:logic_lpm.c:2247 // strdup @ 2244
nullPointerOutOfMemory:misc.c:39 // malloc @ 38
nullPointerOutOfMemory:misc.c:794 // malloc @ 793
nullPointerOutOfMemory:misc.c:795 // malloc @ 793
nullPointerOutOfMemory:numbers.c:351 // strdup @ 348
nullPointerOutOfMemory:scope.c:301 // malloc @ 300
nullPointerOutOfMemory:scope.c:302 // malloc @ 300
nullPointerOutOfMemory:scope.c:303 // malloc @ 300
nullPointerOutOfMemory:scope.c:304 // malloc @ 300
nullPointerOutOfMemory:scope.c:305 // malloc @ 300
nullPointerOutOfMemory:scope.c:307 // malloc @ 300
nullPointerOutOfMemory:scope.c:993 // malloc @ 990
nullPointerOutOfMemory:scope.c:994 // malloc @ 990
nullPointerOutOfMemory:scope.c:995 // malloc @ 990
nullPointerOutOfMemory:scope.c:996 // malloc @ 990
nullPointerOutOfMemory:stmt.c:777 // malloc @ 775
nullPointerOutOfMemory:stmt.c:778 // malloc @ 775
memleakOnRealloc:scope.c:175
memleakOnRealloc:scope.c:1021
memleakOnRealloc:scope.c:1067
memleakOnRealloc:udp.c:245
// These are the global access functions called from the compiler so they // These are the global access functions called from the compiler so they
// are not used here. // are not used here.

52
tgt-vvp/cppcheck.sup
View File

@ -1,3 +1,55 @@
// We use guarded memory allocation routines, but cppcheck is not
// noticing this so it is complaining we could return a NULL value.
nullPointerOutOfMemory:vvp.c:90 // malloc @ 89
nullPointerOutOfMemory:vvp.c:91 // malloc @ 89
nullPointerOutOfMemory:vvp.c:92 // malloc @ 89
nullPointerOutOfMemory:draw_mux.c:83 // strdup @ 80
nullPointerOutOfMemory:draw_mux.c:95 // strdup @ 80
nullPointerOutOfMemory:draw_mux.c:110 // strdup @ 80
nullPointerOutOfMemory:draw_net_input.c:92 // malloc @ 90
nullPointerOutOfMemory:draw_net_input.c:93 // malloc @ 90
nullPointerOutOfMemory:draw_net_input.c:118 // malloc @ 110
nullPointerOutOfMemory:draw_net_input.c:119 // malloc @ 110
nullPointerOutOfMemory:draw_net_input.c:237 // malloc @ 235
nullPointerOutOfMemory:draw_net_input.c:238 // malloc @ 235
nullPointerOutOfMemory:draw_net_input.c:256 // malloc @ 248
nullPointerOutOfMemory:draw_net_input.c:257 // malloc @ 248
nullPointerOutOfMemory:draw_net_input.c:269 // malloc @ 235
nullPointerOutOfMemory:draw_net_input.c:667 // malloc @ 665
nullPointerOutOfMemory:draw_net_input.c:668 // malloc @ 665
nullPointerOutOfMemory:draw_net_input.c:779 // malloc @ 761
nullPointerOutOfMemory:draw_net_input.c:780 // malloc @ 761
nullPointerOutOfMemory:modpath.c:75 // calloc @ 68
nullPointerOutOfMemory:modpath.c:92 // calloc @ 68
nullPointerOutOfMemory:modpath.c:111 // calloc @ 69
nullPointerOutOfMemory:modpath.c:139 // calloc @ 138
nullPointerOutOfMemory:modpath.c:140 // calloc @ 138
nullPointerOutOfMemory:modpath.c:141 // calloc @ 138
nullPointerOutOfMemory:modpath.c:142 // calloc @ 138
nullPointerOutOfMemory:vvp_process.c:2120 // malloc @ 2118
nullPointerOutOfMemory:vvp_process.c:2121 // malloc @ 2118
nullPointerOutOfMemory:vvp_scope.c:900 // calloc @ 865
nullPointerOutOfMemory:vvp_scope.c:1094 // calloc @ 1092
nullPointerOutOfMemory:vvp_scope.c:1117 // calloc @ 1092
nullPointerOutOfMemory:vvp_scope.c:1700 // malloc @ 1684
nullPointerOutOfMemory:vvp_scope.c:1701 // malloc @ 1684
nullPointerOutOfMemory:vvp_scope.c:1730 // malloc @ 1684
nullPointerOutOfMemory:vvp_scope.c:1731 // malloc @ 1684
nullPointerOutOfMemory:vvp_scope.c:1741 // malloc @ 1684
nullPointerOutOfMemory:vvp_scope.c:1745 // malloc @ 1684
nullPointerOutOfMemory:vvp_scope.c:1746 // malloc @ 1684
nullPointerOutOfMemory:vvp_scope.c:1757 // malloc @ 1684
nullPointerOutOfMemory:vvp_scope.c:1764 // malloc @ 1684
nullPointerOutOfMemory:vvp_scope.c:1991 // calloc @ 1989
nullPointerOutOfMemory:vvp_scope.c:2062 // calloc @ 2060
nullPointerOutOfMemory:vvp_scope.c:2077 // calloc @ 2060
nullPointerArithmeticOutOfMemory:stmt_assign.c:216 // calloc @ 619
nullPointerArithmeticOutOfMemory:stmt_assign.c:364 // calloc @ 619
memleakOnRealloc:draw_net_input.c:639
memleakOnRealloc:vvp_scope.c:57
memleakOnRealloc:vvp_scope.c:106
memleakOnRealloc:vvp_scope.c:853
// These are the global access functions called from the compiler so they // These are the global access functions called from the compiler so they
// are not used here. // are not used here.

4
veriuser.h
View File

@ -1,7 +1,7 @@
#ifndef VERIUSER_H #ifndef VERIUSER_H
#define VERIUSER_H #define VERIUSER_H
/* /*
* Copyright (c) 2002-2019 Stephen Williams (steve@icarus.com) * Copyright (c) 2002-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -251,7 +251,7 @@ typedef struct t_tfexprinfo {
/* Extern functions from the library. */ /* Extern functions from the library. */
extern void io_printf (const char *, ...) extern void io_printf (const char *, ...)
__attribute__((format (printf,1,2))); __attribute__((format (printf,1,2)));
extern char* mc_scan_plusargs(char*plusarg); extern char* mc_scan_plusargs(const char*plusarg);
extern int tf_asynchoff(void); extern int tf_asynchoff(void);
extern int tf_asynchon(void); extern int tf_asynchon(void);

2
vvp/Makefile.in
View File

@ -110,6 +110,8 @@ distclean: clean
cppcheck: $(O:.o=.cc) draw_tt.c cppcheck: $(O:.o=.cc) draw_tt.c
cppcheck --enable=all --std=c99 --std=c++11 -f \ cppcheck --enable=all --std=c99 --std=c++11 -f \
--check-level=exhaustive \
--suppressions-list=$(srcdir)/../cppcheck-global.sup \
--suppressions-list=$(srcdir)/cppcheck.sup \ --suppressions-list=$(srcdir)/cppcheck.sup \
-UMODULE_DIR1 -UMODULE_DIR2 -UYY_USER_INIT \ -UMODULE_DIR1 -UMODULE_DIR2 -UYY_USER_INIT \
-UYYPARSE_PARAM -UYYPRINT -Ushort -Usize_t -Uyyoverflow \ -UYYPARSE_PARAM -UYYPRINT -Ushort -Usize_t -Uyyoverflow \

58
vvp/cppcheck.sup
View File

@ -1,3 +1,32 @@
// We use guarded memory allocation routines, but cppcheck is not
// noticing this so it is complaining we could return a NULL value.
nullPointerOutOfMemory:delay.cc:829 // calloc @ 828
nullPointerOutOfMemory:delay.cc:1252 // calloc @ 1251
nullPointerOutOfMemory:delay.cc:1253 // calloc @ 1251
nullPointerOutOfMemory:vpi_scope.cc:760 // calloc @ 757
nullPointerOutOfMemory:vpi_mcd.cc:68 // malloc @ 66
nullPointerOutOfMemory:vpi_mcd.cc:69 // malloc @ 66
nullPointerOutOfMemory:vpi_mcd.cc:75 // malloc @ 66
nullPointerOutOfMemory:vpi_mcd.cc:76 // malloc @ 66
nullPointerOutOfMemory:vpi_mcd.cc:77 // malloc @ 66
nullPointerOutOfMemory:vpi_mcd.cc:78 // malloc @ 66
nullPointerOutOfMemory:vpi_mcd.cc:79 // malloc @ 66
nullPointerOutOfMemory:vpi_mcd.cc:80 // malloc @ 66
nullPointerOutOfMemory:vpi_priv.cc:1090 // malloc @ 1089
nullPointerOutOfMemory:vpi_priv.cc:1102 // malloc @ 1101
nullPointerOutOfMemory:vpi_priv.cc:1112 // malloc @ 1111
nullPointerOutOfMemory:vpi_signal.cc:105 // strdup @ 623
nullPointerOutOfMemory:vpi_signal.cc:110 // strdup @ 109
nullPointerOutOfMemory:vpi_signal.cc:1380 // malloc @ 1379
nullPointerOutOfMemory:vpi_tasks.cc:577 // malloc @ 574
nullPointerOutOfMemory:vpi_tasks.cc:580 // malloc @ 574
ctunullpointerOutOfMemory:compile.cc:651 // strdup @ 1599 (vpi_signal.cc)
ctunullpointerOutOfMemory:stop.cc:489 // strdup @ 543
ctunullpointerOutOfMemory:vpi_signal.cc:105 // strdup @ 122 (vpi_bit.cc)
memleakOnRealloc:vpi_modules.cc:254
memleakOnRealloc:vpi_mcd.cc:316
memleakOnRealloc:vpi_signal.cc:1205
// The new() operator is always used to allocate space for this class and // The new() operator is always used to allocate space for this class and
// pool is defined there. // pool is defined there.
uninitMemberVar:vvp_net.cc:192 uninitMemberVar:vvp_net.cc:192
@ -57,3 +86,32 @@ unusedFunction:lib_main.cc:71
unusedFunction:lib_main.cc:62 unusedFunction:lib_main.cc:62
// vvp_set_verbose_flag() // vvp_set_verbose_flag()
unusedFunction:lib_main.cc:76 unusedFunction:lib_main.cc:76
// The following are just unused.
// alias_word()
unusedFunction:array.cc:848
// intermodpath_delete()
unusedFunction:delay.cc:1462
// count_force4_pool()
unusedFunction:schedule.cc:402
// call_scope()
unusedFunction:ufunc.h:62
// get_bit()
unusedFunction:vpi_priv.h:477
// copy_bits()
unusedFunction:vvp_net.cc:615
// mov()
unusedFunction:vvp_net.cc:1546
// eq_xz()
unusedFunction:vvp_net.cc:1751
// as_string()
unusedFunction:vvp_net.cc:1854
// fully_featured_resolv_()
unusedFunction:vvp_net.cc:3582
// words()
unusedFunction:vvp_net.h:595
// force_vec8()
unusedFunction:vvp_net_sig.cc:128
// Unused functions from the lexor
unusedFunction:lexor.cc

18
vvp/delay.cc
View File

@ -166,7 +166,7 @@ vvp_fun_delay::vvp_fun_delay(vvp_net_t*n, unsigned width, const vvp_delay_t&d)
initial_ = true; initial_ = true;
// Calculate the values used when converting variable delays // Calculate the values used when converting variable delays
// to simulation time units. // to simulation time units.
__vpiScope*scope = vpip_peek_current_scope(); const __vpiScope*scope = vpip_peek_current_scope();
int powr = scope->time_units - scope->time_precision; int powr = scope->time_units - scope->time_precision;
round_ = 1; round_ = 1;
@ -820,12 +820,12 @@ static vpiHandle modpath_src_iterate(int code, vpiHandle ref)
// ever one input path term and one output path term. // ever one input path term and one output path term.
switch (code) { switch (code) {
case vpiModPathIn: { case vpiModPathIn: {
vpiHandle*args = (vpiHandle*)calloc(1, sizeof(vpiHandle*)); vpiHandle*args = static_cast<vpiHandle*>(calloc(1, sizeof(vpiHandle*)));
args[0] = &rfp->path_term_in; args[0] = &rfp->path_term_in;
return vpip_make_iterator(1, args, true); return vpip_make_iterator(1, args, true);
} }
case vpiModPathOut: { case vpiModPathOut: {
vpiHandle*args = (vpiHandle*)calloc(1, sizeof(vpiHandle*)); vpiHandle*args = static_cast<vpiHandle*>(calloc(1, sizeof(vpiHandle*)));
args[0] = &rfp->dest->path_term_out; args[0] = &rfp->dest->path_term_out;
return vpip_make_iterator(1, args, true); return vpip_make_iterator(1, args, true);
} }
@ -1081,8 +1081,9 @@ struct __vpiModPath* vpip_make_modpath(vvp_net_t *net)
#ifdef CHECK_WITH_VALGRIND #ifdef CHECK_WITH_VALGRIND
mp_count += 1; mp_count += 1;
mp_list = (struct __vpiModPath **) realloc(mp_list, mp_list = static_cast<struct __vpiModPath **>
mp_count*sizeof(struct __vpiModPath **)); (realloc(static_cast<void*>(mp_list),
mp_count*sizeof(struct __vpiModPath **)));
mp_list[mp_count-1] = obj; mp_list[mp_count-1] = obj;
#endif #endif
return obj; return obj;
@ -1247,7 +1248,7 @@ static vpiHandle intermodpath_iterate(int code, vpiHandle ref)
// For now intermodpaths only support exactly two ports // For now intermodpaths only support exactly two ports
switch (code) { switch (code) {
case vpiPort: { case vpiPort: {
vpiHandle*args = (vpiHandle*)calloc(2, sizeof(vpiHandle*)); vpiHandle*args = static_cast<vpiHandle*>(calloc(2, sizeof(vpiHandle*)));
args[0] = rfp->port1; args[0] = rfp->port1;
args[1] = rfp->port2; args[1] = rfp->port2;
return vpip_make_iterator(2, args, true); return vpip_make_iterator(2, args, true);
@ -1449,8 +1450,9 @@ struct __vpiInterModPath* vpip_make_intermodpath(vvp_net_t *net, vpiPortInfo* po
#ifdef CHECK_WITH_VALGRIND #ifdef CHECK_WITH_VALGRIND
imp_count += 1; imp_count += 1;
imp_list = (struct __vpiInterModPath **) realloc(imp_list, imp_list = static_cast<struct __vpiInterModPath **>
imp_count*sizeof(struct __vpiInterModPath **)); (realloc(static_cast<void>(imp_list),
imp_count*sizeof(struct __vpiInterModPath **)));
imp_list[imp_count-1] = obj; imp_list[imp_count-1] = obj;
#endif #endif
return obj; return obj;

6
vvp/event.cc
View File

@ -370,7 +370,7 @@ class anyedge_vec4_value : public anyedge_value {
public: public:
anyedge_vec4_value() {}; anyedge_vec4_value() {};
virtual ~anyedge_vec4_value() {}; virtual ~anyedge_vec4_value() override {};
void reset() override { old_bits.set_to_x(); } void reset() override { old_bits.set_to_x(); }
@ -402,7 +402,7 @@ class anyedge_real_value : public anyedge_value {
public: public:
anyedge_real_value() : old_bits(0.0) {}; anyedge_real_value() : old_bits(0.0) {};
virtual ~anyedge_real_value() {}; virtual ~anyedge_real_value() override {};
void reset() override { old_bits = 0.0; } void reset() override { old_bits = 0.0; }
@ -431,7 +431,7 @@ class anyedge_string_value : public anyedge_value {
public: public:
anyedge_string_value() {}; anyedge_string_value() {};
virtual ~anyedge_string_value() {}; virtual ~anyedge_string_value() override {};
void reset() override { old_bits.clear(); } void reset() override { old_bits.clear(); }

11
vvp/vpi_bit.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (C) 2020 Cary R. (cygcary@yahoo.com) * Copyright (C) 2020-2025 Cary R. (cygcary@yahoo.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -32,15 +32,15 @@ static const __vpiBit*bit_from_handle(const __vpiHandle*ref)
if (ref == NULL) return NULL; if (ref == NULL) return NULL;
const __vpiBit::as_bit_t*ptr = dynamic_cast<const __vpiBit::as_bit_t*> (ref); const __vpiBit::as_bit_t*ptr = dynamic_cast<const __vpiBit::as_bit_t*> (ref);
if (ptr == NULL) return NULL; if (ptr == NULL) return NULL;
return (const struct __vpiBit*) ref; return reinterpret_cast<const struct __vpiBit*>(ref);
} }
static __vpiBit*bit_from_handle(__vpiHandle*ref) static __vpiBit*bit_from_handle(__vpiHandle*ref)
{ {
if (ref == NULL) return NULL; if (ref == NULL) return NULL;
__vpiBit::as_bit_t*ptr = dynamic_cast<__vpiBit::as_bit_t*> (ref); const __vpiBit::as_bit_t*ptr = dynamic_cast<__vpiBit::as_bit_t*> (ref);
if (ptr == NULL) return NULL; if (ptr == NULL) return NULL;
return (struct __vpiBit*) ref; return reinterpret_cast<struct __vpiBit*>(ref);
} }
static int bit_get_type(const __vpiBit*rfp) static int bit_get_type(const __vpiBit*rfp)
@ -118,7 +118,8 @@ static char* bit_get_str(int code, vpiHandle ref)
struct __vpiSignal*parent = rfp->get_parent(); struct __vpiSignal*parent = rfp->get_parent();
assert(parent); assert(parent);
char *nm, *ixs; char *nm;
const char *ixs;
nm = strdup(vpi_get_str(vpiName, parent)); nm = strdup(vpi_get_str(vpiName, parent));
s_vpi_value vp; s_vpi_value vp;
vp.format = vpiDecStrVal; vp.format = vpiDecStrVal;

8
vvp/vpi_callback.cc
View File

@ -174,7 +174,7 @@ struct sync_cb : public vvp_gen_event_s {
sync_callback*handle; sync_callback*handle;
bool sync_flag; bool sync_flag;
~sync_cb () { } ~sync_cb () override { }
virtual void run_run() override; virtual void run_run() override;
}; };
@ -231,7 +231,7 @@ static void vpip_real_value_change(value_callback*cbh, vpiHandle ref)
class value_part_callback : public value_callback { class value_part_callback : public value_callback {
public: public:
explicit value_part_callback(p_cb_data data); explicit value_part_callback(p_cb_data data);
~value_part_callback(); ~value_part_callback() override;
bool test_value_callback_ready(void) override; bool test_value_callback_ready(void) override;
@ -398,7 +398,7 @@ static value_callback* make_value_change(p_cb_data data)
class sync_callback : public __vpiCallback { class sync_callback : public __vpiCallback {
public: public:
explicit sync_callback(p_cb_data data); explicit sync_callback(p_cb_data data);
~sync_callback(); ~sync_callback() override;
public: public:
// scheduled event // scheduled event
@ -969,7 +969,7 @@ static uint64_t vlg_round_to_u64(double rval)
static void real_signal_value(struct t_vpi_value*vp, double rval) static void real_signal_value(struct t_vpi_value*vp, double rval)
{ {
static const size_t RBUF_SIZE = 64 + 1; static const size_t RBUF_SIZE = 64 + 1;
char*rbuf = (char *) need_result_buf(RBUF_SIZE, RBUF_VAL); char*rbuf = static_cast<char *>(need_result_buf(RBUF_SIZE, RBUF_VAL));
switch (vp->format) { switch (vp->format) {
case vpiObjTypeVal: case vpiObjTypeVal:

10
vvp/vpi_cobject.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012-2022 Picture Elements, Inc. * Copyright (c) 2012-2025 Picture Elements, Inc.
* Stephen Williams (steve@icarus.com) * Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
@ -69,7 +69,7 @@ void __vpiCobjectVar::vpi_get_value(p_vpi_value val)
// FIXME: We need to get the assigned object address if one is assigned. // FIXME: We need to get the assigned object address if one is assigned.
//fprintf(stderr, "HERE: %p\n", get_net()); //fprintf(stderr, "HERE: %p\n", get_net());
static const size_t RBUF_USE_SIZE = 64 + 1; static const size_t RBUF_USE_SIZE = 64 + 1;
char*rbuf = (char *) need_result_buf(RBUF_USE_SIZE, RBUF_VAL); char*rbuf = static_cast<char *>(need_result_buf(RBUF_USE_SIZE, RBUF_VAL));
switch (val->format) { switch (val->format) {
case vpiObjTypeVal: case vpiObjTypeVal:
@ -93,9 +93,9 @@ void __vpiCobjectVar::vpi_get_value(p_vpi_value val)
break; break;
case vpiVectorVal: case vpiVectorVal:
val->value.vector = (p_vpi_vecval) val->value.vector = static_cast<p_vpi_vecval>
need_result_buf(2*sizeof(s_vpi_vecval), (need_result_buf(2*sizeof(s_vpi_vecval),
RBUF_VAL); RBUF_VAL));
for (unsigned idx = 0; idx < 2; idx += 1) { for (unsigned idx = 0; idx < 2; idx += 1) {
val->value.vector[idx].aval = 0; val->value.vector[idx].aval = 0;
val->value.vector[idx].bval = 0; val->value.vector[idx].bval = 0;

36
vvp/vpi_const.cc
View File

@ -32,7 +32,7 @@
class __vpiStringConst : public __vpiHandle { class __vpiStringConst : public __vpiHandle {
public: public:
explicit __vpiStringConst(char*val); explicit __vpiStringConst(char*val);
~__vpiStringConst(); ~__vpiStringConst() override;
int get_type_code(void) const override; int get_type_code(void) const override;
int vpi_get(int code) override; int vpi_get(int code) override;
void vpi_get_value(p_vpi_value val) override; void vpi_get_value(p_vpi_value val) override;
@ -132,7 +132,7 @@ void __vpiStringConst::vpi_get_value(p_vpi_value vp)
// fallthrough // fallthrough
case vpiStringVal: case vpiStringVal:
cp = value_; cp = value_;
rbuf = (char *) need_result_buf(size + 1, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(size + 1, RBUF_VAL));
vp->value.str = rbuf; vp->value.str = rbuf;
for (unsigned int i = 0; i < size; i++) { for (unsigned int i = 0; i < size; i++) {
@ -163,7 +163,7 @@ void __vpiStringConst::vpi_get_value(p_vpi_value vp)
"at first 4 bytes!\n"); "at first 4 bytes!\n");
} }
static const size_t RBUF_USE_SIZE = 12; static const size_t RBUF_USE_SIZE = 12;
rbuf = (char *) need_result_buf(RBUF_USE_SIZE, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(RBUF_USE_SIZE, RBUF_VAL));
uint_value = 0; uint_value = 0;
for(unsigned i=0; i<size; i += 1){ for(unsigned i=0; i<size; i += 1){
uint_value <<=8; uint_value <<=8;
@ -174,7 +174,7 @@ void __vpiStringConst::vpi_get_value(p_vpi_value vp)
break; break;
case vpiBinStrVal: case vpiBinStrVal:
rbuf = (char *) need_result_buf(8 * size + 1, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(8 * size + 1, RBUF_VAL));
cp = rbuf; cp = rbuf;
for(unsigned i=0; i<size; i += 1){ for(unsigned i=0; i<size; i += 1){
for(int bit=7; bit>=0; bit -= 1){ for(int bit=7; bit>=0; bit -= 1){
@ -186,7 +186,7 @@ void __vpiStringConst::vpi_get_value(p_vpi_value vp)
break; break;
case vpiHexStrVal: case vpiHexStrVal:
rbuf = (char *) need_result_buf(2 * size + 1, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(2 * size + 1, RBUF_VAL));
cp = rbuf; cp = rbuf;
for(unsigned i=0; i<size; i += 1){ for(unsigned i=0; i<size; i += 1){
for(int nibble=1; nibble>=0; nibble -= 1){ for(int nibble=1; nibble>=0; nibble -= 1){
@ -213,10 +213,10 @@ void __vpiStringConst::vpi_get_value(p_vpi_value vp)
break; break;
case vpiVectorVal: case vpiVectorVal:
vp->value.vector = (p_vpi_vecval) vp->value.vector = static_cast<p_vpi_vecval>
need_result_buf((size+3)/4* (need_result_buf((size+3)/4*
sizeof(s_vpi_vecval), sizeof(s_vpi_vecval),
RBUF_VAL); RBUF_VAL));
uint_value = 0; uint_value = 0;
vecp = vp->value.vector; vecp = vp->value.vector;
vecp->aval = vecp->bval = 0; vecp->aval = vecp->bval = 0;
@ -271,7 +271,7 @@ vpiHandle vpip_make_string_const(char*text, bool persistent_flag)
class __vpiStringParam : public __vpiStringConst { class __vpiStringParam : public __vpiStringConst {
public: public:
__vpiStringParam(char*txt, char*name); __vpiStringParam(char*txt, char*name);
~__vpiStringParam(); ~__vpiStringParam() override;
int get_type_code(void) const override; int get_type_code(void) const override;
int vpi_get(int code) override; int vpi_get(int code) override;
char*vpi_get_str(int code) override; char*vpi_get_str(int code) override;
@ -465,7 +465,7 @@ vvp_vector4_t vector4_from_text(const char*bits, unsigned wid)
struct __vpiBinaryParam : public __vpiBinaryConst { struct __vpiBinaryParam : public __vpiBinaryConst {
__vpiBinaryParam(const vvp_vector4_t&b, char*name); __vpiBinaryParam(const vvp_vector4_t&b, char*name);
~__vpiBinaryParam(); ~__vpiBinaryParam() override;
int get_type_code(void) const override; int get_type_code(void) const override;
int vpi_get(int code) override; int vpi_get(int code) override;
char*vpi_get_str(int code) override; char*vpi_get_str(int code) override;
@ -595,7 +595,7 @@ int __vpiDecConst::vpi_get(int code)
void __vpiDecConst::vpi_get_value(p_vpi_value vp) void __vpiDecConst::vpi_get_value(p_vpi_value vp)
{ {
static const size_t RBUF_USE_SIZE = 64 + 1; static const size_t RBUF_USE_SIZE = 64 + 1;
char*rbuf = (char *) need_result_buf(RBUF_USE_SIZE, RBUF_VAL); char*rbuf = static_cast<char *>(need_result_buf(RBUF_USE_SIZE, RBUF_VAL));
char*cp = rbuf; char*cp = rbuf;
switch (vp->format) { switch (vp->format) {
@ -613,7 +613,7 @@ void __vpiDecConst::vpi_get_value(p_vpi_value vp)
case vpiBinStrVal: case vpiBinStrVal:
for(int bit=31; bit>=0;bit--){ for(int bit=31; bit>=0;bit--){
*cp++ = "01"[ (value>>bit)&1 ]; *cp++ = "01"[ (static_cast<unsigned>(value)>>bit)&1 ];
} }
*cp = 0; *cp = 0;
@ -692,7 +692,7 @@ vpiHandle vpip_make_real_const(double value)
struct __vpiRealParam : public __vpiRealConst { struct __vpiRealParam : public __vpiRealConst {
__vpiRealParam(double val, char*name); __vpiRealParam(double val, char*name);
~__vpiRealParam(); ~__vpiRealParam() override;
int get_type_code(void) const override; int get_type_code(void) const override;
int vpi_get(int code) override; int vpi_get(int code) override;
char*vpi_get_str(int code) override; char*vpi_get_str(int code) override;
@ -815,7 +815,7 @@ int __vpiNullConst::vpi_get(int code)
void __vpiNullConst::vpi_get_value(p_vpi_value val) void __vpiNullConst::vpi_get_value(p_vpi_value val)
{ {
static const size_t RBUF_USE_SIZE = 64 + 1; static const size_t RBUF_USE_SIZE = 64 + 1;
char*rbuf = (char *) need_result_buf(RBUF_USE_SIZE, RBUF_VAL); char*rbuf = static_cast<char *>(need_result_buf(RBUF_USE_SIZE, RBUF_VAL));
switch (val->format) { switch (val->format) {
@ -840,9 +840,9 @@ void __vpiNullConst::vpi_get_value(p_vpi_value val)
break; break;
case vpiVectorVal: case vpiVectorVal:
val->value.vector = (p_vpi_vecval) val->value.vector = static_cast<p_vpi_vecval>
need_result_buf(2*sizeof(s_vpi_vecval), (need_result_buf(2*sizeof(s_vpi_vecval),
RBUF_VAL); RBUF_VAL));
for (unsigned idx = 0; idx < 2; idx += 1) { for (unsigned idx = 0; idx < 2; idx += 1) {
val->value.vector[idx].aval = 0; val->value.vector[idx].aval = 0;
val->value.vector[idx].bval = 0; val->value.vector[idx].bval = 0;

8
vvp/vpi_darray.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012-2022 Stephen Williams (steve@icarus.com) * Copyright (c) 2012-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -42,12 +42,12 @@ __vpiDarrayVar::__vpiDarrayVar(__vpiScope*sc, const char*na, vvp_net_t*ne)
unsigned __vpiDarrayVar::get_size() const unsigned __vpiDarrayVar::get_size() const
{ {
vvp_fun_signal_object*fun = dynamic_cast<vvp_fun_signal_object*> (get_net()->fun); const vvp_fun_signal_object*fun = dynamic_cast<vvp_fun_signal_object*> (get_net()->fun);
if(!fun) if(!fun)
return 0; return 0;
vvp_object_t val = fun->get_object(); vvp_object_t val = fun->get_object();
vvp_darray*aval = val.peek<vvp_darray>(); const vvp_darray*aval = val.peek<vvp_darray>();
if(!aval) if(!aval)
return 0; return 0;
@ -307,7 +307,7 @@ int __vpiQueueVar::vpi_get(int code)
vvp_fun_signal_object*fun = dynamic_cast<vvp_fun_signal_object*> (get_net()->fun); vvp_fun_signal_object*fun = dynamic_cast<vvp_fun_signal_object*> (get_net()->fun);
assert(fun); assert(fun);
vvp_object_t val = fun->get_object(); vvp_object_t val = fun->get_object();
vvp_queue*aval = val.peek<vvp_queue>(); const vvp_queue*aval = val.peek<vvp_queue>();
switch (code) { switch (code) {
case vpiArrayType: case vpiArrayType:

12
vvp/vpi_mcd.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2000-2024 Stephen G. Tell <steve@telltronics.org> * Copyright (c) 2000-2025 Stephen G. Tell <steve@telltronics.org>
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -41,7 +41,7 @@ extern FILE* vpi_trace;
/* /*
* MCD/FD manipulation macros * MCD/FD manipulation macros
*/ */
#define IS_MCD(mcd) !((mcd)>>31&1) #define IS_MCD(mcd) !(static_cast<unsigned>(mcd)>>31&1)
#define FD_IDX(fd) ((fd)&~(1U<<31)) #define FD_IDX(fd) ((fd)&~(1U<<31))
#define FD_INCR 32 #define FD_INCR 32
@ -63,7 +63,7 @@ bool vpip_mcd0_disable = false;
void vpip_mcd_init(FILE *log) void vpip_mcd_init(FILE *log)
{ {
fd_table_len = FD_INCR; fd_table_len = FD_INCR;
fd_table = (mcd_entry_s *) malloc(fd_table_len*sizeof(mcd_entry_s)); fd_table = static_cast<mcd_entry_s *>(malloc(fd_table_len*sizeof(mcd_entry_s)));
for (unsigned idx = 0; idx < fd_table_len; idx += 1) { for (unsigned idx = 0; idx < fd_table_len; idx += 1) {
fd_table[idx].fp = NULL; fd_table[idx].fp = NULL;
fd_table[idx].filename = NULL; fd_table[idx].filename = NULL;
@ -210,7 +210,7 @@ vpi_mcd_vprintf(PLI_UINT32 mcd, const char*fmt, va_list ap)
* so the print needs to be redone with a larger buffer (very rare). * so the print needs to be redone with a larger buffer (very rare).
*/ */
if ((unsigned) rc >= sizeof buffer) { if ((unsigned) rc >= sizeof buffer) {
buf_ptr = (char *)malloc(rc + 1); buf_ptr = static_cast<char *>(malloc(rc + 1));
need_free = true; need_free = true;
rc = vsnprintf(buf_ptr, rc+1, fmt, saved_ap); rc = vsnprintf(buf_ptr, rc+1, fmt, saved_ap);
} }
@ -313,8 +313,8 @@ extern "C" PLI_INT32 vpi_fopen(const char*name, const char*mode)
return 0; return 0;
} }
fd_table_len += FD_INCR; fd_table_len += FD_INCR;
fd_table = (mcd_entry_s *) realloc(fd_table, fd_table = static_cast<mcd_entry_s *>
fd_table_len*sizeof(mcd_entry_s)); (realloc(fd_table, fd_table_len*sizeof(mcd_entry_s)));
for (unsigned idx = i; idx < fd_table_len; idx += 1) { for (unsigned idx = i; idx < fd_table_len; idx += 1) {
fd_table[idx].fp = NULL; fd_table[idx].fp = NULL;
fd_table[idx].filename = NULL; fd_table[idx].filename = NULL;

9
vvp/vpi_modules.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2001-2022 Stephen Williams (steve@icarus.com) * Copyright (c) 2001-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -72,7 +72,7 @@ void vpip_add_env_and_default_module_paths()
if (char *var = ::getenv("IVERILOG_VPI_MODULE_PATH")) { if (char *var = ::getenv("IVERILOG_VPI_MODULE_PATH")) {
char *ptr = var; char *ptr = var;
char *end = var+strlen(var); const char *end = var+strlen(var);
int len = 0; int len = 0;
while (ptr <= end) { while (ptr <= end) {
if (*ptr == 0 || *ptr == path_sep) { if (*ptr == 0 || *ptr == path_sep) {
@ -232,7 +232,7 @@ void vpip_load_module(const char*name)
#if defined(__MINGW32__) || defined (__CYGWIN__) #if defined(__MINGW32__) || defined (__CYGWIN__)
void*function = ivl_dlsym(dll, "vpip_set_callback"); void*function = ivl_dlsym(dll, "vpip_set_callback");
if (function) { if (function) {
vpip_set_callback_t set_callback = (vpip_set_callback_t)function; vpip_set_callback_t set_callback = static_cast<vpip_set_callback_t>(function);
if (!set_callback(&vpi_routines, vpip_routines_version)) { if (!set_callback(&vpi_routines, vpip_routines_version)) {
fprintf(stderr, "Failed to link VPI module %s. Try rebuilding it with iverilog-vpi.\n", name); fprintf(stderr, "Failed to link VPI module %s. Try rebuilding it with iverilog-vpi.\n", name);
ivl_dlclose(dll); ivl_dlclose(dll);
@ -250,7 +250,8 @@ void vpip_load_module(const char*name)
/* Add the dll to the list so it can be closed when we are done. */ /* Add the dll to the list so it can be closed when we are done. */
dll_list_cnt += 1; dll_list_cnt += 1;
dll_list = (ivl_dll_t*)realloc(dll_list, dll_list_cnt*sizeof(ivl_dll_t)); dll_list = static_cast<ivl_dll_t*>
(realloc(static_cast<void *>(dll_list), dll_list_cnt*sizeof(ivl_dll_t)));
dll_list[dll_list_cnt-1] = dll; dll_list[dll_list_cnt-1] = dll;
vpi_mode_flag = VPI_MODE_REGISTER; vpi_mode_flag = VPI_MODE_REGISTER;

38
vvp/vpi_priv.cc
View File

@ -223,7 +223,7 @@ PLI_INT32 vpi_chk_error(p_vpi_error_info info)
info->level = vpip_last_error.level; info->level = vpip_last_error.level;
info->message = vpip_last_error.message; info->message = vpip_last_error.message;
info->product = vpi_vlog_info.product; info->product = vpi_vlog_info.product;
info->code = (char *) ""; info->code = (char *)"";
info->file = 0; info->file = 0;
info->line = 0; info->line = 0;
@ -500,7 +500,7 @@ __vpiScope*vpip_timescale_scope_from_handle(vpiHandle obj)
struct __vpiSysTaskCall*task; struct __vpiSysTaskCall*task;
struct __vpiSignal*signal; struct __vpiSignal*signal;
struct __vpiRealVar*real; struct __vpiRealVar*real;
__vpiNamedEvent*event; const __vpiNamedEvent*event;
switch (obj->get_type_code()) { switch (obj->get_type_code()) {
case vpiSysTaskCall: case vpiSysTaskCall:
@ -547,7 +547,7 @@ int vpip_time_units_from_handle(vpiHandle obj)
if (obj == 0) if (obj == 0)
return vpip_get_time_precision(); return vpip_get_time_precision();
__vpiScope*scope = vpip_timescale_scope_from_handle(obj); const __vpiScope*scope = vpip_timescale_scope_from_handle(obj);
if (scope == 0) if (scope == 0)
return vpip_get_time_precision(); return vpip_get_time_precision();
@ -559,7 +559,7 @@ int vpip_time_precision_from_handle(vpiHandle obj)
if (obj == 0) if (obj == 0)
return vpip_get_time_precision(); return vpip_get_time_precision();
__vpiScope*scope = vpip_timescale_scope_from_handle(obj); const __vpiScope*scope = vpip_timescale_scope_from_handle(obj);
if (scope == 0) if (scope == 0)
return vpip_get_time_precision(); return vpip_get_time_precision();
@ -641,7 +641,7 @@ static void vec4_get_value_string(const vvp_vector4_t&word_val, unsigned width,
unsigned nchar = width / 8; unsigned nchar = width / 8;
unsigned tail = width % 8; unsigned tail = width % 8;
char*rbuf = (char *) need_result_buf(nchar + 1, RBUF_VAL); char*rbuf = static_cast<char *>(need_result_buf(nchar + 1, RBUF_VAL));
char*cp = rbuf; char*cp = rbuf;
if (tail > 0) { if (tail > 0) {
@ -700,7 +700,7 @@ void vpip_vec4_get_value(const vvp_vector4_t&word_val, unsigned width,
break; break;
case vpiBinStrVal: case vpiBinStrVal:
rbuf = (char *) need_result_buf(width+1, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(width+1, RBUF_VAL));
for (unsigned idx = 0 ; idx < width ; idx += 1) { for (unsigned idx = 0 ; idx < width ; idx += 1) {
vvp_bit4_t bit = word_val.value(idx); vvp_bit4_t bit = word_val.value(idx);
rbuf[width-idx-1] = vvp_bit4_to_ascii(bit); rbuf[width-idx-1] = vvp_bit4_to_ascii(bit);
@ -711,7 +711,7 @@ void vpip_vec4_get_value(const vvp_vector4_t&word_val, unsigned width,
case vpiOctStrVal: { case vpiOctStrVal: {
unsigned hwid = ((width+2) / 3) + 1; unsigned hwid = ((width+2) / 3) + 1;
rbuf = (char *) need_result_buf(hwid, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(hwid, RBUF_VAL));
vpip_vec4_to_oct_str(word_val, rbuf, hwid); vpip_vec4_to_oct_str(word_val, rbuf, hwid);
vp->value.str = rbuf; vp->value.str = rbuf;
break; break;
@ -719,7 +719,7 @@ void vpip_vec4_get_value(const vvp_vector4_t&word_val, unsigned width,
case vpiDecStrVal: { case vpiDecStrVal: {
// HERE need a better estimate. // HERE need a better estimate.
rbuf = (char *) need_result_buf(width+1, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(width+1, RBUF_VAL));
vpip_vec4_to_dec_str(word_val, rbuf, width+1, signed_flag); vpip_vec4_to_dec_str(word_val, rbuf, width+1, signed_flag);
vp->value.str = rbuf; vp->value.str = rbuf;
break; break;
@ -727,7 +727,7 @@ void vpip_vec4_get_value(const vvp_vector4_t&word_val, unsigned width,
case vpiHexStrVal: { case vpiHexStrVal: {
unsigned hwid = ((width + 3) / 4) + 1; unsigned hwid = ((width + 3) / 4) + 1;
rbuf = (char *) need_result_buf(hwid, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(hwid, RBUF_VAL));
vpip_vec4_to_hex_str(word_val, rbuf, hwid); vpip_vec4_to_hex_str(word_val, rbuf, hwid);
vp->value.str = rbuf; vp->value.str = rbuf;
break; break;
@ -778,8 +778,8 @@ void vpip_vec4_get_value(const vvp_vector4_t&word_val, unsigned width,
case vpiVectorVal: { case vpiVectorVal: {
unsigned hwid = (width + 31)/32; unsigned hwid = (width + 31)/32;
s_vpi_vecval *op = (p_vpi_vecval) s_vpi_vecval *op = static_cast<p_vpi_vecval>
need_result_buf(hwid * sizeof(s_vpi_vecval), RBUF_VAL); (need_result_buf(hwid * sizeof(s_vpi_vecval), RBUF_VAL));
vp->value.vector = op; vp->value.vector = op;
op->aval = op->bval = 0; op->aval = op->bval = 0;
@ -842,8 +842,8 @@ void vpip_vec2_get_value(const vvp_vector2_t&word_val, unsigned width,
case vpiVectorVal: { case vpiVectorVal: {
unsigned hwid = (width + 31)/32; unsigned hwid = (width + 31)/32;
s_vpi_vecval *op = (p_vpi_vecval) s_vpi_vecval *op = static_cast<p_vpi_vecval>
need_result_buf(hwid * sizeof(s_vpi_vecval), RBUF_VAL); (need_result_buf(hwid * sizeof(s_vpi_vecval), RBUF_VAL));
vp->value.vector = op; vp->value.vector = op;
op->aval = op->bval = 0; op->aval = op->bval = 0;
@ -923,7 +923,7 @@ void vpip_real_get_value(double real, s_vpi_value*vp)
break; break;
case vpiDecStrVal: case vpiDecStrVal:
rbuf = (char *) need_result_buf(1025, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(1025, RBUF_VAL));
vpip_vec4_to_dec_str(vvp_vector4_t(1024, real), rbuf, 1025, true); vpip_vec4_to_dec_str(vvp_vector4_t(1024, real), rbuf, 1025, true);
vp->value.str = rbuf; vp->value.str = rbuf;
break; break;
@ -997,7 +997,7 @@ void vpip_string_get_value(const string&val, s_vpi_value*vp)
vp->format = vpiStringVal; vp->format = vpiStringVal;
// fallthrough // fallthrough
case vpiStringVal: case vpiStringVal:
rbuf = (char *) need_result_buf(val.size() + 1, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(val.size() + 1, RBUF_VAL));
strcpy(rbuf, val.c_str()); strcpy(rbuf, val.c_str());
vp->value.str = rbuf; vp->value.str = rbuf;
break; break;
@ -1049,7 +1049,7 @@ struct vpip_put_value_event : vvp_gen_event_s {
s_vpi_value value; s_vpi_value value;
int flags; int flags;
virtual void run_run() override; virtual void run_run() override;
~vpip_put_value_event() { } ~vpip_put_value_event() override { }
}; };
void vpip_put_value_event::run_run() void vpip_put_value_event::run_run()
@ -1350,7 +1350,7 @@ static vpiHandle find_name(const char *name, vpiHandle handle)
* name it cannot be found by name. Because of this we need * name it cannot be found by name. Because of this we need
* to skip ports here so the correct handle can be located. */ * to skip ports here so the correct handle can be located. */
if (vpi_get(vpiType, ref->intern[i]) == vpiPort) continue; if (vpi_get(vpiType, ref->intern[i]) == vpiPort) continue;
char *nm = vpi_get_str(vpiName, ref->intern[i]); const char *nm = vpi_get_str(vpiName, ref->intern[i]);
if (nm && !strcmp(name, nm)) { if (nm && !strcmp(name, nm)) {
rtn = ref->intern[i]; rtn = ref->intern[i];
break; break;
@ -1418,7 +1418,7 @@ static vpiHandle find_scope(const char *name, vpiHandle handle, int depth)
vpiHandle rtn = 0; vpiHandle rtn = 0;
vpiHandle hand; vpiHandle hand;
while (iter && (hand = vpi_scan(iter))) { while (iter && (hand = vpi_scan(iter))) {
char *nm = vpi_get_str(vpiName, hand); const char *nm = vpi_get_str(vpiName, hand);
if (strcmp(nm_first,nm)==0) { if (strcmp(nm_first,nm)==0) {
if (nm_rest) if (nm_rest)
@ -1727,7 +1727,7 @@ vpiHandle vpi_handle_multi(PLI_INT32 type,
while (current_net) { while (current_net) {
if (!current_net) break; // End of list if (!current_net) break; // End of list
vvp_fun_part* part = dynamic_cast<vvp_fun_part*>(current_net->fun); const vvp_fun_part* part = dynamic_cast<vvp_fun_part*>(current_net->fun);
// Its a part select! // Its a part select!
if (part) { if (part) {

4
vvp/vpi_priv.h
View File

@ -1086,8 +1086,8 @@ extern double vpip_scaled_time_from_handle(vvp_time64_t time, vpiHandle obj);
extern void vpip_time_to_timestruct(struct t_vpi_time*ts, vvp_time64_t ti); extern void vpip_time_to_timestruct(struct t_vpi_time*ts, vvp_time64_t ti);
extern vvp_time64_t vpip_timestruct_to_time(const struct t_vpi_time*ts); extern vvp_time64_t vpip_timestruct_to_time(const struct t_vpi_time*ts);
extern double vpip_time_to_scaled_real(vvp_time64_t ti, __vpiScope*sc); extern double vpip_time_to_scaled_real(vvp_time64_t ti, const __vpiScope*sc);
extern vvp_time64_t vpip_scaled_real_to_time64(double val, __vpiScope*sc); extern vvp_time64_t vpip_scaled_real_to_time64(double val, const __vpiScope*sc);
/* /*
* These functions are used mostly as compile time to strings into * These functions are used mostly as compile time to strings into

5
vvp/vpi_real.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2003-2022 Stephen Williams (steve@icarus.com) * Copyright (c) 2003-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -61,7 +61,8 @@ static char* real_var_get_str(int code, vpiHandle ref)
return simple_set_rbuf_str(file_names[0]); return simple_set_rbuf_str(file_names[0]);
} }
char *nm, *ixs; char *nm;
const char *ixs;
if (rfp->is_netarray) { if (rfp->is_netarray) {
nm = strdup(vpi_get_str(vpiName, rfp->within.parent)); nm = strdup(vpi_get_str(vpiName, rfp->within.parent));
s_vpi_value vp; s_vpi_value vp;

18
vvp/vpi_scope.cc
View File

@ -149,8 +149,9 @@ static void delete_sub_scopes(__vpiScope *scope)
for (citer = scope->classes.begin(); for (citer = scope->classes.begin();
citer != scope->classes.end(); ++ citer ) { citer != scope->classes.end(); ++ citer ) {
class_list_count += 1; class_list_count += 1;
class_list = (class_type **) realloc(class_list, class_list = static_cast<class_type **>
class_list_count*sizeof(class_type **)); (realloc(static_cast<void>(class_list),
class_list_count*sizeof(class_type **)));
class_list[class_list_count-1] = citer->second; class_list[class_list_count-1] = citer->second;
} }
} }
@ -324,7 +325,7 @@ static vpiHandle make_subset_iterator_(int type_code, vector<vpiHandle>&table)
if (mcnt == 0) if (mcnt == 0)
return 0; return 0;
args = (vpiHandle*)calloc(mcnt, sizeof(vpiHandle)); args = static_cast<vpiHandle*>(calloc(mcnt, sizeof(vpiHandle)));
for (unsigned idx = 0; idx < table.size(); idx += 1) for (unsigned idx = 0; idx < table.size(); idx += 1)
if (compare_types(type_code, table[idx]->get_type_code())) if (compare_types(type_code, table[idx]->get_type_code()))
args[ncnt++] = table[idx]; args[ncnt++] = table[idx];
@ -658,11 +659,12 @@ unsigned vpip_add_item_to_context(automatic_hooks_s*item,
unsigned idx = scope->nitem++; unsigned idx = scope->nitem++;
if (scope->item == 0) if (scope->item == 0)
scope->item = (automatic_hooks_s**) scope->item = static_cast<automatic_hooks_s**>
malloc(sizeof(automatic_hooks_s*)); (malloc(sizeof(automatic_hooks_s*)));
else else
scope->item = (automatic_hooks_s**) scope->item = static_cast<automatic_hooks_s**>
realloc(scope->item, sizeof(automatic_hooks_s*)*scope->nitem); (realloc(static_cast<void *>(scope->item),
sizeof(automatic_hooks_s*)*scope->nitem));
scope->item[idx] = item; scope->item[idx] = item;
@ -752,7 +754,7 @@ static vpiHandle portinfo_iterate(int code, vpiHandle ref)
switch (code) { switch (code) {
case vpiBit: { case vpiBit: {
vpiHandle*args = (vpiHandle*)calloc(width, sizeof(vpiHandle*)); vpiHandle*args = static_cast<vpiHandle*>(calloc(width, sizeof(vpiHandle*)));
for (unsigned i = 0; i<rfp->port_bits_.size(); i++) { for (unsigned i = 0; i<rfp->port_bits_.size(); i++) {
args[i] = rfp->port_bits_[i]; args[i] = rfp->port_bits_[i];

36
vvp/vpi_signal.cc
View File

@ -95,7 +95,7 @@ void *need_result_buf(unsigned cnt, vpi_rbuf_t type)
char *simple_set_rbuf_str(const char *s1) char *simple_set_rbuf_str(const char *s1)
{ {
char *res = (char *) need_result_buf(strlen(s1)+1, RBUF_STR); char *res = static_cast<char *>(need_result_buf(strlen(s1)+1, RBUF_STR));
if (res) strcpy(res,s1); if (res) strcpy(res,s1);
return res; return res;
} }
@ -114,7 +114,7 @@ char *generic_get_str(int code, vpiHandle ref, const char *name, const char *ind
} }
if (index != NULL) len += strlen(index) + 2; /* include space for brackets */ if (index != NULL) len += strlen(index) + 2; /* include space for brackets */
char *res = (char *) need_result_buf(len, RBUF_STR); char *res = static_cast<char *>(need_result_buf(len, RBUF_STR));
if (!res) { if (!res) {
free(bn); free(bn);
return NULL; return NULL;
@ -159,7 +159,7 @@ static vpiHandle fill_in_var4(struct __vpiSignal*obj,
static void format_vpiBinStrVal(vvp_signal_value*sig, int base, unsigned wid, static void format_vpiBinStrVal(vvp_signal_value*sig, int base, unsigned wid,
s_vpi_value*vp) s_vpi_value*vp)
{ {
char *rbuf = (char *) need_result_buf(wid+1, RBUF_VAL); char *rbuf = static_cast<char *>(need_result_buf(wid+1, RBUF_VAL));
long end = base + (signed)wid; long end = base + (signed)wid;
long offset = end - 1; long offset = end - 1;
long ssize = (signed)sig->value_size(); long ssize = (signed)sig->value_size();
@ -180,7 +180,7 @@ static void format_vpiOctStrVal(vvp_signal_value*sig, int base, unsigned wid,
s_vpi_value*vp) s_vpi_value*vp)
{ {
unsigned dwid = (wid + 2) / 3; unsigned dwid = (wid + 2) / 3;
char *rbuf = (char *) need_result_buf(dwid+1, RBUF_VAL); char *rbuf = static_cast<char *>(need_result_buf(dwid+1, RBUF_VAL));
long end = base + (signed)wid; long end = base + (signed)wid;
long ssize = (signed)sig->value_size(); long ssize = (signed)sig->value_size();
unsigned val = 0; unsigned val = 0;
@ -236,7 +236,7 @@ static void format_vpiHexStrVal(vvp_signal_value*sig, int base, unsigned wid,
s_vpi_value*vp) s_vpi_value*vp)
{ {
unsigned dwid = (wid + 3) / 4; unsigned dwid = (wid + 3) / 4;
char *rbuf = (char *) need_result_buf(dwid+1, RBUF_VAL); char *rbuf = static_cast<char *>(need_result_buf(dwid+1, RBUF_VAL));
long end = base + (signed)wid; long end = base + (signed)wid;
long ssize = (signed)sig->value_size(); long ssize = (signed)sig->value_size();
unsigned val = 0; unsigned val = 0;
@ -296,7 +296,7 @@ static void format_vpiDecStrVal(vvp_signal_value*sig, int base, unsigned wid,
int signed_flag, s_vpi_value*vp) int signed_flag, s_vpi_value*vp)
{ {
unsigned hwid = (sig->value_size()+2) / 3 + 1; unsigned hwid = (sig->value_size()+2) / 3 + 1;
char *rbuf = (char *) need_result_buf(hwid, RBUF_VAL); char *rbuf = static_cast<char *>(need_result_buf(hwid, RBUF_VAL));
long ssize = (signed)sig->value_size(); long ssize = (signed)sig->value_size();
long end = base + (signed)wid; long end = base + (signed)wid;
@ -382,7 +382,7 @@ static void format_vpiStringVal(vvp_signal_value*sig, int base, unsigned wid,
/* The result will use a character for each 8 bits of the /* The result will use a character for each 8 bits of the
vector. Add one extra character for the highest bits that vector. Add one extra character for the highest bits that
don't form an 8 bit group. */ don't form an 8 bit group. */
char *rbuf = (char *) need_result_buf(wid/8 + ((wid&7)!=0) + 1, RBUF_VAL); char *rbuf = static_cast<char *>(need_result_buf(wid/8 + ((wid&7)!=0) + 1, RBUF_VAL));
char *cp = rbuf; char *cp = rbuf;
char tmp = 0; char tmp = 0;
@ -442,8 +442,8 @@ static void format_vpiStrengthVal(vvp_signal_value*sig, int base,
long end = base + (signed)wid; long end = base + (signed)wid;
s_vpi_strengthval*op; s_vpi_strengthval*op;
op = (s_vpi_strengthval*) op = static_cast<s_vpi_strengthval*>
need_result_buf(wid * sizeof(s_vpi_strengthval), RBUF_VAL); (need_result_buf(wid * sizeof(s_vpi_strengthval), RBUF_VAL));
for (long idx = base ; idx < end ; idx += 1) { for (long idx = base ; idx < end ; idx += 1) {
if (idx >=0 && idx < (signed)sig->value_size()) { if (idx >=0 && idx < (signed)sig->value_size()) {
@ -497,8 +497,8 @@ static void format_vpiVectorVal(vvp_signal_value*sig, int base, unsigned wid,
unsigned int obit = 0; unsigned int obit = 0;
unsigned hwid = (wid + 31)/32; unsigned hwid = (wid + 31)/32;
s_vpi_vecval *op = (p_vpi_vecval) s_vpi_vecval *op = static_cast<p_vpi_vecval>
need_result_buf(hwid * sizeof(s_vpi_vecval), RBUF_VAL); (need_result_buf(hwid * sizeof(s_vpi_vecval), RBUF_VAL));
vp->value.vector = op; vp->value.vector = op;
op->aval = op->bval = 0; op->aval = op->bval = 0;
@ -618,7 +618,8 @@ static char* signal_get_str(int code, vpiHandle ref)
if ((code != vpiName) && (code != vpiFullName)) return NULL; if ((code != vpiName) && (code != vpiFullName)) return NULL;
char *nm, *ixs; char *nm;
const char *ixs;
if (rfp->is_netarray) { if (rfp->is_netarray) {
nm = strdup(vpi_get_str(vpiName, rfp->within.parent)); nm = strdup(vpi_get_str(vpiName, rfp->within.parent));
s_vpi_value vp; s_vpi_value vp;
@ -1194,16 +1195,17 @@ void* __vpiSignal::operator new(size_t siz)
const unsigned alloc_count = 512; const unsigned alloc_count = 512;
if ((alloc_array == 0) || (alloc_index == alloc_count)) { if ((alloc_array == 0) || (alloc_index == alloc_count)) {
alloc_array = (struct vpiSignal_plug*) alloc_array = static_cast<struct vpiSignal_plug*>
calloc(alloc_count, sizeof(struct vpiSignal_plug)); (calloc(alloc_count, sizeof(struct vpiSignal_plug)));
alloc_index = 0; alloc_index = 0;
#ifdef CHECK_WITH_VALGRIND #ifdef CHECK_WITH_VALGRIND
VALGRIND_MAKE_MEM_NOACCESS(alloc_array, alloc_count * VALGRIND_MAKE_MEM_NOACCESS(alloc_array, alloc_count *
sizeof(struct vpiSignal_plug)); sizeof(struct vpiSignal_plug));
VALGRIND_CREATE_MEMPOOL(alloc_array, 0, 1); VALGRIND_CREATE_MEMPOOL(alloc_array, 0, 1);
signal_pool_count += 1; signal_pool_count += 1;
signal_pool = (vpiSignal_plug **) realloc(signal_pool, signal_pool = static_cast<vpiSignal_plug **>
signal_pool_count*sizeof(vpiSignal_plug **)); (realloc(static_cast<void *>(signal_pool),
signal_pool_count*sizeof(vpiSignal_plug **)));
signal_pool[signal_pool_count-1] = alloc_array; signal_pool[signal_pool_count-1] = alloc_array;
#endif #endif
} }
@ -1374,7 +1376,7 @@ static char* PV_get_str(int code, vpiHandle ref)
case vpiFullName: { case vpiFullName: {
const char*nm = vpi_get_str(code, rfp->parent); const char*nm = vpi_get_str(code, rfp->parent);
size_t len = 256+strlen(nm); size_t len = 256+strlen(nm);
char *full = (char *) malloc(len); char *full = static_cast<char *>(malloc(len));
snprintf(full, len, "%s[%d:%d]", nm, snprintf(full, len, "%s[%d:%d]", nm,
(int)vpi_get(vpiLeftRange, ref), (int)vpi_get(vpiLeftRange, ref),
(int)vpi_get(vpiRightRange, ref)); (int)vpi_get(vpiRightRange, ref));

4
vvp/vpi_string.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2012-2022 Stephen Williams (steve@icarus.com) * Copyright (c) 2012-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -69,7 +69,7 @@ void __vpiStringVar::vpi_get_value(p_vpi_value val)
string str = fun->get_string(); string str = fun->get_string();
if (val->format == vpiStringVal || val->format == vpiObjTypeVal) { if (val->format == vpiStringVal || val->format == vpiObjTypeVal) {
char*rbuf = (char *) need_result_buf(str.size()+1, RBUF_VAL); char*rbuf = static_cast<char *>(need_result_buf(str.size()+1, RBUF_VAL));
strcpy(rbuf, str.c_str()); strcpy(rbuf, str.c_str());
val->format = vpiStringVal; val->format = vpiStringVal;
val->value.str = rbuf; val->value.str = rbuf;

27
vvp/vpi_tasks.cc
View File

@ -114,7 +114,7 @@ static int sysfunc_get(int type, vpiHandle ref)
static char *systask_get_str(int type, vpiHandle ref) static char *systask_get_str(int type, vpiHandle ref)
{ {
struct __vpiSysTaskCall*rfp = dynamic_cast<__vpiSysTaskCall*>(ref); const struct __vpiSysTaskCall*rfp = dynamic_cast<__vpiSysTaskCall*>(ref);
switch (type) { switch (type) {
case vpiFile: case vpiFile:
@ -143,7 +143,7 @@ static vpiHandle systask_iter(int, vpiHandle ref)
} }
struct systask_def : public __vpiSysTaskCall { struct systask_def : public __vpiSysTaskCall {
virtual ~systask_def() {}; virtual ~systask_def() override {}
virtual int get_type_code(void) const override { return vpiSysTaskCall; } virtual int get_type_code(void) const override { return vpiSysTaskCall; }
virtual int vpi_get(int code) override { return systask_get(code, this); } virtual int vpi_get(int code) override { return systask_get(code, this); }
virtual char*vpi_get_str(int code) override { return systask_get_str(code, this); } virtual char*vpi_get_str(int code) override { return systask_get_str(code, this); }
@ -152,7 +152,7 @@ struct systask_def : public __vpiSysTaskCall {
}; };
struct sysfunc_def : public systask_def { struct sysfunc_def : public systask_def {
virtual ~sysfunc_def() {}; virtual ~sysfunc_def() override {};
virtual int get_type_code(void) const override { return vpiSysFuncCall; } virtual int get_type_code(void) const override { return vpiSysFuncCall; }
virtual int vpi_get(int code) override { return sysfunc_get(code, this); } virtual int vpi_get(int code) override { return sysfunc_get(code, this); }
}; };
@ -571,8 +571,8 @@ static unsigned def_count = 0;
static struct __vpiUserSystf* allocate_def(void) static struct __vpiUserSystf* allocate_def(void)
{ {
if (def_table == 0) { if (def_table == 0) {
def_table = (struct __vpiUserSystf**) def_table = static_cast<struct __vpiUserSystf**>
malloc(sizeof (struct __vpiUserSystf*)); (malloc(sizeof(struct __vpiUserSystf*)));
def_table[0] = new __vpiUserSystf; def_table[0] = new __vpiUserSystf;
@ -580,8 +580,9 @@ static struct __vpiUserSystf* allocate_def(void)
return def_table[0]; return def_table[0];
} }
def_table = (struct __vpiUserSystf**) def_table = static_cast<struct __vpiUserSystf**>
realloc(def_table, (def_count+1)*sizeof (struct __vpiUserSystf*)); (realloc(static_cast<void *>(def_table),
(def_count+1)*sizeof(struct __vpiUserSystf*)));
def_table[def_count] = new __vpiUserSystf; def_table[def_count] = new __vpiUserSystf;
@ -706,10 +707,10 @@ static unsigned vpi_call_error_num = 0;
static void add_vpi_call_error(vpi_call_error_type type, const char *name, static void add_vpi_call_error(vpi_call_error_type type, const char *name,
long file_idx, long lineno) long file_idx, long lineno)
{ {
vpi_call_error_lst = (vpi_call_error_p) vpi_call_error_lst = static_cast<vpi_call_error_p>
realloc((void *)vpi_call_error_lst, (realloc(static_cast<void *>(vpi_call_error_lst),
(vpi_call_error_num + 1) * (vpi_call_error_num + 1) *
sizeof(vpi_call_error_s)); sizeof(vpi_call_error_s)));
vpi_call_error_lst[vpi_call_error_num].type = type; vpi_call_error_lst[vpi_call_error_num].type = type;
vpi_call_error_lst[vpi_call_error_num].name = strdup(name); vpi_call_error_lst[vpi_call_error_num].name = strdup(name);
vpi_call_error_lst[vpi_call_error_num].file_idx = file_idx; vpi_call_error_lst[vpi_call_error_num].file_idx = file_idx;
@ -974,13 +975,13 @@ void vpip_execute_vpi_call(vthread_t thr, vpiHandle ref)
/* If the function returns a value, then push the value /* If the function returns a value, then push the value
to the appropriate thread stack. */ to the appropriate thread stack. */
if (sysfunc_real*func_real = dynamic_cast<sysfunc_real*>(ref)) { if (const sysfunc_real*func_real = dynamic_cast<sysfunc_real*>(ref)) {
vthread_push(thr, func_real->return_value()); vthread_push(thr, func_real->return_value());
} }
else if (sysfunc_str*func_string = dynamic_cast<sysfunc_str*>(ref)) { else if (const sysfunc_str*func_string = dynamic_cast<sysfunc_str*>(ref)) {
vthread_push(thr, func_string->return_value()); vthread_push(thr, func_string->return_value());
} }
else if (sysfunc_vec4*func_vec4 = dynamic_cast<sysfunc_vec4*>(ref)) { else if (const sysfunc_vec4*func_vec4 = dynamic_cast<sysfunc_vec4*>(ref)) {
vthread_push(thr, func_vec4->return_value()); vthread_push(thr, func_vec4->return_value());
} }
vpip_cur_task = 0; vpip_cur_task = 0;

8
vvp/vpi_time.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2001-2018 Stephen Williams (steve@icarus.com) * Copyright (c) 2001-2025 Stephen Williams (steve@icarus.com)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU * and/or modify it in source code form under the terms of the GNU
@ -53,7 +53,7 @@ vvp_time64_t vpip_timestruct_to_time(const struct t_vpi_time*ts)
return ti; return ti;
} }
double vpip_time_to_scaled_real(vvp_time64_t ti, __vpiScope*scope) double vpip_time_to_scaled_real(vvp_time64_t ti, const __vpiScope*scope)
{ {
double val; double val;
int scale = 0; int scale = 0;
@ -70,7 +70,7 @@ double vpip_time_to_scaled_real(vvp_time64_t ti, __vpiScope*scope)
* does not check for overflow. It is only used for modpath delays and * does not check for overflow. It is only used for modpath delays and
* they are required to be non-negative. * they are required to be non-negative.
*/ */
vvp_time64_t vpip_scaled_real_to_time64(double val, __vpiScope*scope) vvp_time64_t vpip_scaled_real_to_time64(double val, const __vpiScope*scope)
{ {
int shift = 0; int shift = 0;
if (scope) shift = scope->time_units - scope->time_precision; if (scope) shift = scope->time_units - scope->time_precision;
@ -107,7 +107,7 @@ static void timevar_get_value(vpiHandle ref, s_vpi_value*vp, bool is_int_func,
int units = rfp->scope? rfp->scope->time_units : vpi_time_precision; int units = rfp->scope? rfp->scope->time_units : vpi_time_precision;
static const size_t RBUF_USE_SIZE = 128; static const size_t RBUF_USE_SIZE = 128;
char*rbuf = (char *) need_result_buf(RBUF_USE_SIZE, RBUF_VAL); char*rbuf = static_cast<char *>(need_result_buf(RBUF_USE_SIZE, RBUF_VAL));
/* Calculate the divisor needed to scale the simulation time /* Calculate the divisor needed to scale the simulation time
(in time_precision units) to time units of the scope. */ (in time_precision units) to time units of the scope. */

27
vvp/vpi_vthr_vector.cc
View File

@ -70,7 +70,7 @@ class __vpiVThrWord : public __vpiHandle {
static int vthr_word_get(int code, vpiHandle ref) static int vthr_word_get(int code, vpiHandle ref)
{ {
__vpiVThrWord*rfp = dynamic_cast<__vpiVThrWord*>(ref); const __vpiVThrWord*rfp = dynamic_cast<__vpiVThrWord*>(ref);
switch (code) { switch (code) {
@ -98,9 +98,9 @@ static double vlg_round(double rval)
static void vthr_real_get_value(vpiHandle ref, s_vpi_value*vp) static void vthr_real_get_value(vpiHandle ref, s_vpi_value*vp)
{ {
__vpiVThrWord*obj = dynamic_cast<__vpiVThrWord*>(ref); const __vpiVThrWord*obj = dynamic_cast<__vpiVThrWord*>(ref);
static const size_t RBUF_USE_SIZE = 66; static const size_t RBUF_USE_SIZE = 66;
char *rbuf = (char *) need_result_buf(RBUF_USE_SIZE, RBUF_VAL); char *rbuf = static_cast<char *>(need_result_buf(RBUF_USE_SIZE, RBUF_VAL));
double val = 0.0; double val = 0.0;
@ -271,7 +271,7 @@ void __vpiVThrStrStack::vpi_get_value(p_vpi_value vp)
vp->format = vpiStringVal; vp->format = vpiStringVal;
// fallthrough // fallthrough
case vpiStringVal: case vpiStringVal:
rbuf = (char *) need_result_buf(val.size()+1, RBUF_VAL); rbuf = static_cast<char *>(need_result_buf(val.size()+1, RBUF_VAL));
strcpy(rbuf, val.c_str()); strcpy(rbuf, val.c_str());
vp->value.str = rbuf; vp->value.str = rbuf;
break; break;
@ -404,7 +404,7 @@ void __vpiVThrVec4Stack::vpi_get_value(p_vpi_value vp)
void __vpiVThrVec4Stack::vpi_get_value_binstr_(p_vpi_value vp, const vvp_vector4_t&val) void __vpiVThrVec4Stack::vpi_get_value_binstr_(p_vpi_value vp, const vvp_vector4_t&val)
{ {
unsigned wid = val.size(); unsigned wid = val.size();
char*rbuf = (char*) need_result_buf(wid+1, RBUF_VAL); char*rbuf = static_cast<char*>(need_result_buf(wid+1, RBUF_VAL));
for (unsigned idx = 0 ; idx < wid ; idx += 1) { for (unsigned idx = 0 ; idx < wid ; idx += 1) {
rbuf[wid-idx-1] = vvp_bit4_to_ascii(val.value(idx)); rbuf[wid-idx-1] = vvp_bit4_to_ascii(val.value(idx));
} }
@ -416,7 +416,7 @@ void __vpiVThrVec4Stack::vpi_get_value_decstr_(p_vpi_value vp, const vvp_vector4
{ {
unsigned wid = val.size(); unsigned wid = val.size();
int nbuf = (wid+2)/3 + 1; int nbuf = (wid+2)/3 + 1;
char *rbuf = (char*) need_result_buf(nbuf, RBUF_VAL); char *rbuf = static_cast<char*>(need_result_buf(nbuf, RBUF_VAL));
vpip_vec4_to_dec_str(val, rbuf, nbuf, signed_flag_); vpip_vec4_to_dec_str(val, rbuf, nbuf, signed_flag_);
vp->value.str = rbuf; vp->value.str = rbuf;
@ -426,7 +426,7 @@ void __vpiVThrVec4Stack::vpi_get_value_octstr_(p_vpi_value vp, const vvp_vector4
{ {
unsigned wid = val.size(); unsigned wid = val.size();
unsigned owid = (wid + 2) / 3; unsigned owid = (wid + 2) / 3;
char*rbuf = (char*) need_result_buf(owid+1, RBUF_VAL); char*rbuf = static_cast<char*>(need_result_buf(owid+1, RBUF_VAL));
rbuf[owid] = 0; rbuf[owid] = 0;
unsigned oval = 0; unsigned oval = 0;
@ -467,7 +467,7 @@ void __vpiVThrVec4Stack::vpi_get_value_hexstr_(p_vpi_value vp, const vvp_vector4
{ {
unsigned wid = val.size(); unsigned wid = val.size();
unsigned hwid = (wid + 3) /4; unsigned hwid = (wid + 3) /4;
char*rbuf = (char*) need_result_buf(hwid+1, RBUF_VAL); char*rbuf = static_cast<char*>(need_result_buf(hwid+1, RBUF_VAL));
rbuf[hwid] = 0; rbuf[hwid] = 0;
unsigned hval = 0; unsigned hval = 0;
@ -524,7 +524,7 @@ void __vpiVThrVec4Stack::vpi_get_value_real_(p_vpi_value vp, const vvp_vector4_t
void __vpiVThrVec4Stack::vpi_get_value_string_(p_vpi_value vp, const vvp_vector4_t&val) void __vpiVThrVec4Stack::vpi_get_value_string_(p_vpi_value vp, const vvp_vector4_t&val)
{ {
char*rbuf = (char*) need_result_buf((val.size() / 8) + 1, RBUF_VAL); char*rbuf = static_cast<char*>(need_result_buf((val.size() / 8) + 1, RBUF_VAL));
char*cp = rbuf; char*cp = rbuf;
char tmp = 0; char tmp = 0;
@ -557,8 +557,8 @@ void __vpiVThrVec4Stack::vpi_get_value_vector_(p_vpi_value vp, const vvp_vector4
{ {
unsigned wid = val.size(); unsigned wid = val.size();
vp->value.vector = (s_vpi_vecval*) vp->value.vector = static_cast<s_vpi_vecval*>
need_result_buf((wid+31)/32*sizeof(s_vpi_vecval), RBUF_VAL); (need_result_buf((wid+31)/32*sizeof(s_vpi_vecval), RBUF_VAL));
assert(vp->value.vector); assert(vp->value.vector);
for (unsigned idx = 0 ; idx < wid ; idx += 1) { for (unsigned idx = 0 ; idx < wid ; idx += 1) {
@ -588,8 +588,9 @@ void __vpiVThrVec4Stack::vpi_get_value_vector_(p_vpi_value vp, const vvp_vector4
void __vpiVThrVec4Stack::vpi_get_value_strength_(p_vpi_value vp, const vvp_vector4_t&val) void __vpiVThrVec4Stack::vpi_get_value_strength_(p_vpi_value vp, const vvp_vector4_t&val)
{ {
s_vpi_strengthval*op = (s_vpi_strengthval*) s_vpi_strengthval*op = static_cast<s_vpi_strengthval*>
need_result_buf(val.size() * sizeof(s_vpi_strengthval), RBUF_VAL); (need_result_buf(val.size() * sizeof(s_vpi_strengthval),
RBUF_VAL));
for (unsigned idx = 0 ; idx < val.size() ; idx += 1) { for (unsigned idx = 0 ; idx < val.size() ; idx += 1) {
switch (val.value(idx)) { switch (val.value(idx)) {

5
vvp/vpip_to_dec.cc
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2008-2011 Stephen Williams <steve@icarus.com> * Copyright (c) 2008-2025 Stephen Williams <steve@icarus.com>
* Copyright (c) 2002 Larry Doolittle (larry@doolittle.boa.org) * Copyright (c) 2002 Larry Doolittle (larry@doolittle.boa.org)
* *
* This source code is free software; you can redistribute it * This source code is free software; you can redistribute it
@ -150,7 +150,8 @@ unsigned vpip_vec4_to_dec_str(const vvp_vector4_t&vec4,
#define ALLOC_MARGIN 4 #define ALLOC_MARGIN 4
if (!valv || vlen > vlen_alloc) { if (!valv || vlen > vlen_alloc) {
if (valv) free(valv); if (valv) free(valv);
valv = (unsigned long*) calloc(vlen+ALLOC_MARGIN, sizeof (*valv)); valv = static_cast<unsigned long*>
(calloc(vlen+ALLOC_MARGIN, sizeof (*valv)));
vlen_alloc=vlen+ALLOC_MARGIN; vlen_alloc=vlen+ALLOC_MARGIN;
} else { } else {
memset(valv,0,vlen*sizeof(valv[0])); memset(valv,0,vlen*sizeof(valv[0]));

10
vvp/vvp_darray.h
View File

@ -29,7 +29,7 @@ class vvp_darray : public vvp_object {
public: public:
inline vvp_darray() { } inline vvp_darray() { }
virtual ~vvp_darray(); virtual ~vvp_darray() override;
virtual size_t get_size(void) const =0; virtual size_t get_size(void) const =0;
@ -52,7 +52,7 @@ template <class TYPE> class vvp_darray_atom : public vvp_darray {
public: public:
explicit inline vvp_darray_atom(size_t siz) : array_(siz) { } explicit inline vvp_darray_atom(size_t siz) : array_(siz) { }
~vvp_darray_atom(); ~vvp_darray_atom() override;
size_t get_size(void) const override; size_t get_size(void) const override;
void set_word(unsigned adr, const vvp_vector4_t&value) override; void set_word(unsigned adr, const vvp_vector4_t&value) override;
@ -184,7 +184,7 @@ class vvp_queue : public vvp_darray {
class vvp_queue_real : public vvp_queue { class vvp_queue_real : public vvp_queue {
public: public:
~vvp_queue_real(); ~vvp_queue_real() override;
size_t get_size(void) const override { return queue.size(); }; size_t get_size(void) const override { return queue.size(); };
void copy_elems(vvp_object_t src, unsigned max_size) override; void copy_elems(vvp_object_t src, unsigned max_size) override;
@ -206,7 +206,7 @@ class vvp_queue_real : public vvp_queue {
class vvp_queue_string : public vvp_queue { class vvp_queue_string : public vvp_queue {
public: public:
~vvp_queue_string(); ~vvp_queue_string() override;
size_t get_size(void) const override { return queue.size(); }; size_t get_size(void) const override { return queue.size(); };
void copy_elems(vvp_object_t src, unsigned max_size) override; void copy_elems(vvp_object_t src, unsigned max_size) override;
@ -228,7 +228,7 @@ class vvp_queue_string : public vvp_queue {
class vvp_queue_vec4 : public vvp_queue { class vvp_queue_vec4 : public vvp_queue {
public: public:
~vvp_queue_vec4(); ~vvp_queue_vec4() override;
size_t get_size(void) const override { return queue.size(); }; size_t get_size(void) const override { return queue.size(); };
void copy_elems(vvp_object_t src, unsigned max_size) override; void copy_elems(vvp_object_t src, unsigned max_size) override;

14
vvp/vvp_net_sig.cc
View File

@ -409,7 +409,7 @@ unsigned vvp_fun_signal4_aa::value_size() const
vvp_bit4_t vvp_fun_signal4_aa::value(unsigned idx) const vvp_bit4_t vvp_fun_signal4_aa::value(unsigned idx) const
{ {
vvp_vector4_t*bits4 = static_cast<vvp_vector4_t*> const vvp_vector4_t*bits4 = static_cast<vvp_vector4_t*>
(vthread_get_rd_context_item(context_idx_)); (vthread_get_rd_context_item(context_idx_));
return bits4->value(idx); return bits4->value(idx);
@ -417,7 +417,7 @@ vvp_bit4_t vvp_fun_signal4_aa::value(unsigned idx) const
vvp_scalar_t vvp_fun_signal4_aa::scalar_value(unsigned idx) const vvp_scalar_t vvp_fun_signal4_aa::scalar_value(unsigned idx) const
{ {
vvp_vector4_t*bits4 = static_cast<vvp_vector4_t*> const vvp_vector4_t*bits4 = static_cast<vvp_vector4_t*>
(vthread_get_rd_context_item(context_idx_)); (vthread_get_rd_context_item(context_idx_));
return vvp_scalar_t(bits4->value(idx), 6, 6); return vvp_scalar_t(bits4->value(idx), 6, 6);
@ -425,7 +425,7 @@ vvp_scalar_t vvp_fun_signal4_aa::scalar_value(unsigned idx) const
void vvp_fun_signal4_aa::vec4_value(vvp_vector4_t&val) const void vvp_fun_signal4_aa::vec4_value(vvp_vector4_t&val) const
{ {
vvp_vector4_t*bits4 = static_cast<vvp_vector4_t*> const vvp_vector4_t*bits4 = static_cast<vvp_vector4_t*>
(vthread_get_rd_context_item(context_idx_)); (vthread_get_rd_context_item(context_idx_));
val = *bits4; val = *bits4;
@ -433,7 +433,7 @@ void vvp_fun_signal4_aa::vec4_value(vvp_vector4_t&val) const
const vvp_vector4_t&vvp_fun_signal4_aa::vec4_unfiltered_value() const const vvp_vector4_t&vvp_fun_signal4_aa::vec4_unfiltered_value() const
{ {
vvp_vector4_t*bits4 = static_cast<vvp_vector4_t*> const vvp_vector4_t*bits4 = static_cast<vvp_vector4_t*>
(vthread_get_rd_context_item(context_idx_)); (vthread_get_rd_context_item(context_idx_));
return *bits4; return *bits4;
@ -528,7 +528,7 @@ void vvp_fun_signal_real_aa::free_instance(vvp_context_t context)
double vvp_fun_signal_real_aa::real_unfiltered_value() const double vvp_fun_signal_real_aa::real_unfiltered_value() const
{ {
double*bits = static_cast<double*> const double*bits = static_cast<double*>
(vthread_get_rd_context_item(context_idx_)); (vthread_get_rd_context_item(context_idx_));
return *bits; return *bits;
@ -688,7 +688,7 @@ double vvp_fun_signal_string_aa::real_value() const
const std::string& vvp_fun_signal_string_aa::get_string() const const std::string& vvp_fun_signal_string_aa::get_string() const
{ {
string*bits = static_cast<std::string*> const string*bits = static_cast<std::string*>
(vthread_get_rd_context_item(context_idx_)); (vthread_get_rd_context_item(context_idx_));
return *bits; return *bits;
@ -765,7 +765,7 @@ void vvp_fun_signal_object_aa::reset_instance(vvp_context_t context)
vvp_object_t vvp_fun_signal_object_aa::get_object() const vvp_object_t vvp_fun_signal_object_aa::get_object() const
{ {
vvp_object_t*bits = static_cast<vvp_object_t*> const vvp_object_t*bits = static_cast<vvp_object_t*>
(vthread_get_rd_context_item(context_idx_)); (vthread_get_rd_context_item(context_idx_));
return *bits; return *bits;
} }

6
vvp/words.cc
View File

@ -190,7 +190,7 @@ void compile_variable(char*label, char*name,
net->fil = new vvp_wire_vec4(wid, init); net->fil = new vvp_wire_vec4(wid, init);
net->fun = new vvp_fun_signal4_sa(wid); net->fun = new vvp_fun_signal4_sa(wid);
} }
vvp_signal_value*vfil = dynamic_cast<vvp_signal_value*>(net->fil); const vvp_signal_value*vfil = dynamic_cast<vvp_signal_value*>(net->fil);
define_functor_symbol(label, net); define_functor_symbol(label, net);
@ -295,7 +295,7 @@ class __compile_net_resolv : public base_net_resolv {
signed_flag_ = signed_flag; signed_flag_ = signed_flag;
} }
~__compile_net_resolv() { } ~__compile_net_resolv() override { }
bool resolve(bool message_flag) override; bool resolve(bool message_flag) override;
@ -457,7 +457,7 @@ class __compile_real_net_resolv : public base_net_resolv {
{ {
} }
~__compile_real_net_resolv() { } ~__compile_real_net_resolv() override { }
bool resolve(bool message_flag) override; bool resolve(bool message_flag) override;