nickg/nvc | Build 21785130883 | src/type.c | Coveralls - Test Coverage History & Statistics

109

static inline tree_t tree_array_nth(item_t *item, unsigned n)

27,917,807✔

111

   object_t *o = obj_array_nth(item->obj_array, n);

27,917,807✔

112

   return container_of(o, struct _tree, object);

27,917,807✔

115

static inline void tree_array_add(item_t *item, tree_t t)

10,322✔

117

   obj_array_add(&(item->obj_array), &(t->object));

10,322✔

118

10,322✔

120

static inline type_t type_array_nth(item_t *item, unsigned n)

3,606,619✔

122

   object_t *o = obj_array_nth(item->obj_array, n);

3,606,619✔

123

   return container_of(o, struct _type, object);

3,606,619✔

126

static inline void type_array_add(item_t *item, type_t t)

111,243✔

128

   obj_array_add(&(item->obj_array), &(t->object));

111,243✔

129

111,243✔

131

type_t type_new(type_kind_t kind)

108,541✔

133

   object_t *o = object_new(NULL, &type_object, kind);

108,541✔

134

   return container_of(o, struct _type, object);

108,541✔

137

type_kind_t type_kind(type_t t)

10,183,237✔

139

   assert(t != NULL);

10,183,237✔

140

   return t->object.kind;

10,183,237✔

143

static inline type_t type_base_map(type_t t, hash_t *map)

1,349,409✔

145

   assert(t->object.kind == T_SUBTYPE);

1,349,409✔

146

   type_t base = type_base(t);

1,349,409✔

147

   if (map != NULL)

1,349,409✔

148

      return hash_get(map, base) ?: base;

5,683✔

153

static inline type_t type_result_or_null(type_t t)

7,335,239✔

155

   item_t *item = lookup_item(&type_object, t, I_RESULT);

7,335,239✔

156

   if (item->object == NULL)

7,335,239✔

159

      return container_of(item->object, struct _type, object);

7,201,486✔

162

static bool _type_eq(type_t a, type_t b, bool strict, hash_t *map)

31,816,948✔

164

   assert(a != NULL);

31,816,948✔

165

   assert(b != NULL);

31,816,948✔

167

   if (a == b)

31,816,948✔

170

   type_kind_t kind_a = a->object.kind;

28,478,879✔

171

   type_kind_t kind_b = b->object.kind;

28,478,879✔

173

   if (map != NULL) {

28,478,879✔

174

      a = hash_get(map, a) ?: a;

32,559✔

175

      kind_a = a->object.kind;

32,559✔

177

      b = hash_get(map, b) ?: b;

32,559✔

178

      kind_b = b->object.kind;

32,559✔

180

      if (a == b)

32,559✔

184

   if (!strict) {

28,476,365✔

186

      while ((kind_a = a->object.kind) == T_SUBTYPE)

28,867,056✔

187

         a = type_base_map(a, map);

393,329✔

188

      while ((kind_b = b->object.kind) == T_SUBTYPE)

29,429,807✔

189

         b = type_base_map(b, map);

956,080✔

191

      if (a == b)

28,473,727✔

195

   const imask_t has = has_map[a->object.kind];

28,220,111✔

197

   if (!(has & I_PARAMS)) {

28,220,111✔

198

      ident_t ai = lookup_item(&type_object, a, I_IDENT)->ident;

24,553,577✔

199

      ident_t bi = lookup_item(&type_object, b, I_IDENT)->ident;

24,553,577✔

201

      if (ai != bi)

24,553,577✔

203

      else if (ai == NULL && kind_a == T_GENERIC)

1,538✔

207

   if (kind_a == T_INCOMPLETE || kind_b == T_INCOMPLETE)

3,667,728✔

210

   if (kind_a != kind_b)

3,666,841✔

213

   if (kind_a == T_ARRAY)

3,666,767✔

216

   if (kind_a == T_ACCESS)

3,666,767✔

219

   if ((has & I_DIMS) && (type_dims(a) != type_dims(b)))

3,666,767✔

222

   if (kind_a == T_SIGNATURE) {

3,666,767✔

223

      type_t ra = type_result_or_null(a);

3,666,460✔

224

      type_t rb = type_result_or_null(b);

3,666,460✔

226

      if (ra != NULL && rb != NULL) {

3,666,460✔

227

         if (!_type_eq(ra, rb, strict, map))

3,599,372✔

230

      else if (ra != NULL || rb != NULL)

67,088✔

234

   if (has & I_PARAMS) {

1,621,313✔

235

      item_t *ap = lookup_item(&type_object, a, I_PARAMS);

1,621,006✔

236

      item_t *bp = lookup_item(&type_object, b, I_PARAMS);

1,621,006✔

238

      const int acount = obj_array_count(ap->obj_array);

1,621,006✔

239

      const int bcount = obj_array_count(bp->obj_array);

1,621,006✔

241

      if (acount != bcount)

1,621,006✔

244

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

1,715,751✔

245

         type_t ai = type_array_nth(ap, i);

1,680,603✔

246

         type_t bi = type_array_nth(bp, i);

1,680,603✔

247

         if (ai != bi && !_type_eq(ai, bi, strict, map))

1,680,603✔

255

bool type_strict_eq(type_t a, type_t b)

23,125✔

257

   return _type_eq(a, b, true, NULL);

23,125✔

260

bool type_eq(type_t a, type_t b)

26,246,486✔

262

   return _type_eq(a, b, false, NULL);

26,246,486✔

265

bool type_eq_map(type_t a, type_t b, hash_t *map)

422,558✔

267

   return _type_eq(a, b, false, map);

422,558✔

270

ident_t type_ident(type_t t)

361,595✔

272

   assert(t != NULL);

363,455✔

274

   item_t *item = lookup_item(&type_object, t, I_IDENT);

363,455✔

275

   if (item->ident == NULL) {

363,455✔

276

      switch (t->object.kind) {

1,895✔

277

      case T_SUBTYPE:

1,860✔

278

         return type_ident(type_base(t));

1,860✔

279

      case T_NONE:

35✔

280

         return ident_new("none");

35✔

292

bool type_has_ident(type_t t)

115,268✔

294

   assert(t != NULL);

115,268✔

295

   return (lookup_item(&type_object, t, I_IDENT)->ident != NULL);

115,268✔

298

void type_set_ident(type_t t, ident_t id)

72,535✔

300

   assert(t != NULL);

72,535✔

301

   lookup_item(&type_object, t, I_IDENT)->ident = id;

72,535✔

302

72,535✔

304

unsigned type_dims(type_t t)

7,270✔

306

   item_t *item = lookup_item(&type_object, t, I_DIMS);

7,270✔

307

   return obj_array_count(item->obj_array);

7,270✔

310

tree_t type_dim(type_t t, unsigned n)

969,820✔

312

   item_t *item = lookup_item(&type_object, t, I_DIMS);

969,820✔

313

   return tree_array_nth(item, n);

969,820✔

316

void type_add_dim(type_t t, tree_t r)

701✔

318

   tree_array_add(lookup_item(&type_object, t, I_DIMS), r);

701✔

319

   object_write_barrier(&(t->object), &(r->object));

701✔

320

701✔

322

type_t type_base(type_t t)

13,347,232✔

324

   item_t *item = lookup_item(&type_object, t, I_BASE);

13,347,232✔

325

   assert(item->object != NULL);

13,347,232✔

326

   return container_of(item->object, struct _type, object);

13,347,232✔

329

void type_set_base(type_t t, type_t b)

46,213✔

331

   lookup_item(&type_object, t, I_BASE)->object = &(b->object);

46,213✔

332

   object_write_barrier(&(t->object), &(b->object));

46,213✔

333

46,213✔

335

type_t type_elem(type_t t)

1,663,732✔

337

   assert(t != NULL);

3,050,374✔

339

   if (t->object.kind == T_NONE)

3,050,374✔

342

      item_t *item = lookup_item(&type_object, t, I_ELEM);

3,050,374✔

343

      if (t->object.kind == T_SUBTYPE && item->object == NULL)

3,050,374✔

344

         return type_elem(type_base(t));

1,386,642✔

346

         assert(item->object != NULL);

1,663,732✔

352

void type_set_elem(type_t t, type_t e)

6,933✔

354

   lookup_item(&type_object, t, I_ELEM)->object = &(e->object);

6,933✔

355

   object_write_barrier(&(t->object), &(e->object));

6,933✔

356

6,933✔

358

bool type_has_elem(type_t t)

13,125✔

360

   return lookup_item(&type_object, t, I_ELEM)->object != NULL;

13,125✔

363

unsigned type_subkind(type_t t)

7,992✔

365

   item_t *item = lookup_item(&type_object, t, I_SUBKIND);

7,992✔

366

   return item->ival;

7,992✔

369

void type_set_subkind(type_t t, unsigned sub)

292✔

371

   lookup_item(&type_object, t, I_SUBKIND)->ival = sub;

292✔

372

292✔

374

bool type_is_universal(type_t t)

7,324✔

376

   assert(t != NULL);

7,324✔

378

   switch (t->object.kind) {

7,324✔

379

   case T_INTEGER:

3,317✔

380

      return t == std_type(NULL, STD_UNIVERSAL_INTEGER);

3,317✔

381

   case T_REAL:

4✔

382

      return t == std_type(NULL, STD_UNIVERSAL_REAL);

4✔

388

unsigned type_units(type_t t)

4,783✔

390

   item_t *item = lookup_item(&type_object, t, I_UNITS);

4,783✔

391

   return obj_array_count(item->obj_array);

4,783✔

394

tree_t type_unit(type_t t, unsigned n)

45,638✔

396

   item_t *item = lookup_item(&type_object, t, I_UNITS);

45,638✔

397

   return tree_array_nth(item, n);

45,638✔

400

void type_add_unit(type_t t, tree_t u)

158✔

402

   tree_array_add(lookup_item(&type_object, t, I_UNITS), u);

158✔

403

   object_write_barrier(&(t->object), &(u->object));

158✔

404

158✔

406

unsigned type_enum_literals(type_t t)

734,817✔

408

   item_t *item = lookup_item(&type_object, t, I_LITERALS);

734,817✔

409

   return obj_array_count(item->obj_array);

734,817✔

412

tree_t type_enum_literal(type_t t, unsigned n)

26,598,333✔

414

   item_t *item = lookup_item(&type_object, t, I_LITERALS);

26,598,333✔

415

   return tree_array_nth(item, n);

26,598,333✔

418

void type_enum_add_literal(type_t t, tree_t lit)

4,854✔

420

   assert(tree_kind(lit) == T_ENUM_LIT);

4,854✔

421

   tree_array_add(lookup_item(&type_object, t, I_LITERALS), lit);

4,854✔

422

   object_write_barrier(&(t->object), &(lit->object));

4,854✔

423

4,854✔

425

unsigned type_params(type_t t)

3,411✔

427

   item_t *item = lookup_item(&type_object, t, I_PARAMS);

3,411✔

428

   return obj_array_count(item->obj_array);

3,411✔

431

type_t type_param(type_t t, unsigned n)

3,261✔

433

   item_t *item = lookup_item(&type_object, t, I_PARAMS);

3,261✔

434

   return type_array_nth(item, n);

3,261✔

437

void type_add_param(type_t t, type_t p)

107,844✔

439

   type_array_add(lookup_item(&type_object, t, I_PARAMS), p);

107,844✔

440

   object_write_barrier(&(t->object), &(p->object));

107,844✔

441

107,844✔

443

unsigned type_fields(type_t t)

107,806✔

445

   if (t->object.kind == T_SUBTYPE)

138,859✔

446

      return type_fields(type_base(t));

31,053✔

448

      item_t *item = lookup_item(&type_object, t, I_FIELDS);

107,806✔

449

      return obj_array_count(item->obj_array);

107,806✔

453

tree_t type_field(type_t t, unsigned n)

304,016✔

455

   if (t->object.kind == T_SUBTYPE)

367,652✔

456

      return type_field(type_base(t), n);

63,636✔

458

      item_t *item = lookup_item(&type_object, t, I_FIELDS);

304,016✔

459

      return tree_array_nth(item, n);

304,016✔

463

void type_add_field(type_t t, tree_t p)

4,609✔

465

   tree_array_add(lookup_item(&type_object, t, I_FIELDS), p);

4,609✔

466

   object_write_barrier(&(t->object), &(p->object));

4,609✔

467

4,609✔

469

type_t type_result(type_t t)

1,917,582✔

471

   item_t *item = lookup_item(&type_object, t, I_RESULT);

1,917,582✔

472

   assert(item->object != NULL);

1,917,582✔

473

   return container_of(item->object, struct _type, object);

1,917,582✔

476

bool type_has_result(type_t t)

3,086,187✔

478

   return lookup_item(&type_object, t, I_RESULT)->object != NULL;

3,086,187✔

481

void type_set_result(type_t t, type_t r)

50,828✔

483

   lookup_item(&type_object, t, I_RESULT)->object = &(r->object);

50,828✔

484

   object_write_barrier(&(t->object), &(r->object));

50,828✔

485

50,828✔

487

unsigned type_indexes(type_t t)

1,457,519✔

489

   item_t *item = lookup_item(&type_object, t, I_INDEXES);

1,457,519✔

490

   return obj_array_count(item->obj_array);

1,457,519✔

493

void type_add_index(type_t t, type_t sub)

3,399✔

495

   type_array_add(lookup_item(&type_object, t, I_INDEXES), sub);

3,399✔

496

   object_write_barrier(&(t->object), &(sub->object));

3,399✔

497

3,399✔

499

type_t type_index(type_t t, unsigned n)

242,152✔

501

   item_t *item = lookup_item(&type_object, t, I_INDEXES);

242,152✔

502

   return type_array_nth(item, n);

242,152✔

505

tree_t type_constraint(type_t t)

2,793,242✔

507

   item_t *item = lookup_item(&type_object, t, I_CONSTRAINT);

2,793,242✔

508

   assert(item->object != NULL);

2,793,242✔

509

   return container_of(item->object, struct _tree, object);

2,793,242✔

512

bool type_has_constraint(type_t t)

2,866,541✔

514

   item_t *item = lookup_item(&type_object, t, I_CONSTRAINT);

2,866,541✔

515

   return item->object != NULL;

2,866,541✔

518

void type_set_constraint(type_t t, tree_t c)

45,348✔

520

   assert(c->object.kind == T_CONSTRAINT);

45,348✔

521

   lookup_item(&type_object, t, I_CONSTRAINT)->object = &(c->object);

45,348✔

522

   object_write_barrier(&(t->object), &(c->object));

45,348✔

523

45,348✔

525

void type_set_resolution(type_t t, tree_t r)

356✔

527

   lookup_item(&type_object, t, I_RESOLUTION)->object = &(r->object);

356✔

528

   object_write_barrier(&(t->object), &(r->object));

356✔

529

356✔

531

bool type_has_resolution(type_t t)

58,115✔

533

   return lookup_item(&type_object, t, I_RESOLUTION)->object != NULL;

58,115✔

536

tree_t type_resolution(type_t t)

10,370✔

538

   item_t *item = lookup_item(&type_object, t, I_RESOLUTION);

10,370✔

539

   assert(item->object != NULL);

10,370✔

540

   return container_of(item->object, struct _tree, object);

10,370✔

543

type_t type_designated(type_t t)

14,935✔

545

   if (t->object.kind == T_SUBTYPE)

14,936✔

546

      return type_designated(type_base(t));

1✔

548

      item_t *item = lookup_item(&type_object, t, I_DESIGNATED);

14,935✔

549

      assert(item->object != NULL);

14,935✔

550

      return container_of(item->object, struct _type, object);

14,935✔

554

void type_set_designated(type_t t, type_t d)

520✔

556

   lookup_item(&type_object, t, I_DESIGNATED)->object = &(d->object);

520✔

557

   object_write_barrier(&(t->object), &(d->object));

520✔

558

520✔

560

void type_signature(type_t t, text_buf_t *tb)

2,293✔

562

   assert(t->object.kind == T_SIGNATURE);

2,293✔

564

   tb_printf(tb, "[");

2,293✔

565

   const int nparams = type_params(t);

2,293✔

566

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

3,685✔

567

      tb_printf(tb, "%s%s", (i == 0 ? "" : ", "),

1,902✔

569

   type_t r = type_result_or_null(t);

2,293✔

570

   if (r != NULL)

2,293✔

571

      tb_printf(tb, "%sreturn %s", nparams > 0 ? " " : "", type_pp(r));

3,048✔

572

   tb_printf(tb, "]");

2,293✔

573

2,293✔

575

const char *type_pp2(type_t t, type_t other)

13,303✔

577

   assert(t != NULL);

13,303✔

579

   switch (type_kind(t)) {

13,303✔

580

   case T_SIGNATURE:

2,603✔

582

         static hash_t *cache = NULL;

2,603✔

583

         if (cache == NULL)

2,603✔

584

            cache = hash_new(64);

488✔

586

         text_buf_t *tb = hash_get(cache, t);

2,603✔

587

         if (tb == NULL) {

2,603✔

588

            tb = tb_new();

1,027✔

589

            hash_put(cache, t, tb);

1,027✔

591

            if (type_has_ident(t)) {

1,027✔

592

               tb_istr(tb, type_ident(t));

1,024✔

593

               tb_append(tb, ' ');

1,024✔

595

            type_signature(t, tb);

1,027✔

598

         return tb_get(tb);

2,603✔

601

   case T_GENERIC:

214✔

602

      if (!type_has_ident(t))

214✔

608

         const char *full1 = istr(type_ident(t));

10,698✔

609

         const char *dot1  = strrchr(full1, '.');

10,698✔

610

         const char *tail1 = dot1 ? dot1 + 1 : full1;

10,698✔

612

         if (other != NULL) {

10,698✔

613

            const char *full2 = istr(type_ident(other));

168✔

614

            const char *dot2  = strrchr(full2, '.');

168✔

615

            const char *tail2 = dot2 ? dot2 + 1 : full2;

168✔

617

            return strcmp(tail1, tail2) ? tail1 : full1;

168✔

625

const char *type_pp(type_t t)

13,135✔

627

   return type_pp2(t, NULL);

13,135✔

630

type_kind_t type_base_kind(type_t t)

28,375,841✔

632

   assert(t != NULL);

36,932,420✔

633

   if (t->object.kind == T_SUBTYPE)

36,932,420✔

634

      return type_base_kind(type_base(t));

8,556,579✔

636

      return t->object.kind;

28,375,841✔

639

bool type_is_array(type_t t)

5,532,579✔

641

   const type_kind_t base = type_base_kind(t);

5,532,579✔

642

   if (base == T_GENERIC)

5,532,579✔

643

      return type_subkind(type_base_recur(t)) == GTYPE_ARRAY;

2,352✔

645

      return base == T_ARRAY;

5,530,227✔

648

bool type_is_record(type_t t)

3,274,011✔

650

   return type_base_kind(t) == T_RECORD;

3,274,011✔

653

bool type_is_protected(type_t t)

179,513✔

655

   return type_base_kind(t) == T_PROTECTED;

179,513✔

658

bool type_is_file(type_t t)

123,531✔

660

   const type_kind_t base = type_base_kind(t);

123,531✔

661

   if (base == T_GENERIC)

123,531✔

662

      return type_subkind(type_base_recur(t)) == GTYPE_FILE;

414✔

664

      return base == T_FILE;

123,117✔

667

bool type_is_access(type_t t)

242,178✔

669

   const type_kind_t base = type_base_kind(t);

242,178✔

670

   if (base == T_GENERIC)

242,178✔

671

      return type_subkind(type_base_recur(t)) == GTYPE_ACCESS;

1,438✔

673

      return base == T_ACCESS;

240,740✔

676

bool type_is_incomplete(type_t t)

329,322✔

678

   return type_base_kind(t) == T_INCOMPLETE;

329,322✔

681

bool type_is_none(type_t t)

16,086,591✔

683

   return type_base_kind(t) == T_NONE;

16,086,591✔

686

bool type_is_valid(type_t t)

255✔

688

   return type_base_kind(t) != T_NONE;

255✔

691

bool type_has_error(type_t t)

28✔

693

   switch (t->object.kind) {

28✔

696

   case T_SIGNATURE:

26✔

698

         type_t r = type_result_or_null(t);

26✔

699

         if (r != NULL && type_is_none(r))

26✔

702

         const int nparams = type_params(t);

26✔

703

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

52✔

704

            if (type_is_none(type_param(t, i)))

28✔

712

   default:

2✔

713

      return false;

2✔

717

tree_t type_constraint_for_field(type_t t, tree_t f)

11,931✔

719

   if (t->object.kind != T_SUBTYPE)

11,964✔

721

   else if (!type_has_constraint(t))

10,729✔

724

   tree_t c = type_constraint(t);

10,500✔

726

   if (tree_subkind(c) != C_RECORD)

10,500✔

729

   const int nelem = tree_ranges(c);

10,500✔

730

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

14,815✔

731

      tree_t ei = tree_range(c, i);

14,782✔

732

      assert(tree_kind(ei) == T_ELEM_CONSTRAINT);

14,782✔

734

      if (tree_has_ref(ei) && tree_ref(ei) == f)

14,782✔

735

         return ei;

10,467✔

739

   return type_constraint_for_field(type_base(t), f);

33✔

742

bool type_is_unconstrained(type_t t)

2,709,306✔

744

   assert(t != NULL);

2,709,306✔

746

   if (t->object.kind == T_SUBTYPE) {

2,709,306✔

747

      if (type_is_record(t)) {

1,367,712✔

748

         if (standard() >= STD_08) {

26,899✔

749

            const int nfields = type_fields(t);

25,484✔

750

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

76,003✔

751

               tree_t f = type_field(t, i);

50,573✔

752

               if (!type_is_unconstrained(tree_type(f)))

50,573✔

753

                  continue;

41,823✔

755

               tree_t ec = type_constraint_for_field(t, f);

8,750✔

756

               if (ec == NULL || type_is_unconstrained(tree_type(ec)))

8,750✔

757

                  return true;

54✔

761

         return false;

26,845✔

763

      else if (type_is_array(t)) {

1,340,813✔

764

         if (standard() >= STD_08) {

1,122,448✔

765

            if (type_is_array(t)) {

418,183✔

766

               type_t elem = type_elem(t);

418,183✔

767

               if (type_is_unconstrained(elem))

418,183✔

772

         for (; t->object.kind == T_SUBTYPE; t = type_base(t)) {

1,156,506✔

773

            if (type_has_constraint(t)) {

1,129,600✔

774

               tree_t c = type_constraint(t);

1,094,221✔

775

               if (tree_subkind(c) == C_INDEX)

1,094,221✔

780

         assert(t->object.kind == T_ARRAY);

26,906✔

786

   else if (t->object.kind == T_ARRAY)

1,341,594✔

788

   else if (t->object.kind == T_GENERIC && type_subkind(t) == GTYPE_ARRAY)

915,849✔

790

   else if (t->object.kind == T_RECORD && standard() >= STD_08) {

915,740✔

791

      const int nfields = type_fields(t);

18,355✔

792

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

61,827✔

793

         if (type_is_unconstrained(tree_type(type_field(t, i))))

46,150✔

799

      return false;

897,385✔

802

bool type_is_enum(type_t t)

157,952✔

804

   return type_base_kind(t) == T_ENUM;

157,952✔

807

bool type_is_discrete(type_t t)

25,411✔

809

   const type_kind_t base = type_base_kind(t);

25,411✔

810

   if (base == T_GENERIC) {

25,411✔

811

      const gtype_class_t class = type_subkind(type_base_recur(t));

55✔

812

      return class == GTYPE_INTEGER || class == GTYPE_DISCRETE;

55✔

815

      return base == T_INTEGER || base == T_ENUM;

25,356✔

818

bool type_is_numeric(type_t t)

8,708✔

820

   const type_kind_t base = type_base_kind(t);

8,708✔

821

   if (base == T_GENERIC) {

8,708✔

822

      const gtype_class_t class = type_subkind(type_base_recur(t));

9✔

823

      return class == GTYPE_INTEGER || class == GTYPE_FLOATING;

9✔

826

      return base == T_INTEGER || base == T_REAL;

8,699✔

829

bool type_is_subprogram(type_t t)

1,078,177✔

831

   return t->object.kind == T_SIGNATURE;

1,078,177✔

834

bool type_is_physical(type_t t)

524✔

836

   const type_kind_t base = type_base_kind(t);

524✔

837

   if (base == T_GENERIC)

524✔

838

      return type_subkind(type_base_recur(t)) == GTYPE_PHYSICAL;

1✔

840

      return base == T_PHYSICAL;

523✔

843

bool type_is_integer(type_t t)

801,617✔

845

   const type_kind_t base = type_base_kind(t);

801,617✔

846

   if (base == T_GENERIC)

801,617✔

847

      return type_subkind(type_base_recur(t)) == GTYPE_INTEGER;

43✔

849

      return base == T_INTEGER;

801,574✔

852

bool type_is_real(type_t t)

53,596✔

854

   const type_kind_t base = type_base_kind(t);

53,596✔

855

   if (base == T_GENERIC)

53,596✔

856

      return type_subkind(type_base_recur(t)) == GTYPE_FLOATING;

4✔

858

      return base == T_REAL;

53,592✔

861

bool type_is_generic(type_t t)

219,891✔

863

   return type_base_kind(t) == T_GENERIC;

219,891✔

866

bool type_is_scalar(type_t t)

1,214,049✔

868

   const type_kind_t base = type_base_kind(t);

1,214,049✔

869

   if (base == T_GENERIC) {

1,214,049✔

870

      const gtype_class_t class = type_subkind(type_base_recur(t));

941✔

871

      return class == GTYPE_SCALAR || class == GTYPE_DISCRETE

941✔

872

         || class == GTYPE_FLOATING || class == GTYPE_INTEGER;

1,797✔

875

      return base == T_INTEGER || base == T_REAL

1,213,108✔

876

         || base == T_ENUM || base == T_PHYSICAL || base == T_NONE;

1,213,108✔

879

bool type_is_representable(type_t t)

83,073✔

881

   if (type_is_scalar(t))

85,789✔

883

   else if (standard() < STD_19) {

32,188✔

884

      if (type_is_array(t) && dimension_of(t) == 1) {

26,754✔

885

         type_t elem = type_elem(t);

21,961✔

886

         return type_is_enum(elem) && all_character_literals(elem);

27,902✔

889

         return false;

4,793✔

891

   else if (type_is_record(t)) {

5,434✔

892

      const int nfields = type_fields(t);

1,074✔

893

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

3,183✔

894

         if (!type_is_representable(tree_type(type_field(t, i))))

2,548✔

900

   else if (type_is_array(t))

4,360✔

901

      return type_is_representable(type_elem(t));

2,716✔

906

bool type_const_bounds(type_t t)

1,232,819✔

908

   if (type_is_unconstrained(t))

1,232,819✔

910

   else if (type_is_record(t)) {

1,062,713✔

911

      const int nfields = type_fields(t);

25,761✔

912

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

109,485✔

913

         type_t ftype = tree_type(type_field(t, i));

86,755✔

914

         if (!type_const_bounds(ftype))

86,755✔

920

   else if (type_is_array(t)) {

1,036,952✔

921

      const int ndims = dimension_of(t);

518,589✔

922

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

1,023,672✔

923

         int64_t low, high;

612,957✔

924

         if (!folded_bounds(range_of(t, i), &low, &high))

612,957✔

925

            return false;

107,874✔

928

      return type_const_bounds(type_elem(t));

410,715✔

930

   else if (type_is_integer(t)) {

518,363✔

931

      int64_t low, high;

88,285✔

932

      return folded_bounds(range_of(t, 0), &low, &high);

88,285✔

938

type_t type_base_recur(type_t t)

573,658✔

940

   assert(t != NULL);

573,658✔

941

   while (t->object.kind == T_SUBTYPE)

819,640✔

942

      t = type_base(t);

245,982✔

943

   return t;

573,658✔

946

type_t type_elem_recur(type_t type)

144,676✔

948

   while (type_is_array(type))

292,473✔

949

      type = type_elem(type);

147,797✔

950

   return type;

144,676✔

953

void type_copy_mark(type_t t, object_copy_ctx_t *ctx)

762✔

955

   object_copy_mark_root(&(t->object), ctx);

762✔

956

762✔

958

const char *type_kind_str(type_kind_t t)

5,492✔

960

   assert(t < T_LAST_TYPE_KIND);

5,492✔

961

   return kind_text_map[t];

5,492✔

964

unsigned type_width(type_t type)

695✔

966

   if (type_is_array(type)) {

695✔

967

      const unsigned elem_w = type_width(type_elem(type));

226✔

968

      unsigned w = 1;

226✔

969

      const int ndims = dimension_of(type);

226✔

970

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

458✔

971

         int64_t low, high;

232✔

972

         range_bounds(range_of(type, i), &low, &high);

232✔

973

         w *= MAX(high - low + 1, 0);

232✔

975

      return w * elem_w;

226✔

978

      type_is_scalar(type);

469✔

979

      return 1;

469✔

983

bool type_is_composite(type_t t)

86,104✔

985

   const type_kind_t base = type_base_kind(t);

86,104✔

986

   return base == T_ARRAY || base == T_RECORD;

86,104✔

989

bool type_is_homogeneous(type_t t)

155,658✔

991

   if (type_is_scalar(t))

216,389✔

993

   else if (type_is_array(t))

76,223✔

994

      return type_is_homogeneous(type_elem(t));

60,731✔

999

bool type_is_resolved(type_t t)

102✔

1001

   if (t->object.kind == T_SUBTYPE)

102✔

1002

      return type_has_resolution(t) || type_is_resolved(type_base(t));

27✔

1007

bool type_frozen(type_t t)

327✔

1009

   return arena_frozen(object_arena(&(t->object)));

327✔

1012

tree_t type_container(type_t t)

192✔

1014

   object_t *o = arena_root(object_arena(&(t->object)));

192✔

1015

   assert(o->tag == OBJECT_TAG_TREE);

192✔

1016

   return container_of(o, struct _tree, object);

192✔

1019

object_t *type_to_object(type_t t)

5,228✔

1021

   return t ? &(t->object) : NULL;

5,228✔

1024

type_t type_from_object(object_t *obj)

1,493✔

1026

   assert(obj->tag == OBJECT_TAG_TYPE);

1,493✔

1027

   return container_of(obj, struct _type, object);

1,493✔

1030

int type_bit_width(type_t type)

17,555✔

1032

   switch (type_kind(type)) {

35,368✔

1033

   case T_INTEGER:

5,254✔

1036

         tree_t r = range_of(type, 0);

5,254✔

1037

         return bits_for_range(assume_int(tree_left(r)),

5,254✔

1045

   case T_SUBTYPE:

11,403✔

1046

      return type_bit_width(type_base(type));

11,403✔

1048

   case T_ENUM:

10,911✔

1049

      return bits_for_range(0, type_enum_literals(type) - 1);

10,911✔

1051

   case T_ARRAY:

6,410✔

1052

      return type_bit_width(type_elem(type));

6,410✔

1059

int type_byte_width(type_t type)

16,428✔

1061

   return (type_bit_width(type) + 7) / 8;

16,428✔

1064

bool type_is_character_array(type_t t)

29,428✔

1069

   if (!type_is_array(t))

29,428✔

1072

   if (dimension_of(t) != 1)

26,256✔

1075

   type_t elem = type_base_recur(type_elem(t));

26,255✔

1077

   if (!type_is_enum(elem))

26,255✔

1080

   const int nlits = type_enum_literals(elem);

26,214✔

1081

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

442,978✔

1082

      tree_t lit = type_enum_literal(elem, i);

442,964✔

1083

      if (ident_char(tree_ident(lit), 0) == '\'')

442,964✔

1090

bool type_matches_class(type_t t, gtype_class_t class)

399✔

1092

   switch (class) {

399✔

1095

   case GTYPE_SCALAR:

7✔

1096

      return type_is_scalar(t);

7✔

1097

   case GTYPE_DISCRETE:

52✔

1098

      return type_is_discrete(t);

52✔

1099

   case GTYPE_INTEGER:

14✔

1100

      return type_is_integer(t);

14✔

1101

   case GTYPE_FLOATING:

3✔

1102

      return type_is_real(t);

3✔

1103

   case GTYPE_PHYSICAL:

3✔

1104

      return type_is_physical(t);

3✔

1105

   case GTYPE_ACCESS:

5✔

1106

      return type_is_access(t);

5✔

1107

   case GTYPE_ARRAY:

53✔

1108

      return type_is_array(t);

53✔

1109

   case GTYPE_FILE:

6✔

1110

      return type_is_file(t);

6✔

nickg / nvc / 21785130883

Source File
Press 'n' to go to next uncovered line, 'b' for previous

nickg / nvc / 21785130883

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