errors.c

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <lxsameer@lxsameer.com>
 *
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This library 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "serene/rt/errors.h"
 
#if defined(__unix__) || defined(__APPLE__)
#  include "errno.h"
#endif
#include <stdio.h>
 
#include "serene/rt/context.h"
#include "serene/utils.h"
#include "serene/utils/srn_dbg_sym.h"
 
#ifdef SRN_WITH_SERENE
#  include "serene/rt/core.h"
#endif
 
// TODO(lxsameer): Move this function to an auto generated file alongside
// the actual srn_error_tag_t, something like tablegen or something.
static const char *srn_error_tag_name(srn_error_tag_t tag) {
  switch (tag) {
  case ABSURD:
    return "ABSURD";
  case NOT_IMPLEMENTED:
    return "NOT_IMPLEMENTED";
  case SEQ_LIMIT_REACHED:
    return "SEQ_LIMIT_REACHED";
  case AL_LIMIT_REACHED:
    return "AL_LIMIT_REACHED";
  case SM_BUFFER_ID_EXHAUSTED:
    return "SM_BUFFER_ID_EXHAUSTED";
  case INDEX_OUT_OF_BOUND:
    return "INDEX_OUT_OF_BOUND";
  case CORRUPTED_SEQ:
    return "CORRUPTED_SEQ";
  case CORRUPTED_ARRAY_LIST:
    return "CORRUPTED_ARRAY_LIST";
  case FAILED_TO_ADD_MODULE:
    return "FAILED_TO_ADD_MODULE";
  case JIT_IR_PARSE_FAILED:
    return "JIT_IR_PARSE_FAILED";
  case JIT_SYMBOL_NOT_FOUND:
    return "JIT_SYMBOL_NOT_FOUND";
  case JIT_SYMBOL_ALREADY_DEFINED:
    return "JIT_SYMBOL_ALREADY_DEFINED";
  case EMPTY_NAMESPACE_NAME:
    return "EMPTY_NAMESPACE_NAME";
  case EMPTY_SYMBOL_NAME:
    return "EMPTY_SYMBOL_NAME";
  case STRING_LENGTH_LIMIT_EXCEEDED:
    return "STRING_LENGTH_LIMIT_EXCEEDED";
  case WRONG_RANGE:
    return "WRONG_RANGE";
  case EPOLL_INIT_FAILED:
    return "EPOLL_INIT_FAILED";
  case EPOLL_EVENT_FD_FAILED:
    return "EPOLL_EVENT_FD_FAILED";
  case EPOLL_FAILED_TO_ADD_FD:
    return "EPOLL_FAILED_TO_ADD_FD";
  case CONNECTION_REFUSED:
    return "CONNECTION_REFUSED";
  case CONNECTION_RESET:
    return "CONNECTION_RESET";
  case CONNECTION_ABORTED:
    return "CONNECTION_ABORTED";
  case BROKEN_PIPE:
    return "BROKEN_PIPE";
  case BAD_DESCRIPTOR:
    return "BAD_DESCRIPTOR";
  case TIMED_OUT:
    return "TIMED_OUT";
  case CANCELED:
    return "CANCELED";
  case NOT_CONNECTED:
    return "NOT_CONNECTED";
  case ADDRESS_IN_USE:
    return "ADDRESS_IN_USE";
  case HOST_UNREACHABLE:
    return "HOST_UNREACHABLE";
  case NETWORK_UNREACHABLE:
    return "NETWORK_UNREACHABLE";
  case MESSAGE_TOO_LONG:
    return "MESSAGE_TOO_LONG";
  case TOO_MANY_OPEN_FILES:
    return "TOO_MANY_OPEN_FILES";
  case PERMISSION_DENIED:
    return "PERMISSION_DENIED";
  case OUT_OF_MEMORY:
    return "OUT_OF_MEMORY";
  case NOT_FOUND:
    return "NOT_FOUND";
  case ALREADY_EXISTS:
    return "ALREADY_EXISTS";
  case IS_A_DIRECTORY:
    return "IS_A_DIRECTORY";
  case NOT_A_DIRECTORY:
    return "NOT_A_DIRECTORY";
  case NO_SPACE:
    return "NO_SPACE";
  case INVALID_ARGUMENT:
    return "INVALID_ARGUMENT";
  case CHANNEL_BUSY:
    return "CHANNEL_BUSY";
  case MEMORY_MAP_FAILED:
    return "MEMORY_MAP_FAILED";
  case IR_PARSE_ERROR:
    return "IR_PARSE_ERROR";
  case UNKNOWN_IO_ERROR:
    return "UNKNOWN_IO_ERROR";
  }
  return "UNKNOWN";
}
 
// TODO(lxsameer): This is pretty basic, we need to replace it by a better implementation
// TODO(lxsameer): use LLVMSymbolizer (llvm::symbolize::LLVMSymbolizer) to resolve frame addresses
// to file and line, not just symbol names.
char *srn_error_to_string(const srn_context_t *ctx, const srn_error_t *err) {
  PANIC_IF_NULL(err);
  const char *tag = srn_error_tag_name(err->tag);
  const char *msg = err->msg != nullptr ? err->msg : "<null>";
 
  int header_len = snprintf(nullptr, 0, "[%s]: %s", tag, msg);
  PANIC_IF(header_len < 0, "srn_error_to_string: formatting failed");
 
  // Measure the trace lines before allocating so a single allocation covers
  // the whole string.
  int trace_len = 0;
  char sym[256];
  if (err->layer == SRN_ERR_RUNTIME_LAYER && err->as.frames != nullptr) {
    for (uint16_t i = 0; i < err->as.frames->count; i++) {
      void *addr       = err->as.frames->return_addrs[i];
      const char *name = srn_dbg_sym_name(addr, sym, sizeof(sym));
      if (name != nullptr) {
        trace_len += snprintf(nullptr, 0, "\n  #%u %p %s", i, addr, name);
      } else {
        trace_len += snprintf(nullptr, 0, "\n  #%u %p", i, addr);
      }
    }
  }
 
  size_t total = (size_t)header_len + (size_t)trace_len + 1;
  char *buf    = srn_allocate(ctx, total, alignof(char));
  PANIC_IF_NULL(buf);
 
  int written = snprintf(buf, total, "[%s]: %s", tag, msg);
  if (err->layer == SRN_ERR_RUNTIME_LAYER && err->as.frames != nullptr) {
    for (uint16_t i = 0; i < err->as.frames->count; i++) {
      void *addr       = err->as.frames->return_addrs[i];
      const char *name = srn_dbg_sym_name(addr, sym, sizeof(sym));
      if (name != nullptr) {
        written += snprintf(buf + written, total - (size_t)written, "\n  #%u %p %s", i, addr, name);
      } else {
        written += snprintf(buf + written, total - (size_t)written, "\n  #%u %p", i, addr);
      }
    }
  }
 
  return buf;
}
 
void srn_error_trace_push(const srn_context_t *ctx, srn_error_t *err, void *addr) {
  if (err->layer != SRN_ERR_RUNTIME_LAYER) {
    return;
  }
 
  if (err->as.frames == nullptr) {
    err->as.frames = ALLOC(ctx, srn_trace_frames_t);
    PANIC_IF_NULL(err->as.frames);
    err->as.frames->count = 0;
  }
 
  if (err->as.frames->count >= TRACE_FRAME_DEPTH) {
    return;
  }
 
  err->as.frames->return_addrs[err->as.frames->count++] = addr;
}
 
srn_error_t *
srn_errors_make(const srn_context_t *ctx, srn_error_tag_t tag, const char *msg, void *caller) {
  srn_error_t *err = ALLOC(ctx, srn_error_t);
  PANIC_IF_NULL(err);
  err->layer     = SRN_ERR_RUNTIME_LAYER;
  err->tag       = tag;
  err->msg       = (char *)msg;
  err->as.frames = nullptr;
  srn_error_trace_push(ctx, err, caller);
  return err;
}
 
srn_error_t *srn_errors_from(const srn_context_t *ctx, const srn_error_t *src, void *caller) {
  PANIC_IF_NULL(src);
  srn_error_t *err = ALLOC_OR_PANIC(ctx, srn_error_t);
  err->layer       = src->layer;
  err->tag         = src->tag;
  err->msg         = src->msg;
  err->as          = src->as;
 
  if (src->layer == SRN_ERR_RUNTIME_LAYER && src->as.frames != nullptr) {
    err->as.frames  = ALLOC_OR_PANIC(ctx, srn_trace_frames_t);
    *err->as.frames = *src->as.frames;
  }
 
  srn_error_trace_push(ctx, err, caller);
  return err;
}
 
void *srn_errors_fail(
  const srn_context_t *ctx, size_t size, size_t alignment, srn_error_tag_t tag, const char *msg,
  void *caller
) {
  // The ERROR_HEADER convention guarantees `srn_error_t *maybe_error` is the
  // first member of any fallible T, so offset 0 of the value is that pointer.
  // Allocate the value and set it to a fresh error; the caller checks it with
  // HAS_ERROR and never reads the other fields of an errored value.
  void *value = srn_allocate(ctx, size, alignment);
  PANIC_IF_NULL(value);
  *(srn_error_t **)value = srn_errors_make(ctx, tag, msg, caller);
  return value;
}
 
#if defined(__unix__) || defined(__APPLE__)
srn_error_tag_t srn_errno_to_tag(int errno_value, srn_error_tag_t default_tag) {
  switch (errno_value) {
  case ECONNREFUSED:
    return CONNECTION_REFUSED;
  case ECONNRESET:
    return CONNECTION_RESET;
  case ECONNABORTED:
    return CONNECTION_ABORTED;
  case EPIPE:
    return BROKEN_PIPE;
  case EBADF:
    return BAD_DESCRIPTOR;
  case ETIMEDOUT:
    return TIMED_OUT;
  case ECANCELED:
    return CANCELED;
  case ENOTCONN:
    return NOT_CONNECTED;
  case EADDRINUSE:
    return ADDRESS_IN_USE;
  case EHOSTUNREACH:
    return HOST_UNREACHABLE;
  case ENETUNREACH:
    return NETWORK_UNREACHABLE;
  case EMSGSIZE:
    return MESSAGE_TOO_LONG;
  case EMFILE:
  case ENFILE:
    return TOO_MANY_OPEN_FILES;
  case EACCES:
  case EPERM:
    return PERMISSION_DENIED;
  case ENOMEM:
  case ENOBUFS:
    return OUT_OF_MEMORY;
  case ENOENT:
    return NOT_FOUND;
  case EEXIST:
    return ALREADY_EXISTS;
  case EISDIR:
    return IS_A_DIRECTORY;
  case ENOTDIR:
    return NOT_A_DIRECTORY;
  case ENOSPC:
    return NO_SPACE;
  default:
    return default_tag;
  }
}
#else
#  error "srn_errno_to_tag has no errno mapping for this target; provide a native mapping."
#endif
 
#ifdef SRN_WITH_SERENE
srn_value_t *srn_errors_make_error(
  srn_context_t *ctx, srn_metadata_t *metadata, srn_error_tag_t tag, const char *msg
) {
  PANIC_IF_NULL(metadata);
  srn_error_t *err = ALLOC(ctx, srn_error_t);
  PANIC_IF_NULL(err);
  err->layer       = SRN_ERR_PARSE_LAYER;
  err->tag         = tag;
  err->msg         = (char *)msg;
  err->as.metadata = metadata;
  return srn_value_make(ctx, VError, metadata, (void *)err);
}
 
srn_value_t *
srn_errors_err_to_value(srn_context_t *ctx, srn_metadata_t *metadata, srn_error_t *err) {
  PANIC_IF_NULL(err);
  PANIC_IF_NULL(ctx);
  return srn_value_make(ctx, VError, metadata, (void *)err);
}
#endif