- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
typedef long bool_t;
#define TRUE 1
#define FALSE 0
void f() {
bool_t var;
for (var = TRUE; var > FALSE; var++) { /* ... */ }
}
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+133
typedef long bool_t;
#define TRUE 1
#define FALSE 0
void f() {
bool_t var;
for (var = TRUE; var > FALSE; var++) { /* ... */ }
}
+134
static U32 Round_up_to_next_2_power( U32 value )
{
if ( value > 16 )
if ( value > 64 )
if ( value > 128 )
if ( value > 256 )
if ( value > 512 )
return( 1024 );
else
return( 512 );
else
return( 256 );
else
return( 128 );
else
if ( value > 32 )
return( 64 );
else
return( 32 );
else
if ( value > 4 )
if ( value > 8 )
return( 16 );
else
return( 8 );
else
if ( value > 2 )
return( 4 );
return( value );
}
Simple function to round up to the next power of 2.
+118
... *sizeof(uint32_t)
Правильно. А то вдруг кто его переопределит.
+135
// Hammer the CFG with large numbers of overlapping variable scopes, which
// implicit destructors triggered at each edge.
#define EXPAND_BASIC_STRUCT(i) struct X##i { X##i(int); ~X##i(); };
#define EXPAND_NORET_STRUCT(i) struct X##i { X##i(int); ~X##i() __attribute__((noreturn)); };
EXPAND_BASIC_STRUCT(0000); EXPAND_NORET_STRUCT(0001);
EXPAND_BASIC_STRUCT(0010); EXPAND_BASIC_STRUCT(0011);
EXPAND_BASIC_STRUCT(0100); EXPAND_NORET_STRUCT(0101);
EXPAND_NORET_STRUCT(0110); EXPAND_BASIC_STRUCT(0111);
EXPAND_BASIC_STRUCT(1000); EXPAND_NORET_STRUCT(1001);
EXPAND_BASIC_STRUCT(1010); EXPAND_BASIC_STRUCT(1011);
EXPAND_NORET_STRUCT(1100); EXPAND_NORET_STRUCT(1101);
EXPAND_BASIC_STRUCT(1110); EXPAND_BASIC_STRUCT(1111);
#define EXPAND_2_VARS(c, i, x) const X##i var_##c##_##i##0(x), &var_##c##_##i##1 = X##i(x)
#define EXPAND_4_VARS(c, i, x) EXPAND_2_VARS(c, i##0, x); EXPAND_2_VARS(c, i##1, x)
#define EXPAND_8_VARS(c, i, x) EXPAND_4_VARS(c, i##0, x); EXPAND_4_VARS(c, i##1, x)
#define EXPAND_16_VARS(c, i, x) EXPAND_8_VARS(c, i##0, x); EXPAND_8_VARS(c, i##1, x)
#define EXPAND_32_VARS(c, x) EXPAND_16_VARS(c, 0, x); EXPAND_16_VARS(c, 1, x)
#define EXPAND_2_INNER_CASES(i, x, y) INNER_CASE(i, x, y); INNER_CASE(i + 1, x, y);
#define EXPAND_4_INNER_CASES(i, x, y) EXPAND_2_INNER_CASES(i, x, y) EXPAND_2_INNER_CASES(i + 2, x, y)
#define EXPAND_8_INNER_CASES(i, x, y) EXPAND_4_INNER_CASES(i, x, y) EXPAND_4_INNER_CASES(i + 4, x, y)
#define EXPAND_16_INNER_CASES(i, x, y) EXPAND_8_INNER_CASES(i, x, y) EXPAND_8_INNER_CASES(i + 8, x, y)
#define EXPAND_32_INNER_CASES(i, x, y) EXPAND_16_INNER_CASES(i, x, y) EXPAND_16_INNER_CASES(i + 16, x, y)
#define EXPAND_2_OUTER_CASES(i, x, y) OUTER_CASE(i, x, y); OUTER_CASE(i + 1, x, y);
#define EXPAND_4_OUTER_CASES(i, x, y) EXPAND_2_OUTER_CASES(i, x, y) EXPAND_2_OUTER_CASES(i + 2, x, y)
#define EXPAND_8_OUTER_CASES(i, x, y) EXPAND_4_OUTER_CASES(i, x, y) EXPAND_4_OUTER_CASES(i + 4, x, y)
#define EXPAND_16_OUTER_CASES(i, x, y) EXPAND_8_OUTER_CASES(i, x, y) EXPAND_8_OUTER_CASES(i + 8, x, y)
#define EXPAND_32_OUTER_CASES(i, x, y) EXPAND_16_OUTER_CASES(i, x, y) EXPAND_16_OUTER_CASES(i + 16, x, y)
Рекурсивное (EXPAND_... ) макроговно из clang и генератор (EXPAND_..._STRUCT) структур через какую-то непонятную жопу
https://github.com/llvm-mirror/clang/blob/master/INPUTS/cfg-nested-var-scopes.cpp
+131
#include <stdio.h>
#include <tchar.h>
#define MVALUE 6
void bufret(int pos, int limit, int maxlimit, bool direction)
{
putchar((char)((pos&0xff)+0x30)) ;
if(((pos<limit)&&direction)||((pos>1)&&(!direction)))
{
putchar('-') ;
if(direction)
pos++ ;
else
pos--;
}
else
{
limit++ ;
if(direction)
pos=limit;
else
pos=1 ;
direction=!direction ;
putchar('\n') ;
}
if(limit < maxlimit)
bufret(pos,limit,maxlimit,direction) ;
}
int _tmain(int argc, _TCHAR* argv[])
{
bufret(1, 1, MVALUE+1, true) ;
getchar() ;
return 0;
}
Решил наговнокодить по мотивам этой статьи:
http://habrahabr.ru/post/116842/
Как думаете, получилось,
+131
#include <stdio.h>
#include <stdint.h>
#define ARR_L 11
#define INS_P (arr[0])
#define MOD_L(a) ((a) % ARR_L)
#define INS_P_M (MOD_L(INS_P))
#define ARR_ACS(a) (arr[MOD_L(a)]) //access to arr
void foo (uint8_t *arr)
{
if (ARR_ACS(0) == 0)
{
printf("%u ", ARR_ACS(1));
ARR_ACS(1) += ARR_ACS(2);
ARR_ACS(0) = 1;
}
else
{
printf("%u ", ARR_ACS(2));
ARR_ACS(2) += ARR_ACS(1);
ARR_ACS(0) = 0;
}
}
int main(void) {
uint8_t arr[ARR_L] = {1,1,1,0,0,0,0,0,0,0,0};
for (size_t a = 0; a < 13; a++)
{
foo(arr);
}
return 0;
}
Считалка чисел Фибоначчи на основе фигни, придуманной в http://govnokod.ru/15967
Надо сделать метаязык для удобного составления набора инструкций для этой штуки. И еще надо осилить длинную арифметику, ну это вообще круто будет
+129
#include <stdio.h>
#include <stdint.h>
#define ARR_L 11
#define INS_P (arr[0])
#define MOD_L(a) ((a) % ARR_L)
#define INS_P_M (MOD_L(INS_P))
#define ARR_ACS(a) (arr[MOD_L(a)]) //access to arr
void foo (uint8_t *arr)
{
ARR_ACS(3) = INS_P * ARR_ACS(INS_P);
ARR_ACS( MOD_L( INS_P_M + 1 ) ) = ((INS_P * INS_P) * 2);
if (INS_P != 0) {ARR_ACS(INS_P_M)++;};
INS_P = INS_P_M + 1;
// tut voobche lubaya fignya, kotoraya chtoby izmenyala
// figny v massive v zavisimosti ot sostoyania massiva
}
int main(void) {
uint8_t arr[ARR_L] = {0,2,6,3,2,62,7,113,0,26,13};
for (size_t a = 0; a < 10000; a++)
{
foo(arr);
printf
(
"%.3u %.3u %.3u %.3u %.3u "
"%.3u %.3u %.3u %.3u %.3u %.3u\n",
INS_P,arr[1],arr[2],arr[3],arr[4],
arr[5],arr[6],arr[7],arr[8],arr[9],arr[10]);
}
return 0;
}
Машина Тьюринга с лентой конечной длины - конечный автомат. Состояние обязательно зациклится, какие бы правила преобразования над конечным алфавитом мы не вводили и каким бы ни было начальное состояние ленты.
В сишке есть возможности вменяемо сделать вывод чисел из массива подряд для N-ного количества аргументов?
Цикл не предлагать
+131
key_t cXxxYyyyZzz::getKey( char *pValue )
{
key_t key=INVALID_SEMKEY;
if ( !pValue ) return key;
for(int i=0; (char)0 != pValue[i]; ++i )
{
if ( 1==i && 'x' == tolower(pValue[1]) && '0' == pValue[0] )
continue;
if ( !isxdigit(pValue[i]) )
return key;
}
return strtoul(pValue,(char**)0,16);
}
немецкий велосипед.
+133
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
void my_char_plus(const void *a, const void *b, void *c)
{
char tmp = (*(char*)a + *(char*)b);
memcpy(c,(void*)(&tmp),sizeof(char));
}
void my_char_minus(const void *a, const void *b, void *c)
{
char tmp = (*(char*)a - *(char*)b);
memcpy(c,(void*)(&tmp),sizeof(char));
}
void operation(const void *funct(const void*,const void*,void*),
const void *a, const void *b, void *c )
{
funct(a,b,c);
}
char ret_last_arg(const void *funct(const void*,const void*,void*),
const void *a, const void *b)
{
char c;
funct(a,b,(void*)&c);
return c;
}
int main(void)
{
char a, b;
a = 5; b = 7;
void *plus = &my_char_plus; char c;
operation(plus, (const void*)&a, (const void*)&b, (void*)&c);
printf("5 + 7 = %i\n", c);
void *minus = &my_char_minus;
char d = ret_last_arg(minus, (const void*)&a, (const void*)&b);
printf("5 - 7 = %i\n", d);
// LISP LISP LISP
#define LISP(ar,aa,bb) ret_last_arg(ar, (const void*)&(char){aa}, (const void*)&(char){bb} )
char e = LISP(plus,2,LISP(plus,2,2));
printf("(+ 2 (+ 2 2 ) ) = %i\n", e);
return 0;
}
Лиспопрограммирование на сишке через макрос (префиксная запись)
Только оно кривовато тут, т.е. получаем трехадресный код (не как в лиспе)
http://masters.donntu.edu.ua/2006/fvti/svyezhentsev/library/article2.htm
Можно делать интерпретаторы фигни всякой, шитый код. Я упорот короче
+132
#include <stdio.h>
unsigned int mid (unsigned int a, unsigned int b)
{
if (a > b) {unsigned int c = a; a = b; b = c;}
for(; a < b; a--, b++) {;};
return a;
}
int main(void) {
printf("%u %u %u %u", mid(2,2), mid(3,2), mid(2,3), mid(3,3));
return 0;
}
Это я хочу найти середину. Где-то я туплю