/*

  Copyright (c) 1992, 1993
	Regents of the University of California
  All rights reserved.

  Use and copying of this software and preparation of derivative works
  based upon this software are permitted.  However, any distribution of
  this software or derivative works must include the above copyright
  notice.

  This software is made available AS IS, and neither the Electronics
  Research Laboratory or the Universify of California make any
  warranty about the software, its performance or its conformity to
  any specification.

  Author: Szu-Tsung Cheng, stcheng@ic.Berkeley.EDU
	  10/92
	  10/93

  $Header: /projects/development/hsv/CVSRepository/vl2mv/src/parser/vl_write_util.c,v 1.3 2009/03/09 20:25:58 fabio Exp $


*/

#include <stdio.h>
#include <math.h>
#include "util.h"
#include "st.h"
#include "array.h"
#include "list.h"
#include "set.h"
#include "graph.h"
#include "vl_types.h"
#include "vl_defs.h"
#include "vlr_int.h"
#include "vl_fg_defs.h"
#include "vl_fg_types.h"
#include "vl_create.h"
#include "vl_write.h"
#include "vl_write_util.h"
#include "vl_vardecl.h"
#include "vl_edgedetector.h"
#include "vl_traverse.h"
#include "vl_mux.h"
#include "vl_flowgraph.h"
#include "verilog.h"

extern vl_desc *mod_list;
extern int implicitClocking;
extern int compatibleChecking;
extern int set_notation;
extern int debug_mode;
extern int decomposeTable;
extern int noBus;
extern int smartEvent;
extern int vlTimedSystem;
extern int Zconnection;
extern int implicitDeclare;

extern int WarningLevel;

extern int rst_ckt, use_rst_ckt, mark_sel_var;
extern lsList ctrl_list, rst_ctrl_list;
extern st_table *sensitiveList;
extern int lhs_hi, lhs_lo;
extern int lhs_must_be_wire;
extern int Vlerrno;
extern int silent_err;
extern char *cntxt_event;

int deadlock_semantic = 0;
int arrayBoundNond=0;
int vis_nond=1;
int vis_nond_var=0;
int instantiateInputLatch = 0;

static char *nond_output();
static int isTautology ARGS((lsList syndrome_expr_list));
static void postprocess_vlr_rel ARGS((FILE *file, short type, char *carry,
				      vl_term *results, vl_term *out));
static int evaluable_expr ARGS((vl_expr *expr));
static void vl_write_bin_equal_const(FILE *file, vl_expr *val, vl_term *term, vl_term *out);

void vl_mv_to_bin(vl_term *term)
{
    if (term->flag & MVar) {
	char buf[MAXSTRLEN];
	sprintf(buf, "enforced mv->binary encoding on '%s'", term->name->name);
	Translate_Warning(buf);

	term->flag &= !MVar;
	if (term->hi < 0) {
	    term->hi = MAXBITNUM-1;
	    term->lo = 0;
	} else {
	    int range, blen;

	    for (range = term->hi - term->lo + 1, blen = -1;
		 range>0; range >>= 1)
		blen++;
	    if (blen>0)
		if ((1<<(blen-1)) < term->hi-term->lo+1)
		    blen++;
	    term->lo = 0;
	    term->hi = blen-1;
	}
    }
}



void vl_bin_to_mv(vl_term *term)
{
    int blen;

    if (!(term->flag & MVar)) {
	Translate_Warning("enforced binary->mv encoding");

	term->flag |= MVar;
	blen = term->hi-term->lo+1;
	term->lo = 1;
	term->hi = (1 << (blen));
    }
}


void vl_write_mv_comp(FILE *file, short type, vl_term *in1, vl_term *in2, vl_term *out)
{
    lsList domain;
    lsGen igen, jgen;
    lsHandle ihandle, jhandle;
    vl_enumerator *i, *j;

    if (in1->hi-in1->lo != in2->hi-in2->lo)
	Translate_Warning("comparator have MV's of different domain elts");

    fprintf(file, ".names %s %s %s\n",
	    in1->name->name, in2->name->name, out->name->name);
    if (set_notation) {
      if (in1->term_type != in2->term_type) {
	char buf[MAXSTRLEN];
	sprintf(buf, "'%s':comparing %s and %s of different domains",
		vl_currentModule->name->name,
		in1->name->name, in2->name->name);
	semantic_error(buf);
      }

      fprintf(file, "%s %d\n", HSIS_DEFAULT, type==Bneq2Expr);
      fprintf(file, "- %s%s %d\n",
	      HSIS_EQUAL, in1->name->name, type!=Bneq2Expr);

    } else {
	switch (type) {
	case Beq2Expr:

	    if (in1->term_type != in2->term_type) {
		char buf[MAXSTRLEN];
		sprintf(buf, "'%s':comparing %s and %s of different domains",
			vl_currentModule->name->name,
			in1->name->name, in2->name->name);
		semantic_error(buf);
	    }

	    domain = in1->term_type->specifier->u.enum_type->domain_list;
	    for (igen=lsStart(domain);
		 lsNext(igen,(lsGeneric*)&i,&ihandle)!=LS_NOMORE;) {
		for (jgen=lsStart(domain);
		     lsNext(jgen,(lsGeneric*)&j,&jhandle)!=LS_NOMORE;) {
		    fprintf(file, "%s %s %d\n",
			    i->name, j->name, (strcmp(i->name, j->name)==0));
		}
		lsFinish(jgen);
	    }
	    lsFinish(igen);
	    break;
	case Bneq2Expr:

	    if (in1->term_type != in2->term_type) {
		char buf[MAXSTRLEN];
		sprintf(buf, "'%s':comparing %s and %s of different domains",
			vl_currentModule->name->name,
			in1->name->name, in2->name->name);
		semantic_error(buf);
	    }

	    domain = in1->term_type->specifier->u.enum_type->domain_list;
	    for (igen=lsStart(domain);
		 lsNext(igen,(lsGeneric*)&i,&ihandle)!=LS_NOMORE;) {
		for (jgen=lsStart(domain);
		     lsNext(jgen,(lsGeneric*)&j,&jhandle)!=LS_NOMORE;) {
		    fprintf(file, "%s %s %d\n",
			    i->name, j->name, (strcmp(i->name, j->name)!=0));
		}
		lsFinish(jgen);
	    }
	    lsFinish(igen);
	    break;
	}
    }
}


void vl_write_bin_comp(FILE *file, short type, vl_term *in1, vl_term *in2, vl_term *out)
{
    vl_term *tmp, *ripple_term;
    char *ripple;

    tmp = new_term(NIL(vl_range), 0, -1);

    if (in1->lo > in1->hi) {
	tmp->lo = in2->lo;
	tmp->hi = in2->hi;
    } else if (in2->lo > in2->hi) {
	tmp->lo = in1->lo;
	tmp->hi = in1->hi;
    } else {
	tmp->lo = 0;
	tmp->hi = MIN(in1->hi-in1->lo, in2->hi-in2->lo);
    }
    write_var_decl(file, tmp);
    vl_write_vector_bop(file, BxorExpr, in1, in2, tmp);

    ripple = vlStrdup(new_termname());
    ripple_term = vl_create_term(vl_create_id_range(ripple,NIL(vl_range)),
				 tmp->lo, tmp->hi);
    if (tmp->lo <= tmp->hi) {
	ripple =
	    vl_write_vector_bop(file, UorExpr, tmp, NIL(vl_term), ripple_term);
	vl_write_bit_connect(file, ripple_term->name->name, out->name->name,
			     (type==Beq2Expr));
	vl_free_term(ripple_term);
    } else {
	vl_write_bit_connect(file, tmp->name->name, out->name->name,
			     (type==Beq2Expr));
    }
    vl_free_term(tmp);
}


static void vl_write_bin_equal_const(
  FILE *file,
  vl_expr *val,
  vl_term *term,
  vl_term *out
  )
{
    int lo, hi;
    int i, v;

    if (term->lo > term->hi) {
	lo = 0;
	hi = 0;
    } else {
	lo = term->lo;
	hi = term->hi;
    }

    /* Write table header and default value. */
    fprintf(file, ".names");
    for (i=lo; i<=hi; i++) {
	fprintf(file, " %s%s%d%s", term->name->name,
		SEP_LBITSELECT, i, SEP_RBITSELECT);
    }
    fprintf(file, " %s\n.def 0\n", out->name->name);

    for (i=lo, v=vl_eval_expr(val); i<=hi; i++, v >>= 1) {
	fprintf(file, "%d ", (v & 1));
    }
    fprintf(file, " 1\n");
}


void vl_write_mv_connect(FILE *file, vl_term *in, vl_term *out)
{
    lsList domain;
    lsGen enum_gen;
    lsHandle enum_handle;
    vl_enumerator *enum_elt;

    if (in->term_type != out->term_type) {
	char buf[MAXSTRLEN];
	sprintf(buf, "connecting %s and %s of different domains",
		out->name->name, in->name->name);
	semantic_error(buf);
    }

    fprintf(file, ".names %s %s\n", in->name->name, out->name->name);

    if (set_notation) {
	fprintf(file, "- =%s\n", in->name->name);
    } else {
	domain = in->term_type->specifier->u.enum_type->domain_list;
	for (enum_gen=lsStart(domain);
	     lsNext(enum_gen,(lsGeneric*)&enum_elt,&enum_handle)!=LS_NOMORE;) {
	    fprintf(file, "%s %s\n", enum_elt->name, enum_elt->name);
	}
	lsFinish(enum_gen);
    }
}


void vl_write_bin_connect(FILE *file, vl_term *in, vl_term *out, int inverted)
{
    int i;
    char out_buf[MAXSTRLEN], in_buf[MAXSTRLEN];

    if (out->lo > out->hi) {
	if (in->lo > in->hi) {
	    vl_write_bit_connect(file, in->name->name, out->name->name, 0);
	} else {
	    char buf[MAXSTRLEN];

	    sprintf(buf, "%s%s%d%s", in->name->name,
		    SEP_LBITSELECT, in->lo, SEP_RBITSELECT);
	    vl_write_bit_connect(file, buf, out->name->name, 0);
	}
    } else {
	if (in->lo > in->hi) {
	    int i;
	    sprintf(out_buf, "%s%s%d%s", out->name->name,
		    SEP_LBITSELECT, out->lo, SEP_RBITSELECT);
	    sprintf(in_buf, "%s", in->name->name);
	    if (set_notation && !inverted) {
		fprintf(file, ".names %s %s\n- =%s\n",
			in_buf, out_buf, in_buf);

	    } else {
		vl_write_bit_connect(file, in_buf, out_buf, inverted);
	    }

	    sprintf(in_buf, "%s", WRT_BLIF_GND(file));
	    for (i=out->lo+1; i<=out->hi; i++) {
		sprintf(out_buf, "%s%s%d%s", out->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
		if (set_notation) {
		    fprintf(file, ".names %s %s\n- =%s\n",
			    in_buf, out_buf, in_buf);
		} else {
		    vl_write_bit_connect(file, in_buf, out_buf, 0);
		}
	    }
	} else {
	    for (i=out->lo; i<=out->hi; i++) {
		sprintf(out_buf, "%s%s%d%s", out->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
		sprintf(in_buf, "%s%s%d%s", in->name->name,
			SEP_LBITSELECT, i+in->lo-out->lo,
			SEP_RBITSELECT);
		if (set_notation && !inverted) {
		    fprintf(file, ".names %s %s\n- =%s\n",
			    in_buf, out_buf, in_buf);
		} else {
		    vl_write_bit_connect(file, in_buf, out_buf,
					 inverted);
		}
	    }
	}
    }
}


void vl_write_consts(FILE *file)
{


    file = file;
}


void vl_write_const(FILE *file, vl_expr *val, vl_term *out)
{
    int ismvar=0;
    int i, v;
    int lo, hi;
    int find_elt=0;
    char buf[MAXSTRLEN];
    lsList domain;
    lsGen enum_gen;
    lsHandle enum_handle;
    vl_enumerator *enum_elt;

    ismvar = out->flag & MVar;

    if (ismvar) {
	assert (val);

	fprintf(file, ".names %s\n", out->name->name);
	switch(val->type) {
	case BitExpr:
	    Translate_Warning("Using binary constant as value of mv variable");
	case IntExpr:
	    domain = out->term_type->specifier->u.enum_type->domain_list;
	    for (enum_gen=lsStart(domain);
		 lsNext(enum_gen,
			(lsGeneric*)&enum_elt,&enum_handle)!=LS_NOMORE;) {
		find_elt=1;
		if (enum_elt->val==val->u.intval) break;
		find_elt=0;
	    }
	    lsFinish(enum_gen);

	    if (find_elt)
		fprintf(file, "%s\n", enum_elt->name);
	    else {
		char buf[MAXSTRLEN];
		sprintf(buf, "trying to assign to '%s' out of its domain",
			out->name->name);
		semantic_error(buf);
	    }
	    break;
	case RealExpr:
	    semantic_error("assinging real value to enumeration typed var");
	    break;
	case IDExpr:
	    if (st_lookup(out->term_type->specifier->u.enum_type->domain_st,
			  val->u.name->name, (char**)&enum_elt)) {
		fprintf(file, "%s\n", enum_elt->name);
	    } else {
		char buf[MAXSTRLEN];

		sprintf(buf, "%s should be a constant/symbolic name",
			val->u.name->name);
		internal_error(buf);
	    }
	    break;
	}
    } else {

	if (out->name->mpg_master_exp && out->hi==-1 && out->lo==0)

	    get_hilo(out->name, &hi, &lo);
	else {

	    hi = out->hi;
	    lo = out->lo;
	}
	if (val) {
	    if (lo <= hi) {
		int v0;
		v0 = val->u.bexpr.part0;
		for (i=lo, v=vl_eval_expr(val); i<=hi;
		     i++, v >>= 1, v0 >>= 1) {
		    sprintf(buf, "%s%s%d%s", out->name->name,
			    SEP_LBITSELECT, i, SEP_RBITSELECT);
		    fprintf(file, ".names %s\n", buf);
		    if ((v & 1) && (v0 & 1))
			fprintf(file, "-\n");
		    else
			fprintf(file, "%d\n", (v & 1));
		}
	    } else {
		fprintf(file, ".names %s\n", out->name->name);
		fprintf(file, "%d\n", vl_eval_expr(val) & 1);
	    }
	} else {
	    if (lo <= hi) {
		for (i=lo; i<=hi; i++) {
		    sprintf(buf, "%s%s%d%s", out->name->name,
			    SEP_LBITSELECT, i, SEP_RBITSELECT);
		    fprintf(file, ".names %s\n", buf);
		    fprintf(file, "0\n1\n");
		}
	    } else {
		fprintf(file, ".names %s\n", out->name->name);
		fprintf(file, "0\n1\n");
	    }
	}
    }
}



void write_int_connect(FILE *file, int v, vl_term *out)
{
    int lo, hi, i;
    char buf[MAXSTRLEN];
    lsList args;

    lo = out->lo; hi = out->hi;
    if (hi < lo) {
	fprintf(file, ".names %s\n", out->name->name);
	fprintf(file, "%d\n", (v&1));
    } else {
	args = lsCreate();
	sprintf(buf, "%d", out->hi-out->lo+1);
	lsNewEnd(args, (lsGeneric)vlStrdup(buf), 0);
	sprintf(buf, "%d", v);
	lsNewEnd(args, (lsGeneric)vlStrdup(buf), 0);

	for (i=lo; i<=hi; i++, v >>= 1) {
	    sprintf(buf, "%s%s%d%s", out->name->name,
		    SEP_LBITSELECT, i, SEP_RBITSELECT);
	    fprintf(file, ".names %s\n", buf);
	    fprintf(file, "%d\n", (v & 1));
	}

	lsDestroy(args, vl_chk_free);
    }
}



vl_term *write_local_control(FILE *file, vl_term *ctrl, lsList sub_ctrls, int inverted)
{
    int i, j;
    vl_term *retval;
    lsGen gen;
    lsHandle handle;
    vl_term *sub_ctrl;
    int unconditional_assign = 0;




    if (!sub_ctrls)
	unconditional_assign = 1;
    else if (lsLength(sub_ctrls)==0)
	unconditional_assign = 1;

    if (unconditional_assign) {
	retval = new_term(NIL(vl_range), 0, -1);
	vl_write_bit_connect(file, ctrl->name->name, retval->name->name,
			     inverted);
	return retval;
    }

    retval = new_term(NIL(vl_range), 0, -1);

    fprintf(file, ".names %s ", ctrl->name->name);
    gen = lsStart(sub_ctrls);
    if (lsNext(gen, (lsGeneric*)&sub_ctrl, &handle) == LS_OK) {
	fprintf(file, "%s ", ((vl_term*)(((int)sub_ctrl)&~1))->name->name);
	while (lsNext(gen, (lsGeneric*)&sub_ctrl, &handle) != LS_NOMORE) {
	    fprintf(file, "%s ", ((vl_term*)(((int)sub_ctrl)&~1))->name->name);
	}
    }
    lsFinish(gen);
    fprintf(file, "%s\n", retval->name->name);

    for (i=0; i<lsLength(sub_ctrls); i++) {
	fprintf(file, "%c ", (inverted)?'0':'1');
	for (j=0; j<lsLength(sub_ctrls); j++) {
	    fprintf(file, "%c ", (i==j)?'1':'-');
	}
	fprintf(file, "1\n");
    }

    fprintf(file, "%c ", (inverted)?'0':'1');
    gen = lsStart(sub_ctrls);
    if (lsNext(gen, (lsGeneric*)&sub_ctrl, &handle) == LS_OK) {
	fprintf(file, "%c ", ((int)sub_ctrl&1)?'1':'0');
	while (lsNext(gen, (lsGeneric*)&sub_ctrl, &handle) != LS_NOMORE) {
	    fprintf(file, "%c ", ((int)sub_ctrl&1)?'1':'0');
	}
    }
    lsFinish(gen);
    fprintf(file, "0\n");

    fprintf(file, "%c ", (inverted)?'1':'0');
    for (i=0; i<lsLength(sub_ctrls); i++) {
	fprintf(file, "%c ", '-');
    }
    fprintf(file, "0\n");

    return retval;
}



void write_switch(FILE *file, vl_id_range *id_sym,
		  vl_term *sel, vl_expr *sel_expr,
		  vl_term *orig, vl_term *new, vl_term *out_term)
{
    int lo, hi;
    int bit_hi, bit_lo;
    int idx;
    vl_expr *hi_expr;
    char new_buf[MAXSTRLEN], orig_buf[MAXSTRLEN], out_buf[MAXSTRLEN];

    get_hilo(id_sym, &bit_hi, &bit_lo);

    lo = vl_eval_expr(out_term->name->range->left);
    if (out_term->name->range->right)
	hi = vl_eval_expr(out_term->name->range->right);
    else
	hi = lo;

    if (!sel) {
	int const_hi, const_lo;

	assert(ISVLCONST(sel_expr->type));

	const_hi = min_bit_width(hi)-1;
	const_lo = 0;
	sel = new_term(NIL(vl_range), const_lo, const_hi);
	write_var_decl(file, sel);
	vl_write_const(file, sel_expr, sel);
    }

    hi_expr = vl_create_expr(IntExpr, hi, (double)0.0,
			     NIL(void), NIL(void), NIL(void));
    for (idx=lo; idx<=hi; idx++) {
	vl_term *ctrl;
	vl_term *new_elt, *orig_elt, *out_elt;
	vl_expr *const_expr;
	vl_term *const_trm;

	const_expr = vl_create_expr(IntExpr, idx, (double)0.0,
				    NIL(void), NIL(void), NIL(void));
	const_trm = new_term(NIL(vl_range), 0, data_width(hi_expr)-1);
#if 0
	write_var_decl(file, const_trm);
	vl_write_const(file, const_expr, const_trm);
	vl_chk_free((char*)const_expr);

	ctrl = new_term(NIL(vl_range), 0, -1);
	vl_write_bin_comp(file, Beq2Expr, const_trm, sel, ctrl);
#else
	ctrl = new_term(NIL(vl_range), 0, -1);
	vl_write_bin_equal_const(file, const_expr, sel, ctrl);
	vl_chk_free((char*)const_expr);
#endif
	sprintf(new_buf, "%s%s%d%s",
		new->name->name, SEP_LARRAY, idx, SEP_RARRAY);
	if (rst_ckt && !strstr(orig->name->name, SEP_GATEPIN)) {
	    int i;
	    sprintf(orig_buf, "%s", new_termname());
	    if (bit_lo == 0 && bit_hi == -1) {
		if (out_term->term_type) {
		    if (vis_nond) {
			char *old_name;
			vl_range *old_range;
			vl_enumerator *enum_elt;
			old_name = out_term->name->name;
			old_range = out_term->name->range;
			out_term->name->name = orig_buf;
			out_term->name->range = NIL(vl_range);
			write_var_decl(file, out_term);
			out_term->name->name = old_name;
			out_term->name->range = old_range;
			lsFirstItem(out_term->term_type->specifier->u.enum_type->domain_list, (lsGeneric*)&enum_elt, 0);
			fprintf(file, ".names %s\n%s\n", orig_buf,
				enum_elt->name);
		    } else {
			fprintf(file, ".names %s\n-\n", orig_buf);
		    }
		} else {
		    if (vis_nond) {
			fprintf(file, ".names %s\n0\n", orig_buf);
		    } else {
			fprintf(file, ".names %s\n-\n", orig_buf);
		    }
		}
	    } else {
		for (i=bit_lo; i<=bit_hi; i++)
		    if (vis_nond) {
			fprintf(file, ".names %s%s%d%s\n0\n", orig_buf,
				SEP_LBITSELECT, i, SEP_RBITSELECT);
		    } else {
			fprintf(file, ".names %s%s%d%s\n-\n", orig_buf,
				SEP_LBITSELECT, i, SEP_RBITSELECT);
		    }
	    }
	} else {
	    sprintf(orig_buf, "%s%s%d%s",
		    orig->name->name, SEP_LARRAY, idx, SEP_RARRAY);
	}
	sprintf(out_buf, "%s%s%d%s",
		out_term->name->name, SEP_LARRAY, idx, SEP_RARRAY);
	new_elt = new;
	orig_elt = create_rename_term(orig->name, orig_buf, bit_lo, bit_hi);
	orig_elt->name->range = NIL(vl_range);
	orig_elt->flag = orig->flag;
	orig_elt->term_type = orig->term_type;
	out_elt = create_rename_term(out_term->name, out_buf, bit_lo, bit_hi);
	out_elt->name->range = NIL(vl_range);
	instantiate_mux(file, new_elt, orig_elt, ctrl, out_elt);
    }
    vl_chk_free((char*)hi_expr);
}


char *new_termname()
{
    static char sbuf[MAXSTRLEN];
    static unsigned int TermCount=0;

    sprintf(sbuf, "%s%x", NODE, TermCount++);
    return sbuf;
}

char *new_instname()
{
    static char sbuf[MAXSTRLEN];
    static unsigned int InstCount=0;

    sprintf(sbuf, "%s%x%s", NODE, InstCount++, NODE);
    return sbuf;
}


vl_range *get_decl_range(void *decl)
{
    if (!decl) return NIL(vl_range);
    switch (((typestructPtr)(decl))->type) {
    case InputDecl:
    case OutputDecl:
    case InoutDecl:
    case RegDecl:
	return ((vl_rangedeclPtr)(decl))->range;
    case WireDecl:
    case SWireDecl:
    case TriDecl:
    case Tri0Decl:
    case Tri1Decl:
    case TriandDecl:
    case TriorDecl:
    case WandDecl:
    case WorDecl:
	return ((vl_netdeclPtr)(decl))->range;
    default:
	return NIL(vl_range);
    }
}

vl_expr *get_decl_range_left(void *decl)
{
    switch (((typestructPtr)(decl))->type) {
    case InputDecl:
    case OutputDecl:
    case InoutDecl:
    case RegDecl:
	if (!((vl_rangedeclPtr)(decl))->range) return NIL(vl_expr);
	return ((vl_rangedeclPtr)(decl))->range->left;
    case WireDecl:
    case SWireDecl:
    case TriDecl:
    case Tri0Decl:
    case Tri1Decl:
    case TriandDecl:
    case TriorDecl:
    case WandDecl:
    case WorDecl:
	if (!((vl_netdeclPtr)(decl))->range) return NIL(vl_expr);
	return ((vl_netdeclPtr)(decl))->range->left;
    default:
	return NIL(vl_expr);
    }
}

vl_expr *get_decl_range_right(void *decl)
{
    switch (((typestructPtr)(decl))->type) {
    case InputDecl:
    case OutputDecl:
    case InoutDecl:
    case RegDecl:
	if (!((vl_rangedeclPtr)(decl))->range) return NIL(vl_expr);
	return ((vl_rangedeclPtr)(decl))->range->right;
    case WireDecl:
    case SWireDecl:
    case TriDecl:
    case Tri0Decl:
    case Tri1Decl:
    case TriandDecl:
    case TriorDecl:
    case WandDecl:
    case WorDecl:
	if (!((vl_netdeclPtr)(decl))->range) return NIL(vl_expr);
	return ((vl_netdeclPtr)(decl))->range->right;
    default:
	return NIL(vl_expr);
    }
}

void *
chng_decl_range(void *decl, vl_range *new_range)
{
    void *retval = NIL(void);
    if (!decl) return decl;

    switch (((typestructPtr)(decl))->type) {
    case InputDecl:
    case OutputDecl:
    case InoutDecl:
    case RegDecl:
	retval = (void*)chk_malloc(sizeof(vl_rangedecl));
	((vl_rangedeclPtr)(retval))->type = ((vl_rangedeclPtr)decl)->type;
	((vl_rangedeclPtr)(retval))->flags = ((vl_rangedeclPtr)decl)->flags;
	((vl_rangedeclPtr)(retval))->handle = ((vl_rangedeclPtr)decl)->handle;
	((vl_rangedeclPtr)(retval))->ids = lsCreate();
	((vl_rangedeclPtr)(retval))->range = new_range;
	break;
    case WireDecl:
    case SWireDecl:
    case TriDecl:
    case Tri0Decl:
    case Tri1Decl:
    case TriandDecl:
    case TriorDecl:
    case WandDecl:
    case WorDecl:
	retval = (void*)chk_malloc(sizeof(vl_netdecl));
	((vl_netdeclPtr)(retval))->type = ((vl_netdeclPtr)decl)->type;
	((vl_netdeclPtr)(retval))->flags = ((vl_netdeclPtr)decl)->flags;
	((vl_netdeclPtr)(retval))->strength = ((vl_netdeclPtr)decl)->strength;
	((vl_netdeclPtr)(retval))->delay = ((vl_netdeclPtr)decl)->delay;
	((vl_netdeclPtr)(retval))->handle = ((vl_netdeclPtr)decl)->handle;
	((vl_netdeclPtr)(retval))->ids = lsCreate();
	((vl_netdeclPtr)(retval))->range = new_range;
	break;
    default:
	break;
    }
    return retval;
}

short get_decl_flags(void *decl)
{
    if (!decl) return 0;

    switch (((typestructPtr)(decl))->type) {
    case InputDecl:
    case OutputDecl:
    case InoutDecl:
    case RegDecl:
	return ((vl_rangedeclPtr)(decl))->flags;
    case WireDecl:
    case SWireDecl:
    case TriDecl:
    case Tri0Decl:
    case Tri1Decl:
    case TriandDecl:
    case TriorDecl:
    case WandDecl:
    case WorDecl:
	return ((vl_netdeclPtr)(decl))->flags;
    default:
	return 0;
    }
}

void get_type(vl_id_range *id, vl_type **var_type)
{

    id = id;
    var_type = var_type;
}


void get_hilo(vl_id_range *id, int *hi, int *lo)
{
    vl_expr *left, *right;
    int leftval, rightval;

    if (get_decl_range(id->mpg_master_exp)) {
	left = get_decl_range_left(id->mpg_master_exp);
	right = get_decl_range_right(id->mpg_master_exp);
	leftval = vl_eval_expr(left);
	rightval = vl_eval_expr(right);
	if (leftval > rightval) {
	    int temp;

	    temp=leftval; leftval = rightval; rightval = temp;
	}
	*lo = leftval;
	*hi = rightval;
    } else {
	*lo = 0;
	*hi = -1;
    }
}



void insert_control_list(var_info *cur_var, vl_term *sel)
{
    vl_id_range *id_sym;

    if (!sel) return;
    st_lookup(vl_currentModule->sig_st, cur_var->id->name, (char**)&id_sym);
    lsNewEnd(cur_var->cond_list, (lsGeneric)sel, LS_NH);
}


void print_control_var_pair(FILE *file, char *ctrl, char *var)
{
    fprintf(file, "%s %s ", ctrl, var);
}



vl_term *write_multi_in_or(FILE *file, lsList in_list)
{
    lsGen gen;
    lsHandle handle;
    vl_term *term_out;
    vl_term *in_term, *true_in_term;
    int i, j;

    term_out = new_term(NIL(vl_range), 0, -1);

    fprintf(file, ".names ");
    gen = lsStart(in_list);
    if (lsNext(gen, (lsGeneric*)&in_term, &handle) == LS_OK) {
	true_in_term = (vl_term*)((int)in_term & (~1));
	fprintf(file, "%s ", true_in_term->name->name);
	while (lsNext(gen, (lsGeneric*)&in_term, &handle) != LS_NOMORE) {
	    true_in_term = (vl_term*)((int)in_term & (~1));
	    fprintf(file, "%s ", true_in_term->name->name);
	}
    }
    fprintf(file, "%s\n", term_out->name->name);
    lsFinish(gen);

    if (set_notation) {
	fprintf(file, "%s 1\n", HSIS_DEFAULT);
    } else {
	gen = lsStart(in_list);
	for (i=0; i<lsLength(in_list); i++) {
	    lsNext(gen, (lsGeneric*)&in_term, &handle);
	    for (j=0; j<lsLength(in_list); j++) {
		fprintf(file, "%c ", (i==j)?(((int)in_term&1)?'0':'1'):'-');
	    }
	    fprintf(file, "1\n");
	}
	lsFinish(gen);
    }

    gen = lsStart(in_list);
    if (lsNext(gen, (lsGeneric*)&in_term, &handle) == LS_OK) {
	fprintf(file, "%c ", ((int)in_term&1)?'1':'0');
	while (lsNext(gen, (lsGeneric*)&in_term, &handle) != LS_NOMORE) {
	    fprintf(file, "%c ", ((int)in_term&1)?'1':'0');
	}
    }
    lsFinish(gen);
    fprintf(file, "0\n");

    return term_out;
}



vl_term *array_or(FILE *file, array_t *in_array)
{
    vl_term *term_out;
    vl_term *in_term, *true_in_term;
    int i, j;
    int ithItem;

    term_out = new_term(NIL(vl_range), 0, -1);

    fprintf(file, ".names ");
    ithItem = 0;
    for (i=0; i<array_n(in_array); i++) {
	true_in_term = array_fetch(vl_term*, in_array, i);
	if (true_in_term) {
	    fprintf(file, "%s ", true_in_term->name->name);
	}

    }
    fprintf(file, "%s\n", term_out->name->name);

    if (set_notation) {
	fprintf(file, "%s 1\n", HSIS_DEFAULT);
    } else {
	for (i=0; i<array_n(in_array); i++) {
	    in_term = array_fetch(vl_term*, in_array, i);
	    if (!in_term) continue;
	    for (j=0; j<array_n(in_array); j++) {
		if (array_fetch(vl_term*, in_array, j))
		    fprintf(file, "%c ", (i==j)?'1':'-');
	    }
	    fprintf(file, "1\n");
	}
    }

    for (i=0; i<array_n(in_array); i++)
	if (array_fetch(vl_term*, in_array, i))
	    fprintf(file, "0 ");
    fprintf(file, "0\n");

    return term_out;
}


vl_term *syndrome_to_control(FILE *file, char *key, st_table *sig_st)
{
    vl_term *retval=NIL(vl_term);
    vl_id_range *id_sym;
    syndrome_expr *se;
    vl_term *ctrl_term;
    int ith_var = 0;
    char *syndrome;
    char *dc;
    lsList comp;
    lsGen gen;
    lsHandle handle;
    var_info *cur_var;
    int fg_id = -1;
    char lc_name[MAXSTRLEN];
    int need_leading_and = 1;
    int ithItem;

    if (!st_lookup(sig_st, key, (char**)&cur_var)) return true_term(file);
    id_sym = cur_var->id;


    if (!(dc = check_dc((!rst_ckt)?id_sym->syndrome_expr_list:
			id_sym->rst_syndrome_expr_list)))
	return NIL(vl_term);;


    retval = new_term(NIL(vl_range), 0, -1);
    if (!vlTimedSystem)
	if (isTautology((!rst_ckt)?id_sym->syndrome_expr_list:
				   id_sym->rst_syndrome_expr_list))
	    retval->flag |= TautologyTrue;
    if (vlTimedSystem && !rst_ckt) {
	for (gen=lsStart((!rst_ckt)?
			 id_sym->syndrome_expr_list:
			 id_sym->rst_syndrome_expr_list);
	     lsNext(gen,(lsGeneric*)&se,&handle)!=LS_NOMORE; ) {
	    st_table *dummy;
	    if (st_lookup(vl_description->fg_vars_st, (char*)se->fg_id,
			  (char**)&dummy))
		if (dummy == sig_st) {
		    fg_id = se->fg_id; break;
		}
	}
	lsFinish(gen);
	sprintf(lc_name, "%s%06x", FG_LC_PS, fg_id);
	if (fg_id != -1) {
	    fprintf(file, ".names %s ", lc_name);
	} else {
	    fprintf(file, ".names %s\n0\n", retval->name->name);
	    retval->flag |= ConflictFalse;
	    return retval;
	}
    } else {
	fprintf(file, ".names ");
    }
    ithItem = 0;
    for (gen=lsStart((!rst_ckt)?ctrl_list:rst_ctrl_list), ith_var=0;
	 lsNext(gen,(lsGeneric*)&ctrl_term,&handle)!=LS_NOMORE; ith_var++) {
	if (!dc[ith_var]) {
	    fprintf(file, "%s ", ctrl_term->name->name);
	}
    }
    lsFinish(gen);

    fprintf(file, "%s\n", retval->name->name);

    if (set_notation)
	fprintf(file, "%s 0\n", HSIS_DEFAULT);

    for (gen=lsStart((!rst_ckt)?
		     id_sym->syndrome_expr_list:
		     id_sym->rst_syndrome_expr_list);
	 lsNext(gen,(lsGeneric*)&se,&handle)!=LS_NOMORE; ) {
	st_table *dummy;
	int printed;

	printed = 0;
	if (st_lookup(vl_description->fg_vars_st, (char*)se->fg_id,
		      (char**)&dummy))
	    if (dummy == sig_st) {
		if (vlTimedSystem && !rst_ckt)
		    fg_put_loc_context(file, se->pre_cond, lc_name);
		fprintf(file, " ");
		printed = put_entry(file, se->syndrome, dc, need_leading_and);
		if (!need_leading_and && !printed)
		    fprintf(file, "%d ", 1);
		fprintf(file, "1\n");
	    }
    }
    lsFinish(gen);

    if (!set_notation) {
	comp=put_guard_zero(file, (!rst_ckt)?
			    id_sym->syndrome_expr_list:
			    id_sym->rst_syndrome_expr_list);
	for (gen=lsStart(comp); lsNext(gen,&syndrome,&handle)!=LS_NOMORE; ) {
	    put_entry(file, syndrome, dc, 1);
	    fprintf(file, "0\n");
	}
	lsFinish(gen);
    }

    vl_chk_free(dc);

    return retval;
}


lsList put_guard_zero(FILE *file, lsList se_list)
{
    lsList retval=(lsList)0;

    return retval;
}


lsList get_transition(FILE *file)
{
    lsList retval;
    char buf[MAXSTRLEN], *cp;
    char syndrome[MAXSTRLEN];
    int n_entries, i;

    retval = lsCreate();
    while (fgets(buf, MAXSTRLEN-1, file)) {
	if ((cp = strstr(buf, ".p")) != NIL(char)) {
	    cp += strlen(".p");
	    n_entries = atoi(cp);
	    for (i=0; i<n_entries && fgets(buf, MAXSTRLEN-1, file); i++) {
		sscanf(buf, "%s", syndrome);
		lsNewEnd(retval, vlStrdup(syndrome), 0);
	    }
	    break;
	}
    }
    return retval;
}


int put_entry(FILE *file, char *str, char *dc, int need_leading_and)
{
    unsigned int i;
    lsGen gen;
    lsHandle handle;
    vl_term *ctrl_term;
    int print_something=0;

    for (i=0, gen=lsStart((!rst_ckt)?ctrl_list:rst_ctrl_list);
	 i<strlen(str) && lsNext(gen,(lsGeneric*)&ctrl_term,&handle)!=LS_NOMORE;
	 i++) {
	if (!dc) {
	    fprintf(file, "%c ", str[i]);
	} else if (!dc[i]) {
	    fprintf(file, "%c ", str[i]);
	}
    }

    return print_something;
}


int put_blif_header(FILE *file, lsList se_list)
{
    int terminal_count=0;
    int retval;
    unsigned int i;
    syndrome_expr *se;

    fprintf(file, ".model scratch\n");
    fprintf(file, ".outputs n%d\n", retval = terminal_count++);
    if (lsLength(se_list)) {
	fprintf(file, ".inputs");
	lsFirstItem(se_list, (lsGeneric*)&se, 0);
	for (i=0; i<strlen(se->syndrome); i++) {
	    fprintf(file, " n%d", terminal_count++);
	}
	fprintf(file, "\n");
    }
    return retval;
}


int put_blif_gate_header(FILE *file, lsList se_list)
{
    int terminal_count=0;
    int retval;
    unsigned int i;
    syndrome_expr *se;

    fprintf(file, ".names");
    if (lsLength(se_list)) {
	lsFirstItem(se_list, (lsGeneric*)&se, 0);
	for (i=0; i<strlen(se->syndrome); i++) {
	    fprintf(file, " n%d", ++terminal_count);
	}
    }
    fprintf(file, " n%d\n", retval = ++terminal_count);

    return retval;
}

void put_blif_tail(FILE *file)
{
    fprintf(file, ".end\n\n");
}


vl_term *write_array_access(FILE *file, vl_id_range *id_sym, vl_term *idx_term, vl_expr *idx_expr)
{
    int lo, hi, idx;
    int bit_lo, bit_hi, bit;
    int i, j;
    unsigned int k;
    vl_term *retval;
    char buf[MAXSTRLEN];

    lo = vl_eval_expr(id_sym->range->left);
    if (id_sym->range->right)
	hi = vl_eval_expr(id_sym->range->right);
    else
	hi = lo;


    if (!idx_term) {
	int const_hi, const_lo;

	assert(ISVLCONST(idx_expr->type));

	const_hi = min_bit_width(hi)-1;
	const_lo = 0;
	idx_term = new_term(NIL(vl_range), const_lo, const_hi);
	write_var_decl(file, idx_term);
	vl_write_const(file, idx_expr, idx_term);
    }


    get_hilo(id_sym, &bit_hi, &bit_lo);
    retval = new_term(NIL(vl_range), bit_lo, bit_hi);
    retval->flag = id_sym->flags;
    retval->term_type = id_sym->id_type;
    write_var_decl(file, retval);

    if (bit_lo > bit_hi) {
	if (id_sym->flags & MVar) {

	    lsList domain;

	    domain = id_sym->id_type->specifier->u.enum_type->domain_list;

	    fprintf(file, ".names ");
	    for (i=idx_term->hi; i>=idx_term->lo; i--) {
		fprintf(file, "%s%s%d%s ", idx_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
	    }
	    for (idx=lo; idx<=hi; idx++) {
		fprintf(file, "%s%s%d%s ", id_sym->name,
			SEP_LARRAY, idx, SEP_RARRAY);
	    }
	    fprintf(file, "%s\n", retval->name->name);


	    if (set_notation) {
		for (i=0; i<(1<<(idx_term->hi-idx_term->lo+1)); i++) {
		    strcpy(buf,
			   num_to_binstr(i,(idx_term->hi-idx_term->lo+1)));
		    for (k=0; k<strlen(buf); k++)
			fprintf(file, "%c ", buf[k]);
		    for (idx=lo; idx<=hi; idx++) fprintf(file, "- ");
		    if (i <= hi && i >= lo)
			fprintf(file, "%s%s%s%d%s\n", HSIS_EQUAL,
				id_sym->name, SEP_LARRAY, i, SEP_RARRAY);
		    else {
			if (arrayBoundNond) {
			    fprintf(file, "-\n");
			} else {
			    vl_enumerator *enum_elt;
			    lsFirstItem(id_sym->id_type->specifier
					    ->u.enum_type->domain_list,
					(lsGeneric*)&enum_elt, 0);
			    fprintf(file, "%s\n", enum_elt->name);
			}
		    }
		}
	    } else {
		lsList domain;
		lsGen enum_gen;
		lsHandle enum_handle;
		vl_enumerator *enum_elt;
		domain = id_sym->id_type->specifier->u.enum_type->domain_list;
		for (i=0; i<(1<<(idx_term->hi-idx_term->lo+1)); i++) {
		    for (enum_gen=lsStart(domain);
			 lsNext(enum_gen,(lsGeneric*)&enum_elt,&enum_handle)!=
			 LS_NOMORE; ) {
			strcpy(buf,
			       num_to_binstr(i,(idx_term->hi-idx_term->lo+1)));
			for (k=0; k<strlen(buf); k++)
			    fprintf(file, "%c ", buf[k]);
			for (idx=lo; idx<=hi; idx++)
			    fprintf(file, "%s ",
				    (idx==i)?enum_elt->name:"-");
			fprintf(file, "%s\n",
				(i<=hi && i>=lo)?enum_elt->name:
				    (arrayBoundNond)?"-":enum_elt->name);
		    }
		    lsFinish(enum_gen);
		}
	    }
	} else {

	    fprintf(file, ".names ");
	    for (i=idx_term->hi; i>=idx_term->lo; i--) {
		fprintf(file, "%s%s%d%s ", idx_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
	    }
	    for (idx=lo; idx<=hi; idx++) {
		fprintf(file, "%s%s%d%s ", id_sym->name,
			SEP_LARRAY, idx, SEP_RARRAY);
	    }
	    fprintf(file, "%s\n", retval->name->name);
	    fprintf(file, ".def 0\n");

	    for (i=0; i<(1<<(idx_term->hi-idx_term->lo+1)); i++) {
		for (j=0; j<=1; j++) {
		    if (j==0 && i<=hi && i>=lo) continue;
		    if ((i>hi || i<lo) && !arrayBoundNond) continue;
		    strcpy(buf,
			   num_to_binstr(i, (idx_term->hi-idx_term->lo+1)));
		    for (k=0; k<strlen(buf); k++)
			fprintf(file, "%c ", buf[k]);
		    for (idx=lo; idx<=hi; idx++) {
			fprintf(file, "%c ", (idx==i)?((j==0)?'0':'1'):'-');
		    }
		    fprintf(file, "%c\n", (i<=hi && i>=lo)?'1':'-');
		}
	    }
	}
    } else {
	for (bit=bit_lo; bit<=bit_hi; bit++) {

	    fprintf(file, ".names ");
	    for (i=idx_term->hi; i>=idx_term->lo; i--) {
		fprintf(file, "%s%s%d%s ", idx_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
	    }
	    for (idx=lo; idx<=hi; idx++) {
		fprintf(file, "%s%s%d%s%s%d%s ", id_sym->name,
			SEP_LARRAY, idx, SEP_RARRAY,
			SEP_LBITSELECT, bit, SEP_RBITSELECT);
	    }
	    fprintf(file, "%s%s%d%s\n", retval->name->name,
		    SEP_LBITSELECT,bit,SEP_RBITSELECT);
	    fprintf(file, ".def 0\n");

	    for (i=0; i<(1<<(idx_term->hi-idx_term->lo+1)); i++) {
		for (j=0; j<=1; j++) {
		    if (j==0 && i<=hi && i>=lo) continue;
		    if ((i>hi || i<lo) && !arrayBoundNond) continue;
		    strcpy(buf,
			   num_to_binstr(i,(idx_term->hi-idx_term->lo+1)));
		    for (k=0; k<strlen(buf); k++)
			fprintf(file, "%c ", buf[k]);
		    for (idx=lo; idx<=hi; idx++) {
			fprintf(file, "%c ", (idx==i)?((j==0)?'0':'1'):'-');
		    }
		    fprintf(file, "%c\n", (i<=hi && i>=lo)? '1':'-');
		}
	    }
	}
    }

    return retval;
}


char *sel_var(char *name)
{
    return name;
}

int isMVar(short unsigned flag)
{
    return (flag & MVar);
}

int isOutPort(short unsigned flag)
{
    return (flag & OutPort);
}


void check_assign(vl_bassign_stmt *assign, int procedural)
{
    vl_id_range *lhs_id;
    char buf[MAXSTRLEN];

    st_lookup(vl_currentModule->sig_st,
	      assign->lhs->name->name, (char**)&lhs_id);

    if (procedural) {
	if (assign->type != NbassignStmt &&
	    assign->type != DelayNbassignStmt &&
	    assign->type != EventNbassignStmt &&
	    !(lhs_id->flags & RegVar)) {
	    yylineno = assign->lineno;
	    sprintf(buf,
	      "error: wire '%s' is used as lhs of = in procedural statement\n",
		    lhs_id->name);
	    compile_error(buf);
	}
	if (lhs_must_be_wire && (lhs_id->flags & RegVar)) {

	}
	if (compatibleChecking && !(lhs_id->flags & RegVar)) {
	    yylineno = assign->lineno;
	    sprintf(buf,
	      "error: wire '%s' is used as lhs of <= in procedural statement\n",
		    lhs_id->name);
	    compile_error(buf);
	}
    } else {
	if (lhs_id->flags & RegVar) {
	    yylineno = assign->lineno;
	    sprintf(buf,
	      "error: reg '%s' is used as lhs of continus assignment\n",
		    lhs_id->name);
	    compile_error(buf);
	}
    }
}


void instantiate_reset_mux(FILE *file, vl_id_range *id_sym, int lo, int hi,
  var_info *var, var_info *lvar)
{
    extern vl_term *Initial_Signal;
    vl_term *term_out;
    char buf[MAXSTRLEN];
    vl_term *init_term;

    sprintf(buf, "%s%s", id_sym->name, new_termname());
    term_out = create_rename_term(id_sym, buf, lo, hi);
    term_out->flag =
	get_decl_flags(var->id->mpg_master_exp);
    write_var_decl(file,term_out);
    lsFirstItem(id_sym->initial, (lsGeneric*)&init_term, 0);
    instantiate_mux(file, init_term,
		    lvar->current_terminal,
		    Initial_Signal, term_out);
    lvar->current_terminal = term_out;
}


void instantiate_input_latch(FILE *file, vl_id_range *id_sym)
{
    char buf[MAXSTRLEN];

    sprintf(buf, "%s%s%s", id_sym->name, SEP_DIR, PIN_IN);
    if (id_sym->flags & InPort && id_sym->flags & RegVar) {
	if (!instantiateInputLatch) return;
	if (id_sym->flags & MVar) {
	    fprintf(file, ".latch %s %s\n", id_sym->name, buf);
	} else {
	    int i, lo, hi;

	    get_hilo(id_sym, &hi, &lo);
	    if (lo > hi) {
		fprintf(file, ".latch %s %s\n", id_sym->name, buf);
	    } else {
		for (i=lo; i<=hi; i++) {
		    fprintf(file, ".latch %s%s%d%s %s%s%d%s\n",
			    id_sym->name,
			    SEP_LBITSELECT, i, SEP_RBITSELECT,
			    buf, SEP_LBITSELECT, i, SEP_RBITSELECT);
		}
	    }
	}
    }
}


void instantiate_hidden_latch(FILE *file, vl_id_range *id_sym)
{
    char buf[MAXSTRLEN];
    lsList domain;
    lsGen enum_gen;
    lsHandle enum_handle;
    vl_enumerator *enum_elt;


    if (!id_sym->mpg_master_exp) return;
    if (strstr(id_sym->name, SEP_LATCH)) return;

    sprintf(buf, "%s%s", id_sym->name, PIN_HIDDEN);
    if (id_sym->flags & HiddenLatch) {
	if (id_sym->flags & MVar) {
	    domain = id_sym->id_type->specifier->u.enum_type->domain_list;
	    fprintf(file, ".mv %s %d ", buf, lsLength(domain));
	    for (enum_gen = lsStart(domain);
		 lsNext(enum_gen, (lsGeneric*)&enum_elt, &enum_handle) !=
		     LS_NOMORE;) {
		fprintf(file, "%s ", enum_elt->name);
	    }
	    lsFinish(enum_gen);
	    fprintf(file, "\n");
	    fprintf(file, ".latch %s %s\n", id_sym->name, buf);
	    fprintf(file, ".r %s\n-\n", buf);
	} else {
	    int i, lo, hi;

	    get_hilo(id_sym, &hi, &lo);
	    if (lo > hi) {
		fprintf(file, ".latch %s %s\n", id_sym->name, buf);
		fprintf(file, ".r %s\n-\n", buf);
	    } else {
		for (i=lo; i<=hi; i++) {
		    fprintf(file, ".latch %s%s%d%s %s%s%d%s\n",
			    id_sym->name, SEP_LBITSELECT, i, SEP_RBITSELECT,
			    buf, SEP_LBITSELECT, i, SEP_RBITSELECT);
		    fprintf(file, ".r %s%s%d%s\n-\n",
			    buf, SEP_LBITSELECT, i, SEP_RBITSELECT);
		}
	    }
	}
    }
}


char *check_dc(lsList syndrome_expr_list)
{
    lsGen lgen;
    lsHandle handle;
    char *retval;
    int nsym;
    syndrome_expr *se;
    int i;
    int rtvl;

    if (lsLength(syndrome_expr_list) == 0) return NIL(char);

    rtvl = lsFirstItem(syndrome_expr_list,(lsGeneric*)&se,0);
    assert(rtvl == LS_OK);
    nsym = strlen(se->syndrome);
    retval = (char*)chk_malloc(nsym * sizeof(char));
    for (i=0; i<nsym; i++) {
	retval[i] = 1;
	for (lgen=lsStart(syndrome_expr_list);
	     lsNext(lgen,(lsGeneric*)&se,&handle)!=LS_NOMORE;) {
	    if (se->syndrome[i] != '-')
		retval[i] = 0;
	}
	(void)lsFinish(lgen);
    }

    return retval;
}


void put_nblock_transition(FILE *file, int non_block_wire, int n_entries,
		      vl_id_range *id_sym, int idx_lo, int idx_hi, int cur, char *dc, lsList ripple)
{
    lsGen lgen;
    lsList comp;
    lsHandle handle;
    int lo, hi;
    int i, j, k;
    char *syndrome;
    syndrome_expr *se;
    lsList domain=(lsList)0;
    lsGen enum_gen;
    lsHandle enum_handle;
    vl_enumerator *enum_elt;

    for (lgen=lsStart((!rst_ckt)?
		      id_sym->syndrome_expr_list:
		      id_sym->rst_syndrome_expr_list),
	 i=0;
	 lsNext(lgen,(lsGeneric*)&se,&handle)!=LS_NOMORE; i++) {
	if (!(id_sym->flags & MVar)) {
	    lo=0; hi=1;
	} else {
	    get_hilo(id_sym, &hi, &lo);
	}

	if (id_sym->id_type)
	    domain = id_sym->id_type->specifier->u.enum_type->domain_list;

	if (!(id_sym->flags & MVar)) {
	    for (k=lo; k<=hi; k++) {
		if (vlTimedSystem && !rst_ckt)
		    fg_put_loc_context(file, se->pre_cond, NIL(char));
		fprintf(file, " ");
		put_entry(file, se->syndrome, dc, 1);

		if (ripple) {
		    for (j=0; j<i; j++) fprintf(file, "- ");
		    fprintf(file, "%d ", 1); j++;
		    for (; j<n_entries; j++) fprintf(file, "- ");
		}

		for (j=0; j<i; j++) fprintf(file, "- ");
		fprintf(file, "%d ", k); j++;
		for (; j<n_entries; j++) fprintf(file, "- ");
		fprintf(file, "%s%d\n", (non_block_wire||rst_ckt)?"":"- ", k);
	    }
	} else {
	    for (enum_gen=lsStart(domain);
		 lsNext(enum_gen,
			(lsGeneric*)&enum_elt,&enum_handle)!=LS_NOMORE;) {
		if (vlTimedSystem && !vlTimedSystem)
		    fg_put_loc_context(file, se->pre_cond, NIL(char));
		fprintf(file, " ");
		put_entry(file, se->syndrome, dc, 1);

		if (ripple) {
		    for (j=0; j<i; j++) fprintf(file, "- ");
		    fprintf(file, "%d ", 1); j++;
		    for (; j<n_entries; j++) fprintf(file, "- ");
		}

		for (j=0; j<i; j++) fprintf(file, "- ");
		fprintf(file, "%s ", enum_elt->name); j++;
		for (; j<n_entries; j++) fprintf(file, "- ");
		fprintf(file, "%s%s\n",
			(non_block_wire||rst_ckt)?"":"- ", enum_elt->name);
	    }
	    lsFinish(enum_gen);
	}


    }
    lsFinish(lgen);


    if (deadlock_semantic) {
	comp = put_guard_zero(file, (!rst_ckt)?id_sym->syndrome_expr_list:
			      id_sym->rst_syndrome_expr_list);
	if (comp)
	    if (lsLength(comp) > 0 && !(id_sym->flags & RegVar)) {
		char buf[MAXSTRLEN], tmp_buf[MAXSTRLEN];
		strcpy(tmp_buf, id_sym->name);
		strip_char(tmp_buf,SEP_LATCH);
		sprintf(buf, "%s: wire '%s' might be unassigned in certain context(s).\n", vl_currentModule->name->name, tmp_buf);
		strcat(buf, "\tDeadlock is assumed. To make its value a don't care, turn off -k option");
		if (WarningLevel > 0)
		    Translate_Notice(buf);
	    }
    }


    if (!set_notation && !(deadlock_semantic && non_block_wire)) {
	comp = put_guard_zero(file, (!rst_ckt)?id_sym->syndrome_expr_list:
			      id_sym->rst_syndrome_expr_list);
	if (!(id_sym->flags & MVar)) {
	    for (lgen=lsStart(comp);
		 lsNext(lgen,&syndrome,&handle)!=LS_NOMORE;) {
		if (!(id_sym->flags & MVar)) {
		    lo=0; hi=1;
		}
		for (k=lo; k<=hi; k++) {
		    put_entry(file, syndrome, dc, 1);
		    for (j=0; j<n_entries*((ripple)?2:1); j++)
			fprintf(file, "- ");
		    if (non_block_wire || rst_ckt)
			fprintf(file, "%d\n", k);
		    else
			fprintf(file, "%d %d\n", k, k);
		}
	    }
	    lsFinish(lgen);
	} else {
	    for (lgen=lsStart(comp);
		 lsNext(lgen,&syndrome,&handle)!=LS_NOMORE;) {
		if (!(id_sym->flags & MVar)) {
		    lo=0; hi=1;
		}
		for (enum_gen=lsStart(domain);
		     lsNext(enum_gen,
			    (lsGeneric*)&enum_elt,&enum_handle)!=LS_NOMORE;) {
		    put_entry(file, syndrome, dc, 1);
		    for (j=0; j<n_entries*((ripple)?2:1); j++)
			fprintf(file, "- ");
		    if (non_block_wire || rst_ckt)
			fprintf(file, "%s\n", enum_elt->name);
		    else
			fprintf(file, "%s %s\n",
				enum_elt->name, enum_elt->name);
		}
		lsFinish(enum_gen);
	    }
	    lsFinish(lgen);
	}
    }


    idx_lo = idx_lo;
    idx_hi = idx_hi;
    cur = cur;
}


void put_nblock_mout_transition(FILE *file, int non_block_wire,
				int n_entries,
				vl_id_range *id_sym,
				int idx_lo, int idx_hi, int cur,
				char *dc, char *latch_name)
{
    lsGen lgen;
    lsList comp;
    lsHandle handle;
    int lo, hi;
    int i, j, k;
    char *syndrome;
    syndrome_expr *se;

    for (lgen=lsStart((!rst_ckt)?
		      id_sym->syndrome_expr_list:
		      id_sym->rst_syndrome_expr_list),
	 i=0;
	 lsNext(lgen,(lsGeneric*)&se,&handle)!=LS_NOMORE; i++) {
	if (!(id_sym->flags & MVar)) {
	    lo=0; hi=1;
	} else {
	    get_hilo(id_sym, &hi, &lo);
	}

	if (vlTimedSystem && !rst_ckt)
	    fg_put_loc_context(file, se->pre_cond, NIL(char));
	fprintf(file, " ");
	put_entry(file, se->syndrome, dc, 1);

	for (j=0; j<n_entries; j++)
	    if (idx_lo == 0 && idx_hi == -1)
		fprintf(file, "- ");
	    else
		for (k=idx_lo; k<=idx_hi; k++) fprintf(file, "- ");
	if (!(non_block_wire||rst_ckt)) {
	    if (idx_lo == 0 && idx_hi == -1)
		fprintf(file, "- ");
	    else
		for (k=idx_lo; k<=idx_hi; k++)
		    fprintf(file, "- ");
	}
	if (id_sym->flags & MVar || (idx_lo==0 && idx_hi==-1)) {
	    fprintf(file, "%s%s\n", HSIS_EQUAL, se->expr->name->name);
	} else {
	    for (k=idx_lo; k<=idx_hi; k++) {
		fprintf(file, "%s%s%s%d%s ", HSIS_EQUAL,
			se->expr->name->name,
			SEP_LBITSELECT, k, SEP_RBITSELECT);
	    }
	    fprintf(file, "\n");
	}
    }
    lsFinish(lgen);


    if (deadlock_semantic) {
	comp = put_guard_zero(file, (!rst_ckt)?id_sym->syndrome_expr_list:
			      id_sym->rst_syndrome_expr_list);
	if (comp)
	    if (lsLength(comp) > 0 && !(id_sym->flags & RegVar)) {
		char buf[MAXSTRLEN], tmp_buf[MAXSTRLEN];
		strcpy(tmp_buf, id_sym->name);
		strip_char(tmp_buf,SEP_LATCH);
		sprintf(buf, "%s: wire '%s' might be unassigned in certain context(s).\n", vl_currentModule->name->name, tmp_buf);
		strcat(buf, "\tDeadlock is assumed. To make its value a don't care, use -k option");
		if (WarningLevel > 0)
		    Translate_Notice(buf);
	    }
    }


    if (!set_notation && !(deadlock_semantic && non_block_wire)) {
	comp = put_guard_zero(file, (!rst_ckt)?id_sym->syndrome_expr_list:
			      id_sym->rst_syndrome_expr_list);
	for (lgen=lsStart(comp);
	     lsNext(lgen,&syndrome,&handle)!=LS_NOMORE;) {

	    put_entry(file, syndrome, dc, 1);
	    for (j=0; j<n_entries; j++)
		if (idx_lo == 0 && idx_hi == -1)
		    fprintf(file, "- ");
		else
		    for (k=idx_lo; k<=idx_hi; k++) fprintf(file, "- ");
	    if (!(non_block_wire || rst_ckt)) {
		if (idx_lo == 0 && idx_hi == -1)
		    fprintf(file, "- ");
		else
		    for (k=idx_lo; k<=idx_hi; k++)
			fprintf(file, "- ");
	    }
	    if (id_sym->flags & MVar || (idx_lo==0 && idx_hi==-1)) {
		if (!(non_block_wire || rst_ckt)) {
		    fprintf(file, "%s%s\n", HSIS_EQUAL, latch_name);
		} else {
		    fprintf(file, "-\n");
		}
	    } else {
		if (!(non_block_wire || rst_ckt))
		    for (k=idx_lo; k<=idx_hi; k++) {
			fprintf(file, "%s%s%s%d%s ", HSIS_EQUAL,
				latch_name, SEP_LBITSELECT, k, SEP_RBITSELECT);
		    }
		else
		    for (k=idx_lo; k<=idx_hi; k++) {
			fprintf(file,"-");
		    }
		fprintf(file, "\n");
	    }
	}

	lsFinish(lgen);
    }


    cur = cur;
}


void create_wire_nondeterminism(FILE *file, char * var_name,
				vl_id_range *id_sym, array_t *vars_array)
{
    char buf[MAXSTRLEN];
    char input_buf[MAXSTRLEN];
    char *cp;
    st_table *vars;
    var_info *cur_var;
    int h, i, j, k;
    int hi, lo;
    int num_changer=0;
    lsList domain;
    lsGen enum_gen;
    lsHandle enum_handle;
    vl_enumerator *enum_elt;


    get_hilo(id_sym, &hi, &lo);

    cp = buf; *cp = '\0';
    cp = strappend(cp, ".names ");
    for (i=0; i<array_n(vars_array); i++) {
	vars = array_fetch(st_table*, vars_array, i);
	if (vars) {
	    if (st_lookup(vars, var_name, (char**)&cur_var)) {
		num_changer++;
		cp = strappendS(cp,
				cur_var->current_terminal->name->name);
	    }
	}
    }
    strcpy(input_buf, buf);
    if (!num_changer)
	if (!((id_sym->flags & OutPort) && Zconnection))
	    return;


    if (id_sym->flags &MVar) {
	fprintf(file, "%s %s\n", buf, id_sym->name);

	if (set_notation) {
	    for (i=0; i<array_n(vars_array); i++) {
		vars = array_fetch(st_table*, vars_array, i);
		if (vars) {
		    if (st_lookup(vars, var_name, (char**)&cur_var)) {
			for (j=0; j<num_changer; j++) {
			    fprintf(file, "- ");
			}
			fprintf(file, "%s%s\n", HSIS_EQUAL,
				cur_var->current_terminal->name->name);
		    }
		}
	    }
	} else {
	    domain = id_sym->id_type->specifier->u.enum_type->domain_list;
	    for (i=0; i<num_changer; i++) {
		for (enum_gen=lsStart(domain);
		     lsNext(enum_gen,
			    (lsGeneric*)&enum_elt,&enum_handle)!=LS_NOMORE;) {
		    for (k=0; k<num_changer; k++) {
			fprintf(file, "%s ", (i==k)?enum_elt->name:"-");
		    }
		    fprintf(file, "%s\n", enum_elt->name);
		}
		lsFinish(enum_gen);
	    }
	}

    } else if (lo > hi) {

	fprintf(file, "%s %s\n", buf, id_sym->name);

	for (i=0; i<num_changer; i++) {
	    for (j=0; j<=1; j++) {
		for (k=0; k<num_changer; k++) {
		    fprintf(file, "%c ", (i==k)?'0'+j:'-');
		}
		fprintf(file, "%d\n", j);
	    }
	}

    } else {
	array_t *ctrlv;

	for (h=lo; h<=hi; h++) {
	    cp = buf; *cp = '\0';
	    cp = strappend(cp, ".names ");
	    ctrlv = array_alloc(char*,0);
	    for (i=0, num_changer=0; i<array_n(vars_array); i++) {
		vars = array_fetch(st_table*, vars_array, i);
		if (vars) {
		    if (st_lookup(vars, var_name, (char**)&cur_var)) {
			char tmp_buf[MAXSTRLEN];
			int real_changer = 0;
			if (h == lo &&
			    cur_var->current_terminal->lo >
			    cur_var->current_terminal->hi)
			    real_changer = 1;
			if (cur_var->current_terminal->lo <=
			    cur_var->current_terminal->hi)
			    if (cur_var->current_terminal->lo <= h &&
				cur_var->current_terminal->hi >= h)
				real_changer = 1;
			if (real_changer) {
			    num_changer++;

			    sprintf(tmp_buf, "%s%s%d%s",
				    cur_var->current_terminal->name->name,
				    SEP_LBITSELECT, h, SEP_RBITSELECT);
			    cp = strappendS(cp, tmp_buf);
			    array_insert_last(char*,ctrlv,
					      vlStrdup(cur_var->current_terminal->name->name));
			}
		    }
		}
	    }
	    if (!num_changer) continue;
	    fprintf(file, "%s %s%s%d%s\n", buf, id_sym->name,
		    SEP_LBITSELECT, h, SEP_RBITSELECT);
	    if (set_notation) {
		for (i=0; i<num_changer; i++) {
		    for (k=0; k<num_changer; k++) {
			fprintf(file, "- ");
		    }
		    fprintf(file, "%s%s%s%d%s\n", HSIS_EQUAL,
			    array_fetch(char*, ctrlv, i),
			    SEP_LBITSELECT, h, SEP_RBITSELECT);
		}
	    } else {
		for (i=0; i<num_changer; i++) {
		    for (j=0; j<=1; j++) {
			for (k=0; k<num_changer; k++) {
			    fprintf(file, "%c ", (i==k)?'0'+j:'-');
			}
			fprintf(file, "%d\n", j);
		    }
		}
	    }

	    for (i=0; i<array_n(ctrlv); i++)
		vl_chk_free(array_fetch(char*, ctrlv, i));
	    array_free(ctrlv);

	}
    }
}


vl_term *put_quasi_control(FILE *file, char *dc, char *quasi_name, vl_id_range *id_sym, int n_entries)
{
    int ith_var;
    vl_term *ctrl_term;
    vl_term *retval;
    lsGen lgen;
    lsHandle handle;
    syndrome_expr *se;
    int retval_width, retval_range;
    char buf[MAXSTRLEN];

    retval_range = lsLength((!rst_ckt)?
			    id_sym->syndrome_expr_list:
			    id_sym->rst_syndrome_expr_list);
    retval_width  = min_bit_width(retval_range);
    retval = new_term(NIL(vl_range), 0, retval_width-1);
    fprintf(file, ".mv %s,%s%s%s %d\n",
	    retval->name->name, retval->name->name, SEP_GATEPIN, PIN_NS,
	    n_entries+1);
    fprintf(file, ".latch %s%s%s %s\n",
	    retval->name->name, SEP_GATEPIN, PIN_NS, retval->name->name);
    fprintf(file, ".r %s\n0\n", retval->name->name);


    fprintf(file, ".names ");

    for (lgen=lsStart((!rst_ckt)?ctrl_list:rst_ctrl_list), ith_var=0;
	 lsNext(lgen,(lsGeneric*)&ctrl_term,&handle)!=LS_NOMORE;
	 ith_var++) {
	if (!dc[ith_var]) fprintf(file, "%s ", ctrl_term->name->name);
    }
    (void)lsFinish(lgen);

    fprintf(file, "%s %s%s%s\n",
	    retval->name->name, retval->name->name, SEP_GATEPIN, PIN_NS);

    fprintf(file, "%s %s%s\n",
	    HSIS_DEFAULT, HSIS_EQUAL, retval->name->name);

    for (lgen=lsStart((!rst_ckt)?
		      id_sym->syndrome_expr_list:
		      id_sym->rst_syndrome_expr_list), ith_var=0;
	 lsNext(lgen,(lsGeneric*)&se,&handle)!=LS_NOMORE;
	 ith_var++) {
	if (vlTimedSystem && !rst_ckt)
	    fg_put_loc_context(file, se->pre_cond, NIL(char));
	fprintf(file, " ");
	put_entry(file, se->syndrome, dc, 1);
	fprintf(file, "- %d\n",
		(strcmp(se->expr->name->name,quasi_name))?ith_var+1:0);
    }
    (void)lsFinish(lgen);

    sprintf(buf, "%s%s%s", retval->name->name, SEP_GATEPIN, PIN_NS);
    vl_chk_free(retval->name->name);
    retval->name->name = vlStrdup(buf);

    return retval;
}


void put_quasi_table(FILE *file, char *dc, char *quasi_name, char *sync_name,
		     vl_id_range *id_sym, vl_term *out_term, int lo, int hi,
		     int n_entries)
{
    int ith_var, j;
    lsGen lgen;
    lsHandle handle;
    syndrome_expr *se;
    vl_term *ctrl_term;


    ctrl_term = put_quasi_control(file, dc, quasi_name, id_sym, n_entries);

    if (hi < lo) {


	fprintf(file, ".names %s ", ctrl_term->name->name);

	for (lgen=lsStart((!rst_ckt)?
			  id_sym->syndrome_expr_list:
			  id_sym->rst_syndrome_expr_list);
	     lsNext(lgen,(lsGeneric*)&se,&handle)!=LS_NOMORE;) {
	    fprintf(file, "%s ", se->expr->name->name);
	}
	(void)lsFinish(lgen);
	fprintf(file, "%s ", sync_name);

	fprintf(file, "%s\n", out_term->name->name);


	for (lgen=lsStart((!rst_ckt)?
			  id_sym->syndrome_expr_list:
			  id_sym->rst_syndrome_expr_list), ith_var=0;
	     lsNext(lgen,(lsGeneric*)&se,&handle)!=LS_NOMORE;
	     ith_var++) {
	    if (strcmp(se->expr->name->name, quasi_name)) {
		fprintf(file, "%d ", ith_var+1);
		for (j=0; j<n_entries; j++) fprintf(file, "- ");
		fprintf(file, "- %s%s\n", HSIS_EQUAL,se->expr->name->name);
	    }
	}
	(void)lsFinish(lgen);
	fprintf(file, "0 ");
	for (j=0; j<n_entries; j++) fprintf(file, "- ");
	fprintf(file, "- %s%s\n", HSIS_EQUAL, sync_name);
    } else {
	int bit;


	fprintf(file, ".names %s ", ctrl_term->name->name);

	for (lgen=lsStart((!rst_ckt)?
			  id_sym->syndrome_expr_list:
			  id_sym->rst_syndrome_expr_list);
	     lsNext(lgen,(lsGeneric*)&se,&handle)!=LS_NOMORE;) {
	    for (bit=lo; bit<=hi; bit++)
		fprintf(file, "%s%s%d%s ", se->expr->name->name,
			SEP_LBITSELECT, bit, SEP_RBITSELECT);
	}
	(void)lsFinish(lgen);

	for (bit=lo; bit<=hi; bit++)
	    fprintf(file, "%s%s%d%s%s%s ", quasi_name,
		    SEP_LBITSELECT, bit, SEP_RBITSELECT,
		    SEP_GATEPIN, PIN_PS);

	fprintf(file, "%s ", HSIS_ARROW);
	for (bit=lo; bit<=hi; bit++)
	    fprintf(file, "%s%s%d%s ", out_term->name->name,
		    SEP_LBITSELECT, bit, SEP_RBITSELECT);
	fprintf(file, "\n");


	for (lgen=lsStart((!rst_ckt)?
			  id_sym->syndrome_expr_list:
			  id_sym->rst_syndrome_expr_list), ith_var=0;
	     lsNext(lgen,(lsGeneric*)&se,&handle)!=LS_NOMORE;
	     ith_var++) {
	    if (strcmp(se->expr->name->name, quasi_name)) {
		fprintf(file, "%d ", ith_var+1);
		for (j=0; j<n_entries; j++)
		    for (bit=lo; bit<=hi; bit++) fprintf(file, "- ");
		for (bit=lo; bit<=hi; bit++) fprintf(file, "- ");
		for (bit=lo; bit<=hi; bit++)
		    fprintf(file, "%s%s%s%d%s ",
			    HSIS_EQUAL,se->expr->name->name,
			    SEP_LBITSELECT, bit, SEP_RBITSELECT);
		fprintf(file, "\n");
	    }
	}
	(void)lsFinish(lgen);
	fprintf(file, "0 ");
	for (j=0; j<n_entries; j++)
	    for (bit=lo; bit<=hi; bit++) fprintf(file, "- ");
	for (bit=lo; bit<=hi; bit++) fprintf(file, "- ");

	for (bit=lo; bit<=hi; bit++)
	    fprintf(file, "%s%s%s%d%s%s%s ",
		    HSIS_EQUAL, quasi_name,
		    SEP_LBITSELECT, bit, SEP_RBITSELECT,
		    SEP_GATEPIN, PIN_PS);
	fprintf(file, "\n");
    }
}


void declare_mvar_io(FILE *file, char *dir, vl_id_range *id_sym)
{
    int idx, idx_hi, idx_lo;

    if (!id_sym->range) {
	fprintf(file, "%s %s", dir, id_sym->name);
	fprintf(file, "\n");
    } else {
	idx_lo = vl_eval_expr(id_sym->range->left);
	if (id_sym->range->right)
	    idx_hi = vl_eval_expr(id_sym->range->right);
	else
	    idx_hi = idx_lo;

	for (idx = idx_lo; idx <= idx_hi; idx++) {
	    fprintf(file, "%s %s%s%d%s", dir,
		    id_sym->name, SEP_LARRAY, idx, SEP_RARRAY);
	    fprintf(file, "\n");
	}
    }
}

void declare_bin_scalar_io(FILE *file, char *dir, vl_id_range *id_sym)
{
    int idx, idx_lo, idx_hi;

    if (!id_sym->range) {
	fprintf(file, "%s %s", dir, id_sym->name);
	fprintf(file, "\n");
    } else {
	idx_lo = vl_eval_expr(id_sym->range->left);
	if (id_sym->range->right)
	    idx_hi = vl_eval_expr(id_sym->range->right);
	else
	    idx_hi = idx_lo;

	for (idx = idx_lo; idx <= idx_hi; idx++) {
	    fprintf(file, "%s %s%s%d%s", dir,
		    id_sym->name, SEP_LARRAY, idx, SEP_RARRAY);
	    fprintf(file, "\n");
	}
    }
}

void declare_bin_vector_io(FILE *file, char *dir, vl_id_range *id_sym)
{
    int idx, idx_lo, idx_hi;
    int i, lo, hi;
    int ithItem;

    get_hilo(id_sym, &hi, &lo);

    if (!id_sym->range) {
	fprintf(file, "%s ", dir);
	ithItem = 0;
	for (i=lo; i<=hi; i++) {
	    char buf[MAXSTRLEN];

	    sprintf(buf, "%s%s%d%s", id_sym->name,
		    SEP_LBITSELECT, i, SEP_RBITSELECT);
	    fprintf(file, "%s ", buf);
	}
	fprintf(file, "\n");
    } else {
	idx_lo = vl_eval_expr(id_sym->range->left);
	if (id_sym->range->right)
	    idx_hi = vl_eval_expr(id_sym->range->right);
	else
	    idx_hi = idx_lo;

	for (idx = idx_lo; idx <= idx_hi; idx++) {
	    fprintf(file, "%s ", dir);
	    for (i=lo; i<=hi; i++) {
		char buf[MAXSTRLEN];

		sprintf(buf, "%s%s%d%s%s%d%s", id_sym->name,
			SEP_LARRAY, idx, SEP_RARRAY,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
		fprintf(file, "%s ", buf);
	    }
	    fprintf(file, "\n");
	}
    }
}


void put_const_port_connect(FILE *file, char *outstr,
			    vl_id_range *master,
			    vl_port_connect *instance,
			    lsList input_consts,
			    vl_term *term_out)
{
    int i, hi, lo;
    char buf[MAXSTRLEN];

    get_hilo(master, &hi, &lo);
    if (isMVar(master->flags)) {

	sprintf(buf, "%s=%s ", master->name, term_out->name->name);
    } else {

	if (lo > hi) {

	    sprintf(buf, "%s=%s ",
		    master->name, term_out->name->name);
	} else {

	    char tmp[MAXSTRLEN];

	    buf[0] = '\0';
	    for (i=lo; i<=hi; i++) {
		sprintf(tmp, "%s%s%d%s=%s%s%d%s ",
			master->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT,
			term_out->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
		strcat(buf, tmp);
	    }
	}
    }

    if (file) fprintf(file, "%s", buf);
    if (outstr) sprintf(outstr, "%s", buf);
}


void put_mvar_port_connect(FILE *file, char *outstr,
			   vl_id_range *master,
			   vl_port_connect *instance)
{
    int idx, idx_lo, idx_hi;
    char buf[MAXSTRLEN];

    if (!master->range) {
	sprintf(buf, "%s=%s ",
		master->name,
		instance->expr->term->name->name);
    } else {
	char tmp[MAXSTRLEN];

	buf[0] = '\0';
	idx_lo = vl_eval_expr(master->range->left);
	if (master->range->right)
	    idx_hi = vl_eval_expr(master->range->right);
	else
	    idx_hi = idx_lo;

	for (idx=idx_lo; idx<=idx_hi; idx++) {
	    sprintf(tmp, "%s%s%d%s=%s%s%d%s ",
		    master->name, SEP_LARRAY, idx, SEP_RARRAY,
		    instance->expr->term->name->name,
		    SEP_LARRAY, idx, SEP_RARRAY);
	    strcat(buf, tmp);
	}
    }

    if (file) fprintf(file, "%s", buf);
    if (outstr) sprintf(outstr, "%s", buf);
}


void put_bin_scalar_port_connect(FILE *file, char *outstr,
				 vl_id_range *master,
				 vl_port_connect *instance)
{
    int idx, idx_lo, idx_hi;
    char buf[MAXSTRLEN];

    if (instance->expr->term->lo > instance->expr->term->hi){
	if (!master->range) {
	    sprintf(buf, "%s=%s ",
		    master->name,
		    instance->expr->term->name->name);
	} else {
	    char tmp[MAXSTRLEN];

	    buf[0] = '\0';
	    idx_lo = vl_eval_expr(master->range->left);
	    if (master->range->right)
		idx_hi = vl_eval_expr(master->range->right);
	    else
		idx_hi = idx_lo;

	    for (idx=idx_lo; idx<=idx_hi; idx++) {
		sprintf(tmp, "%s%s%d%s=%s%s%d%s ",
			master->name,
			SEP_LARRAY, idx, SEP_RARRAY,
			instance->expr->term->name->name,
			SEP_LARRAY, idx, SEP_RARRAY);
		strcat(buf, tmp);
	    }
	}
    } else {
	if (!master->range) {
	    sprintf(buf, "%s=%s%s%d%s ",
		    master->name,
		    instance->expr->term->name->name,
		    SEP_LBITSELECT,
		    instance->expr->term->lo,
		    SEP_RBITSELECT);
	} else {
	    char tmp[MAXSTRLEN];

	    buf[0] = '\0';
	    idx_lo = vl_eval_expr(master->range->left);
	    if (master->range->right)
		idx_hi = vl_eval_expr(master->range->right);
	    else
		idx_hi = idx_lo;

	    for (idx=idx_lo; idx<=idx_hi; idx++) {
		sprintf(tmp, "%s%s%d%s=%s%s%d%s%s%d%s ",
			master->name,
			SEP_LARRAY, idx, SEP_RARRAY,
			instance->expr->term->name->name,
			SEP_LARRAY, idx, SEP_RARRAY,
			SEP_LBITSELECT,
			instance->expr->term->lo,
			SEP_RBITSELECT);
		strcat(buf, tmp);
	    }
	}
    }

    if (file) fprintf(file, "%s", buf);
    if (outstr) sprintf(outstr, "%s", buf);
}


void put_bin_vector_port_connect(FILE *file, char *outstr,
				 vl_id_range *master,
				 vl_port_connect *instance)
{
    int sig_lo;
    int lo, hi;
    int idx, idx_lo, idx_hi;
    int i;
    char buf[MAXSTRLEN];

    get_hilo(master, &hi, &lo);
    sig_lo = instance->expr->term->lo;

    if (!master->range) {
	char tmp[MAXSTRLEN];

	buf[0] = '\0';
	for (i=lo; i<=hi; i++) {
	    char mast_buf[MAXSTRLEN];
	    char inst_buf[MAXSTRLEN];

	    sprintf(mast_buf, "%s%s%d%s", master->name,
		    SEP_LBITSELECT, i, SEP_RBITSELECT);
	    sprintf(inst_buf, "%s%s%d%s",
		    instance->expr->term->name->name,
		    SEP_LBITSELECT,sig_lo-lo+i,SEP_RBITSELECT);
	    sprintf(tmp, "%s=%s ", mast_buf, inst_buf);
	    strcat(buf, tmp);
	}
    } else {
	idx_lo = vl_eval_expr(master->range->left);
	if (master->range->right)
	    idx_hi = vl_eval_expr(master->range->right);
	else
	    idx_hi = idx_lo;

	{
	    char tmp[MAXSTRLEN];

	    buf[0] = '\0';
	    for (idx=idx_lo; idx<=idx_hi; idx++) {
		for (i=lo; i<=hi; i++) {
		    char mast_buf[MAXSTRLEN];
		    char inst_buf[MAXSTRLEN];

		    sprintf(mast_buf, "%s%s%d%s%s%d%s", master->name,
			    SEP_LARRAY, idx, SEP_RARRAY,
			    SEP_LBITSELECT, i, SEP_RBITSELECT);
		    sprintf(inst_buf, "%s%s%d%s%s%d%s",
			    instance->expr->term->name->name,
			    SEP_LARRAY, idx, SEP_RARRAY,
			    SEP_LBITSELECT,
			    sig_lo-lo+i,
			    SEP_RBITSELECT);
		    sprintf(tmp, "%s=%s ", mast_buf, inst_buf);
		    strcat(buf, tmp);
		}
	    }
	}
    }

    if (file) fprintf(file, "%s", buf);
    if (outstr) sprintf(outstr, "%s", buf);
}


void put_bin_scalar_func_connect(FILE *file, vl_id_range *master,
				 vl_term *instance)
{
    int idx, idx_lo, idx_hi;

    if (instance->lo > instance->hi){
	if (!master->range) {
	    fprintf(file, "%s=%s ",
		    master->name,
		    instance->name->name);
	} else {
	    idx_lo = vl_eval_expr(master->range->left);
	    if (master->range->right)
		idx_hi = vl_eval_expr(master->range->right);
	    else
		idx_hi = idx_lo;

	    for (idx=idx_lo; idx<=idx_hi; idx++) {
		fprintf(file, "%s%s%d%s=%s%s%d%s ",
			master->name,
			SEP_LARRAY, idx, SEP_RARRAY,
			instance->name->name,
			SEP_LARRAY, idx, SEP_RARRAY);
	    }
	}
    } else {
	if (!master->range) {
	    fprintf(file, "%s=%s%s%d%s ",
		    master->name,
		    instance->name->name,
		    SEP_LBITSELECT,
		    instance->lo,
		    SEP_RBITSELECT);
	} else {
	    idx_lo = vl_eval_expr(master->range->left);
	    if (master->range->right)
		idx_hi = vl_eval_expr(master->range->right);
	    else
		idx_hi = idx_lo;

	    for (idx=idx_lo; idx<=idx_hi; idx++) {
		fprintf(file, "%s%s%d%s=%s%s%d%s%s%d%s ",
			master->name,
			SEP_LARRAY, idx, SEP_RARRAY,
			instance->name->name,
			SEP_LARRAY, idx, SEP_RARRAY,
			SEP_LBITSELECT,
			instance->lo,
			SEP_RBITSELECT);
	    }
	}
    }
}


void put_bin_vector_func_connect(FILE *file, vl_id_range *master,
				 vl_term *instance)
{
    int sig_lo;
    int lo, hi;
    int idx, idx_lo, idx_hi;
    int i;

    get_hilo(master, &hi, &lo);
    sig_lo = instance->lo;

    if (!master->range) {
	for (i=lo; i<=hi; i++) {
	    char mast_buf[MAXSTRLEN];
	    char inst_buf[MAXSTRLEN];

	    sprintf(mast_buf, "%s%s%d%s", master->name,
		    SEP_LBITSELECT, i, SEP_RBITSELECT);
	    sprintf(inst_buf, "%s%s%d%s",
		    instance->name->name,
		    SEP_LBITSELECT,sig_lo-lo+i,SEP_RBITSELECT);
	    fprintf(file, "%s=%s ", mast_buf, inst_buf);
	}
    } else {
	idx_lo = vl_eval_expr(master->range->left);
	if (master->range->right)
	    idx_hi = vl_eval_expr(master->range->right);
	else
	    idx_hi = idx_lo;

	for (idx=idx_lo; idx<=idx_hi; idx++) {
	    for (i=lo; i<=hi; i++) {
		char mast_buf[MAXSTRLEN];
		char inst_buf[MAXSTRLEN];

		sprintf(mast_buf, "%s%s%d%s%s%d%s", master->name,
			SEP_LARRAY, idx, SEP_RARRAY,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
		sprintf(inst_buf, "%s%s%d%s%s%d%s",
			instance->name->name,
			SEP_LARRAY, idx, SEP_RARRAY,
			SEP_LBITSELECT,
			sig_lo-lo+i,
			SEP_RBITSELECT);
		fprintf(file, "%s=%s ", mast_buf, inst_buf);
	    }
	}
    }
}


char *write_red_op(FILE *file, short type, vl_term *in1, vl_term *in2, vl_term *out)
{
    int bpos;
    char *ripple=NIL(char);

    fprintf(file, ".names ");
    for (bpos=in1->lo; bpos<=in1->hi; bpos++) {
	fprintf(file, "%s%s%d%s ", in1->name->name,
		SEP_LBITSELECT, bpos, SEP_RBITSELECT);
    }

    fprintf(file, "%s\n", out->name->name);

    if (set_notation) {
	fprintf(file, "%s %c\n", HSIS_DEFAULT,
		(type==UnorExpr||type==UandExpr)?'0':'1');
	for (bpos=in1->lo; bpos<=in1->hi; bpos++) {
	    fprintf(file, "%c ",
		    (type==UorExpr||type==UnorExpr)?'0':'1');
	}
	fprintf(file, "%c\n",
		(type==UnorExpr||type==UandExpr)?'1':'0');
    } else {
	for (bpos=in1->lo; bpos<=in1->hi; bpos++) {
	    int i;
	    for (i=in1->lo; i<=in1->hi; i++) {
		fprintf(file, "%c ",
			(i==bpos)?
			((type==UorExpr||type==UnorExpr)?'1':'0'):'-');
	    }
	    fprintf(file, "%c\n",
		    (type==UorExpr||type==UnandExpr)?'1':'0');
	}
	for (bpos=in1->lo; bpos<=in1->hi; bpos++) {
	    fprintf(file, "%c ",
		    (type==UorExpr||type==UnorExpr)?'0':'1');
	}
	fprintf(file, "%c\n",
		(type==UorExpr||type==UnandExpr)?'0':'1');
    }

    in2 = in2;

    return ripple;
}



char *write_rel_vector_bop(FILE *file, short type, vl_term *in1, vl_term *in2, vl_term *out)
{
    int bpos;
    vl_term *tmpterm;
    char term1[MAXSTRLEN], term2[MAXSTRLEN], outerm[MAXSTRLEN];
    char *ripple=NIL(char);


    tmpterm = create_rename_term(out->name, new_termname(), out->lo, out->hi);
    out->lo = 0;
    out->hi = -1;

    if (in1->lo > in1->hi && in2->lo > in2->hi) {

	ripple = vl_write_bop(file, type,
			      in1->name->name, in2->name->name, NIL(char),
			      tmpterm->name->name,
			      !IS_VLR_REL_OP(type));
	if (IS_VLR_REL_OP(type))
	    postprocess_vlr_rel(file, type, ripple, tmpterm, out);
    } else if (in1->lo > in1->hi && in2->lo <= in2->hi) {

	char tmpterm_buf[MAXSTRLEN];
	if (tmpterm->lo > tmpterm->hi)
	    sprintf(tmpterm_buf, "%s", tmpterm->name->name);
	else
	    sprintf(tmpterm_buf, "%s%s%d%s", tmpterm->name->name,
		    SEP_LBITSELECT, tmpterm->lo, SEP_RBITSELECT);
	sprintf(term2, "%s%s%d%s", in2->name->name,
		SEP_LBITSELECT, in2->lo, SEP_RBITSELECT);
	ripple = vl_write_bop(file, type,
			      in1->name->name, term2, NIL(char),
			      tmpterm_buf,
			      !IS_VLR_REL_OP(type));

	for (bpos=in2->lo+1; bpos<=in2->hi; bpos++) {
	    sprintf(term2, "%s%s%d%s", in2->name->name,
		    SEP_LBITSELECT, bpos, SEP_RBITSELECT);
	    sprintf(tmpterm_buf, "%s%s%d%s",
		    tmpterm->name->name,
		    SEP_LBITSELECT,
		    tmpterm->lo+(bpos-in2->lo),
		    SEP_RBITSELECT);
	    vl_write_bit_connect(file, term2, tmpterm_buf, 0);
	}
	if (IS_VLR_REL_OP(type))
	    postprocess_vlr_rel(file, type, ripple, tmpterm, out);
    } else if (in1->lo <= in1->hi && in2->lo > in2->hi) {

	char tmpterm_buf[MAXSTRLEN];
	if (tmpterm->lo > tmpterm->hi)
	    sprintf(tmpterm_buf, "%s", tmpterm->name->name);
	else
	    sprintf(tmpterm_buf, "%s%s%d%s", tmpterm->name->name,
		    SEP_LBITSELECT, tmpterm->lo, SEP_RBITSELECT);
	sprintf(term1, "%s%s%d%s", in1->name->name,
		SEP_LBITSELECT, in1->lo, SEP_RBITSELECT);
	ripple = vl_write_bop(file, type,
			      term1, in2->name->name, NIL(char),
			      tmpterm_buf,
			      !IS_VLR_REL_OP(type));

	for (bpos=in1->lo+1; bpos<=in1->hi; bpos++) {
	    sprintf(term1, "%s%s%d%s", in1->name->name,
		    SEP_LBITSELECT, bpos, SEP_RBITSELECT);
	    sprintf(tmpterm_buf, "%s%s%d%s",
		    tmpterm->name->name,
		    SEP_LBITSELECT,
		    tmpterm->lo+(bpos-in1->lo),
		    SEP_RBITSELECT);
	    vl_write_bit_connect(file, term1, tmpterm_buf, 0);
	}
	if (IS_VLR_REL_OP(type))
	    postprocess_vlr_rel(file, type, ripple, tmpterm, out);
    } else {

	for (bpos=tmpterm->lo, ripple=NIL(char); bpos<=tmpterm->hi; bpos++) {
	    if (bpos > in1->hi-in1->lo)
		sprintf(term1, "%s", WRT_BLIF_GND(file));
	    else
		sprintf(term1, "%s%s%d%s",
			in1->name->name,
			SEP_LBITSELECT, in1->lo+bpos, SEP_RBITSELECT);
	    if (bpos > in2->hi-in2->lo)
		sprintf(term2, "%s", WRT_BLIF_GND(file));
	    else
		sprintf(term2, "%s%s%d%s",
			in2->name->name,
			SEP_LBITSELECT, in2->lo+bpos, SEP_RBITSELECT);
	    sprintf(outerm, "%s%s%d%s",
		    tmpterm->name->name,
		    SEP_LBITSELECT, tmpterm->lo+bpos, SEP_RBITSELECT);
	    ripple = vl_write_bop(file, type, term1, term2, ripple, outerm,
				  !IS_VLR_REL_OP(type));
	}
	if (IS_VLR_REL_OP(type))
	    postprocess_vlr_rel(file, type, ripple, tmpterm, out);
    }

    vl_chk_free((char*)tmpterm);

    return ripple;
}


char *write_op_vector_bop(FILE *file, short type, vl_term *in1, vl_term *in2, vl_term *out)
{
    int bpos;
    char term1[MAXSTRLEN], term2[MAXSTRLEN], outerm[MAXSTRLEN];
    char *ripple = NIL(char);


    if (in1->lo > in1->hi && in2->lo > in2->hi) {

	if ((vector_width(in1->lo, in1->hi) <
	     vector_width(out->lo, out->hi)) &&
	    (vector_width(in2->lo, in2->hi) <
	     vector_width(out->lo, out->hi))) {
	    sprintf(outerm, "%s%s%d%s",
		    out->name->name,
		    SEP_LBITSELECT,
		    out->lo,
		    SEP_RBITSELECT);
	    ripple = vl_write_bop(file, type,
				  in1->name->name, in2->name->name,
				  NIL(char),
				  outerm, 0);
	    sprintf(outerm, "%s%s%d%s",
		    out->name->name,
		    SEP_LBITSELECT,
		    out->lo+1,
		    SEP_RBITSELECT);
	    vl_write_bit_connect(file, ripple, outerm, 0);
	} else {
	    ripple = vl_write_bop(file, type,
				  in1->name->name, in2->name->name,
				  NIL(char),
				  out->name->name, 0);
	}
    } else if (in1->lo > in1->hi && in2->lo <= in2->hi) {

	sprintf(term2, "%s%s%d%s", in2->name->name,
		SEP_LBITSELECT, in2->lo, SEP_RBITSELECT);
	sprintf(outerm, "%s%s%d%s", out->name->name,
		SEP_LBITSELECT, out->lo, SEP_RBITSELECT);
	ripple = vl_write_bop(file, type,
			      in1->name->name,term2,NIL(char),outerm, 0);

	if (IS_VLR_LOG_OP(type)) {
	    sprintf(term2, "%s", WRT_BLIF_GND(file));
	    for (bpos=in1->lo+1; bpos<=in1->hi; bpos++) {
		sprintf(outerm, "%s%s%d%s",
			out->name->name,
			SEP_LBITSELECT,
			out->lo+(bpos-in2->lo),
			SEP_RBITSELECT);
		vl_write_bit_connect(file, term2, outerm, 0);
	    }
	} else {
	    for (bpos=in2->lo+1; bpos<=in2->hi; bpos++) {
		sprintf(term2, "%s%s%d%s", in2->name->name,
			SEP_LBITSELECT, bpos, SEP_RBITSELECT);
		sprintf(outerm, "%s%s%d%s",
			out->name->name,
			SEP_LBITSELECT,
			out->lo+(bpos-in2->lo),
			SEP_RBITSELECT);
		if (type == BplusExpr || type == BminusExpr) {
		    ripple = vl_write_bop(file, type,
					  term2,ripple,NIL(char),outerm,0);
		} else {
		    vl_write_bit_connect(file, term2, outerm, 0);
		}
	    }
	}

	if ((vector_width(in1->lo, in1->hi) <
	     vector_width(out->lo, out->hi)) &&
	    (vector_width(in2->lo, in2->hi) <
	     vector_width(out->lo, out->hi))) {
	    sprintf(outerm, "%s%s%d%s",
		    out->name->name,
		    SEP_LBITSELECT,
		    bpos,
		    SEP_RBITSELECT);
	    vl_write_bit_connect(file, ripple, outerm, 0);
	}
    } else if (in1->lo <= in1->hi && in2->lo > in2->hi) {

	sprintf(term1, "%s%s%d%s", in1->name->name,
		SEP_LBITSELECT, in1->lo, SEP_RBITSELECT);
	sprintf(outerm, "%s%s%d%s", out->name->name,
		SEP_LBITSELECT, out->lo, SEP_RBITSELECT);
	ripple = vl_write_bop(file, type,
			      term1,in2->name->name,NIL(char),outerm, 0);

	if (IS_VLR_LOG_OP(type)) {
	    sprintf(term1, "%s", WRT_BLIF_GND(file));
	    for (bpos=in1->lo+1; bpos<=in1->hi; bpos++) {
		sprintf(outerm, "%s%s%d%s", out->name->name,
			SEP_LBITSELECT,
			out->lo+(bpos-in1->lo),
			SEP_RBITSELECT);
		vl_write_bit_connect(file, term1, outerm, 0);
	    }
	} else {
	    for (bpos=in1->lo+1; bpos<=in1->hi; bpos++) {
		sprintf(term1, "%s%s%d%s", in1->name->name,
			SEP_LBITSELECT, bpos, SEP_RBITSELECT);
		sprintf(outerm, "%s%s%d%s",
			out->name->name,
			SEP_LBITSELECT,
			out->lo+(bpos-in1->lo),
			SEP_RBITSELECT);
		if (type == BplusExpr || type == BminusExpr) {
		    ripple = vl_write_bop(file, type,
					  term1,ripple,NIL(char),outerm,0);
		} else {
		    vl_write_bit_connect(file, term1, outerm, 0);
		}
	    }
	}

	if ((vector_width(in1->lo, in1->hi) <
	     vector_width(out->lo, out->hi)) &&
	    (vector_width(in2->lo, in2->hi) <
	     vector_width(out->lo, out->hi))) {
	    sprintf(outerm, "%s%s%d%s",
		    out->name->name,
		    SEP_LBITSELECT,
		    bpos,
		    SEP_RBITSELECT);
	    vl_write_bit_connect(file, ripple, outerm, 0);
	}
    } else {

	for (bpos=out->lo, ripple=NIL(char); bpos<=out->hi; bpos++) {
	    if (RIPPLE_INTERFERE(type)) {
		if (bpos-out->lo <=
		    MIN(in1->hi-in1->lo,in2->hi-in2->lo)) {
		    sprintf(term1, "%s%s%d%s",
			    in1->name->name,
			    SEP_LBITSELECT, in1->lo+bpos, SEP_RBITSELECT);
		    sprintf(term2, "%s%s%d%s",
			    in2->name->name,
			    SEP_LBITSELECT, in2->lo+bpos, SEP_RBITSELECT);
		    sprintf(outerm, "%s%s%d%s",
			    out->name->name,
			    SEP_LBITSELECT, out->lo+bpos, SEP_RBITSELECT);
		    ripple =
			vl_write_bop(file, type, term1, term2, ripple,
				     outerm, (bpos==out->hi));
		} else if (bpos-out->lo ==
			   MIN(in1->hi-in1->lo,in2->hi-in2->lo)+1) {
		    sprintf(outerm, "%s%s%d%s",
			    out->name->name,
			    SEP_LBITSELECT, out->lo+bpos, SEP_RBITSELECT);
		    fprintf(file, ".names %s %s\n1 1\n0 0\n",
			    ripple, outerm);
		} else {
		    sprintf(outerm, "%s%s%d%s",
			    out->name->name,
			    SEP_LBITSELECT, out->lo+bpos, SEP_RBITSELECT);
		    fprintf(file, ".names %s\n0\n", outerm);
		}
	    } else {
		if (bpos-out->lo <=
		    MIN(in1->hi-in1->lo,in2->hi-in2->lo)) {
		    sprintf(term1, "%s%s%d%s",
			    in1->name->name,
			    SEP_LBITSELECT, in1->lo+bpos, SEP_RBITSELECT);
		    sprintf(term2, "%s%s%d%s",
			    in2->name->name,
			    SEP_LBITSELECT, in2->lo+bpos, SEP_RBITSELECT);
		    sprintf(outerm, "%s%s%d%s",
			    out->name->name,
			    SEP_LBITSELECT, out->lo+bpos, SEP_RBITSELECT);
		    ripple =
			vl_write_bop(file, type, term1, term2, ripple,
				     outerm, (bpos==out->hi));
		} else {
		    if (bpos-out->lo <= in1->hi-in1->lo) {
			sprintf(term1, "%s%s%d%s",
				in1->name->name,
				SEP_LBITSELECT, in1->lo+bpos,
				SEP_RBITSELECT);
			sprintf(outerm, "%s%s%d%s",
				out->name->name,
				SEP_LBITSELECT, out->lo+bpos,
				SEP_RBITSELECT);
			fprintf(file, ".names %s %s\n0 0\n1 1\n",
				term1, outerm);
		    } else if (bpos-out->lo <= in2->hi-in2->lo) {
			sprintf(term2, "%s%s%d%s",
				in2->name->name,
				SEP_LBITSELECT, in2->lo+bpos,
				SEP_RBITSELECT);
			sprintf(outerm, "%s%s%d%s",
				out->name->name,
				SEP_LBITSELECT, out->lo+bpos,
				SEP_RBITSELECT);
			fprintf(file, ".names %s %s\n0 0\n1 1\n",
				term2, outerm);
		    } else {
			sprintf(outerm, "%s%s%d%s",
				out->name->name,
				SEP_LBITSELECT, out->lo+bpos,
				SEP_RBITSELECT);
			fprintf(file, ".names %s\n0\n", outerm);
		    }
		}
	    }
	}
    }

    return ripple;
}


static void postprocess_vlr_rel(FILE *file, short type, char *carry,
				vl_term *results, vl_term *out)
{
    char *tmp_termname;
    vl_term *zero_term;

    switch(type) {
    case BltExpr:

	zero_term = new_term(NIL(vl_range), 0, -1);
	if (results->hi < results->lo)
	    vl_write_bit_connect(file,
				results->name->name, zero_term->name->name, 0);
	else
	    vl_write_vector_bop(file, UorExpr,
				results, NIL(vl_term), zero_term);
	vl_write_bop(file, BandExpr, carry, zero_term->name->name, NIL(char),
		     out->name->name, 1);
	break;
    case BgtExpr:

	zero_term = new_term(NIL(vl_range), 0, -1);
	if (results->hi < results->lo)
	    vl_write_bit_connect(file,
				results->name->name, zero_term->name->name, 1);
	else
	    vl_write_vector_bop(file, UnorExpr,
				results, NIL(vl_term), zero_term);
	tmp_termname = new_termname();
	vl_write_bop(file, BorExpr, carry, zero_term->name->name, NIL(char),
		     tmp_termname, 1);
	vl_write_bit_connect(file, tmp_termname, out->name->name, 1);
	break;
    case BleExpr:

	zero_term = new_term(NIL(vl_range), 0, -1);
	if (results->hi < results->lo)
	    vl_write_bit_connect(file,
				results->name->name, zero_term->name->name, 1);
	else
	    vl_write_vector_bop(file, UnorExpr,
				results, NIL(vl_term), zero_term);
	vl_write_bop(file, BorExpr, carry, zero_term->name->name, NIL(char),
		     out->name->name, 1);
	break;
    case BgeExpr:

	zero_term = new_term(NIL(vl_range), 0, -1);
	if (results->hi < results->lo)
	    vl_write_bit_connect(file,
				results->name->name, zero_term->name->name, 0);
	else
	    vl_write_vector_bop(file, UorExpr,
				results, NIL(vl_term), zero_term);
	tmp_termname = new_termname();
	vl_write_bop(file, BandExpr, carry, zero_term->name->name, NIL(char),
		     tmp_termname, 1);
	vl_write_bit_connect(file, tmp_termname, out->name->name, 1);
	break;
    }
}


vl_port *search_match_port(char *name, lsList ports)
{
    lsGen gen;
    lsHandle handle;
    vl_port *retval=NIL(vl_port), *port;
    lsHandle port_handle;
    vl_id_range *id;

    gen = lsStart(ports);
    while (lsNext(gen, (lsGeneric*)&port, &handle)!=LS_NOMORE) {
	lsFirstItem(port->port_exp, (lsGeneric*)&id, &port_handle);
	if (!strcmp(name, id->name)) {
	    retval = port;
	    break;
	}
    }
    lsFinish(gen);

    return retval;
}


vl_port_connect *search_inst_port(char *name, lsList ports)
{
    lsGen gen;
    lsHandle handle;
    vl_port_connect *retval=NIL(vl_port_connect), *port;

    gen = lsStart(ports);
    while (lsNext(gen, (lsGeneric*)&port, &handle)!=LS_NOMORE) {
	if (!strcmp(name, port->id->name)) {
	    retval = port;
	    break;
	}
    }
    lsFinish(gen);

    return retval;
}



char *vl_translate_prim_symbol(unsigned char sym)
{
    char buf[MAXSTRLEN];

    switch(sym) {
    case PrimNone: return("");
    case Prim0: return("0");
    case Prim1: return("1");
    case PrimX: return("-");
    case PrimQ: return("-");
    case PrimB: return("-");
    case PrimM: return("-");
    case PrimR: return("0 1");
    case PrimF: return("1 0");
    case PrimS: return("- -");
    case PrimBB: return("- -");
    case PrimQ0: return("- 0");
    case PrimQ1: return("- 1");
    case PrimQB: return("- -");
    case Prim0X: return("0 -");
    case Prim1X: return("1 -");
    case PrimX0: return("- 0");
    case PrimX1: return("- 1");
    case PrimXB: return("- -");
    case PrimBX: return("- -");
    case PrimP: sprintf(buf, "P");
    case PrimN: sprintf(buf, "N");
	strcat(buf, " :: can not be handled yet");
	Translate_Warning(buf);
	return("");
    default: {
	char msg[MAXSTRLEN];
	sprintf(msg, "Unexpected primitive symbol type %d", sym);
	internal_error(msg); return(NULL);
    }
    }
}

vl_term *sensitive_control(FILE *file, st_table *sensitive_list)
{
    vl_term *retval;
    st_generator *gen;
    char *key, *dummy;
    vl_id_range *id_sym;
    int i, j;
    int lo, hi;
    int ithItem;

    retval = new_term(NIL(vl_range), 0, -1);
    fprintf(file, ".names ");
    ithItem = 0;
    gen = st_init_gen(sensitive_list);
    while (st_gen(gen, &key, &dummy)) {
	if (!st_lookup(vl_currentModule->sig_st, key, (char**)&id_sym)) {
	    char buf[MAXSTRLEN];

	    sprintf(buf, "sensitive var:%s is not defined in module %s",
		    key, vl_currentModule->name->name);
	    semantic_error(buf);
	}

	get_hilo(id_sym, &hi, &lo);
	if (lo < hi || id_sym->range) {
	    char buf[MAXSTRLEN];

	    sprintf(buf, "%s is vector/array while as sensitive var in %s",
		    key, vl_currentModule->name->name);
	    semantic_error(buf);
	}

	fprintf(file, "%s ", key);
    }
    st_free_gen(gen);
    fprintf(file, "%s\n", retval->name->name);

    for (i=0; i<st_count(sensitive_list); i++) {
	for (j=0; j<st_count(sensitive_list); j++)
	    fprintf(file, "%c ", (i==j)?'1':'-');
	fprintf(file, "1\n");
    }
    for (i=0; i<st_count(sensitive_list); i++)
	fprintf(file, "0 ");
    fprintf(file, "0\n");

    return retval;
}


void patch_unaffected_term(FILE *file, vl_id_range *id_sym,
			   vl_term *orig_term,
			   vl_term *out_term)
{
    int i;
    int set_floating = 0;

    if (orig_term->lo == out_term->lo && orig_term->hi == out_term->hi)
	return;
    if (orig_term->lo >= orig_term->hi && out_term->lo >= out_term->hi)
	return;

    if (vl_currentFunction)
	if (!strcmp(id_sym->name, orig_term->name->name))
	    set_floating = 1;

    if (set_floating) {
	for (i=orig_term->lo; i<out_term->lo; i++) {
	    fprintf(file, ".names %s%s%d%s\n-\n",
		    out_term->name->name,
		    SEP_LBITSELECT, i, SEP_RBITSELECT);
	}

	for (i=out_term->hi+1; i<=orig_term->hi; i++) {
	    fprintf(file, ".names %s%s%d%s\n-\n",
		    out_term->name->name,
		    SEP_LBITSELECT, i, SEP_RBITSELECT);
	}
    } else {

	for (i=orig_term->lo; i<out_term->lo; i++) {
	    if (set_notation) {
		fprintf(file,".names %s%s%d%s %s%s%d%s\n- %s%s%s%d%s\n",
			orig_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT,
			out_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT,
			HSIS_EQUAL,
			orig_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
	    } else {
		fprintf(file, ".names %s%s%d%s %s%s%d%s\n1 1\n0 0\n",
			orig_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT,
			out_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
	    }
	}

	for (i=out_term->hi+1; i<=orig_term->hi; i++) {
	    if (set_notation) {
		fprintf(file,".names %s%s%d%s %s%s%d%s\n- %s%s%s%d%s\n",
			orig_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT,
			out_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT,
			HSIS_EQUAL,
			orig_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
	    } else {
		fprintf(file, ".names %s%s%d%s %s%s%d%s\n1 1\n0 0\n",
			orig_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT,
			out_term->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
	    }
	}
    }

    out_term->lo = orig_term->lo;
    out_term->hi = orig_term->hi;
}

int need_edge_detector(lsList table_entries, int ith_port)
{
    int retval=0;
    lsGen gen;
    lsHandle handle;
    vl_prim_entry *e;

    for (gen=lsStart(table_entries);
	 lsNext(gen, (lsGeneric*)&e, &handle) != LS_NOMORE; ) {
	register unsigned char sym;
	sym = e->inputs[ith_port];
	if (IS_TRANSITION(sym)) {
	    retval = 1;
	    break;
	}
    }
    (void)lsFinish(gen);

    return retval;
}


void dump_debug_information(FILE *file, vl_id_range *id_var,
			    vl_term *current_term, int lineno,
			    lsList ctrl_list, char *ctrl_syndrome)
{
    lsGen gen;
    lsHandle handle;
    vl_term *ctrl;
    int i;
    char *Comment;

    Comment = HSIS_COMMENT;
    if (debug_mode) {
	if (lineno >= 0) {
	    fprintf(file, "%s%sl %d%s%s\n",
		    Comment, Comment,
		    lineno,
		    Comment, Comment);
	}
	fprintf(file, "%s%sv %s.%s%s%s\n",
		Comment, Comment,
		vl_currentModule->name->name, id_var->name,
		Comment, Comment);
	for (i=0, gen=lsStart(ctrl_list);
	     lsNext(gen, (lsGeneric*)&ctrl, &handle)!=LS_NOMORE; i++) {
	    if (ctrl_syndrome[i] == '-') continue;
	    if (ctrl_syndrome[i] == '1')
		fprintf(file, "%s%sg %s%s%s\n",
			Comment, Comment,
			ctrl->name->name,
			Comment, Comment);
	    if (ctrl_syndrome[i] == '0')
		fprintf(file, "%s%sG %s%s%s\n",
			Comment, Comment,
			ctrl->name->name,
			Comment, Comment);
	}
	lsFinish(gen);
    }

    current_term = current_term;
}


int vector_width(int lo, int hi)
{
    if (lo > hi) return 1;
    return hi - lo + 1;
}


void expand_term(FILE *file, vl_term *in, vl_term *out)
{
    int i;
    char in_buf[MAXSTRLEN], out_buf[MAXSTRLEN];
    lsList args;

    assert(vector_width(in->lo, in->hi) <= vector_width(out->lo, out->hi));

    if (vector_width(in->lo, in->hi) == vector_width(out->lo, out->hi)) {
	vl_write_bin_connect(file, in, out, 0);
    } else {
	char buf[MAXSTRLEN];
	args = lsCreate();
	sprintf(buf, "%d", in->hi-in->lo+1);
	lsNewEnd(args, (lsGeneric)vlStrdup(buf), 0);
	sprintf(buf, "%d", out->hi-out->lo+1);
	lsNewEnd(args, (lsGeneric)vlStrdup(buf), 0);

	for (i=out->lo; i<=out->hi; i++) {
	    if (in->lo > in->hi) {
		sprintf(out_buf, "%s%s%d%s", out->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
		sprintf(in_buf, "%s",
			(i==out->lo)?in->name->name:WRT_BLIF_GND(file));
		if (set_notation) {
		    fprintf(file, ".names %s %s\n- =%s\n",
			    in_buf, out_buf, in_buf);
		} else {
		    vl_write_bit_connect(file, in_buf, out_buf, 0);
		}
	    } else {
		sprintf(out_buf, "%s%s%d%s", out->name->name,
			SEP_LBITSELECT, i, SEP_RBITSELECT);
		if (i-out->lo <= in->hi-in->lo)
		    sprintf(in_buf, "%s%s%d%s", in->name->name,
			    SEP_LBITSELECT, i+in->lo-out->lo, SEP_RBITSELECT);
		else
		    sprintf(in_buf, "%s", WRT_BLIF_GND(file));
		if (set_notation) {
		    fprintf(file, ".names %s %s\n- =%s\n",
			    in_buf, out_buf, in_buf);
		} else {
		    vl_write_bit_connect(file, in_buf, out_buf, 0);
		}
	    }
	}

	lsDestroy(args, vl_chk_free);
    }
}

void shrink_term(FILE *file, vl_term *in, vl_term *out)
{
    int i;
    char in_buf[MAXSTRLEN], out_buf[MAXSTRLEN];
    lsList args;

    assert(vector_width(in->lo, in->hi) >= vector_width(out->lo, out->hi));

    if (vector_width(in->lo, in->hi) == vector_width(out->lo, out->hi)) {
	vl_write_bin_connect(file, in, out, 0);
    } else {
	char buf[MAXSTRLEN];
	args = lsCreate();
	sprintf(buf, "%d", in->hi-in->lo+1);
	lsNewEnd(args, (lsGeneric)vlStrdup(buf), 0);
	sprintf(buf, "%d", out->hi-out->lo+1);
	lsNewEnd(args, (lsGeneric)vlStrdup(buf), 0);

	for (i=in->lo; i<=in->hi; i++) {
	    if (out->lo > out->hi) {
		if (i == in->lo) {
		    sprintf(out_buf, "%s", out->name->name);
		    sprintf(in_buf, "%s%s%d%s", in->name->name,
			    SEP_LARRAY, i, SEP_RARRAY);
		    if (set_notation) {
			fprintf(file, ".names %s %s\n- =%s\n",
				in_buf, out_buf, in_buf);
		    } else {
			vl_write_bit_connect(file, in_buf, out_buf, 0);
		    }
		}
	    } else {
		if (i-in->lo <= out->hi-out->lo) {
		    sprintf(out_buf, "%s%s%d%s", out->name->name,
			    SEP_LBITSELECT,i+in->lo-out->lo,SEP_RBITSELECT);
		    sprintf(in_buf, "%s%s%d%s", in->name->name,
			    SEP_LBITSELECT, i, SEP_RBITSELECT);
		    if (set_notation) {
			fprintf(file, ".names %s %s\n- =%s\n",
				in_buf, out_buf, in_buf);
		    } else {
			vl_write_bit_connect(file, in_buf, out_buf, 0);
		    }
		}
	    }
	}

	lsDestroy(args, vl_chk_free);
    }
}


void subrange_term(FILE *file, vl_term *in, vl_term *out)
{
}


vl_term *vl_write_nond_wire(FILE *file, vl_term *ctrl_term, lsList nond_list, vl_term *reference_term)
{
    vl_term *retval;
    vl_term *nond_term;
    vl_expr *nond_expr;
    lsHandle handle;
    lsGen gen;
    lsList domain;
    lsGen enum_gen;
    vl_enumerator *enum_elt;
    lsHandle enum_handle;
    lsList nond_consts, nond_terms;
    int num_terms, num_consts;
    int i, j, k, l;

    retval = typed_new_term(reference_term->term_type, NIL(vl_range),
			    reference_term->lo, reference_term->hi);
    if (vis_nond && rst_ckt) {
	char *cp;
	cp = (char*)chk_malloc(strlen(reference_term->name->name) +
			       strlen(retval->name->name) +
			       2*strlen(SEP_GATEPIN)+strlen(PIN_INITIAL)+1);
	sprintf(cp, "%s%s%s%s%s", reference_term->name->name, SEP_GATEPIN,
		PIN_INITIAL, SEP_GATEPIN, retval->name->name);
	retval->name->name = cp;
    }
    retval->flag = reference_term->flag;
    if (!vis_nond || rst_ckt)
	write_var_decl(file, retval);
    nond_consts = lsCreate();
    nond_terms = lsCreate();
    for (gen=lsStart(nond_list), num_terms=0, num_consts=0;
	 lsNext(gen, (lsGeneric*)&nond_expr, &handle) != LS_NOMORE; ) {
	if (ISVLCONST(nond_expr->type)) {

	    num_consts++;
	    lsNewEnd(nond_consts, (lsGeneric)nond_expr->u.intval, 0);
	} else {

	    num_terms++;
	    lsNewEnd(nond_terms, (lsGeneric)nond_expr->term, 0);
	}
    }
    (void)lsFinish(gen);


    fprintf(file, ".names ");
    for (gen=lsStart(nond_terms);
	 lsNext(gen, (lsGeneric*)&nond_term, &handle) != LS_NOMORE; ) {
	if (reference_term->lo > reference_term->hi ||
	    reference_term->flag & MVar)
	    if (nond_term->lo > nond_term->hi || reference_term->flag & MVar)
		fprintf(file, "%s ", nond_term->name->name);
	    else
		fprintf(file, "%s%s%d%s ", nond_term->name->name,
			SEP_LBITSELECT, nond_term->lo, SEP_RBITSELECT);
	else {
	    for (l=reference_term->lo; l<=reference_term->hi; l++)
		fprintf(file, "%s%s%d%s ", nond_term->name->name,
			SEP_LBITSELECT, l, SEP_RBITSELECT);
	}
    }
    (void)lsFinish(gen);
    if (reference_term->lo > reference_term->hi ||
	reference_term->flag & MVar)
	fprintf(file, "%s\n",
		nond_output(retval->name->name, reference_term->name->name));
    else {
	fprintf(file, "%s ", HSIS_ARROW);
	for (l=reference_term->lo; l<=reference_term->hi; l++)
	    fprintf(file, "%s%s%d%s ",
		    nond_output(retval->name->name,reference_term->name->name),
		    SEP_LBITSELECT, l, SEP_RBITSELECT);
	fprintf(file, "\n");
    }



    for (gen=lsStart(nond_consts);
	 lsNext(gen,(lsGeneric*)&k,&handle) != LS_NOMORE; ) {
	if (reference_term->lo > reference_term->hi ||
	    reference_term->flag & MVar)
	    for (j=0; j<num_terms; j++) fprintf(file, "- ");
	else
	    for (l=reference_term->lo; l<=reference_term->hi; l++)
		for (j=0; j<num_terms; j++) fprintf(file, "- ");

	if (reference_term->flag & MVar) {
	    domain = reference_term->term_type->specifier->u.enum_type->domain_list;
	    for (enum_gen = lsStart(domain), i=0;
		 lsNext(enum_gen, (lsGeneric*)&enum_elt, &enum_handle) !=
		     LS_NOMORE; i++)
		if (k == i) {
		    fprintf(file, "%s ", enum_elt->name);

		}
	    (void)lsFinish(enum_gen);
	} else {
	    if (reference_term->lo > reference_term->hi) {

		fprintf(file, "%d", k);
	    } else {

		for (l=reference_term->lo, j=k; l<=reference_term->hi;
		     l++, j >>= 1)
		    fprintf(file, "%d ", j & 0x1);
	    }
	}
	fprintf(file, "\n");
    }
    (void)lsFinish(gen);

    for (gen=lsStart(nond_terms), j=0;
	 lsNext(gen,(lsGeneric*)&nond_term,&handle) != LS_NOMORE; j++) {
	if (set_notation || reference_term->lo <= reference_term->hi) {


	    for (i=0; i<num_terms; i++)
		if (reference_term->lo > reference_term->hi ||
		    reference_term->flag & MVar)
		    fprintf(file, "- ");
		else {
		    for (l=reference_term->lo; l<=reference_term->hi; l++)
			fprintf(file, "- ");
		}

	    if (reference_term->lo > reference_term->hi ||
		reference_term->flag & MVar) {
		if (nond_term->lo > nond_term->hi)
		    fprintf(file, "%s%s\n", HSIS_EQUAL, nond_term->name->name);
		else
		    fprintf(file, "%s%s%s%d%s\n", HSIS_EQUAL,
			    nond_term->name->name,
			    SEP_LBITSELECT, nond_term->lo, SEP_RBITSELECT);
	    } else {
		for (l=reference_term->lo; l<=reference_term->hi; l++)
		    fprintf(file, "%s%s%s%d%s ", HSIS_EQUAL,
			    nond_term->name->name,
			    SEP_LBITSELECT,
			    nond_term->lo-reference_term->lo+l,
			    SEP_RBITSELECT);
		fprintf(file, "\n");
	    }

	} else {


	    if (reference_term->flag & MVar) {

		domain = reference_term->term_type->specifier->u.enum_type->domain_list;
		for (enum_gen=lsStart(domain);
		     lsNext(enum_gen, (lsGeneric*)&enum_elt,
			    &enum_handle) !=
			 LS_NOMORE; ) {
		    for (i=0; i<j; i++) fprintf(file, "- ");
		    fprintf(file, "%s ", enum_elt->name);
		    for (i++; i<num_terms; i++) fprintf(file, "- ");
		    fprintf(file, "%s\n", enum_elt->name);
		}
		(void)lsFinish(enum_gen);
	    } else {

	    }

	}
    }
    (void)lsFinish(gen);

    lsDestroy(nond_consts, 0);
    lsDestroy(nond_terms, 0);
    return retval;
}


void vl_get_minmax_delay(vl_delay *delay, vl_expr **min_delay, vl_expr **max_delay)
{
    lsGen gen;
    lsHandle handle;
    vl_expr *delayi;
    int i;

    if (!(delay->delay3 && !delay->delay2)) return;
    assert(lsLength((lsList)delay->delay1) == 2);

    *min_delay = *max_delay = NIL(vl_expr);
    for (gen=lsStart((lsList)delay->delay1), i=1;
	 lsNext(gen, (lsGeneric*)&delayi, &handle) != LS_NOMORE; i++) {
	if (i==1) *min_delay = delayi;
	else if (i==2) *max_delay = delayi;
	else break;
    }
    lsFinish(gen);
}


static int isTautology(lsList syndrome_expr_list)
{
    lsGen gen;
    lsHandle handle;
    syndrome_expr *se;
    unsigned int i;
    int unguarded = 0;

    for (gen = lsStart(syndrome_expr_list);
	 lsNext(gen, (lsGeneric*)&se, &handle) != LS_NOMORE; ) {
	unguarded = 1;
	for (i=0; i<strlen(se->syndrome); i++) {
	    if ((se->syndrome)[i] != '-') {
		unguarded = 0;
		break;
	    }
	}
	if (unguarded) break;
    }
    lsFinish(gen);

    return unguarded;
}



void write_case_tag_const(FILE *file, vl_term *selector,
			  vl_expr *tag_expr, st_table *vars)
{

    if (!tag_expr->term) {
	if (tag_expr->type == IntExpr || tag_expr->type == BitExpr ||
	    evaluable_expr(tag_expr)) {
	    tag_expr->term = typed_new_term(selector->name->id_type,
					NIL(vl_range),
					selector->lo, selector->hi);
	    write_var_decl(file, tag_expr->term);
	    write_int_connect(file, vl_eval_expr(tag_expr), tag_expr->term);
	} else if (tag_expr->type != IDExpr && tag_expr->type != ConcatExpr) {
	    vl_write_expr(file, tag_expr, vars);
	} else if (tag_expr->type == IDExpr) {
	    vl_id_range *sel_id_sym;
	    vl_enumerator *enum_elt;

	    if (!st_lookup(vl_currentModule->sig_st, selector->name->name,
			   (char**)&sel_id_sym)) {
		sel_id_sym = vl_copy_id_range(selector->name);
		if (selector->term_type)
		    sel_id_sym->id_type = selector->term_type;
		if (!strstr(selector->name->name, SEP_GATEPIN)) {
		    st_insert(vl_currentModule->sig_st,
			      vlStrdup(selector->name->name),
			      (char*)sel_id_sym);
		}
	    }
	    if (!sel_id_sym->id_type) {
		vl_write_expr(file, tag_expr, vars);
		return;
	    }

	    if (st_lookup(sel_id_sym->id_type->specifier->
			  u.enum_type->domain_st,
			  tag_expr->u.name->name,
			  (char**)&enum_elt)) {

		tag_expr->term = typed_new_term(selector->term_type,
					    NIL(vl_range),
					    selector->lo, selector->hi);
		tag_expr->term->flag = selector->flag;
		write_var_decl(file, tag_expr->term);
		tag_expr->type = IntExpr;
		tag_expr->u.intval = enum_elt->val;
		vl_write_const(file, tag_expr, tag_expr->term);
	    } else {
		char buf[MAXSTRLEN];

		sprintf(buf,"'%s':var '%s' should not be used as CASE-tag",
			vl_currentModule->name->name, tag_expr->u.name->name);
		semantic_error(buf);
	    }
	} else if (tag_expr->type == ConcatExpr) {
	    vl_write_expr(file, tag_expr, vars);
	}
    }
}


void width_unknown()
{
    char buf[MAXSTRLEN];

    sprintf(buf, "%s:you are giving me concatenation of something I can't determined the width", vl_currentModule->name->name);
    yylineno = -1;
    compile_error(buf);
}


vl_term *concate_assigns(array_t *assign_array)
{
    vl_term *retval;
    vl_term *ith_term;
    int n_bits;
    int i;

    n_bits=0;
    for (i=0; i<array_n(assign_array); i++) {
	ith_term = array_fetch(vl_term*, assign_array, i);
	if (ith_term->flag & MVar)
	    compile_error("boomer:concating symbolic variables");

	if (ith_term->hi < ith_term->lo) n_bits++;
	else n_bits += (ith_term->hi - ith_term->lo + 1);
    }

    retval = new_term(NIL(vl_range), 0, n_bits-1);

    return retval;
}


void connect_concat(FILE *file, vl_term *assign_term, array_t *lhs_array)
{
    int i;
    int old_lo, old_hi;
    int n_bits, bit_pos;
    vl_term *lhs_term;

    old_lo = assign_term->lo;
    old_hi = assign_term->hi;
    for (i=array_n(lhs_array)-1, bit_pos = assign_term->lo; i>=0; i--) {
	lhs_term = array_fetch(vl_term*, lhs_array, i);
	if (lhs_term->hi < lhs_term->lo) n_bits = 1;
	else n_bits = lhs_term->hi - lhs_term->lo + 1;
	assign_term->lo = bit_pos;
	assign_term->hi = assign_term->lo + n_bits - 1;
	vl_write_bin_connect(file, assign_term, lhs_term, 0);
	bit_pos += n_bits;
    }
    assign_term->lo = old_lo;
    assign_term->hi = old_hi;
}


fg_graph_info *get_assoc_lc_name(char *loc, char *lc_name)
{
    int location;
    lsGen ggen;
    lsHandle ghandle;
    graph_t *graph;
    fg_graph_info *retval=NIL(fg_graph_info);

    if (!loc) return retval;
    if (!lc_name) return retval;

    location = atoi(strstr(loc, FG_LLOC)+strlen(FG_LLOC));
    for(ggen=lsStart(vl_currentModule->flow_graphs);
	lsNext(ggen, (lsGeneric*)&graph, &ghandle) != LS_NOMORE; ) {
	if (location >= ((fg_graph_info*)graph->user_data)->pause_lo &&
	    location <  ((fg_graph_info*)graph->user_data)->pause_hi) {
	    sprintf(lc_name, "%s%06x",
		    FG_LC_PS, ((fg_graph_info*)graph->user_data)->fg_id);
	    retval = (fg_graph_info*)(graph->user_data);
	    break;
	}
    }
    lsFinish(ggen);

    return retval;
}


void write_out_port(FILE *file, vl_id_range *id_sym,
		    int m_hi, int m_lo, vl_expr *inst_expr,
		    st_table *auxSigST)
{
    if (inst_expr->type == IDExpr) {
	st_insert(vl_currentModule->sig_st, inst_expr->u.name->name,
		  (char*)vl_create_id_range(inst_expr->u.name->name,
					    NIL(vl_range)));
    }
    inst_expr->term = new_term(NIL(vl_range), m_lo, m_hi);
}


void vl_write_outport_connect(FILE *file, vl_expr *inst_expr)
{
    int rep=1;
    int i;
    int bitWidth;
    lsGen gen;
    lsHandle handle;
    vl_term *term_out;
    vl_expr *e;

    if (inst_expr->type != ConcatExpr) return;

    if (inst_expr->u.exprs.e2) {
	rep = vl_eval_expr(inst_expr->u.exprs.e2);
    }

    term_out = inst_expr->term;
    assert(term_out);
    term_out->hi = term_out->lo - 1;
    for (i=0; i<rep; i++) {
	for (gen=lsStart((lsList)(inst_expr->u.exprs.e1));
	     lsNext(gen, (lsGeneric*)&e, &handle) != LS_NOMORE; ) {
	    vl_write_expr(file, e, NIL(st_table));
	    assert(e->term);
	    bitWidth = (e->term->hi - e->term->lo+1);
	    bitWidth = (bitWidth>0) ? bitWidth : 1;
	    term_out->lo = term_out->hi + 1;
	    term_out->hi = term_out->lo + bitWidth - 1;
	    vl_write_bin_connect(file, term_out, e->term, 0);
	}
	lsFinish(gen);
    }
    term_out->lo = 0;
}


static int evaluable_expr(vl_expr *expr)
{
    int old_silent_err;
    int retval;

    old_silent_err = silent_err;
    silent_err = 1;
    Vlerrno = 0;

    vl_eval_expr(expr);

    retval = Vlerrno;
    silent_err = old_silent_err;
    return !retval;
}


void write_const_param(FILE *file, vl_expr *expr, vl_id_range *ival)
{
    int l, r;
    vl_expr *ce;

    if (expr->type == IDExpr) {

	l = 31; r = 0;
    } else {
	l = vl_eval_expr(expr->u.idrng->range->left);
	if (expr->u.idrng->range->right)
	    r = vl_eval_expr(expr->u.idrng->range->right);
	else
	    r = l;
    }

    expr->term = new_term(NIL(vl_range), 0, (l>r)?l:r);
    write_var_decl(file, expr->term);

    ce = vl_create_expr(IntExpr, (int)ival->mpg_master_exp, (double)0.0,
			NIL(void), NIL(void), NIL(void));
    vl_write_const(file, ce, expr->term);
    vl_chk_free((char*)ce);

    expr->term->hi = (l>r)?l:r;
    expr->term->lo = (l>r)?r:l;
}


void chkUndefPorts(vl_expr *expr, st_table *sig_st)
{
    char *dummy;

    if (implicitDeclare)
	if (sig_st)
	    if (expr->type == IDExpr)
		if (!st_lookup(vl_currentModule->sig_st, expr->u.name->name,
			       &dummy)) {
		    st_insert(sig_st, expr->u.name->name, 0);
		}
}


void record_pseudo_cntxt(FILE *file, int fg_id, st_table *pre_cond,
			 char *ctrl_syndrome,
			 char *rst_ctrl_syndrome, st_table *vars)
{
    vl_id_range *cntxt_idsym;
    vl_term *out_term, *new_out;

    cntxt_idsym = vl_create_id_range(cntxt_event, NIL(vl_range));
    cntxt_idsym->flags |= EventVar;
    st_insert(vl_currentModule->sig_st, cntxt_idsym->name, (char*)cntxt_idsym);

    out_term = new_term(NIL(vl_range), 0, -1);
    write_int_connect(file, 1, out_term);
    new_out = vl_copy_term(out_term);

    if (!rst_ckt) {
	lsNewEnd(cntxt_idsym->syndrome_expr_list,
		 (lsGeneric)create_syndrome_expr(vlStrdup(ctrl_syndrome),
						 new_out, pre_cond, fg_id),
		 0);
    } else {
	lsNewEnd(cntxt_idsym->rst_syndrome_expr_list,
		 (lsGeneric)create_syndrome_expr(vlStrdup(rst_ctrl_syndrome),
						 new_out, pre_cond, fg_id),
		 0);
    }




    st_insert(vars, cntxt_idsym->name,
	      (char*)create_var_info(vl_copy_id_range(cntxt_idsym), out_term));

    cntxt_event = NIL(char);
}


char *descape(char *str, char ch1, char ch2)
{
    static char retval[MAXSTRLEN];

    strcpy(retval, str);
    return retval;
}


char *triPort(char *name)
{
    static char retval[MAXSTRLEN];
    vl_id_range *id_sym;

    strcpy(retval, name);
    if (st_lookup(vl_currentModule->sig_st, name, (char**)&id_sym)) {
	if (Zconnection) {
	    if ((id_sym->flags & InPort) && (id_sym->flags & OutPort)) {
		strcat(retval, SEP_GATEPIN);  strcat(retval, PIN_INOUT);
	    }
	}
    }
    return retval;
}


static char *
nond_output(char *local_name, char *var_name)
{
    static char buf[MAXSTRLEN];
    char *cp;

    if (vis_nond && !rst_ckt) {
	sprintf(buf, var_name);
	if ((cp=strstr(buf, SEP_GATEPIN))) *cp = '\0';
	vis_nond_var = 1;
	return buf;
    } else {
	return local_name;
    }
}


void to_upper(char *str)
{
    int i;
    int len;

    len = strlen(str);
    for (i=0; i<len; i++)
	if (islower((int)(str[i])))
	    str[i] += ('A' - 'a');
}


char *
shift_mv_vars(char *inputs, int nval)
{
    static char buf[MAXSTRLEN];
    int len, i;
    char arg[MAXSTRLEN];
    char token[MAXSTRLEN];
    char *cp;
    int ith;

    buf[0] = '\0';
    len = strlen(inputs);
    for (cp=inputs, ith=0; cp<inputs+len; ith++) {
	i=0;
	while ((*cp == ' ' || *cp == '\t') && *cp != '\0') cp++;
	while ((*cp != ' ' && *cp != '\t') && *cp != '\0') {
	    token[i] = *cp;
	    cp++;  i++;
	}
	if (i > 0) {
	    token[i] = '\0';
	    if (ith == 0)
		sprintf(arg, " %s ", token);
	    else
		sprintf(arg, " , %s ", token);
	    strcat(buf, arg);
	}
    }

    return buf;
}