void *Md5_Init()
#ifdef _YOYO_MD5_BUILTIN
  {
    static YOYO_FUNCTABLE funcs[] = 
      { {0},
        {Oj_Clone_OjMID, Md5_Clone },
        {Oj_Digest_Update_OjMID, Md5_Update },
        {0}};
    
    YOYO_MD5 *md5 = __Object(sizeof(YOYO_MD5),funcs);
    return Md5_Start(md5);
  }
#endif
  ;

void *Yo_Unwind_Scope(void *pooled,int min_top,void *mark)
#ifdef _YOYO_CORE_BUILTIN
  {
    YOYO_C_SUPPORT_INFO *nfo = Yo_Tls_Get(Yo_Csup_Nfo_Tls);
    int L = min_top>=0?min_top:0;
    //int counter = 0;
    if ( nfo )
      {
        YOYO_AUTORELEASE *q_p = 0;
        nfo->stats.unwinding = 1;
        while ( nfo->auto_top >= L )
          {
            YOYO_AUTORELEASE *q = &nfo->auto_pool[nfo->auto_top];
            STRICT_REQUIRE(nfo->auto_top <= nfo->auto_count);
            //printf("ptr: %p, cleanup: %p ?= pooled: %p, mark: %p\n", q->ptr, q->cleanup, pooled, mark);
            if ( q->ptr && (q->cleanup != Yo_Pool_Marker_Tag) )
              {
                if ( !pooled || q->ptr != pooled )
                  {
                    q->cleanup(q->ptr);
                    //++counter;
                  }
                else
                  q_p = q;
              }
            --nfo->auto_top;
            if ( q->cleanup == Yo_Pool_Marker_Tag && !min_top && mark == q->ptr )
              break;
          }
        REQUIRE(nfo->auto_top < nfo->auto_count);
        if ( q_p )
          {
            ++nfo->auto_top;
            nfo->auto_pool[nfo->auto_top] = *q_p;
          }
        nfo->stats.unwinding = 0;
      }
    //printf("unwind: released %d ptrs, still pooled %d ptrs\n",counter,nfo->auto_top+1);
    return pooled;
  }
#endif
  ;

int YOYO_LOCAL_ID(ar_Mark); \

while () __Auto_Release

P>>TLS тебе нужен в случаях использования __Auto_Release поэтому большой разницы в количестве раз его использования при __Auto_Release я не вижу.

P>>>>>кстати, на счёт этого макроса — а разве нельзя его было сделать через for?

AS>int Idnty_Of(YO_XNODE *Q, char *email, char *first, char *last)
AS>  {
AS>    char *hex;
AS>    int i = 0;
AS>    YO_XNODE *q;
AS>    YO_MD5 *md5 = Md5_Init();
    
AS>    email = Str_Utf8_Lower(email);
AS>    first = Str_Utf8_Upper(first);
AS>    last  = Str_Utf8_Upper(last);
    
AS>    Md5_Update(md5,email,strlen(email));
AS>    Md5_Update(md5,first,strlen(first));
AS>    Md5_Update(md5,last,strlen(last));
AS>    hex = Str_Hex_Encode(Md5_Finish(md5,0),16);
  
AS>    q = Xnode_Down_If(Q,"idnty");
AS>    if ( q ) 
AS>      {
AS>        __Raise_If( Xnode_Value_Get_Int(q,"no",-1) != i, "identity index is broken" );
AS>        if ( !strcmp( hex, Xnode_Value_Get_Str(q,"@","") ) )
AS>          {
AS>            return i;
AS>          }
AS>        ++i;
AS>        q = Xnode_Next_If(q,"idnty");
AS>      }
    
AS>    q = Xnode_Append(Q,"idnty");
AS>    Xnode_Value_Set_Str(q,"email",email);
AS>    Xnode_Value_Set_Str(q,"first",first);
AS>    Xnode_Value_Set_Str(q,"last",last);
AS>    Xnode_Value_Set_Str(q,"@",hex);
AS>    Xnode_Value_Set_Int(q,"no",i);
    
AS>    return i;    
AS>  }
AS>

YO_MD5 *md5 = Md5_Init();

email = Str_Utf8_Lower(email);
first = Str_Utf8_Upper(first);
last  = Str_Utf8_Upper(last);

P>  #define __Auto_Release \
P>  switch ( 0 ) while ( 1 ) \
P>    if ( 1 ) \
P>      { \
P>        Yo_Unwind_Scope(0,0,0); \
P>        break; \
P>      case 0: Yo_Push_Scope(); \
P>        goto YOYO_LOCAL_ID(ar_Body);\
P>      } \
P>    else \
P>      YOYO_LOCAL_ID(ar_Body):

P>

P>__Auto_Release
P>{

P>}
P>

#include <stdio.h>
 
int push(void)
{
        printf("push\n");
        return 1;
}
 
void pop(int *x)
{
        printf("pop\n");
        *x=0;
}
 
#define MACRO_RAII for(int temp_var=push();temp_var==1;pop(&temp_var))
 
int main(void)
{
        MACRO_RAII
        {
                printf("LOL\n");
        }       
        return 0;
}

push
LOL
pop

void foo ()
{
 bar ();
 
 if (foofoo ())
 {
  int i;
    
    foobar ();
 }
}

int Idnty_Of(YO_XNODE *Q, char *email, char *first, char *last)
  {
    char *hex;
    int i = 0;
    YO_XNODE *q;
    YO_MD5 *md5 = Md5_Init();
    
    email = Str_Utf8_Lower(email);
    first = Str_Utf8_Upper(first);
    last  = Str_Utf8_Upper(last);
    
    Md5_Update(md5,email,strlen(email));
    Md5_Update(md5,first,strlen(first));
    Md5_Update(md5,last,strlen(last));
    hex = Str_Hex_Encode(Md5_Finish(md5,0),16);
  
    q = Xnode_Down_If(Q,"idnty");
    if ( q ) 
      {
        __Raise_If( Xnode_Value_Get_Int(q,"no",-1) != i, "identity index is broken" );
        if ( !strcmp( hex, Xnode_Value_Get_Str(q,"@","") ) )
          {
            return i;
          }
        ++i;
        q = Xnode_Next_If(q,"idnty");
      }
    
    q = Xnode_Append(Q,"idnty");
    Xnode_Value_Set_Str(q,"email",email);
    Xnode_Value_Set_Str(q,"first",first);
    Xnode_Value_Set_Str(q,"last",last);
    Xnode_Value_Set_Str(q,"@",hex);
    Xnode_Value_Set_Int(q,"no",i);
    
    return i;    
  }

some_shit_for_md5(Md5_Finish(md5_1,0),Md5_Finish(md5_2,0));

P>some_shit_for_md5(Md5_Finish(md5_1,0),Md5_Finish(md5_2,0));
P>

  void *Md5_Finish(YO_MD5 *md5, void *digest)
    {
      if ( !md5->finished )
        {
          static byte_t PADDING[64] = {
            0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
          };
          byte_t bits[8];
          uint_t index, padLen;
          Md5_Internal_Encode (bits, md5->count, 8);
          index = (uint_t)((md5->count[0] >> 3) & 0x3f);
          padLen = (index < 56) ? (56 - index) : (120 - index);
          Md5_Update(md5, PADDING, padLen);
          Md5_Update(md5, bits, 8);
          md5->finished = 1;
        }
      if ( !digest ) digest = __Malloc(16);
      Md5_Internal_Encode(digest, md5->state, 16);
      return digest;
    }

byte_t digest[16];
YO_MD5 md5 = YO_MD5_INITIALIZER;
Md5_Update(&md5,data,len);
Md5_Finish(&md5,digest);

или ещё короче, что ровно то же самое

byte_t digest[16];
Md5_Digest(data,len,digest);

int saved_deep=current_stack_deep();
// do any shit
stack_unwind_to_deep(saved_deep);

P>>int saved_deep=current_stack_deep();
P>>// do any shit
P>>stack_unwind_to_deep(saved_deep);
P>>

  #define __Auto_Release \
  switch ( 0 ) while ( 1 ) \
    if ( 1 ) \
      { \
        Yo_Unwind_Scope(0,0,0); \
        break; \
      case 0: Yo_Push_Scope(); \
        goto YOYO_LOCAL_ID(ar_Body);\
      } \
    else \
      YOYO_LOCAL_ID(ar_Body):

__Auto_Release
{

}