ellipsis-token.h

Go to the documentation of this file.

 
#ifndef ELLIPSIS_TOKEN_H
#define ELLIPSIS_TOKEN_H 1
 
#include "utils/ellipsis-str32.h"
#include "utils/ellipsis-str8.h"
#include "utils/ellipsis-error.h"
#include "utils/ellipsis-init.h"
#include "ellipsis-category.h"
#include "ellipsis-what.h"
#include <string.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 unsigned long long vtype;
 
typedef struct ellipsis‿token ellipsis‿token;
typedef struct ellipsis‿token‿list ellipsis‿token‿list;
 
typedef ellipsis‿token* macro_cb(ellipsis‿token*);
 
struct ellipsis‿token {
  ellipsis‿str32 const* contents;
  ellipsis‿str32 const* space;
  ellipsis‿token* next;
  union {
    ellipsis‿token‿list* payload;
    macro_cb* callback;
    ellipsis‿str8* data;
  };
  size_t line;
  size_t file;
  vtype value;
ellipsis‿category cat:ellipsis‿category‿width;
  ellipsis‿token‿what is_what:2;
  bool is_functional:1;
  bool is_undefinable:1;
  bool back_in:1;
  bool toeol:1;
};
 
#define TOKEN_IS_INNER_CASE(N) case (N): ret  |= (arr[N-1] != s[N-1])<<(N-1)
 
inline
bool ellipsis‿token‿is_inner(ellipsis‿token const* t, size_t len, char32_t const s[restrict static len]) {
  unsigned ret  = 0;
  if (t
      && t->contents
      && t->contents->length == len) {
    char32_t const*restrict arr = t->contents->array;
    switch (len) {
      TOKEN_IS_INNER_CASE(4);
      TOKEN_IS_INNER_CASE(3);
      TOKEN_IS_INNER_CASE(2);
      TOKEN_IS_INNER_CASE(1);
      ret = !ret;
      /* downgraded */ break;
    default:
      ret = !memcmp(t->contents->array, s, sizeof(char32_t[len]));
    }
  }
  return ret;
}
 
#define TOKEN_IS(T, S) ellipsis‿token‿is_inner(T, (sizeof(U"" S U"")/sizeof(U' '))-1, U"" S U"")
 
inline
void ellipsis‿token‿destroy(ellipsis‿token t[static 1]) {
  extern typeof(ellipsis‿token‿destroy) ellipsis‿token‿destroy‿_Insta;
  ellipsis‿token‿destroy‿_Insta(t);
}
 
inline
void ellipsis‿token‿delete(ellipsis‿token t[static 1]) {
  extern typeof(ellipsis‿token‿delete) ellipsis‿token‿delete‿_Insta;
  ellipsis‿token‿delete‿_Insta(t);
}
 
inline
void ellipsis‿token‿delete_all(ellipsis‿token t[static 1]) {
  extern typeof(ellipsis‿token‿delete_all) ellipsis‿token‿delete_all‿_Insta;
  ellipsis‿token‿delete_all‿_Insta(t);
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿cpy(ellipsis‿token const* t) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__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 ;
    /* 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(1, ((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 token");}
      }
      goto DEFER_ID_1_1;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿cpy) ellipsis‿token‿cpy‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿cpy‿_Insta(t);
      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;
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿deepcpy(ellipsis‿token const* t) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__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 ;
    /* 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(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 deep copy token");}
      }
      goto DEFER_ID_1_3;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿deepcpy) ellipsis‿token‿deepcpy‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿deepcpy‿_Insta(t);
      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;
}
 
inline
ellipsis‿token* ellipsis‿token‿alloc(void) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__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 ;
    /* 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(3, ((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 allocate token");}
      }
      goto DEFER_ID_1_5;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿alloc) ellipsis‿token‿alloc‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿alloc‿_Insta();
      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
bool ellipsis‿token‿equiv(ellipsis‿token* a, ellipsis‿token* b) {
  extern typeof(ellipsis‿token‿equiv) ellipsis‿token‿equiv‿_Insta;
  return ellipsis‿token‿equiv‿_Insta(a, b);
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿string(char const str[static 1]) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__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(4, str, abort, true, "str", "assertion", "attempt to create string token from invalid string");} 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_8: {
        [[__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(5, ((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 create string token");}
      }
      goto DEFER_ID_1_7;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿string) ellipsis‿token‿string‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿string‿_Insta(str);
      goto DEFER_ID_1_8;
    } while(false);
 
    goto DEFER_ID_1_8;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_8:;
  return DEFER_LOC_ID_0_1;
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿nominal(char const id[static 1]) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_9:
    goto DEFER_END_ID_1_10;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(6, id, abort, true, "id", "assertion", "attempt to create nominal token from invalid string");} 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_10: {
        [[__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(7, ((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 create nominal token");}
      }
      goto DEFER_ID_1_9;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿nominal) ellipsis‿token‿nominal‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿nominal‿_Insta(id);
      goto DEFER_ID_1_10;
    } while(false);
 
    goto DEFER_ID_1_10;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_10:;
  return DEFER_LOC_ID_0_1;
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿number(vtype numb) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_11:
    goto DEFER_END_ID_1_12;
  } else { 
    (void)0 ;
    /* 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_12: {
        [[__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(8, ((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 create number token");}
      }
      goto DEFER_ID_1_11;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿number) ellipsis‿token‿number‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿number‿_Insta(numb);
      goto DEFER_ID_1_12;
    } while(false);
 
    goto DEFER_ID_1_12;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_12:;
  return DEFER_LOC_ID_0_1;
}
 
inline
void ellipsis‿token‿destroy‿_Ctra(ellipsis‿token t[static 1]) {
  extern typeof(ellipsis‿token‿destroy‿_Ctra) ellipsis‿token‿destroy‿_Inner;
  ellipsis‿token‿destroy‿_Inner(t);
}
 
inline
void ellipsis‿token‿delete‿_Ctra(ellipsis‿token t[static 1]) {
  extern typeof(ellipsis‿token‿delete‿_Ctra) ellipsis‿token‿delete‿_Inner;
  ellipsis‿token‿delete‿_Inner(t);
}
 
inline
void ellipsis‿token‿delete_all‿_Ctra(ellipsis‿token t[static 1]) {
  extern typeof(ellipsis‿token‿delete_all‿_Ctra) ellipsis‿token‿delete_all‿_Inner;
  ellipsis‿token‿delete_all‿_Inner(t);
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿cpy‿_Ctra(ellipsis‿token const* t) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_13:
    goto DEFER_END_ID_1_14;
  } 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_14: {
        [[__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(9, ((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 token");}
      }
      goto DEFER_ID_1_13;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿cpy‿_Ctra) ellipsis‿token‿cpy‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿cpy‿_Inner(t);
      goto DEFER_ID_1_14;
    } while(false);
 
    goto DEFER_ID_1_14;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_14:;
  return DEFER_LOC_ID_0_1;
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿deepcpy‿_Ctra(ellipsis‿token const* t) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__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_16;
  } 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_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(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 deep copy token");}
      }
      goto DEFER_ID_1_15;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿deepcpy‿_Ctra) ellipsis‿token‿deepcpy‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿deepcpy‿_Inner(t);
      goto DEFER_ID_1_16;
    } while(false);
 
    goto DEFER_ID_1_16;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_16:;
  return DEFER_LOC_ID_0_1;
}
 
inline
ellipsis‿token* ellipsis‿token‿alloc‿_Ctra(void) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_17:
    goto DEFER_END_ID_1_18;
  } else { 
    (void)0 ;
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_9)[DEFER_LOC_ID_0_2]  = {};
    if (false) {
    DEFER_ID_1_18: {
        [[__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(11, ((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 allocate token");}
      }
      goto DEFER_ID_1_17;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿alloc‿_Ctra) ellipsis‿token‿alloc‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿alloc‿_Inner();
      goto DEFER_ID_1_18;
    } while(false);
 
    goto DEFER_ID_1_18;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_18:;
  return DEFER_LOC_ID_0_1;
}
 
inline
bool ellipsis‿token‿equiv‿_Ctra(ellipsis‿token* a, ellipsis‿token* b) {
  extern typeof(ellipsis‿token‿equiv‿_Ctra) ellipsis‿token‿equiv‿_Inner;
  return ellipsis‿token‿equiv‿_Inner(a, b);
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿string‿_Ctra(char const str[static 1]) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_19:
    goto DEFER_END_ID_1_20;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(12, str, unreachable, false, "str", "assumption", "attempt to create string token from invalid string");} while (false);
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_10)[DEFER_LOC_ID_0_2] = {};
    if (false) {
    DEFER_ID_1_20: {
        [[__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(13, ((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 create string token");}
      }
      goto DEFER_ID_1_19;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿string‿_Ctra) ellipsis‿token‿string‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿string‿_Inner(str);
      goto DEFER_ID_1_20;
    } while(false);
 
    goto DEFER_ID_1_20;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_20:;
  return DEFER_LOC_ID_0_1;
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿nominal‿_Ctra(char const id[static 1]) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_21:
    goto DEFER_END_ID_1_22;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(14, id, unreachable, false, "id", "assumption", "attempt to create nominal token from invalid string");} while (false);
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_11)[DEFER_LOC_ID_0_2] = {};
    if (false) {
    DEFER_ID_1_22: {
        [[__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(15, ((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 create nominal token");}
      }
      goto DEFER_ID_1_21;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿nominal‿_Ctra) ellipsis‿token‿nominal‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿nominal‿_Inner(id);
      goto DEFER_ID_1_22;
    } while(false);
 
    goto DEFER_ID_1_22;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_22:;
  return DEFER_LOC_ID_0_1;
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿number‿_Ctra(vtype numb) {
  typeof(ellipsis‿token*) 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*)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_23:
    goto DEFER_END_ID_1_24;
  } else { 
    (void)0 ;
    /* defer */
    [[__maybe_unused__, __deprecated__("dummy variable for better diagnostics")]]
    unsigned (*DEFER_LOC_ID_1_12)[DEFER_LOC_ID_0_2] = {};
    if (false) {
    DEFER_ID_1_24: {
        [[__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(16, ((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 create number token");}
      }
      goto DEFER_ID_1_23;
    } else
      (void)0 ;
    extern typeof(ellipsis‿token‿number‿_Ctra) ellipsis‿token‿number‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿token‿number‿_Inner(numb);
      goto DEFER_ID_1_24;
    } while(false);
 
    goto DEFER_ID_1_24;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_24:;
  return DEFER_LOC_ID_0_1;
}
 
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿pop(ellipsis‿token* head[static 1]) {
  ellipsis‿token* ret = nullptr;
  if (*head) {
    ret = *head;
    *head = (*head)->next;
    ret->next = nullptr;
  }
  return ret;
}
 
inline
void ellipsis‿token‿push(ellipsis‿token* head[static 1], ellipsis‿token el[static 1]) {
  if (*head) {
    el->next  = *head;
  }
  *head = el;
}
 
inline
void ellipsis‿token‿drop(ellipsis‿token* head[static 1]) {
  ellipsis‿token* top = ellipsis‿token‿pop(head);
  if (top) {
    ellipsis‿token‿delete(top);
  }
}
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿repeat(ellipsis‿token p[static 1], size_t n) {
  if (!n) {
    ELLIPSIS_DIAGNOSTIC("asking for zero copies of a ¤");
  }
  ellipsis‿token* ret = nullptr;
  ellipsis‿token* prev  = nullptr;
  while (n) {
    ret = ellipsis‿token‿cpy(p);
    if (!ret && prev) {
      ellipsis‿token‿delete_all(prev);
      /* downgraded */ break;
    }
    ret->next = prev;
    prev  = ret;
    --n;
  }
  return ret;
}
 
#define TOKEN_NEW(...) ellipsis‿token‿new((ellipsis‿token){__VA_ARGS__})
 
GNU_ATTR_RETURNS_NONNULL
STDC_ATTR_NODISCARD()
inline
ellipsis‿token* ellipsis‿token‿new(ellipsis‿token const __LOC_ID_0_1) {
  ellipsis‿token* __LOC_ID_1_1  = ellipsis‿token‿alloc();
  ELLIPSIS_CONTRACT(17, __LOC_ID_1_1, abort, true, "__LOC(0)", "assertion", "unable to allocate " "ellipsis∷token");
  *__LOC_ID_1_1 = __LOC_ID_0_1;
  return __LOC_ID_1_1;
}
 
inline void ellipsis‿token‿move(ellipsis‿token* __LOC_ID_0_2[restrict static 1], ellipsis‿token**restrict __LOC_ID_0_3) {
  if (*__LOC_ID_0_2)
    ellipsis‿token‿delete((void*)*__LOC_ID_0_2);
  if (__LOC_ID_0_3) {
    *__LOC_ID_0_2= *__LOC_ID_0_3;
    *__LOC_ID_0_3= nullptr;
  } else {
    *__LOC_ID_0_2= nullptr;
  }
 
}
 
inline void ellipsis‿token‿cmove(ellipsis‿token const* __LOC_ID_0_4[restrict static 1], ellipsis‿token const**restrict __LOC_ID_0_5) {
  if (*__LOC_ID_0_4)
    ellipsis‿token‿delete((void*)*__LOC_ID_0_4);
  if (__LOC_ID_0_5) {
    *__LOC_ID_0_4= *__LOC_ID_0_5;
    *__LOC_ID_0_5= nullptr;
  } else {
    *__LOC_ID_0_4= nullptr;
  }
 
}
 
#endif