СИ макросы понеслось

Брр, ужас какой.

#ifndef _CLEANUPBLK_H
#define _CLEANUPBLK_H

#define CLEANUPBLK(name) \
__##name##_cleanupblk:

#define CLEANUPBEG(name) \
__##name##_cleanupall:

#define CLEANUPNEXT(name, val) \
__##name##_cleanup_##val:

#define CLEANUPEND(name) \
goto __##name##_cleanupend; \
goto __##name##_cleanupblk; \
goto __##name##_cleanupall; \
__##name##_cleanupend:

#define CLEANUPALL(name) \
goto __##name##_cleanupall

#define CLEANUPBRK(name) \
goto __##name##_cleanupend

#define CLEANUPSEL(name, val) \
goto __##name##_cleanup_##val

#endif // _CLEANUPBLK_H

Только goto

Тепер пользователю будет труднее допустить ошибку:

#ifndef _CLEANUPBLK_H
#define _CLEANUPBLK_H

#define CLEANUPBLK(name) \
goto  __CLEANUPBLK_##name; \
goto __CLEANUPBEG_##name; \
goto __CLEANUPEND_##name; \
__CLEANUPBLK_##name:

#define CLEANUPBEG(name) \
goto __CLEANUPBEG_##name; \
goto  __CLEANUPBLK_##name; \
goto __CLEANUPEND_##name; \
__CLEANUPBEG_##name:

#define CLEANUPNEXT(name, val) \
__CLEANUPNEXT_##name##_##val:

#define CLEANUPEND(name) \
goto __CLEANUPEND_##name; \
goto __CLEANUPBLK_##name; \
goto __CLEANUPBEG_##name; \
__CLEANUPEND_##name:

#define CLEANUPALL(name) \
goto __CLEANUPBEG_##name

#define CLEANUPBRK(name) \
goto __CLEANUPEND_##name

#define CLEANUPSEL(name, val) \
goto __CLEANUPNEXT_##name##_##val

#endif // _CLEANUPBLK_H

Кажется счастье уже не далеко :)))

Кажется я нашел:

#ifndef _CLEANUPBLK_H
#define _CLEANUPBLK_H

#define CLEANUPBLK(name) \
goto  __CLEANUPBLK_##name; \
goto __CLEANUPBEG_##name; \
goto __CLEANUPEND_##name; \
__CLEANUPBLK_##name: \
{

#define CLEANUPBEG(name) \
} \
goto __CLEANUPBEG_##name; \
goto  __CLEANUPBLK_##name; \
goto __CLEANUPEND_##name; \
__CLEANUPBEG_##name: \
{

#define CLEANUPNEXT(name, val) \
} \
__CLEANUPNEXT_##name##_##val: \
{

#define CLEANUPEND(name) \
} \
goto __CLEANUPEND_##name; \
goto __CLEANUPBLK_##name; \
goto __CLEANUPBEG_##name; \
__CLEANUPEND_##name:

#define CLEANUPALL(name) \
goto __CLEANUPBEG_##name

#define CLEANUPBRK(name) \
goto __CLEANUPEND_##name

#define CLEANUPSEL(name, val) \
goto __CLEANUPNEXT_##name##_##val

#endif // _CLEANUPBLK_H

1. Можно поизвращаться с setjmp/longjmp, эмулировать на них исключения
2. RAII, http://en.wikipedia.org/wiki/RAII
В Си это будет автоматические переменные, на стеке, блок { auto int x = ...} по которому автоматически автоматические переменные самоуничтожатся
3. Может, что-то можно придумать с GCC расширением про адресуемые метки, "labels as values":
---------------8<---------------------
typedef void *Inst;
void engine()
{
static Inst program[] = { &&add /* ... */ };
Inst *ip = program;
int *sp;
goto *ip++; /* dispatch first VM inst. */
add:
sp[1]=sp[0]+sp[1];
sp++;
goto *ip++; /* dispatch next VM inst. */
}
====================8<===============
Figure 1: Direct threaded code using GNU C’s “labels as values”

то есть, у тебя будет код вроде:


(подставляется в что-то вроде:)

CLEANUP(LB1,1)
{ auto STATUS result1=init1( ... );
if (!result1) {goto LB1}
...
LB1:
clean1();
}

static Inst labels[] = { NULL, &&LB1, &&LB2 /* ... */ };

CLEANUP(LB1,1)
{ auto STATUS result1=init1(..);
if (!result1) {goto labels[1]};
...
LB1:
clean1();
}

resultN, labels[N] (а не *curlabel++) -- чтобы сохранялась прозрачность абстракции макры, чтобы можно было вкладывать их друг в друга (CLEANUP в CLEANUP).
В принципе, CLEANUP можно обернуть другой макрой, которая будет это N корректно вести по вложенности

У меня их тоже можно вкладывать, но прийдется вызывать все макры с именем блока. CLEANUPBLK(main) { CLEANUPBLK(test) { } CLEANUPBEG(test) { } CLEANUPEND(test) } CLEANUPBEG(main) { ... } CLEANUPEND(main)

У меня их тоже можно вкладывать, но прийдется вызывать все макры с именем блока.
CLEANUPBLK(main)
{
  CLEANUPBLK(test)
  {
  }
  CLEANUPBEG(test)
  {
  }
  CLEANUPEND(test)
}
CLEANUPBEG(main)
{
 ...
}
CLEANUPEND(main)

соответственно, идея в том, что при хороших макрах в духе DRY (Don't Repeat Yourself) эти LBN и N в static Inst labels[] = { NULL, ...} и CLEANUP(LB##N,N) не будут создаваться руками, а какой-то другой макрой, чтобы нельзя было сделать дурацкую ручную ошибку.

1 => IN
2
2
2
1 => OUT
1

1             => IN 
 2
 2
 2
1             => OUT
1

а resultN тоже организовать в массив. Тогда можно проимитировать исключения, выдать диагностику result[N] по которой видно, где что успело проинициализироваться, а где нет.

Спасибо тебе за помощь вот результат поддерживаются вложения:

#ifndef _CLEANUPBLK_H
#define _CLEANUPBLK_H

#include <errno.h>

#define CLEANUPBLK(name) \
do \
{ \
void *__cleanupblklabel = &&__cleanupblk_##name; \
goto __cleanupblk_##name##_do; \
__cleanupblk_##name: break; \
__cleanupblk_##name##_do:

#define CLEANUPBEG \
errno = 0; \
} \
while (0);  \
switch (errno) \
{ \
	case -1: \
		break; \
	case 0: \
	{

#define CLEANUPNEXT(val) \
	} \
	case val: \
	{

#define CLEANUPEND \
	} \
}

#define CLEANUPALL \
errno = 0; \
goto *__cleanupblklabel

#define CLEANUPBRK \
errno = -1; \
goto *__cleanupblklabel

#define CLEANUPSEL(val) \
errno = val; \
goto *__cleanupblklabel

#endif // _CLEANUPBLK_H

Какой бессмысленный ужас.

.h

#ifndef _CLEANUPBLK_H
#define _CLEANUPBLK_H

extern int __cleanupblk_exit_code;

#define CLEANUPBLK(name) \
do \
{ \
void *__cleanupblk_break = &&__cleanupblk_##name##_break; \
goto __cleanupblk_##name##_do; \
__cleanupblk_##name##_break: break; \
__cleanupblk_##name##_do:

#define CLEANUPBEG \
__cleanupblk_exit_code = 0; \
} \
while (0);  \
switch (__cleanupblk_exit_code) \
{ \
	case -1: \
		break; \
	case 0: \
	{

#define CLEANUPNEXT(val) \
	} \
	case val: \
	{

#define CLEANUPEND \
	} \
}

#define CLEANUPALL \
{ \
__cleanupblk_exit_code = 0; \
goto *__cleanupblk_break; \
}

#define CLEANUPBRK \
{ \
__cleanupblk_exit_code = -1; \
goto *__cleanupblk_break; \
}

#define CLEANUPSEL(val) \
{ \
__cleanupblk_exit_code = val; \
goto *__cleanupblk_break; \
}

#endif // _CLEANUPBLK_H

.c
#include "cleanupblk.h"

int __cleanupblk_exit_code;

Исправил маленькие недочеты, кажется тепер все. Я счастлив :))))

Мой мозг съел c++ :)))

Не надо сваливать это на Си++. Прикола ради напиши вариант _использования_ твоих мега-макросов.

CLMETD(modbus_rtu, bool, run, (self, bool support_restart))
{
	bool result = false;
	void *old_int_handler;
	void *old_pipe_handler;
	tcp_serv_t tcp_serv;
	rt_t rt;
	rt_timer_t rt_timer;
	sigset_t old_sigset;
	
	self->clockid = clocktype2clockid(self->clock_type, NULL);

	CLEANUPBLK()
	{
		if (support_restart && (old_int_handler = signal(SIGINT, modbus_rtu_stop_handler)) == SIG_ERR)
		{
			SYSLOG_ERRNO_FL(LOG_ERR, "signal error");
			CLEANUPBRK;
		}

		if ((old_pipe_handler= signal(SIGPIPE, SIG_IGN)) == SIG_ERR)
		{
			SYSLOG_ERRNO_FL(LOG_ERR, "signal error");
			CLEANUPSEL(1);
		}

		if (!modbus_rtu_ports_open(self))
			CLEANUPSEL(2);

		if (!tcp_serv_start(&tcp_serv, self->listen_port, self->max_connection, POLLIN | POLLOUT | POLLERR,
							true, self, NULL, modbus_rtu_client_handler, modbus_rtu_pre_handler, NULL))
			CLEANUPSEL(3);

		if (!rt_enable(&rt, schedpolicy2int(self->sched_policy, NULL),
					   self->rt_sched_priority, PREFAULT_STACK_SIZE))
			CLEANUPSEL(4);

		if (!rt_timer_create(&rt_timer, self->clockid, SIGALRM, modbus_rtu_alarm_handler))
			CLEANUPSEL(5);

		if (!rt_timer_sigblock(&rt_timer, &old_sigset))
			CLEANUPSEL(6);

		struct itimerspec itspc;
		itspc.it_value.tv_sec = 1;
		itspc.it_value.tv_nsec = 0;
		itspc.it_interval.tv_sec = 1;
		itspc.it_interval.tv_nsec = 0;

		if (!rt_timer_start(&rt_timer, &itspc))
			CLEANUPALL;

		// do work
		modbus_rtu_work = 1;
		while (modbus_rtu_work == 1)
		{
			if (!rt_timer_sigsuspend(&rt_timer, &old_sigset))
				break;

			int count = tcp_serv_poll(&tcp_serv, tcp_serv.active_conn == 0 ? -1 : 0);
			if (count == -1)
				break;
			if (count > 0)
				SYSLOG_FL(LOG_ERR, "poll not full handling, not handlied socket count = %d",, count);
		}
		if (modbus_rtu_work != 1)
			result = true;
	}
	CLEANUPBEG
	{
		rt_timer_sigunblock(&rt_timer, &old_sigset);
	}
	CLEANUPNEXT(6)
	{
		rt_timer_destroy(&rt_timer);
	}
	CLEANUPNEXT(5)
	{
		rt_disable(&rt);
	}
	CLEANUPNEXT(4)
	{
		tcp_serv_stop(&tcp_serv);
	}
	CLEANUPNEXT(3)
	{
		modbus_rtu_ports_close(self);
	}
	CLEANUPNEXT(2)
	{
		if (signal(SIGPIPE, old_pipe_handler) == SIG_ERR)
			SYSLOG_ERRNO_FL(LOG_ERR, "signal error");
	}
	CLEANUPNEXT(1)
	{
		if (support_restart && signal(SIGINT, old_int_handler) == SIG_ERR)
			SYSLOG_ERRNO_FL(LOG_ERR, "signal error");
	}
	CLEANUPEND;

	return result;
} // CLMETD(modbus_rtu, bool, run)

И это лучше, чем обычный вариант со структурным goto? Если да, то чем?

Вопервых goto может прыгнуть хот куда, а c моими инструкциями(CLEANUPALL, CLEANUPBRK, CLEANUPSEL) мы ограничены тем блоком в котором мы их вызываем. Да и при использовании вложенных блоков гораздо трудьнее допустить ошибки с именами меток.

выглядит ужасно. Дикая смесь из while(0), switch, goto *laber_addr.. брр

Да, но использовать мне удобно.

лучше составь конечный автомат и прикрути http://en.wikipedia.org/wiki/Ragel http://www.complang.org/ragel/

> при использовании вложенных блоков гораздо трудьнее допустить ошибки с именами меток.

Ты хочешь сказать, то ошибиться с циферкой в CLEANUPSEL сложнее, чемс читабельным именем метки в goto? Да ты робот, по ходу.

Впрочем, если хочешь набить синяков именно таким причудливым образом, дело твое.

enum или #define должны помочь не роботам.

Ты не бойся я этим 1,2,3 по позже дам нормальные имена.

> 1. void *__cleanupblk_break = &&__cleanupblk_##name##_break;
..
> 2. goto *__cleanupblk_break; \

сдаётся, goto "label as value" тут не очень нужен.

1. что будет, если попадутся вложенная часть 1.?
то есть, не A.1 A.2 B.1 B.2, а A.1 B.1 B.2 A.2 ?
(B.1 перезатирает внутреннюю переменную в макре A.1)

2. помни, что это GCC-расширение, и код становится немобильным на другие С компиляторы.

> enum или #define должны помочь не роботам.

Количество писанины растет, а выгод как-то не прибавляется %) Насчет блочной дисциплины твоих макросов - перепутать местами CLEANUPSEL мложно, так ведь? И компилятор этого не заметит, как и в случае с goto.

не надо им вообще имена давать вручную.
CLEANUPBLK()
{ {
CLEANUPBRK;
CLEANUPSEL(1);
{ CLEANUPSEL(2);
}

CLEANUPSEL(3);

CLEANUPSEL(4);
CLEANUPSEL(5);

CLEANUPSEL(6);

..
CLEANUPALL;

// do work
CLEANUPBEG
CLEANUPNEXT(6)
CLEANUPNEXT(5)
CLEANUPNEXT(4)
CLEANUPNEXT(3)
CLEANUPNEXT(2)
CLEANUPNEXT(1)
CLEANUPEND;

return result;
} // CLMETD(modbus_rtu, bo


чёткий паттерн 12345677654321. Вот в макре другой его и посчитай, оберни эти CLEANUPSEL(N)/CLEANUPNEXT(N) в какой-то стек.

>1. что будет, если попадутся вложенная часть 1.?
то есть, не A.1 A.2 B.1 B.2, а A.1 B.1 B.2 A.2 ?
(B.1 перезатирает внутреннюю переменную в макре A.1)

Я основывался на этом принципе:
{
  void *label <------
                    |
  ...----------------
  {                 |
    void *label<--  |
                 |  |
    goto *label---  |
  }                 |
  goto *label -------
}
если они верен то значит должно быть все впорядке

>чёткий паттерн 12345677654321. Вот в макре другой его и посчитай, оберни эти CLEANUPSEL(N)/CLEANUPNEXT(N) в какой-то стек.

Да для данного конкретного случая скорее всего сделаю какой нибудь макрос.

На всякий случай замечу что этот исходник я переделал как только сделал данные макросы и это еще не конечный результат.

Я не говорю что они идеальны. Я просто хочу выяснить нужны они мне или нет.

> Я просто хочу выяснить нужны они мне или нет.

Если они вообще кому-то и нужны, то только тебе одному, ибо ты их автор. Все остальные пользуются структурным goto для случая отдельной функции, пулом (в стиле APR, например) для стека вызовов, или конечным автоматом. А реализовать нормальные "локальные исключения" тебе не позволит ограниченность препроцессора Си.

Мамочки...

У меня только один вопрос. goto -- переход безусловный? В чем тогда смысл нескольких последовательных goto в макросе CLEANUPEND?

Сначало лишние goto ипользовал чтобы компилятор не кричал что есть неиспользованные метки, а потом для чтобы компилятор предупреждал когда я забуду одно из слов (CLEANUPBLK, CLEANUPBEG, CLEANUPNEXT, CLEANUPEND)

m4 не подойдёт? Более мощный препроцессор. Код сейчас не приведу, не
 помню. Но общая идея - можно сделать блок кода аргументом макроса. 
Т.е., задать что-то на входе и на выходе. 

Также нужно будет помнить, что нельзя внутри блока пользоваться 
longjmp (или как оно там называется). А goto и return, возможно, 
стоит перекрыть. 

В применении это будет выглядеть примерно так:

PROTECTED_BLOCK({ код инициализации 1},
  { 
  защищённый код уровня 1; 
  return;  // перекрыт, чтобы выполнять раскрутку
  PROTECTED_BLOCK({ код инициализации 2},
                    {защищённый код уровня 2},
                    {откат уровня 2})
  },
{ откат уровня 1 })

> Вопервых goto может прыгнуть хот куда

Откуда вы такие беретесь?

Когда коту делать нечего от яйца лижет. Вы немного дальше пошли.

Exceptions in C: http://adomas.org/excc/exceptions.pdf

>Откуда вы такие беретесь?

Откуда вы такие беретесь?

> Exceptions in C: http://adomas.org/excc/exceptions.pdf

Любопытная штука, но завязана на GNU-расширение и не thread-safe.

Скорее всего так

:))) Вот это торкнуло :)
Оно зачем а? Коллег врагами делать чтоли?

>:))) Вот это торкнуло :) Оно зачем а? Коллег врагами делать чтоли?

Откуда вы такие беретесь? :)))

По его словам я бы не сказал что он мне коллега

Я так и не понял до конца, что тебе надо, но видимо проще всего здесь юзать гнутое расширение ({ })

#define WITH(res, arg, block) { res* resource=init_res(arg); if(!res) goto end; block free_res(res*); end: }

Использование:

WITH(my_res, 123, 
  ({ 
     int i=0; 
     while( i<100 ) {
        WITH( res2, 456, ({  че-то еще })
        ... ну и так далее
     }
  })
)

И еще, чтобы везде ставить ; использовать известный трюк do{}while(0);

исправление -- забыл скобку: WITH( res2, 456, ({ че-то еще }) )

А если ресурсы разных типов, то добавить еще аргумент(ы) в WITH(res, res_init, res_free, block)

Кстати, интел это расширение держит, насчет меток как целых чисел -- не знаю.