reflection.h

Go to the documentation of this file.

/*
 CCCC: Comprehensiev C Compensation Compiler - Comptime Reflection API
 
 Copyright (C) 2025 George Watson
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
 
#ifndef CCCC_REFLECTION_H
#define CCCC_REFLECTION_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Forward declarations (opaque types for comptime functions)
 
// Reserved tag spellings keep these handles from colliding with a user's own
// `struct Node`, `union Type`, ... in the comptime scope. cccc's own sources
// define __CCCC_TAG(n) as `n` to match their internal struct names.
#ifndef __CCCC_TAG
#define __CCCC_TAG(n) __cccc_##n
#endif
 
typedef struct __CCCC_TAG(VirtualMachine) VirtualMachine;
 
typedef struct __CCCC_TAG(Type) Type;
 
typedef struct __CCCC_TAG(Node) Node;
 
typedef struct __CCCC_TAG(Obj) Obj;
 
typedef struct __CCCC_TAG(Member) Member;
 
typedef struct __CCCC_TAG(EnumConstant) EnumConstant;
 
typedef struct __CCCC_TAG(Token) Token;
 
typedef struct __CCCC_TAG(AttrTarget) AttrTarget;
 
#ifndef CCCC_REFLECTION_PROTOTYPES_ONLY
typedef enum {
    TK_VOID    = 0,
    TK_BOOL    = 1,
    TK_CHAR    = 2,
    TK_SHORT   = 3,
    TK_INT     = 4,
    TK_LONG    = 5,
    TK_FLOAT   = 6,
    TK_DOUBLE  = 7,
    TK_LDOUBLE = 8,
    TK_ENUM    = 9,
    TK_PTR     = 10,
    TK_FUNC    = 11,
    TK_ARRAY   = 12,
    TK_VLA     = 13,
    TK_STRUCT  = 14,
    TK_UNION   = 15,
} TypeKind;
 
typedef enum {
    NK_NULL_EXPR        = 0,
    NK_ADD              = 1,
    NK_SUB              = 2,
    NK_MUL              = 3,
    NK_DIV              = 4,
    NK_NEG              = 5,
    NK_MOD              = 6,
    NK_BITAND           = 7,
    NK_BITOR            = 8,
    NK_BITXOR           = 9,
    NK_SHL              = 10,
    NK_SHR              = 11,
    NK_EQ               = 12,
    NK_NE               = 13,
    NK_LT               = 14,
    NK_LE               = 15,
    NK_ASSIGN           = 16,
    NK_COND             = 17,
    NK_COMMA            = 18,
    NK_MEMBER           = 19,
    NK_ADDR             = 20,
    NK_DEREF            = 21,
    NK_NOT              = 22,
    NK_BITNOT           = 23,
    NK_LOGAND           = 24,
    NK_LOGOR            = 25,
    NK_RETURN           = 26,
    NK_IF               = 27,
    NK_FOR              = 28, /* also `while` */
    NK_DO               = 29,
    NK_SWITCH           = 30,
    NK_CASE             = 31,
    NK_BLOCK            = 32,
    NK_GOTO             = 33,
    NK_GOTO_EXPR        = 34,
    NK_LABEL            = 35,
    NK_LABEL_VAL        = 36,
    NK_FUNCALL          = 37,
    NK_EXPR_STMT        = 38,
    NK_STMT_EXPR        = 39,
    NK_VAR              = 40,
    NK_VLA_PTR          = 41,
    NK_NUM              = 42,
    NK_CAST             = 43,
    NK_MEMZERO          = 44,
    NK_ASM              = 45,
    NK_CAS              = 46,
    NK_EXCH             = 47,
    NK_FRAME_ADDR       = 48,
    NK_BLOCK_LITERAL    = 49,
    NK_BLOCK_CALL       = 50,
    NK_MACRO_CALL       = 51,
    NK_COMPLEX          = 52,
    NK_UNREACHABLE      = 53,
    NK_BITOP            = 54,
    NK_OVERFLOW_ARITH   = 55,
    NK_INIT_SPLICE      = 56,
    NK_ALOAD            = 57,
    NK_ASTORE           = 58,
    NK_RETURN_ADDR      = 59,
    NK_DYNOBJ_SIZE      = 60,
    NK_CONVERTVECTOR    = 61,
    NK_DECIMAL_TO_CHARS = 62,
    NK_FENCE            = 63,
    NK_QUOTE_LAZY       = 64,
    NK_DYNAMIC_CHECK    = 65,
    NK_VA_NAMED_COUNT   = 66,
} NodeKind;
 
typedef enum {
    AST_JUMP_GOTO     = 1,
    AST_JUMP_BREAK    = 2,
    AST_JUMP_CONTINUE = 3,
} AstJumpKind;
 
typedef enum {
    AST_BITOP_CLZ      = 1,
    AST_BITOP_CTZ      = 2,
    AST_BITOP_POPCOUNT = 3,
    AST_BITOP_PARITY   = 4,
    AST_BITOP_FFS      = 5,
    AST_BITOP_BSWAP    = 6,
} AstBitop;
 
typedef enum {
    AST_OVERFLOW_ADD = 1,
    AST_OVERFLOW_SUB = 2,
    AST_OVERFLOW_MUL = 3,
} AstOverflowOp;
 
typedef enum {
    ATTR_TARGET_TYPEDEF  = 1,
    ATTR_TARGET_TYPE     = 2,
    ATTR_TARGET_FUNCTION = 3,
    ATTR_TARGET_GLOBAL   = 4,
    ATTR_TARGET_MEMBER   = 5,
    ATTR_TARGET_PARAM    = 6,
} AttrTargetKind;
#endif // CCCC_REFLECTION_PROTOTYPES_ONLY
 
const char *__builtin_gensym(const char *prefix);
 
Node *__builtin_macroexpand_1(Node *node);
 
Node *__builtin_macroexpand(Node *node);
 
int __builtin_ast_vararg_count(void);
 
Node *__builtin_ast_vararg_at(int index);
 
Node **__builtin_ast_varargs_as_array(void);
 
const char *__builtin_ast_vararg_str_at(int index);
 
// ============================================================================
// Generated Node Source Locations (ticket #173)
// ============================================================================
 
Token *__builtin_ast_current_token(void);
 
Token *__builtin_ast_synthetic_token(const char *label);
 
Token *__builtin_ast_token_from_node(Node *node);
 
Node *__builtin_ast_set_token(Node *node, Token *tok);
 
Node *__builtin_ast_copy_location(Node *dst, Node *src);
 
Node *__builtin_ast_copy_node(Node *n);
 
// ============================================================================
// Macro Diagnostics (ticket #78)
// ============================================================================
 
void __builtin_macro_error_at(Node *node, const char *fmt, ...)
    __attribute__((format(printf, 2, 3)));
 
void __builtin_macro_warning_at(Node *node, const char *fmt, ...)
    __attribute__((format(printf, 2, 3)));
 
Node *__builtin_quote(const char *tmpl, ...);
 
Node *__builtin_quote_n(const char *tmpl, Node **nodes, int count);
 
Node *__builtin_quote_lazy(const char *tmpl, ...);
 
Node *__builtin_quote_lazy_n(const char *tmpl, Node **nodes, int count);
 
Node *__builtin_node_list(Node **nodes, int count);
 
// ============================================================================
// Type Lookup and Introspection
// ============================================================================
 
Type *__builtin_ast_find_type(const char *name);
 
bool __builtin_ast_type_exists(const char *name);
 
Type *__builtin_ast_get_type(const char *name);
 
TypeKind __builtin_ast_type_kind(Type *ty);
 
int __builtin_ast_type_size(Type *ty);
 
int __builtin_ast_type_align(Type *ty);
 
bool __builtin_ast_type_is_unsigned(Type *ty);
 
bool __builtin_ast_type_is_const(Type *ty);
 
Type *__builtin_ast_type_base(Type *ty);
 
int __builtin_ast_type_array_len(Type *ty);
 
Type *__builtin_ast_type_return_type(Type *ty);
 
int __builtin_ast_type_param_count(Type *ty);
 
Type *__builtin_ast_type_param_at(Type *ty, int index);
 
bool __builtin_ast_type_is_variadic(Type *ty);
 
const char *__builtin_ast_type_name(Type *ty);
 
const char *__builtin_ast_type_c_name(Type *ty);
 
Type *__builtin_ast_make_pointer(Type *base);
 
Type *__builtin_ast_make_array(Type *base, int length);
 
Type *__builtin_ast_make_func_ptr_type(Type *return_ty, Type **param_types,
                                       int nparams);
 
// Ticket #171: qualified type constructors
Type *__builtin_ast_make_const(Type *ty);
Type *__builtin_ast_make_volatile(Type *ty);
 
// ============================================================================
// Enum Reflection
// ============================================================================
 
int __builtin_ast_enum_count(Type *enum_type);
 
EnumConstant *__builtin_ast_enum_at(Type *enum_type, int index);
 
EnumConstant *__builtin_ast_enum_find(Type *enum_type, const char *name);
 
const char *__builtin_ast_enum_constant_name(EnumConstant *ec);
 
int64_t __builtin_ast_enum_constant_value(EnumConstant *ec);
 
const char *__builtin_ast_enum_name(Type *e);
 
int __builtin_ast_enum_value_count(Type *e);
 
const char *__builtin_ast_enum_value_name(Type *e, int index);
 
int64_t __builtin_ast_enum_value(Type *e, int index);
 
Node *__builtin_ast_enum_to_string_switch(Type *ty, Node *expr);
 
Node *__builtin_ast_enum_from_string_chain(Type *ty, Node *expr);
 
// ============================================================================
// Struct/Union Member Introspection
// ============================================================================
 
int __builtin_ast_struct_member_count(Type *struct_type);
 
Member *__builtin_ast_struct_member_at(Type *struct_type, int index);
 
Member *__builtin_ast_struct_member_find(Type *struct_type, const char *name);
 
const char *__builtin_ast_member_name(Member *m);
 
Type *__builtin_ast_member_type(Member *m);
 
int __builtin_ast_member_offset(Member *m);
 
bool __builtin_ast_member_is_bitfield(Member *m);
 
int __builtin_ast_member_bitfield_width(Member *m);
 
int64_t __builtin_ast_offsetof_chain(Type *ty, const char **names, int n);
 
// ============================================================================
// Global Symbol Introspection
// ============================================================================
 
Obj *__builtin_ast_find_global(const char *name);
 
int __builtin_ast_global_count(void);
 
Obj *__builtin_ast_global_at(int index);
 
const char *__builtin_ast_obj_name(Obj *obj);
 
Type *__builtin_ast_obj_type(Obj *obj);
 
bool __builtin_ast_obj_is_function(Obj *obj);
 
bool __builtin_ast_obj_is_definition(Obj *obj);
 
bool __builtin_ast_obj_is_static(Obj *obj);
 
Node *__builtin_ast_function_body(Obj *fn);
 
int __builtin_ast_function_param_count(Obj *fn);
 
Obj *__builtin_ast_function_param_at(Obj *fn, int index);
 
int __builtin_ast_function_local_count(Obj *fn);
 
Obj *__builtin_ast_function_local_at(Obj *fn, int index);
 
Obj *__builtin_ast_obj_next(Obj *obj);
 
NodeKind __builtin_ast_node_kind(Node *node);
 
Type *__builtin_ast_node_type(Node *node);
 
Node *__builtin_ast_node_next(Node *node);
 
Node *__builtin_ast_node_lhs(Node *node);
 
Node *__builtin_ast_node_rhs(Node *node);
 
Node *__builtin_ast_node_body(Node *node);
 
Node *__builtin_ast_node_cond(Node *node);
 
Node *__builtin_ast_node_then(Node *node);
 
Node *__builtin_ast_node_else(Node *node);
 
Node *__builtin_ast_node_init(Node *node);
 
Node *__builtin_ast_node_inc(Node *node);
 
int __builtin_ast_block_count(Node *block);
 
Node *__builtin_ast_block_at(Node *block, int index);
 
Node *__builtin_ast_call_callee(Node *call);
 
int __builtin_ast_call_arg_count(Node *call);
 
Node *__builtin_ast_call_arg_at(Node *call, int index);
 
long long __builtin_ast_node_int_value(Node *node);
 
double __builtin_ast_node_float_value(Node *node);
 
Obj *__builtin_ast_node_var_obj(Node *node);
 
Member *__builtin_ast_node_member(Node *node);
 
int __builtin_ast_switch_case_count(Node *sw);
 
Node *__builtin_ast_switch_case_at(Node *sw, int index);
 
Node *__builtin_ast_switch_default(Node *sw);
 
long long __builtin_ast_case_begin(Node *node);
 
long long __builtin_ast_case_end(Node *node);
 
Node *__builtin_ast_case_body(Node *node);
 
const char *__builtin_ast_macro_call_name(Node *node);
 
int __builtin_ast_macro_call_arg_count(Node *node);
 
Node *__builtin_ast_macro_call_arg_at(Node *node, int index);
 
Node *__builtin_ast_node_strip_implicit(Node *node);
 
const char *__builtin_ast_label_name(Node *node);
 
int __builtin_ast_goto_jump_kind(Node *node);
 
const char *__builtin_ast_asm_template(Node *node);
 
int __builtin_ast_asm_output_count(Node *node);
 
int __builtin_ast_asm_input_count(Node *node);
 
const char *__builtin_ast_asm_operand_constraint(Node *node, int index);
 
const char *__builtin_ast_asm_operand_name(Node *node, int index);
 
Node *__builtin_ast_asm_operand_expr(Node *node, int index);
 
int __builtin_ast_asm_clobber_count(Node *node);
 
const char *__builtin_ast_asm_clobber_at(Node *node, int index);
 
bool __builtin_ast_asm_is_volatile(Node *node);
 
bool __builtin_ast_asm_is_goto(Node *node);
 
int __builtin_ast_asm_goto_label_count(Node *node);
 
const char *__builtin_ast_asm_goto_label_at(Node *node, int index);
 
int __builtin_ast_atomic_order(Node *node);
 
int __builtin_ast_atomic_fail_order(Node *node);
 
bool __builtin_ast_atomic_is_weak(Node *node);
 
Node *__builtin_ast_cas_addr(Node *node);
 
Node *__builtin_ast_cas_expected(Node *node);
 
Node *__builtin_ast_cas_desired(Node *node);
 
bool __builtin_ast_fence_is_signal(Node *node);
 
int __builtin_ast_bitop_op(Node *node);
 
int __builtin_ast_bitop_width(Node *node);
 
int __builtin_ast_overflow_op(Node *node);
 
Node *__builtin_ast_overflow_result_ptr(Node *node);
 
int __builtin_attr_target_kind(AttrTarget *target);
 
const char *__builtin_attr_target_name(AttrTarget *target);
 
Type *__builtin_attr_target_type(AttrTarget *target);
 
Obj *__builtin_attr_target_obj(AttrTarget *target);
 
Token *__builtin_attr_target_token(AttrTarget *target);
 
Member *__builtin_attr_target_member(AttrTarget *target);
 
Type *__builtin_attr_target_owner(AttrTarget *target);
 
Type *__builtin_attr_target_param(AttrTarget *target);
 
int __builtin_attr_target_param_index(AttrTarget *target);
 
int __builtin_ast_member_has_attr(Member *m, const char *name);
 
int __builtin_ast_member_attr_arg_count(Member *m, const char *name);
 
Node *__builtin_ast_member_attr_arg(Member *m, const char *name, int index);
 
int __builtin_ast_member_attr_count(Member *m);
 
const char *__builtin_ast_member_attr_name_at(Member *m, int index);
 
int __builtin_ast_member_attr_arg_count_at(Member *m, int index);
 
Node *__builtin_ast_member_attr_arg_at(Member *m, int index, int arg);
 
int __builtin_ast_param_has_attr(Type *p, const char *name);
 
int __builtin_ast_param_attr_arg_count(Type *p, const char *name);
 
Node *__builtin_ast_param_attr_arg(Type *p, const char *name, int index);
 
int __builtin_ast_param_attr_count(Type *p);
 
const char *__builtin_ast_param_attr_name_at(Type *p, int index);
 
int __builtin_ast_param_attr_arg_count_at(Type *p, int index);
 
Node *__builtin_ast_param_attr_arg_at(Type *p, int index, int arg);
 
// ============================================================================
// AST Node Construction - Literals
// ============================================================================
 
Node *__builtin_ast_int_literal(int64_t value);
 
Node *__builtin_ast_float_literal(double value);
 
Node *__builtin_ast_string_literal(const char *str);
 
const char *__builtin_ast_string_literal_value(Node *node);
 
bool __builtin_ast_const_int_value(Node *node, int64_t *out);
 
bool __builtin_ast_const_uint_value(Node *node, uint64_t *out);
 
Node *__builtin_ast_var_ref(const char *name);
 
Node *__builtin_ast_param_ref(Obj *fn, const char *name);
 
// ============================================================================
// AST Node Construction - Expressions
// ============================================================================
 
Node *__builtin_ast_binary(NodeKind op, Node *left, Node *right);
 
Node *__builtin_ast_unary(NodeKind op, Node *operand);
 
Node *__builtin_ast_cast(Node *expr, Type *target_type);
 
// Ticket #171: new expression builders
 
Node *__builtin_ast_cond(Node *cond, Node *then_expr, Node *else_expr);
 
Node *__builtin_ast_null(void);
 
Node *__builtin_ast_sizeof_type(Type *ty);
 
Node *__builtin_ast_alignof_type(Type *ty);
 
Node *__builtin_ast_sizeof_expr(Node *expr);
 
Node *__builtin_ast_subscript(Node *arr, Node *idx);
 
Node *__builtin_ast_comma(Node *lhs, Node *rhs);
 
// ============================================================================
// AST Node Construction - Statements
// ============================================================================
 
Node *__builtin_ast_return(Node *expr);
 
Node *__builtin_ast_block(Node **stmts, int count);
 
Node *__builtin_ast_block_add_stmt(Node *block, Node *stmt);
 
Node *__builtin_ast_if(Node *cond, Node *then_body, Node *else_body);
 
Node *__builtin_ast_switch(Node *cond);
 
void __builtin_ast_switch_add_case(Node *switch_node, Node *value, Node *body);
 
void __builtin_ast_switch_set_default(Node *switch_node, Node *body);
 
Node *__builtin_ast_expr_stmt(Node *expr);
 
// ============================================================================
// AST Node Construction - Local Variable Injection (ticket #77)
// ============================================================================
 
Node *__builtin_ast_local_var(const char *name, Type *ty);
 
Node *__builtin_ast_local_var_unique(Type *ty);
 
Node *__builtin_ast_assign(Node *target, Node *value);
 
Node *__builtin_ast_member(Node *obj, const char *name);
 
Node *__builtin_ast_funcall(Node *callee, Node **args, int n);
 
Node *__builtin_ast_while(Node *cond, Node *body);
 
Node *__builtin_ast_for(Node *init, Node *cond, Node *inc, Node *body);
 
Node *__builtin_ast_do_while(Node *body, Node *cond);
 
// ============================================================================
// Loop-building context (ticket #1249)
// ============================================================================
 
void __builtin_ast_push_loop(Node *loop);
 
void __builtin_ast_pop_loop(void);
 
Node *__builtin_ast_loop_set_body(Node *loop, Node *body);
 
// ============================================================================
// Function Generation
// ============================================================================
 
Obj *__builtin_ast_function(const char *name, Type *return_type);
 
Node *__builtin_ast_publish(Obj *obj, Token *tok);
 
Node *__builtin_ast_publish_type(Type *ty, Token *tok);
 
void __builtin_emit_directive(const char *line);
 
void __builtin_ast_function_add_param(Obj *fn, const char *name, Type *type);
 
void __builtin_ast_function_set_body(Obj *fn, Node *body);
 
void __builtin_ast_function_set_static(Obj *fn, bool is_static);
 
void __builtin_ast_function_set_inline(Obj *fn, bool is_inline);
 
void __builtin_ast_function_set_variadic(Obj *fn, bool is_variadic);
 
// Ticket #171: function prototype (forward declaration only, no body)
Obj *__builtin_ast_function_prototype(const char *name, Type *return_type);
 
// ============================================================================
// Programmatic Attribute Application — ticket #619
// ============================================================================
 
void __builtin_ast_add_attribute(Obj *fn, const char *attr_text);
 
// Internal helper for MarkAsBuildTarget: composes "cccc::build_target(kind=…)"
// at runtime so the macro doesn't require string concatenation.
void __builtin_ast_add_build_target_attr(Obj *fn, const char *kind);
 
// Ticket #171: struct/union/enum/typedef type builders
 
Type *__builtin_ast_make_struct(const char *name);
 
Type *__builtin_ast_make_union(const char *name);
 
Type *__builtin_ast_struct_add_field(Type *ty, const char *name,
                                     Type *field_type);
 
Type *__builtin_ast_make_enum(const char *name);
 
void __builtin_ast_enum_add_constant(Type *ty, const char *name, int64_t value);
 
Type *__builtin_ast_make_typedef(const char *name, Type *underlying);
 
// ============================================================================
// Global Variable Generation (ticket #152)
// ============================================================================
 
Obj *__builtin_ast_global_var(const char *name, Type *ty);
 
void __builtin_ast_global_var_set_init_data(Obj *var, const char *data,
                                            int len);
 
void __builtin_ast_global_var_set_static(Obj *var, bool is_static);
 
// ============================================================================
// Function-building context (ticket #148)
// ============================================================================
 
void __builtin_ast_push_fn(Obj *fn);
 
void __builtin_ast_pop_fn(void);
 
void __builtin_ast_push_block(Node *block);
void __builtin_ast_pop_block(void);
Node *__builtin_ast_block_add_current_stmt(Node *stmt);
 
void __builtin_ast_push_struct(Type *ty);
void __builtin_ast_pop_struct(void);
Type *__builtin_ast_struct_add_current_field(const char *name,
                                             Type       *field_type);
 
void __builtin_ast_push_switch(Node *switch_node);
void __builtin_ast_pop_switch(void);
void __builtin_ast_switch_add_current_case(Node *value, Node *body);
void __builtin_ast_switch_set_current_default(Node *body);
 
void __builtin_ast_push_enum(Type *ty);
void __builtin_ast_pop_enum(void);
void __builtin_ast_enum_add_current_constant(const char *name, int value);
 
// ============================================================================
// AST Dump Functions (ticket #58) — Nim-style dumpTree / dumpAstGen
// ============================================================================
 
void __builtin_dump_tree(Node *node);
 
const char *__builtin_dump_tree_to_string(Node *node);
 
void __builtin_dump_ast_gen(Node *node);
 
const char *__builtin_dump_ast_gen_to_string(Node *node);
 
// ============================================================================
// Convenience Macros (automatically pass VM)
// ============================================================================
 
// Quasi-quoting helpers (ticket #1, #172)
#define Quote(tmpl, ...) __builtin_quote(tmpl, ##__VA_ARGS__)
#define QuoteN(tmpl, nodes, count) __builtin_quote_n(tmpl, nodes, count)
#define QuoteLazy(tmpl, ...) __builtin_quote_lazy(tmpl, ##__VA_ARGS__)
#define QuoteLazyN(tmpl, nodes, count)                                         \
    __builtin_quote_lazy_n(tmpl, nodes, count)
// Build a ->next-linked chain from a compound-literal array for $@k splices:
//   NodeList((Node*[]){ a, b, c }, 3)
#define NodeList(nodes, count) __builtin_node_list(nodes, count)
 
// Diagnostic helpers (ticket #78) — note: variadic macros require C99+
#define MacroErrorAt(node, ...) __builtin_macro_error_at(node, __VA_ARGS__)
#define MacroWarningAt(node, ...) __builtin_macro_warning_at(node, __VA_ARGS__)
 
// AST dump helpers (ticket #58)
#define DumpTree(node) __builtin_dump_tree(node)
#define DumpTreeToString(node) __builtin_dump_tree_to_string(node)
#define DumpAstGen(node) __builtin_dump_ast_gen(node)
#define DumpAstGenToString(node) __builtin_dump_ast_gen_to_string(node)
#define Gensym(prefix) __builtin_gensym(prefix)
#define MacroExpand1(node) __builtin_macroexpand_1(node)
#define MacroExpand(node) __builtin_macroexpand(node)
#define VarargCount() __builtin_ast_vararg_count()
#define VarargAt(i) __builtin_ast_vararg_at(i)
#define VarargAsArray() __builtin_ast_varargs_as_array()
#define VarargStrAt(i)                           __builtin_ast_vararg_str_at(i)
 
#define __builtin_dispatch_2(_1, _2, which, ...) which(_1, _2)
#define __builtin_dispatch_3(_1, _2, _3, which, ...) which(_1, _2, _3)
 
#define CurrentToken() __builtin_ast_current_token()
#define SyntheticToken(label) __builtin_ast_synthetic_token(label)
#define TokenFromNode(node) __builtin_ast_token_from_node(node)
#define SetToken(node, tok) __builtin_ast_set_token(node, tok)
#define CopyLocation(dst, src) __builtin_ast_copy_location(dst, src)
#define CopyNode(n) __builtin_ast_copy_node(n)
 
#define FindType(name) __builtin_ast_find_type(name)
#define TypeExists(name) __builtin_ast_type_exists(name)
#define GetType(name) __builtin_ast_get_type(name)
 
// Type introspection — no VM needed
#define GetTypeKind(ty) __builtin_ast_type_kind(ty)
#define TypeSize(ty) __builtin_ast_type_size(ty)
#define TypeAlign(ty) __builtin_ast_type_align(ty)
#define TypeIsUnsigned(ty) __builtin_ast_type_is_unsigned(ty)
#define TypeIsConst(ty) __builtin_ast_type_is_const(ty)
#define TypeBase(ty) __builtin_ast_type_base(ty)
#define TypeArrayLen(ty) __builtin_ast_type_array_len(ty)
#define TypeReturnType(ty) __builtin_ast_type_return_type(ty)
#define TypeParamCount(ty) __builtin_ast_type_param_count(ty)
#define TypeParamAt(ty, i) __builtin_ast_type_param_at(ty, i)
#define TypeIsVariadic(ty) __builtin_ast_type_is_variadic(ty)
#define TypeName(ty) __builtin_ast_type_name(ty)
#define TypeCName(ty) __builtin_ast_type_c_name(ty)
 
#define MakeIntLiteral(val) __builtin_ast_int_literal(val)
#define MakeFloatLiteral(val) __builtin_ast_float_literal(val)
#define MakeStringLiteral(str) __builtin_ast_string_literal(str)
#define StringLiteralValue(node) __builtin_ast_string_literal_value(node)
#define ConstIntValue(node, out) __builtin_ast_const_int_value(node, out)
#define ConstUIntValue(node, out) __builtin_ast_const_uint_value(node, out)
#define MakeVarRef(name) __builtin_ast_var_ref(name)
#define MakeParamRef(fn, name) __builtin_ast_param_ref(fn, name)
 
#define MakeBinary(op, l, r) __builtin_ast_binary(op, l, r)
#define MakeUnary(op, operand) __builtin_ast_unary(op, operand)
#define MakeCast(expr, ty) __builtin_ast_cast(expr, ty)
 
// Ticket #171: new expression builders
// Ternary conditional: cond ? then_expr : else_expr
#define MakeCond(c, t, e) __builtin_ast_cond(c, t, e)
// Typed null pointer: (void *)0
#define MakeNull() __builtin_ast_null()
// sizeof(type) / _Alignof(type) as a compile-time integer literal
#define MakeSizeofType(ty) __builtin_ast_sizeof_type(ty)
#define MakeAlignofType(ty) __builtin_ast_alignof_type(ty)
// sizeof(expr): resolves expr's type then returns its size as an integer
// literal
#define MakeSizeofExpr(expr) __builtin_ast_sizeof_expr(expr)
// Array subscript: arr[idx] (desugared as *(arr+idx))
#define MakeSubscript(arr, idx) __builtin_ast_subscript(arr, idx)
// Comma expression: evaluate lhs (for side effects), yield rhs
#define MakeComma(lhs, rhs) __builtin_ast_comma(lhs, rhs)
 
#define MakeReturn(expr) __builtin_ast_return(expr)
#define MakeBlock(stmts, count) __builtin_ast_block(stmts, count)
#define __builtin_block_add_stmt_1(stmt, _ignored)                             \
    __builtin_ast_block_add_current_stmt(stmt)
#define __builtin_block_add_stmt_2(block, stmt)                                \
    __builtin_ast_block_add_stmt(block, stmt)
#define BlockAddStmt(...)                                                      \
    __builtin_dispatch_2(__VA_ARGS__, __builtin_block_add_stmt_2,              \
                         __builtin_block_add_stmt_1)
#define MakeIf(c, t, e) __builtin_ast_if(c, t, e)
#define MakeSwitch(cond) __builtin_ast_switch(cond)
#define __builtin_switch_add_case_2(v, b, _ignored)                            \
    __builtin_ast_switch_add_current_case(v, b)
#define __builtin_switch_add_case_3(sw, v, b)                                  \
    __builtin_ast_switch_add_case(sw, v, b)
#define SwitchAddCase(...)                                                     \
    __builtin_dispatch_3(__VA_ARGS__, __builtin_switch_add_case_3,             \
                         __builtin_switch_add_case_2)
#define __builtin_switch_set_default_1(b, _ignored)                            \
    __builtin_ast_switch_set_current_default(b)
#define __builtin_switch_set_default_2(sw, b)                                  \
    __builtin_ast_switch_set_default(sw, b)
#define SwitchSetDefault(...)                                                  \
    __builtin_dispatch_2(__VA_ARGS__, __builtin_switch_set_default_2,          \
                         __builtin_switch_set_default_1)
#define MakeExprStmt(expr) __builtin_ast_expr_stmt(expr)
#define MakeLocalVar(name, ty) __builtin_ast_local_var(name, ty)
#define MakeLocalVarUnique(ty) __builtin_ast_local_var_unique(ty)
#define MakeAssign(target, value) __builtin_ast_assign(target, value)
#define MakeMember(obj, name) __builtin_ast_member(obj, name)
#define MakeFuncCall(callee, args, n) __builtin_ast_funcall(callee, args, n)
 
// Thin AST wrappers over <string.h> functions, available via the implicit
// #include <string.h> at the top of this header.
#define Memcpy(dst, src, n)                                                    \
    __builtin_ast_funcall(__builtin_ast_var_ref("memcpy"),                     \
                          (Node *[]){(dst), (src), (n)}, 3)
#define Strlen(s)                                                              \
    __builtin_ast_funcall(__builtin_ast_var_ref("strlen"), (Node *[]){(s)}, 1)
#define Strcmp(a, b)                                                           \
    __builtin_ast_funcall(__builtin_ast_var_ref("strcmp"),                     \
                          (Node *[]){(a), (b)}, 2)
#define MakeWhile(cond, body) __builtin_ast_while(cond, body)
#define MakeFor(init, cond, inc, body) __builtin_ast_for(init, cond, inc, body)
#define MakeDoWhile(body, cond) __builtin_ast_do_while(body, cond)
#define LoopSetBody(loop, body) __builtin_ast_loop_set_body(loop, body)
#define WithLoop(loop)                                                         \
    for (int _cccc_loop_ctx_ = (__builtin_ast_push_loop((loop)), 1);           \
         _cccc_loop_ctx_; _cccc_loop_ctx_ = (__builtin_ast_pop_loop(), 0))
 
#define MakePointer(base) __builtin_ast_make_pointer(base)
#define MakeArray(base, len) __builtin_ast_make_array(base, len)
#define MakeFuncPtrType(ret, params, n)                                        \
    __builtin_ast_make_func_ptr_type(ret, params, n)
 
// Ticket #171: qualified type constructors
#define MakeConst(ty) __builtin_ast_make_const(ty)
#define MakeVolatile(ty) __builtin_ast_make_volatile(ty)
 
#define EnumCount(ty) __builtin_ast_enum_count(ty)
#define EnumAt(ty, i) __builtin_ast_enum_at(ty, i)
#define EnumFind(ty, name) __builtin_ast_enum_find(ty, name)
#define EnumConstantName(ec) __builtin_ast_enum_constant_name(ec)
#define EnumConstantValue(ec) __builtin_ast_enum_constant_value(ec)
#define EnumName(ty) __builtin_ast_enum_name(ty)
#define EnumValueCount(ty) __builtin_ast_enum_value_count(ty)
#define EnumValueName(ty, i) __builtin_ast_enum_value_name(ty, i)
#define EnumValue(ty, i) __builtin_ast_enum_value(ty, i)
 
#define EnumToString(ty, expr) __builtin_ast_enum_to_string_switch(ty, expr)
#define EnumFromString(ty, expr) __builtin_ast_enum_from_string_chain(ty, expr)
 
#define StructMemberCount(ty) __builtin_ast_struct_member_count(ty)
#define StructMemberAt(ty, i) __builtin_ast_struct_member_at(ty, i)
#define StructMemberFind(ty, name) __builtin_ast_struct_member_find(ty, name)
#define MemberName(m) __builtin_ast_member_name(m)
#define MemberType(m) __builtin_ast_member_type(m)
#define MemberOffset(m) __builtin_ast_member_offset(m)
#define MemberIsBitfield(m) __builtin_ast_member_is_bitfield(m)
#define MemberBitfieldWidth(m) __builtin_ast_member_bitfield_width(m)
 
// ForeachMember(type, varname, body) — host-side (comptime
// C) loop over the members of a struct/union type. `varname` is bound to
// each Member* in turn; `body` is a compound statement run once per
// member at macro-evaluation time (typically building AST nodes via
// BlockAddStmt etc.). Two-layer __COUNTER__ indirection gives each
// call-site unique loop-variable names so ForeachMember can be nested.
#define __builtin_foreach_member_body(type, varname, body, uid)                  \
    do {                                                                         \
        Type *__builtin_fem_ty_##uid = (type);                                   \
        int   __builtin_fem_n_##uid = StructMemberCount(__builtin_fem_ty_##uid); \
        for (int __builtin_fem_i_##uid = 0;                                      \
             __builtin_fem_i_##uid < __builtin_fem_n_##uid;                      \
             __builtin_fem_i_##uid++) {                                          \
            Member *varname =                                                    \
                StructMemberAt(__builtin_fem_ty_##uid, __builtin_fem_i_##uid);   \
            body                                                                 \
        }                                                                        \
    } while (0)
#define __builtin_foreach_member_uid(type, varname, body, uid)                 \
    __builtin_foreach_member_body(type, varname, body, uid)
#define ForeachMember(type, varname, body)                                     \
    __builtin_foreach_member_uid(type, varname, body, __COUNTER__)
 
#define OffsetofChain(type, ...)                                               \
    MakeIntLiteral(__builtin_ast_offsetof_chain(                               \
        type, (const char *[]){__VA_ARGS__},                                   \
        (int)(sizeof((const char *[]){__VA_ARGS__}) / sizeof(const char *))))
 
#define FindGlobal(name) __builtin_ast_find_global(name)
#define GlobalCount() __builtin_ast_global_count()
#define GlobalAt(i) __builtin_ast_global_at(i)
#define ObjName(obj) __builtin_ast_obj_name(obj)
#define ObjType(obj) __builtin_ast_obj_type(obj)
#define ObjIsFunction(obj) __builtin_ast_obj_is_function(obj)
#define ObjIsDefinition(obj) __builtin_ast_obj_is_definition(obj)
#define ObjIsStatic(obj) __builtin_ast_obj_is_static(obj)
#define FnBody(fn) __builtin_ast_function_body(fn)
#define FnParamCount(fn) __builtin_ast_function_param_count(fn)
#define FnParamAt(fn, i) __builtin_ast_function_param_at(fn, i)
#define FnLocalCount(fn) __builtin_ast_function_local_count(fn)
#define FnLocalAt(fn, i) __builtin_ast_function_local_at(fn, i)
#define ObjNext(obj) __builtin_ast_obj_next(obj)
#define GetNodeKind(node) __builtin_ast_node_kind(node)
#define GetNodeType(node) __builtin_ast_node_type(node)
#define NodeNext(node) __builtin_ast_node_next(node)
#define NodeLhs(node) __builtin_ast_node_lhs(node)
#define NodeRhs(node) __builtin_ast_node_rhs(node)
#define NodeBody(node) __builtin_ast_node_body(node)
#define NodeCond(node) __builtin_ast_node_cond(node)
#define NodeThen(node) __builtin_ast_node_then(node)
#define NodeElse(node) __builtin_ast_node_else(node)
#define NodeInit(node) __builtin_ast_node_init(node)
#define NodeInc(node) __builtin_ast_node_inc(node)
#define BlockCount(block) __builtin_ast_block_count(block)
#define BlockAt(block, i) __builtin_ast_block_at(block, i)
#define CallCallee(call) __builtin_ast_call_callee(call)
#define CallArgCount(call) __builtin_ast_call_arg_count(call)
#define CallArgAt(call, i) __builtin_ast_call_arg_at(call, i)
#define NodeIntValue(node) __builtin_ast_node_int_value(node)
#define NodeFloatValue(node) __builtin_ast_node_float_value(node)
#define NodeVarObj(node) __builtin_ast_node_var_obj(node)
#define NodeMember(node) __builtin_ast_node_member(node)
#define SwitchCaseCount(sw) __builtin_ast_switch_case_count(sw)
#define SwitchCaseAt(sw, i) __builtin_ast_switch_case_at(sw, i)
#define SwitchDefault(sw) __builtin_ast_switch_default(sw)
#define CaseBegin(node) __builtin_ast_case_begin(node)
#define CaseEnd(node) __builtin_ast_case_end(node)
#define CaseBody(node) __builtin_ast_case_body(node)
#define MacroCallName(node) __builtin_ast_macro_call_name(node)
#define MacroCallArgCount(node) __builtin_ast_macro_call_arg_count(node)
#define MacroCallArgAt(node, i) __builtin_ast_macro_call_arg_at(node, i)
#define StripImplicit(node) __builtin_ast_node_strip_implicit(node)
#define LabelName(node) __builtin_ast_label_name(node)
#define GotoJumpKind(node) __builtin_ast_goto_jump_kind(node)
#define AsmTemplate(node) __builtin_ast_asm_template(node)
#define AsmOutputCount(node) __builtin_ast_asm_output_count(node)
#define AsmInputCount(node) __builtin_ast_asm_input_count(node)
#define AsmOperandConstraint(node, i)                                          \
    __builtin_ast_asm_operand_constraint(node, i)
#define AsmOperandName(node, i) __builtin_ast_asm_operand_name(node, i)
#define AsmOperandExpr(node, i) __builtin_ast_asm_operand_expr(node, i)
#define AsmClobberCount(node) __builtin_ast_asm_clobber_count(node)
#define AsmClobberAt(node, i) __builtin_ast_asm_clobber_at(node, i)
#define AsmIsVolatile(node) __builtin_ast_asm_is_volatile(node)
#define AsmIsGoto(node) __builtin_ast_asm_is_goto(node)
#define AsmGotoLabelCount(node) __builtin_ast_asm_goto_label_count(node)
#define AsmGotoLabelAt(node, i) __builtin_ast_asm_goto_label_at(node, i)
#define AtomicOrder(node) __builtin_ast_atomic_order(node)
#define AtomicFailOrder(node) __builtin_ast_atomic_fail_order(node)
#define AtomicIsWeak(node) __builtin_ast_atomic_is_weak(node)
#define CasAddr(node) __builtin_ast_cas_addr(node)
#define CasExpected(node) __builtin_ast_cas_expected(node)
#define CasDesired(node) __builtin_ast_cas_desired(node)
#define FenceIsSignal(node) __builtin_ast_fence_is_signal(node)
#define BitopOp(node) __builtin_ast_bitop_op(node)
#define BitopWidth(node) __builtin_ast_bitop_width(node)
#define OverflowOp(node) __builtin_ast_overflow_op(node)
#define OverflowResultPtr(node) __builtin_ast_overflow_result_ptr(node)
#define GetAttrTargetKind(target) __builtin_attr_target_kind(target)
#define AttrTargetName(target) __builtin_attr_target_name(target)
#define AttrTargetType(target) __builtin_attr_target_type(target)
#define AttrTargetObj(target) __builtin_attr_target_obj(target)
#define AttrTargetToken(target) __builtin_attr_target_token(target)
#define AttrTargetMember(target) __builtin_attr_target_member(target)
#define AttrTargetOwner(target) __builtin_attr_target_owner(target)
#define AttrTargetParam(target) __builtin_attr_target_param(target)
#define AttrTargetParamIndex(target) __builtin_attr_target_param_index(target)
#define MemberHasAttr(m, name) __builtin_ast_member_has_attr(m, name)
#define MemberAttrArgCount(m, name) __builtin_ast_member_attr_arg_count(m, name)
#define MemberAttrArg(m, name, i) __builtin_ast_member_attr_arg(m, name, i)
#define MemberAttrCount(m) __builtin_ast_member_attr_count(m)
#define MemberAttrNameAt(m, i) __builtin_ast_member_attr_name_at(m, i)
#define MemberAttrArgCountAt(m, i) __builtin_ast_member_attr_arg_count_at(m, i)
#define MemberAttrArgAt(m, i, j) __builtin_ast_member_attr_arg_at(m, i, j)
#define ParamHasAttr(p, name) __builtin_ast_param_has_attr(p, name)
#define ParamAttrArgCount(p, name) __builtin_ast_param_attr_arg_count(p, name)
#define ParamAttrArg(p, name, i) __builtin_ast_param_attr_arg(p, name, i)
#define ParamAttrCount(p) __builtin_ast_param_attr_count(p)
#define ParamAttrNameAt(p, i) __builtin_ast_param_attr_name_at(p, i)
#define ParamAttrArgCountAt(p, i) __builtin_ast_param_attr_arg_count_at(p, i)
#define ParamAttrArgAt(p, i, j) __builtin_ast_param_attr_arg_at(p, i, j)
 
#define MakeFunction(name, ret_type) __builtin_ast_function(name, ret_type)
#define PublishNode(decl)                                                      \
    _Generic((decl),                                                           \
        Obj *: __builtin_ast_publish,                                          \
        Type *: __builtin_ast_publish_type)((decl), 0)
#define PublishNodeAt(decl, tok)                                               \
    _Generic((decl),                                                           \
        Obj *: __builtin_ast_publish,                                          \
        Type *: __builtin_ast_publish_type)((decl), (tok))
#define EmitDirective(line) __builtin_emit_directive(line)
#define FunctionAddParam(fn, name, type)                                       \
    __builtin_ast_function_add_param(fn, name, type)
#define FunctionSetBody(fn, body) __builtin_ast_function_set_body(fn, body)
#define FunctionSetStatic(fn, is_static)                                       \
    __builtin_ast_function_set_static(fn, is_static)
#define FunctionSetInline(fn, is_inline)                                       \
    __builtin_ast_function_set_inline(fn, is_inline)
#define FunctionSetVariadic(fn, is_variadic)                                   \
    __builtin_ast_function_set_variadic(fn, is_variadic)
 
// Ticket #171: function forward declaration / prototype builder
// Creates a declaration-only Obj (no body); use FunctionAddParam for
// parameters and PublishNode to make it visible in scope.
#define FunctionPrototype(name, ret) __builtin_ast_function_prototype(name, ret)
 
// Mode attribute registration for AST-generated functions.
// Ticket #619: generic attribute application and convenience shorthands.
// Use AddAttribute(fn, "cccc::test(suite=\"s\", timeout=5000)") for
// fine-grained control.
#define AddAttribute(fn, text) __builtin_ast_add_attribute(fn, text)
#define MarkAsTest(fn) AddAttribute(fn, "cccc::test")
#define MarkAsBuild(fn) AddAttribute(fn, "cccc::build")
#define MarkAsBuildTarget(fn, kind)                                            \
    __builtin_ast_add_build_target_attr(fn, kind)
 
// Ticket #171: struct/union/enum/typedef type builders
// Build a new named aggregate and expose it so GetType(name) resolves it.
//
//   Type *s = MakeStruct("Point");
//   StructAddField(s, "x", GetType("int"));
//   StructAddField(s, "y", GetType("int"));
//
// StructAddField works for both struct and union types.
// MakeTypedef registers name as an alias for underlying and returns it.
// EnumAddConstant adds a constant to the enum AND to scope (usable as int).
#define MakeStruct(name) __builtin_ast_make_struct(name)
#define MakeUnion(name) __builtin_ast_make_union(name)
#define __builtin_struct_add_field_2(name, field_type, _ignored)               \
    __builtin_ast_struct_add_current_field(name, field_type)
#define __builtin_struct_add_field_3(ty, name, field_type)                     \
    __builtin_ast_struct_add_field(ty, name, field_type)
#define StructAddField(...)                                                    \
    __builtin_dispatch_3(__VA_ARGS__, __builtin_struct_add_field_3,            \
                         __builtin_struct_add_field_2)
#define MakeEnum(name) __builtin_ast_make_enum(name)
#define __builtin_enum_add_constant_2(name, value, _ignored)                   \
    __builtin_ast_enum_add_current_constant(name, value)
#define __builtin_enum_add_constant_3(ty, name, value)                         \
    __builtin_ast_enum_add_constant(ty, name, value)
#define EnumAddConstant(...)                                                   \
    __builtin_dispatch_3(__VA_ARGS__, __builtin_enum_add_constant_3,           \
                         __builtin_enum_add_constant_2)
#define MakeTypedef(name, underlying)                                          \
    __builtin_ast_make_typedef(name, underlying)
 
// Comptime variable access (ticket #188)
int64_t __builtin_get_comptime_int(const char *name);
double __builtin_get_comptime_float(const char *name);
Node *__builtin_get_comptime_var(const char *name);
Node *__builtin_get_comptime_ptr(const char *name);
Node *__builtin_get_comptime_member(const char *var_name, const char *field);
 
#define GetComptimeInt(name) __builtin_get_comptime_int(name)
#define GetComptimeFloat(name) __builtin_get_comptime_float(name)
#define GetComptimeVar(name) __builtin_get_comptime_var(name)
#define GetComptimePtr(name) __builtin_get_comptime_ptr(name)
#define GetComptimeMember(var, field) __builtin_get_comptime_member(var, field)
 
// Constexpr variable access (ticket #189)
Node *__builtin_get_constexpr_value(const char *name);
 
#define GetConstexprValue(name) __builtin_get_constexpr_value(name)
 
// ============================================================================
// Initializer Builders (ticket #296)
// ============================================================================
 
Node *__builtin_ast_compound_literal(Type *ty, Node **inits, int n);
 
Node *__builtin_ast_init_array(Type *elem_ty, Node **elems, int n);
 
Node *__builtin_ast_init_struct(Type *ty, const char **fields, Node **values,
                                int n);
 
#define CompoundLiteral(ty, ...)                                               \
    __builtin_ast_compound_literal(                                            \
        ty, (Node *[]){__VA_ARGS__},                                           \
        (int)(sizeof((Node *[]){__VA_ARGS__}) / sizeof(Node *)))
 
#define InitArray(elem_ty, ...)                                                \
    __builtin_ast_init_array(                                                  \
        elem_ty, (Node *[]){__VA_ARGS__},                                      \
        (int)(sizeof((Node *[]){__VA_ARGS__}) / sizeof(Node *)))
 
#define InitStruct(ty, fields, values, n)                                      \
    __builtin_ast_init_struct(ty, fields, values, n)
 
// ============================================================================
// Serialization
// ============================================================================
 
Node *__builtin_ast_serialize(Type *ty, Node *expr, Node *buf);
 
Node *__builtin_ast_deserialize(Type *ty, Node *buf);
 
#define Serialize(ty, expr, buf) __builtin_ast_serialize(ty, expr, buf)
#define Deserialize(ty, buf) __builtin_ast_deserialize(ty, buf)
 
// Global variable generation (ticket #152)
#define GlobalVar(name, ty) __builtin_ast_global_var(name, ty)
#define GlobalVarSetInitData(var, data, len)                                   \
    __builtin_ast_global_var_set_init_data(var, data, len)
#define GlobalVarSetStatic(var, is_static)                                     \
    __builtin_ast_global_var_set_static(var, is_static)
 
// Function-building context (ticket #148)
// Usage:
//   WithFn(fn) {
//       FunctionSetBody(fn, Quote("return 42;"));
//   }
// Inside the block, current_fn is set to fn so Quote("return x;") casts
// to the correct return type.  The pop always runs even on early exit.
#define WithFn(fn)                                                             \
    for (int _cccc_fn_ctx_ = (__builtin_ast_push_fn((fn)), 1); _cccc_fn_ctx_;  \
         _cccc_fn_ctx_     = (__builtin_ast_pop_fn(), 0))
 
#define WithBlock(block)                                                       \
    for (int _cccc_block_ctx_ = (__builtin_ast_push_block((block)), 1);        \
         _cccc_block_ctx_; _cccc_block_ctx_ = (__builtin_ast_pop_block(), 0))
 
#define WithStruct(ty)                                                         \
    for (int _cccc_struct_ctx_ = (__builtin_ast_push_struct((ty)), 1);         \
         _cccc_struct_ctx_;                                                    \
         _cccc_struct_ctx_ = (__builtin_ast_pop_struct(), 0))
 
#define WithSwitch(sw)                                                         \
    for (int _cccc_switch_ctx_ = (__builtin_ast_push_switch((sw)), 1);         \
         _cccc_switch_ctx_;                                                    \
         _cccc_switch_ctx_ = (__builtin_ast_pop_switch(), 0))
 
#define WithEnum(ty)                                                            \
    for (int _cccc_enum_ctx_              = (__builtin_ast_push_enum((ty)), 1); \
         _cccc_enum_ctx_; _cccc_enum_ctx_ = (__builtin_ast_pop_enum(), 0))
 
// GenerateSum/GenerateMap/GenerateReduce/GenerateFilter
// -- FP-style array generators. Each publishes a single function named after
// elem_ty's spelling (via TypeCName, since builtin scalar types have no
// TypeName): sum_<T>, map_<T>, reduce_<T>, filter_<T>. Implemented as plain
// C functions in reflection.c (registered via cc_register_cfunc) rather than
// @comptime functions, so they're callable from any [[cccc::comptime]] context,
// not just from within reflection.h's own macro program.
 
void __builtin_generate_sum(Type *elem_ty);
 
void __builtin_generate_map(Type *elem_ty);
 
void __builtin_generate_reduce(Type *elem_ty);
 
void __builtin_generate_filter(Type *elem_ty);
 
#define GenerateSum(elem_type) __builtin_generate_sum(elem_type)
#define GenerateMap(elem_type) __builtin_generate_map(elem_type)
#define GenerateReduce(elem_type) __builtin_generate_reduce(elem_type)
#define GenerateFilter(elem_type) __builtin_generate_filter(elem_type)
 
#ifdef __cplusplus
}
#endif
 
#endif // CCCC_REFLECTION_H