
/*  A Bison parser, made from ../struct/mvl_scomp.yac  */

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

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

#line 31 "../struct/mvl_scomp.yac"

#include <stdio.h>
#include "../mvl_include.h"
#include "mvl_stype.h"
#include "mvl_syacc.h"
#include "mvl_stdef.h"


static int       MVL_GENFLG = 0;	/* Indicates if generic 	*/
static int       MVL_CONRNK = 0;       	/* rank of an implicit connexion*/
static int       MVL_SIGIDX = 1;       	/* structural's signal index    */
static int       MVL_SIMFLG = 0;       	/* simple flag                  */
static int       MVL_CONCNT = 0;       	/* connector's count            */
static char      *MVL_MODNAM;        	/* current model name           */
static char      *MVL_CHDNAM;        	/* child's model name           */
static char      *MVL_LOCNAM;        	/* instance's name           	*/
static struct chain *MVL_NM1LST = NULL; /* 1-st name liste              */
static struct chain *MVL_NM2LST = NULL; /* 2-nd name liste              */
static struct lofig *MVL_CHDPNT = NULL; /* current child pointer        */
static struct lofig *MVL_CHDHED = NULL; /* childs list                  */


#line 53 "../struct/mvl_scomp.yac"
typedef union
  {
  int         valu;
  char       *text;
  char        flag;
  mvl_name    name;
  mvl_expr    expr;
} MVL_Y_STYPE;

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

#define MVL_Y_LTYPE mvl_y_ltype
#endif

#include <stdio.h>

#ifndef __STDC__
#define const
#endif



#define	MVL_Y_FINAL		210
#define	MVL_Y_FLAG		-32768
#define	MVL_Y_NTBASE	130

#define MVL_Y_TRANSLATE(x) ((unsigned)(x) <= 384 ? mvl_y_translate[x] : 206)

static const short mvl_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,   129
};

#if MVL_Y_DEBUG != 0
static const short mvl_y_prhs[] = {     0,
     0,     3,     4,    14,    17,    18,    20,    26,    30,    33,
    34,    38,    39,    40,    49,    51,    54,    56,    58,    63,
    64,    68,    70,    71,    73,    77,    81,    83,    85,    86,
    88,    94,    98,   101,   102,   106,   114,   116,   117,   118,
   132,   135,   137,   138,   141,   143,   145,   148,   156,   157,
   165,   166,   172,   175,   176,   180,   188,   190,   192,   193,
   196,   198,   201,   202,   208,   209,   211,   217,   220,   221,
   225,   229,   231,   233,   235,   237,   239,   241,   243,   248,
   251,   253,   255,   257,   259,   263,   265,   267,   269,   271,
   273,   277,   282,   283,   285,   286,   288,   290,   292,   294,
   295,   297,   299,   301,   303,   305,   307,   309,   311,   313,
   315,   317,   319,   320,   322,   323,   327,   328,   332,   335,
   336,   338,   340,   342,   344,   346
};

#endif

static const short mvl_y_rhs[] = {   131,
   154,     0,     0,    62,   200,    74,   132,   133,   149,   205,
   200,   202,     0,    62,     1,     0,     0,   134,     0,    69,
     5,   135,   204,   202,     0,    69,     1,   202,     0,   137,
   136,     0,     0,   136,   202,   137,     0,     0,     0,    55,
   138,   196,   139,    13,   194,   145,   140,     0,     1,     0,
    12,   141,     0,   203,     0,   142,     0,     5,   144,   143,
   204,     0,     0,   143,    10,   144,     0,   203,     0,     0,
   146,     0,     5,   147,   204,     0,   203,   148,   203,     0,
   115,     0,    58,     0,     0,   150,     0,    98,     5,   151,
   204,   202,     0,    98,     1,   202,     0,   153,   152,     0,
     0,   152,   202,   153,     0,   191,   196,    13,   193,   194,
   145,   195,     0,     1,     0,     0,     0,    41,   155,   201,
    91,   201,    74,   156,   157,    45,   167,   205,   200,   202,
     0,    41,     1,     0,   158,     0,     0,   158,   159,     0,
   160,     0,   161,     0,     1,   202,     0,   111,   196,    13,
   194,   145,   195,   202,     0,     0,    53,    26,   162,   163,
   205,    53,   202,     0,     0,    98,     5,   164,   204,   202,
     0,   166,   165,     0,     0,   165,   202,   166,     0,   191,
   196,    13,   192,   194,   145,   195,     0,     1,     0,   168,
     0,     0,   168,   169,     0,   170,     0,     1,   202,     0,
     0,   199,   201,   171,   172,   202,     0,     0,   173,     0,
    98,    79,     5,   174,   204,     0,   176,   175,     0,     0,
   175,    10,   176,     0,   177,    18,   178,     0,   178,     0,
     1,     0,   179,     0,   182,     0,   201,     0,   180,     0,
   181,     0,   201,     5,   203,   204,     0,   201,   146,     0,
   183,     0,   184,     0,   185,     0,   186,     0,   185,     3,
   186,     0,   187,     0,   188,     0,   189,     0,   190,     0,
   179,     0,     5,   182,   204,     0,    56,     5,   182,   204,
     0,     0,   111,     0,     0,    73,     0,    96,     0,    72,
     0,    77,     0,     0,    73,     0,    96,     0,    72,     0,
    77,     0,    46,     0,   127,     0,    81,     0,    47,     0,
   128,     0,    82,     0,    84,     0,    85,     0,     0,    51,
     0,     0,    26,   197,   198,     0,     0,   198,    10,    26,
     0,    26,    13,     0,     0,   201,     0,    26,     0,    14,
     0,    29,     0,     6,     0,    61,     0
};

#if MVL_Y_DEBUG != 0
static const short mvl_y_rline[] = { 0,
   223,   232,   248,   259,   265,   266,   270,   275,   281,   286,
   287,   293,   298,   302,   305,   309,   314,   316,   321,   328,
   329,   335,   340,   346,   351,   358,   377,   379,   384,   385,
   389,   394,   401,   406,   407,   413,   543,   557,   565,   573,
   582,   588,   592,   593,   598,   599,   600,   606,   691,   710,
   724,   725,   733,   738,   739,   745,   859,   873,   877,   878,
   883,   884,   892,   937,   993,   994,   998,  1006,  1011,  1012,
  1018,  1073,  1137,  1152,  1175,  1181,  1187,  1189,  1194,  1206,
  1217,  1223,  1229,  1235,  1237,  1255,  1261,  1266,  1268,  1270,
  1373,  1380,  1389,  1390,  1394,  1396,  1398,  1400,  1402,  1410,
  1412,  1414,  1416,  1418,  1423,  1425,  1427,  1429,  1431,  1433,
  1435,  1437,  1442,  1444,  1449,  1455,  1458,  1459,  1469,  1476,
  1478,  1483,  1488,  1493,  1498,  1503
};

static const char * const mvl_y_tname[] = {   "$","error","$illegal.","Ampersand",
"Apostrophe","LeftParen","RightParen","DoubleStar","Star","Plus","Comma","Minus",
"VarAsgn","Colon","Semicolon","_LESym","Box","_LTSym","Arrow","_EQSym","_GESym",
"_GTSym","Bar","_NESym","Dot","Slash","Identifier","DecimalInt","DecimalReal",
"AbstractLit","BasedInt","BasedReal","CharacterLit","StringLit","BitStringLit",
"ABS","ACCESS","AFTER","ALIAS","ALL","_AND","ARCHITECTURE","ARRAY","ASSERT",
"ATTRIBUTE","_BEGIN","BIT","BIT_VECTOR","BLOCK","BODY","BUFFER","BUS","CASE",
"COMPONENT","CONFIGURATION","CONSTANT","CONVERT","DISCONNECT","DOWNTO","ELSE",
"ELSIF","_END","ENTITY","ERROR","_EXIT","_FILE","FOR","FUNCTION","GENERATE",
"GENERIC","GUARDED","IF","_INOUT","_IN","IS","_LABEL","LIBRARY","_LINKAGE","LOOP",
"MAP","MOD","MUX_BIT","MUX_VECTOR","_NAND","NATURAL","NATURAL_VECTOR","NEW",
"_NEXT","_NOR","_NOT","_NULL","OF","ON","OPEN","_OR","OTHERS","_OUT","PACKAGE",
"PORT","PROCEDURE","PROCESS","RANGE","RECORD","REG_BIT","REG_VECTOR","REGISTER",
"REM","REPORT","RETURN","SELECT","SEVERITY","SIGNAL","_STABLE","SUBTYPE","THEN",
"TO","TRANSPORT","_TYPE","UNITS","UNTIL","USE","VARIABLE","WAIT","WARNING","WHEN",
"WHILE","WITH","WOR_BIT","WOR_VECTOR","_XOR","design_file","entity_declaration",
"@1",".generic_clause.","generic_clause","formal_generic_list","...formal_generic_element..",
"formal_generic_element","@2","@3","generic_VarAsgn__expression","generic_expression",
"generic_aggregate","...generic_element_association..","generic_element_association",
".constraint.","constraint","range","direction",".port_clause.","port_clause",
"formal_port_list","...formal_port_element..","formal_port_element","architecture_body",
"@4","@5","architecture_declarative_part","..block_declaration_item..","block_declaration_item",
"signal_declaration","component_declaration","@6",".PORT__local_port_list.",
"local_port_list","...local_port_element..","local_port_element","architecture_statement_part",
"..concurrent_statement..","concurrent_statement","component_instantiation_statement",
"@7",".port_map_aspect.","port_map_aspect","association_list","...association_element..",
"association_element","formal_port_name","actual_port_name","name","indexed_name",
"slice_name","expression","relation","simple_expression",".sign.term..add_op__term..",
"term","factor","primary","aggregate","type_convertion",".SIGNAL.",".local_port_mode.",
".mode.","type_mark",".BUS.","identifier_list","@8","...identifier..","a_label",
".simple_name.","simple_name","Semicolon_ERR","abstractlit","RightParen_ERR",
"END_ERR",""
};
#endif

static const short mvl_y_r1[] = {     0,
   130,   132,   131,   131,   133,   133,   134,   134,   135,   136,
   136,   138,   139,   137,   137,   140,   141,   141,   142,   143,
   143,   144,   145,   145,   146,   147,   148,   148,   149,   149,
   150,   150,   151,   152,   152,   153,   153,   155,   156,   154,
   154,   157,   158,   158,   159,   159,   159,   160,   162,   161,
   163,   163,   164,   165,   165,   166,   166,   167,   168,   168,
   169,   169,   171,   170,   172,   172,   173,   174,   175,   175,
   176,   176,   176,   177,   178,   179,   179,   179,   180,   181,
   182,   183,   184,   185,   185,   186,   187,   188,   188,   188,
   189,   190,   191,   191,   192,   192,   192,   192,   192,   193,
   193,   193,   193,   193,   194,   194,   194,   194,   194,   194,
   194,   194,   195,   195,   197,   196,   198,   198,   199,   200,
   200,   201,   202,   203,   204,   205
};

static const short mvl_y_r2[] = {     0,
     2,     0,     9,     2,     0,     1,     5,     3,     2,     0,
     3,     0,     0,     8,     1,     2,     1,     1,     4,     0,
     3,     1,     0,     1,     3,     3,     1,     1,     0,     1,
     5,     3,     2,     0,     3,     7,     1,     0,     0,    13,
     2,     1,     0,     2,     1,     1,     2,     7,     0,     7,
     0,     5,     2,     0,     3,     7,     1,     1,     0,     2,
     1,     2,     0,     5,     0,     1,     5,     2,     0,     3,
     3,     1,     1,     1,     1,     1,     1,     1,     4,     2,
     1,     1,     1,     1,     3,     1,     1,     1,     1,     1,
     3,     4,     0,     1,     0,     1,     1,     1,     1,     0,
     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     1,     1,     0,     1,     0,     3,     0,     3,     2,     0,
     1,     1,     1,     1,     1,     1
};

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

static const short mvl_y_defgoto[] = {   208,
     2,    12,    15,    16,    28,    38,    29,    35,    58,   118,
   131,   132,   153,   144,   104,   105,   115,   129,    21,    22,
    42,    52,    43,     8,    11,    46,    55,    56,    67,    68,
    69,   100,   112,   138,   149,   139,    78,    79,    97,    98,
   122,   135,   136,   163,   191,   164,   165,   166,   187,   168,
   169,   170,   171,   172,   173,   174,   175,   176,   177,   178,
    44,   185,    77,    92,   120,    48,    57,    70,    99,     5,
   179,    25,   145,    37,    33
};

static const short mvl_y_pact[] = {   -12,
    14,     8,-32768,-32768,   -19,-32768,    41,-32768,-32768,-32768,
    32,    -8,   -23,    85,   -21,-32768,    32,    55,    16,    86,
    31,-32768,    20,-32768,-32768,-32768,-32768,    89,-32768,    55,
     4,-32768,    32,-32768,    72,-32768,    55,    55,-32768,-32768,
-32768,    89,-32768,    72,    55,-32768,-32768,-32768,-32768,    16,
    55,    55,    90,-32768,    57,     3,-32768,    92,-32768,-32768,
     4,   -26,-32768,    55,    74,    72,-32768,-32768,-32768,    97,
    -2,-32768,-32768,-32768,-32768,-32768,    -2,    31,    11,-32768,
-32768,    95,    98,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,   113,   113,    32,    55,   110,-32768,-32768,    32,    29,
    -2,-32768,    99,   117,-32768,    79,    55,-32768,-32768,-32768,
   126,    31,   113,-32768,    89,   -40,    34,-32768,-32768,-32768,
-32768,    35,     5,    81,    79,-32768,-32768,-32768,    99,    99,
-32768,-32768,-32768,    53,    55,-32768,-32768,    89,-32768,    72,
    55,    55,-32768,-32768,-32768,   130,-32768,    55,    55,   123,
-32768,-32768,    87,    28,-32768,     5,   -20,    99,-32768,-32768,
    33,   132,    89,-32768,   120,-32768,   121,-32768,-32768,-32768,
-32768,-32768,   137,-32768,-32768,-32768,-32768,-32768,   136,-32768,
-32768,-32768,-32768,-32768,    -2,-32768,-32768,    89,    33,-32768,
   133,    33,    33,    99,-32768,   113,-32768,    89,    28,-32768,
-32768,     7,    79,-32768,-32768,-32768,-32768,   142,   144,-32768
};

static const short mvl_y_pgoto[] = {-32768,
-32768,-32768,-32768,-32768,-32768,-32768,   100,-32768,-32768,-32768,
-32768,-32768,-32768,   -11,   -79,   -34,-32768,-32768,-32768,-32768,
-32768,-32768,    88,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,    -5,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,   -51,-32768,   -39,  -135,-32768,
-32768,  -129,-32768,-32768,-32768,   -38,-32768,-32768,-32768,-32768,
   -82,-32768,-32768,   -75,  -118,   -41,-32768,-32768,-32768,   -13,
    10,   -29,   -93,   -42,   -50
};


#define	MVL_Y_LAST		160


static const short mvl_y_table[] = {    51,
    39,    93,    53,    64,    40,   137,   142,    49,    50,   116,
     6,    95,    36,   106,     3,    54,    26,   127,   167,    45,
    13,    60,    61,   133,    82,   113,    23,    94,   160,   -93,
   -93,   188,   161,   125,    80,   143,    96,   161,   130,     4,
   140,    10,     6,    84,    85,    73,    74,   -42,     7,     1,
    75,   181,   182,     4,     9,    65,   183,     4,     4,   198,
    14,   124,   114,   167,   127,   108,   -38,    17,    24,    76,
    27,   -58,   126,   140,   128,   184,    20,   121,    86,    87,
   107,    88,    89,   162,   207,    18,    30,  -120,   162,    19,
    31,    32,    36,    34,    36,   148,   158,    47,   150,    81,
   202,    63,    62,     6,    71,   147,    83,   101,   110,   196,
   159,   151,   152,    66,    41,    41,   203,   103,   155,   156,
   190,   128,   109,   102,    90,    91,   111,   114,   117,   119,
   123,   146,   134,   141,   154,   157,   189,   192,   -74,   193,
   194,   209,   199,   210,   195,   197,   186,   205,    72,    59,
   180,     0,   200,     0,   201,   204,     0,     0,     0,   206
};

static const short mvl_y_check[] = {    42,
    30,    77,    44,     1,     1,     1,   125,    37,    38,   103,
     1,     1,     6,    93,     1,    45,     1,    58,   154,    33,
    11,    51,    52,   117,    66,   101,    17,    78,     1,    26,
    26,   161,     5,   113,    64,   129,    26,     5,     5,    26,
   123,     1,    33,    46,    47,    72,    73,    45,    41,    62,
    77,    72,    73,    26,    74,    53,    77,    26,    26,   189,
    69,   112,    29,   199,    58,    95,    26,    91,    14,    96,
    55,    61,   115,   156,   115,    96,    98,   107,    81,    82,
    94,    84,    85,    56,   203,     1,     1,    74,    56,     5,
     5,    61,     6,    74,     6,   138,    10,    26,   140,    26,
   194,    45,    13,    94,    13,   135,    10,    13,    99,   185,
   153,   141,   142,   111,   111,   111,   196,     5,   148,   149,
   163,   115,    13,    26,   127,   128,    98,    29,    12,    51,
     5,    79,    98,    53,     5,    13,     5,    18,    18,     3,
     5,     0,    10,     0,   179,   188,   158,   199,    61,    50,
   156,    -1,   192,    -1,   193,   198,    -1,    -1,    -1,   202
};
/* -*-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 mvl_y_errok		(mvl_y_errstatus = 0)
#define mvl_y_clearin	(mvl_y_char = MVL_Y_EMPTY)
#define MVL_Y_EMPTY		-2
#define MVL_Y_EOF		0
#define MVL_Y_ACCEPT	return(0)
#define MVL_Y_ABORT 	return(1)
#define MVL_Y_ERROR		goto mvl_y_errlab1
/* Like MVL_Y_ERROR except do call mvl_y_error.
   This remains here temporarily to ease the
   transition to the new meaning of MVL_Y_ERROR, for GCC.
   Once GCC version 2 has supplanted version 1, this can go.  */
#define MVL_Y_FAIL		goto mvl_y_errlab
#define MVL_Y_RECOVERING()  (!!mvl_y_errstatus)
#define MVL_Y_BACKUP(token, value) \
do								\
  if (mvl_y_char == MVL_Y_EMPTY && mvl_y_len == 1)				\
    { mvl_y_char = (token), mvl_y_lval = (value);			\
      mvl_y_char1 = MVL_Y_TRANSLATE (mvl_y_char);				\
      MVL_Y_POPSTACK;						\
      goto mvl_y_backup;						\
    }								\
  else								\
    { mvl_y_error ("syntax error: cannot back up"); MVL_Y_ERROR; }	\
while (0)

#define MVL_Y_TERROR	1
#define MVL_Y_ERRCODE	256

#ifndef MVL_Y_PURE
#define MVL_Y_LEX		mvl_y_lex()
#endif

#ifdef MVL_Y_PURE
#ifdef MVL_Y_LSP_NEEDED
#define MVL_Y_LEX		mvl_y_lex(&mvl_y_lval, &mvl_y_lloc)
#else
#define MVL_Y_LEX		mvl_y_lex(&mvl_y_lval)
#endif
#endif

/* If nonreentrant, generate the variables here */

#ifndef MVL_Y_PURE

int	mvl_y_char;			/*  the lookahead symbol		*/
MVL_Y_STYPE	mvl_y_lval;			/*  the semantic value of the		*/
				/*  lookahead symbol			*/

#ifdef MVL_Y_LSP_NEEDED
MVL_Y_LTYPE mvl_y_lloc;			/*  location data for the lookahead	*/
				/*  symbol				*/
#endif

int mvl_y_nerrs;			/*  number of parse errors so far       */
#endif  /* not MVL_Y_PURE */

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

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

#ifndef	MVL_Y_INITDEPTH
#define MVL_Y_INITDEPTH 200
#endif

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

#if MVL_Y_MAXDEPTH == 0
#undef MVL_Y_MAXDEPTH
#endif

#ifndef MVL_Y_MAXDEPTH
#define MVL_Y_MAXDEPTH 10000
#endif

#if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
#define __mvl_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
__mvl_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
__mvl_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
mvl_y_parse()
{
  register int mvl_y_state;
  register int mvl_y_n;
  register short *mvl_y_ssp;
  register MVL_Y_STYPE *mvl_y_vsp;
  int mvl_y_errstatus;	/*  number of tokens to shift before error messages enabled */
  int mvl_y_char1;		/*  lookahead token as an internal (translated) token number */

  short	mvl_y_ssa[MVL_Y_INITDEPTH];	/*  the state stack			*/
  MVL_Y_STYPE mvl_y_vsa[MVL_Y_INITDEPTH];	/*  the semantic value stack		*/

  short *mvl_y_ss = mvl_y_ssa;		/*  refer to the stacks thru separate pointers */
  MVL_Y_STYPE *mvl_y_vs = mvl_y_vsa;	/*  to allow mvl_y_overflow to reallocate them elsewhere */

#ifdef MVL_Y_LSP_NEEDED
  MVL_Y_LTYPE mvl_y_lsa[MVL_Y_INITDEPTH];	/*  the location stack			*/
  MVL_Y_LTYPE *mvl_y_ls = mvl_y_lsa;
  MVL_Y_LTYPE *mvl_y_lsp;

#define MVL_Y_POPSTACK   (mvl_y_vsp--, mvl_y_ssp--, mvl_y_lsp--)
#else
#define MVL_Y_POPSTACK   (mvl_y_vsp--, mvl_y_ssp--)
#endif

  int mvl_y_stacksize = MVL_Y_INITDEPTH;

#ifdef MVL_Y_PURE
  int mvl_y_char;
  MVL_Y_STYPE mvl_y_lval;
  int mvl_y_nerrs;
#ifdef MVL_Y_LSP_NEEDED
  MVL_Y_LTYPE mvl_y_lloc;
#endif
#endif

  MVL_Y_STYPE mvl_y_val;		/*  the variable used to return		*/
				/*  semantic values from the action	*/
				/*  routines				*/

  int mvl_y_len;

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

  mvl_y_state = 0;
  mvl_y_errstatus = 0;
  mvl_y_nerrs = 0;
  mvl_y_char = MVL_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.  */

  mvl_y_ssp = mvl_y_ss - 1;
  mvl_y_vsp = mvl_y_vs;
#ifdef MVL_Y_LSP_NEEDED
  mvl_y_lsp = mvl_y_ls;
#endif

/* Push a new state, which is found in  mvl_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.  */
mvl_y_newstate:

  *++mvl_y_ssp = mvl_y_state;

  if (mvl_y_ssp >= mvl_y_ss + mvl_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. */
      MVL_Y_STYPE *mvl_y_vs1 = mvl_y_vs;
      short *mvl_y_ss1 = mvl_y_ss;
#ifdef MVL_Y_LSP_NEEDED
      MVL_Y_LTYPE *mvl_y_ls1 = mvl_y_ls;
#endif

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

#ifdef mvl_y_overflow
      /* Each stack pointer address is followed by the size of
	 the data in use in that stack, in bytes.  */
      mvl_y_overflow("parser stack overflow",
		 &mvl_y_ss1, size * sizeof (*mvl_y_ssp),
		 &mvl_y_vs1, size * sizeof (*mvl_y_vsp),
#ifdef MVL_Y_LSP_NEEDED
		 &mvl_y_ls1, size * sizeof (*mvl_y_lsp),
#endif
		 &mvl_y_stacksize);

      mvl_y_ss = mvl_y_ss1; mvl_y_vs = mvl_y_vs1;
#ifdef MVL_Y_LSP_NEEDED
      mvl_y_ls = mvl_y_ls1;
#endif
#else /* no mvl_y_overflow */
      /* Extend the stack our own way.  */
      if (mvl_y_stacksize >= MVL_Y_MAXDEPTH)
	{
	  mvl_y_error("parser stack overflow");
	  return 2;
	}
      mvl_y_stacksize *= 2;
      if (mvl_y_stacksize > MVL_Y_MAXDEPTH)
	mvl_y_stacksize = MVL_Y_MAXDEPTH;
      mvl_y_ss = (short *) alloca (mvl_y_stacksize * sizeof (*mvl_y_ssp));
      __mvl_y__bcopy ((char *)mvl_y_ss1, (char *)mvl_y_ss, size * sizeof (*mvl_y_ssp));
      mvl_y_vs = (MVL_Y_STYPE *) alloca (mvl_y_stacksize * sizeof (*mvl_y_vsp));
      __mvl_y__bcopy ((char *)mvl_y_vs1, (char *)mvl_y_vs, size * sizeof (*mvl_y_vsp));
#ifdef MVL_Y_LSP_NEEDED
      mvl_y_ls = (MVL_Y_LTYPE *) alloca (mvl_y_stacksize * sizeof (*mvl_y_lsp));
      __mvl_y__bcopy ((char *)mvl_y_ls1, (char *)mvl_y_ls, size * sizeof (*mvl_y_lsp));
#endif
#endif /* no mvl_y_overflow */

      mvl_y_ssp = mvl_y_ss + size - 1;
      mvl_y_vsp = mvl_y_vs + size - 1;
#ifdef MVL_Y_LSP_NEEDED
      mvl_y_lsp = mvl_y_ls + size - 1;
#endif

#if MVL_Y_DEBUG != 0
      if (mvl_y_debug)
	fprintf(stderr, "Stack size increased to %d\n", mvl_y_stacksize);
#endif

      if (mvl_y_ssp >= mvl_y_ss + mvl_y_stacksize - 1)
	MVL_Y_ABORT;
    }

#if MVL_Y_DEBUG != 0
  if (mvl_y_debug)
    fprintf(stderr, "Entering state %d\n", mvl_y_state);
#endif

  goto mvl_y_backup;
 mvl_y_backup:

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

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

  mvl_y_n = mvl_y_pact[mvl_y_state];
  if (mvl_y_n == MVL_Y_FLAG)
    goto mvl_y_default;

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

  /* mvl_y_char is either MVL_Y_EMPTY or MVL_Y_EOF
     or a valid token in external form.  */

  if (mvl_y_char == MVL_Y_EMPTY)
    {
#if MVL_Y_DEBUG != 0
      if (mvl_y_debug)
	fprintf(stderr, "Reading a token: ");
#endif
      mvl_y_char = MVL_Y_LEX;
    }

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

  if (mvl_y_char <= 0)		/* This means end of input. */
    {
      mvl_y_char1 = 0;
      mvl_y_char = MVL_Y_EOF;		/* Don't call MVL_Y_LEX any more */

#if MVL_Y_DEBUG != 0
      if (mvl_y_debug)
	fprintf(stderr, "Now at end of input.\n");
#endif
    }
  else
    {
      mvl_y_char1 = MVL_Y_TRANSLATE(mvl_y_char);

#if MVL_Y_DEBUG != 0
      if (mvl_y_debug)
	{
	  fprintf (stderr, "Next token is %d (%s", mvl_y_char, mvl_y_tname[mvl_y_char1]);
	  /* Give the individual parser a way to print the precise meaning
	     of a token, for further debugging info.  */
#ifdef MVL_Y_PRINT
	  MVL_Y_PRINT (stderr, mvl_y_char, mvl_y_lval);
#endif
	  fprintf (stderr, ")\n");
	}
#endif
    }

  mvl_y_n += mvl_y_char1;
  if (mvl_y_n < 0 || mvl_y_n > MVL_Y_LAST || mvl_y_check[mvl_y_n] != mvl_y_char1)
    goto mvl_y_default;

  mvl_y_n = mvl_y_table[mvl_y_n];

  /* mvl_y_n is what to do for this token type in this state.
     Negative => reduce, -mvl_y_n is rule number.
     Positive => shift, mvl_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 (mvl_y_n < 0)
    {
      if (mvl_y_n == MVL_Y_FLAG)
	goto mvl_y_errlab;
      mvl_y_n = -mvl_y_n;
      goto mvl_y_reduce;
    }
  else if (mvl_y_n == 0)
    goto mvl_y_errlab;

  if (mvl_y_n == MVL_Y_FINAL)
    MVL_Y_ACCEPT;

  /* Shift the lookahead token.  */

#if MVL_Y_DEBUG != 0
  if (mvl_y_debug)
    fprintf(stderr, "Shifting token %d (%s), ", mvl_y_char, mvl_y_tname[mvl_y_char1]);
#endif

  /* Discard the token being shifted unless it is eof.  */
  if (mvl_y_char != MVL_Y_EOF)
    mvl_y_char = MVL_Y_EMPTY;

  *++mvl_y_vsp = mvl_y_lval;
#ifdef MVL_Y_LSP_NEEDED
  *++mvl_y_lsp = mvl_y_lloc;
#endif

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

  mvl_y_state = mvl_y_n;
  goto mvl_y_newstate;

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

  mvl_y_n = mvl_y_defact[mvl_y_state];
  if (mvl_y_n == 0)
    goto mvl_y_errlab;

/* Do a reduction.  mvl_y_n is the number of a rule to reduce with.  */
mvl_y_reduce:
  mvl_y_len = mvl_y_r2[mvl_y_n];
  mvl_y_val = mvl_y_vsp[1-mvl_y_len]; /* implement default value of the action */

#if MVL_Y_DEBUG != 0
  if (mvl_y_debug)
    {
      int i;

      fprintf (stderr, "Reducing via rule %d (line %d), ",
	       mvl_y_n, mvl_y_rline[mvl_y_n]);

      /* Print the symbols being reduced, and their result.  */
      for (i = mvl_y_prhs[mvl_y_n]; mvl_y_rhs[i] > 0; i++)
	fprintf (stderr, "%s ", mvl_y_tname[mvl_y_rhs[i]]);
      fprintf (stderr, " -> %s\n", mvl_y_tname[mvl_y_r1[mvl_y_n]]);
    }
#endif


  switch (mvl_y_n) {

case 1:
#line 225 "../struct/mvl_scomp.yac"
{
		freelomodel (MVL_CHDHED);
		mvl_fretab (MVL_HSHTAB);
		;
    break;}
case 2:
#line 235 "../struct/mvl_scomp.yac"
{
		MVL_HSHTAB = mvl_initab ();
                MVL_SIMFLG = 0;           /* simple flag                  */
                MVL_NM1LST = NULL;        /* 1-st name liste              */
                MVL_NM2LST = NULL;        /* 2-nd name liste              */
                MVL_CHDPNT = NULL;        /* current child pointer        */
                MVL_CHDHED = NULL;        /* childs list                  */

		MVL_MODNAM = mvl_y_vsp[-1].text;
		mvl_addtab (MVL_HSHTAB,MVL_MODNAM,MVL_MODNAM,MVL_MODDFN,
		            MVL_ROTDFN);
		;
    break;}
case 3:
#line 252 "../struct/mvl_scomp.yac"
{
		if ((mvl_y_vsp[-1].text != NULL) && (mvl_y_vsp[-1].text != mvl_y_vsp[-7].text))
		  mvl_error (1,mvl_y_vsp[-1].text);
		mvl_addtab (MVL_HSHTAB,MVL_MODNAM,MVL_MODNAM,MVL_CCNDFN,
		            MVL_CONCNT);
		MVL_CONCNT = 0;
		;
    break;}
case 4:
#line 261 "../struct/mvl_scomp.yac"
{ mvl_error (2,""); ;
    break;}
case 12:
#line 294 "../struct/mvl_scomp.yac"
{
            MVL_GENFLG = 1;
            ;
    break;}
case 13:
#line 298 "../struct/mvl_scomp.yac"
{
            MVL_GENFLG = 0;
            ;
    break;}
case 17:
#line 315 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = 0; ;
    break;}
case 18:
#line 317 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = 0; ;
    break;}
case 22:
#line 336 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = 0; ;
    break;}
case 23:
#line 341 "../struct/mvl_scomp.yac"
{
                mvl_y_val.name.LEFT  = -1;
                mvl_y_val.name.RIGHT = -1;
		mvl_y_val.name.ERR_FLG = 0;
                ;
    break;}
case 24:
#line 347 "../struct/mvl_scomp.yac"
{ mvl_y_val.name = mvl_y_vsp[0].name; ;
    break;}
case 25:
#line 354 "../struct/mvl_scomp.yac"
{ mvl_y_val.name = mvl_y_vsp[-1].name; ;
    break;}
case 26:
#line 361 "../struct/mvl_scomp.yac"
{
                mvl_y_val.name.LEFT  = mvl_y_vsp[-2].valu;
                mvl_y_val.name.RIGHT = mvl_y_vsp[0].valu;

                if (((mvl_y_vsp[-2].valu > mvl_y_vsp[0].valu) && (mvl_y_vsp[-1].valu == MVL_UPTDFN)) ||
		    ((mvl_y_vsp[-2].valu < mvl_y_vsp[0].valu) && (mvl_y_vsp[-1].valu == MVL_DWTDFN)))
		  {
                  mvl_error (32,"");
		  mvl_y_val.name.ERR_FLG = 1;
		  }
		else
		  mvl_y_val.name.ERR_FLG = 0;
                ;
    break;}
case 27:
#line 378 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_UPTDFN; ;
    break;}
case 28:
#line 380 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_DWTDFN; ;
    break;}
case 32:
#line 397 "../struct/mvl_scomp.yac"
{ mvl_error (3,""); ;
    break;}
case 36:
#line 420 "../struct/mvl_scomp.yac"
{
		struct locon *locon_pnt;
		struct losig *losig_pnt;
		int           sig_width;
		int           sig_conf;
		char         *sig_name;
		struct chain *sig_list;
		int           local_err;

		local_err = mvl_y_vsp[-1].name.ERR_FLG;
  		if ((mvl_y_vsp[-1].name.LEFT==-1)&&((mvl_y_vsp[-2].valu==MVL_BTVDFN)||(mvl_y_vsp[-2].valu==MVL_MXVDFN)||(mvl_y_vsp[-2].valu==MVL_WRVDFN)))
                  {
                  mvl_error (33,"");
                  }

		if (mvl_y_vsp[-1].name.LEFT <= mvl_y_vsp[-1].name.RIGHT)
		  sig_width = mvl_y_vsp[-1].name.RIGHT - mvl_y_vsp[-1].name.LEFT  + 1;
		else
		  sig_width = mvl_y_vsp[-1].name.LEFT  - mvl_y_vsp[-1].name.RIGHT + 1;

		sig_conf   = mvl_y_vsp[-3].valu + mvl_y_vsp[-2].valu + mvl_y_vsp[0].valu;
		MVL_NM1LST = reverse (MVL_NM1LST);
		sig_list   = MVL_NM1LST;
		while ((sig_list != NULL) && (local_err == 0))
		  {
		  sig_name = (char *)sig_list->DATA;

		  if (mvl_chktab (MVL_HSHTAB,sig_name,MVL_MODNAM,
		                  MVL_SIGDFN) != 0)
		    mvl_error (4,sig_name);
		  else
		    {
		    switch (sig_conf)
		      {
		      case (MVL_ICNDFN + MVL_BITDFN + MVL_NORDFN) :
		      case (MVL_ICNDFN + MVL_BTVDFN + MVL_NORDFN) :
		        losig_pnt = mvl_addlosig (MVL_LOFPNT,MVL_SIGIDX,'E','0',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        locon_pnt = mvl_addlocon (MVL_LOFPNT,losig_pnt,'I',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_OCNDFN + MVL_BITDFN + MVL_NORDFN) :
		      case (MVL_OCNDFN + MVL_BTVDFN + MVL_NORDFN) :
		        losig_pnt = mvl_addlosig (MVL_LOFPNT,MVL_SIGIDX,'E','0',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        locon_pnt = mvl_addlocon (MVL_LOFPNT,losig_pnt,'O',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_OCNDFN + MVL_MUXDFN + MVL_BUSDFN) :
		      case (MVL_OCNDFN + MVL_MXVDFN + MVL_BUSDFN) :
		        losig_pnt = mvl_addlosig (MVL_LOFPNT,MVL_SIGIDX,'E','M',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        locon_pnt = mvl_addlocon (MVL_LOFPNT,losig_pnt,'Z',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_OCNDFN + MVL_WORDFN + MVL_BUSDFN) :
		      case (MVL_OCNDFN + MVL_WRVDFN + MVL_BUSDFN) :
		        losig_pnt = mvl_addlosig (MVL_LOFPNT,MVL_SIGIDX,'E','W',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        locon_pnt = mvl_addlocon (MVL_LOFPNT,losig_pnt,'Z',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_BCNDFN + MVL_BITDFN + MVL_NORDFN) :
		      case (MVL_BCNDFN + MVL_BTVDFN + MVL_NORDFN) :
		        losig_pnt = mvl_addlosig (MVL_LOFPNT,MVL_SIGIDX,'E','0',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        locon_pnt = mvl_addlocon (MVL_LOFPNT,losig_pnt,'B',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_BCNDFN + MVL_MUXDFN + MVL_BUSDFN) :
		      case (MVL_BCNDFN + MVL_MXVDFN + MVL_BUSDFN) :
		        losig_pnt = mvl_addlosig (MVL_LOFPNT,MVL_SIGIDX,'E','M',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        locon_pnt = mvl_addlocon (MVL_LOFPNT,losig_pnt,'T',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_BCNDFN + MVL_WORDFN + MVL_BUSDFN) :
		      case (MVL_BCNDFN + MVL_WRVDFN + MVL_BUSDFN) :
		        losig_pnt = mvl_addlosig (MVL_LOFPNT,MVL_SIGIDX,'E','W',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        locon_pnt = mvl_addlocon (MVL_LOFPNT,losig_pnt,'T',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_XCNDFN + MVL_BITDFN + MVL_NORDFN) :
		      case (MVL_XCNDFN + MVL_BTVDFN + MVL_NORDFN) :
		        losig_pnt = mvl_addlosig (MVL_LOFPNT,MVL_SIGIDX,'E','0',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        locon_pnt = mvl_addlocon (MVL_LOFPNT,losig_pnt,'X',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;
		      default :
		        mvl_error (5,sig_name);
		        local_err = 1;
		        break;
		      }

		    if (local_err == 0)
		      {
		      mvl_addtab (MVL_HSHTAB,sig_name,MVL_MODNAM,MVL_PNTDFN,
		                  (int)losig_pnt);
		      mvl_addtab (MVL_HSHTAB,sig_name,MVL_MODNAM,MVL_SIGDFN,
		                  sig_conf);
                      mvl_addtab (MVL_HSHTAB,sig_name,MVL_MODNAM,MVL_LFTDFN,
		                  mvl_y_vsp[-1].name.LEFT);
                      mvl_addtab (MVL_HSHTAB,sig_name,MVL_MODNAM,MVL_RGTDFN,
		                  mvl_y_vsp[-1].name.RIGHT);
		      MVL_CONCNT += sig_width;
		      MVL_SIGIDX += sig_width;
		      }
		    }

		  sig_list = sig_list->NEXT;
		  }
		freechain (MVL_NM1LST);
		MVL_NM1LST = NULL;
		;
    break;}
case 37:
#line 544 "../struct/mvl_scomp.yac"
{
		/*   The following 3 lines reject tokens until the	*/
		/* sync. token ('Semicolon') is found		*/
 		do
		  mvl_y_char = mvl_y_lex ();
		while ((mvl_y_char != Semicolon) && (mvl_y_char != 0));
		mvl_y_errok;

		mvl_error (6,"");
		;
    break;}
case 38:
#line 558 "../struct/mvl_scomp.yac"
{
            if(strcmp(IN_LO,"vbe") == 0)
              {
              MVL_Y_ACCEPT;
              }
            ;
    break;}
case 39:
#line 568 "../struct/mvl_scomp.yac"
{
		if (mvl_y_vsp[-1].text != MVL_MODNAM)
		  mvl_error (1,mvl_y_vsp[-1].text);
		;
    break;}
case 40:
#line 578 "../struct/mvl_scomp.yac"
{
		if ((mvl_y_vsp[-1].text != NULL) && (mvl_y_vsp[-1].text != mvl_y_vsp[-10].text))
		  mvl_error (7,mvl_y_vsp[-1].text);
		;
    break;}
case 41:
#line 584 "../struct/mvl_scomp.yac"
{ mvl_error (8,""); ;
    break;}
case 47:
#line 602 "../struct/mvl_scomp.yac"
{ mvl_error (9,""); ;
    break;}
case 48:
#line 613 "../struct/mvl_scomp.yac"
{
		struct losig *losig_pnt;
		int           sig_width;
		int           sig_conf;
		char         *sig_name;
		struct chain *sig_list;
		int           local_err;

		local_err = mvl_y_vsp[-2].name.ERR_FLG;
                if ((mvl_y_vsp[-2].name.LEFT==-1)&&((mvl_y_vsp[-3].valu==MVL_BTVDFN)||(mvl_y_vsp[-3].valu==MVL_RGVDFN)))
                  {
                  mvl_error (33,"");
                  }
		if (mvl_y_vsp[-2].name.LEFT <= mvl_y_vsp[-2].name.RIGHT)
		  sig_width = mvl_y_vsp[-2].name.RIGHT - mvl_y_vsp[-2].name.LEFT  + 1;
		else
		  sig_width = mvl_y_vsp[-2].name.LEFT  - mvl_y_vsp[-2].name.RIGHT + 1;

		sig_conf   = mvl_y_vsp[-3].valu + mvl_y_vsp[-1].valu;
		MVL_NM1LST = reverse (MVL_NM1LST);
		sig_list   = MVL_NM1LST;
		while ((sig_list != NULL) && (local_err == 0))
		  {
		  sig_name = (char *)sig_list->DATA;

		  if (mvl_chktab (MVL_HSHTAB,sig_name,MVL_MODNAM,
		                  MVL_SIGDFN) != 0)
		    mvl_error (10,sig_name);
		  else
		    {
		    switch (sig_conf)
		      {
		      case (MVL_BITDFN + MVL_NORDFN):
		      case (MVL_BTVDFN + MVL_NORDFN):
		        losig_pnt = mvl_addlosig(MVL_LOFPNT,MVL_SIGIDX,'I','0',
		                                 sig_name,mvl_y_vsp[-2].name.LEFT,mvl_y_vsp[-2].name.RIGHT);
		        break;

		      case (MVL_MUXDFN + MVL_BUSDFN):
		      case (MVL_MXVDFN + MVL_BUSDFN):
		        losig_pnt = mvl_addlosig(MVL_LOFPNT,MVL_SIGIDX,'I','M',
		                                 sig_name,mvl_y_vsp[-2].name.LEFT,mvl_y_vsp[-2].name.RIGHT);
		        break;

		      case (MVL_WORDFN + MVL_BUSDFN):
		      case (MVL_WRVDFN + MVL_BUSDFN):
		        losig_pnt = mvl_addlosig(MVL_LOFPNT,MVL_SIGIDX,'I','W',
		                                 sig_name,mvl_y_vsp[-2].name.LEFT,mvl_y_vsp[-2].name.RIGHT);
		        break;

		      default:
		        mvl_error (11,sig_name);
		        local_err = 1;
		        break;
		      }

		    if (local_err == 0)
		      {
		      mvl_addtab (MVL_HSHTAB,sig_name,MVL_MODNAM,MVL_PNTDFN,
		                  (int)losig_pnt);
		      mvl_addtab (MVL_HSHTAB,sig_name,MVL_MODNAM,MVL_SIGDFN,
		                  sig_conf);
                      mvl_addtab (MVL_HSHTAB,sig_name,MVL_MODNAM,MVL_LFTDFN,
		                  mvl_y_vsp[-2].name.LEFT);
                      mvl_addtab (MVL_HSHTAB,sig_name,MVL_MODNAM,MVL_RGTDFN,
		                  mvl_y_vsp[-2].name.RIGHT);
		      MVL_SIGIDX += sig_width;
		      }
		    }

		  sig_list = sig_list->NEXT;
		  }
		freechain (MVL_NM1LST);
		MVL_NM1LST = NULL;
		;
    break;}
case 49:
#line 693 "../struct/mvl_scomp.yac"
{
		MVL_CHDNAM = mvl_y_vsp[0].text;

		if (mvl_chktab (MVL_HSHTAB,MVL_CHDNAM,MVL_MODNAM,MVL_MODDFN) != 0)
		  {
		  mvl_error (12,MVL_CHDNAM);
		  MVL_CHDPNT = NULL;
		  }
		else
		  {
		  MVL_CHDHED = addlomodel (MVL_CHDHED,MVL_CHDNAM);

		  MVL_CHDPNT = MVL_CHDHED;
		  mvl_addtab (MVL_HSHTAB,MVL_CHDNAM,MVL_MODNAM,MVL_MODDFN,MVL_CHDDFN);
		  }
		;
    break;}
case 50:
#line 713 "../struct/mvl_scomp.yac"
{
		if (MVL_CHDPNT != NULL)
		  {
		  mvl_addtab (MVL_HSHTAB,mvl_y_vsp[-5].text,MVL_MODNAM,MVL_CCNDFN,MVL_CONCNT);
		  MVL_LOFPNT->MODELCHAIN = addchain (MVL_LOFPNT->MODELCHAIN,mvl_y_vsp[-5].text);
		  }
		MVL_CONCNT = 0;
		;
    break;}
case 56:
#line 752 "../struct/mvl_scomp.yac"
{
		struct locon *locon_pnt;
		int           sig_width;
		int           sig_conf;
		char         *sig_name;
		struct chain *sig_list;
		int           local_err = 0;

		if ((mvl_y_vsp[-1].name.ERR_FLG != 0) || (MVL_CHDPNT == NULL))
		  local_err = 1;

                if ((mvl_y_vsp[-1].name.LEFT==-1)&&((mvl_y_vsp[-2].valu==MVL_BTVDFN)||(mvl_y_vsp[-2].valu==MVL_MXVDFN)||(mvl_y_vsp[-2].valu==MVL_WRVDFN)))
                  {
                  mvl_error (33,"");
                  }
		if (mvl_y_vsp[-1].name.LEFT <= mvl_y_vsp[-1].name.RIGHT)
		  sig_width = mvl_y_vsp[-1].name.RIGHT - mvl_y_vsp[-1].name.LEFT  + 1;
		else
		  sig_width = mvl_y_vsp[-1].name.LEFT  - mvl_y_vsp[-1].name.RIGHT + 1;

		sig_conf   = mvl_y_vsp[-3].valu + mvl_y_vsp[-2].valu + mvl_y_vsp[0].valu;
		MVL_NM1LST = reverse (MVL_NM1LST);
		sig_list   = MVL_NM1LST;
		while ((sig_list != NULL) && (local_err == 0))
		  {
		  sig_name = (char *)sig_list->DATA;
		  if (mvl_chktab (MVL_HSHTAB,sig_name,MVL_CHDNAM,
		                  MVL_SIGDFN) != 0)
		    mvl_error (4,sig_name);
		  else
		    {
		    switch (sig_conf)
		      {
		      case (MVL_ICNDFN + MVL_BITDFN + MVL_NORDFN) :
		      case (MVL_ICNDFN + MVL_BTVDFN + MVL_NORDFN) :
		        locon_pnt = mvl_addlocon (MVL_CHDPNT,NULL,'I',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_OCNDFN + MVL_BITDFN + MVL_NORDFN) :
		      case (MVL_OCNDFN + MVL_BTVDFN + MVL_NORDFN) :
		        locon_pnt = mvl_addlocon (MVL_CHDPNT,NULL,'O',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_OCNDFN + MVL_MUXDFN + MVL_BUSDFN) :
		      case (MVL_OCNDFN + MVL_MXVDFN + MVL_BUSDFN) :
		        locon_pnt = mvl_addlocon (MVL_CHDPNT,NULL,'Z',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_OCNDFN + MVL_WORDFN + MVL_BUSDFN) :
		      case (MVL_OCNDFN + MVL_WRVDFN + MVL_BUSDFN) :
		        locon_pnt = mvl_addlocon (MVL_CHDPNT,NULL,'Z',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_BCNDFN + MVL_BITDFN + MVL_NORDFN) :
		      case (MVL_BCNDFN + MVL_BTVDFN + MVL_NORDFN) :
		        locon_pnt = mvl_addlocon (MVL_CHDPNT,NULL,'B',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_BCNDFN + MVL_MUXDFN + MVL_BUSDFN) :
		      case (MVL_BCNDFN + MVL_MXVDFN + MVL_BUSDFN) :
		        locon_pnt = mvl_addlocon (MVL_CHDPNT,NULL,'T',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_BCNDFN + MVL_WORDFN + MVL_BUSDFN) :
		      case (MVL_BCNDFN + MVL_WRVDFN + MVL_BUSDFN) :
		        locon_pnt = mvl_addlocon (MVL_CHDPNT,NULL,'T',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      case (MVL_XCNDFN + MVL_BITDFN + MVL_NORDFN) :
		      case (MVL_XCNDFN + MVL_BTVDFN + MVL_NORDFN) :
		        locon_pnt = mvl_addlocon (MVL_CHDPNT,NULL,'X',
		                                  sig_name,mvl_y_vsp[-1].name.LEFT,mvl_y_vsp[-1].name.RIGHT);
		        break;

		      default :
		        mvl_error (5,sig_name);
		        local_err = 1;
		        break;
		      }

		    if (local_err == 0)
		      {
		      mvl_addtab (MVL_HSHTAB,MVL_CONCNT,MVL_CHDNAM,MVL_PNTDFN,
		                  sig_name);
		      mvl_addtab (MVL_HSHTAB,sig_name,  MVL_CHDNAM,MVL_SIGDFN,
		                  sig_conf);
		      mvl_addtab (MVL_HSHTAB,sig_name,  MVL_CHDNAM,MVL_RNGDFN,
		                  MVL_CONCNT);
		      mvl_addtab (MVL_HSHTAB,sig_name,  MVL_CHDNAM,MVL_LFTDFN,
		                  mvl_y_vsp[-1].name.LEFT);
		      mvl_addtab (MVL_HSHTAB,sig_name,  MVL_CHDNAM,MVL_RGTDFN,
		                  mvl_y_vsp[-1].name.RIGHT);
		      MVL_CONCNT += sig_width;
		      }
		    }
		  sig_list = sig_list->NEXT;
		  }
		freechain (MVL_NM1LST);
		MVL_NM1LST = NULL;
		;
    break;}
case 57:
#line 860 "../struct/mvl_scomp.yac"
{
		/*   The following 3 lines reject tokens until the	*/
		/* sync. token ('Semicolon') is found			*/
		do
		  mvl_y_char = mvl_y_lex ();
		while ((mvl_y_char != Semicolon) && (mvl_y_char != 0));
		mvl_y_errok;

		mvl_error (6,"");
		;
    break;}
case 62:
#line 886 "../struct/mvl_scomp.yac"
{
		mvl_error (18,"");
		;
    break;}
case 63:
#line 894 "../struct/mvl_scomp.yac"
{
		int con_count;
		int local_err = 0;

		MVL_CONRNK = 0;
		MVL_CHDNAM = mvl_y_vsp[0].text;
                MVL_LOCNAM = mvl_y_vsp[-1].text;
                /* Verifying the component has been declared before */
		if (mvl_chktab (MVL_HSHTAB,mvl_y_vsp[-1].text,MVL_MODNAM,MVL_LBLDFN) != 0)
		  {
		  mvl_error (13,mvl_y_vsp[-1].text);
		  local_err = 1;
		  }

		if (mvl_chktab (MVL_HSHTAB,mvl_y_vsp[0].text,MVL_MODNAM,
		                MVL_MODDFN) != MVL_CHDDFN)
		  {
		  mvl_error (14,mvl_y_vsp[0].text);
		  local_err = 1;
		  }

		if (local_err == 0)
		  {
		  mvl_addtab (MVL_HSHTAB,mvl_y_vsp[-1].text,MVL_MODNAM,MVL_LBLDFN,1);
		  con_count  = mvl_chktab (MVL_HSHTAB,mvl_y_vsp[0].text,MVL_MODNAM,MVL_CCNDFN);
		  MVL_NM1LST = NULL;
		  while (con_count != 0)
		    {
		    MVL_NM1LST = addchain (MVL_NM1LST,NULL);
		    con_count--;
		    }
		  MVL_CHDPNT = MVL_CHDHED;
		  while (MVL_CHDPNT != NULL)
		    {
		    if (MVL_CHDPNT->NAME == mvl_y_vsp[0].text)
		      break;
		    MVL_CHDPNT = MVL_CHDPNT->NEXT;
		    }
		  }
		else
		  MVL_CHDPNT = NULL;
		;
    break;}
case 64:
#line 938 "../struct/mvl_scomp.yac"
{
		struct loins *loins_pnt;
                struct chain *chain_pnt;
                char         *prt_name;
                int           i=0;

                chain_pnt  = MVL_NM1LST;


/*--------- Here checking than connectors of the instance are connected --
                while (chain_pnt != NULL)
                  {
                  if (chain_pnt->DATA == NULL)
                    {
                    prt_name  = (char *) mvl_chktab (MVL_HSHTAB,i,
                                                     MVL_CHDNAM,MVL_PNTDFN);
                    (void)fprintf(stderr,"CHECK = %s type = %d\n",prt_name,
                            mvl_chktab(MVL_HSHTAB,prt_name,MVL_CHDNAM,MVL_SIGDFN) & 0x00000007);
                    break;
                    }
                  i++;
                  chain_pnt = chain_pnt->NEXT;
                  }
------------------------- End checking connections ---------*/
		
/*--------- Here create a Not Connected losig for a locon not connected ---*/
                while (chain_pnt != NULL)
                  {
                  if (chain_pnt->DATA == NULL)
                    {
                    char tampon[256];
                  
/*--                    mvl_warning (42,(char *) mvl_chktab (MVL_HSHTAB,i,
                                               MVL_CHDNAM,MVL_PNTDFN)); --- */
                    MVL_SIGIDX++;
                    (void)sprintf(tampon,"NOT_CONNECTED_%d",MVL_SIGIDX);
                    chain_pnt->DATA = mvl_addlosig(MVL_LOFPNT,MVL_SIGIDX,
                                        'I','0',tampon,-1,-1);
                    }
                  i++;
                  chain_pnt = chain_pnt->NEXT;
                  }
/*------------------------- End creating connections ---------*/
		MVL_NM1LST = reverse (MVL_NM1LST);
		if ((MVL_CHDPNT != NULL) 
                   && (MVL_ERRFLG ==0))
		  loins_pnt = addloins (MVL_LOFPNT,mvl_y_vsp[-4].text,MVL_CHDPNT,MVL_NM1LST,
		                        NULL);
		freechain (MVL_NM1LST);
		MVL_NM1LST = NULL;
		MVL_SIMFLG = MVL_UKNDFN;
		;
    break;}
case 71:
#line 1021 "../struct/mvl_scomp.yac"
{
		int           sig_width;
		int           con_pos;
		struct chain *sig_list1;
		struct chain *sig_list2;
		int           local_err = 0;

		if (MVL_CHDPNT == NULL)
		  local_err = 1;
		sig_list1 = MVL_NM1LST;

		if (MVL_SIMFLG == MVL_IMPDFN)
		  sig_list1 = MVL_NM2LST;
		MVL_SIMFLG = MVL_EXPDFN;

                if (mvl_y_vsp[-2].name.LEFT <= mvl_y_vsp[-2].name.RIGHT)
                  sig_width = mvl_y_vsp[-2].name.RIGHT - mvl_y_vsp[-2].name.LEFT + 1;
                else
                  sig_width = mvl_y_vsp[-2].name.LEFT - mvl_y_vsp[-2].name.RIGHT + 1;

		if (local_err == 0)
		  {
		  if (sig_width != mvl_y_vsp[0].expr.WIDTH)
		    mvl_error (38,"");
		  else
		    {
                    if(MVL_ERRFLG == 0)
                      { 
		      con_pos = mvl_chktab (MVL_HSHTAB,mvl_y_vsp[-2].name.NAME,MVL_CHDNAM,
		                            MVL_RNGDFN);
		      while (con_pos != 0)
		        {
		        sig_list1 = sig_list1->NEXT;
		        con_pos--;
		        }
		      sig_list2 = mvl_y_vsp[0].expr.LIST;
		      while (sig_list2 != NULL)
		        {
		        if (sig_list1->DATA != NULL)
		          {
		          mvl_error (41,mvl_y_vsp[-2].name.NAME);
		          break;
		          }
		        sig_list1->DATA = sig_list2->DATA;
		        sig_list2       = sig_list2->NEXT;
		        sig_list1       = sig_list1->NEXT;
		        }
                      } 
		    }
		  }
		freechain (mvl_y_vsp[0].expr.LIST);
		;
    break;}
case 72:
#line 1074 "../struct/mvl_scomp.yac"
{
		int           sig_width;
		struct chain *sig_list1;
		char         *prt_name;
		int           prt_width;
		int           left_bnd;
		int           right_bnd;
		int           local_err = 0;
                int           i;

		if (MVL_CHDPNT == NULL)
		  local_err = 1;

		if (MVL_SIMFLG == MVL_UKNDFN)
		  {
		  MVL_SIMFLG = MVL_IMPDFN;
		  MVL_NM2LST = MVL_NM1LST;
		  }
		if (MVL_SIMFLG != MVL_IMPDFN)
		  {
		  mvl_error (15,"");
		  local_err = 1;
		  }

		prt_name  = (char *) mvl_chktab (MVL_HSHTAB,MVL_CONRNK,
		                                 MVL_CHDNAM,MVL_PNTDFN);
                if(prt_name == NULL)
                {
                local_err = 1;
                mvl_error(76,MVL_LOCNAM);
                }
		right_bnd = mvl_chktab (MVL_HSHTAB,prt_name,MVL_CHDNAM,
		                        MVL_LFTDFN);
		left_bnd  = mvl_chktab (MVL_HSHTAB,prt_name,MVL_CHDNAM,
		                        MVL_RGTDFN);

		if (left_bnd <= right_bnd)
                  prt_width = right_bnd - left_bnd  + 1;
		else
                  prt_width = left_bnd  - right_bnd + 1;

		if (local_err == 0)
		  {
		  if (prt_width != mvl_y_vsp[0].expr.WIDTH)
                    {
		    mvl_error (38,"");
                    for(i=0;i<prt_width;i++)
                      MVL_NM2LST = MVL_NM2LST->NEXT;
                    }
		  else
		    {
		    sig_list1 = mvl_y_vsp[0].expr.LIST;
		    while (sig_list1 != NULL)
		      {
		      MVL_NM2LST->DATA = sig_list1->DATA;
		      sig_list1        = sig_list1->NEXT;
		      MVL_NM2LST       = MVL_NM2LST->NEXT;
		      }
		    }
		  MVL_CONRNK += prt_width;
		  }
		freechain (mvl_y_vsp[0].expr.LIST);
		;
    break;}
case 73:
#line 1138 "../struct/mvl_scomp.yac"
{
		/*   The following 3 lines reject tokens until the	*/
		/* sync. token ('Comma') is found			*/
		do
		  mvl_y_char = mvl_y_lex ();
		while ((mvl_y_char != Comma) && (mvl_y_char != 0));
		mvl_y_errok;

		MVL_CONRNK++;
		mvl_error (31,"");
		;
    break;}
case 74:
#line 1153 "../struct/mvl_scomp.yac"
{
		if (MVL_CHDPNT != NULL)
		  {
		  if (mvl_chktab(MVL_HSHTAB,mvl_y_vsp[0].name.NAME,MVL_CHDNAM,MVL_SIGDFN) != 0)
		    {
                    mvl_y_val.name.LEFT  = mvl_chktab (MVL_HSHTAB,mvl_y_vsp[0].name.NAME,MVL_CHDNAM,
		                           MVL_LFTDFN);
                    mvl_y_val.name.RIGHT = mvl_chktab (MVL_HSHTAB,mvl_y_vsp[0].name.NAME,MVL_CHDNAM,
		                           MVL_RGTDFN);
                    }
		  else
		    {
		    mvl_error (16,mvl_y_vsp[0].name.NAME);
		    mvl_y_val.name = mvl_y_vsp[0].name;
		    }
		  }
		else
		  mvl_y_val.name = mvl_y_vsp[0].name;
		;
    break;}
case 75:
#line 1176 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[0].expr; 
                ;
    break;}
case 76:
#line 1182 "../struct/mvl_scomp.yac"
{
                mvl_y_val.name.NAME  = mvl_y_vsp[0].text;
  		mvl_y_val.name.LEFT  = -1;
  		mvl_y_val.name.RIGHT = -1;
                ;
    break;}
case 77:
#line 1188 "../struct/mvl_scomp.yac"
{ mvl_y_val.name = mvl_y_vsp[0].name; ;
    break;}
case 78:
#line 1190 "../struct/mvl_scomp.yac"
{ mvl_y_val.name = mvl_y_vsp[0].name; ;
    break;}
case 79:
#line 1198 "../struct/mvl_scomp.yac"
{
                mvl_y_val.name.NAME  = mvl_y_vsp[-3].text;
                mvl_y_val.name.LEFT  = mvl_y_vsp[-1].valu;
                mvl_y_val.name.RIGHT = mvl_y_vsp[-1].valu;
                ;
    break;}
case 80:
#line 1208 "../struct/mvl_scomp.yac"
{
                mvl_y_val.name.NAME  = mvl_y_vsp[-1].text;
                mvl_y_val.name.LEFT  = mvl_y_vsp[0].name.LEFT;
                mvl_y_val.name.RIGHT = mvl_y_vsp[0].name.RIGHT;
                ;
    break;}
case 81:
#line 1218 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[0].expr; 
                 ;
    break;}
case 82:
#line 1224 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[0].expr; 
                ;
    break;}
case 83:
#line 1230 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[0].expr; 
                ;
    break;}
case 84:
#line 1236 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[0].expr; ;
    break;}
case 85:
#line 1240 "../struct/mvl_scomp.yac"
{
		struct chain *list1;

		list1 = mvl_y_vsp[-2].expr.LIST;
		while (list1->NEXT != NULL)
		  list1 = list1->NEXT;

		list1->NEXT = mvl_y_vsp[0].expr.LIST;
		mvl_y_val.expr.LIST     = mvl_y_vsp[-2].expr.LIST;
		mvl_y_val.expr.WIDTH    = mvl_y_vsp[-2].expr.WIDTH + mvl_y_vsp[0].expr.WIDTH;
                ;
    break;}
case 86:
#line 1256 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[0].expr; ;
    break;}
case 87:
#line 1262 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[0].expr; ;
    break;}
case 88:
#line 1267 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[0].expr; ;
    break;}
case 89:
#line 1269 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[0].expr; ;
    break;}
case 90:
#line 1271 "../struct/mvl_scomp.yac"
{
		mvl_expr      expr;
		struct losig *losig_pnt;
		int           i;
		int           left;
		int           right;
		int           left_bnd;
		int           right_bnd;
		int           sig_width;
		int           rev_flg;
		int           in_bound;
		int           out_bound;

		if (mvl_chktab (MVL_HSHTAB,mvl_y_vsp[0].name.NAME,MVL_MODNAM,MVL_SIGDFN) != 0)
		  {
  		  left_bnd  = mvl_chktab (MVL_HSHTAB,mvl_y_vsp[0].name.NAME,MVL_MODNAM,
		                          MVL_LFTDFN);
  		  right_bnd = mvl_chktab (MVL_HSHTAB,mvl_y_vsp[0].name.NAME,MVL_MODNAM,
		                          MVL_RGTDFN);

		  if (mvl_y_vsp[0].name.LEFT == -1)
		    {
		    left  = left_bnd;
		    right = right_bnd;
		    }
		  else
		    {
		    left  = mvl_y_vsp[0].name.LEFT;
		    right = mvl_y_vsp[0].name.RIGHT;
		    }

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

    		  losig_pnt = (struct losig *)
		              mvl_chktab (MVL_HSHTAB,mvl_y_vsp[0].name.NAME,MVL_MODNAM,
		                          MVL_PNTDFN);
		  expr.LIST = NULL;
		  for (i=0 ; i<sig_width ; i++)
		    {
		    if (i >= in_bound)
		      expr.LIST = addchain (expr.LIST,losig_pnt);
		    if (i >= out_bound)
		      break;
		    losig_pnt = losig_pnt->NEXT;
		    }
		  if (rev_flg == 1)
		    expr.LIST = reverse (expr.LIST);
		  }
		else
		  {
		  mvl_error(17,mvl_y_vsp[0].name.NAME);
		  expr.WIDTH = 1;
		  expr.LIST  = addchain (NULL,NULL);
		  }
		mvl_y_val.expr = expr;
		;
    break;}
case 91:
#line 1376 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[-1].expr; ;
    break;}
case 92:
#line 1384 "../struct/mvl_scomp.yac"
{ mvl_y_val.expr = mvl_y_vsp[-1].expr; ;
    break;}
case 95:
#line 1395 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_ICNDFN; ;
    break;}
case 96:
#line 1397 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_ICNDFN; ;
    break;}
case 97:
#line 1399 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_OCNDFN; ;
    break;}
case 98:
#line 1401 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_BCNDFN; ;
    break;}
case 99:
#line 1403 "../struct/mvl_scomp.yac"
{
		mvl_warning (2,"");
		mvl_y_val.valu = MVL_XCNDFN;
		;
    break;}
case 100:
#line 1411 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_ICNDFN; ;
    break;}
case 101:
#line 1413 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_ICNDFN; ;
    break;}
case 102:
#line 1415 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_OCNDFN; ;
    break;}
case 103:
#line 1417 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_BCNDFN; ;
    break;}
case 104:
#line 1419 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_XCNDFN; ;
    break;}
case 105:
#line 1424 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_BITDFN; ;
    break;}
case 106:
#line 1426 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_WORDFN; ;
    break;}
case 107:
#line 1428 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_MUXDFN; ;
    break;}
case 108:
#line 1430 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_BTVDFN; ;
    break;}
case 109:
#line 1432 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_WRVDFN; ;
    break;}
case 110:
#line 1434 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_MXVDFN; ;
    break;}
case 111:
#line 1436 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = 0; ;
    break;}
case 112:
#line 1438 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = 0; ;
    break;}
case 113:
#line 1443 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_NORDFN; ;
    break;}
case 114:
#line 1445 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = MVL_BUSDFN; ;
    break;}
case 115:
#line 1450 "../struct/mvl_scomp.yac"
{ 
                if(MVL_GENFLG != 1)
                  MVL_NM1LST = addchain (MVL_NM1LST,mvl_y_vsp[0].text); 
                ;
    break;}
case 118:
#line 1462 "../struct/mvl_scomp.yac"
{ 
                if(MVL_GENFLG != 1)
                  MVL_NM1LST = addchain (MVL_NM1LST,mvl_y_vsp[0].text); 
                ;
    break;}
case 119:
#line 1471 "../struct/mvl_scomp.yac"
{ mvl_y_val.text = mvl_y_vsp[-1].text; 
                ;
    break;}
case 120:
#line 1477 "../struct/mvl_scomp.yac"
{ mvl_y_val.text = NULL; ;
    break;}
case 121:
#line 1479 "../struct/mvl_scomp.yac"
{ mvl_y_val.text = mvl_y_vsp[0].text; ;
    break;}
case 122:
#line 1484 "../struct/mvl_scomp.yac"
{ mvl_y_val.text = mvl_y_vsp[0].text; ;
    break;}
case 123:
#line 1489 "../struct/mvl_scomp.yac"
{ mvl_y_errok; ;
    break;}
case 124:
#line 1494 "../struct/mvl_scomp.yac"
{ mvl_y_val.valu = atoi (mvl_y_vsp[0].valu); ;
    break;}
case 125:
#line 1499 "../struct/mvl_scomp.yac"
{ mvl_y_errok; ;
    break;}
case 126:
#line 1504 "../struct/mvl_scomp.yac"
{ mvl_y_errok; ;
    break;}
}
   /* the action file gets copied in in place of this dollarsign */
#line 442 "/labo/gnu/lib/bison.simple"

  mvl_y_vsp -= mvl_y_len;
  mvl_y_ssp -= mvl_y_len;
#ifdef MVL_Y_LSP_NEEDED
  mvl_y_lsp -= mvl_y_len;
#endif

#if MVL_Y_DEBUG != 0
  if (mvl_y_debug)
    {
      short *ssp1 = mvl_y_ss - 1;
      fprintf (stderr, "state stack now");
      while (ssp1 != mvl_y_ssp)
	fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

  *++mvl_y_vsp = mvl_y_val;

#ifdef MVL_Y_LSP_NEEDED
  mvl_y_lsp++;
  if (mvl_y_len == 0)
    {
      mvl_y_lsp->first_line = mvl_y_lloc.first_line;
      mvl_y_lsp->first_column = mvl_y_lloc.first_column;
      mvl_y_lsp->last_line = (mvl_y_lsp-1)->last_line;
      mvl_y_lsp->last_column = (mvl_y_lsp-1)->last_column;
      mvl_y_lsp->text = 0;
    }
  else
    {
      mvl_y_lsp->last_line = (mvl_y_lsp+mvl_y_len-1)->last_line;
      mvl_y_lsp->last_column = (mvl_y_lsp+mvl_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.  */

  mvl_y_n = mvl_y_r1[mvl_y_n];

  mvl_y_state = mvl_y_pgoto[mvl_y_n - MVL_Y_NTBASE] + *mvl_y_ssp;
  if (mvl_y_state >= 0 && mvl_y_state <= MVL_Y_LAST && mvl_y_check[mvl_y_state] == *mvl_y_ssp)
    mvl_y_state = mvl_y_table[mvl_y_state];
  else
    mvl_y_state = mvl_y_defgoto[mvl_y_n - MVL_Y_NTBASE];

  goto mvl_y_newstate;

mvl_y_errlab:   /* here on detecting error */

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

#ifdef MVL_Y_ERROR_VERBOSE
      mvl_y_n = mvl_y_pact[mvl_y_state];

      if (mvl_y_n > MVL_Y_FLAG && mvl_y_n < MVL_Y_LAST)
	{
	  int size = 0;
	  char *msg;
	  int x, count;

	  count = 0;
	  for (x = 0; x < (sizeof(mvl_y_tname) / sizeof(char *)); x++)
	    if (mvl_y_check[x + mvl_y_n] == x)
	      size += strlen(mvl_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(mvl_y_tname) / sizeof(char *)); x++)
		    if (mvl_y_check[x + mvl_y_n] == x)
		      {
			strcat(msg, count == 0 ? ", expecting `" : " or `");
			strcat(msg, mvl_y_tname[x]);
			strcat(msg, "'");
			count++;
		      }
		}
	      mvl_y_error(msg);
	      free(msg);
	    }
	  else
	    mvl_y_error ("parse error; also virtual memory exceeded");
	}
      else
#endif /* MVL_Y_ERROR_VERBOSE */
	mvl_y_error("parse error");
    }

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

  if (mvl_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 (mvl_y_char == MVL_Y_EOF)
	MVL_Y_ABORT;

#if MVL_Y_DEBUG != 0
      if (mvl_y_debug)
	fprintf(stderr, "Discarding token %d (%s).\n", mvl_y_char, mvl_y_tname[mvl_y_char1]);
#endif

      mvl_y_char = MVL_Y_EMPTY;
    }

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

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

  goto mvl_y_errhandle;

mvl_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.  */
  mvl_y_n = mvl_y_defact[mvl_y_state];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  if (mvl_y_n) goto mvl_y_default;
#endif

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

  if (mvl_y_ssp == mvl_y_ss) MVL_Y_ABORT;
  mvl_y_vsp--;
  mvl_y_state = *--mvl_y_ssp;
#ifdef MVL_Y_LSP_NEEDED
  mvl_y_lsp--;
#endif

#if MVL_Y_DEBUG != 0
  if (mvl_y_debug)
    {
      short *ssp1 = mvl_y_ss - 1;
      fprintf (stderr, "Error: state stack now");
      while (ssp1 != mvl_y_ssp)
	fprintf (stderr, " %d", *++ssp1);
      fprintf (stderr, "\n");
    }
#endif

mvl_y_errhandle:

  mvl_y_n = mvl_y_pact[mvl_y_state];
  if (mvl_y_n == MVL_Y_FLAG)
    goto mvl_y_errdefault;

  mvl_y_n += MVL_Y_TERROR;
  if (mvl_y_n < 0 || mvl_y_n > MVL_Y_LAST || mvl_y_check[mvl_y_n] != MVL_Y_TERROR)
    goto mvl_y_errdefault;

  mvl_y_n = mvl_y_table[mvl_y_n];
  if (mvl_y_n < 0)
    {
      if (mvl_y_n == MVL_Y_FLAG)
	goto mvl_y_errpop;
      mvl_y_n = -mvl_y_n;
      goto mvl_y_reduce;
    }
  else if (mvl_y_n == 0)
    goto mvl_y_errpop;

  if (mvl_y_n == MVL_Y_FINAL)
    MVL_Y_ACCEPT;

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

  *++mvl_y_vsp = mvl_y_lval;
#ifdef MVL_Y_LSP_NEEDED
  *++mvl_y_lsp = mvl_y_lloc;
#endif

  mvl_y_state = mvl_y_n;
  goto mvl_y_newstate;
}
#line 1507 "../struct/mvl_scomp.yac"

