static unsigned emit_as_input(ivl_scope_t scope, ivl_net_const_t net_const)
{
ivl_scope_t const_scope = ivl_const_scope(net_const);
ivl_scope_t parent = ivl_scope_parent(scope);
/* Look to see if the constant scope is a parent of this scope. */
while (parent) {
if (parent == const_scope) break;
parent = ivl_scope_parent(parent);
}
/* If the constant scope is a parent then look for an input in
* this scope and use that for the name. */
if (parent) {
ivl_nexus_t nex = ivl_const_nex(net_const);
unsigned idx, count = ivl_nexus_ptrs(nex);
for (idx = 0; idx < count; idx += 1) {
ivl_nexus_ptr_t nex_ptr = ivl_nexus_ptr(nex, idx);
ivl_signal_t sig = ivl_nexus_ptr_sig(nex_ptr);
if (sig && (ivl_signal_port(sig) == IVL_SIP_INPUT)) {
emit_id(ivl_signal_basename(sig));
return 1;
}
}
}
return 0;
}
void emit_const_nexus(ivl_scope_t scope, ivl_net_const_t net_const)
{
ivl_scope_t const_scope = ivl_const_scope(net_const);
unsigned idx, count, lineno;
const char *file;
count = ivl_scope_params(const_scope);
file = ivl_const_file(net_const);
lineno = ivl_const_lineno(net_const);
/* Look to see if the constant matches a parameter in its scope. */
for (idx = 0; idx < count; idx += 1) {
ivl_parameter_t par = ivl_scope_param(const_scope, idx);
if (lineno != ivl_parameter_lineno(par)) continue;
if (strcmp(file, ivl_parameter_file(par)) == 0) {
/* Check that the appropriate expression bits match the
* original parameter bits. */
// HERE: Verify that the values match and then print the name.
// Does this work with out of scope references? Check real parameters.
emit_id(ivl_parameter_basename(par));
return;
}
}
/* If the scopes don't match then we assume this is an empty port. */
if (const_scope != scope) {
/* This constant could really be from an input port. */
if (emit_as_input(scope, net_const)) return;
fprintf(vlog_out, "/* Empty */");
return;
}
switch (ivl_const_type(net_const)) {
case IVL_VT_LOGIC:
case IVL_VT_BOOL:
emit_number(ivl_const_bits(net_const),
ivl_const_width(net_const),
ivl_const_signed(net_const),
ivl_const_file(net_const),
ivl_const_lineno(net_const));
break;
case IVL_VT_STRING:
emit_number_as_string(net_const);
break;
case IVL_VT_REAL:
emit_real_number(ivl_const_real(net_const));
break;
default:
fprintf(vlog_out, "<invalid>");
fprintf(stderr, "%s:%u: vlog95 error: Unknown constant type "
"(%d).\n",
ivl_const_file(net_const),
ivl_const_lineno(net_const),
(int)ivl_const_type(net_const));
vlog_errors += 1;
break;
}
}
static void emit_expr_scope_piece(ivl_scope_t scope)
{
ivl_scope_t parent = ivl_scope_parent(scope);
/* If this scope has a parent then emit it first. */
if (parent) {
emit_expr_scope_piece(parent);
fprintf(vlog_out, ".");
}
emit_id(ivl_scope_basename(scope));
}
/*
* An event in an expression context must be a named event.
*/
static void emit_expr_event(ivl_scope_t scope, ivl_expr_t expr, unsigned wid)
{
ivl_event_t event = ivl_expr_event(expr);
ivl_scope_t ev_scope = ivl_event_scope(event);
assert(! ivl_event_nany(event));
assert(! ivl_event_npos(event));
assert(! ivl_event_nneg(event));
emit_scope_call_path(scope, ev_scope);
emit_id(ivl_event_basename(event));
}
static void emit_stmt_fork_named(ivl_scope_t scope, ivl_statement_t stmt)
{
ivl_scope_t my_scope = ivl_stmt_block_scope(stmt);
fprintf(vlog_out, "%*cfork: ", get_indent(), ' ');
emit_id(ivl_scope_basename(my_scope));
emit_stmt_file_line(stmt);
fprintf(vlog_out, "\n");
emit_stmt_block_body(scope, stmt);
fprintf(vlog_out, "%*cjoin /* %s */\n", get_indent(), ' ',
ivl_scope_basename(my_scope));
}
/*
* This routine emits the appropriate string to call the call_scope from the
* given scope. If the module scopes for the two match then just return the
* base name of the call_scope. If the module scopes are different, but the
* call_scope begins with the entire module scope of scope then we can trim
* the top off the call_scope (it is a sub-scope of the module that contains
* scope). Otherwise we need to print the entire path of call_scope.
*/
void emit_scope_path(ivl_scope_t scope, ivl_scope_t call_scope)
{
ivl_scope_t mod_scope = get_module_scope(scope);
ivl_scope_t call_mod_scope = get_module_scope(call_scope);
if (mod_scope == call_mod_scope) {
emit_id(ivl_scope_basename(call_scope));
} else {
emit_scope_path_piece(mod_scope, call_scope);
}
}
static unsigned find_driving_signal(ivl_scope_t scope, ivl_nexus_t nex)
{
ivl_signal_t sig = 0;
unsigned is_array = 0;
int64_t array_idx = 0;
unsigned idx, count = ivl_nexus_ptrs(nex);
for (idx = 0; idx < count; idx += 1) {
ivl_nexus_ptr_t nex_ptr = ivl_nexus_ptr(nex, idx);
ivl_signal_t t_sig = ivl_nexus_ptr_sig(nex_ptr);
if (! t_sig) continue;
if (ivl_signal_local(t_sig)) continue;
/* An output can be used if it is driven by this nexus. */
if ((ivl_nexus_ptr_drive1(nex_ptr) == IVL_DR_HiZ) &&
(ivl_nexus_ptr_drive0(nex_ptr) == IVL_DR_HiZ) &&
(ivl_signal_port(t_sig) != IVL_SIP_OUTPUT)) {
continue;
}
/* We have a signal that can be used to find the name. */
if (sig) {
// HERE: Which one should we use? For now it's the first one found.
// I believe this needs to be solved (see above).
fprintf(stderr, "%s:%u: vlog95 warning: Duplicate name (%s",
ivl_signal_file(t_sig), ivl_signal_lineno(t_sig),
ivl_signal_basename(t_sig));
if (ivl_signal_dimensions(t_sig) > 0) {
int64_t tmp_idx = ivl_nexus_ptr_pin(nex_ptr);
tmp_idx += ivl_signal_array_base(t_sig);
fprintf(stderr, "[%"PRId64"]", tmp_idx);
}
fprintf(stderr, ") found for nexus (%s",
ivl_signal_basename(sig));
if (is_array) fprintf(stderr, "[%"PRId64"]", array_idx);
fprintf(stderr, ")\n");
} else {
sig = t_sig;
if (ivl_signal_dimensions(sig) > 0) {
is_array = 1;
array_idx = ivl_nexus_ptr_pin(nex_ptr);
array_idx += ivl_signal_array_base(sig);
}
}
}
if (sig) {
emit_scope_call_path(scope, ivl_signal_scope(sig));
emit_id(ivl_signal_basename(sig));
if (is_array) fprintf(vlog_out, "[%"PRId64"]", array_idx);
return 1;
}
return 0;
}
static void emit_scope_path_piece(ivl_scope_t scope, ivl_scope_t call_scope)
{
ivl_scope_t parent = ivl_scope_parent(call_scope);
/* If we are not at the top of the scope (parent != 0) and the two
* scopes do not match then print the parent scope. */
if ((parent != 0) && (scope != parent)) {
emit_scope_path_piece(scope, parent);
fprintf(vlog_out, ".");
}
/* Print the base scope. */
emit_id(ivl_scope_basename(call_scope));
}
void emit::load_emit( JsonObject &jo )
{
emit et;
et.id_ = emit_id( jo.get_string( "id" ) );
et.field_name = jo.get_string( "field" );
jo.read( "density", et.density_ );
jo.read( "qty", et.qty_ );
jo.read( "chance", et.chance_ );
emits_all[ et.id_ ] = et;
}
static void emit_expr_signal(ivl_scope_t scope, ivl_expr_t expr, unsigned wid)
{
ivl_signal_t sig = ivl_expr_signal(expr);
emit_scope_call_path(scope, ivl_signal_scope(sig));
emit_id(ivl_signal_basename(sig));
if (ivl_signal_dimensions(sig)) {
int lsb = ivl_signal_array_base(sig);
int msb = lsb + ivl_signal_array_count(sig);
fprintf(vlog_out, "[");
emit_scaled_expr(scope, ivl_expr_oper1(expr), msb, lsb);
fprintf(vlog_out, "]");
}
}
void emit_event(ivl_scope_t scope, ivl_statement_t stmt)
{
unsigned eidx, nevents, first = 1;
nevents = ivl_stmt_nevent(stmt);
for (eidx = 0; eidx < nevents; eidx += 1) {
unsigned idx, count, had_edge = 0;
ivl_event_t event = ivl_stmt_events(stmt, eidx);
/* Check for any edge events. */
count = ivl_event_nany(event);
if (count) had_edge = 1;
for (idx = 0; idx < count; idx += 1) {
if (first) first = 0;
else fprintf(vlog_out, " or ");
emit_nexus_as_ca(scope, ivl_event_any(event, idx), 0);
}
/* Check for positive edge events. */
count = ivl_event_npos(event);
if (count) had_edge = 1;
for (idx = 0; idx < count; idx += 1) {
if (first) first = 0;
else fprintf(vlog_out, " or ");
fprintf(vlog_out, "posedge ");
emit_nexus_as_ca(scope, ivl_event_pos(event, idx), 0);
}
/* Check for negative edge events. */
count = ivl_event_nneg(event);
if (count) had_edge = 1;
for (idx = 0; idx < count; idx += 1) {
if (first) first = 0;
else fprintf(vlog_out, " or ");
fprintf(vlog_out, "negedge ");
emit_nexus_as_ca(scope, ivl_event_neg(event, idx), 0);
}
/* We have a named event if there were no edge events. */
if (!had_edge) {
ivl_scope_t ev_scope = ivl_event_scope(event);
if (first) first = 0;
else fprintf(vlog_out, " or ");
emit_scope_module_path(scope, ev_scope);
emit_id(ivl_event_basename(event));
}
}
}
static void emit_stmt_lval_name(ivl_scope_t scope, ivl_lval_t lval,
ivl_signal_t sig)
{
ivl_expr_t array_idx = ivl_lval_idx(lval);
emit_scope_call_path(scope, ivl_signal_scope(sig));
emit_id(ivl_signal_basename(sig));
if (array_idx) {
int msb, lsb;
assert(ivl_signal_dimensions(sig));
fprintf(vlog_out, "[");
/* For an array the LSB/MSB order is not important. They are
* always accessed from base counting up. */
lsb = ivl_signal_array_base(sig);
msb = lsb + ivl_signal_array_count(sig) - 1;
emit_scaled_expr(scope, array_idx, msb, lsb);
fprintf(vlog_out, "]");
}
}
static unsigned emit_param_name_in_scope(ivl_scope_t scope, ivl_expr_t expr)
{
unsigned idx, count, lineno;
const char *file;
count = ivl_scope_params(scope);
file = ivl_expr_file(expr);
lineno = ivl_expr_lineno(expr);
for (idx = 0; idx < count; idx += 1) {
ivl_parameter_t par = ivl_scope_param(scope, idx);
if (lineno != ivl_parameter_lineno(par)) continue;
if (strcmp(file, ivl_parameter_file(par)) == 0) {
/* Check that the appropriate expression bits match the
* original parameter bits. */
ivl_expr_t pex = ivl_parameter_expr(par);
unsigned wid = ivl_expr_width(expr);
unsigned param_wid = ivl_expr_width(pex);
const char *my_bits = ivl_expr_bits(expr);
const char *param_bits = ivl_expr_bits(pex);
unsigned bit;
if (param_wid < wid) wid = param_wid;
for (bit = 0; bit < wid; bit += 1) {
if (my_bits[bit] != param_bits[bit]) {
fprintf(stderr, "%s:%u: vlog95 error: Constant "
"expression bits do not match "
"parameter bits.\n",
ivl_expr_file(expr),
ivl_expr_lineno(expr));
break;
}
}
// HERE: Does this work with an out of scope parameter reference?
// What about real parameters?
emit_id(ivl_parameter_basename(par));
return 1;
}
}
return 0;
}
void mdeath::gas(monster *z)
{
std::string explode = string_format(_("a %s explode!"), z->name().c_str());
sounds::sound(z->pos(), 24, explode);
g->m.emit_field( z->pos(), emit_id( "emit_toxic_blast" ) );
}
void mdeath::gas( monster &z )
{
std::string explode = string_format( _( "a %s explode!" ), z.name() );
sounds::sound( z.pos(), 24, sounds::sound_t::combat, explode );
g->m.emit_field( z.pos(), emit_id( "emit_toxic_blast" ) );
}
static unsigned find_signal_in_nexus(ivl_scope_t scope, ivl_nexus_t nex)
{
ivl_signal_t use_sig = 0;
unsigned is_driver = 0;
unsigned is_array = 0;
int64_t array_idx = 0;
unsigned idx, count = ivl_nexus_ptrs(nex);
for (idx = 0; idx < count; idx += 1) {
ivl_nexus_ptr_t nex_ptr = ivl_nexus_ptr(nex, idx);
ivl_signal_t sig = ivl_nexus_ptr_sig(nex_ptr);
if (! sig) continue;
if (ivl_signal_local(sig)) {
/* If the local signal is another receiver skip it. */
if ((ivl_nexus_ptr_drive1(nex_ptr) == IVL_DR_HiZ) &&
(ivl_nexus_ptr_drive0(nex_ptr) == IVL_DR_HiZ)) {
continue;
}
assert(0);
}
/* We have a signal that can be used to find the name. */
if (scope == ivl_signal_scope(sig)) {
if (use_sig) {
/* Swap a receiver for a driver. */
if (is_driver &&
(ivl_nexus_ptr_drive1(nex_ptr) == IVL_DR_HiZ) &&
(ivl_nexus_ptr_drive0(nex_ptr) == IVL_DR_HiZ)) {
use_sig = sig;
is_driver = 0;
if (ivl_signal_dimensions(sig) > 0) {
is_array = 1;
array_idx = ivl_nexus_ptr_pin(nex_ptr);
array_idx += ivl_signal_array_base(sig);
}
continue;
}
// HERE: Which one should we use? For now it's the first one found.
// I believe this needs to be solved (see the inout.v test).
fprintf(stderr, "%s:%u: vlog95 warning: Duplicate "
"name (%s",
ivl_signal_file(sig),
ivl_signal_lineno(sig),
ivl_signal_basename(sig));
if (ivl_signal_dimensions(sig) > 0) {
int64_t tmp_idx = ivl_nexus_ptr_pin(nex_ptr);
tmp_idx += ivl_signal_array_base(sig);
fprintf(stderr, "[%"PRId64"]", tmp_idx);
}
fprintf(stderr, ") found for nexus (%s",
ivl_signal_basename(use_sig));
if (is_array) fprintf(stderr, "[%"PRId64"]", array_idx);
fprintf(stderr, ")\n");
} else {
use_sig = sig;
/* This signal is a driver. */
if ((ivl_nexus_ptr_drive1(nex_ptr) != IVL_DR_HiZ) ||
(ivl_nexus_ptr_drive0(nex_ptr) != IVL_DR_HiZ)) {
is_driver = 1;
}
if (ivl_signal_dimensions(sig) > 0) {
is_array = 1;
array_idx = ivl_nexus_ptr_pin(nex_ptr);
array_idx += ivl_signal_array_base(sig);
}
}
}
}
if (use_sig) {
emit_id(ivl_signal_basename(use_sig));
if (is_array) fprintf(vlog_out, "[%"PRId64"]", array_idx);
return 1;
}
return 0;
}
void mdeath::smokeburst( monster &z )
{
std::string explode = string_format( _( "a %s explode!" ), z.name() );
sounds::sound( z.pos(), 24, sounds::sound_t::combat, explode, false, "explosion", "small" );
g->m.emit_field( z.pos(), emit_id( "emit_smoke_blast" ) );
}
void mdeath::smokeburst( monster &z )
{
std::string explode = string_format( _( "a %s explode!" ), z.name().c_str() );
sounds::sound( z.pos(), 24, explode );
g->m.emit_field( z.pos(), emit_id( "emit_smoke_blast" ) );
}
static void emit_expr_array(ivl_scope_t scope, ivl_expr_t expr, unsigned wid)
{
ivl_signal_t sig = ivl_expr_signal(expr);
emit_scope_call_path(scope, ivl_signal_scope(sig));
emit_id(ivl_signal_basename(sig));
}