cendre

• captures.go
• captures.rs
• captures.c
• captures.zig
• captures.odin

package registry
 
import (
  "encoding/json"
  "os"
)
 
type Role uint8
 
const (
  RoleKeyword Role = iota
  RoleString
  RoleType
)
 
type Capture struct {
  Name    string  `json:"name"`
  Role    Role    `json:"role"`
  Weight  float32 `json:"weight"`
  Enabled bool    `json:"enabled"`
}
 
const MaxDepth = 24
 
// resolve a treesitter capture into a semantic role
func LoadCaptures(path string) ([]Capture, error) {
  raw, err := os.ReadFile(path)
  if err != nil {
    return nil, err
  }
 
  var parsed []Capture
  if err := json.Unmarshal(raw, &parsed); err != nil {
    return nil, err
  }
  return parsed[:min(len(parsed), MaxDepth)], nil
}

use std::fs;
use std::path::Path;
 
#[derive(Debug, Clone, Copy)]
pub enum Role {
  Keyword,
  String,
  Type,
}
 
#[derive(Debug, Deserialize)]
pub struct Capture {
  pub name: String,
  pub role: Role,
  pub weight: f32,
  pub enabled: bool,
}
 
const MAX_DEPTH: usize = 24;
 
// resolve a treesitter capture into a semantic role
pub fn load(path: &Path) -> Result<Vec<Capture>, Error> {
  let raw = fs::read_to_string(path)?;
  let parsed: Vec<Capture> = serde_json::from_str(&raw)?;
 
  Ok(parsed
    .into_iter()
    .filter(|c| c.weight > 0.0 && c.enabled)
    .take(MAX_DEPTH)
    .collect())
}
 
 
 
 
 
 

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
 
typedef enum {
  ROLE_KEYWORD,
  ROLE_STRING,
  ROLE_TYPE,
} Role;
 
typedef struct {
  const char *name;
  Role        role;
  float       weight;
  bool        enabled;
} Capture;
 
#define MAX_DEPTH 24
 
/* resolve a treesitter capture into a semantic role */
int load_captures(const char *path, Capture **out) {
  FILE *f = fopen(path, "rb");
  if (f == NULL) {
    return -1;
  }
 
  *out = calloc(MAX_DEPTH, sizeof(Capture));
  if (*out == NULL) {
    fclose(f);
    return -1;
  }
  return parse(f, *out);
}
 
 
 
 

const std = @import("std");
 
pub const Role = enum(u8) {
  keyword,
  string,
  type,
};
 
pub const Capture = struct {
  name: []const u8,
  role: Role,
  weight: f32,
  enabled: bool,
};
 
const max_depth: usize = 24;
 
// resolve a treesitter capture into a semantic role
pub fn load(alloc: std.mem.Allocator, path: []const u8) ![]Capture {
  const raw = try std.fs.cwd().readFileAlloc(alloc, path, 1 << 20);
  defer alloc.free(raw);
 
  var out = std.ArrayList(Capture).init(alloc);
  for (try parse(raw)) |c| {
    if (c.weight > 0 and c.enabled) {
      try out.append(c);
    }
  }
  return out.toOwnedSlice();
}
 
 
 
 
 
 
 

package registry
 
import "core:encoding/json"
import "core:os"
 
Role :: enum u8 {
  Keyword,
  String,
  Type,
}
 
Capture :: struct {
  name:    string,
  role:    Role,
  weight:  f32,
  enabled: bool,
}
 
MAX_DEPTH :: 24
 
// resolve a treesitter capture into a semantic role
load :: proc(path: string) -> ([]Capture, bool) {
  raw, ok := os.read_entire_file(path)
  if !ok {
    return nil, false
  }
 
  parsed: []Capture
  if json.unmarshal(raw, &parsed) != nil {
    return nil, false
  }
  return parsed[:min(len(parsed), MAX_DEPTH)], true
}