core.h

Go to the documentation of this file.

/* -*- C -*-
 * Serene programming language
 * Copyright (C) 2019-2026 Sameer Rahmani <[email protected]>
 *
 * 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/>.
 */
 
#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "llvm-c/Core.h"
#include "llvm-c/Types.h"
#include "serene/rt/impl/seq.h"
 
typedef struct srn_context_t srn_context_t;
typedef struct srn_expr_t srn_expr_t;
typedef struct srn_value_t srn_value_t;
typedef struct srn_closure_t srn_closure_t;
typedef struct srn_error_t srn_error_t;
typedef struct srn_namespace_t srn_namespace_t;
typedef struct srn_string_t srn_string_t;
typedef struct srn_symbol_t srn_symbol_t;
typedef struct srn_list_t srn_list_t;
typedef struct srn_keyword_t srn_keyword_t;
typedef struct srn_seq_t srn_seq_t;
typedef struct srn_map_t srn_map_t;
 
// -----------------------------------------------------------------------------
// Internal ABI
// In C we can't mark fastcc portably; we treat codeptrs as plain fn ptrs.
// LLVM IR will set calling convention = fastcc on definitions & calls.
// -----------------------------------------------------------------------------
typedef srn_value_t *(*srn_fnptr_t)(srn_context_t *ctx, srn_value_t *argv,
                                    uint32_t argc);
 
typedef struct srn_src_location_t {
  /// ID of the source buffer that is registered with the source manager
  uint16_t buffer_id;
  uint16_t line;
  uint16_t col;
  uint16_t len;
} srn_src_location_t;
 
typedef struct srn_metadata_t {
  /// `nullptr` is a valid value and represents an unknown location.
  srn_src_location_t *loc;
  /// An optional pointer to the original and raw expression. We use this
  /// to track what value/expression is a descendant of which expression.
  srn_expr_t *raw_expr;
} srn_metadata_t;
 
/// We use this for testing
static srn_metadata_t absurd_metadata = {nullptr, nullptr};
 
// -----------------------------------------------------------------------------
// Syntaces
// This is type will be represented in LLVM like:
// %srn_syntax_t = type { i64, ptr, i64 } ; { tag, loc, payload }
// -----------------------------------------------------------------------------
typedef enum srn_syntax_tag_e : size_t {
  SNil = 0,
  STrue,
  SFalse,
  SSymbol,
  SNumber,
  SList,
  SSeq,
  SQuote,
  SString,
  SKeyword,
  SMap,
  /// SError should be last
  SError,
} srn_syntax_tag_t;
 
typedef struct srn_syntax_t {
  srn_syntax_tag_t type;
  srn_metadata_t *metadata;
  /// IMPORTANT NOTE: The size of this union should never be larger than a word
  union {
    /// For syntax only, we represent numbers as a strings,
    const char *symbol;
    const char *number;
    const char *string;
    srn_error_t *error;
    seq_t *list;
    const char *keyword;
    seq_t *seq;
    seq_t *map;
    struct srn_syntax_t *quote;
  } as;
} srn_syntax_t;
 
// -----------------------------------------------------------------------------
// Values
// This is type will be represented in LLVM like:
// %srn_value_t = type { i64, ptr, i64 } ; { tag, loc, payload }
// -----------------------------------------------------------------------------
typedef enum srn_value_tag_e : size_t {
  VNil = 0,
  VTrue,
  VFalse,
  VI64,
  VF64,
  VList,
  VSeq,
  VQuote,
  VClosure,
  VNamespace,
  VString,
  VSymbol,
  VKeyword,
  VMap,
  /// VError should be last
  VError,
} srn_value_tag_t;
 
typedef struct srn_value_t {
  srn_value_tag_t type;
  srn_metadata_t *metadata;
  /// IMPORTANT NOTE: The size of this union should never be larger than a word
  union {
    /// We represent all the immidiate numbers with this field and cast as we
    /// to an appropriate type. It might change in the future.
    int64_t i64;
    double f64;
    srn_closure_t *closure;
    srn_namespace_t *ns;
    srn_string_t *string;
    srn_symbol_t *symbol;
    srn_error_t *error;
    srn_list_t *list;
    srn_keyword_t *keyword;
    srn_seq_t *seq;
    srn_map_t *map;
  } as;
} srn_value_t;
 
#define SIZE_OF_VALUE_PALYLOAD 8
_Static_assert(sizeof(((srn_value_t *)0)->as) == SIZE_OF_VALUE_PALYLOAD,
               "srn_value_t's union has the wrong size");
 
static srn_value_t nil_v   = {.type = VNil};
static srn_value_t true_v  = {.type = VTrue};
static srn_value_t false_v = {.type = VFalse};
 
#define TYPE(value_ref)        ((value_ref)->type)
#define METADATA(value_ref)    ((value_ref)->metadata)
#define IS_A(value_ref, field) (TYPE(value_ref) == (field))
#define IS_TRUE(value_ref)     (TYPE(value_ref) == VTrue)
#define IS_FALSE(value_ref)    (TYPE(value_ref) == VFalse)
#define IS_NIL(value_ref)      (TYPE(value_ref) == VNil)
 
#define AS_I64(value_ref)     ((value_ref)->as.i64)
#define AS_F64(value_ref)     ((value_ref)->as.f64)
#define AS_CLOSURE(value_ref) ((value_ref)->as.closure)
#define AS_NS(value_ref)      ((value_ref)->as.ns)
#define AS_STRING(value_ref)  ((value_ref)->as.string)
#define AS_SYMBOL(value_ref)  ((value_ref)->as.symbol)
#define AS_ERROR(value_ref)   ((value_ref)->as.error)
#define AS_LIST(value_ref)    ((value_ref)->as.list)
#define AS_KEYWORD(value_ref) ((value_ref)->as.keyword)
#define AS_SEQ(value_ref)     ((value_ref)->as.seq)
#define AS_MAP(value_ref)     ((value_ref)->as.map)
 
/// Creates a new serene value. We always heap allocate the values. So, ANY
/// value creation should go through this function
[[nodiscard]] [[gnu::nonnull(1)]] [[gnu::returns_nonnull]]
srn_value_t *srn_value_make(srn_context_t *ctx, srn_value_tag_t tag,
                            srn_metadata_t *metadata, void *payload);
 
/// LLVM type for srn_value_t in LLVM IR. { i64, ptr, i64 }
static inline LLVMTypeRef srn_llvm_value_t(LLVMContextRef llctx) {
  LLVMTypeRef i64t = LLVMInt64TypeInContext(llctx);
 
  // opaque ptr
  LLVMTypeRef i8t  = LLVMInt8TypeInContext(llctx);
  LLVMTypeRef ptrt = LLVMPointerType(i8t, 0);
 
  LLVMTypeRef fields[3];
  fields[0] = i64t; // type tag (srn_value_tag_t as i64)
  fields[1] = ptrt; // loc pointer
  fields[2] = i64t; // payload (the union)
 
  LLVMTypeRef st = LLVMStructCreateNamed(llctx, "srn_value_t");
  LLVMStructSetBody(st, fields, 3, 0);
  return st;
}