bytecode.c

Go to the documentation of this file.

/*
 * This file is part of the Fun programming language.
 * https://fun-lang.xyz/
 *
 * Copyright 2025 Johannes Findeisen <you@hanez.org>
 * Licensed under the terms of the Apache-2.0 license.
 * https://opensource.org/license/apache-2-0
 */
 
#include "bytecode.h"
#include <stdio.h>
#include <stdlib.h>
 
/**
 * @file bytecode.c
 * @brief Bytecode container utilities: creation, mutation, dump helpers.
 */
 
/**
 * @brief Allocate and initialize an empty Bytecode object.
 *
 * Initializes instruction and constant arrays to empty and clears metadata.
 * Caller owns the returned pointer and must free it with bytecode_free().
 *
 * @return Newly allocated Bytecode*, or NULL on allocation failure.
 */
Bytecode *bytecode_new(void) {
  Bytecode *bc = (Bytecode *)malloc(sizeof(Bytecode));
  bc->instructions = NULL;
  bc->instr_count = 0;
  bc->constants = NULL;
  bc->const_count = 0;
  bc->name = NULL;
  bc->source_file = NULL;
  return bc;
}
 
/**
 * @brief Append a constant to a Bytecode's constant table with de-duplication.
 *
 * The value is compared against existing constants and if an equal constant is
 * already present, its index is returned without modifying the table. Equality
 * uses value_equals which supports numeric cross-type (int/float) equality and
 * string content equality. The caller retains ownership of @p v in all cases.
 * When a new constant is inserted, a deep copy is stored in the table.
 *
 * @param bc Target bytecode (must not be NULL).
 * @param v  Value to store (copied on insert).
 * @return The index of the stored or matched existing constant (zero-based).
 */
int bytecode_add_constant(Bytecode *bc, Value v) {
  /* Linear scan for a match. This is fast enough for small constant pools and
   * avoids duplicates (smaller bytecode, better cache locality). */
  for (int i = 0; i < bc->const_count; ++i) {
    if (value_equals(&bc->constants[i], &v)) {
      return i;
    }
  }
 
  /* Not found: append a copy */
  bc->constants = (Value *)realloc(bc->constants, sizeof(Value) * (bc->const_count + 1));
  bc->constants[bc->const_count] = copy_value(&v);
  return bc->const_count++;
}
 
/**
 * @brief Append a single instruction to the instruction stream.
 *
 * @param bc      Target bytecode (must not be NULL).
 * @param op      Opcode to emit.
 * @param operand Operand value (semantics depend on opcode).
 * @return The index of the emitted instruction (zero-based).
 */
int bytecode_add_instruction(Bytecode *bc, OpCode op, int32_t operand) {
  bc->instructions = (Instruction *)realloc(bc->instructions, sizeof(Instruction) * (bc->instr_count + 1));
  bc->instructions[bc->instr_count].op = op;
  bc->instructions[bc->instr_count].operand = operand;
  return bc->instr_count++;
}
 
/**
 * @brief Patch the operand of a previously emitted instruction.
 *
 * Silently ignores out-of-bounds indices.
 *
 * @param bc      Target bytecode.
 * @param idx     Instruction index to patch.
 * @param operand New operand value.
 */
void bytecode_set_operand(Bytecode *bc, int idx, int32_t operand) {
  if (idx >= 0 && idx < bc->instr_count) {
    bc->instructions[idx].operand = operand;
  }
}
 
/**
 * @brief Free a Bytecode and all memory it owns.
 *
 * Frees constants (deep), instruction array, and metadata strings.
 * Accepts NULL and is then a no-op.
 *
 * @param bc Bytecode to free (may be NULL).
 */
void bytecode_free(Bytecode *bc) {
  if (!bc) return;
  for (int i = 0; i < bc->const_count; ++i) {
    free_value(bc->constants[i]);
  }
  free(bc->constants);
  free(bc->instructions);
  if (bc->name) free((void *)bc->name);
  if (bc->source_file) free((void *)bc->source_file);
  free(bc);
}
 
/**
 * @brief Convert an opcode enum to a short mnemonic string.
 *
 * @param op Opcode value.
 * @return Read-only C string with the mnemonic, or "???" if unknown.
 */
static const char *opcode_name(OpCode op) {
  switch (op) {
  case OP_NOP:
    return "NOP";
  case OP_LOAD_CONST:
    return "LOAD_CONST";
  case OP_LOAD_LOCAL:
    return "LOAD_LOCAL";
  case OP_STORE_LOCAL:
    return "STORE_LOCAL";
  case OP_LOAD_GLOBAL:
    return "LOAD_GLOBAL";
  case OP_STORE_GLOBAL:
    return "STORE_GLOBAL";
  case OP_ADD:
    return "ADD";
  case OP_SUB:
    return "SUB";
  case OP_MUL:
    return "MUL";
  case OP_DIV:
    return "DIV";
  case OP_LT:
    return "LT";
  case OP_LTE:
    return "LTE";
  case OP_GT:
    return "GT";
  case OP_GTE:
    return "GTE";
  case OP_EQ:
    return "EQ";
  case OP_NEQ:
    return "NEQ";
  case OP_POP:
    return "POP";
  case OP_JUMP:
    return "JUMP";
  case OP_JUMP_IF_FALSE:
    return "JUMP_IF_FALSE";
  case OP_CALL:
    return "CALL";
  case OP_RETURN:
    return "RETURN";
  case OP_PRINT:
    return "PRINT";
  case OP_ECHO:
    return "ECHO";
  case OP_HALT:
    return "HALT";
  case OP_MOD:
    return "MOD";
  case OP_AND:
    return "AND";
  case OP_OR:
    return "OR";
  case OP_NOT:
    return "NOT";
  case OP_DUP:
    return "DUP";
  case OP_SWAP:
    return "SWAP";
  case OP_MAKE_ARRAY:
    return "MAKE_ARRAY";
  case OP_INDEX_GET:
    return "INDEX_GET";
  case OP_INDEX_SET:
    return "INDEX_SET";
  case OP_LEN:
    return "LEN";
  case OP_PUSH:
    return "ARR_PUSH";
  case OP_APOP:
    return "ARR_POP";
  case OP_SET:
    return "ARR_SET";
  case OP_INSERT:
    return "ARR_INSERT";
  case OP_REMOVE:
    return "ARR_REMOVE";
  case OP_SLICE:
    return "SLICE";
  case OP_TO_NUMBER:
    return "TO_NUMBER";
  case OP_TO_STRING:
    return "TO_STRING";
  case OP_TYPEOF:
    return "TYPEOF";
  case OP_CAST:
    return "CAST";
  case OP_SPLIT:
    return "SPLIT";
  case OP_JOIN:
    return "JOIN";
  case OP_SUBSTR:
    return "SUBSTR";
  case OP_FIND:
    return "FIND";
  case OP_REGEX_MATCH:
    return "REGEX_MATCH";
  case OP_REGEX_SEARCH:
    return "REGEX_SEARCH";
  case OP_REGEX_REPLACE:
    return "REGEX_REPLACE";
  case OP_CONTAINS:
    return "CONTAINS";
  case OP_INDEX_OF:
    return "INDEX_OF";
  case OP_CLEAR:
    return "CLEAR";
  case OP_ENUMERATE:
    return "ENUMERATE";
  case OP_ZIP:
    return "ZIP";
  case OP_MIN:
    return "MIN";
  case OP_MAX:
    return "MAX";
  case OP_CLAMP:
    return "CLAMP";
  case OP_ABS:
    return "ABS";
  case OP_POW:
    return "POW";
  case OP_RANDOM_SEED:
    return "RANDOM_SEED";
  case OP_RANDOM_INT:
    return "RANDOM_INT";
  case OP_MAKE_MAP:
    return "MAKE_MAP";
  case OP_KEYS:
    return "KEYS";
  case OP_VALUES:
    return "VALUES";
  case OP_HAS_KEY:
    return "HAS_KEY";
  case OP_READ_FILE:
    return "READ_FILE";
  case OP_WRITE_FILE:
    return "WRITE_FILE";
  case OP_ENV:
    return "ENV";
  case OP_INPUT_LINE:
    return "INPUT_LINE";
  case OP_PROC_RUN:
    return "PROC_RUN";
  case OP_PROC_SYSTEM:
    return "PROC_SYSTEM";
  case OP_TIME_NOW_MS:
    return "TIME_NOW_MS";
  case OP_CLOCK_MONO_MS:
    return "CLOCK_MONO_MS";
  case OP_DATE_FORMAT:
    return "DATE_FORMAT";
  case OP_ENV_ALL:
    return "ENV_ALL";
  case OP_FUN_VERSION:
    return "FUN_VERSION";
  case OP_THREAD_SPAWN:
    return "THREAD_SPAWN";
  case OP_THREAD_JOIN:
    return "THREAD_JOIN";
  case OP_SLEEP_MS:
    return "SLEEP_MS";
  case OP_RANDOM_NUMBER:
    return "RANDOM_NUMBER";
  case OP_BAND:
    return "BAND";
  case OP_BOR:
    return "BOR";
  case OP_BXOR:
    return "BXOR";
  case OP_BNOT:
    return "BNOT";
  case OP_SHL:
    return "SHL";
  case OP_SHR:
    return "SHR";
  case OP_ROTL:
    return "ROTL";
  case OP_ROTR:
    return "ROTR";
  case OP_JSON_PARSE:
    return "JSON_PARSE";
  case OP_JSON_STRINGIFY:
    return "JSON_STRINGIFY";
  case OP_JSON_FROM_FILE:
    return "JSON_FROM_FILE";
  case OP_JSON_TO_FILE:
    return "JSON_TO_FILE";
  case OP_CURL_GET:
    return "CURL_GET";
  case OP_CURL_POST:
    return "CURL_POST";
  case OP_CURL_DOWNLOAD:
    return "CURL_DOWNLOAD";
  case OP_SQLITE_OPEN:
    return "SQLITE_OPEN";
  case OP_SQLITE_CLOSE:
    return "SQLITE_CLOSE";
  case OP_SQLITE_EXEC:
    return "SQLITE_EXEC";
  case OP_SQLITE_QUERY:
    return "SQLITE_QUERY";
  case OP_PCSC_ESTABLISH:
    return "PCSC_ESTABLISH";
  case OP_PCSC_RELEASE:
    return "PCSC_RELEASE";
  case OP_PCSC_LIST_READERS:
    return "PCSC_LIST_READERS";
  case OP_PCSC_CONNECT:
    return "PCSC_CONNECT";
  case OP_PCSC_DISCONNECT:
    return "PCSC_DISCONNECT";
  case OP_PCSC_TRANSMIT:
    return "PCSC_TRANSMIT";
  case OP_PCRE2_TEST:
    return "PCRE2_TEST";
  case OP_PCRE2_MATCH:
    return "PCRE2_MATCH";
  case OP_PCRE2_FINDALL:
    return "PCRE2_FINDALL";
  case OP_OPENSSL_MD5:
    return "OPENSSL_MD5";
  case OP_OPENSSL_SHA256:
    return "OPENSSL_SHA256";
  case OP_OPENSSL_SHA512:
    return "OPENSSL_SHA512";
  case OP_OPENSSL_RIPEMD160:
    return "OPENSSL_RIPEMD160";
  case OP_INI_LOAD:
    return "INI_LOAD";
  case OP_INI_FREE:
    return "INI_FREE";
  case OP_INI_GET_STRING:
    return "INI_GET_STRING";
  case OP_INI_GET_INT:
    return "INI_GET_INT";
  case OP_INI_GET_DOUBLE:
    return "INI_GET_DOUBLE";
  case OP_INI_GET_BOOL:
    return "INI_GET_BOOL";
  case OP_INI_SET:
    return "INI_SET";
  case OP_INI_UNSET:
    return "INI_UNSET";
  case OP_INI_SAVE:
    return "INI_SAVE";
  case OP_XML_PARSE:
    return "XML_PARSE";
  case OP_XML_ROOT:
    return "XML_ROOT";
  case OP_XML_NAME:
    return "XML_NAME";
  case OP_XML_TEXT:
    return "XML_TEXT";
  case OP_FLOOR:
    return "FLOOR";
  case OP_CEIL:
    return "CEIL";
  case OP_TRUNC:
    return "TRUNC";
  case OP_ROUND:
    return "ROUND";
  case OP_SIN:
    return "SIN";
  case OP_COS:
    return "COS";
  case OP_TAN:
    return "TAN";
  case OP_EXP:
    return "EXP";
  case OP_LOG:
    return "LOG";
  case OP_LOG10:
    return "LOG10";
  case OP_SQRT:
    return "SQRT";
  case OP_GCD:
    return "GCD";
  case OP_LCM:
    return "LCM";
  case OP_ISQRT:
    return "ISQRT";
  case OP_SIGN:
    return "SIGN";
  case OP_FMIN:
    return "FMIN";
  case OP_FMAX:
    return "FMAX";
  case OP_RUST_HELLO:
    return "RUST_HELLO";
  case OP_RUST_HELLO_ARGS:
    return "RUST_HELLO_ARGS";
  case OP_RUST_HELLO_ARGS_RETURN:
    return "RUST_HELLO_ARGS_RETURN";
  case OP_RUST_GET_SP:
    return "RUST_GET_SP";
  case OP_RUST_SET_EXIT:
    return "RUST_SET_EXIT";
  default:
    return "???";
  }
}
 
/**
 * @brief Print a human-readable dump of constants and instructions to stdout.
 *
 * Intended for debugging and tests. Formats constants with print_value()
 * and shows each instruction index, mnemonic and operand.
 *
 * @param bc Bytecode to dump (prints "<null bytecode>" if NULL).
 */
void bytecode_dump(const Bytecode *bc) {
  if (!bc) {
    printf("<null bytecode>\n");
    return;
  }
  printf("Constants (%d):\n", bc->const_count);
  for (int i = 0; i < bc->const_count; ++i) {
    printf("  [%d] ", i);
    print_value(&bc->constants[i]);
    printf("\n");
  }
  printf("Instructions (%d):\n", bc->instr_count);
  for (int i = 0; i < bc->instr_count; ++i) {
    const Instruction *ins = &bc->instructions[i];
    printf("  %3d: %-15s %d\n", i, opcode_name(ins->op), ins->operand);
  }
}