ellipsis-lexer.h

Go to the documentation of this file.

 
#ifndef ELLIPSIS_SPACE_H
#define ELLIPSIS_SPACE_H 1
 
#include <uchar.h>
#include <stdbool.h>
#include <inttypes.h>
#include "encoding/ellipsis-base64.h"
#include "utils/ellipsis-error.h"
#include "encoding/ellipsis-entity.h"
#include "language/ellipsis-special.h"
#include "language/directive/ellipsis-special-directive.h"
#include "utils/ellipsis-str32.h"
#include "token/ellipsis-token.h"
#include "ellipsis-infra.h"
#include "utils/ellipsis-bitset.h"
#include "encoding/XID_Continue.h"
#include "encoding/XID_Start.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)
 
inline
ellipsis‿str32 const* ellipsis‿lex‿nonspace(size_t len[static 1], char const*restrict s[static 1],
    ellipsis‿special const** sp, ellipsis‿token t[static 1],
    ellipsis‿special‿find*f) {
  typeof(ellipsis‿str32 const*) 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 const*)) {};
  }
  [[__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 allocate string for non-space token");}
      }
      goto DEFER_ID_1_1;
    } else
      (void)0 ;
    extern typeof(ellipsis‿lex‿nonspace) ellipsis‿lex‿nonspace‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿lex‿nonspace‿_Insta(len, s, sp, t, f);
      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 const* ellipsis‿lex‿space(size_t len[static 1], char const*restrict s[static 1]) {
  typeof(ellipsis‿str32 const*) 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 const*)) {};
  }
  [[__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 ;
 
    extern typeof(ellipsis‿lex‿space) ellipsis‿lex‿space‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿lex‿space‿_Insta(len, s);
      goto DEFER_ID_1_3;
    } while(false);
 
    goto DEFER_ID_1_3;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_4:;
  return DEFER_LOC_ID_0_1;
}
 
inline
ellipsis‿category ellipsis‿lex‿category(ellipsis‿str32 const s[static 1], ellipsis‿special‿find* find) {
  typeof(ellipsis‿category) 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‿category)) {};
  }
  [[__maybe_unused__]] register unsigned DEFER_LOC_ID_0_2 = 1U;
  [[__maybe_unused__]] register bool defer_return_flag  = false;
  if (false) {
  DEFER_ID_1_4:
    goto DEFER_END_ID_1_6;
  } else { 
    (void)0 ;
    extern typeof(ellipsis‿lex‿category) ellipsis‿lex‿category‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿lex‿category‿_Insta(s, find);
      goto DEFER_ID_1_4;
    } while(false);
 
    goto DEFER_ID_1_4;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_6:;
  return DEFER_LOC_ID_0_1;
}
 
inline
char* ellipsis‿lex‿strdup_escape(size_t len, char const s[static len], size_t nlenp[static 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_8;
  } 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_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(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 allocate string for strdup with escapes");}
      }
      goto DEFER_ID_1_5;
    } else
      (void)0 ;
    extern typeof(ellipsis‿lex‿strdup_escape) ellipsis‿lex‿strdup_escape‿_Insta;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿lex‿strdup_escape‿_Insta(len, s, nlenp);
      goto DEFER_ID_1_6;
    } while(false);
 
    goto DEFER_ID_1_6;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_8:;
  return DEFER_LOC_ID_0_1;
}
 
inline
ellipsis‿str32 const* ellipsis‿lex‿nonspace‿_Ctra(size_t len[static 1], char const*restrict s[static 1],
    ellipsis‿special const** sp, ellipsis‿token t[static 1],
    ellipsis‿special‿find*f) {
  typeof(ellipsis‿str32 const*) 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 const*)) {};
  }
  [[__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_10;
  } 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_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(3, ((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 string for non-space token");}
      }
      goto DEFER_ID_1_7;
    } else
      (void)0 ;
    extern typeof(ellipsis‿lex‿nonspace‿_Ctra) ellipsis‿lex‿nonspace‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿lex‿nonspace‿_Inner(len, s, sp, t, f);
      goto DEFER_ID_1_8;
    } while(false);
 
    goto DEFER_ID_1_8;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_10:;
  return DEFER_LOC_ID_0_1;
}
 
inline
ellipsis‿str32 const* ellipsis‿lex‿space‿_Ctra(size_t len[static 1], char const*restrict s[static 1]) {
  typeof(ellipsis‿str32 const*) 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 const*)) {};
  }
  [[__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_12;
  } else { 
    (void)0 ;
 
    extern typeof(ellipsis‿lex‿space‿_Ctra) ellipsis‿lex‿space‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿lex‿space‿_Inner(len, s);
      goto DEFER_ID_1_9;
    } while(false);
 
    goto DEFER_ID_1_9;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_12:;
  return DEFER_LOC_ID_0_1;
}
 
inline
ellipsis‿category ellipsis‿lex‿category‿_Ctra(ellipsis‿str32 const s[static 1], ellipsis‿special‿find* find) {
  typeof(ellipsis‿category) 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‿category)) {};
  }
  [[__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_14;
  } else { 
    (void)0 ;
    extern typeof(ellipsis‿lex‿category‿_Ctra) ellipsis‿lex‿category‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿lex‿category‿_Inner(s, find);
      goto DEFER_ID_1_10;
    } while(false);
 
    goto DEFER_ID_1_10;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_14:;
  return DEFER_LOC_ID_0_1;
}
 
inline
char* ellipsis‿lex‿strdup_escape‿_Ctra(size_t len, char const s[static len], size_t nlenp[static 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_11:
    goto DEFER_END_ID_1_16;
  } else { 
    (void)0 ;
    /* 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_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(4, ((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 string for strdup with escapes");}
      }
      goto DEFER_ID_1_11;
    } else
      (void)0 ;
    extern typeof(ellipsis‿lex‿strdup_escape‿_Ctra) ellipsis‿lex‿strdup_escape‿_Inner;
    do {
      /* return mode 2 */
      defer_return_flag = true;
      DEFER_LOC_ID_0_1 =  ellipsis‿lex‿strdup_escape‿_Inner(len, s, nlenp);
      goto DEFER_ID_1_12;
    } while(false);
 
    goto DEFER_ID_1_12;
  } 
[[__maybe_unused__]] DEFER_END_ID_1_16:;
  return DEFER_LOC_ID_0_1;
}
 
inline
bool ellipsis‿lex‿Start(char32_t val) {
  return val == U'_' || ellipsis_bitset_member(ellipsis‿XID‿Start, val);
}
 
inline
bool ellipsis‿lex‿Continue(char32_t val) {
  return ellipsis_bitset_member(ellipsis‿XID‿Continue, val);
}
 
inline
bool ellipsis‿lex‿is_space(char32_t c) {
  switch (c) {
  case U'\t' : return true;
  case U' ' : return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U' ': return true;
  case U'　': return true;
  default: return false;
  }
}
 
inline
size_t ellipsis‿str32‿escape(char32_t* pc32, char const* s, bool account_eol) {
  size_t l  = 1;
  switch (s[1]) {
  default: *pc32  = U'\\';/* downgraded */ break;
 
  case '\\': *pc32  = U'\\'; l = 2;/* downgraded */ break;
  case 'a': *pc32 = U'\a'; l = 2;/* downgraded */ break;
  case 'b': *pc32 = U'\b'; l = 2;/* downgraded */ break;
  case 'f': *pc32 = U'\f'; l = 2;/* downgraded */ break;
  case 'n': *pc32 = U'\n'; l = 2;/* downgraded */ break;
  case 'r': *pc32 = U'\r'; l = 2;/* downgraded */ break;
  case 't': *pc32 = U'\t'; l = 2;/* downgraded */ break;
  case 'v': *pc32 = U'\v'; l = 2;/* downgraded */ break;
  case '\"': *pc32  = U'\"'; l = 2;/* downgraded */ break;
  case '\'': *pc32  = U'\''; l = 2;/* downgraded */ break;
 
  case '\n': *pc32  = U'\r'; l = 2; if (account_eol) {ellipsis‿infra‿newline();}/* downgraded */ break;
 
  case 'u':
    if (sscanf(s+2, "%4" SCNx32, pc32) < 1) {
      l = 1;
      *pc32 = U'\\';
    } else {
      l = 6;
    }
    /* downgraded */ break;
 
  case 'U':
    if (sscanf(s+2, "%8" SCNx32, pc32) < 1) {
      l = 1;
      *pc32 = U'\\';
    } else {
      l = 10;
    }
    /* downgraded */ break;
  }
  return l;
}
 
inline
size_t ellipsis‿lex‿str_escape(char pc[static 1], size_t lenp[static 1], char const s[static 2], bool account_eol) {
  char32_t c32  = 0;
  size_t l  = 1;
  *lenp = 1;
  switch (s[1]) {
  default: *pc  = '\\';/* downgraded */ break;
 
  case '\\': *pc  = '\\'; l  = 2;/* downgraded */ break;
  case 'a': *pc = '\a'; l  = 2;/* downgraded */ break;
  case 'b': *pc = '\b'; l  = 2;/* downgraded */ break;
  case 'f': *pc = '\f'; l  = 2;/* downgraded */ break;
  case 'n': *pc = '\n'; l  = 2;/* downgraded */ break;
  case 'r': *pc = '\r'; l  = 2;/* downgraded */ break;
  case 't': *pc = '\t'; l  = 2;/* downgraded */ break;
  case 'v': *pc = '\v'; l  = 2;/* downgraded */ break;
  case '\"': *pc  = '\"'; l  = 2;/* downgraded */ break;
  case '\'': *pc  = '\''; l  = 2;/* downgraded */ break;
 
  case '\n': *pc  = '\r'; l  = 2; if (account_eol) {ellipsis‿infra‿newline();}/* downgraded */ break;
 
  case '0':
  case '1':
  case '2':
  case '3':
  case '4':
  case '5':
  case '6':
  case '7': {
    int el  = 0;
    if (sscanf(s+1, "%3" SCNo32 "%n", &c32, &el) < 1) {
      l = 1;
      *pc = '\\';
    } else {
      if (!c32) {
        *lenp = 1;
        l = el+1;
        *pc = 0;
      } else {
        size_t len  = c32rtomb(pc, c32, &(mbstate_t) {});
        ELLIPSIS_CONTRACT(5, len <= MB_CUR_MAX, abort, true, "len ≤ MB_CUR_MAX", "assertion", "Unable to convert octal escape character");
        *lenp = len;
        l = el+1;
      }
    }
    /* downgraded */ break;
  }
  case 'x': {
    int el  = 0;
    if (sscanf(s+2, "%" SCNx32 "%n", &c32, &el) < 1) {
      l = 1;
      *pc = '\\';
    } else {
      if (!c32) {
        *lenp = 1;
        l = el+2;
        *pc = 0;
      } else {
        size_t len  = c32rtomb(pc, c32, &(mbstate_t) {});
        ELLIPSIS_CONTRACT(6, len <= MB_CUR_MAX, abort, true, "len ≤ MB_CUR_MAX", "assertion", "Unable to convert hexadecimal escape character");
        *lenp = len;
        l = el+2;
      }
    }
    /* downgraded */ break;
  }
 
  case 'u':
    if (sscanf(s+2, "%4" SCNx32, &c32) < 1) {
      l = 1;
      *pc = '\\';
    } else {
      size_t len  = c32rtomb(pc, c32, &(mbstate_t) {});
      ELLIPSIS_CONTRACT(7, len <= MB_CUR_MAX, abort, true, "len ≤ MB_CUR_MAX", "assertion", "unable to convert short Unicode identifier");
      *lenp = len;
      l = 6;
    }
    /* downgraded */ break;
 
  case 'U':
    if (sscanf(s+2, "%8" SCNx32, &c32) < 1) {
      l = 1;
      *pc = '\\';
    } else {
      size_t len  = c32rtomb(pc, c32, &(mbstate_t) {});
      ELLIPSIS_CONTRACT(8, len <= MB_CUR_MAX, abort, true, "len ≤ MB_CUR_MAX", "assertion", "unable to convert long Unicode identifier");
      *lenp = len;
      l = 10;
    }
    /* downgraded */ break;
  }
  return l;
}
 
#endif