nickg/nvc | Build 19989699650 | src/parse.c | Coveralls - Test Coverage History & Statistics

190

static void _pop_state(const state_t *s)

4,486,475✔

195

   hint_str = s->old_hint;

4,486,475✔

196

   if (s->old_start_loc.first_line != LINE_INVALID)

4,486,475✔

197

      start_loc = s->old_start_loc;

950,786✔

198

4,486,475✔

207

static void skip_pragma(pragma_kind_t kind)

65✔

209

   if (nametab == NULL)

65✔

210

      warn_at(&yylloc, "ignoring pragma outside of design unit");

6✔

212

      tree_t p = tree_new(T_PRAGMA);

59✔

213

      tree_set_loc(p, &yylloc);

59✔

214

      tree_set_subkind(p, kind);

59✔

216

      APUSH(pragmas, p);

59✔

218

65✔

220

static token_t wrapped_yylex(void)

1,727,999✔

222

   for (;;) {

1,728,064✔

223

      const token_t token = processed_yylex();

1,728,064✔

224

      switch (token) {

1,728,064✔

225

      case tSYNTHON:

3✔

226

         skip_pragma(PRAGMA_SYNTHESIS_ON);

3✔

227

         break;

3✔

228

      case tSYNTHOFF:

4✔

229

         skip_pragma(PRAGMA_SYNTHESIS_OFF);

4✔

230

         break;

4✔

231

      case tCOVERAGEON:

28✔

232

         skip_pragma(PRAGMA_COVERAGE_ON);

28✔

233

         break;

28✔

234

      case tCOVERAGEOFF:

29✔

235

         skip_pragma(PRAGMA_COVERAGE_OFF);

29✔

236

         break;

29✔

240

      case tTRANSLATEOFF:

1✔

241

         skip_pragma(PRAGMA_TRANSLATE_OFF);

1✔

242

         break;

1✔

243

      default:

1,727,999✔

244

         return token;

1,727,999✔

249

static token_t peek_nth(int n)

8,933,175✔

251

   while (((tokenq_head - tokenq_tail) & (tokenq_sz - 1)) < n) {

10,661,174✔

252

      const token_t token = wrapped_yylex();

1,727,999✔

254

      int next = (tokenq_head + 1) & (tokenq_sz - 1);

1,727,999✔

255

      if (unlikely(next == tokenq_tail)) {

1,727,999✔

274

      extern yylval_t yylval;

1,727,999✔

276

      tokenq[tokenq_head].token = token;

1,727,999✔

277

      tokenq[tokenq_head].lval  = yylval;

1,727,999✔

278

      tokenq[tokenq_head].loc   = yylloc;

1,727,999✔

280

      tokenq_head = next;

1,727,999✔

283

   const int pos = (tokenq_tail + n - 1) & (tokenq_sz - 1);

8,933,175✔

284

   return tokenq[pos].token;

8,933,175✔

287

static bool look_for(const look_params_t *params)

51,002✔

289

   bool found = false;

51,002✔

290

   token_t tok = -1;

51,002✔

291

   int n, nest = 0;

51,002✔

292

   for (n = 1; ;) {

51,002✔

293

      tok = peek_nth(n++);

143,752✔

294

      if ((tok == tEOF) || (tok == params->abort))

143,752✔

295

         goto stop_looking;

2✔

296

      else if (tok == params->nest_in)

143,750✔

297

         nest++;

6,521✔

299

      if (nest == params->depth) {

143,750✔

300

         for (int i = 0; i < ARRAY_LEN(params->look); i++) {

555,854✔

301

            if (tok == params->look[i]) {

446,086✔

302

               found = true;

7,014✔

303

               goto stop_looking;

7,014✔

307

         if (params->lookfn != NULL && (*params->lookfn)(tok)) {

109,768✔

312

         for (int i = 0; i < ARRAY_LEN(params->stop); i++) {

394,516✔

313

            if (tok == params->stop[i])

328,734✔

314

               goto stop_looking;

43,986✔

318

      if (tok == params->nest_out)

92,750✔

319

         nest--;

6,521✔

321

 stop_looking:

51,002✔

328

   return found;

51,002✔

331

static void drop_token(void)

1,723,510✔

333

   assert(tokenq_head != tokenq_tail);

1,723,510✔

335

   if (start_loc.first_line == LINE_INVALID)

1,723,510✔

336

      start_loc = tokenq[tokenq_tail].loc;

717,461✔

338

   last_lval = tokenq[tokenq_tail].lval;

1,723,510✔

339

   last_loc  = tokenq[tokenq_tail].loc;

1,723,510✔

341

   tokenq_tail = (tokenq_tail + 1) & (tokenq_sz - 1);

1,723,510✔

343

   nopt_hist = 0;

1,723,510✔

344

1,723,510✔

346

static void drop_tokens_until(token_t tok)

22✔

348

   token_t next = tEOF;

22✔

349

   do {

73✔

350

      free_token(tok, &last_lval);

73✔

351

      next = peek();

73✔

352

      drop_token();

73✔

353

   } while ((tok != next) && (next != tEOF));

73✔

359

22✔

361

static void _vexpect(va_list ap)

228✔

363

   if (n_correct >= RECOVER_THRESH) {

228✔

364

      diag_t *d = diag_new(DIAG_ERROR, &(tokenq[tokenq_tail].loc));

44✔

365

      diag_printf(d, "unexpected $yellow$%s$$ while parsing %s, expecting ",

44✔

368

      bool first = true;

44✔

369

      for (int i = 0; i < nopt_hist; i++) {

65✔

370

         diag_printf(d, "%s$yellow$%s$$", i == 0 ? "one of " : ", ",

26✔

372

         first = false;

21✔

375

      int tok = va_arg(ap, int);

44✔

376

      while (tok != -1) {

157✔

377

         const int tmp = tok;

113✔

378

         tok = va_arg(ap, int);

113✔

380

         if (first && (tok != -1))

113✔

381

            diag_printf(d, "one of ");

12✔

382

         else if (!first)

101✔

383

            diag_printf(d, (tok == -1) ? " or " : ", ");

142✔

385

         diag_printf(d, "$yellow$%s$$", token_str(tmp));

113✔

387

         first = false;

113✔

390

      diag_hint(d, &(tokenq[tokenq_tail].loc), "this token was unexpected");

44✔

391

      diag_emit(d);

44✔

394

   n_correct = 0;

228✔

396

   drop_token();

228✔

397

   suppress_errors(nametab);

228✔

398

228✔

400

static void _expect(int dummy, ...)

225✔

402

   va_list ap;

225✔

403

   va_start(ap, dummy);

225✔

404

   _vexpect(ap);

225✔

405

   va_end(ap);

225✔

406

225✔

408

static bool consume(token_t tok)

1,723,310✔

410

   const token_t got = peek();

1,723,310✔

411

   if (tok != got) {

1,723,310✔

412

      expect(tok);

101✔

413

      return false;

101✔

416

      n_correct++;

1,723,209✔

417

      drop_token();

1,723,209✔

418

      return true;

1,723,209✔

422

static bool optional(token_t tok)

1,366,785✔

424

   if (peek() == tok) {

1,366,785✔

425

      consume(tok);

196,074✔

426

      return true;

196,074✔

429

      if (nopt_hist < ARRAY_LEN(opt_hist))

1,170,711✔

430

         opt_hist[nopt_hist++] = tok;

1,170,711✔

431

      return false;

1,170,711✔

435

static bool _scan(int dummy, ...)

2,003,115✔

437

   va_list ap;

2,003,115✔

438

   va_start(ap, dummy);

2,003,115✔

440

   token_t p = peek();

2,003,115✔

441

   bool found = false;

2,003,115✔

443

   while (!found) {

2,003,115✔

444

      const int tok = va_arg(ap, token_t);

10,397,336✔

445

      if (tok == -1)

10,397,336✔

447

      else if (p == tok)

8,569,062✔

451

   va_end(ap);

2,003,115✔

452

   return found;

2,003,115✔

455

static int _one_of(int dummy, ...)

198,957✔

457

   va_list ap;

198,957✔

458

   va_start(ap, dummy);

198,957✔

460

   token_t p = peek();

198,957✔

461

   bool found = false;

198,957✔

463

   while (!found) {

198,957✔

464

      const int tok = va_arg(ap, token_t);

286,344✔

465

      if (tok == -1)

286,344✔

467

      else if (p == tok)

286,341✔

471

   va_end(ap);

198,957✔

473

   if (found) {

198,957✔

474

      consume(p);

198,954✔

475

      return p;

198,954✔

478

      va_start(ap, dummy);

3✔

479

      _vexpect(ap);

3✔

480

      va_end(ap);

3✔

482

      return -1;

3✔

486

static const loc_t *_diff_loc(const loc_t *start, const loc_t *end)

1,348,547✔

488

   static loc_t result;

1,348,547✔

490

   result = get_loc(start->first_line,

1,348,547✔

491

                    start->first_column,

1,348,547✔

492

                    end->first_line + end->line_delta,

1,348,547✔

493

                    end->first_column + end->column_delta,

1,348,547✔

494

                    start->file_ref);

1,348,547✔

495

   return &result;

1,348,547✔

498

static ident_t error_marker(void)

38✔

500

   return well_known(W_ERROR);

38✔

503

static tree_t error_expr(void)

9✔

505

   tree_t t = tree_new(T_REF);

9✔

506

   tree_set_ident(t, error_marker());

9✔

507

   tree_set_type(t, type_new(T_NONE));

9✔

508

   return t;

9✔

511

static tree_t find_binding(tree_t inst)

1,776✔

513

   ident_t name;

1,776✔

514

   tree_t unit = NULL;

1,776✔

515

   if (tree_kind(inst) == T_BINDING) {

1,776✔

516

      name = tree_ident(inst);

207✔

517

      if (tree_has_ident2(inst))

207✔

518

         name = ident_prefix(name, tree_ident2(inst), '-');

94✔

521

      name = tree_ident2(inst);

1,569✔

522

      if (tree_has_ref(inst))

1,569✔

523

         unit = tree_ref(inst);

2✔

526

   if (unit == NULL)

96✔

527

      unit = resolve_name(nametab, tree_loc(inst), name);

1,774✔

529

   if (unit == NULL)

1,776✔

532

   const char *what = is_design_unit(unit) ? "design unit" : "object";

1,766✔

533

   const tree_kind_t kind = tree_kind(unit);

1,766✔

534

   switch (tree_class(inst)) {

1,766✔

535

   case C_COMPONENT:

480✔

536

      if (kind != T_COMPONENT) {

480✔

537

         parse_error(tree_loc(inst), "%s %s is not a component declaration",

3✔

539

         return NULL;

3✔

542

   case C_ENTITY:

1,223✔

543

      if (kind != T_ENTITY && kind != T_ARCH) {

1,223✔

544

         parse_error(tree_loc(inst), "%s %s is not an entity",

2✔

546

         return NULL;

2✔

549

   case C_CONFIGURATION:

63✔

550

      if (kind != T_CONFIGURATION) {

63✔

551

         parse_error(tree_loc(inst), "%s %s is not a configuration",

1✔

553

         return NULL;

1✔

563

static void set_label_and_loc(tree_t t, ident_t label, const loc_t *loc)

67,887✔

565

   tree_set_loc(t, loc);

67,887✔

567

   if (label == NULL)

67,887✔

568

      label = get_implicit_label(t, nametab);

67,512✔

570

   tree_set_ident(t, label);

67,887✔

571

67,887✔

573

static void require_std(vhdl_standard_t which, const char *feature)

2,311✔

575

   static bool warned = false;

2,311✔

577

   if (standard() < which && !warned) {

2,311✔

578

      warned = true;

1✔

580

      if (n_correct >= RECOVER_THRESH) {

1✔

581

         diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC);

1✔

582

         diag_printf(d, "%s %s not supported in VHDL-%s",

2✔

583

                     feature, feature[strlen(feature)-1] == 's' ? "are" : "is",

1✔

585

         diag_hint(d, NULL, "pass $bold$--std=%s$$ to enable this feature",

1✔

587

         diag_emit(d);

1✔

590

2,311✔

592

static tree_t bit_string_to_literal(const char *str, const loc_t *loc)

2,579✔

594

   tree_t t = tree_new(T_STRING);

2,579✔

595

   tree_set_loc(t, loc);

2,579✔

597

   const char *p = str;

2,579✔

598

   int length = -1;

2,579✔

600

   if (isdigit_iso88591(*p)) {

2,579✔

601

      require_std(STD_08, "bit string literals with length specifier");

85✔

602

      unsigned long slength = strtoul(p, (char **)&p, 10);

85✔

603

      if (slength > INT32_MAX) {

85✔

604

         error_at(loc, "sorry, bit strings longer than %d elements are "

1✔

606

         return t;

1✔

608

      length = slength;

84✔

611

   enum { UNSIGNED, SIGNED } mode = UNSIGNED;

2,578✔

613

   switch (*p) {

2,578✔

614

   case 'U': case 'u': mode = UNSIGNED; ++p; break;

17✔

615

   case 'S': case 's': mode = SIGNED; ++p; break;

20✔

618

   char base_ch = *p++;

2,578✔

619

   int base;

2,578✔

620

   switch (base_ch) {

2,578✔

622

   case 'O': case 'o': base = 8;  break;

85✔

623

   case 'B': case 'b': base = 2;  break;

80✔

624

   case 'D': case 'd': base = 10; break;

53✔

630

   tree_t one = tree_new(T_REF);

2,578✔

631

   tree_set_ident(one, ident_new("'1'"));

2,578✔

632

   tree_set_loc(one, loc);

2,578✔

634

   tree_t zero = tree_new(T_REF);

2,578✔

635

   tree_set_ident(zero, ident_new("'0'"));

2,578✔

636

   tree_set_loc(zero, loc);

2,578✔

638

   if (base == 10) {

2,578✔

639

      require_std(STD_08, "decimal bit string literals");

53✔

641

      int ddigits = 0;

53✔

642

      uint8_t *decimal LOCAL = xmalloc(strlen(str));

106✔

644

      for (++p; *p != '\"'; p++) {

386✔

645

         if (!isdigit_iso88591(*p)) {

334✔

646

            parse_error(loc, "invalid digit '%c' in decimal bit string", *p);

1✔

647

            return t;

1✔

650

            decimal[ddigits++] = *p - '0';

333✔

653

      const int maxbits = (length == -1 ? ddigits * 4 : length);

52✔

654

      tree_t *bits LOCAL = xmalloc_array(maxbits, sizeof(tree_t));

104✔

655

      int pos = maxbits - 1;

52✔

657

      for (;;) {

1,019✔

658

         bool all_zero = true;

1,019✔

659

         int cout = 0;

1,019✔

660

         for (int i = 0, cin = 0; i < ddigits; i++, cin = cout) {

37,781✔

661

            all_zero &= (decimal[i] == 0);

36,762✔

662

            cout = decimal[i] & 1;

36,762✔

663

            decimal[i] >>= 1;

36,762✔

664

            if (cin) decimal[i] += 5;

36,762✔

667

         if (all_zero)

1,019✔

669

         else if (pos < 0 && cout) {

968✔

670

            parse_error(CURRENT_LOC, "excess non-zero digits in "

1✔

672

            return t;

1✔

674

         else if (pos >= 0)

967✔

675

            bits[pos--] = cout ? one : zero;

1,385✔

678

      if (length == -1)

51✔

679

         length = maxbits - pos - 1;

10✔

681

      for (int i = maxbits - length; i < maxbits; i++)

1,593✔

682

         tree_add_char(t, i <= pos ? zero : bits[i]);

1,542✔

687

   tree_t *bits LOCAL = NULL;

5,050✔

688

   if (length >= 0)

2,525✔

689

      bits = xmalloc_array(length, sizeof(tree_t));

42✔

691

   tree_t pad = mode == UNSIGNED ? zero : NULL;

2,525✔

692

   int nbits = 0;

2,525✔

693

   for (++p; *p != '\"'; p++) {

10,227✔

694

      const bool extended = (isdigit_iso88591(*p) && *p < '0' + base)

13,381✔

695

         || (base > 10 && *p >= 'A' && *p < 'A' + base - 10)

2,032✔

696

         || (base > 10 && *p >= 'a' && *p < 'a' + base - 10);

9,052✔

698

      int n = (isdigit_iso88591(*p) ? (*p - '0')

7,706✔

699

               : 10 + (isupper_iso88591(*p) ? (*p - 'A') : (*p - 'a')));

7,706✔

700

      tree_t digit = NULL;

7,706✔

702

      if (!extended) {

7,706✔

703

         if (standard() < STD_08 || !isprint_iso88591(*p)) {

129✔

704

            parse_error(loc, "invalid digit '%c' in bit string", *p);

1✔

705

            return t;

1✔

708

            const char rune[] = { '\'', *p, '\'', '\0' };

128✔

709

            digit = tree_new(T_REF);

128✔

710

            tree_set_ident(digit, ident_new(rune));

128✔

711

            tree_set_loc(digit, loc);

128✔

715

      for (int d = (base >> 1); d > 0; n = n % d, d >>= 1) {

35,491✔

716

         tree_t bit = extended ? ((n / d) ? one : zero) : digit;

27,789✔

717

         if (pad == NULL) pad = bit;

27,789✔

718

         if (length >= 0) {

27,789✔

719

            tree_t left = nbits == 0 ? bit : bits[0];

380✔

720

            if (nbits < length)

380✔

721

               bits[nbits++] = bit;

245✔

722

            else if (left != pad && tree_ident(left) != tree_ident(pad)) {

135✔

723

               parse_error(CURRENT_LOC, "excess %s digits in bit "

5✔

726

               return t;

3✔

728

            else if (length > 0) {

132✔

729

               for (int i = 0; i < length - 1; i++)

1,422✔

730

                  bits[i] = bits[i + 1];

1,295✔

731

               bits[length - 1] = bit;

127✔

735

            tree_add_char(t, bit);

27,409✔

739

   if (pad == NULL && nbits < length)

2,521✔

740

      parse_error(CURRENT_LOC, "signed bit string literal cannot be an "

1✔

742

   else if (length >= 0) {

2,520✔

745

      for (; pos < length - nbits; pos++)

182✔

746

         tree_add_char(t, pad);

144✔

747

      for (int i = 0; pos < length; pos++, i++)

279✔

748

         tree_add_char(t, bits[i]);

241✔

754

static tree_t get_time(int64_t fs, const loc_t *loc)

66✔

756

   tree_t lit = tree_new(T_LITERAL);

66✔

757

   tree_set_subkind(lit, L_INT);

66✔

758

   tree_set_ival(lit, fs);

66✔

759

   tree_set_loc(lit, loc);

66✔

760

   tree_set_type(lit, std_type(NULL, STD_TIME));

66✔

762

   return lit;

66✔

765

static void set_delay_mechanism(tree_t t, tree_t reject)

7,643✔

767

   if (reject == NULL) {

7,643✔

771

      tree_t assign = (tree_kind(t) == T_COND_ASSIGN ? tree_cond(t, 0) : t);

7,565✔

772

      if (tree_waveforms(assign) == 0)

7,565✔

775

      tree_t w = tree_waveform(assign, 0);

7,559✔

776

      if (tree_has_delay(w))

7,559✔

777

         tree_set_reject(t, tree_delay(w));

595✔

780

      tree_set_reject(t, reject);

78✔

781

      solve_types(nametab, reject, std_type(NULL, STD_TIME));

78✔

785

static tree_t add_port(tree_t d, const char *name, type_t type,

67,027✔

788

   type_t ftype = tree_type(d);

67,027✔

790

   tree_t port = tree_new(T_PARAM_DECL);

67,027✔

791

   tree_set_ident(port, ident_new(name));

67,027✔

792

   tree_set_loc(port, tree_loc(d));

67,027✔

793

   tree_set_type(port, type);

67,027✔

794

   tree_set_subkind(port, mode);

67,027✔

795

   if (def != NULL)

67,027✔

796

      tree_set_value(port, def);

220✔

797

   if (type_is_file(type))

67,027✔

798

      tree_set_class(port, C_FILE);

711✔

800

   tree_add_port(d, port);

67,027✔

801

   type_add_param(ftype, type);

67,027✔

803

   return port;

67,027✔

806

static tree_t builtin_proc(ident_t name, subprogram_kind_t kind, ...)

874✔

808

   type_t f = type_new(T_SIGNATURE);

874✔

809

   type_set_ident(f, name);

874✔

811

   tree_t d = tree_new(T_PROC_DECL);

874✔

812

   tree_set_ident(d, name);

874✔

813

   tree_set_type(d, f);

874✔

814

   tree_set_subkind(d, kind);

874✔

815

   tree_set_flag(d, TREE_F_NEVER_WAITS);

874✔

817

   tree_set_flag(d, TREE_F_PREDEFINED);

874✔

818

   tree_set_loc(d, CURRENT_LOC);

874✔

819

   return d;

874✔

822

static tree_t builtin_fn(ident_t name, type_t result,

33,901✔

825

   type_t f = type_new(T_SIGNATURE);

33,901✔

826

   type_set_ident(f, name);

33,901✔

827

   type_set_result(f, result);

33,901✔

829

   tree_t d = tree_new(T_FUNC_DECL);

33,901✔

830

   tree_set_ident(d, name);

33,901✔

831

   tree_set_type(d, f);

33,901✔

832

   tree_set_subkind(d, kind);

33,901✔

834

   va_list ap;

33,901✔

835

   va_start(ap, kind);

33,901✔

836

   char *argname;

33,901✔

837

   while ((argname = va_arg(ap, char*))) {

99,288✔

838

      type_t type = va_arg(ap, type_t);

65,387✔

839

      assert(type != NULL);

65,387✔

840

      add_port(d, argname, type, PORT_IN, NULL);

65,387✔

842

   va_end(ap);

33,901✔

844

   tree_set_flag(d, TREE_F_PREDEFINED);

33,901✔

845

   tree_set_loc(d, CURRENT_LOC);

33,901✔

846

   return d;

33,901✔

849

static void declare_binary(tree_t container, ident_t name, type_t lhs,

31,453✔

852

   tree_t d = builtin_fn(name, result, kind, "L", lhs, "R", rhs, NULL);

31,453✔

853

   mangle_func(nametab, d);

31,453✔

854

   insert_name(nametab, d, NULL);

31,453✔

855

   tree_add_decl(container, d);

31,453✔

856

31,453✔

858

static void declare_unary(tree_t container, ident_t name, type_t operand,

2,376✔

861

   tree_t d = builtin_fn(name, result, kind, "VALUE", operand, NULL);

2,376✔

862

   mangle_func(nametab, d);

2,376✔

863

   insert_name(nametab, d, NULL);

2,376✔

864

   tree_add_decl(container, d);

2,376✔

865

2,376✔

867

static bool is_bit_or_std_ulogic(type_t type)

1,817✔

869

   if (!type_is_enum(type))

1,817✔

872

   ident_t name = type_ident(type);

386✔

874

   return name == well_known(W_STD_BIT) || name == well_known(W_IEEE_ULOGIC);

418✔

877

static void declare_predefined_ops(tree_t container, type_t t)

4,945✔

881

   ident_t mult   = well_known(W_OP_TIMES);

4,945✔

882

   ident_t div    = well_known(W_OP_DIVIDE);

4,945✔

883

   ident_t plus   = well_known(W_OP_ADD);

4,945✔

884

   ident_t minus  = well_known(W_OP_MINUS);

4,945✔

885

   ident_t cmp_lt = well_known(W_OP_LESS_THAN);

4,945✔

886

   ident_t cmp_le = well_known(W_OP_LESS_EQUAL);

4,945✔

887

   ident_t cmp_gt = well_known(W_OP_GREATER_THAN);

4,945✔

888

   ident_t cmp_ge = well_known(W_OP_GREATER_EQUAL);

4,945✔

889

   ident_t eq     = well_known(W_OP_EQUAL);

4,945✔

890

   ident_t neq    = well_known(W_OP_NOT_EQUAL);

4,945✔

892

   ident_t min_i = NULL, max_i = NULL;

4,945✔

893

   if (standard() >= STD_08) {

4,945✔

894

      min_i = ident_new("MINIMUM");

1,817✔

895

      max_i = ident_new("MAXIMUM");

1,817✔

900

   tree_t std = find_std(nametab);

4,945✔

902

   type_t std_bool = std_type(std, STD_BOOLEAN);

4,945✔

903

   type_t std_int  = NULL;

4,945✔

904

   type_t std_real = NULL;

4,945✔

905

   type_t std_uint = NULL;

4,945✔

907

   type_kind_t kind = type_kind(t);

4,945✔

909

   switch (kind) {

4,945✔

918

   case T_ARRAY:

2,550✔

920

      declare_binary(container, eq, t, t, std_bool, S_ARRAY_EQ);

2,550✔

921

      declare_binary(container, neq, t, t, std_bool, S_ARRAY_NEQ);

2,550✔

923

      if (dimension_of(t) == 1) {

2,550✔

924

         type_t elem = type_elem(t);

2,304✔

925

         const bool scalar_elem = type_is_scalar(elem);

2,304✔

926

         const bool ordered =

4,608✔

927

            standard() >= STD_19 ? scalar_elem : type_is_discrete(elem);

2,304✔

929

         if (ordered) {

2,304✔

930

            declare_binary(container, cmp_lt, t, t, std_bool, S_ARRAY_LT);

1,019✔

931

            declare_binary(container, cmp_le, t, t, std_bool, S_ARRAY_LE);

1,019✔

932

            declare_binary(container, cmp_gt, t, t, std_bool, S_ARRAY_GT);

1,019✔

933

            declare_binary(container, cmp_ge, t, t, std_bool, S_ARRAY_GE);

1,019✔

936

         ident_t concat = ident_new("\"&\"");

2,304✔

937

         declare_binary(container, concat, t, t, t, S_CONCAT);

2,304✔

938

         declare_binary(container, concat, t, elem, t, S_CONCAT);

2,304✔

939

         declare_binary(container, concat, elem, t, t, S_CONCAT);

2,304✔

940

         declare_binary(container, concat, elem, elem, t, S_CONCAT);

2,304✔

942

         if (standard() >= STD_08) {

2,304✔

943

            if (ordered) {

787✔

944

               declare_binary(container, min_i, t, t, t, S_MINIMUM);

265✔

945

               declare_binary(container, max_i, t, t, t, S_MAXIMUM);

265✔

948

            if (scalar_elem) {

787✔

949

               declare_unary(container, min_i, t, elem, S_MINIMUM);

289✔

950

               declare_unary(container, max_i, t, elem, S_MAXIMUM);

289✔

956

   case T_RECORD:

1,291✔

958

      declare_binary(container, eq, t, t, std_bool, S_RECORD_EQ);

1,291✔

959

      declare_binary(container, neq, t, t, std_bool, S_RECORD_NEQ);

1,291✔

960

      break;

1,291✔

962

   case T_PHYSICAL:

45✔

963

      std_int  = std_type(std, STD_INTEGER);

45✔

964

      std_real = std_type(std, STD_REAL);

45✔

965

      std_uint = std_type(std, STD_UNIVERSAL_INTEGER);

45✔

968

      declare_binary(container, mult, t, std_int, t, S_MUL_PI);

45✔

969

      declare_binary(container, mult, t, std_real, t, S_MUL_PR);

45✔

970

      declare_binary(container, mult, std_int, t, t, S_MUL_IP);

45✔

971

      declare_binary(container, mult, std_real, t, t, S_MUL_RP);

45✔

974

      declare_binary(container, div, t, std_int, t, S_DIV_PI);

45✔

975

      declare_binary(container, div, t, std_real, t, S_DIV_PR);

45✔

976

      declare_binary(container, div, t, t, std_uint, S_DIV_PP);

45✔

979

      declare_binary(container, plus, t, t, t, S_ADD);

45✔

982

      declare_binary(container, minus, t, t, t, S_SUB);

45✔

985

      declare_unary(container, plus, t, t, S_IDENTITY);

45✔

986

      declare_unary(container, minus, t, t, S_NEGATE);

45✔

989

      declare_binary(container, cmp_lt, t, t, std_bool, S_SCALAR_LT);

45✔

990

      declare_binary(container, cmp_le, t, t, std_bool, S_SCALAR_LE);

45✔

991

      declare_binary(container, cmp_gt, t, t, std_bool, S_SCALAR_GT);

45✔

992

      declare_binary(container, cmp_ge, t, t, std_bool, S_SCALAR_GE);

45✔

995

      declare_binary(container, eq, t, t, std_bool, S_SCALAR_EQ);

45✔

996

      declare_binary(container, neq, t, t, std_bool, S_SCALAR_NEQ);

45✔

999

      declare_unary(container, well_known(W_OP_ABS), t, t, S_ABS);

45✔

1001

      if (standard() >= STD_08) {

45✔

1002

         declare_binary(container, min_i, t, t, t, S_MINIMUM);

14✔

1003

         declare_binary(container, max_i, t, t, t, S_MAXIMUM);

14✔

1006

         declare_binary(container, well_known(W_OP_MOD), t, t, t, S_MOD);

14✔

1007

         declare_binary(container, well_known(W_OP_REM), t, t, t, S_REM);

14✔

1012

   case T_INTEGER:

149✔

1014

      declare_binary(container, well_known(W_OP_MOD), t, t, t, S_MOD);

149✔

1017

      declare_binary(container, well_known(W_OP_REM), t, t, t, S_REM);

149✔

1020

   case T_REAL:

175✔

1022

      declare_binary(container, plus, t, t, t, S_ADD);

175✔

1025

      declare_binary(container, minus, t, t, t, S_SUB);

175✔

1028

      declare_binary(container, mult, t, t, t, S_MUL);

175✔

1031

      declare_binary(container, div, t, t, t, S_DIV);

175✔

1034

      declare_unary(container, plus, t, t, S_IDENTITY);

175✔

1035

      declare_unary(container, minus, t, t, S_NEGATE);

175✔

1038

      if (!bootstrapping) {

175✔

1039

         std_int = std_type(std, STD_INTEGER);

163✔

1040

         declare_binary(container, well_known(W_OP_EXPONENT),

163✔

1045

      declare_unary(container, well_known(W_OP_ABS), t, t, S_ABS);

175✔

1048

   case T_ENUM:

631✔

1049

      declare_binary(container, cmp_lt, t, t, std_bool, S_SCALAR_LT);

631✔

1050

      declare_binary(container, cmp_le, t, t, std_bool, S_SCALAR_LE);

631✔

1051

      declare_binary(container, cmp_gt, t, t, std_bool, S_SCALAR_GT);

631✔

1052

      declare_binary(container, cmp_ge, t, t, std_bool, S_SCALAR_GE);

631✔

1054

      if (standard() >= STD_08) {

631✔

1055

         declare_binary(container, min_i, t, t, t, S_MINIMUM);

245✔

1056

         declare_binary(container, max_i, t, t, t, S_MAXIMUM);

245✔

1061

      declare_binary(container, eq, t, t, std_bool, S_SCALAR_EQ);

958✔

1062

      declare_binary(container, neq, t, t, std_bool, S_SCALAR_NEQ);

958✔

1063

      break;

958✔

1066

   if (standard() >= STD_08 && !bootstrapping && type_is_representable(t)) {

4,945✔

1069

      declare_unary(container, ident_new("TO_STRING"), t,

530✔

1077

   if (bootstrapping && kind == T_REAL

4,945✔

1078

       && t == std_type(std, STD_UNIVERSAL_REAL)) {

6✔

1079

      type_t uint = std_type(std, STD_UNIVERSAL_INTEGER);

3✔

1081

      declare_binary(container, mult, t, uint, t, S_MUL_RI);

3✔

1082

      declare_binary(container, mult, uint, t, t, S_MUL_IR);

3✔

1083

      declare_binary(container, div, t, uint, t, S_DIV_RI);

3✔

1088

   if (standard() >= STD_08) {

4,945✔

1089

      if (kind == T_ARRAY) {

1,817✔

1090

         type_t elem = type_elem(t);

866✔

1091

         if (is_bit_or_std_ulogic(elem)) {

866✔

1092

            declare_binary(container, ident_new("\"?=\""),

65✔

1094

            declare_binary(container, ident_new("\"?/=\""),

65✔

1098

      else if (is_bit_or_std_ulogic(t)) {

951✔

1099

         declare_binary(container, ident_new("\"?=\""), t, t, t, S_MATCH_EQ);

4✔

1100

         declare_binary(container, ident_new("\"?/=\""), t, t, t, S_MATCH_NEQ);

4✔

1101

         declare_binary(container, ident_new("\"?<\""), t, t, t, S_MATCH_LT);

4✔

1102

         declare_binary(container, ident_new("\"?<=\""), t, t, t, S_MATCH_LE);

4✔

1103

         declare_binary(container, ident_new("\"?>\""), t, t, t, S_MATCH_GT);

4✔

1104

         declare_binary(container, ident_new("\"?>=\""), t, t, t, S_MATCH_GE);

4✔

1110

   if (bootstrapping && (t == std_bool || t == std_type(std, STD_BIT))) {

4,945✔

1111

      declare_binary(container, ident_new("\"and\""), t, t, t, S_SCALAR_AND);

6✔

1112

      declare_binary(container, ident_new("\"or\""), t, t, t, S_SCALAR_OR);

6✔

1113

      declare_binary(container, ident_new("\"xor\""), t, t, t, S_SCALAR_XOR);

6✔

1114

      declare_binary(container, ident_new("\"nand\""), t, t, t, S_SCALAR_NAND);

6✔

1115

      declare_binary(container, ident_new("\"nor\""), t, t, t, S_SCALAR_NOR);

6✔

1116

      declare_binary(container, ident_new("\"xnor\""), t, t, t, S_SCALAR_XNOR);

6✔

1117

      declare_unary(container, ident_new("\"not\""), t, t, S_SCALAR_NOT);

6✔

1120

   bool vec_logical = false;

4,945✔

1121

   if (kind == T_ARRAY && dimension_of(t) == 1) {

4,945✔

1122

      type_t base = type_elem(t);

2,304✔

1123

      vec_logical = (base == std_bool || base == std_type(NULL, STD_BIT));

2,304✔

1126

   if (vec_logical) {

2,304✔

1127

      std_int = std_type(NULL, STD_INTEGER);

198✔

1129

      ident_t and  = well_known(W_OP_AND);

198✔

1130

      ident_t or   = well_known(W_OP_OR);

198✔

1131

      ident_t xor  = well_known(W_OP_XOR);

198✔

1132

      ident_t nand = well_known(W_OP_NAND);

198✔

1133

      ident_t nor  = well_known(W_OP_NOR);

198✔

1134

      ident_t xnor = well_known(W_OP_XNOR);

198✔

1136

      declare_binary(container, and, t, t, t, S_ARRAY_AND);

198✔

1137

      declare_binary(container, or, t, t, t, S_ARRAY_OR);

198✔

1138

      declare_binary(container, xor, t, t, t, S_ARRAY_XOR);

198✔

1139

      declare_binary(container, nand, t, t, t, S_ARRAY_NAND);

198✔

1140

      declare_binary(container, nor, t, t, t, S_ARRAY_NOR);

198✔

1141

      declare_binary(container, xnor, t, t, t, S_ARRAY_XNOR);

198✔

1143

      declare_unary(container, well_known(W_OP_NOT), t, t, S_ARRAY_NOT);

198✔

1145

      declare_binary(container, ident_new("\"sll\""), t, std_int, t, S_SLL);

198✔

1146

      declare_binary(container, ident_new("\"srl\""), t, std_int, t, S_SRL);

198✔

1147

      declare_binary(container, ident_new("\"sla\""), t, std_int, t, S_SLA);

198✔

1148

      declare_binary(container, ident_new("\"sra\""), t, std_int, t, S_SRA);

198✔

1149

      declare_binary(container, ident_new("\"rol\""), t, std_int, t, S_ROL);

198✔

1150

      declare_binary(container, ident_new("\"ror\""), t, std_int, t, S_ROR);

198✔

1152

      if (standard() >= STD_08) {

198✔

1153

         type_t e = type_elem(t);

45✔

1155

         declare_unary(container, and, t, e, S_REDUCE_AND);

45✔

1156

         declare_unary(container, or, t, e, S_REDUCE_OR);

45✔

1157

         declare_unary(container, xor, t, e, S_REDUCE_XOR);

45✔

1158

         declare_unary(container, nand, t, e, S_REDUCE_NAND);

45✔

1159

         declare_unary(container, nor, t, e, S_REDUCE_NOR);

45✔

1160

         declare_unary(container, xnor, t, e, S_REDUCE_XNOR);

45✔

1162

         declare_binary(container, and, t, e, t, S_MIXED_AND);

45✔

1163

         declare_binary(container, or, t, e, t, S_MIXED_OR);

45✔

1164

         declare_binary(container, xor, t, e, t, S_MIXED_XOR);

45✔

1165

         declare_binary(container, nand, t, e, t, S_MIXED_NAND);

45✔

1166

         declare_binary(container, nor, t, e, t, S_MIXED_NOR);

45✔

1167

         declare_binary(container, xnor, t, e, t, S_MIXED_XNOR);

45✔

1169

         declare_binary(container, and, e, t, t, S_MIXED_AND);

45✔

1170

         declare_binary(container, or, e, t, t, S_MIXED_OR);

45✔

1171

         declare_binary(container, xor, e, t, t, S_MIXED_XOR);

45✔

1172

         declare_binary(container, nand, e, t, t, S_MIXED_NAND);

45✔

1173

         declare_binary(container, nor, e, t, t, S_MIXED_NOR);

45✔

1174

         declare_binary(container, xnor, e, t, t, S_MIXED_XNOR);

45✔

1180

   switch (kind) {

4,945✔

1181

   case T_FILE:

101✔

1183

         ident_t file_open_i  = ident_new("FILE_OPEN");

101✔

1184

         ident_t file_close_i = ident_new("FILE_CLOSE");

101✔

1185

         ident_t read_i       = ident_new("READ");

101✔

1186

         ident_t write_i      = ident_new("WRITE");

101✔

1187

         ident_t endfile_i    = ident_new("ENDFILE");

101✔

1188

         ident_t read_mode_i  = ident_new("READ_MODE");

101✔

1190

         tree_t read_mode = get_local_decl(nametab, std, read_mode_i, 0);

101✔

1191

         assert(read_mode != NULL);

101✔

1193

         type_t open_kind   = std_type(NULL, STD_FILE_OPEN_KIND);

101✔

1194

         type_t open_status = std_type(NULL, STD_FILE_OPEN_STATUS);

101✔

1195

         type_t std_string  = std_type(NULL, STD_STRING);

101✔

1197

         tree_t file_open1 = builtin_proc(file_open_i, S_FILE_OPEN1);

101✔

1198

         add_port(file_open1, "F", t, PORT_INOUT, NULL);

101✔

1199

         add_port(file_open1, "EXTERNAL_NAME", std_string, PORT_IN, NULL);

101✔

1200

         add_port(file_open1, "OPEN_KIND", open_kind, PORT_IN,

101✔

1202

         insert_name(nametab, file_open1, file_open_i);

101✔

1203

         tree_add_decl(container, file_open1);

101✔

1205

         tree_t file_open2 = builtin_proc(file_open_i, S_FILE_OPEN2);

101✔

1206

         add_port(file_open2, "STATUS", open_status, PORT_OUT, NULL);

101✔

1207

         add_port(file_open2, "F", t, PORT_INOUT, NULL);

101✔

1208

         add_port(file_open2, "EXTERNAL_NAME", std_string, PORT_IN, NULL);

101✔

1209

         add_port(file_open2, "OPEN_KIND", open_kind, PORT_IN,

101✔

1211

         insert_name(nametab, file_open2, file_open_i);

101✔

1212

         tree_add_decl(container, file_open2);

101✔

1214

         tree_t file_close = builtin_proc(file_close_i, S_FILE_CLOSE);

101✔

1215

         add_port(file_close, "F", t, PORT_INOUT, NULL);

101✔

1216

         mangle_func(nametab, file_close);

101✔

1217

         insert_name(nametab, file_close, file_close_i);

101✔

1218

         tree_add_decl(container, file_close);

101✔

1220

         if (standard() >= STD_08) {

101✔

1221

            ident_t flush_i = ident_new("FLUSH");

18✔

1223

            tree_t flush = builtin_proc(flush_i, S_FILE_FLUSH);

18✔

1224

            add_port(flush, "F", t, PORT_IN, NULL);

18✔

1225

            mangle_func(nametab, flush);

18✔

1226

            insert_name(nametab, flush, flush_i);

18✔

1227

            tree_add_decl(container, flush);

18✔

1230

         if (standard() >= STD_19) {

101✔

1231

            ident_t rewind_i   = ident_new("FILE_REWIND");

9✔

1232

            ident_t seek_i     = ident_new("FILE_SEEK");

9✔

1233

            ident_t begin_i    = ident_new("FILE_ORIGIN_BEGIN");

9✔

1234

            ident_t truncate_i = ident_new("FILE_TRUNCATE");

9✔

1235

            ident_t state_i    = ident_new("FILE_STATE");

9✔

1236

            ident_t mode_i     = ident_new("FILE_MODE");

9✔

1237

            ident_t position_i = ident_new("FILE_POSITION");

9✔

1238

            ident_t size_i     = ident_new("FILE_SIZE");

9✔

1239

            ident_t canseek_i  = ident_new("FILE_CANSEEK");

9✔

1241

            type_t origin_kind = std_type(NULL, STD_FILE_ORIGIN_KIND);

9✔

1242

            type_t open_state = std_type(NULL, STD_FILE_OPEN_STATE);

9✔

1244

            tree_t origin_begin = get_local_decl(nametab, std, begin_i, 0);

9✔

1245

            assert(origin_begin != NULL);

9✔

1247

            tree_t file_open3 = builtin_fn(file_open_i, open_status,

9✔

1253

            tree_set_flag(file_open3, TREE_F_IMPURE);

9✔

1254

            tree_set_class(tree_port(file_open3, 0), C_FILE);

9✔

1255

            tree_set_value(tree_port(file_open3, 2), make_ref(read_mode));

9✔

1256

            mangle_func(nametab, file_open3);

9✔

1257

            insert_name(nametab, file_open3, file_open_i);

9✔

1258

            tree_add_decl(container, file_open3);

9✔

1260

            tree_t rewind = builtin_proc(rewind_i, S_FILE_REWIND);

9✔

1261

            add_port(rewind, "F", t, PORT_IN, NULL);

9✔

1262

            mangle_func(nametab, rewind);

9✔

1263

            insert_name(nametab, rewind, rewind_i);

9✔

1264

            tree_add_decl(container, rewind);

9✔

1266

            std_int = std_type(std, STD_INTEGER);

9✔

1268

            tree_t seek = builtin_proc(seek_i, S_FILE_SEEK);

9✔

1269

            add_port(seek, "F", t, PORT_IN, NULL);

9✔

1270

            add_port(seek, "OFFSET", std_int, PORT_IN, NULL);

9✔

1271

            add_port(seek, "ORIGIN", origin_kind, PORT_IN,

9✔

1273

            mangle_func(nametab, seek);

9✔

1274

            insert_name(nametab, seek, seek_i);

9✔

1275

            tree_add_decl(container, seek);

9✔

1277

            tree_t truncate = builtin_proc(truncate_i, S_FILE_TRUNCATE);

9✔

1278

            add_port(truncate, "F", t, PORT_IN, NULL);

9✔

1279

            add_port(truncate, "SIZE", std_int, PORT_IN, NULL);

9✔

1280

            add_port(truncate, "ORIGIN", origin_kind, PORT_IN,

9✔

1282

            mangle_func(nametab, truncate);

9✔

1283

            insert_name(nametab, truncate, truncate_i);

9✔

1284

            tree_add_decl(container, truncate);

9✔

1286

            tree_t state = builtin_fn(state_i, open_state, S_FILE_STATE,

9✔

1288

            tree_set_class(tree_port(state, 0), C_FILE);

9✔

1289

            mangle_func(nametab, state);

9✔

1290

            insert_name(nametab, state, state_i);

9✔

1291

            tree_add_decl(container, state);

9✔

1293

            tree_t mode = builtin_fn(mode_i, open_kind, S_FILE_MODE,

9✔

1295

            tree_set_class(tree_port(mode, 0), C_FILE);

9✔

1296

            mangle_func(nametab, mode);

9✔

1297

            insert_name(nametab, mode, mode_i);

9✔

1298

            tree_add_decl(container, mode);

9✔

1300

            tree_t position = builtin_fn(position_i, std_int, S_FILE_POSITION,

9✔

1302

            tree_set_class(tree_port(position, 0), C_FILE);

9✔

1303

            tree_set_value(tree_port(position, 1), make_ref(origin_begin));

9✔

1304

            mangle_func(nametab, position);

9✔

1305

            insert_name(nametab, position, position_i);

9✔

1306

            tree_add_decl(container, position);

9✔

1308

            tree_t size = builtin_fn(size_i, std_int, S_FILE_SIZE,

9✔

1310

            tree_set_class(tree_port(size, 0), C_FILE);

9✔

1311

            mangle_func(nametab, size);

9✔

1312

            insert_name(nametab, size, size_i);

9✔

1313

            tree_add_decl(container, size);

9✔

1315

            tree_t canseek = builtin_fn(canseek_i, std_bool, S_FILE_CANSEEK,

9✔

1317

            tree_set_class(tree_port(canseek, 0), C_FILE);

9✔

1318

            mangle_func(nametab, canseek);

9✔

1319

            insert_name(nametab, canseek, canseek_i);

9✔

1320

            tree_add_decl(container, canseek);

9✔

1323

         type_t of = type_designated(t);

101✔

1325

         tree_t read = builtin_proc(read_i, S_FILE_READ);

101✔

1326

         add_port(read, "F", t, PORT_INOUT, NULL);

101✔

1327

         add_port(read, "VALUE", of, PORT_OUT, NULL);

101✔

1328

         if (type_is_array(of) && type_is_unconstrained(of)) {

101✔

1329

            type_t std_nat = std_type(NULL, STD_NATURAL);

23✔

1330

            add_port(read, "LENGTH", std_nat, PORT_OUT, NULL);

23✔

1332

         insert_name(nametab, read, read_i);

101✔

1333

         tree_add_decl(container, read);

101✔

1335

         tree_t write = builtin_proc(write_i, S_FILE_WRITE);

101✔

1336

         add_port(write, "F", t, PORT_INOUT, NULL);

101✔

1337

         add_port(write, "VALUE", of, PORT_IN, NULL);

101✔

1338

         insert_name(nametab, write, write_i);

101✔

1339

         tree_add_decl(container, write);

101✔

1341

         declare_unary(container, endfile_i, t, std_bool, S_ENDFILE);

101✔

1343

      break;

101✔

1345

   case T_ACCESS:

324✔

1347

         ident_t deallocate_i = ident_new("DEALLOCATE");

324✔

1349

         tree_t deallocate = builtin_proc(deallocate_i, S_DEALLOCATE);

324✔

1350

         add_port(deallocate, "P", t, PORT_INOUT, NULL);

324✔

1352

         mangle_func(nametab, deallocate);

324✔

1353

         insert_name(nametab, deallocate, deallocate_i);

324✔

1354

         tree_add_decl(container, deallocate);

324✔

1356

      break;

324✔

1362

   if (bootstrapping && standard() >= STD_08) {

4,945✔

1364

      type_t std_bit = NULL;

36✔

1365

      if (t == std_bool || t == (std_bit = std_type(NULL, STD_BIT))) {

36✔

1366

         tree_t d1 = builtin_fn(ident_new("RISING_EDGE"), std_bool,

4✔

1368

         mangle_func(nametab, d1);

4✔

1369

         tree_set_class(tree_port(d1, 0), C_SIGNAL);

4✔

1370

         tree_add_decl(container, d1);

4✔

1372

         tree_t d2 = builtin_fn(ident_new("FALLING_EDGE"), std_bool,

4✔

1374

         mangle_func(nametab, d2);

4✔

1375

         tree_set_class(tree_port(d2, 0), C_SIGNAL);

4✔

1376

         tree_add_decl(container, d2);

4✔

1378

         if (t == std_bit)

4✔

1379

            declare_unary(container, well_known(W_OP_CCONV), t,

2✔

1383

4,945✔

1385

static void declare_alias(tree_t container, tree_t to, ident_t name)

8✔

1387

   tree_t alias = tree_new(T_ALIAS);

8✔

1388

   tree_set_ident(alias, name);

8✔

1389

   tree_set_value(alias, make_ref(to));

8✔

1390

   tree_set_type(alias, tree_type(to));

8✔

1391

   tree_set_flag(alias, TREE_F_PREDEFINED);

8✔

1393

   tree_add_decl(container, alias);

8✔

1394

8✔

1396

static void declare_additional_standard_operators(tree_t unit)

3✔

1398

   assert(bootstrapping);

3✔

1403

   type_t std_uint  = std_type(unit, STD_UNIVERSAL_INTEGER);

3✔

1404

   type_t std_ureal = std_type(unit, STD_UNIVERSAL_REAL);

3✔

1405

   type_t std_int   = std_type(unit, STD_INTEGER);

3✔

1406

   type_t std_real  = std_type(unit, STD_REAL);

3✔

1408

   ident_t exp_i = well_known(W_OP_EXPONENT);

3✔

1410

   declare_binary(unit, exp_i, std_uint, std_int, std_uint, S_EXP);

3✔

1411

   declare_binary(unit, exp_i, std_ureal, std_int, std_ureal, S_EXP);

3✔

1412

   declare_binary(unit, exp_i, std_int, std_int, std_int, S_EXP);

3✔

1413

   declare_binary(unit, exp_i, std_real, std_int, std_real, S_EXP);

3✔

1415

   if (standard() < STD_08)

3✔

1421

   ident_t to_string   = ident_new("TO_STRING");

2✔

1422

   type_t  std_string  = std_type(unit, STD_STRING);

2✔

1423

   type_t  std_time    = std_type(unit, STD_TIME);

2✔

1424

   type_t  std_natural = std_type(unit, STD_NATURAL);

2✔

1425

   type_t  std_bit_vec = std_type(unit, STD_BIT_VECTOR);

2✔

1427

   const int ndecls = tree_decls(unit);

2✔

1428

   for (int i = 0; i < ndecls; i++) {

682✔

1429

      tree_t d = tree_decl(unit, i);

680✔

1430

      if (tree_kind(d) == T_TYPE_DECL) {

680✔

1431

         type_t type = tree_type(d);

36✔

1432

         if (type_is_representable(type))

36✔

1433

            declare_unary(unit, to_string, type, std_string, S_TO_STRING);

31✔

1439

   tree_t d1 = builtin_fn(to_string, std_string, S_TO_STRING_TIME,

2✔

1441

   mangle_func(nametab, d1);

2✔

1442

   tree_add_decl(unit, d1);

2✔

1444

   tree_t d2 = builtin_fn(to_string, std_string, S_TO_STRING_REAL_DIGITS,

2✔

1446

   mangle_func(nametab, d2);

2✔

1447

   tree_add_decl(unit, d2);

2✔

1449

   tree_t d3 = builtin_fn(to_string, std_string, S_TO_STRING_REAL_FORMAT,

2✔

1451

   mangle_func(nametab, d3);

2✔

1452

   tree_add_decl(unit, d3);

2✔

1454

   tree_t d4 = builtin_fn(ident_new("TO_HSTRING"), std_string,

2✔

1456

   mangle_func(nametab, d4);

2✔

1457

   tree_add_decl(unit, d4);

2✔

1459

   declare_alias(unit, d4, ident_new("TO_HEX_STRING"));

2✔

1461

   tree_t d5 = builtin_fn(ident_new("TO_OSTRING"), std_string,

2✔

1463

   mangle_func(nametab, d5);

2✔

1464

   tree_add_decl(unit, d5);

2✔

1466

   declare_alias(unit, d5, ident_new("TO_OCTAL_STRING"));

2✔

1468

   tree_t d6;

2✔

1469

   for (int n = 0; (d6 = get_local_decl(nametab, NULL, to_string, n)); n++) {

21✔

1470

      if (type_eq(tree_type(tree_port(d6, 0)), std_bit_vec))

21✔

1474

   assert(d6 != NULL);

2✔

1475

   declare_alias(unit, d6, ident_new("TO_BSTRING"));

2✔

1476

   declare_alias(unit, d6, ident_new("TO_BINARY_STRING"));

2✔

1479

static void unary_op(tree_t expr, tree_t (*arg_fn)(tree_t))

11,920✔

1481

   tree_t right = (*arg_fn)(NULL);

11,920✔

1482

   tree_set_loc(expr, CURRENT_LOC);

11,920✔

1483

   add_param(expr, right, P_POS, NULL);

11,920✔

1484

11,920✔

1486

static void binary_op(tree_t expr, tree_t left, tree_t (*right_fn)(tree_t))

54,026✔

1488

   add_param(expr, left, P_POS, NULL);

54,026✔

1490

   tree_t right = (*right_fn)(NULL);

54,026✔

1491

   tree_set_loc(expr, CURRENT_LOC);

54,026✔

1492

   add_param(expr, right, P_POS, NULL);

54,026✔

1493

54,026✔

1495

static tree_t implicit_dereference(tree_t t)

1,297✔

1497

   type_t access = type_designated(tree_type(t));

1,297✔

1499

   tree_t all = tree_new(T_ALL);

1,297✔

1500

   tree_set_loc(all, tree_loc(t));

1,297✔

1501

   tree_set_value(all, t);

1,297✔

1502

   tree_set_type(all, access);

1,297✔

1504

   return all;

1,297✔

1507

static type_t prefix_type(tree_t prefix, type_t signature)

39,974✔

1509

   if (scope_formal_kind(nametab) == F_SUBPROGRAM)

39,974✔

1515

   while ((kind = tree_kind(ref)) != T_REF) {

42,453✔

1516

      switch (kind) {

2,789✔

1517

      case T_ARRAY_SLICE:

2,496✔

1521

         ref = tree_value(ref);

2,496✔

1522

         break;

2,496✔

1528

   if (tree_has_ref(ref) && !class_has_type(class_of(tree_ref(ref))))

39,664✔

1531

   return solve_types(nametab, prefix, signature);

39,028✔

1534

static bool is_range_expr(tree_t t)

32,793✔

1536

   switch (tree_kind(t)) {

32,793✔

1537

   case T_REF:

9,280✔

1538

      if (tree_has_ref(t))

9,280✔

1539

         return aliased_type_decl(tree_ref(t)) != NULL;

9,150✔

1541

         return !!(query_name(nametab, tree_ident(t), NULL) & N_TYPE);

130✔

1543

   case T_ATTR_REF:

4,760✔

1545

         const attr_kind_t predef = tree_subkind(t);

4,760✔

1546

         return predef == ATTR_RANGE || predef == ATTR_REVERSE_RANGE;

4,760✔

1554

static tree_t ensure_labelled(tree_t t, ident_t label)

20,380✔

1556

   tree_set_ident(t, label ?: get_implicit_label(t, nametab));

20,380✔

1557

   return t;

20,380✔

1560

static tree_t select_decl(tree_t prefix, ident_t suffix, name_mask_t *mask)

748✔

1562

   ident_t qual = ident_prefix(tree_ident(prefix), suffix, '.');

748✔

1564

   tree_t decl = NULL;

748✔

1565

   *mask = query_name(nametab, qual, &decl);

748✔

1567

   tree_t ref = tree_new(T_REF);

748✔

1568

   tree_set_ident(ref, qual);

748✔

1569

   tree_set_loc(ref, CURRENT_LOC);

748✔

1570

   tree_set_ref(ref, decl);

748✔

1572

   if (*mask == 0) {

748✔

1573

      parse_error(CURRENT_LOC, "name %s not found in %s", istr(suffix),

2✔

1575

      tree_set_type(ref, type_new(T_NONE));

2✔

1578

   return ref;

748✔

1581

static tree_t could_be_slice_name(tree_t fcall)

14,521✔

1587

   if (tree_params(fcall) != 1)

14,521✔

1590

   tree_t p0 = tree_param(fcall, 0);

6,115✔

1591

   if (tree_subkind(p0) != P_POS)

6,115✔

1594

   tree_t value = tree_value(p0);

6,090✔

1595

   if (tree_kind(value) != T_REF)

6,090✔

1598

   if (!tree_has_ref(value))

4,140✔

1601

   tree_t decl = tree_ref(value);

4,095✔

1602

   if (!is_type_decl(decl))

4,095✔

1605

   tree_t new = tree_new(T_FCALL);

4✔

1606

   tree_set_ident(new, tree_ident(fcall));

4✔

1607

   tree_set_loc(new, tree_loc(fcall));

4✔

1609

   tree_t aref = tree_new(T_ATTR_REF);

4✔

1610

   tree_set_name(aref, value);

4✔

1611

   tree_set_ident(aref, ident_new("RANGE"));

4✔

1612

   tree_set_loc(aref, tree_loc(value));

4✔

1613

   tree_set_subkind(aref, ATTR_RANGE);

4✔

1615

   tree_t r = tree_new(T_RANGE);

4✔

1616

   tree_set_subkind(r, RANGE_EXPR);

4✔

1617

   tree_set_value(r, aref);

4✔

1618

   tree_set_loc(r, tree_loc(p0));

4✔

1620

   solve_types(nametab, r, NULL);

4✔

1622

   tree_t slice = tree_new(T_ARRAY_SLICE);

4✔

1623

   tree_set_value(slice, new);

4✔

1624

   tree_add_range(slice, r);

4✔

1625

   tree_set_loc(slice, tree_loc(fcall));

4✔

1627

   return slice;

4✔

1630

static bool is_implicit_block(tree_t t)

166✔

1632

   const tree_kind_t kind = tree_kind(t);

166✔

1633

   return kind == T_ARCH || kind == T_BLOCK || kind == T_IF_GENERATE

166✔

1634

      || kind == T_FOR_GENERATE;

166✔

1637

static void make_universal_type(tree_t container, type_kind_t kind,

6✔

1640

   assert(bootstrapping);

6✔

1641

   ident_t name_i = ident_new(name);

6✔

1643

   type_t type = type_new(kind);

6✔

1644

   type_set_ident(type, name_i);

6✔

1646

   tree_t r = tree_new(T_RANGE);

6✔

1647

   tree_set_subkind(r, RANGE_TO);

6✔

1648

   tree_set_left(r, min);

6✔

1649

   tree_set_right(r, max);

6✔

1650

   tree_set_type(r, type);

6✔

1652

   type_add_dim(type, r);

6✔

1654

   tree_set_type(min, type);

6✔

1655

   tree_set_type(max, type);

6✔

1657

   tree_t decl = tree_new(T_TYPE_DECL);

6✔

1658

   tree_set_loc(decl, CURRENT_LOC);

6✔

1659

   tree_set_ident(decl, name_i);

6✔

1660

   tree_set_type(decl, type);

6✔

1662

   tree_add_decl(container, decl);

6✔

1664

   declare_predefined_ops(container, type);

6✔

1665

6✔

1667

static void make_universal_int(tree_t container)

3✔

1669

   tree_t min = tree_new(T_LITERAL);

3✔

1670

   tree_set_subkind(min, L_INT);

3✔

1671

   tree_set_ival(min, INT64_MIN);

3✔

1673

   tree_t max = tree_new(T_LITERAL);

3✔

1674

   tree_set_subkind(max, L_INT);

3✔

1675

   tree_set_ival(max, INT64_MAX);

3✔

1677

   make_universal_type(container, T_INTEGER, "universal_integer", min, max);

3✔

1678

3✔

1680

static void make_universal_real(tree_t container)

3✔

1682

   tree_t min = tree_new(T_LITERAL);

3✔

1683

   tree_set_subkind(min, L_REAL);

3✔

1684

   tree_set_dval(min, -DBL_MAX);

3✔

1686

   tree_t max = tree_new(T_LITERAL);

3✔

1687

   tree_set_subkind(max, L_REAL);

3✔

1688

   tree_set_dval(max, DBL_MAX);

3✔

1690

   make_universal_type(container, T_REAL, "universal_real", min, max);

3✔

1691

3✔

1693

static void make_implicit_guard_signal(tree_t block, tree_t expr)

27✔

1695

   tree_t guard = tree_new(T_IMPLICIT_SIGNAL);

27✔

1696

   tree_set_subkind(guard, IMPLICIT_GUARD);

27✔

1697

   tree_set_ident(guard, ident_new("GUARD"));

27✔

1698

   tree_set_loc(guard, tree_loc(expr));

27✔

1699

   tree_set_type(guard, std_type(NULL, STD_BOOLEAN));

27✔

1700

   tree_set_value(guard, expr);

27✔

1702

   tree_add_decl(block, guard);

27✔

1703

   insert_name(nametab, guard, NULL);

27✔

1704

   sem_check(guard, nametab);

27✔

1705

27✔

1707

static tree_t fcall_to_conv_func(tree_t value)

230✔

1709

   assert(tree_kind(value) == T_FCALL);

230✔

1711

   if (!(tree_flags(value) & TREE_F_CONVERSION))

230✔

1714

   if (!tree_has_ref(value))

209✔

1717

   tree_t decl = tree_ref(value);

209✔

1718

   if (tree_ports(decl) != 1)

209✔

1721

   tree_t p0 = tree_value(tree_param(value, 0));

207✔

1723

   tree_t ref = name_to_ref(p0);

207✔

1724

   if (ref == NULL || class_of(ref) != C_SIGNAL)

207✔

1725

      return value;

6✔

1727

   tree_t conv = tree_new(T_CONV_FUNC);

201✔

1728

   tree_set_loc(conv, tree_loc(value));

201✔

1729

   tree_set_value(conv, p0);

201✔

1730

   tree_set_ident(conv, tree_ident(value));

201✔

1731

   tree_set_type(conv, tree_type(value));

201✔

1732

   tree_set_ref(conv, decl);

201✔

1734

   return conv;

201✔

1737

static void instantiate_subprogram(tree_t new, tree_t decl, tree_t body)

129✔

1739

   tree_t roots[] = { decl, body };

129✔

1740

   ident_t prefixes[] = { tree_ident(decl) };

129✔

1741

   ident_t dotted = ident_prefix(scope_prefix(nametab), tree_ident(new), '.');

129✔

1742

   new_instance(roots, body != NULL ? 2 :1, dotted, prefixes, 1);

138✔

1744

   tree_t decl_copy = roots[0], body_copy = roots[1];

129✔

1745

   tree_t src = body_copy ?: decl_copy;

129✔

1747

   tree_set_type(new, tree_type(src));

129✔

1748

   tree_set_flag(new, tree_flags(decl));

129✔

1749

   tree_set_global_flags(new, tree_global_flags(decl));

129✔

1751

   tree_copy_generics(new, src);

129✔

1752

   tree_copy_ports(new, src);

129✔

1754

   if (body != NULL) {

129✔

1755

      tree_copy_decls(new, body_copy);

120✔

1756

      tree_copy_stmts(new, body_copy);

120✔

1758

      tree_set_flag(new, tree_flags(body));

120✔

1759

      tree_set_global_flags(new, tree_global_flags(body));

120✔

1763

   map_generic_subprogram(nametab, decl_copy, new);

129✔

1764

   if (body != NULL) map_generic_subprogram(nametab, body_copy, new);

129✔

1765

129✔

1767

static void instantiate_package(tree_t new, tree_t pack, tree_t body)

281✔

1769

   assert(body == NULL || tree_primary(body) == pack);

281✔

1771

   ident_t prefix = tree_ident(pack);

281✔

1772

   tree_t container = tree_container(pack);

281✔

1773

   if (container != pack)

281✔

1774

      prefix = ident_prefix(tree_ident(container), prefix, '.');

17✔

1776

   tree_t roots[] = { pack, body };

281✔

1777

   ident_t prefixes[] = { prefix };

281✔

1778

   ident_t dotted = ident_prefix(scope_prefix(nametab), tree_ident(new), '.');

281✔

1779

   new_instance(roots, body != NULL ? 2 : 1, dotted, prefixes, 1);

365✔

1781

   tree_t pack_copy = roots[0], body_copy = roots[1];

281✔

1783

   tree_copy_generics(new, pack_copy);

281✔

1785

   const int ndecls = tree_decls(pack_copy);

281✔

1786

   for (int i = 0; i < ndecls; i++) {

5,150✔

1787

      tree_t d = tree_decl(pack_copy, i);

4,869✔

1788

      if (tree_kind(d) == T_CONST_DECL && !tree_has_value(d))

4,869✔

1789

         continue;   // Skip deferred constants

9✔

1791

      tree_add_decl(new, d);

4,860✔

1794

   tree_set_global_flags(new, tree_global_flags(pack));

281✔

1796

   if (body != NULL) {

281✔

1802

      const int ndecls = tree_decls(body_copy);

197✔

1803

      for (int i = 0; i < ndecls; i++)

4,070✔

1804

         tree_add_decl(new, tree_decl(body_copy, i));

3,873✔

1806

      tree_set_global_flags(new, tree_global_flags(body));

197✔

1808

281✔

1810

static void add_interface(tree_t container, tree_t decl, tree_kind_t kind)

38,137✔

1812

   if (kind == T_GENERIC_DECL)

38,137✔

1813

      tree_add_generic(container, decl);

3,353✔

1815

      tree_add_port(container, decl);

34,784✔

1816

38,137✔

1818

static void ident_list_push(ident_list_t **list, ident_t i, loc_t loc)

66,849✔

1820

   ident_list_t *c = xmalloc(sizeof(ident_list_t));

66,849✔

1821

   c->ident = i;

66,849✔

1822

   c->loc   = loc;

66,849✔

1823

   c->next  = NULL;

66,849✔

1825

   ident_list_t **it;

66,849✔

1826

   for (it = list; *it; it = &((*it)->next));

74,381✔

1827

   *it = c;

66,849✔

1828

66,849✔

1830

static void _ident_list_cleanup(ident_list_t **list)

61,304✔

1832

   for (ident_list_t *it = *list, *tmp; it; it = tmp) {

128,153✔

1833

      tmp = it->next;

66,849✔

1834

      free(it);

66,849✔

1836

   *list = NULL;

61,304✔

1837

61,304✔

1839

static type_t get_subtype_for(tree_t expr)

215✔

1841

   type_t type = tree_type(expr);

215✔

1843

   type_t sub = type_new(T_SUBTYPE);

215✔

1844

   type_set_base(sub, type_base_recur(type));

215✔

1846

   const loc_t *loc = tree_loc(expr);

215✔

1848

   tree_t c = tree_new(T_CONSTRAINT);

215✔

1849

   tree_set_loc(c, loc);

215✔

1851

   type_set_constraint(sub, c);

215✔

1853

   if (type_is_record(type)) {

215✔

1854

      tree_set_subkind(c, C_RECORD);

23✔

1856

      const int nfields = type_fields(type);

23✔

1857

      for (int i = 0; i < nfields; i++) {

55✔

1858

         tree_t f = type_field(type, i);

32✔

1859

         type_t ft = tree_type(f);

32✔

1861

         if (!type_is_unconstrained(ft))

32✔

1862

            continue;

5✔

1864

         tree_t rref = tree_new(T_RECORD_REF);

27✔

1865

         tree_set_ident(rref, tree_ident(f));

27✔

1866

         tree_set_loc(rref, loc);

27✔

1867

         tree_set_ref(rref, f);

27✔

1868

         tree_set_value(rref, expr);

27✔

1870

         tree_t cons = type_constraint_for_field(type, f);

27✔

1871

         if (cons != NULL)

27✔

1872

            tree_set_type(rref, tree_type(cons));

13✔

1874

            tree_set_type(rref, ft);

14✔

1876

         tree_t ec = tree_new(T_ELEM_CONSTRAINT);

27✔

1877

         tree_set_loc(ec, loc);

27✔

1878

         tree_set_ident(ec, tree_ident(f));

27✔

1879

         tree_set_ref(ec, f);

27✔

1880

         tree_set_type(ec, get_subtype_for(rref));

27✔

1882

         tree_add_range(c, ec);

27✔

1885

   else if (type_is_array(type)) {

192✔

1886

      tree_set_subkind(c, C_INDEX);

176✔

1888

      const int ndims = dimension_of(type);

176✔

1889

      for (int i = 0; i < ndims; i++) {

358✔

1890

         tree_t rref = tree_new(T_ATTR_REF);

182✔

1891

         tree_set_name(rref, expr);

182✔

1892

         tree_set_ident(rref, ident_new("RANGE"));

182✔

1893

         tree_set_loc(rref, loc);

182✔

1894

         tree_set_subkind(rref, ATTR_RANGE);

182✔

1896

         if (i > 0) {

182✔

1897

            tree_t p = tree_new(T_LITERAL);

6✔

1898

            tree_set_subkind(p, L_INT);

6✔

1899

            tree_set_ival(p, i + 1);

6✔

1900

            tree_set_loc(p, loc);

6✔

1901

            tree_set_type(p, std_type(NULL, STD_UNIVERSAL_INTEGER));

6✔

1903

            add_param(rref, p, P_POS, NULL);

6✔

1906

         tree_t r = tree_new(T_RANGE);

182✔

1907

         tree_set_subkind(r, RANGE_EXPR);

182✔

1908

         tree_set_value(r, rref);

182✔

1909

         tree_set_loc(r, loc);

182✔

1911

         solve_types(nametab, r, NULL);

182✔

1913

         tree_add_range(c, r);

182✔

1916

      type_set_elem(sub, get_element_subtype(expr));

176✔

1918

   else if (!is_anonymous_subtype(type))

16✔

1920

   else if (type_is_scalar(type)) {

7✔

1922

      tree_set_subkind(c, C_RANGE);

7✔

1923

      tree_add_range(c, range_of(type, 0));

7✔

1931

static type_t get_element_subtype(tree_t expr)

239✔

1933

   type_t type = tree_type(expr);

239✔

1934

   assert(type_is_array(type));

239✔

1936

   type_t elem = type_elem(type);

239✔

1937

   if (type_const_bounds(elem) || class_of(expr) == C_TYPE)

239✔

1938

      return elem;

194✔

1940

   tree_t aref = tree_new(T_ARRAY_REF);

45✔

1941

   tree_set_value(aref, expr);

45✔

1942

   tree_set_type(aref, elem);

45✔

1943

   tree_set_loc(aref, tree_loc(expr));

45✔

1945

   const int ndims = dimension_of(type);

45✔

1946

   for (int i = 0; i < ndims; i++) {

93✔

1947

      tree_t left = tree_new(T_ATTR_REF);

48✔

1948

      tree_set_loc(left, tree_loc(expr));

48✔

1949

      tree_set_name(left, expr);

48✔

1950

      tree_set_subkind(left, ATTR_LEFT);

48✔

1951

      tree_set_ident(left, ident_new("LEFT"));

48✔

1952

      tree_set_type(left, index_type_of(type, i));

48✔

1954

      add_param(aref, left, P_POS, NULL);

48✔

1957

   return get_subtype_for(aref);

45✔

1960

static type_t apply_subtype_attribute(tree_t aref)

129✔

1962

   assert(tree_subkind(aref) == ATTR_SUBTYPE);

129✔

1964

   tree_t name = tree_name(aref);

129✔

1965

   type_t type = get_type_or_null(name);

129✔

1967

   if (type == NULL) {

129✔

1968

      parse_error(tree_loc(aref), "prefix of 'SUBTYPE attribute does not "

1✔

1970

      return type_new(T_NONE);

1✔

1974

      return get_subtype_for(name);

128✔

1978

static type_t apply_element_attribute(tree_t aref)

67✔

1980

   assert(tree_subkind(aref) == ATTR_ELEMENT);

67✔

1982

   tree_t prefix = tree_name(aref);

67✔

1983

   type_t type = get_type_or_null(prefix);

67✔

1985

   if (type == NULL) {

67✔

1986

      parse_error(tree_loc(aref), "prefix of 'ELEMENT attribute does not "

1✔

1988

      return type_new(T_NONE);

1✔

1990

   else if (type_is_none(type))

66✔

1992

   else if (!type_is_array(type)) {

64✔

1993

      parse_error(tree_loc(aref), "prefix of 'ELEMENT attribute must be an "

1✔

1995

      return type_new(T_NONE);

1✔

1998

   return get_element_subtype(prefix);

63✔

2001

static type_t apply_designated_subtype_attribute(tree_t aref)

7✔

2003

   assert(tree_subkind(aref) == ATTR_DESIGNATED_SUBTYPE);

7✔

2005

   type_t type = get_type_or_null(tree_name(aref));

7✔

2007

   if (type == NULL) {

7✔

2008

      parse_error(tree_loc(aref), "prefix of 'DESIGNATED_SUBTYPE attribute "

1✔

2010

      return type_new(T_NONE);

1✔

2012

   else if (!type_is_file(type) && !type_is_access(type)) {

6✔

2013

      parse_error(tree_loc(aref), "prefix of 'DESIGNATED_SUBTYPE attribute "

1✔

2015

      return type_new(T_NONE);

1✔

2018

   return type_designated(type);

5✔

2021

static type_t apply_base_attribute(tree_t aref)

12✔

2023

   assert(tree_subkind(aref) == ATTR_BASE);

12✔

2025

   tree_t name = tree_name(aref);

12✔

2026

   type_t type = NULL;

12✔

2028

   if (tree_kind(name) == T_REF && tree_has_ref(name)) {

12✔

2029

      tree_t decl = aliased_type_decl(tree_ref(name));

12✔

2030

      if (decl != NULL)

12✔

2031

         type = tree_type(decl);

11✔

2034

   if (type == NULL) {

11✔

2035

      parse_error(tree_loc(aref), "prefix of 'BASE attribute must be a type "

1✔

2037

      return type_new(T_NONE);

1✔

2039

   else if (type_kind(type) == T_SUBTYPE)

11✔

2040

      return type_base(type);

6✔

2045

static type_t apply_index_attribute(tree_t aref)

13✔

2047

   assert(tree_subkind(aref) == ATTR_INDEX);

13✔

2049

   type_t type = get_type_or_null(tree_name(aref));

13✔

2051

   if (!type_is_array(type)) {

13✔

2052

      parse_error(tree_loc(aref), "prefix of 'INDEX attribute must be an "

1✔

2054

      return type_new(T_NONE);

1✔

2057

   const int ndims = dimension_of(type);

12✔

2058

   const int nparams = tree_params(aref);

12✔

2060

   int index = 0;

12✔

2061

   if (nparams == 1) {

12✔

2064

      tree_t p = tree_value(tree_param(aref, 0));

6✔

2065

      if (tree_kind(p) != T_LITERAL) {

6✔

2066

         parse_error(tree_loc(p), "only integer literals are supported "

1✔

2068

         return type_new(T_NONE);

1✔

2071

      const int64_t ival = tree_ival(p);

5✔

2072

      if (ival < 1 || ival > ndims) {

5✔

2073

         parse_error(tree_loc(p), "'INDEX parameter for type %s must be "

2✔

2075

         return type_new(T_NONE);

2✔

2078

      index = ival - 1;

3✔

2081

   return index_type_of(type, index);

9✔

2084

static type_t apply_type_attribute(tree_t aref)

228✔

2086

   switch (tree_subkind(aref)) {

228✔

2087

   case ATTR_SUBTYPE:

129✔

2088

      return apply_subtype_attribute(aref);

129✔

2089

   case ATTR_ELEMENT:

67✔

2090

      return apply_element_attribute(aref);

67✔

2091

   case ATTR_BASE:

12✔

2092

      return apply_base_attribute(aref);

12✔

2093

   case ATTR_DESIGNATED_SUBTYPE:

7✔

2094

      return apply_designated_subtype_attribute(aref);

7✔

2095

   case ATTR_INDEX:

13✔

2096

      return apply_index_attribute(aref);

13✔

2103

static void implicit_signal_attribute(tree_t aref)

310✔

2105

   if (find_enclosing(nametab, S_SUBPROGRAM) != NULL) {

310✔

2106

      parse_error(tree_loc(aref), "implicit signal %s cannot be used in a "

4✔

2108

      return;

176✔

2111

   tree_t b = find_enclosing(nametab, S_CONCURRENT_BLOCK);

306✔

2112

   if (b == NULL) {

306✔

2118

   tree_t prefix = tree_name(aref);

306✔

2119

   const attr_kind_t attr = tree_subkind(aref);

306✔

2121

   tree_t delay = NULL;

306✔

2122

   if (attr != ATTR_TRANSACTION && tree_params(aref) > 0)

306✔

2123

      delay = tree_value(tree_param(aref, 0));

119✔

2125

   LOCAL_TEXT_BUF tb = tb_new();

440✔

2126

   tree_t ref = name_to_ref(prefix);

306✔

2127

   if (ref != NULL)

306✔

2128

      tb_istr(tb, tree_ident(ref));

305✔

2129

   tb_append(tb, '$');

306✔

2130

   switch (attr) {

306✔

2131

   case ATTR_DELAYED: tb_cat(tb, "delayed"); break;

162✔

2132

   case ATTR_TRANSACTION: tb_cat(tb, "transaction"); break;

32✔

2133

   case ATTR_STABLE: tb_cat(tb, "stable"); break;

89✔

2134

   case ATTR_QUIET: tb_cat(tb, "quiet"); break;

23✔

2137

   if (delay != NULL && tree_kind(delay) == T_LITERAL) {

306✔

2138

      tb_printf(tb, "_%"PRIi64, tree_ival(delay));

100✔

2139

      if (tree_has_ident(delay))

100✔

2140

         tb_printf(tb, "_%s", istr(tree_ident(delay)));

99✔

2142

   else if (delay != NULL && tree_kind(delay) == T_REF)

206✔

2143

      tb_printf(tb, "_%s", istr(tree_ident(delay)));

18✔

2145

   ident_t id = ident_new(tb_get(tb));

306✔

2147

   implicit_kind_t kind;

306✔

2148

   switch (attr) {

306✔

2157

   const int ndecls = tree_decls(b);

306✔

2158

   for (int i = 0; i < ndecls; i++) {

1,444✔

2159

      tree_t d = tree_decl(b, i);

1,310✔

2160

      if (tree_kind(d) != T_IMPLICIT_SIGNAL)

1,310✔

2161

         continue;

919✔

2162

      else if (tree_ident(d) != id || tree_subkind(d) != kind)

391✔

2163

         continue;

203✔

2165

      bool match = false;

188✔

2166

      tree_t value = tree_value(d);

188✔

2167

      if (attr == ATTR_DELAYED || attr == ATTR_STABLE || attr == ATTR_QUIET) {

188✔

2168

         assert(tree_kind(value) == T_WAVEFORM);

170✔

2170

         match = same_tree(tree_value(value), prefix)

340✔

2171

            && ((delay == NULL && !tree_has_delay(value))

170✔

2172

                || (delay != NULL && tree_has_delay(value)

40✔

2173

                    && same_tree(tree_delay(value), delay)));

39✔

2175

      else if (attr == ATTR_TRANSACTION)

18✔

2176

         match = same_tree(value, prefix);

18✔

2178

      if (match) {

188✔

2179

         tree_set_value(aref, make_ref(d));

172✔

2180

         return;

172✔

2183

         tb_append(tb, '_');

16✔

2184

         id = ident_new(tb_get(tb));

16✔

2188

   tree_t imp = tree_new(T_IMPLICIT_SIGNAL);

134✔

2189

   tree_set_ident(imp, id);

134✔

2190

   tree_set_loc(imp, tree_loc(aref));

134✔

2191

   tree_set_subkind(imp, kind);

134✔

2193

   if (attr == ATTR_TRANSACTION) {

134✔

2194

      tree_set_type(imp, std_type(NULL, STD_BIT));

14✔

2195

      tree_set_value(imp, prefix);

14✔

2198

      tree_t w = tree_new(T_WAVEFORM);

120✔

2199

      tree_set_loc(w, CURRENT_LOC);

120✔

2200

      tree_set_value(w, prefix);

120✔

2201

      if (delay != NULL)

120✔

2202

         tree_set_delay(w, delay);

80✔

2204

      tree_set_type(imp, solve_types(nametab, aref, NULL));

120✔

2205

      tree_set_value(imp, w);

120✔

2208

   tree_add_decl(b, imp);

134✔

2209

   tree_set_value(aref, make_ref(imp));

134✔

2212

static attr_kind_t parse_predefined_attr(ident_t ident)

20,785✔

2214

   static struct {

20,785✔

2259

   INIT_ONCE({

68,917✔

2266

   const vhdl_standard_t std = standard();

20,785✔

2267

   const uint32_t hash = ident_casehash(ident);

20,785✔

2269

   for (int i = 0; i < ARRAY_LEN(predef) && predef[i].std <= std; i++) {

139,606✔

2270

      if (predef[i].hash == hash && ident_casecmp(predef[i].ident, ident))

139,383✔

2271

         return predef[i].attr;

20,562✔

2277

static void add_generic_type_op(tree_t parent, int nargs, type_t type,

984✔

2280

   ident_t id = ident_new(name);

984✔

2282

   type_t ftype = type_new(T_SIGNATURE);

984✔

2283

   type_set_ident(ftype, id);

984✔

2284

   type_set_result(ftype, result);

984✔

2286

   for (int i = 0; i < nargs; i++)

2,853✔

2287

      type_add_param(ftype, type);

1,869✔

2289

   tree_t p = tree_new(T_GENERIC_DECL);

984✔

2290

   tree_set_class(p, C_FUNCTION);

984✔

2291

   tree_set_ident(p, id);

984✔

2292

   tree_set_type(p, ftype);

984✔

2293

   tree_set_subkind(p, PORT_IN);

984✔

2294

   tree_set_loc(p, CURRENT_LOC);

984✔

2295

   tree_set_flag(p, TREE_F_PREDEFINED);

984✔

2308

   tree_t box = tree_new(T_BOX);

984✔

2309

   tree_set_loc(box, CURRENT_LOC);

984✔

2311

   tree_set_value(p, box);

984✔

2313

   for (int j = 0; j < nargs; j++) {

2,853✔

2314

      tree_t arg = tree_new(T_PARAM_DECL);

1,869✔

2315

      tree_set_ident(arg, ident_new(j == 0 ? "L" : "R"));

2,754✔

2316

      tree_set_type(arg, type);

1,869✔

2317

      tree_set_subkind(arg, PORT_IN);

1,869✔

2318

      tree_set_class(arg, C_CONSTANT);

1,869✔

2319

      tree_set_loc(arg, CURRENT_LOC);

1,869✔

2321

      tree_add_port(p, arg);

1,869✔

2324

   add_interface(parent, p, T_GENERIC_DECL);

984✔

2325

   insert_name(nametab, p, NULL);

984✔

2326

984✔

2328

static void declare_generic_ops(tree_t parent, type_t type)

262✔

2330

   type_t std_bool = std_type(NULL, STD_BOOLEAN);

262✔

2331

   type_t std_string = std_type(NULL, STD_STRING);

262✔

2333

   const gtype_class_t class = type_subkind(type);

262✔

2335

   switch (class) {

262✔

2336

   case GTYPE_INTEGER:

11✔

2337

      add_generic_type_op(parent, 2, type, type, "\"**\"");

11✔

2339

   case GTYPE_PHYSICAL:

15✔

2340

      add_generic_type_op(parent, 2, type, type, "\"mod\"");

15✔

2341

      add_generic_type_op(parent, 2, type, type, "\"rem\"");

15✔

2343

   case GTYPE_FLOATING:

19✔

2344

      add_generic_type_op(parent, 2, type, type, "\"+\"");

19✔

2345

      add_generic_type_op(parent, 2, type, type, "\"-\"");

19✔

2346

      add_generic_type_op(parent, 1, type, type, "\"+\"");

19✔

2347

      add_generic_type_op(parent, 1, type, type, "\"-\"");

19✔

2348

      if (class != GTYPE_PHYSICAL) {

19✔

2349

         add_generic_type_op(parent, 2, type, type, "\"*\"");

15✔

2350

         add_generic_type_op(parent, 2, type, type, "\"/\"");

15✔

2352

      add_generic_type_op(parent, 1, type, type, "\"abs\"");

19✔

2354

   case GTYPE_DISCRETE:

42✔

2356

      add_generic_type_op(parent, 2, type, std_bool, "\"<\"");

42✔

2357

      add_generic_type_op(parent, 2, type, std_bool, "\">\"");

42✔

2358

      add_generic_type_op(parent, 2, type, std_bool, "\"<=\"");

42✔

2359

      add_generic_type_op(parent, 2, type, std_bool, "\">=\"");

42✔

2360

      add_generic_type_op(parent, 2, type, type, "MINIMUM");

42✔

2361

      add_generic_type_op(parent, 2, type, type, "MAXIMUM");

42✔

2362

      add_generic_type_op(parent, 1, type, std_string, "TO_STRING");

42✔

2364

   case GTYPE_ARRAY:

262✔

2368

      add_generic_type_op(parent, 2, type, std_bool, "\"=\"");

262✔

2369

      add_generic_type_op(parent, 2, type, std_bool, "\"/=\"");

262✔

2370

      break;

262✔

2373

   if (class == GTYPE_ACCESS) {

262✔

2374

      ident_t id = ident_new("DEALLOCATE");

5✔

2376

      type_t ftype = type_new(T_SIGNATURE);

5✔

2377

      type_set_ident(ftype, id);

5✔

2378

      type_add_param(ftype, type);

5✔

2380

      tree_t p = tree_new(T_GENERIC_DECL);

5✔

2381

      tree_set_class(p, C_PROCEDURE);

5✔

2382

      tree_set_ident(p, id);

5✔

2383

      tree_set_type(p, ftype);

5✔

2384

      tree_set_subkind(p, PORT_IN);

5✔

2385

      tree_set_loc(p, CURRENT_LOC);

5✔

2386

      tree_set_flag(p, TREE_F_PREDEFINED);

5✔

2388

      tree_t box = tree_new(T_BOX);

5✔

2389

      tree_set_loc(box, CURRENT_LOC);

5✔

2391

      tree_set_value(p, box);

5✔

2393

      tree_t arg = tree_new(T_PARAM_DECL);

5✔

2394

      tree_set_ident(arg, ident_new("PTR"));

5✔

2395

      tree_set_type(arg, type);

5✔

2396

      tree_set_subkind(arg, PORT_INOUT);

5✔

2397

      tree_set_class(arg, C_VARIABLE);

5✔

2398

      tree_set_loc(arg, CURRENT_LOC);

5✔

2400

      tree_add_port(p, arg);

5✔

2402

      add_interface(parent, p, T_GENERIC_DECL);

5✔

2403

      insert_name(nametab, p, NULL);

5✔

2405

   else if (class == GTYPE_ARRAY) {

257✔

2407

      type_t elem = type_elem(type);

21✔

2408

      if (type_kind(elem) == T_GENERIC && !type_has_ident(elem))

21✔

2409

         declare_generic_ops(parent, elem);

11✔

2411

      const int nindex = type_indexes(type);

21✔

2412

      for (int i = 0; i < nindex; i++) {

42✔

2413

         type_t index = type_index(type, i);

21✔

2414

         if (type_kind(index) == T_GENERIC && !type_has_ident(index))

21✔

2415

            declare_generic_ops(parent, index);

9✔

2418

262✔

2420

static bool is_vhdl_infix_op(token_t tok)

97✔

2422

   return tok == tEQ || tok == tNEQ || tok == tLT || tok == tGT

97✔

2423

      || tok == tLE || tok == tGE || tok == tNAND || tok == tNOR

94✔

2427

      || tok == tMLE || tok == tMGT || tok == tMGE;

97✔

2430

static void add_predef_alias(tree_t t, void *context)

711✔

2432

   tree_t parent = context;

711✔

2433

   assert(is_subprogram(t));

711✔

2435

   tree_t a = tree_new(T_ALIAS);

711✔

2436

   tree_set_loc(a, CURRENT_LOC);

711✔

2437

   tree_set_ident(a, tree_ident(t));

711✔

2438

   tree_set_value(a, make_ref(t));

711✔

2439

   tree_set_type(a, tree_type(t));

711✔

2440

   tree_set_flag(a, TREE_F_PREDEFINED);

711✔

2442

   insert_name(nametab, a, NULL);

711✔

2443

   tree_add_decl(parent, a);

711✔

2444

711✔

2446

static void convert_universal_bounds(tree_t r)

5,829✔

2452

   assert(tree_kind(r) == T_RANGE);

5,829✔

2454

   const range_kind_t kind = tree_subkind(r);

5,829✔

2455

   if (kind != RANGE_TO && kind != RANGE_DOWNTO)

5,829✔

2458

   tree_t left = tree_left(r);

4,030✔

2459

   tree_t right = tree_right(r);

4,030✔

2461

   type_t ltype = tree_type(left);

4,030✔

2462

   type_t rtype = tree_type(right);

4,030✔

2464

   type_t uint = std_type(NULL, STD_UNIVERSAL_INTEGER);

4,030✔

2465

   if (!type_eq(ltype, uint) || !type_eq(rtype, uint))

4,030✔

2466

      return;

3,193✔

2468

   type_t std_int = std_type(NULL, STD_INTEGER);

837✔

2469

   tree_set_type(r, std_int);

837✔

2471

   tree_t lconv = tree_new(T_TYPE_CONV);

837✔

2472

   tree_set_loc(lconv, tree_loc(left));

837✔

2473

   tree_set_type(lconv, std_int);

837✔

2474

   tree_set_value(lconv, left);

837✔

2476

   tree_set_left(r, lconv);

837✔

2478

   tree_t rconv = tree_new(T_TYPE_CONV);

837✔

2479

   tree_set_loc(rconv, tree_loc(right));

837✔

2480

   tree_set_type(rconv, std_int);

837✔

2481

   tree_set_value(rconv, right);

837✔

2483

   tree_set_right(r, rconv);

837✔

2486

static type_t name_to_type_mark(tree_t name)

83,672✔

2488

   type_t type = solve_types(nametab, name, NULL);

83,672✔

2490

   if (type_is_none(type))

83,672✔

2493

   const tree_kind_t namek = tree_kind(name);

83,592✔

2494

   if (namek == T_ATTR_REF)

83,592✔

2497

   tree_t decl = NULL;

83,458✔

2498

   if (namek == T_REF && tree_has_ref(name))

83,458✔

2499

      decl = aliased_type_decl(tree_ref(name));

83,455✔

2501

   if (decl == NULL) {

83,455✔

2502

      diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC);

7✔

2503

      const char *id = namek == T_REF ? istr(tree_ident(name)) : NULL;

7✔

2504

      diag_printf(d, "type mark%s%s does not denote a type or a subtype",

10✔

2506

      diag_hint(d, CURRENT_LOC, "%s is a %s name", id ?: "this",

10✔

2508

      diag_emit(d);

7✔

2509

      return type_new(T_NONE);

7✔

2512

   return tree_type(decl);

83,451✔

2515

static void find_disconnect_specification(tree_t guard, tree_t target)

22✔

2517

   if (tree_kind(target) != T_REF)

22✔

2518

      return;

1✔

2519

   else if (!tree_has_ref(target))

21✔

2522

   tree_t decl = tree_ref(target);

21✔

2525

   ident_t name = ident_prefix(tree_ident(decl), ident_new("disconnect"), '$');

21✔

2527

   tree_t spec = NULL;

21✔

2528

   query_name(nametab, name, &spec);

21✔

2530

   if (spec != NULL)

21✔

2531

      tree_set_spec(guard, spec);

6✔

2534

static tree_t find_subprogram_body(tree_t decl)

130✔

2536

   const tree_kind_t decl_kind = tree_kind(decl);

130✔

2537

   if (decl_kind == T_FUNC_BODY || decl_kind == T_PROC_BODY)

130✔

2541

   tree_t pack = tree_container(decl);

54✔

2542

   if (tree_kind(pack) != T_PACKAGE)

54✔

2545

   tree_t du = find_enclosing(nametab, S_DESIGN_UNIT);

53✔

2546

   if (du == pack)

53✔

2549

   tree_t pack_body, d;

45✔

2550

   if (tree_kind(du) == T_PACK_BODY && tree_primary(du) == pack)

45✔

2552

   else if ((pack_body = body_of(pack)) == NULL)

37✔

2555

   type_t type = tree_type(decl);

45✔

2556

   ident_t id = tree_ident(decl);

45✔

2557

   for (int nth = 0; (d = get_local_decl(nametab, pack_body, id, nth)); nth++) {

109✔

2558

      if (is_subprogram(d) && is_body(d) && type_eq(tree_type(d), type))

108✔

2559

         return d;

44✔

2565

static void package_body_deferred_instantiation(tree_t pack, tree_t container)

4✔

2572

   assert(standard() >= STD_08);

4✔

2574

   const int ndecls = tree_decls(pack);

4✔

2575

   for (int i = 0; i < ndecls; i++) {

125✔

2576

      tree_t decl = tree_decl(pack, i);

121✔

2578

      const tree_kind_t dkind = tree_kind(decl);

121✔

2579

      if (dkind != T_FUNC_INST && dkind != T_PROC_INST)

121✔

2580

         continue;

110✔

2581

      else if (!tree_has_ref(decl))

11✔

2582

         continue;

3✔

2584

      tree_t ref = tree_ref(decl);

8✔

2585

      if (is_body(ref))

8✔

2588

      tree_t body = find_subprogram_body(ref);

8✔

2589

      if (body == NULL) {

8✔

2590

         diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC);

1✔

2591

         diag_printf(d, "subprogram %s cannot be instantiated until its "

1✔

2593

         diag_hint(d, tree_loc(decl), "subprogram instantiation in package "

1✔

2595

         diag_hint(d, NULL, "the instantiated subprogram body occurs at "

1✔

2598

         diag_lrm(d, STD_08, "4.4");

1✔

2599

         diag_emit(d);

1✔

2602

         tree_t inst = tree_new(dkind);

7✔

2603

         tree_set_ident(inst, tree_ident(decl));

7✔

2604

         tree_set_ident2(inst, tree_ident2(decl));

7✔

2605

         tree_set_ref(inst, body);

7✔

2607

         instantiate_subprogram(inst, ref, body);

7✔

2609

         hash_t *gmap = hash_new(16);

7✔

2610

         const int ngenmaps = tree_genmaps(decl);

7✔

2611

         for (int i = 0; i < ngenmaps; i++) {

34✔

2612

            tree_t map = tree_genmap(decl, i);

27✔

2613

            assert(tree_subkind(map) == P_POS);

27✔

2615

            tree_add_genmap(inst, map);

27✔

2617

            tree_t g = tree_generic(inst, tree_pos(map));

27✔

2618

            tree_t value = tree_value(map);

27✔

2620

            switch (tree_class(g)) {

27✔

2621

            case C_TYPE:

7✔

2622

               hash_put(gmap, tree_type(g), tree_type(value));

7✔

2623

               break;

7✔

2624

            case C_FUNCTION:

20✔

2626

               hash_put(gmap, g, tree_ref(value));

20✔

2627

               break;

20✔

2637

         instance_fixup(inst, gmap);

7✔

2639

         tree_add_decl(container, inst);

7✔

2642

4✔

2644

static tree_t find_generic_subprogram_body(tree_t inst, tree_t decl)

122✔

2646

   tree_t body = find_subprogram_body(decl);

122✔

2648

   if (body == NULL) {

122✔

2649

      tree_t du = find_enclosing(nametab, S_DESIGN_UNIT);

9✔

2650

      if (tree_kind(du) != T_PACKAGE)

9✔

2651

         parse_error(CURRENT_LOC, "subprogram %s cannot be instantiated "

1✔

2656

         tree_set_ref(inst, decl);

8✔

2657

         tree_set_global_flags(inst, TREE_GF_DEFERRED_INST);

8✔

2661

      tree_set_ref(inst, body);

113✔

2663

   return body;

122✔

2666

static psl_node_t with_default_clock(psl_node_t prop)

377✔

2668

   if (psl_kind(prop) == P_CLOCKED)

377✔

2671

   psl_node_t def = find_default_clock(nametab);

373✔

2672

   if (def == NULL)

373✔

2675

   psl_node_t p = psl_new(P_CLOCKED);

371✔

2676

   psl_set_value(p, prop);

371✔

2677

   psl_set_ref(p, def);

371✔

2678

   psl_set_loc(p, psl_loc(prop));

371✔

2680

   return p;

371✔

2686

static ident_t p_identifier(void)

490,626✔

2690

   if (consume(tID))

490,626✔

2691

      return last_lval.ident;

490,623✔

2693

      return error_marker();

3✔

2696

static ident_t p_selected_identifier(void)

7,488✔

2700

   ident_t id = p_identifier();

7,488✔

2701

   while (optional(tDOT))

9,141✔

2702

      id = ident_prefix(id, p_identifier(), '.');

1,653✔

2704

   return id;

7,488✔

2707

static ident_list_t *p_identifier_list(void)

61,251✔

2711

   ident_list_t *result = NULL;

61,251✔

2713

   ident_list_push(&result, p_identifier(), last_loc);

61,251✔

2715

   while (optional(tCOMMA))

66,803✔

2716

      ident_list_push(&result, p_identifier(), last_loc);

5,552✔

2718

   return result;

61,251✔

2721

static ident_t p_operator_symbol(void)

7,423✔

2725

   consume(tSTRING);

7,423✔

2727

   char *s = last_lval.str;

7,423✔

2728

   for (char *p = s; *p != '\0'; p++)

37,292✔

2729

      *p = tolower_iso88591(*p);

29,869✔

2731

   ident_t id = ident_new(s);

7,423✔

2733

   if (!is_operator_symbol(id))

7,423✔

2734

      parse_error(CURRENT_LOC, "%s is not an operator symbol", s);

1✔

2736

   free(s);

7,423✔

2737

   return id;

7,423✔

2740

static void p_library_clause(tree_t unit)

1,115✔

2744

   BEGIN("library clause");

2,230✔

2746

   consume(tLIBRARY);

1,115✔

2748

   LOCAL_IDENT_LIST ids = p_identifier_list();

2,230✔

2750

   consume(tSEMI);

1,115✔

2752

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

2,230✔

2753

      tree_t l = tree_new(T_LIBRARY);

1,115✔

2754

      tree_set_ident(l, it->ident);

1,115✔

2755

      tree_set_loc(l, &(it->loc));

1,115✔

2757

      tree_add_context(unit, l);

1,115✔

2759

      lib_t lib = lib_find(it->ident);

1,115✔

2760

      if (lib == NULL) {

1,115✔

2761

         LOCAL_TEXT_BUF tb = tb_new();

2✔

2762

         lib_print_search_paths(tb);

1✔

2764

         diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC);

1✔

2765

         diag_printf(d, "library %s not found", istr(it->ident));

1✔

2766

         lib_search_paths_to_diag(d);

1✔

2767

         diag_emit(d);

1✔

2770

         tree_set_ident2(l, lib_name(lib));

1,114✔

2772

      insert_name(nametab, l, NULL);

1,115✔

2774

1,115✔

2776

static void p_use_clause(tree_t unit, add_func_t addf)

3,067✔

2780

   BEGIN("use clause");

6,134✔

2782

   consume(tUSE);

3,067✔

2784

   do {

3,068✔

2785

      tree_t u = tree_new(T_USE);

3,068✔

2787

      ident_t i1 = p_identifier(), i2 = NULL;

3,068✔

2788

      consume(tDOT);

3,068✔

2790

      do {

5,983✔

2791

         i1 = ident_prefix(i1, i2, '.');

5,983✔

2793

         switch (peek()) {

5,983✔

2794

         case tID:

3,055✔

2795

            i2 = p_identifier();

3,055✔

2796

            break;

3,055✔

2797

         case tSTRING:

7✔

2798

            i2 = p_operator_symbol();

7✔

2799

            break;

7✔

2800

         case tALL:

2,918✔

2801

            consume(tALL);

2,918✔

2802

            i2 = well_known(W_ALL);

2,918✔

2803

            break;

2,918✔

2804

         default:

3✔

2805

            expect(tID, tSTRING, tALL);

3✔

2806

            i2 = NULL;

3✔

2807

            break;

3✔

2809

      } while (optional(tDOT));

5,983✔

2811

      tree_set_ident(u, i1);

3,068✔

2812

      tree_set_ident2(u, i2);

3,068✔

2814

      tree_set_loc(u, CURRENT_LOC);

3,068✔

2815

      (*addf)(unit, u);

3,068✔

2817

      tree_t head = resolve_name(nametab, CURRENT_LOC, i1);

3,068✔

2818

      if (head == NULL)

3,068✔

2819

         continue;

5✔

2821

      const tree_kind_t kind = tree_kind(head);

3,063✔

2822

      if (kind == T_LIBRARY && !tree_has_ident2(head)) {

3,063✔

2825

      else if (is_uninstantiated_package(head))

3,063✔

2826

         parse_error(CURRENT_LOC, "cannot use an uninstantiated package");

1✔

2827

      else if (kind == T_LIBRARY || kind == T_PACKAGE

3,062✔

2828

               || kind == T_PACK_INST

163✔

2829

               || (kind == T_GENERIC_DECL

31✔

2830

                   && tree_class(head) == C_PACKAGE)) {

30✔

2831

         tree_set_ref(u, head);

3,061✔

2832

         insert_names_from_use(nametab, u);

3,061✔

2835

         parse_error(CURRENT_LOC, "%s is not a library or %spackage",

1✔

2837

   } while (optional(tCOMMA));

3,068✔

2839

   consume(tSEMI);

3,067✔

2840

3,067✔

2842

static void p_context_reference(tree_t unit)

25✔

2846

   BEGIN("context reference");

50✔

2848

   consume(tCONTEXT);

25✔

2850

   do {

25✔

2851

      ident_t name = p_selected_identifier();

25✔

2853

      tree_t c = tree_new(T_CONTEXT_REF);

25✔

2854

      tree_set_ident(c, name);

25✔

2855

      tree_set_loc(c, CURRENT_LOC);

25✔

2857

      tree_t ctx = resolve_name(nametab, CURRENT_LOC, name);

25✔

2858

      if (ctx != NULL && tree_kind(ctx) == T_CONTEXT) {

25✔

2859

         insert_names_from_context(nametab, ctx);

23✔

2860

         tree_set_ref(c, ctx);

23✔

2862

      else if (ctx != NULL)

2✔

2866

      tree_add_context(unit, c);

25✔

2867

   } while (optional(tCOMMA));

25✔

2869

   consume(tSEMI);

25✔

2870

25✔

2872

static void p_context_item(tree_t unit)

4,095✔

2876

   BEGIN("context item");

8,190✔

2878

   switch (peek()) {

4,095✔

2879

   case tLIBRARY:

1,115✔

2880

      p_library_clause(unit);

1,115✔

2881

      break;

1,115✔

2883

   case tUSE:

2,955✔

2884

      p_use_clause(unit, tree_add_context);

2,955✔

2885

      break;

2,955✔

2887

   case tCONTEXT:

25✔

2888

      p_context_reference(unit);

25✔

2889

      break;

25✔

2894

4,095✔

2896

static void p_context_clause(tree_t unit)

12,933✔

2900

   BEGIN("context clause");

25,866✔

2902

   const int start_errors = error_count();

12,933✔

2904

   while (scan(tLIBRARY, tUSE, tCONTEXT)) {

17,028✔

2905

      if (peek() == tCONTEXT && peek_nth(3) == tIS)

4,114✔

2908

         p_context_item(unit);

4,095✔

2912

   if (error_count() > start_errors)

12,933✔

2913

      suppress_errors(nametab);

12✔

2914

12,933✔

2916

static port_mode_t p_mode(void)

13,800✔

2920

   switch (one_of(tIN, tOUT, tINOUT, tBUFFER, tLINKAGE)) {

13,800✔

2936

static tree_t p_range(tree_t left)

18,153✔

2940

   EXTEND("range");

18,153✔

2942

   tree_t r = tree_new(T_RANGE);

18,153✔

2943

   tree_set_subkind(r, RANGE_ERROR);

18,153✔

2945

   if (is_range_expr(left)) {

18,153✔

2946

      tree_set_subkind(r, RANGE_EXPR);

3,126✔

2947

      tree_set_value(r, left);

3,126✔

2948

      tree_set_loc(r, tree_loc(left));

3,126✔

2951

      tree_set_left(r, left);

15,027✔

2953

      switch (one_of(tTO, tDOWNTO)) {

15,027✔

2954

      case tTO:

7,588✔

2955

         tree_set_subkind(r, RANGE_TO);

7,588✔

2956

         tree_set_right(r, p_expression());

7,588✔

2957

         break;

7,588✔

2959

      case tDOWNTO:

7,438✔

2960

         tree_set_subkind(r, RANGE_DOWNTO);

7,438✔

2961

         tree_set_right(r, p_expression());

7,438✔

2962

         break;

7,438✔

2965

      tree_set_loc(r, CURRENT_LOC);

15,027✔

2968

   return r;

18,153✔

2971

static tree_t p_range_constraint(type_t constraint)

714✔

2975

   BEGIN("range constraint");

714✔

2977

   consume(tRANGE);

714✔

2979

   tree_t t = tree_new(T_CONSTRAINT);

714✔

2980

   tree_set_subkind(t, C_RANGE);

714✔

2982

   tree_t expr1 = p_expression();

714✔

2984

   switch (peek()) {

714✔

2985

   case tTO:

699✔

2988

         tree_t r = p_range(expr1);

699✔

2989

         solve_types(nametab, r, constraint);

699✔

2990

         tree_add_range(t, r);

699✔

2992

      break;

699✔

2993

   default:

15✔

2995

         tree_t r = tree_new(T_RANGE);

15✔

2996

         tree_set_loc(r, tree_loc(expr1));

15✔

2997

         tree_set_subkind(r, RANGE_EXPR);

15✔

2998

         tree_set_value(r, expr1);

15✔

3000

         solve_types(nametab, r, constraint);

15✔

3002

         tree_add_range(t, r);

15✔

3006

   tree_set_loc(t, CURRENT_LOC);

714✔

3007

   return t;

714✔

3010

static tree_t p_discrete_range(tree_t head)

17,459✔

3014

   BEGIN_WITH_HEAD("discrete range", head);

34,918✔

3016

   tree_t expr1 = head ?: p_expression();

17,459✔

3018

   switch (peek()) {

17,459✔

3019

   case tTO:

14,273✔

3022

      return p_range(expr1);

14,273✔

3024

   case tRANGE:

56✔

3026

         type_t constraint = solve_types(nametab, expr1, NULL);

56✔

3028

         const bool is_type =

112✔

3029

            tree_kind(expr1) == T_REF

56✔

3030

            && tree_has_ref(expr1)

55✔

3031

            && is_type_decl(tree_ref(expr1));

110✔

3033

         if (!is_type && !type_is_none(constraint)) {

56✔

3034

            parse_error(tree_loc(expr1), "expected type mark while parsing "

2✔

3036

            constraint = type_new(T_NONE);

2✔

3039

         consume(tRANGE);

56✔

3041

         tree_t left = p_expression();

56✔

3042

         tree_t r = p_range(left);

56✔

3043

         solve_types(nametab, r, constraint);

56✔

3044

         tree_set_type(r, constraint);

56✔

3045

         return r;

56✔

3048

   default:

3,130✔

3050

         type_t type = solve_types(nametab, expr1, NULL);

3,130✔

3052

         if (tree_kind(expr1) == T_ATTR_REF)

3,130✔

3053

            return p_range(expr1);   // Special attributes such as 'RANGE

2,225✔

3054

         else if (tree_kind(expr1) == T_REF && tree_has_ref(expr1)) {

905✔

3057

            if (aliased_type_decl(tree_ref(expr1)) != NULL) {

902✔

3058

               tree_t tmp = tree_new(T_ATTR_REF);

900✔

3059

               tree_set_name(tmp, expr1);

900✔

3060

               tree_set_ident(tmp, ident_new("RANGE"));

900✔

3061

               tree_set_loc(tmp, tree_loc(expr1));

900✔

3062

               tree_set_subkind(tmp, ATTR_RANGE);

900✔

3064

               return p_range(tmp);

900✔

3067

               parse_error(CURRENT_LOC, "name %s in discrete range does not "

2✔

3070

         else if (!type_is_none(type))

3✔

3071

            parse_error(CURRENT_LOC, "expecting a discrete range");

1✔

3074

         tree_t r = tree_new(T_RANGE);

5✔

3075

         tree_set_loc(r, CURRENT_LOC);

5✔

3076

         tree_set_subkind(r, RANGE_ERROR);

5✔

3077

         return r;

5✔

3082

static tree_t p_slice_name(tree_t prefix, tree_t head)

2,244✔

3086

   EXTEND("slice name");

2,244✔

3088

   type_t type = prefix_type(prefix, NULL);

2,244✔

3090

   if (type != NULL && type_is_access(type)) {

2,244✔

3091

      prefix = implicit_dereference(prefix);

35✔

3092

      type   = tree_type(prefix);

35✔

3095

   tree_t t = tree_new(T_ARRAY_SLICE);

2,244✔

3096

   tree_set_value(t, prefix);

2,244✔

3098

   type_t index_type = NULL;

2,244✔

3099

   if (type != NULL && type_is_array(type))

2,244✔

3100

      index_type = index_type_of(type, 0);

2,225✔

3102

   tree_t r = p_discrete_range(head);

2,244✔

3103

   solve_types(nametab, r, index_type);

2,244✔

3104

   convert_universal_bounds(r);

2,244✔

3106

   tree_add_range(t, r);

2,244✔

3107

   consume(tRPAREN);

2,244✔

3109

   tree_set_loc(t, CURRENT_LOC);

2,244✔

3110

   return t;

2,244✔

3113

static tree_t p_formal_part(type_t *signature)

7,014✔

3119

   BEGIN("formal part");

14,028✔

3121

   tree_t name = p_name(0);

7,014✔

3123

   switch (tree_kind(name)) {

7,014✔

3130

   case T_FCALL:

86✔

3131

      if (tree_params(name) == 1)

86✔

3132

         tree_set_flag(name, TREE_F_CONVERSION);

85✔

3135

   case T_REF:

6,251✔

3137

      if (peek() == tLSQUARE) {

6,251✔

3138

         require_std(STD_19, "signature in generic formal designator");

5✔

3139

         *signature = p_signature();

5✔

3140

         tree_set_loc(name, CURRENT_LOC);

5✔

3144

   default:

1✔

3145

      parse_error(CURRENT_LOC, "illegal formal designator");

1✔

3146

      return error_expr();

1✔

3152

static tree_t p_actual_part(class_t class, formal_kind_t kind)

51,002✔

3158

   BEGIN("actual part");

102,004✔

3160

   if (optional(tOPEN)) {

51,002✔

3161

      tree_t t = tree_new(T_OPEN);

94✔

3162

      tree_set_loc(t, CURRENT_LOC);

94✔

3163

      return t;

94✔

3166

   if (class == C_FUNCTION || class == C_PROCEDURE || class == C_PACKAGE)

50,908✔

3167

      return p_name(N_SUBPROGRAM);

142✔

3168

   else if (class == C_TYPE) {

50,766✔

3169

      type_t type = p_subtype_indication();

301✔

3171

      tree_t ref = tree_new(T_TYPE_REF);

301✔

3172

      tree_set_ident(ref, type_ident(type));

301✔

3173

      tree_set_type(ref, type);

301✔

3174

      tree_set_loc(ref, CURRENT_LOC);

301✔

3175

      return ref;

301✔

3178

   if (optional(tINERTIAL)) {

50,465✔

3179

      require_std(STD_08, "inertial in actual designator");

20✔

3181

      tree_t expr = p_expression();

20✔

3183

      if (kind == F_PORT_MAP) {

20✔

3184

         tree_t w = tree_new(T_INERTIAL);

18✔

3185

         tree_set_loc(w, CURRENT_LOC);

18✔

3186

         tree_set_value(w, expr);

18✔

3188

         return w;

18✔

3191

         parse_error(CURRENT_LOC, "the reserved word INERTIAL can only be "

2✔

3193

         return expr;

2✔

3201

   const token_t next = peek();

50,445✔

3202

   const bool had_name = (next == tID || next == tSTRING);

50,445✔

3204

   tree_t designator = p_expression();

50,445✔

3206

   const bool could_be_conversion =

100,890✔

3208

      && tree_kind(designator) == T_FCALL

44,429✔

3209

      && tree_params(designator) == 1;

53,016✔

3211

   if (could_be_conversion)

50,445✔

3212

      tree_set_flag(designator, TREE_F_CONVERSION);

854✔

3217

static void p_association_element(tree_t map, int pos, tree_t unit,

51,002✔

3222

   BEGIN("association element");

102,004✔

3224

   tree_t p = tree_new(T_PARAM);

51,002✔

3226

   const look_params_t lookp = {

51,002✔

3235

   class_t class = C_DEFAULT;

51,002✔

3236

   type_t type = NULL;

51,002✔

3237

   if (look_for(&lookp)) {

51,002✔

3238

      tree_set_subkind(p, P_NAMED);

7,014✔

3240

      push_scope_for_formals(nametab, kind, unit);

7,014✔

3242

      type_t signature = NULL;

7,014✔

3243

      tree_t name = p_formal_part(&signature);

7,014✔

3245

      tree_t ref = name_to_ref(name);

7,014✔

3246

      if (ref != NULL && tree_has_ref(ref)) {

7,014✔

3247

         tree_t decl = tree_ref(ref);

5,551✔

3248

         const tree_kind_t kind = tree_kind(decl);

5,551✔

3249

         if (kind == T_PORT_DECL || kind == T_PARAM_DECL

5,551✔

3250

             || kind == T_GENERIC_DECL)

1,709✔

3251

            class = tree_class(decl);

4,963✔

3254

      if (signature != NULL && kind != F_GENERIC_MAP) {

7,014✔

3255

         parse_error(tree_loc(name), "a signature is only allowed in a "

1✔

3257

         signature = NULL;

1✔

3260

      if (class != C_PACKAGE && (kind == F_GENERIC_MAP || kind == F_PORT_MAP))

7,014✔

3261

         type = solve_types(nametab, name, signature);

3,493✔

3263

      if (kind == F_PORT_MAP && tree_kind(name) == T_FCALL)

7,014✔

3264

         name = fcall_to_conv_func(name);

84✔

3266

      tree_set_name(p, name);

7,014✔

3268

      pop_scope(nametab);

7,014✔

3270

      consume(tASSOC);

7,014✔

3273

      tree_set_subkind(p, P_POS);

43,988✔

3274

      tree_set_pos(p, pos);

43,988✔

3276

      tree_t formal = NULL;

43,988✔

3277

      switch (kind) {

43,988✔

3278

      case F_GENERIC_MAP:

606✔

3279

         if (unit != NULL && pos < tree_generics(unit))

606✔

3280

            formal = tree_generic(unit, pos);

596✔

3282

      case F_PORT_MAP:

1,490✔

3283

         if (unit != NULL && pos < tree_ports(unit))

1,490✔

3284

            formal = tree_port(unit, pos);

1,481✔

3290

      if (formal != NULL && (class = tree_class(formal)) != C_PACKAGE)

2,077✔

3291

         type = tree_type(formal);

2,047✔

3294

   tree_t value = p_actual_part(class, kind);

51,002✔

3296

   if (kind == F_PORT_MAP)

51,002✔

3297

      solve_types(nametab, value, type);

3,902✔

3298

   else if (kind == F_GENERIC_MAP && class != C_PACKAGE) {

47,100✔

3299

      type_t value_type = solve_types(nametab, value, type);

1,657✔

3303

      if (class == C_TYPE && type != NULL)

1,657✔

3304

         map_generic_type(nametab, type, value_type);

301✔

3307

   if (kind == F_PORT_MAP && tree_kind(value) == T_FCALL)

51,002✔

3308

      value = fcall_to_conv_func(value);

146✔

3310

   tree_set_value(p, value);

51,002✔

3311

   tree_set_loc(p, CURRENT_LOC);

51,002✔

3313

   switch (kind) {

51,002✔

3314

   case F_GENERIC_MAP:

1,737✔

3315

      tree_add_genmap(map, p);

1,737✔

3316

      break;

1,737✔

3317

   case F_PORT_MAP:

49,265✔

3319

      tree_add_param(map, p);

49,265✔

3320

      break;

49,265✔

3324

51,002✔

3326

static void p_association_list(tree_t map, tree_t unit, formal_kind_t kind)

23,991✔

3330

   BEGIN("association list");

47,982✔

3332

   int pos = 0;

23,991✔

3333

   do {

51,002✔

3334

      p_association_element(map, pos++, unit, kind);

51,002✔

3335

   } while (optional(tCOMMA));

51,002✔

3336

23,991✔

3338

static void p_actual_parameter_part(tree_t call)

21,449✔

3342

   BEGIN("actual parameter part");

42,898✔

3344

   p_association_list(call, call, F_SUBPROGRAM);

21,449✔

3345

21,449✔

3347

static void p_parameter_map_aspect(tree_t call)

2✔

3351

   BEGIN("actual parameter part");

4✔

3353

   consume(tPARAMETER);

2✔

3354

   consume(tMAP);

2✔

3356

   require_std(STD_19, "parameter map aspect");

2✔

3358

   consume(tLPAREN);

2✔

3360

   p_association_list(call, call, F_SUBPROGRAM);

2✔

3362

   consume(tRPAREN);

2✔

3363

2✔

3365

static tree_t p_function_call(ident_t id, tree_t prefix)

14,521✔

3370

   EXTEND("function call");

29,042✔

3372

   tree_t call;

14,521✔

3373

   if (prefix != NULL) {

14,521✔

3374

      call = tree_new(T_PROT_FCALL);

784✔

3375

      tree_set_ident(call, id);

784✔

3376

      tree_set_name(call, prefix);

784✔

3379

      call = tree_new(T_FCALL);

13,737✔

3380

      tree_set_ident(call, id);

13,737✔

3383

   if (peek() == tGENERIC) {

14,521✔

3384

      tree_t inst = tree_new(T_FUNC_INST);

17✔

3385

      tree_set_ident(inst, ident_prefix(id, ident_uniq("inst"), '$'));

17✔

3387

      tree_t decl = resolve_uninstantiated_subprogram(nametab, CURRENT_LOC,

17✔

3389

      if (decl != NULL) {

17✔

3390

         tree_t body = find_generic_subprogram_body(inst, decl);

17✔

3391

         instantiate_subprogram(inst, decl, body);

17✔

3402

      p_generic_map_aspect(inst, inst);

17✔

3404

      require_std(STD_19, "generic map on function call");

17✔

3406

      tree_set_loc(inst, CURRENT_LOC);

17✔

3407

      sem_check(inst, nametab);

17✔

3409

      hash_t *map = get_generic_map(nametab);

17✔

3410

      if (map != NULL)

17✔

3411

         instance_fixup(inst, map);

17✔

3413

      tree_set_ref(call, inst);

17✔

3415

      mangle_func(nametab, inst);

17✔

3417

      tree_t container = find_enclosing(nametab, S_DECLARATIVE_REGION);

17✔

3418

      tree_add_decl(container, inst);

17✔

3421

   if (peek() == tPARAMETER)

14,521✔

3422

      p_parameter_map_aspect(call);

1✔

3423

   else if (optional(tLPAREN)) {

14,520✔

3424

      p_actual_parameter_part(call);

13,850✔

3425

      consume(tRPAREN);

13,850✔

3428

   tree_set_loc(call, CURRENT_LOC);

14,521✔

3429

   return could_be_slice_name(call);

14,521✔

3432

static tree_t p_attribute_name(tree_t prefix)

23,171✔

3436

   EXTEND("attribute name");

23,171✔

3438

   type_t signature = NULL;

23,171✔

3439

   if (peek() == tLSQUARE)

23,171✔

3440

      signature = p_signature();

14✔

3442

   consume(tTICK);

23,171✔

3444

   attr_kind_t kind;

23,171✔

3445

   ident_t id;

23,171✔

3446

   switch (peek()) {

23,171✔

3447

   case tRANGE:

2,203✔

3448

      consume(tRANGE);

2,203✔

3449

      id = ident_new("RANGE");

2,203✔

3450

      kind = ATTR_RANGE;

2,203✔

3451

      break;

2,203✔

3452

   case tREVRANGE:

53✔

3453

      consume(tREVRANGE);

53✔

3454

      id = ident_new("REVERSE_RANGE");

53✔

3455

      kind = ATTR_REVERSE_RANGE;

53✔

3456

      break;

53✔

3457

   case tSUBTYPE:

129✔

3458

      consume(tSUBTYPE);

129✔

3459

      require_std(STD_08, "subtype attribute");

129✔

3460

      id = ident_new("SUBTYPE");

129✔

3461

      kind = ATTR_SUBTYPE;

129✔

3462

      break;

129✔

3463

   case tID:

20,785✔

3464

      id = p_identifier();

20,785✔

3465

      kind = parse_predefined_attr(id);

20,785✔

3466

      break;

20,785✔

3467

   default:

1✔

3468

      one_of(tRANGE, tREVRANGE, tID, tSUBTYPE);

1✔

3469

      kind = ATTR_USER;

1✔

3470

      id = error_marker();

1✔

3473

   type_t type = prefix_type(prefix, signature);

23,171✔

3475

   if (signature != NULL) {

23,171✔

3476

      bool valid_signature = false;

14✔

3477

      if (type == NULL)

14✔

3479

      else if (type_is_subprogram(type))

13✔

3481

      else if (class_of(prefix) == C_LITERAL && type_is_enum(type))

5✔

3483

      else if (type_is_none(type))

1✔

3487

         parse_error(CURRENT_LOC, "prefix of attribute name with signature "

1✔

3491

   if (type != NULL && type_kind(type) == T_INCOMPLETE) {

23,171✔

3492

      type = resolve_type(nametab, type);

2✔

3493

      tree_set_type(prefix, type);

2✔

3496

   const bool deref_prefix =

46,342✔

3497

      !is_type_attribute(kind) && kind != ATTR_REFLECT

23,171✔

3498

      && kind != ATTR_PATH_NAME && kind != ATTR_INSTANCE_NAME

22,943✔

3499

      && kind != ATTR_SIMPLE_NAME

22,624✔

3500

      && type != NULL && type_is_access(type);

45,222✔

3502

   if (deref_prefix) {

23,171✔

3503

      prefix = implicit_dereference(prefix);

168✔

3504

      type   = tree_type(prefix);

168✔

3507

   tree_t t = tree_new(T_ATTR_REF);

23,171✔

3508

   tree_set_name(t, prefix);

23,171✔

3510

   tree_set_ident(t, id);

23,171✔

3511

   tree_set_subkind(t, kind);

23,171✔

3512

   tree_set_loc(t, CURRENT_LOC);

23,171✔

3514

   if (attribute_has_param(kind) && optional(tLPAREN)) {

23,171✔

3515

      add_param(t, p_expression(), P_POS, NULL);

3,099✔

3516

      consume(tRPAREN);

3,099✔

3517

      tree_set_loc(t, CURRENT_LOC);

3,099✔

3520

   if (is_type_attribute(kind))

23,171✔

3521

      tree_set_type(t, apply_type_attribute(t));

228✔

3522

   else if (kind == ATTR_DELAYED || kind == ATTR_TRANSACTION

22,943✔

3523

            || kind == ATTR_STABLE || kind == ATTR_QUIET)

22,747✔

3524

      implicit_signal_attribute(t);

310✔

3526

   return t;

23,171✔

3529

static tree_t p_selected_name(tree_t prefix, name_mask_t *mask)

12,192✔

3533

   EXTEND("selected name");

24,384✔

3537

   tree_kind_t prefix_kind = tree_kind(prefix);

12,192✔

3538

   if ((*mask & N_FUNC) && prefix_kind == T_REF) {

12,192✔

3539

      ident_t id = tree_ident(prefix);

17✔

3540

      tree_t sub = find_enclosing(nametab, S_SUBPROGRAM);

17✔

3541

      if (sub != NULL && tree_ident(sub) == id)

17✔

3542

         tree_set_ref(prefix, sub);

2✔

3544

         prefix = p_function_call(id, NULL);

15✔

3545

         prefix_kind = T_FCALL;

15✔

3548

   else if (prefix_kind == T_PROT_REF) {

12,175✔

3549

      prefix = p_function_call(tree_ident(prefix), tree_value(prefix));

120✔

3550

      prefix_kind = T_FCALL;

120✔

3553

   consume(tDOT);

12,192✔

3554

   *mask = 0;

12,192✔

3556

   ident_t suffix = NULL;

12,192✔

3557

   switch (peek()) {

12,192✔

3558

   case tID:

11,148✔

3559

      suffix = p_identifier();

11,148✔

3560

      break;

11,148✔

3562

   case tSTRING:

5✔

3563

      suffix = p_operator_symbol();

5✔

3564

      break;

5✔

3566

   case tALL:

1,039✔

3568

         consume(tALL);

1,039✔

3570

         tree_t all = tree_new(T_ALL);

1,039✔

3571

         tree_set_loc(all, CURRENT_LOC);

1,039✔

3572

         tree_set_value(all, prefix);

1,039✔

3573

         *mask |= N_OBJECT;

1,039✔

3574

         return all;

1,039✔

3583

   if (prefix_kind == T_REF && tree_has_ref(prefix)) {

11,153✔

3584

      tree_t decl = tree_ref(prefix);

9,302✔

3585

      const tree_kind_t kind = tree_kind(decl);

9,302✔

3586

      if (kind == T_LIBRARY) {

9,302✔

3587

         ident_t unit_name = ident_prefix(tree_ident(prefix), suffix, '.');

346✔

3588

         tree_t unit = resolve_name(nametab, CURRENT_LOC, unit_name);

346✔

3589

         if (unit == NULL) {

346✔

3590

            tree_t dummy = tree_new(T_REF);

3✔

3591

            tree_set_ident(dummy, unit_name);

3✔

3592

            tree_set_type(dummy, type_new(T_NONE));

3✔

3593

            *mask |= N_ERROR;

3✔

3594

            return dummy;

3✔

3597

            assert(is_design_unit(unit));

343✔

3599

            tree_t ref = tree_new(T_REF);

343✔

3600

            tree_set_loc(ref, CURRENT_LOC);

343✔

3601

            tree_set_ident(ref, unit_name);

343✔

3602

            tree_set_ref(ref, unit);

343✔

3603

            return ref;

343✔

3606

      else if (kind == T_GENERIC_DECL && tree_class(decl) == C_PACKAGE)

8,956✔

3607

         return select_decl(tree_value(decl), suffix, mask);

76✔

3608

      else if (is_container(decl)) {

8,880✔

3609

         tree_t ref = select_decl(prefix, suffix, mask);

672✔

3610

         if (!tree_has_ref(ref))

672✔

3614

         tree_t du = find_enclosing(nametab, S_DESIGN_UNIT);

509✔

3615

         if (du == decl || (kind == T_ENTITY && primary_unit_of(du) == decl))

509✔

3616

            return ref;

2✔

3617

         else if (kind == T_PACKAGE && is_uninstantiated_package(decl))

507✔

3618

            parse_error(CURRENT_LOC, "cannot reference %s in uninstantiated "

1✔

3621

         else if (kind != T_PACKAGE && kind != T_PACK_INST

506✔

3622

                  && !is_enclosing(nametab, decl)) {

38✔

3623

            diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC);

2✔

3624

            diag_printf(d, "expanded name cannot reference %s in %s %s "

2✔

3627

            diag_lrm(d, STD_08, "8.3");

2✔

3628

            diag_emit(d);

2✔

3631

         return ref;

507✔

3633

      else if (is_type_decl(decl)) {

8,208✔

3634

         diag_t *d = pedantic_diag(tree_loc(prefix));

4✔

3635

         if (d != NULL) {

4✔

3636

            diag_printf(d, "type mark cannot be the prefix of a selected name");

1✔

3637

            diag_emit(d);

1✔

3640

         *mask |= N_TYPE;

4✔

3644

   if (scope_formal_kind(nametab) == F_SUBPROGRAM) {

10,059✔

3645

      tree_t rref = tree_new(T_RECORD_REF);

41✔

3646

      tree_set_value(rref, prefix);

41✔

3647

      tree_set_ident(rref, suffix);

41✔

3648

      tree_set_loc(rref, CURRENT_LOC);

41✔

3649

      *mask |= N_OBJECT;

41✔

3650

      return rref;

41✔

3653

   type_t type = solve_types(nametab, prefix, NULL);

10,018✔

3655

   if (type_is_access(type)) {

10,018✔

3656

      prefix = implicit_dereference(prefix);

750✔

3657

      type   = tree_type(prefix);

750✔

3658

      prefix_kind = T_ALL;

750✔

3661

   if (type_kind(type) == T_INCOMPLETE) {

10,018✔

3662

      type = resolve_type(nametab, type);

447✔

3663

      tree_set_type(prefix, type);

447✔

3666

   if (type_is_record(type) || type_is_none(type)) {

10,018✔

3667

      tree_t rref = tree_new(T_RECORD_REF);

9,013✔

3668

      tree_set_value(rref, prefix);

9,013✔

3669

      tree_set_ident(rref, suffix);

9,013✔

3670

      tree_set_loc(rref, CURRENT_LOC);

9,013✔

3671

      *mask |= N_OBJECT;

9,013✔

3672

      return rref;

9,013✔

3674

   else if (type_is_protected(type)) {

1,005✔

3675

      tree_t pref = tree_new(T_PROT_REF);

1,003✔

3676

      tree_set_value(pref, prefix);

1,003✔

3677

      tree_set_ident(pref, suffix);

1,003✔

3678

      tree_set_loc(pref, CURRENT_LOC);

1,003✔

3679

      *mask |= N_SUBPROGRAM;

1,003✔

3680

      return pref;

1,003✔

3682

   else if (type_kind(type) == T_INCOMPLETE) {

2✔

3688

   else if (prefix_kind == T_REF) {

2✔

3689

      parse_error(tree_loc(prefix), "object %s with type %s cannot be selected",

1✔

3691

      tree_set_type(prefix, type_new(T_NONE));

1✔

3692

      *mask |= N_ERROR;

1✔

3693

      return prefix;

1✔

3696

      parse_error(tree_loc(prefix), "object with type %s cannot be selected",

1✔

3698

      tree_set_type(prefix, type_new(T_NONE));

1✔

3699

      *mask |= N_ERROR;

1✔

3700

      return prefix;

1✔

3704

static tree_t p_indexed_name(tree_t prefix, tree_t head)

14,559✔

3708

   EXTEND("indexed name");

14,559✔

3710

   type_t type = prefix_type(prefix, NULL);

14,559✔

3712

   if (type != NULL && type_is_access(type)) {

14,559✔

3713

      prefix = implicit_dereference(prefix);

344✔

3714

      type   = tree_type(prefix);

344✔

3717

   tree_t t = tree_new(T_ARRAY_REF);

14,559✔

3718

   tree_set_value(t, prefix);

14,559✔

3720

   do {

14,559✔

3721

      tree_t index = head ?: p_expression();

16,200✔

3722

      head = NULL;

16,200✔

3723

      add_param(t, index, P_POS, NULL);

16,200✔

3724

   } while (optional(tCOMMA));

16,200✔

3726

   consume(tRPAREN);

14,559✔

3728

   tree_set_loc(t, CURRENT_LOC);

14,559✔

3729

   return t;

14,559✔

3732

static tree_t p_type_conversion(tree_t prefix)

2,853✔

3736

   EXTEND("type conversion");

2,853✔

3738

   consume(tLPAREN);

2,853✔

3740

   type_t type = NULL;

2,853✔

3741

   if (tree_kind(prefix) == T_ATTR_REF)

2,853✔

3742

      type = tree_type(prefix);

9✔

3744

      assert(tree_kind(prefix) == T_REF);

2,844✔

3745

      tree_t tdecl = resolve_name(nametab, CURRENT_LOC, tree_ident(prefix));

2,844✔

3746

      if (tdecl == NULL)

2,844✔

3749

         tdecl = aliased_type_decl(tdecl);

2,844✔

3750

         assert(tdecl);   // Call to this is guarded by N_TYPE mask

2,844✔

3751

         type = tree_type(tdecl);

2,844✔

3755

   tree_t value = p_expression();

2,853✔

3756

   solve_types(nametab, value, NULL);

2,853✔

3758

   tree_t conv = tree_new(T_TYPE_CONV);

2,853✔

3759

   tree_set_type(conv, type);

2,853✔

3760

   tree_set_value(conv, value);

2,853✔

3762

   consume(tRPAREN);

2,853✔

3764

   tree_set_loc(conv, CURRENT_LOC);

2,853✔

3765

   return conv;

2,853✔

3768

static void p_partial_pathname(tree_t name)

185✔

3772

   BEGIN("partial pathname");

370✔

3774

   do {

417✔

3775

      tree_t pe = tree_new(T_PATH_ELT);

417✔

3776

      tree_set_ident(pe, p_identifier());

417✔

3778

      if (optional(tLPAREN)) {

417✔

3779

         tree_t expr = p_expression();

30✔

3780

         solve_types(nametab, expr, NULL);

30✔

3782

         tree_set_subkind(pe, PE_GENERATE);

30✔

3783

         tree_set_value(pe, expr);

30✔

3784

         consume(tRPAREN);

30✔

3785

         tree_set_loc(pe, CURRENT_LOC);

30✔

3788

         tree_set_subkind(pe, PE_SIMPLE);

387✔

3789

         tree_set_loc(pe, &last_loc);

387✔

3792

      tree_add_part(name, pe);

417✔

3793

   } while (optional(tDOT));

417✔

3794

185✔

3796

static void p_package_pathname(tree_t name)

7✔

3801

   BEGIN("package pathname");

14✔

3803

   consume(tAT);

7✔

3805

   tree_t pe = tree_new(T_PATH_ELT);

7✔

3806

   tree_set_subkind(pe, PE_LIBRARY);

7✔

3807

   tree_set_ident(pe, p_identifier());

7✔

3808

   tree_set_loc(pe, CURRENT_LOC);

7✔

3810

   tree_add_part(name, pe);

7✔

3812

   consume(tDOT);

7✔

3814

   p_partial_pathname(name);

7✔

3815

7✔

3817

static void p_absolute_pathname(tree_t name)

44✔

3821

   BEGIN("absolute pathname");

88✔

3823

   consume(tDOT);

44✔

3825

   tree_t pe = tree_new(T_PATH_ELT);

44✔

3826

   tree_set_subkind(pe, PE_ABSOLUTE);

44✔

3827

   tree_set_loc(pe, CURRENT_LOC);

44✔

3829

   tree_add_part(name, pe);

44✔

3831

   p_partial_pathname(name);

44✔

3832

44✔

3834

static void p_relative_pathname(tree_t name)

134✔

3838

   BEGIN("relative pathname");

268✔

3840

   tree_t pe = tree_new(T_PATH_ELT);

134✔

3841

   tree_set_subkind(pe, PE_RELATIVE);

134✔

3843

   tree_add_part(name, pe);

134✔

3845

   while (peek() == tCARET) {

185✔

3846

      consume(tCARET);

51✔

3847

      consume(tDOT);

51✔

3849

      tree_t pe = tree_new(T_PATH_ELT);

51✔

3850

      tree_set_loc(pe, CURRENT_LOC);

51✔

3851

      tree_set_subkind(pe, PE_CARET);

51✔

3853

      tree_add_part(name, pe);

51✔

3856

   p_partial_pathname(name);

134✔

3857

134✔

3859

static void p_external_pathname(tree_t name)

185✔

3863

   BEGIN("external pathname");

370✔

3865

   switch (peek()) {

185✔

3866

   case tDOT:

44✔

3867

      p_absolute_pathname(name);

44✔

3868

      break;

44✔

3869

   case tCARET:

134✔

3871

      p_relative_pathname(name);

134✔

3872

      break;

134✔

3873

   case tAT:

7✔

3874

      p_package_pathname(name);

7✔

3875

      break;

7✔

3879

185✔

3881

static tree_t p_external_name(void)

185✔

3887

   BEGIN("external name");

185✔

3889

   consume(tLTLT);

185✔

3891

   require_std(STD_08, "external names");

185✔

3893

   tree_t t = tree_new(T_EXTERNAL_NAME);

185✔

3895

   switch (one_of(tCONSTANT, tSIGNAL, tVARIABLE)) {

185✔

3896

   case tSIGNAL:   tree_set_class(t, C_SIGNAL); break;

142✔

3897

   case tCONSTANT: tree_set_class(t, C_CONSTANT); break;

37✔

3898

   case tVARIABLE: tree_set_class(t, C_VARIABLE); break;

6✔

3901

   p_external_pathname(t);

185✔

3903

   consume(tCOLON);

185✔

3905

   tree_set_type(t, p_subtype_indication());

185✔

3907

   consume(tGTGT);

185✔

3909

   tree_set_global_flags(t, TREE_GF_EXTERNAL_NAME);

185✔

3911

   tree_set_loc(t, CURRENT_LOC);

185✔

3912

   return t;

185✔

3915

static tree_t p_name(name_mask_t stop_mask)

313,699✔

3920

   BEGIN("name");

627,398✔

3922

   ident_t id = NULL;

313,699✔

3923

   switch (peek()) {

313,699✔

3924

   case tSTRING:

99✔

3925

      id = p_operator_symbol();

99✔

3926

      break;

99✔

3928

   case tID:

313,409✔

3929

      id = p_identifier();

313,409✔

3930

      break;

313,409✔

3932

   case tLTLT:

185✔

3933

      return p_external_name();

185✔

3935

   default:

6✔

3937

         expect(tSTRING, tID);

6✔

3939

         tree_t dummy = tree_new(T_REF);

6✔

3940

         tree_set_loc(dummy, CURRENT_LOC);

6✔

3941

         tree_set_ident(dummy, error_marker());

6✔

3942

         tree_set_type(dummy, type_new(T_NONE));

6✔

3943

         return dummy;

6✔

3947

   tree_t decl = NULL;

313,508✔

3948

   name_mask_t mask = query_name(nametab, id, &decl);

313,508✔

3950

   tree_t prefix = tree_new(T_REF);

313,508✔

3951

   tree_set_ident(prefix, id);

313,508✔

3952

   tree_set_loc(prefix, CURRENT_LOC);

313,508✔

3953

   tree_set_ref(prefix, decl);

313,508✔

3955

   for (;;) {

385,750✔

3956

      switch (peek()) {

385,750✔

3958

         break;

51,364✔

3960

      case tDOT:

12,192✔

3961

         prefix = p_selected_name(prefix, &mask);

12,192✔

3962

         continue;

12,192✔

3964

      case tTICK:

26,799✔

3965

         if (peek_nth(2) == tLPAREN) {

26,799✔

3966

            if (mask & stop_mask)

3,642✔

3967

               return prefix;

256✔

3969

               prefix = p_qualified_expression(prefix);

3,386✔

3970

               mask = N_OBJECT;

3,386✔

3974

            prefix = p_attribute_name(prefix);

23,157✔

3975

            mask = is_type_attribute(tree_subkind(prefix)) ? N_TYPE : N_OBJECT;

46,086✔

3977

         continue;

26,543✔

3979

      case tPARAMETER:

102✔

3981

         if ((mask & stop_mask) || !(mask & N_SUBPROGRAM))

102✔

3982

            return prefix;

85✔

3984

            prefix = p_function_call(tree_ident(prefix), NULL);

17✔

3985

            mask = N_OBJECT;

17✔

3986

            continue;

17✔

3996

      if (mask & stop_mask)

51,364✔

3997

         return prefix;

17,874✔

3999

      if (!(mask & N_FUNC) && scope_formal_kind(nametab) == F_SUBPROGRAM) {

33,490✔

4001

         mask |= N_OBJECT;

18✔

4004

      const tree_kind_t prefix_kind = tree_kind(prefix);

33,490✔

4006

      if (mask & N_TYPE) {

33,490✔

4008

         prefix = p_type_conversion(prefix);

2,853✔

4009

         mask = N_OBJECT;

2,853✔

4010

         continue;

2,853✔

4012

      else if ((mask & N_SUBPROGRAM) && prefix_kind == T_REF) {

30,637✔

4014

         prefix = p_function_call(tree_ident(prefix), NULL);

13,705✔

4015

         mask = N_OBJECT;

13,705✔

4016

         continue;

13,705✔

4018

      else if (!(mask & N_OBJECT) && prefix_kind == T_PROT_REF) {

16,932✔

4020

         prefix = p_function_call(tree_ident(prefix), tree_value(prefix));

129✔

4021

         mask = N_OBJECT;

129✔

4022

         continue;

129✔

4028

      consume(tLPAREN);

16,803✔

4030

      tree_t head = p_expression();

16,803✔

4032

      if (scan(tDOWNTO, tTO) || is_range_expr(head))

16,803✔

4033

         prefix = p_slice_name(prefix, head);

2,244✔

4035

         prefix = p_indexed_name(prefix, head);

14,559✔

4039

static type_t p_type_mark(void)

16,477✔

4043

   BEGIN("type mark");

32,954✔

4045

   tree_t name = p_name(N_TYPE);

16,477✔

4046

   return name_to_type_mark(name);

16,477✔

4049

static tree_t p_index_constraint(type_t base)

10,750✔

4053

   BEGIN("index constraint");

10,750✔

4055

   consume(tLPAREN);

10,750✔

4057

   int n = 0;

10,750✔

4058

   tree_t t = tree_new(T_CONSTRAINT);

10,750✔

4059

   tree_set_subkind(t, C_INDEX);

10,750✔

4060

   do {

10,920✔

4061

      type_t index_type = base ? index_type_of(base, n++) : NULL;

10,920✔

4062

      tree_t r = p_discrete_range(NULL);

10,920✔

4063

      solve_types(nametab, r, index_type);

10,920✔

4064

      tree_add_range(t, r);

10,920✔

4065

   } while (optional(tCOMMA));

10,920✔

4067

   consume(tRPAREN);

10,750✔

4069

   tree_set_loc(t, CURRENT_LOC);

10,750✔

4070

   return t;

10,750✔

4073

static type_t p_element_constraint(type_t base)

867✔

4077

   BEGIN("element constraint");

867✔

4079

   type_t sub = type_new(T_SUBTYPE);

867✔

4080

   if (is_anonymous_subtype(base)) {

867✔

4081

      type_set_base(sub, type_base(base));

16✔

4082

      if (type_has_constraint(base))

16✔

4083

         type_set_constraint(sub, type_constraint(base));

11✔

4084

      if (type_has_elem(base))

16✔

4085

         type_set_elem(sub, type_elem(base));

5✔

4088

      type_set_base(sub, base);

851✔

4090

   if (type_is_record(base))

867✔

4091

      type_set_constraint(sub, p_record_constraint(sub));

122✔

4093

      p_array_constraint(sub, base);

745✔

4095

   return sub;

867✔

4098

static void p_array_constraint(type_t type, type_t base)

5,549✔

4103

   BEGIN("array constraint");

5,832✔

4105

   if (peek_nth(2) == tOPEN) {

5,549✔

4106

      consume(tLPAREN);

62✔

4107

      consume(tOPEN);

62✔

4108

      consume(tRPAREN);

62✔

4110

      if (!type_is_array(type) && !type_is_none(type))

62✔

4111

         parse_error(CURRENT_LOC, "open array constraint cannot be used "

1✔

4115

      tree_t c = p_index_constraint(base);

5,487✔

4117

      if (type_has_constraint(type)) {

5,487✔

4118

         diag_t *d = diag_new(DIAG_ERROR, tree_loc(c));

3✔

4119

         diag_printf(d, "array element is already constrained");

3✔

4120

         diag_hint(d, tree_loc(type_constraint(type)),

3✔

4122

         diag_emit(d);

3✔

4125

         type_set_constraint(type, c);

5,484✔

4128

   if (peek() != tLPAREN)

5,549✔

4129

      return;

5,266✔

4132

   type_t elem = base;

283✔

4133

   if (type_is_array(base))

283✔

4134

      elem = type_elem(base);

283✔

4136

   type_set_elem(type, p_element_constraint(elem));

283✔

4139

static tree_t p_record_element_constraint(type_t base)

584✔

4143

   BEGIN("record element constraint");

584✔

4145

   ident_t id = p_identifier();

584✔

4148

   tree_t decl = NULL;

584✔

4149

   if (type_is_record(base))

584✔

4150

      decl = resolve_field_name(nametab, &last_loc, id, base);

584✔

4152

   type_t ftype;

584✔

4153

   if (decl != NULL) {

584✔

4154

      assert(tree_kind(decl) == T_FIELD_DECL);

581✔

4156

      tree_t cons = type_constraint_for_field(base, decl);

581✔

4157

      ftype = cons ? tree_type(cons) : tree_type(decl);

581✔

4160

      ftype = type_new(T_NONE);

3✔

4162

   tree_t elem = tree_new(T_ELEM_CONSTRAINT);

584✔

4163

   tree_set_ident(elem, id);

584✔

4164

   tree_set_ref(elem, decl);

584✔

4166

   type_t sub = p_element_constraint(ftype);

584✔

4168

   tree_set_type(elem, sub);

584✔

4169

   tree_set_loc(elem, CURRENT_LOC);

584✔

4170

   return elem;

584✔

4173

static tree_t p_record_constraint(type_t base)

347✔

4177

   BEGIN("record constraint");

347✔

4179

   consume(tLPAREN);

347✔

4181

   tree_t c = tree_new(T_CONSTRAINT);

347✔

4182

   tree_set_subkind(c, C_RECORD);

347✔

4184

   do {

584✔

4185

      tree_add_range(c, p_record_element_constraint(base));

584✔

4186

   } while (optional(tCOMMA));

584✔

4188

   consume(tRPAREN);

347✔

4190

   tree_set_loc(c, CURRENT_LOC);

347✔

4191

   return c;

347✔

4194

static void p_constraint(type_t type)

10,792✔

4199

   BEGIN("constraint");

21,584✔

4201

   assert(type_kind(type) == T_SUBTYPE);

10,792✔

4202

   type_t base = type_base(type);

10,792✔

4204

   switch (peek()) {

10,792✔

4205

   case tRANGE:

500✔

4206

      type_set_constraint(type, p_range_constraint(base));

500✔

4207

      break;

500✔

4209

   case tLPAREN:

10,292✔

4210

      if (standard() < STD_08)

10,292✔

4211

         type_set_constraint(type, p_index_constraint(base));

5,263✔

4212

      else if (type_is_record(base))

5,029✔

4213

         type_set_constraint(type, p_record_constraint(base));

225✔

4215

         p_array_constraint(type, base);

4,804✔

4221

10,792✔

4223

static tree_t p_element_resolution(void)

30✔

4227

   BEGIN("element resolution");

30✔

4229

   tree_t t = tree_new(T_ELEM_RESOLUTION);

30✔

4231

   do {

31✔

4232

      tree_t a = tree_new(T_ASSOC);

31✔

4233

      tree_set_subkind(a, A_POS);

31✔

4234

      tree_set_value(a, p_resolution_indication());

31✔

4235

      tree_set_loc(a, CURRENT_LOC);

31✔

4237

      tree_add_assoc(t, a);

31✔

4238

   } while (optional(tCOMMA));

31✔

4240

   tree_set_loc(t, CURRENT_LOC);

30✔

4241

   return t;

30✔

4244

static tree_t p_resolution_indication(void)

57✔

4248

   BEGIN("resolution indication");

114✔

4250

   if (peek() == tID || standard() < STD_08)

57✔

4251

      return p_name(N_SUBPROGRAM);

27✔

4253

      one_of(tLPAREN, tID);

30✔

4254

      tree_t rname = p_element_resolution();

30✔

4255

      consume(tRPAREN);

30✔

4256

      return rname;

30✔

4260

static type_t p_subtype_indication(void)

65,743✔

4264

   BEGIN("subtype indication");

65,743✔

4266

   bool made_subtype = false;

65,743✔

4267

   type_t type = NULL;

65,743✔

4268

   tree_t rname = NULL;

65,743✔

4270

   if (peek() == tLPAREN)

65,743✔

4271

      rname = p_resolution_indication();

26✔

4273

      tree_t name = p_name(N_TYPE);

65,717✔

4274

      if (peek() == tID)

65,717✔

4277

         type = name_to_type_mark(name);

65,389✔

4280

   if (rname != NULL) {

65,743✔

4281

      type = type_new(T_SUBTYPE);

354✔

4282

      made_subtype = true;

354✔

4284

      type_set_resolution(type, rname);

354✔

4285

      type_set_base(type, p_type_mark());

354✔

4287

      resolve_resolution(nametab, rname, type);

354✔

4290

   if (type == NULL)

65,743✔

4293

   if (scan(tRANGE, tLPAREN)) {

65,743✔

4294

      if (!made_subtype) {

10,792✔

4295

         type_t sub = type_new(T_SUBTYPE);

10,773✔

4296

         type_set_base(sub, type);

10,773✔

4298

         type = sub;

10,773✔

4301

      p_constraint(type);

10,792✔

4304

   return type;

65,743✔

4307

static tree_t p_abstract_literal(void)

89,429✔

4311

   BEGIN("abstract literal");

89,429✔

4313

   tree_t t = tree_new(T_LITERAL);

89,429✔

4315

   switch (one_of(tINT, tREAL)) {

89,429✔

4316

   case tINT:

71,880✔

4317

      tree_set_subkind(t, L_INT);

71,880✔

4318

      tree_set_ival(t, last_lval.i64);

71,880✔

4319

      break;

71,880✔

4321

   case tREAL:

17,549✔

4322

      tree_set_subkind(t, L_REAL);

17,549✔

4323

      tree_set_dval(t, last_lval.real);

17,549✔

4324

      break;

17,549✔

4327

   tree_set_loc(t, CURRENT_LOC);

89,429✔

4328

   return t;

89,429✔

4331

static tree_t p_physical_literal(void)

7,813✔

4335

   BEGIN("physical literal");

7,813✔

4337

   tree_t mult;

7,813✔

4338

   if (scan(tINT, tREAL))

7,813✔

4339

      mult = p_abstract_literal();

7,812✔

4341

      mult = tree_new(T_LITERAL);

1✔

4342

      tree_set_ival(mult, 1);

1✔

4345

   ident_t ident = p_identifier();

7,813✔

4347

   tree_set_subkind(mult, L_PHYSICAL);

7,813✔

4348

   tree_set_loc(mult, CURRENT_LOC);

7,813✔

4349

   tree_set_ident(mult, ident);

7,813✔

4350

   tree_set_type(mult, NULL);

7,813✔

4352

   return mult;

7,813✔

4355

static tree_t p_numeric_literal(void)

89,317✔

4359

   BEGIN("numeric literal");

178,634✔

4361

   if (peek_nth(2) == tID)

89,317✔

4362

      return p_physical_literal();

7,700✔

4364

      return p_abstract_literal();

81,617✔

4367

static tree_t p_string_literal(void)

22,681✔

4371

   BEGIN("string literal");

22,681✔

4373

   consume(tSTRING);

22,681✔

4375

   tree_t t = tree_new(T_STRING);

22,681✔

4376

   tree_set_loc(t, CURRENT_LOC);

22,681✔

4378

   for (const char *p = last_lval.str + 1; *(p + 1) != '\0'; p++) {

342,192✔

4379

      const char ch[] = { '\'', *p, '\'', '\0' };

319,511✔

4380

      tree_t ref = tree_new(T_REF);

319,511✔

4381

      tree_set_loc(ref, CURRENT_LOC);

319,511✔

4382

      tree_set_ident(ref, ident_new(ch));

319,511✔

4383

      tree_add_char(t, ref);

319,511✔

4386

   free(last_lval.str);

22,681✔

4387

   return t;

22,681✔

4390

static tree_t p_literal(void)

114,758✔

4395

   BEGIN("literal");

229,516✔

4397

   switch (peek()) {

114,758✔

4398

   case tNULL:

181✔

4400

         consume(tNULL);

181✔

4402

         tree_t t = tree_new(T_LITERAL);

181✔

4403

         tree_set_loc(t, CURRENT_LOC);

181✔

4404

         tree_set_subkind(t, L_NULL);

181✔

4405

         return t;

181✔

4408

   case tINT:

89,317✔

4410

      return p_numeric_literal();

89,317✔

4412

   case tSTRING:

22,681✔

4413

      return p_string_literal();

22,681✔

4415

   case tBITSTRING:

2,579✔

4417

         consume(tBITSTRING);

2,579✔

4419

         tree_t t = bit_string_to_literal(last_lval.str, CURRENT_LOC);

2,579✔

4420

         free(last_lval.str);

2,579✔

4421

         return t;

2,579✔

4430

static void p_agg_choice(tree_t parent, tree_t head, type_t constraint)

5,698✔

4434

   BEGIN("choice");

11,396✔

4438

   tree_t t = tree_new(T_ASSOC);

5,698✔

4440

   if (head == NULL && optional(tOTHERS))

5,698✔

4441

      tree_set_subkind(t, A_OTHERS);

2,601✔

4443

      tree_t name = head ?: p_expression();

3,097✔

4444

      const tree_kind_t name_kind = tree_kind(name);

3,097✔

4446

      bool is_range = false;

3,097✔

4448

      if (scan(tDOWNTO, tTO, tRANGE, tREVRANGE))

3,097✔

4450

      else if (constraint != NULL && name_kind == T_REF && tree_has_ref(name))

2,548✔

4452

      else if (name_kind == T_ATTR_REF) {

2,548✔

4453

         const attr_kind_t attr = tree_subkind(name);

185✔

4454

         is_range = attr == ATTR_RANGE || attr == ATTR_REVERSE_RANGE;

185✔

4457

      tree_t choice = NULL;

3,282✔

4458

      if (is_range) {

185✔

4459

         tree_set_subkind(t, A_RANGE);

656✔

4460

         tree_add_range(t, (choice = p_discrete_range(name)));

656✔

4463

         tree_set_subkind(t, A_NAMED);

2,441✔

4464

         tree_set_name(t, (choice = name));

2,441✔

4467

      if (constraint != NULL)

3,097✔

4471

   tree_set_loc(t, CURRENT_LOC);

5,698✔

4472

   tree_add_assoc(parent, t);

5,698✔

4473

5,698✔

4475

static void p_agg_choices(tree_t parent, tree_t head, type_t constraint)

5,455✔

4479

   BEGIN("choices");

10,910✔

4483

   p_agg_choice(parent, head, constraint);

5,455✔

4485

   while (optional(tBAR))

5,698✔

4486

      p_agg_choice(parent, NULL, constraint);

243✔

4487

5,455✔

4489

static tree_t p_choice(tree_t head, type_t constraint)

3,499✔

4493

   BEGIN("choice");

6,998✔

4495

   tree_t t = tree_new(T_CHOICE);

3,499✔

4497

   if (head == NULL && optional(tOTHERS)) {

3,499✔

4498

      tree_set_loc(t, CURRENT_LOC);

455✔

4499

      return t;

455✔

4502

   tree_t name = head ?: p_expression();

3,044✔

4503

   const tree_kind_t name_kind = tree_kind(name);

3,044✔

4505

   bool is_range = false;

3,044✔

4507

   if (scan(tDOWNTO, tTO, tRANGE, tREVRANGE))

3,044✔

4509

   else if (constraint != NULL && name_kind == T_REF && tree_has_ref(name))

3,008✔

4510

      is_range = is_type_decl(tree_ref(name));

1,060✔

4511

   else if (name_kind == T_ATTR_REF) {

1,948✔

4512

      const attr_kind_t attr = tree_subkind(name);

13✔

4513

      is_range = attr == ATTR_RANGE || attr == ATTR_REVERSE_RANGE;

13✔

4516

   tree_t choice = NULL;

4,117✔

4517

   if (is_range)

1,073✔

4518

      tree_add_range(t, (choice = p_discrete_range(name)));

44✔

4520

      tree_set_name(t, (choice = name));

3,000✔

4522

   if (constraint != NULL)

3,044✔

4523

      solve_types(nametab, choice, constraint);

3,044✔

4525

   tree_set_loc(t, CURRENT_LOC);

3,044✔

4526

   return t;

3,044✔

4529

static void p_choices(tree_t parent, tree_t head, type_t constraint)

2,876✔

4533

   BEGIN("choices");

5,752✔

4535

   do {

3,499✔

4536

      tree_add_choice(parent, p_choice(head, constraint));

3,499✔

4537

      head = NULL;

3,499✔

4538

   } while (optional(tBAR));

3,499✔

4539

2,876✔

4541

static void p_element_association(tree_t agg, tree_t head)

37,738✔

4545

   BEGIN("element association");

75,476✔

4547

   if (head == NULL && peek() != tOTHERS)

37,738✔

4548

      head = p_expression();

28,535✔

4550

   const int nstart = tree_assocs(agg);

37,738✔

4552

   if (scan(tBAR, tASSOC, tTO, tDOWNTO, tOTHERS)) {

37,738✔

4553

      p_agg_choices(agg, head, NULL);

5,455✔

4555

      consume(tASSOC);

5,455✔

4557

      tree_t value = p_expression();

5,455✔

4558

      const int nassocs = tree_assocs(agg);

5,455✔

4559

      for (int i = nstart; i < nassocs; i++) {

11,153✔

4560

         tree_t a = tree_assoc(agg, i);

5,698✔

4561

         tree_set_value(a, value);

5,698✔

4562

         tree_set_loc(a, CURRENT_LOC);

5,698✔

4566

      tree_t t = tree_new(T_ASSOC);

32,283✔

4567

      tree_set_subkind(t, A_POS);

32,283✔

4568

      tree_set_value(t, head ?: p_expression());

32,283✔

4569

      tree_set_loc(t, CURRENT_LOC);

32,283✔

4570

      tree_set_pos(t, nstart);

32,283✔

4572

      tree_add_assoc(agg, t);

32,283✔

4574

37,738✔

4576

static tree_t p_aggregate(void)

2,512✔

4580

   BEGIN("aggregate");

2,512✔

4582

   tree_t t = tree_new(T_AGGREGATE);

2,512✔

4584

   consume(tLPAREN);

2,512✔

4586

   do {

2,699✔

4587

      p_element_association(t, NULL);

2,699✔

4588

   } while (optional(tCOMMA));

2,699✔

4590

   consume(tRPAREN);

2,512✔

4592

   tree_set_loc(t, CURRENT_LOC);

2,512✔

4593

   return t;

2,512✔

4596

static tree_t p_aggregate_or_expression(void)

26,182✔

4600

   BEGIN("aggregate or expression");

52,364✔

4602

   if (peek_nth(2) == tOTHERS)

26,182✔

4603

      return p_aggregate();

2,380✔

4605

   consume(tLPAREN);

23,802✔

4607

   tree_t head = p_expression();

23,802✔

4609

   switch (peek()) {

23,802✔

4610

   case tRPAREN:

17,200✔

4611

      consume(tRPAREN);

17,200✔

4612

      return head;

17,200✔

4614

   case tASSOC:

6,602✔

4620

         tree_t t = tree_new(T_AGGREGATE);

6,602✔

4622

         p_element_association(t, head);

6,602✔

4623

         while (optional(tCOMMA))

35,039✔

4624

            p_element_association(t, NULL);

28,437✔

4626

         consume(tRPAREN);

6,602✔

4628

         tree_set_loc(t, CURRENT_LOC);

6,602✔

4629

         return t;

6,602✔

4639

static tree_t p_qualified_expression(tree_t prefix)

3,642✔

4643

   EXTEND("qualified expression");

3,642✔

4645

   type_t type = NULL;

3,642✔

4646

   if (prefix == NULL)

3,642✔

4647

      type = p_type_mark();

256✔

4649

      switch (tree_kind(prefix)) {

3,386✔

4650

      case T_ATTR_REF:

1✔

4651

         if (is_type_attribute(tree_subkind(prefix)))

1✔

4652

            type = tree_type(prefix);

1✔

4654

      case T_REF:

3,385✔

4655

         if (tree_has_ref(prefix)) {

3,385✔

4656

            tree_t decl = aliased_type_decl(tree_ref(prefix));

3,385✔

4657

            if (decl != NULL)

3,385✔

4658

               type = tree_type(decl);

3,384✔

4666

   if (type == NULL) {

3,641✔

4667

      parse_error(tree_loc(prefix), "expecting type mark while parsing "

1✔

4669

      type = type_new(T_NONE);

1✔

4672

   tree_t qual = tree_new(T_QUALIFIED);

3,642✔

4673

   tree_set_type(qual, type);

3,642✔

4674

   tree_set_ident(qual, type_ident(type));

3,642✔

4676

   consume(tTICK);

3,642✔

4678

   tree_t value = p_aggregate_or_expression();

3,642✔

4680

   tree_set_value(qual, value);

3,642✔

4681

   solve_types(nametab, value, type);

3,642✔

4683

   tree_set_loc(qual, CURRENT_LOC);

3,642✔

4684

   return qual;

3,642✔

4687

static tree_t p_allocator(void)

545✔

4691

   BEGIN("allocator");

545✔

4693

   consume(tNEW);

545✔

4695

   tree_t new = tree_new(T_NEW);

545✔

4697

   tree_t value;

545✔

4698

   if (peek_nth(2) == tTICK && peek_nth(3) == tLPAREN)

545✔

4699

      value = p_qualified_expression(NULL);

256✔

4701

      type_t type = p_subtype_indication();

289✔

4703

      value = tree_new(T_QUALIFIED);

289✔

4704

      tree_set_type(value, type);

289✔

4705

      tree_set_loc(value, CURRENT_LOC);

289✔

4708

   tree_set_value(new, value);

545✔

4709

   tree_set_loc(new, CURRENT_LOC);

545✔

4711

   return new;

545✔

4714

static tree_t p_primary(tree_t head)

326,861✔

4720

   BEGIN("primary");

653,722✔

4722

   assert(head == NULL);

326,861✔

4724

   switch (peek()) {

326,861✔

4725

   case tLPAREN:

22,540✔

4726

      return p_aggregate_or_expression();

22,540✔

4728

   case tINT:

92,077✔

4732

      return p_literal();

92,077✔

4734

   case tSTRING:

22,758✔

4735

      if (peek_nth(2) != tLPAREN && peek_nth(2) != tDOT)

22,758✔

4736

         return p_literal();

22,681✔

4740

         tree_t expr = p_name(0);

188,844✔

4741

         if (peek() == tLSQUARE)

188,844✔

4742

            return p_attribute_name(expr);

14✔

4743

         else if (tree_kind(expr) == T_PROT_REF)

188,830✔

4744

            return p_function_call(tree_ident(expr), tree_value(expr));

535✔

4749

   case tLTLT:

117✔

4750

      return p_name(N_SUBPROGRAM);

117✔

4752

   case tNEW:

545✔

4753

      return p_allocator();

545✔

4755

   case tPREV:

49✔

4763

         psl_node_t p = p_psl_builtin_function_call();

49✔

4764

         psl_check(p, nametab);

49✔

4766

         tree_t t = tree_new(T_PSL_FCALL);

49✔

4767

         tree_set_psl(t, p);

49✔

4768

         tree_set_loc(t, CURRENT_LOC);

49✔

4769

         return t;

49✔

4772

   default:

8✔

4773

      expect(tLPAREN, tINT, tREAL, tNULL, tID, tSTRING, tBITSTRING, tNEW);

8✔

4774

      return error_expr();

8✔

4778

static ident_t p_logical_operator(void)

8,247✔

4780

   switch (one_of(tAND, tOR, tNAND, tNOR, tXOR, tXNOR)) {

8,247✔

4781

   case tAND:

5,727✔

4782

      return well_known(W_OP_AND);

5,727✔

4783

   case tOR:

1,749✔

4784

      return well_known(W_OP_OR);

1,749✔

4785

   case tNAND:

147✔

4786

      return well_known(W_OP_NAND);

147✔

4787

   case tNOR:

151✔

4788

      return well_known(W_OP_NOR);

151✔

4789

   case tXOR:

332✔

4790

      return well_known(W_OP_XOR);

332✔

4791

   case tXNOR:

141✔

4792

      return well_known(W_OP_XNOR);

141✔

4798

static tree_t p_unary_expression(tree_t head)

326,990✔

4802

   BEGIN("unary expression");

653,980✔

4804

   if (head != NULL)

326,990✔

4807

   ident_t op = NULL;

326,568✔

4808

   switch (peek()) {

326,568✔

4809

   case tNOT:

2,942✔

4810

      consume(tNOT);

2,942✔

4811

      op = well_known(W_OP_NOT);

2,942✔

4812

      break;

2,942✔

4814

   case tABS:

252✔

4815

      consume(tABS);

252✔

4816

      op = well_known(W_OP_ABS);

252✔

4817

      break;

252✔

4819

   case tAND:

276✔

4825

      require_std(STD_08, "unary logical operators");

276✔

4826

      op = p_logical_operator();

276✔

4827

      break;

276✔

4833

   if (op != NULL) {

3,470✔

4834

      tree_t t = tree_new(T_FCALL);

3,470✔

4835

      tree_set_ident(t, op);

3,470✔

4836

      unary_op(t, p_primary);

3,470✔

4837

      tree_set_loc(t, CURRENT_LOC);

3,470✔

4839

      return t;

3,470✔

4842

      return p_primary(NULL);

323,098✔

4845

static tree_t p_factor(tree_t head)

326,990✔

4849

   BEGIN("factor");

653,980✔

4851

   tree_t operand = p_unary_expression(head);

326,990✔

4853

   if (optional(tPOWER)) {

326,990✔

4854

      tree_t second = p_primary(NULL);

291✔

4856

      tree_t t = tree_new(T_FCALL);

291✔

4857

      tree_set_loc(t, CURRENT_LOC);

291✔

4858

      tree_set_ident(t, well_known(W_OP_EXPONENT));

291✔

4859

      add_param(t, operand, P_POS, NULL);

291✔

4860

      add_param(t, second, P_POS, NULL);

291✔

4862

      return t;

291✔

4868

static ident_t p_multiplying_operator(void)

3,162✔

4870

   switch (one_of(tTIMES, tOVER, tMOD, tREM)) {

3,162✔

4871

   case tTIMES:

1,828✔

4872

      return well_known(W_OP_TIMES);

1,828✔

4873

   case tOVER:

899✔

4874

      return well_known(W_OP_DIVIDE);

899✔

4875

   case tMOD:

288✔

4876

      return well_known(W_OP_MOD);

288✔

4877

   case tREM:

147✔

4878

      return well_known(W_OP_REM);

147✔

4884

static tree_t p_term(tree_t head)

323,828✔

4888

   BEGIN("term");

323,828✔

4890

   tree_t term = p_factor(head);

323,828✔

4892

   while (scan(tTIMES, tOVER, tMOD, tREM)) {

326,990✔

4893

      ident_t op  = p_multiplying_operator();

3,162✔

4894

      tree_t left = term;

3,162✔

4896

      term = tree_new(T_FCALL);

3,162✔

4897

      tree_set_ident(term, op);

3,162✔

4898

      binary_op(term, left, p_factor);

3,162✔

4901

   return term;

323,828✔

4904

static ident_t p_adding_operator(void)

12,247✔

4906

   switch (one_of(tPLUS, tMINUS, tAMP)) {

12,247✔

4907

   case tPLUS:

3,909✔

4908

      return well_known(W_OP_ADD);

3,909✔

4909

   case tMINUS:

5,741✔

4910

      return well_known(W_OP_MINUS);

5,741✔

4911

   case tAMP:

2,597✔

4912

      return well_known(W_OP_CONCAT);

2,597✔

4918

static ident_t p_sign(void)

8,448✔

4920

   switch (one_of(tPLUS, tMINUS)) {

8,448✔

4921

   case tPLUS:

36✔

4922

      return well_known(W_OP_ADD);

36✔

4923

   case tMINUS:

8,412✔

4924

      return well_known(W_OP_MINUS);

8,412✔

4930

static tree_t p_simple_expression(tree_t head)

311,581✔

4934

   BEGIN("simple expression");

311,581✔

4936

   tree_t expr = NULL;

311,581✔

4937

   if (head == NULL && scan(tPLUS, tMINUS)) {

320,029✔

4938

      ident_t sign = p_sign();

8,448✔

4939

      expr = tree_new(T_FCALL);

8,448✔

4940

      tree_set_ident(expr, sign);

8,448✔

4941

      unary_op(expr, p_term);

8,448✔

4942

      tree_set_loc(expr, CURRENT_LOC);

8,448✔

4945

      expr = p_term(head);

303,133✔

4947

   while (scan(tPLUS, tMINUS, tAMP)) {

323,828✔

4948

      tree_t left = expr;

12,247✔

4949

      expr = tree_new(T_FCALL);

12,247✔

4950

      tree_set_ident(expr, p_adding_operator());

12,247✔

4951

      binary_op(expr, left, p_term);

12,247✔

4954

   return expr;

311,581✔

4957

static ident_t p_shift_operator(void)

312✔

4959

   switch (one_of(tSLL, tSRL, tSLA, tSRA, tROL, tROR)) {

312✔

4960

   case tSLL:

36✔

4961

      return well_known(W_OP_SLL);

36✔

4962

   case tSRL:

32✔

4963

      return well_known(W_OP_SRL);

32✔

4964

   case tSLA:

26✔

4965

      return well_known(W_OP_SLA);

26✔

4966

   case tSRA:

32✔

4967

      return well_known(W_OP_SRA);

32✔

4968

   case tROL:

96✔

4969

      return well_known(W_OP_ROL);

96✔

4970

   case tROR:

90✔

4971

      return well_known(W_OP_ROR);

90✔

4977

static tree_t p_shift_expression(tree_t head)

311,269✔

4981

   BEGIN("shift expression");

311,269✔

4983

   tree_t shift = p_simple_expression(head);

311,269✔

4985

   while (scan(tSLL, tSRL, tSLA, tSRA, tROL, tROR)) {

311,581✔

4986

      ident_t op   = p_shift_operator();

312✔

4987

      tree_t left  = shift;

312✔

4988

      tree_t right = p_simple_expression(NULL);

312✔

4990

      shift = tree_new(T_FCALL);

312✔

4991

      tree_set_ident(shift, op);

312✔

4992

      tree_set_loc(shift, CURRENT_LOC);

312✔

4994

      add_param(shift, left, P_POS, NULL);

312✔

4995

      add_param(shift, right, P_POS, NULL);

312✔

4998

   return shift;

311,269✔

5001

static ident_t p_relational_operator(void)

30,646✔

5003

   switch (one_of(tEQ, tNEQ, tLT, tLE, tGT, tGE,

30,646✔

5005

   case tEQ:

23,813✔

5006

      return well_known(W_OP_EQUAL);

23,813✔

5007

   case tNEQ:

1,037✔

5008

      return well_known(W_OP_NOT_EQUAL);

1,037✔

5009

   case tLT:

2,440✔

5010

      return well_known(W_OP_LESS_THAN);

2,440✔

5011

   case tLE:

738✔

5012

      return well_known(W_OP_LESS_EQUAL);

738✔

5013

   case tGT:

1,490✔

5014

      return well_known(W_OP_GREATER_THAN);

1,490✔

5015

   case tGE:

739✔

5016

      return well_known(W_OP_GREATER_EQUAL);

739✔

5017

   case tMEQ:

97✔

5018

      return well_known(W_OP_MATCH_EQUAL);

97✔

5019

   case tMNEQ:

64✔

5020

      return well_known(W_OP_MATCH_NOT_EQUAL);

64✔

5021

   case tMLT:

58✔

5022

      return well_known(W_OP_MATCH_LESS_THAN);

58✔

5023

   case tMLE:

59✔

5024

      return well_known(W_OP_MATCH_LESS_EQUAL);

59✔

5025

   case tMGT:

56✔

5026

      return well_known(W_OP_MATCH_GREATER_THAN);

56✔

5027

   case tMGE:

55✔

5028

      return well_known(W_OP_MATCH_GREATER_EQUAL);

55✔

5034

static tree_t p_relation(tree_t head)

280,623✔

5038

   BEGIN("relation");

280,623✔

5040

   tree_t rel = p_shift_expression(head);

280,623✔

5042

   while (scan(tEQ, tNEQ, tLT, tLE, tGT, tGE,

492,442✔

5044

      ident_t op  = p_relational_operator();

30,646✔

5045

      tree_t left = rel;

30,646✔

5047

      rel = tree_new(T_FCALL);

30,646✔

5048

      tree_set_ident(rel, op);

30,646✔

5049

      binary_op(rel, left, p_shift_expression);

30,646✔

5052

   return rel;

280,623✔

5055

static tree_t p_expression_with_head(tree_t head)

271,462✔

5063

   BEGIN("expression");

271,462✔

5065

   tree_t expr = p_relation(head);

271,462✔

5067

   for (;;) {

279,187✔

5068

      const token_t tok = peek();

279,187✔

5069

      if (tok == tUNION) {

279,187✔

5070

         psl_node_t un = p_psl_union(expr);

12✔

5071

         tree_t new = tree_new(T_PSL_UNION);

12✔

5072

         tree_set_psl(new, un);

12✔

5073

         tree_set_loc(new, CURRENT_LOC);

12✔

5074

         expr = new;

12✔

5076

      else if (tok == tNOR || tok == tNAND) {

279,175✔

5077

         tree_t new = tree_new(T_FCALL);

256✔

5078

         tree_set_ident(new, p_logical_operator());

256✔

5079

         binary_op(new, expr, p_relation);

256✔

5080

         expr = new;

256✔

5081

         break;

256✔

5083

      else if (tok == tAND || tok == tOR || tok == tXOR || tok == tXNOR) {

278,919✔

5084

         tree_t new = tree_new(T_FCALL);

7,713✔

5085

         tree_set_ident(new, p_logical_operator());

7,713✔

5086

         binary_op(new, expr, p_relation);

7,713✔

5087

         expr = new;

7,713✔

5093

   return expr;

271,462✔

5096

static inline tree_t p_expression(void)

271,450✔

5100

   if (optional(tCCONV)) {

271,450✔

5101

      require_std(STD_08, "condition conversion");

2✔

5103

      tree_t expr = tree_new(T_FCALL);

2✔

5104

      tree_set_ident(expr, well_known(W_OP_CCONV));

2✔

5105

      unary_op(expr, p_primary);

2✔

5106

      return expr;

2✔

5109

      return p_expression_with_head(NULL);

271,448✔

5112

static type_t p_interface_type_indication(tree_t parent)

33,404✔

5116

   BEGIN("interface type indication");

66,808✔

5118

   if (peek() == tTYPE) {

33,404✔

5119

      require_std(STD_19, "anonymous type indication");

3✔

5121

      type_t type = p_anonymous_type_indication();

3✔

5123

      tree_t g = tree_new(T_GENERIC_DECL);

3✔

5124

      tree_set_loc(g, CURRENT_LOC);

3✔

5125

      tree_set_ident(g, ident_uniq("anonymous"));

3✔

5126

      tree_set_subkind(g, PORT_IN);

3✔

5127

      tree_set_class(g, C_TYPE);

3✔

5128

      tree_set_type(g, type);

3✔

5130

      tree_add_generic(parent, g);

3✔

5132

      return type;

3✔

5135

      return p_subtype_indication();

33,401✔

5138

static void p_interface_constant_declaration(tree_t parent, tree_kind_t kind,

27,802✔

5143

   BEGIN("interface constant declaration");

55,604✔

5145

   const bool explicit_constant = optional(tCONSTANT);

27,802✔

5146

   tree_flags_t flags = (explicit_constant) ? TREE_F_EXPLICIT_CLASS : 0;

27,802✔

5148

   LOCAL_IDENT_LIST ids = p_identifier_list();

55,604✔

5150

   consume(tCOLON);

27,802✔

5155

   port_mode_t mode = PORT_IN;

27,802✔

5156

   if (scan(tIN, tOUT, tINOUT, tBUFFER, tLINKAGE)) {

27,802✔

5157

      flags |= TREE_F_EXPLICIT_MODE;

8,428✔

5158

      mode = p_mode();

8,428✔

5161

   class_t class = C_CONSTANT;

27,802✔

5162

   if ((mode == PORT_OUT || mode == PORT_INOUT) && !explicit_constant)

27,802✔

5163

      class = C_VARIABLE;

1,787✔

5165

   if (kind == T_GENERIC_DECL) {

27,802✔

5168

      switch (tree_kind(parent)) {

1,792✔

5169

      case T_PACKAGE:

264✔

5172

         flags |= TREE_F_LOCALLY_STATIC;

264✔

5173

         break;

264✔

5179

   type_t type = p_interface_type_indication(parent);

27,802✔

5181

   tree_t init = NULL;

27,802✔

5182

   if (optional(tWALRUS)) {

27,802✔

5183

      init = p_expression();

5,082✔

5184

      solve_types(nametab, init, type);

5,082✔

5187

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

58,415✔

5188

      tree_t d = tree_new(kind);

30,613✔

5189

      tree_set_ident(d, it->ident);

30,613✔

5190

      tree_set_loc(d, &(it->loc));

30,613✔

5191

      tree_set_subkind(d, mode);

30,613✔

5192

      tree_set_type(d, type);

30,613✔

5193

      tree_set_class(d, class);

30,613✔

5194

      tree_set_flag(d, flags);

30,613✔

5196

      if (init != NULL)

30,613✔

5197

         tree_set_value(d, init);

5,198✔

5199

      add_interface(parent, d, kind);

30,613✔

5200

      sem_check(d, nametab);

30,613✔

5202

      if (ordered)

30,613✔

5203

         insert_name(nametab, d, NULL);

7,532✔

5205

      flags |= TREE_F_CONTINUATION;

30,613✔

5207

27,802✔

5209

static void p_array_mode_view_indication(type_t *type, tree_t *name)

17✔

5213

   BEGIN("array mode view indication");

17✔

5215

   consume(tVIEW);

17✔

5216

   consume(tLPAREN);

17✔

5218

   *name = p_name(0);

17✔

5219

   solve_types(nametab, *name, NULL);

17✔

5221

   consume(tRPAREN);

17✔

5222

   consume(tOF);

17✔

5224

   *type = p_subtype_indication();

17✔

5225

17✔

5227

static void p_record_mode_view_indication(type_t *type, tree_t *name)

85✔

5231

   BEGIN("record mode view indication");

170✔

5233

   consume(tVIEW);

85✔

5235

   *name = p_name(0);

85✔

5236

   type_t name_type = solve_types(nametab, *name, NULL);

85✔

5238

   if (optional(tOF))

85✔

5239

      *type = p_subtype_indication();

12✔

5240

   else if (type_kind(name_type) != T_VIEW) {

73✔

5241

      parse_error(tree_loc(*name), "name in mode view indication does not "

1✔

5243

      *type = type_new(T_NONE);

1✔

5246

      *type = type_designated(name_type);

72✔

5247

85✔

5249

static port_mode_t p_mode_view_indication(type_t *type, tree_t *name)

102✔

5253

   BEGIN("mode view indication");

204✔

5255

   if (peek_nth(2) == tLPAREN) {

102✔

5256

      p_array_mode_view_indication(type, name);

17✔

5257

      return PORT_ARRAY_VIEW;

17✔

5260

      p_record_mode_view_indication(type, name);

85✔

5261

      return PORT_RECORD_VIEW;

85✔

5265

static void p_interface_signal_declaration(tree_t parent, tree_kind_t kind,

4,885✔

5272

   BEGIN("interface signal declaration");

9,770✔

5274

   tree_flags_t flags = optional(tSIGNAL) ? TREE_F_EXPLICIT_CLASS : 0;

4,885✔

5276

   LOCAL_IDENT_LIST ids = p_identifier_list();

9,770✔

5277

   consume(tCOLON);

4,885✔

5279

   type_t type = NULL;

4,885✔

5280

   tree_t init = NULL;

4,885✔

5281

   port_mode_t mode = PORT_IN;

4,885✔

5283

   if (peek() == tVIEW) {

4,885✔

5284

      require_std(STD_19, "mode view indication");

102✔

5285

      mode = p_mode_view_indication(&type, &init);

102✔

5288

      if (scan(tIN, tOUT, tINOUT, tBUFFER, tLINKAGE)) {

4,783✔

5289

         mode = p_mode();

4,434✔

5290

         flags |= TREE_F_EXPLICIT_MODE;

4,434✔

5293

      type = p_interface_type_indication(parent);

4,783✔

5295

      if (optional(tBUS))

4,783✔

5296

         flags |= TREE_F_BUS;

5✔

5298

      if (optional(tWALRUS)) {

4,783✔

5299

         init = p_expression();

338✔

5300

         solve_types(nametab, init, type);

338✔

5304

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

10,049✔

5305

      tree_t d = tree_new(kind);

5,164✔

5306

      tree_set_ident(d, it->ident);

5,164✔

5307

      tree_set_loc(d, &(it->loc));

5,164✔

5308

      tree_set_subkind(d, mode);

5,164✔

5309

      tree_set_type(d, type);

5,164✔

5310

      tree_set_class(d, C_SIGNAL);

5,164✔

5311

      tree_set_flag(d, flags);

5,164✔

5313

      if (init != NULL)

5,164✔

5314

         tree_set_value(d, init);

442✔

5316

      add_interface(parent, d, kind);

5,164✔

5317

      sem_check(d, nametab);

5,164✔

5319

      if (ordered)

5,164✔

5320

         insert_name(nametab, d, NULL);

159✔

5322

      flags |= TREE_F_CONTINUATION;

5,164✔

5324

4,885✔

5326

static void p_interface_variable_declaration(tree_t parent, tree_kind_t kind)

819✔

5330

   BEGIN("interface variable declaration");

1,638✔

5332

   tree_flags_t flags = optional(tVARIABLE) ? TREE_F_EXPLICIT_CLASS : 0;

819✔

5334

   LOCAL_IDENT_LIST ids = p_identifier_list();

1,638✔

5335

   consume(tCOLON);

819✔

5337

   port_mode_t mode = PORT_IN;

819✔

5338

   if (scan(tIN, tOUT, tINOUT, tBUFFER, tLINKAGE)) {

819✔

5339

      mode = p_mode();

802✔

5340

      flags |= TREE_F_EXPLICIT_MODE;

802✔

5343

   type_t type = p_interface_type_indication(parent);

819✔

5345

   tree_t init = NULL;

819✔

5346

   if (optional(tWALRUS)) {

819✔

5347

      init = p_expression();

6✔

5348

      solve_types(nametab, init, type);

6✔

5351

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

1,644✔

5352

      tree_t d = tree_new(kind);

825✔

5353

      tree_set_ident(d, it->ident);

825✔

5354

      tree_set_loc(d, &(it->loc));

825✔

5355

      tree_set_type(d, type);

825✔

5356

      tree_set_class(d, C_VARIABLE);

825✔

5357

      tree_set_subkind(d, mode);

825✔

5358

      tree_set_flag(d, flags);

825✔

5360

      if (init != NULL)

825✔

5361

         tree_set_value(d, init);

6✔

5363

      add_interface(parent, d, kind);

825✔

5364

      sem_check(d, nametab);

825✔

5366

      if (standard() >= STD_19)

825✔

5367

         insert_name(nametab, d, NULL);

28✔

5369

      flags |= TREE_F_CONTINUATION;

825✔

5371

819✔

5373

static void p_interface_file_declaration(tree_t parent, tree_kind_t kind)

35✔

5377

   BEGIN("interface file declaration");

70✔

5379

   consume(tFILE);

35✔

5381

   LOCAL_IDENT_LIST ids = p_identifier_list();

70✔

5383

   consume(tCOLON);

35✔

5385

   type_t type = p_subtype_indication();

35✔

5387

   tree_flags_t flags = 0;

35✔

5388

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

74✔

5389

      tree_t d = tree_new(kind);

39✔

5390

      tree_set_ident(d, it->ident);

39✔

5391

      tree_set_loc(d, &(it->loc));

39✔

5392

      tree_set_subkind(d, PORT_IN);

39✔

5393

      tree_set_flag(d, flags);

39✔

5394

      tree_set_type(d, type);

39✔

5395

      tree_set_class(d, C_FILE);

39✔

5397

      add_interface(parent, d, kind);

39✔

5398

      sem_check(d, nametab);

39✔

5400

      if (standard() >= STD_19)

39✔

5401

         insert_name(nametab, d, NULL);

15✔

5403

      flags |= TREE_F_CONTINUATION;

39✔

5405

35✔

5407

static void p_private_incomplete_type_definition(type_t type)

24✔

5411

   BEGIN("private incomplete type definition");

48✔

5413

   consume(tPRIVATE);

24✔

5415

   type_set_subkind(type, GTYPE_PRIVATE);

24✔

5416

24✔

5418

static void p_scalar_incomplete_type_definition(type_t type)

5✔

5422

   BEGIN("scalar incomplete type definition");

10✔

5424

   consume(tBOX);

5✔

5426

   type_set_subkind(type, GTYPE_SCALAR);

5✔

5427

5✔

5429

static void p_discrete_incomplete_type_definition(type_t type)

19✔

5433

   BEGIN("discrete incomplete type definition");

38✔

5435

   consume(tLPAREN);

19✔

5436

   consume(tBOX);

19✔

5437

   consume(tRPAREN);

19✔

5439

   type_set_subkind(type, GTYPE_DISCRETE);

19✔

5440

19✔

5442

static void p_integer_incomplete_type_definition(type_t type)

11✔

5446

   BEGIN("integer incomplete type definition");

22✔

5448

   consume(tRANGE);

11✔

5449

   consume(tBOX);

11✔

5451

   type_set_subkind(type, GTYPE_INTEGER);

11✔

5452

11✔

5454

static void p_physical_incomplete_type_definition(type_t type)

4✔

5458

   BEGIN("physical incomplete type definition");

8✔

5460

   consume(tUNITS);

4✔

5461

   consume(tBOX);

4✔

5463

   type_set_subkind(type, GTYPE_PHYSICAL);

4✔

5464

4✔

5466

static void p_floating_incomplete_type_definition(type_t type)

4✔

5470

   BEGIN("floating incomplete type definition");

8✔

5472

   consume(tRANGE);

4✔

5473

   consume(tBOX);

4✔

5474

   consume(tDOT);

4✔

5475

   consume(tBOX);

4✔

5477

   type_set_subkind(type, GTYPE_FLOATING);

4✔

5478

4✔

5480

static type_t p_array_index_incomplete_type(void)

21✔

5484

   BEGIN("array index incomplete type");

42✔

5486

   if (peek() == tTYPE)

21✔

5487

      return p_anonymous_type_indication();

9✔

5489

      return p_index_subtype_definition(NULL);

12✔

5492

static void p_array_index_incomplete_type_list(type_t type)

21✔

5496

   BEGIN("array index incomplete type list");

42✔

5498

   do {

21✔

5499

      type_add_index(type, p_array_index_incomplete_type());

21✔

5500

   } while (optional(tCOMMA));

21✔

5501

21✔

5503

static type_t p_incomplete_subtype_indication(void)

32✔

5507

   BEGIN("incomplete subtype indication");

64✔

5509

   if (peek() == tTYPE)

32✔

5510

      return p_anonymous_type_indication();

18✔

5512

      return p_subtype_indication();

14✔

5515

static void p_array_incomplete_type_definition(type_t type)

21✔

5520

   BEGIN("array incomplete type definition");

42✔

5522

   consume(tARRAY);

21✔

5523

   consume(tLPAREN);

21✔

5525

   p_array_index_incomplete_type_list(type);

21✔

5527

   consume(tRPAREN);

21✔

5528

   consume(tOF);

21✔

5530

   type_set_elem(type, p_incomplete_subtype_indication());

21✔

5532

   type_set_subkind(type, GTYPE_ARRAY);

21✔

5533

21✔

5535

static void p_access_incomplete_type_definition(type_t type)

5✔

5539

   BEGIN("access incomplete type definition");

10✔

5541

   consume(tACCESS);

5✔

5543

   type_set_designated(type, p_incomplete_subtype_indication());

5✔

5545

   type_set_subkind(type, GTYPE_ACCESS);

5✔

5546

5✔

5548

static void p_file_incomplete_type_definition(type_t type)

6✔

5552

   BEGIN("file incomplete type definition");

12✔

5554

   consume(tFILE);

6✔

5555

   consume(tOF);

6✔

5557

   type_set_designated(type, p_incomplete_subtype_indication());

6✔

5559

   type_set_subkind(type, GTYPE_FILE);

6✔

5560

6✔

5562

static void p_incomplete_type_definition(type_t type)

99✔

5574

   BEGIN("incomplete type definition");

198✔

5576

   switch (peek()) {

99✔

5577

   case tPRIVATE:

24✔

5578

      p_private_incomplete_type_definition(type);

24✔

5579

      break;

24✔

5580

   case tBOX:

5✔

5581

      p_scalar_incomplete_type_definition(type);

5✔

5582

      break;

5✔

5583

   case tLPAREN:

19✔

5584

      p_discrete_incomplete_type_definition(type);

19✔

5585

      break;

19✔

5586

   case tRANGE:

15✔

5587

      if (peek_nth(3) == tDOT)

15✔

5588

         p_floating_incomplete_type_definition(type);

4✔

5590

         p_integer_incomplete_type_definition(type);

11✔

5592

   case tUNITS:

4✔

5593

      p_physical_incomplete_type_definition(type);

4✔

5594

      break;

4✔

5595

   case tARRAY:

21✔

5596

      p_array_incomplete_type_definition(type);

21✔

5597

      break;

21✔

5598

   case tACCESS:

5✔

5599

      p_access_incomplete_type_definition(type);

5✔

5600

      break;

5✔

5601

   case tFILE:

6✔

5602

      p_file_incomplete_type_definition(type);

6✔

5603

      break;

6✔

5608

   require_std(STD_19, "incomplete type definition");

99✔

5609

99✔

5611

static type_t p_anonymous_type_indication(void)

30✔

5615

   BEGIN("anonymous type indication");

30✔

5617

   consume(tTYPE);

30✔

5618

   consume(tIS);

30✔

5620

   type_t type = type_new(T_GENERIC);

30✔

5621

   p_incomplete_type_definition(type);

30✔

5623

   return type;

30✔

5626

static void p_interface_type_declaration(tree_t parent, tree_kind_t kind)

244✔

5631

   BEGIN("interface type declaration");

488✔

5633

   consume(tTYPE);

244✔

5635

   ident_t id = p_identifier();

244✔

5637

   require_std(STD_08, "interface type declarations");

244✔

5639

   type_t type = type_new(T_GENERIC);

244✔

5640

   type_set_ident(type, id);

244✔

5642

   if (optional(tIS))

244✔

5643

      p_incomplete_type_definition(type);

69✔

5645

      type_set_subkind(type, GTYPE_PRIVATE);

175✔

5647

   tree_t d = tree_new(kind);

244✔

5648

   tree_set_ident(d, id);

244✔

5649

   tree_set_loc(d, CURRENT_LOC);

244✔

5650

   tree_set_type(d, type);

244✔

5651

   tree_set_class(d, C_TYPE);

244✔

5652

   tree_set_subkind(d, PORT_IN);

244✔

5654

   add_interface(parent, d, kind);

244✔

5655

   sem_check(d, nametab);

244✔

5658

   insert_name(nametab, d, NULL);

244✔

5665

   if (kind == T_GENERIC_DECL)

244✔

5666

      declare_generic_ops(parent, type);

242✔

5667

244✔

5669

static void p_formal_parameter_list(tree_t decl, type_t type)

15,278✔

5673

   BEGIN("formal parameter list");

30,555✔

5675

   p_interface_list(decl, T_PARAM_DECL, standard() >= STD_19);

15,278✔

5677

   const int nports = tree_ports(decl);

15,278✔

5678

   if (nports == 0)

15,278✔

5679

      return;   // Was parse error

1✔

5681

   for (int i = 0; i < nports; i++) {

46,137✔

5682

      tree_t p = tree_port(decl, i);

30,860✔

5683

      if (i == 0 && tree_has_value(p))

30,860✔

5684

         tree_set_flag(decl, TREE_F_CALL_NO_ARGS);

281✔

5685

      if (tree_has_type(p))

30,860✔

5686

         type_add_param(type, tree_type(p));

30,859✔

5688

         type_add_param(type, type_new(T_NONE));   // Will raise error later

1✔

5692

static tree_t p_interface_function_specification(void)

181✔

5702

   BEGIN("interface function specification");

181✔

5704

   bool impure = false;

181✔

5705

   switch (peek()) {

181✔

5706

   case tPURE: consume(tPURE); break;

3✔

5707

   case tIMPURE: consume(tIMPURE); impure = true; break;

2✔

5711

   consume(tFUNCTION);

181✔

5713

   ident_t id = p_designator();

181✔

5715

   type_t type = type_new(T_SIGNATURE);

181✔

5716

   type_set_ident(type, id);

181✔

5718

   tree_t d = tree_new(T_GENERIC_DECL);

181✔

5719

   tree_set_class(d, C_FUNCTION);

181✔

5720

   tree_set_ident(d, id);

181✔

5721

   tree_set_type(d, type);

181✔

5722

   tree_set_subkind(d, PORT_IN);

181✔

5724

   if (impure)

181✔

5725

      tree_set_flag(d, TREE_F_IMPURE);

2✔

5727

   if (optional(tLPAREN)) {

181✔

5728

      push_scope(nametab);

176✔

5729

      p_formal_parameter_list(d, type);

176✔

5730

      consume(tRPAREN);

176✔

5731

      pop_scope(nametab);

176✔

5734

      tree_set_flag(d, TREE_F_CALL_NO_ARGS);

5✔

5736

   consume(tRETURN);

181✔

5738

   if (peek_nth(2) != tOF)

181✔

5739

      type_set_result(type, p_type_mark());

181✔

5753

   tree_set_loc(d, CURRENT_LOC);

181✔

5754

   return d;

181✔

5757

static tree_t p_interface_procedure_specification(void)

9✔

5761

   BEGIN("interface procedure specification");

9✔

5763

   consume(tPROCEDURE);

9✔

5765

   ident_t id = p_designator();

9✔

5767

   type_t type = type_new(T_SIGNATURE);

9✔

5768

   type_set_ident(type, id);

9✔

5770

   tree_t d = tree_new(T_GENERIC_DECL);

9✔

5771

   tree_set_class(d, C_PROCEDURE);

9✔

5772

   tree_set_ident(d, id);

9✔

5773

   tree_set_type(d, type);

9✔

5774

   tree_set_subkind(d, PORT_IN);

9✔

5776

   if (optional(tLPAREN)) {

9✔

5777

      push_scope(nametab);

9✔

5778

      p_formal_parameter_list(d, type);

9✔

5779

      consume(tRPAREN);

9✔

5780

      pop_scope(nametab);

9✔

5785

   tree_set_loc(d, CURRENT_LOC);

9✔

5786

   return d;

9✔

5789

static void p_interface_subprogram_declaration(tree_t parent, tree_kind_t kind)

190✔

5793

   BEGIN("interface subprogram declaration");

380✔

5795

   tree_t d = NULL;

190✔

5797

   require_std(STD_08, "interface subprogram declarations");

190✔

5799

   switch (peek()) {

190✔

5800

   case tFUNCTION:

181✔

5803

      d = p_interface_function_specification();

181✔

5804

      break;

181✔

5806

   case tPROCEDURE:

9✔

5807

      d = p_interface_procedure_specification();

9✔

5808

      break;

9✔

5815

   if (optional(tIS)) {

190✔

5816

      switch (peek()) {

142✔

5817

      case tID:

4✔

5819

            ident_t id = p_identifier();

4✔

5820

            type_t constraint = tree_type(d);

4✔

5822

            tree_t decl = resolve_subprogram_name(nametab, &last_loc,

4✔

5825

            tree_t box = tree_new(T_BOX);

4✔

5826

            tree_set_loc(box, &last_loc);

4✔

5827

            tree_set_type(box, constraint);

4✔

5828

            tree_set_ident(box, id);

4✔

5829

            tree_set_ref(box, decl);

4✔

5831

            tree_set_value(d, box);

4✔

5833

         break;

4✔

5834

      case tBOX:

138✔

5836

            consume(tBOX);

138✔

5838

            tree_t box = tree_new(T_BOX);

138✔

5839

            tree_set_loc(box, CURRENT_LOC);

138✔

5840

            tree_set_type(box, tree_type(d));

138✔

5842

            tree_set_value(d, box);

138✔

5844

         break;

138✔

5850

   add_interface(parent, d, kind);

190✔

5851

   sem_check(d, nametab);

190✔

5853

   insert_name(nametab, d, NULL);

190✔

5856

static void p_interface_package_generic_map_aspect(tree_t map, tree_t pack)

73✔

5860

   BEGIN("interface package generic map aspect");

146✔

5862

   consume(tGENERIC);

73✔

5863

   consume(tMAP);

73✔

5864

   consume(tLPAREN);

73✔

5866

   switch (peek()) {

73✔

5867

   case tBOX:

56✔

5868

      consume(tBOX);

56✔

5869

      tree_set_subkind(map, PACKAGE_MAP_BOX);

56✔

5870

      break;

56✔

5872

   case tDEFAULT:

6✔

5873

      consume(tDEFAULT);

6✔

5874

      tree_set_subkind(map, PACKAGE_MAP_DEFAULT);

6✔

5875

      break;

6✔

5877

   default:

11✔

5878

      tree_set_subkind(map, PACKAGE_MAP_MATCHING);

11✔

5879

      p_association_list(map, pack, F_GENERIC_MAP);

11✔

5880

      break;

11✔

5883

   consume(tRPAREN);

73✔

5885

   tree_set_loc(map, CURRENT_LOC);

73✔

5886

73✔

5888

static void p_interface_package_declaration(tree_t parent, tree_kind_t kind)

73✔

5893

   BEGIN("interface package declaration");

146✔

5895

   consume(tPACKAGE);

73✔

5897

   require_std(STD_08, "interface package declarations");

73✔

5899

   tree_t d = tree_new(T_GENERIC_DECL);

73✔

5900

   tree_set_class(d, C_PACKAGE);

73✔

5901

   tree_set_ident(d, p_identifier());

73✔

5902

   tree_set_subkind(d, PORT_IN);

73✔

5904

   consume(tIS);

73✔

5905

   consume(tNEW);

73✔

5907

   ident_t unit_name = p_selected_identifier();

73✔

5909

   tree_t pack = resolve_name(nametab, CURRENT_LOC, unit_name);

73✔

5910

   if (pack != NULL && !is_uninstantiated_package(pack)) {

73✔

5911

      parse_error(CURRENT_LOC, "unit %s is not an uninstantiated package",

1✔

5916

   tree_t map = tree_new(T_PACKAGE_MAP);

73✔

5917

   tree_set_ident(map, unit_name);

73✔

5918

   tree_set_loc(map, CURRENT_LOC);

73✔

5919

   tree_set_ref(map, pack);

73✔

5921

   tree_set_value(d, map);

73✔

5923

   p_interface_package_generic_map_aspect(map, pack);

73✔

5925

   tree_set_loc(d, CURRENT_LOC);

73✔

5927

   add_interface(parent, d, kind);

73✔

5928

   sem_check(d, nametab);

73✔

5930

   insert_name(nametab, d, NULL);

73✔

5931

73✔

5933

static void p_interface_declaration(tree_t parent, tree_kind_t kind,

34,049✔

5942

   BEGIN("interface declaration");

68,098✔

5944

   switch (peek()) {

34,049✔

5945

   case tCONSTANT:

5,212✔

5946

      p_interface_constant_declaration(parent, kind, ordered);

5,212✔

5947

      break;

5,212✔

5949

   case tSIGNAL:

1,140✔

5950

      p_interface_signal_declaration(parent, kind, ordered);

1,140✔

5951

      break;

1,140✔

5953

   case tVARIABLE:

819✔

5954

      p_interface_variable_declaration(parent, kind);

819✔

5955

      break;

819✔

5957

   case tFILE:

35✔

5958

      p_interface_file_declaration(parent, kind);

35✔

5959

      break;

35✔

5961

   case tTYPE:

244✔

5962

      p_interface_type_declaration(parent, kind);

244✔

5963

      break;

244✔

5965

   case tFUNCTION:

190✔

5969

      p_interface_subprogram_declaration(parent, kind);

190✔

5970

      break;

190✔

5972

   case tPACKAGE:

73✔

5973

      p_interface_package_declaration(parent, kind);

73✔

5974

      break;

73✔

5976

   case tID:

26,335✔

5977

      if (kind == T_PORT_DECL)

26,335✔

5978

         p_interface_signal_declaration(parent, kind, ordered);

3,745✔

5980

         p_interface_constant_declaration(parent, kind, ordered);

22,590✔

5983

   default:

1✔

5984

      expect(tCONSTANT, tSIGNAL, tVARIABLE, tFILE, tID, tTYPE,

1✔

5987

34,049✔

5989

static void p_interface_element(tree_t parent, tree_kind_t kind, bool ordered)

34,049✔

5993

   BEGIN("interface element");

68,098✔

5995

   p_interface_declaration(parent, kind, ordered);

34,049✔

5996

34,049✔

5998

static void p_interface_list(tree_t parent, tree_kind_t kind, bool ordered)

17,708✔

6002

   BEGIN("interface list");

35,415✔

6004

   if (peek() == tRPAREN) {

17,708✔

6005

      parse_error(&last_loc, "interface list cannot be empty");

1✔

6006

      return;

1✔

6009

   if (ordered)

17,707✔

6010

      push_scope(nametab);

4,107✔

6012

   p_interface_element(parent, kind, ordered);

17,707✔

6014

   while (optional(tSEMI)) {

34,049✔

6015

      if (peek() == tRPAREN) {

16,357✔

6016

         require_std(STD_19, "optional trailing semicolons on interface lists");

15✔

6017

         break;

15✔

6019

      p_interface_element(parent, kind, ordered);

16,342✔

6022

   if (ordered)

17,707✔

6023

      pop_scope(nametab);

4,107✔

6026

static void p_port_list(tree_t parent)

1,347✔

6030

   BEGIN("port list");

2,694✔

6032

   p_interface_list(parent, T_PORT_DECL, standard() >= STD_19);

1,347✔

6033

1,347✔

6035

static void p_port_clause(tree_t parent)

1,347✔

6039

   BEGIN("port clause");

2,694✔

6041

   consume(tPORT);

1,347✔

6042

   consume(tLPAREN);

1,347✔

6044

   p_port_list(parent);

1,347✔

6046

   consume(tRPAREN);

1,347✔

6047

   consume(tSEMI);

1,347✔

6048

1,347✔

6050

static void p_generic_list(tree_t parent)

1,083✔

6054

   BEGIN("generic list");

2,166✔

6056

   p_interface_list(parent, T_GENERIC_DECL, standard() >= STD_08);

1,083✔

6057

1,083✔

6059

static void p_generic_clause(tree_t parent)

992✔

6063

   BEGIN("generic clause");

1,984✔

6065

   consume(tGENERIC);

992✔

6066

   consume(tLPAREN);

992✔

6068

   p_generic_list(parent);

992✔

6070

   consume(tRPAREN);

992✔

6071

   consume(tSEMI);

992✔

6072

992✔

6074

static void p_entity_header(tree_t entity)

5,201✔

6078

   BEGIN("entity header");

10,402✔

6080

   if (scan(tGENERIC)) {

5,201✔

6081

      p_generic_clause(entity);

561✔

6082

      insert_generics(nametab, entity);

561✔

6085

   if (scan(tPORT)) {

5,201✔

6086

      p_port_clause(entity);

900✔

6087

      insert_ports(nametab, entity);

900✔

6089

5,201✔

6091

static tree_t p_attribute_declaration(void)

118✔

6095

   BEGIN("attribute declaration");

118✔

6097

   tree_t t = tree_new(T_ATTR_DECL);

118✔

6099

   consume(tATTRIBUTE);

118✔

6100

   tree_set_ident(t, p_identifier());

118✔

6101

   consume(tCOLON);

118✔

6102

   tree_set_type(t, p_type_mark());

118✔

6103

   consume(tSEMI);

118✔

6105

   tree_set_loc(t, CURRENT_LOC);

118✔

6106

   insert_name(nametab, t, NULL);

118✔

6107

   sem_check(t, nametab);

118✔

6108

   return t;

118✔

6111

static class_t p_entity_class(void)

353✔

6117

   BEGIN("entity class");

706✔

6119

   switch (one_of(tENTITY, tPROCEDURE, tTYPE, tSIGNAL, tLABEL, tGROUP,

353✔

6162

static tree_t p_entity_designator(void)

348✔

6166

   BEGIN("entity designator");

348✔

6168

   ident_t id = p_designator();

348✔

6170

   tree_t t = tree_new(T_ATTR_SPEC);

348✔

6171

   tree_set_loc(t, CURRENT_LOC);

348✔

6172

   tree_set_subkind(t, SPEC_EXACT);

348✔

6173

   tree_set_ident2(t, id);

348✔

6175

   if (peek() == tLSQUARE) {

348✔

6176

      type_t signature = p_signature();

151✔

6178

      tree_t d = resolve_subprogram_name(nametab, tree_loc(t), id, signature);

151✔

6179

      tree_set_ref(t, d);

151✔

6182

   return t;

348✔

6185

static void p_entity_name_list(tree_list_t *list)

351✔

6189

   BEGIN("entity name list");

702✔

6191

   switch (peek()) {

351✔

6192

   case tOTHERS:

1✔

6194

         consume(tOTHERS);

1✔

6196

         tree_t t = tree_new(T_ATTR_SPEC);

1✔

6197

         tree_set_loc(t, CURRENT_LOC);

1✔

6198

         tree_set_subkind(t, SPEC_OTHERS);

1✔

6200

         APUSH(*list, t);

1✔

6202

      break;

1✔

6203

   case tALL:

2✔

6205

         consume(tALL);

2✔

6207

         tree_t t = tree_new(T_ATTR_SPEC);

2✔

6208

         tree_set_loc(t, CURRENT_LOC);

2✔

6209

         tree_set_subkind(t, SPEC_ALL);

2✔

6211

         APUSH(*list, t);

2✔

6213

      break;

2✔

6215

      do {

348✔

6216

         APUSH(*list, p_entity_designator());

348✔

6217

      } while (optional(tCOMMA));

348✔

6219

351✔

6221

static class_t p_entity_specification(tree_list_t *list)

351✔

6225

   BEGIN("entity specification");

702✔

6227

   p_entity_name_list(list);

351✔

6229

   consume(tCOLON);

351✔

6231

   return p_entity_class();

351✔

6234

static void p_attribute_specification(tree_t parent)

351✔

6238

   BEGIN("attribute specification");

351✔

6240

   consume(tATTRIBUTE);

351✔

6241

   ident_t head = p_identifier();

351✔

6243

   type_t type;

351✔

6244

   tree_t attr_decl = resolve_name(nametab, CURRENT_LOC, head);

351✔

6245

   if (attr_decl == NULL)

351✔

6246

      type = type_new(T_NONE);

2✔

6247

   else if (tree_kind(attr_decl) != T_ATTR_DECL) {

349✔

6253

      type = tree_type(attr_decl);

349✔

6255

   consume(tOF);

351✔

6257

   tree_list_t specs = AINIT;

351✔

6258

   class_t class = p_entity_specification(&specs);

351✔

6260

   consume(tIS);

351✔

6262

   tree_t value = p_expression();

351✔

6263

   solve_types(nametab, value, type);

351✔

6265

   consume(tSEMI);

351✔

6267

   const loc_t *loc = CURRENT_LOC;

351✔

6269

   for (int i = 0; i < specs.count; i++) {

702✔

6270

      tree_t t = specs.items[i];

351✔

6271

      assert(tree_kind(t) == T_ATTR_SPEC);

351✔

6273

      if (class == C_LITERAL || class == C_LABEL)

351✔

6275

      else if (tree_subkind(t) == SPEC_EXACT && !tree_has_ref(t))

335✔

6276

         tree_set_ref(t, resolve_name(nametab, loc, tree_ident2(t)));

186✔

6278

      tree_set_class(t, class);

351✔

6279

      tree_set_ident(t, head);

351✔

6280

      tree_set_value(t, value);

351✔

6281

      tree_set_type(t, type);

351✔

6283

      insert_name(nametab, t, NULL);

351✔

6284

      tree_add_decl(parent, t);

351✔

6285

      sem_check(t, nametab);

351✔

6288

   ACLEAR(specs);

351✔

6289

351✔

6291

static type_t p_integer_type_definition(tree_t r, ident_t id)

146✔

6295

   EXTEND("integer type definition");

146✔

6297

   type_t t = type_new(T_INTEGER);

146✔

6298

   type_add_dim(t, r);

146✔

6299

   type_set_ident(t, id);

146✔

6300

   mangle_type(nametab, t);

146✔

6302

   return t;

146✔

6305

static type_t p_real_type_definition(tree_t r, ident_t id)

23✔

6309

   EXTEND("real type definition");

23✔

6311

   type_t t = type_new(T_REAL);

23✔

6312

   type_add_dim(t, r);

23✔

6313

   type_set_ident(t, id);

23✔

6314

   mangle_type(nametab, t);

23✔

6316

   return t;

23✔

6319

static tree_t p_base_unit_declaration(void)

45✔

6323

   BEGIN("base unit declaration");

45✔

6325

   ident_t id = p_identifier();

45✔

6326

   consume(tSEMI);

45✔

6328

   tree_t value = tree_new(T_LITERAL);

45✔

6329

   tree_set_loc(value, CURRENT_LOC);

45✔

6330

   tree_set_subkind(value, L_PHYSICAL);

45✔

6331

   tree_set_ident(value, id);

45✔

6332

   tree_set_ival(value, 1);

45✔

6334

   tree_t t = tree_new(T_UNIT_DECL);

45✔

6335

   tree_set_loc(t, CURRENT_LOC);

45✔

6336

   tree_set_value(t, value);

45✔

6337

   tree_set_ident(t, id);

45✔

6339

   return t;

45✔

6342

static tree_t p_secondary_unit_declaration(type_t type)

113✔

6346

   BEGIN("secondary unit declaration");

113✔

6348

   ident_t id = p_identifier();

113✔

6349

   consume(tEQ);

113✔

6351

   tree_t value = p_physical_literal();

113✔

6353

   consume(tSEMI);

113✔

6355

   tree_t u = tree_new(T_UNIT_DECL);

113✔

6356

   tree_set_ident(u, id);

113✔

6357

   tree_set_value(u, value);

113✔

6358

   tree_set_loc(u, CURRENT_LOC);

113✔

6359

   tree_set_type(u, type);

113✔

6361

   return u;

113✔

6364

static type_t p_physical_type_definition(tree_t range, ident_t id)

45✔

6369

   EXTEND("physical type definition");

45✔

6371

   type_t t = type_new(T_PHYSICAL);

45✔

6372

   type_set_ident(t, id);

45✔

6373

   mangle_type(nametab, t);

45✔

6375

   consume(tUNITS);

45✔

6377

   tree_t base = p_base_unit_declaration();

45✔

6378

   tree_set_type(base, t);

45✔

6379

   tree_set_type(tree_value(base), t);

45✔

6380

   type_add_unit(t, base);

45✔

6381

   type_add_dim(t, range);

45✔

6383

   push_scope(nametab);

45✔

6385

   insert_name(nametab, base, NULL);

45✔

6387

   while (scan(tINT, tREAL, tID)) {

158✔

6388

      tree_t unit = p_secondary_unit_declaration(t);

113✔

6389

      type_add_unit(t, unit);

113✔

6390

      insert_name(nametab, unit, NULL);

113✔

6393

   pop_scope(nametab);

45✔

6395

   consume(tEND);

45✔

6396

   consume(tUNITS);

45✔

6398

   if (peek() == tID) {

45✔

6399

      ident_t trailing = p_identifier();

1✔

6400

      if (trailing != id)

1✔

6401

         parse_error(&yylloc, "expected physical type definition trailing "

1✔

6405

   return t;

45✔

6408

static tree_t p_enumeration_literal(void)

4,626✔

6412

   BEGIN("enumeration literal");

4,626✔

6414

   tree_t t = tree_new(T_ENUM_LIT);

4,626✔

6415

   tree_set_ident(t, p_identifier());

4,626✔

6416

   tree_set_loc(t, CURRENT_LOC);

4,626✔

6418

   return t;

4,626✔

6421

static type_t p_enumeration_type_definition(ident_t id)

456✔

6425

   BEGIN("enumeration type definition");

456✔

6427

   type_t t = type_new(T_ENUM);

456✔

6428

   type_set_ident(t, id);

456✔

6429

   mangle_type(nametab, t);

456✔

6431

   consume(tLPAREN);

456✔

6433

   unsigned pos = 0;

456✔

6434

   do {

4,626✔

6435

      tree_t lit = p_enumeration_literal();

4,626✔

6436

      tree_set_pos(lit, pos++);

4,626✔

6437

      tree_set_type(lit, t);

4,626✔

6438

      type_enum_add_literal(t, lit);

4,626✔

6439

   } while (optional(tCOMMA));

4,626✔

6441

   tree_t r = tree_new(T_RANGE);

456✔

6442

   tree_set_subkind(r, RANGE_TO);

456✔

6443

   tree_set_left(r, make_ref(type_enum_literal(t, 0)));

456✔

6444

   tree_set_right(r, make_ref(type_enum_literal(t, pos - 1)));

456✔

6445

   tree_set_loc(r, CURRENT_LOC);

456✔

6446

   tree_set_type(r, t);

456✔

6448

   type_add_dim(t, r);

456✔

6450

   consume(tRPAREN);

456✔

6452

   return t;

456✔

6455

static type_t p_scalar_type_definition(ident_t id)

670✔

6460

   BEGIN("scalar type definition");

1,340✔

6462

   switch (peek()) {

670✔

6463

   case tRANGE:

214✔

6465

         tree_t r = tree_range(p_range_constraint(NULL), 0);

214✔

6467

         if (peek() == tUNITS)

214✔

6468

            return p_physical_type_definition(r, id);

45✔

6469

         else if (type_is_real(tree_type(r)))

169✔

6470

            return p_real_type_definition(r, id);

23✔

6472

            return p_integer_type_definition(r, id);

146✔

6475

   case tLPAREN:

456✔

6476

      return p_enumeration_type_definition(id);

456✔

6484

static type_t p_access_type_definition(ident_t id)

324✔

6488

   BEGIN("access type definition");

324✔

6490

   consume(tACCESS);

324✔

6492

   type_t t = type_new(T_ACCESS);

324✔

6493

   type_set_ident(t, id);

324✔

6494

   type_set_designated(t, p_subtype_indication());

324✔

6495

   mangle_type(nametab, t);

324✔

6497

   return t;

324✔

6500

static type_t p_file_type_definition(ident_t id)

101✔

6504

   BEGIN("file type definition");

101✔

6506

   consume(tFILE);

101✔

6507

   consume(tOF);

101✔

6509

   type_t t = type_new(T_FILE);

101✔

6510

   type_set_ident(t, id);

101✔

6511

   type_set_designated(t, p_type_mark());

101✔

6512

   mangle_type(nametab, t);

101✔

6514

   return t;

101✔

6517

static void p_element_declaration(type_t rec)

3,519✔

6521

   BEGIN("element declaration");

7,038✔

6523

   LOCAL_IDENT_LIST ids = p_identifier_list();

7,038✔

6525

   consume(tCOLON);

3,519✔

6527

   type_t type = p_subtype_indication();

3,519✔

6529

   consume(tSEMI);

3,519✔

6531

   int pos = type_fields(rec);

3,519✔

6532

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

7,336✔

6533

      tree_t f = tree_new(T_FIELD_DECL);

3,817✔

6534

      tree_set_ident(f, it->ident);

3,817✔

6535

      tree_set_type(f, type);

3,817✔

6536

      tree_set_pos(f, pos++);

3,817✔

6537

      tree_set_loc(f, &(it->loc));

3,817✔

6539

      type_add_field(rec, f);

3,817✔

6541

3,519✔

6543

static type_t p_record_type_definition(ident_t id)

1,291✔

6549

   BEGIN("record type definition");

1,291✔

6551

   consume(tRECORD);

1,291✔

6553

   type_t r = type_new(T_RECORD);

1,291✔

6554

   type_set_ident(r, id);

1,291✔

6555

   mangle_type(nametab, r);

1,291✔

6557

   if (peek() == tEND)

1,291✔

6558

      require_std(STD_19, "empty record");

3✔

6560

      do {

3,519✔

6561

         p_element_declaration(r);

3,519✔

6562

      } while (peek() == tID);

3,519✔

6565

   consume(tEND);

1,291✔

6566

   consume(tRECORD);

1,291✔

6568

   if (peek() == tID) {

1,291✔

6569

      ident_t trailing = p_identifier();

41✔

6570

      if (trailing != id)

41✔

6571

         parse_error(&yylloc, "expected record type definition trailing "

1✔

6575

   return r;

1,291✔

6578

static type_t p_index_subtype_definition(tree_t head)

1,978✔

6582

   BEGIN_WITH_HEAD("index subtype definition", head);

1,978✔

6584

   type_t type;

1,978✔

6585

   if (head != NULL)

1,978✔

6586

      type = name_to_type_mark(head);

1,806✔

6588

      type = p_type_mark();

172✔

6590

   consume(tRANGE);

1,978✔

6591

   consume(tBOX);

1,978✔

6593

   return type;

1,978✔

6596

static type_t p_unconstrained_array_definition(type_t base, tree_t head)

1,806✔

6601

   EXTEND("unconstrained array definition");

1,806✔

6603

   type_add_index(base, p_index_subtype_definition(head));

1,806✔

6605

   while (optional(tCOMMA))

1,966✔

6606

      type_add_index(base, p_index_subtype_definition(NULL));

160✔

6608

   mangle_type(nametab, base);

1,806✔

6610

   consume(tRPAREN);

1,806✔

6611

   consume(tOF);

1,806✔

6613

   type_set_elem(base, p_subtype_indication());

1,806✔

6614

   return base;

1,806✔

6617

static type_t p_constrained_array_definition(type_t base, tree_t head)

744✔

6621

   EXTEND("constrained array definition");

744✔

6623

   tree_t constraint = tree_new(T_CONSTRAINT);

744✔

6624

   tree_set_subkind(constraint, C_INDEX);

744✔

6626

   type_t sub = type_new(T_SUBTYPE);

744✔

6627

   type_set_base(sub, base);

744✔

6628

   type_set_constraint(sub, constraint);

744✔

6629

   type_set_ident(sub, type_ident(base));

744✔

6631

   mangle_type(nametab, sub);

744✔

6633

   do {

900✔

6634

      tree_t r = p_discrete_range(head);

900✔

6635

      solve_types(nametab, r, NULL);

900✔

6636

      convert_universal_bounds(r);

900✔

6638

      tree_add_range(constraint, r);

900✔

6639

      type_add_index(base, tree_type(r));

900✔

6641

      head = NULL;

900✔

6642

   } while (optional(tCOMMA));

900✔

6644

   consume(tRPAREN);

744✔

6646

   tree_set_loc(constraint, CURRENT_LOC);

744✔

6648

   consume(tOF);

744✔

6650

   type_set_elem(base, p_subtype_indication());

744✔

6651

   return sub;

744✔

6654

static type_t p_array_type_definition(ident_t id)

2,550✔

6658

   BEGIN("array type definition");

5,100✔

6660

   type_t base = type_new(T_ARRAY);

2,550✔

6661

   type_set_ident(base, id);

2,550✔

6663

   consume(tARRAY);

2,550✔

6664

   consume(tLPAREN);

2,550✔

6666

   tree_t head = p_expression();

2,550✔

6668

   if (peek_nth(2) == tBOX)

2,550✔

6669

      return p_unconstrained_array_definition(base, head);

1,806✔

6671

      return p_constrained_array_definition(base, head);

744✔

6674

static type_t p_composite_type_definition(ident_t id)

3,841✔

6678

   BEGIN("composite type definition");

7,682✔

6680

   switch (peek()) {

3,841✔

6681

   case tRECORD:

1,291✔

6682

      return p_record_type_definition(id);

1,291✔

6684

   case tARRAY:

2,550✔

6685

      return p_array_type_definition(id);

2,550✔

6693

static void p_private_variable_declaration(tree_t decl)

9✔

6697

   BEGIN("private variable declaration");

18✔

6699

   consume(tPRIVATE);

9✔

6701

   require_std(STD_19, "private variable declarations");

9✔

6703

   p_variable_declaration(decl);

9✔

6704

9✔

6706

static void p_protected_type_declarative_item(tree_t decl)

477✔

6712

   BEGIN("protected type declarative item");

954✔

6714

   switch (peek()) {

477✔

6723

   case tFUNCTION:

453✔

6727

      if (peek_nth(3) == tIS && peek_nth(4) == tNEW)

453✔

6730

         tree_t spec = p_subprogram_specification();

453✔

6731

         tree_set_flag(spec, TREE_F_PROTECTED);

453✔

6732

         tree_add_decl(decl, p_subprogram_declaration(spec));

453✔

6736

   case tPRIVATE:

9✔

6737

      p_private_variable_declaration(decl);

9✔

6738

      break;

9✔

6740

   case tALIAS:

15✔

6741

      p_alias_declaration(decl);

15✔

6742

      break;

15✔

6748

477✔

6750

static void p_protected_type_declarative_part(tree_t decl)

213✔

6754

   BEGIN("protected type declarative part");

426✔

6756

   while (not_at_token(tEND))

690✔

6757

      p_protected_type_declarative_item(decl);

477✔

6758

213✔

6760

static tree_t p_protected_type_declaration(ident_t id)

213✔

6764

   BEGIN("protected type declaration");

213✔

6766

   consume(tPROTECTED);

213✔

6768

   type_t type = type_new(T_PROTECTED);

213✔

6769

   type_set_ident(type, id);

213✔

6771

   mangle_type(nametab, type);

213✔

6773

   tree_t t = tree_new(T_PROT_DECL);

213✔

6774

   tree_set_ident(t, id);

213✔

6775

   tree_set_type(t, type);

213✔

6776

   tree_set_loc(t, CURRENT_LOC);

213✔

6778

   insert_name(nametab, t, NULL);

213✔

6780

   push_scope(nametab);

213✔

6781

   scope_set_prefix(nametab, id);

213✔

6783

   p_protected_type_declarative_part(t);

213✔

6785

   const int ndecls = tree_decls(t);

213✔

6786

   for (int i = 0; i < ndecls; i++) {

690✔

6787

      tree_t d = tree_decl(t, i);

477✔

6788

      if (is_subprogram(d) || tree_kind(d) == T_ALIAS)

477✔

6789

         type_add_field(type, d);

468✔

6792

   pop_scope(nametab);

213✔

6794

   consume(tEND);

213✔

6795

   consume(tPROTECTED);

213✔

6797

   p_trailing_label(id);

213✔

6799

   tree_set_loc(t, CURRENT_LOC);

213✔

6800

   sem_check(t, nametab);

213✔

6801

   return t;

213✔

6804

static tree_t p_protected_type_definition(ident_t id)

422✔

6808

   BEGIN("protected type definition");

844✔

6810

   if (peek_nth(2) == tBODY)

422✔

6811

      return p_protected_type_body(id);

209✔

6813

      return p_protected_type_declaration(id);

213✔

6816

static type_t p_type_definition(tree_t tdecl)

4,939✔

6822

   BEGIN("type definition");

9,878✔

6824

   ident_t id = tree_ident(tdecl);

4,939✔

6826

   switch (peek()) {

4,939✔

6827

   case tRANGE:

670✔

6829

      return p_scalar_type_definition(id);

670✔

6831

   case tACCESS:

324✔

6832

      return p_access_type_definition(id);

324✔

6834

   case tFILE:

101✔

6835

      return p_file_type_definition(id);

101✔

6837

   case tRECORD:

3,841✔

6839

      return p_composite_type_definition(id);

3,841✔

6841

   default:

3✔

6842

      expect(tRANGE, tACCESS, tFILE, tRECORD);

3✔

6843

      return type_new(T_NONE);

3✔

6847

static type_t p_full_type_declaration(tree_t tdecl)

4,939✔

6851

   EXTEND("full type declaration");

4,939✔

6853

   consume(tIS);

4,939✔

6855

   type_t t = p_type_definition(tdecl);

4,939✔

6857

   consume(tSEMI);

4,939✔

6859

   return t;

4,939✔

6862

static type_t p_incomplete_type_declaration(ident_t id)

48✔

6866

   EXTEND("incomplete type declaration");

48✔

6868

   consume(tSEMI);

48✔

6870

   type_t t = type_new(T_INCOMPLETE);

48✔

6871

   type_set_ident(t, id);

48✔

6872

   mangle_type(nametab, t);

48✔

6874

   return t;

48✔

6877

static void p_type_declaration(tree_t container)

5,409✔

6881

   BEGIN("type declaration");

10,818✔

6883

   consume(tTYPE);

5,409✔

6885

   ident_t id = p_identifier();

5,409✔

6886

   hide_name(nametab, id);

5,409✔

6889

   if (peek_nth(1) == tIS && peek_nth(2) == tPROTECTED) {

5,409✔

6890

      consume(tIS);

422✔

6891

      tree_add_decl(container, p_protected_type_definition(id));

422✔

6892

      consume(tSEMI);

422✔

6897

      if (bootstrapping) {

4,987✔

6898

         if (id == ident_new("INTEGER"))

43✔

6899

            make_universal_int(container);

3✔

6900

         else if (id == ident_new("REAL"))

40✔

6901

            make_universal_real(container);

3✔

6904

      tree_t t = tree_new(T_TYPE_DECL);

4,987✔

6905

      tree_set_ident(t, id);

4,987✔

6906

      tree_set_loc(t, CURRENT_LOC);

4,987✔

6908

      type_t type;

4,987✔

6909

      if (peek() == tSEMI)

4,987✔

6910

         type = p_incomplete_type_declaration(id);

48✔

6912

         type = p_full_type_declaration(t);

4,939✔

6914

      tree_set_type(t, type);

4,987✔

6915

      tree_set_loc(t, CURRENT_LOC);

4,987✔

6917

      insert_name(nametab, t, id);

4,987✔

6918

      tree_add_decl(container, t);

4,987✔

6920

      const type_kind_t kind = type_kind(type);

4,987✔

6922

      type_t base = type;

4,987✔

6923

      if (kind == T_SUBTYPE) {

4,987✔

6924

         base = type_base(type);

744✔

6925

         assert(type_kind(base) == T_ARRAY);

744✔

6926

         mangle_type(nametab, base);

744✔

6929

      if (kind != T_INCOMPLETE)

4,987✔

6930

         declare_predefined_ops(container, base);

4,939✔

6932

      if (kind == T_PHYSICAL) {

4,987✔

6933

         const int nunits = type_units(type);

45✔

6934

         for (int i = 0; i < nunits; i++)

203✔

6935

            solve_types(nametab, tree_value(type_unit(type, i)), type);

158✔

6938

      sem_check(t, nametab);

4,987✔

6940

5,409✔

6942

static tree_t p_subtype_declaration(void)

1,472✔

6946

   BEGIN("subtype declaration");

1,472✔

6948

   consume(tSUBTYPE);

1,472✔

6950

   ident_t id = p_identifier();

1,472✔

6951

   hide_name(nametab, id);

1,472✔

6953

   consume(tIS);

1,472✔

6955

   type_t sub = p_subtype_indication();

1,472✔

6957

   consume(tSEMI);

1,472✔

6959

   if (type_kind(sub) != T_SUBTYPE || type_has_ident(sub)) {

1,472✔

6962

      type_t new = type_new(T_SUBTYPE);

139✔

6963

      type_set_base(new, sub);

139✔

6965

      sub = new;

139✔

6967

   type_set_ident(sub, id);

1,472✔

6969

   mangle_type(nametab, sub);

1,472✔

6971

   tree_t t = tree_new(T_SUBTYPE_DECL);

1,472✔

6972

   tree_set_ident(t, id);

1,472✔

6973

   tree_set_type(t, sub);

1,472✔

6974

   tree_set_loc(t, CURRENT_LOC);

1,472✔

6976

   insert_name(nametab, t, id);

1,472✔

6977

   sem_check(t, nametab);

1,472✔

6978

   return t;

1,472✔

6981

static tree_t p_conditional_expression(void)

10,095✔

6985

   BEGIN("conditional expression");

20,190✔

6987

   tree_t expr0 = p_expression();

10,095✔

6989

   if (optional(tWHEN)) {

10,095✔

6990

      require_std(STD_19, "conditional expressions");

15✔

6992

      tree_t value = tree_new(T_COND_VALUE);

15✔

6994

      do {

18✔

6995

         tree_t cond = tree_new(T_COND_EXPR);

18✔

6996

         tree_set_result(cond, expr0);

18✔

6997

         tree_set_value(cond, p_condition());

18✔

6999

         tree_set_loc(cond, CURRENT_LOC);

18✔

7001

         tree_add_cond(value, cond);

18✔

7003

         consume(tELSE);

18✔

7005

         expr0 = p_expression();

18✔

7006

      } while (optional(tWHEN));

18✔

7008

      tree_t last = tree_new(T_COND_EXPR);

15✔

7009

      tree_set_result(last, expr0);

15✔

7010

      tree_set_loc(last, CURRENT_LOC);

15✔

7012

      tree_add_cond(value, last);

15✔

7014

      tree_set_loc(value, CURRENT_LOC);

15✔

7015

      return value;

15✔

7021

static tree_t p_expression_or_unaffected(void)

29,370✔

7025

   BEGIN("expression or unaffected");

58,740✔

7027

   if (optional(tUNAFFECTED)) {

29,370✔

7028

      require_std(STD_19, "unaffected in conditional expression");

10✔

7029

      return NULL;

10✔

7032

      return p_expression();

29,360✔

7035

static tree_t p_conditional_or_unaffected_expression(vhdl_standard_t minstd)

29,321✔

7040

   BEGIN("conditional expression");

58,642✔

7042

   tree_t expr0 = p_expression_or_unaffected();

29,321✔

7044

   if (optional(tWHEN)) {

29,321✔

7045

      require_std(minstd, "conditional expressions");

35✔

7047

      tree_t value = tree_new(T_COND_VALUE);

35✔

7049

      tree_t c0 = tree_new(T_COND_EXPR);

35✔

7050

      tree_set_result(c0, expr0);

35✔

7051

      tree_set_value(c0, p_condition());

35✔

7052

      tree_set_loc(c0, CURRENT_LOC);

35✔

7054

      tree_add_cond(value, c0);

35✔

7056

      while (optional(tELSE)) {

54✔

7057

         tree_t cond = tree_new(T_COND_EXPR);

49✔

7058

         tree_set_result(cond, p_expression_or_unaffected());

49✔

7059

         tree_set_loc(cond, CURRENT_LOC);

49✔

7061

         tree_add_cond(value, cond);

49✔

7063

         if (!optional(tWHEN))

49✔

7066

         tree_set_value(cond, p_condition());

19✔

7067

         tree_set_loc(cond, CURRENT_LOC);

19✔

7070

      tree_set_loc(value, CURRENT_LOC);

35✔

7071

      return value;

35✔

7077

static void p_constant_declaration(tree_t parent)

6,715✔

7081

   BEGIN("constant declaration");

13,430✔

7083

   consume(tCONSTANT);

6,715✔

7085

   LOCAL_IDENT_LIST ids = p_identifier_list();

13,430✔

7087

   for (ident_list_t *it = ids; it != NULL; it = it->next)

13,434✔

7088

      hide_name(nametab, it->ident);

6,719✔

7090

   consume(tCOLON);

6,715✔

7092

   type_t type = p_subtype_indication();

6,715✔

7094

   tree_t init = NULL;

6,715✔

7095

   if (optional(tWALRUS))

6,715✔

7096

      init = p_conditional_expression();

6,290✔

7102

   tree_flags_t flags = 0;

6,715✔

7103

   switch (tree_kind(parent)) {

6,715✔

7104

   case T_ENTITY:

4,232✔

7112

      flags |= TREE_F_GLOBALLY_STATIC;

4,232✔

7113

      break;

4,232✔

7118

   consume(tSEMI);

6,715✔

7120

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

13,434✔

7121

      tree_t t = tree_new(T_CONST_DECL);

6,719✔

7122

      tree_set_ident(t, it->ident);

6,719✔

7123

      tree_set_type(t, type);

6,719✔

7124

      tree_set_flag(t, flags);

6,719✔

7125

      tree_set_loc(t, &(it->loc));

6,719✔

7127

      if (init != NULL) {

6,719✔

7128

         tree_set_value(t, init);

6,294✔

7130

         if (standard() < STD_19 || type_is_unconstrained(type))

6,294✔

7131

            solve_types(nametab, init, type);

5,673✔

7133

            solve_known_subtype(nametab, init, t);

621✔

7136

      tree_add_decl(parent, t);

6,719✔

7138

      insert_name(nametab, t, it->ident);

6,719✔

7139

      sem_check(t, nametab);

6,719✔

7141

6,715✔

7143

static tree_t p_condition(void)

28,325✔

7145

   BEGIN("condition");

28,325✔

7147

   tree_t value = p_expression();

28,325✔

7148

   solve_condition(nametab, &value);

28,325✔

7150

   return value;

28,325✔

7153

static tree_t p_assertion(void)

17,586✔

7157

   BEGIN("assertion");

17,586✔

7159

   tree_t s = tree_new(T_ASSERT);

17,586✔

7161

   consume(tASSERT);

17,586✔

7163

   tree_set_value(s, p_condition());

17,586✔

7165

   if (optional(tREPORT)) {

17,586✔

7166

      tree_t message = p_expression();

6,092✔

7167

      solve_types(nametab, message, std_type(NULL, STD_STRING));

6,092✔

7168

      tree_set_message(s, message);

6,092✔

7171

   if (optional(tSEVERITY)) {

17,586✔

7172

      tree_t severity = p_expression();

5,646✔

7173

      solve_types(nametab, severity, std_type(NULL, STD_SEVERITY_LEVEL));

5,646✔

7174

      tree_set_severity(s, severity);

5,646✔

7177

   tree_set_loc(s, CURRENT_LOC);

17,586✔

7178

   return s;

17,586✔

7181

static tree_t p_concurrent_assertion_statement(ident_t label)

963✔

7185

   BEGIN("concurrent assertion statement");

963✔

7187

   tree_t conc = tree_new(T_CONCURRENT);

963✔

7189

   if (optional(tPOSTPONED))

963✔

7190

      tree_set_flag(conc, TREE_F_POSTPONED);

22✔

7192

   tree_t s = p_assertion();

963✔

7193

   tree_add_stmt(conc, s);

963✔

7195

   consume(tSEMI);

963✔

7197

   tree_set_loc(s, CURRENT_LOC);

963✔

7198

   tree_set_loc(conc, CURRENT_LOC);

963✔

7200

   ensure_labelled(conc, label);

963✔

7202

   if (label) insert_name(nametab, conc, NULL);

963✔

7203

   sem_check(conc, nametab);

963✔

7204

   return conc;

963✔

7207

static ident_t p_designator(void)

25,728✔

7211

   BEGIN("designator");

51,456✔

7213

   switch (peek()) {

25,728✔

7214

   case tID:

18,415✔

7215

      return p_identifier();

18,415✔

7216

   case tSTRING:

7,312✔

7217

      return p_operator_symbol();

7,312✔

7218

   default:

1✔

7219

      expect(tID, tSTRING);

1✔

7220

      return error_marker();

1✔

7224

static void p_subprogram_header(tree_t spec)

16,587✔

7228

   if (optional(tGENERIC)) {

16,587✔

7229

      require_std(STD_08, "generic subprograms");

91✔

7231

      consume(tLPAREN);

91✔

7232

      p_generic_list(spec);

91✔

7233

      consume(tRPAREN);

91✔

7235

      insert_generics(nametab, spec);

91✔

7237

16,587✔

7239

static tree_t p_subprogram_specification(void)

16,587✔

7251

   BEGIN("subprogram specification");

33,174✔

7253

   tree_t t = NULL;

16,587✔

7254

   type_t type = NULL;

16,587✔

7256

   bool impure = false;

16,587✔

7257

   switch (one_of(tFUNCTION, tPROCEDURE, tPURE, tIMPURE)) {

16,587✔

7258

   case tIMPURE:

888✔

7259

      impure = true;

888✔

7261

   case tPURE:

921✔

7262

      consume(tFUNCTION);

921✔

7264

   case tFUNCTION:

13,311✔

7265

      t = tree_new(T_FUNC_DECL);

13,311✔

7266

      break;

13,311✔

7268

   case tPROCEDURE:

3,276✔

7269

      t = tree_new(T_PROC_DECL);

3,276✔

7270

      break;

3,276✔

7276

   type = type_new(T_SIGNATURE);

16,587✔

7277

   tree_set_type(t, type);

16,587✔

7278

   tree_set_ident(t, p_designator());

16,587✔

7279

   tree_set_subkind(t, S_USER);

16,587✔

7281

   type_set_ident(type, tree_ident(t));

16,587✔

7283

   if (impure)

16,587✔

7284

      tree_set_flag(t, TREE_F_IMPURE);

888✔

7286

   push_scope(nametab);

16,587✔

7288

   p_subprogram_header(t);

16,587✔

7290

   bool has_param_list = false;

16,587✔

7291

   if (optional(tLPAREN))

16,587✔

7293

   else if (standard() >= STD_08 && optional(tPARAMETER)) {

1,541✔

7294

      consume(tLPAREN);

47✔

7295

      has_param_list = true;

47✔

7298

   if (has_param_list) {

47✔

7299

      p_formal_parameter_list(t, type);

15,093✔

7300

      consume(tRPAREN);

15,093✔

7303

      tree_set_flag(t, TREE_F_CALL_NO_ARGS);

1,494✔

7305

   if (tree_kind(t) == T_FUNC_DECL) {

16,587✔

7306

      consume(tRETURN);

13,311✔

7308

      if (peek_nth(2) != tOF)

13,311✔

7309

         type_set_result(type, p_type_mark());

13,294✔

7311

         require_std(STD_19, "function knows return type");

17✔

7313

         ident_t id = p_identifier();

17✔

7315

         consume(tOF);

17✔

7317

         type_t of = p_type_mark(), sub;

17✔

7319

         if (type_is_unconstrained(of)) {

17✔

7320

            tree_t rref = tree_new(T_REF);

15✔

7321

            tree_set_loc(rref, CURRENT_LOC);

15✔

7322

            tree_set_ident(rref, ident_new("result"));

15✔

7323

            tree_set_ref(rref, t);

15✔

7324

            tree_set_type(rref, of);

15✔

7326

            sub = get_subtype_for(rref);

15✔

7329

            parse_error(CURRENT_LOC, "type mark of return identifier must "

2✔

7332

            sub = type_new(T_SUBTYPE);

2✔

7333

            type_set_base(sub, of);

2✔

7336

         type_set_ident(sub, id);

17✔

7337

         type_set_result(type, sub);

17✔

7339

         tree_set_flag(t, TREE_F_KNOWS_SUBTYPE);

17✔

7343

   pop_scope(nametab);

16,587✔

7345

   mangle_func(nametab, t);

16,587✔

7347

   tree_set_loc(t, CURRENT_LOC);

16,587✔

7348

   return t;

16,587✔

7351

static tree_t p_subprogram_instantiation_declaration(void)

93✔

7356

   tree_kind_t kind;

93✔

7357

   switch (one_of(tFUNCTION, tPROCEDURE)) {

93✔

7359

   case tPROCEDURE: kind = T_PROC_INST; break;

35✔

7363

   tree_t inst = tree_new(kind);

93✔

7364

   tree_set_ident(inst, p_designator());

93✔

7366

   consume(tIS);

93✔

7367

   consume(tNEW);

93✔

7369

   require_std(STD_08, "subprogram instantiation declarations");

93✔

7371

   tree_t name = p_name(N_SUBPROGRAM | N_TYPE);

93✔

7373

   type_t constraint = NULL;

93✔

7374

   if (peek() == tLSQUARE)

93✔

7375

      constraint = p_signature();

25✔

7377

   tree_t decl = NULL;

93✔

7378

   if (tree_kind(name) != T_REF)

93✔

7379

      parse_error(CURRENT_LOC, "expecting uninstantiated subprogram name");

1✔

7381

      decl = resolve_uninstantiated_subprogram(nametab, tree_loc(name),

92✔

7385

   if (decl != NULL) {

93✔

7386

      tree_t body = find_generic_subprogram_body(inst, decl);

86✔

7387

      instantiate_subprogram(inst, decl, body);

86✔

7391

      type_t type = type_new(T_SIGNATURE);

7✔

7392

      type_set_ident(type, error_marker());

7✔

7393

      if (kind == T_FUNC_INST)

7✔

7394

         type_set_result(type, type_new(T_NONE));

3✔

7396

      tree_set_type(inst, type);

7✔

7399

   if (peek() == tGENERIC)

93✔

7400

      p_generic_map_aspect(inst, inst);

89✔

7402

   consume(tSEMI);

93✔

7404

   tree_set_loc(inst, CURRENT_LOC);

93✔

7405

   sem_check(inst, nametab);

93✔

7407

   hash_t *map = get_generic_map(nametab);

93✔

7408

   if (map != NULL)

93✔

7409

      instance_fixup(inst, map);

89✔

7411

   mangle_func(nametab, inst);

93✔

7412

   insert_name(nametab, inst, NULL);

93✔

7413

   return inst;

93✔

7416

static void p_variable_declaration(tree_t parent)

10,240✔

7421

   BEGIN("variable declaration");

20,480✔

7423

   const bool shared = optional(tSHARED);

10,240✔

7425

   consume(tVARIABLE);

10,240✔

7427

   LOCAL_IDENT_LIST ids = p_identifier_list();

20,480✔

7429

   for (ident_list_t *it = ids; it != NULL; it = it->next)

21,669✔

7430

      hide_name(nametab, it->ident);

11,429✔

7432

   consume(tCOLON);

10,240✔

7434

   type_t type = p_subtype_indication();

10,240✔

7436

   tree_t init = NULL;

10,240✔

7437

   if (optional(tWALRUS)) {

10,240✔

7438

      init = p_conditional_expression();

2,028✔

7439

      solve_types(nametab, init, type);

2,028✔

7442

   consume(tSEMI);

10,240✔

7444

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

21,669✔

7445

      tree_t t = tree_new(T_VAR_DECL);

11,429✔

7446

      tree_set_loc(t, &(it->loc));

11,429✔

7447

      tree_set_ident(t, it->ident);

11,429✔

7448

      tree_set_type(t, type);

11,429✔

7450

      if (init != NULL)

11,429✔

7451

         tree_set_value(t, init);

2,055✔

7453

      if (shared)

11,429✔

7454

         tree_set_flag(t, TREE_F_SHARED);

183✔

7456

      tree_add_decl(parent, t);

11,429✔

7457

      insert_name(nametab, t, it->ident);

11,429✔

7458

      sem_check(t, nametab);

11,429✔

7460

10,240✔

7462

static tree_flags_t p_signal_kind(void)

5,633✔

7466

   switch (peek()) {

5,633✔

7467

   case tBUS:

24✔

7468

      consume(tBUS);

24✔

7469

      return TREE_F_BUS;

24✔

7470

   case tREGISTER:

3✔

7471

      consume(tREGISTER);

3✔

7472

      return TREE_F_REGISTER;

3✔

7478

static void p_signal_declaration(tree_t parent)

5,633✔

7483

   BEGIN("signal declaration");

11,266✔

7485

   consume(tSIGNAL);

5,633✔

7487

   LOCAL_IDENT_LIST ids = p_identifier_list();

11,266✔

7489

   for (ident_list_t *it = ids; it != NULL; it = it->next)

12,203✔

7490

      hide_name(nametab, it->ident);

6,570✔

7492

   consume(tCOLON);

5,633✔

7494

   type_t type = p_subtype_indication();

5,633✔

7495

   tree_flags_t flags = p_signal_kind();

5,633✔

7497

   tree_t init = NULL;

5,633✔

7498

   if (optional(tWALRUS))

5,633✔

7499

      init = p_conditional_expression();

1,777✔

7501

   consume(tSEMI);

5,633✔

7503

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

12,203✔

7504

      tree_t t = tree_new(T_SIGNAL_DECL);

6,570✔

7505

      tree_set_loc(t, &(it->loc));

6,570✔

7506

      tree_set_ident(t, it->ident);

6,570✔

7507

      tree_set_type(t, type);

6,570✔

7508

      tree_set_flag(t, flags);

6,570✔

7510

      if (init != NULL) {

6,570✔

7511

         solve_known_subtype(nametab, init, t);

1,966✔

7512

         tree_set_value(t, init);

1,966✔

7515

      tree_add_decl(parent, t);

6,570✔

7517

      insert_name(nametab, t, it->ident);

6,570✔

7518

      sem_check(t, nametab);

6,570✔

7520

5,633✔

7522

static type_t p_signature(void)

726✔

7526

   BEGIN("signature");

1,452✔

7528

   type_t type = type_new(T_SIGNATURE);

726✔

7530

   consume(tLSQUARE);

726✔

7532

   bool error = false;

726✔

7533

   if (not_at_token(tRETURN, tRSQUARE)) {

726✔

7534

      do {

1,636✔

7535

         type_t param = p_type_mark();

1,636✔

7536

         type_add_param(type, param);

1,636✔

7537

         error = error || type_is_none(param);

1,636✔

7538

      } while (optional(tCOMMA));

1,636✔

7541

   if (optional(tRETURN)) {

726✔

7542

      type_t ret = p_type_mark();

328✔

7543

      type_set_result(type, ret);

328✔

7544

      error = error || type_is_none(ret);

330✔

7547

   consume(tRSQUARE);

726✔

7549

   return error ? type_new(T_NONE) : type;

726✔

7552

static void p_alias_declaration(tree_t parent)

1,552✔

7556

   BEGIN("alias declaration");

3,104✔

7558

   tree_t t = tree_new(T_ALIAS);

1,552✔

7560

   consume(tALIAS);

1,552✔

7562

   ident_t id = p_designator();

1,552✔

7563

   tree_set_ident(t, id);

1,552✔

7565

   hide_name(nametab, id);

1,552✔

7567

   bool has_subtype_indication = false;

1,552✔

7568

   if (optional(tCOLON)) {

1,552✔

7569

      tree_set_type(t, p_subtype_indication());

808✔

7570

      has_subtype_indication = true;

808✔

7572

   consume(tIS);

1,552✔

7574

   tree_t value = p_name(N_SUBPROGRAM | N_TYPE);

1,552✔

7575

   tree_set_value(t, value);

1,552✔

7577

   if (peek() == tLPAREN) {

1,552✔

7578

      parse_error(tree_loc(value), "name cannot be indexed or sliced");

1✔

7579

      tree_set_type(t, type_new(T_NONE));

1✔

7580

      drop_tokens_until(tRPAREN);

1✔

7583

   const tree_kind_t value_kind = tree_kind(value);

1,552✔

7584

   bool nonobject_alias = false, type_alias = false;

1,552✔

7586

   if (peek() == tLSQUARE) {

1,552✔

7587

      type_t type = p_signature();

531✔

7588

      if (has_subtype_indication) {

531✔

7593

      else if (value_kind != T_REF && value_kind != T_PROT_REF) {

531✔

7594

         if (!type_is_none((type = solve_types(nametab, value, NULL)))) {

1✔

7600

         ident_t id = tree_ident(value);

530✔

7601

         type_set_ident(type, ident_rfrom(id, '.') ?: id);

530✔

7602

         solve_types(nametab, value, type);

530✔

7604

      tree_set_type(t, type);

531✔

7606

   else if (value_kind == T_REF && tree_has_ref(value)) {

1,021✔

7608

      tree_t decl = tree_ref(value);

848✔

7609

      if (is_design_unit(decl) || tree_kind(decl) == T_COMPONENT) {

848✔

7610

         tree_set_flag(t, TREE_F_NONOBJECT_ALIAS);

3✔

7611

         nonobject_alias = true;

3✔

7614

         solve_types(nametab, value, NULL);

845✔

7617

      solve_types(nametab, value, NULL);

173✔

7619

   if (value_kind == T_REF && tree_has_ref(value)) {

1,552✔

7620

      tree_t decl = tree_ref(value);

1,350✔

7621

      if (is_type_decl(decl))

1,350✔

7622

         type_alias = true;

65✔

7625

   if ((type_alias || nonobject_alias) && has_subtype_indication)

1,552✔

7626

      parse_error(CURRENT_LOC, "nonobject alias may not have a "

1✔

7629

   consume(tSEMI);

1,552✔

7631

   tree_set_loc(t, CURRENT_LOC);

1,552✔

7633

   insert_name(nametab, t, NULL);

1,552✔

7634

   sem_check(t, nametab);

1,552✔

7636

   tree_add_decl(parent, t);

1,552✔

7638

   if (type_alias) {

1,552✔

7642

      type_t type = tree_type(value);

65✔

7644

      switch (type_kind(type)) {

65✔

7645

      case T_ENUM:

27✔

7647

            const int nlits = type_enum_literals(type);

27✔

7648

            for (int i = 0; i < nlits; i++) {

641✔

7649

               tree_t lit = type_enum_literal(type, i);

614✔

7651

               tree_t a = tree_new(T_ALIAS);

614✔

7652

               tree_set_loc(a, CURRENT_LOC);

614✔

7653

               tree_set_ident(a, tree_ident(lit));

614✔

7654

               tree_set_value(a, make_ref(lit));

614✔

7655

               tree_set_type(a, type);

614✔

7656

               tree_set_flag(a, TREE_F_PREDEFINED);

614✔

7658

               insert_name(nametab, a, NULL);

614✔

7659

               tree_add_decl(parent, a);

614✔

7664

      case T_PHYSICAL:

1✔

7666

            const int nunits = type_units(type);

1✔

7667

            for (int i = 0; i < nunits; i++) {

3✔

7668

               tree_t unit = type_unit(type, i);

2✔

7670

               tree_t a = tree_new(T_ALIAS);

2✔

7671

               tree_set_loc(a, CURRENT_LOC);

2✔

7672

               tree_set_ident(a, tree_ident(unit));

2✔

7673

               tree_set_value(a, make_ref(unit));

2✔

7674

               tree_set_type(a, type);

2✔

7675

               tree_set_flag(a, TREE_F_PREDEFINED);

2✔

7677

               insert_name(nametab, a, NULL);

2✔

7678

               tree_add_decl(parent, a);

2✔

7685

      walk_predefs(nametab, tree_ident(value), add_predef_alias, parent);

65✔

7687

1,552✔

7689

static void p_file_open_information(tree_t *mode, tree_t *name)

154✔

7693

   BEGIN("file open information");

308✔

7695

   if (optional(tOPEN)) {

154✔

7696

      *mode = p_expression();

41✔

7697

      solve_types(nametab, *mode, std_type(NULL, STD_FILE_OPEN_KIND));

41✔

7700

      *mode = NULL;

113✔

7702

   if (optional(tIS)) {

154✔

7703

      ident_t mode_name = ident_new("READ_MODE");

50✔

7704

      if ((*mode == NULL) && scan(tIN, tOUT)) {

50✔

7706

         switch (one_of(tIN, tOUT)) {

2✔

7708

         case tOUT: mode_name = ident_new("WRITE_MODE"); break;

1✔

7712

      *name = p_expression();

50✔

7713

      solve_types(nametab, *name, std_type(NULL, STD_STRING));

50✔

7715

      if (*mode == NULL) {

50✔

7716

         tree_t decl = get_local_decl(nametab, find_std(nametab), mode_name, 0);

9✔

7717

         *mode = make_ref(decl);

9✔

7721

      *name = NULL;

104✔

7722

154✔

7724

static void p_file_declaration(tree_t parent)

154✔

7728

   BEGIN("file declaration");

308✔

7730

   consume(tFILE);

154✔

7732

   LOCAL_IDENT_LIST ids = p_identifier_list();

308✔

7734

   for (ident_list_t *it = ids; it != NULL; it = it->next)

314✔

7735

      hide_name(nametab, it->ident);

160✔

7737

   consume(tCOLON);

154✔

7739

   type_t type = p_subtype_indication();

154✔

7741

   tree_t mode, name;

154✔

7742

   p_file_open_information(&mode, &name);

154✔

7744

   consume(tSEMI);

154✔

7746

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

314✔

7747

      tree_t t = tree_new(T_FILE_DECL);

160✔

7748

      tree_set_ident(t, it->ident);

160✔

7749

      tree_set_type(t, type);

160✔

7750

      if (name != NULL) {

160✔

7751

         tree_set_file_mode(t, mode);

50✔

7752

         tree_set_value(t, name);

50✔

7754

      tree_set_loc(t, &(it->loc));

160✔

7756

      tree_add_decl(parent, t);

160✔

7758

      insert_name(nametab, t, it->ident);

160✔

7759

      sem_check(t, nametab);

160✔

7761

154✔

7763

static void p_disconnection_specification(tree_t container)

14✔

7767

   BEGIN("disconnection specification");

28✔

7769

   consume(tDISCONNECT);

14✔

7771

   LOCAL_IDENT_LIST ids = p_identifier_list();

28✔

7773

   consume(tCOLON);

14✔

7775

   type_t type = p_type_mark();

14✔

7777

   consume(tAFTER);

14✔

7779

   tree_t delay = p_expression();

14✔

7780

   solve_types(nametab, delay, std_type(NULL, STD_TIME));

14✔

7782

   consume(tSEMI);

14✔

7784

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

28✔

7785

      tree_t d = tree_new(T_DISCONNECT);

14✔

7786

      tree_set_loc(d, &(it->loc));

14✔

7787

      tree_set_ident(d, it->ident);

14✔

7788

      tree_set_type(d, type);

14✔

7789

      tree_set_delay(d, delay);

14✔

7790

      tree_set_ref(d, resolve_name(nametab, CURRENT_LOC, it->ident));

14✔

7793

      ident_t name = ident_prefix(it->ident, ident_new("disconnect"), '$');

14✔

7794

      insert_name(nametab, d, name);

14✔

7796

      tree_add_decl(container, d);

14✔

7797

      sem_check(d, nametab);

14✔

7799

14✔

7801

static void p_entity_class_entry_list(tree_t group)

2✔

7805

   BEGIN("entity class entry list");

4✔

7807

   do {

2✔

7808

      p_entity_class();

2✔

7809

      optional(tBOX);

2✔

7810

   } while (optional(tCOMMA));

2✔

7811

2✔

7813

static tree_t p_group_template_declaration(void)

2✔

7817

   BEGIN("group template declaration");

2✔

7819

   consume(tGROUP);

2✔

7821

   tree_t g = tree_new(T_GROUP_TEMPLATE);

2✔

7822

   tree_set_ident(g, p_identifier());

2✔

7824

   consume(tIS);

2✔

7825

   consume(tLPAREN);

2✔

7826

   p_entity_class_entry_list(g);

2✔

7827

   consume(tRPAREN);

2✔

7828

   consume(tSEMI);

2✔

7830

   tree_set_loc(g, CURRENT_LOC);

2✔

7831

   insert_name(nametab, g, NULL);

2✔

7833

   return g;

2✔

7836

static void p_group_constituent_list(tree_t group)

2✔

7840

   BEGIN("group constituent list");

4✔

7842

   do {

2✔

7843

      (void)p_name(0);   // Do nothing with groups currently

2✔

7844

   } while (optional(tCOMMA));

2✔

7845

2✔

7847

static tree_t p_group_declaration(void)

2✔

7851

   BEGIN("group declaration");

2✔

7853

   consume(tGROUP);

2✔

7855

   tree_t g = tree_new(T_GROUP);

2✔

7856

   tree_set_ident(g, p_identifier());

2✔

7858

   consume(tCOLON);

2✔

7860

   ident_t template_name = p_identifier();

2✔

7861

   tree_t template = resolve_name(nametab, CURRENT_LOC, template_name);

2✔

7862

   if (template != NULL && tree_kind(template) != T_GROUP_TEMPLATE) {

2✔

7868

   tree_set_ref(g, template);

2✔

7870

   consume(tLPAREN);

2✔

7871

   p_group_constituent_list(g);

2✔

7872

   consume(tRPAREN);

2✔

7873

   consume(tSEMI);

2✔

7875

   tree_set_loc(g, CURRENT_LOC);

2✔

7876

   insert_name(nametab, g, NULL);

2✔

7878

   return g;

2✔

7881

static void p_protected_type_body_declarative_item(tree_t body)

757✔

7889

   BEGIN("protected type body declarative item");

1,514✔

7891

   switch (peek()) {

757✔

7899

   case tTYPE:

40✔

7900

      p_type_declaration(body);

40✔

7901

      break;

40✔

7907

   case tCONSTANT:

7✔

7908

      p_constant_declaration(body);

7✔

7909

      break;

7✔

7915

   case tFUNCTION:

461✔

7919

      if (peek_nth(3) == tIS && peek_nth(4) == tNEW)

461✔

7922

         tree_t spec = p_subprogram_specification();

461✔

7923

         tree_set_flag(spec, TREE_F_PROTECTED);

461✔

7924

         if (peek() == tSEMI)

461✔

7925

            tree_add_decl(body, p_subprogram_declaration(spec));

5✔

7927

            tree_add_decl(body, p_subprogram_body(spec));

456✔

7931

   case tVARIABLE:

240✔

7932

      p_variable_declaration(body);

240✔

7933

      break;

240✔

7939

   case tFILE:

9✔

7940

      p_file_declaration(body);

9✔

7941

      break;

9✔

7954

757✔

7956

static void p_protected_type_body_declarative_part(tree_t body)

209✔

7960

   BEGIN("protected type body declarative part");

418✔

7962

   while (not_at_token(tEND))

966✔

7963

      p_protected_type_body_declarative_item(body);

757✔

7964

209✔

7966

static tree_t p_protected_type_body(ident_t id)

209✔

7971

   BEGIN("protected type body");

209✔

7973

   consume(tPROTECTED);

209✔

7974

   consume(tBODY);

209✔

7976

   tree_t body = tree_new(T_PROT_BODY);

209✔

7977

   tree_set_ident(body, id);

209✔

7978

   tree_set_loc(body, CURRENT_LOC);

209✔

7980

   tree_t decl = resolve_name(nametab, CURRENT_LOC, id);

209✔

7981

   if (decl != NULL) {

209✔

7982

      switch (tree_kind(decl)) {

206✔

7983

      case T_PROT_BODY:   // Duplicate body will trigger an error later

2✔

7984

         if (!tree_has_primary(decl)) {

2✔

7985

            assert(error_count() > 0); // Fallout from previous error, ignore

1✔

7989

         decl = tree_primary(decl);

1✔

7991

      case T_PROT_DECL:

203✔

7992

         tree_set_primary(body, decl);

203✔

7993

         break;

203✔

7994

      default:

2✔

7995

         parse_error(CURRENT_LOC, "object %s is not a protected type "

2✔

8001

   if (decl == NULL)

206✔

8002

      tree_set_type(body, type_new(T_NONE));

6✔

8004

      type_t type = tree_type(decl);

203✔

8005

      assert(type_is_protected(type));

203✔

8006

      tree_set_type(body, type);

203✔

8009

   insert_name(nametab, body, NULL);

209✔

8011

   push_scope(nametab);

209✔

8013

   if (decl != NULL) insert_decls(nametab, decl);

209✔

8015

   scope_set_prefix(nametab, id);

209✔

8016

   scope_set_container(nametab, body);

209✔

8018

   p_protected_type_body_declarative_part(body);

209✔

8020

   consume(tEND);

209✔

8021

   consume(tPROTECTED);

209✔

8022

   consume(tBODY);

209✔

8024

   p_trailing_label(id);

209✔

8026

   tree_set_loc(body, CURRENT_LOC);

209✔

8027

   sem_check(body, nametab);

209✔

8029

   pop_scope(nametab);

209✔

8030

   return body;

209✔

8033

static tree_t p_package_instantiation_declaration(tree_t unit)

284✔

8037

   consume(tPACKAGE);

284✔

8039

   ident_t id = p_identifier();

284✔

8041

   consume(tIS);

284✔

8042

   consume(tNEW);

284✔

8044

   require_std(STD_08, "package instantiation declarations");

284✔

8046

   ident_t unit_name = p_selected_identifier();

284✔

8047

   tree_t pack = resolve_name(nametab, CURRENT_LOC, unit_name);

284✔

8049

   if (pack != NULL && !is_uninstantiated_package(pack)) {

284✔

8050

      parse_error(CURRENT_LOC, "unit %s is not an uninstantiated package",

2✔

8055

   tree_t new;

284✔

8056

   if (unit != NULL) {

284✔

8058

      assert(tree_kind(unit) == T_DESIGN_UNIT);

76✔

8059

      tree_change_kind(unit, T_PACK_INST);

76✔

8060

      new = unit;

76✔

8062

      ident_t qual = ident_prefix(lib_name(lib_work()), id, '.');

76✔

8063

      tree_set_ident(new, qual);

76✔

8066

      new = tree_new(T_PACK_INST);

208✔

8067

      tree_set_ident(new, id);

208✔

8070

   tree_t body = NULL;

284✔

8071

   if (pack != NULL) {

284✔

8072

      if (package_needs_body(pack) && (body = body_of(pack)) == NULL)

281✔

8076

      instantiate_package(new, pack, body);

281✔

8079

   tree_set_ref(new, pack);

284✔

8081

   if (peek() == tGENERIC)

284✔

8082

      p_generic_map_aspect(new, new);

267✔

8084

   consume(tSEMI);

284✔

8086

   tree_set_loc(new, CURRENT_LOC);

284✔

8087

   insert_name(nametab, new, NULL);

284✔

8089

   sem_check(new, nametab);

284✔

8091

   hash_t *map = get_generic_map(nametab);

284✔

8092

   if (map != NULL)

284✔

8093

      instance_fixup(new, map);

252✔

8095

   return new;

284✔

8098

static tree_t p_element_array_mode_view_indication(void)

2✔

8102

   BEGIN("element array mode view indication");

2✔

8104

   consume(tVIEW);

2✔

8105

   consume(tLPAREN);

2✔

8107

   tree_t name = p_name(0);

2✔

8108

   solve_types(nametab, name, NULL);

2✔

8110

   consume(tRPAREN);

2✔

8112

   return name;

2✔

8115

static tree_t p_element_record_mode_view_indication(void)

16✔

8119

   BEGIN("element record mode view indication");

16✔

8121

   consume(tVIEW);

16✔

8123

   tree_t name = p_name(0);

16✔

8124

   solve_types(nametab, name, NULL);

16✔

8126

   return name;

16✔

8129

static port_mode_t p_element_mode_view_indication(tree_t *name)

18✔

8133

   BEGIN("element mode view indication");

36✔

8135

   if (peek_nth(2) == tLPAREN) {

18✔

8136

      *name = p_element_array_mode_view_indication();

2✔

8137

      return PORT_ARRAY_VIEW;

2✔

8140

      *name = p_element_record_mode_view_indication();

16✔

8141

      return PORT_RECORD_VIEW;

16✔

8145

static void p_mode_view_element_declaration(type_t view, type_t of)

154✔

8149

   BEGIN("mode view element declaration");

308✔

8151

   LOCAL_IDENT_LIST ids = p_identifier_list();

308✔

8153

   consume(tCOLON);

154✔

8155

   tree_t name = NULL;

154✔

8157

   port_mode_t mode;

154✔

8158

   if (peek() == tVIEW)

154✔

8159

      mode = p_element_mode_view_indication(&name);

18✔

8161

      mode = p_mode();

136✔

8163

   for (ident_list_t *it = ids; it != NULL; it = it->next) {

322✔

8164

      tree_t elt = tree_new(T_VIEW_ELEMENT);

168✔

8165

      tree_set_ident(elt, it->ident);

168✔

8166

      tree_set_loc(elt, &(it->loc));

168✔

8167

      tree_set_subkind(elt, mode);

168✔

8168

      tree_set_value(elt, name);

168✔

8170

      type_add_field(view, elt);

168✔

8172

      tree_t f = resolve_field_name(nametab, &(it->loc), it->ident, of);

168✔

8173

      if (f == NULL)

168✔

8174

         tree_set_type(elt, type_new(T_NONE));

2✔

8176

         tree_set_ref(elt, f);

166✔

8177

         tree_set_type(elt, tree_type(f));

166✔

8181

   consume(tSEMI);

154✔

8182

154✔

8184

static tree_t p_mode_view_declaration(void)

73✔

8189

   BEGIN("mode view declaration");

73✔

8191

   consume(tVIEW);

73✔

8193

   tree_t view = tree_new(T_VIEW_DECL);

73✔

8195

   ident_t id = p_identifier();

73✔

8196

   tree_set_ident(view, id);

73✔

8198

   consume(tOF);

73✔

8200

   type_t of = p_subtype_indication();

73✔

8202

   type_t type = type_new(T_VIEW);

73✔

8203

   type_set_ident(type, id);

73✔

8204

   type_set_designated(type, of);

73✔

8206

   tree_set_type(view, type);

73✔

8208

   consume(tIS);

73✔

8210

   if (type_is_record(of)) {

73✔

8211

      while (not_at_token(tEND))

226✔

8212

         p_mode_view_element_declaration(type, of);

154✔

8214

      consume(tEND);

72✔

8217

      parse_error(CURRENT_LOC, "subtype indication of a mode view declaration "

1✔

8219

      drop_tokens_until(tEND);

1✔

8222

   consume(tVIEW);

73✔

8224

   p_trailing_label(id);

73✔

8226

   consume(tSEMI);

73✔

8228

   tree_set_loc(view, CURRENT_LOC);

73✔

8229

   insert_name(nametab, view, NULL);

73✔

8230

   sem_check(view, nametab);

73✔

8231

   return view;

73✔

8234

static void p_entity_declarative_item(tree_t entity)

93✔

8244

   BEGIN("entity declarative item");

186✔

8246

   switch (peek()) {

93✔

8247

   case tATTRIBUTE:

19✔

8248

      if (peek_nth(3) == tOF)

19✔

8249

         p_attribute_specification(entity);

10✔

8251

         tree_add_decl(entity, p_attribute_declaration());

9✔

8254

   case tTYPE:

1✔

8255

      p_type_declaration(entity);

1✔

8256

      break;

1✔

8258

   case tSUBTYPE:

7✔

8259

      tree_add_decl(entity, p_subtype_declaration());

7✔

8260

      break;

7✔

8262

   case tCONSTANT:

10✔

8263

      p_constant_declaration(entity);

10✔

8264

      break;

10✔

8266

   case tALIAS:

1✔

8267

      p_alias_declaration(entity);

1✔

8268

      break;

1✔

8270

   case tFUNCTION:

31✔

8274

      if (peek_nth(3) == tIS && peek_nth(4) == tNEW)

31✔

8277

         tree_t spec = p_subprogram_specification();

31✔

8278

         if (peek() == tSEMI)

31✔

8279

            tree_add_decl(entity, p_subprogram_declaration(spec));

9✔

8281

            tree_add_decl(entity, p_subprogram_body(spec));

22✔

8285

   case tUSE:

6✔

8286

      p_use_clause(entity, tree_add_decl);

6✔

8287

      break;

6✔

8289

   case tDISCONNECT:

1✔

8290

      p_disconnection_specification(entity);

1✔

8291

      break;

1✔

8300

   case tSHARED:

3✔

8301

      p_variable_declaration(entity);

3✔

8302

      break;

3✔

8304

   case tSIGNAL:

6✔

8305

      p_signal_declaration(entity);

6✔

8306

      break;

6✔

8308

   case tPACKAGE:

3✔

8309

      if (peek_nth(4) == tNEW)

3✔

8310

         tree_add_decl(entity, p_package_instantiation_declaration(NULL));

3✔

8321

   default:

5✔

8322

      expect(tATTRIBUTE, tTYPE, tSUBTYPE, tCONSTANT, tFUNCTION, tPROCEDURE,

10✔

8326

93✔

8328

static void p_entity_declarative_part(tree_t entity)

5,201✔

8332

   BEGIN("entity declarative part");

10,402✔

8334

   while (not_at_token(tEND, tBEGIN))

5,294✔

8335

      p_entity_declarative_item(entity);

93✔

8336

5,201✔

8338

static void p_subprogram_declarative_item(tree_t sub)

9,397✔

8346

   BEGIN("subprogram declarative item");

18,794✔

8348

   switch (peek()) {

9,397✔

8349

   case tVARIABLE:

6,594✔

8350

      p_variable_declaration(sub);

6,594✔

8351

      break;

6,594✔

8353

   case tTYPE:

83✔

8354

      p_type_declaration(sub);

83✔

8355

      break;

83✔

8357

   case tALIAS:

726✔

8358

      p_alias_declaration(sub);

726✔

8359

      break;

726✔

8361

   case tCONSTANT:

1,770✔

8362

      p_constant_declaration(sub);

1,770✔

8363

      break;

1,770✔

8365

   case tFUNCTION:

110✔

8369

      if (peek_nth(3) == tIS && peek_nth(4) == tNEW)

110✔

8370

         tree_add_decl(sub, p_subprogram_instantiation_declaration());

1✔

8372

         tree_t spec = p_subprogram_specification();

109✔

8373

         tree_set_flag(spec, tree_flags(sub) & TREE_F_PROTECTED);

109✔

8374

         if (peek() == tSEMI)

109✔

8377

            tree_add_decl(sub, p_subprogram_body(spec));

109✔

8381

   case tATTRIBUTE:

13✔

8382

      if (peek_nth(3) == tOF)

13✔

8383

         p_attribute_specification(sub);

9✔

8385

         tree_add_decl(sub, p_attribute_declaration());

4✔

8388

   case tSUBTYPE:

56✔

8389

      tree_add_decl(sub, p_subtype_declaration());

56✔

8390

      break;

56✔

8392

   case tUSE:

9✔

8393

      p_use_clause(sub, tree_add_decl);

9✔

8394

      break;

9✔

8396

   case tFILE:

28✔

8397

      p_file_declaration(sub);

28✔

8398

      break;

28✔

8407

   default:

8✔

8408

      expect(tVARIABLE, tTYPE, tALIAS, tCONSTANT, tFUNCTION, tPROCEDURE,

8✔

8411

9,397✔

8413

static void p_subprogram_declarative_part(tree_t sub)

9,544✔

8417

   BEGIN("subprogram declarative part");

19,088✔

8419

   while (not_at_token(tBEGIN))

18,941✔

8420

      p_subprogram_declarative_item(sub);

9,397✔

8421

9,544✔

8423

static void p_sequence_of_statements(tree_t parent)

31,965✔

8427

   BEGIN("sequence of statements");

63,927✔

8429

   while (not_at_token(tEND, tELSE, tELSIF, tWHEN))

116,385✔

8430

      tree_add_stmt(parent, p_sequential_statement());

84,423✔

8431

31,962✔

8433

static void p_trailing_label(ident_t label)

41,236✔

8437

   if ((peek() == tID) || (peek() == tSTRING)) {

41,236✔

8438

      ident_t trailing = p_designator();

6,958✔

8439

      if (label == NULL)

6,958✔

8440

         parse_error(&last_loc, "unexpected trailing label for %s without "

3✔

8442

      else if (trailing != label)

6,955✔

8443

         parse_error(&last_loc, "expected trailing %s label to match %s",

7✔

8446

41,236✔

8448

static tree_t p_subprogram_body(tree_t spec)

9,544✔

8453

   EXTEND("subprogram body");

9,544✔

8455

   consume(tIS);

9,544✔

8457

   const tree_kind_t kind =

19,088✔

8458

      (tree_kind(spec) == T_FUNC_DECL) ? T_FUNC_BODY : T_PROC_BODY;

9,544✔

8459

   tree_change_kind(spec, kind);

9,544✔

8461

   insert_name(nametab, spec, NULL);

9,544✔

8463

   push_scope(nametab);

9,544✔

8464

   scope_set_subprogram(nametab, spec);

9,544✔

8466

   insert_generics(nametab, spec);

9,544✔

8467

   insert_ports(nametab, spec);

9,544✔

8469

   sem_check(spec, nametab);

9,544✔

8471

   if (tree_flags(spec) & TREE_F_KNOWS_SUBTYPE) {

9,544✔

8476

      type_t sub = type_result(tree_type(spec));

15✔

8477

      assert(type_kind(sub) == T_SUBTYPE);

15✔

8479

      tree_t d = tree_new(T_SUBTYPE_DECL);

15✔

8480

      tree_set_ident(d, type_ident(sub));

15✔

8481

      tree_set_type(d, sub);

15✔

8482

      tree_set_loc(d, CURRENT_LOC);

15✔

8484

      insert_name(nametab, d, NULL);

15✔

8486

      tree_add_decl(spec, d);

15✔

8489

   p_subprogram_declarative_part(spec);

9,544✔

8491

   consume(tBEGIN);

9,544✔

8493

   p_sequence_of_statements(spec);

9,544✔

8495

   consume(tEND);

9,544✔

8497

   pop_scope(nametab);

9,544✔

8499

   if (scan(tFUNCTION, tPROCEDURE))

9,544✔

8500

      consume(kind == T_FUNC_BODY ? tFUNCTION : tPROCEDURE);

8,506✔

8502

   p_trailing_label(tree_ident(spec));

9,544✔

8503

   consume(tSEMI);

9,544✔

8505

   tree_set_loc(spec, CURRENT_LOC);

9,544✔

8506

   return spec;

9,544✔

8509

static tree_t p_subprogram_declaration(tree_t spec)

7,043✔

8513

   EXTEND("subprogram declaration");

7,043✔

8515

   insert_name(nametab, spec, NULL);

7,043✔

8517

   consume(tSEMI);

7,043✔

8519

   tree_set_loc(spec, CURRENT_LOC);

7,043✔

8520

   sem_check(spec, nametab);

7,043✔

8521

   return spec;

7,043✔

8524

static void p_sensitivity_list(tree_t proc)

783✔

8528

   BEGIN("sensitivity list");

1,566✔

8530

   do {

1,143✔

8531

      tree_t name = p_name(0);

1,143✔

8532

      tree_add_trigger(proc, name);

1,143✔

8533

      solve_types(nametab, name, NULL);

1,143✔

8534

   } while (optional(tCOMMA));

1,143✔

8535

783✔

8537

static void p_process_declarative_item(tree_t proc)

4,934✔

8545

   BEGIN("process declarative item");

9,868✔

8547

   switch (peek()) {

4,934✔

8548

   case tVARIABLE:

3,217✔

8549

      p_variable_declaration(proc);

3,217✔

8550

      break;

3,217✔

8552

   case tTYPE:

277✔

8553

      p_type_declaration(proc);

277✔

8554

      break;

277✔

8556

   case tSUBTYPE:

103✔

8557

      tree_add_decl(proc, p_subtype_declaration());

103✔

8558

      break;

103✔

8560

   case tCONSTANT:

706✔

8561

      p_constant_declaration(proc);

706✔

8562

      break;

706✔

8564

   case tFUNCTION:

413✔

8568

      if (peek_nth(3) == tIS && peek_nth(4) == tNEW)

413✔

8571

         tree_t spec = p_subprogram_specification();

413✔

8572

         if (peek() == tSEMI)

413✔

8573

            tree_add_decl(proc, p_subprogram_declaration(spec));

91✔

8575

            tree_add_decl(proc, p_subprogram_body(spec));

322✔

8579

   case tATTRIBUTE:

38✔

8580

      if (peek_nth(3) == tOF)

38✔

8581

         p_attribute_specification(proc);

19✔

8583

         tree_add_decl(proc, p_attribute_declaration());

19✔

8586

   case tUSE:

5✔

8587

      p_use_clause(proc, tree_add_decl);

5✔

8588

      break;

5✔

8590

   case tALIAS:

92✔

8591

      p_alias_declaration(proc);

92✔

8592

      break;

92✔

8594

   case tFILE:

64✔

8595

      p_file_declaration(proc);

64✔

8596

      break;

64✔

8598

   case tGROUP:

2✔

8599

      if (peek_nth(3) == tIS)

2✔

8600

         tree_add_decl(proc, p_group_template_declaration());

1✔

8602

         tree_add_decl(proc, p_group_declaration());

1✔

8605

   default:

17✔

8606

      expect(tVARIABLE, tTYPE, tSUBTYPE, tCONSTANT, tFUNCTION, tPROCEDURE,

17✔

8609

4,934✔

8611

static void p_process_declarative_part(tree_t proc)

5,004✔

8615

   BEGIN("process declarative part");

10,008✔

8617

   while (not_at_token(tBEGIN))

9,925✔

8618

      p_process_declarative_item(proc);

4,921✔

8619

5,004✔

8621

static void p_process_statement_part(tree_t proc)

5,004✔

8625

   BEGIN("process statement part");

10,005✔

8627

   p_sequence_of_statements(proc);

5,004✔

8628

5,001✔

8630

static void p_process_sensitivity_list(tree_t proc)

213✔

8634

   BEGIN("process sensitivity list");

426✔

8636

   if (peek() == tALL) {

213✔

8637

      consume(tALL);

50✔

8639

      tree_t all = tree_new(T_ALL);

50✔

8640

      tree_set_loc(all, CURRENT_LOC);

50✔

8641

      tree_add_trigger(proc, all);

50✔

8644

      p_sensitivity_list(proc);

163✔

8645

213✔

8647

static tree_t p_process_statement(ident_t label)

5,004✔

8653

   EXTEND("process statement");

5,004✔

8655

   tree_t t = tree_new(T_PROCESS);

5,004✔

8657

   const bool postponed = optional(tPOSTPONED);

5,004✔

8659

   consume(tPROCESS);

5,004✔

8661

   if (optional(tLPAREN)) {

5,004✔

8662

      if (standard() < STD_08)

472✔

8663

         p_sensitivity_list(t);

259✔

8665

         p_process_sensitivity_list(t);

213✔

8666

      consume(tRPAREN);

472✔

8669

   optional(tIS);

5,004✔

8671

   if (label == NULL) {

5,004✔

8672

      tree_set_ident(t, get_implicit_label(t, nametab));

2,104✔

8673

      tree_set_flag(t, TREE_F_SYNTHETIC_NAME);

2,104✔

8676

      tree_set_loc(t, CURRENT_LOC);

2,900✔

8677

      tree_set_ident(t, label);

2,900✔

8678

      insert_name(nametab, t, label);

2,900✔

8681

   push_scope(nametab);

5,004✔

8682

   scope_set_container(nametab, t);

5,004✔

8683

   scope_set_prefix(nametab, tree_ident(t));

5,004✔

8685

   p_process_declarative_part(t);

5,004✔

8687

   consume(tBEGIN);

5,004✔

8689

   p_process_statement_part(t);

5,004✔

8691

   consume(tEND);

5,001✔

8692

   if (postponed)

5,001✔

8693

      optional(tPOSTPONED);

25✔

8694

   consume(tPROCESS);

5,001✔

8696

   p_trailing_label(label);

5,001✔

8698

   consume(tSEMI);

5,001✔

8700

   pop_scope(nametab);

5,001✔

8702

   tree_set_loc(t, CURRENT_LOC);

5,001✔

8704

   if (postponed)

5,001✔

8705

      tree_set_flag(t, TREE_F_POSTPONED);

25✔

8707

   sem_check(t, nametab);

5,001✔

8708

   return t;

5,001✔

8711

static tree_t p_entity_statement(void)

37✔

8716

   BEGIN("entity statement");

74✔

8718

   ident_t label = NULL;

37✔

8719

   if ((peek() == tID) && (peek_nth(2) == tCOLON)) {

37✔

8720

      label = p_identifier();

4✔

8721

      consume(tCOLON);

4✔

8724

   switch (peek()) {

37✔

8725

   case tASSERT:

29✔

8726

      return p_concurrent_assertion_statement(label);

29✔

8728

   case tPROCESS:

2✔

8729

      return p_process_statement(label);

2✔

8731

   case tID:

3✔

8732

      return p_concurrent_procedure_call_statement(label, NULL);

3✔

8734

   case tPOSTPONED:

3✔

8735

      if (peek_nth(2) == tASSERT)

3✔

8737

      else if (peek_nth(2) == tPROCESS)

3✔

8740

         return p_concurrent_procedure_call_statement(label, NULL);

3✔

8748

static void p_entity_statement_part(tree_t entity)

64✔

8752

   BEGIN("entity statement part");

128✔

8754

   while (not_at_token(tEND))

101✔

8755

      tree_add_stmt(entity, p_entity_statement());

37✔

8756

64✔

8758

static void p_entity_declaration(tree_t unit)

5,201✔

8763

   BEGIN("entity declaration");

10,402✔

8765

   tree_change_kind(unit, T_ENTITY);

5,201✔

8767

   consume(tENTITY);

5,201✔

8769

   ident_t id = p_identifier();

5,201✔

8770

   tree_set_ident(unit, id);

5,201✔

8772

   consume(tIS);

5,201✔

8774

   push_scope(nametab);

5,201✔

8776

   tree_set_loc(unit, CURRENT_LOC);

5,201✔

8777

   insert_name(nametab, unit, id);

5,201✔

8779

   push_scope(nametab);

5,201✔

8781

   ident_t qual = ident_prefix(lib_name(lib_work()), id, '.');

5,201✔

8782

   scope_set_prefix(nametab, qual);

5,201✔

8784

   p_entity_header(unit);

5,201✔

8785

   p_entity_declarative_part(unit);

5,201✔

8787

   if (optional(tBEGIN))

5,201✔

8788

      p_entity_statement_part(unit);

64✔

8790

   consume(tEND);

5,201✔

8791

   optional(tENTITY);

5,201✔

8792

   p_trailing_label(id);

5,201✔

8793

   consume(tSEMI);

5,201✔

8795

   tree_set_ident(unit, qual);

5,201✔

8796

   tree_set_loc(unit, CURRENT_LOC);

5,201✔

8798

   sem_check(unit, nametab);

5,201✔

8800

   pop_scope(nametab);

5,201✔

8801

   pop_scope(nametab);

5,201✔

8802

5,201✔

8804

static tree_t p_component_declaration(void)

361✔

8813

   BEGIN("component declaration");

361✔

8815

   tree_t c = tree_new(T_COMPONENT);

361✔

8817

   consume(tCOMPONENT);

361✔

8818

   tree_set_ident(c, p_identifier());

361✔

8819

   optional(tIS);

361✔

8821

   push_scope(nametab);

361✔

8823

   if (peek() == tGENERIC) {

361✔

8824

      p_generic_clause(c);

151✔

8825

      insert_generics(nametab, c);

151✔

8828

   if (peek() == tPORT) {

361✔

8829

      p_port_clause(c);

256✔

8830

      insert_ports(nametab, c);

256✔

8833

   pop_scope(nametab);

361✔

8835

   consume(tEND);

361✔

8836

   if (peek() != tCOMPONENT)

361✔

8837

      require_std(STD_19, "optional end component");

1✔

8839

      consume(tCOMPONENT);

360✔

8840

   p_trailing_label(tree_ident(c));

361✔

8841

   consume(tSEMI);

361✔

8843

   tree_set_loc(c, CURRENT_LOC);

361✔

8844

   insert_name(nametab, c, NULL);

361✔

8845

   sem_check(c, nametab);

361✔

8846

   return c;

361✔

8849

static void p_package_declarative_item(tree_t pack)

12,484✔

8862

   BEGIN("package declarative item");

24,968✔

8864

   switch (peek()) {

12,484✔

8865

   case tTYPE:

2,166✔

8866

      p_type_declaration(pack);

2,166✔

8867

      break;

2,166✔

8869

   case tFUNCTION:

6,334✔

8873

      if (peek_nth(3) == tIS && peek_nth(4) == tNEW)

6,334✔

8874

         tree_add_decl(pack, p_subprogram_instantiation_declaration());

42✔

8876

         tree_t spec = p_subprogram_specification();

6,292✔

8877

         if (peek() == tSEMI)

6,292✔

8878

            tree_add_decl(pack, p_subprogram_declaration(spec));

6,290✔

8880

            tree_add_decl(pack, p_subprogram_body(spec));

2✔

8884

   case tSUBTYPE:

809✔

8885

      tree_add_decl(pack, p_subtype_declaration());

809✔

8886

      break;

809✔

8888

   case tSIGNAL:

185✔

8889

      p_signal_declaration(pack);

185✔

8890

      break;

185✔

8892

   case tATTRIBUTE:

260✔

8893

      if (peek_nth(3) == tOF)

260✔

8894

         p_attribute_specification(pack);

188✔

8896

         tree_add_decl(pack, p_attribute_declaration());

72✔

8899

   case tCONSTANT:

1,944✔

8900

      p_constant_declaration(pack);

1,944✔

8901

      break;

1,944✔

8903

   case tCOMPONENT:

41✔

8904

      tree_add_decl(pack, p_component_declaration());

41✔

8905

      break;

41✔

8907

   case tFILE:

14✔

8908

      p_file_declaration(pack);

14✔

8909

      break;

14✔

8911

   case tSHARED:

29✔

8912

      p_variable_declaration(pack);

29✔

8913

      break;

29✔

8915

   case tALIAS:

563✔

8916

      p_alias_declaration(pack);

563✔

8917

      break;

563✔

8919

   case tUSE:

11✔

8920

      p_use_clause(pack, tree_add_decl);

11✔

8921

      break;

11✔

8934

   case tPACKAGE:

24✔

8935

      if (peek_nth(4) == tNEW)

24✔

8936

         tree_add_decl(pack, p_package_instantiation_declaration(NULL));

14✔

8938

         require_std(STD_08, "nested package declarations");

10✔

8939

         tree_add_decl(pack, p_package_declaration(NULL));

10✔

8943

   case tVIEW:

56✔

8944

      tree_add_decl(pack, p_mode_view_declaration());

56✔

8945

      break;

56✔

8947

   default:

48✔

8948

      expect(tTYPE, tFUNCTION, tPROCEDURE, tIMPURE, tPURE, tSUBTYPE, tSIGNAL,

95✔

8952

12,484✔

8954

static void p_package_declarative_part(tree_t pack)

1,499✔

8958

   BEGIN("package declarative part");

2,998✔

8960

   while (not_at_token(tEND))

13,983✔

8961

      p_package_declarative_item(pack);

12,484✔

8962

1,499✔

8964

static void p_package_header(tree_t unit)

693✔

8968

   BEGIN("package header");

1,386✔

8970

   if (peek() == tGENERIC) {

693✔

8971

      p_generic_clause(unit);

223✔

8973

      if (peek() == tGENERIC) {

223✔

8974

         p_generic_map_aspect(unit, unit);

1✔

8975

         consume(tSEMI);

1✔

8978

      insert_generics(nametab, unit);

223✔

8980

693✔

8982

static tree_t p_package_declaration(tree_t unit)

1,499✔

8990

   BEGIN("package declaration");

1,499✔

8992

   consume(tPACKAGE);

1,499✔

8994

   ident_t name = p_identifier(), qual = name;

1,499✔

8996

   tree_t pack;

1,499✔

8997

   if (unit != NULL) {

1,499✔

8999

      assert(tree_kind(unit) == T_DESIGN_UNIT);

1,484✔

9000

      tree_change_kind(unit, T_PACKAGE);

1,484✔

9001

      pack = unit;

1,484✔

9004

      qual = ident_prefix(lib_name(lib_work()), name, '.');

1,484✔

9005

      scope_set_prefix(nametab, qual);

1,484✔

9008

      pack = tree_new(T_PACKAGE);

15✔

9009

      scope_set_prefix(nametab, name);

15✔

9012

   tree_set_ident(pack, name);

1,499✔

9013

   tree_set_loc(pack, CURRENT_LOC);

1,499✔

9015

   insert_name(nametab, pack, NULL);

1,499✔

9017

   push_scope(nametab);

1,499✔

9019

   consume(tIS);

1,499✔

9021

   push_scope(nametab);

1,499✔

9022

   scope_set_container(nametab, pack);

1,499✔

9024

   if (standard() >= STD_08)

1,499✔

9025

      p_package_header(pack);

693✔

9027

   p_package_declarative_part(pack);

1,499✔

9029

   if (bootstrapping)

1,499✔

9030

      declare_additional_standard_operators(pack);

3✔

9032

   pop_scope(nametab);

1,499✔

9034

   consume(tEND);

1,499✔

9035

   optional(tPACKAGE);

1,499✔

9036

   p_trailing_label(name);

1,499✔

9037

   consume(tSEMI);

1,499✔

9039

   tree_set_ident(pack, qual);

1,499✔

9040

   tree_set_loc(pack, CURRENT_LOC);

1,499✔

9042

   sem_check(pack, nametab);

1,499✔

9044

   pop_scope(nametab);

1,499✔

9045

   return pack;

1,499✔

9048

static ident_list_t *p_instantiation_list(void)

219✔

9052

   switch (peek()) {

219✔

9053

   case tID:

166✔

9054

      return p_identifier_list();

166✔

9056

   case tOTHERS:

7✔

9057

      consume(tOTHERS);

7✔

9058

      return NULL;

7✔

9060

   case tALL:

46✔

9062

         consume(tALL);

46✔

9064

         ident_list_t *result = NULL;

46✔

9065

         ident_list_push(&result, well_known(W_ALL), last_loc);

46✔

9066

         return result;

46✔

9075

static ident_list_t *p_component_specification(ident_t *comp_name)

219✔

9079

   BEGIN("component specification");

219✔

9081

   ident_list_t *ids = p_instantiation_list();

219✔

9082

   consume(tCOLON);

219✔

9083

   *comp_name = p_identifier();

219✔

9085

   return ids;

219✔

9088

static void p_port_map_aspect(tree_t inst, tree_t unit)

1,405✔

9092

   BEGIN("port map aspect");

2,810✔

9094

   consume(tPORT);

1,405✔

9095

   consume(tMAP);

1,405✔

9096

   consume(tLPAREN);

1,405✔

9098

   p_association_list(inst, unit, F_PORT_MAP);

1,405✔

9100

   consume(tRPAREN);

1,405✔

9101

1,405✔

9103

static void p_generic_map_aspect(tree_t inst, tree_t unit)

1,124✔

9107

   BEGIN("generic map aspect");

2,248✔

9109

   consume(tGENERIC);

1,124✔

9110

   consume(tMAP);

1,124✔

9111

   consume(tLPAREN);

1,124✔

9113

   p_association_list(inst, unit, F_GENERIC_MAP);

1,124✔

9115

   consume(tRPAREN);

1,124✔

9116

1,124✔

9118

static tree_t p_entity_aspect(void)

216✔

9122

   switch (one_of(tENTITY, tCONFIGURATION, tOPEN)) {

216✔

9123

   case tENTITY:

158✔

9125

         tree_t bind = tree_new(T_BINDING);

158✔

9126

         tree_set_class(bind, C_ENTITY);

158✔

9127

         tree_set_ident(bind, p_selected_identifier());

158✔

9128

         if (optional(tLPAREN)) {

158✔

9129

            tree_set_ident2(bind, p_identifier());

94✔

9130

            consume(tRPAREN);

94✔

9132

         tree_set_loc(bind, CURRENT_LOC);

158✔

9134

         return bind;

158✔

9137

   case tCONFIGURATION:

49✔

9139

         tree_t bind = tree_new(T_BINDING);

49✔

9140

         tree_set_class(bind, C_CONFIGURATION);

49✔

9141

         tree_set_ident(bind, p_selected_identifier());

49✔

9142

         tree_set_loc(bind, CURRENT_LOC);

49✔

9144

         return bind;

49✔

9153

static tree_t p_binding_indication(tree_t comp)

218✔

9157

   BEGIN("binding indication");

218✔

9159

   tree_t bind = NULL, unit = NULL;

218✔

9160

   if (optional(tUSE)) {

218✔

9161

      if ((bind = p_entity_aspect()) && (unit = find_binding(bind))) {

216✔

9162

         tree_set_ref(bind, unit);

203✔

9163

         unit = primary_unit_of(unit);

203✔

9167

   if (comp) {

218✔

9168

      insert_generics(nametab, comp);

214✔

9169

      insert_ports(nametab, comp);

214✔

9172

   if (peek() == tGENERIC) {

218✔

9173

      if (bind == NULL) {

55✔

9174

         consume(tGENERIC);

1✔

9175

         parse_error(CURRENT_LOC, "sorry, binding indication with generic map "

1✔

9177

         drop_tokens_until(tRPAREN);

1✔

9180

         p_generic_map_aspect(bind, unit);

54✔

9183

   if (peek() == tPORT) {

218✔

9184

      if (bind == NULL) {

61✔

9191

         p_port_map_aspect(bind, unit);

61✔

9194

   if (bind != NULL)

218✔

9195

      tree_set_loc(bind, CURRENT_LOC);

207✔

9197

   return bind;

218✔

9200

static void p_configuration_specification(tree_t parent)

102✔

9204

   BEGIN("configuration specification");

204✔

9206

   consume(tFOR);

102✔

9208

   ident_t comp_name;

102✔

9209

   LOCAL_IDENT_LIST ids = p_component_specification(&comp_name);

204✔

9211

   tree_t comp = resolve_name(nametab, CURRENT_LOC, comp_name);

102✔

9212

   if (comp != NULL && tree_kind(comp) != T_COMPONENT) {

102✔

9213

      parse_error(CURRENT_LOC, "%s does not name a component", istr(comp_name));

1✔

9217

   push_scope(nametab);

102✔

9219

   bool is_open = (peek() == tUSE && peek_nth(2) == tOPEN);

102✔

9220

   tree_t bind = p_binding_indication(comp);

102✔

9221

   if (!is_open && bind == NULL)

102✔

9222

      parse_error(CURRENT_LOC, "a binding indication in an explicit "

1✔

9224

   consume(tSEMI);

102✔

9226

   if (ids != NULL) {

102✔

9227

      for (ident_list_t *it = ids; it != NULL; it = it->next) {

202✔

9228

         tree_t t = tree_new(T_SPEC);

103✔

9229

         tree_set_loc(t, &(it->loc));

103✔

9230

         tree_set_ident(t, it->ident);

103✔

9231

         tree_set_ident2(t, comp_name);

103✔

9232

         tree_set_value(t, bind);

103✔

9233

         tree_set_ref(t, comp);

103✔

9235

         const spec_kind_t kind =

206✔

9236

            it->ident == well_known(W_ALL) ? SPEC_ALL : SPEC_EXACT;

103✔

9238

         tree_add_decl(parent, t);

103✔

9239

         insert_spec(nametab, t, kind, it->ident, 1);

103✔

9240

         sem_check(t, nametab);

103✔

9245

      tree_t t = tree_new(T_SPEC);

3✔

9246

      tree_set_loc(t, CURRENT_LOC);

3✔

9247

      tree_set_ident2(t, comp_name);

3✔

9248

      tree_set_value(t, bind);

3✔

9249

      tree_set_ref(t, comp);

3✔

9251

      tree_add_decl(parent, t);

3✔

9252

      insert_spec(nametab, t, SPEC_OTHERS, NULL, 1);

3✔

9253

      sem_check(t, nametab);

3✔

9256

   pop_scope(nametab);

102✔

9257

102✔

9259

static void p_configuration_declarative_part(tree_t unit)

6✔

9263

   BEGIN("configuration declarative part");

12✔

9265

   switch (peek()) {

6✔

9266

   case tUSE:

3✔

9267

      p_use_clause(unit, tree_add_decl);

3✔

9268

      break;

3✔

9270

   case tATTRIBUTE:

3✔

9271

      p_attribute_specification(unit);

3✔

9272

      break;

3✔

9284

6✔

9286

static void p_component_configuration(tree_t unit)

117✔

9291

   BEGIN("component configuration");

234✔

9293

   consume(tFOR);

117✔

9295

   ident_t comp_name;

117✔

9296

   LOCAL_IDENT_LIST ids = p_component_specification(&comp_name);

234✔

9298

   tree_t comp = resolve_name(nametab, CURRENT_LOC, comp_name);

117✔

9299

   if (comp != NULL && tree_kind(comp) != T_COMPONENT) {

117✔

9304

   push_scope(nametab);

117✔

9306

   tree_t bind = NULL;

117✔

9307

   if (peek() != tEND && peek() != tFOR) {

117✔

9308

      bind = p_binding_indication(comp);

116✔

9309

      consume(tSEMI);

116✔

9312

   tree_t bcfg = NULL;

117✔

9313

   if (peek() == tFOR) {

117✔

9314

      tree_t of = bind != NULL && tree_has_ref(bind) ? tree_ref(bind) : NULL;

2✔

9315

      bcfg = p_block_configuration(of);

2✔

9318

   if (ids != NULL) {

117✔

9319

      for (ident_list_t *it = ids; it != NULL; it = it->next) {

226✔

9320

         tree_t t = tree_new(T_SPEC);

113✔

9321

         tree_set_loc(t, &(it->loc));

113✔

9322

         tree_set_ident(t, it->ident);

113✔

9323

         tree_set_ident2(t, comp_name);

113✔

9324

         tree_set_value(t, bind);

113✔

9325

         tree_set_ref(t, comp);

113✔

9326

         if (bcfg != NULL) tree_add_decl(t, bcfg);

113✔

9328

         const spec_kind_t kind =

226✔

9329

            it->ident == well_known(W_ALL) ? SPEC_ALL : SPEC_EXACT;

113✔

9331

         tree_add_decl(unit, t);

113✔

9332

         sem_check(t, nametab);

113✔

9333

         insert_spec(nametab, t, kind, it->ident, 1);

113✔

9338

      tree_t t = tree_new(T_SPEC);

4✔

9339

      tree_set_loc(t, CURRENT_LOC);

4✔

9340

      tree_set_ident2(t, comp_name);

4✔

9341

      tree_set_value(t, bind);

4✔

9342

      tree_set_ref(t, comp);

4✔

9343

      if (bcfg != NULL) tree_add_decl(t, bcfg);

4✔

9345

      tree_add_decl(unit, t);

4✔

9346

      sem_check(t, nametab);

4✔

9347

      insert_spec(nametab, t, SPEC_OTHERS, NULL, 1);

4✔

9350

   pop_scope(nametab);

117✔

9352

   consume(tEND);

117✔

9353

   consume(tFOR);

117✔

9354

   consume(tSEMI);

117✔

9355

117✔

9357

static void p_configuration_item(tree_t unit)

167✔

9361

   BEGIN("configuration item");

334✔

9363

   const token_t third = peek_nth(3);

167✔

9364

   if ((third == tCOLON) || (third == tCOMMA))

167✔

9365

      p_component_configuration(unit);

117✔

9367

      tree_add_decl(unit, p_block_configuration(NULL));

50✔

9368

167✔

9370

static tree_t p_index_specification(void)

26✔

9374

   tree_t head = p_expression();

26✔

9376

   if (scan(tTO, tDOWNTO))

26✔

9377

      return p_discrete_range(head);

10✔

9382

static void p_block_specification(tree_t b)

168✔

9386

   BEGIN("block specification");

336✔

9388

   ident_t id = p_identifier();

168✔

9389

   tree_set_ident(b, id);

168✔

9391

   if (optional(tLPAREN)) {

168✔

9392

      (void)p_index_specification();    // XXX: not used

26✔

9393

      consume(tRPAREN);

26✔

9395

168✔

9397

static tree_t p_block_configuration(tree_t of)

168✔

9401

   BEGIN("block configuration");

168✔

9403

   consume(tFOR);

168✔

9405

   tree_t b = tree_new(T_BLOCK_CONFIG);

168✔

9406

   p_block_specification(b);

168✔

9408

   push_scope(nametab);

168✔

9410

   tree_t sub = NULL;

168✔

9411

   if (of != NULL) {

168✔

9412

      switch (tree_kind(of)) {

117✔

9413

      case T_ENTITY:

115✔

9415

            ident_t qual = ident_prefix(tree_ident(of), tree_ident(b), '-');

115✔

9416

            if ((sub = lib_get_qualified(qual)) == NULL)

115✔

9417

               parse_error(CURRENT_LOC, "cannot find architecture %s of "

1✔

9422

      case T_ARCH:

2✔

9424

            ident_t expect = ident_rfrom(tree_ident(of), '-');

2✔

9425

            if (tree_ident(b) != expect)

2✔

9440

      sub = resolve_name(nametab, CURRENT_LOC, tree_ident(b));

51✔

9442

   if (sub != NULL && !is_implicit_block(sub)) {

168✔

9443

      parse_error(CURRENT_LOC, "%s is not a block that can be configured",

1✔

9448

   if (sub != NULL) {

167✔

9449

      tree_set_ref(b, sub);

165✔

9451

      if (tree_kind(sub) == T_IF_GENERATE)

165✔

9452

         sub = tree_cond(sub, 0);

6✔

9454

      insert_names_for_config(nametab, sub);

165✔

9457

      suppress_errors(nametab);

3✔

9459

   while (not_at_token(tEND))

335✔

9460

      p_configuration_item(b);

167✔

9462

   if (sub != NULL) {

168✔

9463

      const int nstmts = tree_stmts(sub);

165✔

9464

      for (int i = 0; i < nstmts; i++) {

685✔

9465

         tree_t s = tree_stmt(sub, i);

520✔

9466

         if (tree_kind(s) == T_INSTANCE)

520✔

9467

            query_spec(nametab, s);

144✔

9472

   pop_scope(nametab);

168✔

9474

   consume(tEND);

168✔

9475

   consume(tFOR);

168✔

9476

   consume(tSEMI);

168✔

9478

   tree_set_loc(b, CURRENT_LOC);

168✔

9479

   sem_check(b, nametab);

168✔

9480

   return b;

168✔

9483

static ident_t p_entity_name(tree_t *entity)

5,333✔

9487

   BEGIN("entity name");

10,666✔

9489

   ident_t ename = p_selected_identifier();

5,333✔

9491

   ident_t qual = ename;

5,333✔

9492

   if (ident_runtil(ename, '.') == ename)

5,333✔

9493

      qual = ident_prefix(lib_name(lib_work()), ename, '.');

5,331✔

9495

   *entity = resolve_name(nametab, CURRENT_LOC, qual);

5,333✔

9497

   if (*entity != NULL && tree_kind(*entity) != T_ENTITY) {

5,333✔

9498

      diag_t *d = diag_new(DIAG_ERROR, CURRENT_LOC);

2✔

9499

      diag_printf(d, "%s%s is not an entity",

4✔

9500

                  is_design_unit(*entity) ? "design unit " : "", istr(ename));

2✔

9501

      diag_hint(d, tree_loc(*entity), "%s is a %s", istr(ename),

2✔

9503

      diag_emit(d);

2✔

9504

      *entity = NULL;

2✔

9505

      return ename;

2✔

9511

static void p_configuration_declaration(tree_t unit)

116✔

9516

   BEGIN("configuration declaration");

232✔

9518

   consume(tCONFIGURATION);

116✔

9520

   tree_change_kind(unit, T_CONFIGURATION);

116✔

9522

   ident_t id = p_identifier();

116✔

9523

   tree_set_ident(unit, id);

116✔

9525

   push_scope(nametab);

116✔

9527

   consume(tOF);

116✔

9529

   tree_t of = NULL;

116✔

9530

   ident_t ename = p_entity_name(&of);

116✔

9531

   tree_set_ident2(unit, ename);

116✔

9533

   if (of != NULL) {

116✔

9534

      tree_set_primary(unit, of);

115✔

9535

      insert_name(nametab, of, ename);

115✔

9536

      insert_decls(nametab, of);

115✔

9539

   consume(tIS);

116✔

9541

   while (not_at_token(tFOR))

122✔

9542

      p_configuration_declarative_part(unit);

6✔

9544

   tree_add_decl(unit, p_block_configuration(of));

116✔

9546

   consume(tEND);

116✔

9547

   optional(tCONFIGURATION);

116✔

9548

   p_trailing_label(id);

116✔

9549

   consume(tSEMI);

116✔

9551

   pop_scope(nametab);

116✔

9553

   tree_set_loc(unit, CURRENT_LOC);

116✔

9554

   sem_check(unit, nametab);

116✔

9556

   tree_set_ident(unit, ident_prefix(lib_name(lib_work()), id, '.'));

116✔

9557

116✔

9559

static void p_context_declaration(tree_t unit)

19✔

9564

   BEGIN("context declaration");

38✔

9566

   consume(tCONTEXT);

19✔

9568

   tree_change_kind(unit, T_CONTEXT);

19✔

9570

   ident_t id = p_identifier();

19✔

9571

   tree_set_ident(unit, ident_prefix(lib_name(lib_work()), id, '.'));

19✔

9573

   consume(tIS);

19✔

9575

   push_scope(nametab);

19✔

9578

   if (tree_contexts(unit) != 3)     // Implicit WORK and STD

19✔

9579

      parse_error(tree_loc(tree_context(unit, 3)), "context clause preceeding "

1✔

9582

   p_context_clause(unit);

19✔

9584

   consume(tEND);

19✔

9585

   optional(tCONTEXT);

19✔

9586

   p_trailing_label(id);

19✔

9587

   consume(tSEMI);

19✔

9589

   tree_set_loc(unit, CURRENT_LOC);

19✔

9590

   sem_check(unit, nametab);

19✔

9592

   pop_scope(nametab);

19✔

9593

19✔

9595

static void p_primary_unit(tree_t unit)

6,896✔

9600

   BEGIN("primary unit");

13,792✔

9602

   switch (peek()) {

6,896✔

9603

   case tENTITY:

5,201✔

9604

      p_entity_declaration(unit);

5,201✔

9605

      break;

5,201✔

9607

   case tPACKAGE:

1,560✔

9608

      if (standard() >= STD_08 && peek_nth(4) == tNEW)

1,560✔

9609

         p_package_instantiation_declaration(unit);

76✔

9611

         p_package_declaration(unit);

1,484✔

9614

   case tCONFIGURATION:

116✔

9615

      p_configuration_declaration(unit);

116✔

9616

      break;

116✔

9618

   case tCONTEXT:

19✔

9619

      p_context_declaration(unit);

19✔

9620

      break;

19✔

9625

6,896✔

9627

static void p_block_declarative_item(tree_t parent)

12,881✔

9640

   BEGIN("block declarative item");

25,762✔

9642

   switch (peek()) {

12,881✔

9643

   case tSIGNAL:

5,442✔

9644

      p_signal_declaration(parent);

5,442✔

9645

      break;

5,442✔

9647

   case tTYPE:

2,482✔

9648

      p_type_declaration(parent);

2,482✔

9649

      break;

2,482✔

9651

   case tSUBTYPE:

449✔

9652

      tree_add_decl(parent, p_subtype_declaration());

449✔

9653

      break;

449✔

9655

   case tFILE:

32✔

9656

      p_file_declaration(parent);

32✔

9657

      break;

32✔

9659

   case tCONSTANT:

1,484✔

9660

      p_constant_declaration(parent);

1,484✔

9661

      break;

1,484✔

9663

   case tFUNCTION:

1,885✔

9667

      if (peek_nth(3) == tIS && peek_nth(4) == tNEW)

1,885✔

9668

         tree_add_decl(parent, p_subprogram_instantiation_declaration());

49✔

9670

         tree_t spec = p_subprogram_specification();

1,836✔

9671

         if (peek() == tSEMI)

1,836✔

9672

            tree_add_decl(parent, p_subprogram_declaration(spec));

161✔

9674

            tree_add_decl(parent, p_subprogram_body(spec));

1,675✔

9678

   case tALIAS:

142✔

9679

      p_alias_declaration(parent);

142✔

9680

      break;

142✔

9682

   case tATTRIBUTE:

101✔

9683

      if (peek_nth(3) == tOF)

101✔

9684

         p_attribute_specification(parent);

87✔

9686

         tree_add_decl(parent, p_attribute_declaration());

14✔

9689

   case tFOR:

102✔

9690

      p_configuration_specification(parent);

102✔

9691

      break;

102✔

9693

   case tCOMPONENT:

320✔

9694

      tree_add_decl(parent, p_component_declaration());

320✔

9695

      break;

320✔

9697

   case tUSE:

44✔

9698

      p_use_clause(parent, tree_add_decl);

44✔

9699

      break;

44✔

9701

   case tSHARED:

123✔

9702

      p_variable_declaration(parent);

123✔

9703

      break;

123✔

9705

   case tDISCONNECT:

13✔

9706

      p_disconnection_specification(parent);

13✔

9707

      break;

13✔

9709

   case tGROUP:

2✔

9710

      if (peek_nth(3) == tIS)

2✔

9711

         tree_add_decl(parent, p_group_template_declaration());

1✔

9713

         tree_add_decl(parent, p_group_declaration());

1✔

9716

   case tPACKAGE:

179✔

9717

      if (peek_nth(4) == tNEW)

179✔

9718

         tree_add_decl(parent, p_package_instantiation_declaration(NULL));

175✔

9719

      else if (peek_nth(2) == tBODY) {

4✔

9724

         require_std(STD_08, "nested package declarations");

4✔

9725

         tree_add_decl(parent, p_package_declaration(NULL));

4✔

9729

   case tSTARTPSL:

35✔

9730

      consume(tSTARTPSL);

35✔

9731

      p_psl_declaration(parent);

35✔

9732

      break;

35✔

9734

   case tDEFAULT:

22✔

9738

      p_psl_declaration(parent);

22✔

9739

      break;

22✔

9741

   case tVIEW:

17✔

9742

      tree_add_decl(parent, p_mode_view_declaration());

17✔

9743

      break;

17✔

9745

   default:

7✔

9746

      expect(tSIGNAL, tTYPE, tSUBTYPE, tFILE, tCONSTANT, tFUNCTION, tIMPURE,

21✔

9750

12,881✔

9752

static tree_t p_target(tree_t name)

24,164✔

9756

   BEGIN("target");

48,328✔

9758

   if (name == NULL) {

24,164✔

9759

      if (peek() == tLPAREN)

77✔

9760

         return p_aggregate();

23✔

9762

         return p_name(0);

54✔

9768

static tree_t p_simple_variable_assignment(ident_t label, tree_t name)

16,523✔

9773

   EXTEND("simple variable assignment");

16,523✔

9775

   tree_t target = p_target(name);

16,523✔

9777

   consume(tWALRUS);

16,523✔

9779

   tree_t value = p_conditional_or_unaffected_expression(STD_08);

16,523✔

9781

   solve_target(nametab, target, value);

16,523✔

9782

   solve_known_subtype(nametab, value, target);

16,523✔

9784

   tree_t t = tree_new(T_VAR_ASSIGN);

16,523✔

9785

   tree_set_target(t, target);

16,523✔

9786

   tree_set_value(t, value);

16,523✔

9788

   consume(tSEMI);

16,523✔

9790

   tree_set_loc(t, CURRENT_LOC);

16,523✔

9791

   ensure_labelled(t, label);

16,523✔

9793

   sem_check(t, nametab);

16,523✔

9794

   return t;

16,523✔

9797

static void p_selected_expressions(tree_t stmt, tree_t target)

9✔

9801

   BEGIN("selected waveforms");

18✔

9803

   type_t with_type = tree_type(tree_value(stmt));

9✔

9805

   do {

24✔

9806

      tree_t expr = p_expression();

24✔

9808

      if (!tree_has_type(target))

24✔

9809

         solve_target(nametab, target, expr);

9✔

9811

      solve_known_subtype(nametab, expr, target);

24✔

9813

      tree_t a = tree_new(T_VAR_ASSIGN);

24✔

9814

      tree_set_target(a, target);

24✔

9815

      tree_set_value(a, expr);

24✔

9817

      sem_check(a, nametab);

24✔

9819

      consume(tWHEN);

24✔

9821

      tree_t alt = tree_new(T_ALTERNATIVE);

24✔

9822

      tree_add_stmt(alt, a);

24✔

9824

      p_choices(alt, NULL, with_type);

24✔

9826

      tree_set_loc(alt, CURRENT_LOC);

24✔

9827

      tree_add_stmt(stmt, alt);

24✔

9828

   } while (optional(tCOMMA));

24✔

9829

9✔

9831

static tree_t p_selected_variable_assignment(ident_t label)

12✔

9835

   BEGIN("selected variable assignment");

12✔

9837

   require_std(STD_08, "selected variable assignment");

12✔

9839

   consume(tWITH);

12✔

9841

   tree_t value = p_expression();

12✔

9842

   solve_types(nametab, value, NULL);

12✔

9844

   consume(tSELECT);

12✔

9846

   tree_kind_t kind = T_SELECT;

12✔

9847

   if (optional(tQUESTION))

12✔

9848

      kind = T_MATCH_SELECT;

6✔

9850

   tree_t t = tree_new(kind);

12✔

9851

   tree_set_value(t, value);

12✔

9853

   tree_t target = p_target(NULL);

12✔

9857

   switch (one_of(tWALRUS, tLE)) {

12✔

9858

   case tLE:

3✔

9859

      p_selected_waveforms(t, target, NULL);

3✔

9860

      break;

3✔

9862

   case tWALRUS:

9✔

9864

      p_selected_expressions(t, target);

9✔

9865

      break;

9✔

9868

   consume(tSEMI);

12✔

9870

   tree_set_loc(t, CURRENT_LOC);

12✔

9871

   ensure_labelled(t, label);

12✔

9873

   sem_check(t, nametab);

12✔

9874

   return t;

12✔

9877

static tree_t p_variable_assignment_statement(ident_t label, tree_t name)

16,535✔

9883

   EXTEND("variable assignment statement");

33,070✔

9885

   if (name == NULL && peek() == tWITH)

16,535✔

9886

      return p_selected_variable_assignment(label);

12✔

9888

      return p_simple_variable_assignment(label, name);

16,523✔

9891

static tree_t p_waveform_element(tree_t target)

8,113✔

9895

   BEGIN("waveform element");

8,113✔

9897

   tree_t w = tree_new(T_WAVEFORM);

8,113✔

9899

   if (!optional(tNULL)) {

8,113✔

9900

      tree_t value = p_expression();

8,096✔

9901

      tree_set_value(w, value);

8,096✔

9903

      if (!tree_has_type(target))

8,096✔

9904

         solve_target(nametab, target, value);

7,494✔

9906

      solve_known_subtype(nametab, value, target);

8,096✔

9908

   else if (!tree_has_type(target))

17✔

9909

      solve_types(nametab, target, NULL);

16✔

9911

   if (optional(tAFTER)) {

8,113✔

9912

      tree_t delay = p_expression();

909✔

9913

      tree_set_delay(w, delay);

909✔

9914

      solve_types(nametab, delay, std_type(NULL, STD_TIME));

909✔

9917

   tree_set_loc(w, CURRENT_LOC);

8,113✔

9919

   return w;

8,113✔

9922

static void p_waveform(tree_t stmt, tree_t target)

7,877✔

9926

   BEGIN("waveform");

15,748✔

9928

   if (optional(tUNAFFECTED)) {

7,877✔

9929

      solve_types(nametab, target, NULL);

6✔

9930

      return;

6✔

9933

   do {

8,113✔

9934

      tree_add_waveform(stmt, p_waveform_element(target));

8,113✔

9935

   } while (optional(tCOMMA));

8,113✔

9937

   tree_set_loc(stmt, CURRENT_LOC);

7,871✔

9940

static tree_t p_delay_mechanism(void)

7,522✔

9944

   BEGIN("delay mechanism");

15,044✔

9946

   switch (peek()) {

7,522✔

9947

   case tTRANSPORT:

66✔

9948

      consume(tTRANSPORT);

66✔

9949

      return get_time(0, CURRENT_LOC);

66✔

9951

   case tREJECT:

12✔

9953

         consume(tREJECT);

12✔

9954

         tree_t t = p_expression();

12✔

9955

         consume(tINERTIAL);

12✔

9956

         return t;

12✔

9959

   case tINERTIAL:

1✔

9960

      consume(tINERTIAL);

1✔

9961

      return NULL;

1✔

9968

static port_mode_t p_force_mode(void)

107✔

9972

   BEGIN("force mode");

214✔

9974

   switch (peek()) {

107✔

9975

   case tIN: consume(tIN); return PORT_IN;

4✔

9976

   case tOUT: consume(tOUT); return PORT_OUT;

7✔

9981

static tree_t p_simple_force_assignment(ident_t label, tree_t target)

68✔

9985

   EXTEND("simple force assignment");

68✔

9987

   consume(tFORCE);

68✔

9989

   require_std(STD_08, "simple force assignments");

68✔

9991

   type_t target_type;

68✔

9992

   if (tree_kind(target) == T_AGGREGATE) {

68✔

9993

      parse_error(CURRENT_LOC, "target of a simple force assignment may "

1✔

9995

      target_type = type_new(T_NONE);

1✔

9998

      target_type = solve_types(nametab, target, NULL);

67✔

10000

   tree_set_type(target, target_type);

68✔

10002

   tree_t t = tree_new(T_FORCE);

68✔

10003

   tree_set_target(t, target);

68✔

10004

   tree_set_subkind(t, p_force_mode());

68✔

10006

   tree_t expr = p_conditional_or_unaffected_expression(STD_08);

68✔

10007

   solve_types(nametab, expr, target_type);

68✔

10009

   tree_set_value(t, expr);

68✔

10011

   consume(tSEMI);

68✔

10013

   set_label_and_loc(t, label, CURRENT_LOC);

68✔

10014

   sem_check(t, nametab);

68✔

10015

   return t;

68✔

10018

static tree_t p_simple_release_assignment(ident_t label, tree_t target)

39✔

10022

   EXTEND("simple force assignment");

39✔

10024

   consume(tRELEASE);

39✔

10026

   require_std(STD_08, "simple release assignments");

39✔

10028

   type_t target_type;

39✔

10029

   if (tree_kind(target) == T_AGGREGATE) {

39✔

10030

      parse_error(CURRENT_LOC, "target of a simple release assignment may "

1✔

10032

      target_type = type_new(T_NONE);

1✔

10035

      target_type = solve_types(nametab, target, NULL);

38✔

10037

   tree_set_type(target, target_type);

39✔

10039

   tree_t t = tree_new(T_RELEASE);

39✔

10040

   tree_set_target(t, target);

39✔

10041

   tree_set_subkind(t, p_force_mode());

39✔

10043

   consume(tSEMI);

39✔

10045

   set_label_and_loc(t, label, CURRENT_LOC);

39✔

10046

   sem_check(t, nametab);

39✔

10047

   return t;

39✔

10050

static tree_t p_signal_assignment_statement(ident_t label, tree_t name)

5,324✔

10054

   EXTEND("signal assignment statement");

10,648✔

10056

   tree_t target = p_target(name);

5,324✔

10058

   consume(tLE);

5,324✔

10060

   switch (peek()) {

5,324✔

10061

   case tFORCE: return p_simple_force_assignment(label, target);

68✔

10062

   case tRELEASE: return p_simple_release_assignment(label, target);

39✔

10063

   default: break;

5,217✔

10067

   tree_t t = tree_new(T_SIGNAL_ASSIGN);

5,217✔

10068

   tree_set_target(t, target);

5,217✔

10070

   tree_t reject = p_delay_mechanism();

5,217✔

10072

   p_waveform(t, target);

5,217✔

10074

   if (peek() == tWHEN) {

5,217✔

10075

      require_std(STD_08, "conditional signal assignment statements");

5✔

10077

      tree_t stmt = tree_new(T_COND_ASSIGN);

5✔

10078

      tree_set_target(stmt, target);

5✔

10080

      p_conditional_waveforms(stmt, target, t);

5✔

10082

      const int nconds = tree_conds(stmt);

5✔

10083

      for (int i = 0; i < nconds; i++) {

15✔

10084

         tree_t c = tree_cond(stmt, i);

10✔

10085

         assert(tree_stmts(c) == 1);

10✔

10086

         set_delay_mechanism(tree_stmt(c, 0), reject);

10✔

10092

      set_delay_mechanism(t, reject);

5,212✔

10094

   consume(tSEMI);

5,217✔

10096

   set_label_and_loc(t, label, CURRENT_LOC);

5,217✔

10097

   sem_check(t, nametab);

5,217✔

10098

   return t;

5,217✔

10101

static void p_sensitivity_clause(tree_t wait)

361✔

10105

   BEGIN("sensitivity clause");

722✔

10107

   consume(tON);

361✔

10108

   p_sensitivity_list(wait);

361✔

10109

361✔

10111

static void p_condition_clause(tree_t wait)

306✔

10115

   BEGIN("condition clause");

612✔

10117

   consume(tUNTIL);

306✔

10119

   tree_set_value(wait, p_condition());

306✔

10120

306✔

10122

static void p_timeout_clause(tree_t wait)

5,317✔

10126

   BEGIN("timeout clause");

10,634✔

10128

   consume(tFOR);

5,317✔

10130

   tree_t delay = p_expression();

5,317✔

10131

   tree_set_delay(wait, delay);

5,317✔

10132

   solve_types(nametab, delay, std_type(NULL, STD_TIME));

5,317✔

10133

5,317✔

10135

static tree_t p_wait_statement(ident_t label)

9,917✔

10140

   EXTEND("wait statement");

9,917✔

10142

   tree_t t = tree_new(T_WAIT);

9,917✔

10144

   consume(tWAIT);

9,917✔

10146

   if (peek() == tON)

9,917✔

10147

      p_sensitivity_clause(t);

361✔

10149

   if (peek() == tUNTIL)

9,917✔

10150

      p_condition_clause(t);

306✔

10152

   if (peek() == tFOR)

9,917✔

10153

      p_timeout_clause(t);

5,317✔

10155

   consume(tSEMI);

9,917✔

10157

   set_label_and_loc(t, label, CURRENT_LOC);

9,917✔

10158

   sem_check(t, nametab);

9,917✔

10159

   return t;

9,917✔

10162

static tree_t p_assertion_statement(ident_t label)

16,623✔

10166

   EXTEND("assertion statement");

16,623✔

10168

   tree_t t = p_assertion();

16,623✔

10169

   consume(tSEMI);

16,623✔

10171

   set_label_and_loc(t, label, CURRENT_LOC);

16,623✔

10172

   sem_check(t, nametab);

16,623✔

10173

   return t;

16,623✔

10176

static tree_t p_report_statement(ident_t label)

2,135✔

10180

   EXTEND("report statement");

2,135✔

10182

   tree_t t = tree_new(T_REPORT);

2,135✔

10184

   consume(tREPORT);

2,135✔

10186

   tree_t m = p_expression();

2,135✔

10187

   tree_set_message(t, m);

2,135✔

10188

   solve_types(nametab, m, std_type(NULL, STD_STRING));

2,135✔

10190

   if (optional(tSEVERITY)) {

2,135✔

10191

      tree_t s = p_expression();

458✔

10192

      solve_types(nametab, s, std_type(NULL, STD_SEVERITY_LEVEL));

458✔

10193

      tree_set_severity(t, s);

458✔

10196

   consume(tSEMI);

2,135✔

10198

   set_label_and_loc(t, label, CURRENT_LOC);

2,135✔

10199

   sem_check(t, nametab);

2,135✔

10200

   return t;

2,135✔

10203

static tree_t p_if_statement(ident_t label)

8,638✔

10209

   EXTEND("if statement");

8,638✔

10211

   tree_t t = tree_new(T_IF);

8,638✔

10212

   consume(tIF);

8,638✔

10214

   tree_t c0 = tree_new(T_COND_STMT);

8,638✔

10215

   tree_set_value(c0, p_condition());

8,638✔

10216

   tree_add_cond(t, c0);

8,638✔

10218

   consume(tTHEN);

8,638✔

10220

   p_sequence_of_statements(c0);

8,638✔

10222

   tree_set_loc(c0, CURRENT_LOC);

8,638✔

10224

   while (optional(tELSIF)) {

9,519✔

10225

      tree_t c = tree_new(T_COND_STMT);

881✔

10226

      tree_set_value(c, p_condition());

881✔

10227

      tree_add_cond(t, c);

881✔

10229

      consume(tTHEN);

881✔

10231

      p_sequence_of_statements(c);

881✔

10233

      tree_set_loc(c, CURRENT_LOC);

881✔

10236

   if (optional(tELSE)) {

8,638✔

10237

      tree_t c = tree_new(T_COND_STMT);

2,343✔

10238

      tree_add_cond(t, c);

2,343✔

10240

      p_sequence_of_statements(c);

2,343✔

10242

      tree_set_loc(c, CURRENT_LOC);

2,343✔

10245

   consume(tEND);

8,638✔

10246

   consume(tIF);

8,638✔

10247

   p_trailing_label(label);

8,638✔

10248

   consume(tSEMI);

8,638✔

10250

   set_label_and_loc(t, label, CURRENT_LOC);

8,638✔

10251

   sem_check(t, nametab);

8,638✔

10252

   return t;

8,638✔

10255

static tree_t p_null_statement(ident_t label)

226✔

10259

   EXTEND("null statement");

226✔

10261

   consume(tNULL);

226✔

10262

   consume(tSEMI);

226✔

10264

   tree_t t = tree_new(T_NULL);

226✔

10265

   set_label_and_loc(t, label, CURRENT_LOC);

226✔

10266

   return t;

226✔

10269

static void p_parameter_specification(tree_t loop, tree_kind_t pkind)

2,685✔

10273

   BEGIN("paremeter specification");

5,370✔

10275

   ident_t id = p_identifier();

2,685✔

10276

   const loc_t id_loc = last_loc;

2,685✔

10278

   consume(tIN);

2,685✔

10280

   tree_t r = p_discrete_range(NULL);

2,685✔

10281

   solve_types(nametab, r, NULL);

2,685✔

10282

   convert_universal_bounds(r);

2,685✔

10283

   tree_add_range(loop, r);

2,685✔

10287

   type_t base = type_base_recur(tree_type(r));

2,685✔

10289

   tree_t constraint = tree_new(T_CONSTRAINT);

2,685✔

10290

   tree_set_subkind(constraint, C_RANGE);

2,685✔

10291

   tree_add_range(constraint, r);

2,685✔

10293

   type_t sub = type_new(T_SUBTYPE);

2,685✔

10294

   type_set_base(sub, base);

2,685✔

10295

   type_set_constraint(sub, constraint);

2,685✔

10297

   tree_t param = tree_new(pkind);

2,685✔

10298

   tree_set_ident(param, id);

2,685✔

10299

   tree_set_type(param, sub);

2,685✔

10300

   tree_set_loc(param, &id_loc);

2,685✔

10301

   tree_set_class(param, C_CONSTANT);

2,685✔

10302

   tree_set_subkind(param, PORT_IN);

2,685✔

10304

   tree_add_decl(loop, param);

2,685✔

10306

   insert_name(nametab, param, NULL);

2,685✔

10307

2,685✔

10309

static tree_t p_iteration_scheme(void)

2,978✔

10313

   BEGIN("iteration scheme");

5,956✔

10315

   if (optional(tWHILE)) {

2,978✔

10316

      tree_t t = tree_new(T_WHILE);

204✔

10317

      tree_set_value(t, p_condition());

204✔

10318

      return t;

204✔

10320

   else if (optional(tFOR)) {

2,774✔

10321

      tree_t t = tree_new(T_FOR);

2,507✔

10322

      scope_set_container(nametab, t);

2,507✔

10323

      p_parameter_specification(t, T_PARAM_DECL);

2,507✔

10324

      return t;

2,507✔

10327

      return tree_new(T_LOOP);

267✔

10330

static tree_t p_loop_statement(ident_t label)

2,978✔

10335

   BEGIN("loop statement");

2,978✔

10337

   push_scope(nametab);

2,978✔

10339

   tree_t t = p_iteration_scheme();

2,978✔

10341

   consume(tLOOP);

2,978✔

10343

   scope_set_container(nametab, t);

2,978✔

10344

   set_label_and_loc(t, label, CURRENT_LOC);

2,978✔

10346

   if (label != NULL)

2,978✔

10347

      insert_name(nametab, t, NULL);

110✔

10349

   sem_check(t, nametab);

2,978✔

10351

   p_sequence_of_statements(t);

2,978✔

10353

   consume(tEND);

2,978✔

10354

   consume(tLOOP);

2,978✔

10355

   p_trailing_label(label);

2,978✔

10356

   consume(tSEMI);

2,978✔

10358

   pop_scope(nametab);

2,978✔

10360

   tree_set_loc(t, CURRENT_LOC);

2,978✔

10361

   return t;

2,978✔

10364

static tree_t p_return_statement(ident_t label)

13,082✔

10370

   EXTEND("return statement");

13,082✔

10372

   consume(tRETURN);

13,082✔

10374

   tree_t stmt = NULL;

13,082✔

10376

   if (optional(tWHEN)) {

13,082✔

10377

      require_std(STD_19, "conditional return statement");

7✔

10379

      stmt = tree_new(T_COND_RETURN);

7✔

10380

      tree_set_value(stmt, p_condition());

7✔

10383

      stmt = tree_new(T_RETURN);

13,075✔

10385

      if (peek() != tSEMI) {

13,075✔

10386

         type_t return_type = NULL;

12,730✔

10387

         tree_t subprog = find_enclosing(nametab, S_SUBPROGRAM);

12,730✔

10388

         if (subprog != NULL && tree_kind(subprog) == T_FUNC_BODY) {

12,730✔

10389

            return_type = type_result(tree_type(subprog));

12,726✔

10390

            tree_set_type(stmt, return_type);

12,726✔

10393

         tree_t value = p_conditional_or_unaffected_expression(STD_19);

12,730✔

10394

         solve_types(nametab, value, return_type);

12,730✔

10395

         tree_set_value(stmt, value);

12,730✔

10399

   consume(tSEMI);

13,082✔

10401

   set_label_and_loc(stmt, label, CURRENT_LOC);

13,082✔

10402

   sem_check(stmt, nametab);

13,082✔

10403

   return stmt;

13,082✔

10406

static tree_t p_exit_statement(ident_t label)

319✔

10410

   EXTEND("exit statement");

319✔

10412

   consume(tEXIT);

319✔

10414

   tree_t t = tree_new(T_EXIT);

319✔

10416

   if (peek() == tID) {

319✔

10417

      ident_t id = p_identifier();

38✔

10418

      tree_set_ident2(t, id);

38✔

10420

      tree_t loop = resolve_name(nametab, CURRENT_LOC, id);

38✔

10421

      if (loop != NULL && !is_loop_stmt(loop))

38✔

10425

      tree_t loop = find_enclosing(nametab, S_LOOP);

281✔

10426

      if (loop == NULL)

281✔

10427

         parse_error(CURRENT_LOC, "cannot use exit statement outside loop");

2✔

10429

         tree_set_ident2(t, tree_ident(loop));

279✔

10432

   if (optional(tWHEN))

319✔

10433

      tree_set_value(t, p_condition());

129✔

10435

   consume(tSEMI);

319✔

10437

   set_label_and_loc(t, label, CURRENT_LOC);

319✔

10438

   sem_check(t, nametab);

319✔

10439

   return t;

319✔

10442

static tree_t p_next_statement(ident_t label)

96✔

10446

   EXTEND("next statement");

96✔

10448

   consume(tNEXT);

96✔

10450

   tree_t t = tree_new(T_NEXT);

96✔

10452

   if (peek() == tID) {

96✔

10453

      ident_t id = p_identifier();

2✔

10454

      tree_set_ident2(t, id);

2✔

10456

      tree_t loop = resolve_name(nametab, CURRENT_LOC, id);

2✔

10457

      if (loop != NULL && !is_loop_stmt(loop))

2✔

10461

      tree_t loop = find_enclosing(nametab, S_LOOP);

94✔

10462

      if (loop == NULL)

94✔

10463

         parse_error(CURRENT_LOC, "cannot use next statement outside loop");

3✔

10465

         tree_set_ident2(t, tree_ident(loop));

91✔

10468

   if (optional(tWHEN))

96✔

10469

      tree_set_value(t, p_condition());

63✔

10471

   consume(tSEMI);

96✔

10473

   set_label_and_loc(t, label, CURRENT_LOC);

96✔

10474

   sem_check(t, nametab);

96✔

10475

   return t;

96✔

10478

static tree_t p_procedure_call_statement(ident_t label, tree_t name)

7,988✔

10485

   EXTEND("procedure call statement");

15,973✔

10487

   tree_t call = NULL;

7,988✔

10489

   switch (tree_kind(name)) {

7,988✔

10490

   case T_REF:

7,788✔

10491

      call = tree_new(T_PCALL);

7,788✔

10492

      tree_set_ident2(call, tree_ident(name));

7,788✔

10493

      break;

7,788✔

10495

   case T_PROT_REF:

190✔

10496

      call = tree_new(T_PROT_PCALL);

190✔

10497

      tree_set_ident2(call, tree_ident(name));

190✔

10498

      tree_set_name(call, tree_value(name));

190✔

10499

      break;

190✔

10501

   default:

10✔

10503

      if (!type_is_none(solve_types(nametab, name, NULL)))

10✔

10504

         parse_error(CURRENT_LOC, "expected procedure name");

5✔

10506

      call = tree_new(T_PCALL);

7✔

10507

      tree_set_ident2(call, error_marker());

7✔

10508

      set_label_and_loc(call, label, CURRENT_LOC);

7✔

10509

      drop_tokens_until(tSEMI);

7✔

10510

      return call;

7✔

10513

   if (peek() == tGENERIC) {

7,978✔

10514

      ident_t id = tree_ident(name);

19✔

10515

      tree_t inst = tree_new(T_PROC_INST);

19✔

10516

      tree_set_ident(inst, ident_prefix(id, ident_uniq("inst"), '$'));

19✔

10518

      tree_t decl = resolve_uninstantiated_subprogram(nametab, CURRENT_LOC,

19✔

10520

      if (decl != NULL) {

19✔

10521

         tree_t body = find_generic_subprogram_body(inst, decl);

19✔

10522

         instantiate_subprogram(inst, decl, body);

19✔

10532

      p_generic_map_aspect(inst, inst);

19✔

10534

      require_std(STD_19, "generic map on procedure call");

19✔

10536

      tree_set_loc(inst, CURRENT_LOC);

19✔

10537

      sem_check(inst, nametab);

19✔

10539

      hash_t *map = get_generic_map(nametab);

19✔

10540

      if (map != NULL)

19✔

10541

         instance_fixup(inst, map);

19✔

10543

      tree_set_ref(call, inst);

19✔

10545

      mangle_func(nametab, inst);

19✔

10547

      tree_t container = find_enclosing(nametab, S_DECLARATIVE_REGION);

19✔

10548

      tree_add_decl(container, inst);

19✔

10551

   if (peek() == tPARAMETER)

7,978✔

10552

      p_parameter_map_aspect(call);

1✔

10553

   else if (optional(tLPAREN)) {

7,977✔

10554

      p_actual_parameter_part(call);

7,545✔

10555

      consume(tRPAREN);

7,545✔

10558

   consume(tSEMI);

7,978✔

10560

   set_label_and_loc(call, label, CURRENT_LOC);

7,978✔

10562

   solve_types(nametab, call, NULL);

7,978✔

10563

   sem_check(call, nametab);

7,978✔

10564

   return call;

7,978✔

10567

static tree_t p_case_statement_alternative(type_t type)

2,569✔

10571

   BEGIN("case statement alternative");

2,569✔

10573

   consume(tWHEN);

2,569✔

10575

   tree_t alt = tree_new(T_ALTERNATIVE);

2,569✔

10577

   p_choices(alt, NULL, type);

2,569✔

10579

   consume(tASSOC);

2,569✔

10581

   p_sequence_of_statements(alt);

2,569✔

10583

   tree_set_loc(alt, CURRENT_LOC);

2,569✔

10584

   return alt;

2,569✔

10587

static tree_t p_case_statement(ident_t label)

556✔

10592

   EXTEND("case statement");

556✔

10594

   consume(tCASE);

556✔

10596

   tree_kind_t kind = T_CASE;

556✔

10597

   if (optional(tQUESTION)) {

556✔

10598

      require_std(STD_08, "matching case statements");

28✔

10599

      kind = T_MATCH_CASE;

28✔

10602

   tree_t t = tree_new(kind);

556✔

10604

   tree_t value = p_expression();

556✔

10605

   tree_set_value(t, value);

556✔

10607

   type_t type = solve_types(nametab, value, NULL);

556✔

10609

   consume(tIS);

556✔

10611

   do {

2,569✔

10612

      tree_add_stmt(t, p_case_statement_alternative(type));

2,569✔

10613

   } while (peek() == tWHEN);

2,569✔

10615

   consume(tEND);

556✔

10616

   consume(tCASE);

556✔

10618

   if (kind == T_MATCH_CASE)

556✔

10619

      consume(tQUESTION);

28✔

10621

   p_trailing_label(label);

556✔

10622

   consume(tSEMI);

556✔

10624

   set_label_and_loc(t, label, CURRENT_LOC);

556✔

10625

   sem_check(t, nametab);

556✔

10626

   return t;

556✔

10629

static void p_sequential_block_declarative_part(tree_t block)

8✔

10633

   BEGIN("sequential block declarative part");

16✔

10635

   while (not_at_token(tBEGIN))

21✔

10636

      p_process_declarative_item(block);

13✔

10637

8✔

10639

static void p_sequential_block_statement_part(tree_t block)

8✔

10643

   BEGIN("sequential block statement part");

16✔

10645

   p_sequence_of_statements(block);

8✔

10646

8✔

10648

static tree_t p_sequential_block_statement(ident_t label)

8✔

10653

   BEGIN("sequential block statement");

8✔

10655

   consume(tBLOCK);

8✔

10656

   optional(tIS);

8✔

10658

   require_std(STD_19, "sequential block statements");

8✔

10660

   push_scope(nametab);

8✔

10662

   tree_t t = tree_new(T_SEQUENCE);

8✔

10664

   scope_set_container(nametab, t);

8✔

10665

   set_label_and_loc(t, label, CURRENT_LOC);

8✔

10667

   p_sequential_block_declarative_part(t);

8✔

10669

   consume(tBEGIN);

8✔

10671

   p_sequential_block_statement_part(t);

8✔

10673

   consume(tEND);

8✔

10674

   optional(tBLOCK);

8✔

10676

   p_trailing_label(label);

8✔

10677

   consume(tSEMI);

8✔

10679

   tree_set_loc(t, CURRENT_LOC);

8✔

10680

   sem_check(t, nametab);

8✔

10681

   pop_scope(nametab);

8✔

10683

   return t;

8✔

10686

static tree_t p_sequential_statement(void)

84,427✔

10694

   BEGIN("sequential statement");

168,851✔

10696

   ident_t label = NULL;

84,427✔

10697

   if ((peek() == tID) && (peek_nth(2) == tCOLON)) {

84,427✔

10698

      label = p_identifier();

378✔

10699

      consume(tCOLON);

378✔

10702

   switch (peek()) {

84,427✔

10703

   case tWAIT:

9,917✔

10704

      return p_wait_statement(label);

9,917✔

10706

   case tASSERT:

16,623✔

10707

      return p_assertion_statement(label);

16,623✔

10709

   case tREPORT:

2,135✔

10710

      return p_report_statement(label);

2,135✔

10712

   case tIF:

8,638✔

10713

      return p_if_statement(label);

8,638✔

10715

   case tNULL:

226✔

10716

      return p_null_statement(label);

226✔

10718

   case tRETURN:

13,082✔

10719

      return p_return_statement(label);

13,082✔

10721

   case tCASE:

556✔

10722

      return p_case_statement(label);

556✔

10724

   case tWHILE:

2,978✔

10727

      return p_loop_statement(label);

2,978✔

10729

   case tEXIT:

319✔

10730

      return p_exit_statement(label);

319✔

10732

   case tNEXT:

96✔

10733

      return p_next_statement(label);

96✔

10735

   case tWITH:

12✔

10736

      return p_variable_assignment_statement(label, NULL);

12✔

10740

      break;

29,727✔

10742

   case tLPAREN:

109✔

10744

         tree_t agg = p_aggregate();

109✔

10746

         switch (peek()) {

109✔

10747

         case tWALRUS:

56✔

10748

            return p_variable_assignment_statement(label, agg);

56✔

10750

         case tLE:

53✔

10751

            return p_signal_assignment_statement(label, agg);

53✔

10759

   case tBLOCK:

8✔

10760

      return p_sequential_block_statement(label);

8✔

10762

   default:

1✔

10763

      expect(tWAIT, tID, tASSERT, tREPORT, tIF, tNULL, tRETURN, tCASE, tWHILE,

1✔

10765

      drop_tokens_until(tSEMI);

1✔

10766

      return tree_new(T_NULL);

1✔

10769

   tree_t name = p_name(N_SUBPROGRAM);

29,727✔

10771

   switch (peek()) {

29,727✔

10772

   case tWALRUS:

16,467✔

10773

      return p_variable_assignment_statement(label, name);

16,467✔

10775

   case tLE:

5,271✔

10776

      return p_signal_assignment_statement(label, name);

5,271✔

10778

   case tSEMI:

7,988✔

10782

      return p_procedure_call_statement(label, name);

7,988✔

10784

   default:

1✔

10785

      expect(tWALRUS, tLE, tSEMI);

1✔

10786

      drop_tokens_until(tSEMI);

1✔

10787

      return tree_new(T_NULL);

1✔

10791

static tree_t p_instantiated_unit(tree_t name)

1,569✔

10797

   BEGIN("instantiated unit");

1,569✔

10799

   tree_t t = tree_new(T_INSTANCE);

1,569✔

10801

   switch (peek()) {

1,569✔

10802

   case tENTITY:

1,071✔

10803

      consume(tENTITY);

1,071✔

10804

      tree_set_class(t, C_ENTITY);

1,071✔

10805

      break;

1,071✔

10807

   case tCONFIGURATION:

14✔

10808

      consume(tCONFIGURATION);

14✔

10809

      tree_set_class(t, C_CONFIGURATION);

14✔

10810

      break;

14✔

10812

   case tCOMPONENT:

253✔

10813

      consume(tCOMPONENT);

253✔

10816

   default:

484✔

10817

      tree_set_class(t, C_COMPONENT);

484✔

10820

   if (name != NULL) {

1,569✔

10821

      if (tree_kind(name) == T_REF) {

3✔

10822

         tree_set_ident2(t, tree_ident(name));

2✔

10823

         if (tree_has_ref(name))

2✔

10824

            tree_set_ref(t, tree_ref(name));

2✔

10827

         parse_error(tree_loc(name), "invalid instantiated unit name");

1✔

10828

         tree_set_ident2(t, error_marker());

1✔

10832

      tree_set_ident2(t, p_selected_identifier());

1,566✔

10834

   if ((tree_class(t) == C_ENTITY) && optional(tLPAREN)) {

1,569✔

10835

      tree_set_ident2(t, ident_prefix(tree_ident2(t), p_identifier(), '-'));

68✔

10836

      consume(tRPAREN);

68✔

10839

   tree_set_loc(t, CURRENT_LOC);

1,569✔

10840

   return t;

1,569✔

10843

static tree_t p_component_instantiation_statement(ident_t label, tree_t name)

1,569✔

10847

   EXTEND("component instantiation statement");

1,569✔

10849

   tree_t t = p_instantiated_unit(name);

1,569✔

10850

   tree_set_ident(t, label);

1,569✔

10851

   tree_set_loc(t, CURRENT_LOC);

1,569✔

10853

   tree_t ref = find_binding(t);

1,569✔

10854

   tree_set_ref(t, ref);

1,569✔

10856

   tree_t entity = ref ? primary_unit_of(ref) : NULL;

1,569✔

10858

   tree_t spec = query_spec(nametab, t);

1,569✔

10859

   if (spec != NULL)

1,569✔

10860

      tree_set_spec(t, spec);

102✔

10862

   if (label != NULL)

1,569✔

10863

      insert_name(nametab, t, NULL);

1,567✔

10865

   push_scope(nametab);

1,569✔

10867

   if (ref == NULL) suppress_errors(nametab);

1,569✔

10869

   if (peek() == tGENERIC)

1,569✔

10870

      p_generic_map_aspect(t, entity);

627✔

10872

   if (peek() == tPORT)

1,569✔

10873

      p_port_map_aspect(t, entity);

1,155✔

10875

   consume(tSEMI);

1,569✔

10877

   tree_set_loc(t, CURRENT_LOC);

1,569✔

10879

   if (label == NULL){

1,569✔

10880

      parse_error(CURRENT_LOC, "component instantiation statement must "

2✔

10882

      tree_set_ident(t, error_marker());

2✔

10885

   sem_check(t, nametab);

1,569✔

10886

   pop_scope(nametab);

1,569✔

10888

   return t;

1,569✔

10891

static void p_options(tree_t *reject, tree_t *guard)

2,305✔

10895

   BEGIN("options");

2,305✔

10897

   if (optional(tGUARDED)) {

2,305✔

10898

      tree_t decl = NULL;

24✔

10899

      name_mask_t mask = query_name(nametab, ident_new("GUARD"), &decl);

24✔

10900

      if ((mask & N_OBJECT) && decl != NULL) {

24✔

10901

         tree_t g = tree_new(T_GUARD);

22✔

10902

         tree_set_loc(g, CURRENT_LOC);

22✔

10903

         tree_set_ref(g, decl);

22✔

10904

         tree_set_type(g, tree_type(decl));

22✔

10906

         *guard = g;

22✔

10909

         parse_error(CURRENT_LOC, "guarded assignment has no visible "

24✔

10913

   *reject = p_delay_mechanism();

2,305✔

10914

2,305✔

10916

static void p_conditional_waveforms(tree_t stmt, tree_t target, tree_t s0)

2,263✔

10920

   BEGIN("conditional waveforms");

4,526✔

10922

   for (;;) {

2,431✔

10923

      tree_t c = tree_new(T_COND_STMT);

2,431✔

10925

      tree_t a = s0;

2,431✔

10926

      if (a == NULL) {

2,431✔

10927

         a = tree_new(T_SIGNAL_ASSIGN);

2,426✔

10928

         tree_set_target(a, target);

2,426✔

10929

         p_waveform(a, target);

2,426✔

10932

         s0 = NULL;

5✔

10933

         tree_set_loc(a, CURRENT_LOC);

5✔

10935

      tree_add_stmt(c, a);

2,431✔

10936

      tree_add_cond(stmt, c);

2,431✔

10938

      if (optional(tWHEN)) {

2,431✔

10939

         tree_t when = p_condition();

256✔

10940

         tree_set_value(c, when);

256✔

10941

         tree_set_loc(c, tree_loc(when));

256✔

10942

         solve_types(nametab, when, std_type(NULL, STD_BOOLEAN));

256✔

10944

         if (!optional(tELSE))

256✔

10950

2,263✔

10952

static tree_t p_conditional_signal_assignment(tree_t name)

2,258✔

10956

   BEGIN("conditional signal assignment");

2,258✔

10958

   tree_t conc = tree_new(T_CONCURRENT);

2,258✔

10959

   tree_t stmt = tree_new(T_COND_ASSIGN);

2,258✔

10960

   tree_add_stmt(conc, stmt);

2,258✔

10962

   tree_t target = p_target(name);

2,258✔

10963

   tree_set_target(stmt, target);

2,258✔

10965

   consume(tLE);

2,258✔

10967

   tree_t reject = NULL, guard = NULL;

2,258✔

10968

   p_options(&reject, &guard);

2,258✔

10970

   if (guard != NULL) {

2,258✔

10971

      tree_set_guard(stmt, guard);

15✔

10972

      find_disconnect_specification(guard, target);

15✔

10975

   p_conditional_waveforms(stmt, target, NULL);

2,258✔

10977

   const int nconds = tree_conds(stmt);

2,258✔

10978

   for (int i = 0; i < nconds; i++) {

4,679✔

10979

      tree_t c = tree_cond(stmt, i);

2,421✔

10980

      assert(tree_stmts(c) == 1);

2,421✔

10981

      set_delay_mechanism(tree_stmt(c, 0), reject);

2,421✔

10984

   consume(tSEMI);

2,258✔

10986

   tree_set_loc(stmt, CURRENT_LOC);

2,258✔

10987

   tree_set_loc(conc, CURRENT_LOC);

2,258✔

10988

   return conc;

2,258✔

10991

static void p_selected_waveforms(tree_t stmt, tree_t target, tree_t reject)

50✔

10995

   BEGIN("selected waveforms");

100✔

10997

   type_t with_type = tree_type(tree_value(stmt));

50✔

10999

   do {

234✔

11000

      tree_t a = tree_new(T_SIGNAL_ASSIGN);

234✔

11001

      tree_set_target(a, target);

234✔

11002

      if (reject != NULL)

234✔

11005

      p_waveform(a, target);

234✔

11007

      sem_check(a, nametab);

234✔

11009

      consume(tWHEN);

234✔

11011

      tree_t alt = tree_new(T_ALTERNATIVE);

234✔

11012

      tree_add_stmt(alt, a);

234✔

11014

      p_choices(alt, NULL, with_type);

234✔

11016

      tree_set_loc(alt, CURRENT_LOC);

234✔

11017

      tree_add_stmt(stmt, alt);

234✔

11018

   } while (optional(tCOMMA));

234✔

11019

50✔

11021

static tree_t p_selected_signal_assignment(void)

47✔

11025

   BEGIN("selected signal assignment");

47✔

11027

   consume(tWITH);

47✔

11029

   tree_t value = p_expression();

47✔

11030

   solve_types(nametab, value, NULL);

47✔

11032

   consume(tSELECT);

47✔

11034

   tree_t stmt;

47✔

11035

   if (optional(tQUESTION)) {

47✔

11036

      require_std(STD_08, "matching select statements");

9✔

11037

      stmt = tree_new(T_MATCH_SELECT);

9✔

11040

      stmt = tree_new(T_SELECT);

38✔

11042

   tree_set_value(stmt, value);

47✔

11044

   tree_t conc = tree_new(T_CONCURRENT);

47✔

11045

   tree_add_stmt(conc, stmt);

47✔

11047

   tree_t target = p_target(NULL);

47✔

11049

   consume(tLE);

47✔

11051

   tree_t reject = NULL, guard = NULL;

47✔

11052

   p_options(&reject, &guard);

47✔

11054

   if (guard != NULL) {

47✔

11055

      tree_set_guard(stmt, guard);

7✔

11056

      find_disconnect_specification(guard, target);

7✔

11059

   p_selected_waveforms(stmt, target, reject);

47✔

11060

   consume(tSEMI);

47✔

11062

   tree_set_loc(stmt, CURRENT_LOC);

47✔

11063

   tree_set_loc(conc, CURRENT_LOC);

47✔

11064

   return conc;

47✔

11067

static tree_t p_concurrent_signal_assignment_statement(ident_t label,

2,305✔

11073

   EXTEND("concurrent signal assignment statement");

2,305✔

11075

   const bool postponed = name == NULL && optional(tPOSTPONED);

2,305✔

11077

   tree_t t;

2,305✔

11078

   if (peek() == tWITH) {

2,305✔

11079

      assert(name == NULL);

47✔

11080

      t = p_selected_signal_assignment();

47✔

11083

      t = p_conditional_signal_assignment(name);

2,258✔

11085

   tree_set_loc(t, CURRENT_LOC);

2,305✔

11086

   ensure_labelled(t, label);

2,305✔

11088

   if (postponed)

2,305✔

11091

   if (label) insert_name(nametab, t, NULL);

2,305✔

11092

   sem_check(t, nametab);

2,305✔

11093

   return t;

2,305✔

11096

static tree_t p_concurrent_procedure_call_statement(ident_t label, tree_t name)

68✔

11100

   EXTEND("concurrent procedure call statement");

68✔

11102

   const bool postponed = name == NULL && optional(tPOSTPONED);

68✔

11104

   tree_t call = NULL;

68✔

11105

   if (name == NULL) {

68✔

11106

      call = tree_new(T_PCALL);

6✔

11107

      tree_set_ident2(call, p_identifier());

6✔

11109

   else if (tree_kind(name) == T_PROT_REF) {

62✔

11110

      call = tree_new(T_PROT_PCALL);

3✔

11111

      tree_set_ident2(call, tree_ident(name));

3✔

11112

      tree_set_name(call, tree_value(name));

3✔

11115

      call = tree_new(T_PCALL);

59✔

11116

      tree_set_ident2(call, tree_ident(name));

59✔

11119

   if (optional(tLPAREN)) {

68✔

11120

      p_actual_parameter_part(call);

54✔

11121

      consume(tRPAREN);

54✔

11124

   consume(tSEMI);

68✔

11126

   tree_set_loc(call, CURRENT_LOC);

68✔

11128

   solve_types(nametab, call, NULL);

68✔

11130

   tree_t conc = tree_new(T_CONCURRENT);

68✔

11131

   tree_add_stmt(conc, call);

68✔

11133

   if (postponed)

68✔

11134

      tree_set_flag(conc, TREE_F_POSTPONED);

3✔

11136

   tree_set_loc(conc, CURRENT_LOC);

68✔

11137

   ensure_labelled(conc, label);

68✔

11138

   tree_set_ident(call, tree_ident(conc));

68✔

11140

   if (label) insert_name(nametab, conc, NULL);

68✔

11141

   sem_check(conc, nametab);

68✔

11142

   return conc;

68✔

11145

static void p_concurrent_statement_or_psl(tree_t parent)

11,246✔

11150

   if (peek() == tSTARTPSL) {

11,246✔

11151

      consume(tSTARTPSL);

400✔

11153

      if (peek() == tID) {

400✔

11154

         ident_t label = p_identifier();

199✔

11155

         consume(tCOLON);

199✔

11156

         tree_add_stmt(parent, p_psl_directive(label));

199✔

11158

      else if (scan(tDEFAULT, tSEQUENCE, tPROPERTY, tENDPOINT))

201✔

11159

         p_psl_declaration(parent);

66✔

11161

         tree_add_stmt(parent, p_psl_directive(NULL));

135✔

11164

      tree_add_stmt(parent, p_concurrent_statement());

10,846✔

11165

11,243✔

11167

static void p_block_statement_part(tree_t arch)

426✔

11171

   BEGIN("block statement part");

852✔

11173

   while (not_at_token(tEND))

881✔

11174

      p_concurrent_statement_or_psl(arch);

455✔

11175

426✔

11177

static void p_block_declarative_part(tree_t arch)

426✔

11181

   BEGIN("block declarative part");

852✔

11183

   while (not_at_token(tBEGIN))

810✔

11184

      p_block_declarative_item(arch);

384✔

11185

426✔

11187

static void p_block_header(tree_t block)

426✔

11192

   if (peek() == tGENERIC) {

426✔

11193

      p_generic_clause(block);

57✔

11195

      if (peek() == tGENERIC) {

57✔

11196

         p_generic_map_aspect(block, block);

50✔

11197

         consume(tSEMI);

50✔

11200

      insert_generics(nametab, block);

57✔

11203

   if (peek() == tPORT) {

426✔

11204

      p_port_clause(block);

191✔

11206

      if (peek() == tPORT) {

191✔

11207

         p_port_map_aspect(block, block);

189✔

11208

         consume(tSEMI);

189✔

11211

      insert_ports(nametab, block);

191✔

11213

426✔

11215

static tree_t p_block_statement(ident_t label)

426✔

11220

   EXTEND("block statement");

426✔

11222

   tree_t b = tree_new(T_BLOCK);

426✔

11223

   tree_set_ident(b, label);

426✔

11225

   consume(tBLOCK);

426✔

11227

   if (label == NULL)

426✔

11228

      parse_error(CURRENT_LOC, "block statement must have a label");

1✔

11230

      tree_set_loc(b, CURRENT_LOC);

425✔

11231

      insert_name(nametab, b, NULL);

425✔

11234

   push_scope(nametab);

426✔

11235

   scope_set_prefix(nametab, label ?: error_marker());

426✔

11236

   scope_set_container(nametab, b);

426✔

11238

   if (peek() == tLPAREN) {

426✔

11239

      consume(tLPAREN);

27✔

11241

      tree_t expr = p_expression();

27✔

11242

      solve_condition(nametab, &expr);

27✔

11244

      make_implicit_guard_signal(b, expr);

27✔

11246

      consume(tRPAREN);

27✔

11249

   optional(tIS);

426✔

11250

   p_block_header(b);

426✔

11251

   p_block_declarative_part(b);

426✔

11252

   consume(tBEGIN);

426✔

11253

   p_block_statement_part(b);

426✔

11254

   consume(tEND);

426✔

11255

   consume(tBLOCK);

426✔

11256

   p_trailing_label(label);

426✔

11257

   consume(tSEMI);

426✔

11259

   tree_set_loc(b, CURRENT_LOC);

426✔

11260

   sem_check(b, nametab);

426✔

11262

   hash_t *map = get_generic_map(nametab);

426✔

11263

   if (map != NULL)

426✔

11264

      instance_fixup(b, map);

44✔

11266

   pop_scope(nametab);

426✔

11267

   return b;

426✔

11270

static void p_generate_statement_body(tree_t container, ident_t alt_label)

422✔

11275

   BEGIN("generate statement body");

844✔

11277

   if (scan(tSIGNAL, tTYPE, tSUBTYPE, tFILE, tCONSTANT, tFUNCTION, tIMPURE,

422✔

11280

      while (not_at_token(tBEGIN))

194✔

11281

         p_block_declarative_item(container);

79✔

11282

      consume(tBEGIN);

115✔

11285

   while (not_at_token(tEND, tELSIF, tELSE, tWHEN))

887✔

11286

      p_concurrent_statement_or_psl(container);

465✔

11288

   if (peek() == tEND && (peek_nth(2) == tID || peek_nth(2) == tSEMI)) {

422✔

11289

      consume(tEND);

9✔

11290

      p_trailing_label(alt_label);

9✔

11291

      consume(tSEMI);

9✔

11293

422✔

11295

static tree_t p_for_generate_statement(ident_t label)

178✔

11300

   EXTEND("for generate statement");

178✔

11302

   consume(tFOR);

178✔

11304

   tree_t g = tree_new(T_FOR_GENERATE);

178✔

11305

   tree_set_ident(g, label);

178✔

11307

   if (label != NULL)

178✔

11308

      insert_name(nametab, g, NULL);

177✔

11310

   push_scope(nametab);

178✔

11311

   scope_set_prefix(nametab, label);

178✔

11312

   scope_set_container(nametab, g);

178✔

11314

   p_parameter_specification(g, T_GENERIC_DECL);

178✔

11316

   consume(tGENERATE);

178✔

11318

   p_generate_statement_body(g, NULL);

178✔

11320

   consume(tEND);

178✔

11321

   consume(tGENERATE);

178✔

11322

   p_trailing_label(label);

178✔

11323

   consume(tSEMI);

178✔

11325

   pop_scope(nametab);

178✔

11327

   if (label == NULL)

178✔

11328

      parse_error(CURRENT_LOC, "generate statement must have a label");

1✔

11330

   tree_set_loc(g, CURRENT_LOC);

178✔

11331

   sem_check(g, nametab);

178✔

11332

   return g;

178✔

11335

static tree_t p_if_generate_statement(ident_t label)

176✔

11343

   EXTEND("if generate statement");

176✔

11345

   consume(tIF);

176✔

11347

   tree_t g = tree_new(T_IF_GENERATE);

176✔

11348

   tree_set_ident(g, label);

176✔

11350

   if (label != NULL)

176✔

11351

      insert_name(nametab, g, NULL);

175✔

11353

   ident_t alt_label = NULL;

176✔

11354

   if (peek() == tID && peek_nth(2) == tCOLON) {

176✔

11355

      require_std(STD_08, "alternative labels");

4✔

11357

      alt_label = p_identifier();

4✔

11358

      consume(tCOLON);

4✔

11361

   push_scope(nametab);

176✔

11362

   scope_set_container(nametab, g);

176✔

11363

   scope_set_prefix(nametab, alt_label ?: label);

348✔

11365

   tree_t c0 = tree_new(T_COND_STMT);

176✔

11366

   tree_set_ident(c0, alt_label ?: label);

176✔

11367

   tree_set_value(c0, p_condition());

176✔

11369

   tree_add_cond(g, c0);

176✔

11371

   consume(tGENERATE);

176✔

11373

   p_generate_statement_body(c0, alt_label);

176✔

11375

   pop_scope(nametab);

176✔

11377

   tree_set_loc(c0, CURRENT_LOC);

176✔

11379

   while (optional(tELSIF)) {

183✔

11380

      require_std(STD_08, "elsif in generate statements");

7✔

11382

      ident_t alt_label = NULL;

7✔

11383

      if (peek() == tID && peek_nth(2) == tCOLON) {

7✔

11384

         alt_label = p_identifier();

7✔

11385

         consume(tCOLON);

7✔

11388

      push_scope(nametab);

7✔

11389

      scope_set_prefix(nametab, alt_label ?: label);

7✔

11391

      tree_t c = tree_new(T_COND_STMT);

7✔

11392

      tree_set_ident(c, alt_label ?: label);

7✔

11393

      tree_set_value(c, p_condition());

7✔

11395

      consume(tGENERATE);

7✔

11397

      p_generate_statement_body(c, alt_label);

7✔

11399

      pop_scope(nametab);

7✔

11401

      tree_set_loc(c, CURRENT_LOC);

7✔

11402

      tree_add_cond(g, c);

7✔

11405

   if (optional(tELSE)) {

176✔

11406

      require_std(STD_08, "else in generate statements");

12✔

11408

      ident_t alt_label = label;

12✔

11409

      if (peek() == tID && peek_nth(2) == tCOLON) {

12✔

11410

         alt_label = p_identifier();

7✔

11411

         consume(tCOLON);

7✔

11414

      push_scope(nametab);

12✔

11415

      scope_set_prefix(nametab, alt_label ?: label);

12✔

11417

      tree_t c = tree_new(T_COND_STMT);

12✔

11418

      tree_set_ident(c, alt_label ?: label);

12✔

11420

      consume(tGENERATE);

12✔

11422

      p_generate_statement_body(c, alt_label);

12✔

11424

      pop_scope(nametab);

12✔

11426

      tree_set_loc(c, CURRENT_LOC);

12✔

11427

      tree_add_cond(g, c);

12✔

11430

   consume(tEND);

176✔

11431

   consume(tGENERATE);

176✔

11432

   p_trailing_label(label);

176✔

11433

   consume(tSEMI);

176✔

11435

   if (label == NULL)

176✔

11436

      parse_error(CURRENT_LOC, "generate statement must have a label");

1✔

11438

   tree_set_loc(g, CURRENT_LOC);

176✔

11439

   sem_check(g, nametab);

176✔

11440

   return g;

176✔

11443

static tree_t p_case_generate_alternative(type_t type)

49✔

11447

   BEGIN("case generate alternative");

49✔

11449

   consume(tWHEN);

49✔

11451

   ident_t alt_label = NULL;

49✔

11452

   if (peek() == tID && peek_nth(2) == tCOLON) {

49✔

11453

      alt_label = p_identifier();

15✔

11454

      consume(tCOLON);

15✔

11457

   tree_t alt = tree_new(T_ALTERNATIVE);

49✔

11458

   tree_set_ident(alt, alt_label);

49✔

11459

   p_choices(alt, NULL, type);

49✔

11461

   consume(tASSOC);

49✔

11463

   push_scope(nametab);

49✔

11464

   scope_set_prefix(nametab, alt_label);

49✔

11466

   p_generate_statement_body(alt, alt_label);

49✔

11468

   tree_set_loc(alt, CURRENT_LOC);

49✔

11469

   pop_scope(nametab);

49✔

11471

   return alt;

49✔

11474

static tree_t p_case_generate_statement(ident_t label)

19✔

11479

   EXTEND("case generate statement");

19✔

11481

   consume(tCASE);

19✔

11483

   require_std(STD_08, "case generate statements");

19✔

11485

   tree_t g = tree_new(T_CASE_GENERATE);

19✔

11486

   tree_set_ident(g, label);

19✔

11488

   if (label != NULL)

19✔

11489

      insert_name(nametab, g, NULL);

19✔

11491

   tree_t value = p_expression();

19✔

11492

   tree_set_value(g, value);

19✔

11494

   type_t type = solve_types(nametab, value, NULL);

19✔

11496

   consume(tGENERATE);

19✔

11498

   do {

49✔

11499

      tree_add_stmt(g, p_case_generate_alternative(type));

49✔

11500

   } while (peek() == tWHEN);

49✔

11502

   consume(tEND);

19✔

11503

   consume(tGENERATE);

19✔

11505

   p_trailing_label(label);

19✔

11506

   consume(tSEMI);

19✔

11508

   if (label == NULL)

19✔

11511

   tree_set_loc(g, CURRENT_LOC);

19✔

11512

   sem_check(g, nametab);

19✔

11513

   return g;

19✔

11516

static tree_t p_generate_statement(ident_t label)

373✔

11520

   EXTEND("generate statement");

746✔

11522

   switch (peek()) {

373✔

11523

   case tFOR:

178✔

11524

      return p_for_generate_statement(label);

178✔

11525

   case tIF:

176✔

11526

      return p_if_generate_statement(label);

176✔

11527

   case tCASE:

19✔

11528

      return p_case_generate_statement(label);

19✔

11536

static psl_node_t p_psl_low_bound(tree_t head)

32✔

11540

   BEGIN_WITH_HEAD("PSL Low Bound", head);

64✔

11542

   return p_hdl_expression(head, PSL_TYPE_NUMERIC);

32✔

11545

static psl_node_t p_psl_high_bound(void)

32✔

11549

   BEGIN("PSL Low Bound");

64✔

11551

   if (optional(tINF)) {

32✔

11552

      tree_t inf = tree_new(T_LITERAL);

6✔

11553

      tree_set_loc(inf, CURRENT_LOC);

6✔

11554

      tree_set_subkind(inf, L_INT);

6✔

11555

      tree_set_ival(inf, INT32_MAX);

6✔

11557

      psl_node_t p = psl_new(P_HDL_EXPR);

6✔

11558

      psl_set_type(p, PSL_TYPE_NUMERIC);

6✔

11559

      psl_set_tree(p, inf);

6✔

11560

      psl_set_loc(p, CURRENT_LOC);

6✔

11561

      return p;

6✔

11564

      return p_hdl_expression(NULL, PSL_TYPE_NUMERIC);

26✔

11567

static psl_node_t p_psl_range(tree_t head)

32✔

11571

   BEGIN_WITH_HEAD("PSL Range", head);

32✔

11573

   psl_node_t low = p_psl_low_bound(head);

32✔

11575

   consume(tTO);

32✔

11577

   psl_node_t high = p_psl_high_bound();

32✔

11579

   psl_node_t p = psl_new(P_RANGE);

32✔

11580

   psl_set_left(p, low);

32✔

11581

   psl_set_right(p, high);

32✔

11583

   psl_set_loc(p, CURRENT_LOC);

32✔

11584

   return p;

32✔

11587

static psl_node_t p_psl_value_range(void)

10✔

11591

   BEGIN("PSL Value Range");

20✔

11593

   tree_t tree = p_expression();

10✔

11595

   if (peek() == tTO)

10✔

11596

      return p_psl_range(tree);

4✔

11598

   psl_node_t p = psl_new(P_HDL_EXPR);

6✔

11599

   psl_set_tree(p, tree);

6✔

11601

   psl_set_loc(p, CURRENT_LOC);

6✔

11602

   return p;

6✔

11605

static psl_node_t p_psl_value_set(void)

7✔

11609

   BEGIN("PSL Value Set");

7✔

11611

   psl_node_t p = psl_new(P_VALUE_SET);

7✔

11613

   switch (one_of(tBOOLEAN, tLBRACE)) {

7✔

11614

   case tBOOLEAN:

3✔

11615

      psl_set_subkind(p, PSL_VALUE_SET_BOOLEAN);

3✔

11616

      break;

3✔

11617

   case tLBRACE:

4✔

11619

         psl_set_subkind(p, PSL_VALUE_SET_EXPLICIT);

4✔

11621

         do {

10✔

11622

            psl_add_operand(p, p_psl_value_range());

10✔

11623

         } while (optional(tCOMMA));

10✔

11625

         consume(tRBRACE);

4✔

11627

      break;

4✔

11630

   psl_set_loc(p, CURRENT_LOC);

7✔

11631

   return p;

7✔

11634

static psl_node_t p_psl_union(tree_t head)

25✔

11636

   consume(tUNION);

25✔

11638

   psl_node_t lhs = psl_new(P_HDL_EXPR);

25✔

11639

   psl_set_tree(lhs, head);

25✔

11640

   psl_set_loc(lhs, tree_loc(head));

25✔

11641

   psl_set_type(lhs, PSL_TYPE_ANY);

25✔

11642

   psl_set_loc(lhs, CURRENT_LOC);

25✔

11644

   psl_node_t un = psl_new(P_UNION);

25✔

11645

   psl_add_operand(un, lhs);

25✔

11646

   psl_add_operand(un, p_hdl_expression(NULL, PSL_TYPE_ANY));

25✔

11647

   psl_set_loc(un, CURRENT_LOC);

25✔

11649

   return un;

25✔

11652

static psl_node_t p_hdl_expression(tree_t head, psl_type_t type)

1,190✔

11654

   BEGIN("PSL HDL expression");

1,190✔

11656

   tree_t expr = p_relation(head);

1,190✔

11659

   for (;;) {

1,205✔

11660

      const token_t tok = peek();

1,205✔

11661

      if (tok == tUNION) {

1,205✔

11662

         psl_node_t un = p_psl_union(expr);

13✔

11663

         tree_t new = tree_new(T_PSL_UNION);

13✔

11664

         tree_set_psl(new, un);

13✔

11665

         tree_set_loc(new, CURRENT_LOC);

13✔

11666

         expr = new;

13✔

11668

      else if (tok == tNOR || tok == tNAND) {

1,192✔

11675

      else if (tok == tXOR || tok == tXNOR) {

1,192✔

11676

         tree_t new = tree_new(T_FCALL);

2✔

11677

         tree_set_ident(new, p_logical_operator());

2✔

11678

         binary_op(new, expr, p_relation);

2✔

11679

         expr = new;

2✔

11685

   psl_node_t p = psl_new(P_HDL_EXPR);

1,190✔

11686

   psl_set_tree(p, expr);

1,190✔

11687

   psl_set_loc(p, tree_loc(expr));

1,190✔

11688

   psl_set_type(p, type);

1,190✔

11689

   psl_set_loc(p, CURRENT_LOC);

1,190✔

11691

   return p;

1,190✔

11694

static psl_node_t p_psl_boolean(tree_t head)

456✔

11699

   BEGIN_WITH_HEAD("PSL Boolean", head);

912✔

11701

   psl_node_t p = p_hdl_expression(head, PSL_TYPE_BOOLEAN);

456✔

11703

   const token_t infix = peek();

456✔

11704

   switch (infix) {

456✔

11705

   case tAND:

54✔

11708

         consume(infix);

54✔

11710

         psl_node_t right = p_psl_boolean(NULL);

54✔

11712

         tree_t fcall = tree_new(T_FCALL);

54✔

11713

         tree_set_ident(fcall, well_known(infix == tOR ? W_OP_OR : W_OP_AND));

108✔

11714

         tree_set_loc(fcall, CURRENT_LOC);

54✔

11715

         add_param(fcall, psl_tree(p), P_POS, NULL);

54✔

11716

         add_param(fcall, psl_tree(right), P_POS, NULL);

54✔

11718

         psl_set_tree(p, fcall);

54✔

11719

         psl_set_loc(p, CURRENT_LOC);

54✔

11720

         return p;

54✔

11728

static psl_node_t p_psl_clock_expression(void)

96✔

11730

   tree_t expr = p_expression();

96✔

11731

   solve_types(nametab, expr, std_type(NULL, STD_BOOLEAN));

96✔

11733

   psl_node_t p = psl_new(P_CLOCK_DECL);

96✔

11734

   psl_set_tree(p, expr);

96✔

11736

   return p;

96✔

11739

static tree_t p_psl_clock_declaration(void)

96✔

11743

   BEGIN("PSL clock declaration");

96✔

11745

   scan_as_psl();

96✔

11747

   consume(tDEFAULT);

96✔

11748

   consume(tCLOCK);

96✔

11750

   consume(tIS);

96✔

11752

   scan_as_vhdl();

96✔

11754

   psl_node_t p = p_psl_clock_expression();

96✔

11756

   tree_t t = tree_new(T_PSL_DECL);

96✔

11757

   tree_set_psl(t, p);

96✔

11758

   tree_set_ident(t, well_known(W_DEFAULT_CLOCK));

96✔

11760

   consume(tSEMI);

96✔

11762

   psl_set_loc(p, CURRENT_LOC);

96✔

11763

   psl_check(p, nametab);

96✔

11765

   insert_name(nametab, t, NULL);

96✔

11767

   tree_set_loc(t, CURRENT_LOC);

96✔

11768

   return t;

96✔

11771

static psl_node_t p_psl_builtin_function_call(void)

49✔

11782

   BEGIN("PSL Built-in Function call");

49✔

11784

   psl_builtin_kind_t kind;

49✔

11785

   switch (one_of(tPSLNEXT, tPREV, tSTABLE, tROSE, tFELL, tENDED,

49✔

11788

   case tPREV:    kind = PSL_BUILTIN_PREV; break;

31✔

11789

   case tSTABLE:  kind = PSL_BUILTIN_STABLE; break;

3✔

11790

   case tROSE:    kind = PSL_BUILTIN_ROSE; break;

5✔

11791

   case tFELL:    kind = PSL_BUILTIN_FELL; break;

3✔

11792

   case tENDED:   kind = PSL_BUILTIN_ENDED; break;

1✔

11793

   case tNONDET:  kind = PSL_BUILTIN_NONDET; break;

6✔

11798

   psl_node_t p = psl_new(P_BUILTIN_FCALL);

49✔

11799

   psl_set_subkind(p, kind);

49✔

11801

   consume(tLPAREN);

49✔

11803

   switch (kind) {

49✔

11804

   case PSL_BUILTIN_PREV:

31✔

11806

         psl_node_t p1 = p_hdl_expression(NULL, PSL_TYPE_ANY);

31✔

11807

         psl_add_operand(p, p1);

31✔

11809

         if (optional(tCOMMA)) {

31✔

11810

            psl_node_t p2 = p_hdl_expression(NULL, PSL_TYPE_NUMERIC);

16✔

11811

            psl_add_operand(p, p2);

16✔

11813

            if (optional(tCOMMA))

16✔

11826

   case PSL_BUILTIN_FELL:

11✔

11830

         psl_node_t p1 = p_hdl_expression(NULL, PSL_TYPE_BIT);

11✔

11831

         psl_add_operand(p, p1);

11✔

11833

         if (optional(tCOMMA))

11✔

11838

   case PSL_BUILTIN_ENDED:

1✔

11840

         psl_node_t p1 = p_psl_sequence();

1✔

11841

         psl_add_operand(p, p1);

1✔

11843

         if (optional(tCOMMA))

1✔

11848

   case PSL_BUILTIN_NONDET:

6✔

11850

         psl_node_t p1 = p_psl_value_set();

6✔

11851

         psl_add_operand(p, p1);

6✔

11853

      break;

6✔

11868

   consume(tRPAREN);

49✔

11870

   psl_set_loc(p, CURRENT_LOC);

49✔

11871

   return p;

49✔

11889

static psl_node_t p_psl_parameter_definition(void)

1✔

11893

   BEGIN("PSL Parameter Definition");

1✔

11895

   tree_t decl = tree_new(T_PARAM_DECL);

1✔

11897

   tree_set_ident(decl, p_identifier());

1✔

11898

   insert_name(nametab, decl, NULL);

1✔

11900

   psl_node_t p = psl_new(P_PARAM_DECL);

1✔

11901

   psl_set_tree(p, decl);

1✔

11903

   if (peek() == tLPAREN)

1✔

11906

   consume(tIN);

1✔

11908

   psl_set_value(p, p_psl_value_set());

1✔

11910

   psl_set_loc(p, CURRENT_LOC);

1✔

11911

   return p;

1✔

11914

static void p_psl_parameters_definition(psl_node_t p)

1✔

11918

   BEGIN("PSL Parameters Definition");

2✔

11920

   do {

1✔

11921

      psl_add_operand(p, p_psl_parameter_definition());

1✔

11922

   } while (optional(tCOMMA));

1✔

11923

1✔

11925

static psl_node_t p_psl_parametrized_sere(void)

1✔

11929

   BEGIN("PSL Parametrized SERE");

1✔

11931

   consume(tFOR);

1✔

11933

   psl_node_t p = psl_new(P_PARAM_SERE);

1✔

11934

   p_psl_parameters_definition(p);

1✔

11936

   consume(tCOLON);

1✔

11938

   switch (one_of(tAMP, tDBLAMP, tBAR)) {

1✔

11942

   case tDBLAMP:

1✔

11943

      psl_set_subkind(p, PSL_SERE_EQU_AND);

1✔

11944

      break;

1✔

11950

   consume(tLBRACE);

1✔

11952

   psl_set_value(p, p_psl_sere());

1✔

11954

   consume(tRBRACE);

1✔

11956

   psl_set_loc(p, CURRENT_LOC);

1✔

11957

   return p;

1✔

11960

static psl_node_t p_psl_count(void)

48✔

11964

   BEGIN("PSL Count");

96✔

11966

   tree_t count = p_expression();

48✔

11968

   if (peek() == tTO)

48✔

11969

      return p_psl_range(count);

15✔

11971

      return p_hdl_expression(count, PSL_TYPE_NUMERIC);

33✔

11974

static psl_node_t p_psl_proc_block(psl_node_t value)

4✔

11978

   BEGIN("PSL Procedural Block");

4✔

11980

   consume(t2LSQUARE);

4✔

11982

   tree_t b = tree_new(T_SEQUENCE);

4✔

11984

   psl_node_t p = psl_new(P_PROC_BLOCK);

4✔

11985

   psl_set_value(p, value);

4✔

11986

   psl_set_tree(p, b);

4✔

11988

   scan_as_vhdl();

4✔

11990

   while (not_at_token(t2RSQUARE)) {

11✔

11991

      if (scan(tSIGNAL, tTYPE, tSUBTYPE, tFILE, tCONSTANT, tFUNCTION, tIMPURE,

7✔

11994

         p_block_declarative_item(b);

3✔

11996

         tree_add_stmt(b, p_sequential_statement());

4✔

11999

   scan_as_psl();

4✔

12001

   consume(t2RSQUARE);

4✔

12003

   tree_set_loc(b, CURRENT_LOC);

4✔

12004

   psl_set_loc(p, CURRENT_LOC);

4✔

12005

   return p;

4✔

12008

static type_t p_psl_subtype_indication(void)

7✔

12010

   BEGIN("PSL subtype indication");

14✔

12015

   token_t third = peek_nth(3);

7✔

12016

   if (peek() == tID && peek_nth(1) == tID &&

7✔

12017

       (third == tSEMI || third == tCOMMA || third == tRPAREN))

7✔

12018

      return p_type_mark();

6✔

12020

      return p_subtype_indication();

1✔

12023

static type_t p_psl_param_spec(psl_node_t node, psl_type_t *psl_type, class_t *class)

22✔

12040

   BEGIN("PSL Parameter specification");

44✔

12042

   *class = C_SIGNAL;

22✔

12044

   switch (peek()) {

22✔

12045

   case tPROPERTY:

1✔

12046

      consume(tPROPERTY);

1✔

12047

      *psl_type = PSL_TYPE_PROPERTY;

1✔

12048

      break;

1✔

12050

   case tSEQUENCE:

1✔

12051

      consume(tSEQUENCE);

1✔

12052

      *psl_type = PSL_TYPE_SEQUENCE;

1✔

12053

      break;

1✔

12055

   case tCONST:

10✔

12056

      *class = C_CONSTANT;

10✔

12058

      if (peek_nth(2) == tID) {

10✔

12059

         consume(tCONST);

2✔

12060

         *psl_type = PSL_TYPE_NUMERIC;

2✔

12061

         return std_type(NULL, STD_INTEGER);

2✔

12064

      one_of(tCONST, tMUTABLE);

14✔

12065

   case tHDLTYPE:

18✔

12071

      switch (one_of(tHDLTYPE, tBOOLEAN, tBIT, tBITVECTOR, tNUMERIC, tSTRINGK)) {

18✔

12072

      case tHDLTYPE:

7✔

12073

         *psl_type = PSL_TYPE_HDLTYPE;

7✔

12074

         scan_as_vhdl();

7✔

12075

         type_t t = p_psl_subtype_indication();

7✔

12076

         scan_as_psl();

7✔

12077

         return t;

7✔

12078

      case tBOOLEAN:

2✔

12079

         *psl_type = PSL_TYPE_BOOLEAN;

2✔

12080

         return std_type(NULL, STD_BOOLEAN);

2✔

12081

      case tBIT:

2✔

12082

         *psl_type = PSL_TYPE_BIT;

2✔

12083

         return std_type(NULL, STD_BIT);

2✔

12084

         break;

2✔

12085

      case tBITVECTOR:

2✔

12086

         *psl_type = PSL_TYPE_BITVECTOR;

2✔

12087

         return std_type(NULL, STD_BIT_VECTOR);

2✔

12088

         break;

3✔

12089

      case tNUMERIC:

3✔

12090

         *psl_type = PSL_TYPE_NUMERIC;

3✔

12091

         return std_type(NULL, STD_INTEGER);

3✔

12092

         break;

2✔

12093

      case tSTRINGK:

2✔

12094

         *psl_type = PSL_TYPE_STRING;

2✔

12095

         return std_type(NULL, STD_STRING);

2✔

12099

  return type_new(T_NONE);

2✔

12102

static void p_psl_formal_parameter(psl_node_t node)

22✔

12106

   BEGIN("PSL Formal parameter");

44✔

12108

   psl_type_t psl_type = PSL_TYPE_NUMERIC;

22✔

12109

   class_t class;

22✔

12110

   type_t type = p_psl_param_spec(node, &psl_type, &class);

22✔

12112

   do {

22✔

12113

      tree_t p = tree_new(T_PARAM_DECL);

22✔

12114

      tree_set_ident(p, p_identifier());

22✔

12115

      tree_set_loc(p, CURRENT_LOC);

22✔

12116

      tree_set_class(p, class);

22✔

12117

      tree_set_subkind(p, psl_type);

22✔

12118

      tree_set_type(p, type);

22✔

12119

      psl_add_port(node, p);

22✔

12120

      insert_name(nametab, p, NULL);

22✔

12121

   } while (optional(tCOMMA));

22✔

12122

22✔

12124

static void p_psl_formal_parameter_list(psl_node_t node)

20✔

12128

   BEGIN("PSL Formal parameter list");

40✔

12130

   p_psl_formal_parameter(node);

20✔

12132

   while (optional(tSEMI))

22✔

12133

      p_psl_formal_parameter(node);

2✔

12134

20✔

12136

static void p_psl_actual_parameter(psl_node_t node, bool seq)

7✔

12143

   BEGIN("PSL Actual parameter");

14✔

12147

   psl_add_operand(node, (seq) ? p_psl_sequence() : p_psl_property());

7✔

12148

7✔

12150

static void p_psl_actual_parameter_list(psl_node_t node, bool seq)

6✔

12156

   BEGIN("PSL Actual parameter list");

12✔

12158

   p_psl_actual_parameter(node, seq);

6✔

12160

   while (optional(tCOMMA))

7✔

12161

      p_psl_actual_parameter(node, seq);

1✔

12162

6✔

12164

static psl_node_t p_psl_clocked_sere(psl_node_t head)

1✔

12168

   BEGIN("PSL Clocked SERE");

1✔

12170

   consume(tAT);

1✔

12172

   tree_t expr = p_expression();

1✔

12173

   solve_types(nametab, expr, std_type(NULL, STD_BOOLEAN));

1✔

12175

   psl_node_t p = psl_new(P_CLOCKED);

1✔

12176

   psl_set_value(p, head);

1✔

12177

   psl_set_tree(p, expr);

1✔

12179

   psl_set_loc(p, CURRENT_LOC);

1✔

12180

   return p;

1✔

12183

static psl_node_t p_psl_compound_sere(psl_node_t head)

36✔

12192

   BEGIN("PSL Compound SERE");

36✔

12194

   if (head == NULL) {

36✔

12195

      switch (peek()) {

18✔

12196

      case tLBRACE:

16✔

12197

         head = p_psl_braced_sere();

16✔

12198

         break;

16✔

12199

      case tFOR:

1✔

12200

         head = p_psl_parametrized_sere();

1✔

12201

         break;

1✔

12202

      default:

1✔

12203

         head = p_psl_boolean(NULL);

1✔

12204

         break;

1✔

12208

   for (;;) {

58✔

12209

      switch (peek()) {

58✔

12210

      case tBAR:

5✔

12212

            consume(tBAR);

5✔

12214

            psl_node_t p = psl_new(P_SERE);

5✔

12215

            psl_add_operand(p, head);

5✔

12216

            psl_set_subkind(p, PSL_SERE_OR);

5✔

12217

            psl_add_operand(p, p_psl_compound_sere(NULL));

5✔

12218

            psl_set_loc(p, CURRENT_LOC);

5✔

12220

            head = p;

5✔

12222

         break;

5✔

12223

      case tAMP:

2✔

12225

            consume(tAMP);

2✔

12227

            psl_node_t p = psl_new(P_SERE);

2✔

12228

            psl_add_operand(p, head);

2✔

12229

            psl_set_subkind(p, PSL_SERE_NEQ_AND);

2✔

12230

            psl_add_operand(p, p_psl_compound_sere(NULL));

2✔

12231

            psl_set_loc(p, CURRENT_LOC);

2✔

12233

            head = p;

2✔

12235

         break;

2✔

12236

      case tDBLAMP:

9✔

12238

            consume(tDBLAMP);

9✔

12240

            psl_node_t p = psl_new(P_SERE);

9✔

12241

            psl_add_operand(p, head);

9✔

12242

            psl_set_subkind(p, PSL_SERE_EQU_AND);

9✔

12243

            psl_add_operand(p, p_psl_compound_sere(NULL));

9✔

12244

            psl_set_loc(p, CURRENT_LOC);

9✔

12246

            head = p;

9✔

12248

         break;

9✔

12249

      case tWITHIN:

1✔

12251

            consume(tWITHIN);

1✔

12253

            psl_node_t p = psl_new(P_SERE);

1✔

12254

            psl_add_operand(p, head);

1✔

12255

            psl_set_subkind(p, PSL_SERE_WITHIN);

1✔

12256

            psl_add_operand(p, p_psl_compound_sere(NULL));

1✔

12257

            psl_set_loc(p, CURRENT_LOC);

1✔

12259

            head = p;

1✔

12261

         break;

1✔

12262

      case tPLUSRPT:

5✔

12267

         head = p_psl_repeated_sere(head);

5✔

12268

         break;

5✔

12272

      default:

36✔

12273

         return head;

36✔

12278

static psl_node_t p_psl_sere(void)

414✔

12283

   BEGIN("PSL SERE");

414✔

12285

   psl_node_t head;

414✔

12286

   switch (peek()) {

414✔

12287

   case tLBRACE:

373✔

12293

      head = p_psl_sequence();

373✔

12294

      break;

373✔

12295

   case tFOR:

1✔

12296

      head = p_psl_compound_sere(NULL);

1✔

12297

      break;

1✔

12298

   default:

40✔

12299

      head = p_psl_boolean(NULL);

40✔

12300

      break;

40✔

12303

   for (;;) {

614✔

12304

      const token_t tok = peek();

614✔

12306

      switch (tok) {

614✔

12307

      case tCOLON:

182✔

12310

            consume(tok);

182✔

12312

            const psl_sere_kind_t kind =

182✔

12313

               tok == tCOLON ? PSL_SERE_FUSION : PSL_SERE_CONCAT;

182✔

12315

            psl_node_t rhs = p_psl_sere();

182✔

12317

            psl_node_t p = psl_new(P_SERE);

182✔

12318

            psl_set_subkind(p, kind);

182✔

12319

            psl_add_operand(p, head);

182✔

12320

            psl_set_loc(p, CURRENT_LOC);

182✔

12322

            if (psl_kind(rhs) == P_SERE && psl_subkind(rhs) == kind) {

182✔

12323

               const int nops = psl_operands(rhs);

55✔

12324

               for (int i = 0; i < nops; i++)

168✔

12325

                  psl_add_operand(p, psl_operand(rhs, i));

113✔

12328

               psl_add_operand(p, rhs);

127✔

12333

      case tBAR:

18✔

12342

         head = p_psl_compound_sere(head);

18✔

12343

         continue;

18✔

12344

      default:

414✔

12345

         return head;

414✔

12350

static psl_node_t p_psl_braced_sere(void)

231✔

12355

   BEGIN("PSL Braced SERE");

231✔

12357

   consume(tLBRACE);

231✔

12359

   psl_node_t sere = p_psl_sere();

231✔

12361

   consume(tRBRACE);

231✔

12363

   psl_set_loc(sere, CURRENT_LOC);

231✔

12364

   return sere;

231✔

12367

static psl_node_t p_psl_repeated_sere(psl_node_t head)

70✔

12374

   EXTEND("PSL Repeated SERE");

140✔

12376

   assert(head != NULL);

70✔

12378

   if (peek() == t2LSQUARE)

70✔

12379

      return p_psl_proc_block(head);

4✔

12381

   psl_node_t p = psl_new(P_REPEAT);

66✔

12382

   psl_set_value(p, head);

66✔

12384

   switch (one_of(tPLUSRPT, tTIMESRPT, tGOTORPT, tEQRPT, t2LSQUARE)) {

66✔

12385

   case tPLUSRPT:

9✔

12386

      psl_set_subkind(p, PSL_PLUS_REPEAT);

9✔

12387

      break;

9✔

12389

   case tTIMESRPT:

32✔

12390

      psl_set_subkind(p, PSL_TIMES_REPEAT);

32✔

12391

      if (peek() != tRSQUARE)

32✔

12392

         psl_set_delay(p, p_psl_count());

23✔

12393

      consume(tRSQUARE);

32✔

12394

      break;

32✔

12396

   case tGOTORPT:

9✔

12397

      psl_set_subkind(p, PSL_GOTO_REPEAT);

9✔

12398

      if (peek() != tRSQUARE)

9✔

12399

         psl_set_delay(p, p_psl_count());

9✔

12400

      consume(tRSQUARE);

9✔

12401

      break;

9✔

12403

   case tEQRPT:

16✔

12404

      psl_set_subkind(p, PSL_EQUAL_REPEAT);

16✔

12405

      if (peek() != tRSQUARE)

16✔

12406

         psl_set_delay(p, p_psl_count());

16✔

12407

      consume(tRSQUARE);

16✔

12408

      break;

16✔

12414

   psl_set_loc(p, CURRENT_LOC);

66✔

12415

   return p;

66✔

12418

static psl_node_t p_sequence_instance(tree_t decl)

7✔

12422

   EXTEND("PSL Sequence Instance");

7✔

12424

   psl_node_t s_decl = tree_psl(decl);

7✔

12426

   if (psl_kind(s_decl) != P_SEQUENCE_DECL)

7✔

12427

      parse_error(CURRENT_LOC, "%s is not a PSL sequence",

1✔

12430

   psl_node_t p = psl_new(P_SEQUENCE_INST);

7✔

12431

   psl_set_ref(p, s_decl);

7✔

12433

   if (optional(tLPAREN)) {

7✔

12434

      p_psl_actual_parameter_list(p, true);

6✔

12435

      consume(tRPAREN);

6✔

12438

   psl_set_loc(p, CURRENT_LOC);

7✔

12439

   return p;

7✔

12442

static psl_node_t p_psl_sequence(void)

593✔

12446

   BEGIN("PSL Sequence");

593✔

12448

   psl_node_t head = NULL;

593✔

12449

   switch (peek()) {

593✔

12450

   case tLBRACE:

215✔

12451

      head = p_psl_braced_sere();

215✔

12452

      break;

215✔

12453

   case tID:

363✔

12455

         tree_t name = p_name(N_PSL);

363✔

12458

         if (tree_kind(name) == T_REF && tree_has_ref(name)) {

363✔

12459

            tree_t decl = tree_ref(name);

354✔

12460

            if (tree_kind(decl) == T_PSL_DECL)

354✔

12461

               head = p_sequence_instance(decl);

7✔

12464

         if (head == NULL)

7✔

12465

            head = p_psl_boolean(name);

356✔

12468

   case tTIMESRPT:

10✔

12472

         type_t std_bool = std_type(NULL, STD_BOOLEAN);

10✔

12473

         tree_t true_ref = make_ref(type_enum_literal(std_bool, 1));

10✔

12475

         head = psl_new(P_HDL_EXPR);

10✔

12476

         psl_set_tree(head, true_ref);

10✔

12477

         psl_set_type(head, PSL_TYPE_BOOLEAN);

10✔

12479

      break;

10✔

12480

   default:

5✔

12481

      head = p_psl_boolean(NULL);

5✔

12482

      break;

5✔

12485

   for (;;) {

659✔

12486

      switch (peek()) {

659✔

12487

      case tPLUSRPT:

65✔

12492

         head = p_psl_repeated_sere(head);

65✔

12493

         break;

65✔

12494

      case tAT:

1✔

12495

         head = p_psl_clocked_sere(head);

1✔

12496

         break;

1✔

12497

      default:

593✔

12498

         return head;

593✔

12503

static psl_node_t p_psl_fl_property(void)

1,084✔

12530

   BEGIN("FL property");

2,168✔

12532

   psl_node_t p = NULL;

1,084✔

12533

   const token_t tok = peek();

1,084✔

12534

   switch (tok) {

1,084✔

12535

   case tALWAYS:

149✔

12537

         consume(tALWAYS);

149✔

12539

         p = psl_new(P_ALWAYS);

149✔

12540

         psl_set_value(p, p_psl_fl_property());

149✔

12541

         psl_set_loc(p, CURRENT_LOC);

149✔

12543

      break;

149✔

12545

   case tNEVER:

13✔

12547

         consume(tNEVER);

13✔

12549

         p = psl_new(P_NEVER);

13✔

12550

         psl_set_value(p, p_psl_fl_property());

13✔

12551

         psl_set_loc(p, CURRENT_LOC);

13✔

12553

      break;

13✔

12555

   case tEVENTUALLY:

8✔

12557

         consume(tEVENTUALLY);

8✔

12559

         p = psl_new(P_EVENTUALLY);

8✔

12560

         psl_set_value(p, p_psl_fl_property());

8✔

12561

         psl_set_loc(p, CURRENT_LOC);

8✔

12563

      break;

8✔

12565

   case tPSLNEXT:

84✔

12568

         consume(tok);

84✔

12570

         p = psl_new(P_NEXT);

84✔

12572

         if (tok == tNEXT1)

84✔

12573

            psl_set_flag(p, PSL_F_STRONG);

1✔

12575

         if (optional(tLSQUARE)) {

84✔

12576

            psl_node_t count = p_hdl_expression(NULL, PSL_TYPE_NUMERIC);

28✔

12577

            psl_set_delay(p, count);

28✔

12579

            consume(tRSQUARE);

28✔

12582

         psl_set_value(p, p_psl_fl_property());

84✔

12583

         psl_set_loc(p, CURRENT_LOC);

84✔

12585

      break;

84✔

12587

   case tNEXTA:

2✔

12590

         consume(tok);

2✔

12592

         p = psl_new(P_NEXT_A);

2✔

12594

         if (tok == tNEXTA1)

2✔

12597

         consume(tLSQUARE);

2✔

12599

         psl_set_delay(p, p_psl_range(NULL));

2✔

12601

         consume(tRSQUARE);

2✔

12603

         psl_set_value(p, p_psl_fl_property());

2✔

12604

         psl_set_loc(p, CURRENT_LOC);

2✔

12606

      break;

2✔

12608

   case tNEXTE:

11✔

12611

         consume(tok);

11✔

12613

         p = psl_new(P_NEXT_E);

11✔

12615

         if (tok == tNEXTE1)

11✔

12616

            psl_set_flag(p, PSL_F_STRONG);

3✔

12618

         consume(tLSQUARE);

11✔

12620

         psl_set_delay(p, p_psl_range(NULL));

11✔

12622

         consume(tRSQUARE);

11✔

12624

         psl_set_value(p, p_psl_fl_property());

11✔

12625

         psl_set_loc(p, CURRENT_LOC);

11✔

12627

      break;

11✔

12629

   case tNEXTEVENT:

1✔

12632

         consume(tok);

1✔

12634

         p = psl_new(P_NEXT_EVENT);

1✔

12636

         if (tok == tNEXTEVENT1)

1✔

12639

         consume(tLPAREN);

1✔

12640

         (void)p_psl_fl_property();

1✔

12641

         consume(tRPAREN);

1✔

12643

         if (optional(tLSQUARE)) {

1✔

12644

            psl_node_t count = p_hdl_expression(NULL, PSL_TYPE_NUMERIC);

1✔

12645

            psl_set_delay(p, count);

1✔

12647

            consume(tRSQUARE);

1✔

12650

         consume(tLPAREN);

1✔

12651

         psl_set_value(p, p_psl_fl_property());

1✔

12652

         consume(tRPAREN);

1✔

12654

         psl_set_loc(p, CURRENT_LOC);

1✔

12656

      break;

1✔

12658

   case tLPAREN:

233✔

12660

         consume(tLPAREN);

233✔

12661

         p = p_psl_fl_property();

233✔

12662

         consume(tRPAREN);

233✔

12664

         if (psl_kind(p) == P_HDL_EXPR && is_vhdl_infix_op(peek())) {

233✔

12668

            tree_t expr = p_expression_with_head(psl_tree(p));

14✔

12669

            psl_set_tree(p, expr);

14✔

12672

         psl_set_loc(p, CURRENT_LOC);

233✔

12674

      break;

233✔

12676

   case tLBRACE:

61✔

12681

      p = p_psl_sequence();

61✔

12682

      break;

61✔

12684

   default:

522✔

12685

      p = p_hdl_expression(NULL, PSL_TYPE_BOOLEAN);

522✔

12686

      break;

522✔

12689

   const token_t infix = peek();

1,084✔

12690

   switch (infix) {

1,084✔

12691

   case tIFIMPL:

165✔

12696

         consume(infix);

165✔

12698

         psl_logic_t kind;

165✔

12699

         switch (infix) {

165✔

12701

         case tOR:      kind = PSL_LOGIC_OR; break;

30✔

12702

         case tIFIMPL:  kind = PSL_LOGIC_IF; break;

120✔

12703

         case tIFFIMPL: kind = PSL_LOGIC_IFF; break;

6✔

12707

         psl_node_t right = p_psl_fl_property();

165✔

12711

         const bool prefer_hdl =

330✔

12712

            (kind == PSL_LOGIC_OR || kind == PSL_LOGIC_AND)

165✔

12713

            && psl_kind(p) == P_HDL_EXPR && psl_kind(right) == P_HDL_EXPR;

165✔

12715

         if (prefer_hdl) {

165✔

12716

            ident_t op = well_known(kind == PSL_LOGIC_OR ? W_OP_OR : W_OP_AND);

38✔

12718

            tree_t fcall = tree_new(T_FCALL);

29✔

12719

            tree_set_ident(fcall, op);

29✔

12720

            tree_set_loc(fcall, CURRENT_LOC);

29✔

12721

            add_param(fcall, psl_tree(p), P_POS, NULL);

29✔

12722

            add_param(fcall, psl_tree(right), P_POS, NULL);

29✔

12724

            psl_set_tree(p, fcall);

29✔

12725

            psl_set_loc(p, CURRENT_LOC);

29✔

12726

            return p;

29✔

12729

            psl_node_t log = psl_new(P_LOGICAL);

136✔

12730

            psl_set_subkind(log, kind);

136✔

12731

            psl_add_operand(log, p);

136✔

12732

            psl_add_operand(log, right);

136✔

12733

            psl_set_loc(log, CURRENT_LOC);

136✔

12735

            return log;

136✔

12739

   case tSUFFIXOVR:

11✔

12742

         consume(infix);

11✔

12744

         const psl_suffix_impl_t kind =

11✔

12745

            infix == tSUFFIXOVR ? PSL_SUFFIX_OVERLAP : PSL_SUFFIX_NON;

11✔

12747

         psl_node_t suff = psl_new(P_SUFFIX_IMPL);

11✔

12748

         psl_set_subkind(suff, kind);

11✔

12749

         psl_add_operand(suff, p);

11✔

12750

         psl_add_operand(suff, p_psl_fl_property());

11✔

12751

         psl_set_loc(suff, CURRENT_LOC);

11✔

12753

         return suff;

11✔

12756

   case tUNTIL:

26✔

12761

         consume(infix);

26✔

12763

         psl_flags_t flags = 0;

26✔

12764

         if (infix == tUNTIL1 || infix == tUNTIL1_)

26✔

12765

            flags |= PSL_F_STRONG;

3✔

12766

         if (infix == tUNTIL_ || infix == tUNTIL1_)

26✔

12767

            flags |= PSL_F_INCLUSIVE;

13✔

12769

         psl_node_t until = psl_new(P_UNTIL);

26✔

12770

         psl_set_flag(until, flags);

26✔

12771

         psl_add_operand(until, p);

26✔

12772

         psl_add_operand(until, p_psl_fl_property());

26✔

12773

         psl_set_loc(until, CURRENT_LOC);

26✔

12775

         return until;

26✔

12778

   case tBEFORE:

9✔

12783

         consume(infix);

9✔

12785

         psl_flags_t flags = 0;

9✔

12786

         if (infix == tBEFORE1 || infix == tBEFORE1_)

9✔

12787

            flags |= PSL_F_STRONG;

1✔

12788

         if (infix == tBEFORE_ || infix == tBEFORE1_)

9✔

12789

            flags |= PSL_F_INCLUSIVE;

3✔

12791

         psl_node_t until = psl_new(P_BEFORE);

9✔

12792

         psl_set_flag(until, flags);

9✔

12793

         psl_add_operand(until, p);

9✔

12794

         psl_add_operand(until, p_psl_fl_property());

9✔

12795

         psl_set_loc(until, CURRENT_LOC);

9✔

12797

         return until;

9✔

12800

   case tABORT:

9✔

12804

         consume(infix);

9✔

12806

         const psl_abort_t kind =

9✔

12807

            infix == tSYNC_ABORT ? PSL_ABORT_SYNC : PSL_ABORT_ASYNC;

9✔

12809

         psl_node_t abort = psl_new(P_ABORT);

9✔

12810

         psl_set_subkind(abort, kind);

9✔

12811

         psl_add_operand(abort, p);

9✔

12812

         psl_add_operand(abort, p_hdl_expression(NULL, PSL_TYPE_BOOLEAN));

9✔

12813

         psl_set_loc(abort, CURRENT_LOC);

9✔

12815

         return abort;

9✔

12818

   case tAT:

4✔

12820

         consume(tAT);

4✔

12822

         tree_t expr = p_expression();

4✔

12823

         solve_types(nametab, expr, std_type(NULL, STD_BOOLEAN));

4✔

12825

         psl_node_t clk = psl_new(P_CLOCKED);

4✔

12826

         psl_set_value(clk, p);

4✔

12827

         psl_set_tree(clk, expr);

4✔

12829

         psl_set_loc(clk, CURRENT_LOC);

4✔

12830

         return clk;

4✔

12838

static void p_psl_report(psl_node_t p)

106✔

12840

   consume(tREPORT);

106✔

12842

   tree_t m = p_expression();

106✔

12843

   psl_set_message(p, m);

106✔

12844

   solve_types(nametab, m, std_type(NULL, STD_STRING));

106✔

12845

106✔

12847

static psl_node_t p_psl_property(void)

371✔

12851

   BEGIN("property");

742✔

12853

   return p_psl_fl_property();

371✔

12856

static psl_node_t p_psl_assert_directive(void)

183✔

12860

   BEGIN("assert directive");

183✔

12862

   consume(tASSERT);

183✔

12864

   psl_node_t p = with_default_clock(p_psl_property());

183✔

12866

   psl_node_t a = psl_new(P_ASSERT);

183✔

12867

   psl_set_value(a, p);

183✔

12869

   if (peek() == tREPORT)

183✔

12870

      p_psl_report(a);

15✔

12872

   consume(tSEMI);

183✔

12874

   psl_set_loc(a, CURRENT_LOC);

183✔

12875

   return a;

183✔

12878

static psl_node_t p_psl_assume_directive(void)

4✔

12883

   BEGIN("assume directive");

4✔

12885

   token_t tok = one_of(tASSUME, tASSUMEG);

4✔

12887

   psl_node_t a = psl_new(P_ASSUME);

4✔

12888

   if (tok == tASSUME)

4✔

12889

      psl_set_subkind(a, PSL_NO_GUARANTEE);

3✔

12891

      psl_set_subkind(a, PSL_GUARANTEE);

1✔

12893

   psl_node_t p = with_default_clock(p_psl_property());

4✔

12894

   psl_set_value(a, p);

4✔

12896

   if (peek() == tREPORT && tok == tASSUMEG)

4✔

12897

      p_psl_report(a);

1✔

12899

   consume(tSEMI);

4✔

12901

   psl_set_loc(a, CURRENT_LOC);

4✔

12902

   return a;

4✔

12905

static psl_node_t p_psl_restrict_directive(void)

4✔

12910

   BEGIN("restrict directive");

4✔

12912

   token_t tok = peek();

4✔

12913

   assert(tok == tRESTRICT || tok == tRESTRICTG);

4✔

12914

   consume(tok);

4✔

12916

   psl_node_t a = psl_new(P_RESTRICT);

4✔

12917

   if (tok == tRESTRICT)

4✔

12918

      psl_set_subkind(a, PSL_NO_GUARANTEE);

3✔

12920

      psl_set_subkind(a, PSL_GUARANTEE);

1✔

12922

   psl_node_t p = with_default_clock(p_psl_sequence());

4✔

12923

   psl_set_value(a, p);

4✔

12925

   if (peek() == tREPORT && tok == tRESTRICTG)

4✔

12926

      p_psl_report(a);

1✔

12928

   consume(tSEMI);

4✔

12930

   psl_set_loc(a, CURRENT_LOC);

4✔

12931

   return a;

4✔

12934

static psl_node_t p_psl_fairness(void)

3✔

12939

   BEGIN("fairness statement");

3✔

12941

   psl_flags_t flags = 0;

3✔

12942

   if (optional(tSTRONG))

3✔

12943

      flags |= PSL_F_STRONG;

1✔

12945

   consume(tFAIRNESS);

3✔

12947

   psl_node_t a = psl_new(P_FAIRNESS);

3✔

12948

   psl_set_flag(a, flags);

3✔

12950

   tree_t e1 = p_expression();

3✔

12951

   solve_psl_condition(nametab, &e1);

3✔

12953

   psl_node_t p1 = psl_new(P_HDL_EXPR);

3✔

12954

   psl_set_tree(p1, e1);

3✔

12956

   psl_add_operand(a, p1);

3✔

12958

   if (flags & PSL_F_STRONG) {

3✔

12959

      consume(tCOMMA);

1✔

12961

      tree_t e2 = p_expression();

1✔

12962

      solve_psl_condition(nametab, &e2);

1✔

12964

      psl_node_t p2 = psl_new(P_HDL_EXPR);

1✔

12965

      psl_set_tree(p2, e2);

1✔

12967

      psl_add_operand(a, p2);

1✔

12970

   consume(tSEMI);

3✔

12972

   psl_set_loc(a, CURRENT_LOC);

3✔

12973

   return a;

3✔

12976

static psl_node_t p_psl_cover_directive(void)

141✔

12980

   BEGIN("cover directive");

141✔

12982

   consume(tCOVER);

141✔

12984

   psl_node_t p = with_default_clock(p_psl_sequence());

141✔

12986

   psl_node_t a = psl_new(P_COVER);

141✔

12987

   psl_set_value(a, p);

141✔

12989

   if (peek() == tREPORT)

141✔

12990

      p_psl_report(a);

89✔

12992

   consume(tSEMI);

141✔

12994

   psl_set_loc(a, CURRENT_LOC);

141✔

12995

   return a;

141✔

12998

static psl_node_t p_psl_verification_directive(void)

336✔

13003

   BEGIN("verification directive");

672✔

13005

   switch (peek()) {

336✔

13006

   case tASSERT:

183✔

13007

      return p_psl_assert_directive();

183✔

13008

   case tASSUME:

4✔

13010

      return p_psl_assume_directive();

4✔

13011

   case tRESTRICT:

4✔

13013

      return p_psl_restrict_directive();

4✔

13014

   case tFAIRNESS:

3✔

13016

      return p_psl_fairness();

3✔

13017

   case tCOVER:

141✔

13018

      return p_psl_cover_directive();

141✔

13019

   default:

1✔

13020

      one_of(tASSERT, tASSUME, tASSUMEG, tRESTRICT, tRESTRICTG, tFAIRNESS,

1✔

13022

      return NULL;

1✔

13026

static tree_t p_psl_directive(ident_t label)

336✔

13030

   BEGIN("PSL directive");

336✔

13032

   tree_t t = tree_new(T_PSL_DIRECT);

336✔

13034

   scan_as_psl();

336✔

13038

   push_scope(nametab);

336✔

13039

   insert_names_for_psl(nametab);

336✔

13041

   psl_node_t p = p_psl_verification_directive();

336✔

13043

   scan_as_vhdl();

336✔

13045

   if (p != NULL) {

336✔

13046

      tree_set_psl(t, p);

335✔

13047

      psl_check(p, nametab);

335✔

13050

   pop_scope(nametab);

336✔

13052

   tree_set_loc(t, CURRENT_LOC);

336✔

13053

   ensure_labelled(t, label);

336✔

13055

   if (label) insert_name(nametab, t, NULL);

336✔

13057

   return t;

336✔

13060

static tree_t p_psl_property_declaration(void)

21✔

13064

   BEGIN("PSL property declaration");

21✔

13066

   scan_as_psl();

21✔

13068

   psl_node_t decl = psl_new(P_PROPERTY_DECL);

21✔

13070

   consume(tPROPERTY);

21✔

13072

   ident_t ident = p_identifier();

21✔

13073

   psl_set_ident(decl, ident);

21✔

13075

   tree_t t = tree_new(T_PSL_DECL);

21✔

13076

   tree_set_psl(t, decl);

21✔

13077

   tree_set_ident(t, ident);

21✔

13078

   insert_name(nametab, t, NULL);

21✔

13080

   push_scope(nametab);

21✔

13081

   scope_set_container(nametab, t);

21✔

13082

   insert_names_for_psl(nametab);

21✔

13084

   if (optional(tLPAREN)) {

21✔

13085

      p_psl_formal_parameter_list(decl);

19✔

13086

      consume(tRPAREN);

19✔

13089

   consume(tIS);

21✔

13091

   psl_node_t prop = p_psl_property();

21✔

13092

   psl_set_value(decl, prop);

21✔

13094

   consume(tSEMI);

21✔

13096

   psl_set_loc(decl, CURRENT_LOC);

21✔

13097

   psl_check(decl, nametab);

21✔

13099

   pop_scope(nametab);

21✔

13101

   scan_as_vhdl();

21✔

13103

   tree_set_loc(t, CURRENT_LOC);

21✔

13104

   return t;

21✔

13107

static tree_t p_psl_sequence_declaration(void)

5✔

13111

   BEGIN("PSL sequence declaration");

5✔

13113

   scan_as_psl();

5✔

13115

   psl_node_t decl = psl_new(P_SEQUENCE_DECL);

5✔

13117

   consume(tSEQUENCE);

5✔

13119

   ident_t ident = p_identifier();

5✔

13120

   psl_set_ident(decl, ident);

5✔

13122

   tree_t t = tree_new(T_PSL_DECL);

5✔

13123

   tree_set_psl(t, decl);

5✔

13124

   tree_set_ident(t, ident);

5✔

13125

   insert_name(nametab, t, NULL);

5✔

13127

   push_scope(nametab);

5✔

13128

   scope_set_container(nametab, t);

5✔

13129

   insert_names_for_psl(nametab);

5✔

13131

   if (optional(tLPAREN)) {

5✔

13132

      p_psl_formal_parameter_list(decl);

1✔

13133

      consume(tRPAREN);

1✔

13136

   consume(tIS);

5✔

13138

   psl_node_t prop = p_psl_sequence();

5✔

13139

   psl_set_value(decl, prop);

5✔

13141

   consume(tSEMI);

5✔

13143

   psl_set_loc(decl, CURRENT_LOC);

5✔

13144

   psl_check(decl, nametab);

5✔

13146

   pop_scope(nametab);

5✔

13148

   scan_as_vhdl();

5✔

13150

   tree_set_loc(t, CURRENT_LOC);

5✔

13151

   return t;

5✔

13154

static tree_t p_psl_endpoint_declaration(void)

1✔

13158

   BEGIN("PSL endpoint declaration");

1✔

13160

   scan_as_psl();

1✔

13162

   psl_node_t decl = psl_new(P_ENDPOINT_DECL);

1✔

13164

   consume(tENDPOINT);

1✔

13166

   ident_t ident = p_identifier();

1✔

13167

   psl_set_ident(decl, ident);

1✔

13169

   tree_t t = tree_new(T_PSL_DECL);

1✔

13170

   tree_set_psl(t, decl);

1✔

13171

   tree_set_ident(t, ident);

1✔

13172

   insert_name(nametab, t, NULL);

1✔

13174

   push_scope(nametab);

1✔

13175

   insert_names_for_psl(nametab);

1✔

13177

   consume(tIS);

1✔

13179

   psl_node_t prop = p_psl_sequence();

1✔

13180

   psl_set_value(decl, prop);

1✔

13182

   consume(tSEMI);

1✔

13184

   psl_set_loc(decl, CURRENT_LOC);

1✔

13185

   psl_check(decl, nametab);

1✔

13187

   pop_scope(nametab);

1✔

13189

   scan_as_vhdl();

1✔

13191

   tree_set_loc(t, CURRENT_LOC);

1✔

13192

   return t;

1✔

13195

static void p_psl_declaration(tree_t parent)

123✔

13199

   BEGIN("PSL declaration");

246✔

13201

   switch (peek()) {

123✔

13202

   case tPROPERTY:

21✔

13203

      tree_add_decl(parent, p_psl_property_declaration());

21✔

13204

      break;

21✔

13205

   case tSEQUENCE:

5✔

13206

      tree_add_decl(parent, p_psl_sequence_declaration());

5✔

13207

      break;

5✔

13208

   case tDEFAULT:

96✔

13209

      tree_add_decl(parent, p_psl_clock_declaration());

96✔

13210

      break;

96✔

13211

   case tENDPOINT:

1✔

13212

      tree_add_decl(parent, p_psl_endpoint_declaration());

1✔

13213

      break;

1✔

13218

123✔

13220

static tree_t p_psl_or_concurrent_assert(ident_t label)

163✔

13228

   BEGIN("PSL or concurrent assertion statement");

326✔

13230

   if (peek() == tPOSTPONED)

163✔

13233

   consume(tASSERT);

163✔

13235

   push_scope(nametab);

163✔

13236

   insert_names_for_psl(nametab);

163✔

13238

   scan_as_psl();

163✔

13240

   psl_node_t p = p_psl_property();

163✔

13242

   scan_as_vhdl();

163✔

13244

   tree_t conc;

163✔

13245

   if (psl_kind(p) == P_HDL_EXPR) {

163✔

13246

      tree_t value = psl_tree(p);

118✔

13247

      solve_condition(nametab, &value);

118✔

13249

      tree_t s = tree_new(T_ASSERT);

118✔

13250

      tree_set_value(s, value);

118✔

13252

      if (optional(tREPORT)) {

118✔

13253

         tree_t message = p_expression();

24✔

13254

         solve_types(nametab, message, std_type(NULL, STD_STRING));

24✔

13255

         tree_set_message(s, message);

24✔

13258

      if (optional(tSEVERITY)) {

118✔

13259

         tree_t severity = p_expression();

24✔

13260

         solve_types(nametab, severity, std_type(NULL, STD_SEVERITY_LEVEL));

24✔

13261

         tree_set_severity(s, severity);

24✔

13264

      consume(tSEMI);

118✔

13266

      tree_set_loc(s, CURRENT_LOC);

118✔

13268

      conc = tree_new(T_CONCURRENT);

118✔

13269

      tree_add_stmt(conc, s);

118✔

13272

      psl_node_t a = psl_new(P_ASSERT);

45✔

13273

      psl_set_value(a, with_default_clock(p));

45✔

13275

      if (peek() == tREPORT)

45✔

13278

      consume(tSEMI);

45✔

13280

      psl_set_loc(a, CURRENT_LOC);

45✔

13281

      psl_check(a, nametab);

45✔

13283

      conc = tree_new(T_PSL_DIRECT);

45✔

13284

      tree_set_psl(conc, a);

45✔

13287

   pop_scope(nametab);

163✔

13289

   tree_set_loc(conc, CURRENT_LOC);

163✔

13290

   ensure_labelled(conc, label);

163✔

13292

   if (label) insert_name(nametab, conc, NULL);

163✔

13293

   sem_check(conc, nametab);

163✔

13294

   return conc;

163✔

13297

static tree_t p_concurrent_statement(void)

10,846✔

13305

   BEGIN("concurrent statement");

21,689✔

13307

   ident_t label = NULL;

10,846✔

13308

   if ((peek() == tID) && (peek_nth(2) == tCOLON)) {

10,846✔

13309

      label = p_identifier();

5,949✔

13310

      consume(tCOLON);

5,949✔

13313

   switch (peek()) {

10,846✔

13314

   case tPROCESS:

4,977✔

13315

      return p_process_statement(label);

4,977✔

13317

   case tCOMPONENT:

1,338✔

13320

      return p_component_instantiation_statement(label, NULL);

1,338✔

13322

   case tWITH:

47✔

13323

      return p_concurrent_signal_assignment_statement(label, NULL);

47✔

13325

   case tASSERT:

1,075✔

13326

      if (standard() >= STD_08)

1,075✔

13327

         return p_psl_or_concurrent_assert(label);

163✔

13329

         return p_concurrent_assertion_statement(label);

912✔

13331

   case tCOVER:

2✔

13332

      return p_psl_directive(label);

2✔

13334

   case tBLOCK:

426✔

13335

      return p_block_statement(label);

426✔

13337

   case tIF:

373✔

13340

      return p_generate_statement(label);

373✔

13342

   case tLPAREN:

18✔

13344

      return p_concurrent_signal_assignment_statement(label, NULL);

18✔

13346

   case tID:

2,533✔

13348

         const token_t p2 = peek_nth(2);

2,533✔

13349

         if ((label != NULL && p2 == tSEMI) || p2 == tGENERIC || p2 == tPORT)

2,533✔

13350

            return p_component_instantiation_statement(label, NULL);

228✔

13352

            tree_t name = p_name(N_SUBPROGRAM), conc;

2,305✔

13353

            if (peek() == tLE)

2,305✔

13354

               return p_concurrent_signal_assignment_statement(label, name);

2,238✔

13355

            else if (scan(tGENERIC, tPORT))

67✔

13356

               return p_component_instantiation_statement(label, name);

3✔

13358

               switch (tree_kind(name)) {

64✔

13359

               case T_REF:

59✔

13360

                  if (tree_has_ref(name)) {

59✔

13361

                     tree_t decl = tree_ref(name);

53✔

13362

                     if (tree_kind(decl) == T_COMPONENT)

53✔

13367

                  return p_concurrent_procedure_call_statement(label, name);

62✔

13368

               default:

2✔

13369

                  parse_error(CURRENT_LOC, "expected concurrent statement");

2✔

13370

                  drop_tokens_until(tSEMI);

2✔

13371

                  return ensure_labelled(tree_new(T_CONCURRENT), label);

2✔

13379

   case tPOSTPONED:

49✔

13381

         const token_t tok2 = peek_nth(2);

49✔

13382

         if (tok2 == tASSERT)

49✔

13383

            return p_concurrent_assertion_statement(label);

22✔

13384

         else if (tok2 == tID || tok2 == tLPAREN) {

27✔

13385

            consume(tPOSTPONED);

2✔

13387

            tree_t name = p_name(N_SUBPROGRAM), conc;

2✔

13388

            if (peek() == tLE)

2✔

13389

               conc = p_concurrent_signal_assignment_statement(label, name);

2✔

13393

            tree_set_flag(conc, TREE_F_POSTPONED);

2✔

13394

            return conc;

2✔

13397

            return p_process_statement(label);

25✔

13399

   default:

8✔

13400

      expect(tPROCESS, tPOSTPONED, tCOMPONENT, tENTITY, tCONFIGURATION,

15✔

13403

      drop_tokens_until(tSEMI);

8✔

13404

      return ensure_labelled(tree_new(T_BLOCK), label);

8✔

13408

static void p_architecture_declarative_part(tree_t arch)

5,217✔

13412

   BEGIN("architecture declarative part");

10,434✔

13414

   while (not_at_token(tBEGIN))

17,632✔

13415

      p_block_declarative_item(arch);

12,415✔

13416

5,217✔

13418

static void p_architecture_statement_part(tree_t arch)

5,217✔

13422

   BEGIN("architecture statement part");

10,431✔

13424

   while (not_at_token(tEND))

15,540✔

13425

      p_concurrent_statement_or_psl(arch);

10,326✔

13426

5,214✔

13428

static void p_architecture_body(tree_t unit)

5,217✔

13434

   BEGIN("architecture body");

10,431✔

13436

   tree_change_kind(unit, T_ARCH);

5,217✔

13438

   consume(tARCHITECTURE);

5,217✔

13440

   ident_t arch_name = p_identifier();

5,217✔

13441

   tree_set_ident(unit, arch_name);

5,217✔

13443

   consume(tOF);

5,217✔

13445

   tree_t e = NULL;

5,217✔

13446

   ident_t entity_name = p_entity_name(&e);

5,217✔

13447

   tree_set_ident2(unit, entity_name);

5,217✔

13449

   consume(tIS);

5,217✔

13451

   if (e != NULL) {

5,217✔

13452

      tree_set_primary(unit, e);

5,214✔

13453

      insert_names_from_context(nametab, e);

5,214✔

13456

   push_scope(nametab);

5,217✔

13458

   if (entity_name != arch_name && e != NULL)

5,217✔

13459

      insert_name(nametab, e, entity_name);

5,164✔

13461

   ident_t ename = ident_prefix(lib_name(lib_work()), entity_name, '.');

5,217✔

13462

   ident_t qual = ident_prefix(ename, arch_name, '-');

5,217✔

13463

   scope_set_prefix(nametab, qual);

5,217✔

13465

   tree_set_loc(unit, CURRENT_LOC);

5,217✔

13466

   insert_name(nametab, unit, NULL);

5,217✔

13468

   push_scope(nametab);

5,217✔

13469

   scope_set_container(nametab, unit);

5,217✔

13471

   if (e != NULL) {

5,217✔

13472

      insert_generics(nametab, e);

5,214✔

13473

      insert_ports(nametab, e);

5,214✔

13474

      insert_decls(nametab, e);

5,214✔

13477

   continue_proc_labelling_from(e, nametab);

5,217✔

13479

   p_architecture_declarative_part(unit);

5,217✔

13481

   consume(tBEGIN);

5,217✔

13483

   p_architecture_statement_part(unit);

5,217✔

13485

   consume(tEND);

5,214✔

13486

   optional(tARCHITECTURE);

5,214✔

13487

   p_trailing_label(arch_name);

5,214✔

13488

   consume(tSEMI);

5,214✔

13490

   tree_set_ident(unit, qual);

5,214✔

13491

   tree_set_loc(unit, CURRENT_LOC);

5,214✔

13493

   sem_check(unit, nametab);

5,214✔

13495

   pop_scope(nametab);

5,214✔

13496

   pop_scope(nametab);

5,214✔

13497

5,214✔

13499

static void p_package_body_declarative_item(tree_t parent)

8,330✔

13510

   BEGIN("package body declarative item");

16,660✔

13512

   switch (peek()) {

8,330✔

13513

   case tFUNCTION:

6,993✔

13517

      if (peek_nth(3) == tIS && peek_nth(4) == tNEW)

6,993✔

13518

         tree_add_decl(parent, p_subprogram_instantiation_declaration());

1✔

13520

         tree_t spec = p_subprogram_specification();

6,992✔

13521

         if (peek() == tSEMI)

6,992✔

13522

            tree_add_decl(parent, p_subprogram_declaration(spec));

34✔

13524

            tree_add_decl(parent, p_subprogram_body(spec));

6,958✔

13528

   case tSHARED:

25✔

13529

      p_variable_declaration(parent);

25✔

13530

      break;

25✔

13532

   case tFILE:

7✔

13533

      p_file_declaration(parent);

7✔

13534

      break;

7✔

13536

   case tATTRIBUTE:

35✔

13537

      if (peek_nth(3) == tOF)

35✔

13538

         p_attribute_specification(parent);

35✔

13542

      if (standard() < STD_08)

35✔

13543

         parse_error(tree_loc(tree_decl(parent, tree_decls(parent) - 1)),

1✔

13548

   case tTYPE:

360✔

13549

      p_type_declaration(parent);

360✔

13550

      break;

360✔

13552

   case tCONSTANT:

794✔

13553

      p_constant_declaration(parent);

794✔

13554

      break;

794✔

13556

   case tSUBTYPE:

48✔

13557

      tree_add_decl(parent, p_subtype_declaration());

48✔

13558

      break;

48✔

13560

   case tALIAS:

13✔

13561

      p_alias_declaration(parent);

13✔

13562

      break;

13✔

13564

   case tUSE:

34✔

13565

      p_use_clause(parent, tree_add_decl);

34✔

13566

      break;

34✔

13575

   case tPACKAGE:

18✔

13576

      if (peek_nth(4) == tNEW)

18✔

13577

         tree_add_decl(parent, p_package_instantiation_declaration(NULL));

16✔

13578

      else if (peek_nth(2) == tBODY) {

2✔

13579

         require_std(STD_08, "nested package declarations");

1✔

13580

         tree_add_decl(parent, p_package_body(NULL));

1✔

13583

         require_std(STD_08, "nested package declarations");

1✔

13584

         tree_add_decl(parent, p_package_declaration(NULL));

1✔

13588

   default:

3✔

13589

      expect(tFUNCTION, tPROCEDURE, tSHARED, tIMPURE, tPURE, tATTRIBUTE, tTYPE,

6✔

13593

8,330✔

13595

static void p_package_body_declarative_part(tree_t unit)

798✔

13599

   BEGIN("package body declarative part");

1,596✔

13601

   while (not_at_token(tEND))

9,128✔

13602

      p_package_body_declarative_item(unit);

8,330✔

13603

798✔

13605

static tree_t p_package_body(tree_t unit)

798✔

13610

   BEGIN("package body");

798✔

13612

   consume(tPACKAGE);

798✔

13613

   consume(tBODY);

798✔

13615

   ident_t name = p_identifier(), qual = name;

798✔

13617

   tree_t body;

798✔

13618

   if (unit != NULL) {

798✔

13620

      assert(tree_kind(unit) == T_DESIGN_UNIT);

797✔

13621

      tree_change_kind(unit, T_PACK_BODY);

797✔

13622

      body = unit;

797✔

13624

      qual = ident_prefix(lib_name(lib_work()), name, '.');

797✔

13627

      body = tree_new(T_PACK_BODY);

1✔

13629

   tree_t pack = resolve_name(nametab, CURRENT_LOC, qual);

798✔

13630

   if (pack != NULL && tree_kind(pack) != T_PACKAGE) {

798✔

13634

   else if (pack != NULL) {

798✔

13635

      tree_set_primary(body, pack);

793✔

13636

      insert_names_from_context(nametab, pack);

793✔

13639

   push_scope(nametab);

798✔

13641

   tree_set_ident(body, ident_prefix(qual, ident_new("body"), '-'));

798✔

13642

   tree_set_loc(body, CURRENT_LOC);

798✔

13644

   scope_set_prefix(nametab, qual);

798✔

13645

   insert_name(nametab, body, name);

798✔

13647

   consume(tIS);

798✔

13649

   push_scope(nametab);

798✔

13650

   scope_set_container(nametab, body);

798✔

13652

   if (pack != NULL) {

798✔

13653

      insert_generics(nametab, pack);

793✔

13654

      insert_decls(nametab, pack);

793✔

13657

   p_package_body_declarative_part(body);

798✔

13659

   if (pack != NULL && (tree_global_flags(pack) & TREE_GF_DEFERRED_INST))

798✔

13660

      package_body_deferred_instantiation(pack, body);

4✔

13662

   consume(tEND);

798✔

13664

   if (optional(tPACKAGE))

798✔

13665

      consume(tBODY);

706✔

13667

   p_trailing_label(name);

798✔

13668

   consume(tSEMI);

798✔

13670

   tree_set_loc(body, CURRENT_LOC);

798✔

13671

   sem_check(body, nametab);

798✔

13673

   pop_scope(nametab);

798✔

13674

   pop_scope(nametab);

798✔

13676

   return body;

798✔

13679

static void p_secondary_unit(tree_t unit)

6,014✔

13683

   BEGIN("secondary unit");

12,025✔

13685

   switch (peek()) {

6,014✔

13686

   case tARCHITECTURE:

5,217✔

13687

      p_architecture_body(unit);

5,217✔

13688

      break;

5,217✔

13690

   case tPACKAGE:

797✔

13691

      p_package_body(unit);

797✔

13692

      break;

797✔

13697

6,011✔

13699

static void p_library_unit(tree_t unit)

12,914✔

13703

   BEGIN("library unit");

12,914✔

13705

   switch (peek()) {

12,914✔

13706

   case tENTITY:

5,336✔

13709

      p_primary_unit(unit);

5,336✔

13710

      break;

5,336✔

13712

   case tARCHITECTURE:

5,217✔

13713

      p_secondary_unit(unit);

5,217✔

13714

      break;

5,217✔

13716

   case tPACKAGE:

2,357✔

13717

      if (peek_nth(2) == tBODY)

2,357✔

13718

         p_secondary_unit(unit);

797✔

13720

         p_primary_unit(unit);

1,560✔

13723

   default:

4✔

13724

      expect(tENTITY, tCONFIGURATION, tARCHITECTURE, tPACKAGE,

7✔

13728

   if (bootstrapping && unit != find_std(nametab))

12,911✔

13729

      parse_error(tree_loc(unit), "--bootstrap must only be used with "

12,911✔

13731

12,911✔

13733

static tree_t p_design_unit(void)

12,914✔

13735

   BEGIN("design unit");

12,914✔

13737

   push_scope(nametab);

12,914✔

13739

   tree_t unit = tree_new(T_DESIGN_UNIT);

12,914✔

13740

   scope_set_container(nametab, unit);

12,914✔

13742

   ident_t std_i = well_known(W_STD);

12,914✔

13744

   tree_t std = tree_new(T_LIBRARY);

12,914✔

13745

   tree_set_ident(std, std_i);

12,914✔

13746

   tree_set_ident2(std, std_i);

12,914✔

13747

   tree_add_context(unit, std);

12,914✔

13748

   insert_name(nametab, std, std_i);

12,914✔

13750

   ident_t work_name = lib_name(lib_work());

12,914✔

13751

   tree_t work = tree_new(T_LIBRARY);

12,914✔

13752

   tree_set_ident(work, work_name);

12,914✔

13753

   tree_set_ident2(work, work_name);

12,914✔

13754

   tree_add_context(unit, work);

12,914✔

13755

   insert_name(nametab, work, well_known(W_WORK));

12,914✔

13756

   insert_name(nametab, work, NULL);

12,914✔

13759

   if (!bootstrapping) {

12,914✔

13760

      lib_t lstd = lib_require(std_i);

12,911✔

13761

      ident_t standard_i = well_known(W_STD_STANDARD);

12,911✔

13762

      tree_t std_pkg = lib_get(lstd, standard_i);

12,911✔

13763

      if (std_pkg == NULL)

12,911✔

13766

      tree_t u = tree_new(T_USE);

12,911✔

13767

      tree_set_ident(u, standard_i);

12,911✔

13768

      tree_set_ident2(u, well_known(W_ALL));

12,911✔

13769

      tree_set_ref(u, std_pkg);

12,911✔

13771

      tree_add_context(unit, u);

12,911✔

13772

      insert_names_from_use(nametab, u);

12,911✔

13775

   p_context_clause(unit);

12,914✔

13776

   p_library_unit(unit);

12,914✔

13778

   pop_scope(nametab);

12,911✔

13780

   return unit;

12,911✔

13783

static void flush_pragmas(tree_t unit)

12,911✔

13786

   tree_t coverage_off = NULL, synthesis_off = NULL, translate_off = NULL;

12,911✔

13788

   for (int i = 0; i < pragmas.count; i++) {

12,970✔

13789

      tree_t p = pragmas.items[i];

59✔

13790

      tree_add_pragma(unit, p);

59✔

13792

      switch (tree_subkind(p)) {

59✔

13793

      case PRAGMA_SYNTHESIS_ON: synthesis_off = NULL; break;

3✔

13794

      case PRAGMA_SYNTHESIS_OFF: synthesis_off = p; break;

4✔

13795

      case PRAGMA_COVERAGE_ON: coverage_off = NULL; break;

25✔

13796

      case PRAGMA_COVERAGE_OFF: coverage_off = p; break;

26✔

13798

      case PRAGMA_TRANSLATE_OFF: translate_off = p; break;

1✔

13802

   if (coverage_off != NULL)

12,911✔

13803

      warn_at(tree_loc(coverage_off), "no matching $bold$coverage on$$ "

1✔

13806

   if (synthesis_off != NULL)

12,911✔

13807

      warn_at(tree_loc(synthesis_off), "no matching $bold$synthesis "

1✔

13810

   if (translate_off != NULL)

12,911✔

13811

      warn_at(tree_loc(translate_off), "no matching $bold$pragma "

1✔

13814

   ACLEAR(pragmas);

12,911✔

13815

12,911✔

13817

tree_t parse(void)

17,436✔

13819

   n_correct = RECOVER_THRESH;

17,436✔

13821

   scan_as_vhdl();

17,436✔

13823

   if (peek() == tEOF)

17,436✔

13826

   make_new_arena();

12,914✔

13827

   nametab = nametab_new();

12,914✔

13829

   tree_t unit = p_design_unit();

12,914✔

13831

   nametab_finish(nametab);

12,911✔

13832

   nametab = NULL;

12,911✔

13834

   flush_pragmas(unit);

12,911✔

13836

   if (tree_kind(unit) == T_DESIGN_UNIT)

12,911✔

13837

      return NULL;

4✔

13842

void reset_vhdl_parser(void)

4,512✔

13844

   bootstrapping = opt_get_int(OPT_BOOTSTRAP);

4,512✔

13846

   if (tokenq == NULL) {

4,512✔

13847

      tokenq_sz = 128;

4,497✔

13848

      tokenq = xmalloc_array(tokenq_sz, sizeof(tokenq_t));

4,497✔

13851

   tokenq_head = tokenq_tail = 0;

4,512✔

13852

4,512✔

nickg / nvc / 19989699650

Source File
Press 'n' to go to next uncovered line, 'b' for previous

nickg / nvc / 19989699650

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous