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

168 lines
4.4 KiB
C++
Raw Normal View History

Create the shell of a proper type system. Rather then just relying on comparing type names all throughout elaboration, create type description data structures and use them during elaboration to handle proper types.
2011-02-07 05:55:31 +01:00
/*
* Copyright (c) 2011 Stephen Williams (steve@icarus.com)
*
* This source code is free software; you can redistribute it
* and/or modify it in source code form under the terms of the GNU
* General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
# include "vtype.h"
Elaborate array subtypes of ports. There are internal types that are unbounded arrays. Allow subtype syntax that creates bounded versions of these arrays, and elaborate them as vectors at port boundaries. This makes some interesting types work out. Also start replacing vhdlint and vhdlreal with int64_t and double, which are reasonable values for universal_integer and universal_real from the VHDL standard. I need these cleaned up because the ints in particular are used for the literal expressions in array index constraints.
2011-02-14 04:01:21 +01:00
# include <typeinfo>
Create the shell of a proper type system. Rather then just relying on comparing type names all throughout elaboration, create type description data structures and use them during elaboration to handle proper types.
2011-02-07 05:55:31 +01:00
using namespace std;
std::map<perm_string, const VType*> global_types;
const VTypePrimitive primitive_BOOLEAN (VTypePrimitive::BOOLEAN);
const VTypePrimitive primitive_BIT (VTypePrimitive::BIT);;
const VTypePrimitive primitive_INTEGER (VTypePrimitive::INTEGER);;
const VTypePrimitive primitive_STDLOGIC(VTypePrimitive::STDLOGIC);;
Handle signed vs unsigned vector types. In principle, some of these should be handled by overloaded operator functions, but these are built in types with natural translations so do the obvious things.
2011-02-26 05:09:31 +01:00
const VTypeArray primitive_BIT_VECTOR(&primitive_BIT, vector<VTypeArray::range_t> (1));
const VTypeArray primitive_BOOL_VECTOR(&primitive_BOOLEAN, vector<VTypeArray::range_t> (1));
Create the shell of a proper type system. Rather then just relying on comparing type names all throughout elaboration, create type description data structures and use them during elaboration to handle proper types.
2011-02-07 05:55:31 +01:00
void preload_global_types(void)
{
global_types[perm_string::literal("boolean")] = &primitive_BOOLEAN;
global_types[perm_string::literal("bit")] = &primitive_BIT;
global_types[perm_string::literal("integer")] = &primitive_INTEGER;
global_types[perm_string::literal("std_logic")] = &primitive_STDLOGIC;
Handle signed vs unsigned vector types. In principle, some of these should be handled by overloaded operator functions, but these are built in types with natural translations so do the obvious things.
2011-02-26 05:09:31 +01:00
global_types[perm_string::literal("bit_vector")]= &primitive_BOOL_VECTOR;
Create the shell of a proper type system. Rather then just relying on comparing type names all throughout elaboration, create type description data structures and use them during elaboration to handle proper types.
2011-02-07 05:55:31 +01:00
}
Stub support for library import. This provides a stub implementation for library import. Use this stub to make up a slightly more functional ieee library implementation.
2011-02-19 20:39:00 +01:00
void import_ieee(void)
{
Stub support for "use" directives. Implement the parser infrastructure for handling library use clauses, and use that to handle specific packages of the ieee library. Make the numeric types come from the numeric_* packages instead of being built in.
2011-02-19 22:08:26 +01:00
}
static void import_ieee_use_std_logic_1164(perm_string)
{
}
static void import_ieee_use_numeric_bit(perm_string name)
{
bool all_flag = name=="all";
Declare the numeric signed type.
2011-02-20 01:50:36 +01:00
if (all_flag || name == "signed") {
vector<VTypeArray::range_t> dims (1);
Handle signed vs unsigned vector types. In principle, some of these should be handled by overloaded operator functions, but these are built in types with natural translations so do the obvious things.
2011-02-26 05:09:31 +01:00
global_types[perm_string::literal("signed")] = new VTypeArray(&primitive_STDLOGIC, dims, true);
Declare the numeric signed type.
2011-02-20 01:50:36 +01:00
}
Stub support for "use" directives. Implement the parser infrastructure for handling library use clauses, and use that to handle specific packages of the ieee library. Make the numeric types come from the numeric_* packages instead of being built in.
2011-02-19 22:08:26 +01:00
if (all_flag || name == "unsigned") {
vector<VTypeArray::range_t> dims (1);
Handle signed vs unsigned vector types. In principle, some of these should be handled by overloaded operator functions, but these are built in types with natural translations so do the obvious things.
2011-02-26 05:09:31 +01:00
global_types[perm_string::literal("unsigned")] = new VTypeArray(&primitive_BIT, dims, false);
Stub support for "use" directives. Implement the parser infrastructure for handling library use clauses, and use that to handle specific packages of the ieee library. Make the numeric types come from the numeric_* packages instead of being built in.
2011-02-19 22:08:26 +01:00
}
}
static void import_ieee_use_numeric_std(perm_string name)
{
bool all_flag = name=="all";
Declare the numeric signed type.
2011-02-20 01:50:36 +01:00
if (all_flag || name == "signed") {
vector<VTypeArray::range_t> dims (1);
global_types[perm_string::literal("signed")] = new VTypeArray(&primitive_STDLOGIC, dims);
}
Stub support for "use" directives. Implement the parser infrastructure for handling library use clauses, and use that to handle specific packages of the ieee library. Make the numeric types come from the numeric_* packages instead of being built in.
2011-02-19 22:08:26 +01:00
if (all_flag || name == "unsigned") {
vector<VTypeArray::range_t> dims (1);
global_types[perm_string::literal("unsigned")] = new VTypeArray(&primitive_STDLOGIC, dims);
}
}
void import_ieee_use(perm_string package, perm_string name)
{
if (package == "std_logic_1164") {
import_ieee_use_std_logic_1164(name);
return;
}
if (package == "numeric_bit") {
import_ieee_use_numeric_bit(name);
return;
}
Stub support for library import. This provides a stub implementation for library import. Use this stub to make up a slightly more functional ieee library implementation.
2011-02-19 20:39:00 +01:00
Stub support for "use" directives. Implement the parser infrastructure for handling library use clauses, and use that to handle specific packages of the ieee library. Make the numeric types come from the numeric_* packages instead of being built in.
2011-02-19 22:08:26 +01:00
if (package == "numeric_std") {
import_ieee_use_numeric_std(name);
return;
}
Stub support for library import. This provides a stub implementation for library import. Use this stub to make up a slightly more functional ieee library implementation.
2011-02-19 20:39:00 +01:00
}
Create the shell of a proper type system. Rather then just relying on comparing type names all throughout elaboration, create type description data structures and use them during elaboration to handle proper types.
2011-02-07 05:55:31 +01:00
VType::~VType()
{
}
Elaborate array subtypes of ports. There are internal types that are unbounded arrays. Allow subtype syntax that creates bounded versions of these arrays, and elaborate them as vectors at port boundaries. This makes some interesting types work out. Also start replacing vhdlint and vhdlreal with int64_t and double, which are reasonable values for universal_integer and universal_real from the VHDL standard. I need these cleaned up because the ints in particular are used for the literal expressions in array index constraints.
2011-02-14 04:01:21 +01:00
void VType::show(ostream&out) const
{
out << typeid(*this).name();
}
Create the shell of a proper type system. Rather then just relying on comparing type names all throughout elaboration, create type description data structures and use them during elaboration to handle proper types.
2011-02-07 05:55:31 +01:00
VTypePrimitive::VTypePrimitive(VTypePrimitive::type_t tt)
: type_(tt)
{
}
VTypePrimitive::~VTypePrimitive()
{
}
Do type mapping in the parser. In VHDL, types are declared before they are used, so it is possible to do type binding during parse. This makes the parser a little bit cleaner.
2011-02-14 01:37:10 +01:00
Elaborate array subtypes of ports. There are internal types that are unbounded arrays. Allow subtype syntax that creates bounded versions of these arrays, and elaborate them as vectors at port boundaries. This makes some interesting types work out. Also start replacing vhdlint and vhdlreal with int64_t and double, which are reasonable values for universal_integer and universal_real from the VHDL standard. I need these cleaned up because the ints in particular are used for the literal expressions in array index constraints.
2011-02-14 04:01:21 +01:00
void VTypePrimitive::show(ostream&out) const
{
switch (type_) {
case BOOLEAN:
out << "BOOLEAN";
break;
case BIT:
out << "BIT";
break;
case INTEGER:
out << "INTEGER";
break;
case STDLOGIC:
out << "std_logic";
break;
}
}
Handle signed vs unsigned vector types. In principle, some of these should be handled by overloaded operator functions, but these are built in types with natural translations so do the obvious things.
2011-02-26 05:09:31 +01:00
VTypeArray::VTypeArray(const VType*element, const vector<VTypeArray::range_t>&r, bool sv)
: etype_(element), ranges_(r), signed_flag_(sv)
Do type mapping in the parser. In VHDL, types are declared before they are used, so it is possible to do type binding during parse. This makes the parser a little bit cleaner.
2011-02-14 01:37:10 +01:00
{
}
VTypeArray::~VTypeArray()
{
}
Elaborate array subtypes of ports. There are internal types that are unbounded arrays. Allow subtype syntax that creates bounded versions of these arrays, and elaborate them as vectors at port boundaries. This makes some interesting types work out. Also start replacing vhdlint and vhdlreal with int64_t and double, which are reasonable values for universal_integer and universal_real from the VHDL standard. I need these cleaned up because the ints in particular are used for the literal expressions in array index constraints.
2011-02-14 04:01:21 +01:00
size_t VTypeArray::dimensions() const
{
return ranges_.size();
}
const VType* VTypeArray::element_type() const
{
return etype_;
}
void VTypeArray::show(ostream&out) const
{
out << "array ";
for (vector<range_t>::const_iterator cur = ranges_.begin()
; cur != ranges_.end() ; ++cur) {
out << "(" << cur->msb() << " downto " << cur->lsb() << ")";
}
out << " of ";
Handle signed vs unsigned vector types. In principle, some of these should be handled by overloaded operator functions, but these are built in types with natural translations so do the obvious things.
2011-02-26 05:09:31 +01:00
if (signed_flag_)
out << "signed ";
Elaborate array subtypes of ports. There are internal types that are unbounded arrays. Allow subtype syntax that creates bounded versions of these arrays, and elaborate them as vectors at port boundaries. This makes some interesting types work out. Also start replacing vhdlint and vhdlreal with int64_t and double, which are reasonable values for universal_integer and universal_real from the VHDL standard. I need these cleaned up because the ints in particular are used for the literal expressions in array index constraints.
2011-02-14 04:01:21 +01:00
if (etype_)
etype_->show(out);
else
out << "<nil>";
}