neovm-core 0.0.2

//! Marker builtins for the Elisp interpreter.
//!
//! Markers track positions in buffers and adjust when text is inserted or
//! deleted before them. GNU Emacs exposes markers as first-class marker
//! objects, not vectors, so NeoVM keeps them as heap objects too.
//!
//! Pure builtins:
//!   `markerp`, `marker-position`, `marker-buffer`,
//!   `marker-insertion-type`, `set-marker-insertion-type`,
//!   `copy-marker`, `make-marker`
//!
//! Eval-dependent builtins:
//!   `set-marker`, `move-marker`, `point-marker`, `point-min-marker`,
//!   `point-max-marker`, `mark-marker`

use super::error::{EvalResult, Flow, signal};
use super::value::*;
use crate::buffer::{BufferId, BufferManager, InsertionType};

// ---------------------------------------------------------------------------
// Marker struct (for documentation / internal helpers)
// ---------------------------------------------------------------------------

#[allow(dead_code)]
pub(crate) struct Marker {
    pub buffer: Option<BufferId>,
    pub position: Option<i64>,
    pub insertion_type: bool, // true = advances when text inserted at marker pos
}

// ---------------------------------------------------------------------------
// Argument helpers
// ---------------------------------------------------------------------------

fn expect_args(name: &str, args: &[Value], n: usize) -> Result<(), Flow> {
    if args.len() != n {
        Err(signal(
            "wrong-number-of-arguments",
            vec![Value::symbol(name), Value::fixnum(args.len() as i64)],
        ))
    } else {
        Ok(())
    }
}

fn expect_range_args(name: &str, args: &[Value], min: usize, max: usize) -> Result<(), Flow> {
    if args.len() < min || args.len() > max {
        Err(signal(
            "wrong-number-of-arguments",
            vec![Value::symbol(name), Value::fixnum(args.len() as i64)],
        ))
    } else {
        Ok(())
    }
}

// ---------------------------------------------------------------------------
// Marker value helpers
// ---------------------------------------------------------------------------

const MARK_MARKER_ID: u64 = i64::MAX as u64;

pub(crate) fn is_marker(v: &Value) -> bool {
    v.is_marker()
}

pub(crate) fn make_marker_value(
    buffer_id: Option<BufferId>,
    position: Option<i64>,
    insertion_type: bool,
) -> Value {
    make_marker_value_with_id(buffer_id, position, insertion_type, None)
}

pub(crate) fn make_marker_value_with_id(
    buffer_id: Option<BufferId>,
    position: Option<i64>,
    insertion_type: bool,
    marker_id: Option<u64>,
) -> Value {
    // Seed charpos from the 1-based Lisp position so unregistered markers
    // (e.g. synthesized mark-markers, bufferless fixture markers that never
    // get registered into a buffer's chain) still report a sensible
    // position when the reader path reads MarkerData.charpos directly.
    //
    // Markers that later get registered via register_marker have their
    // charpos/bytepos overwritten through the chain path, so this only
    // matters for unregistered/synthesized markers.
    let charpos = match position {
        Some(p) if p > 0 => (p - 1) as usize,
        _ => 0,
    };
    Value::make_marker(crate::heap_types::MarkerData {
        buffer: buffer_id,
        insertion_type,
        marker_id,
        bytepos: 0,
        charpos,
        next_marker: std::ptr::null_mut(),
    })
}

pub(crate) fn make_registered_buffer_marker(
    buffers: &mut BufferManager,
    buffer_id: BufferId,
    position: i64,
    insertion_type: bool,
) -> Value {
    let byte_pos = match buffers.get(buffer_id) {
        Some(buffer) => lisp_pos_to_byte(buffer, position),
        None => 0,
    };
    let marker = make_marker_value(Some(buffer_id), Some(position), insertion_type);
    let marker_id = buffers.allocate_marker_id();
    set_marker_id(&marker, marker_id);
    // Reuse the just-allocated MarkerObj as the chain node for this
    // buffer; calling `create_marker` here would allocate a *second*
    // MarkerObj with the same marker_id, wasting an allocation and
    // leaving the Lisp-visible Value off-chain.
    if let Some(marker_ptr) = marker
        .as_veclike_ptr()
        .map(|p| p as *mut crate::tagged::header::MarkerObj)
    {
        let _ = buffers.register_marker_id(
            marker_ptr,
            buffer_id,
            marker_id,
            byte_pos,
            if insertion_type {
                InsertionType::After
            } else {
                InsertionType::Before
            },
        );
    }

    marker
}

pub(crate) fn marker_logical_fields(v: &Value) -> Option<(Option<BufferId>, Option<i64>, bool)> {
    if !v.is_marker() {
        return None;
    };
    let data = v.as_marker_data().unwrap();
    // T7: the stale `position` cache is gone. Equality now compares live
    // charpos (+1 for 1-based Lisp shape) when the marker has any
    // position information — either attached to a buffer, or a
    // bufferless fixture marker seeded from
    // `make_marker_value(None, Some(N), _)`. A truly unset marker has
    // `buffer == None && charpos == 0`, which reports `None` and matches
    // GNU's "points nowhere" semantics.
    let position = if data.buffer.is_some() || data.charpos > 0 {
        Some(data.charpos as i64 + 1)
    } else {
        None
    };
    Some((data.buffer, position, data.insertion_type))
}

/// Tagged-pointer version: compute equal hash key from a marker Value.
pub(crate) fn marker_equal_hash_key_value(v: &Value) -> HashKey {
    if let Some(marker) = v.as_marker_data() {
        HashKey::Text(format!(
            "marker:{:?}:{}:{}",
            marker.buffer.map(|buffer| buffer.0),
            marker.charpos,
            marker.insertion_type
        ))
    } else {
        HashKey::Ptr(v.bits())
    }
}

pub(crate) fn marker_id_value(v: &Value) -> Option<u64> {
    if !v.is_marker() {
        return None;
    };
    v.as_marker_data().unwrap().marker_id
}

fn is_mark_marker(v: &Value) -> bool {
    marker_id_value(v) == Some(MARK_MARKER_ID)
}

fn set_marker_id(v: &Value, mid: u64) {
    if v.is_marker() {
        let _ = v.with_marker_data_mut(|data| {
            data.marker_id = Some(mid);
        });
    }
}

/// Assert that a value is a marker and return a wrong-type-argument error if
/// it is not.
fn expect_marker(_name: &str, v: &Value) -> Result<(), Flow> {
    if is_marker(v) {
        Ok(())
    } else {
        Err(signal(
            "wrong-type-argument",
            vec![Value::symbol("markerp"), *v],
        ))
    }
}

fn marker_position_value(v: &Value) -> Value {
    if !v.is_marker() {
        return Value::NIL;
    };
    let data = v.as_marker_data().unwrap();
    // T7: the stale `position` cache is gone. The only source of truth is
    // `charpos` (live for buffer-attached markers, pre-seeded from the
    // Lisp position for unregistered/synthesized markers in
    // `make_marker_value_with_id`). Use `buffer.is_some()` to decide
    // "attached", matching GNU (`Fmarker_position` returns nil for a
    // detached marker). Bufferless NeoVM-internal fixture markers that
    // carry a seeded charpos report it back as `charpos + 1`; if charpos
    // is 0 (i.e. `make_marker_value(None, None, _)`), return nil.
    if data.buffer.is_some() {
        Value::fixnum(data.charpos as i64 + 1)
    } else if data.charpos > 0 {
        Value::fixnum(data.charpos as i64 + 1)
    } else {
        Value::NIL
    }
}

/// Return marker position as an integer.
///
/// Signals `error` when marker is unset, matching Emacs behavior in position
/// contexts that require a concrete marker location.
pub(crate) fn marker_position_as_int(v: &Value) -> Result<i64, Flow> {
    expect_marker("marker-position", v)?;
    match marker_position_value(v).kind() {
        ValueKind::Fixnum(n) => Ok(n),
        _ => Err(signal(
            "error",
            vec![Value::string("Marker does not point anywhere")],
        )),
    }
}

pub(crate) fn marker_position_as_int_with_buffers(
    buffers: &BufferManager,
    v: &Value,
) -> Result<i64, Flow> {
    expect_marker("marker-position", v)?;

    // Special mark-marker: resolves via buffer's tracked mark-char.
    // (See buffer.rs mark_char() for how the mark position is stored.)
    if is_mark_marker(v) {
        if let Some(buf_id) = marker_buffer_id(v)
            && let Some(buf) = buffers.get(buf_id)
        {
            return match buf.mark_char() {
                Some(char_pos) => Ok(char_pos as i64 + 1),
                None => Err(signal(
                    "error",
                    vec![Value::string("Marker does not point anywhere")],
                )),
            };
        }
    }

    let data = v.as_marker_data().unwrap();
    // T7: stale `position` cache is gone. Attached markers return live
    // charpos+1; bufferless NeoVM-internal fixture markers seeded with a
    // position keep reporting it back via the seeded charpos; a truly
    // unset marker (`make-marker` with no buffer and no position) has
    // charpos == 0 and buffer == None, which signals "points nowhere".
    if data.buffer.is_some() {
        Ok(data.charpos as i64 + 1)
    } else if data.charpos > 0 {
        Ok(data.charpos as i64 + 1)
    } else {
        Err(signal(
            "error",
            vec![Value::string("Marker does not point anywhere")],
        ))
    }
}

pub(crate) fn marker_position_as_int_eval(
    eval: &super::eval::Context,
    v: &Value,
) -> Result<i64, Flow> {
    marker_position_as_int_with_buffers(&eval.buffers, v)
}

fn marker_buffer_value(v: &Value) -> Value {
    if !v.is_marker() {
        return Value::NIL;
    };
    match v.as_marker_data().unwrap().buffer {
        Some(buffer_id) => Value::make_buffer(buffer_id),
        None => Value::NIL,
    }
}

fn marker_insertion_type_value(v: &Value) -> Value {
    if !v.is_marker() {
        return Value::NIL;
    };
    Value::bool_val(v.as_marker_data().unwrap().insertion_type)
}

fn marker_buffer_id(v: &Value) -> Option<BufferId> {
    if !v.is_marker() {
        return None;
    };
    v.as_marker_data().unwrap().buffer
}

fn lisp_pos_to_byte(buf: &crate::buffer::Buffer, lisp_pos: i64) -> usize {
    // GNU Emacs: set-marker clamps to the full buffer, not the narrowed region.
    buf.lisp_pos_to_full_buffer_byte(lisp_pos)
}

fn marker_targets_current_mark(marker: &Value) -> bool {
    is_mark_marker(marker)
}

// ---------------------------------------------------------------------------
// Pure builtins
// ---------------------------------------------------------------------------

/// (markerp OBJECT) -> t if OBJECT is a marker, nil otherwise
pub(crate) fn builtin_markerp(args: Vec<Value>) -> EvalResult {
    expect_args("markerp", &args, 1)?;
    Ok(Value::bool_val(is_marker(&args[0])))
}

/// Eval-dependent marker-position that reads adjusted positions from the buffer.
pub(crate) fn builtin_marker_position(
    eval: &mut super::eval::Context,
    args: Vec<Value>,
) -> EvalResult {
    builtin_marker_position_in_buffers(&eval.buffers, args)
}

pub(crate) fn builtin_marker_position_in_buffers(
    _buffers: &BufferManager,
    args: Vec<Value>,
) -> EvalResult {
    expect_args("marker-position", &args, 1)?;
    expect_marker("marker-position", &args[0])?;
    Ok(marker_position_value(&args[0]))
}

/// Context-aware marker-buffer that returns nil for killed buffers.
/// GNU returns nil when the marker's buffer has been killed.
pub(crate) fn builtin_marker_buffer(
    eval: &mut super::eval::Context,
    args: Vec<Value>,
) -> EvalResult {
    expect_args("marker-buffer", &args, 1)?;
    expect_marker("marker-buffer", &args[0])?;
    if let Some(buffer_id) = marker_buffer_id(&args[0])
        && eval.buffers.get(buffer_id).is_some()
    {
        return Ok(Value::make_buffer(buffer_id));
    }
    Ok(Value::NIL)
}

/// Buffer-aware marker-buffer for the VM fast dispatch path.
/// Returns nil for killed buffers (same as the eval-aware version).
pub(crate) fn builtin_marker_buffer_in_buffers(
    buffers: &BufferManager,
    args: Vec<Value>,
) -> EvalResult {
    expect_args("marker-buffer", &args, 1)?;
    expect_marker("marker-buffer", &args[0])?;
    if let Some(buffer_id) = marker_buffer_id(&args[0])
        && buffers.get(buffer_id).is_some()
    {
        return Ok(Value::make_buffer(buffer_id));
    }
    Ok(Value::NIL)
}

/// (marker-insertion-type MARKER) -> t or nil
pub(crate) fn builtin_marker_insertion_type(args: Vec<Value>) -> EvalResult {
    expect_args("marker-insertion-type", &args, 1)?;
    expect_marker("marker-insertion-type", &args[0])?;
    Ok(marker_insertion_type_value(&args[0]))
}

/// Eval-dependent set-marker-insertion-type that also updates the buffer's
/// marker entry so insertion behavior changes immediately.
pub(crate) fn builtin_set_marker_insertion_type(
    eval: &mut super::eval::Context,
    args: Vec<Value>,
) -> EvalResult {
    builtin_set_marker_insertion_type_in_buffers(&mut eval.buffers, args)
}

pub(crate) fn builtin_set_marker_insertion_type_in_buffers(
    buffers: &mut BufferManager,
    args: Vec<Value>,
) -> EvalResult {
    expect_args("set-marker-insertion-type", &args, 2)?;
    expect_marker("set-marker-insertion-type", &args[0])?;
    let new_type = args[1].is_truthy();
    if args[0].is_marker() {
        let _ = args[0].with_marker_data_mut(|data| {
            data.insertion_type = new_type;
        });
    }

    if let Some(mid) = marker_id_value(&args[0]) {
        let ins_type = if new_type {
            InsertionType::After
        } else {
            InsertionType::Before
        };
        buffers.update_marker_insertion_type(mid, ins_type);
    }

    Ok(args[1])
}

/// (make-marker) -> new empty marker (no buffer, no position)
pub(crate) fn builtin_make_marker(args: Vec<Value>) -> EvalResult {
    expect_args("make-marker", &args, 0)?;
    Ok(make_marker_value(None, None, false))
}

/// Eval-dependent copy-marker that registers the new marker in the buffer.
pub(crate) fn builtin_copy_marker(eval: &mut super::eval::Context, args: Vec<Value>) -> EvalResult {
    builtin_copy_marker_in_buffers(&mut eval.buffers, args)
}

pub(crate) fn builtin_copy_marker_in_buffers(
    buffers: &mut BufferManager,
    args: Vec<Value>,
) -> EvalResult {
    expect_range_args("copy-marker", &args, 1, 2)?;
    let insertion_type = if args.len() > 1 {
        args[1].is_truthy()
    } else {
        false
    };

    let src = &args[0];
    match src.kind() {
        ValueKind::Veclike(VecLikeType::Marker) => {
            let buffer_id = marker_buffer_id(src);

            let position = if is_mark_marker(src) {
                buffer_id
                    .and_then(|buf_id| buffers.get(buf_id))
                    .and_then(|buf| buf.mark_char().map(|m| m as i64 + 1))
            } else {
                match marker_position_value(src).kind() {
                    ValueKind::Fixnum(n) => Some(n),
                    _ => None,
                }
            };

            let marker = make_marker_value(buffer_id, position, insertion_type);
            register_marker_in_buffers(buffers, &marker, buffer_id, position);
            Ok(marker)
        }
        ValueKind::Fixnum(n) => {
            let buffer_id = buffers.current_buffer().map(|b| b.id);
            let marker = make_marker_value(buffer_id, Some(n), insertion_type);
            register_marker_in_buffers(buffers, &marker, buffer_id, Some(n));
            Ok(marker)
        }
        ValueKind::Nil => Ok(make_marker_value(None, None, insertion_type)),
        _other => Err(signal(
            "wrong-type-argument",
            vec![Value::symbol("integer-or-marker-p"), args[0]],
        )),
    }
}

// ---------------------------------------------------------------------------
// Eval-dependent builtins
// ---------------------------------------------------------------------------

/// (set-marker MARKER POSITION &optional BUFFER) -> MARKER
///
/// Set the position and (optionally) the buffer of MARKER.  If POSITION is
/// nil, the marker is unset (points nowhere).  BUFFER defaults to the current
/// buffer.
pub(crate) fn builtin_set_marker(eval: &mut super::eval::Context, args: Vec<Value>) -> EvalResult {
    builtin_set_marker_in_buffers(&mut eval.buffers, args)
}

pub(crate) fn builtin_set_marker_in_buffers(
    buffers: &mut BufferManager,
    args: Vec<Value>,
) -> EvalResult {
    expect_range_args("set-marker", &args, 2, 3)?;
    expect_marker("set-marker", &args[0])?;

    let targets_current_mark = marker_targets_current_mark(&args[0]);

    let buffer_id: Option<BufferId> = if args.len() > 2 && args[2].is_truthy() {
        match args[2].kind() {
            ValueKind::String => {
                let name = args[2].as_runtime_string_owned().ok_or_else(|| {
                    signal(
                        "wrong-type-argument",
                        vec![Value::symbol("stringp"), args[2]],
                    )
                })?;
                buffers.find_buffer_by_name(&name)
            }
            ValueKind::Veclike(VecLikeType::Buffer) => args[2].as_buffer_id(),
            _other => {
                return Err(signal(
                    "wrong-type-argument",
                    vec![Value::symbol("stringp"), args[2]],
                ));
            }
        }
    } else {
        // Default to current buffer
        buffers.current_buffer().map(|b| b.id)
    };

    // Resolve position
    let position: Option<i64> = match args[1].kind() {
        ValueKind::Nil => None,
        ValueKind::Fixnum(n) => Some(n),
        ValueKind::Veclike(VecLikeType::Marker) => {
            marker_position_as_int_with_buffers(buffers, &args[1]).ok()
        }
        _other => {
            return Err(signal(
                "wrong-type-argument",
                vec![Value::symbol("integer-or-marker-p"), args[1]],
            ));
        }
    };

    // GNU Emacs: when position is nil, the marker is detached from its buffer.
    let buffer_id = position.and(buffer_id);

    // Clamp position to the full buffer range (1 .. total_chars+1), matching
    // GNU Emacs which clamps to the whole buffer, ignoring narrowing.
    let position = match (position, buffer_id) {
        (Some(pos), Some(buf_id)) => {
            if let Some(buf) = buffers.get(buf_id) {
                let max_pos = buf.total_chars() as i64 + 1;
                Some(pos.clamp(1, max_pos))
            } else {
                Some(pos)
            }
        }
        (other, _) => other,
    };

    register_marker_in_buffers(buffers, &args[0], buffer_id, position);

    if args[0].is_marker() {
        let _ = args[0].with_marker_data_mut(|data| {
            data.buffer = buffer_id;
            // T7: stale `position` cache removed. If `position` is None
            // (marker detached), clear charpos/bytepos so the unset
            // discriminator (`buffer.is_none() && charpos == 0`) fires
            // correctly. For attached markers, register_marker_in_buffers
            // above already spliced the marker into the new buffer's
            // chain, which wrote authoritative charpos/bytepos.
            if position.is_none() {
                data.charpos = 0;
                data.bytepos = 0;
            }
        });
    }

    if targets_current_mark {
        let target_buf_id = buffer_id.or_else(|| buffers.current_buffer().map(|buf| buf.id));
        if let Some(buf_id) = target_buf_id {
            match position {
                Some(pos) => {
                    if let Some(byte_pos) =
                        buffers.get(buf_id).map(|buf| lisp_pos_to_byte(buf, pos))
                    {
                        let _ = buffers.set_buffer_mark(buf_id, byte_pos);
                    }
                }
                None => {
                    let _ = buffers.clear_buffer_mark(buf_id);
                }
            }
        }
    }

    Ok(args[0])
}

/// (move-marker MARKER POSITION &optional BUFFER) -> MARKER
///
/// GNU Emacs exposes `move-marker` as the marker-moving primitive used by
/// Lisp code such as `indent.el`. Its observable behavior matches
/// `set-marker`, so reuse that implementation.
pub(crate) fn builtin_move_marker(eval: &mut super::eval::Context, args: Vec<Value>) -> EvalResult {
    builtin_move_marker_in_buffers(&mut eval.buffers, args)
}

pub(crate) fn builtin_move_marker_in_buffers(
    buffers: &mut BufferManager,
    args: Vec<Value>,
) -> EvalResult {
    builtin_set_marker_in_buffers(buffers, args)
}

/// Register a Lisp marker in the target buffer's marker list so that
/// insert/delete operations automatically adjust its position.
#[allow(dead_code)]
fn register_marker_in_buffer(
    eval: &mut super::eval::Context,
    marker: &Value,
    buffer_id: Option<BufferId>,
    position: Option<i64>,
) {
    register_marker_in_buffers(&mut eval.buffers, marker, buffer_id, position);
}

fn register_marker_in_buffers(
    buffers: &mut BufferManager,
    marker: &Value,
    buffer_id: Option<BufferId>,
    position: Option<i64>,
) {
    if is_mark_marker(marker) {
        return;
    }

    // Read insertion type from marker vector
    let insertion_type_val = marker_insertion_type_value(marker);
    let ins_type = if insertion_type_val.is_truthy() {
        crate::buffer::InsertionType::After
    } else {
        crate::buffer::InsertionType::Before
    };

    // Get or assign a marker-id
    let existing_mid = marker_id_value(marker);

    // Remove old registration from all buffers (this also unchains the
    // marker on the old buffer's intrusive chain — BufferText::remove_marker
    // walks the chain and unlinks, clearing MarkerData.buffer/bytepos/charpos).
    if let Some(mid) = existing_mid {
        buffers.remove_marker(mid);
    }

    if let (Some(buf_id), Some(pos)) = (buffer_id, position) {
        let mid = existing_mid.unwrap_or_else(|| buffers.allocate_marker_id());
        set_marker_id(marker, mid);
        // Resolve the MarkerObj pointer from the Lisp-visible Value so
        // register_marker_id can splice it into buf_id's chain.
        let marker_ptr = marker
            .as_veclike_ptr()
            .map(|p| p as *mut crate::tagged::header::MarkerObj);
        // Defensive: the marker's old chain was cleared by `remove_marker`
        // above if it had a previous buffer binding. But Values freshly
        // created via `make_marker_value` (point-marker etc.) don't go
        // through that path — they arrive here with `next_marker == null`
        // by construction of `MarkerData`. If for some reason this marker
        // is still on a chain (e.g. same-buffer re-registration where
        // `existing_mid` matched a chain entry we just removed), the
        // chain_splice_at_head precondition would fire; belt-and-braces
        // unlink from this buffer first.
        if let (Some(ptr), Some(buf)) = (marker_ptr, buffers.get(buf_id)) {
            buf.text.chain_unlink(ptr);
        }
        if let (Some(ptr), Some(byte_pos)) = (
            marker_ptr,
            buffers.get(buf_id).map(|buf| lisp_pos_to_byte(buf, pos)),
        ) {
            let _ = buffers.register_marker_id(ptr, buf_id, mid, byte_pos, ins_type);
        }
    }
}

/// (point-marker) -> marker at current point
pub(crate) fn builtin_point_marker(
    eval: &mut super::eval::Context,
    args: Vec<Value>,
) -> EvalResult {
    builtin_point_marker_in_buffers(&mut eval.buffers, args)
}

pub(crate) fn builtin_point_marker_in_buffers(
    buffers: &mut BufferManager,
    args: Vec<Value>,
) -> EvalResult {
    expect_args("point-marker", &args, 0)?;
    let buf = buffers
        .current_buffer()
        .ok_or_else(|| signal("error", vec![Value::string("No current buffer")]))?;
    let pos = buf.point_char() as i64 + 1; // 1-based
    let buffer_id = buf.id;
    let marker = make_marker_value(Some(buffer_id), Some(pos), false);
    register_marker_in_buffers(buffers, &marker, Some(buffer_id), Some(pos));
    Ok(marker)
}

/// (point-min-marker) -> marker at point-min
pub(crate) fn builtin_point_min_marker(
    eval: &mut super::eval::Context,
    args: Vec<Value>,
) -> EvalResult {
    builtin_point_min_marker_in_buffers(&mut eval.buffers, args)
}

pub(crate) fn builtin_point_min_marker_in_buffers(
    buffers: &mut BufferManager,
    args: Vec<Value>,
) -> EvalResult {
    expect_args("point-min-marker", &args, 0)?;
    let buf = buffers
        .current_buffer()
        .ok_or_else(|| signal("error", vec![Value::string("No current buffer")]))?;
    let pos = buf.point_min_char() as i64 + 1; // 1-based
    let buffer_id = buf.id;
    let marker = make_marker_value(Some(buffer_id), Some(pos), false);
    register_marker_in_buffers(buffers, &marker, Some(buffer_id), Some(pos));
    Ok(marker)
}

/// (point-max-marker) -> marker at point-max
pub(crate) fn builtin_point_max_marker(
    eval: &mut super::eval::Context,
    args: Vec<Value>,
) -> EvalResult {
    builtin_point_max_marker_in_buffers(&mut eval.buffers, args)
}

pub(crate) fn builtin_point_max_marker_in_buffers(
    buffers: &mut BufferManager,
    args: Vec<Value>,
) -> EvalResult {
    expect_args("point-max-marker", &args, 0)?;
    let buf = buffers
        .current_buffer()
        .ok_or_else(|| signal("error", vec![Value::string("No current buffer")]))?;
    let pos = buf.point_max_char() as i64 + 1; // 1-based
    let buffer_id = buf.id;
    let marker = make_marker_value(Some(buffer_id), Some(pos), false);
    register_marker_in_buffers(buffers, &marker, Some(buffer_id), Some(pos));
    Ok(marker)
}

/// (mark-marker) -> marker at mark, or error if no mark set
pub(crate) fn builtin_mark_marker(eval: &mut super::eval::Context, args: Vec<Value>) -> EvalResult {
    builtin_mark_marker_in_buffers(&eval.buffers, args)
}

pub(crate) fn builtin_mark_marker_in_buffers(
    buffers: &BufferManager,
    args: Vec<Value>,
) -> EvalResult {
    expect_args("mark-marker", &args, 0)?;
    let buf = buffers
        .current_buffer()
        .ok_or_else(|| signal("error", vec![Value::string("No current buffer")]))?;
    let buffer_id = buf.id;
    match buf.mark_char() {
        Some(char_pos) => {
            let pos = char_pos as i64 + 1; // 1-based
            Ok(make_marker_value_with_id(
                Some(buffer_id),
                Some(pos),
                false,
                Some(MARK_MARKER_ID),
            ))
        }
        // T7: with MarkerData.position deleted, an unset marker must be
        // distinguishable solely by `buffer.is_none()`. Drop the buffer
        // binding for unset mark-markers; `marker-position` on this value
        // still returns nil, and `marker-buffer` returns nil, matching
        // GNU's "unset marker points nowhere" semantics.
        None => Ok(make_marker_value_with_id(
            None,
            None,
            false,
            Some(MARK_MARKER_ID),
        )),
    }
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------
#[cfg(test)]
#[path = "marker_test.rs"]
mod tests;