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

109

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

29,582,764✔

111

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

29,582,764✔

112

   return container_of(o, struct _tree, object);

29,582,764✔

115

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

51,525✔

117

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

51,525✔

118

51,525✔

120

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

3,320,728✔

122

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

3,320,728✔

123

   return container_of(o, struct _type, object);

3,320,728✔

126

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

101,896✔

128

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

101,896✔

129

101,896✔

131

type_t type_new(type_kind_t kind)

100,329✔

133

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

100,329✔

134

   return container_of(o, struct _type, object);

100,329✔

137

type_kind_t type_kind(type_t t)

8,487,545✔

139

   assert(t != NULL);

8,487,545✔

140

   return t->object.kind;

8,487,545✔

143

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

1,251,605✔

145

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

1,251,605✔

146

   type_t base = type_base(t);

1,251,605✔

147

   if (map != NULL)

1,251,605✔

148

      return hash_get(map, base) ?: base;

5,921✔

153

static inline type_t type_result_or_null(type_t t)

6,789,924✔

155

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

6,789,924✔

156

   if (item->object == NULL)

6,789,924✔

159

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

6,670,509✔

162

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

28,821,498✔

164

   assert(a != NULL);

28,821,498✔

165

   assert(b != NULL);

28,821,498✔

167

   if (a == b)

28,821,498✔

170

   type_kind_t kind_a = a->object.kind;

25,718,281✔

171

   type_kind_t kind_b = b->object.kind;

25,718,281✔

173

   if (map != NULL) {

25,718,281✔

174

      assert(standard() >= STD_08);   // Type generics

31,012✔

176

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

31,012✔

177

      kind_a = a->object.kind;

31,012✔

179

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

31,012✔

180

      kind_b = b->object.kind;

31,012✔

182

      if (a == b)

31,012✔

186

   if (!strict) {

25,715,853✔

188

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

26,078,753✔

189

         a = type_base_map(a, map);

365,549✔

190

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

26,599,260✔

191

         b = type_base_map(b, map);

886,056✔

193

      if (a == b)

25,713,204✔

197

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

25,473,791✔

199

   if (!(has & I_PARAMS)) {

25,473,791✔

200

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

22,079,309✔

201

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

22,079,309✔

203

      if (ai != bi)

22,079,309✔

205

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

1,356✔

209

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

3,395,671✔

212

   if (kind_a != kind_b)

3,394,784✔

215

   if (kind_a == T_ARRAY)

3,394,715✔

218

   if (kind_a == T_ACCESS)

3,394,715✔

221

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

3,394,715✔

224

   if (kind_a == T_SIGNATURE) {

3,394,715✔

225

      type_t ra = type_result_or_null(a);

3,394,413✔

226

      type_t rb = type_result_or_null(b);

3,394,413✔

228

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

3,394,413✔

229

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

3,334,599✔

232

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

59,814✔

236

   if (has & I_PARAMS) {

1,494,353✔

237

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

1,494,051✔

238

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

1,494,051✔

240

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

1,494,051✔

241

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

1,494,051✔

243

      if (acount != bcount)

1,494,051✔

246

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

1,583,771✔

247

         type_t ai = type_array_nth(ap, i);

1,550,579✔

248

         type_t bi = type_array_nth(bp, i);

1,550,579✔

249

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

1,550,579✔

257

bool type_strict_eq(type_t a, type_t b)

21,520✔

259

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

21,520✔

262

bool type_eq(type_t a, type_t b)

23,661,808✔

264

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

23,661,808✔

267

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

395,555✔

269

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

395,555✔

272

ident_t type_ident(type_t t)

273,300✔

274

   assert(t != NULL);

275,477✔

276

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

275,477✔

277

   if (item->ident == NULL) {

275,477✔

278

      switch (t->object.kind) {

2,212✔

279

      case T_SUBTYPE:

2,177✔

280

         return type_ident(type_base(t));

2,177✔

281

      case T_NONE:

35✔

282

         return ident_new("none");

35✔

294

bool type_has_ident(type_t t)

94,579✔

296

   assert(t != NULL);

94,579✔

297

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

94,579✔

300

void type_set_ident(type_t t, ident_t id)

67,378✔

302

   assert(t != NULL);

67,378✔

303

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

67,378✔

304

67,378✔

306

unsigned type_dims(type_t t)

6,941✔

308

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

6,941✔

309

   return obj_array_count(item->obj_array);

6,941✔

312

tree_t type_dim(type_t t, unsigned n)

841,183✔

314

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

841,183✔

315

   return tree_array_nth(item, n);

841,183✔

318

void type_add_dim(type_t t, tree_t r)

665✔

320

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

665✔

321

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

665✔

322

665✔

324

type_t type_base(type_t t)

11,041,862✔

326

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

11,041,862✔

327

   assert(item->object != NULL);

11,041,862✔

328

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

11,041,862✔

331

void type_set_base(type_t t, type_t b)

42,488✔

333

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

42,488✔

334

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

42,488✔

335

42,488✔

337

type_t type_elem(type_t t)

1,281,753✔

339

   assert(t != NULL);

2,366,728✔

341

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

2,366,728✔

344

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

2,366,728✔

345

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

2,366,728✔

346

         return type_elem(type_base(t));

1,084,975✔

348

         assert(item->object != NULL);

1,281,753✔

354

void type_set_elem(type_t t, type_t e)

5,116✔

356

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

5,116✔

357

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

5,116✔

358

5,116✔

360

bool type_has_elem(type_t t)

11,936✔

362

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

11,936✔

365

unsigned type_subkind(type_t t)

6,799✔

367

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

6,799✔

368

   return item->ival;

6,799✔

371

void type_set_subkind(type_t t, unsigned sub)

268✔

373

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

268✔

374

268✔

376

bool type_is_universal(type_t t)

7,278✔

378

   assert(t != NULL);

7,278✔

380

   switch (t->object.kind) {

7,278✔

381

   case T_INTEGER:

3,306✔

382

      return t == std_type(NULL, STD_UNIVERSAL_INTEGER);

3,306✔

383

   case T_REAL:

4✔

384

      return t == std_type(NULL, STD_UNIVERSAL_REAL);

4✔

390

unsigned type_units(type_t t)

4,427✔

392

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

4,427✔

393

   return obj_array_count(item->obj_array);

4,427✔

396

tree_t type_unit(type_t t, unsigned n)

41,940✔

398

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

41,940✔

399

   return tree_array_nth(item, n);

41,940✔

402

void type_add_unit(type_t t, tree_t u)

158✔

404

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

158✔

405

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

158✔

406

158✔

408

unsigned type_enum_literals(type_t t)

402,865✔

410

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

402,865✔

411

   return obj_array_count(item->obj_array);

402,865✔

414

tree_t type_enum_literal(type_t t, unsigned n)

26,230,433✔

416

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

26,230,433✔

417

   return tree_array_nth(item, n);

26,230,433✔

420

void type_enum_add_literal(type_t t, tree_t lit)

4,616✔

422

   assert(tree_kind(lit) == T_ENUM_LIT);

4,616✔

423

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

4,616✔

424

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

4,616✔

425

4,616✔

427

unsigned type_params(type_t t)

2,175✔

429

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

2,175✔

430

   return obj_array_count(item->obj_array);

2,175✔

433

type_t type_param(type_t t, unsigned n)

5,150✔

435

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

5,150✔

436

   return type_array_nth(item, n);

5,150✔

439

void type_add_param(type_t t, type_t p)

98,793✔

441

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

98,793✔

442

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

98,793✔

443

98,793✔

445

unsigned type_fields(type_t t)

113,601✔

447

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

149,730✔

448

      return type_fields(type_base(t));

36,129✔

450

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

113,601✔

451

      return obj_array_count(item->obj_array);

113,601✔

455

tree_t type_field(type_t t, unsigned n)

318,492✔

457

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

394,142✔

458

      return type_field(type_base(t), n);

75,650✔

460

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

318,492✔

461

      return tree_array_nth(item, n);

318,492✔

465

void type_add_field(type_t t, tree_t p)

4,237✔

467

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

4,237✔

468

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

4,237✔

469

4,237✔

471

type_t type_result(type_t t)

1,805,297✔

473

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

1,805,297✔

474

   assert(item->object != NULL);

1,805,297✔

475

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

1,805,297✔

478

bool type_has_result(type_t t)

2,880,183✔

480

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

2,880,183✔

483

void type_set_result(type_t t, type_t r)

47,280✔

485

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

47,280✔

486

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

47,280✔

487

47,280✔

489

unsigned type_indexes(type_t t)

1,192,735✔

491

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

1,192,735✔

492

   return obj_array_count(item->obj_array);

1,192,735✔

495

void type_add_index(type_t t, type_t sub)

3,103✔

497

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

3,103✔

498

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

3,103✔

499

3,103✔

501

type_t type_index(type_t t, unsigned n)

214,420✔

503

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

214,420✔

504

   return type_array_nth(item, n);

214,420✔

507

unsigned type_constraints(type_t t)

2,213,172✔

509

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

2,213,172✔

510

   return obj_array_count(item->obj_array);

2,213,172✔

513

void type_add_constraint(type_t t, tree_t c)

41,849✔

515

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

41,849✔

516

   tree_array_add(lookup_item(&type_object, t, I_CONSTR), c);

41,849✔

517

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

41,849✔

518

41,849✔

520

tree_t type_constraint(type_t t, unsigned n)

2,150,716✔

522

   assert(n == 0);    // TODO: this list is largely redundant now

2,150,716✔

523

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

2,150,716✔

524

   return tree_array_nth(item, n);

2,150,716✔

527

void type_set_resolution(type_t t, tree_t r)

351✔

529

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

351✔

530

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

351✔

531

351✔

533

bool type_has_resolution(type_t t)

31,876✔

535

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

31,876✔

538

tree_t type_resolution(type_t t)

3,561✔

540

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

3,561✔

541

   assert(item->object != NULL);

3,561✔

542

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

3,561✔

545

type_t type_designated(type_t t)

10,408✔

547

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

10,409✔

548

      return type_designated(type_base(t));

1✔

550

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

10,408✔

551

      assert(item->object != NULL);

10,408✔

552

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

10,408✔

556

void type_set_designated(type_t t, type_t d)

480✔

558

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

480✔

559

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

480✔

560

480✔

562

void type_signature(type_t t, text_buf_t *tb)

1,073✔

564

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

1,073✔

566

   tb_printf(tb, "[");

1,073✔

567

   const int nparams = type_params(t);

1,073✔

568

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

2,506✔

569

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

1,972✔

571

   type_t r = type_result_or_null(t);

1,073✔

572

   if (r != NULL)

1,073✔

573

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

663✔

574

   tb_printf(tb, "]");

1,073✔

575

1,073✔

577

const char *type_pp2(type_t t, type_t other)

6,594✔

579

   assert(t != NULL);

6,594✔

581

   switch (type_kind(t)) {

6,594✔

582

   case T_SIGNATURE:

2,592✔

584

         static hash_t *cache = NULL;

2,592✔

585

         if (cache == NULL)

2,592✔

586

            cache = hash_new(64);

439✔

588

         text_buf_t *tb = hash_get(cache, t);

2,592✔

589

         if (tb == NULL) {

2,592✔

590

            tb = tb_new();

1,010✔

591

            hash_put(cache, t, tb);

1,010✔

593

            if (type_has_ident(t)) {

1,010✔

594

               tb_istr(tb, type_ident(t));

1,007✔

595

               tb_append(tb, ' ');

1,007✔

597

            type_signature(t, tb);

1,010✔

600

         return tb_get(tb);

2,592✔

603

   case T_GENERIC:

214✔

604

      if (!type_has_ident(t))

214✔

610

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

4,000✔

611

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

4,000✔

612

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

4,000✔

614

         if (other != NULL) {

4,000✔

615

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

124✔

616

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

124✔

617

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

124✔

619

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

124✔

627

const char *type_pp(type_t t)

6,470✔

629

   return type_pp2(t, NULL);

6,470✔

632

type_kind_t type_base_kind(type_t t)

25,458,286✔

634

   assert(t != NULL);

32,414,848✔

635

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

32,414,848✔

636

      return type_base_kind(type_base(t));

6,956,562✔

638

      return t->object.kind;

25,458,286✔

641

bool type_is_array(type_t t)

4,313,877✔

643

   const type_kind_t base = type_base_kind(t);

4,313,877✔

644

   if (base == T_GENERIC)

4,313,877✔

645

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

1,912✔

647

      return base == T_ARRAY;

4,311,965✔

650

bool type_is_record(type_t t)

2,397,471✔

652

   return type_base_kind(t) == T_RECORD;

2,397,471✔

655

bool type_is_protected(type_t t)

143,259✔

657

   return type_base_kind(t) == T_PROTECTED;

143,259✔

660

bool type_is_file(type_t t)

116,442✔

662

   const type_kind_t base = type_base_kind(t);

116,442✔

663

   if (base == T_GENERIC)

116,442✔

664

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

402✔

666

      return base == T_FILE;

116,040✔

669

bool type_is_access(type_t t)

218,066✔

671

   const type_kind_t base = type_base_kind(t);

218,066✔

672

   if (base == T_GENERIC)

218,066✔

673

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

1,347✔

675

      return base == T_ACCESS;

216,719✔

678

bool type_is_incomplete(type_t t)

306,871✔

680

   return type_base_kind(t) == T_INCOMPLETE;

306,871✔

683

bool type_is_none(type_t t)

15,949,032✔

685

   return type_base_kind(t) == T_NONE;

15,949,032✔

688

bool type_is_valid(type_t t)

242✔

690

   return type_base_kind(t) != T_NONE;

242✔

693

bool type_has_error(type_t t)

27✔

695

   switch (t->object.kind) {

27✔

698

   case T_SIGNATURE:

25✔

700

         type_t r = type_result_or_null(t);

25✔

701

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

25✔

704

         const int nparams = type_params(t);

25✔

705

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

49✔

706

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

26✔

714

   default:

2✔

715

      return false;

2✔

719

tree_t type_constraint_for_field(type_t t, tree_t f)

9,912✔

721

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

9,966✔

722

      const int ncon = type_constraints(t);

8,641✔

723

      if (ncon > 0) {

8,641✔

724

         tree_t c = type_constraint(t, ncon - 1);

8,612✔

726

         if (tree_subkind(c) != C_RECORD)

8,612✔

729

         const int nelem = tree_ranges(c);

8,612✔

730

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

12,688✔

731

            tree_t ei = tree_range(c, i);

12,663✔

732

            assert(tree_kind(ei) == T_ELEM_CONSTRAINT);

12,663✔

734

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

12,663✔

735

               return ei;

8,587✔

739

      return type_constraint_for_field(type_base(t), f);

54✔

745

bool type_is_unconstrained(type_t t)

2,129,661✔

747

   assert(t != NULL);

2,129,661✔

749

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

2,129,661✔

750

      if (type_is_record(t)) {

1,085,906✔

751

         if (standard() >= STD_08) {

30,807✔

752

            const int nfields = type_fields(t);

29,443✔

753

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

88,297✔

754

               tree_t f = type_field(t, i);

58,875✔

755

               if (!type_is_unconstrained(tree_type(f)))

58,875✔

756

                  continue;

51,803✔

758

               tree_t ec = type_constraint_for_field(t, f);

7,072✔

759

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

7,072✔

760

                  return true;

21✔

764

         return false;

30,786✔

766

      else if (type_is_array(t)) {

1,055,099✔

767

         if (standard() >= STD_08) {

928,559✔

768

            if (type_is_array(t)) {

325,402✔

769

               type_t elem = type_elem(t);

325,402✔

770

               if (type_is_unconstrained(elem))

325,402✔

775

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

960,491✔

776

            if (type_constraints(t) > 0) {

935,607✔

777

               tree_t c = type_constraint(t, 0);

908,515✔

778

               if (tree_subkind(c) == C_INDEX)

908,515✔

783

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

24,884✔

789

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

1,043,755✔

791

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

637,072✔

793

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

637,017✔

794

      const int nfields = type_fields(t);

14,709✔

795

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

45,457✔

796

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

33,152✔

802

      return false;

622,308✔

805

bool type_is_enum(type_t t)

117,104✔

807

   return type_base_kind(t) == T_ENUM;

117,104✔

810

bool type_is_discrete(type_t t)

23,575✔

812

   const type_kind_t base = type_base_kind(t);

23,575✔

813

   if (base == T_GENERIC) {

23,575✔

814

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

37✔

815

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

37✔

818

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

23,538✔

821

bool type_is_numeric(type_t t)

8,182✔

823

   const type_kind_t base = type_base_kind(t);

8,182✔

824

   if (base == T_GENERIC) {

8,182✔

825

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

9✔

826

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

9✔

829

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

8,173✔

832

bool type_is_subprogram(type_t t)

1,036,633✔

834

   return t->object.kind == T_SIGNATURE;

1,036,633✔

837

bool type_is_physical(type_t t)

510✔

839

   const type_kind_t base = type_base_kind(t);

510✔

840

   if (base == T_GENERIC)

510✔

841

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

1✔

843

      return base == T_PHYSICAL;

509✔

846

bool type_is_integer(type_t t)

566,896✔

848

   const type_kind_t base = type_base_kind(t);

566,896✔

849

   if (base == T_GENERIC)

566,896✔

850

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

28✔

852

      return base == T_INTEGER;

566,868✔

855

bool type_is_real(type_t t)

46,555✔

857

   const type_kind_t base = type_base_kind(t);

46,555✔

858

   if (base == T_GENERIC)

46,555✔

859

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

4✔

861

      return base == T_REAL;

46,551✔

864

bool type_is_generic(type_t t)

204,626✔

866

   return type_base_kind(t) == T_GENERIC;

204,626✔

869

bool type_is_scalar(type_t t)

934,821✔

871

   const type_kind_t base = type_base_kind(t);

934,821✔

872

   if (base == T_GENERIC) {

934,821✔

873

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

686✔

874

      return class == GTYPE_SCALAR || class == GTYPE_DISCRETE

686✔

875

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

1,332✔

878

      return base == T_INTEGER || base == T_REAL

934,135✔

879

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

934,135✔

882

bool type_is_representable(type_t t)

14,770✔

884

   if (type_is_scalar(t))

15,556✔

886

   else if (standard() < STD_19) {

7,696✔

887

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

6,307✔

888

         type_t elem = type_elem(t);

4,137✔

889

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

4,959✔

892

         return false;

2,170✔

894

   else if (type_is_record(t)) {

1,389✔

895

      const int nfields = type_fields(t);

424✔

896

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

1,342✔

897

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

953✔

903

   else if (type_is_array(t))

965✔

904

      return type_is_representable(type_elem(t));

786✔

909

bool type_const_bounds(type_t t)

902,356✔

911

   if (type_is_unconstrained(t))

902,356✔

913

   else if (type_is_record(t)) {

718,984✔

914

      const int nfields = type_fields(t);

25,085✔

915

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

104,092✔

916

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

80,862✔

917

         if (!type_const_bounds(ftype))

80,862✔

923

   else if (type_is_array(t)) {

693,899✔

924

      const int ndims = dimension_of(t);

381,875✔

925

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

686,294✔

926

         int64_t low, high;

412,909✔

927

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

412,909✔

928

            return false;

108,490✔

931

      return type_const_bounds(type_elem(t));

273,385✔

933

   else if (type_is_integer(t)) {

312,024✔

934

      int64_t low, high;

69,117✔

935

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

69,117✔

941

type_t type_base_recur(type_t t)

435,393✔

943

   assert(t != NULL);

435,393✔

944

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

646,079✔

945

      t = type_base(t);

210,686✔

946

   return t;

435,393✔

949

type_t type_elem_recur(type_t type)

102,702✔

951

   while (type_is_array(type))

209,047✔

952

      type = type_elem(type);

106,345✔

953

   return type;

102,702✔

962

unsigned type_width(type_t type)

297✔

964

   if (type_is_array(type)) {

297✔

965

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

54✔

966

      unsigned w = 1;

54✔

967

      const int ndims = dimension_of(type);

54✔

968

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

108✔

969

         int64_t low, high;

54✔

970

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

54✔

971

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

54✔

973

      return w * elem_w;

54✔

976

      type_is_scalar(type);

243✔

977

      return 1;

243✔

981

bool type_is_composite(type_t t)

79,217✔

983

   const type_kind_t base = type_base_kind(t);

79,217✔

984

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

79,217✔

987

bool type_is_homogeneous(type_t t)

94,812✔

989

   if (type_is_scalar(t))

133,859✔

991

   else if (type_is_array(t))

51,379✔

992

      return type_is_homogeneous(type_elem(t));

39,047✔

997

bool type_is_resolved(type_t t)

83✔

999

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

83✔

1000

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

27✔

1005

bool type_frozen(type_t t)

297✔

1007

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

297✔

1010

tree_t type_container(type_t t)

75✔

1012

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

75✔

1013

   assert(o->tag == OBJECT_TAG_TREE);

75✔

1014

   return container_of(o, struct _tree, object);

75✔

1028

int type_bit_width(type_t type)

16,639✔

1030

   switch (type_kind(type)) {

33,625✔

1031

   case T_INTEGER:

5,133✔

1034

         tree_t r = range_of(type, 0);

5,133✔

1035

         return bits_for_range(assume_int(tree_left(r)),

5,133✔

1043

   case T_SUBTYPE:

10,924✔

1044

      return type_bit_width(type_base(type));

10,924✔

1046

   case T_ENUM:

10,184✔

1047

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

10,184✔

1049

   case T_ARRAY:

6,062✔

1050

      return type_bit_width(type_elem(type));

6,062✔

1057

int type_byte_width(type_t type)

15,806✔

1059

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

15,806✔

1062

bool type_is_character_array(type_t t)

28,637✔

1067

   if (!type_is_array(t))

28,637✔

1070

   if (dimension_of(t) != 1)

25,574✔

1073

   type_t elem = type_base_recur(type_elem(t));

25,573✔

1075

   if (!type_is_enum(elem))

25,573✔

1078

   const int nlits = type_enum_literals(elem);

25,528✔

1079

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

428,086✔

1080

      tree_t lit = type_enum_literal(elem, i);

428,071✔

1081

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

428,071✔

1088

bool type_matches_class(type_t t, gtype_class_t class)

372✔

1090

   switch (class) {

372✔

1093

   case GTYPE_SCALAR:

7✔

1094

      return type_is_scalar(t);

7✔

1095

   case GTYPE_DISCRETE:

46✔

1096

      return type_is_discrete(t);

46✔

1097

   case GTYPE_INTEGER:

14✔

1098

      return type_is_integer(t);

14✔

1099

   case GTYPE_FLOATING:

3✔

1100

      return type_is_real(t);

3✔

1101

   case GTYPE_PHYSICAL:

3✔

1102

      return type_is_physical(t);

3✔

1103

   case GTYPE_ACCESS:

5✔

1104

      return type_is_access(t);

5✔

1105

   case GTYPE_ARRAY:

46✔

1106

      return type_is_array(t);

46✔

1107

   case GTYPE_FILE:

6✔

1108

      return type_is_file(t);

6✔

nickg / nvc / 13356534393

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

nickg / nvc / 13356534393

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