Типы в Си

Тестирую парсер Си компилятора. А конкретно одно правило грамматики, называется type_name. Попросил ИИ сгенерить набор тестов, чтобы перебрать как можно больше вариантов. Вот такой список получился. Ничего важного не пропущено?

1. Simple Types

These test the "type_name : specifier_qualifier_list" branch with basic type specifiers.

• 1. void
• 2. char
• 3. int
• 4. short
• 5. long
• 6. float
• 7. double
• 8. signed
• 9. unsigned
• 10. bool
• 11. _Complex
• 12. _Imaginary

( дальше начинается интересное )

Рекурсивные типы

Типы в языке Си штука рекурсивная. То есть внутри описателя типа могут встречаться другие описатели типов. Грок накидал ещё несколько вариантов для тестирования парсера.

Вариант 1: Вложенная структура с простым полем

struct Outer { int x; struct Inner { int y; } inner; }

Вариант 2: Структура с указателем на себя

struct Node { int data; struct Node *next; }

Вариант 3: Указатель на функцию с параметром-структурой

void (*)(struct Pair { int x; int y; })

Вариант 4: Вложенная структура с полем-массивом

struct Container { struct Item { int value; } items[10]; }

Вариант 5: Объединение с вложенной структурой и анонимной структурой

union Variant { struct { int a; int b; }; struct Named { float x; } named; }

Extended ASCII на шелле

Попросил claude.ai сбацать скрипт на шелле, чтобы показывал таблицу символов расширенной ASCII. Вроде ничо так получилось с третьего раза: extended-ascii.sh. С детства люблю буковки разглядывать. 😀

 0240     0260 °   0300 À   0320 Ð   0340 à   0360 ð  
 0241 ¡   0261 ±   0301 Á   0321 Ñ   0341 á   0361 ñ  
 0242 ¢   0262 ²   0302 Â   0322 Ò   0342 â   0362 ò  
 0243 £   0263 ³   0303 Ã   0323 Ó   0343 ã   0363 ó  
 0244 ¤   0264 ´   0304 Ä   0324 Ô   0344 ä   0364 ô  
 0245 ¥   0265 µ   0305 Å   0325 Õ   0345 å   0365 õ  
 0246 ¦   0266 ¶   0306 Æ   0326 Ö   0346 æ   0366 ö  
 0247 §   0267 ·   0307 Ç   0327 ×   0347 ç   0367 ÷  
 0250 ¨   0270 ¸   0310 È   0330 Ø   0350 è   0370 ø  
 0251 ©   0271 ¹   0311 É   0331 Ù   0351 é   0371 ù  
 0252 ª   0272 º   0312 Ê   0332 Ú   0352 ê   0372 ú  
 0253 «   0273 »   0313 Ë   0333 Û   0353 ë   0373 û  
 0254 ¬   0274 ¼   0314 Ì   0334 Ü   0354 ì   0374 ü  
 0255 ­    0275 ½   0315 Í   0335 Ý   0355 í   0375 ý  
 0256 ®   0276 ¾   0316 Î   0336 Þ   0356 î   0376 þ  
 0257 ¯   0277 ¿   0317 Ï   0337 ß   0357 ï   0377 ÿ 

Слияние типов в Си

Согласно грамматике, в Си можно писать: signed short int. Причём в любом порядке. А можно char char char char char. Первое правильно, второе неправильно. Можно писать long long но нельзя shоrt short. Можно long double но нельзя short float. Существуют определённые правила, по которым длинная последовательность элементарных спецификаторов типа сливается в один правильный тип. Или отвергается как неверная. Вот таблица совместимости типов. Я убрал отсюда _Atomic, с ним совсем сложно и лучше рассматривать отдельно. 

            void char short int long float double signed unsigned _Bool _Complex _Imaginary struct union enum MyType
--------------------------------------------------------------------------------------------------------------------
void        ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
char        ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✓      ✓        ✗     ✗        ✗          ✗      ✗     ✗    ✗
short       ✗    ✗    ✗     ✓   ✗    ✗     ✗      ✓      ✓        ✗     ✗        ✗          ✗      ✗     ✗    ✗
int         ✗    ✗    ✓     ✗   ✓    ✗     ✗      ✓      ✓        ✗     ✗        ✗          ✗      ✗     ✗    ✗
long        ✗    ✗    ✗     ✓   ✓    ✗     ✓      ✓      ✓        ✗     ✗        ✗          ✗      ✗     ✗    ✗
float       ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✓        ✓          ✗      ✗     ✗    ✗
double      ✗    ✗    ✗     ✗   ✓    ✗     ✗      ✗      ✗        ✗     ✓        ✓          ✗      ✗     ✗    ✗
signed      ✗    ✓    ✓     ✓   ✓    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
unsigned    ✗    ✓    ✓     ✓   ✓    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
_Bool       ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
_Complex    ✗    ✗    ✗     ✗   ✗    ✓     ✓      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
_Imaginary  ✗    ✗    ✗     ✗   ✗    ✓     ✓      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
struct      ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
union       ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
enum        ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗
MyType      ✗    ✗    ✗     ✗   ✗    ✗     ✗      ✗      ✗        ✗     ✗        ✗          ✗      ✗     ✗    ✗

Заметки о конкретных комбинациях:

void

• Несовместимо со всеми другими спецификаторами, так как `void` является отдельным типом.
• Пример: `void int` недопустимо.

char, short, int, long

• Совместимо с `signed`, `unsigned` (например, `unsigned char`, `signed long`).
• `short` и `int` объединяются как `short int`.
• `long` и `int` объединяются как `long int`.
• `long` может объединяться с `double` (`long double`) и самим собой (`long long`).
• Несовместимо с `float`, `double`, `_Complex`, `_Imaginary`, `struct`, `union`, `enum`, `MyType`.

float, double

• Совместимо с `_Complex`, `_Imaginary` (например, `float _Complex`, `double _Imaginary`).
• `double` с `long` образует `long double`.
• Несовместимо с `signed`, `unsigned`, целочисленными типами, `struct`, `union`, `enum`, `MyType`.

signed, unsigned

• Применяется к `char`, `short`, `int`, `long` (например, `unsigned short`).
• `signed` подразумевается для `int`, если он один.
• Несовместимо с `float`, `double`, `_Bool`, `_Complex`, `_Imaginary`, `struct`, `union`, `enum`, `MyType`.

_Bool

• Несовместимо со всеми другими спецификаторами.

_Complex, _Imaginary

• Сочетается с `float`, `double` (например, `float _Complex`).
• Несовместимо с целочисленными типами, `_Bool`, `struct`, `union`, `enum`, `MyType`.

struct, union, enum

• Несовместимо с базовыми типами, `signed`, `unsigned`, `_Complex`, `_Imaginary`, `MyType`.

MyType (typedef)

• Представляет определенный пользователем тип (например, `typedef int MyType`).
• Несовместимо с другими спецификаторами, так как это полный тип.
• Совместимость зависит от базового типа (например, если `MyType` - это `int`, он ведет себя как `int`).

Самосочетания

• Большинство спецификаторов не могут сочетаться друг с другом (например, `int int` недопустимо).
• `long` является исключением: `long long` допустимо.
• `struct`, `union`, `enum`, `MyType` не могут повторяться.