ellipsis-special.h

Go to the documentation of this file.

 
#ifndef ELLIPSIS_SPECIAL_H
#define ELLIPSIS_SPECIAL_H 1
 
#include <stddef.h>
#include "ellipsis-category.h"
#include "utils/ellipsis-str32.h"
#include "utils/ellipsis-str8.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 struct ellipsis‿special ellipsis‿special;
 
#undef ELLIPSIS_STR8_LITERAL
#define ELLIPSIS_STR8_LITERAL ELLIPSIS_STR8_LITERAL_GLOBAL
 
#undef ELLIPSIS_STR32_LITERAL
#define ELLIPSIS_STR32_LITERAL ELLIPSIS_STR32_LITERAL_GLOBAL
 
struct ellipsis‿special {
  ellipsis‿category cat;
  ellipsis‿str8 const* starter8;
  ellipsis‿str8 const* closer8;
  ellipsis‿str32 const* repl32;
};
 
typedef ellipsis‿special const* ellipsis‿special‿find(size_t len, char const buf[len]);
typedef void ellipsis‿special‿append(size_t len, ellipsis‿special* p);
 
inline
ellipsis‿str32* ellipsis‿special‿scan‿str32(ellipsis‿special const sp[static 1],
    size_t len[static 1], char const*restrict buf[static 1],
    bool terminated[static 1], bool without, bool unescaped) {
  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_1:
    goto DEFER_END_ID_1_2;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(1, sp, abort, true, "sp", "assertion", "pointer to special needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(2, len, abort, true, "len", "assertion", "pointer to length needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(3, buf, abort, true, "buf", "assertion", "pointer to buffer pointer needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(4, *buf, abort, true, "*buf", "assertion", "pointer to buffer needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(5, terminated, abort, true, "terminated", "assertion", "pointer to return state needed in scan");} 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(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", "scan did not return a value");}
      }
      goto DEFER_ID_1_1;
    } else
      (void)0 ;
    extern typeof(ellipsis‿special‿scan‿str32) ellipsis‿special‿scan‿str32‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿special‿scan‿str32‿_Insta(sp, len, buf, terminated, without, unescaped);
      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‿str32* ellipsis‿special‿scan‿str32‿_Ctra(ellipsis‿special const sp[static 1],
    size_t len[static 1], char const*restrict buf[static 1],
    bool terminated[static 1], bool without, bool unescaped) {
  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_3:
    goto DEFER_END_ID_1_4;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(7, sp, unreachable, false, "sp", "assumption", "pointer to special needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(8, len, unreachable, false, "len", "assumption", "pointer to length needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(9, buf, unreachable, false, "buf", "assumption", "pointer to buffer pointer needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(10, *buf, unreachable, false, "*buf", "assumption", "pointer to buffer needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(11, terminated, unreachable, false, "terminated", "assumption", "pointer to return state needed in scan");} 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(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", "scan did not return a value");}
      }
      goto DEFER_ID_1_3;
    } else
      (void)0 ;
    extern typeof(ellipsis‿special‿scan‿str32‿_Ctra) ellipsis‿special‿scan‿str32‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿special‿scan‿str32‿_Inner(sp, len, buf, terminated, without, unescaped);
      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‿str8* ellipsis‿special‿scan‿str8(ellipsis‿special const sp[static 1],
    size_t len[static 1], char const*restrict buf[static 1],
    bool terminated[static 1], bool without, bool unescaped) {
  typeof(ellipsis‿str8*) 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‿str8*)) {};
  }
  [[__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(13, sp, abort, true, "sp", "assertion", "pointer to special needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(14, len, abort, true, "len", "assertion", "pointer to length needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(15, buf, abort, true, "buf", "assertion", "pointer to buffer pointer needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(16, *buf, abort, true, "*buf", "assertion", "pointer to buffer needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(17, terminated, abort, true, "terminated", "assertion", "pointer to return state needed in scan");} 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(18, ((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", "scan did not return a value");}
      }
      goto DEFER_ID_1_5;
    } else
      (void)0 ;
    extern typeof(ellipsis‿special‿scan‿str8) ellipsis‿special‿scan‿str8‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿special‿scan‿str8‿_Insta(sp, len, buf, terminated, without, unescaped);
      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
ellipsis‿str8* ellipsis‿special‿scan‿str8‿_Ctra(ellipsis‿special const sp[static 1],
    size_t len[static 1], char const*restrict buf[static 1],
    bool terminated[static 1], bool without, bool unescaped) {
  typeof(ellipsis‿str8*) 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‿str8*)) {};
  }
  [[__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(19, sp, unreachable, false, "sp", "assumption", "pointer to special needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(20, len, unreachable, false, "len", "assumption", "pointer to length needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(21, buf, unreachable, false, "buf", "assumption", "pointer to buffer pointer needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(22, *buf, unreachable, false, "*buf", "assumption", "pointer to buffer needed in scan");} while (false);
    do {ELLIPSIS_CONTRACT(23, terminated, unreachable, false, "terminated", "assumption", "pointer to return state needed in scan");} 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(24, ((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", "scan did not return a value");}
      }
      goto DEFER_ID_1_7;
    } else
      (void)0 ;
    extern typeof(ellipsis‿special‿scan‿str8‿_Ctra) ellipsis‿special‿scan‿str8‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿special‿scan‿str8‿_Inner(sp, len, buf, terminated, without, unescaped);
      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;
}
 
void ellipsis‿special‿cpy(size_t len, ellipsis‿special target[static restrict len], ellipsis‿special const source[static restrict len]);
void ellipsis‿special‿delete(size_t len, ellipsis‿special const target[static restrict len]);
 
#define SPECIAL_ADD_IIII(STARTER, CLOSER, CAT, REPL) \
 {\
 .cat = CAT, \
 .starter8  = &ELLIPSIS_STR8_STRING_LITERAL(STARTER), \
 .closer8 = &ELLIPSIS_STR8_STRING_LITERAL(CLOSER), \
 .repl32  = &ELLIPSIS_STR32_STRING_LITERAL(REPL), \
 }
 
#define SPECIAL_ADD(STARTER, ...) SPECIAL_ADD_I ## __VA_OPT__(Iplus) (STARTER __VA_OPT__(,) __VA_ARGS__)
 
#define SPECIAL_ADD_I(STARTER) SPECIAL_ADD_III(STARTER, "", punctuator)
 
#define SPECIAL_ADD_II(STARTER, CLOSER) SPECIAL_ADD_III(STARTER, CLOSER, special)
 
#define SPECIAL_ADD_III(STARTER, CLOSER, CAT) SPECIAL_ADD_IIII(STARTER, CLOSER, CAT, "")
 
#define SPECIAL_ADD_IIplus(STARTER, CLOSER, ...) SPECIAL_ADD_II ## __VA_OPT__(Iplus) (STARTER, CLOSER __VA_OPT__(,) __VA_ARGS__)
 
#define SPECIAL_ADD_IIIplus(STARTER, CLOSER, CAT, ...) SPECIAL_ADD_III ## __VA_OPT__(I) (STARTER, CLOSER, CAT __VA_OPT__(,) __VA_ARGS__)
 
#define PUNCTUATOR_ADD(STARTER, ...) PUNCTUATOR_ADD_I ## __VA_OPT__(I) (STARTER __VA_OPT__(,) __VA_ARGS__)
 
#define PUNCTUATOR_ADD_I(STARTER) PUNCTUATOR_ADD_II(STARTER, STARTER)
 
#define PUNCTUATOR_ADD_II(STARTER, REPL) SPECIAL_ADD(STARTER, "", punctuator, REPL)
 
#define PUNCTUATOR_ADDON(STARTER, ...) PUNCTUATOR_ADDON_I ## __VA_OPT__(I) (STARTER __VA_OPT__(,) __VA_ARGS__)
 #define PUNCTUATOR_ADDON_I(STARTER) PUNCTUATOR_ADD(STARTER),
 #define PUNCTUATOR_ADDON_II(STARTER, REPL, ...) PUNCTUATOR_ADD(STARTER, REPL),
 
#define PUNCTUATOR_TEXT0(...)
#define PUNCTUATOR_TEXT1(...)
#define PUNCTUATOR_TEXT2(...)
#define PUNCTUATOR_TEXT3(...)
 
#define SPECIAL_ADDON(STARTER, CLOSER, CAT, ...) SPECIAL_ADDON_III ## __VA_OPT__(I) (STARTER, CLOSER, CAT __VA_OPT__(,) __VA_ARGS__)
 #define SPECIAL_ADDON_III(STARTER, CLOSER, CAT) SPECIAL_ADD(STARTER, CLOSER, CAT),
 #define SPECIAL_ADDON_IIII(STARTER, CLOSER, CAT, REPL, ...) SPECIAL_ADD(STARTER, CLOSER, CAT, REPL),
 
#define SPECIAL_TEXT0(...)
#define SPECIAL_TEXT1(...)
#define SPECIAL_TEXT2(...)
#define SPECIAL_TEXT3(...)
 
#define KEYWORD_ADD(STARTER, ...) KEYWORD_ADD_I ## __VA_OPT__(I) (STARTER __VA_OPT__(,) __VA_ARGS__)
 
 #define KEYWORD_ADD_ID(X, ...) KEYWORD_ADD(#X __VA_OPT__(, #__VA_ARGS__)),
 
#define KEYWORD_HEADING(...)
#define KEYWORD_TEXT(...)
 
#define KEYWORD_ADD_I(STARTER) KEYWORD_ADD_II(STARTER, STARTER)
 
#define KEYWORD_ADD_II(STARTER, REPL) SPECIAL_ADD(STARTER, "", keyword, REPL)
 
#define NOMINAL_ADD(...) NOMINAL_ADD_2(__VA_ARGS__)
#define NOMINAL_ADD_2(X, R, ...) NOMINAL_ADD_1(X, R)
#define NOMINAL_ADD_1(X, ...) NOMINAL_ADD_I ## __VA_OPT__(I)(X __VA_OPT__(,) __VA_ARGS__)
 
 #define NOMINAL_ADD_I(X) SPECIAL_ADD(X, "", nominal, ""),
 #define NOMINAL_ADD_II(X, R) SPECIAL_ADD(X, "", nominal, R),
 
#endif