HomePhorge
Diffusion Ant (mir/inline-method) Code

ant/src/silver/compile_ctx.c
3fa05edd2fe3mir/inline-method

Last Change
Raw File

compile_ctx.c
View Options

#include "silver/compiler.h"
#include "silver/compile_ctx.h"
#include <stdlib.h>
#include <string.h>
static void sv_compile_ctx_rebuild_local_lookup(sv_compiler_t *ctx, int cap) {
if (cap < 16) cap = 16;
int *heads = malloc((size_t)cap * sizeof(int));
if (!heads) return;
for (int i = 0; i < cap; i++) heads[i] = -1;
for (int i = 0; i < ctx->local_count; i++) {
sv_local_t *loc = &ctx->locals[i];
int bucket = (int)(loc->name_hash & (uint32_t)(cap - 1));
loc->lookup_next = heads[bucket];
heads[bucket] = i;
}
free(ctx->local_lookup_heads);
ctx->local_lookup_heads = heads;
ctx->local_lookup_cap = cap;
}
void sv_compile_ctx_init_root(
sv_compiler_t *ctx, ant_t *js,
const char *filename,
const char *source,
ant_offset_t source_len,
sv_compile_mode_t mode,
bool is_strict,
sv_line_table_t *line_table
) {
memset(ctx, 0, sizeof(*ctx));
ctx->js = js;
ctx->filename = filename;
ctx->source = source;
ctx->source_len = source_len;
ctx->mode = mode;
ctx->is_strict = is_strict;
ctx->strict_args_local = -1;
ctx->new_target_local = -1;
ctx->super_local = -1;
ctx->using_stack_local = -1;
ctx->line_table = line_table;
}
void sv_compile_ctx_init_child(
sv_compiler_t *ctx,
sv_compiler_t *enclosing,
sv_ast_t *node,
sv_compile_mode_t mode
) {
memset(ctx, 0, sizeof(*ctx));
ctx->js = enclosing->js;
ctx->filename = enclosing->filename;
ctx->source = enclosing->source;
ctx->source_len = enclosing->source_len;
ctx->line_table = enclosing->line_table;
ctx->enclosing = enclosing;
ctx->scope_depth = 0;
ctx->is_arrow = node && !!(node->flags & FN_ARROW);
ctx->is_async = node && !!(node->flags & FN_ASYNC);
ctx->is_strict = enclosing->is_strict;
ctx->mode = mode;
ctx->strict_args_local = -1;
ctx->new_target_local = -1;
ctx->super_local = -1;
ctx->using_stack_local = -1;
ctx->param_count = node ? node->args.count : 0;
}
void sv_compile_ctx_cleanup(sv_compiler_t *ctx) {
free(ctx->code);
free(ctx->constants);
free(ctx->atoms);
free(ctx->locals);
free(ctx->local_lookup_heads);
free(ctx->upval_descs);
free(ctx->loops);
free(ctx->srcpos);
free(ctx->slot_types);
free(ctx->deferred_exports);
free(ctx->using_cleanups);
const_dedup_entry_t *entry;
const_dedup_entry_t *tmp;
HASH_ITER(hh, ctx->const_dedup, entry, tmp) {
HASH_DEL(ctx->const_dedup, entry);
free(entry);
}
}
sv_line_table_t *sv_compile_ctx_build_line_table(const char *source, ant_offset_t source_len) {
if (!source || source_len <= 0) return NULL;
sv_line_table_t *lt = malloc(sizeof(sv_line_table_t));
if (!lt) return NULL;
int cap = (int)(source_len / 32) + 64;
lt->offsets = malloc((size_t)cap * sizeof(uint32_t));
lt->count = 0;
lt->offsets[lt->count++] = 0;
for (ant_offset_t i = 0; i < source_len; i++) {
if (source[i] == '\n') {
if (lt->count >= cap) {
cap *= 2;
lt->offsets = realloc(lt->offsets, (size_t)cap * sizeof(uint32_t));
}
lt->offsets[lt->count++] = (uint32_t)(i + 1);
}}
return lt;
}
void sv_compile_ctx_free_line_table(sv_line_table_t *lt) {
if (!lt) return;
free(lt->offsets);
free(lt);
}
void sv_compile_ctx_line_table_lookup(
sv_line_table_t *lt,
uint32_t off,
uint32_t *out_line,
uint32_t *out_col
) {
int lo = 0;
int hi = lt->count - 1;
while (lo < hi) {
int mid = lo + (hi - lo + 1) / 2;
if (lt->offsets[mid] <= off) lo = mid;
else hi = mid - 1;
}
*out_line = (uint32_t)(lo + 1);
*out_col = off - lt->offsets[lo] + 1;
}
uint32_t sv_compile_ctx_hash_local_name(const char *name, uint32_t len) {
uint32_t hash = 2166136261u;
for (uint32_t i = 0; i < len; i++) {
hash ^= (uint8_t)name[i];
hash *= 16777619u;
}
return hash;
}
void sv_compile_ctx_ensure_local_lookup_capacity(sv_compiler_t *ctx, int next_count) {
int needed = 16;
while (needed < next_count * 2) needed <<= 1;
if (needed <= ctx->local_lookup_cap) return;
sv_compile_ctx_rebuild_local_lookup(ctx, needed);
}
void sv_compile_ctx_local_lookup_insert(sv_compiler_t *ctx, int idx) {
if (idx < 0 || idx >= ctx->local_count) return;
if (!ctx->local_lookup_heads || ctx->local_lookup_cap <= 0) return;
sv_local_t *loc = &ctx->locals[idx];
int bucket = (int)(loc->name_hash & (uint32_t)(ctx->local_lookup_cap - 1));
loc->lookup_next = ctx->local_lookup_heads[bucket];
ctx->local_lookup_heads[bucket] = idx;
}
void sv_compile_ctx_local_lookup_remove(sv_compiler_t *ctx, int idx) {
if (
!ctx->local_lookup_heads || ctx->local_lookup_cap <= 0 ||
idx < 0 || idx >= ctx->local_count
) return;
sv_local_t *loc = &ctx->locals[idx];
int bucket = (int)(loc->name_hash & (uint32_t)(ctx->local_lookup_cap - 1));
int cur = ctx->local_lookup_heads[bucket];
int prev = -1;
while (cur != -1) {
if (cur == idx) {
int next = ctx->locals[cur].lookup_next;
if (prev == -1) ctx->local_lookup_heads[bucket] = next;
else ctx->locals[prev].lookup_next = next;
break;
}
prev = cur;
cur = ctx->locals[cur].lookup_next;
}
}

Owner Packages

  • No Owners