}
}
+pub(super)
+fn compile_into_module<R: Read>(wam: &mut Machine, src: R, name: ClauseName) -> EvalSession
+{
+ let mut indices = default_index_store!(wam.atom_tbl_of(&name));
+ try_eval_session!(setup_indices(wam, name.owning_module(), &mut indices));
+
+ let mut compiler = ListingCompiler::new(&wam.code_repo);
+
+ let results = try_eval_session!(compiler.gather_items(wam, src, &mut indices));
+ let module_code = try_eval_session!(compiler.generate_code(results.worker_results, wam,
+ &mut indices.code_dir, 0));
+
+ let mut clause_code_generator = ClauseCodeGenerator::new(module_code.len());
+ try_eval_session!(clause_code_generator.generate_clause_code(results.dynamic_clause_map,
+ wam));
+
+ match wam.indices.modules.get_mut(&name.owning_module()) {
+ Some(module) => {
+ let code_dir = mem::replace(&mut indices.code_dir, CodeDir::new());
+ module.code_dir.extend(as_module_code_dir(code_dir));
+ },
+ _ => unreachable!()
+ };
+
+ wam.code_repo.code.extend(module_code.into_iter());
+ clause_code_generator.add_clause_code(wam);
+
+ EvalSession::EntrySuccess
+}
+
pub struct GatherResult {
dynamic_clause_map: DynamicClauseMap,
pub(crate) worker_results: Vec<PredicateCompileQueue>,
continue;
}
+ if let Some(idx) = wam.indices.code_dir.get(&(name.clone(), arity)) {
+ if !idx.is_undefined() && name.owning_module() != idx.module_name() {
+ let err_str = format!("{}/{}", name.as_str(), arity);
+ let err_str = clause_name!(err_str, wam.indices.atom_tbl());
+
+ return Err(SessionError::CannotOverwriteDynamicClause(err_str));
+ }
+ }
+
let predicate = Predicate(heads_and_tails.into_iter().map(|(head, tail)| {
let clause = Term::Clause(Cell::default(), clause_name!("clause"),
vec![Box::new(head), Box::new(tail)],
pub(crate)
fn generate_code(&mut self, decls: Vec<PredicateCompileQueue>, wam: &Machine,
- code_dir: &mut CodeDir)
+ code_dir: &mut CodeDir, code_offset: usize)
-> Result<Code, SessionError>
{
let mut code = vec![];
let (name, arity) = decl.predicate_indicator().ok_or(SessionError::NamelessEntry)?;
let non_counted_bt = self.non_counted_bt_preds.contains(&(name.clone(), arity));
- let p = code.len() + wam.code_size();
+ let p = code.len() + wam.code_size() + code_offset;
let mut decl_code = compile_relation(&TopLevel::Predicate(decl), non_counted_bt,
wam.machine_flags())?;
let mut results = try_eval_session!(compiler.gather_items(wam, src, &mut indices));
let module_code = try_eval_session!(compiler.generate_code(results.worker_results, wam,
- &mut indices.code_dir));
+ &mut indices.code_dir, 0));
let toplvl_code = try_eval_session!(compiler.generate_code(results.toplevel_results, wam,
- &mut results.toplevel_indices.code_dir));
+ &mut results.toplevel_indices.code_dir,
+ module_code.len()));
if let Some(ref mut module) = &mut compiler.module {
module.term_expansions = results.addition_results.take_term_expansions();
try_eval_session!(wam.code_repo.compile_hook(CompileTimeHook::UserGoalExpansion, flags));
if let Some(module) = compiler.module.take() {
- try_eval_session!(add_non_module_code(wam, results.dynamic_clause_map, toplvl_code,
- results.toplevel_indices));
+ let mut clause_code_generator = ClauseCodeGenerator::new(module_code.len() + toplvl_code.len());
+
+ try_eval_session!(clause_code_generator.generate_clause_code(results.dynamic_clause_map, wam));
+ try_eval_session!(wam.check_toplevel_code(&results.toplevel_indices));
add_module_code(wam, module, module_code, indices);
+ add_toplevel_code(wam, toplvl_code, results.toplevel_indices);
+
+ clause_code_generator.add_clause_code(wam);
} else {
try_eval_session!(add_non_module_code(wam, results.dynamic_clause_map, module_code,
- indices));
+ indices));
}
EvalSession::EntrySuccess
pub fn compile_special_form<R: Read>(wam: &mut Machine, src: R) -> Result<Code, SessionError>
{
let mut indices = default_index_store!(wam.indices.atom_tbl.clone());
- setup_indices(wam, &mut indices)?;
+ setup_indices(wam, clause_name!("builtins"), &mut indices)?;
let mut compiler = ListingCompiler::new(&wam.code_repo);
let results = compiler.gather_items(wam, src, &mut indices)?;
- compiler.generate_code(results.worker_results, wam, &mut indices.code_dir)
+ compiler.generate_code(results.worker_results, wam, &mut indices.code_dir, 0)
}
#[inline]
}
}
-fn setup_indices(wam: &mut Machine, indices: &mut IndexStore) -> Result<(), SessionError> {
- if let Some(builtins) = wam.indices.take_module(clause_name!("builtins")) {
+pub(super)
+fn setup_indices(wam: &mut Machine, module: ClauseName, indices: &mut IndexStore)
+ -> Result<(), SessionError>
+{
+ if let Some(module) = wam.indices.take_module(module) {
let flags = wam.machine_flags();
- let result = indices.use_module(&mut wam.code_repo, flags, &builtins);
+ let result = indices.use_module(&mut wam.code_repo, flags, &module);
- wam.indices.insert_module(builtins);
+ wam.indices.insert_module(module);
result
} else {
Err(SessionError::ModuleNotFound)
pub fn compile_user_module<R: Read>(wam: &mut Machine, src: R) -> EvalSession {
let mut indices = default_index_store!(wam.indices.atom_tbl.clone());
- try_eval_session!(setup_indices(wam, &mut indices));
+ try_eval_session!(setup_indices(wam, clause_name!("builtins"), &mut indices));
compile_listing(wam, src, indices)
}
use prolog::machine::machine_errors::*;
use prolog::num::ToPrimitive;
+use std::io::Read;
+
impl Machine {
- fn get_predicate_key(&self, name: RegType, arity: RegType) -> PredicateKey {
+ pub(super)
+ fn atom_tbl_of(&self, name: &ClauseName) -> TabledData<Atom> {
+ match name {
+ &ClauseName::User(ref rc) => rc.table.clone(),
+ _ => self.indices.atom_tbl()
+ }
+ }
+
+ fn compile_into_machine<R: Read>(&mut self, src: R, name: ClauseName) -> EvalSession
+ {
+ match name.owning_module().as_str() {
+ "user" => compile_user_module(self, src),
+ _ => compile_into_module(self, src, name)
+ }
+ }
+
+ fn get_predicate_key(&self, name: RegType, arity: RegType) -> PredicateKey
+ {
let name = self.machine_st[name].clone();
let arity = self.machine_st[arity].clone();
(name, arity)
}
- fn print_new_dynamic_clause(&self, addrs: VecDeque<Addr>, name: RegType, arity: RegType)
+ fn print_new_dynamic_clause(&self, addrs: VecDeque<Addr>, name: ClauseName, arity: usize)
-> String
{
let mut output = PrinterOutputter::new();
- let (name, arity) = self.get_predicate_key(name, arity);
-
output.append(format!(":- dynamic({}/{}). ", name.as_str(), arity).as_str());
for addr in addrs {
self.indices.dynamic_code_dir.remove(&(name, arity));
}
- fn handle_eval_result_from_dynamic_compile(&mut self, pred_str: String, src: ClauseName)
+ fn handle_eval_result_from_dynamic_compile(&mut self, pred_str: String, name: ClauseName,
+ src: ClauseName)
{
let machine_st = mem::replace(&mut self.machine_st, MachineState::new());
- let result = compile_user_module(self, pred_str.as_bytes());
+ let result = self.compile_into_machine(pred_str.as_bytes(), name);
self.machine_st = machine_st;
if let EvalSession::Error(err) = result {
let h = self.machine_st.heap.h;
let stub = MachineError::functor_stub(src, 1);
let err = MachineError::session_error(h, err);
- let err = self.machine_st.error_form(err, stub);
+ let err = self.machine_st.error_form(err, stub);
self.machine_st.throw_exception(err);
}
fn recompile_dynamic_predicate(&mut self, place: DynamicAssertPlace)
{
+ let (name, arity) = self.get_predicate_key(temp_v!(3), temp_v!(4));
+
let stub = MachineError::functor_stub(place.predicate_name(), 1);
let pred_str = match self.machine_st.try_from_list(temp_v!(2), stub) {
Ok(addrs) => {
let added_clause = self.machine_st[temp_v!(1)].clone();
place.push_to_queue(&mut addrs, added_clause);
- self.print_new_dynamic_clause(addrs, temp_v!(3), temp_v!(4))
+ self.print_new_dynamic_clause(addrs, name.clone(), arity)
},
Err(err) =>
return self.machine_st.throw_exception(err)
};
- self.handle_eval_result_from_dynamic_compile(pred_str, place.predicate_name());
+ self.handle_eval_result_from_dynamic_compile(pred_str, name, place.predicate_name());
}
- fn retract_from_dynamic_predicate(&mut self) {
+ fn retract_from_dynamic_predicate(&mut self)
+ {
let index = self.machine_st[temp_v!(3)].clone();
let index = match self.machine_st.store(self.machine_st.deref(index)) {
Addr::Con(Constant::Number(Number::Integer(n))) => n.to_usize().unwrap(),
};
let stub = MachineError::functor_stub(clause_name!("retract"), 1);
+ let (name, arity) = self.get_predicate_key(temp_v!(1), temp_v!(2));
+
let pred_str = match self.machine_st.try_from_list(temp_v!(4), stub) {
Ok(addrs) => {
let mut addrs = VecDeque::from(addrs);
return;
}
- self.print_new_dynamic_clause(addrs, temp_v!(1), temp_v!(2))
+ self.print_new_dynamic_clause(addrs, name.clone(), arity)
},
Err(err) =>
return self.machine_st.throw_exception(err)
};
- self.handle_eval_result_from_dynamic_compile(pred_str, clause_name!("retract"));
+ self.handle_eval_result_from_dynamic_compile(pred_str, name, clause_name!("retract"));
}
pub(super)
pub enum SessionError {
CannotOverwriteBuiltIn(ClauseName),
+ CannotOverwriteDynamicClause(ClauseName),
CannotOverwriteImport(ClauseName),
ModuleDoesNotContainExport,
ModuleNotFound,
}
impl IndexStore {
- pub fn predicate_exists(&self, name: ClauseName, arity: usize,
+ pub fn predicate_exists(&self, name: ClauseName, module: ClauseName, arity: usize,
op_spec: Option<(usize, Specifier)>)
-> bool
{
- match ClauseType::from(name, arity, op_spec) {
- ClauseType::Named(name, arity, _) =>
- self.code_dir.contains_key(&(name, arity)),
- ClauseType::Op(op_decl, ..) =>
- self.code_dir.contains_key(&(op_decl.name(), op_decl.arity())),
- _ => true
+ match self.modules.get(&module) {
+ Some(module) =>
+ match ClauseType::from(name, arity, op_spec) {
+ ClauseType::Named(name, arity, _) =>
+ module.code_dir.contains_key(&(name, arity)),
+ ClauseType::Op(op_decl, ..) =>
+ module.code_dir.contains_key(&(op_decl.name(), op_decl.arity())),
+ _ => true
+ },
+ None =>
+ match ClauseType::from(name, arity, op_spec) {
+ ClauseType::Named(name, arity, _) =>
+ self.code_dir.contains_key(&(name, arity)),
+ ClauseType::Op(op_decl, ..) =>
+ self.code_dir.contains_key(&(op_decl.name(), op_decl.arity())),
+ _ => true
+ }
}
}
// ensure we don't try to overwrite an existing predicate from a different module.
if !existing_idx.is_undefined() && !idx.is_undefined() {
// allow the overwriting of user-level predicates by all other predicates.
- if existing_idx.module_name() == key.0.owning_module() {
+ if existing_idx.module_name().as_str() == "user" {
continue;
}
},
&SystemClauseType::GetCurrentPredicateList => {
let mut addrs = vec![];
-
+
for ((name, arity), idx) in indices.code_dir.iter() {
if idx.is_undefined() {
continue;
}
-
+
let h = self.heap.h;
self.heap.push(HeapCellValue::NamedStr(2, clause_name!("/"), Some((400, YFX))));
self.heap.push(HeapCellValue::Addr(Addr::Con(Constant::Atom(name.clone(), None))));
self.heap.push(heap_integer!(*arity));
-
+
addrs.push(Addr::Str(h));
}
self.fail = match self.store(self.deref(head)) {
Addr::Str(s) =>
match self.heap[s].clone() {
- HeapCellValue::NamedStr(arity, name, op_spec) =>
- indices.predicate_exists(name, arity, op_spec),
+ HeapCellValue::NamedStr(arity, name, op_spec) => {
+ let module = name.owning_module();
+ indices.predicate_exists(name, module, arity, op_spec)
+ },
_ => unreachable!()
},
- Addr::Con(Constant::Atom(name, op_spec)) =>
- indices.predicate_exists(name, 0, op_spec),
+ Addr::Con(Constant::Atom(name, op_spec)) => {
+ let module = name.owning_module();
+ indices.predicate_exists(name, module, 0, op_spec)
+ },
head => {
let err = MachineError::type_error(ValidType::Callable, head);
let stub = MachineError::functor_stub(clause_name!("clause"), 2);
impl fmt::Display for SessionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
+ &SessionError::CannotOverwriteDynamicClause(ref msg) =>
+ write!(f, "cannot overwrite dynamic predicate {}", msg),
&SessionError::CannotOverwriteBuiltIn(ref msg) =>
write!(f, "cannot overwrite {}", msg),
&SessionError::CannotOverwriteImport(ref msg) =>
write!(f, "cannot overwrite import {}", msg),
&SessionError::ModuleNotFound => write!(f, "module not found."),
- &SessionError::ModuleDoesNotContainExport => write!(f, "module does not contain claimed export."),
- &SessionError::QueryFailure => write!(f, "false."),
- &SessionError::QueryFailureWithException(ref e) => write!(f, "{}", error_string(e)),
+ &SessionError::ModuleDoesNotContainExport =>
+ write!(f, "module does not contain claimed export."),
+ &SessionError::QueryFailure =>
+ write!(f, "false."),
+ &SessionError::QueryFailureWithException(ref e) =>
+ write!(f, "{}", error_string(e)),
&SessionError::OpIsInfixAndPostFix =>
write!(f, "cannot define an op to be both postfix and infix."),
- &SessionError::NamelessEntry => write!(f, "the predicate head is not an atom or clause."),
- &SessionError::ParserError(ref e) => write!(f, "syntax_error({})", e.as_str()),
- &SessionError::UserPrompt => write!(f, "enter predicate at [user] prompt")
+ &SessionError::NamelessEntry =>
+ write!(f, "the predicate head is not an atom or clause."),
+ &SessionError::ParserError(ref e) =>
+ write!(f, "syntax_error({})", e.as_str()),
+ &SessionError::UserPrompt =>
+ write!(f, "enter predicate at [user] prompt")
}
}
}
projects / scryer-prolog.git / commitdiff