Class: AdLint::Cc1::UnresolvedType

Inherits:
Type
  • Object
show all
Defined in:
lib/adlint/cc1/type.rb

Instance Attribute Summary

Attributes inherited from Type

#declarations, #name, #type_table

Instance Method Summary collapse

Methods inherited from Type

#==, #aligned_bit_size, #aligned_byte_size, #byte_alignment, #byte_size, #composite?, #inspect, #length=, #more_cv_qualified?, #parameter?, #unsigned?

Methods included from StandardTypesAccessor

#char_alignment, #char_as_unsigned_char?, #char_size, #code_ptr_alignment, #code_ptr_size, #data_ptr_alignment, #data_ptr_size, #double_alignment, #double_size, #float_alignment, #float_size, #int_alignment, #int_size, #long_alignment, #long_double_alignment, #long_double_size, #long_long_alignment, #long_long_size, #long_size, #short_alignment, #short_size, #standard_types

Methods included from ArithmeticAccessor

#arithmetic, #logical_right_shift?

Methods included from Visitable

#accept

Constructor Details

#initialize(type_tbl) ⇒ UnresolvedType

Returns a new instance of UnresolvedType.



1172
1173
1174
 
# File 'lib/adlint/cc1/type.rb', line 1172

def initialize(type_tbl)
  super(type_tbl, "__adlint__unresolved_type")
end

Instance Method Details

#_arithmetic_type_with_array(lhs_type, rhs_type = self) ⇒ Object 



1651
1652
1653
1654
 
# File 'lib/adlint/cc1/type.rb', line 1651

def _arithmetic_type_with_array(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_bitfield(lhs_type, rhs_type = self) ⇒ Object 



1631
1632
1633
1634
1635
1636
 
# File 'lib/adlint/cc1/type.rb', line 1631

def _arithmetic_type_with_bitfield(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with BitfieldType and UnresolvedType
  #       makes integer-promoted type of BitfieldType.
  lhs_type.integer_promoted_type # NOTREACHED
end

#_arithmetic_type_with_char(lhs_type, rhs_type = self) ⇒ Object 



1433
1434
1435
1436
1437
1438
 
# File 'lib/adlint/cc1/type.rb', line 1433

def _arithmetic_type_with_char(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `char' and UnresolvedType
  #       makes integer-promoted type of `char'.
  lhs_type.integer_promoted_type # NOTREACHED
end

#_arithmetic_type_with_double(lhs_type, rhs_type = self) ⇒ Object 



1618
1619
1620
1621
1622
 
# File 'lib/adlint/cc1/type.rb', line 1618

def _arithmetic_type_with_double(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `double' and UnresolvedType makes `double'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_enum(lhs_type, rhs_type = self) ⇒ Object 



1638
1639
1640
1641
1642
 
# File 'lib/adlint/cc1/type.rb', line 1638

def _arithmetic_type_with_enum(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with EnumType and UnresolvedType makes EnumType.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_extended_big_int(lhs_type, rhs_type = self) ⇒ Object 



1666
1667
1668
1669
1670
1671
 
# File 'lib/adlint/cc1/type.rb', line 1666

def _arithmetic_type_with_extended_big_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with ExtendedBigIntType and UnresolvedType
  #       makes ExtendedBigIntType.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_float(lhs_type, rhs_type = self) ⇒ Object 



1612
1613
1614
1615
1616
 
# File 'lib/adlint/cc1/type.rb', line 1612

def _arithmetic_type_with_float(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `float' and UnresolvedType makes `float'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_function(lhs_type, rhs_type = self) ⇒ Object 



1428
1429
1430
1431
 
# File 'lib/adlint/cc1/type.rb', line 1428

def _arithmetic_type_with_function(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_int(lhs_type, rhs_type = self) ⇒ Object 



1496
1497
1498
1499
1500
 
# File 'lib/adlint/cc1/type.rb', line 1496

def _arithmetic_type_with_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `int' and UnresolvedType makes `int'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_long(lhs_type, rhs_type = self) ⇒ Object 



1529
1530
1531
1532
1533
 
# File 'lib/adlint/cc1/type.rb', line 1529

def _arithmetic_type_with_long(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `long' and UnresolvedType makes `long'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_long_double(lhs_type, rhs_type = self) ⇒ Object 



1624
1625
1626
1627
1628
1629
 
# File 'lib/adlint/cc1/type.rb', line 1624

def _arithmetic_type_with_long_double(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `long double' and UnresolvedType
  #       makes `long double'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_long_int(lhs_type, rhs_type = self) ⇒ Object 



1549
1550
1551
1552
1553
1554
 
# File 'lib/adlint/cc1/type.rb', line 1549

def _arithmetic_type_with_long_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `long int' and UnresolvedType
  #       makes `long int'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_long_long(lhs_type, rhs_type = self) ⇒ Object 



1570
1571
1572
1573
1574
1575
 
# File 'lib/adlint/cc1/type.rb', line 1570

def _arithmetic_type_with_long_long(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `long long' and UnresolvedType
  #       makes `long long'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_long_long_int(lhs_type, rhs_type = self) ⇒ Object 



1591
1592
1593
1594
1595
1596
 
# File 'lib/adlint/cc1/type.rb', line 1591

def _arithmetic_type_with_long_long_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `long long int' and UnresolvedType
  #       makes `long long int'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_pointer(lhs_type, rhs_type = self) ⇒ Object 



1644
1645
1646
1647
1648
1649
 
# File 'lib/adlint/cc1/type.rb', line 1644

def _arithmetic_type_with_pointer(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with PointerType and UnresolvedType
  #       makes PointerType.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_short(lhs_type, rhs_type = self) ⇒ Object 



1454
1455
1456
1457
1458
1459
 
# File 'lib/adlint/cc1/type.rb', line 1454

def _arithmetic_type_with_short(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `short' and UnresolvedType
  #       makes integer-promoted type of `short'.
  lhs_type.integer_promoted_type # NOTREACHED
end

#_arithmetic_type_with_short_int(lhs_type, rhs_type = self) ⇒ Object 



1475
1476
1477
1478
1479
1480
 
# File 'lib/adlint/cc1/type.rb', line 1475

def _arithmetic_type_with_short_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `short int' and UnresolvedType
  #       makes integer-promoted type of `short int'.
  lhs_type.integer_promoted_type # NOTREACHED
end

#_arithmetic_type_with_signed(lhs_type, rhs_type = self) ⇒ Object 



1502
1503
1504
1505
1506
 
# File 'lib/adlint/cc1/type.rb', line 1502

def _arithmetic_type_with_signed(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `signed' and UnresolvedType makes `signed'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_signed_char(lhs_type, rhs_type = self) ⇒ Object 



1440
1441
1442
1443
1444
1445
 
# File 'lib/adlint/cc1/type.rb', line 1440

def _arithmetic_type_with_signed_char(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `signed char' and UnresolvedType
  #       makes integer-promoted type of `signed char'.
  lhs_type.integer_promoted_type # NOTREACHED
end

#_arithmetic_type_with_signed_int(lhs_type, rhs_type = self) ⇒ Object 



1508
1509
1510
1511
1512
1513
 
# File 'lib/adlint/cc1/type.rb', line 1508

def _arithmetic_type_with_signed_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `signed int' and UnresolvedType
  #       makes `signed int'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_signed_long(lhs_type, rhs_type = self) ⇒ Object 



1535
1536
1537
1538
1539
1540
 
# File 'lib/adlint/cc1/type.rb', line 1535

def _arithmetic_type_with_signed_long(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `signed long' and UnresolvedType
  #       makes `signed long'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_signed_long_int(lhs_type, rhs_type = self) ⇒ Object 



1556
1557
1558
1559
1560
1561
 
# File 'lib/adlint/cc1/type.rb', line 1556

def _arithmetic_type_with_signed_long_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `signed long int' and UnresolvedType
  #       makes `signed long int'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_signed_long_long(lhs_type, rhs_type = self) ⇒ Object 



1577
1578
1579
1580
1581
1582
 
# File 'lib/adlint/cc1/type.rb', line 1577

def _arithmetic_type_with_signed_long_long(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `signed long long' and UnresolvedType
  #       makes `signed long long'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_signed_long_long_int(lhs_type, rhs_type = self) ⇒ Object 



1598
1599
1600
1601
1602
1603
 
# File 'lib/adlint/cc1/type.rb', line 1598

def _arithmetic_type_with_signed_long_long_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `signed long long int' and UnresolvedType
  #       makes `signed long long int'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_signed_short(lhs_type, rhs_type = self) ⇒ Object 



1461
1462
1463
1464
1465
1466
 
# File 'lib/adlint/cc1/type.rb', line 1461

def _arithmetic_type_with_signed_short(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `signed short' and UnresolvedType
  #       makes integer-promoted type of `signed short'.
  lhs_type.integer_promoted_type # NOTREACHED
end

#_arithmetic_type_with_signed_short_int(lhs_type, rhs_type = self) ⇒ Object 



1482
1483
1484
1485
1486
1487
 
# File 'lib/adlint/cc1/type.rb', line 1482

def _arithmetic_type_with_signed_short_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `signed short int' and UnresolvedType
  #       makes integer-promoted type of `signed short int'.
  lhs_type.integer_promoted_type # NOTREACHED
end

#_arithmetic_type_with_struct(lhs_type, rhs_type = self) ⇒ Object 



1656
1657
1658
1659
 
# File 'lib/adlint/cc1/type.rb', line 1656

def _arithmetic_type_with_struct(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_undeclared(lhs_type, rhs_type = self) ⇒ Object 



1413
1414
1415
1416
 
# File 'lib/adlint/cc1/type.rb', line 1413

def _arithmetic_type_with_undeclared(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  rhs_type.arithmetic_type_with(lhs_type)
end

#_arithmetic_type_with_union(lhs_type, rhs_type = self) ⇒ Object 



1661
1662
1663
1664
 
# File 'lib/adlint/cc1/type.rb', line 1661

def _arithmetic_type_with_union(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_unresolved(lhs_type, rhs_type = self) ⇒ Object 



1418
1419
1420
1421
 
# File 'lib/adlint/cc1/type.rb', line 1418

def _arithmetic_type_with_unresolved(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_unsigned(lhs_type, rhs_type = self) ⇒ Object 



1515
1516
1517
1518
1519
1520
 
# File 'lib/adlint/cc1/type.rb', line 1515

def _arithmetic_type_with_unsigned(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `unsigned' and UnresolvedType
  #       makes `unsigned'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_unsigned_char(lhs_type, rhs_type = self) ⇒ Object 



1447
1448
1449
1450
1451
1452
 
# File 'lib/adlint/cc1/type.rb', line 1447

def _arithmetic_type_with_unsigned_char(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `unsigned char' and UnresolvedType
  #       makes integer-promoted type of `unsigned char'.
  lhs_type.integer_promoted_type # NOTREACHED
end

#_arithmetic_type_with_unsigned_int(lhs_type, rhs_type = self) ⇒ Object 



1522
1523
1524
1525
1526
1527
 
# File 'lib/adlint/cc1/type.rb', line 1522

def _arithmetic_type_with_unsigned_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `unsigned int' and UnresolvedType
  #       makes `unsigned int'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_unsigned_long(lhs_type, rhs_type = self) ⇒ Object 



1542
1543
1544
1545
1546
1547
 
# File 'lib/adlint/cc1/type.rb', line 1542

def _arithmetic_type_with_unsigned_long(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `unsigned long' and UnresolvedType
  #       makes `unsigned long'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_unsigned_long_int(lhs_type, rhs_type = self) ⇒ Object 



1563
1564
1565
1566
1567
1568
 
# File 'lib/adlint/cc1/type.rb', line 1563

def _arithmetic_type_with_unsigned_long_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `unsigned long int' and UnresolvedType
  #       makes `unsigned long int'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_unsigned_long_long(lhs_type, rhs_type = self) ⇒ Object 



1584
1585
1586
1587
1588
1589
 
# File 'lib/adlint/cc1/type.rb', line 1584

def _arithmetic_type_with_unsigned_long_long(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `unsigned long long' and UnresolvedType
  #       makes `unsigned long long'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_unsigned_long_long_int(lhs_type, rhs_type = self) ⇒ Object 



1605
1606
1607
1608
1609
1610
 
# File 'lib/adlint/cc1/type.rb', line 1605

def _arithmetic_type_with_unsigned_long_long_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `unsigned long long int' and UnresolvedType
  #       makes `unsigned long long int'.
  lhs_type # NOTREACHED
end

#_arithmetic_type_with_unsigned_short(lhs_type, rhs_type = self) ⇒ Object 



1468
1469
1470
1471
1472
1473
 
# File 'lib/adlint/cc1/type.rb', line 1468

def _arithmetic_type_with_unsigned_short(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `unsigned short' and UnresolvedType
  #       makes integer-promoted type of `unsigned short'.
  lhs_type.integer_promoted_type # NOTREACHED
end

#_arithmetic_type_with_unsigned_short_int(lhs_type, rhs_type = self) ⇒ Object 



1489
1490
1491
1492
1493
1494
 
# File 'lib/adlint/cc1/type.rb', line 1489

def _arithmetic_type_with_unsigned_short_int(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  # NOTE: Binary operation with `unsigned short int' and UnresolvedType
  #       makes integer-promoted type of `unsigned short int'.
  lhs_type.integer_promoted_type # NOTREACHED
end

#_arithmetic_type_with_void(lhs_type, rhs_type = self) ⇒ Object 



1423
1424
1425
1426
 
# File 'lib/adlint/cc1/type.rb', line 1423

def _arithmetic_type_with_void(lhs_type, rhs_type = self)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  lhs_type # NOTREACHED
end

#arbitrary_value ⇒ Object 



1368
1369
1370
 
# File 'lib/adlint/cc1/type.rb', line 1368

def arbitrary_value
  ScalarValue.of_nil(logical_right_shift?)
end

#argument_promoted_type ⇒ Object 



1404
1405
1406
 
# File 'lib/adlint/cc1/type.rb', line 1404

def argument_promoted_type
  self # NOTREACHED
end

#arithmetic_type_with(type) ⇒ Object 



1408
1409
1410
1411
 
# File 'lib/adlint/cc1/type.rb', line 1408

def arithmetic_type_with(type)
  # NOTE: An arithmetic operation with UnresolvedType must not be executed!
  type._arithmetic_type_with_unresolved(self)
end

#array? ⇒ Boolean

Returns:

  • (Boolean) 


1248
1249
1250
 
# File 'lib/adlint/cc1/type.rb', line 1248

def array?
  false
end

#base_type ⇒ Object 



1208
1209
1210
 
# File 'lib/adlint/cc1/type.rb', line 1208

def base_type
  self
end

#bit_alignment ⇒ Object 



1200
1201
1202
 
# File 'lib/adlint/cc1/type.rb', line 1200

def bit_alignment
  0
end

#bit_size ⇒ Object 



1196
1197
1198
 
# File 'lib/adlint/cc1/type.rb', line 1196

def bit_size
  0
end

#bitfield? ⇒ Boolean

Returns:

  • (Boolean) 


1308
1309
1310
 
# File 'lib/adlint/cc1/type.rb', line 1308

def bitfield?
  false
end

#brief_image ⇒ Object 



1184
1185
1186
 
# File 'lib/adlint/cc1/type.rb', line 1184

def brief_image
  name
end

#coerce_array_value(val) ⇒ Object 



1388
1389
1390
 
# File 'lib/adlint/cc1/type.rb', line 1388

def coerce_array_value(val)
  ScalarValue.of_nil(logical_right_shift?)
end

#coerce_composite_value(val) ⇒ Object 



1392
1393
1394
 
# File 'lib/adlint/cc1/type.rb', line 1392

def coerce_composite_value(val)
  ScalarValue.of_nil(logical_right_shift?)
end

#coerce_scalar_value(val) ⇒ Object 



1384
1385
1386
 
# File 'lib/adlint/cc1/type.rb', line 1384

def coerce_scalar_value(val)
  ScalarValue.of_nil(logical_right_shift?)
end

#coercible?(to_type) ⇒ Boolean

Returns:

  • (Boolean) 


1224
1225
1226
 
# File 'lib/adlint/cc1/type.rb', line 1224

def coercible?(to_type)
  false
end

#compatible?(to_type) ⇒ Boolean

Returns:

  • (Boolean) 


1220
1221
1222
 
# File 'lib/adlint/cc1/type.rb', line 1220

def compatible?(to_type)
  false
end

#const? ⇒ Boolean

Returns:

  • (Boolean) 


1296
1297
1298
 
# File 'lib/adlint/cc1/type.rb', line 1296

def const?
  false
end

#convertible?(to_type) ⇒ Boolean

Returns:

  • (Boolean) 


1228
1229
1230
 
# File 'lib/adlint/cc1/type.rb', line 1228

def convertible?(to_type)
  false
end

#corresponding_signed_type ⇒ Object 



1673
1674
1675
 
# File 'lib/adlint/cc1/type.rb', line 1673

def corresponding_signed_type
  self # NOTREACHED
end

#corresponding_unsigned_type ⇒ Object 



1677
1678
1679
 
# File 'lib/adlint/cc1/type.rb', line 1677

def corresponding_unsigned_type
  self # NOTREACHED
end

#dup ⇒ Object 



1681
1682
1683
 
# File 'lib/adlint/cc1/type.rb', line 1681

def dup
  UnresolvedType.new(type_table)
end

#enum? ⇒ Boolean

Returns:

  • (Boolean) 


1272
1273
1274
 
# File 'lib/adlint/cc1/type.rb', line 1272

def enum?
  false
end

#enumerators ⇒ Object 



1332
1333
1334
 
# File 'lib/adlint/cc1/type.rb', line 1332

def enumerators
  []
end

#explicitly_signed? ⇒ Boolean

Returns:

  • (Boolean) 


1316
1317
1318
 
# File 'lib/adlint/cc1/type.rb', line 1316

def explicitly_signed?
  false
end

#floating? ⇒ Boolean

Returns:

  • (Boolean) 


1244
1245
1246
 
# File 'lib/adlint/cc1/type.rb', line 1244

def floating?
  false
end

#function? ⇒ Boolean

Returns:

  • (Boolean) 


1268
1269
1270
 
# File 'lib/adlint/cc1/type.rb', line 1268

def function?
  false
end

#have_va_list? ⇒ Boolean

Returns:

  • (Boolean) 


1320
1321
1322
 
# File 'lib/adlint/cc1/type.rb', line 1320

def have_va_list?
  false
end

#id ⇒ Object 



1176
1177
1178
 
# File 'lib/adlint/cc1/type.rb', line 1176

def id
  @id ||= TypeId.new(name)
end

#image ⇒ Object 



1180
1181
1182
 
# File 'lib/adlint/cc1/type.rb', line 1180

def image
  name
end

#impl_length ⇒ Object 



1340
1341
1342
 
# File 'lib/adlint/cc1/type.rb', line 1340

def impl_length
  0
end

#incomplete? ⇒ Boolean

Returns:

  • (Boolean) 


1216
1217
1218
 
# File 'lib/adlint/cc1/type.rb', line 1216

def incomplete?
  true
end

#integer? ⇒ Boolean

Returns:

  • (Boolean) 


1240
1241
1242
 
# File 'lib/adlint/cc1/type.rb', line 1240

def integer?
  false
end

#integer_conversion_rank ⇒ Object 



1396
1397
1398
 
# File 'lib/adlint/cc1/type.rb', line 1396

def integer_conversion_rank
  0 # NOTREACHED
end

#integer_promoted_type ⇒ Object 



1400
1401
1402
 
# File 'lib/adlint/cc1/type.rb', line 1400

def integer_promoted_type
  self # NOTREACHED
end

#length ⇒ Object 



1336
1337
1338
 
# File 'lib/adlint/cc1/type.rb', line 1336

def length
  0
end

#location ⇒ Object 



1188
1189
1190
 
# File 'lib/adlint/cc1/type.rb', line 1188

def location
  nil
end

#max ⇒ Object 



1356
1357
1358
 
# File 'lib/adlint/cc1/type.rb', line 1356

def max
  0
end

#member_named(name) ⇒ Object 



1348
1349
1350
 
# File 'lib/adlint/cc1/type.rb', line 1348

def member_named(name)
  nil
end

#members ⇒ Object 



1344
1345
1346
 
# File 'lib/adlint/cc1/type.rb', line 1344

def members
  []
end

#min ⇒ Object 



1352
1353
1354
 
# File 'lib/adlint/cc1/type.rb', line 1352

def min
  0
end

#named? ⇒ Boolean

Returns:

  • (Boolean) 


1192
1193
1194
 
# File 'lib/adlint/cc1/type.rb', line 1192

def named?
  false
end

#nil_value ⇒ Object 



1360
1361
1362
 
# File 'lib/adlint/cc1/type.rb', line 1360

def nil_value
  ScalarValue.of_nil(logical_right_shift?)
end

#parameter_types ⇒ Object 



1328
1329
1330
 
# File 'lib/adlint/cc1/type.rb', line 1328

def parameter_types
  []
end

#parameter_value ⇒ Object 



1376
1377
1378
 
# File 'lib/adlint/cc1/type.rb', line 1376

def parameter_value
  ScalarValue.of_nil(logical_right_shift?)
end

#pointer? ⇒ Boolean

Returns:

  • (Boolean) 


1260
1261
1262
 
# File 'lib/adlint/cc1/type.rb', line 1260

def pointer?
  false
end

#qualified? ⇒ Boolean

Returns:

  • (Boolean) 


1264
1265
1266
 
# File 'lib/adlint/cc1/type.rb', line 1264

def qualified?
  false
end

#real_type ⇒ Object 



1204
1205
1206
 
# File 'lib/adlint/cc1/type.rb', line 1204

def real_type
  self
end

#restrict? ⇒ Boolean

Returns:

  • (Boolean) 


1304
1305
1306
 
# File 'lib/adlint/cc1/type.rb', line 1304

def restrict?
  false
end

#return_type ⇒ Object 



1324
1325
1326
 
# File 'lib/adlint/cc1/type.rb', line 1324

def return_type
  self
end

#return_value ⇒ Object 



1380
1381
1382
 
# File 'lib/adlint/cc1/type.rb', line 1380

def return_value
  ScalarValue.of_nil(logical_right_shift?)
end

#same_as?(type) ⇒ Boolean

Returns:

  • (Boolean) 


1232
1233
1234
 
# File 'lib/adlint/cc1/type.rb', line 1232

def same_as?(type)
  false
end

#scalar? ⇒ Boolean

Returns:

  • (Boolean) 


1236
1237
1238
 
# File 'lib/adlint/cc1/type.rb', line 1236

def scalar?
  false
end

#signed? ⇒ Boolean

Returns:

  • (Boolean) 


1312
1313
1314
 
# File 'lib/adlint/cc1/type.rb', line 1312

def signed?
  false
end

#standard? ⇒ Boolean

Returns:

  • (Boolean) 


1284
1285
1286
 
# File 'lib/adlint/cc1/type.rb', line 1284

def standard?
  false
end

#struct? ⇒ Boolean

Returns:

  • (Boolean) 


1252
1253
1254
 
# File 'lib/adlint/cc1/type.rb', line 1252

def struct?
  false
end

#undeclared? ⇒ Boolean

Returns:

  • (Boolean) 


1288
1289
1290
 
# File 'lib/adlint/cc1/type.rb', line 1288

def undeclared?
  false
end

#undefined_value ⇒ Object 



1372
1373
1374
 
# File 'lib/adlint/cc1/type.rb', line 1372

def undefined_value
  ScalarValue.of_nil(logical_right_shift?)
end

#union? ⇒ Boolean

Returns:

  • (Boolean) 


1256
1257
1258
 
# File 'lib/adlint/cc1/type.rb', line 1256

def union?
  false
end

#unqualify ⇒ Object 



1212
1213
1214
 
# File 'lib/adlint/cc1/type.rb', line 1212

def unqualify
  self
end

#unresolved? ⇒ Boolean

Returns:

  • (Boolean) 


1292
1293
1294
 
# File 'lib/adlint/cc1/type.rb', line 1292

def unresolved?
  true
end

#user? ⇒ Boolean

Returns:

  • (Boolean) 


1276
1277
1278
 
# File 'lib/adlint/cc1/type.rb', line 1276

def user?
  false
end

#void? ⇒ Boolean

Returns:

  • (Boolean) 


1280
1281
1282
 
# File 'lib/adlint/cc1/type.rb', line 1280

def void?
  false
end

#volatile? ⇒ Boolean

Returns:

  • (Boolean) 


1300
1301
1302
 
# File 'lib/adlint/cc1/type.rb', line 1300

def volatile?
  false
end

#zero_value ⇒ Object 



1364
1365
1366
 
# File 'lib/adlint/cc1/type.rb', line 1364

def zero_value
  ScalarValue.of_nil(logical_right_shift?)
end