ellipsis-base64.h

Go to the documentation of this file.

 
#ifndef ELLIPSIS_BASE64_H
#define ELLIPSIS_BASE64_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)
 
#include <stdint.h>
#include <uchar.h>
#include <stdio.h>
#include "utils/ellipsis-malloc.h"
#include "utils/ellipsis-str8.h"
 
GNU_ATTR_MALLOC()
[[nodiscard]]
inline
char* ellipsis‿base64‿encode(ellipsis‿str8 const source[static restrict 1]) {
  typeof(char*) 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(char*)) {};
  }
  [[__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, source, abort, true, "source", "assertion", "missing source for encoding UTF-8 string");} 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", "allocation for encoding UTF-8 string failed");}
      }
      goto DEFER_ID_1_1;
    } else
      (void)0 ;
    extern typeof(ellipsis‿base64‿encode) ellipsis‿base64‿encode‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿base64‿encode‿_Insta(source);
      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_MALLOC()
[[nodiscard]]
inline
ellipsis‿str8* ellipsis‿base64‿decode(size_t len, unsigned char const buf[static restrict len]) {
  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_3:
    goto DEFER_END_ID_1_4;
  } else { 
    (void)0 ;
    do {ELLIPSIS_CONTRACT(3, buf, abort, true, "buf", "assertion", "missing input string when decoding UTF-8 string");} 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", "allocation for decoding UTF-8 string failed");}
      }
      goto DEFER_ID_1_3;
    } else
      (void)0 ;
    extern typeof(ellipsis‿base64‿decode) ellipsis‿base64‿decode‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿base64‿decode‿_Insta(len, buf);
      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;
}
 
GNU_ATTR_MALLOC()
[[nodiscard]]
inline
char* ellipsis‿base64‿encode‿_Ctra(ellipsis‿str8 const source[static restrict 1]) {
  typeof(char*) 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(char*)) {};
  }
  [[__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, source, unreachable, false, "source", "assumption", "missing source for encoding UTF-8 string");} 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), abort, true, "((typeof(DEFER_LOC_ID_0_1))DEFER_LOC_ID_0_1)", "assertion", "allocation for encoding UTF-8 string failed");}
      }
      goto DEFER_ID_1_5;
    } else
      (void)0 ;
    extern typeof(ellipsis‿base64‿encode‿_Ctra) ellipsis‿base64‿encode‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿base64‿encode‿_Inner(source);
      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;
}
 
GNU_ATTR_MALLOC()
[[nodiscard]]
inline
ellipsis‿str8* ellipsis‿base64‿decode‿_Ctra(size_t len, unsigned char const buf[static restrict len]) {
  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(7, buf, unreachable, false, "buf", "assumption", "missing input string when decoding UTF-8 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(8, ((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", "allocation for decoding UTF-8 string failed");}
      }
      goto DEFER_ID_1_7;
    } else
      (void)0 ;
    extern typeof(ellipsis‿base64‿decode‿_Ctra) ellipsis‿base64‿decode‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿base64‿decode‿_Inner(len, buf);
      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;
}
 
#endif