ellipsis-tlist.h

Go to the documentation of this file.

 
#ifndef ELLIPSIS_TLIST_H
#define ELLIPSIS_TLIST_H 1
 
#include "ellipsis-token.h"
#include "utils/ellipsis-error.h"
#include <threads.h>
 
extern thread_local bool volatile ellipsis‿contracts‿ignore‿dynamic;
extern thread_local bool volatile ellipsis‿contracts‿proceed‿dynamic;
extern thread_local bool volatile ellipsis‿contracts‿verbose‿dynamic;
 
typedef struct ellipsis‿contracts‿is_ice ellipsis‿contracts‿is_ice;
 
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
 
#define STRINGIFY(...) STRINGIFY_(__VA_ARGS__)
#define STRINGIFY_(...) #__VA_ARGS__
 
#define ELLIPSIS_CONTRACT_VIOLATION(COUNT, VERB, CTYPE, CSTR, ...) \
({\
 static char const contract_format_ ## COUNT[]  = \
 __FILE__ ":" STRINGIFY(__LINE__) ": violation of " CTYPE " `" CSTR "`" __VA_OPT__(", ") __VA_ARGS__ "\n";\
 (VERB \
 ? fputs(contract_format_ ## COUNT, stderr) \
 : 0);\
 })
 
#define ELLIPSIS_CONTRACT_IMPL(COUNT, COND, ACTION, VERB, CSTR, CTYPE, ...) \
(((false) || (COND)) \
 ? (void)0 \
 : (ELLIPSIS_CONTRACT_VIOLATION(COUNT, VERB, CTYPE, CSTR __VA_OPT__(,) __VA_ARGS__) \
 , ((false) \
 ? (void)0 \
 : ACTION())))
 
#define ELLIPSIS_TO_VOIDS(...) ((void*)((uintptr_t)((__VA_ARGS__)-(__VA_ARGS__))))
 
#define ELLIPSIS_TEST_ICE(...) (false ? ELLIPSIS_TO_VOIDS(__VA_ARGS__) : (ellipsis‿contracts‿is_ice*)nullptr)
 
#define ELLIPSIS_CONTRACT_ICE_OR_TRUE(...) \
 _Generic( \
 ELLIPSIS_TEST_ICE(__VA_ARGS__), \
 ellipsis‿contracts‿is_ice*: (__VA_ARGS__), \
 default: true)
 
#define ELLIPSIS_CONTRACT_CHECK_STATIC(CTYPE, COND, CSTR, ...) \
 ({\
 static_assert(ELLIPSIS_CONTRACT_ICE_OR_TRUE(COND), \
 "compile time violation of " CTYPE " " CSTR \
 __VA_OPT__(", ") __VA_ARGS__ );\
 })
 
#define ELLIPSIS_CONTRACT(COUNT, COND, ACTION, VERB, CSTR, CTYPE, ...) \
 \
 do { \
 _Generic( \
 ELLIPSIS_TEST_ICE(COND), \
 ellipsis‿contracts‿is_ice*: ELLIPSIS_CONTRACT_CHECK_STATIC(CTYPE, COND, CSTR __VA_OPT__(,) __VA_ARGS__), \
 default: ELLIPSIS_CONTRACT_IMPL(COUNT, COND, ACTION, VERB, CSTR, CTYPE __VA_OPT__(,) __VA_ARGS__));\
 } while(false)
 
typedef ellipsis‿token token;
 
struct ellipsis‿token‿list {
  [[deprecated]] mtx_t mtx;
  [[deprecated]] cnd_t cnd;
  [[deprecated]] token* first;
  [[deprecated]] token* last;
  [[deprecated]] bool finished;
};
 
inline
ellipsis‿token‿list* ellipsis‿token‿list‿init(ellipsis‿token‿list __LOC_ID_0_1[static const 1]) {
  typeof(ellipsis‿token‿list*) DEFER_LOC_ID_0_1;
  if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
    DEFER_LOC_ID_0_1 = (typeof(ellipsis‿token‿list*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_1:
    goto DEFER_END_ID_1_2;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(1, __LOC_ID_0_1, abort, true, "__LOC_ID_0_1", "assertion", "attempt to initialize an invalid token list");} while (false);
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_1)[DEFER_LOC_ID_0_2]  = {};
    if (false) {
    DEFER_ID_1_2: {
        [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
        register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag  = false;
        {ELLIPSIS_CONTRACT(2, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "unable to initialize a token list");}
      }
      goto DEFER_ID_1_1;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿list‿init) ellipsis‿token‿list‿init‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿list‿init‿_Insta(__LOC_ID_0_1);
      goto DEFER_ID_1_2;
    } while(false);
 
    goto DEFER_ID_1_2;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_2:;
  return DEFER_LOC_ID_0_1;
}
 
inline
ellipsis‿token‿list* ellipsis‿token‿list‿cpy(ellipsis‿token‿list __LOC_ID_0_2[static const 1]) {
  typeof(ellipsis‿token‿list*) DEFER_LOC_ID_0_1;
  if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
    DEFER_LOC_ID_0_1 = (typeof(ellipsis‿token‿list*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_3:
    goto DEFER_END_ID_1_4;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(3, __LOC_ID_0_2, abort, true, "__LOC_ID_0_2", "assertion", "attempt to copy an an invalid token list");} while (false);
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_2)[DEFER_LOC_ID_0_2]  = {};
    if (false) {
    DEFER_ID_1_4: {
        [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
        register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag  = false;
        {ELLIPSIS_CONTRACT(4, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "unable to copy a token list");}
      }
      goto DEFER_ID_1_3;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿list‿cpy) ellipsis‿token‿list‿cpy‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿list‿cpy‿_Insta(__LOC_ID_0_2);
      goto DEFER_ID_1_4;
    } while(false);
 
    goto DEFER_ID_1_4;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_4:;
  return DEFER_LOC_ID_0_1;
}
 
STDC_ATTR_NODISCARD()
inline
ellipsis‿str32* ellipsis‿token‿list‿stringify(ellipsis‿token‿list const __LOC_ID_0_3[static const 1]) {
  typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
  if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
    DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_5:
    goto DEFER_END_ID_1_6;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(5, __LOC_ID_0_3, abort, true, "__LOC_ID_0_3", "assertion", "attempt to stringify an an invalid token list");} while (false);
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_3)[DEFER_LOC_ID_0_2]  = {};
    if (false) {
    DEFER_ID_1_6: {
        [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
        register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag  = false;
        {ELLIPSIS_CONTRACT(6, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), unreachable, false, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assumption", "unable to stringify a token list");}
      }
      goto DEFER_ID_1_5;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿list‿stringify) ellipsis‿token‿list‿stringify‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿list‿stringify‿_Insta(__LOC_ID_0_3);
      goto DEFER_ID_1_6;
    } while(false);
 
    goto DEFER_ID_1_6;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_6:;
  return DEFER_LOC_ID_0_1;
}
 
inline
size_t ellipsis‿token‿list‿scatter(size_t len, ellipsis‿token‿list arg[static len], ellipsis‿token‿list in[restrict static 1], bool var, bool call, ellipsis‿str32 const** space) {
  typeof(size_t) DEFER_LOC_ID_0_1;
  if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
    DEFER_LOC_ID_0_1 = (typeof(size_t)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_7:
    goto DEFER_END_ID_1_8;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(7, arg, abort, true, "arg", "assertion", "attempt to scatter into an invalid token list");} while (false);
    do {ELLIPSIS_CONTRACT(8, in, abort, true, "in", "assertion", "attempt to scatter from an invalid token list");} while (false);
    extern typeof(ellipsis‿token‿list‿scatter) ellipsis‿token‿list‿scatter‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿list‿scatter‿_Insta(len, arg, in, var, call, space);
      goto DEFER_ID_1_7;
    } while(false);
 
    goto DEFER_ID_1_7;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_8:;
  return DEFER_LOC_ID_0_1;
}
 
inline
ellipsis‿token‿list* ellipsis‿token‿list‿init‿_Ctra(ellipsis‿token‿list __LOC_ID_0_4[static const 1]) {
  typeof(ellipsis‿token‿list*) DEFER_LOC_ID_0_1;
  if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
    DEFER_LOC_ID_0_1 = (typeof(ellipsis‿token‿list*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_8:
    goto DEFER_END_ID_1_10;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(9, __LOC_ID_0_4, unreachable, false, "__LOC_ID_0_4", "assumption", "attempt to initialize an invalid token list");} while (false);
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_4)[DEFER_LOC_ID_0_2]  = {};
    if (false) {
    DEFER_ID_1_9: {
        [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
        register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag  = false;
        {ELLIPSIS_CONTRACT(10, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "unable to initialize a token list");}
      }
      goto DEFER_ID_1_8;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿list‿init‿_Ctra) ellipsis‿token‿list‿init‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿list‿init‿_Inner(__LOC_ID_0_4);
      goto DEFER_ID_1_9;
    } while(false);
 
    goto DEFER_ID_1_9;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_10:;
  return DEFER_LOC_ID_0_1;
}
 
inline
ellipsis‿token‿list* ellipsis‿token‿list‿cpy‿_Ctra(ellipsis‿token‿list __LOC_ID_0_5[static const 1]) {
  typeof(ellipsis‿token‿list*) DEFER_LOC_ID_0_1;
  if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
    DEFER_LOC_ID_0_1 = (typeof(ellipsis‿token‿list*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_10:
    goto DEFER_END_ID_1_12;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(11, __LOC_ID_0_5, unreachable, false, "__LOC_ID_0_5", "assumption", "attempt to copy an an invalid token list");} while (false);
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_5)[DEFER_LOC_ID_0_2]  = {};
    if (false) {
    DEFER_ID_1_11: {
        [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
        register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag  = false;
        {ELLIPSIS_CONTRACT(12, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "unable to copy a token list");}
      }
      goto DEFER_ID_1_10;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿list‿cpy‿_Ctra) ellipsis‿token‿list‿cpy‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿list‿cpy‿_Inner(__LOC_ID_0_5);
      goto DEFER_ID_1_11;
    } while(false);
 
    goto DEFER_ID_1_11;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_12:;
  return DEFER_LOC_ID_0_1;
}
 
STDC_ATTR_NODISCARD()
inline
ellipsis‿str32* ellipsis‿token‿list‿stringify‿_Ctra(ellipsis‿token‿list const __LOC_ID_0_6[static const 1]) {
  typeof(ellipsis‿str32*) DEFER_LOC_ID_0_1;
  if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
    DEFER_LOC_ID_0_1 = (typeof(ellipsis‿str32*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_12:
    goto DEFER_END_ID_1_14;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(13, __LOC_ID_0_6, unreachable, false, "__LOC_ID_0_6", "assumption", "attempt to stringify an an invalid token list");} while (false);
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_6)[DEFER_LOC_ID_0_2]  = {};
    if (false) {
    DEFER_ID_1_13: {
        [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
        register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag  = false;
        {ELLIPSIS_CONTRACT(14, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "unable to stringify a token list");}
      }
      goto DEFER_ID_1_12;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿list‿stringify‿_Ctra) ellipsis‿token‿list‿stringify‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿list‿stringify‿_Inner(__LOC_ID_0_6);
      goto DEFER_ID_1_13;
    } while(false);
 
    goto DEFER_ID_1_13;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_14:;
  return DEFER_LOC_ID_0_1;
}
 
inline
size_t ellipsis‿token‿list‿scatter‿_Ctra(size_t len, ellipsis‿token‿list arg[static len], ellipsis‿token‿list in[restrict static 1], bool var, bool call, ellipsis‿str32 const** space) {
  typeof(size_t) DEFER_LOC_ID_0_1;
  if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
    DEFER_LOC_ID_0_1 = (typeof(size_t)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_14:
    goto DEFER_END_ID_1_16;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(15, arg, unreachable, false, "arg", "assumption", "attempt to scatter into an invalid token list");} while (false);
    do {ELLIPSIS_CONTRACT(16, in, unreachable, false, "in", "assumption", "attempt to scatter from an invalid token list");} while (false);
    extern typeof(ellipsis‿token‿list‿scatter‿_Ctra) ellipsis‿token‿list‿scatter‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿list‿scatter‿_Inner(len, arg, in, var, call, space);
      goto DEFER_ID_1_14;
    } while(false);
 
    goto DEFER_ID_1_14;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_16:;
  return DEFER_LOC_ID_0_1;
}
 
token const* ellipsis‿token‿list‿top(ellipsis‿token‿list[static 1]);
 
token* ellipsis‿token‿list‿first(ellipsis‿token‿list[static 1]);
 
token* ellipsis‿token‿list‿last(ellipsis‿token‿list[static 1]);
 
void ellipsis‿token‿list‿open(ellipsis‿token‿list[static 1]);
 
void ellipsis‿token‿list‿close(ellipsis‿token‿list[static 1]);
 
void ellipsis‿token‿list‿destroy(ellipsis‿token‿list[static 1]);
 
void ellipsis‿token‿list‿wait(ellipsis‿token‿list[static 1]);
 
bool ellipsis‿token‿list‿is_finished(ellipsis‿token‿list[static 1]);
 
inline
void ellipsis‿token‿list‿delete(ellipsis‿token‿list* tl) {
  if (tl) {
    ellipsis‿token‿list‿destroy(tl);
    free(tl);
  }
}
 
inline void ellipsis‿token‿list‿move(ellipsis‿token‿list* __LOC_ID_0_7[restrict static 1], ellipsis‿token‿list**restrict __LOC_ID_0_8) {
  if (*__LOC_ID_0_7)
    ellipsis‿token‿list‿delete((void*)*__LOC_ID_0_7);
  if (__LOC_ID_0_8) {
    *__LOC_ID_0_7= *__LOC_ID_0_8;
    *__LOC_ID_0_8= nullptr;
  } else {
    *__LOC_ID_0_7= nullptr;
  }
 
}
 
STDC_ATTR_NODISCARD()
inline
ellipsis‿token‿list* ellipsis‿token‿list‿new(void) {
  typeof(ellipsis‿token‿list*) DEFER_LOC_ID_0_1;
  if (__func__[0] == 'm' && __func__[1] == 'a' && __func__[2] == 'i' && __func__[3] == 'n' && !__func__[4]) {
    DEFER_LOC_ID_0_1 = (typeof(ellipsis‿token‿list*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_15:
    goto DEFER_END_ID_1_18;
  } else { 
    (void)0 ;
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_7)[DEFER_LOC_ID_0_2]  = {};
    if (false) {
    DEFER_ID_1_16: {
        [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
        register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag  = false;
        {ELLIPSIS_CONTRACT(17, ((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1), abort, true, "defer_return_value", "postcondition", "unable to allocate token list");}
      }
      goto DEFER_ID_1_15;
    } else
      (void)0 ;
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_8)[DEFER_LOC_ID_0_2]  = {};
    if (false) {
    DEFER_ID_1_17: {
        [[__maybe_unused__, __deprecated__("invalid termination of a deferred block")]]
        register bool const defer_return_flag = false, defer_break_flag = false, defer_continue_flag  = false;
        {if (((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)) ellipsis‿token‿list‿init(((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1));}
      }
      goto DEFER_ID_1_16;
    } else
      (void)0 ;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿malloc(sizeof(ellipsis‿token‿list));
      goto DEFER_ID_1_17;
    } while(false);
 
    goto DEFER_ID_1_17;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_18:;
  return DEFER_LOC_ID_0_1;
}
 
token* ellipsis‿token‿list‿pop(ellipsis‿token‿list[static 1]);
 
token* ellipsis‿token‿list‿all(ellipsis‿token‿list[static 1]);
 
void ellipsis‿token‿list‿append(ellipsis‿token‿list[static 1], token*);
 
void ellipsis‿token‿list‿flush(ellipsis‿token‿list target[static 1], ellipsis‿token‿list source[static 1]);
 
void ellipsis‿token‿list‿push(ellipsis‿token‿list target[static 1], ellipsis‿token‿list source[static 1]);
 
size_t ellipsis‿token‿list‿collect_call(size_t len, ellipsis‿token‿list arg[static len], ellipsis‿token‿list in[restrict static 1], bool var, ellipsis‿str32 const* space[static 1]);
 
bool ellipsis‿token‿list‿equiv(ellipsis‿token‿list* a, ellipsis‿token‿list* b);
 
#endif