Skip to content

Instantly share code, notes, and snippets.

@dolik-rce

dolik-rce/kotlin.c

Created August 19, 2024 06:35
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save dolik-rce/be3e6f9aff1df1fa02f1bd7caa92b9c2 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save dolik-rce/be3e6f9aff1df1fa02f1bd7caa92b9c2 to your computer and use it in GitHub Desktop.
Download ZIP
Optimized kotlin parser
Raw
kotlin.c
This file has been truncated, but you can view the full file.
/* A packrat parser generated by PackCC 2.0.0 */
#include "general.h"
#ifdef _MSC_VER
#undef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif /* _MSC_VER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef _MSC_VER
#if defined __GNUC__ && defined _WIN32 /* MinGW */
#ifndef PCC_USE_SYSTEM_STRNLEN
#define strnlen(str, maxlen) pcc_strnlen(str, maxlen)
static size_t pcc_strnlen(const char *str, size_t maxlen) {
size_t i;
for (i = 0; i < maxlen && str[i]; i++);
return i;
}
#endif /* !PCC_USE_SYSTEM_STRNLEN */
#endif /* defined __GNUC__ && defined _WIN32 */
#endif /* !_MSC_VER */
#include "kotlin_opt.h"
#include "kotlin_pre.h"
#if !defined __has_attribute || defined _MSC_VER
#define __attribute__(x)
#endif
#ifdef _MSC_VER
#define MARK_FUNC_AS_USED __pragma(warning(suppress:4505))
#else
#define MARK_FUNC_AS_USED __attribute__((__unused__))
#endif
#ifdef _MSC_VER
#define MARK_VAR_AS_USED __pragma(warning(suppress:4189))
#else
#define MARK_VAR_AS_USED __attribute__((__unused__))
#endif
#ifndef PCC_BUFFER_MIN_SIZE
#define PCC_BUFFER_MIN_SIZE 256
#endif /* !PCC_BUFFER_MIN_SIZE */
#ifndef PCC_ARRAY_MIN_SIZE
#define PCC_ARRAY_MIN_SIZE 2
#endif /* !PCC_ARRAY_MIN_SIZE */
#ifndef PCC_POOL_MIN_SIZE
#define PCC_POOL_MIN_SIZE 65536
#endif /* !PCC_POOL_MIN_SIZE */
#define PCC_DBG_EVALUATE 0
#define PCC_DBG_MATCH 1
#define PCC_DBG_NOMATCH 2
#define PCC_VOID_VALUE (~(size_t)0)
typedef enum pcc_bool_tag {
PCC_FALSE = 0,
PCC_TRUE
} pcc_bool_t;
typedef struct pcc_char_array_tag {
char *buf;
size_t max;
size_t len;
} pcc_char_array_t;
typedef struct pcc_range_tag {
size_t start;
size_t end;
} pcc_range_t;
typedef int pcc_value_t;
typedef struct parserCtx *pcc_auxil_t;
typedef pkotlin_context_t pcc_context_t;
typedef struct pcc_value_table_tag {
pcc_value_t *buf;
size_t max;
size_t len;
} pcc_value_table_t;
typedef struct pcc_value_refer_table_tag {
pcc_value_t **buf;
size_t max;
size_t len;
} pcc_value_refer_table_t;
typedef struct pcc_capture_tag {
pcc_range_t range;
char *string; /* mutable */
} pcc_capture_t;
typedef struct pcc_capture_table_tag {
pcc_capture_t *buf;
size_t max;
size_t len;
} pcc_capture_table_t;
typedef struct pcc_capture_const_table_tag {
const pcc_capture_t **buf;
size_t max;
size_t len;
} pcc_capture_const_table_t;
typedef struct pcc_thunk_tag pcc_thunk_t;
typedef struct pcc_thunk_array_tag pcc_thunk_array_t;
typedef void (*pcc_action_t)(pcc_context_t *, pcc_thunk_t *, pcc_value_t *);
typedef enum pcc_thunk_type_tag {
PCC_THUNK_LEAF,
PCC_THUNK_NODE
} pcc_thunk_type_t;
typedef struct pcc_thunk_leaf_tag {
pcc_value_refer_table_t values;
pcc_capture_const_table_t capts;
pcc_capture_t capt0;
pcc_action_t action;
} pcc_thunk_leaf_t;
typedef struct pcc_thunk_node_tag {
const pcc_thunk_array_t *thunks; /* just a reference */
pcc_value_t *value; /* just a reference */
} pcc_thunk_node_t;
typedef union pcc_thunk_data_tag {
pcc_thunk_leaf_t leaf;
pcc_thunk_node_t node;
} pcc_thunk_data_t;
struct pcc_thunk_tag {
pcc_thunk_type_t type;
pcc_thunk_data_t data;
};
struct pcc_thunk_array_tag {
pcc_thunk_t **buf;
size_t max;
size_t len;
};
typedef struct pcc_thunk_chunk_tag {
pcc_value_table_t values;
pcc_capture_table_t capts;
pcc_thunk_array_t thunks;
size_t pos; /* the starting position in the character buffer */
} pcc_thunk_chunk_t;
typedef struct pcc_lr_entry_tag pcc_lr_entry_t;
typedef enum pcc_lr_answer_type_tag {
PCC_LR_ANSWER_LR,
PCC_LR_ANSWER_CHUNK
} pcc_lr_answer_type_t;
typedef union pcc_lr_answer_data_tag {
pcc_lr_entry_t *lr;
pcc_thunk_chunk_t *chunk;
} pcc_lr_answer_data_t;
typedef struct pcc_lr_answer_tag pcc_lr_answer_t;
struct pcc_lr_answer_tag {
pcc_lr_answer_type_t type;
pcc_lr_answer_data_t data;
size_t pos; /* the absolute position in the input */
pcc_lr_answer_t *hold;
};
typedef pcc_thunk_chunk_t *(*pcc_rule_t)(pcc_context_t *);
typedef struct pcc_rule_set_tag {
pcc_rule_t *buf;
size_t max;
size_t len;
} pcc_rule_set_t;
typedef struct pcc_lr_head_tag pcc_lr_head_t;
struct pcc_lr_head_tag {
pcc_rule_t rule;
pcc_rule_set_t invol;
pcc_rule_set_t eval;
pcc_lr_head_t *hold;
};
typedef struct pcc_lr_memo_tag {
pcc_rule_t rule;
pcc_lr_answer_t *answer;
} pcc_lr_memo_t;
typedef struct pcc_lr_memo_map_tag {
pcc_lr_memo_t *buf;
size_t max;
size_t len;
} pcc_lr_memo_map_t;
typedef struct pcc_lr_table_entry_tag {
pcc_lr_head_t *head; /* just a reference */
pcc_lr_memo_map_t memos;
pcc_lr_answer_t *hold_a;
pcc_lr_head_t *hold_h;
} pcc_lr_table_entry_t;
typedef struct pcc_lr_table_tag {
pcc_lr_table_entry_t **buf;
size_t max;
size_t len;
size_t ofs;
} pcc_lr_table_t;
struct pcc_lr_entry_tag {
pcc_rule_t rule;
pcc_thunk_chunk_t *seed; /* just a reference */
pcc_lr_head_t *head; /* just a reference */
};
typedef struct pcc_lr_stack_tag {
pcc_lr_entry_t **buf;
size_t max;
size_t len;
} pcc_lr_stack_t;
typedef struct pcc_memory_entry_tag pcc_memory_entry_t;
typedef struct pcc_memory_pool_tag pcc_memory_pool_t;
struct pcc_memory_entry_tag {
pcc_memory_entry_t *next;
};
struct pcc_memory_pool_tag {
pcc_memory_pool_t *next;
size_t allocated;
size_t unused;
};
typedef struct pcc_memory_recycler_tag {
pcc_memory_pool_t *pool_list;
pcc_memory_entry_t *entry_list;
size_t element_size;
} pcc_memory_recycler_t;
struct pkotlin_context_tag {
size_t pos; /* the position in the input of the first character currently buffered */
size_t cur; /* the current parsing position in the character buffer */
size_t level;
pcc_char_array_t buffer;
pcc_lr_table_t lrtable;
pcc_lr_stack_t lrstack;
pcc_thunk_array_t thunks;
pcc_auxil_t auxil;
pcc_memory_recycler_t thunk_chunk_recycler;
pcc_memory_recycler_t lr_head_recycler;
pcc_memory_recycler_t lr_answer_recycler;
};
#ifndef PCC_ERROR
#define PCC_ERROR(auxil) pcc_error()
MARK_FUNC_AS_USED
static void pcc_error(void) {
fprintf(stderr, "Syntax error\n");
exit(1);
}
#endif /* !PCC_ERROR */
#ifndef PCC_GETCHAR
#define PCC_GETCHAR(auxil) getchar()
#endif /* !PCC_GETCHAR */
#ifndef PCC_MALLOC
#define PCC_MALLOC(auxil, size) pcc_malloc_e(size)
static void *pcc_malloc_e(size_t size) {
void *const p = malloc(size);
if (p == NULL) {
fprintf(stderr, "Out of memory\n");
exit(1);
}
return p;
}
#endif /* !PCC_MALLOC */
#ifndef PCC_REALLOC
#define PCC_REALLOC(auxil, ptr, size) pcc_realloc_e(ptr, size)
static void *pcc_realloc_e(void *ptr, size_t size) {
void *const p = realloc(ptr, size);
if (p == NULL) {
fprintf(stderr, "Out of memory\n");
exit(1);
}
return p;
}
#endif /* !PCC_REALLOC */
#ifndef PCC_FREE
#define PCC_FREE(auxil, ptr) free(ptr)
#endif /* !PCC_FREE */
#ifndef PCC_DEBUG
#define PCC_DEBUG(auxil, event, rule, level, pos, buffer, length) ((void)0)
#endif /* !PCC_DEBUG */
static char *pcc_strndup_e(pcc_auxil_t auxil, const char *str, size_t len) {
const size_t m = strnlen(str, len);
char *const s = (char *)PCC_MALLOC(auxil, m + 1);
memcpy(s, str, m);
s[m] = '\0';
return s;
}
static void pcc_char_array__init(pcc_auxil_t auxil, pcc_char_array_t *array) {
array->len = 0;
array->max = 0;
array->buf = NULL;
}
static void pcc_char_array__add(pcc_auxil_t auxil, pcc_char_array_t *array, char ch) {
if (array->max <= array->len) {
const size_t n = array->len + 1;
size_t m = array->max;
if (m == 0) m = PCC_BUFFER_MIN_SIZE;
while (m < n && m != 0) m <<= 1;
if (m == 0) m = n;
array->buf = (char *)PCC_REALLOC(auxil, array->buf, m);
array->max = m;
}
array->buf[array->len++] = ch;
}
static void pcc_char_array__term(pcc_auxil_t auxil, pcc_char_array_t *array) {
PCC_FREE(auxil, array->buf);
}
static void pcc_value_table__init(pcc_auxil_t auxil, pcc_value_table_t *table) {
table->len = 0;
table->max = 0;
table->buf = NULL;
}
MARK_FUNC_AS_USED
static void pcc_value_table__resize(pcc_auxil_t auxil, pcc_value_table_t *table, size_t len) {
if (table->max < len) {
size_t m = table->max;
if (m == 0) m = PCC_ARRAY_MIN_SIZE;
while (m < len && m != 0) m <<= 1;
if (m == 0) m = len;
table->buf = (pcc_value_t *)PCC_REALLOC(auxil, table->buf, sizeof(pcc_value_t) * m);
table->max = m;
}
table->len = len;
}
MARK_FUNC_AS_USED
static void pcc_value_table__clear(pcc_auxil_t auxil, pcc_value_table_t *table) {
memset(table->buf, 0, sizeof(pcc_value_t) * table->len);
}
static void pcc_value_table__term(pcc_auxil_t auxil, pcc_value_table_t *table) {
PCC_FREE(auxil, table->buf);
}
static void pcc_value_refer_table__init(pcc_auxil_t auxil, pcc_value_refer_table_t *table) {
table->len = 0;
table->max = 0;
table->buf = NULL;
}
static void pcc_value_refer_table__resize(pcc_auxil_t auxil, pcc_value_refer_table_t *table, size_t len) {
size_t i;
if (table->max < len) {
size_t m = table->max;
if (m == 0) m = PCC_ARRAY_MIN_SIZE;
while (m < len && m != 0) m <<= 1;
if (m == 0) m = len;
table->buf = (pcc_value_t **)PCC_REALLOC(auxil, table->buf, sizeof(pcc_value_t *) * m);
table->max = m;
}
for (i = table->len; i < len; i++) table->buf[i] = NULL;
table->len = len;
}
static void pcc_value_refer_table__term(pcc_auxil_t auxil, pcc_value_refer_table_t *table) {
PCC_FREE(auxil, table->buf);
}
static void pcc_capture_table__init(pcc_auxil_t auxil, pcc_capture_table_t *table) {
table->len = 0;
table->max = 0;
table->buf = NULL;
}
MARK_FUNC_AS_USED
static void pcc_capture_table__resize(pcc_auxil_t auxil, pcc_capture_table_t *table, size_t len) {
size_t i;
for (i = len; i < table->len; i++) PCC_FREE(auxil, table->buf[i].string);
if (table->max < len) {
size_t m = table->max;
if (m == 0) m = PCC_ARRAY_MIN_SIZE;
while (m < len && m != 0) m <<= 1;
if (m == 0) m = len;
table->buf = (pcc_capture_t *)PCC_REALLOC(auxil, table->buf, sizeof(pcc_capture_t) * m);
table->max = m;
}
for (i = table->len; i < len; i++) {
table->buf[i].range.start = 0;
table->buf[i].range.end = 0;
table->buf[i].string = NULL;
}
table->len = len;
}
static void pcc_capture_table__term(pcc_auxil_t auxil, pcc_capture_table_t *table) {
while (table->len > 0) {
table->len--;
PCC_FREE(auxil, table->buf[table->len].string);
}
PCC_FREE(auxil, table->buf);
}
static void pcc_capture_const_table__init(pcc_auxil_t auxil, pcc_capture_const_table_t *table) {
table->len = 0;
table->max = 0;
table->buf = NULL;
}
static void pcc_capture_const_table__resize(pcc_auxil_t auxil, pcc_capture_const_table_t *table, size_t len) {
size_t i;
if (table->max < len) {
size_t m = table->max;
if (m == 0) m = PCC_ARRAY_MIN_SIZE;
while (m < len && m != 0) m <<= 1;
if (m == 0) m = len;
table->buf = (const pcc_capture_t **)PCC_REALLOC(auxil, (pcc_capture_t **)table->buf, sizeof(const pcc_capture_t *) * m);
table->max = m;
}
for (i = table->len; i < len; i++) table->buf[i] = NULL;
table->len = len;
}
static void pcc_capture_const_table__term(pcc_auxil_t auxil, pcc_capture_const_table_t *table) {
PCC_FREE(auxil, (void *)table->buf);
}
MARK_FUNC_AS_USED
static pcc_thunk_t *pcc_thunk__create_leaf(pcc_auxil_t auxil, pcc_action_t action, size_t valuec, size_t captc) {
pcc_thunk_t *const thunk = (pcc_thunk_t *)PCC_MALLOC(auxil, sizeof(pcc_thunk_t));
thunk->type = PCC_THUNK_LEAF;
pcc_value_refer_table__init(auxil, &thunk->data.leaf.values);
pcc_value_refer_table__resize(auxil, &thunk->data.leaf.values, valuec);
pcc_capture_const_table__init(auxil, &thunk->data.leaf.capts);
pcc_capture_const_table__resize(auxil, &thunk->data.leaf.capts, captc);
thunk->data.leaf.capt0.range.start = 0;
thunk->data.leaf.capt0.range.end = 0;
thunk->data.leaf.capt0.string = NULL;
thunk->data.leaf.action = action;
return thunk;
}
static pcc_thunk_t *pcc_thunk__create_node(pcc_auxil_t auxil, const pcc_thunk_array_t *thunks, pcc_value_t *value) {
pcc_thunk_t *const thunk = (pcc_thunk_t *)PCC_MALLOC(auxil, sizeof(pcc_thunk_t));
thunk->type = PCC_THUNK_NODE;
thunk->data.node.thunks = thunks;
thunk->data.node.value = value;
return thunk;
}
static void pcc_thunk__destroy(pcc_auxil_t auxil, pcc_thunk_t *thunk) {
if (thunk == NULL) return;
switch (thunk->type) {
case PCC_THUNK_LEAF:
PCC_FREE(auxil, thunk->data.leaf.capt0.string);
pcc_capture_const_table__term(auxil, &thunk->data.leaf.capts);
pcc_value_refer_table__term(auxil, &thunk->data.leaf.values);
break;
case PCC_THUNK_NODE:
break;
default: /* unknown */
break;
}
PCC_FREE(auxil, thunk);
}
static void pcc_thunk_array__init(pcc_auxil_t auxil, pcc_thunk_array_t *array) {
array->len = 0;
array->max = 0;
array->buf = NULL;
}
static void pcc_thunk_array__add(pcc_auxil_t auxil, pcc_thunk_array_t *array, pcc_thunk_t *thunk) {
if (array->max <= array->len) {
const size_t n = array->len + 1;
size_t m = array->max;
if (m == 0) m = PCC_ARRAY_MIN_SIZE;
while (m < n && m != 0) m <<= 1;
if (m == 0) m = n;
array->buf = (pcc_thunk_t **)PCC_REALLOC(auxil, array->buf, sizeof(pcc_thunk_t *) * m);
array->max = m;
}
array->buf[array->len++] = thunk;
}
static void pcc_thunk_array__revert(pcc_auxil_t auxil, pcc_thunk_array_t *array, size_t len) {
while (array->len > len) {
array->len--;
pcc_thunk__destroy(auxil, array->buf[array->len]);
}
}
static void pcc_thunk_array__term(pcc_auxil_t auxil, pcc_thunk_array_t *array) {
while (array->len > 0) {
array->len--;
pcc_thunk__destroy(auxil, array->buf[array->len]);
}
PCC_FREE(auxil, array->buf);
}
static void pcc_memory_recycler__init(pcc_auxil_t auxil, pcc_memory_recycler_t *recycler, size_t element_size) {
recycler->pool_list = NULL;
recycler->entry_list = NULL;
recycler->element_size = element_size;
}
static void *pcc_memory_recycler__supply(pcc_auxil_t auxil, pcc_memory_recycler_t *recycler) {
if (recycler->entry_list) {
pcc_memory_entry_t *const tmp = recycler->entry_list;
recycler->entry_list = tmp->next;
return tmp;
}
if (!recycler->pool_list || recycler->pool_list->unused == 0) {
size_t size = PCC_POOL_MIN_SIZE;
if (recycler->pool_list) {
size = recycler->pool_list->allocated << 1;
if (size == 0) size = recycler->pool_list->allocated;
}
{
pcc_memory_pool_t *const pool = (pcc_memory_pool_t *)PCC_MALLOC(
auxil, sizeof(pcc_memory_pool_t) + recycler->element_size * size
);
pool->allocated = size;
pool->unused = size;
pool->next = recycler->pool_list;
recycler->pool_list = pool;
}
}
recycler->pool_list->unused--;
return (char *)recycler->pool_list + sizeof(pcc_memory_pool_t) + recycler->element_size * recycler->pool_list->unused;
}
static void pcc_memory_recycler__recycle(pcc_auxil_t auxil, pcc_memory_recycler_t *recycler, void *ptr) {
pcc_memory_entry_t *const tmp = (pcc_memory_entry_t *)ptr;
tmp->next = recycler->entry_list;
recycler->entry_list = tmp;
}
static void pcc_memory_recycler__term(pcc_auxil_t auxil, pcc_memory_recycler_t *recycler) {
while (recycler->pool_list) {
pcc_memory_pool_t *const tmp = recycler->pool_list;
recycler->pool_list = tmp->next;
PCC_FREE(auxil, tmp);
}
}
MARK_FUNC_AS_USED
static pcc_thunk_chunk_t *pcc_thunk_chunk__create(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = (pcc_thunk_chunk_t *)pcc_memory_recycler__supply(ctx->auxil, &ctx->thunk_chunk_recycler);
pcc_value_table__init(ctx->auxil, &chunk->values);
pcc_capture_table__init(ctx->auxil, &chunk->capts);
pcc_thunk_array__init(ctx->auxil, &chunk->thunks);
chunk->pos = 0;
return chunk;
}
static void pcc_thunk_chunk__destroy(pcc_context_t *ctx, pcc_thunk_chunk_t *chunk) {
if (chunk == NULL) return;
pcc_thunk_array__term(ctx->auxil, &chunk->thunks);
pcc_capture_table__term(ctx->auxil, &chunk->capts);
pcc_value_table__term(ctx->auxil, &chunk->values);
pcc_memory_recycler__recycle(ctx->auxil, &ctx->thunk_chunk_recycler, chunk);
}
static void pcc_rule_set__init(pcc_auxil_t auxil, pcc_rule_set_t *set) {
set->len = 0;
set->max = 0;
set->buf = NULL;
}
static size_t pcc_rule_set__index(pcc_auxil_t auxil, const pcc_rule_set_t *set, pcc_rule_t rule) {
size_t i;
for (i = 0; i < set->len; i++) {
if (set->buf[i] == rule) return i;
}
return PCC_VOID_VALUE;
}
static pcc_bool_t pcc_rule_set__add(pcc_auxil_t auxil, pcc_rule_set_t *set, pcc_rule_t rule) {
const size_t i = pcc_rule_set__index(auxil, set, rule);
if (i != PCC_VOID_VALUE) return PCC_FALSE;
if (set->max <= set->len) {
const size_t n = set->len + 1;
size_t m = set->max;
if (m == 0) m = PCC_ARRAY_MIN_SIZE;
while (m < n && m != 0) m <<= 1;
if (m == 0) m = n;
set->buf = (pcc_rule_t *)PCC_REALLOC(auxil, set->buf, sizeof(pcc_rule_t) * m);
set->max = m;
}
set->buf[set->len++] = rule;
return PCC_TRUE;
}
static pcc_bool_t pcc_rule_set__remove(pcc_auxil_t auxil, pcc_rule_set_t *set, pcc_rule_t rule) {
const size_t i = pcc_rule_set__index(auxil, set, rule);
if (i == PCC_VOID_VALUE) return PCC_FALSE;
memmove(set->buf + i, set->buf + (i + 1), sizeof(pcc_rule_t) * (set->len - (i + 1)));
return PCC_TRUE;
}
static void pcc_rule_set__clear(pcc_auxil_t auxil, pcc_rule_set_t *set) {
set->len = 0;
}
static void pcc_rule_set__copy(pcc_auxil_t auxil, pcc_rule_set_t *set, const pcc_rule_set_t *src) {
size_t i;
pcc_rule_set__clear(auxil, set);
for (i = 0; i < src->len; i++) {
pcc_rule_set__add(auxil, set, src->buf[i]);
}
}
static void pcc_rule_set__term(pcc_auxil_t auxil, pcc_rule_set_t *set) {
PCC_FREE(auxil, set->buf);
}
static pcc_lr_head_t *pcc_lr_head__create(pcc_context_t *ctx, pcc_rule_t rule) {
pcc_lr_head_t *const head = (pcc_lr_head_t *)pcc_memory_recycler__supply(ctx->auxil, &ctx->lr_head_recycler);
head->rule = rule;
pcc_rule_set__init(ctx->auxil, &head->invol);
pcc_rule_set__init(ctx->auxil, &head->eval);
head->hold = NULL;
return head;
}
static void pcc_lr_head__destroy(pcc_context_t *ctx, pcc_lr_head_t *head) {
if (head == NULL) return;
pcc_lr_head__destroy(ctx, head->hold);
pcc_rule_set__term(ctx->auxil, &head->eval);
pcc_rule_set__term(ctx->auxil, &head->invol);
pcc_memory_recycler__recycle(ctx->auxil, &ctx->lr_head_recycler, head);
}
static void pcc_lr_entry__destroy(pcc_auxil_t auxil, pcc_lr_entry_t *lr);
static pcc_lr_answer_t *pcc_lr_answer__create(pcc_context_t *ctx, pcc_lr_answer_type_t type, size_t pos) {
pcc_lr_answer_t *answer = (pcc_lr_answer_t *)pcc_memory_recycler__supply(ctx->auxil, &ctx->lr_answer_recycler);
answer->type = type;
answer->pos = pos;
answer->hold = NULL;
switch (answer->type) {
case PCC_LR_ANSWER_LR:
answer->data.lr = NULL;
break;
case PCC_LR_ANSWER_CHUNK:
answer->data.chunk = NULL;
break;
default: /* unknown */
PCC_FREE(ctx->auxil, answer);
answer = NULL;
}
return answer;
}
static void pcc_lr_answer__set_chunk(pcc_context_t *ctx, pcc_lr_answer_t *answer, pcc_thunk_chunk_t *chunk) {
pcc_lr_answer_t *const a = pcc_lr_answer__create(ctx, answer->type, answer->pos);
switch (answer->type) {
case PCC_LR_ANSWER_LR:
a->data.lr = answer->data.lr;
break;
case PCC_LR_ANSWER_CHUNK:
a->data.chunk = answer->data.chunk;
break;
default: /* unknown */
break;
}
a->hold = answer->hold;
answer->hold = a;
answer->type = PCC_LR_ANSWER_CHUNK;
answer->data.chunk = chunk;
}
static void pcc_lr_answer__destroy(pcc_context_t *ctx, pcc_lr_answer_t *answer) {
while (answer != NULL) {
pcc_lr_answer_t *const a = answer->hold;
switch (answer->type) {
case PCC_LR_ANSWER_LR:
pcc_lr_entry__destroy(ctx->auxil, answer->data.lr);
break;
case PCC_LR_ANSWER_CHUNK:
pcc_thunk_chunk__destroy(ctx, answer->data.chunk);
break;
default: /* unknown */
break;
}
pcc_memory_recycler__recycle(ctx->auxil, &ctx->lr_answer_recycler, answer);
answer = a;
}
}
static void pcc_lr_memo_map__init(pcc_auxil_t auxil, pcc_lr_memo_map_t *map) {
map->len = 0;
map->max = 0;
map->buf = NULL;
}
static size_t pcc_lr_memo_map__index(pcc_context_t *ctx, pcc_lr_memo_map_t *map, pcc_rule_t rule) {
size_t i;
for (i = 0; i < map->len; i++) {
if (map->buf[i].rule == rule) return i;
}
return PCC_VOID_VALUE;
}
static void pcc_lr_memo_map__put(pcc_context_t *ctx, pcc_lr_memo_map_t *map, pcc_rule_t rule, pcc_lr_answer_t *answer) {
const size_t i = pcc_lr_memo_map__index(ctx, map, rule);
if (i != PCC_VOID_VALUE) {
pcc_lr_answer__destroy(ctx, map->buf[i].answer);
map->buf[i].answer = answer;
}
else {
if (map->max <= map->len) {
const size_t n = map->len + 1;
size_t m = map->max;
if (m == 0) m = PCC_ARRAY_MIN_SIZE;
while (m < n && m != 0) m <<= 1;
if (m == 0) m = n;
map->buf = (pcc_lr_memo_t *)PCC_REALLOC(ctx->auxil, map->buf, sizeof(pcc_lr_memo_t) * m);
map->max = m;
}
map->buf[map->len].rule = rule;
map->buf[map->len].answer = answer;
map->len++;
}
}
static pcc_lr_answer_t *pcc_lr_memo_map__get(pcc_context_t *ctx, pcc_lr_memo_map_t *map, pcc_rule_t rule) {
const size_t i = pcc_lr_memo_map__index(ctx, map, rule);
return (i != PCC_VOID_VALUE) ? map->buf[i].answer : NULL;
}
static void pcc_lr_memo_map__term(pcc_context_t *ctx, pcc_lr_memo_map_t *map) {
while (map->len > 0) {
map->len--;
pcc_lr_answer__destroy(ctx, map->buf[map->len].answer);
}
PCC_FREE(ctx->auxil, map->buf);
}
static pcc_lr_table_entry_t *pcc_lr_table_entry__create(pcc_context_t *ctx) {
pcc_lr_table_entry_t *const entry = (pcc_lr_table_entry_t *)PCC_MALLOC(ctx->auxil, sizeof(pcc_lr_table_entry_t));
entry->head = NULL;
pcc_lr_memo_map__init(ctx->auxil, &entry->memos);
entry->hold_a = NULL;
entry->hold_h = NULL;
return entry;
}
static void pcc_lr_table_entry__destroy(pcc_context_t *ctx, pcc_lr_table_entry_t *entry) {
if (entry == NULL) return;
pcc_lr_head__destroy(ctx, entry->hold_h);
pcc_lr_answer__destroy(ctx, entry->hold_a);
pcc_lr_memo_map__term(ctx, &entry->memos);
PCC_FREE(ctx->auxil, entry);
}
static void pcc_lr_table__init(pcc_auxil_t auxil, pcc_lr_table_t *table) {
table->ofs = 0;
table->len = 0;
table->max = 0;
table->buf = NULL;
}
static void pcc_lr_table__resize(pcc_context_t *ctx, pcc_lr_table_t *table, size_t len) {
size_t i;
for (i = len; i < table->len; i++) pcc_lr_table_entry__destroy(ctx, table->buf[i]);
if (table->max < len) {
size_t m = table->max;
if (m == 0) m = PCC_ARRAY_MIN_SIZE;
while (m < len && m != 0) m <<= 1;
if (m == 0) m = len;
table->buf = (pcc_lr_table_entry_t **)PCC_REALLOC(ctx->auxil, table->buf, sizeof(pcc_lr_table_entry_t *) * m);
table->max = m;
}
for (i = table->len; i < len; i++) table->buf[i] = NULL;
table->len = len;
}
static void pcc_lr_table__set_head(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_lr_head_t *head) {
index += table->ofs;
if (index >= table->len) pcc_lr_table__resize(ctx, table, index + 1);
if (table->buf[index] == NULL) table->buf[index] = pcc_lr_table_entry__create(ctx);
table->buf[index]->head = head;
}
static void pcc_lr_table__hold_head(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_lr_head_t *head) {
index += table->ofs;
if (index >= table->len) pcc_lr_table__resize(ctx, table, index + 1);
if (table->buf[index] == NULL) table->buf[index] = pcc_lr_table_entry__create(ctx);
head->hold = table->buf[index]->hold_h;
table->buf[index]->hold_h = head;
}
static void pcc_lr_table__set_answer(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_rule_t rule, pcc_lr_answer_t *answer) {
index += table->ofs;
if (index >= table->len) pcc_lr_table__resize(ctx, table, index + 1);
if (table->buf[index] == NULL) table->buf[index] = pcc_lr_table_entry__create(ctx);
pcc_lr_memo_map__put(ctx, &table->buf[index]->memos, rule, answer);
}
static void pcc_lr_table__hold_answer(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_lr_answer_t *answer) {
index += table->ofs;
if (index >= table->len) pcc_lr_table__resize(ctx, table, index + 1);
if (table->buf[index] == NULL) table->buf[index] = pcc_lr_table_entry__create(ctx);
answer->hold = table->buf[index]->hold_a;
table->buf[index]->hold_a = answer;
}
static pcc_lr_head_t *pcc_lr_table__get_head(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index) {
index += table->ofs;
if (index >= table->len || table->buf[index] == NULL) return NULL;
return table->buf[index]->head;
}
static pcc_lr_answer_t *pcc_lr_table__get_answer(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_rule_t rule) {
index += table->ofs;
if (index >= table->len || table->buf[index] == NULL) return NULL;
return pcc_lr_memo_map__get(ctx, &table->buf[index]->memos, rule);
}
static void pcc_lr_table__shift(pcc_context_t *ctx, pcc_lr_table_t *table, size_t count) {
size_t i;
if (count > table->len - table->ofs) count = table->len - table->ofs;
for (i = 0; i < count; i++) pcc_lr_table_entry__destroy(ctx, table->buf[table->ofs++]);
if (table->ofs > (table->max >> 1)) {
memmove(table->buf, table->buf + table->ofs, sizeof(pcc_lr_table_entry_t *) * (table->len - table->ofs));
table->len -= table->ofs;
table->ofs = 0;
}
}
static void pcc_lr_table__term(pcc_context_t *ctx, pcc_lr_table_t *table) {
while (table->len > table->ofs) {
table->len--;
pcc_lr_table_entry__destroy(ctx, table->buf[table->len]);
}
PCC_FREE(ctx->auxil, table->buf);
}
static pcc_lr_entry_t *pcc_lr_entry__create(pcc_auxil_t auxil, pcc_rule_t rule) {
pcc_lr_entry_t *const lr = (pcc_lr_entry_t *)PCC_MALLOC(auxil, sizeof(pcc_lr_entry_t));
lr->rule = rule;
lr->seed = NULL;
lr->head = NULL;
return lr;
}
static void pcc_lr_entry__destroy(pcc_auxil_t auxil, pcc_lr_entry_t *lr) {
PCC_FREE(auxil, lr);
}
static void pcc_lr_stack__init(pcc_auxil_t auxil, pcc_lr_stack_t *stack) {
stack->len = 0;
stack->max = 0;
stack->buf = NULL;
}
static void pcc_lr_stack__push(pcc_auxil_t auxil, pcc_lr_stack_t *stack, pcc_lr_entry_t *lr) {
if (stack->max <= stack->len) {
const size_t n = stack->len + 1;
size_t m = stack->max;
if (m == 0) m = PCC_ARRAY_MIN_SIZE;
while (m < n && m != 0) m <<= 1;
if (m == 0) m = n;
stack->buf = (pcc_lr_entry_t **)PCC_REALLOC(auxil, stack->buf, sizeof(pcc_lr_entry_t *) * m);
stack->max = m;
}
stack->buf[stack->len++] = lr;
}
static pcc_lr_entry_t *pcc_lr_stack__pop(pcc_auxil_t auxil, pcc_lr_stack_t *stack) {
return stack->buf[--stack->len];
}
static void pcc_lr_stack__term(pcc_auxil_t auxil, pcc_lr_stack_t *stack) {
PCC_FREE(auxil, stack->buf);
}
static pcc_context_t *pcc_context__create(pcc_auxil_t auxil) {
pcc_context_t *const ctx = (pcc_context_t *)PCC_MALLOC(auxil, sizeof(pcc_context_t));
ctx->pos = 0;
ctx->cur = 0;
ctx->level = 0;
pcc_char_array__init(auxil, &ctx->buffer);
pcc_lr_table__init(auxil, &ctx->lrtable);
pcc_lr_stack__init(auxil, &ctx->lrstack);
pcc_thunk_array__init(auxil, &ctx->thunks);
pcc_memory_recycler__init(auxil, &ctx->thunk_chunk_recycler, sizeof(pcc_thunk_chunk_t));
pcc_memory_recycler__init(auxil, &ctx->lr_head_recycler, sizeof(pcc_lr_head_t));
pcc_memory_recycler__init(auxil, &ctx->lr_answer_recycler, sizeof(pcc_lr_answer_t));
ctx->auxil = auxil;
return ctx;
}
static void pcc_context__destroy(pcc_context_t *ctx) {
if (ctx == NULL) return;
pcc_thunk_array__term(ctx->auxil, &ctx->thunks);
pcc_lr_stack__term(ctx->auxil, &ctx->lrstack);
pcc_lr_table__term(ctx, &ctx->lrtable);
pcc_char_array__term(ctx->auxil, &ctx->buffer);
pcc_memory_recycler__term(ctx->auxil, &ctx->thunk_chunk_recycler);
pcc_memory_recycler__term(ctx->auxil, &ctx->lr_head_recycler);
pcc_memory_recycler__term(ctx->auxil, &ctx->lr_answer_recycler);
PCC_FREE(ctx->auxil, ctx);
}
static size_t pcc_refill_buffer(pcc_context_t *ctx, size_t num) {
if (ctx->buffer.len >= ctx->cur + num) return ctx->buffer.len - ctx->cur;
while (ctx->buffer.len < ctx->cur + num) {
const int c = PCC_GETCHAR(ctx->auxil);
if (c < 0) break;
pcc_char_array__add(ctx->auxil, &ctx->buffer, (char)c);
}
return ctx->buffer.len - ctx->cur;
}
MARK_FUNC_AS_USED
static void pcc_commit_buffer(pcc_context_t *ctx) {
memmove(ctx->buffer.buf, ctx->buffer.buf + ctx->cur, ctx->buffer.len - ctx->cur);
ctx->buffer.len -= ctx->cur;
ctx->pos += ctx->cur;
pcc_lr_table__shift(ctx, &ctx->lrtable, ctx->cur);
ctx->cur = 0;
}
MARK_FUNC_AS_USED
static const char *pcc_get_capture_string(pcc_context_t *ctx, const pcc_capture_t *capt) {
if (capt->string == NULL)
((pcc_capture_t *)capt)->string =
pcc_strndup_e(ctx->auxil, ctx->buffer.buf + capt->range.start, capt->range.end - capt->range.start);
return capt->string;
}
static size_t pcc_get_char_as_utf32(pcc_context_t *ctx, int *out) { /* with checking UTF-8 validity */
int c, u;
size_t n;
if (pcc_refill_buffer(ctx, 1) < 1) return 0;
c = (int)(unsigned char)ctx->buffer.buf[ctx->cur];
n = (c < 0x80) ? 1 :
((c & 0xe0) == 0xc0) ? 2 :
((c & 0xf0) == 0xe0) ? 3 :
((c & 0xf8) == 0xf0) ? 4 : 0;
if (n < 1) return 0;
if (pcc_refill_buffer(ctx, n) < n) return 0;
switch (n) {
case 1:
u = c;
break;
case 2:
u = c & 0x1f;
c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 1];
if ((c & 0xc0) != 0x80) return 0;
u <<= 6; u |= c & 0x3f;
if (u < 0x80) return 0;
break;
case 3:
u = c & 0x0f;
c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 1];
if ((c & 0xc0) != 0x80) return 0;
u <<= 6; u |= c & 0x3f;
c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 2];
if ((c & 0xc0) != 0x80) return 0;
u <<= 6; u |= c & 0x3f;
if (u < 0x800) return 0;
break;
case 4:
u = c & 0x07;
c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 1];
if ((c & 0xc0) != 0x80) return 0;
u <<= 6; u |= c & 0x3f;
c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 2];
if ((c & 0xc0) != 0x80) return 0;
u <<= 6; u |= c & 0x3f;
c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 3];
if ((c & 0xc0) != 0x80) return 0;
u <<= 6; u |= c & 0x3f;
if (u < 0x10000 || u > 0x10ffff) return 0;
break;
default:
return 0;
}
if (out) *out = u;
return n;
}
MARK_FUNC_AS_USED
static pcc_bool_t pcc_apply_rule(pcc_context_t *ctx, pcc_rule_t rule, pcc_thunk_array_t *thunks, pcc_value_t *value) {
static pcc_value_t null;
pcc_thunk_chunk_t *c = NULL;
const size_t p = ctx->pos + ctx->cur;
pcc_bool_t b = PCC_TRUE;
pcc_lr_answer_t *a = pcc_lr_table__get_answer(ctx, &ctx->lrtable, p, rule);
pcc_lr_head_t *h = pcc_lr_table__get_head(ctx, &ctx->lrtable, p);
if (h != NULL) {
if (a == NULL && rule != h->rule && pcc_rule_set__index(ctx->auxil, &h->invol, rule) == PCC_VOID_VALUE) {
b = PCC_FALSE;
c = NULL;
}
else if (pcc_rule_set__remove(ctx->auxil, &h->eval, rule)) {
b = PCC_FALSE;
c = rule(ctx);
a = pcc_lr_answer__create(ctx, PCC_LR_ANSWER_CHUNK, ctx->pos + ctx->cur);
a->data.chunk = c;
pcc_lr_table__hold_answer(ctx, &ctx->lrtable, p, a);
}
}
if (b) {
if (a != NULL) {
ctx->cur = a->pos - ctx->pos;
switch (a->type) {
case PCC_LR_ANSWER_LR:
if (a->data.lr->head == NULL) {
a->data.lr->head = pcc_lr_head__create(ctx, rule);
pcc_lr_table__hold_head(ctx, &ctx->lrtable, p, a->data.lr->head);
}
{
size_t i = ctx->lrstack.len;
while (i > 0) {
i--;
if (ctx->lrstack.buf[i]->head == a->data.lr->head) break;
ctx->lrstack.buf[i]->head = a->data.lr->head;
pcc_rule_set__add(ctx->auxil, &a->data.lr->head->invol, ctx->lrstack.buf[i]->rule);
}
}
c = a->data.lr->seed;
break;
case PCC_LR_ANSWER_CHUNK:
c = a->data.chunk;
break;
default: /* unknown */
break;
}
}
else {
pcc_lr_entry_t *const e = pcc_lr_entry__create(ctx->auxil, rule);
pcc_lr_stack__push(ctx->auxil, &ctx->lrstack, e);
a = pcc_lr_answer__create(ctx, PCC_LR_ANSWER_LR, p);
a->data.lr = e;
pcc_lr_table__set_answer(ctx, &ctx->lrtable, p, rule, a);
c = rule(ctx);
pcc_lr_stack__pop(ctx->auxil, &ctx->lrstack);
a->pos = ctx->pos + ctx->cur;
if (e->head == NULL) {
pcc_lr_answer__set_chunk(ctx, a, c);
}
else {
e->seed = c;
h = a->data.lr->head;
if (h->rule != rule) {
c = a->data.lr->seed;
a = pcc_lr_answer__create(ctx, PCC_LR_ANSWER_CHUNK, ctx->pos + ctx->cur);
a->data.chunk = c;
pcc_lr_table__hold_answer(ctx, &ctx->lrtable, p, a);
}
else {
pcc_lr_answer__set_chunk(ctx, a, a->data.lr->seed);
if (a->data.chunk == NULL) {
c = NULL;
}
else {
pcc_lr_table__set_head(ctx, &ctx->lrtable, p, h);
for (;;) {
ctx->cur = p - ctx->pos;
pcc_rule_set__copy(ctx->auxil, &h->eval, &h->invol);
c = rule(ctx);
if (c == NULL || ctx->pos + ctx->cur <= a->pos) break;
pcc_lr_answer__set_chunk(ctx, a, c);
a->pos = ctx->pos + ctx->cur;
}
pcc_thunk_chunk__destroy(ctx, c);
pcc_lr_table__set_head(ctx, &ctx->lrtable, p, NULL);
ctx->cur = a->pos - ctx->pos;
c = a->data.chunk;
}
}
}
}
}
if (c == NULL) return PCC_FALSE;
if (value == NULL) value = &null;
memset(value, 0, sizeof(pcc_value_t)); /* in case */
pcc_thunk_array__add(ctx->auxil, thunks, pcc_thunk__create_node(ctx->auxil, &c->thunks, value));
return PCC_TRUE;
}
MARK_FUNC_AS_USED
static void pcc_do_action(pcc_context_t *ctx, const pcc_thunk_array_t *thunks, pcc_value_t *value) {
size_t i;
for (i = 0; i < thunks->len; i++) {
pcc_thunk_t *const thunk = thunks->buf[i];
switch (thunk->type) {
case PCC_THUNK_LEAF:
thunk->data.leaf.action(ctx, thunk, value);
break;
case PCC_THUNK_NODE:
pcc_do_action(ctx, thunk->data.node.thunks, thunk->data.node.value);
break;
default: /* unknown */
break;
}
}
}
static void pcc_action_filePart_0(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
resetFailure(auxil, _0s);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_unparsable_0(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
reportFailure(auxil, _0s);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_packageHeader_0(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_PACKAGE);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_packageHeader_1(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _1 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[0])
#define _1s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.start))
#define _1e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.end))
makeKotlinTag(auxil, _1, _1s, true);
#undef _1e
#undef _1s
#undef _1
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_0(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_CLASS);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_1(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_INTERFACE);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_2(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _1 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[0])
#define _1s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.start))
#define _1e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.end))
makeKotlinTag(auxil, _1, _1s, true);
#undef _1e
#undef _1s
#undef _1
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_3(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _1 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[0])
#define _1s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.start))
#define _1e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.end))
POP_SCOPE(auxil);
#undef _1e
#undef _1s
#undef _1
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_4(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_OBJECT);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_5(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _2 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[1])
#define _2s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[1]->range.start))
#define _2e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[1]->range.end))
makeKotlinTag(auxil, _2, _2s, true);
#undef _2e
#undef _2s
#undef _2
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_6(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _2 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[1])
#define _2s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[1]->range.start))
#define _2e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[1]->range.end))
POP_SCOPE(auxil);
#undef _2e
#undef _2s
#undef _2
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_7(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_METHOD);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_8(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _3 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[2])
#define _3s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[2]->range.start))
#define _3e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[2]->range.end))
makeKotlinTag(auxil, _3, _3s, true);
#undef _3e
#undef _3s
#undef _3
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_9(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _3 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[2])
#define _3s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[2]->range.start))
#define _3e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[2]->range.end))
POP_SCOPE(auxil);
#undef _3e
#undef _3s
#undef _3
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_10(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_CONSTANT);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_11(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_VARIABLE);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_12(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_TYPEALIAS);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_declaration_13(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _4 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[3])
#define _4s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[3]->range.start))
#define _4e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[3]->range.end))
makeKotlinTag(auxil, _4, _4s, false);
#undef _4e
#undef _4s
#undef _4
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_classParameter_0(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_CONSTANT);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_classParameter_1(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_VARIABLE);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_classParameter_2(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_IGNORE);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_classParameter_3(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _1 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[0])
#define _1s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.start))
#define _1e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.end))
makeKotlinTag(auxil, _1, _1s, true);
#undef _1e
#undef _1s
#undef _1
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_classParameter_4(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _1 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[0])
#define _1s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.start))
#define _1e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.end))
POP_SCOPE(auxil);
#undef _1e
#undef _1s
#undef _1
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_classMemberDeclaration_0(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_OBJECT);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_classMemberDeclaration_1(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _1 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[0])
#define _1s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.start))
#define _1e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.end))
makeKotlinTag(auxil, _1e-_1s != 0 ? _1 : "Companion", _1s, true);
#undef _1e
#undef _1s
#undef _1
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_classMemberDeclaration_2(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _1 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[0])
#define _1s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.start))
#define _1e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.end))
POP_SCOPE(auxil);
#undef _1e
#undef _1s
#undef _1
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_variableDeclaration_0(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
#define _1 pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[0])
#define _1s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.start))
#define _1e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[0]->range.end))
makeKotlinTag(auxil, _1, _1s, false);
#undef _1e
#undef _1s
#undef _1
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_lambdaLiteral_0(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_METHOD); makeKotlinTag(auxil, "<lambda>", _0s, true);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_lambdaLiteral_1(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
POP_SCOPE(auxil);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_lambdaLiteral_2(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_METHOD); makeKotlinTag(auxil, "<lambda>", 8, true);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_lambdaLiteral_3(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
POP_SCOPE(auxil);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_anonymousFunction_0(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
PUSH_KIND(auxil, K_METHOD); makeKotlinTag(auxil, "<anonymous>", _0s, true);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static void pcc_action_anonymousFunction_1(pkotlin_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
#define auxil (__pcc_ctx->auxil)
#define __ (*__pcc_out)
#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
#define _0s ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.start))
#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
POP_SCOPE(auxil);
#undef _0e
#undef _0s
#undef _0
#undef __
#undef auxil
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_file(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_filePart(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_unparsable(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_packageHeader(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_declaration(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_classBody(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_classParameter(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_annotatedDelegationSpecifier(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_typeParameters(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_typeParameter(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_typeConstraints(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_classMemberDeclaration(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_functionValueParameters(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_functionValueParameter(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_variableDeclaration(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_multiVariableDeclaration(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_getter(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_setter(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_parameterWithOptionalType(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_type(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_nullableType(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_userType(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_functionType(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_receiverType(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_receiverTypeAndDot(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_statements(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_statement(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_label(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_block(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_semi(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_semis(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_expression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_equality(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_genericCallLikeComparison(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_elvisExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_rangeExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_multiplicativeExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_asExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_postfixUnaryExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_parenthesizedDirectlyAssignableExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_parenthesizedAssignableExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_indexingSuffix(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_navigationSuffix(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_callSuffix(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_typeArguments(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_valueArguments(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_primaryExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_expression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_equality(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_comparison(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_genericCallLikeComparison(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_infixFunctionCall(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_additiveExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_asExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_postfixUnaryExpression(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_lambdaLiteral(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_anonymousFunction(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_isOperator(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_prefixUnaryOperator(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_modifiers(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_annotation(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_annotationUseSiteTarget(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_simpleIdentifier(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DelimitedComment(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Hidden(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IN(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SUSPEND(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DecDigits(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_HexDigit(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_HexLiteral(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BinLiteral(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Identifier(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FieldIdentifier(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Letter(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UnicodeDigit(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule___(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_NL(pcc_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_file(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "file", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '#' ||
(ctx->buffer.buf + ctx->cur)[1] != '!'
) goto L0001;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0002;
if (
u == 0x00000a ||
u == 0x00000d
) goto L0002;
ctx->cur += n;
}
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0001;
}
}
goto L0005;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0005:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0009;
ctx->cur++;
goto L0008;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Hidden, &chunk->thunks, NULL)) goto L0012;
goto L0011;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0013;
goto L0011;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0010;
L0011:;
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0010;
ctx->cur++;
goto L0008;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0007;
L0008:;
}
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'i' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e'
) goto L0007;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0016;
goto L0015;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0017;
goto L0015;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0014;
L0015:;
}
ctx->cur = p;
goto L0007;
L0014:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0018;
if (ctx->cur == p) break;
continue;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0007;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0020;
if (ctx->cur == p) break;
continue;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '['
) goto L0022;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0023;
if (ctx->cur == p) break;
continue;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0026;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0027;
if (ctx->cur == p) break;
continue;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0026;
goto L0025;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0028;
goto L0025;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0024;
L0025:;
}
if (ctx->cur == p) break;
continue;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0022;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0029;
if (ctx->cur == p) break;
continue;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ']'
) goto L0022;
ctx->cur++;
goto L0021;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0030;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0031;
if (ctx->cur == p) break;
continue;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0030;
goto L0021;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0032;
goto L0021;
L0032:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0007;
L0021:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0033;
if (ctx->cur == p) break;
continue;
L0033:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0034;
if (ctx->cur == p) break;
continue;
L0034:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0035;
if (ctx->cur == p) break;
continue;
L0035:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_packageHeader, &chunk->thunks, NULL)) goto L0036;
if (ctx->cur == p) break;
continue;
L0036:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0037;
if (ctx->cur == p) break;
continue;
L0037:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'm' ||
(ctx->buffer.buf + ctx->cur)[2] != 'p' ||
(ctx->buffer.buf + ctx->cur)[3] != 'o' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 't'
) goto L0038;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0041;
goto L0040;
L0041:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0042;
goto L0040;
L0042:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0039;
L0040:;
}
ctx->cur = p;
goto L0038;
L0039:;
ctx->cur = p;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0038;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0038;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0044;
if (ctx->cur == p) break;
continue;
L0044:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0043;
ctx->cur++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0043;
if (ctx->cur == p) break;
continue;
L0043:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '.' ||
(ctx->buffer.buf + ctx->cur)[1] != '*'
) goto L0047;
ctx->cur += 2;
goto L0046;
L0047:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0048;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 's'
) goto L0048;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0051;
goto L0050;
L0051:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0052;
goto L0050;
L0052:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0049;
L0050:;
}
ctx->cur = p;
goto L0048;
L0049:;
ctx->cur = p;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0048;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0048;
goto L0046;
L0048:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0045;
L0046:;
}
goto L0053;
L0045:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0053:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0054;
if (ctx->cur == p) break;
continue;
L0054:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semi, &chunk->thunks, NULL)) goto L0055;
goto L0056;
L0055:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0056:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0057;
if (ctx->cur == p) break;
continue;
L0057:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0038:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0058;
if (ctx->cur == p) break;
continue;
L0058:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_filePart, &chunk->thunks, NULL)) goto L0061;
goto L0060;
L0061:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0062;
goto L0060;
L0062:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_unparsable, &chunk->thunks, NULL)) goto L0063;
goto L0060;
L0063:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0059;
L0060:;
}
if (ctx->cur == p) break;
continue;
L0059:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
const size_t p = ctx->cur;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0064;
ctx->cur += n;
}
ctx->cur = p;
goto L0000;
L0064:;
ctx->cur = p;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "file", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "file", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_filePart(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "filePart", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_declaration, &chunk->thunks, NULL)) goto L0002;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semis, &chunk->thunks, NULL)) goto L0004;
goto L0005;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0005:;
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0006;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semi, &chunk->thunks, NULL)) goto L0006;
goto L0001;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_filePart_0, 0, 0);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "filePart", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "filePart", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_unparsable(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "unparsable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0001;
if (
u == 0x00000a
) goto L0001;
ctx->cur += n;
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0000;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_unparsable_0, 0, 0);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "unparsable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "unparsable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_packageHeader(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "packageHeader", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
pcc_capture_table__resize(ctx->auxil, &chunk->capts, 1);
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'p' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'c' ||
(ctx->buffer.buf + ctx->cur)[3] != 'k' ||
(ctx->buffer.buf + ctx->cur)[4] != 'a' ||
(ctx->buffer.buf + ctx->cur)[5] != 'g' ||
(ctx->buffer.buf + ctx->cur)[6] != 'e'
) goto L0000;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0004;
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
ctx->cur = p;
goto L0000;
L0001:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_packageHeader_0, 0, 1);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0000;
{
const size_t p = ctx->cur;
size_t q;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0005;
ctx->cur++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
q = ctx->cur;
chunk->capts.buf[0].range.start = p;
chunk->capts.buf[0].range.end = q;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_packageHeader_1, 0, 1);
thunk->data.leaf.capts.buf[0] = &(chunk->capts.buf[0]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semi, &chunk->thunks, NULL)) goto L0008;
goto L0009;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0009:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "packageHeader", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "packageHeader", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_declaration(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "declaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
pcc_capture_table__resize(ctx->auxil, &chunk->capts, 4);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0003;
goto L0004;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0004:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'l' ||
(ctx->buffer.buf + ctx->cur)[2] != 'a' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 's'
) goto L0006;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0009;
goto L0008;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0010;
goto L0008;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0007;
L0008:;
}
ctx->cur = p;
goto L0006;
L0007:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_0, 0, 4);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n'
) goto L0012;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0015;
goto L0014;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0016;
goto L0014;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0013;
L0014:;
}
ctx->cur = p;
goto L0012;
L0013:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0018;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0018:;
}
if (
pcc_refill_buffer(ctx, 9) < 9 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'n' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'f' ||
(ctx->buffer.buf + ctx->cur)[6] != 'a' ||
(ctx->buffer.buf + ctx->cur)[7] != 'c' ||
(ctx->buffer.buf + ctx->cur)[8] != 'e'
) goto L0011;
ctx->cur += 9;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0021;
goto L0020;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0022;
goto L0020;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0019;
L0020:;
}
ctx->cur = p;
goto L0011;
L0019:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_1, 0, 4);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0005;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0005:;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0002;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0023;
if (ctx->cur == p) break;
continue;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
const size_t p = ctx->cur;
size_t q;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0002;
q = ctx->cur;
chunk->capts.buf[0].range.start = p;
chunk->capts.buf[0].range.end = q;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_2, 0, 4);
thunk->data.leaf.capts.buf[0] = &(chunk->capts.buf[0]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0025;
if (ctx->cur == p) break;
continue;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeParameters, &chunk->thunks, NULL)) goto L0024;
goto L0026;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0026:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0028;
if (ctx->cur == p) break;
continue;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0030;
goto L0031;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0031:;
}
if (
pcc_refill_buffer(ctx, 11) < 11 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 't' ||
(ctx->buffer.buf + ctx->cur)[5] != 'r' ||
(ctx->buffer.buf + ctx->cur)[6] != 'u' ||
(ctx->buffer.buf + ctx->cur)[7] != 'c' ||
(ctx->buffer.buf + ctx->cur)[8] != 't' ||
(ctx->buffer.buf + ctx->cur)[9] != 'o' ||
(ctx->buffer.buf + ctx->cur)[10] != 'r'
) goto L0029;
ctx->cur += 11;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0034;
goto L0033;
L0034:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0035;
goto L0033;
L0035:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0032;
L0033:;
}
ctx->cur = p;
goto L0029;
L0032:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0036;
if (ctx->cur == p) break;
continue;
L0036:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0037;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0037:;
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0027;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0038;
if (ctx->cur == p) break;
continue;
L0038:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classParameter, &chunk->thunks, NULL)) goto L0039;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0041;
if (ctx->cur == p) break;
continue;
L0041:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0040;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0042;
if (ctx->cur == p) break;
continue;
L0042:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classParameter, &chunk->thunks, NULL)) goto L0040;
if (ctx->cur == p) break;
continue;
L0040:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0044;
if (ctx->cur == p) break;
continue;
L0044:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0043;
ctx->cur++;
goto L0045;
L0043:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0045:;
}
goto L0046;
L0039:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0046:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0047;
if (ctx->cur == p) break;
continue;
L0047:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0027;
ctx->cur++;
goto L0048;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0048:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0050;
if (ctx->cur == p) break;
continue;
L0050:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0049;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0051;
if (ctx->cur == p) break;
continue;
L0051:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotatedDelegationSpecifier, &chunk->thunks, NULL)) goto L0049;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0053;
if (ctx->cur == p) break;
continue;
L0053:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0052;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0054;
if (ctx->cur == p) break;
continue;
L0054:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotatedDelegationSpecifier, &chunk->thunks, NULL)) goto L0052;
if (ctx->cur == p) break;
continue;
L0052:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0055;
L0049:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0055:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0057;
if (ctx->cur == p) break;
continue;
L0057:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeConstraints, &chunk->thunks, NULL)) goto L0056;
goto L0058;
L0056:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0058:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0062;
if (ctx->cur == p) break;
continue;
L0062:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classBody, &chunk->thunks, NULL)) goto L0061;
goto L0060;
L0061:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0064;
if (ctx->cur == p) break;
continue;
L0064:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '{'
) goto L0063;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0065;
if (ctx->cur == p) break;
continue;
L0065:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0067;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0068;
if (ctx->cur == p) break;
continue;
L0068:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0069;
L0067:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0069:;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0066;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0071;
if (ctx->cur == p) break;
continue;
L0071:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0070;
goto L0072;
L0070:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0072:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0074;
if (ctx->cur == p) break;
continue;
L0074:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classBody, &chunk->thunks, NULL)) goto L0073;
goto L0075;
L0073:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0075:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0077;
if (ctx->cur == p) break;
continue;
L0077:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0076;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0078;
if (ctx->cur == p) break;
continue;
L0078:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0079;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0080;
if (ctx->cur == p) break;
continue;
L0080:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0081;
L0079:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0081:;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0076;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0083;
if (ctx->cur == p) break;
continue;
L0083:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0082;
goto L0084;
L0082:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0084:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0086;
if (ctx->cur == p) break;
continue;
L0086:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classBody, &chunk->thunks, NULL)) goto L0085;
goto L0087;
L0085:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0087:;
}
if (ctx->cur == p) break;
continue;
L0076:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0088;
if (ctx->cur == p) break;
continue;
L0088:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0089;
ctx->cur++;
goto L0090;
L0089:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0090:;
}
goto L0091;
L0066:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0091:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0093;
if (ctx->cur == p) break;
continue;
L0093:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ';'
) goto L0092;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0094;
if (ctx->cur == p) break;
continue;
L0094:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classMemberDeclaration, &chunk->thunks, NULL)) goto L0095;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semis, &chunk->thunks, NULL)) goto L0096;
goto L0097;
L0096:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0097:;
}
if (ctx->cur == p) break;
continue;
L0095:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0098;
L0092:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0098:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0099;
if (ctx->cur == p) break;
continue;
L0099:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '}'
) goto L0063;
ctx->cur++;
goto L0060;
L0063:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0059;
L0060:;
}
goto L0100;
L0059:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0100:;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_3, 0, 4);
thunk->data.leaf.capts.buf[0] = &(chunk->capts.buf[0]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0102;
goto L0103;
L0102:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0103:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0104;
if (ctx->cur == p) break;
continue;
L0104:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'b' ||
(ctx->buffer.buf + ctx->cur)[2] != 'j' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'c' ||
(ctx->buffer.buf + ctx->cur)[5] != 't'
) goto L0101;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0107;
goto L0106;
L0107:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0108;
goto L0106;
L0108:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0105;
L0106:;
}
ctx->cur = p;
goto L0101;
L0105:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_4, 0, 4);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0109;
if (ctx->cur == p) break;
continue;
L0109:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
const size_t p = ctx->cur;
size_t q;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0101;
q = ctx->cur;
chunk->capts.buf[1].range.start = p;
chunk->capts.buf[1].range.end = q;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_5, 0, 4);
thunk->data.leaf.capts.buf[1] = &(chunk->capts.buf[1]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0111;
if (ctx->cur == p) break;
continue;
L0111:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0110;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0112;
if (ctx->cur == p) break;
continue;
L0112:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotatedDelegationSpecifier, &chunk->thunks, NULL)) goto L0110;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0114;
if (ctx->cur == p) break;
continue;
L0114:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0113;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0115;
if (ctx->cur == p) break;
continue;
L0115:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotatedDelegationSpecifier, &chunk->thunks, NULL)) goto L0113;
if (ctx->cur == p) break;
continue;
L0113:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0116;
L0110:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0116:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0118;
if (ctx->cur == p) break;
continue;
L0118:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classBody, &chunk->thunks, NULL)) goto L0117;
goto L0119;
L0117:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0119:;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_6, 0, 4);
thunk->data.leaf.capts.buf[1] = &(chunk->capts.buf[1]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0001;
L0101:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0121;
goto L0122;
L0121:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0122:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0123;
if (ctx->cur == p) break;
continue;
L0123:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n'
) goto L0120;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0126;
goto L0125;
L0126:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0127;
goto L0125;
L0127:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0124;
L0125:;
}
ctx->cur = p;
goto L0120;
L0124:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_7, 0, 4);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0128;
if (ctx->cur == p) break;
continue;
L0128:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0130;
if (ctx->cur == p) break;
continue;
L0130:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeParameters, &chunk->thunks, NULL)) goto L0129;
goto L0131;
L0129:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0131:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0132;
if (ctx->cur == p) break;
continue;
L0132:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0134;
if (ctx->cur == p) break;
continue;
L0134:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_receiverTypeAndDot, &chunk->thunks, NULL)) goto L0133;
goto L0135;
L0133:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0135:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0136;
if (ctx->cur == p) break;
continue;
L0136:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
const size_t p = ctx->cur;
size_t q;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0120;
q = ctx->cur;
chunk->capts.buf[2].range.start = p;
chunk->capts.buf[2].range.end = q;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_8, 0, 4);
thunk->data.leaf.capts.buf[2] = &(chunk->capts.buf[2]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0137;
if (ctx->cur == p) break;
continue;
L0137:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_functionValueParameters, &chunk->thunks, NULL)) goto L0120;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0138;
if (ctx->cur == p) break;
continue;
L0138:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0140;
if (ctx->cur == p) break;
continue;
L0140:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0139;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0141;
if (ctx->cur == p) break;
continue;
L0141:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0139;
goto L0142;
L0139:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0142:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0143;
if (ctx->cur == p) break;
continue;
L0143:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0145;
if (ctx->cur == p) break;
continue;
L0145:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeConstraints, &chunk->thunks, NULL)) goto L0144;
goto L0146;
L0144:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0146:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0147;
if (ctx->cur == p) break;
continue;
L0147:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0149;
if (ctx->cur == p) break;
continue;
L0149:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0151;
goto L0150;
L0151:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0152;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0153;
ctx->cur++;
ctx->cur = p;
goto L0152;
L0153:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0154;
if (ctx->cur == p) break;
continue;
L0154:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0152;
goto L0150;
L0152:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0148;
L0150:;
}
goto L0155;
L0148:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0155:;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_9, 0, 4);
thunk->data.leaf.capts.buf[2] = &(chunk->capts.buf[2]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0001;
L0120:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0157;
goto L0158;
L0157:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0158:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0159;
if (ctx->cur == p) break;
continue;
L0159:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'v' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l'
) goto L0161;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0164;
goto L0163;
L0164:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0165;
goto L0163;
L0165:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0162;
L0163:;
}
ctx->cur = p;
goto L0161;
L0162:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_10, 0, 4);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0160;
L0161:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'v' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r'
) goto L0166;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0169;
goto L0168;
L0169:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0170;
goto L0168;
L0170:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0167;
L0168:;
}
ctx->cur = p;
goto L0166;
L0167:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_11, 0, 4);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0160;
L0166:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0156;
L0160:;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0156;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0172;
if (ctx->cur == p) break;
continue;
L0172:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeParameters, &chunk->thunks, NULL)) goto L0171;
goto L0173;
L0171:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0173:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0175;
if (ctx->cur == p) break;
continue;
L0175:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_receiverTypeAndDot, &chunk->thunks, NULL)) goto L0174;
goto L0176;
L0174:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0176:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0177;
if (ctx->cur == p) break;
continue;
L0177:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_multiVariableDeclaration, &chunk->thunks, NULL)) goto L0179;
goto L0178;
L0179:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_variableDeclaration, &chunk->thunks, NULL)) goto L0180;
goto L0178;
L0180:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0156;
L0178:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0182;
if (ctx->cur == p) break;
continue;
L0182:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeConstraints, &chunk->thunks, NULL)) goto L0181;
goto L0183;
L0181:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0183:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0185;
if (ctx->cur == p) break;
continue;
L0185:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0187;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0188;
ctx->cur++;
ctx->cur = p;
goto L0187;
L0188:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0189;
if (ctx->cur == p) break;
continue;
L0189:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0187;
goto L0186;
L0187:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'b' ||
(ctx->buffer.buf + ctx->cur)[1] != 'y'
) goto L0190;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0193;
goto L0192;
L0193:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0194;
goto L0192;
L0194:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0191;
L0192:;
}
ctx->cur = p;
goto L0190;
L0191:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0195;
if (ctx->cur == p) break;
continue;
L0195:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0190;
goto L0186;
L0190:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0184;
L0186:;
}
goto L0196;
L0184:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0196:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semi, &chunk->thunks, NULL)) goto L0200;
goto L0201;
L0200:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0201:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0202;
if (ctx->cur == p) break;
continue;
L0202:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_setter, &chunk->thunks, NULL)) goto L0199;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0204;
if (ctx->cur == p) break;
continue;
L0204:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semi, &chunk->thunks, NULL)) goto L0205;
goto L0206;
L0205:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0206:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0207;
if (ctx->cur == p) break;
continue;
L0207:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_getter, &chunk->thunks, NULL)) goto L0203;
goto L0208;
L0203:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0208:;
}
goto L0198;
L0199:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semi, &chunk->thunks, NULL)) goto L0210;
goto L0211;
L0210:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0211:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0212;
if (ctx->cur == p) break;
continue;
L0212:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_getter, &chunk->thunks, NULL)) goto L0209;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0214;
if (ctx->cur == p) break;
continue;
L0214:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semi, &chunk->thunks, NULL)) goto L0215;
goto L0216;
L0215:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0216:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0217;
if (ctx->cur == p) break;
continue;
L0217:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_setter, &chunk->thunks, NULL)) goto L0213;
goto L0218;
L0213:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0218:;
}
goto L0198;
L0209:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0197;
L0198:;
}
goto L0219;
L0197:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0219:;
}
goto L0001;
L0156:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0221;
goto L0222;
L0221:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0222:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0223;
if (ctx->cur == p) break;
continue;
L0223:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 9) < 9 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'y' ||
(ctx->buffer.buf + ctx->cur)[2] != 'p' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'a' ||
(ctx->buffer.buf + ctx->cur)[5] != 'l' ||
(ctx->buffer.buf + ctx->cur)[6] != 'i' ||
(ctx->buffer.buf + ctx->cur)[7] != 'a' ||
(ctx->buffer.buf + ctx->cur)[8] != 's'
) goto L0220;
ctx->cur += 9;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0226;
goto L0225;
L0226:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0227;
goto L0225;
L0227:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0224;
L0225:;
}
ctx->cur = p;
goto L0220;
L0224:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_12, 0, 4);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0230;
goto L0229;
L0230:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0231;
goto L0229;
L0231:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0228;
L0229:;
}
if (ctx->cur == p) break;
continue;
L0228:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
const size_t p = ctx->cur;
size_t q;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0220;
q = ctx->cur;
chunk->capts.buf[3].range.start = p;
chunk->capts.buf[3].range.end = q;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_declaration_13, 0, 4);
thunk->data.leaf.capts.buf[3] = &(chunk->capts.buf[3]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0232;
if (ctx->cur == p) break;
continue;
L0232:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0234;
if (ctx->cur == p) break;
continue;
L0234:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeParameters, &chunk->thunks, NULL)) goto L0233;
goto L0235;
L0233:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0235:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0236;
if (ctx->cur == p) break;
continue;
L0236:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0220;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0237;
ctx->cur++;
ctx->cur = p;
goto L0220;
L0237:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0238;
if (ctx->cur == p) break;
continue;
L0238:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0220;
goto L0001;
L0220:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "declaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "declaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_classBody(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "classBody", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '{'
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classMemberDeclaration, &chunk->thunks, NULL)) goto L0002;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semis, &chunk->thunks, NULL)) goto L0003;
goto L0004;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0004:;
}
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '}'
) goto L0000;
ctx->cur++;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "classBody", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "classBody", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_classParameter(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "classParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
pcc_capture_table__resize(ctx->auxil, &chunk->capts, 1);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0004;
goto L0005;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0005:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'v' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l'
) goto L0003;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0009;
goto L0008;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0010;
goto L0008;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0007;
L0008:;
}
ctx->cur = p;
goto L0003;
L0007:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_classParameter_0, 0, 1);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0012;
goto L0013;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0013:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0014;
if (ctx->cur == p) break;
continue;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'v' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r'
) goto L0011;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0017;
goto L0016;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0018;
goto L0016;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0015;
L0016:;
}
ctx->cur = p;
goto L0011;
L0015:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_classParameter_1, 0, 1);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0002;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0020;
goto L0021;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0021:;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_classParameter_2, 0, 1);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0022;
if (ctx->cur == p) break;
continue;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
L0002:;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0023;
if (ctx->cur == p) break;
continue;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
const size_t p = ctx->cur;
size_t q;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0000;
q = ctx->cur;
chunk->capts.buf[0].range.start = p;
chunk->capts.buf[0].range.end = q;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_classParameter_3, 0, 1);
thunk->data.leaf.capts.buf[0] = &(chunk->capts.buf[0]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0024;
if (ctx->cur == p) break;
continue;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0025;
if (ctx->cur == p) break;
continue;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0000;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0027;
if (ctx->cur == p) break;
continue;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0026;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0028;
ctx->cur++;
ctx->cur = p;
goto L0026;
L0028:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0029;
if (ctx->cur == p) break;
continue;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0026;
goto L0030;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0030:;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_classParameter_4, 0, 1);
thunk->data.leaf.capts.buf[0] = &(chunk->capts.buf[0]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "classParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "classParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_annotatedDelegationSpecifier(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "annotatedDelegationSpecifier", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0004;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0004;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0008;
goto L0007;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_functionType, &chunk->thunks, NULL)) goto L0009;
goto L0007;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0006;
L0007:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'b' ||
(ctx->buffer.buf + ctx->cur)[1] != 'y'
) goto L0006;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0013;
goto L0012;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0014;
goto L0012;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0011;
L0012:;
}
ctx->cur = p;
goto L0006;
L0011:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0015;
if (ctx->cur == p) break;
continue;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0006;
goto L0003;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0016;
goto L0003;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_functionType, &chunk->thunks, NULL)) goto L0017;
goto L0003;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0003:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "annotatedDelegationSpecifier", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "annotatedDelegationSpecifier", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_typeParameters(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "typeParameters", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '<'
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeParameter, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0002;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeParameter, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0005;
ctx->cur++;
goto L0007;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0007:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '>'
) goto L0000;
ctx->cur++;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "typeParameters", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "typeParameters", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_typeParameter(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "typeParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'r' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 'f' ||
(ctx->buffer.buf + ctx->cur)[4] != 'i' ||
(ctx->buffer.buf + ctx->cur)[5] != 'e' ||
(ctx->buffer.buf + ctx->cur)[6] != 'd'
) goto L0003;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0006;
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0007;
goto L0005;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0004;
L0005:;
}
ctx->cur = p;
goto L0003;
L0004:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IN, &chunk->thunks, NULL)) goto L0011;
goto L0010;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 't'
) goto L0012;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0015;
goto L0014;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0016;
goto L0014;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0013;
L0014:;
}
ctx->cur = p;
goto L0012;
L0013:;
ctx->cur = p;
}
goto L0010;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0009;
L0010:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0002;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0018;
goto L0002;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0000;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0021;
if (ctx->cur == p) break;
continue;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0020;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0022;
if (ctx->cur == p) break;
continue;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0020;
goto L0023;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0023:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "typeParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "typeParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_typeConstraints(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "typeConstraints", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'w' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'e' ||
(ctx->buffer.buf + ctx->cur)[3] != 'r' ||
(ctx->buffer.buf + ctx->cur)[4] != 'e'
) goto L0000;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0004;
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
ctx->cur = p;
goto L0000;
L0001:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0009;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0009;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0013;
if (ctx->cur == p) break;
continue;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0009;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0014;
if (ctx->cur == p) break;
continue;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "typeConstraints", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "typeConstraints", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_classMemberDeclaration(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "classMemberDeclaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
pcc_capture_table__resize(ctx->auxil, &chunk->capts, 1);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0003;
goto L0004;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0004:;
}
if (
pcc_refill_buffer(ctx, 11) < 11 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 't' ||
(ctx->buffer.buf + ctx->cur)[5] != 'r' ||
(ctx->buffer.buf + ctx->cur)[6] != 'u' ||
(ctx->buffer.buf + ctx->cur)[7] != 'c' ||
(ctx->buffer.buf + ctx->cur)[8] != 't' ||
(ctx->buffer.buf + ctx->cur)[9] != 'o' ||
(ctx->buffer.buf + ctx->cur)[10] != 'r'
) goto L0002;
ctx->cur += 11;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0007;
goto L0006;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0008;
goto L0006;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0005;
L0006:;
}
ctx->cur = p;
goto L0002;
L0005:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_functionValueParameters, &chunk->thunks, NULL)) goto L0002;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0010;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 's'
) goto L0014;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0017;
goto L0016;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0018;
goto L0016;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0015;
L0016:;
}
ctx->cur = p;
goto L0014;
L0015:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0014;
goto L0013;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 's' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'p' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r'
) goto L0020;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0023;
goto L0022;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0024;
goto L0022;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0021;
L0022:;
}
ctx->cur = p;
goto L0020;
L0021:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0025;
if (ctx->cur == p) break;
continue;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0020;
goto L0013;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0010;
L0013:;
}
goto L0026;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0026:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0027;
if (ctx->cur == p) break;
continue;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0028;
goto L0029;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0029:;
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'n' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 't'
) goto L0030;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0033;
goto L0032;
L0033:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0034;
goto L0032;
L0034:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0031;
L0032:;
}
ctx->cur = p;
goto L0030;
L0031:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0035;
if (ctx->cur == p) break;
continue;
L0035:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0030;
goto L0001;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0037;
goto L0038;
L0037:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0038:;
}
if (
pcc_refill_buffer(ctx, 9) < 9 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'm' ||
(ctx->buffer.buf + ctx->cur)[3] != 'p' ||
(ctx->buffer.buf + ctx->cur)[4] != 'a' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n' ||
(ctx->buffer.buf + ctx->cur)[6] != 'i' ||
(ctx->buffer.buf + ctx->cur)[7] != 'o' ||
(ctx->buffer.buf + ctx->cur)[8] != 'n'
) goto L0036;
ctx->cur += 9;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0041;
goto L0040;
L0041:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0042;
goto L0040;
L0042:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0039;
L0040:;
}
ctx->cur = p;
goto L0036;
L0039:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0043;
if (ctx->cur == p) break;
continue;
L0043:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a'
) goto L0044;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0047;
goto L0046;
L0047:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0048;
goto L0046;
L0048:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0045;
L0046:;
}
ctx->cur = p;
goto L0044;
L0045:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0049;
if (ctx->cur == p) break;
continue;
L0049:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0050;
L0044:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0050:;
}
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'b' ||
(ctx->buffer.buf + ctx->cur)[2] != 'j' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'c' ||
(ctx->buffer.buf + ctx->cur)[5] != 't'
) goto L0036;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0053;
goto L0052;
L0053:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0054;
goto L0052;
L0054:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0051;
L0052:;
}
ctx->cur = p;
goto L0036;
L0051:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_classMemberDeclaration_0, 0, 1);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
const size_t p = ctx->cur;
size_t q;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0056;
if (ctx->cur == p) break;
continue;
L0056:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0055;
goto L0057;
L0055:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0057:;
}
q = ctx->cur;
chunk->capts.buf[0].range.start = p;
chunk->capts.buf[0].range.end = q;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_classMemberDeclaration_1, 0, 1);
thunk->data.leaf.capts.buf[0] = &(chunk->capts.buf[0]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0059;
if (ctx->cur == p) break;
continue;
L0059:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0058;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0060;
if (ctx->cur == p) break;
continue;
L0060:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotatedDelegationSpecifier, &chunk->thunks, NULL)) goto L0058;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0062;
if (ctx->cur == p) break;
continue;
L0062:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0061;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0063;
if (ctx->cur == p) break;
continue;
L0063:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotatedDelegationSpecifier, &chunk->thunks, NULL)) goto L0061;
if (ctx->cur == p) break;
continue;
L0061:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0064;
L0058:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0064:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0066;
if (ctx->cur == p) break;
continue;
L0066:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classBody, &chunk->thunks, NULL)) goto L0065;
goto L0067;
L0065:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0067:;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_classMemberDeclaration_2, 0, 1);
thunk->data.leaf.capts.buf[0] = &(chunk->capts.buf[0]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0001;
L0036:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_declaration, &chunk->thunks, NULL)) goto L0068;
goto L0001;
L0068:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "classMemberDeclaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "classMemberDeclaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_functionValueParameters(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "functionValueParameters", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_functionValueParameter, &chunk->thunks, NULL)) goto L0002;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0003;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_functionValueParameter, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0006;
ctx->cur++;
goto L0008;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0008:;
}
goto L0009;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0009:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0000;
ctx->cur++;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "functionValueParameters", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "functionValueParameters", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_functionValueParameter(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "functionValueParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'v' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'g'
) goto L0004;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0007;
goto L0006;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0008;
goto L0006;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0005;
L0006:;
}
ctx->cur = p;
goto L0004;
L0005:;
ctx->cur = p;
}
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'n' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 'n' ||
(ctx->buffer.buf + ctx->cur)[4] != 'l' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'n' ||
(ctx->buffer.buf + ctx->cur)[7] != 'e'
) goto L0009;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0012;
goto L0011;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0013;
goto L0011;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0010;
L0011:;
}
ctx->cur = p;
goto L0009;
L0010:;
ctx->cur = p;
}
goto L0002;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 11) < 11 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'o' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 's' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'n' ||
(ctx->buffer.buf + ctx->cur)[7] != 'l' ||
(ctx->buffer.buf + ctx->cur)[8] != 'i' ||
(ctx->buffer.buf + ctx->cur)[9] != 'n' ||
(ctx->buffer.buf + ctx->cur)[10] != 'e'
) goto L0014;
ctx->cur += 11;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0017;
goto L0016;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0018;
goto L0016;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0015;
L0016:;
}
ctx->cur = p;
goto L0014;
L0015:;
ctx->cur = p;
}
goto L0002;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0020;
if (ctx->cur == p) break;
continue;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0021;
if (ctx->cur == p) break;
continue;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0000;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0023;
if (ctx->cur == p) break;
continue;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0022;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0024;
ctx->cur++;
ctx->cur = p;
goto L0022;
L0024:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0025;
if (ctx->cur == p) break;
continue;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0022;
goto L0026;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0026:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "functionValueParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "functionValueParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_variableDeclaration(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "variableDeclaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
pcc_capture_table__resize(ctx->auxil, &chunk->capts, 1);
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
const size_t p = ctx->cur;
size_t q;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0000;
q = ctx->cur;
chunk->capts.buf[0].range.start = p;
chunk->capts.buf[0].range.end = q;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_variableDeclaration_0, 0, 1);
thunk->data.leaf.capts.buf[0] = &(chunk->capts.buf[0]);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0003;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0003;
goto L0006;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0006:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "variableDeclaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "variableDeclaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_multiVariableDeclaration(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "multiVariableDeclaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_variableDeclaration, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0003;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_variableDeclaration, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0007;
ctx->cur++;
goto L0009;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0009:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0000;
ctx->cur++;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "multiVariableDeclaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "multiVariableDeclaration", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_getter(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "getter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0003;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0005;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0005:;
}
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'g' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 't'
) goto L0002;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0008;
goto L0007;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0009;
goto L0007;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0006;
L0007:;
}
ctx->cur = p;
goto L0002;
L0006:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0002;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0002;
ctx->cur++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0013;
if (ctx->cur == p) break;
continue;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0012;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0014;
if (ctx->cur == p) break;
continue;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0012;
goto L0015;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0015:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0016;
if (ctx->cur == p) break;
continue;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0018;
goto L0017;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0019;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0020;
ctx->cur++;
ctx->cur = p;
goto L0019;
L0020:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0021;
if (ctx->cur == p) break;
continue;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0019;
goto L0017;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0017:;
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0023;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0024;
if (ctx->cur == p) break;
continue;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0025;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0025:;
}
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'g' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 't'
) goto L0022;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0028;
goto L0027;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0029;
goto L0027;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0026;
L0027:;
}
ctx->cur = p;
goto L0022;
L0026:;
ctx->cur = p;
}
{
const size_t p = ctx->cur;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0031;
if (ctx->cur == p) break;
continue;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0030;
if (
u == 0x00000a ||
u == 0x00000d ||
u == 0x00003b
) goto L0030;
ctx->cur += n;
}
ctx->cur = p;
goto L0022;
L0030:;
ctx->cur = p;
}
goto L0001;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "getter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "getter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_setter(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "setter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0003;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0005;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0005:;
}
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 's' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 't'
) goto L0002;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0008;
goto L0007;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0009;
goto L0007;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0006;
L0007:;
}
ctx->cur = p;
goto L0002;
L0006:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0002;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_parameterWithOptionalType, &chunk->thunks, NULL)) goto L0002;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0013;
if (ctx->cur == p) break;
continue;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0012;
ctx->cur++;
goto L0014;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0014:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0015;
if (ctx->cur == p) break;
continue;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0002;
ctx->cur++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0016;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0018;
if (ctx->cur == p) break;
continue;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0016;
goto L0019;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0019:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0020;
if (ctx->cur == p) break;
continue;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0022;
goto L0021;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0023;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0024;
ctx->cur++;
ctx->cur = p;
goto L0023;
L0024:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0025;
if (ctx->cur == p) break;
continue;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0023;
goto L0021;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0021:;
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_modifiers, &chunk->thunks, NULL)) goto L0027;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0028;
if (ctx->cur == p) break;
continue;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0029;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0029:;
}
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 's' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 't'
) goto L0026;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0032;
goto L0031;
L0032:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0033;
goto L0031;
L0033:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0030;
L0031:;
}
ctx->cur = p;
goto L0026;
L0030:;
ctx->cur = p;
}
{
const size_t p = ctx->cur;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0035;
if (ctx->cur == p) break;
continue;
L0035:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0034;
if (
u == 0x00000a ||
u == 0x00000d ||
u == 0x00003b
) goto L0034;
ctx->cur += n;
}
ctx->cur = p;
goto L0026;
L0034:;
ctx->cur = p;
}
goto L0001;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "setter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "setter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_parameterWithOptionalType(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "parameterWithOptionalType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'v' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'g'
) goto L0004;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0007;
goto L0006;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0008;
goto L0006;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0005;
L0006:;
}
ctx->cur = p;
goto L0004;
L0005:;
ctx->cur = p;
}
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'n' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 'n' ||
(ctx->buffer.buf + ctx->cur)[4] != 'l' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'n' ||
(ctx->buffer.buf + ctx->cur)[7] != 'e'
) goto L0009;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0012;
goto L0011;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0013;
goto L0011;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0010;
L0011:;
}
ctx->cur = p;
goto L0009;
L0010:;
ctx->cur = p;
}
goto L0002;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 11) < 11 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'o' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 's' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'n' ||
(ctx->buffer.buf + ctx->cur)[7] != 'l' ||
(ctx->buffer.buf + ctx->cur)[8] != 'i' ||
(ctx->buffer.buf + ctx->cur)[9] != 'n' ||
(ctx->buffer.buf + ctx->cur)[10] != 'e'
) goto L0014;
ctx->cur += 11;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0017;
goto L0016;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0018;
goto L0016;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0015;
L0016:;
}
ctx->cur = p;
goto L0014;
L0015:;
ctx->cur = p;
}
goto L0002;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0020;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0021;
if (ctx->cur == p) break;
continue;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0020;
goto L0022;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0022:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "parameterWithOptionalType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "parameterWithOptionalType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_type(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "type", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SUSPEND, &chunk->thunks, NULL)) goto L0004;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_functionType, &chunk->thunks, NULL)) goto L0007;
goto L0006;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_nullableType, &chunk->thunks, NULL)) goto L0008;
goto L0006;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0009;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0009;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0009;
ctx->cur++;
goto L0006;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0012;
goto L0006;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'y' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'm' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'c'
) goto L0013;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0016;
goto L0015;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0017;
goto L0015;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0014;
L0015:;
}
ctx->cur = p;
goto L0013;
L0014:;
ctx->cur = p;
}
goto L0006;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0006:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "type", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "type", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_nullableType(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "nullableType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0002;
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'y' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'm' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'c'
) goto L0003;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0006;
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0007;
goto L0005;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0004;
L0005:;
}
ctx->cur = p;
goto L0003;
L0004:;
ctx->cur = p;
}
goto L0001;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0008;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0008;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0008;
ctx->cur++;
goto L0001;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '?' ||
(ctx->buffer.buf + ctx->cur)[1] != ':'
) goto L0013;
ctx->cur += 2;
ctx->cur = p;
goto L0012;
L0013:;
ctx->cur = p;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '?'
) goto L0015;
ctx->cur++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Hidden, &chunk->thunks, NULL)) goto L0015;
goto L0014;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '?'
) goto L0016;
ctx->cur++;
goto L0014;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0012;
L0014:;
}
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0000;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "nullableType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "nullableType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_userType(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "userType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0000;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeArguments, &chunk->thunks, NULL)) goto L0001;
goto L0003;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0003:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0004;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0004;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeArguments, &chunk->thunks, NULL)) goto L0007;
goto L0009;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0009:;
}
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "userType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "userType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_functionType(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "functionType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_receiverType, &chunk->thunks, NULL)) goto L0001;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0001;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0004;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0004:;
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0008;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0008;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0008;
goto L0007;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0011;
goto L0007;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0006;
L0007:;
}
goto L0012;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0012:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0013;
if (ctx->cur == p) break;
continue;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0015;
if (ctx->cur == p) break;
continue;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0014;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0016;
if (ctx->cur == p) break;
continue;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0018;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0018;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0020;
if (ctx->cur == p) break;
continue;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0018;
goto L0017;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0021;
goto L0017;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0014;
L0017:;
}
if (ctx->cur == p) break;
continue;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0022;
if (ctx->cur == p) break;
continue;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0024;
if (ctx->cur == p) break;
continue;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0023;
ctx->cur++;
goto L0025;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0025:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0026;
if (ctx->cur == p) break;
continue;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0027;
if (ctx->cur == p) break;
continue;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '-' ||
(ctx->buffer.buf + ctx->cur)[1] != '>'
) goto L0000;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0028;
if (ctx->cur == p) break;
continue;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0000;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "functionType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "functionType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_receiverType(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "receiverType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0004;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SUSPEND, &chunk->thunks, NULL)) goto L0005;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0003:;
}
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0001;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0008;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0008:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_nullableType, &chunk->thunks, NULL)) goto L0010;
goto L0009;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0011;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0011;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0013;
if (ctx->cur == p) break;
continue;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0011;
ctx->cur++;
goto L0009;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0014;
goto L0009;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'y' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'm' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'c'
) goto L0015;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0018;
goto L0017;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0019;
goto L0017;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0016;
L0017:;
}
ctx->cur = p;
goto L0015;
L0016:;
ctx->cur = p;
}
goto L0009;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0009:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "receiverType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "receiverType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_receiverTypeAndDot(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "receiverTypeAndDot", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0004;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SUSPEND, &chunk->thunks, NULL)) goto L0005;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0003:;
}
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0001;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0008;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0008:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_nullableType, &chunk->thunks, NULL)) goto L0010;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0010;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0009;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0013;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0014;
if (ctx->cur == p) break;
continue;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0013;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0015;
if (ctx->cur == p) break;
continue;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0013;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0016;
if (ctx->cur == p) break;
continue;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0013;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0009;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0019;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0021;
if (ctx->cur == p) break;
continue;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeArguments, &chunk->thunks, NULL)) goto L0020;
goto L0022;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0022:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0023;
if (ctx->cur == p) break;
continue;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0019;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0024;
if (ctx->cur == p) break;
continue;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0018;
}
}
goto L0009;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0009:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "receiverTypeAndDot", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "receiverTypeAndDot", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_statements(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "statements", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0001;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semis, &chunk->thunks, NULL)) goto L0003;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0003;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0006;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0006:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semis, &chunk->thunks, NULL)) goto L0008;
goto L0009;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0009:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "statements", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_statement(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "statement", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_label, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0004;
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_declaration, &chunk->thunks, NULL)) goto L0006;
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_postfixUnaryExpression, &chunk->thunks, NULL)) goto L0009;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_navigationSuffix, &chunk->thunks, NULL)) goto L0012;
goto L0011;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeArguments, &chunk->thunks, NULL)) goto L0013;
goto L0011;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_indexingSuffix, &chunk->thunks, NULL)) goto L0014;
goto L0011;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0009;
L0011:;
}
goto L0008;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_postfixUnaryExpression, &chunk->thunks, NULL)) goto L0015;
goto L0008;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0016;
goto L0008;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_parenthesizedDirectlyAssignableExpression, &chunk->thunks, NULL)) goto L0017;
goto L0008;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0007;
L0008:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0018;
if (ctx->cur == p) break;
continue;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0007;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0019;
ctx->cur++;
ctx->cur = p;
goto L0007;
L0019:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0020;
if (ctx->cur == p) break;
continue;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0007;
goto L0005;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0026;
goto L0025;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_label, &chunk->thunks, NULL)) goto L0027;
goto L0025;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_prefixUnaryOperator, &chunk->thunks, NULL)) goto L0028;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0029;
if (ctx->cur == p) break;
continue;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0025;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0024;
L0025:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0030;
if (ctx->cur == p) break;
continue;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_postfixUnaryExpression, &chunk->thunks, NULL)) goto L0023;
goto L0022;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_parenthesizedAssignableExpression, &chunk->thunks, NULL)) goto L0031;
goto L0022;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0021;
L0022:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0032;
if (ctx->cur == p) break;
continue;
L0032:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '+' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0034;
ctx->cur += 2;
goto L0033;
L0034:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '-' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0035;
ctx->cur += 2;
goto L0033;
L0035:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '*' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0036;
ctx->cur += 2;
goto L0033;
L0036:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '/' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0037;
ctx->cur += 2;
goto L0033;
L0037:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '%' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0038;
ctx->cur += 2;
goto L0033;
L0038:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0021;
L0033:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0039;
if (ctx->cur == p) break;
continue;
L0039:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0021;
goto L0005;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r'
) goto L0040;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0043;
goto L0042;
L0043:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0044;
goto L0042;
L0044:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0041;
L0042:;
}
ctx->cur = p;
goto L0040;
L0041:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0045;
if (ctx->cur == p) break;
continue;
L0045:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0040;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0046;
if (ctx->cur == p) break;
continue;
L0046:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0047;
if (ctx->cur == p) break;
continue;
L0047:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0048;
if (ctx->cur == p) break;
continue;
L0048:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_variableDeclaration, &chunk->thunks, NULL)) goto L0050;
goto L0049;
L0050:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_multiVariableDeclaration, &chunk->thunks, NULL)) goto L0051;
goto L0049;
L0051:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0040;
L0049:;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0040;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IN, &chunk->thunks, NULL)) goto L0040;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0040;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_expression, &chunk->thunks, NULL)) goto L0040;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0052;
if (ctx->cur == p) break;
continue;
L0052:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0040;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0053;
if (ctx->cur == p) break;
continue;
L0053:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0056;
goto L0055;
L0056:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0057;
goto L0055;
L0057:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0054;
L0055:;
}
goto L0058;
L0054:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0058:;
}
goto L0005;
L0040:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'w' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 'l' ||
(ctx->buffer.buf + ctx->cur)[4] != 'e'
) goto L0059;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0062;
goto L0061;
L0062:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0063;
goto L0061;
L0063:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0060;
L0061:;
}
ctx->cur = p;
goto L0059;
L0060:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0064;
if (ctx->cur == p) break;
continue;
L0064:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0059;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0065;
if (ctx->cur == p) break;
continue;
L0065:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_expression, &chunk->thunks, NULL)) goto L0059;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0066;
if (ctx->cur == p) break;
continue;
L0066:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0059;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0067;
if (ctx->cur == p) break;
continue;
L0067:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0069;
goto L0068;
L0069:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0070;
goto L0068;
L0070:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0059;
L0068:;
}
goto L0005;
L0059:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'w' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 'l' ||
(ctx->buffer.buf + ctx->cur)[4] != 'e'
) goto L0071;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0074;
goto L0073;
L0074:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0075;
goto L0073;
L0075:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0072;
L0073:;
}
ctx->cur = p;
goto L0071;
L0072:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0076;
if (ctx->cur == p) break;
continue;
L0076:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0071;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0077;
if (ctx->cur == p) break;
continue;
L0077:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0071;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0078;
if (ctx->cur == p) break;
continue;
L0078:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0071;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0079;
if (ctx->cur == p) break;
continue;
L0079:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ';'
) goto L0071;
ctx->cur++;
goto L0005;
L0071:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o'
) goto L0080;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0083;
goto L0082;
L0083:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0084;
goto L0082;
L0084:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0081;
L0082:;
}
ctx->cur = p;
goto L0080;
L0081:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0085;
if (ctx->cur == p) break;
continue;
L0085:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0088;
goto L0087;
L0088:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0089;
goto L0087;
L0089:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0086;
L0087:;
}
goto L0090;
L0086:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0090:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0091;
if (ctx->cur == p) break;
continue;
L0091:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'w' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 'l' ||
(ctx->buffer.buf + ctx->cur)[4] != 'e'
) goto L0080;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0094;
goto L0093;
L0094:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0095;
goto L0093;
L0095:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0092;
L0093:;
}
ctx->cur = p;
goto L0080;
L0092:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0096;
if (ctx->cur == p) break;
continue;
L0096:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0080;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0097;
if (ctx->cur == p) break;
continue;
L0097:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0080;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0098;
if (ctx->cur == p) break;
continue;
L0098:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0080;
ctx->cur++;
goto L0005;
L0080:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0099;
goto L0005;
L0099:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0005:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "statement", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "statement", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_label(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "label", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0000;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0002;
ctx->cur++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Hidden, &chunk->thunks, NULL)) goto L0004;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0005;
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0003:;
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0006;
ctx->cur++;
goto L0001;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "label", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "label", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_block(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "block", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '{'
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statements, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '}'
) goto L0000;
ctx->cur++;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "block", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "block", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_semi(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "semi", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ';'
) goto L0003;
ctx->cur++;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0004;
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0002:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "semi", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "semi", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_semis(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "semis", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ';'
) goto L0004;
ctx->cur++;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0005;
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0003:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0000;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "semis", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "semis", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_expression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "expression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_equality, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '&' ||
(ctx->buffer.buf + ctx->cur)[1] != '&'
) goto L0001;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_equality, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '|' ||
(ctx->buffer.buf + ctx->cur)[1] != '|'
) goto L0004;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_equality, &chunk->thunks, NULL)) goto L0004;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '&' ||
(ctx->buffer.buf + ctx->cur)[1] != '&'
) goto L0007;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_equality, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "expression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "expression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_equality(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "equality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_genericCallLikeComparison, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '<' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0004;
ctx->cur += 2;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '>' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0005;
ctx->cur += 2;
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '<'
) goto L0006;
ctx->cur++;
goto L0003;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '>'
) goto L0007;
ctx->cur++;
goto L0003;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0003:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_genericCallLikeComparison, &chunk->thunks, NULL)) goto L0001;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '=' ||
(ctx->buffer.buf + ctx->cur)[1] != '=' ||
(ctx->buffer.buf + ctx->cur)[2] != '='
) goto L0013;
ctx->cur += 3;
goto L0012;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '=' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0014;
ctx->cur += 2;
goto L0012;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '!' ||
(ctx->buffer.buf + ctx->cur)[1] != '=' ||
(ctx->buffer.buf + ctx->cur)[2] != '='
) goto L0015;
ctx->cur += 3;
goto L0012;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '!' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0016;
ctx->cur += 2;
goto L0012;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0010;
L0012:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_genericCallLikeComparison, &chunk->thunks, NULL)) goto L0010;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '<' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0021;
ctx->cur += 2;
goto L0020;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '>' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0022;
ctx->cur += 2;
goto L0020;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '<'
) goto L0023;
ctx->cur++;
goto L0020;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '>'
) goto L0024;
ctx->cur++;
goto L0020;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0018;
L0020:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0025;
if (ctx->cur == p) break;
continue;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_genericCallLikeComparison, &chunk->thunks, NULL)) goto L0018;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0026;
if (ctx->cur == p) break;
continue;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0027;
if (ctx->cur == p) break;
continue;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "equality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "equality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_genericCallLikeComparison(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "genericCallLikeComparison", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_elvisExpression, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IN, &chunk->thunks, NULL)) goto L0006;
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '!' ||
(ctx->buffer.buf + ctx->cur)[1] != 'i' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n'
) goto L0007;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0010;
goto L0009;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0011;
goto L0009;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0008;
L0009:;
}
ctx->cur = p;
goto L0007;
L0008:;
ctx->cur = p;
}
goto L0005;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0003;
L0005:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_elvisExpression, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0014;
if (ctx->cur == p) break;
continue;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_isOperator, &chunk->thunks, NULL)) goto L0013;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0015;
if (ctx->cur == p) break;
continue;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0013;
goto L0002;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_callSuffix, &chunk->thunks, NULL)) goto L0016;
if (ctx->cur == p) break;
continue;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "genericCallLikeComparison", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "genericCallLikeComparison", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_elvisExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "elvisExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_rangeExpression, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0001;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_rangeExpression, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '?' ||
(ctx->buffer.buf + ctx->cur)[1] != ':'
) goto L0004;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_rangeExpression, &chunk->thunks, NULL)) goto L0004;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0007;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_rangeExpression, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "elvisExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "elvisExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_rangeExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "rangeExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_multiplicativeExpression, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '+'
) goto L0004;
ctx->cur++;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '-'
) goto L0005;
ctx->cur++;
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0003:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_multiplicativeExpression, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '.' ||
(ctx->buffer.buf + ctx->cur)[1] != '.' ||
(ctx->buffer.buf + ctx->cur)[2] != '<'
) goto L0010;
ctx->cur += 3;
goto L0009;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '.' ||
(ctx->buffer.buf + ctx->cur)[1] != '.'
) goto L0011;
ctx->cur += 2;
goto L0009;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0007;
L0009:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_multiplicativeExpression, &chunk->thunks, NULL)) goto L0007;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0014;
if (ctx->cur == p) break;
continue;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '+'
) goto L0016;
ctx->cur++;
goto L0015;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '-'
) goto L0017;
ctx->cur++;
goto L0015;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0013;
L0015:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0018;
if (ctx->cur == p) break;
continue;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_multiplicativeExpression, &chunk->thunks, NULL)) goto L0013;
if (ctx->cur == p) break;
continue;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "rangeExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "rangeExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_multiplicativeExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "multiplicativeExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_asExpression, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '*'
) goto L0004;
ctx->cur++;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '/'
) goto L0005;
ctx->cur++;
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '%'
) goto L0006;
ctx->cur++;
goto L0003;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0003:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_asExpression, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "multiplicativeExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "multiplicativeExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_asExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "asExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_label, &chunk->thunks, NULL)) goto L0004;
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_prefixUnaryOperator, &chunk->thunks, NULL)) goto L0005;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0002;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_postfixUnaryExpression, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 's' ||
(ctx->buffer.buf + ctx->cur)[2] != '?'
) goto L0011;
ctx->cur += 3;
goto L0010;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 's'
) goto L0012;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0015;
goto L0014;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0016;
goto L0014;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0013;
L0014:;
}
ctx->cur = p;
goto L0012;
L0013:;
ctx->cur = p;
}
goto L0010;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0008;
L0010:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "asExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "asExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_postfixUnaryExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "postfixUnaryExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_primaryExpression, &chunk->thunks, NULL)) goto L0002;
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '+' ||
(ctx->buffer.buf + ctx->cur)[1] != '+'
) goto L0006;
ctx->cur += 2;
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '-' ||
(ctx->buffer.buf + ctx->cur)[1] != '-'
) goto L0007;
ctx->cur += 2;
goto L0005;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '!'
) goto L0008;
ctx->cur++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '!'
) goto L0010;
ctx->cur++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Hidden, &chunk->thunks, NULL)) goto L0010;
goto L0009;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '!'
) goto L0011;
ctx->cur++;
goto L0009;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0008;
L0009:;
}
goto L0005;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeArguments, &chunk->thunks, NULL)) goto L0012;
goto L0005;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_callSuffix, &chunk->thunks, NULL)) goto L0013;
goto L0005;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_indexingSuffix, &chunk->thunks, NULL)) goto L0014;
goto L0005;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_navigationSuffix, &chunk->thunks, NULL)) goto L0015;
goto L0005;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0003;
L0005:;
}
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0002;
}
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_primaryExpression, &chunk->thunks, NULL)) goto L0016;
goto L0001;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "postfixUnaryExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "postfixUnaryExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_parenthesizedDirectlyAssignableExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "parenthesizedDirectlyAssignableExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_postfixUnaryExpression, &chunk->thunks, NULL)) goto L0003;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0006;
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0007;
goto L0005;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0004;
L0005:;
}
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_navigationSuffix, &chunk->thunks, NULL)) goto L0009;
goto L0008;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeArguments, &chunk->thunks, NULL)) goto L0010;
goto L0008;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_indexingSuffix, &chunk->thunks, NULL)) goto L0011;
goto L0008;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0003;
L0008:;
}
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_postfixUnaryExpression, &chunk->thunks, NULL)) goto L0012;
goto L0002;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0013;
goto L0002;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_parenthesizedDirectlyAssignableExpression, &chunk->thunks, NULL)) goto L0014;
goto L0002;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0002:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0015;
if (ctx->cur == p) break;
continue;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0000;
ctx->cur++;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "parenthesizedDirectlyAssignableExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "parenthesizedDirectlyAssignableExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_parenthesizedAssignableExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "parenthesizedAssignableExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0006;
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_label, &chunk->thunks, NULL)) goto L0007;
goto L0005;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_prefixUnaryOperator, &chunk->thunks, NULL)) goto L0008;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0005;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0004;
L0005:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0012;
goto L0011;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0013;
goto L0011;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0010;
L0011:;
}
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_postfixUnaryExpression, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_parenthesizedAssignableExpression, &chunk->thunks, NULL)) goto L0014;
goto L0002;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0002:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0015;
if (ctx->cur == p) break;
continue;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0000;
ctx->cur++;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "parenthesizedAssignableExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "parenthesizedAssignableExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_indexingSuffix(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "indexingSuffix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '['
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_expression, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0002;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_expression, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0005;
ctx->cur++;
goto L0007;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0007:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ']'
) goto L0000;
ctx->cur++;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "indexingSuffix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "indexingSuffix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_navigationSuffix(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "navigationSuffix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0003;
ctx->cur++;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '?' ||
(ctx->buffer.buf + ctx->cur)[1] != '.'
) goto L0004;
ctx->cur += 2;
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != ':' ||
(ctx->buffer.buf + ctx->cur)[1] != ':'
) goto L0005;
ctx->cur += 2;
goto L0002;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0002:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0008;
goto L0007;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0009;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_expression, &chunk->thunks, NULL)) goto L0009;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0009;
ctx->cur++;
goto L0007;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'l' ||
(ctx->buffer.buf + ctx->cur)[2] != 'a' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 's'
) goto L0012;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0015;
goto L0014;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0016;
goto L0014;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0013;
L0014:;
}
ctx->cur = p;
goto L0012;
L0013:;
ctx->cur = p;
}
goto L0007;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0007:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "navigationSuffix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "navigationSuffix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_callSuffix(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "callSuffix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeArguments, &chunk->thunks, NULL)) goto L0003;
goto L0004;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0004:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0006;
goto L0007;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0007:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_label, &chunk->thunks, NULL)) goto L0011;
goto L0012;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0012:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0013;
if (ctx->cur == p) break;
continue;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_lambdaLiteral, &chunk->thunks, NULL)) goto L0002;
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeArguments, &chunk->thunks, NULL)) goto L0015;
goto L0016;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0016:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0014;
goto L0001;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "callSuffix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "callSuffix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_typeArguments(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "typeArguments", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '<'
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IN, &chunk->thunks, NULL)) goto L0008;
goto L0007;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 't'
) goto L0009;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0012;
goto L0011;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0013;
goto L0011;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0010;
L0011:;
}
ctx->cur = p;
goto L0009;
L0010:;
ctx->cur = p;
}
goto L0007;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0006;
L0007:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0014;
if (ctx->cur == p) break;
continue;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0015;
goto L0005;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0004;
L0005:;
}
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '*'
) goto L0016;
ctx->cur++;
goto L0002;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0002:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0018;
if (ctx->cur == p) break;
continue;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0017;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IN, &chunk->thunks, NULL)) goto L0026;
goto L0025;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 't'
) goto L0027;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0030;
goto L0029;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0031;
goto L0029;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0028;
L0029:;
}
ctx->cur = p;
goto L0027;
L0028:;
ctx->cur = p;
}
goto L0025;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0024;
L0025:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0032;
if (ctx->cur == p) break;
continue;
L0032:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0023;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0033;
goto L0023;
L0033:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0022;
L0023:;
}
if (ctx->cur == p) break;
continue;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0021;
goto L0020;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '*'
) goto L0034;
ctx->cur++;
goto L0020;
L0034:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0017;
L0020:;
}
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0036;
if (ctx->cur == p) break;
continue;
L0036:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0035;
ctx->cur++;
goto L0037;
L0035:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0037:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0038;
if (ctx->cur == p) break;
continue;
L0038:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '>'
) goto L0000;
ctx->cur++;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "typeArguments", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "typeArguments", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_valueArguments(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "valueArguments", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0002;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0002;
ctx->cur++;
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0004;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0006;
goto L0007;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0007:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0009;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0009;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0011;
ctx->cur++;
ctx->cur = p;
goto L0009;
L0011:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0013;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0013:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '*'
) goto L0014;
ctx->cur++;
goto L0015;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0015:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0016;
if (ctx->cur == p) break;
continue;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_expression, &chunk->thunks, NULL)) goto L0004;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0018;
if (ctx->cur == p) break;
continue;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0017;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0020;
goto L0021;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0021:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0022;
if (ctx->cur == p) break;
continue;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0023;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0024;
if (ctx->cur == p) break;
continue;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0023;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0025;
ctx->cur++;
ctx->cur = p;
goto L0023;
L0025:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0026;
if (ctx->cur == p) break;
continue;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0027;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0027:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '*'
) goto L0028;
ctx->cur++;
goto L0029;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0029:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0030;
if (ctx->cur == p) break;
continue;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_expression, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0032;
if (ctx->cur == p) break;
continue;
L0032:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0031;
ctx->cur++;
goto L0033;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0033:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0034;
if (ctx->cur == p) break;
continue;
L0034:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0004;
ctx->cur++;
goto L0001;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "valueArguments", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "valueArguments", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_primaryExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "primaryExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != '@'
) goto L0002;
ctx->cur += 5;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Identifier, &chunk->thunks, NULL)) goto L0002;
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 's'
) goto L0003;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0006;
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0007;
goto L0005;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0004;
L0005:;
}
ctx->cur = p;
goto L0003;
L0004:;
ctx->cur = p;
}
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0010;
goto L0009;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0011;
goto L0009;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0008;
L0009:;
}
ctx->cur = p;
goto L0003;
L0008:;
ctx->cur = p;
}
goto L0001;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 's' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'p' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != '@'
) goto L0012;
ctx->cur += 6;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Identifier, &chunk->thunks, NULL)) goto L0012;
goto L0001;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 's' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'p' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r'
) goto L0013;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0016;
goto L0015;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0017;
goto L0015;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0014;
L0015:;
}
ctx->cur = p;
goto L0013;
L0014:;
ctx->cur = p;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '<'
) goto L0018;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0018;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0020;
if (ctx->cur == p) break;
continue;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '>'
) goto L0018;
ctx->cur++;
goto L0021;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0021:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0022;
ctx->cur++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0022;
goto L0023;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0023:;
}
goto L0001;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'f'
) goto L0024;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0027;
goto L0026;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0028;
goto L0026;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0025;
L0026:;
}
ctx->cur = p;
goto L0024;
L0025:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0029;
if (ctx->cur == p) break;
continue;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0024;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0030;
if (ctx->cur == p) break;
continue;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0024;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0031;
if (ctx->cur == p) break;
continue;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0024;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0032;
if (ctx->cur == p) break;
continue;
L0032:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0035;
goto L0034;
L0035:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0036;
goto L0034;
L0036:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0033;
L0034:;
}
goto L0037;
L0033:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0037:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0038;
if (ctx->cur == p) break;
continue;
L0038:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ';'
) goto L0039;
ctx->cur++;
goto L0040;
L0039:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0040:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0041;
if (ctx->cur == p) break;
continue;
L0041:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'e' ||
(ctx->buffer.buf + ctx->cur)[1] != 'l' ||
(ctx->buffer.buf + ctx->cur)[2] != 's' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e'
) goto L0024;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0044;
goto L0043;
L0044:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0045;
goto L0043;
L0045:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0042;
L0043:;
}
ctx->cur = p;
goto L0024;
L0042:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0046;
if (ctx->cur == p) break;
continue;
L0046:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0048;
goto L0047;
L0048:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0049;
goto L0047;
L0049:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ';'
) goto L0050;
ctx->cur++;
goto L0047;
L0050:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0024;
L0047:;
}
goto L0001;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'f'
) goto L0051;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0054;
goto L0053;
L0054:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0055;
goto L0053;
L0055:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0052;
L0053:;
}
ctx->cur = p;
goto L0051;
L0052:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0056;
if (ctx->cur == p) break;
continue;
L0056:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0051;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0057;
if (ctx->cur == p) break;
continue;
L0057:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0051;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0058;
if (ctx->cur == p) break;
continue;
L0058:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0051;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0059;
if (ctx->cur == p) break;
continue;
L0059:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0061;
goto L0060;
L0061:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0062;
goto L0060;
L0062:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ';'
) goto L0063;
ctx->cur++;
goto L0060;
L0063:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0051;
L0060:;
}
goto L0001;
L0051:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'w' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'e' ||
(ctx->buffer.buf + ctx->cur)[3] != 'n'
) goto L0064;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0067;
goto L0066;
L0067:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0068;
goto L0066;
L0068:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0065;
L0066:;
}
ctx->cur = p;
goto L0064;
L0065:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0069;
if (ctx->cur == p) break;
continue;
L0069:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0070;
ctx->cur++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0072;
if (ctx->cur == p) break;
continue;
L0072:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0073;
if (ctx->cur == p) break;
continue;
L0073:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'v' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l'
) goto L0071;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0076;
goto L0075;
L0076:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0077;
goto L0075;
L0077:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0074;
L0075:;
}
ctx->cur = p;
goto L0071;
L0074:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0078;
if (ctx->cur == p) break;
continue;
L0078:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_variableDeclaration, &chunk->thunks, NULL)) goto L0071;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0079;
if (ctx->cur == p) break;
continue;
L0079:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0071;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0080;
ctx->cur++;
ctx->cur = p;
goto L0071;
L0080:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0081;
if (ctx->cur == p) break;
continue;
L0081:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0082;
L0071:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0082:;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0070;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0070;
ctx->cur++;
goto L0083;
L0070:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0083:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0084;
if (ctx->cur == p) break;
continue;
L0084:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '{'
) goto L0064;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0085;
if (ctx->cur == p) break;
continue;
L0085:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0090;
goto L0089;
L0090:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IN, &chunk->thunks, NULL)) goto L0093;
goto L0092;
L0093:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '!' ||
(ctx->buffer.buf + ctx->cur)[1] != 'i' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n'
) goto L0094;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0097;
goto L0096;
L0097:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0098;
goto L0096;
L0098:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0095;
L0096:;
}
ctx->cur = p;
goto L0094;
L0095:;
ctx->cur = p;
}
goto L0092;
L0094:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0091;
L0092:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0099;
if (ctx->cur == p) break;
continue;
L0099:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0091;
goto L0089;
L0091:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_isOperator, &chunk->thunks, NULL)) goto L0100;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0101;
if (ctx->cur == p) break;
continue;
L0101:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0100;
goto L0089;
L0100:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0088;
L0089:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0103;
if (ctx->cur == p) break;
continue;
L0103:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0102;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0104;
if (ctx->cur == p) break;
continue;
L0104:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0106;
goto L0105;
L0106:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IN, &chunk->thunks, NULL)) goto L0109;
goto L0108;
L0109:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '!' ||
(ctx->buffer.buf + ctx->cur)[1] != 'i' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n'
) goto L0110;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0113;
goto L0112;
L0113:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0114;
goto L0112;
L0114:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0111;
L0112:;
}
ctx->cur = p;
goto L0110;
L0111:;
ctx->cur = p;
}
goto L0108;
L0110:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0107;
L0108:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0115;
if (ctx->cur == p) break;
continue;
L0115:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0107;
goto L0105;
L0107:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_isOperator, &chunk->thunks, NULL)) goto L0116;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0117;
if (ctx->cur == p) break;
continue;
L0117:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0116;
goto L0105;
L0116:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0102;
L0105:;
}
if (ctx->cur == p) break;
continue;
L0102:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0119;
if (ctx->cur == p) break;
continue;
L0119:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0118;
ctx->cur++;
goto L0120;
L0118:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0120:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0121;
if (ctx->cur == p) break;
continue;
L0121:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '-' ||
(ctx->buffer.buf + ctx->cur)[1] != '>'
) goto L0088;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0122;
if (ctx->cur == p) break;
continue;
L0122:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0124;
goto L0123;
L0124:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0125;
goto L0123;
L0125:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0088;
L0123:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semi, &chunk->thunks, NULL)) goto L0126;
goto L0127;
L0126:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0127:;
}
goto L0087;
L0088:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'e' ||
(ctx->buffer.buf + ctx->cur)[1] != 'l' ||
(ctx->buffer.buf + ctx->cur)[2] != 's' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e'
) goto L0128;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0131;
goto L0130;
L0131:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0132;
goto L0130;
L0132:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0129;
L0130:;
}
ctx->cur = p;
goto L0128;
L0129:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0133;
if (ctx->cur == p) break;
continue;
L0133:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '-' ||
(ctx->buffer.buf + ctx->cur)[1] != '>'
) goto L0128;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0134;
if (ctx->cur == p) break;
continue;
L0134:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0136;
goto L0135;
L0136:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statement, &chunk->thunks, NULL)) goto L0137;
goto L0135;
L0137:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0128;
L0135:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_semi, &chunk->thunks, NULL)) goto L0138;
goto L0139;
L0138:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0139:;
}
goto L0087;
L0128:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0086;
L0087:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0140;
if (ctx->cur == p) break;
continue;
L0140:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0086:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0141;
if (ctx->cur == p) break;
continue;
L0141:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '}'
) goto L0064;
ctx->cur++;
goto L0001;
L0064:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'y'
) goto L0142;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0145;
goto L0144;
L0145:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0146;
goto L0144;
L0146:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0143;
L0144:;
}
ctx->cur = p;
goto L0142;
L0143:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0147;
if (ctx->cur == p) break;
continue;
L0147:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0142;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0151;
if (ctx->cur == p) break;
continue;
L0151:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'c' ||
(ctx->buffer.buf + ctx->cur)[4] != 'h'
) goto L0150;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0154;
goto L0153;
L0154:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0155;
goto L0153;
L0155:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0152;
L0153:;
}
ctx->cur = p;
goto L0150;
L0152:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0156;
if (ctx->cur == p) break;
continue;
L0156:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0150;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0157;
if (ctx->cur == p) break;
continue;
L0157:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0158;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0159;
if (ctx->cur == p) break;
continue;
L0159:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0158:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0150;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0160;
if (ctx->cur == p) break;
continue;
L0160:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0150;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0161;
if (ctx->cur == p) break;
continue;
L0161:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0150;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0163;
if (ctx->cur == p) break;
continue;
L0163:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0162;
ctx->cur++;
goto L0164;
L0162:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0164:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0165;
if (ctx->cur == p) break;
continue;
L0165:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0150;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0166;
if (ctx->cur == p) break;
continue;
L0166:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0150;
if (ctx->cur == p) break;
continue;
L0150:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0149;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0168;
if (ctx->cur == p) break;
continue;
L0168:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'i' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'l' ||
(ctx->buffer.buf + ctx->cur)[5] != 'l' ||
(ctx->buffer.buf + ctx->cur)[6] != 'y'
) goto L0167;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0171;
goto L0170;
L0171:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0172;
goto L0170;
L0172:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0169;
L0170:;
}
ctx->cur = p;
goto L0167;
L0169:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0173;
if (ctx->cur == p) break;
continue;
L0173:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0167;
goto L0174;
L0167:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0174:;
}
goto L0148;
L0149:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0176;
if (ctx->cur == p) break;
continue;
L0176:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'i' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'l' ||
(ctx->buffer.buf + ctx->cur)[5] != 'l' ||
(ctx->buffer.buf + ctx->cur)[6] != 'y'
) goto L0175;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0179;
goto L0178;
L0179:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0180;
goto L0178;
L0180:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0177;
L0178:;
}
ctx->cur = p;
goto L0175;
L0177:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0181;
if (ctx->cur == p) break;
continue;
L0181:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0175;
goto L0148;
L0175:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0142;
L0148:;
}
goto L0001;
L0142:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r' ||
(ctx->buffer.buf + ctx->cur)[3] != 'o' ||
(ctx->buffer.buf + ctx->cur)[4] != 'w'
) goto L0182;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0185;
goto L0184;
L0185:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0186;
goto L0184;
L0186:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0183;
L0184:;
}
ctx->cur = p;
goto L0182;
L0183:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0187;
if (ctx->cur == p) break;
continue;
L0187:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0182;
goto L0001;
L0182:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'r' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'u' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n' ||
(ctx->buffer.buf + ctx->cur)[6] != '@'
) goto L0190;
ctx->cur += 7;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Identifier, &chunk->thunks, NULL)) goto L0190;
goto L0189;
L0190:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'r' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'u' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n'
) goto L0191;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0194;
goto L0193;
L0194:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0195;
goto L0193;
L0195:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0192;
L0193:;
}
ctx->cur = p;
goto L0191;
L0192:;
ctx->cur = p;
}
goto L0189;
L0191:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0188;
L0189:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0196;
if (ctx->cur == p) break;
continue;
L0196:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0197;
goto L0198;
L0197:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0198:;
}
goto L0001;
L0188:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 9) < 9 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 't' ||
(ctx->buffer.buf + ctx->cur)[4] != 'i' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n' ||
(ctx->buffer.buf + ctx->cur)[6] != 'u' ||
(ctx->buffer.buf + ctx->cur)[7] != 'e' ||
(ctx->buffer.buf + ctx->cur)[8] != '@'
) goto L0199;
ctx->cur += 9;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Identifier, &chunk->thunks, NULL)) goto L0199;
goto L0001;
L0199:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 't' ||
(ctx->buffer.buf + ctx->cur)[4] != 'i' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n' ||
(ctx->buffer.buf + ctx->cur)[6] != 'u' ||
(ctx->buffer.buf + ctx->cur)[7] != 'e'
) goto L0200;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0203;
goto L0202;
L0203:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0204;
goto L0202;
L0204:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0201;
L0202:;
}
ctx->cur = p;
goto L0200;
L0201:;
ctx->cur = p;
}
goto L0001;
L0200:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'b' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'e' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'k' ||
(ctx->buffer.buf + ctx->cur)[5] != '@'
) goto L0205;
ctx->cur += 6;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Identifier, &chunk->thunks, NULL)) goto L0205;
goto L0001;
L0205:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'b' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'e' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'k'
) goto L0206;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0209;
goto L0208;
L0209:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0210;
goto L0208;
L0210:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0207;
L0208:;
}
ctx->cur = p;
goto L0206;
L0207:;
ctx->cur = p;
}
goto L0001;
L0206:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0211;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0212;
if (ctx->cur == p) break;
continue;
L0212:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_expression, &chunk->thunks, NULL)) goto L0211;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0213;
if (ctx->cur == p) break;
continue;
L0213:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0211;
ctx->cur++;
goto L0001;
L0211:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_receiverType, &chunk->thunks, NULL)) goto L0215;
goto L0216;
L0215:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0216:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0217;
if (ctx->cur == p) break;
continue;
L0217:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != ':' ||
(ctx->buffer.buf + ctx->cur)[1] != ':'
) goto L0214;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0218;
if (ctx->cur == p) break;
continue;
L0218:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0220;
goto L0219;
L0220:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'l' ||
(ctx->buffer.buf + ctx->cur)[2] != 'a' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 's'
) goto L0221;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0224;
goto L0223;
L0224:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0225;
goto L0223;
L0225:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0222;
L0223:;
}
ctx->cur = p;
goto L0221;
L0222:;
ctx->cur = p;
}
goto L0219;
L0221:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0214;
L0219:;
}
goto L0001;
L0214:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '\"' ||
(ctx->buffer.buf + ctx->cur)[1] != '\"' ||
(ctx->buffer.buf + ctx->cur)[2] != '\"'
) goto L0226;
ctx->cur += 3;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '$' ||
(ctx->buffer.buf + ctx->cur)[1] != '{'
) goto L0229;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0230;
if (ctx->cur == p) break;
continue;
L0230:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0229;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0231;
if (ctx->cur == p) break;
continue;
L0231:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '}'
) goto L0229;
ctx->cur++;
goto L0228;
L0229:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FieldIdentifier, &chunk->thunks, NULL)) goto L0232;
goto L0228;
L0232:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0234;
if (
u == 0x000022 ||
u == 0x000024
) goto L0234;
ctx->cur += n;
}
if (ctx->cur == p) break;
continue;
L0234:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0233;
}
}
goto L0228;
L0233:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '$'
) goto L0235;
ctx->cur++;
goto L0228;
L0235:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '\"' ||
(ctx->buffer.buf + ctx->cur)[1] != '\"'
) goto L0236;
ctx->cur += 2;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\"'
) goto L0237;
ctx->cur++;
ctx->cur = p;
goto L0236;
L0237:;
ctx->cur = p;
}
goto L0228;
L0236:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\"'
) goto L0238;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '\"' ||
(ctx->buffer.buf + ctx->cur)[1] != '\"'
) goto L0239;
ctx->cur += 2;
ctx->cur = p;
goto L0238;
L0239:;
ctx->cur = p;
}
goto L0228;
L0238:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '\"' ||
(ctx->buffer.buf + ctx->cur)[1] != '\"'
) goto L0240;
ctx->cur += 2;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\"'
) goto L0241;
ctx->cur++;
ctx->cur = p;
goto L0240;
L0241:;
ctx->cur = p;
}
goto L0228;
L0240:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\"'
) goto L0242;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '\"' ||
(ctx->buffer.buf + ctx->cur)[1] != '\"'
) goto L0243;
ctx->cur += 2;
ctx->cur = p;
goto L0242;
L0243:;
ctx->cur = p;
}
goto L0228;
L0242:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0227;
L0228:;
}
if (ctx->cur == p) break;
continue;
L0227:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != '\"' ||
(ctx->buffer.buf + ctx->cur)[1] != '\"' ||
(ctx->buffer.buf + ctx->cur)[2] != '\"' ||
(ctx->buffer.buf + ctx->cur)[3] != '\"' ||
(ctx->buffer.buf + ctx->cur)[4] != '\"'
) goto L0245;
ctx->cur += 5;
goto L0244;
L0245:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != '\"' ||
(ctx->buffer.buf + ctx->cur)[1] != '\"' ||
(ctx->buffer.buf + ctx->cur)[2] != '\"' ||
(ctx->buffer.buf + ctx->cur)[3] != '\"'
) goto L0246;
ctx->cur += 4;
goto L0244;
L0246:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '\"' ||
(ctx->buffer.buf + ctx->cur)[1] != '\"' ||
(ctx->buffer.buf + ctx->cur)[2] != '\"'
) goto L0247;
ctx->cur += 3;
goto L0244;
L0247:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0226;
L0244:;
}
goto L0001;
L0226:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\"'
) goto L0248;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '\"' ||
(ctx->buffer.buf + ctx->cur)[1] != '\"'
) goto L0249;
ctx->cur += 2;
ctx->cur = p;
goto L0248;
L0249:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '$' ||
(ctx->buffer.buf + ctx->cur)[1] != '{'
) goto L0252;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0253;
if (ctx->cur == p) break;
continue;
L0253:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0252;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0254;
if (ctx->cur == p) break;
continue;
L0254:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '}'
) goto L0252;
ctx->cur++;
goto L0251;
L0252:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0256;
if (
u == 0x000022 ||
u == 0x000024 ||
u == 0x00005c
) goto L0256;
ctx->cur += n;
}
if (ctx->cur == p) break;
continue;
L0256:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0255;
}
}
goto L0251;
L0255:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '$'
) goto L0257;
ctx->cur++;
goto L0251;
L0257:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\\'
) goto L0258;
ctx->cur++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != 't'
) goto L0260;
ctx->cur++;
goto L0259;
L0260:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != 'b'
) goto L0261;
ctx->cur++;
goto L0259;
L0261:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != 'r'
) goto L0262;
ctx->cur++;
goto L0259;
L0262:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != 'n'
) goto L0263;
ctx->cur++;
goto L0259;
L0263:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\''
) goto L0264;
ctx->cur++;
goto L0259;
L0264:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\"'
) goto L0265;
ctx->cur++;
goto L0259;
L0265:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\\'
) goto L0266;
ctx->cur++;
goto L0259;
L0266:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '$'
) goto L0267;
ctx->cur++;
goto L0259;
L0267:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0258;
L0259:;
}
goto L0251;
L0258:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '\\' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u'
) goto L0268;
ctx->cur += 2;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexDigit, &chunk->thunks, NULL)) goto L0268;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexDigit, &chunk->thunks, NULL)) goto L0268;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexDigit, &chunk->thunks, NULL)) goto L0268;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexDigit, &chunk->thunks, NULL)) goto L0268;
goto L0251;
L0268:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FieldIdentifier, &chunk->thunks, NULL)) goto L0269;
goto L0251;
L0269:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0250;
L0251:;
}
if (ctx->cur == p) break;
continue;
L0250:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\"'
) goto L0248;
ctx->cur++;
goto L0001;
L0248:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_lambdaLiteral, &chunk->thunks, NULL)) goto L0270;
goto L0001;
L0270:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_anonymousFunction, &chunk->thunks, NULL)) goto L0271;
goto L0001;
L0271:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a'
) goto L0273;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0276;
goto L0275;
L0276:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0277;
goto L0275;
L0277:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0274;
L0275:;
}
ctx->cur = p;
goto L0273;
L0274:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0278;
if (ctx->cur == p) break;
continue;
L0278:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0279;
L0273:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0279:;
}
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'b' ||
(ctx->buffer.buf + ctx->cur)[2] != 'j' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'c' ||
(ctx->buffer.buf + ctx->cur)[5] != 't'
) goto L0272;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0282;
goto L0281;
L0282:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0283;
goto L0281;
L0283:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0280;
L0281:;
}
ctx->cur = p;
goto L0272;
L0280:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0284;
if (ctx->cur == p) break;
continue;
L0284:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0272;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0285;
if (ctx->cur == p) break;
continue;
L0285:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotatedDelegationSpecifier, &chunk->thunks, NULL)) goto L0272;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0287;
if (ctx->cur == p) break;
continue;
L0287:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0286;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0288;
if (ctx->cur == p) break;
continue;
L0288:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotatedDelegationSpecifier, &chunk->thunks, NULL)) goto L0286;
if (ctx->cur == p) break;
continue;
L0286:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0289;
if (ctx->cur == p) break;
continue;
L0289:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classBody, &chunk->thunks, NULL)) goto L0272;
goto L0001;
L0272:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'b' ||
(ctx->buffer.buf + ctx->cur)[2] != 'j' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'c' ||
(ctx->buffer.buf + ctx->cur)[5] != 't'
) goto L0290;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0293;
goto L0292;
L0293:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0294;
goto L0292;
L0294:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0291;
L0292:;
}
ctx->cur = p;
goto L0290;
L0291:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0295;
if (ctx->cur == p) break;
continue;
L0295:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_classBody, &chunk->thunks, NULL)) goto L0290;
goto L0001;
L0290:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '['
) goto L0296;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0297;
if (ctx->cur == p) break;
continue;
L0297:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_expression, &chunk->thunks, NULL)) goto L0296;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0299;
if (ctx->cur == p) break;
continue;
L0299:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0298;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0300;
if (ctx->cur == p) break;
continue;
L0300:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_expression, &chunk->thunks, NULL)) goto L0298;
if (ctx->cur == p) break;
continue;
L0298:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0302;
if (ctx->cur == p) break;
continue;
L0302:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0301;
ctx->cur++;
goto L0303;
L0301:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0303:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0304;
if (ctx->cur == p) break;
continue;
L0304:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ']'
) goto L0296;
ctx->cur++;
goto L0001;
L0296:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '['
) goto L0305;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0306;
if (ctx->cur == p) break;
continue;
L0306:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ']'
) goto L0305;
ctx->cur++;
goto L0001;
L0305:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0307;
goto L0001;
L0307:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'u' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e'
) goto L0308;
ctx->cur += 4;
goto L0001;
L0308:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 'e'
) goto L0309;
ctx->cur += 5;
goto L0001;
L0309:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\''
) goto L0310;
ctx->cur++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '\\' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u'
) goto L0312;
ctx->cur += 2;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexDigit, &chunk->thunks, NULL)) goto L0312;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexDigit, &chunk->thunks, NULL)) goto L0312;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexDigit, &chunk->thunks, NULL)) goto L0312;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexDigit, &chunk->thunks, NULL)) goto L0312;
goto L0311;
L0312:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\\'
) goto L0313;
ctx->cur++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != 't'
) goto L0315;
ctx->cur++;
goto L0314;
L0315:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != 'b'
) goto L0316;
ctx->cur++;
goto L0314;
L0316:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != 'r'
) goto L0317;
ctx->cur++;
goto L0314;
L0317:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != 'n'
) goto L0318;
ctx->cur++;
goto L0314;
L0318:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\''
) goto L0319;
ctx->cur++;
goto L0314;
L0319:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\"'
) goto L0320;
ctx->cur++;
goto L0314;
L0320:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\\'
) goto L0321;
ctx->cur++;
goto L0314;
L0321:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '$'
) goto L0322;
ctx->cur++;
goto L0314;
L0322:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0313;
L0314:;
}
goto L0311;
L0313:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0323;
if (
u == 0x00000a ||
u == 0x00000d ||
u == 0x000027 ||
u == 0x00005c
) goto L0323;
ctx->cur += n;
}
goto L0311;
L0323:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0310;
L0311:;
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '\''
) goto L0310;
ctx->cur++;
goto L0001;
L0310:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'n' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l' ||
(ctx->buffer.buf + ctx->cur)[3] != 'l'
) goto L0324;
ctx->cur += 4;
goto L0001;
L0324:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0328;
goto L0329;
L0328:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0329:;
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0327;
ctx->cur++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0327;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0330;
if (!(
u == 0x000045 ||
u == 0x000065
)) goto L0330;
ctx->cur += n;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0331;
if (!(
u == 0x00002d ||
u == 0x00002b
)) goto L0331;
ctx->cur += n;
}
goto L0332;
L0331:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0332:;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0330;
goto L0333;
L0330:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0333:;
}
goto L0326;
L0327:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0334;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0334;
if (!(
u == 0x000045 ||
u == 0x000065
)) goto L0334;
ctx->cur += n;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0335;
if (!(
u == 0x00002d ||
u == 0x00002b
)) goto L0335;
ctx->cur += n;
}
goto L0336;
L0335:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0336:;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0334;
goto L0326;
L0334:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0325;
L0326:;
}
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0325;
if (!(
u == 0x000046 ||
u == 0x000066
)) goto L0325;
ctx->cur += n;
}
goto L0001;
L0325:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0337;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0337;
if (!(
u == 0x000046 ||
u == 0x000066
)) goto L0337;
ctx->cur += n;
}
goto L0001;
L0337:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0339;
goto L0340;
L0339:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0340:;
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0338;
ctx->cur++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0338;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0341;
if (!(
u == 0x000045 ||
u == 0x000065
)) goto L0341;
ctx->cur += n;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0342;
if (!(
u == 0x00002d ||
u == 0x00002b
)) goto L0342;
ctx->cur += n;
}
goto L0343;
L0342:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0343:;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0341;
goto L0344;
L0341:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0344:;
}
goto L0001;
L0338:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0345;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0345;
if (!(
u == 0x000045 ||
u == 0x000065
)) goto L0345;
ctx->cur += n;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0346;
if (!(
u == 0x00002d ||
u == 0x00002b
)) goto L0346;
ctx->cur += n;
}
goto L0347;
L0346:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0347:;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DecDigits, &chunk->thunks, NULL)) goto L0345;
goto L0001;
L0345:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexLiteral, &chunk->thunks, NULL)) goto L0350;
goto L0349;
L0350:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BinLiteral, &chunk->thunks, NULL)) goto L0351;
goto L0349;
L0351:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0352;
if (!(
(u >= 0x000031 && u <= 0x000039)
)) goto L0352;
ctx->cur += n;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0355;
if (!(
(u >= 0x000030 && u <= 0x000039)
)) goto L0355;
ctx->cur += n;
}
goto L0354;
L0355:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '_'
) goto L0356;
ctx->cur++;
goto L0354;
L0356:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0353;
L0354:;
}
if (ctx->cur == p) break;
continue;
L0353:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0349;
L0352:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0357;
if (!(
(u >= 0x000030 && u <= 0x000039)
)) goto L0357;
ctx->cur += n;
}
goto L0349;
L0357:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0348;
L0349:;
}
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0348;
if (!(
u == 0x000055 ||
u == 0x000075
)) goto L0348;
ctx->cur += n;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0358;
if (!(
u == 0x00004c ||
u == 0x00006c
)) goto L0358;
ctx->cur += n;
}
goto L0359;
L0358:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0359:;
}
goto L0001;
L0348:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexLiteral, &chunk->thunks, NULL)) goto L0362;
goto L0361;
L0362:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BinLiteral, &chunk->thunks, NULL)) goto L0363;
goto L0361;
L0363:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0364;
if (!(
(u >= 0x000031 && u <= 0x000039)
)) goto L0364;
ctx->cur += n;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0367;
if (!(
(u >= 0x000030 && u <= 0x000039)
)) goto L0367;
ctx->cur += n;
}
goto L0366;
L0367:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '_'
) goto L0368;
ctx->cur++;
goto L0366;
L0368:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0365;
L0366:;
}
if (ctx->cur == p) break;
continue;
L0365:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0361;
L0364:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0369;
if (!(
(u >= 0x000030 && u <= 0x000039)
)) goto L0369;
ctx->cur += n;
}
goto L0361;
L0369:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0360;
L0361:;
}
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0360;
if (!(
u == 0x00004c ||
u == 0x00006c
)) goto L0360;
ctx->cur += n;
}
goto L0001;
L0360:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_HexLiteral, &chunk->thunks, NULL)) goto L0370;
goto L0001;
L0370:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BinLiteral, &chunk->thunks, NULL)) goto L0371;
goto L0001;
L0371:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0372;
if (!(
(u >= 0x000031 && u <= 0x000039)
)) goto L0372;
ctx->cur += n;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0375;
if (!(
(u >= 0x000030 && u <= 0x000039)
)) goto L0375;
ctx->cur += n;
}
goto L0374;
L0375:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '_'
) goto L0376;
ctx->cur++;
goto L0374;
L0376:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0373;
L0374:;
}
if (ctx->cur == p) break;
continue;
L0373:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0001;
L0372:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
int u;
const size_t n = pcc_get_char_as_utf32(ctx, &u);
if (n == 0) goto L0377;
if (!(
(u >= 0x000030 && u <= 0x000039)
)) goto L0377;
ctx->cur += n;
}
goto L0001;
L0377:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "primaryExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "primaryExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_expression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "inside_expression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_equality, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '&' ||
(ctx->buffer.buf + ctx->cur)[1] != '&'
) goto L0001;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_equality, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0005;
if (ctx->cur == p) break;
continue;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '|' ||
(ctx->buffer.buf + ctx->cur)[1] != '|'
) goto L0004;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_equality, &chunk->thunks, NULL)) goto L0004;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0008;
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '&' ||
(ctx->buffer.buf + ctx->cur)[1] != '&'
) goto L0007;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_equality, &chunk->thunks, NULL)) goto L0007;
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "inside_expression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "inside_expression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_equality(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "inside_equality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_comparison, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0004;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0005;
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0003:;
}
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '=' ||
(ctx->buffer.buf + ctx->cur)[1] != '=' ||
(ctx->buffer.buf + ctx->cur)[2] != '='
) goto L0007;
ctx->cur += 3;
goto L0006;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '=' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0008;
ctx->cur += 2;
goto L0006;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '!' ||
(ctx->buffer.buf + ctx->cur)[1] != '=' ||
(ctx->buffer.buf + ctx->cur)[2] != '='
) goto L0009;
ctx->cur += 3;
goto L0006;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '!' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0010;
ctx->cur += 2;
goto L0006;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0006:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_comparison, &chunk->thunks, NULL)) goto L0001;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0014;
goto L0013;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0015;
goto L0013;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0012;
L0013:;
}
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "inside_equality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "inside_equality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_comparison(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "inside_comparison", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_genericCallLikeComparison, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0004;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0005;
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0003:;
}
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '<' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0007;
ctx->cur += 2;
goto L0006;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '>' ||
(ctx->buffer.buf + ctx->cur)[1] != '='
) goto L0008;
ctx->cur += 2;
goto L0006;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '<'
) goto L0009;
ctx->cur++;
goto L0006;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '>'
) goto L0010;
ctx->cur++;
goto L0006;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0006:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_genericCallLikeComparison, &chunk->thunks, NULL)) goto L0001;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0014;
goto L0013;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0015;
goto L0013;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0012;
L0013:;
}
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "inside_comparison", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "inside_comparison", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_genericCallLikeComparison(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "inside_genericCallLikeComparison", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_infixFunctionCall, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '?' ||
(ctx->buffer.buf + ctx->cur)[1] != ':'
) goto L0001;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_infixFunctionCall, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0009;
goto L0008;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0010;
goto L0008;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0007;
L0008:;
}
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IN, &chunk->thunks, NULL)) goto L0012;
goto L0011;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '!' ||
(ctx->buffer.buf + ctx->cur)[1] != 'i' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n'
) goto L0013;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0016;
goto L0015;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0017;
goto L0015;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0014;
L0015:;
}
ctx->cur = p;
goto L0013;
L0014:;
ctx->cur = p;
}
goto L0011;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0006;
L0011:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0018;
if (ctx->cur == p) break;
continue;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_infixFunctionCall, &chunk->thunks, NULL)) goto L0006;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0020;
if (ctx->cur == p) break;
continue;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '?' ||
(ctx->buffer.buf + ctx->cur)[1] != ':'
) goto L0019;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0021;
if (ctx->cur == p) break;
continue;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_infixFunctionCall, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0025;
goto L0024;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0026;
goto L0024;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0023;
L0024:;
}
if (ctx->cur == p) break;
continue;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_isOperator, &chunk->thunks, NULL)) goto L0022;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0027;
if (ctx->cur == p) break;
continue;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0022;
goto L0005;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0004;
L0005:;
}
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0031;
goto L0030;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0032;
goto L0030;
L0032:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0029;
L0030:;
}
if (ctx->cur == p) break;
continue;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_callSuffix, &chunk->thunks, NULL)) goto L0028;
if (ctx->cur == p) break;
continue;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "inside_genericCallLikeComparison", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "inside_genericCallLikeComparison", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_infixFunctionCall(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "inside_infixFunctionCall", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_additiveExpression, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0004;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0005;
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0003:;
}
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '.' ||
(ctx->buffer.buf + ctx->cur)[1] != '.'
) goto L0001;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_additiveExpression, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0010;
goto L0009;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0011;
goto L0009;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0008;
L0009:;
}
if (ctx->cur == p) break;
continue;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_simpleIdentifier, &chunk->thunks, NULL)) goto L0007;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_additiveExpression, &chunk->thunks, NULL)) goto L0007;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0016;
goto L0015;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0017;
goto L0015;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0014;
L0015:;
}
if (ctx->cur == p) break;
continue;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '.' ||
(ctx->buffer.buf + ctx->cur)[1] != '.'
) goto L0013;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0018;
if (ctx->cur == p) break;
continue;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_additiveExpression, &chunk->thunks, NULL)) goto L0013;
if (ctx->cur == p) break;
continue;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "inside_infixFunctionCall", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "inside_infixFunctionCall", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_additiveExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "inside_additiveExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_asExpression, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0004;
goto L0003;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0005;
goto L0003;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0003:;
}
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '*'
) goto L0007;
ctx->cur++;
goto L0006;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '/'
) goto L0008;
ctx->cur++;
goto L0006;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '%'
) goto L0009;
ctx->cur++;
goto L0006;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0006:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_asExpression, &chunk->thunks, NULL)) goto L0001;
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0014;
goto L0013;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0015;
goto L0013;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0012;
L0013:;
}
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '+'
) goto L0017;
ctx->cur++;
goto L0016;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '-'
) goto L0018;
ctx->cur++;
goto L0016;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0011;
L0016:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_asExpression, &chunk->thunks, NULL)) goto L0011;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0023;
goto L0022;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0024;
goto L0022;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0021;
L0022:;
}
if (ctx->cur == p) break;
continue;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '*'
) goto L0026;
ctx->cur++;
goto L0025;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '/'
) goto L0027;
ctx->cur++;
goto L0025;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '%'
) goto L0028;
ctx->cur++;
goto L0025;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0020;
L0025:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0029;
if (ctx->cur == p) break;
continue;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_asExpression, &chunk->thunks, NULL)) goto L0020;
if (ctx->cur == p) break;
continue;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "inside_additiveExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "inside_additiveExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_asExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "inside_asExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_label, &chunk->thunks, NULL)) goto L0004;
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_prefixUnaryOperator, &chunk->thunks, NULL)) goto L0005;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0002;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0009;
goto L0008;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0010;
goto L0008;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0007;
L0008:;
}
if (ctx->cur == p) break;
continue;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_inside_postfixUnaryExpression, &chunk->thunks, NULL)) goto L0000;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 's' ||
(ctx->buffer.buf + ctx->cur)[2] != '?'
) goto L0014;
ctx->cur += 3;
goto L0013;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 's'
) goto L0015;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0018;
goto L0017;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0019;
goto L0017;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0016;
L0017:;
}
ctx->cur = p;
goto L0015;
L0016:;
ctx->cur = p;
}
goto L0013;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0011;
L0013:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0020;
if (ctx->cur == p) break;
continue;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0011;
if (ctx->cur == p) break;
continue;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "inside_asExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "inside_asExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_inside_postfixUnaryExpression(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "inside_postfixUnaryExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_primaryExpression, &chunk->thunks, NULL)) goto L0002;
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule__, &chunk->thunks, NULL)) goto L0006;
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0007;
goto L0005;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0004;
L0005:;
}
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '+' ||
(ctx->buffer.buf + ctx->cur)[1] != '+'
) goto L0009;
ctx->cur += 2;
goto L0008;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '-' ||
(ctx->buffer.buf + ctx->cur)[1] != '-'
) goto L0010;
ctx->cur += 2;
goto L0008;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '!'
) goto L0011;
ctx->cur++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '!'
) goto L0013;
ctx->cur++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Hidden, &chunk->thunks, NULL)) goto L0013;
goto L0012;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '!'
) goto L0014;
ctx->cur++;
goto L0012;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0011;
L0012:;
}
goto L0008;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeArguments, &chunk->thunks, NULL)) goto L0015;
goto L0008;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_callSuffix, &chunk->thunks, NULL)) goto L0016;
goto L0008;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_indexingSuffix, &chunk->thunks, NULL)) goto L0017;
goto L0008;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_navigationSuffix, &chunk->thunks, NULL)) goto L0018;
goto L0008;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0003;
L0008:;
}
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0002;
}
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_primaryExpression, &chunk->thunks, NULL)) goto L0019;
goto L0001;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "inside_postfixUnaryExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "inside_postfixUnaryExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_lambdaLiteral(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "lambdaLiteral", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '{'
) goto L0002;
ctx->cur++;
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_lambdaLiteral_0, 0, 0);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statements, &chunk->thunks, NULL)) goto L0002;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0004;
if (ctx->cur == p) break;
continue;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '}'
) goto L0002;
ctx->cur++;
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_lambdaLiteral_1, 0, 0);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '{'
) goto L0005;
ctx->cur++;
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_lambdaLiteral_2, 0, 0);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_variableDeclaration, &chunk->thunks, NULL)) goto L0009;
goto L0008;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_multiVariableDeclaration, &chunk->thunks, NULL)) goto L0010;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0011;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0013;
if (ctx->cur == p) break;
continue;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0011;
goto L0014;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0014:;
}
goto L0008;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0007;
L0008:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0016;
if (ctx->cur == p) break;
continue;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0015;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_variableDeclaration, &chunk->thunks, NULL)) goto L0019;
goto L0018;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_multiVariableDeclaration, &chunk->thunks, NULL)) goto L0020;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0022;
if (ctx->cur == p) break;
continue;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0021;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0023;
if (ctx->cur == p) break;
continue;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0021;
goto L0024;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0024:;
}
goto L0018;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0015;
L0018:;
}
if (ctx->cur == p) break;
continue;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0026;
if (ctx->cur == p) break;
continue;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0025;
ctx->cur++;
goto L0027;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0027:;
}
goto L0028;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0028:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0029;
if (ctx->cur == p) break;
continue;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '-' ||
(ctx->buffer.buf + ctx->cur)[1] != '>'
) goto L0005;
ctx->cur += 2;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0030;
if (ctx->cur == p) break;
continue;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_statements, &chunk->thunks, NULL)) goto L0005;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0031;
if (ctx->cur == p) break;
continue;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '}'
) goto L0005;
ctx->cur++;
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_lambdaLiteral_3, 0, 0);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
goto L0001;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "lambdaLiteral", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "lambdaLiteral", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_anonymousFunction(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "anonymousFunction", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SUSPEND, &chunk->thunks, NULL)) goto L0001;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0002;
if (ctx->cur == p) break;
continue;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0003;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0003:;
}
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n'
) goto L0000;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0006;
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0007;
goto L0005;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0004;
L0005:;
}
ctx->cur = p;
goto L0000;
L0004:;
ctx->cur = p;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_anonymousFunction_0, 0, 0);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0009;
if (ctx->cur == p) break;
continue;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0008;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0010;
if (ctx->cur == p) break;
continue;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '.'
) goto L0008;
ctx->cur++;
goto L0011;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0011:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0012;
if (ctx->cur == p) break;
continue;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '('
) goto L0000;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0013;
if (ctx->cur == p) break;
continue;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_parameterWithOptionalType, &chunk->thunks, NULL)) goto L0014;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0016;
if (ctx->cur == p) break;
continue;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0015;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_parameterWithOptionalType, &chunk->thunks, NULL)) goto L0015;
if (ctx->cur == p) break;
continue;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0019;
if (ctx->cur == p) break;
continue;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ','
) goto L0018;
ctx->cur++;
goto L0020;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0020:;
}
goto L0021;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0021:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0022;
if (ctx->cur == p) break;
continue;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ')'
) goto L0000;
ctx->cur++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0024;
if (ctx->cur == p) break;
continue;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0023;
ctx->cur++;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0025;
if (ctx->cur == p) break;
continue;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_type, &chunk->thunks, NULL)) goto L0023;
goto L0026;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0026:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0028;
if (ctx->cur == p) break;
continue;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_typeConstraints, &chunk->thunks, NULL)) goto L0027;
goto L0029;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0029:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0031;
if (ctx->cur == p) break;
continue;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_block, &chunk->thunks, NULL)) goto L0033;
goto L0032;
L0033:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0034;
ctx->cur++;
{
const size_t p = ctx->cur;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '='
) goto L0035;
ctx->cur++;
ctx->cur = p;
goto L0034;
L0035:;
ctx->cur = p;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0036;
if (ctx->cur == p) break;
continue;
L0036:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_expression, &chunk->thunks, NULL)) goto L0034;
goto L0032;
L0034:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0030;
L0032:;
}
goto L0037;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
L0037:;
}
{
pcc_thunk_t *const thunk = pcc_thunk__create_leaf(ctx->auxil, pcc_action_anonymousFunction_1, 0, 0);
thunk->data.leaf.capt0.range.start = chunk->pos;
thunk->data.leaf.capt0.range.end = ctx->cur;
pcc_thunk_array__add(ctx->auxil, &chunk->thunks, thunk);
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "anonymousFunction", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "anonymousFunction", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_isOperator(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "isOperator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 's'
) goto L0002;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0005;
goto L0004;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0006;
goto L0004;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0003;
L0004:;
}
ctx->cur = p;
goto L0002;
L0003:;
ctx->cur = p;
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != '!' ||
(ctx->buffer.buf + ctx->cur)[1] != 'i' ||
(ctx->buffer.buf + ctx->cur)[2] != 's'
) goto L0007;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0010;
goto L0009;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0011;
goto L0009;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0008;
L0009:;
}
ctx->cur = p;
goto L0007;
L0008:;
ctx->cur = p;
}
goto L0001;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "isOperator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "isOperator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_prefixUnaryOperator(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "prefixUnaryOperator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '+' ||
(ctx->buffer.buf + ctx->cur)[1] != '+'
) goto L0002;
ctx->cur += 2;
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != '-' ||
(ctx->buffer.buf + ctx->cur)[1] != '-'
) goto L0003;
ctx->cur += 2;
goto L0001;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '-'
) goto L0004;
ctx->cur++;
goto L0001;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '+'
) goto L0005;
ctx->cur++;
goto L0001;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '!'
) goto L0006;
ctx->cur++;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Hidden, &chunk->thunks, NULL)) goto L0006;
goto L0001;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '!'
) goto L0007;
ctx->cur++;
goto L0001;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "prefixUnaryOperator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "prefixUnaryOperator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_modifiers(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "modifiers", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotation, &chunk->thunks, NULL)) goto L0003;
goto L0002;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'e' ||
(ctx->buffer.buf + ctx->cur)[1] != 'n' ||
(ctx->buffer.buf + ctx->cur)[2] != 'u' ||
(ctx->buffer.buf + ctx->cur)[3] != 'm'
) goto L0006;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0009;
goto L0008;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0010;
goto L0008;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0007;
L0008:;
}
ctx->cur = p;
goto L0006;
L0007:;
ctx->cur = p;
}
goto L0005;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 's' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 'a' ||
(ctx->buffer.buf + ctx->cur)[3] != 'l' ||
(ctx->buffer.buf + ctx->cur)[4] != 'e' ||
(ctx->buffer.buf + ctx->cur)[5] != 'd'
) goto L0011;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0014;
goto L0013;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0015;
goto L0013;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0012;
L0013:;
}
ctx->cur = p;
goto L0011;
L0012:;
ctx->cur = p;
}
goto L0005;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 10) < 10 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 'n' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 'o' ||
(ctx->buffer.buf + ctx->cur)[4] != 't' ||
(ctx->buffer.buf + ctx->cur)[5] != 'a' ||
(ctx->buffer.buf + ctx->cur)[6] != 't' ||
(ctx->buffer.buf + ctx->cur)[7] != 'i' ||
(ctx->buffer.buf + ctx->cur)[8] != 'o' ||
(ctx->buffer.buf + ctx->cur)[9] != 'n'
) goto L0016;
ctx->cur += 10;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0019;
goto L0018;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0020;
goto L0018;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0017;
L0018:;
}
ctx->cur = p;
goto L0016;
L0017:;
ctx->cur = p;
}
goto L0005;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a'
) goto L0021;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0024;
goto L0023;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0025;
goto L0023;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0022;
L0023:;
}
ctx->cur = p;
goto L0021;
L0022:;
ctx->cur = p;
}
goto L0005;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'n' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r'
) goto L0026;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0029;
goto L0028;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0030;
goto L0028;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0027;
L0028:;
}
ctx->cur = p;
goto L0026;
L0027:;
ctx->cur = p;
}
goto L0005;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'v' ||
(ctx->buffer.buf + ctx->cur)[2] != 'e' ||
(ctx->buffer.buf + ctx->cur)[3] != 'r' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'd' ||
(ctx->buffer.buf + ctx->cur)[7] != 'e'
) goto L0031;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0034;
goto L0033;
L0034:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0035;
goto L0033;
L0035:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0032;
L0033:;
}
ctx->cur = p;
goto L0031;
L0032:;
ctx->cur = p;
}
goto L0005;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'l' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'i' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n' ||
(ctx->buffer.buf + ctx->cur)[6] != 'i' ||
(ctx->buffer.buf + ctx->cur)[7] != 't'
) goto L0036;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0039;
goto L0038;
L0039:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0040;
goto L0038;
L0040:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0037;
L0038:;
}
ctx->cur = p;
goto L0036;
L0037:;
ctx->cur = p;
}
goto L0005;
L0036:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'p' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'b' ||
(ctx->buffer.buf + ctx->cur)[3] != 'l' ||
(ctx->buffer.buf + ctx->cur)[4] != 'i' ||
(ctx->buffer.buf + ctx->cur)[5] != 'c'
) goto L0041;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0044;
goto L0043;
L0044:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0045;
goto L0043;
L0045:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0042;
L0043:;
}
ctx->cur = p;
goto L0041;
L0042:;
ctx->cur = p;
}
goto L0005;
L0041:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'p' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 'v' ||
(ctx->buffer.buf + ctx->cur)[4] != 'a' ||
(ctx->buffer.buf + ctx->cur)[5] != 't' ||
(ctx->buffer.buf + ctx->cur)[6] != 'e'
) goto L0046;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0049;
goto L0048;
L0049:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0050;
goto L0048;
L0050:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0047;
L0048:;
}
ctx->cur = p;
goto L0046;
L0047:;
ctx->cur = p;
}
goto L0005;
L0046:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'n' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n' ||
(ctx->buffer.buf + ctx->cur)[6] != 'a' ||
(ctx->buffer.buf + ctx->cur)[7] != 'l'
) goto L0051;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0054;
goto L0053;
L0054:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0055;
goto L0053;
L0055:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0052;
L0053:;
}
ctx->cur = p;
goto L0051;
L0052:;
ctx->cur = p;
}
goto L0005;
L0051:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 9) < 9 ||
(ctx->buffer.buf + ctx->cur)[0] != 'p' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'o' ||
(ctx->buffer.buf + ctx->cur)[3] != 't' ||
(ctx->buffer.buf + ctx->cur)[4] != 'e' ||
(ctx->buffer.buf + ctx->cur)[5] != 'c' ||
(ctx->buffer.buf + ctx->cur)[6] != 't' ||
(ctx->buffer.buf + ctx->cur)[7] != 'e' ||
(ctx->buffer.buf + ctx->cur)[8] != 'd'
) goto L0056;
ctx->cur += 9;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0059;
goto L0058;
L0059:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0060;
goto L0058;
L0060:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0057;
L0058:;
}
ctx->cur = p;
goto L0056;
L0057:;
ctx->cur = p;
}
goto L0005;
L0056:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 'l' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'e' ||
(ctx->buffer.buf + ctx->cur)[6] != 'c'
) goto L0061;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0064;
goto L0063;
L0064:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0065;
goto L0063;
L0065:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0062;
L0063:;
}
ctx->cur = p;
goto L0061;
L0062:;
ctx->cur = p;
}
goto L0005;
L0061:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'p' ||
(ctx->buffer.buf + ctx->cur)[2] != 'e' ||
(ctx->buffer.buf + ctx->cur)[3] != 'r' ||
(ctx->buffer.buf + ctx->cur)[4] != 'a' ||
(ctx->buffer.buf + ctx->cur)[5] != 't' ||
(ctx->buffer.buf + ctx->cur)[6] != 'o' ||
(ctx->buffer.buf + ctx->cur)[7] != 'r'
) goto L0066;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0069;
goto L0068;
L0069:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0070;
goto L0068;
L0070:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0067;
L0068:;
}
ctx->cur = p;
goto L0066;
L0067:;
ctx->cur = p;
}
goto L0005;
L0066:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'n' ||
(ctx->buffer.buf + ctx->cur)[2] != 'f' ||
(ctx->buffer.buf + ctx->cur)[3] != 'i' ||
(ctx->buffer.buf + ctx->cur)[4] != 'x'
) goto L0071;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0074;
goto L0073;
L0074:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0075;
goto L0073;
L0075:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0072;
L0073:;
}
ctx->cur = p;
goto L0071;
L0072:;
ctx->cur = p;
}
goto L0005;
L0071:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'n' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l' ||
(ctx->buffer.buf + ctx->cur)[3] != 'i' ||
(ctx->buffer.buf + ctx->cur)[4] != 'n' ||
(ctx->buffer.buf + ctx->cur)[5] != 'e'
) goto L0076;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0079;
goto L0078;
L0079:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0080;
goto L0078;
L0080:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0077;
L0078:;
}
ctx->cur = p;
goto L0076;
L0077:;
ctx->cur = p;
}
goto L0005;
L0076:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'e' ||
(ctx->buffer.buf + ctx->cur)[1] != 'x' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n' ||
(ctx->buffer.buf + ctx->cur)[6] != 'a' ||
(ctx->buffer.buf + ctx->cur)[7] != 'l'
) goto L0081;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0084;
goto L0083;
L0084:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0085;
goto L0083;
L0085:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0082;
L0083:;
}
ctx->cur = p;
goto L0081;
L0082:;
ctx->cur = p;
}
goto L0005;
L0081:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SUSPEND, &chunk->thunks, NULL)) goto L0086;
goto L0005;
L0086:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 't'
) goto L0087;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0090;
goto L0089;
L0090:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0091;
goto L0089;
L0091:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0088;
L0089:;
}
ctx->cur = p;
goto L0087;
L0088:;
ctx->cur = p;
}
goto L0005;
L0087:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 'b' ||
(ctx->buffer.buf + ctx->cur)[2] != 's' ||
(ctx->buffer.buf + ctx->cur)[3] != 't' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'a' ||
(ctx->buffer.buf + ctx->cur)[6] != 'c' ||
(ctx->buffer.buf + ctx->cur)[7] != 't'
) goto L0092;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0095;
goto L0094;
L0095:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0096;
goto L0094;
L0096:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0093;
L0094:;
}
ctx->cur = p;
goto L0092;
L0093:;
ctx->cur = p;
}
goto L0005;
L0092:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'i' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'l'
) goto L0097;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0100;
goto L0099;
L0100:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0101;
goto L0099;
L0101:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0098;
L0099:;
}
ctx->cur = p;
goto L0097;
L0098:;
ctx->cur = p;
}
goto L0005;
L0097:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'p' ||
(ctx->buffer.buf + ctx->cur)[2] != 'e' ||
(ctx->buffer.buf + ctx->cur)[3] != 'n'
) goto L0102;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0105;
goto L0104;
L0105:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0106;
goto L0104;
L0106:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0103;
L0104:;
}
ctx->cur = p;
goto L0102;
L0103:;
ctx->cur = p;
}
goto L0005;
L0102:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'v' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'g'
) goto L0107;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0110;
goto L0109;
L0110:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0111;
goto L0109;
L0111:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0108;
L0109:;
}
ctx->cur = p;
goto L0107;
L0108:;
ctx->cur = p;
}
goto L0005;
L0107:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'n' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 'n' ||
(ctx->buffer.buf + ctx->cur)[4] != 'l' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'n' ||
(ctx->buffer.buf + ctx->cur)[7] != 'e'
) goto L0112;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0115;
goto L0114;
L0115:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0116;
goto L0114;
L0116:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0113;
L0114:;
}
ctx->cur = p;
goto L0112;
L0113:;
ctx->cur = p;
}
goto L0005;
L0112:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 11) < 11 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'o' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 's' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'n' ||
(ctx->buffer.buf + ctx->cur)[7] != 'l' ||
(ctx->buffer.buf + ctx->cur)[8] != 'i' ||
(ctx->buffer.buf + ctx->cur)[9] != 'n' ||
(ctx->buffer.buf + ctx->cur)[10] != 'e'
) goto L0117;
ctx->cur += 11;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0120;
goto L0119;
L0120:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0121;
goto L0119;
L0121:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0118;
L0119:;
}
ctx->cur = p;
goto L0117;
L0118:;
ctx->cur = p;
}
goto L0005;
L0117:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'e' ||
(ctx->buffer.buf + ctx->cur)[1] != 'x' ||
(ctx->buffer.buf + ctx->cur)[2] != 'p' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'c' ||
(ctx->buffer.buf + ctx->cur)[5] != 't'
) goto L0122;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0125;
goto L0124;
L0125:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0126;
goto L0124;
L0126:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0123;
L0124:;
}
ctx->cur = p;
goto L0122;
L0123:;
ctx->cur = p;
}
goto L0005;
L0122:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 'c' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'u' ||
(ctx->buffer.buf + ctx->cur)[4] != 'a' ||
(ctx->buffer.buf + ctx->cur)[5] != 'l'
) goto L0127;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0130;
goto L0129;
L0130:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0131;
goto L0129;
L0131:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0128;
L0129:;
}
ctx->cur = p;
goto L0127;
L0128:;
ctx->cur = p;
}
goto L0005;
L0127:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0004;
L0005:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0132;
if (ctx->cur == p) break;
continue;
L0132:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
goto L0002;
L0004:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0001;
L0002:;
}
if (ctx->cur == p) break;
continue;
L0001:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0000;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "modifiers", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "modifiers", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_annotation(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "annotation", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotationUseSiteTarget, &chunk->thunks, NULL)) goto L0002;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0003;
if (ctx->cur == p) break;
continue;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0005;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0006;
if (ctx->cur == p) break;
continue;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0005;
goto L0004;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0007;
goto L0004;
L0007:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0002;
L0004:;
}
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0010;
ctx->cur++;
goto L0009;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Hidden, &chunk->thunks, NULL)) goto L0013;
goto L0012;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0014;
goto L0012;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0011;
L0012:;
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0011;
ctx->cur++;
goto L0009;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0008;
L0009:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0016;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0017;
if (ctx->cur == p) break;
continue;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0016;
goto L0015;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0018;
goto L0015;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0008;
L0015:;
}
goto L0001;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_annotationUseSiteTarget, &chunk->thunks, NULL)) goto L0019;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0020;
if (ctx->cur == p) break;
continue;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '['
) goto L0019;
ctx->cur++;
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0023;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0024;
if (ctx->cur == p) break;
continue;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0023;
goto L0022;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0025;
goto L0022;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0021;
L0022:;
}
if (ctx->cur == p) break;
continue;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0019;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ']'
) goto L0019;
ctx->cur++;
goto L0001;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0028;
ctx->cur++;
goto L0027;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Hidden, &chunk->thunks, NULL)) goto L0031;
goto L0030;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0032;
goto L0030;
L0032:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0029;
L0030:;
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0029;
ctx->cur++;
goto L0027;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0026;
L0027:;
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '['
) goto L0026;
ctx->cur++;
{
const size_t p0 = ctx->cur;
const size_t n0 = chunk->thunks.len;
int i;
for (i = 0;; i++) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0035;
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0036;
if (ctx->cur == p) break;
continue;
L0036:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_valueArguments, &chunk->thunks, NULL)) goto L0035;
goto L0034;
L0035:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_userType, &chunk->thunks, NULL)) goto L0037;
goto L0034;
L0037:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0033;
L0034:;
}
if (ctx->cur == p) break;
continue;
L0033:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
if (i < 1) {
ctx->cur = p0;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
goto L0026;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ']'
) goto L0026;
ctx->cur++;
goto L0001;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0038;
if (ctx->cur == p) break;
continue;
L0038:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "annotation", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "annotation", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_annotationUseSiteTarget(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "annotationUseSiteTarget", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0002;
ctx->cur++;
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Hidden, &chunk->thunks, NULL)) goto L0005;
goto L0004;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NL, &chunk->thunks, NULL)) goto L0006;
goto L0004;
L0006:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0003;
L0004:;
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '@'
) goto L0003;
ctx->cur++;
goto L0001;
L0003:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0001:;
}
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'i' ||
(ctx->buffer.buf + ctx->cur)[2] != 'e' ||
(ctx->buffer.buf + ctx->cur)[3] != 'l' ||
(ctx->buffer.buf + ctx->cur)[4] != 'd'
) goto L0008;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0011;
goto L0010;
L0011:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0012;
goto L0010;
L0012:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0009;
L0010:;
}
ctx->cur = p;
goto L0008;
L0009:;
ctx->cur = p;
}
goto L0007;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'p' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'o' ||
(ctx->buffer.buf + ctx->cur)[3] != 'p' ||
(ctx->buffer.buf + ctx->cur)[4] != 'e' ||
(ctx->buffer.buf + ctx->cur)[5] != 'r' ||
(ctx->buffer.buf + ctx->cur)[6] != 't' ||
(ctx->buffer.buf + ctx->cur)[7] != 'y'
) goto L0013;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0016;
goto L0015;
L0016:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0017;
goto L0015;
L0017:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0014;
L0015:;
}
ctx->cur = p;
goto L0013;
L0014:;
ctx->cur = p;
}
goto L0007;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'g' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 't'
) goto L0018;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0021;
goto L0020;
L0021:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0022;
goto L0020;
L0022:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0019;
L0020:;
}
ctx->cur = p;
goto L0018;
L0019:;
ctx->cur = p;
}
goto L0007;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 's' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 't'
) goto L0023;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0026;
goto L0025;
L0026:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0027;
goto L0025;
L0027:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0024;
L0025:;
}
ctx->cur = p;
goto L0023;
L0024:;
ctx->cur = p;
}
goto L0007;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'r' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 'c' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'i' ||
(ctx->buffer.buf + ctx->cur)[5] != 'v' ||
(ctx->buffer.buf + ctx->cur)[6] != 'e' ||
(ctx->buffer.buf + ctx->cur)[7] != 'r'
) goto L0028;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0031;
goto L0030;
L0031:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0032;
goto L0030;
L0032:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0029;
L0030:;
}
ctx->cur = p;
goto L0028;
L0029:;
ctx->cur = p;
}
goto L0007;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'p' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'm'
) goto L0033;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0036;
goto L0035;
L0036:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0037;
goto L0035;
L0037:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0034;
L0035:;
}
ctx->cur = p;
goto L0033;
L0034:;
ctx->cur = p;
}
goto L0007;
L0033:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 's' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'p' ||
(ctx->buffer.buf + ctx->cur)[4] != 'a' ||
(ctx->buffer.buf + ctx->cur)[5] != 'r' ||
(ctx->buffer.buf + ctx->cur)[6] != 'a' ||
(ctx->buffer.buf + ctx->cur)[7] != 'm'
) goto L0038;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0041;
goto L0040;
L0041:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0042;
goto L0040;
L0042:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0039;
L0040:;
}
ctx->cur = p;
goto L0038;
L0039:;
ctx->cur = p;
}
goto L0007;
L0038:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'g' ||
(ctx->buffer.buf + ctx->cur)[5] != 'a' ||
(ctx->buffer.buf + ctx->cur)[6] != 't' ||
(ctx->buffer.buf + ctx->cur)[7] != 'e'
) goto L0043;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0046;
goto L0045;
L0046:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0047;
goto L0045;
L0047:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0044;
L0045:;
}
ctx->cur = p;
goto L0043;
L0044:;
ctx->cur = p;
}
goto L0007;
L0043:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0000;
L0007:;
}
{
for (;;) {
const size_t p = ctx->cur;
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule___, &chunk->thunks, NULL)) goto L0048;
if (ctx->cur == p) break;
continue;
L0048:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
break;
}
}
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != ':'
) goto L0000;
ctx->cur++;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, "annotationUseSiteTarget", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
return chunk;
L0000:;
ctx->level--;
PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, "annotationUseSiteTarget", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
pcc_thunk_chunk__destroy(ctx, chunk);
return NULL;
}
static pcc_thunk_chunk_t *pcc_evaluate_rule_simpleIdentifier(pcc_context_t *ctx) {
pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
chunk->pos = ctx->cur;
PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, "simpleIdentifier", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
ctx->level++;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 's'
) goto L0005;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0008;
goto L0007;
L0008:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0009;
goto L0007;
L0009:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0006;
L0007:;
}
ctx->cur = p;
goto L0005;
L0006:;
ctx->cur = p;
}
goto L0004;
L0005:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'b' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'e' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'k'
) goto L0010;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0013;
goto L0012;
L0013:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0014;
goto L0012;
L0014:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0011;
L0012:;
}
ctx->cur = p;
goto L0010;
L0011:;
ctx->cur = p;
}
goto L0004;
L0010:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'l' ||
(ctx->buffer.buf + ctx->cur)[2] != 'a' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 's'
) goto L0015;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0018;
goto L0017;
L0018:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0019;
goto L0017;
L0019:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0016;
L0017:;
}
ctx->cur = p;
goto L0015;
L0016:;
ctx->cur = p;
}
goto L0004;
L0015:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 't' ||
(ctx->buffer.buf + ctx->cur)[4] != 'i' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n' ||
(ctx->buffer.buf + ctx->cur)[6] != 'u' ||
(ctx->buffer.buf + ctx->cur)[7] != 'e'
) goto L0020;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0023;
goto L0022;
L0023:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0024;
goto L0022;
L0024:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0021;
L0022:;
}
ctx->cur = p;
goto L0020;
L0021:;
ctx->cur = p;
}
goto L0004;
L0020:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o'
) goto L0025;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0028;
goto L0027;
L0028:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0029;
goto L0027;
L0029:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0026;
L0027:;
}
ctx->cur = p;
goto L0025;
L0026:;
ctx->cur = p;
}
goto L0004;
L0025:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'e' ||
(ctx->buffer.buf + ctx->cur)[1] != 'l' ||
(ctx->buffer.buf + ctx->cur)[2] != 's' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e'
) goto L0030;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0033;
goto L0032;
L0033:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0034;
goto L0032;
L0034:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0031;
L0032:;
}
ctx->cur = p;
goto L0030;
L0031:;
ctx->cur = p;
}
goto L0004;
L0030:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r'
) goto L0035;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0038;
goto L0037;
L0038:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0039;
goto L0037;
L0039:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0036;
L0037:;
}
ctx->cur = p;
goto L0035;
L0036:;
ctx->cur = p;
}
goto L0004;
L0035:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n'
) goto L0040;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0043;
goto L0042;
L0043:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0044;
goto L0042;
L0044:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0041;
L0042:;
}
ctx->cur = p;
goto L0040;
L0041:;
ctx->cur = p;
}
goto L0004;
L0040:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'f'
) goto L0045;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0048;
goto L0047;
L0048:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0049;
goto L0047;
L0049:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0046;
L0047:;
}
ctx->cur = p;
goto L0045;
L0046:;
ctx->cur = p;
}
goto L0004;
L0045:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IN, &chunk->thunks, NULL)) goto L0050;
goto L0004;
L0050:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 9) < 9 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 'n' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'f' ||
(ctx->buffer.buf + ctx->cur)[6] != 'a' ||
(ctx->buffer.buf + ctx->cur)[7] != 'c' ||
(ctx->buffer.buf + ctx->cur)[8] != 'e'
) goto L0051;
ctx->cur += 9;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0054;
goto L0053;
L0054:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0055;
goto L0053;
L0055:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0052;
L0053:;
}
ctx->cur = p;
goto L0051;
L0052:;
ctx->cur = p;
}
goto L0004;
L0051:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'i' ||
(ctx->buffer.buf + ctx->cur)[1] != 's'
) goto L0056;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0059;
goto L0058;
L0059:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0060;
goto L0058;
L0060:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0057;
L0058:;
}
ctx->cur = p;
goto L0056;
L0057:;
ctx->cur = p;
}
goto L0004;
L0056:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'n' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l' ||
(ctx->buffer.buf + ctx->cur)[3] != 'l'
) goto L0061;
ctx->cur += 4;
goto L0004;
L0061:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'o' ||
(ctx->buffer.buf + ctx->cur)[1] != 'b' ||
(ctx->buffer.buf + ctx->cur)[2] != 'j' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'c' ||
(ctx->buffer.buf + ctx->cur)[5] != 't'
) goto L0062;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0065;
goto L0064;
L0065:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0066;
goto L0064;
L0066:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0063;
L0064:;
}
ctx->cur = p;
goto L0062;
L0063:;
ctx->cur = p;
}
goto L0004;
L0062:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'p' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'c' ||
(ctx->buffer.buf + ctx->cur)[3] != 'k' ||
(ctx->buffer.buf + ctx->cur)[4] != 'a' ||
(ctx->buffer.buf + ctx->cur)[5] != 'g' ||
(ctx->buffer.buf + ctx->cur)[6] != 'e'
) goto L0067;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0070;
goto L0069;
L0070:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0071;
goto L0069;
L0071:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0068;
L0069:;
}
ctx->cur = p;
goto L0067;
L0068:;
ctx->cur = p;
}
goto L0004;
L0067:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 'r' ||
(ctx->buffer.buf + ctx->cur)[1] != 'e' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'u' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n'
) goto L0072;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0075;
goto L0074;
L0075:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0076;
goto L0074;
L0076:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0073;
L0074:;
}
ctx->cur = p;
goto L0072;
L0073:;
ctx->cur = p;
}
goto L0004;
L0072:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 's' ||
(ctx->buffer.buf + ctx->cur)[1] != 'u' ||
(ctx->buffer.buf + ctx->cur)[2] != 'p' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r'
) goto L0077;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0080;
goto L0079;
L0080:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0081;
goto L0079;
L0081:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0078;
L0079:;
}
ctx->cur = p;
goto L0077;
L0078:;
ctx->cur = p;
}
goto L0004;
L0077:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 's'
) goto L0082;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0085;
goto L0084;
L0085:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0086;
goto L0084;
L0086:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0083;
L0084:;
}
ctx->cur = p;
goto L0082;
L0083:;
ctx->cur = p;
}
goto L0004;
L0082:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r' ||
(ctx->buffer.buf + ctx->cur)[3] != 'o' ||
(ctx->buffer.buf + ctx->cur)[4] != 'w'
) goto L0087;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0090;
goto L0089;
L0090:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0091;
goto L0089;
L0091:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0088;
L0089:;
}
ctx->cur = p;
goto L0087;
L0088:;
ctx->cur = p;
}
goto L0004;
L0087:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'y'
) goto L0092;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0095;
goto L0094;
L0095:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0096;
goto L0094;
L0096:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0093;
L0094:;
}
ctx->cur = p;
goto L0092;
L0093:;
ctx->cur = p;
}
goto L0004;
L0092:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 9) < 9 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'y' ||
(ctx->buffer.buf + ctx->cur)[2] != 'p' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'a' ||
(ctx->buffer.buf + ctx->cur)[5] != 'l' ||
(ctx->buffer.buf + ctx->cur)[6] != 'i' ||
(ctx->buffer.buf + ctx->cur)[7] != 'a' ||
(ctx->buffer.buf + ctx->cur)[8] != 's'
) goto L0097;
ctx->cur += 9;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0100;
goto L0099;
L0100:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0101;
goto L0099;
L0101:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0098;
L0099:;
}
ctx->cur = p;
goto L0097;
L0098:;
ctx->cur = p;
}
goto L0004;
L0097:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 6) < 6 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'y' ||
(ctx->buffer.buf + ctx->cur)[2] != 'p' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e' ||
(ctx->buffer.buf + ctx->cur)[4] != 'o' ||
(ctx->buffer.buf + ctx->cur)[5] != 'f'
) goto L0102;
ctx->cur += 6;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0105;
goto L0104;
L0105:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0106;
goto L0104;
L0106:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0103;
L0104:;
}
ctx->cur = p;
goto L0102;
L0103:;
ctx->cur = p;
}
goto L0004;
L0102:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'v' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l'
) goto L0107;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0110;
goto L0109;
L0110:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0111;
goto L0109;
L0111:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0108;
L0109:;
}
ctx->cur = p;
goto L0107;
L0108:;
ctx->cur = p;
}
goto L0004;
L0107:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 3) < 3 ||
(ctx->buffer.buf + ctx->cur)[0] != 'v' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'r'
) goto L0112;
ctx->cur += 3;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0115;
goto L0114;
L0115:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0116;
goto L0114;
L0116:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0113;
L0114:;
}
ctx->cur = p;
goto L0112;
L0113:;
ctx->cur = p;
}
goto L0004;
L0112:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'w' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'e' ||
(ctx->buffer.buf + ctx->cur)[3] != 'n'
) goto L0117;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0120;
goto L0119;
L0120:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0121;
goto L0119;
L0121:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0118;
L0119:;
}
ctx->cur = p;
goto L0117;
L0118:;
ctx->cur = p;
}
goto L0004;
L0117:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'w' ||
(ctx->buffer.buf + ctx->cur)[1] != 'h' ||
(ctx->buffer.buf + ctx->cur)[2] != 'i' ||
(ctx->buffer.buf + ctx->cur)[3] != 'l' ||
(ctx->buffer.buf + ctx->cur)[4] != 'e'
) goto L0122;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0125;
goto L0124;
L0125:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0126;
goto L0124;
L0126:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0123;
L0124:;
}
ctx->cur = p;
goto L0122;
L0123:;
ctx->cur = p;
}
goto L0004;
L0122:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 't' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'u' ||
(ctx->buffer.buf + ctx->cur)[3] != 'e'
) goto L0127;
ctx->cur += 4;
goto L0004;
L0127:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'f' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 'l' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 'e'
) goto L0128;
ctx->cur += 5;
goto L0004;
L0128:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0003;
L0004:;
}
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0131;
goto L0130;
L0131:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 1) < 1 ||
ctx->buffer.buf[ctx->cur] != '_'
) goto L0132;
ctx->cur++;
goto L0130;
L0132:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0133;
goto L0130;
L0133:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0129;
L0130:;
}
ctx->cur = p;
goto L0003;
L0129:;
ctx->cur = p;
}
ctx->cur = p;
goto L0002;
L0003:;
ctx->cur = p;
}
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Identifier, &chunk->thunks, NULL)) goto L0002;
goto L0001;
L0002:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 8) < 8 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 'b' ||
(ctx->buffer.buf + ctx->cur)[2] != 's' ||
(ctx->buffer.buf + ctx->cur)[3] != 't' ||
(ctx->buffer.buf + ctx->cur)[4] != 'r' ||
(ctx->buffer.buf + ctx->cur)[5] != 'a' ||
(ctx->buffer.buf + ctx->cur)[6] != 'c' ||
(ctx->buffer.buf + ctx->cur)[7] != 't'
) goto L0134;
ctx->cur += 8;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0137;
goto L0136;
L0137:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0138;
goto L0136;
L0138:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0135;
L0136:;
}
ctx->cur = p;
goto L0134;
L0135:;
ctx->cur = p;
}
goto L0001;
L0134:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 10) < 10 ||
(ctx->buffer.buf + ctx->cur)[0] != 'a' ||
(ctx->buffer.buf + ctx->cur)[1] != 'n' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 'o' ||
(ctx->buffer.buf + ctx->cur)[4] != 't' ||
(ctx->buffer.buf + ctx->cur)[5] != 'a' ||
(ctx->buffer.buf + ctx->cur)[6] != 't' ||
(ctx->buffer.buf + ctx->cur)[7] != 'i' ||
(ctx->buffer.buf + ctx->cur)[8] != 'o' ||
(ctx->buffer.buf + ctx->cur)[9] != 'n'
) goto L0139;
ctx->cur += 10;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0142;
goto L0141;
L0142:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0143;
goto L0141;
L0143:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0140;
L0141:;
}
ctx->cur = p;
goto L0139;
L0140:;
ctx->cur = p;
}
goto L0001;
L0139:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 2) < 2 ||
(ctx->buffer.buf + ctx->cur)[0] != 'b' ||
(ctx->buffer.buf + ctx->cur)[1] != 'y'
) goto L0144;
ctx->cur += 2;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0147;
goto L0146;
L0147:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0148;
goto L0146;
L0148:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0145;
L0146:;
}
ctx->cur = p;
goto L0144;
L0145:;
ctx->cur = p;
}
goto L0001;
L0144:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 5) < 5 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'c' ||
(ctx->buffer.buf + ctx->cur)[4] != 'h'
) goto L0149;
ctx->cur += 5;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0152;
goto L0151;
L0152:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0153;
goto L0151;
L0153:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0150;
L0151:;
}
ctx->cur = p;
goto L0149;
L0150:;
ctx->cur = p;
}
goto L0001;
L0149:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 9) < 9 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'm' ||
(ctx->buffer.buf + ctx->cur)[3] != 'p' ||
(ctx->buffer.buf + ctx->cur)[4] != 'a' ||
(ctx->buffer.buf + ctx->cur)[5] != 'n' ||
(ctx->buffer.buf + ctx->cur)[6] != 'i' ||
(ctx->buffer.buf + ctx->cur)[7] != 'o' ||
(ctx->buffer.buf + ctx->cur)[8] != 'n'
) goto L0154;
ctx->cur += 9;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0157;
goto L0156;
L0157:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0158;
goto L0156;
L0158:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0155;
L0156:;
}
ctx->cur = p;
goto L0154;
L0155:;
ctx->cur = p;
}
goto L0001;
L0154:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 11) < 11 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'o' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 't' ||
(ctx->buffer.buf + ctx->cur)[5] != 'r' ||
(ctx->buffer.buf + ctx->cur)[6] != 'u' ||
(ctx->buffer.buf + ctx->cur)[7] != 'c' ||
(ctx->buffer.buf + ctx->cur)[8] != 't' ||
(ctx->buffer.buf + ctx->cur)[9] != 'o' ||
(ctx->buffer.buf + ctx->cur)[10] != 'r'
) goto L0159;
ctx->cur += 11;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0162;
goto L0161;
L0162:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0163;
goto L0161;
L0163:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0160;
L0161:;
}
ctx->cur = p;
goto L0159;
L0160:;
ctx->cur = p;
}
goto L0001;
L0159:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 11) < 11 ||
(ctx->buffer.buf + ctx->cur)[0] != 'c' ||
(ctx->buffer.buf + ctx->cur)[1] != 'r' ||
(ctx->buffer.buf + ctx->cur)[2] != 'o' ||
(ctx->buffer.buf + ctx->cur)[3] != 's' ||
(ctx->buffer.buf + ctx->cur)[4] != 's' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'n' ||
(ctx->buffer.buf + ctx->cur)[7] != 'l' ||
(ctx->buffer.buf + ctx->cur)[8] != 'i' ||
(ctx->buffer.buf + ctx->cur)[9] != 'n' ||
(ctx->buffer.buf + ctx->cur)[10] != 'e'
) goto L0164;
ctx->cur += 11;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0167;
goto L0166;
L0167:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0168;
goto L0166;
L0168:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0165;
L0166:;
}
ctx->cur = p;
goto L0164;
L0165:;
ctx->cur = p;
}
goto L0001;
L0164:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 4) < 4 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'a' ||
(ctx->buffer.buf + ctx->cur)[2] != 't' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a'
) goto L0169;
ctx->cur += 4;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0172;
goto L0171;
L0172:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0173;
goto L0171;
L0173:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
goto L0170;
L0171:;
}
ctx->cur = p;
goto L0169;
L0170:;
ctx->cur = p;
}
goto L0001;
L0169:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (
pcc_refill_buffer(ctx, 7) < 7 ||
(ctx->buffer.buf + ctx->cur)[0] != 'd' ||
(ctx->buffer.buf + ctx->cur)[1] != 'y' ||
(ctx->buffer.buf + ctx->cur)[2] != 'n' ||
(ctx->buffer.buf + ctx->cur)[3] != 'a' ||
(ctx->buffer.buf + ctx->cur)[4] != 'm' ||
(ctx->buffer.buf + ctx->cur)[5] != 'i' ||
(ctx->buffer.buf + ctx->cur)[6] != 'c'
) goto L0174;
ctx->cur += 7;
{
const size_t p = ctx->cur;
{
MARK_VAR_AS_USED
const size_t p = ctx->cur;
MARK_VAR_AS_USED
const size_t n = chunk->thunks.len;
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Letter, &chunk->thunks, NULL)) goto L0177;
goto L0176;
L0177:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnicodeDigit, &chunk->thunks, NULL)) goto L0178;
goto L0176;
L0178:;
ctx->cur = p;
pcc_thunk_array__revert(ctx->auxil, &chunk->th
Raw
kotlin.h
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Raw
kotlin.pego
View raw

(Sorry about that, but we can’t show files that are this big right now.)

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment