Бля, луа просто охуенно. Все сделано очень просто и красиво.

Единственная проблема тут в том, что говноплюсы не умеют в нормальные замыкания.

Подглядел няшный паттерн в бсдшном ините:
В его FSM обработчик каждого из состояний является отдельной функцией, которая в качестве возвращаемого значения возвращает адрес функции-обработчика следующего состояния.
Сам цикл автомата тогда сводится к for (;;) s = (state_t) (*s)();
Жутко просто, но я сам никогда не догадывался так сделать :<

http://www.tedunangst.com/flak/post/worst-common-denominator-programming

0xFFFFFFFFFFFFFFFFuLL

FuLL

int main(){
    char a[] = {'1', 0, '3', 0};
    printf("a = %s\n", a);
    printf("a+2 = %s\n", a+2);
}

define struct union

Писать эффективные вычматы на чистом C — содомия, поскольку кроме убогого препроцессора средств метапрограммирования нет.

Альтернатвы:
1) Более лучший препроцессор, например erb (Ruby). Минус — неудобно возиться с получившимся выхлопом (отладка, балансировка скобочек, етц).
2) Языки, в которых можно явно указать, какие вычисления будут происходить в compile-time. Например, C++ (шаблоны, constexpr).

Хочу попробовать D в качестве второй альтернативы. Есть гнутый компилятор, который [по мнению авторитетных анонимных экспертов] даёт на выхлопе код, не хуже, чем gcc.

самое сложное в переходе с плюсов или жабки на сишечку — это перестать
испытывать стыд при употреблении в коде goto при обработке ошибок. Серьёзно, в
пизду этот спагетти-код, когда можно просто относиться к тому что находится за
goto как к finally секции или деструктору. просто тут код деструктора
расположен прямо в теле функции.
при грамотном использовании goto код становится линейным и легко читаемым

восемь лет назад я охуевал от ебанутости нортелевских стайлгайдов касательно именования функций, файлов и вообще. прошло восемь лет и я начал понимать, что стайлгайды-то были неплохие и для них были причины

Когда я пишу на чистом C, чувство ясности происходящего переполняет меня.
Набирая очередную строчку я уже ясно вижу в какой набор ассемблерных инструкций
она превратится и как её может соптимизировать компилятор. Я вижу не
for(i = 0...), а ассемблерный loop со счётчиком в ecx, я вижу не if (ptr),
а test и jz, я не творю не магию набирая магические буковки, а явственно
осознаю что я делаю. В такие моменты я чувствую себя творцом, а не колдуном.
Именно поэтому, спустя семь лет хардкорного программирования я смог слезть с
иглы C++ и обратиться в истинную веру.

Надо себе на ебальнике выбить уже.
Type ILP64 LP64 LLP64
char 8 8 8
short 16 16 16
int 64 32 32
long 64 64 32
long long 64 64 64
pointer 64 64 64

Бнвач, мне как-то попадалась книжка по реализации ООП в сишечке. Там естественно всё было через структуры, ссылки на функции и прочее горождение С++ из сей. А есть какой-нибудь годный ман/книга как сделать ООП, основанное на сообщениях, типа как смоллтолке и обжцэ?

Чото у каждого второго айтишника в резюме вижу что он знает C.
Еще хуже если там написано "C/C++".

Теперь внимание вопрос: На каком уровне надо знать (какой опыт иметь в) C, чтобы
иметь моральное право указыать ее в резюме, и, при этом, не быть голословным
мудаком?

куркума спалил: http://natashenka.ca/posters/

l29ah-t60 /etc/paludis ∞ man errno
Vim: Чтение из стандартного потока ввода stdin...

l29ah-t60 /etc/paludis ∞ view /usr/include/errno.h
l29ah-t60 /etc/paludis ∞ view /usr/include/bits/errno.h
l29ah-t60 /etc/paludis ∞ view /usr/include/linux/errno.h
l29ah-t60 /etc/paludis ∞ view /usr/include/asm/errno.h
l29ah-t60 /etc/paludis ∞ view /usr/include/asm-generic/errno.h
l29ah-t60 /etc/paludis ∞ view /usr/include/asm-generic/errno-base.h

Какой плагин я забыл поставить?

http://ache.vniz.net/demos.html охуительная история:

Своеобразный программисткий подвиг совершил Дима Бурков. В то время начали появляться первые PC. Unix на них выглядел неубедительно. Linux еще не появился, зато повился Venix. Хачить его было невозможно - не было исходных текстов ядра. Дима Бурков реассемблировал ядро, потом писал программы на Си, которые давали тот же текст ассемблера - так появились тексты ядра на Си ... работа не для слабонервных.

UNIX V5, OpenBSD, Plan 9, FreeBSD, and GNU coreutils implementations of echo.c
https://gist.github.com/dchest/1091803

Проверял GCC на предмет того, как он умеет рекурсию оптимизировать.
Вот такая штука

unsigned int plus(unsigned int a, unsigned int b)
{
  if (b == 0) return a;
  return plus (a+1, b-1);
}

Относительно успешно сворачивается сложение. Получается такая шняга:

movl %edi, %eax
addl %esi, %eax
ret

Хотя в идеале можно было бы обойтись

leal (%rsi,%rdi), %eax
ret

Что касается умножения, там ситуация более печальная

inline unsigned long int product_0(const unsigned int a, const unsigned int b, const unsigned long int tmp)
{
  if (b == 0) return tmp;
  return product_0(a, b-1, tmp+a);
}

unsigned long int product(const unsigned int a, const unsigned int b)
{
  return product_0(a, b, 0);
}

В ассемблере получается такая фигня

product:
.LFB34:
.cfi_startproc
    xorl %eax, %eax
    testl %esi, %esi
    je .L7
    leal -1(%rsi), %eax
    mov %edi, %edi
    addq $1, %rax
    imulq %rdi, %rax
.L7:
    rep
    ret
.cfi_endproc

Тут оно зачем-то зануляет значение регистра, в котором хранится возврашемое из функции значение и сравнивает с нулем значение регистра, в котором в функцию передается число. Если ноль то прыгаем в конец функции, возвращая 0. Тогда внезапно появляется смысл в этом rep ret http://repzret.org/p/repzret/

Why? Because “The processor is unable to apply a branch prediction to the single-byte near-return form (opcode C3h) of the ret instruction.” Thus, “Use of a two-byte near-return can improve performance”, because it is not affected by this shortcoming.

Ну а дальше через leal из регистра rsi число копируется в eax, уменьшаясь при этом на 1 (нахрена?) и потом из регистра edi двигается в edi (НАХРЕНА??), увеличиваем rax на 1 через addq (ну тут понятно зачем, перед этим ведь оно было непонятно зачем уменьшено на 1, но нахрена уменьшать и потом увеличивать? И вообще, для увеличения на 1 лучше incq использовать) ну и в итоге компилятор таки вставляет инструкцию imulq. Распознать умножение в этой рекурсивной хрени компилятор смог, но при этом как-то через жопу все, нагенерировал кучу говна всякого. Можно было намного проще сделать

movl %esi, %eax
imull %edi, %eax

gcc version 4.5.1 если что

Чем может быть полезен массив из нуля элементов?

Прочитал Richard Reese - Understanding and Using C Pointers. Чот как-то... 2/3 книги какая-то лажа о том как объявлять и разыменоывать указатели. Код в книжке няшно подсвечен, цветастый. Но написан будто школьником каким-то. Под конец правда более-менее интересно, но опять же, ничего нового. Я не спец в сях, но книжка явно начального уровня, IMHO. Не верьте обзорам. Рекомендую людям которые не втыкают в указатели или знают их поверхностно. Всё же надо заметить, что в этой книге они описаны довольно подробно.