
/*  A Bison parser, made from ../behave/bvl_bcomp.yac  */

#define BVL_Y_BISON 1  /* Identify Bison output.  */

#define	_AND	258
#define	_BEGIN	259
#define	_END	260
#define	_EQSym	261
#define	_EXIT	262
#define	_FILE	263
#define	_GESym	264
#define	_GTSym	265
#define	_IN	266
#define	_INOUT	267
#define	_LABEL	268
#define	_LESym	269
#define	_LINKAGE	270
#define	_LTSym	271
#define	_NAND	272
#define	_NESym	273
#define	_NEXT	274
#define	_NOR	275
#define	_NOT	276
#define	_NULL	277
#define	_OR	278
#define	_OUT	279
#define	_XOR	280
#define	ABS	281
#define	ACCESS	282
#define	AFTER	283
#define	ALIAS	284
#define	ALL	285
#define	ARCHITECTURE	286
#define	ARRAY	287
#define	ASSERT	288
#define	ATTRIBUTE	289
#define	AbstractLit	290
#define	Ampersand	291
#define	Apostrophe	292
#define	Arrow	293
#define	BIT	294
#define	BIT_VECTOR	295
#define	BLOCK	296
#define	BODY	297
#define	BUFFER	298
#define	BUS	299
#define	Bar	300
#define	BasedInt	301
#define	BasedReal	302
#define	BitStringLit	303
#define	Box	304
#define	CASE	305
#define	COMPONENT	306
#define	CONFIGURATION	307
#define	CONSTANT	308
#define	CharacterLit	309
#define	Colon	310
#define	Comma	311
#define	DISCONNECT	312
#define	DOWNTO	313
#define	DecimalInt	314
#define	DecimalReal	315
#define	Dot	316
#define	DoubleStar	317
#define	ELSE	318
#define	ELSIF	319
#define	ENTITY	320
#define	ERROR	321
#define	FOR	322
#define	FUNCTION	323
#define	GENERATE	324
#define	GENERIC	325
#define	GUARDED	326
#define	IF	327
#define	IS	328
#define	Identifier	329
#define	LIBRARY	330
#define	LOOP	331
#define	LeftParen	332
#define	MAP	333
#define	MOD	334
#define	MUX_BIT	335
#define	MUX_VECTOR	336
#define	Minus	337
#define	NATURAL	338
#define	NATURAL_VECTOR	339
#define	NEW	340
#define	OF	341
#define	ON	342
#define	OPEN	343
#define	OTHERS	344
#define	PACKAGE	345
#define	PORT	346
#define	PROCEDURE	347
#define	PROCESS	348
#define	Plus	349
#define	RANGE	350
#define	RECORD	351
#define	REG_BIT	352
#define	REG_VECTOR	353
#define	REGISTER	354
#define	REM	355
#define	REPORT	356
#define	RETURN	357
#define	RightParen	358
#define	SELECT	359
#define	SEVERITY	360
#define	SIGNAL	361
#define	_STABLE	362
#define	SUBTYPE	363
#define	Semicolon	364
#define	Slash	365
#define	Star	366
#define	StringLit	367
#define	THEN	368
#define	TO	369
#define	TRANSPORT	370
#define	_TYPE	371
#define	UNITS	372
#define	UNTIL	373
#define	USE	374
#define	VARIABLE	375
#define	VarAsgn	376
#define	WAIT	377
#define	WARNING	378
#define	WHEN	379
#define	WHILE	380
#define	WITH	381
#define	WOR_BIT	382
#define	WOR_VECTOR	383

#line 12 "../behave/bvl_bcomp.yac"

#include <stdio.h>
#include MUT_H
#include LOG_H
#include BEH_H

#include "../util/bvl_utype.h"
#include "bvl_byacc.h"
#include "bvl_bedef.h"


#line 24 "../behave/bvl_bcomp.yac"
typedef union  {
	int		 valu;
	char		*text;
        bvl_ablstr       list;
	bvl_name	 name;
        struct g_type dble;
	} BVL_Y_STYPE;

#ifndef BVL_Y_LTYPE
typedef
  struct bvl_y_ltype
    {
      int timestamp;
      int first_line;
      int first_column;
      int last_line;
      int last_column;
      char *text;
   }
  bvl_y_ltype;

#define BVL_Y_LTYPE bvl_y_ltype
#endif

#include <stdio.h>

#ifndef __STDC__
#define const
#endif



#define	BVL_Y_FINAL		276
#define	BVL_Y_FLAG		-32768
#define	BVL_Y_NTBASE	129

#define BVL_Y_TRANSLATE(x) ((unsigned)(x) <= 383 ? bvl_y_translate[x] : 226)

static const short bvl_y_translate[] = {     0,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
     6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
    16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
    26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
    36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
    46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
    56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
    66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
    76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
    86,    87,    88,    89,    90,    91,    92,    93,    94,    95,
    96,    97,    98,    99,   100,   101,   102,   103,   104,   105,
   106,   107,   108,   109,   110,   111,   112,   113,   114,   115,
   116,   117,   118,   119,   120,   121,   122,   123,   124,   125,
   126,   127,   128
};

#if BVL_Y_DEBUG != 0
static const short bvl_y_prhs[] = {     0,
     0,     1,     5,     6,    16,    19,    20,    22,    28,    32,
    35,    36,    40,    47,    49,    52,    54,    56,    57,    63,
    64,    68,    70,    71,    73,    77,    81,    83,    85,    86,
    88,    94,    98,   101,   102,   106,   114,   116,   117,   119,
   120,   122,   124,   126,   127,   140,   143,   145,   146,   149,
   151,   153,   156,   164,   167,   175,   176,   178,   180,   182,
   183,   186,   188,   190,   192,   195,   196,   207,   209,   212,
   214,   217,   219,   222,   224,   226,   232,   239,   240,   246,
   247,   258,   259,   263,   267,   269,   271,   272,   276,   277,
   281,   283,   285,   287,   288,   291,   292,   295,   297,   299,
   301,   303,   305,   307,   309,   313,   317,   321,   325,   327,
   331,   335,   339,   343,   345,   349,   351,   353,   357,   359,
   361,   364,   366,   368,   370,   372,   374,   376,   378,   380,
   384,   386,   388,   390,   392,   397,   404,   408,   410,   412,
   414,   416,   418,   420,   422,   424,   426,   428,   430,   431,
   435,   436,   440,   441,   443,   444,   446,   450,   451,   453,
   454,   456,   458,   460,   463,   465,   467,   469,   471
};

#endif

static const short bvl_y_rhs[] = {    -1,
   130,   131,   155,     0,     0,    65,   218,    73,   132,   133,
   148,   225,   217,   224,     0,    65,     1,     0,     0,   134,
     0,    70,    77,   135,   223,   224,     0,    70,     1,   224,
     0,   137,   136,     0,     0,   136,   224,   137,     0,    53,
   210,    55,   209,   144,   138,     0,     1,     0,   121,   139,
     0,   222,     0,   140,     0,     0,    77,   143,   141,   142,
   223,     0,     0,   142,    56,   143,     0,   222,     0,     0,
   145,     0,    77,   146,   223,     0,   222,   147,   222,     0,
   114,     0,    58,     0,     0,   149,     0,    91,    77,   150,
   223,   224,     0,    91,     1,   224,     0,   152,   151,     0,
     0,   151,   224,   152,     0,   153,   210,    55,   154,   209,
   144,   163,     0,     1,     0,     0,   106,     0,     0,    11,
     0,    24,     0,    12,     0,     0,    31,    74,    86,   218,
    73,   156,   157,     4,   164,   225,   217,   224,     0,    31,
     1,     0,   158,     0,     0,   158,   159,     0,   162,     0,
   160,     0,     1,   224,     0,    53,    74,    55,   209,   144,
   161,   224,     0,   121,   202,     0,   106,   210,    55,   209,
   144,   163,   224,     0,     0,    99,     0,    44,     0,   165,
     0,     0,   165,   166,     0,   167,     0,   170,     0,   171,
     0,     1,   224,     0,     0,   220,    41,   214,     4,   168,
   169,   225,    41,   213,   224,     0,   165,     0,   220,   172,
     0,   172,     0,   220,   174,     0,   174,     0,   220,   176,
     0,   176,     0,   173,     0,    33,   190,   186,   187,   224,
     0,   219,    14,   216,   175,   180,   224,     0,     0,   175,
   180,   124,   190,    63,     0,     0,   126,   190,   177,   104,
   219,    14,   216,   179,   178,   224,     0,     0,   178,    56,
   179,     0,   180,   124,   182,     0,   181,     0,   190,     0,
     0,   185,   183,   184,     0,     0,   184,    45,   185,     0,
   202,     0,    89,     0,   204,     0,     0,   101,   188,     0,
     0,   105,   189,     0,   112,     0,    66,     0,   123,     0,
   191,     0,   192,     0,   193,     0,   194,     0,   195,     3,
   195,     0,   191,     3,   195,     0,   195,    23,   195,     0,
   192,    23,   195,     0,   195,     0,   195,    17,   195,     0,
   195,    20,   195,     0,   195,    25,   195,     0,   194,    25,
   195,     0,   196,     0,   196,   201,   196,     0,   197,     0,
   198,     0,   197,    36,   198,     0,   199,     0,   200,     0,
    21,   200,     0,   202,     0,   203,     0,   204,     0,     6,
     0,    18,     0,    54,     0,   112,     0,    48,     0,    77,
   190,   103,     0,   218,     0,   205,     0,   206,     0,   207,
     0,   218,    77,   222,   223,     0,   218,    77,   222,   147,
   222,   223,     0,   218,    37,   208,     0,   107,     0,    39,
     0,   127,     0,    80,     0,    40,     0,   128,     0,    81,
     0,    97,     0,    98,     0,    83,     0,    84,     0,     0,
    74,   211,   212,     0,     0,   212,    56,    74,     0,     0,
   221,     0,     0,   215,     0,    77,   190,   223,     0,     0,
    71,     0,     0,   218,     0,    74,     0,   204,     0,   221,
    55,     0,    74,     0,    35,     0,   103,     0,   109,     0,
     5,     0
};

#if BVL_Y_DEBUG != 0
static const short bvl_y_rline[] = { 0,
   220,   239,   290,   298,   306,   314,   315,   323,   328,   335,
   340,   341,   347,   370,   386,   391,   399,   403,   413,   417,
   418,   431,   436,   442,   447,   454,   472,   474,   479,   480,
   484,   489,   496,   501,   502,   508,   546,   563,   564,   568,
   570,   572,   574,   579,   589,   598,   604,   608,   609,   614,
   615,   616,   622,   643,   649,   691,   693,   695,   700,   704,
   705,   710,   711,   712,   713,   719,   732,   745,   749,   759,
   763,   770,   771,   778,   782,   786,   801,  1051,  1052,  1073,
  1080,  1310,  1312,  1319,  1334,  1339,  1344,  1347,  1351,  1352,
  1363,  1365,  1367,  1438,  1440,  1446,  1448,  1454,  1459,  1461,
  1466,  1468,  1470,  1472,  1477,  1481,  1488,  1492,  1499,  1501,
  1505,  1513,  1517,  1524,  1526,  1533,  1538,  1540,  1548,  1553,
  1555,  1561,  1567,  1569,  1664,  1666,  1671,  1673,  1675,  1680,
  1687,  1693,  1695,  1697,  1702,  1714,  1732,  1796,  1800,  1802,
  1804,  1806,  1808,  1810,  1812,  1814,  1816,  1818,  1823,  1826,
  1829,  1830,  1837,  1839,  1844,  1846,  1851,  1858,  1860,  1865,
  1867,  1872,  1877,  1882,  1891,  1896,  1901,  1906,  1911
};

static const char * const bvl_y_tname[] = {   "$","error","$illegal.","_AND","_BEGIN",
"_END","_EQSym","_EXIT","_FILE","_GESym","_GTSym","_IN","_INOUT","_LABEL","_LESym",
"_LINKAGE","_LTSym","_NAND","_NESym","_NEXT","_NOR","_NOT","_NULL","_OR","_OUT",
"_XOR","ABS","ACCESS","AFTER","ALIAS","ALL","ARCHITECTURE","ARRAY","ASSERT",
"ATTRIBUTE","AbstractLit","Ampersand","Apostrophe","Arrow","BIT","BIT_VECTOR",
"BLOCK","BODY","BUFFER","BUS","Bar","BasedInt","BasedReal","BitStringLit","Box",
"CASE","COMPONENT","CONFIGURATION","CONSTANT","CharacterLit","Colon","Comma",
"DISCONNECT","DOWNTO","DecimalInt","DecimalReal","Dot","DoubleStar","ELSE","ELSIF",
"ENTITY","ERROR","FOR","FUNCTION","GENERATE","GENERIC","GUARDED","IF","IS","Identifier",
"LIBRARY","LOOP","LeftParen","MAP","MOD","MUX_BIT","MUX_VECTOR","Minus","NATURAL",
"NATURAL_VECTOR","NEW","OF","ON","OPEN","OTHERS","PACKAGE","PORT","PROCEDURE",
"PROCESS","Plus","RANGE","RECORD","REG_BIT","REG_VECTOR","REGISTER","REM","REPORT",
"RETURN","RightParen","SELECT","SEVERITY","SIGNAL","_STABLE","SUBTYPE","Semicolon",
"Slash","Star","StringLit","THEN","TO","TRANSPORT","_TYPE","UNITS","UNTIL","USE",
"VARIABLE","VarAsgn","WAIT","WARNING","WHEN","WHILE","WITH","WOR_BIT","WOR_VECTOR",
"design_file","@1","entity_declaration","@2",".generic_clause.","generic_clause",
"formal_generic_list","...formal_generic_element..","formal_generic_element",
"generic_VarAsgn__expression","generic_expression","generic_aggregate","@3",
"...generic_element_association..","generic_element_association",".constraint.",
"constraint","range","direction",".port_clause.","port_clause","formal_port_list",
"...formal_port_element..","formal_port_element",".SIGNAL.",".mode.","architecture_body",
"@4","architecture_declarative_part","..block_declarative_item..","block_declarative_item",
"constant_declaration","constant_VarAsgn__expression","signal_declaration",".signal_kind.",
"architecture_statement_part","..concurrent_statement..","concurrent_statement",
"block_statement","@5","set_of_statements","concurrent_assertion_statement",
"concurrent_signal_assignment_statement","unlabeled_concurrent_assertion_statement",
"assertion_statement","unlabeled_conditional_signal_assignment","..waveform__WHEN__condition__ELSE..",
"unlabeled_selected_signal_assignment","@6","...waveform__WHEN__choices..","waveform__WHEN__choices",
"waveform","waveform_element","choices","@7","..Bar__choice..","choice",".REPORT__expression.",
".SEVERITY__expression.","report__message","severity__message","expression",
"relation..AND__relation..","relation..OR__relation..","relation.NAND_NOR__relation.",
"relation..XOR__relation..","relation","simple_expression",".sign.term..add_op__term..",
"term","factor","primary","relational_operator","literal","aggregate","name",
"indexed_name","slice_name","attribute_name","attribute_designator","type_mark",
"identifier_list","@8","...identifier..",".label.",".guard_expression.","guard_expression",
".GUARDED.",".simple_name.","simple_name","target","a_label","label","abstractlit",
"RightParen_ERR","Semicolon_ERR","END_ERR",""
};
#endif

static const short bvl_y_r1[] = {     0,
   130,   129,   132,   131,   131,   133,   133,   134,   134,   135,
   136,   136,   137,   137,   138,   139,   139,   141,   140,   142,
   142,   143,   144,   144,   145,   146,   147,   147,   148,   148,
   149,   149,   150,   151,   151,   152,   152,   153,   153,   154,
   154,   154,   154,   156,   155,   155,   157,   158,   158,   159,
   159,   159,   160,   161,   162,   163,   163,   163,   164,   165,
   165,   166,   166,   166,   166,   168,   167,   169,   170,   170,
   171,   171,   171,   171,   172,   173,   174,   175,   175,   177,
   176,   178,   178,   179,   180,   181,   183,   182,   184,   184,
   185,   185,   185,   186,   186,   187,   187,   188,   189,   189,
   190,   190,   190,   190,   191,   191,   192,   192,   193,   193,
   193,   194,   194,   195,   195,   196,   197,   197,   198,   199,
   199,   200,   200,   200,   201,   201,   202,   202,   202,   203,
   204,   204,   204,   204,   205,   206,   207,   208,   209,   209,
   209,   209,   209,   209,   209,   209,   209,   209,   211,   210,
   212,   212,   213,   213,   214,   214,   215,   216,   216,   217,
   217,   218,   219,   220,   221,   222,   223,   224,   225
};

static const short bvl_y_r2[] = {     0,
     0,     3,     0,     9,     2,     0,     1,     5,     3,     2,
     0,     3,     6,     1,     2,     1,     1,     0,     5,     0,
     3,     1,     0,     1,     3,     3,     1,     1,     0,     1,
     5,     3,     2,     0,     3,     7,     1,     0,     1,     0,
     1,     1,     1,     0,    12,     2,     1,     0,     2,     1,
     1,     2,     7,     2,     7,     0,     1,     1,     1,     0,
     2,     1,     1,     1,     2,     0,    10,     1,     2,     1,
     2,     1,     2,     1,     1,     5,     6,     0,     5,     0,
    10,     0,     3,     3,     1,     1,     0,     3,     0,     3,
     1,     1,     1,     0,     2,     0,     2,     1,     1,     1,
     1,     1,     1,     1,     3,     3,     3,     3,     1,     3,
     3,     3,     3,     1,     3,     1,     1,     3,     1,     1,
     2,     1,     1,     1,     1,     1,     1,     1,     1,     3,
     1,     1,     1,     1,     4,     6,     3,     1,     1,     1,
     1,     1,     1,     1,     1,     1,     1,     1,     0,     3,
     0,     3,     0,     1,     0,     1,     3,     0,     1,     0,
     1,     1,     1,     2,     1,     1,     1,     1,     1
};

static const short bvl_y_defact[] = {     1,
     0,     0,     0,     5,   162,     0,     0,     2,     3,    46,
     0,     6,     0,     0,    29,     7,     0,     0,     0,     0,
     0,    30,    44,   168,     9,    14,     0,     0,    11,     0,
     0,   169,   160,    48,   149,     0,   167,     0,    10,    32,
    37,    39,     0,    34,     0,     0,   161,     0,     0,   151,
     0,     8,     0,     0,    33,     0,     4,    60,     0,     0,
     0,    49,    51,    50,   150,   139,   142,   141,   144,   147,
   148,   145,   146,   140,   143,    23,    12,    31,     0,    40,
     0,     0,    52,     0,     0,     0,     0,     0,    24,    35,
    41,    43,    42,     0,   160,     0,     0,   162,     0,    61,
    62,    63,    64,    70,    75,    72,    74,   163,   132,   133,
   134,   131,     0,     0,     0,     0,     0,   152,   166,     0,
     0,     0,    13,    23,     0,    65,     0,   129,   127,     0,
   128,    94,   101,   102,   103,   104,   109,   114,   116,   117,
   119,   120,   122,   123,   124,    80,     0,     0,   158,   155,
    69,    71,    73,   164,    23,    23,    25,    28,    27,     0,
     0,    15,    17,    16,    56,    45,   121,     0,     0,    96,
     0,     0,     0,     0,     0,     0,     0,     0,   125,   126,
     0,     0,     0,   138,   137,     0,   159,    78,     0,     0,
   156,     0,    56,    26,    18,    22,    58,    57,    36,   130,
    98,    95,     0,     0,   106,   108,   113,   105,   110,   111,
   107,   112,   115,   118,     0,     0,   135,     0,     0,    66,
     0,     0,     0,    20,    99,   100,    97,    76,     0,     0,
     0,    85,    86,   157,    60,    54,    53,    55,     0,   158,
   136,     0,    77,     0,     0,     0,    19,     0,     0,     0,
    21,    82,     0,    79,   153,     0,     0,   165,     0,   154,
     0,    81,    92,    84,    87,    91,    93,    67,    83,    89,
    88,     0,    90,     0,     0,     0
};

static const short bvl_y_defgoto[] = {   274,
     1,     3,    12,    15,    16,    28,    39,    29,   123,   162,
   163,   224,   239,   195,    88,    89,   120,   160,    21,    22,
    43,    55,    44,    45,    94,     8,    34,    48,    49,    62,
    63,   222,    64,   199,    81,    82,   100,   101,   235,   245,
   102,   103,   104,   105,   106,   218,   107,   183,   256,   252,
   253,   232,   264,   270,   271,   265,   170,   204,   202,   227,
   233,   133,   134,   135,   136,   137,   138,   139,   140,   141,
   142,   181,   143,   144,   145,   109,   110,   111,   185,    76,
    36,    50,    65,   259,   190,   191,   188,    46,   112,   113,
   114,   115,   196,    38,    25,    33
};

static const short bvl_y_pact[] = {-32768,
   -12,    22,    16,-32768,-32768,   -24,    26,-32768,-32768,-32768,
   -36,   -10,     6,    13,   -35,-32768,     9,    -6,    41,    21,
   110,-32768,-32768,-32768,-32768,-32768,    42,    23,-32768,    -6,
     5,-32768,     6,-32768,-32768,    75,-32768,    -6,    -6,-32768,
-32768,-32768,    23,-32768,    42,    -6,-32768,   129,    14,-32768,
    25,-32768,    41,    -6,    -6,    80,-32768,-32768,    -6,    62,
    42,-32768,-32768,-32768,    86,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,    66,-32768,-32768,     5,    46,
   110,     2,-32768,    84,    90,    72,   112,    27,-32768,-32768,
-32768,-32768,-32768,    25,     6,    -6,     0,    94,     0,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,     7,   136,   -22,    96,    25,    25,-32768,-32768,    23,
   -26,    33,-32768,    66,    -6,-32768,   -15,-32768,-32768,     0,
-32768,    53,   153,   144,-32768,   143,   104,    83,   134,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,    64,   112,   101,    98,
-32768,-32768,-32768,-32768,    66,    66,-32768,-32768,-32768,   112,
   112,-32768,-32768,-32768,   -14,-32768,-32768,    70,    68,    71,
     0,     0,     0,     0,     0,     0,     0,     0,-32768,-32768,
     0,     0,    74,-32768,-32768,    11,-32768,-32768,     0,   177,
-32768,    61,   -14,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,   -40,    -6,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,     6,   112,-32768,     0,    23,-32768,
   -20,    -6,    -6,-32768,-32768,-32768,-32768,-32768,   169,    23,
   -63,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   -16,   101,
-32768,     0,-32768,    12,   110,   112,-32768,     0,   121,   145,
-32768,-32768,    63,-32768,   111,   -18,    45,-32768,    -6,-32768,
     0,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
   146,    45,-32768,   189,   190,-32768
};

static const short bvl_y_pgoto[] = {-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,   142,-32768,-32768,
-32768,-32768,-32768,   -50,   -83,-32768,-32768,    17,-32768,-32768,
-32768,-32768,   119,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,    15,-32768,   -33,-32768,-32768,-32768,-32768,
-32768,-32768,    85,-32768,    91,-32768,    92,-32768,-32768,   -61,
   -11,-32768,-32768,-32768,-32768,   -68,-32768,-32768,-32768,-32768,
   -87,-32768,-32768,-32768,-32768,   -13,    28,-32768,    29,-32768,
    87,-32768,  -140,-32768,   -78,-32768,-32768,-32768,-32768,    24,
    10,-32768,-32768,-32768,-32768,-32768,   -28,   115,    18,    -2,
-32768,   -39,   -85,   -42,   -30,   -76
};


#define	BVL_Y_LAST		229


static const short bvl_y_table[] = {    40,
    54,   121,    96,   108,    95,    41,   -59,    52,    53,   132,
    97,   146,    96,    18,    59,    57,   -68,   -47,   150,     6,
   127,    30,     4,    78,    79,   225,    10,   128,    83,   197,
    17,   158,   128,   129,    97,   108,   164,   261,   129,   246,
   165,    26,   168,   147,    97,    24,     7,   128,     9,    13,
    47,     5,     2,   129,    56,    20,    91,    92,     5,    14,
   242,   130,   186,    66,    67,   126,    60,   119,   158,    93,
    85,   192,   193,     5,   194,    98,   130,   157,   -38,     5,
   236,    23,   226,   148,   198,    98,    37,   159,   179,    19,
    24,   131,   128,    27,   166,     5,   131,    31,   129,    11,
   180,   219,    24,    99,    68,    69,   174,    70,    71,   161,
    42,   131,    47,    37,    32,    35,   266,   124,     5,    61,
   175,    72,    73,   176,   159,    37,   177,    99,   178,    51,
   230,   266,    58,   263,    80,    84,   108,    99,   116,   155,
   156,    86,    87,   217,   117,   118,   119,   122,  -165,   149,
   154,    74,    75,   169,   249,   171,   131,   205,   206,   207,
   208,   209,   210,   211,   212,   108,   172,   173,   250,   182,
   184,   187,   200,   228,   189,   203,   234,   215,   267,   201,
   220,   221,   240,   254,   258,   255,   257,   241,   275,   276,
   272,   237,   238,   267,    77,   251,   247,    90,   151,   269,
   243,   244,   216,   273,   152,   153,   231,   223,   213,   125,
   214,   248,   229,   167,     0,   260,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   262,     0,     0,   268
};

static const short bvl_y_check[] = {    30,
    43,    87,     1,    82,    81,     1,     5,    38,    39,    97,
    33,    99,     1,     1,     1,    46,     5,     4,    41,     2,
    21,     1,     1,    54,    55,    66,     1,    48,    59,    44,
    13,    58,    48,    54,    33,   114,   122,    56,    54,    56,
   124,     1,   130,    37,    33,   109,    31,    48,    73,    86,
    33,    74,    65,    54,    45,    91,    11,    12,    74,    70,
   124,    77,   148,    39,    40,    96,    53,    35,    58,    24,
    61,   155,   156,    74,   160,    74,    77,   120,    74,    74,
   221,    73,   123,    77,    99,    74,   103,   114,     6,    77,
   109,   112,    48,    53,   125,    74,   112,    77,    54,    74,
    18,   189,   109,   126,    80,    81,     3,    83,    84,    77,
   106,   112,    95,   103,     5,    74,   257,    94,    74,   106,
    17,    97,    98,    20,   114,   103,    23,   126,    25,    55,
   216,   272,     4,    89,    55,    74,   215,   126,    55,   116,
   117,    56,    77,   186,    55,    74,    35,   121,    55,    14,
    55,   127,   128,   101,   242,     3,   112,   171,   172,   173,
   174,   175,   176,   177,   178,   244,    23,    25,   245,    36,
   107,    71,   103,   204,    77,   105,   219,   104,   257,   112,
     4,   121,    14,    63,    74,    41,   124,   230,     0,     0,
    45,   222,   223,   272,    53,   246,   239,    79,   114,   261,
   231,   235,   186,   272,   114,   114,   218,   193,   181,    95,
   182,   240,   215,   127,    -1,   255,    -1,    -1,    -1,    -1,
    -1,    -1,    -1,    -1,    -1,   256,    -1,    -1,   259
};
/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
#line 3 "/labo/gnu/lib/bison.simple"

/* Skeleton output parser for bison,
   Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 1, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */


#ifndef alloca
#ifdef __GNUC__
#define alloca __builtin_alloca
#else /* not GNU C.  */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc)
#include <alloca.h>
#else /* not sparc */
#if defined (MSDOS) && !defined (__TURBOC__)
#include <malloc.h>
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
#include <malloc.h>
 #pragma alloca
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
#endif /* not sparc.  */
#endif /* not GNU C.  */
#endif /* alloca not defined.  */

/* This is the parser code that is written into each bison parser
  when the %semantic_parser declaration is not specified in the grammar.
  It was written by Richard Stallman by simplifying the hairy parser
  used when %semantic_parser is specified.  */

/* Note: there must be only one dollar sign in this file.
   It is replaced by the list of actions, each action
   as one case of the switch.  */

#define bvl_y_errok		(bvl_y_errstatus = 0)
#define bvl_y_clearin	(bvl_y_char = BVL_Y_EMPTY)
#define BVL_Y_EMPTY		-2
#define BVL_Y_EOF		0
#define BVL_Y_ACCEPT	return(0)
#define BVL_Y_ABORT 	return(1)
#define BVL_Y_ERROR		goto bvl_y_errlab1
/* Like BVL_Y_ERROR except do call bvl_y_error.
   This remains here temporarily to ease the
   transition to the new meaning of BVL_Y_ERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */
#define BVL_Y_FAIL		goto bvl_y_errlab
#define BVL_Y_RECOVERING()  (!!bvl_y_errstatus)
#define BVL_Y_BACKUP(token, value) \
do								\
  if (bvl_y_char == BVL_Y_EMPTY && bvl_y_len == 1)				\
    { bvl_y_char = (token), bvl_y_lval = (value);			\
      bvl_y_char1 = BVL_Y_TRANSLATE (bvl_y_char);				\
      BVL_Y_POPSTACK;						\
      goto bvl_y_backup;						\
    }								\
  else								\
    { bvl_y_error ("syntax error: cannot back up"); BVL_Y_ERROR; }	\
while (0)

#define BVL_Y_TERROR	1
#define BVL_Y_ERRCODE	256

#ifndef BVL_Y_PURE
#define BVL_Y_LEX		bvl_y_lex()
#endif

#ifdef BVL_Y_PURE
#ifdef BVL_Y_LSP_NEEDED
#define BVL_Y_LEX		bvl_y_lex(&bvl_y_lval, &bvl_y_lloc)
#else
#define BVL_Y_LEX		bvl_y_lex(&bvl_y_lval)
#endif
#endif

/* If nonreentrant, generate the variables here */

#ifndef BVL_Y_PURE

int	bvl_y_char;			/*  the lookahead symbol		*/
BVL_Y_STYPE	bvl_y_lval;			/*  the semantic value of the		*/
				/*  lookahead symbol			*/

#ifdef BVL_Y_LSP_NEEDED
BVL_Y_LTYPE bvl_y_lloc;			/*  location data for the lookahead	*/
				/*  symbol				*/
#endif

int bvl_y_nerrs;			/*  number of parse errors so far       */
#endif  /* not BVL_Y_PURE */

#if BVL_Y_DEBUG != 0
int bvl_y_debug;			/*  nonzero means print parse trace	*/
/* Since this is uninitialized, it does not stop multiple parsers
   from coexisting.  */
#endif

/*  BVL_Y_INITDEPTH indicates the initial size of the parser's stacks	*/

#ifndef	BVL_Y_INITDEPTH
#define BVL_Y_INITDEPTH 200
#endif

/*  BVL_Y_MAXDEPTH is the maximum size the stacks can grow to
    (effective only if the built-in stack extension method is used).  */

#if BVL_Y_MAXDEPTH == 0
#undef BVL_Y_MAXDEPTH
#endif

#ifndef BVL_Y_MAXDEPTH
#define BVL_Y_MAXDEPTH 10000
#endif

#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
#define __bvl_y__bcopy(FROM,TO,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
#else				/* not GNU C or C++ */
#ifndef __cplusplus

/* This is the most reliable way to avoid incompatibilities
   in available built-in functions on various systems.  */
static void
__bvl_y__bcopy (from, to, count)
     char *from;
     char *to;
     int count;
{
  register char *f = from;
  register char *t = to;
  register int i = count;

  while (i-- > 0)
    *t++ = *f++;
}

#else /* __cplusplus */

/* This is the most reliable way to avoid incompatibilities
   in available built-in functions on various systems.  */
static void
__bvl_y__bcopy (char *from, char *to, int count)
{
  register char *f = from;
  register char *t = to;
  register int i = count;

  while (i-- > 0)
    *t++ = *f++;
}

#endif
#endif

#line 169 "/labo/gnu/lib/bison.simple"
int
bvl_y_parse()
{
  register int bvl_y_state;
  register int bvl_y_n;
  register short *bvl_y_ssp;
  register BVL_Y_STYPE *bvl_y_vsp;
  int bvl_y_errstatus;	/*  number of tokens to shift before error messages enabled */
  int bvl_y_char1;		/*  lookahead token as an internal (translated) token number */

  short	bvl_y_ssa[BVL_Y_INITDEPTH];	/*  the state stack			*/
  BVL_Y_STYPE bvl_y_vsa[BVL_Y_INITDEPTH];	/*  the semantic value stack		*/

  short *bvl_y_ss = bvl_y_ssa;		/*  refer to the stacks thru separate pointers */
  BVL_Y_STYPE *bvl_y_vs = bvl_y_vsa;	/*  to allow bvl_y_overflow to reallocate them elsewhere */

#ifdef BVL_Y_LSP_NEEDED
  BVL_Y_LTYPE bvl_y_lsa[BVL_Y_INITDEPTH];	/*  the location stack			*/
  BVL_Y_LTYPE *bvl_y_ls = bvl_y_lsa;
  BVL_Y_LTYPE *bvl_y_lsp;

#define BVL_Y_POPSTACK   (bvl_y_vsp--, bvl_y_ssp--, bvl_y_lsp--)
#else
#define BVL_Y_POPSTACK   (bvl_y_vsp--, bvl_y_ssp--)
#endif

  int bvl_y_stacksize = BVL_Y_INITDEPTH;

#ifdef BVL_Y_PURE
  int bvl_y_char;
  BVL_Y_STYPE bvl_y_lval;
  int bvl_y_nerrs;
#ifdef BVL_Y_LSP_NEEDED
  BVL_Y_LTYPE bvl_y_lloc;
#endif
#endif

  BVL_Y_STYPE bvl_y_val;		/*  the variable used to return		*/
				/*  semantic values from the action	*/
				/*  routines				*/

  int bvl_y_len;

#if BVL_Y_DEBUG != 0
  if (bvl_y_debug)
    fprintf(stderr, "Starting parse\n");
#endif

  bvl_y_state = 0;
  bvl_y_errstatus = 0;
  bvl_y_nerrs = 0;
  bvl_y_char = BVL_Y_EMPTY;		/* Cause a token to be read.  */

  /* Initialize stack pointers.
     Waste one element of value and location stack
     so that they stay on the same level as the state stack.
     The wasted elements are never initialized.  */

  bvl_y_ssp = bvl_y_ss - 1;
  bvl_y_vsp = bvl_y_vs;
#ifdef BVL_Y_LSP_NEEDED
  bvl_y_lsp = bvl_y_ls;
#endif

/* Push a new state, which is found in  bvl_y_state  .  */
/* In all cases, when you get here, the value and location stacks
   have just been pushed. so pushing a state here evens the stacks.  */
bvl_y_newstate:

  *++bvl_y_ssp = bvl_y_state;

  if (bvl_y_ssp >= bvl_y_ss + bvl_y_stacksize - 1)
    {
      /* Give user a chance to reallocate the stack */
      /* Use copies of these so that the &'s don't force the real ones into memory. */
      BVL_Y_STYPE *bvl_y_vs1 = bvl_y_vs;
      short *bvl_y_ss1 = bvl_y_ss;
#ifdef BVL_Y_LSP_NEEDED
      BVL_Y_LTYPE *bvl_y_ls1 = bvl_y_ls;
#endif

      /* Get the current used size of the three stacks, in elements.  */
      int size = bvl_y_ssp - bvl_y_ss + 1;

#ifdef bvl_y_overflow
      /* Each stack pointer address is followed by the size of
	 the data in use in that stack, in bytes.  */
      bvl_y_overflow("parser stack overflow",
		 &bvl_y_ss1, size * sizeof (*bvl_y_ssp),
		 &bvl_y_vs1, size * sizeof (*bvl_y_vsp),
#ifdef BVL_Y_LSP_NEEDED
		 &bvl_y_ls1, size * sizeof (*bvl_y_lsp),
#endif
		 &bvl_y_stacksize);

      bvl_y_ss = bvl_y_ss1; bvl_y_vs = bvl_y_vs1;
#ifdef BVL_Y_LSP_NEEDED
      bvl_y_ls = bvl_y_ls1;
#endif
#else /* no bvl_y_overflow */
      /* Extend the stack our own way.  */
      if (bvl_y_stacksize >= BVL_Y_MAXDEPTH)
	{
	  bvl_y_error("parser stack overflow");
	  return 2;
	}
      bvl_y_stacksize *= 2;
      if (bvl_y_stacksize > BVL_Y_MAXDEPTH)
	bvl_y_stacksize = BVL_Y_MAXDEPTH;
      bvl_y_ss = (short *) alloca (bvl_y_stacksize * sizeof (*bvl_y_ssp));
      __bvl_y__bcopy ((char *)bvl_y_ss1, (char *)bvl_y_ss, size * sizeof (*bvl_y_ssp));
      bvl_y_vs = (BVL_Y_STYPE *) alloca (bvl_y_stacksize * sizeof (*bvl_y_vsp));
      __bvl_y__bcopy ((char *)bvl_y_vs1, (char *)bvl_y_vs, size * sizeof (*bvl_y_vsp));
#ifdef BVL_Y_LSP_NEEDED
      bvl_y_ls = (BVL_Y_LTYPE *) alloca (bvl_y_stacksize * sizeof (*bvl_y_lsp));
      __bvl_y__bcopy ((char *)bvl_y_ls1, (char *)bvl_y_ls, size * sizeof (*bvl_y_lsp));
#endif
#endif /* no bvl_y_overflow */

      bvl_y_ssp = bvl_y_ss + size - 1;
      bvl_y_vsp = bvl_y_vs + size - 1;
#ifdef BVL_Y_LSP_NEEDED
      bvl_y_lsp = bvl_y_ls + size - 1;
#endif

#if BVL_Y_DEBUG != 0
      if (bvl_y_debug)
	fprintf(stderr, "Stack size increased to %d\n", bvl_y_stacksize);
#endif

      if (bvl_y_ssp >= bvl_y_ss + bvl_y_stacksize - 1)
	BVL_Y_ABORT;
    }

#if BVL_Y_DEBUG != 0
  if (bvl_y_debug)
    fprintf(stderr, "Entering state %d\n", bvl_y_state);
#endif

  goto bvl_y_backup;
 bvl_y_backup:

/* Do appropriate processing given the current state.  */
/* Read a lookahead token if we need one and don't already have one.  */
/* bvl_y_resume: */

  /* First try to decide what to do without reference to lookahead token.  */

  bvl_y_n = bvl_y_pact[bvl_y_state];
  if (bvl_y_n == BVL_Y_FLAG)
    goto bvl_y_default;

  /* Not known => get a lookahead token if don't already have one.  */

  /* bvl_y_char is either BVL_Y_EMPTY or BVL_Y_EOF
     or a valid token in external form.  */

  if (bvl_y_char == BVL_Y_EMPTY)
    {
#if BVL_Y_DEBUG != 0
      if (bvl_y_debug)
	fprintf(stderr, "Reading a token: ");
#endif
      bvl_y_char = BVL_Y_LEX;
    }

  /* Convert token to internal form (in bvl_y_char1) for indexing tables with */

  if (bvl_y_char <= 0)		/* This means end of input. */
    {
      bvl_y_char1 = 0;
      bvl_y_char = BVL_Y_EOF;		/* Don't call BVL_Y_LEX any more */

#if BVL_Y_DEBUG != 0
      if (bvl_y_debug)
	fprintf(stderr, "Now at end of input.\n");
#endif
    }
  else
    {
      bvl_y_char1 = BVL_Y_TRANSLATE(bvl_y_char);

#if BVL_Y_DEBUG != 0
      if (bvl_y_debug)
	{
	  fprintf (stderr, "Next token is %d (%s", bvl_y_char, bvl_y_tname[bvl_y_char1]);
	  /* Give the individual parser a way to print the precise meaning
	     of a token, for further debugging info.  */
#ifdef BVL_Y_PRINT
	  BVL_Y_PRINT (stderr, bvl_y_char, bvl_y_lval);
#endif
	  fprintf (stderr, ")\n");
	}
#endif
    }

  bvl_y_n += bvl_y_char1;
  if (bvl_y_n < 0 || bvl_y_n > BVL_Y_LAST || bvl_y_check[bvl_y_n] != bvl_y_char1)
    goto bvl_y_default;

  bvl_y_n = bvl_y_table[bvl_y_n];

  /* bvl_y_n is what to do for this token type in this state.
     Negative => reduce, -bvl_y_n is rule number.
     Positive => shift, bvl_y_n is new state.
       New state is final state => don't bother to shift,
       just return success.
     0, or most negative number => error.  */

  if (bvl_y_n < 0)
    {
      if (bvl_y_n == BVL_Y_FLAG)
	goto bvl_y_errlab;
      bvl_y_n = -bvl_y_n;
      goto bvl_y_reduce;
    }
  else if (bvl_y_n == 0)
    goto bvl_y_errlab;

  if (bvl_y_n == BVL_Y_FINAL)
    BVL_Y_ACCEPT;

  /* Shift the lookahead token.  */

#if BVL_Y_DEBUG != 0
  if (bvl_y_debug)
    fprintf(stderr, "Shifting token %d (%s), ", bvl_y_char, bvl_y_tname[bvl_y_char1]);
#endif

  /* Discard the token being shifted unless it is eof.  */
  if (bvl_y_char != BVL_Y_EOF)
    bvl_y_char = BVL_Y_EMPTY;

  *++bvl_y_vsp = bvl_y_lval;
#ifdef BVL_Y_LSP_NEEDED
  *++bvl_y_lsp = bvl_y_lloc;
#endif

  /* count tokens shifted since error; after three, turn off error status.  */
  if (bvl_y_errstatus) bvl_y_errstatus--;

  bvl_y_state = bvl_y_n;
  goto bvl_y_newstate;

/* Do the default action for the current state.  */
bvl_y_default:

  bvl_y_n = bvl_y_defact[bvl_y_state];
  if (bvl_y_n == 0)
    goto bvl_y_errlab;

/* Do a reduction.  bvl_y_n is the number of a rule to reduce with.  */
bvl_y_reduce:
  bvl_y_len = bvl_y_r2[bvl_y_n];
  bvl_y_val = bvl_y_vsp[1-bvl_y_len]; /* implement default value of the action */

#if BVL_Y_DEBUG != 0
  if (bvl_y_debug)
    {
      int i;

      fprintf (stderr, "Reducing via rule %d (line %d), ",
	       bvl_y_n, bvl_y_rline[bvl_y_n]);

      /* Print the symbols being reduced, and their result.  */
      for (i = bvl_y_prhs[bvl_y_n]; bvl_y_rhs[i] > 0; i++)
	fprintf (stderr, "%s ", bvl_y_tname[bvl_y_rhs[i]]);
      fprintf (stderr, " -> %s\n", bvl_y_tname[bvl_y_r1[bvl_y_n]]);
    }
#endif


  switch (bvl_y_n) {

case 1:
#line 221 "../behave/bvl_bcomp.yac"
{
		/* ###----------------------------------------------### */
		/*    Initializations					*/
		/*      - erroneous description presumed !		*/
		/* ###----------------------------------------------### */

		BVL_NM1LST = NULL;
		BVL_GRDLST = NULL;
		BVL_CNDLST = NULL;
		BVL_VALLST = NULL;
		BVL_ERRFLG = 0;

		hshtab             = initab ();
		BVL_BEFPNT         = beh_addbefig (BVL_HEDFIG,NULL);
		BVL_BEFPNT->ERRFLG = 1;
		BVL_HEDFIG         = BVL_BEFPNT;
		;
    break;}
case 2:
#line 240 "../behave/bvl_bcomp.yac"
{
		struct beout *beout_pnt;
		struct beaux *beaux_pnt;
		struct bebus *bebus_pnt;
		struct bereg *bereg_pnt;

		/* ###----------------------------------------------### */
		/*    Checking that each output have at least one driver*/
		/* ###----------------------------------------------### */

		beout_pnt = BVL_BEFPNT->BEOUT;
		while (beout_pnt != NULL)
		  {
		  if (beout_pnt->ABL == NULL)
		    bvl_error (40, beout_pnt->NAME);
		  beout_pnt = beout_pnt->NEXT;
		  }

		beaux_pnt = BVL_BEFPNT->BEAUX;
		while (beaux_pnt != NULL)
		  {
		  if (beaux_pnt->ABL == NULL)
		    bvl_error (40, beaux_pnt->NAME);
		  beaux_pnt = beaux_pnt->NEXT;
		  }

		bebus_pnt = BVL_BEFPNT->BEBUS;
		while (bebus_pnt != NULL)
		  {
		  if (bebus_pnt->BIABL == NULL)
		    bvl_error (40, bebus_pnt->NAME);
		  bebus_pnt = bebus_pnt->NEXT;
		  }

		bereg_pnt = BVL_BEFPNT->BEREG;
		while (bereg_pnt != NULL)
		  {
		  if (bereg_pnt->BIABL == NULL)
		    bvl_error (40,bereg_pnt->NAME);
		  bereg_pnt = bereg_pnt->NEXT;
		  }

		if (BVL_ERRFLG == 0)
		  BVL_BEFPNT->ERRFLG = 0;

		fretab (hshtab);
		;
    break;}
case 3:
#line 293 "../behave/bvl_bcomp.yac"
{
		BVL_BEFPNT->NAME = bvl_y_vsp[-1].text;
		BVL_MODNAM       = bvl_y_vsp[-1].text;
		;
    break;}
case 4:
#line 302 "../behave/bvl_bcomp.yac"
{
		if ((bvl_y_vsp[-1].text != NULL) && (bvl_y_vsp[-1].text != bvl_y_vsp[-7].text))
		  bvl_error (1,bvl_y_vsp[-1].text);
		;
    break;}
case 5:
#line 308 "../behave/bvl_bcomp.yac"
{
		bvl_error (2,NULL);
		;
    break;}
case 7:
#line 316 "../behave/bvl_bcomp.yac"
{
		BVL_BEFPNT->BEGEN = BVL_GENPNT;
		BVL_GENPNT = NULL;
		;
    break;}
case 9:
#line 331 "../behave/bvl_bcomp.yac"
{ bvl_error (74,NULL); ;
    break;}
case 13:
#line 353 "../behave/bvl_bcomp.yac"
{
		char *type;

		if (bvl_y_vsp[-1].name.FLAG == bvl_y_vsp[-2].dble.FLAG)
		  {
		  BVL_NM1LST = reverse (BVL_NM1LST);
		  type = namealloc ("natural");
		  BVL_GENPNT = bvl_addgen (BVL_GENPNT,BVL_INTLST,BVL_NM1LST,
		                           type,bvl_y_vsp[-1].name.LEFT,bvl_y_vsp[-1].name.RIGHT);
		  }
		else
		  bvl_error (33,NULL);
		freechain (BVL_NM1LST);
		freechain (BVL_INTLST);
		BVL_NM1LST = NULL;
		BVL_INTLST = NULL;
		;
    break;}
case 14:
#line 371 "../behave/bvl_bcomp.yac"
{
		/* ###----------------------------------------------### */
		/*   The following 3 lines reject tokens until the	*/
		/* sync. token 'Semicolon' is found			*/
		/* ###----------------------------------------------### */

		do
		  bvl_y_char = bvl_y_lex ();
		while ((bvl_y_char != Semicolon) && (bvl_y_char != 0));
		bvl_y_errok;
		bvl_error (75,NULL);
		;
    break;}
case 16:
#line 392 "../behave/bvl_bcomp.yac"
{
		long *ptlong;

		ptlong = (long *) mbkalloc (sizeof(long));
		*ptlong = bvl_y_vsp[0].valu;
		BVL_INTLST = addchain (BVL_INTLST,(void *)ptlong);
		;
    break;}
case 18:
#line 405 "../behave/bvl_bcomp.yac"
{
		long *ptlong;

		ptlong = (long *) mbkalloc (sizeof(long));
		*ptlong = bvl_y_vsp[0].valu;
		BVL_INTLST = addchain (BVL_INTLST,(void *)ptlong);
		;
    break;}
case 21:
#line 421 "../behave/bvl_bcomp.yac"
{
		long *ptlong;

		ptlong = (long *) mbkalloc (sizeof(long));
		*ptlong = bvl_y_vsp[0].valu;
		BVL_INTLST = addchain (BVL_INTLST,(void *)ptlong);
		;
    break;}
case 22:
#line 432 "../behave/bvl_bcomp.yac"
{bvl_y_val.valu = bvl_y_vsp[0].valu;;
    break;}
case 23:
#line 437 "../behave/bvl_bcomp.yac"
{
		bvl_y_val.name.FLAG  = 'S';
		bvl_y_val.name.LEFT  = -1;
		bvl_y_val.name.RIGHT = -1;
		;
    break;}
case 24:
#line 443 "../behave/bvl_bcomp.yac"
{ bvl_y_val.name = bvl_y_vsp[0].name; ;
    break;}
case 25:
#line 450 "../behave/bvl_bcomp.yac"
{ bvl_y_val.name = bvl_y_vsp[-1].name; ;
    break;}
case 26:
#line 457 "../behave/bvl_bcomp.yac"
{
		bvl_y_val.name.FLAG  = 'A';
		bvl_y_val.name.LEFT  = bvl_y_vsp[-2].valu;
		bvl_y_val.name.RIGHT = bvl_y_vsp[0].valu;

		if (((bvl_y_vsp[-2].valu > bvl_y_vsp[0].valu) && (bvl_y_vsp[-1].valu == BVL_UPTDFN)) ||
		    ((bvl_y_vsp[-2].valu < bvl_y_vsp[0].valu) && (bvl_y_vsp[-1].valu == BVL_DWTDFN)) ||
		    ((bvl_y_vsp[-2].valu < 0 ) || (bvl_y_vsp[-1].valu < 0 )))
		  {
		  bvl_error (32,NULL);
		  }
		;
    break;}
case 27:
#line 473 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = BVL_UPTDFN; ;
    break;}
case 28:
#line 475 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = BVL_DWTDFN; ;
    break;}
case 32:
#line 492 "../behave/bvl_bcomp.yac"
{ bvl_error (3,NULL); ;
    break;}
case 36:
#line 515 "../behave/bvl_bcomp.yac"
{
		char *signame;
		int   sigconf;
		void *pnt;

		/* ###----------------------------------------------### */
		/*    First, check the validity of the declaration.	*/
		/* Then, for each port, create the apropriate set of	*/
		/* structures (berin, bepor, beout, bebus)		*/
		/* ###----------------------------------------------### */

		chkdcl ('P', bvl_y_vsp[-3].valu, bvl_y_vsp[-2].dble.VALU, bvl_y_vsp[-2].dble.FLAG, bvl_y_vsp[0].valu, bvl_y_vsp[-1].name.FLAG, &sigconf);

		BVL_NM1LST = reverse (BVL_NM1LST);
		while (BVL_NM1LST != NULL)
		  {
		  signame = (char *)BVL_NM1LST->DATA;
		  if (chktab (hshtab,signame,BVL_MODNAM,BVL_SIGDFN) != 0)
		    bvl_error (4,signame);

		  pnt = addstr (BVL_BEFPNT,'P',bvl_y_vsp[-3].valu,bvl_y_vsp[-2].dble.VALU,bvl_y_vsp[-2].dble.FLAG,signame,
		                bvl_y_vsp[-1].name.LEFT,bvl_y_vsp[-1].name.RIGHT);

		  addtab (hshtab,signame,BVL_MODNAM,BVL_SIGDFN,sigconf);
		  addtab (hshtab,signame,BVL_MODNAM,BVL_WMNDFN,bvl_y_vsp[-1].name.LEFT);
		  addtab (hshtab,signame,BVL_MODNAM,BVL_WMXDFN,bvl_y_vsp[-1].name.RIGHT);
		  addtab (hshtab,signame,BVL_MODNAM,BVL_PNTDFN,(int)pnt);

		  BVL_NM1LST = delchain (BVL_NM1LST, BVL_NM1LST);
		  }
		;
    break;}
case 37:
#line 547 "../behave/bvl_bcomp.yac"
{
		/* ###----------------------------------------------### */
		/*   The following 3 lines reject tokens until the	*/
		/* sync. token 'Semicolon' is found			*/
		/* ###----------------------------------------------### */

		do
		  bvl_y_char = bvl_y_lex ();
		while ((bvl_y_char != Semicolon) && (bvl_y_char != 0));
		bvl_y_errok;

		bvl_error (6,NULL);
		;
    break;}
case 40:
#line 569 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = _IN; ;
    break;}
case 41:
#line 571 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = _IN; ;
    break;}
case 42:
#line 573 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = _OUT; ;
    break;}
case 43:
#line 575 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = _INOUT; ;
    break;}
case 44:
#line 584 "../behave/bvl_bcomp.yac"
{
		if (bvl_y_vsp[-1].text != BVL_MODNAM)
		  bvl_error (1,bvl_y_vsp[-1].text);
		;
    break;}
case 45:
#line 594 "../behave/bvl_bcomp.yac"
{
		if ((bvl_y_vsp[-1].text != NULL) && (bvl_y_vsp[-1].text != bvl_y_vsp[-10].text))
		  bvl_error (7,bvl_y_vsp[-1].text);
		;
    break;}
case 46:
#line 600 "../behave/bvl_bcomp.yac"
{ bvl_error (8,NULL); ;
    break;}
case 52:
#line 618 "../behave/bvl_bcomp.yac"
{ bvl_error (9,NULL); ;
    break;}
case 53:
#line 629 "../behave/bvl_bcomp.yac"
{
		int sigconf;
		
		if (chkdcl ('C',0,bvl_y_vsp[-3].dble.VALU,bvl_y_vsp[-3].dble.FLAG,0,bvl_y_vsp[-2].name.FLAG,&sigconf) == 0)
		  {
		  addtab (hshtab,bvl_y_vsp[-5].text,BVL_MODNAM,BVL_WMNDFN,bvl_y_vsp[-2].name.LEFT);
		  addtab (hshtab,bvl_y_vsp[-5].text,BVL_MODNAM,BVL_WMXDFN,bvl_y_vsp[-2].name.RIGHT);
		  addtab (hshtab,bvl_y_vsp[-5].text,BVL_MODNAM,BVL_SIGDFN,sigconf);
		  addtab (hshtab,bvl_y_vsp[-5].text,NULL,BVL_PNTDFN,bvl_y_vsp[-1].text);
		  }
		;
    break;}
case 54:
#line 645 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 55:
#line 656 "../behave/bvl_bcomp.yac"
{
		char *signame;
		int   sigconf;
		void *pnt;
		int   errflg;

		errflg = chkdcl ('S',0,bvl_y_vsp[-3].dble.VALU,bvl_y_vsp[-3].dble.FLAG,bvl_y_vsp[-1].valu,bvl_y_vsp[-2].name.FLAG,&sigconf);

		/* ###----------------------------------------------### */
		/*    First, check the validity of the declaration.	*/
		/* Then, for each signal, create the apropriate set of	*/
		/* structures (berin, bereg, beaux, bebux)		*/
		/* ###----------------------------------------------### */

		BVL_NM1LST = reverse (BVL_NM1LST);
		while (BVL_NM1LST != NULL)
		  {
		  signame = (char *)BVL_NM1LST->DATA;
		  if (chktab (hshtab,signame,BVL_MODNAM,BVL_SIGDFN) != 0)
		    bvl_error (10,signame);

		  pnt = addstr (BVL_BEFPNT,'S',0,bvl_y_vsp[-3].dble.VALU,bvl_y_vsp[-3].dble.FLAG,signame,
		                bvl_y_vsp[-2].name.LEFT,bvl_y_vsp[-2].name.RIGHT);

		  addtab (hshtab,signame,BVL_MODNAM,BVL_SIGDFN,sigconf);
		  addtab (hshtab,signame,BVL_MODNAM,BVL_WMNDFN,bvl_y_vsp[-2].name.LEFT);
		  addtab (hshtab,signame,BVL_MODNAM,BVL_WMXDFN,bvl_y_vsp[-2].name.RIGHT);
		  addtab (hshtab,signame,BVL_MODNAM,BVL_PNTDFN,(int)pnt);

		  BVL_NM1LST = delchain (BVL_NM1LST,BVL_NM1LST);
		  }
		;
    break;}
case 56:
#line 692 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = 0; ;
    break;}
case 57:
#line 694 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = REGISTER; ;
    break;}
case 58:
#line 696 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = BUS; ;
    break;}
case 65:
#line 715 "../behave/bvl_bcomp.yac"
{ bvl_error (18,NULL); ;
    break;}
case 66:
#line 723 "../behave/bvl_bcomp.yac"
{
		if (chktab (hshtab,bvl_y_vsp[-3].text,BVL_MODNAM,BVL_LBLDFN) != 0)
		  bvl_error (19,bvl_y_vsp[-3].text);

		addtab (hshtab,bvl_y_vsp[-3].text,BVL_MODNAM,BVL_LBLDFN,1);
		if (bvl_y_vsp[-1].text != NULL)
		  BVL_GRDLST = addchain (BVL_GRDLST,(char *)bvl_y_vsp[-1].text);
		;
    break;}
case 67:
#line 736 "../behave/bvl_bcomp.yac"
{
		if (bvl_y_vsp[-7].text != NULL)
		  BVL_GRDLST = delchain (BVL_GRDLST,BVL_GRDLST);
		if ((bvl_y_vsp[-1].text != NULL) && (bvl_y_vsp[-1].text != bvl_y_vsp[-9].text))
		  bvl_error (20,bvl_y_vsp[-1].text);
		;
    break;}
case 69:
#line 751 "../behave/bvl_bcomp.yac"
{
		if (chktab (hshtab,bvl_y_vsp[-1].text,BVL_MODNAM,BVL_LBLDFN) != 0)
		  bvl_error (19,bvl_y_vsp[-1].text);

		addtab (hshtab,bvl_y_vsp[-1].text,BVL_MODNAM,BVL_LBLDFN,1);
		if (BVL_ERRFLG == 0)
		  BVL_BEFPNT->BEMSG->LABEL = bvl_y_vsp[-1].text;
		;
    break;}
case 71:
#line 765 "../behave/bvl_bcomp.yac"
{
		if (chktab (hshtab,bvl_y_vsp[-1].text,BVL_MODNAM,BVL_LBLDFN) != 0)
		  bvl_error (19,bvl_y_vsp[-1].text);
		addtab (hshtab,bvl_y_vsp[-1].text,BVL_MODNAM,BVL_LBLDFN,1);
		;
    break;}
case 73:
#line 773 "../behave/bvl_bcomp.yac"
{
		if ( chktab (hshtab,bvl_y_vsp[-1].text,BVL_MODNAM,BVL_LBLDFN) != 0)
		  bvl_error (19,bvl_y_vsp[-1].text);
		addtab (hshtab,bvl_y_vsp[-1].text,BVL_MODNAM,BVL_LBLDFN,1);
		;
    break;}
case 76:
#line 791 "../behave/bvl_bcomp.yac"
{
		if (BVL_ERRFLG == 0)
		  {
		  BVL_BEFPNT->BEMSG = beh_addbemsg(BVL_BEFPNT->BEMSG,NULL,bvl_y_vsp[-1].valu,
		                                   bvl_y_vsp[-2].text,bvl_y_vsp[-3].list.LIST_ABL->DATA,NULL);
		  }
		;
    break;}
case 77:
#line 807 "../behave/bvl_bcomp.yac"
{
		int             i;
		struct beout   *beout_pnt;
		struct bebus   *bebus_pnt;
		struct bereg   *bereg_pnt;
		struct beaux   *beaux_pnt;
		struct bebux   *bebux_pnt;
		struct chain   *abl_pnt;
		struct bvl_expr expr0;
		struct bvl_expr expr1;
		struct bvl_expr expr2;
		struct bvl_expr expr3;
		struct bvl_expr expr4;
		struct bvl_expr expr5;
		struct bvl_expr expr6;
		int             rev_flg = 0;
		int             left_bnd;
		int             right_bnd;
		int             left;
		int             right;
		int             in_bound;
		int             out_bound;
		int             sig_width;
		int             sig_conf;

		expr4 = bvl_y_vsp[-1].list;

		while (BVL_CNDLST != NULL)
		  {
		  expr5 = *((bvl_ablstr *) BVL_CNDLST->DATA);
		  expr6 = *((bvl_ablstr *) BVL_VALLST->DATA);

		  expr0 = bvl_cpyablstr (expr5);
		  expr1 = bvl_crtabl (NOT , expr5, BVL_EMPSTR,-1,-1);
		  expr5 = expr0;
		  expr2 = bvl_crtabl (ANDM, expr4, expr1     ,-1,-1);
		  expr3 = bvl_crtabl (ANDM, expr6, expr5     ,-1,-1);
		  expr4 = bvl_crtabl (OR  , expr2, expr3     ,-1,-1);

		  BVL_CNDLST = delchain (BVL_CNDLST,BVL_CNDLST);
		  BVL_VALLST = delchain (BVL_VALLST,BVL_VALLST);
		  }

		left_bnd  = chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_WMNDFN);
		right_bnd = chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_WMXDFN);
		sig_conf  = chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_SIGDFN);

		left  = bvl_y_vsp[-5].name.LEFT;
		right = bvl_y_vsp[-5].name.RIGHT;

		if (left_bnd <= right_bnd)
		  {
		  sig_width = right_bnd - left_bnd + 1;
		  if (left <= right)
		    {
		    rev_flg   = 0;
		    in_bound  = right_bnd - right;
		    out_bound = right_bnd - left;
		    if ((left < left_bnd) || (right > right_bnd))
		      bvl_error (36,bvl_y_vsp[-5].name.NAME);
		    }
		  else
		    {
		    rev_flg   = 1;
		    in_bound  = right_bnd - left;
		    out_bound = right_bnd - right;
		    if ((left > right_bnd) || (right < left_bnd))
		      bvl_error (36,bvl_y_vsp[-5].name.NAME);
		    }
		  }
		else
		  {
		  sig_width = left_bnd - right_bnd + 1;
		  if (left <= right)
		    {
		    rev_flg   = 1;
		    in_bound  = left  - right_bnd;
		    out_bound = right - right_bnd;
		    if ((left < right_bnd) || (right > left_bnd))
		      bvl_error (36,bvl_y_vsp[-5].name.NAME);
		    }
		  else
		    {
		    rev_flg   = 0;
		    in_bound  = right - right_bnd;
		    out_bound = left  - right_bnd;
		    if ((left > left_bnd) || (right < right_bnd))
		      bvl_error (36,bvl_y_vsp[-5].name.NAME);
		    }
		  }

		if ((out_bound - in_bound + 1) != expr4.WIDTH)
		  bvl_error (35,bvl_y_vsp[-5].name.NAME);

		if (rev_flg == 1)
		  expr4.LIST_ABL = reverse (expr4.LIST_ABL);

		abl_pnt = expr4.LIST_ABL;

		switch (sig_conf)
		  {
		  case (BVL_ICNDFN + BVL_BITDFN + BVL_NORDFN) :
		    bvl_error (21,bvl_y_vsp[-5].name.NAME);
		    break;

		  case (BVL_OCNDFN + BVL_BITDFN + BVL_NORDFN) :
		  case (BVL_BCNDFN + BVL_BITDFN + BVL_NORDFN) :
		    if (bvl_y_vsp[-3].valu == BVL_GRDDFN)
		      bvl_error (22,bvl_y_vsp[-5].name.NAME);
		    beout_pnt = (struct beout *)
		                 chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_PNTDFN);
		    if (BVL_ERRFLG == 0)
		      {
		      for (i=0 ; i<sig_width ; i++)
		        {
		        if (i >= in_bound)
		          {
		          if (beout_pnt->ABL != NULL)
		            bvl_error (39,beout_pnt->NAME);
		          else
		            beout_pnt->ABL = (struct chain *)abl_pnt->DATA;
		          abl_pnt = abl_pnt->NEXT;
		          }
		        if (i >= out_bound)
		          break;
		        beout_pnt = beout_pnt->NEXT;
		        }
		      }
		    break;

		  case (BVL_OCNDFN + BVL_MUXDFN + BVL_BUSDFN) :
		  case (BVL_OCNDFN + BVL_WORDFN + BVL_BUSDFN) :
		  case (BVL_BCNDFN + BVL_MUXDFN + BVL_BUSDFN) :
		  case (BVL_BCNDFN + BVL_WORDFN + BVL_BUSDFN) :
		    if ((bvl_y_vsp[-3].valu != BVL_GRDDFN) || (BVL_GRDLST == NULL))
		      bvl_error (23,bvl_y_vsp[-5].name.NAME);
		    bebus_pnt = (struct bebus *)
		                 chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_PNTDFN);
		    if (BVL_ERRFLG == 0)
		      {
		      for (i=0 ; i<sig_width ; i++)
		        {
		        if (i >= in_bound)
		          {
		          bebus_pnt->BINODE = beh_addbinode (bebus_pnt->BINODE,
		                                             NULL,NULL);
		          bebus_pnt->BIABL  = beh_addbiabl  (bebus_pnt->BIABL,
		                                             BVL_LBLNAM,
		                                             copyExpr(BVL_GRDLST->DATA) ,
		                                             abl_pnt->DATA);
		          abl_pnt           = abl_pnt->NEXT;
		          }
		        if (i >= out_bound)
		          break;
		        bebus_pnt = bebus_pnt->NEXT;
		        }
		      }
		    break;

		  case (BVL_BITDFN + BVL_NORDFN):
		    if (bvl_y_vsp[-3].valu == BVL_GRDDFN)
		      bvl_error (22,bvl_y_vsp[-5].name.NAME);
		    beaux_pnt = (struct beaux *)
		                chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_PNTDFN);
		    if (BVL_ERRFLG == 0)
		      {
		      for (i=0 ; i<sig_width ; i++)
		        {
		        if (i >= in_bound)
		          {
		          if (beaux_pnt->ABL != NULL)
		            bvl_error (39,beaux_pnt->NAME);
		          else
		            beaux_pnt->ABL = (struct chain *)abl_pnt->DATA;
		          abl_pnt = abl_pnt->NEXT;
		          }
		        if (i >= out_bound)
		          break;
		        beaux_pnt = beaux_pnt->NEXT;
		        }
		      }
		    break;

		  case (BVL_RBIDFN + BVL_REGDFN):
		    if ((bvl_y_vsp[-3].valu != BVL_GRDDFN) || (BVL_GRDLST == NULL))
		      bvl_error (23,bvl_y_vsp[-5].name.NAME);
		    bereg_pnt = (struct bereg *)
		                chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_PNTDFN);
		    if (BVL_ERRFLG == 0)
		      {
		      for (i=0 ; i<sig_width ; i++)
		        {
		        if (i >= in_bound)
		          {
		          bereg_pnt->BINODE = beh_addbinode (bereg_pnt->BINODE,
		                                             NULL,NULL);
		          bereg_pnt->BIABL  = beh_addbiabl  (bereg_pnt->BIABL,
		                                             BVL_LBLNAM,
		                                             copyExpr(BVL_GRDLST->DATA) ,
		                                             abl_pnt->DATA);
		          abl_pnt           = abl_pnt->NEXT;
		          }
		        if (i >= out_bound)
		          break;
		        bereg_pnt = bereg_pnt->NEXT;
		        }
		      }
		    break;

		  case (BVL_MUXDFN + BVL_BUSDFN) :
		  case (BVL_WORDFN + BVL_BUSDFN) :
		    if ((bvl_y_vsp[-3].valu != BVL_GRDDFN) || (BVL_GRDLST == NULL))
		      bvl_error (23,bvl_y_vsp[-5].name.NAME);
		    bebux_pnt = (struct bebux *)
		                chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_PNTDFN);
		    if (BVL_ERRFLG == 0)
		      {
		      for (i=0 ; i<sig_width ; i++)
		        {
		        if (i >= in_bound)
		          {
		          bebux_pnt->BINODE = beh_addbinode (bebux_pnt->BINODE,
		                                             NULL,NULL);
		          bebux_pnt->BIABL  = beh_addbiabl  (bebux_pnt->BIABL,
		                                             BVL_LBLNAM,
		                                             copyExpr(BVL_GRDLST->DATA) ,
		                                             abl_pnt->DATA);
		          abl_pnt           = abl_pnt->NEXT;
		          }
		        if (i >= out_bound)
		          break;
		        bebux_pnt = bebux_pnt->NEXT;
		        }
		      }
		    break;

		  default :
		    bvl_error (17,bvl_y_vsp[-5].name.NAME);
		    break;
		  }
		;
    break;}
case 79:
#line 1057 "../behave/bvl_bcomp.yac"
{
		struct bvl_expr *expr_pnt;

		expr_pnt           = (bvl_ablstr *)mbkalloc(sizeof(bvl_ablstr));
		expr_pnt->WIDTH    = bvl_y_vsp[-1].list.WIDTH;
		expr_pnt->LIST_ABL = bvl_y_vsp[-1].list.LIST_ABL;
		BVL_CNDLST         = addchain (BVL_CNDLST,(char *) expr_pnt);

		expr_pnt           = (bvl_ablstr *)mbkalloc(sizeof(bvl_ablstr));
		expr_pnt->WIDTH    = bvl_y_vsp[-3].list.WIDTH;
		expr_pnt->LIST_ABL = bvl_y_vsp[-3].list.LIST_ABL;
		BVL_VALLST         = addchain (BVL_VALLST,(char *) expr_pnt);
		;
    break;}
case 80:
#line 1075 "../behave/bvl_bcomp.yac"
{
		BVL_SLCEXP = bvl_y_vsp[0].list;
		BVL_BDDPNT = NULL;
		;
    break;}
case 81:
#line 1086 "../behave/bvl_bcomp.yac"
{
		int             i;
		struct beout   *beout_pnt;
		struct bebus   *bebus_pnt;
		struct bereg   *bereg_pnt;
		struct beaux   *beaux_pnt;
		struct bebux   *bebux_pnt;
		struct chain   *abl_pnt;
		struct bvl_expr expr1;
		int             rev_flg = 0;
		int             left_bnd;
		int             right_bnd;
		int             left;
		int             right;
		int             in_bound;
		int             out_bound;
		int             sig_width;
		int             sig_conf;

		expr1 = bvl_crtabl (OR ,bvl_y_vsp[-2].list ,bvl_y_vsp[-1].list,-1,-1);
		if (BVL_BDDPNT != one)
		  bvl_error (25,NULL);
		left_bnd  = chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_WMNDFN);
		right_bnd = chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_WMXDFN);
		sig_conf  = chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_SIGDFN);

		left  = bvl_y_vsp[-5].name.LEFT;
		right = bvl_y_vsp[-5].name.RIGHT;
		if (left_bnd <= right_bnd)
		  {
		  sig_width = right_bnd - left_bnd + 1;
		  if (left <= right)
		    {
		    rev_flg   = 0;
		    in_bound  = right_bnd - right;
		    out_bound = right_bnd - left;
		    if ((left < left_bnd) || (right > right_bnd))
		      bvl_error (36,bvl_y_vsp[-5].name.NAME);
		    }
		  else
		    {
		    rev_flg   = 1;
		    in_bound  = right_bnd - left;
		    out_bound = right_bnd - right;
		    if ((left > right_bnd) || (right < left_bnd))
		      bvl_error (36,bvl_y_vsp[-5].name.NAME);
		    }
		  }
		else
		  {
		  sig_width = left_bnd - right_bnd + 1;
		  if (left <= right)
		    {
		    rev_flg   = 1;
		    in_bound  = left  - right_bnd;
		    out_bound = right - right_bnd;
		    if ((left < right_bnd) || (right > left_bnd))
		      bvl_error (36,bvl_y_vsp[-5].name.NAME);
		    }
		  else
		    {
		    rev_flg   = 0;
		    in_bound  = right - right_bnd;
		    out_bound = left  - right_bnd;
		    if ((left > left_bnd) || (right < right_bnd))
		      bvl_error (36,bvl_y_vsp[-5].name.NAME);
		    }
		  }

		if ((out_bound - in_bound + 1) != expr1.WIDTH)
		  bvl_error (35,bvl_y_vsp[-5].name.NAME);

		if (rev_flg == 1)
		  expr1.LIST_ABL = reverse (expr1.LIST_ABL);

		abl_pnt = expr1.LIST_ABL;

		switch (sig_conf)
		  {
		  case (BVL_ICNDFN + BVL_BITDFN + BVL_NORDFN) :
		    bvl_error (21,bvl_y_vsp[-5].name.NAME);
		    break;

		  case (BVL_OCNDFN + BVL_BITDFN + BVL_NORDFN) :
		  case (BVL_BCNDFN + BVL_BITDFN + BVL_NORDFN) :
		    if (bvl_y_vsp[-3].valu == BVL_GRDDFN)
		      bvl_error (22,bvl_y_vsp[-5].name.NAME);
		    beout_pnt = (struct beout *)
		                chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_PNTDFN);
		    if (BVL_ERRFLG == 0)
		      {
		      for (i=0 ; i<sig_width ; i++)
		        {
		        if (i >= in_bound)
		          {
		          if (beout_pnt->ABL != NULL)
		            bvl_error (39,beout_pnt->NAME);
		          else
		            beout_pnt->ABL = (struct chain *)abl_pnt->DATA;
		          abl_pnt = abl_pnt->NEXT;
		          }
		        if (i >= out_bound)
		          break;
		        beout_pnt = beout_pnt->NEXT;
		        }
		      }
		    break;

		  case (BVL_OCNDFN + BVL_MUXDFN + BVL_BUSDFN) :
		  case (BVL_OCNDFN + BVL_WORDFN + BVL_BUSDFN) :
		  case (BVL_BCNDFN + BVL_MUXDFN + BVL_BUSDFN) :
		  case (BVL_BCNDFN + BVL_WORDFN + BVL_BUSDFN) :
		    if ((bvl_y_vsp[-3].valu != BVL_GRDDFN) || (BVL_GRDLST == NULL))
		      bvl_error (23,bvl_y_vsp[-5].name.NAME);
		    bebus_pnt = (struct bebus *)
		                chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_PNTDFN);
		    if (BVL_ERRFLG == 0)
		      {
		      for (i=0 ; i<sig_width ; i++)
		        {
		        if (i >= in_bound)
		          {
		          bebus_pnt->BINODE = beh_addbinode (bebus_pnt->BINODE,
		                                             NULL,NULL);
		          bebus_pnt->BIABL  = beh_addbiabl  (bebus_pnt->BIABL,
		                                             BVL_LBLNAM,
		                                             copyExpr(BVL_GRDLST->DATA) ,
		                                             abl_pnt->DATA);
		          abl_pnt           = abl_pnt->NEXT;
		          }
		        if (i >= out_bound)
		          break;
		        bebus_pnt = bebus_pnt->NEXT;
		        }
		      }
		    break;

		  case (BVL_BITDFN + BVL_NORDFN):
		    if (bvl_y_vsp[-3].valu == BVL_GRDDFN)
		      bvl_error (22,bvl_y_vsp[-5].name.NAME);
		    beaux_pnt = (struct beaux *)
		                chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_PNTDFN);
		    if (BVL_ERRFLG == 0)
		      {
		      for (i=0 ; i<sig_width ; i++)
		        {
		        if (i >= in_bound)
		          {
		          if (beaux_pnt->ABL != NULL)
		            bvl_error (39,beaux_pnt->NAME);
		          else
		           {
		            beaux_pnt->ABL = (struct chain *)abl_pnt->DATA;
		            }
		          abl_pnt = abl_pnt->NEXT;
		          }
		        if (i >= out_bound)
		          break;
		        beaux_pnt = beaux_pnt->NEXT;
		        }
		      }
		    break;

		  case (BVL_RBIDFN + BVL_REGDFN):
		    if ((bvl_y_vsp[-3].valu != BVL_GRDDFN) || (BVL_GRDLST == NULL))
		      bvl_error (23,bvl_y_vsp[-5].name.NAME);
		    bereg_pnt = (struct bereg *)
		                chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_PNTDFN);
		    if (BVL_ERRFLG == 0)
		      {
		      for (i=0 ; i<sig_width ; i++)
		        {
		        if (i >= in_bound)
		          {
		          bereg_pnt->BINODE = beh_addbinode (bereg_pnt->BINODE,
		                                             NULL,NULL);
		          bereg_pnt->BIABL  = beh_addbiabl  (bereg_pnt->BIABL,
		                                             BVL_LBLNAM,
		                                             copyExpr(BVL_GRDLST->DATA) ,
		                                             abl_pnt->DATA);
		          abl_pnt           = abl_pnt->NEXT;
		          }
		        if (i >= out_bound)
		          break;
		        bereg_pnt = bereg_pnt->NEXT;
		        }
		      }
		    break;

		  case (BVL_MUXDFN + BVL_BUSDFN) :
		  case (BVL_WORDFN + BVL_BUSDFN) :
		    if ((bvl_y_vsp[-3].valu != BVL_GRDDFN) || (BVL_GRDLST == NULL))
		      bvl_error (23,bvl_y_vsp[-5].name.NAME);
		    bebux_pnt = (struct bebux *)
		                chktab (hshtab,bvl_y_vsp[-5].name.NAME,BVL_MODNAM,BVL_PNTDFN);
		    if (BVL_ERRFLG == 0)
		      {
		      for (i=0 ; i<sig_width ; i++)
		        {
		        if (i >= in_bound)
		          {
		          bebux_pnt->BINODE = beh_addbinode (bebux_pnt->BINODE,
		                                             NULL,NULL);
		          bebux_pnt->BIABL  = beh_addbiabl  (bebux_pnt->BIABL,
		                                             BVL_LBLNAM,
		                                             copyExpr(BVL_GRDLST->DATA) ,
		                                             abl_pnt->DATA);
		          abl_pnt           = abl_pnt->NEXT;
		          }
		        if (i >= out_bound)
		          break;
		        bebux_pnt = bebux_pnt->NEXT;
		        }
		      }
		    break;

		  default :
		    bvl_error (17,bvl_y_vsp[-5].name.NAME);
		    break;
		  }
		;
    break;}
case 82:
#line 1311 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = BVL_EMPSTR; ;
    break;}
case 83:
#line 1315 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (OR,bvl_y_vsp[-2].list,bvl_y_vsp[0].list,-1,-1); ;
    break;}
case 84:
#line 1322 "../behave/bvl_bcomp.yac"
{
		struct bvl_expr expr1;

		bvl_select (&expr1,BVL_NM1LST,&BVL_BDDPNT,BVL_SLCEXP);
		freechain (BVL_NM1LST);
		BVL_NM1LST = NULL;

		bvl_y_val.list = bvl_crtabl (ANDM,bvl_y_vsp[-2].list,expr1,-1,-1);
		;
    break;}
case 85:
#line 1335 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 86:
#line 1340 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 87:
#line 1345 "../behave/bvl_bcomp.yac"
{ BVL_NM1LST = addchain (NULL ,bvl_y_vsp[0].text); ;
    break;}
case 88:
#line 1347 "../behave/bvl_bcomp.yac"
{ bvl_y_errok; ;
    break;}
case 90:
#line 1355 "../behave/bvl_bcomp.yac"
{
		if (bvl_y_vsp[0].text == "others")
		  bvl_error (30,NULL);
		BVL_NM1LST = addchain (BVL_NM1LST ,bvl_y_vsp[0].text);
		;
    break;}
case 91:
#line 1364 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 92:
#line 1366 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = "others"; ;
    break;}
case 93:
#line 1368 "../behave/bvl_bcomp.yac"
{
		char           *val;
		char            val2[256];
		int             left;
		int             right;
		int             in_bound;
		int             out_bound;
		int             left_bnd;
		int             right_bnd;
		int             sig_conf;

		strcpy (val2,"B\"");
		sig_conf = chktab (hshtab,bvl_y_vsp[0].name.NAME,BVL_MODNAM,BVL_SIGDFN);
		val      = (char *) chktab (hshtab,bvl_y_vsp[0].name.NAME,NULL,BVL_PNTDFN);
		if (sig_conf == 0)
		  bvl_error (17,bvl_y_vsp[0].name.NAME);
		else
		  {
		  if (sig_conf != BVL_CSTDFN)
		    bvl_error (76,bvl_y_vsp[0].name.NAME);
		  }

		left_bnd  = chktab (hshtab,bvl_y_vsp[0].name.NAME,BVL_MODNAM,BVL_WMNDFN);
		right_bnd = chktab (hshtab,bvl_y_vsp[0].name.NAME,BVL_MODNAM,BVL_WMXDFN);

		left  = bvl_y_vsp[0].name.LEFT;
		right = bvl_y_vsp[0].name.RIGHT;

		if (left_bnd <= right_bnd)
		  {
		  if (left <= right)
		    {
		    in_bound = left - left_bnd;
		    out_bound = right - left_bnd;
		    if ((left < left_bnd) || (right > right_bnd))
		      bvl_error (36,bvl_y_vsp[0].name.NAME);
		    }
		  else
		    {
		    in_bound = left - right_bnd;
		    out_bound = right - right_bnd;
		    if ((left > right_bnd) || (right < left_bnd))
		      bvl_error (36,bvl_y_vsp[0].name.NAME);
		    }
		  }
		else
		  {
		  if (left <= right)
		    {
		    in_bound = right - left_bnd;
		    out_bound = left - left_bnd;
		    if ((left < right_bnd) || (right > left_bnd))
		      bvl_error (36,bvl_y_vsp[0].name.NAME);
		    }
		  else
		    {
		    in_bound = right - right_bnd;
		    out_bound = left - right_bnd;
		    if ((left > left_bnd) || (right < right_bnd))
		      bvl_error (36,bvl_y_vsp[0].name.NAME);
		    }
		  }

		bvl_tobin (&val2[2],val,in_bound,out_bound);
		strcat (val2,"\"");
		bvl_y_val.text = namealloc (val2);
		;
    break;}
case 94:
#line 1439 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = NULL; ;
    break;}
case 95:
#line 1442 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 96:
#line 1447 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = 'E'; ;
    break;}
case 97:
#line 1450 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = bvl_y_vsp[0].valu; ;
    break;}
case 98:
#line 1455 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 99:
#line 1460 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = 'E'; ;
    break;}
case 100:
#line 1462 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = 'W'; ;
    break;}
case 101:
#line 1467 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 102:
#line 1469 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 103:
#line 1471 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 104:
#line 1473 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 105:
#line 1480 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (AND ,bvl_y_vsp[-2].list ,bvl_y_vsp[0].list ,-1,-1); ;
    break;}
case 106:
#line 1484 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (AND ,bvl_y_vsp[-2].list ,bvl_y_vsp[0].list ,-1,-1); ;
    break;}
case 107:
#line 1491 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (OR ,bvl_y_vsp[-2].list ,bvl_y_vsp[0].list ,-1,-1); ;
    break;}
case 108:
#line 1495 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (OR ,bvl_y_vsp[-2].list ,bvl_y_vsp[0].list ,-1,-1); ;
    break;}
case 109:
#line 1500 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 110:
#line 1504 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (NAND ,bvl_y_vsp[-2].list ,bvl_y_vsp[0].list ,-1,-1); ;
    break;}
case 111:
#line 1508 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (NOR ,bvl_y_vsp[-2].list ,bvl_y_vsp[0].list ,-1,-1); ;
    break;}
case 112:
#line 1516 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (XOR ,bvl_y_vsp[-2].list ,bvl_y_vsp[0].list ,-1,-1); ;
    break;}
case 113:
#line 1520 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (XOR ,bvl_y_vsp[-2].list ,bvl_y_vsp[0].list ,-1,-1); ;
    break;}
case 114:
#line 1525 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 115:
#line 1529 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (bvl_y_vsp[-1].valu ,bvl_y_vsp[-2].list ,bvl_y_vsp[0].list ,-1,-1); ;
    break;}
case 116:
#line 1534 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 117:
#line 1539 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 118:
#line 1543 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (CONC,bvl_y_vsp[-2].list,bvl_y_vsp[0].list,-1,-1); ;
    break;}
case 119:
#line 1549 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 120:
#line 1554 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 121:
#line 1557 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_crtabl (NOT,bvl_y_vsp[0].list,BVL_EMPSTR,-1,-1); ;
    break;}
case 122:
#line 1562 "../behave/bvl_bcomp.yac"
{
		struct bvl_expr expr1;
		expr1.IDENT = bvl_y_vsp[0].text;
		bvl_y_val.list = bvl_crtabl (NOPS,expr1,BVL_EMPSTR,-1,-1);
		;
    break;}
case 123:
#line 1568 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[0].list; ;
    break;}
case 124:
#line 1570 "../behave/bvl_bcomp.yac"
{
		struct bvl_expr expr1;
		int             left;
		int             right;
		int             left_bnd;
		int             right_bnd;
		int             in_bound;
		int             out_bound;
		int             sig_conf;

		sig_conf = chktab (hshtab,bvl_y_vsp[0].name.NAME,BVL_MODNAM,BVL_SIGDFN);
		switch (sig_conf)
		  {
		  case (BVL_ICNDFN + BVL_BITDFN + BVL_NORDFN) :
		  case (BVL_BCNDFN + BVL_BITDFN + BVL_NORDFN) :
		  case (BVL_BCNDFN + BVL_MUXDFN + BVL_BUSDFN) :
		  case (BVL_BCNDFN + BVL_WORDFN + BVL_BUSDFN) :
		  case (BVL_BITDFN + BVL_NORDFN):
		  case (BVL_MUXDFN + BVL_BUSDFN):
		  case (BVL_WORDFN + BVL_BUSDFN):
		  case (BVL_RBIDFN + BVL_REGDFN):
		  case (BVL_CSTDFN):
		    break;
		  case (BVL_OCNDFN + BVL_BITDFN + BVL_NORDFN) :
		  case (BVL_OCNDFN + BVL_MUXDFN + BVL_BUSDFN) :
		  case (BVL_OCNDFN + BVL_WORDFN + BVL_BUSDFN) :
		    bvl_error (26,bvl_y_vsp[0].name.NAME);
		    break;
		  default :
		    bvl_error (17,bvl_y_vsp[0].name.NAME);
		    break;
		  }

		left_bnd  = chktab (hshtab,bvl_y_vsp[0].name.NAME,BVL_MODNAM,BVL_WMNDFN);
		right_bnd = chktab (hshtab,bvl_y_vsp[0].name.NAME,BVL_MODNAM,BVL_WMXDFN);

		left  = bvl_y_vsp[0].name.LEFT;
		right = bvl_y_vsp[0].name.RIGHT;

		if (left_bnd <= right_bnd)
		  {
		  if (left <= right)
		    {
		    in_bound  = left  - left_bnd;
		    out_bound = right - left_bnd;
		    if ((left < left_bnd) || (right > right_bnd))
		      bvl_error (36,bvl_y_vsp[0].name.NAME);
		    }
		  else
		    {
		    in_bound  = right - left_bnd;
		    out_bound = left  - left_bnd;
		    if ((left > right_bnd) || (right < left_bnd))
		      bvl_error (36,bvl_y_vsp[0].name.NAME);
		    }
		  }
		else
		  {
		  if (left <= right)
		    {
		    in_bound  = left  - right_bnd;
		    out_bound = right - right_bnd;
		    if ((left < right_bnd) || (right > left_bnd))
		      bvl_error (36,bvl_y_vsp[0].name.NAME);
		    }
		  else
		    {
		    in_bound  = right - right_bnd;
		    out_bound = left  - right_bnd;
		    if ((left > left_bnd) || (right < right_bnd))
		      bvl_error (36,bvl_y_vsp[0].name.NAME);
		    }
		  }

		if (sig_conf != BVL_CSTDFN)
		  {
		  expr1.IDENT = bvl_y_vsp[0].name.NAME;
		  if(bvl_y_vsp[0].name.FLAG == 'X')
			{
		  	expr1 = bvl_crtabl (NOPI,expr1,BVL_EMPSTR,left,right);
		  	bvl_y_val.list = bvl_crtabl (STABLE,expr1,BVL_EMPSTR,left,right);
			}
		  else 
		  	bvl_y_val.list = bvl_crtabl (NOPI,expr1,BVL_EMPSTR,left,right);
		  }
		else
		  {
		  expr1.IDENT = (char *)chktab(hshtab,bvl_y_vsp[0].name.NAME,NULL,BVL_PNTDFN);
		  bvl_y_val.list = bvl_crtabl (NOPS,expr1,BVL_EMPSTR,in_bound,out_bound);
		  }
		;
    break;}
case 125:
#line 1665 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = EQ; ;
    break;}
case 126:
#line 1667 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = NE; ;
    break;}
case 127:
#line 1672 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 128:
#line 1674 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 129:
#line 1676 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 130:
#line 1683 "../behave/bvl_bcomp.yac"
{ bvl_y_val.list = bvl_y_vsp[-1].list; ;
    break;}
case 131:
#line 1688 "../behave/bvl_bcomp.yac"
{
		bvl_y_val.name.NAME  = bvl_y_vsp[0].text;
		bvl_y_val.name.LEFT  = chktab (hshtab,bvl_y_vsp[0].text,BVL_MODNAM,BVL_WMNDFN);
		bvl_y_val.name.RIGHT = chktab (hshtab,bvl_y_vsp[0].text,BVL_MODNAM,BVL_WMXDFN);
		;
    break;}
case 132:
#line 1694 "../behave/bvl_bcomp.yac"
{ bvl_y_val.name = bvl_y_vsp[0].name; ;
    break;}
case 133:
#line 1696 "../behave/bvl_bcomp.yac"
{ bvl_y_val.name = bvl_y_vsp[0].name; ;
    break;}
case 134:
#line 1698 "../behave/bvl_bcomp.yac"
{ bvl_y_val.name = bvl_y_vsp[0].name; ;
    break;}
case 135:
#line 1706 "../behave/bvl_bcomp.yac"
{
		bvl_y_val.name.NAME  = bvl_y_vsp[-3].text;
		bvl_y_val.name.LEFT  = bvl_y_vsp[-1].valu;
		bvl_y_val.name.RIGHT = bvl_y_vsp[-1].valu;
		;
    break;}
case 136:
#line 1720 "../behave/bvl_bcomp.yac"
{
		if (((bvl_y_vsp[-1].valu > bvl_y_vsp[-3].valu) && (bvl_y_vsp[-2].valu != BVL_UPTDFN)) ||
		    ((bvl_y_vsp[-1].valu < bvl_y_vsp[-3].valu) && (bvl_y_vsp[-2].valu != BVL_DWTDFN)))
		  bvl_error (32,bvl_y_vsp[-5].text);

		bvl_y_val.name.NAME  = bvl_y_vsp[-5].text;
		bvl_y_val.name.LEFT  = bvl_y_vsp[-3].valu;
		bvl_y_val.name.RIGHT = bvl_y_vsp[-1].valu;
		;
    break;}
case 137:
#line 1735 "../behave/bvl_bcomp.yac"
{
		char             extname[100];
		char            *lclname;
		int              sig_conf;
		struct bvl_expr  expr1;
		struct bvl_expr  expr2;
		struct chain    *ptabl;

		sig_conf = chktab (hshtab,bvl_y_vsp[-2].text,BVL_MODNAM,BVL_SIGDFN);
		switch (sig_conf)
		  {
		  case (BVL_ICNDFN + BVL_BITDFN + BVL_NORDFN) :
		  case (BVL_BCNDFN + BVL_BITDFN + BVL_NORDFN) :
		  case (BVL_BCNDFN + BVL_MUXDFN + BVL_BUSDFN) :
		  case (BVL_BCNDFN + BVL_WORDFN + BVL_BUSDFN) :
		  case (BVL_BITDFN + BVL_NORDFN):
		  case (BVL_MUXDFN + BVL_BUSDFN):
		  case (BVL_WORDFN + BVL_BUSDFN):
		  case (BVL_RBIDFN + BVL_REGDFN):
		    break;
		  default :
		    bvl_error (79,bvl_y_vsp[-2].text);
		  }

		if (chktab (hshtab,bvl_y_vsp[-2].text,BVL_MODNAM,BVL_WMNDFN) != -1)
		  bvl_error (79,bvl_y_vsp[-2].text);

		sprintf (extname,"%s'delayed",bvl_y_vsp[-2].text);
		lclname = namealloc (extname);

		if (BVL_ERRFLG == 0)
		  {
		  if (chktab (hshtab,bvl_y_vsp[-2].text,BVL_MODNAM,BVL_STBDFN) == 0)
		    {
		    expr1.IDENT = bvl_y_vsp[-2].text;
		    expr1.WIDTH  = 1;
		    expr2 = bvl_crtabl (NOPI,expr1,BVL_EMPSTR,-1,-1);
		    ptabl = expr2.LIST_ABL->DATA;

		    if (BVL_AUXMOD == 1)
		      BVL_BEFPNT->BERIN=beh_addberin(BVL_BEFPNT->BERIN,lclname);

		    BVL_BEFPNT->BEDLY = beh_addbeaux(BVL_BEFPNT->BEDLY,lclname,
		                                     ptabl,NULL);
		    addtab (hshtab,bvl_y_vsp[-2].text     ,BVL_MODNAM,BVL_STBDFN,1);
		    addtab (hshtab,lclname,BVL_MODNAM,BVL_WMNDFN,-1);
		    addtab (hshtab,lclname,BVL_MODNAM,BVL_WMXDFN,-1);
		    addtab (hshtab,lclname,BVL_MODNAM,BVL_SIGDFN,
		            (BVL_ICNDFN + BVL_BITDFN + BVL_NORDFN));
		    }
		  }
		BVL_BEFPNT->TYPE |= BEH_STABLE;
		bvl_y_val.name.NAME = bvl_y_vsp[-2].text;
		bvl_y_val.name.LEFT = -1;
		bvl_y_val.name.RIGHT = -1;
		bvl_y_val.name.FLAG  = 'X';

		;
    break;}
case 139:
#line 1801 "../behave/bvl_bcomp.yac"
{ bvl_y_val.dble.VALU = BIT; bvl_y_val.dble.FLAG = 'S'; ;
    break;}
case 140:
#line 1803 "../behave/bvl_bcomp.yac"
{ bvl_y_val.dble.VALU = WOR_BIT; bvl_y_val.dble.FLAG = 'S'; ;
    break;}
case 141:
#line 1805 "../behave/bvl_bcomp.yac"
{ bvl_y_val.dble.VALU = MUX_BIT; bvl_y_val.dble.FLAG = 'S'; ;
    break;}
case 142:
#line 1807 "../behave/bvl_bcomp.yac"
{ bvl_y_val.dble.VALU = BIT; bvl_y_val.dble.FLAG = 'A'; ;
    break;}
case 143:
#line 1809 "../behave/bvl_bcomp.yac"
{ bvl_y_val.dble.VALU = WOR_BIT; bvl_y_val.dble.FLAG = 'A'; ;
    break;}
case 144:
#line 1811 "../behave/bvl_bcomp.yac"
{ bvl_y_val.dble.VALU = MUX_BIT; bvl_y_val.dble.FLAG = 'A'; ;
    break;}
case 145:
#line 1813 "../behave/bvl_bcomp.yac"
{ bvl_y_val.dble.VALU = REG_BIT; bvl_y_val.dble.FLAG = 'S'; ;
    break;}
case 146:
#line 1815 "../behave/bvl_bcomp.yac"
{ bvl_y_val.dble.VALU = REG_BIT; bvl_y_val.dble.FLAG = 'A'; ;
    break;}
case 147:
#line 1817 "../behave/bvl_bcomp.yac"
{ bvl_y_val.dble.VALU = NATURAL; bvl_y_val.dble.FLAG = 'S'; ;
    break;}
case 148:
#line 1819 "../behave/bvl_bcomp.yac"
{ bvl_y_val.dble.VALU = NATURAL; bvl_y_val.dble.FLAG = 'A'; ;
    break;}
case 149:
#line 1824 "../behave/bvl_bcomp.yac"
{ BVL_NM1LST = addchain (BVL_NM1LST,bvl_y_vsp[0].text); ;
    break;}
case 152:
#line 1833 "../behave/bvl_bcomp.yac"
{ BVL_NM1LST = addchain (BVL_NM1LST,bvl_y_vsp[0].text); ;
    break;}
case 153:
#line 1838 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = NULL; ;
    break;}
case 154:
#line 1840 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 155:
#line 1845 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = NULL; ;
    break;}
case 156:
#line 1847 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 157:
#line 1854 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = (char *)bvl_y_vsp[-1].list.LIST_ABL->DATA; ;
    break;}
case 158:
#line 1859 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = BVL_UNGDFN ; ;
    break;}
case 159:
#line 1861 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = BVL_GRDDFN; ;
    break;}
case 160:
#line 1866 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = NULL; ;
    break;}
case 161:
#line 1868 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 162:
#line 1873 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 163:
#line 1878 "../behave/bvl_bcomp.yac"
{ bvl_y_val.name = bvl_y_vsp[0].name; ;
    break;}
case 164:
#line 1884 "../behave/bvl_bcomp.yac"
{
		BVL_LBLNAM = bvl_y_vsp[-1].text;
		bvl_y_val.text = bvl_y_vsp[-1].text;
		;
    break;}
case 165:
#line 1892 "../behave/bvl_bcomp.yac"
{ bvl_y_val.text = bvl_y_vsp[0].text; ;
    break;}
case 166:
#line 1897 "../behave/bvl_bcomp.yac"
{ bvl_y_val.valu = atoi (bvl_y_vsp[0].text); ;
    break;}
case 167:
#line 1902 "../behave/bvl_bcomp.yac"
{ bvl_y_errok; ;
    break;}
case 168:
#line 1907 "../behave/bvl_bcomp.yac"
{ bvl_y_errok; ;
    break;}
case 169:
#line 1912 "../behave/bvl_bcomp.yac"
{ bvl_y_errok; ;
    break;}
}
   /* the action file gets copied in in place of this dollarsign */
#line 442 "/labo/gnu/lib/bison.simple"

  bvl_y_vsp -= bvl_y_len;
  bvl_y_ssp -= bvl_y_len;
#ifdef BVL_Y_LSP_NEEDED
  bvl_y_lsp -= bvl_y_len;
#endif

#if BVL_Y_DEBUG != 0
  if (bvl_y_debug)
    {
      short *ssp1 = bvl_y_ss - 1;
      fprintf (stderr, "state stack now");
      while (ssp1 != bvl_y_ssp)
	fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

  *++bvl_y_vsp = bvl_y_val;

#ifdef BVL_Y_LSP_NEEDED
  bvl_y_lsp++;
  if (bvl_y_len == 0)
    {
      bvl_y_lsp->first_line = bvl_y_lloc.first_line;
      bvl_y_lsp->first_column = bvl_y_lloc.first_column;
      bvl_y_lsp->last_line = (bvl_y_lsp-1)->last_line;
      bvl_y_lsp->last_column = (bvl_y_lsp-1)->last_column;
      bvl_y_lsp->text = 0;
    }
  else
    {
      bvl_y_lsp->last_line = (bvl_y_lsp+bvl_y_len-1)->last_line;
      bvl_y_lsp->last_column = (bvl_y_lsp+bvl_y_len-1)->last_column;
    }
#endif

  /* Now "shift" the result of the reduction.
     Determine what state that goes to,
     based on the state we popped back to
     and the rule number reduced by.  */

  bvl_y_n = bvl_y_r1[bvl_y_n];

  bvl_y_state = bvl_y_pgoto[bvl_y_n - BVL_Y_NTBASE] + *bvl_y_ssp;
  if (bvl_y_state >= 0 && bvl_y_state <= BVL_Y_LAST && bvl_y_check[bvl_y_state] == *bvl_y_ssp)
    bvl_y_state = bvl_y_table[bvl_y_state];
  else
    bvl_y_state = bvl_y_defgoto[bvl_y_n - BVL_Y_NTBASE];

  goto bvl_y_newstate;

bvl_y_errlab:   /* here on detecting error */

  if (! bvl_y_errstatus)
    /* If not already recovering from an error, report this error.  */
    {
      ++bvl_y_nerrs;

#ifdef BVL_Y_ERROR_VERBOSE
      bvl_y_n = bvl_y_pact[bvl_y_state];

      if (bvl_y_n > BVL_Y_FLAG && bvl_y_n < BVL_Y_LAST)
	{
	  int size = 0;
	  char *msg;
	  int x, count;

	  count = 0;
	  for (x = 0; x < (sizeof(bvl_y_tname) / sizeof(char *)); x++)
	    if (bvl_y_check[x + bvl_y_n] == x)
	      size += strlen(bvl_y_tname[x]) + 15, count++;
	  msg = (char *) malloc(size + 15);
	  if (msg != 0)
	    {
	      strcpy(msg, "parse error");

	      if (count < 5)
		{
		  count = 0;
		  for (x = 0; x < (sizeof(bvl_y_tname) / sizeof(char *)); x++)
		    if (bvl_y_check[x + bvl_y_n] == x)
		      {
			strcat(msg, count == 0 ? ", expecting `" : " or `");
			strcat(msg, bvl_y_tname[x]);
			strcat(msg, "'");
			count++;
		      }
		}
	      bvl_y_error(msg);
	      free(msg);
	    }
	  else
	    bvl_y_error ("parse error; also virtual memory exceeded");
	}
      else
#endif /* BVL_Y_ERROR_VERBOSE */
	bvl_y_error("parse error");
    }

  goto bvl_y_errlab1;
bvl_y_errlab1:   /* here on error raised explicitly by an action */

  if (bvl_y_errstatus == 3)
    {
      /* if just tried and failed to reuse lookahead token after an error, discard it.  */

      /* return failure if at end of input */
      if (bvl_y_char == BVL_Y_EOF)
	BVL_Y_ABORT;

#if BVL_Y_DEBUG != 0
      if (bvl_y_debug)
	fprintf(stderr, "Discarding token %d (%s).\n", bvl_y_char, bvl_y_tname[bvl_y_char1]);
#endif

      bvl_y_char = BVL_Y_EMPTY;
    }

  /* Else will try to reuse lookahead token
     after shifting the error token.  */

  bvl_y_errstatus = 3;		/* Each real token shifted decrements this */

  goto bvl_y_errhandle;

bvl_y_errdefault:  /* current state does not do anything special for the error token. */

#if 0
  /* This is wrong; only states that explicitly want error tokens
     should shift them.  */
  bvl_y_n = bvl_y_defact[bvl_y_state];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  if (bvl_y_n) goto bvl_y_default;
#endif

bvl_y_errpop:   /* pop the current state because it cannot handle the error token */

  if (bvl_y_ssp == bvl_y_ss) BVL_Y_ABORT;
  bvl_y_vsp--;
  bvl_y_state = *--bvl_y_ssp;
#ifdef BVL_Y_LSP_NEEDED
  bvl_y_lsp--;
#endif

#if BVL_Y_DEBUG != 0
  if (bvl_y_debug)
    {
      short *ssp1 = bvl_y_ss - 1;
      fprintf (stderr, "Error: state stack now");
      while (ssp1 != bvl_y_ssp)
	fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

bvl_y_errhandle:

  bvl_y_n = bvl_y_pact[bvl_y_state];
  if (bvl_y_n == BVL_Y_FLAG)
    goto bvl_y_errdefault;

  bvl_y_n += BVL_Y_TERROR;
  if (bvl_y_n < 0 || bvl_y_n > BVL_Y_LAST || bvl_y_check[bvl_y_n] != BVL_Y_TERROR)
    goto bvl_y_errdefault;

  bvl_y_n = bvl_y_table[bvl_y_n];
  if (bvl_y_n < 0)
    {
      if (bvl_y_n == BVL_Y_FLAG)
	goto bvl_y_errpop;
      bvl_y_n = -bvl_y_n;
      goto bvl_y_reduce;
    }
  else if (bvl_y_n == 0)
    goto bvl_y_errpop;

  if (bvl_y_n == BVL_Y_FINAL)
    BVL_Y_ACCEPT;

#if BVL_Y_DEBUG != 0
  if (bvl_y_debug)
    fprintf(stderr, "Shifting error token, ");
#endif

  *++bvl_y_vsp = bvl_y_lval;
#ifdef BVL_Y_LSP_NEEDED
  *++bvl_y_lsp = bvl_y_lloc;
#endif

  bvl_y_state = bvl_y_n;
  goto bvl_y_newstate;
}
#line 1914 "../behave/bvl_bcomp.yac"


static struct dct_entry *addent (head , key)

struct dct_entry *head;
char             *key;

  {
  struct dct_entry *entry;
  int               i;

  if (BVL_DCEHED == NULL)
    {
    BVL_DCEHED = (struct dct_entry *)
                 mbkalloc (sizeof(struct dct_entry) * BVL_ALODFN);

    entry = BVL_DCEHED;
    for (i=1 ; i<BVL_ALODFN ; i++)
      {
      entry->next = entry + 1;
      entry++;
      }
    entry->next = NULL;
    }

  entry       = BVL_DCEHED;
  BVL_DCEHED  = BVL_DCEHED->next;

  entry->next = head;
  entry->data = NULL;
  entry->key  = key;

  return (entry);
  }

static struct dct_recrd *addrcd (head , key)

struct dct_recrd *head;
char             *key;

  {
  struct dct_recrd *recrd;
  int               i;

  if (BVL_DCRHED == NULL)
    {
    BVL_DCRHED = (struct dct_recrd *)
                 mbkalloc (sizeof(struct dct_recrd) * BVL_ALODFN);

    recrd = BVL_DCRHED;
    for (i=1 ; i<BVL_ALODFN ; i++)
      {
      recrd->next = recrd + 1;
      recrd++;
      }
    recrd->next = NULL;
    }

  recrd           = BVL_DCRHED;
  BVL_DCRHED      = BVL_DCRHED->next;

  recrd->next     = head;
  recrd->fd0_val  = 0;
  recrd->fd1_val  = 0;
  recrd->fd2_val  = 0;
  recrd->fd3_val  = 0;
  recrd->fd4_val  = 0;
  recrd->fd5_val  = 0;
  recrd->fd6_val  = 0;
  recrd->pnt_val  = 0;
  recrd->key      = key;

  return (recrd);
  }

static struct dct_entry **initab ()

  {
  struct dct_entry **head;
  int                i;

  head = (struct dct_entry **)
         mbkalloc (sizeof(struct dct_entry *) * BVL_HSZDFN);

  for (i=0 ; i<BVL_HSZDFN ; i++)
    head[i] = NULL;

  return (head);
  }

static void addtab (head,key_str,ctx_str,field,valu)

struct dct_entry **head;
char              *key_str;
char              *ctx_str;
int                field;
int                valu;

  {
  int               found = 0;
  int               index;
  struct dct_entry *entry_pnt;
  struct dct_recrd *recrd_pnt;

  index     = (int) key_str % BVL_HSZDFN;
  entry_pnt = head[index];

  while (entry_pnt != NULL)
    {
    if (entry_pnt->key == key_str)
      {
      found = 1;
      break;
      }
    entry_pnt = entry_pnt->next;
    }

  if (found == 0)
    {
    head[index] = addent (head[index],key_str); 
    entry_pnt = head[index]; 
    }

  found = 0;
  recrd_pnt = entry_pnt->data;
  while (recrd_pnt != NULL)
    {
    if (recrd_pnt->key == ctx_str)
      {
      found = 1;
      break;
      }
    recrd_pnt = recrd_pnt->next;
    }

  if (found == 0)
    {
    entry_pnt->data = addrcd (entry_pnt->data,ctx_str); 
    recrd_pnt       = entry_pnt->data ;
    }

  switch (field)
    {
    case 0 :
      recrd_pnt->fd0_val = valu; break;
    case 1 :
      recrd_pnt->fd1_val = valu; break;
    case 2 :
      recrd_pnt->fd2_val = valu; break;
    case 3 :
      recrd_pnt->fd3_val = valu; break;
    case 4 :
      recrd_pnt->fd4_val = valu; break;
    case 5 :
      recrd_pnt->fd5_val = valu; break;
    case 6 :
      recrd_pnt->fd6_val = valu; break;
    case 7 :
      recrd_pnt->pnt_val = valu; break;
    }

  }

static int chktab (head,key_str,ctx_str,field)

struct dct_entry **head;
char              *key_str;
char              *ctx_str;
int                field;

  {
  int               found = 0;
  int               valu = 0;
  struct dct_entry *entry_pnt;
  struct dct_recrd *recrd_pnt;

  entry_pnt = head [(int)key_str % BVL_HSZDFN];

  while (entry_pnt != NULL)
    {
    if (entry_pnt->key == key_str)
      {
      found = 1;
      break;
      }
    entry_pnt = entry_pnt->next;
    }

  if (found == 1)
    {
    found = 0;
    recrd_pnt = entry_pnt->data;
    while (recrd_pnt != NULL)
      {
      if (recrd_pnt->key == ctx_str)
        {
        found = 1;
        break;
        }
      recrd_pnt = recrd_pnt->next;
      }
    if (found == 1)
      {
      switch (field)
        {
        case 0 :
          valu = recrd_pnt->fd0_val; break;
        case 1 :
          valu = recrd_pnt->fd1_val; break;
        case 2 :
          valu = recrd_pnt->fd2_val; break;
        case 3 :
          valu = recrd_pnt->fd3_val; break;
        case 4 :
          valu = recrd_pnt->fd4_val; break;
        case 5 :
          valu = recrd_pnt->fd5_val; break;
        case 6 :
          valu = recrd_pnt->fd6_val; break;
        case 7 :
          valu = recrd_pnt->pnt_val; break;
        }
      }
    }

  return (valu);
  }

static void fretab (pt_hash)

struct dct_entry **pt_hash;
  {
  struct dct_entry *pt_entry;
  struct dct_entry *pt_nxtentry;
  struct dct_recrd *pt_record;
  int               i;

  if (pt_hash != NULL)
    {
    for (i=0 ; i<BVL_HSZDFN ; i++)
      {
      if ((pt_entry = pt_hash[i]) != NULL)
        {
        while (pt_entry != NULL)
          {
          pt_record = pt_entry->data;

          while (pt_record->next != NULL)
            pt_record = pt_record->next;

          pt_record->next = BVL_DCRHED;
          BVL_DCRHED      = pt_entry->data;

          pt_nxtentry     = pt_entry->next;
          pt_entry->next  = BVL_DCEHED;
          BVL_DCEHED      = pt_entry;
          pt_entry        = pt_nxtentry;
          }
        }
      }
    mbkfree (pt_hash);
    }
  }

void *addstr (ptfig, object, mode, type, flag, name, left, right)

struct befig *ptfig;
char          object;
int           mode;
int           type;
char          flag;
char         *name;
short         left;
short         right;

  {
  void  *pnt    = NULL;
  char   porflg = 0;
  char   rinflg = 0;
  char   outflg = 0;
  char   busflg = 0;
  char   auxflg = 0;
  char   buxflg = 0;
  char   regflg = 0;
  char   lclmod;
  char   lcltyp;
  char   extname[100];
  short  i;
  short  inc = 1;

  switch (object)
    {
    case 'P':

	/* ###------------------------------------------------------### */
	/*   if object is a port ...					*/
	/* ###------------------------------------------------------### */

      porflg = 1;
      switch (mode)
        {
        case _IN:
          lclmod = 'I'; lcltyp = 'B'; rinflg = 1; break;
        case _OUT:
          switch (type)
            {
            case BIT:
              lclmod = 'O'; lcltyp = 'B'; outflg = 1; break;
            case MUX_BIT:
              lclmod = 'Z'; lcltyp = 'M'; busflg = 1; break;
            case WOR_BIT:
              lclmod = 'Z'; lcltyp = 'W'; busflg = 1; break;
            }
          break;
        case _INOUT:
          rinflg = 1;
          switch (type)
            {
            case BIT:
              lclmod = 'B'; lcltyp = 'B'; outflg = 1; break;
            case MUX_BIT:
              lclmod = 'T'; lcltyp = 'M'; busflg = 1; break;
            case WOR_BIT:
              lclmod = 'T'; lcltyp = 'W'; busflg = 1; break;
            }
          break;
        }
      break;

    case 'S':

	/* ###------------------------------------------------------### */
	/*   if object is a signal ...					*/
	/* ###------------------------------------------------------### */

      switch (type)
        {
        case BIT:
          lcltyp = 'B'; rinflg = BVL_AUXMOD; auxflg = 1; break;
        case REG_BIT:
          rinflg = 1; regflg = 1; break;
        case MUX_BIT:
          lcltyp = 'M'; rinflg = 1; buxflg = 1; break;
        case WOR_BIT:
          lcltyp = 'W'; rinflg = 1; buxflg = 1; break;
        }
      break;
    }

  if (flag == 'S')
    {
	/* ###------------------------------------------------------### */
	/*   if object is a scalar ...					*/
	/* ###------------------------------------------------------### */

    if (porflg == 1)
      ptfig->BEPOR = beh_addbepor (ptfig->BEPOR,name,lclmod,lcltyp);
    if (rinflg == 1)
      ptfig->BERIN = beh_addberin (ptfig->BERIN,name);
    if (outflg == 1)
      ptfig->BEOUT = beh_addbeout (ptfig->BEOUT,name,NULL,NULL);
    if (busflg == 1)
      ptfig->BEBUS = beh_addbebus (ptfig->BEBUS,name,NULL,NULL,lcltyp);
    if (auxflg == 1)
      ptfig->BEAUX = beh_addbeaux (ptfig->BEAUX,name,NULL,NULL);
    if (buxflg == 1)
      ptfig->BEBUX = beh_addbebux (ptfig->BEBUX,name,NULL,NULL,lcltyp);
    if (regflg == 1)
      ptfig->BEREG = beh_addbereg (ptfig->BEREG,name,NULL,NULL);

    }
  else
    {
	/* ###------------------------------------------------------### */
	/*   if object is an array ...					*/
	/* ###------------------------------------------------------### */

    if (left >= right)
      inc = -1;

    for (i=left ; i!=(right+inc) ; i+=inc)
      {
      sprintf (extname,"%s %d",name,i);

      if (porflg == 1)
        ptfig->BEPOR = beh_addbepor (ptfig->BEPOR,extname,lclmod,lcltyp);
      if (rinflg == 1)
        ptfig->BERIN = beh_addberin (ptfig->BERIN,extname);
      if (outflg == 1)
        ptfig->BEOUT = beh_addbeout (ptfig->BEOUT,extname,NULL,NULL);
      if (busflg == 1)
        ptfig->BEBUS = beh_addbebus (ptfig->BEBUS,extname,NULL,NULL,lcltyp);
      if (auxflg == 1)
        ptfig->BEAUX = beh_addbeaux (ptfig->BEAUX,extname,NULL,NULL);
      if (buxflg == 1)
        ptfig->BEBUX = beh_addbebux (ptfig->BEBUX,extname,NULL,NULL,lcltyp);
      if (regflg == 1)
        ptfig->BEREG = beh_addbereg (ptfig->BEREG,extname,NULL,NULL);
      }
    }

  if (outflg == 1)
    pnt = (void *) ptfig->BEOUT;
  if (busflg == 1)
    pnt = (void *) ptfig->BEBUS;
  if (auxflg == 1)
    pnt = (void *) ptfig->BEAUX;
  if (buxflg == 1)
    pnt = (void *) ptfig->BEBUX;
  if (regflg == 1)
    pnt = (void *) ptfig->BEREG;

  return (pnt);
  }

int chkdcl (object,mode,type,flag,kind,constraint,conf)

char object;
int  mode;
int  type;
char flag;
int  kind;
char constraint;
int  *conf;

  {
  int errflg = 0;
  int lclcnf = 0;

  if (flag != constraint)
    {
    errflg = 1;
    bvl_error (33,NULL);
    }
  else
    {
    switch (object)
      {
      case 'P':
	/* ###------------------------------------------------------### */
	/*    If object is a port :					*/
	/*       - if type is bit, no guard indication can be used	*/
	/*       - if type is wor_bit or mux_bit, bus kind must be used	*/
	/*       - other types are illegal				*/
	/* ###------------------------------------------------------### */

        switch (type)
          {
          case BIT:

            lclcnf += BVL_BITDFN + BVL_NORDFN;
            switch (mode)
              {
              case _IN :
                lclcnf += BVL_ICNDFN; break;
              case _OUT:
                lclcnf += BVL_OCNDFN; break;
              case _INOUT :
                lclcnf += BVL_BCNDFN; break;
              case _LINKAGE :
              case 0 :
                errflg = 1; break;
              }
            if (kind != 0)
              errflg = 1;
            break;

          case MUX_BIT:

            lclcnf += BVL_MUXDFN + BVL_BUSDFN;
            switch (mode)
              {
              case _OUT :
                lclcnf += BVL_OCNDFN; break;
              case _INOUT :
                lclcnf += BVL_BCNDFN; break;
              case _IN :
              case _LINKAGE :
              case 0 :
                errflg = 1; break;
              }
            if (kind != BUS)
              errflg = 1;
            break;

          case WOR_BIT:

            lclcnf += BVL_WORDFN + BVL_BUSDFN;
            switch (mode)
              {
              case _OUT :
                lclcnf += BVL_OCNDFN; break;
              case _INOUT :
                lclcnf += BVL_BCNDFN; break;
              case _IN :
              case _LINKAGE :
              case 0 :
                errflg = 1; break;
              }
            if (kind != BUS)
              errflg = 1;
            break;

          case REG_BIT:
          case NATURAL:

            errflg = 1;
            break;
          }
        if (errflg == 1)
          bvl_error (5,NULL);
        break;

      case 'G':
	/* ###------------------------------------------------------### */
	/*    If object is a generic :					*/
	/*       - only natural type is allowed				*/
	/* ###------------------------------------------------------### */

        if ((type != NATURAL) || (mode != 0) || (kind != 0))
          {
          errflg = 1;
          bvl_error (77,NULL);
          }
        break;

      case 'S':
	/* ###------------------------------------------------------### */
	/*    If object is a signal :					*/
	/*       - no mode can be specified				*/
	/*       - if type is bit no guard indication can be used	*/
	/*       - if type is wor_bit or mux_bit, bus kind must be used	*/
	/*       - if type is reg_bit, register kind must be used	*/
	/*       - other types are illegal				*/
	/* ###------------------------------------------------------### */

        switch (type)
          {
          case BIT:
            lclcnf += BVL_BITDFN + BVL_NORDFN;
            if ((mode != 0) || (kind != 0))
              errflg = 1;
            break;
          case MUX_BIT:
            lclcnf += BVL_MUXDFN + BVL_BUSDFN;
            if ((mode != 0) || (kind != BUS))
              errflg = 1;
            break;
          case WOR_BIT:
            lclcnf += BVL_WORDFN + BVL_BUSDFN;
            if ((mode != 0) || (kind != BUS))
              errflg = 1;
            break;
          case REG_BIT:
            lclcnf += BVL_RBIDFN + BVL_REGDFN;
            if ((mode != 0) || (kind != REGISTER))
              errflg = 1;
            break;
          case NATURAL:
            errflg = 1; break;
          }

        if (mode != 0)
          errflg = 1;

        if (errflg == 1)
          bvl_error (11,NULL);
        break;

      case 'C':
	/* ###------------------------------------------------------### */
	/*    If object is a constant :					*/
	/*       - only bit type without any other indication is legal	*/
	/* ###------------------------------------------------------### */

        lclcnf += BVL_CSTDFN;
        if ((type != BIT) || (mode != 0) || (kind != 0))
          {
          errflg = 1;
          bvl_error (78,NULL);
          }
        break;
      }
    }

  *conf = lclcnf ;
  return (errflg);
  }
