distrib/sources/mbkvrlog/mgl_scomp.yac

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   AVERTEC                      */
   4 /*                                                                          */
   5 /*    Produit : Structural Verilog Compiler                                 */
   6 /*    Fichier : mgl_scomp.yac                                               */
   7 /*                                                                          */
   8 /*    (c) copyright 2000 AVERTEC                                            */
   9 /*    Tous droits reserves                                                  */
  10 /*                                                                          */
  11 /*    Auteur(s) : Anthony LESTER                                            */
  12 /*                                                                          */
  13 /*                                                                          */
  14 /****************************************************************************/
  15
  16 %{
  17
  18 #define YYDEBUG 1
  19 #define YYPARSE_PARAM parm
  20 #define YYLEX_PARAM parm
  21
  22 #define MGL_CONTEXT(x) ((mgl_getcontext(parm))->x)
  23
  24 #undef yyerror
  25 #define yyerror(x) mgl_scomperror(x, (mgl_getcontext(parm)))
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29
  30 #include AVT_H
  31 #include MUT_H
  32 #include MLO_H
  33 #include MLU_H
  34 #include MGL_H
  35
  36 #include "mgl_type.h"
  37 #include "mgl_parse.h"
  38 #include "mgl_util.h"
  39 #include "mgl_error.h"
  40
  41 #undef __GNUC__ /* to get round a bug in bison.simple */
  42
  43 /*****************************************************************************
  44 * function declarations                                                      *
  45 *****************************************************************************/
  46
  47 void mgl_scompclean();
  48 int mgl_scomperror();
  49 int mgl_scomplex();
  50
  51 %}
  52
  53 %pure_parser
  54
  55 %union {
  56     double      decimal;
  57     int         integer;
  58     int         base;
  59     char       *text;
  60     mgl_name    name;
  61     mgl_expr    expr;
  62 };
  63
  64 %expect 1
  65
  66 %token T_ALWAYS
  67 %token T_AND
  68 %token T_ASSIGN
  69 %token T_ATTRIBUTE
  70
  71 %token T_BEGIN
  72 %token T_BUF
  73 %token T_BUFIF0
  74 %token T_BUFIF1
  75
  76 %token T_CASE
  77 %token T_CASEX
  78 %token T_CASEZ
  79 %token T_CMOS
  80
  81 %token T_DEASSIGN
  82 %token T_DEFAULT
  83 %token T_DEFPARAM
  84 %token T_DISABLE
  85
  86 %token T_EDGE
  87 %token T_ELSE
  88 %token T_END
  89 %token T_ENDATTRIBUTE
  90 %token T_ENDCASE
  91 %token T_ENDFUNCTION
  92 %token T_ENDMODULE
  93 %token T_ENDPRIMITIVE
  94 %token T_ENDSPECIFY
  95 %token T_ENDTABLE
  96 %token T_ENDTASK
  97 %token T_EVENT
  98
  99 %token T_FOR
 100 %token T_FORCE
 101 %token T_FOREVER
 102 %token T_FORK
 103 %token T_FUNCTION
 104
 105 %token T_HIGHZ0
 106 %token T_HIGHZ1
 107
 108 %token T_IF
 109 %token T_IFNONE
 110 %token T_INITIAL
 111 %token T_INOUT
 112 %token T_INPUT
 113 %token T_INTEGER
 114
 115 %token T_JOIN
 116
 117 %token T_LARGE
 118
 119 %token T_MEDIUM
 120 %token T_MODULE
 121 %token T_MACROMODULE
 122
 123 %token T_NAND
 124 %token T_NEGEDGE
 125 %token T_NMOS
 126 %token T_NOR
 127 %token T_NOT
 128 %token T_NOTIF0
 129 %token T_NOTIF1
 130
 131 %token T_OR
 132 %token T_OUTPUT
 133
 134 %token T_PARAMETER
 135 %token T_PMOS
 136 %token T_POSEDGE
 137 %token T_PRIMITIVE
 138 %token T_PULL0
 139 %token T_PULL1
 140 %token T_PULLDOWN
 141 %token T_PULLUP
 142
 143 %token T_RCMOS
 144 %token T_REAL
 145 %token T_REALTIME
 146 %token T_REG
 147 %token T_RELEASE
 148 %token T_REPEAT
 149 %token T_RNMOS
 150 %token T_RPMOS
 151 %token T_RTRAN
 152 %token T_RTRANIF0
 153 %token T_RTRANIF1
 154
 155 %token T_SCALARED
 156 %token T_SIGNED
 157 %token T_SMALL
 158 %token T_SPECIFY
 159 %token T_SPECPARAM
 160 %token T_STRENGTH
 161 %token T_STRONG0
 162 %token T_STRONG1
 163 %token T_SUPPLY0
 164 %token T_SUPPLY1
 165
 166 %token T_TABLE
 167 %token T_TASK
 168 %token T_TIME
 169 %token T_TRAN
 170 %token T_TRANIF0
 171 %token T_TRANIF1
 172 %token T_TRI
 173 %token T_TRI0
 174 %token T_TRI1
 175 %token T_TRIAND
 176 %token T_TRIOR
 177 %token T_TRIREG
 178
 179 %token T_UNSIGNED
 180
 181 %token T_VECTORED
 182
 183 %token T_WAIT
 184 %token T_WAND
 185 %token T_WEAK0
 186 %token T_WEAK1
 187 %token T_WHILE
 188 %token T_WIRE
 189 %token T_WOR
 190
 191 %token T_XNOR
 192 %token T_XOR
 193
 194 %token T_LOGICAL_NOT
 195 %token T_LOGICAL_AND
 196 %token T_LOGICAL_OR
 197 %token T_BITWISE_NOT
 198 %token T_BITWISE_AND
 199 %token T_BITWISE_NAND
 200 %token T_BITWISE_OR
 201 %token T_BITWISE_NOR
 202 %token T_BITWISE_EXOR
 203 %token T_BITWISE_EXNOR
 204 %token T_MINUS
 205 %token T_PLUS
 206 %token T_MULTIPLY
 207 %token T_DIVIDE
 208 %token T_MODULO
 209 %token T_EQUALS
 210 %token T_DOES_NOT_EQUAL
 211 %token T_LESS_THAN
 212 %token T_LESS_THAN_OR_EQUAL_TO
 213 %token T_GREATER_THAN
 214 %token T_GREATER_THAN_OR_EQUAL_TO
 215 %token T_IDENTICAL
 216 %token T_NOT_IDENTICAL
 217 %token T_SHIFT_LEFT
 218 %token T_SHIFT_RIGHT
 219
 220 %token T_LEADTO
 221 %token T_ALLPATH
 222 %token T_CONDITIONAL
 223
 224 %token SYS_SETUP
 225 %token SYS_HOLD
 226 %token SYS_SETUPHOLD
 227 %token SYS_SKEW
 228 %token SYS_RECOVERY
 229 %token SYS_PERIOD
 230 %token SYS_WIDTH
 231
 232 %token <text>    Identifier SystemIdentifier
 233 %token <decimal> RealLit
 234 %token <integer> IntegerLit
 235 %token <text>    StringLit
 236 %token <text>    MinTypMaxLit
 237
 238 %right '?' ':'
 239 %left T_LOGICAL_OR
 240 %left T_LOGICAL_AND
 241 %left T_BITWISE_OR
 242 %left T_BITWISE_AND T_BITWISE_EXOR T_BITWISE_EXNOR
 243 %left T_EQUALS T_DOES_NOT_EQUAL T_IDENTICAL T_NOT_IDENTICAL
 244 %left T_LESS_THAN T_LESS_THAN_OR_EQUAL_TO T_GREATER_THAN T_GREATER_THAN_OR_EQUAL_TO
 245 %left T_SHIFT_LEFT T_SHIFT_RIGHT
 246 %left T_PLUS T_MINUS
 247 %left T_MULTIPLY T_DIVIDE T_MODULO
 248 %right T_BITWISE_NOT T_LOGICAL_NOT T_UNARY_OPERATOR
 249
 250 %type <text>     name_of_module name_of_module_instance lvalue identifier_hopt
 251 %type <name>     range range_option expandrange expandrange_option
 252 %type <expr>     primary expression concatenation
 253
 254 %start verilog_file
 255
 256 %%
 257
 258 verilog_file        : description_list
 259                     ;
 260
 261 description_list    : /* empty */
 262                     | description_list description
 263                     ;
 264
 265 description         : module
 266                     {
 267                         chain_list *ptchain;
 268                         chain_list *ptassign;
 269                         losig_list *ptnextsig, *ptsig, *ptprevsig;
 270
 271                         lofigchain(MGL_CONTEXT(LOFIG));
 272                         if (MGL_CONTEXT(ASSIGN_LIST) != NULL) {
 273                             if (MGL_CONTEXT(LOFIG)->MODE != 'P') {
 274                                 for (ptchain = MGL_CONTEXT(ASSIGN_LIST); ptchain; ptchain = ptchain->NEXT) {
 275                                     ptassign = (chain_list *)ptchain->DATA;
 276                                     mgl_assign(MGL_CONTEXT(LOFIG), (char *)ptassign->DATA, (char *)ptassign->NEXT->DATA, MGL_CONTEXT(HSHTAB), mgl_getcontext(parm));
 277                                     freechain(ptassign);
 278                                 }
 279                                 /* delete marked signals */
 280                                 ptprevsig = NULL;
 281                                 for (ptsig = MGL_CONTEXT(LOFIG)->LOSIG; ptsig; ptsig = ptnextsig) {
 282                                     ptnextsig = ptsig->NEXT;
 283                                     if (ptsig->INDEX == 0) {
 284                                         if (ptprevsig == NULL) MGL_CONTEXT(LOFIG)->LOSIG = ptnextsig;
 285                                         else ptprevsig->NEXT = ptnextsig;
 286                                     }
 287                                     else ptprevsig = ptsig;
 288                                 }
 289                             }
 290                             freechain(MGL_CONTEXT(ASSIGN_LIST));
 291                             MGL_CONTEXT(ASSIGN_LIST) = NULL;
 292                         }
 293                         mgl_fretab(MGL_CONTEXT(HSHTAB));
 294                         MGL_CONTEXT(HSHTAB) = NULL;
 295                     }
 296                     | primitive
 297                     {
 298                         mgl_fretab(MGL_CONTEXT(HSHTAB));
 299                         MGL_CONTEXT(HSHTAB) = NULL;
 300                     }
 301                     ;
 302
 303 module              : T_MODULE Identifier
 304                     {
 305                         MGL_CONTEXT(HSHTAB) = mgl_initab();
 306                         MGL_CONTEXT(SIGIDX) = 1;
 307                         MGL_CONTEXT(FIGNAME) = $2;
 308                         MGL_CONTEXT(NM1LST) = NULL;
 309                         MGL_CONTEXT(NM2LST) = NULL;
 310                         MGL_CONTEXT(NM3LST) = NULL;
 311                         MGL_CONTEXT(MODEL) = NULL;
 312                         MGL_CONTEXT(ASSIGN_LIST) = NULL;
 313                         MGL_CONTEXT(ONLY_ORIENT) = 0;
 314                         MGL_CONTEXT(BLDFLG) = 1;
 315
 316                         if (MGL_CONTEXT(TOPFIG) != NULL && MGL_CONTEXT(FIGNAME) == MGL_CONTEXT(TOPFIG)->NAME) {
 317                             MGL_CONTEXT(LOFIG) = MGL_CONTEXT(TOPFIG);
 318                         }
 319                         else {
 320                             if ((MGL_CONTEXT(LOFIG) = getloadedlofig(MGL_CONTEXT(FIGNAME))) != NULL) {
 321                                 if (!MGL_CONTEXT(LOFIG)->LOINS && !MGL_CONTEXT(LOFIG)->LOTRS) {
 322                                     MGL_CONTEXT(SIGIDX) = getnumberoflosig(MGL_CONTEXT(LOFIG)) + 1;
 323                                     MGL_CONTEXT(BLDFLG) = 1;
 324                                     mgl_clean_lorcnet(MGL_CONTEXT(LOFIG));
 325                                 }
 326                                 else MGL_CONTEXT(BLDFLG) = 0;
 327                                 MGL_CONTEXT(ONLY_ORIENT) = 1;
 328                             }
 329                             else {
 330                                 MGL_CONTEXT(LOFIG) = addlofig(MGL_CONTEXT(FIGNAME));
 331                                 MGL_CONTEXT(BLDFLG) = 1;
 332                                 MGL_CONTEXT(ONLY_ORIENT) = 0;
 333                             }
 334                         }
 335                         mgl_addtab(MGL_CONTEXT(HSHTAB), MGL_CONTEXT(FIGNAME), MGL_CONTEXT(FIGNAME), MGL_MODDFN, MGL_FIGDFN);
 336                     }
 337                     list_of_ports ';' module_item_list T_ENDMODULE
 338                     ;
 339
 340 list_of_ports       : /* empty */
 341                     | '(' port_list ')'
 342                     {
 343                     }
 344                     ;
 345
 346 port_list           : port
 347                     | port_list ',' port
 348                     ;
 349
 350 port                : port_expression_option
 351                     {
 352                     }
 353                     | '.' Identifier '(' port_expression_option ')'
 354                     {
 355                     }
 356                     ;
 357
 358 port_expression_option : /*empty */
 359                     | port_expression
 360                     {
 361                     }
 362                     ;
 363
 364 port_expression     : port_reference
 365                     {
 366                     }
 367                     | '{' port_reference_list '}'
 368                     {
 369                     }
 370                     ;
 371
 372 port_reference_list : port_reference
 373                     {
 374                     }
 375                     | port_reference_list ',' port_reference
 376                     {
 377                     }
 378                     ;
 379
 380 port_reference      : Identifier
 381                     {
 382                     }
 383                     | Identifier '[' expression ']'
 384                     {
 385                     }
 386                     | Identifier range
 387                     {
 388                     }
 389                     ;
 390
 391 module_item_list    : /* empty */
 392                     | module_item_list module_item
 393                     ;
 394
 395 module_item         : parameter_decl
 396                     | input_decl
 397                     | output_decl
 398                     | inout_decl
 399                     | net_decl
 400                     | reg_decl
 401                     | integer_decl
 402                     | real_decl
 403                     | gate_instantiation
 404                     | module_instantiation
 405                     | parameter_override
 406                     | continuous_assign
 407                     | specify_block
 408                     | always_statement
 409                     | initial_statement
 410                     | task
 411                     | function
 412                     ;
 413
 414 primitive           : T_PRIMITIVE Identifier
 415                     {
 416                         MGL_CONTEXT(HSHTAB) = mgl_initab();
 417                         MGL_CONTEXT(SIGIDX) = 1;
 418                         MGL_CONTEXT(FIGNAME) = $2;
 419                         MGL_CONTEXT(NM1LST) = NULL;
 420                         MGL_CONTEXT(NM2LST) = NULL;
 421                         MGL_CONTEXT(NM3LST) = NULL;
 422                         MGL_CONTEXT(MODEL) = NULL;
 423                         MGL_CONTEXT(ASSIGN_LIST) = NULL;
 424                         MGL_CONTEXT(ONLY_ORIENT) = 0;
 425                         MGL_CONTEXT(BLDFLG) = 1;
 426
 427                         if (MGL_CONTEXT(TOPFIG) != NULL && MGL_CONTEXT(FIGNAME) == MGL_CONTEXT(TOPFIG)->NAME) {
 428                             MGL_CONTEXT(LOFIG) = MGL_CONTEXT(TOPFIG);
 429                         }
 430                         else {
 431                             if ((MGL_CONTEXT(LOFIG) = getloadedlofig(MGL_CONTEXT(FIGNAME))) != NULL) {
 432                                 if (!MGL_CONTEXT(LOFIG)->LOINS && !MGL_CONTEXT(LOFIG)->LOTRS) {
 433                                     MGL_CONTEXT(SIGIDX) = getnumberoflosig(MGL_CONTEXT(LOFIG)) + 1;
 434                                     MGL_CONTEXT(BLDFLG) = 1;
 435                                     mgl_clean_lorcnet(MGL_CONTEXT(LOFIG));
 436                                 }
 437                                 else MGL_CONTEXT(BLDFLG) = 0;
 438                                 MGL_CONTEXT(ONLY_ORIENT) = 1;
 439                             }
 440                             else {
 441                                 MGL_CONTEXT(LOFIG) = addlofig(MGL_CONTEXT(FIGNAME));
 442                                 MGL_CONTEXT(BLDFLG) = 1;
 443                                 MGL_CONTEXT(ONLY_ORIENT) = 0;
 444                             }
 445                         }
 446                         mgl_addtab(MGL_CONTEXT(HSHTAB), MGL_CONTEXT(FIGNAME), MGL_CONTEXT(FIGNAME), MGL_MODDFN, MGL_FIGDFN);
 447                     }
 448                       list_of_ports ';' primitive_decl_list table_definition T_ENDPRIMITIVE
 449                     ;
 450
 451 primitive_decl_list : /* empty */
 452                     | primitive_decl_list primitive_decl
 453                     ;
 454
 455 primitive_decl      : input_decl
 456                     | output_decl
 457                     | reg_decl
 458                     ;
 459
 460 table_definition    : T_TABLE table_entries T_ENDTABLE
 461                     ;
 462
 463 table_entries       : combinational_entry_eclr
 464                     | sequential_entry_eclr
 465                     ;
 466
 467 combinational_entry_eclr : combinational_entry
 468                     | combinational_entry_eclr combinational_entry
 469                     ;
 470
 471 combinational_entry : input_list ':' output_symbol ';'
 472                     ;
 473
 474 sequential_entry_eclr : sequential_entry
 475                     | sequential_entry_eclr sequential_entry
 476                     ;
 477
 478 sequential_entry    : input_list ':' state ':' next_state ';'
 479                     ;
 480
 481 input_list          : level_symbol_or_edge_eclr
 482                     ;
 483
 484 level_symbol_or_edge_eclr : level_symbol_or_edge
 485                     | level_symbol_or_edge_eclr level_symbol_or_edge
 486                     ;
 487
 488 level_symbol_or_edge : level_symbol
 489                     | edge
 490                     ;
 491
 492 edge                : '(' level_symbol level_symbol ')'
 493                     | edge_symbol
 494                     ;
 495
 496 state               : level_symbol
 497                     ;
 498
 499 next_state          : output_symbol
 500                     | '-'
 501                     ;
 502
 503 output_symbol       : '0'
 504                     | '1'
 505                     | 'x'
 506                     | 'X'
 507                     ;
 508
 509 level_symbol        : '0'
 510                     | '1'
 511                     | 'x'
 512                     | 'X'
 513                     | '?'
 514                     | 'b'
 515                     | 'B'
 516                     ;
 517
 518 edge_symbol         : 'r'
 519                     | 'R'
 520                     | 'f'
 521                     | 'F'
 522                     | 'p'
 523                     | 'P'
 524                     | 'n'
 525                     | 'N'
 526                     | '*'
 527                     ;
 528
 529 task                : T_TASK Identifier ';'
 530                     {
 531                         MGL_CONTEXT(BLDFLG) = 0;
 532                     }
 533                     tf_declaration_list statement_or_null T_ENDTASK
 534                     {
 535                         MGL_CONTEXT(BLDFLG) = 1;
 536                     }
 537                     ;
 538
 539 tf_declaration_list : /* empty */
 540                     | tf_declaration_list tf_declaration
 541                     ;
 542
 543 tf_declaration      : parameter_decl
 544                     | input_decl
 545                     | output_decl
 546                     | inout_decl
 547                     | reg_decl
 548                     | integer_decl
 549                     | real_decl
 550                     ;
 551
 552 function            : T_FUNCTION range_option Identifier ';'
 553                     {
 554                         MGL_CONTEXT(BLDFLG) = 0;
 555                     }
 556                     function_decl_list statement_or_null T_ENDFUNCTION
 557                     {
 558                         MGL_CONTEXT(BLDFLG) = 1;
 559                     }
 560                     ;
 561
 562 function_decl_list  : /* empty */
 563                     | function_decl_list function_decl
 564                     ;
 565
 566 function_decl       : parameter_decl
 567                     | input_decl
 568                     | reg_decl
 569                     | integer_decl
 570                     | real_decl
 571                     ;
 572
 573 initial_statement   : T_INITIAL statement
 574                     {
 575                     }
 576                     ;
 577
 578 always_statement    : T_ALWAYS statement
 579                     {
 580                     }
 581                     ;
 582
 583 delay_or_event_control :
 584                       delay_control
 585                     | event_control
 586                     ;
 587
 588 delay_control       : '#' IntegerLit
 589                     | '#' RealLit
 590                     | '#' Identifier
 591                     | '#' '(' expression ')'
 592                     ;
 593
 594 event_control       : '@' Identifier
 595                     | '@' '(' event_expression ')'
 596                     | '@' '(' or_event_expression ')'
 597                     ;
 598
 599 or_event_expression : event_expression T_OR event_expression
 600                     | or_event_expression T_OR event_expression
 601                     ;
 602
 603 event_expression    : expression
 604                     {
 605                     }
 606                     | T_POSEDGE expression
 607                     {
 608                     }
 609                     | T_NEGEDGE expression
 610                     {
 611                     }
 612                     | T_EDGE expression
 613                     {
 614                     }
 615                     ;
 616
 617 parameter_override  : T_DEFPARAM assignment_list ';'
 618                     ;
 619
 620 parameter_decl      : T_PARAMETER range_option assignment_list ';'
 621                     ;
 622
 623 input_decl          : T_INPUT range_option variable_list ';'
 624                     {
 625                         if (MGL_CONTEXT(BLDFLG) || MGL_CONTEXT(ONLY_ORIENT)) {
 626                             losig_list *ptlosig;
 627                             locon_list *ptlocon;
 628                             chain_list *ptchain;
 629                             losig_list *ptprevsig;
 630                             long        prevleft, prevright;
 631                             char       *radical;
 632                             int         index;
 633
 634                             if ($2.ERR_FLAG) avt_errmsg(MGL_ERRMSG, "002", AVT_WARNING, MGL_CONTEXT(LINENUM));
 635                             MGL_CONTEXT(NM1LST) = reverse(MGL_CONTEXT(NM1LST));
 636                             for (ptchain = MGL_CONTEXT(NM1LST); ptchain; ptchain = ptchain->NEXT) {
 637                                 if (strchr((char *)ptchain->DATA, ' ')) {
 638                                     radical = vectorradical((char *)ptchain->DATA);
 639                                     index = vectorindex((char *)ptchain->DATA);
 640                                     if (MGL_CONTEXT(ONLY_ORIENT)) {
 641                                         ptlocon = mgl_orientlocon(MGL_CONTEXT(LOFIG), IN, (char *)ptchain->DATA, -1, -1);
 642                                         ptlosig = ptlocon->SIG;
 643                                     }
 644                                     else {
 645                                         ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), EXTERNAL, '0', (char *)ptchain->DATA, -1, -1);
 646                                         ptlocon = mgl_addlocon(MGL_CONTEXT(LOFIG), ptlosig, IN, (char *)ptchain->DATA, -1, -1);
 647                                         MGL_CONTEXT(SIGIDX) = ptlosig->INDEX + 1;
 648                                     }
 649                                     if ((ptprevsig = (losig_list *)mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_PNTDFN)) != NULL) {
 650                                         prevleft = mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_LFTDFN);
 651                                         prevright = mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_RGTDFN);
 652                                         if ((prevleft == prevright && abs(index-prevright) != 1)
 653                                         || (prevleft < prevright && index != prevright+1)
 654                                         || (prevleft > prevright && index != prevright-1)) {
 655                                             avt_errmsg(MGL_ERRMSG, "007", AVT_ERROR, radical, MGL_CONTEXT(LINENUM));
 656                                         }
 657                                         if (!MGL_CONTEXT(ONLY_ORIENT) && !ptlosig->NEXT && radical != vectorradical(ptlosig->NEXT->NAMECHAIN->DATA)) {
 658                                             avt_errmsg(MGL_ERRMSG, "008", AVT_ERROR, radical, MGL_CONTEXT(LINENUM));
 659                                         }
 660                                     }
 661                                     else {
 662                                         mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, index);
 663                                     }
 664                                     mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
 665                                     mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, index);
 666                                 }
 667                                 else {
 668                                     if (mgl_chktab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN) != 0) {
 669                                         avt_errmsg(MGL_ERRMSG, "003", AVT_ERROR, (char *)ptchain->DATA, MGL_CONTEXT(LINENUM));
 670                                     }
 671                                     if (MGL_CONTEXT(ONLY_ORIENT)) {
 672                                         ptlocon = mgl_orientlocon(MGL_CONTEXT(LOFIG), IN, (char *)ptchain->DATA, $2.LEFT, $2.RIGHT);
 673                                         ptlosig = ptlocon->SIG;
 674                                     }
 675                                     else {
 676                                         ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), EXTERNAL, '0', (char *)ptchain->DATA, $2.LEFT, $2.RIGHT);
 677                                         ptlocon = mgl_addlocon(MGL_CONTEXT(LOFIG), ptlosig, IN, (char *)ptchain->DATA, $2.LEFT, $2.RIGHT);
 678                                         MGL_CONTEXT(SIGIDX) = ptlosig->INDEX + 1;
 679                                     }
 680                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
 681                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, $2.LEFT);
 682                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, $2.RIGHT);
 683                                 }
 684                             }
 685                             freechain(MGL_CONTEXT(NM1LST));
 686                             MGL_CONTEXT(NM1LST) = NULL;
 687                         }
 688                     }
 689                     ;
 690
 691 output_decl         : T_OUTPUT range_option variable_list ';'
 692                     {
 693                         if (MGL_CONTEXT(BLDFLG) || MGL_CONTEXT(ONLY_ORIENT)) {
 694                             losig_list *ptlosig;
 695                             locon_list *ptlocon;
 696                             chain_list *ptchain;
 697                             losig_list *ptprevsig;
 698                             long        prevleft, prevright;
 699                             char       *radical;
 700                             int         index;
 701
 702                             if ($2.ERR_FLAG) avt_errmsg(MGL_ERRMSG, "002", AVT_WARNING, MGL_CONTEXT(LINENUM));
 703                             MGL_CONTEXT(NM1LST) = reverse(MGL_CONTEXT(NM1LST));
 704                             for (ptchain = MGL_CONTEXT(NM1LST); ptchain; ptchain = ptchain->NEXT) {
 705                                 if (strchr((char *)ptchain->DATA, ' ')) {
 706                                     radical = vectorradical((char *)ptchain->DATA);
 707                                     index = vectorindex((char *)ptchain->DATA);
 708                                     if (MGL_CONTEXT(ONLY_ORIENT)) {
 709                                         ptlocon = mgl_orientlocon(MGL_CONTEXT(LOFIG), OUT, (char *)ptchain->DATA, -1, -1);
 710                                         ptlosig = ptlocon->SIG;
 711                                     }
 712                                     else {
 713                                         ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), EXTERNAL, '0', (char *)ptchain->DATA, -1, -1);
 714                                         ptlocon = mgl_addlocon(MGL_CONTEXT(LOFIG), ptlosig, OUT, (char *)ptchain->DATA, -1, -1);
 715                                         MGL_CONTEXT(SIGIDX) = ptlosig->INDEX + 1;
 716                                     }
 717                                     if ((ptprevsig = (losig_list *)mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_PNTDFN)) != NULL) {
 718                                         prevleft = mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_LFTDFN);
 719                                         prevright = mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_RGTDFN);
 720                                         if ((prevleft == prevright && abs(index-prevright) != 1)
 721                                         || (prevleft < prevright && index != prevright+1)
 722                                         || (prevleft > prevright && index != prevright-1)) {
 723                                             avt_errmsg(MGL_ERRMSG, "007", AVT_ERROR, radical, MGL_CONTEXT(LINENUM));
 724                                         }
 725                                         if (!MGL_CONTEXT(ONLY_ORIENT) && !ptlosig->NEXT && radical != vectorradical(ptlosig->NEXT->NAMECHAIN->DATA)) {
 726                                             avt_errmsg(MGL_ERRMSG, "008", AVT_ERROR, radical, MGL_CONTEXT(LINENUM));
 727                                         }
 728                                     }
 729                                     else {
 730                                         mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, index);
 731                                     }
 732                                     mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
 733                                     mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, index);
 734                                 }
 735                                 else {
 736                                     if (mgl_chktab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN) != 0) {
 737                                         avt_errmsg(MGL_ERRMSG, "003", AVT_ERROR, (char *)ptchain->DATA, MGL_CONTEXT(LINENUM));
 738                                     }
 739                                     if (MGL_CONTEXT(ONLY_ORIENT)) {
 740                                         ptlocon = mgl_orientlocon(MGL_CONTEXT(LOFIG), OUT, (char *)ptchain->DATA, $2.LEFT, $2.RIGHT);
 741                                         ptlosig = ptlocon->SIG;
 742                                     }
 743                                     else {
 744                                         ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), EXTERNAL, '0', (char *)ptchain->DATA, $2.LEFT, $2.RIGHT);
 745                                         ptlocon = mgl_addlocon(MGL_CONTEXT(LOFIG), ptlosig, OUT, (char *)ptchain->DATA, $2.LEFT, $2.RIGHT);
 746                                         MGL_CONTEXT(SIGIDX) = ptlosig->INDEX + 1;
 747                                     }
 748                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
 749                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, $2.LEFT);
 750                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, $2.RIGHT);
 751                                 }
 752                             }
 753                             freechain(MGL_CONTEXT(NM1LST));
 754                             MGL_CONTEXT(NM1LST) = NULL;
 755                         }
 756                     }
 757                     ;
 758
 759 inout_decl          : T_INOUT range_option variable_list ';'
 760                     {
 761                         if (MGL_CONTEXT(BLDFLG) || MGL_CONTEXT(ONLY_ORIENT)) {
 762                             losig_list *ptlosig;
 763                             locon_list *ptlocon;
 764                             chain_list *ptchain;
 765                             losig_list *ptprevsig;
 766                             long        prevleft, prevright;
 767                             char       *radical;
 768                             int         index;
 769
 770                             if ($2.ERR_FLAG) avt_errmsg(MGL_ERRMSG, "002", AVT_WARNING, MGL_CONTEXT(LINENUM));
 771                             MGL_CONTEXT(NM1LST) = reverse(MGL_CONTEXT(NM1LST));
 772                             for (ptchain = MGL_CONTEXT(NM1LST); ptchain; ptchain = ptchain->NEXT) {
 773                                 if (strchr((char *)ptchain->DATA, ' ')) {
 774                                     radical = vectorradical((char *)ptchain->DATA);
 775                                     index = vectorindex((char *)ptchain->DATA);
 776                                     if (MGL_CONTEXT(ONLY_ORIENT)) {
 777                                         ptlocon = mgl_orientlocon(MGL_CONTEXT(LOFIG), INOUT, (char *)ptchain->DATA, -1, -1);
 778                                         ptlosig = ptlocon->SIG;
 779                                     }
 780                                     else {
 781                                         ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), EXTERNAL, '0', (char *)ptchain->DATA, -1, -1);
 782                                         ptlocon = mgl_addlocon(MGL_CONTEXT(LOFIG), ptlosig, INOUT, (char *)ptchain->DATA, -1, -1);
 783                                         MGL_CONTEXT(SIGIDX) = ptlosig->INDEX + 1;
 784                                     }
 785                                     if ((ptprevsig = (losig_list *)mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_PNTDFN)) != NULL) {
 786                                         prevleft = mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_LFTDFN);
 787                                         prevright = mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_RGTDFN);
 788                                         if ((prevleft == prevright && abs(index-prevright) != 1)
 789                                         || (prevleft < prevright && index != prevright+1)
 790                                         || (prevleft > prevright && index != prevright-1)) {
 791                                             avt_errmsg(MGL_ERRMSG, "007", AVT_ERROR, radical, MGL_CONTEXT(LINENUM));
 792                                         }
 793                                         if (!MGL_CONTEXT(ONLY_ORIENT) && !ptlosig->NEXT && radical != vectorradical(ptlosig->NEXT->NAMECHAIN->DATA)) {
 794                                             avt_errmsg(MGL_ERRMSG, "008", AVT_ERROR, radical, MGL_CONTEXT(LINENUM));
 795                                         }
 796                                     }
 797                                     else {
 798                                         mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, index);
 799                                     }
 800                                     mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
 801                                     mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, index);
 802                                 }
 803                                 else {
 804                                     if (mgl_chktab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN) != 0) {
 805                                         avt_errmsg(MGL_ERRMSG, "003", AVT_ERROR, (char *)ptchain->DATA, MGL_CONTEXT(LINENUM));
 806                                     }
 807                                     if (MGL_CONTEXT(ONLY_ORIENT)) {
 808                                         ptlocon = mgl_orientlocon(MGL_CONTEXT(LOFIG), INOUT, (char *)ptchain->DATA, $2.LEFT, $2.RIGHT);
 809                                         ptlosig = ptlocon->SIG;
 810                                     }
 811                                     else {
 812                                         ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), EXTERNAL, '0', (char *)ptchain->DATA, $2.LEFT, $2.RIGHT);
 813                                         ptlocon = mgl_addlocon(MGL_CONTEXT(LOFIG), ptlosig, INOUT, (char *)ptchain->DATA, $2.LEFT, $2.RIGHT);
 814                                         MGL_CONTEXT(SIGIDX) = ptlosig->INDEX + 1;
 815                                     }
 816                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
 817                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, $2.LEFT);
 818                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, $2.RIGHT);
 819                                 }
 820                             }
 821                             freechain(MGL_CONTEXT(NM1LST));
 822                             MGL_CONTEXT(NM1LST) = NULL;
 823                         }
 824                     }
 825                     ;
 826
 827 net_decl            : nettype charge_strength expandrange_option delay_option variable_list ';'
 828                     {
 829                         if (MGL_CONTEXT(BLDFLG) && MGL_CONTEXT(LOFIG)->MODE != 'P') {
 830                             losig_list *ptlosig;
 831                             chain_list *ptchain;
 832                             losig_list *ptprevsig;
 833                             long        prevleft, prevright;
 834                             char       *radical;
 835                             int         index;
 836
 837                             if ($3.ERR_FLAG) avt_errmsg(MGL_ERRMSG, "002", AVT_WARNING, MGL_CONTEXT(LINENUM));
 838                             for (ptchain = MGL_CONTEXT(NM1LST); ptchain; ptchain = ptchain->NEXT) {
 839                                 if (strchr((char *)ptchain->DATA, ' ')) {
 840                                     radical = vectorradical((char *)ptchain->DATA);
 841                                     index = vectorindex((char *)ptchain->DATA);
 842                                     ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), INTERNAL, '0', (char *)ptchain->DATA, -1, -1);
 843                                     MGL_CONTEXT(SIGIDX) = ptlosig->INDEX + 1;
 844                                     if ((ptprevsig = (losig_list *)mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_PNTDFN)) != NULL) {
 845                                         prevleft = mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_LFTDFN);
 846                                         prevright = mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_RGTDFN);
 847                                         if ((prevleft == prevright && abs(index-prevright) != 1)
 848                                         || (prevleft < prevright && index != prevright+1)
 849                                         || (prevleft > prevright && index != prevright-1)) {
 850                                             avt_errmsg(MGL_ERRMSG, "007", AVT_ERROR, radical, MGL_CONTEXT(LINENUM));
 851                                         }
 852                                         if (!ptlosig->NEXT || radical != vectorradical(ptlosig->NEXT->NAMECHAIN->DATA)) {
 853                                             avt_errmsg(MGL_ERRMSG, "008", AVT_ERROR, radical, MGL_CONTEXT(LINENUM));
 854                                         }
 855                                     }
 856                                     else {
 857                                         mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, index);
 858                                     }
 859                                     mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
 860                                     mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, index);
 861                                 }
 862                                 else {
 863                                     if (mgl_chktab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN) != 0) {
 864                                         avt_errmsg(MGL_ERRMSG, "004", AVT_WARNING, (char *)ptchain->DATA, MGL_CONTEXT(LINENUM));
 865                                     }
 866                                     else {
 867                                         ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), INTERNAL, '0', (char *)ptchain->DATA, $3.LEFT, $3.RIGHT);
 868                                         MGL_CONTEXT(SIGIDX) = ptlosig->INDEX + 1;
 869                                         mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
 870                                         mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, $3.LEFT);
 871                                         mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, $3.RIGHT);
 872                                     }
 873                                 }
 874                             }
 875                         }
 876                         freechain(MGL_CONTEXT(NM1LST));
 877                         MGL_CONTEXT(NM1LST) = NULL;
 878                     }
 879                     | nettype expandrange_option delay_option variable_list ';'
 880                     {
 881                         if (MGL_CONTEXT(BLDFLG) && MGL_CONTEXT(LOFIG)->MODE != 'P') {
 882                             losig_list *ptlosig;
 883                             chain_list *ptchain;
 884                             losig_list *ptprevsig;
 885                             long        prevleft, prevright;
 886                             char       *radical;
 887                             int         index;
 888
 889                             for (ptchain = MGL_CONTEXT(NM1LST); ptchain; ptchain = ptchain->NEXT) {
 890                                 if (strchr((char *)ptchain->DATA, ' ')) {
 891                                     radical = vectorradical((char *)ptchain->DATA);
 892                                     index = vectorindex((char *)ptchain->DATA);
 893                                     ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), INTERNAL, '0', (char *)ptchain->DATA, -1, -1);
 894                                     MGL_CONTEXT(SIGIDX) = ptlosig->INDEX + 1;
 895                                     if ((ptprevsig = (losig_list *)mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_PNTDFN)) != NULL) {
 896                                         prevleft = mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_LFTDFN);
 897                                         prevright = mgl_chktab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_RGTDFN);
 898                                         if ((prevleft == prevright && abs(index-prevright) != 1)
 899                                         || (prevleft < prevright && index != prevright+1)
 900                                         || (prevleft > prevright && index != prevright-1)) {
 901                                             avt_errmsg(MGL_ERRMSG, "007", AVT_ERROR, radical, MGL_CONTEXT(LINENUM));
 902                                         }
 903                                         if (!ptlosig->NEXT || radical != vectorradical(ptlosig->NEXT->NAMECHAIN->DATA)) {
 904                                             avt_errmsg(MGL_ERRMSG, "008", AVT_ERROR, radical, MGL_CONTEXT(LINENUM));
 905                                         }
 906                                     }
 907                                     else {
 908                                         mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, index);
 909                                     }
 910                                     mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
 911                                     mgl_addtab(MGL_CONTEXT(HSHTAB), radical, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, index);
 912                                 }
 913                                 else {
 914                                     if (mgl_chktab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN) != 0) {
 915                                         avt_errmsg(MGL_ERRMSG, "004", AVT_WARNING, (char *)ptchain->DATA, MGL_CONTEXT(LINENUM));
 916                                     }
 917                                     else {
 918                                         ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), INTERNAL, '0', (char *)ptchain->DATA, $2.LEFT, $2.RIGHT);
 919                                         MGL_CONTEXT(SIGIDX) = ptlosig->INDEX + 1;
 920                                         mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
 921                                         mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, $2.LEFT);
 922                                         mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, $2.RIGHT);
 923                                     }
 924                                 }
 925                             }
 926                         }
 927                         freechain(MGL_CONTEXT(NM1LST));
 928                         MGL_CONTEXT(NM1LST) = NULL;
 929                     }
 930                     | nettype drive_strength expandrange_option delay_option assignment_list ';'
 931                     | nettype expandrange_option delay_option assignment_list ';'
 932                     ;
 933
 934 nettype             : T_WIRE
 935                     | T_WOR
 936                     | T_WAND
 937                     | T_TRI
 938                     | T_TRIOR
 939                     | T_TRIAND
 940                     | T_TRI0
 941                     | T_TRI1
 942                     | T_SUPPLY0
 943                     | T_SUPPLY1
 944                     | T_TRIREG
 945                     ;
 946
 947 expandrange_option  : /* empty */
 948                     {
 949                         $$.NAME = NULL;
 950                         $$.LEFT = -1;
 951                         $$.RIGHT = -1;
 952                         $$.ERR_FLAG = 0;
 953                     }
 954                     | expandrange
 955                     {
 956                         $$ = $1;
 957                     }
 958                     ;
 959
 960 expandrange         : range
 961                     {
 962                         $$ = $1;
 963                     }
 964                     | T_SCALARED range
 965                     {
 966                         $$ = $2;
 967                     }
 968                     | T_VECTORED range
 969                     {
 970                         $$ = $2;
 971                     }
 972                     ;
 973
 974 reg_decl            : T_REG range_option register_list ';'
 975                     | T_TIME range_option register_list ';'
 976                     ;
 977
 978 register_list       : register_variable
 979                     | register_list ',' register_variable
 980                     ;
 981
 982 register_variable   : Identifier range_option
 983                     {
 984                     }
 985                     ;
 986
 987 integer_decl        : T_INTEGER variable_list ';'
 988                     ;
 989
 990 real_decl           : T_REAL variable_list ';'
 991                     ;
 992
 993 continuous_assign   : T_ASSIGN drive_strength_option delay_option assignment_list ';'
 994                     ;
 995
 996 variable_list       : Identifier
 997                     {
 998                         MGL_CONTEXT(NM1LST) = addchain(NULL, $1);
 999                     }
1000                     | variable_list ',' Identifier
1001                     {
1002                         MGL_CONTEXT(NM1LST) = addchain(MGL_CONTEXT(NM1LST), $3);
1003                     }
1004                     ;
1005
1006 charge_strength     : '(' T_SMALL ')'
1007                     | '(' T_MEDIUM ')'
1008                     | '(' T_LARGE ')'
1009                     ;
1010
1011 drive_strength_option : /* empty */
1012                     | drive_strength
1013                     ;
1014
1015 drive_strength      : '(' strength0 ',' strength1 ')'
1016                     | '(' strength1 ',' strength0 ')'
1017                     | '(' strength0 ')'
1018                     | '(' strength1 ')'
1019                     ;
1020
1021 strength0           : T_SUPPLY0
1022                     | T_STRONG0
1023                     | T_PULL0
1024                     | T_WEAK0
1025                     | T_HIGHZ0
1026                     ;
1027
1028 strength1           : T_SUPPLY1
1029                     | T_STRONG1
1030                     | T_PULL1
1031                     | T_WEAK1
1032                     | T_HIGHZ1
1033                     ;
1034
1035 range_option        : /* empty */
1036                     {
1037                         $$.LEFT = -1;
1038                         $$.RIGHT = -1;
1039                         $$.ERR_FLAG = 0;
1040                     }
1041                     | range
1042                     {
1043                         $$ = $1;
1044                     }
1045                     ;
1046
1047 range               : '[' expression ':' expression ']'
1048                     {
1049                         if ($2.TYPE == MGL_RESULT && $4.TYPE == MGL_RESULT) {
1050                             $$.LEFT = $2.RESULT;
1051                             $$.RIGHT = $4.RESULT;
1052                             $$.ERR_FLAG = 0;
1053                         }
1054                         else {
1055                             $$.LEFT = -1;
1056                             $$.RIGHT = -1;
1057                             $$.ERR_FLAG = 1;
1058                         }
1059                     }
1060                     ;
1061
1062 assignment_list     : assignment
1063                     | assignment_list ',' assignment
1064                     ;
1065
1066 gate_instantiation  : gatetype drive_delay_clr gate_instance_list ';'
1067                     ;
1068
1069 drive_delay_clr     : /* empty */
1070                     | drive_delay_clr drive_delay
1071                     ;
1072
1073 drive_delay         : drive_strength
1074                     | delay
1075                     ;
1076
1077 gatetype            : T_AND
1078                     | T_NAND
1079                     | T_OR
1080                     | T_NOR
1081                     | T_XOR
1082                     | T_XNOR
1083                     | T_BUF
1084                     | T_NOT
1085                     | T_BUFIF0
1086                     | T_BUFIF1
1087                     | T_NOTIF0
1088                     | T_NOTIF1
1089                     | T_PULLUP
1090                     | T_PULLDOWN
1091                     {
1092                     }
1093                     ;
1094
1095 gate_instance_list  : gate_instance
1096                     | gate_instance_list ',' gate_instance
1097                     ;
1098
1099 gate_instance       : name_of_gate_instance range_option '(' terminal_list ')'
1100                     {
1101                         freechain(MGL_CONTEXT(NM1LST));
1102                         MGL_CONTEXT(NM1LST) = NULL;
1103                     }
1104                     | '(' terminal_list ')'
1105                     {
1106                         freechain(MGL_CONTEXT(NM1LST));
1107                         MGL_CONTEXT(NM1LST) = NULL;
1108                     }
1109                     ;
1110
1111 name_of_gate_instance : Identifier
1112                     {
1113                     }
1114                     ;
1115
1116 terminal_list       : terminal
1117                     | terminal_list ',' terminal
1118                     ;
1119
1120 terminal            : expression
1121                     {
1122                         if ($1.TYPE == MGL_IDENT) {
1123                             MGL_CONTEXT(NM1LST) = addchain(MGL_CONTEXT(NM1LST), $1.IDENT);
1124                         }
1125                         else if ($1.TYPE == MGL_CONCAT) {
1126                             MGL_CONTEXT(NM1LST) = append($1.CONCAT, MGL_CONTEXT(NM1LST));
1127                         }
1128                         else if ($1.TYPE == MGL_RESULT) {
1129                             if ($1.RESULT == 0) {
1130                                 MGL_CONTEXT(NM1LST) = addchain(MGL_CONTEXT(NM1LST), MGL_VSS);
1131                             }
1132                             else if ($1.RESULT == 1) {
1133                                 MGL_CONTEXT(NM1LST) = addchain(MGL_CONTEXT(NM1LST), MGL_VDD);
1134                             }
1135                         }
1136                     }
1137                     ;
1138
1139 module_instantiation : name_of_module
1140                     {
1141                         if (MGL_CONTEXT(BLDFLG) && MGL_CONTEXT(LOFIG)->MODE != 'P') {
1142                             MGL_CONTEXT(MODELNAME) = $1;
1143                             MGL_CONTEXT(MODEL) = getloadedlofig(MGL_CONTEXT(MODELNAME));
1144                             if (MGL_CONTEXT(MODEL) == NULL && MGL_USE_LIBRARY) {
1145                                 MGL_CONTEXT(MODEL) = getlofig(MGL_CONTEXT(MODELNAME), 'P');
1146                             }
1147                         }
1148                     }
1149                     parameter_assign_option module_instance_list ';'
1150                     {
1151                     }
1152                     ;
1153
1154 name_of_module      : Identifier
1155                     {
1156                         $$ = $1;
1157                     }
1158                     ;
1159
1160 parameter_assign_option : /* empty */
1161                     | parameter_assign
1162                     ;
1163
1164 parameter_assign    : '#' '(' expression_list ')'
1165                     ;
1166
1167 expression_list     : expression
1168                     {
1169                         if ($1.TYPE == MGL_IDENT) {
1170                             MGL_CONTEXT(NM3LST) = addchain(MGL_CONTEXT(NM3LST), $1.IDENT);
1171                         }
1172                         else if ($1.TYPE == MGL_CONCAT) {
1173                             MGL_CONTEXT(NM3LST) = append($1.CONCAT, MGL_CONTEXT(NM3LST));
1174                         }
1175                         else if ($1.TYPE == MGL_RESULT) {
1176                             if ($1.RESULT == 0) {
1177                                 MGL_CONTEXT(NM3LST) = addchain(MGL_CONTEXT(NM3LST), MGL_VSS);
1178                             }
1179                             else if ($1.RESULT == 1) {
1180                                 MGL_CONTEXT(NM3LST) = addchain(MGL_CONTEXT(NM3LST), MGL_VDD);
1181                             }
1182                         }
1183                     }
1184                     | expression_list ',' expression
1185                     {
1186                         if ($3.TYPE == MGL_IDENT) {
1187                             MGL_CONTEXT(NM3LST) = addchain(MGL_CONTEXT(NM3LST), $3.IDENT);
1188                         }
1189                         else if ($3.TYPE == MGL_CONCAT) {
1190                             MGL_CONTEXT(NM3LST) = append($3.CONCAT, MGL_CONTEXT(NM3LST));
1191                         }
1192                         else if ($3.TYPE == MGL_RESULT) {
1193                             if ($3.RESULT == 0) {
1194                                 MGL_CONTEXT(NM3LST) = addchain(MGL_CONTEXT(NM3LST), MGL_VSS);
1195                             }
1196                             else if ($3.RESULT == 1) {
1197                                 MGL_CONTEXT(NM3LST) = addchain(MGL_CONTEXT(NM3LST), MGL_VDD);
1198                             }
1199                         }
1200                     }
1201                     ;
1202
1203 module_instance_list : module_instance
1204                     | module_instance_list ',' module_instance
1205                     ;
1206
1207 module_instance     : name_of_module_instance range_option '(' list_of_module_terminals ')'
1208                     {
1209                         if (MGL_CONTEXT(BLDFLG) && MGL_CONTEXT(LOFIG)->MODE != 'P') {
1210                             losig_list *ptlosig;
1211                             losig_list *ptvddsig = NULL;
1212                             losig_list *ptvsssig = NULL;
1213                             chain_list *sigchain = NULL;
1214                             chain_list *ptchain;
1215                             int         index;
1216
1217                             for (ptchain = MGL_CONTEXT(NM1LST); ptchain; ptchain = ptchain->NEXT) {
1218                                 if (ptchain->DATA == MGL_VDD) {
1219                                     if (ptvddsig != NULL) ptlosig = ptvddsig;
1220                                     else {
1221                                         index = MGL_CONTEXT(SIGIDX);
1222                                         ptlosig = mgl_givevdd(MGL_CONTEXT(LOFIG), $1, &index);
1223                                         ptvddsig = ptlosig;
1224                                         MGL_CONTEXT(SIGIDX) = index;
1225                                     }
1226                                 }
1227                                 else if (ptchain->DATA == MGL_VSS) {
1228                                     if (ptvsssig != NULL) ptlosig = ptvsssig;
1229                                     else {
1230                                         index = MGL_CONTEXT(SIGIDX);
1231                                         ptlosig = mgl_givevss(MGL_CONTEXT(LOFIG), $1, &index);
1232                                         ptvsssig = ptlosig;
1233                                         MGL_CONTEXT(SIGIDX) = index;
1234                                     }
1235                                 }
1236                                 else if ((ptlosig = mgl_getlosig(MGL_CONTEXT(LOFIG), (char *)ptchain->DATA, MGL_CONTEXT(HSHTAB), mgl_getcontext(parm))) == NULL) {
1237                                     ptlosig = mgl_addlosig(MGL_CONTEXT(LOFIG), MGL_CONTEXT(SIGIDX), INTERNAL, '0', (char *)ptchain->DATA, -1, -1);
1238                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_PNTDFN, (long)ptlosig);
1239                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_LFTDFN, -1);
1240                                     mgl_addtab(MGL_CONTEXT(HSHTAB), (char *)ptchain->DATA, MGL_CONTEXT(FIGNAME), MGL_RGTDFN, -1);
1241                                     MGL_CONTEXT(SIGIDX)++;
1242                                 }
1243                                 sigchain = addchain(sigchain, ptlosig);
1244                             }
1245                             sigchain = reverse(sigchain);
1246                             if ($2.LEFT == -1 || $2.RIGHT == -1) {
1247                                 if (MGL_CONTEXT(MODEL) == NULL && MGL_CONTEXT(NM2LST) != NULL) {
1248                                     mgl_addloins(MGL_CONTEXT(LOFIG), MGL_CONTEXT(MODELNAME), $1, MGL_CONTEXT(NM2LST), sigchain);
1249                                 }
1250                                 else {
1251                                     index = MGL_CONTEXT(SIGIDX);
1252                                     if (MGL_CONTEXT(NM2LST) != NULL || MGL_CONTEXT(NM1LST) == NULL) sigchain = mgl_sortsig(MGL_CONTEXT(MODEL), $1, MGL_CONTEXT(NM2LST), sigchain, MGL_CONTEXT(LOFIG), &index);
1253                                     MGL_CONTEXT(SIGIDX) = index;
1254                                     addloins(MGL_CONTEXT(LOFIG), $1, MGL_CONTEXT(MODEL), sigchain);
1255                                 }
1256                             }
1257                             else {
1258                             }
1259                             freechain(sigchain);
1260                         }
1261                         freechain(MGL_CONTEXT(NM1LST));
1262                         MGL_CONTEXT(NM1LST) = NULL;
1263                         freechain(MGL_CONTEXT(NM2LST));
1264                         MGL_CONTEXT(NM2LST) = NULL;
1265                     }
1266                     | '(' list_of_module_terminals ')'
1267                     {
1268                         freechain(MGL_CONTEXT(NM1LST));
1269                         MGL_CONTEXT(NM1LST) = NULL;
1270                         freechain(MGL_CONTEXT(NM2LST));
1271                         MGL_CONTEXT(NM2LST) = NULL;
1272                     }
1273                     ;
1274
1275 name_of_module_instance : Identifier
1276                     {
1277                         $$ = $1;
1278                     }
1279                     ;
1280
1281 list_of_module_terminals : /* empty */
1282                     | terminal_list
1283                     | named_port_connection_list
1284                     ;
1285
1286 named_port_connection_list : named_port_connection
1287                     | named_port_connection_list ',' named_port_connection
1288                     ;
1289
1290 named_port_connection : '.' Identifier '(' expression ')'
1291                     {
1292                         if ($4.TYPE == MGL_IDENT) {
1293                             MGL_CONTEXT(NM1LST) = addchain(MGL_CONTEXT(NM1LST), $4.IDENT);
1294                             MGL_CONTEXT(NM2LST) = addchain(MGL_CONTEXT(NM2LST), $2);
1295                         }
1296                         else if ($4.TYPE == MGL_CONCAT) {
1297                             lofig_list *ptfig;
1298                             chain_list *ptchain;
1299                             int         i = 0;
1300                             int         left, right, increment;
1301
1302                             if (MGL_CONTEXT(BLDFLG) && MGL_CONTEXT(LOFIG)->MODE != 'P'
1303                              && (ptfig = getloadedlofig(MGL_CONTEXT(MODELNAME))) != NULL) {
1304                                 mgl_getloconrange(ptfig->LOCON, $2, &left, &right);
1305                                 for (ptchain = $4.CONCAT; ptchain; ptchain = ptchain->NEXT) i++;
1306                                 if (left == -1 || right == -1 || abs(right-left)+1 != i) {
1307                                     avt_errmsg(MGL_ERRMSG, "006", AVT_ERROR, MGL_CONTEXT(LINENUM));
1308                                     EXIT(1);
1309                                 }
1310                                 MGL_CONTEXT(NM1LST) = append($4.CONCAT, MGL_CONTEXT(NM1LST));
1311                                 i = left;
1312                                 if (right > left) increment = 1;
1313                                 else increment = -1;
1314                                 for (i = left; i != right+increment; i += increment) {
1315                                     MGL_CONTEXT(NM2LST) = addchain(MGL_CONTEXT(NM2LST), vectorize($2, i));
1316                                 }
1317                             }
1318                             else {
1319                                 i=0;
1320                                 for (ptchain = $4.CONCAT; ptchain; ptchain = ptchain->NEXT) i++;
1321                                 MGL_CONTEXT(NM1LST) = append($4.CONCAT, MGL_CONTEXT(NM1LST));
1322                                 for (i = i-1; i >= 0; i--) {
1323                                     MGL_CONTEXT(NM2LST) = addchain(MGL_CONTEXT(NM2LST), vectorize($2, i));
1324                                 }
1325                             }
1326                         }
1327                         else if ($4.TYPE == MGL_RESULT) {
1328                             if ($4.RESULT == 0) {
1329                                 MGL_CONTEXT(NM1LST) = addchain(MGL_CONTEXT(NM1LST), MGL_VSS);
1330                                 MGL_CONTEXT(NM2LST) = addchain(MGL_CONTEXT(NM2LST), $2);
1331                             }
1332                             else if ($4.RESULT == 1) {
1333                                 MGL_CONTEXT(NM1LST) = addchain(MGL_CONTEXT(NM1LST), MGL_VDD);
1334                                 MGL_CONTEXT(NM2LST) = addchain(MGL_CONTEXT(NM2LST), $2);
1335                             }
1336                         }
1337                     }
1338                     ;
1339
1340 statement           : assignment ';'
1341                     | T_WAIT '(' expression ')' statement_or_null
1342                     | T_IF '(' expression ')' statement_or_null
1343                     | T_IF '(' expression ')' statement_or_null T_ELSE statement_or_null
1344                     | T_CASE '(' expression ')' case_item_list T_ENDCASE
1345                     | T_CASEZ '(' expression ')' case_item_list T_ENDCASE
1346                     | T_FOR '(' assignment ';' expression ';' assignment ')' statement
1347                     | T_DISABLE Identifier ';'
1348                     | T_FOREVER statement
1349                     | T_REPEAT '(' expression ')' statement
1350                     | T_WHILE '(' expression ')' statement
1351                     | delay_or_event_control statement_or_null
1352                     | statement_group
1353                     | task_enable ';'
1354                     | system_task_enable ';'
1355                     | T_ASSIGN assignment ';'
1356                     | T_DEASSIGN lvalue ';'
1357                     ;
1358
1359 statement_or_null   : statement
1360                     | ';'
1361                     ;
1362
1363 assignment          : lvalue '=' expression
1364                     {
1365                         chain_list *ptchain;
1366
1367                         if ($1 != NULL && $3.TYPE == MGL_IDENT) {
1368                             ptchain = addchain(NULL, $3.IDENT);
1369                             ptchain = addchain(ptchain, $1);
1370                             MGL_CONTEXT(ASSIGN_LIST) = addchain(MGL_CONTEXT(ASSIGN_LIST), ptchain);
1371                         }
1372                     }
1373                     | lvalue '=' delay_or_event_control expression
1374                     {
1375                     }
1376                     | lvalue T_LESS_THAN_OR_EQUAL_TO expression
1377                     {
1378                         chain_list *ptchain;
1379
1380                         if ($1 != NULL && $3.TYPE == MGL_IDENT) {
1381                             ptchain = addchain(NULL, $3.IDENT);
1382                             ptchain = addchain(ptchain, $1);
1383                             MGL_CONTEXT(ASSIGN_LIST) = addchain(MGL_CONTEXT(ASSIGN_LIST), ptchain);
1384                         }
1385                     }
1386                     | lvalue T_LESS_THAN_OR_EQUAL_TO delay_or_event_control expression
1387                     {
1388                     }
1389                     ;
1390
1391 case_item_list      : case_item
1392                     | case_item_list case_item
1393                     ;
1394
1395 case_item           : expression_list ':' statement_or_null
1396                     | T_DEFAULT ':' statement_or_null
1397                     | T_DEFAULT statement_or_null
1398                     ;
1399
1400 statement_group     : T_BEGIN statement_list T_END
1401                     | T_BEGIN ':' Identifier block_decl_list statement_list T_END
1402                     ;
1403
1404 statement_list      : /* empty */
1405                     | statement_list statement
1406                     ;
1407
1408 block_decl_list     : /* empty */
1409                     | block_decl_list block_decl
1410                     ;
1411
1412 block_decl          : parameter_decl
1413                     | reg_decl
1414                     | integer_decl
1415                     | real_decl
1416                     ;
1417
1418 lvalue              : identifier_hopt
1419                     {
1420                         $$ = $1;
1421                     }
1422                     | identifier_hopt '[' expression ']'
1423                     {
1424                         if ($3.TYPE == MGL_RESULT && $1 != NULL) {
1425                             $$ = vectorize($1, $3.RESULT);
1426                         }
1427                         else $$ = NULL;
1428                     }
1429                     | concatenation
1430                     {
1431                         $$ = NULL;
1432                     }
1433                     ;
1434
1435 expression          : primary
1436                     {
1437                         $$ = $1;
1438                     }
1439                     | T_MINUS primary %prec T_UNARY_OPERATOR
1440                     {
1441                         $$ = $2;
1442                         if ($$.TYPE == MGL_RESULT) {
1443                             $$.RESULT = -$$.RESULT;
1444                         }
1445                     }
1446                     | T_LOGICAL_NOT primary %prec T_UNARY_OPERATOR
1447                     {
1448                         $$.TYPE = 0;
1449                     }
1450                     | T_BITWISE_NOT primary %prec T_UNARY_OPERATOR
1451                     {
1452                         $$.TYPE = 0;
1453                     }
1454                     | T_BITWISE_AND primary %prec T_UNARY_OPERATOR
1455                     {
1456                         $$.TYPE = 0;
1457                     }
1458                     | T_BITWISE_OR primary %prec T_UNARY_OPERATOR
1459                     {
1460                         $$.TYPE = 0;
1461                     }
1462                     | T_BITWISE_NAND primary %prec T_UNARY_OPERATOR
1463                     {
1464                         $$.TYPE = 0;
1465                     }
1466                     | T_BITWISE_NOR primary %prec T_UNARY_OPERATOR
1467                     {
1468                         $$.TYPE = 0;
1469                     }
1470                     | T_BITWISE_EXOR primary %prec T_UNARY_OPERATOR
1471                     {
1472                         $$.TYPE = 0;
1473                     }
1474                     | T_BITWISE_EXNOR primary %prec T_UNARY_OPERATOR
1475                     {
1476                         $$.TYPE = 0;
1477                     }
1478                     | expression T_PLUS expression
1479                     {
1480                         $$.TYPE = 0;
1481                     }
1482                     | expression T_MINUS expression
1483                     {
1484                         $$.TYPE = 0;
1485                     }
1486                     | expression T_MULTIPLY expression
1487                     {
1488                         $$.TYPE = 0;
1489                     }
1490                     | expression T_DIVIDE expression
1491                     {
1492                         $$.TYPE = 0;
1493                     }
1494                     | expression T_MODULO expression
1495                     {
1496                         $$.TYPE = 0;
1497                     }
1498                     | expression T_EQUALS expression
1499                     {
1500                         $$.TYPE = 0;
1501                     }
1502                     | expression T_DOES_NOT_EQUAL expression
1503                     {
1504                         $$.TYPE = 0;
1505                     }
1506                     | expression T_IDENTICAL expression
1507                     {
1508                         $$.TYPE = 0;
1509                     }
1510                     | expression T_NOT_IDENTICAL expression
1511                     {
1512                         $$.TYPE = 0;
1513                     }
1514                     | expression T_LOGICAL_AND expression
1515                     {
1516                         $$.TYPE = 0;
1517                     }
1518                     | expression T_LOGICAL_OR expression
1519                     {
1520                         $$.TYPE = 0;
1521                     }
1522                     | expression T_LESS_THAN expression
1523                     {
1524                         $$.TYPE = 0;
1525                     }
1526                     | expression T_LESS_THAN_OR_EQUAL_TO expression
1527                     {
1528                         $$.TYPE = 0;
1529                     }
1530                     | expression T_GREATER_THAN expression
1531                     {
1532                         $$.TYPE = 0;
1533                     }
1534                     | expression T_GREATER_THAN_OR_EQUAL_TO expression
1535                     {
1536                         $$.TYPE = 0;
1537                     }
1538                     | expression T_BITWISE_AND expression
1539                     {
1540                         $$.TYPE = 0;
1541                     }
1542                     | expression T_BITWISE_OR expression
1543                     {
1544                         $$.TYPE = 0;
1545                     }
1546                     | expression T_BITWISE_EXOR expression
1547                     {
1548                         $$.TYPE = 0;
1549                     }
1550                     | expression T_BITWISE_EXNOR expression
1551                     {
1552                         $$.TYPE = 0;
1553                     }
1554                     | expression T_SHIFT_LEFT expression
1555                     {
1556                         $$.TYPE = 0;
1557                     }
1558                     | expression T_SHIFT_RIGHT expression
1559                     {
1560                         $$.TYPE = 0;
1561                     }
1562                     | expression '?' expression ':' expression
1563                     {
1564                         $$.TYPE = 0;
1565                     }
1566                     | StringLit
1567                     {
1568                         $$.TYPE = 0;
1569                         mbkfree($1);
1570                     }
1571                     ;
1572
1573 primary             : IntegerLit
1574                     {
1575                         $$.TYPE = MGL_RESULT;
1576                         $$.RESULT = $1;
1577                     }
1578                     | identifier_hopt
1579                     {
1580                         int left, right, exist, increment, i;
1581
1582                         if ($1!=NULL) {
1583                             exist = mgl_chktab(MGL_CONTEXT(HSHTAB), $1, MGL_CONTEXT(FIGNAME), MGL_PNTDFN);
1584                             left = mgl_chktab(MGL_CONTEXT(HSHTAB), $1, MGL_CONTEXT(FIGNAME), MGL_LFTDFN);
1585                             right = mgl_chktab(MGL_CONTEXT(HSHTAB), $1, MGL_CONTEXT(FIGNAME), MGL_RGTDFN);
1586                             if (!exist || left == -1 || right == -1) {
1587                                 $$.IDENT = $1;
1588                                 if ($1 != NULL) {
1589                                     $$.TYPE = MGL_IDENT;
1590                                 }
1591                                 else {
1592                                     $$.TYPE = 0;
1593                                 }
1594                             }
1595                             else {
1596                                 $$.TYPE = MGL_CONCAT;
1597                                 $$.CONCAT = NULL;
1598                                 if (left < right) increment = 1;
1599                                 else increment = -1;
1600                                 for (i = left; i != right+increment; i += increment) {
1601                                     $$.CONCAT = addchain($$.CONCAT, (char *)vectorize($1, i));
1602                                 }
1603                             }
1604                         }
1605                         else $$.TYPE = 0;
1606
1607                     }
1608                     | identifier_hopt '[' expression ']'
1609                     {
1610                         if ($3.TYPE == MGL_RESULT && $1 != NULL) {
1611                             $$.TYPE = MGL_IDENT;
1612                             $$.IDENT = vectorize($1, $3.RESULT);
1613                         }
1614                         else {
1615                             $$.TYPE = 0;
1616                         }
1617                     }
1618                     | identifier_hopt '[' expression ':' expression ']'
1619                     {
1620                         int left, right, increment, i;
1621
1622                         if ($3.TYPE == MGL_RESULT && $5.TYPE == MGL_RESULT) {
1623                             left = $3.RESULT;
1624                             right = $5.RESULT;
1625                             $$.TYPE = MGL_CONCAT;
1626                             $$.CONCAT = NULL;
1627                             if (left < right) increment = 1;
1628                             else increment = -1;
1629                             for (i = left; i != right+increment; i += increment) {
1630                                 $$.CONCAT = addchain($$.CONCAT, (char *)vectorize($1, i));
1631                             }
1632                         }
1633                         else $$.TYPE = 0;
1634                     }
1635                     | concatenation
1636                     {
1637                         $$ = $1;
1638                     }
1639                     | multiple_concatenation
1640                     {
1641                         $$.TYPE = 0;
1642                     }
1643                     | function_call
1644                     {
1645                         $$.TYPE = 0;
1646                     }
1647                     | '(' expression ')'
1648                     {
1649                         $$ = $2;
1650                     }
1651                     | MinTypMaxLit
1652                     {
1653                         $$.TYPE = 0;
1654                     }
1655                     | system_call
1656                     {
1657                         $$.TYPE = 0;
1658                     }
1659                     | RealLit
1660                     {
1661                         $$.TYPE = 0;
1662                     }
1663                     ;
1664
1665 identifier_hopt     : Identifier
1666                     {
1667                         $$ = $1;
1668                     }
1669                     | identifier_hopt '.' Identifier
1670                     {
1671                         $$ = NULL;
1672                     }
1673                     ;
1674
1675 concatenation       : '{' expression_list '}'
1676                     {
1677                         if (MGL_CONTEXT(NM3LST) != NULL) {
1678                             $$.TYPE = MGL_CONCAT;
1679                             $$.CONCAT = MGL_CONTEXT(NM3LST);
1680                             MGL_CONTEXT(NM3LST) = NULL;
1681                         }
1682                     }
1683                     ;
1684
1685 multiple_concatenation : '{' expression '{' expression_list '}' '}'
1686                     ;
1687
1688 function_call       : Identifier '(' expression_list ')'
1689                     {
1690                     }
1691                     ;
1692
1693 system_call         : SystemIdentifier '(' expression_list ')'
1694                     {
1695                     }
1696                     | SystemIdentifier
1697                     {
1698                     }
1699                     ;
1700
1701 task_enable         : Identifier '(' expression_list ')'
1702                     {
1703                     }
1704                     | Identifier
1705                     {
1706                     }
1707                     ;
1708
1709 system_task_enable  : SystemIdentifier '(' expression_list ')'
1710                     {
1711                     }
1712                     | SystemIdentifier
1713                     {
1714                     }
1715                     ;
1716
1717 delay_option        : /* empty */
1718                     | delay
1719                     ;
1720
1721 delay               : '#' IntegerLit
1722                     | '#' RealLit
1723                     | '#' Identifier
1724                     | '#' '(' expression_list ')'
1725                     ;
1726
1727 specify_block       : T_SPECIFY specify_item_list T_ENDSPECIFY
1728                     ;
1729
1730 specify_item_list   : /* empty */
1731                     | specify_item_list specify_item
1732                     ;
1733
1734 specify_item        : specparam_declaration
1735                     | path_declaration
1736                     | system_timing_check
1737                     ;
1738
1739 specparam_declaration : T_SPECPARAM assignment_list ';'
1740                     ;
1741
1742 path_declaration    : simple_path_declaration ';'
1743                     | edge_sensitive_path_declaration ';'
1744                     | state_dependent_path_declaration ';'
1745                     ;
1746
1747 list_of_path_inputs : specify_input_terminal_descriptor
1748                     | list_of_path_inputs ',' specify_input_terminal_descriptor
1749                     ;
1750
1751 specify_input_terminal_descriptor : Identifier
1752                     {
1753                     }
1754                     | Identifier '[' expression ']'
1755                     {
1756                     }
1757                     | Identifier '[' expression ':' expression ']'
1758                     {
1759                     }
1760                     ;
1761
1762 list_of_path_outputs : specify_output_terminal_descriptor
1763                     | list_of_path_outputs ',' specify_output_terminal_descriptor
1764                     ;
1765
1766 specify_output_terminal_descriptor : Identifier
1767                     {
1768                     }
1769                     | Identifier '[' expression ']'
1770                     {
1771                     }
1772                     | Identifier '[' expression ':' expression ']'
1773                     {
1774                     }
1775                     ;
1776
1777 path_delay_value    : path_delay_expression
1778                     | '(' path_delay_expression ',' path_delay_expression ')'
1779                     | '(' path_delay_expression ',' path_delay_expression ',' path_delay_expression ')'
1780                     | '(' path_delay_expression ',' path_delay_expression ',' path_delay_expression ',' path_delay_expression ',' path_delay_expression ',' path_delay_expression ')'
1781                     ;
1782
1783 path_delay_expression : expression
1784                     {
1785                     }
1786                     ;
1787
1788 polarity_operator   : /* empty */
1789                     | T_PLUS
1790                     | T_MINUS
1791                     ;
1792
1793 simple_path_declaration :
1794                       parallel_path_description '=' path_delay_value
1795                     | full_path_description '=' path_delay_value
1796                     ;
1797
1798 parallel_path_description :
1799                       '(' path_start T_LEADTO list_of_path_outputs ')'
1800                     ;
1801
1802 full_path_description :
1803                       '(' path_start T_ALLPATH list_of_path_outputs ')'
1804                     ;
1805
1806 path_start          : edge_identifier list_of_path_inputs polarity_operator
1807                     ;
1808
1809 edge_sensitive_path_declaration :
1810                       parallel_edge_sensitive_path_description '=' path_delay_value
1811                     | full_edge_sensitive_path_description '=' path_delay_value
1812                     ;
1813
1814 parallel_edge_sensitive_path_description :
1815                       '(' path_start T_LEADTO '(' list_of_path_outputs polarity_operator ':' expression ')' ')'
1816                     ;
1817
1818 full_edge_sensitive_path_description :
1819                       '(' path_start T_ALLPATH '(' list_of_path_outputs polarity_operator ':' expression ')' ')'
1820                     ;
1821
1822 edge_identifier     : /* empty */
1823                     | T_POSEDGE
1824                     | T_NEGEDGE
1825                     ;
1826
1827 state_dependent_path_declaration :
1828                       T_IF '(' expression ')' simple_path_declaration
1829                     | T_IF '(' expression ')' edge_sensitive_path_declaration
1830                     | T_IFNONE simple_path_declaration
1831                     ;
1832
1833 system_timing_check : SYS_SETUP
1834                     | SYS_HOLD
1835                     | SYS_SETUPHOLD
1836                     | SYS_SKEW
1837                     | SYS_RECOVERY
1838                     | SYS_PERIOD
1839                     | SYS_WIDTH
1840                     ;
1841 %%
1842
1843 /* ###--------------------------------------------------------------### */
1844 /*  function : yyerror                                                  */
1845 /* ###--------------------------------------------------------------### */
1846
1847 int
1848 mgl_scomperror(char *str, mgl_scompcontext *context)
1849 {
1850     context->ERRFLG++;
1851
1852     avt_errmsg(MGL_ERRMSG, "001", AVT_ERROR, context->LINENUM);
1853
1854     return 1;
1855 }
1856
1857 /* ###--------------------------------------------------------------### */
1858 /*  function : yyclean                                                  */
1859 /* ###--------------------------------------------------------------### */
1860
1861 void
1862 mgl_scompclean(mgl_scompcontext *context)
1863 {
1864     if (context->ASSIGN_LIST != NULL) {
1865         freechain(context->ASSIGN_LIST);
1866         context->ASSIGN_LIST = NULL;
1867     }
1868     if (context->HSHTAB != NULL) {
1869         mgl_fretab(context->HSHTAB);
1870         context->HSHTAB = NULL;
1871     }
1872 }