use std::{rc::Rc};
use std::{collections::VecDeque};
use fnv::{FnvBuildHasher};
use quickscope::ScopeMap;
use crate::{lang::{Sequence, Rst}, RantValue, Rant};
use crate::runtime::*;
use super::{output::OutputWriter};
type CallStackVector<I> = SmallVec<[StackFrame<I>; super::CALL_STACK_INLINE_COUNT]>;
pub struct CallStack<I> {
frames: CallStackVector<I>,
locals: ScopeMap<InternalString, RantVar, FnvBuildHasher>,
}
impl<I> Default for CallStack<I> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<I> CallStack<I> {
#[inline]
pub(crate) fn new() -> Self {
Self {
frames: Default::default(),
locals: Default::default(),
}
}
#[inline]
pub fn is_empty(&self) -> bool {
self.frames.is_empty()
}
#[inline]
pub fn len(&self) -> usize {
self.frames.len()
}
#[inline]
pub fn pop_frame(&mut self) -> Option<StackFrame<I>> {
if let Some(frame) = self.frames.pop() {
self.locals.pop_layer();
return Some(frame)
}
None
}
#[inline]
pub fn push_frame(&mut self, frame: StackFrame<I>) {
self.locals.push_layer();
self.frames.push(frame);
}
#[inline]
pub fn top_mut(&mut self) -> Option<&mut StackFrame<I>> {
self.frames.last_mut()
}
#[inline]
pub fn parent_mut(&mut self, depth: usize) -> Option<&mut StackFrame<I>> {
self.frames.iter_mut().rev().nth(depth)
}
#[inline]
pub fn parent(&self, depth: usize) -> Option<&StackFrame<I>> {
self.frames.iter().rev().nth(depth)
}
#[inline]
pub fn top(&self) -> Option<&StackFrame<I>> {
self.frames.last()
}
pub fn gen_stack_trace(&self) -> String {
let mut trace = String::new();
let mut last_frame_info: Option<(String, usize)> = None;
for frame in self.frames.iter().rev() {
let current_frame_string = frame.to_string();
if let Some((last_frame_string, count)) = last_frame_info.take() {
if current_frame_string == last_frame_string {
last_frame_info = Some((last_frame_string, count + 1));
} else {
match count {
1 => trace.push_str(&format!("-> {}\n", last_frame_string)),
_ => trace.push_str(&format!("-> {} ({} frames)\n", last_frame_string, count)),
}
last_frame_info = Some((current_frame_string, 1));
}
} else {
last_frame_info = Some((current_frame_string, 1));
}
}
if let Some((last_frame_string, count)) = last_frame_info.take() {
match count {
1 => trace.push_str(&format!("-> {}", last_frame_string)),
_ => trace.push_str(&format!("-> {} ({} frames)", last_frame_string, count)),
}
}
trace
}
#[inline]
pub fn set_var_value(&mut self, context: &mut Rant, id: &str, access: AccessPathKind, val: RantValue) -> RuntimeResult<()> {
match access {
AccessPathKind::Local => {
if let Some(var) = self.locals.get_mut(id) {
if !var.write(val) {
runtime_error!(RuntimeErrorType::InvalidAccess, "cannot reassign local constant '{}'", id);
}
return Ok(())
}
},
AccessPathKind::Descope(n) => {
if let Some(var) = self.locals.get_parent_mut(id, n) {
if !var.write(val) {
runtime_error!(RuntimeErrorType::InvalidAccess, "cannot reassign local constant '{}'", id);
}
return Ok(())
}
},
AccessPathKind::ExplicitGlobal => {}
}
if context.has_global(id) {
if !context.set_global(id, val) {
runtime_error!(RuntimeErrorType::InvalidAccess, "cannot reassign global constant '{}'", id);
}
return Ok(())
}
runtime_error!(RuntimeErrorType::InvalidAccess, "variable '{}' not found", id);
}
#[inline]
pub fn get_var_depth(&self, context: &Rant, id: &str, access: AccessPathKind) -> RuntimeResult<usize> {
match access {
AccessPathKind::Local => {
if let Some(d) = self.locals.depth_of(id) {
return Ok(d)
}
},
AccessPathKind::Descope(n) => {
if let Some((_, d)) = self.locals.get_parent_depth(id, n) {
return Ok(d)
}
},
AccessPathKind::ExplicitGlobal => {}
}
if context.has_global(id) {
return Ok(self.locals.depth() - 1)
}
runtime_error!(RuntimeErrorType::InvalidAccess, "variable '{}' not found", id);
}
#[inline]
pub fn get_var_value(&self, context: &Rant, id: &str, access: AccessPathKind, prefer_function: bool) -> RuntimeResult<RantValue> {
macro_rules! percolating_func_lookup {
($value_iter:expr) => {
if let Some(mut vars) = $value_iter {
if let Some(mut var) = vars.next() {
if !var.value_ref().is_callable() {
if let Some(func_var) = vars
.find(|v| v.value_ref().is_callable())
.or_else(|| context.get_global_var(id).filter(|v| v.value_ref().is_callable()))
{
var = func_var;
}
}
return Ok(var.value_cloned())
}
}
}
}
match access {
AccessPathKind::Local => {
if prefer_function {
percolating_func_lookup!(self.locals.get_all(id));
} else if let Some(var) = self.locals.get(id) {
return Ok(var.value_cloned())
}
},
AccessPathKind::Descope(n) => {
if prefer_function {
percolating_func_lookup!(self.locals.get_parents(id, n));
} else if let Some(var) = self.locals.get_parent(id, n) {
return Ok(var.value_cloned())
}
},
AccessPathKind::ExplicitGlobal => {},
}
if let Some(val) = context.get_global(id) {
return Ok(val)
}
Err(RuntimeError {
error_type: RuntimeErrorType::InvalidAccess,
description: Some(format!("{} '{}' not found", if prefer_function { "function" } else { "variable" }, id)),
stack_trace: None,
})
}
pub fn get_var_mut<'a>(&'a mut self, context: &'a mut Rant, id: &str, access: AccessPathKind) -> RuntimeResult<&'a mut RantVar> {
match access {
AccessPathKind::Local => {
if let Some(var) = self.locals.get_mut(id) {
return Ok(var)
}
},
AccessPathKind::Descope(n) => {
if let Some(var) = self.locals.get_parent_mut(id, n) {
return Ok(var)
}
},
AccessPathKind::ExplicitGlobal => {},
}
if let Some(var) = context.get_global_var_mut(id) {
return Ok(var)
}
Err(RuntimeError {
error_type: RuntimeErrorType::InvalidAccess,
description: Some(format!("variable '{}' not found", id)),
stack_trace: None,
})
}
pub fn def_local_var(&mut self, id: &str, var: RantVar) -> RuntimeResult<()> {
self.locals.define(InternalString::from(id), var);
Ok(())
}
#[inline]
pub fn def_var_value(&mut self, context: &mut Rant, id: &str, access: AccessPathKind, val: RantValue, is_const: bool) -> RuntimeResult<()> {
match access {
AccessPathKind::Local => {
if let Some(v) = self.locals.get(id) {
if v.is_const() && self.locals.depth_of(id) == Some(0) {
runtime_error!(RuntimeErrorType::InvalidAccess, "attempted to redefine local constant '{}'", id);
}
}
let variable = if is_const { RantVar::ByValConst(val) } else { RantVar::ByVal(val) };
self.locals.define(InternalString::from(id), variable);
return Ok(())
},
AccessPathKind::Descope(descope_count) => {
if let Some((v, vd)) = self.locals.get_parent_depth(id, descope_count) {
if v.is_const() && vd == descope_count {
runtime_error!(RuntimeErrorType::InvalidAccess, "attempted to redefine parent constant '{}'", id);
}
}
let variable = if is_const { RantVar::ByValConst(val) } else { RantVar::ByVal(val) };
self.locals.define_parent(InternalString::from(id), variable, descope_count);
return Ok(())
},
AccessPathKind::ExplicitGlobal => {}
}
if !(if is_const { context.set_global_const(id, val) } else { context.set_global(id, val) }) {
runtime_error!(RuntimeErrorType::InvalidAccess, "attempted to redefine global constant '{}'", id);
}
Ok(())
}
#[inline]
pub fn taste_for_first(&self, target_flavor: StackFrameFlavor) -> Option<usize> {
for (frame_index, frame) in self.frames.iter().rev().enumerate() {
if frame.flavor > target_flavor {
return None
} else if frame.flavor == target_flavor {
return Some(frame_index)
}
}
None
}
#[inline]
pub fn taste_for(&self, target_flavor: StackFrameFlavor) -> Option<usize> {
for (frame_index, frame) in self.frames.iter().rev().enumerate() {
if frame.flavor == target_flavor {
return Some(frame_index)
}
}
None
}
}
pub struct StackFrame<I> {
sequence: Option<Rc<Sequence>>,
pc: usize,
started: bool,
output: Option<OutputWriter>,
intents: VecDeque<I>,
debug_pos: (usize, usize),
origin: Rc<RantProgramInfo>,
flavor: StackFrameFlavor,
}
impl<I> StackFrame<I> {
#[inline]
pub(crate) fn new(sequence: Rc<Sequence>, has_output: bool, prev_output: Option<&OutputWriter>) -> Self {
Self {
origin: Rc::clone(&sequence.origin),
sequence: Some(sequence),
output: if has_output { Some(OutputWriter::new(prev_output)) } else { None },
started: false,
pc: 0,
intents: Default::default(),
debug_pos: (0, 0),
flavor: Default::default(),
}
}
#[inline]
pub(crate) fn with_extended_config(
sequence: Option<Rc<Sequence>>,
has_output: bool,
prev_output: Option<&OutputWriter>,
origin: Rc<RantProgramInfo>,
debug_pos: (usize, usize),
flavor: StackFrameFlavor
) -> Self
{
Self {
origin,
sequence,
output: if has_output { Some(OutputWriter::new(prev_output)) } else { None },
started: false,
pc: 0,
intents: Default::default(),
debug_pos,
flavor,
}
}
#[inline(always)]
pub(crate) fn with_flavor(self, flavor: StackFrameFlavor) -> Self {
let mut frame = self;
frame.flavor = flavor;
frame
}
}
impl<I> StackFrame<I> {
#[inline]
pub(crate) fn seq_next(&mut self) -> Option<Rc<Rst>> {
if self.is_done() {
return None
}
if self.started {
self.pc += 1;
} else {
self.started = true;
}
self.sequence.as_ref().and_then(|seq| seq.get(self.pc).map(Rc::clone))
}
#[inline(always)]
pub fn pc(&self) -> usize {
self.pc
}
#[inline(always)]
pub fn flavor(&self) -> StackFrameFlavor {
self.flavor
}
#[inline(always)]
pub fn output(&self) -> Option<&OutputWriter> {
self.output.as_ref()
}
#[inline(always)]
pub fn origin(&self) -> &Rc<RantProgramInfo> {
&self.origin
}
#[inline(always)]
pub fn debug_pos(&self) -> (usize, usize) {
self.debug_pos
}
#[inline]
pub fn origin_name(&self) -> &str {
self.origin.path
.as_deref()
.unwrap_or_else(||
self.origin.name
.as_deref()
.unwrap_or(DEFAULT_PROGRAM_NAME)
)
}
#[inline(always)]
pub(crate) fn take_intent(&mut self) -> Option<I> {
self.intents.pop_front()
}
#[inline(always)]
pub fn push_intent_front(&mut self, intent: I) {
self.intents.push_front(intent);
}
#[inline(always)]
pub fn push_intent_back(&mut self, intent: I) {
self.intents.push_back(intent);
}
#[inline]
pub fn use_output_mut<F: FnOnce(&mut OutputWriter)>(&mut self, func: F) {
if let Some(output) = self.output.as_mut() {
func(output);
}
}
#[inline]
pub fn use_output<'a, F: FnOnce(&'a OutputWriter) -> R, R>(&'a self, func: F) -> Option<R> {
self.output.as_ref().map(|output| func(output))
}
#[inline]
pub fn set_debug_info(&mut self, info: &DebugInfo) {
match info {
DebugInfo::Location { line, col } => self.debug_pos = (*line, *col),
}
}
}
impl<I> StackFrame<I> {
#[inline(always)]
fn is_done(&self) -> bool {
self.sequence.is_none() || self.pc >= self.sequence.as_ref().unwrap().len()
}
#[inline]
pub fn write_frag(&mut self, frag: &str) {
if let Some(output) = self.output.as_mut() {
output.write_frag(frag);
}
}
#[inline]
pub fn write_ws(&mut self, ws: &str) {
if let Some(output) = self.output.as_mut() {
output.write_ws(ws);
}
}
#[inline]
pub fn write_value(&mut self, val: RantValue) {
if let Some(output) = self.output.as_mut() {
output.write_value(val);
}
}
#[inline]
pub fn into_output(mut self) -> Option<RantValue> {
self.output.take().map(|o| o.render_value())
}
}
impl<I> Display for StackFrame<I> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "[{}:{}:{}] in {}",
self.origin_name(),
self.debug_pos.0,
self.debug_pos.1,
self.sequence.as_ref()
.and_then(|seq| seq.name().map(|name| name.as_str()))
.unwrap_or_else(|| self.flavor.name()),
)
}
}
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
pub enum StackFrameFlavor {
Original,
NativeCall,
BlockElement,
RepeaterElement,
FunctionBody,
DynamicKeyExpression,
ArgumentExpression,
}
impl Default for StackFrameFlavor {
fn default() -> Self {
Self::Original
}
}
impl StackFrameFlavor {
fn name(&self) -> &'static str {
match self {
Self::Original => "sequence",
Self::NativeCall => "native call",
Self::BlockElement => "block element",
Self::RepeaterElement => "repeater element",
Self::FunctionBody => "function body",
Self::DynamicKeyExpression => "dynamic key",
Self::ArgumentExpression => "argument",
}
}
}