ajust/add devlaration errors to be more standard compliant

src/machine/machine_errors.rs

@@ -268,6 +268,26 @@ impl DomainError for HeapCellValue {
     }
 }
 
+impl DomainError for FunctorStub {
+    fn domain_error(
+        self,
+        machine_st: &mut MachineState,
+        valid_type: DomainErrorType,
+    ) -> MachineError {
+        let stub = functor!(
+            atom!("domain_error"),
+            [atom(valid_type.as_atom()), str(machine_st.heap.len(), 0)],
+            [self]
+        );
+
+        MachineError {
+            stub,
+            location: None,
+            from: ErrorProvenance::Constructed,
+        }
+    }
+}
+
 impl DomainError for Number {
     fn domain_error(self, machine_st: &mut MachineState, error: DomainErrorType) -> MachineError {
         let stub = functor!(
@@ -731,6 +751,8 @@ pub enum DeclarationError {
     InvalidOpDeclSpecValue(Atom),
     InvalidOpDeclPrecType(Term),
     InvalidOpDeclPrecDomain(Fixnum),
+    ShallNotCreate(Atom),
+    ShallNotModify(Atom),
 }
 
 impl From<ArithmeticError> for CompilationError {
@@ -844,6 +866,7 @@ pub(crate) enum DomainErrorType {
     StreamOrAlias,
     OperatorSpecifier,
     OperatorPriority,
+    Declaration,
 }
 
 impl DomainErrorType {
@@ -857,6 +880,7 @@ impl DomainErrorType {
             DomainErrorType::StreamOrAlias => atom!("stream_or_alias"),
             DomainErrorType::OperatorSpecifier => atom!("operator_specifier"),
             DomainErrorType::OperatorPriority => atom!("operator_priority"),
+            DomainErrorType::Declaration => atom!("declaration"),
         }
     }
 }

src/machine/machine_state.rs

@@ -986,7 +986,7 @@ impl MachineState {
                 atom_as_cell!(atom!("todo_insert_invalid_term_here")),
             ),
             DeclarationError::InvalidDecl(name, arity) => {
-                self.existence_error(ExistenceError::Declaration(name, arity))
+                self.domain_error(DomainErrorType::Declaration, functor_stub(name, arity))
             }
             DeclarationError::InvalidOpDeclNameType(_term) => self.type_error(
                 ValidType::List,
@@ -1006,6 +1006,12 @@ impl MachineState {
             DeclarationError::InvalidOpDeclPrecDomain(num) => {
                 self.domain_error(DomainErrorType::OperatorPriority, fixnum_as_cell!(num))
             }
+            DeclarationError::ShallNotCreate(atom) => {
+                self.permission_error(Permission::Create, atom!("operator"), atom)
+            }
+            DeclarationError::ShallNotModify(atom) => {
+                self.permission_error(Permission::Modify, atom!("operator"), atom)
+            }
         }
     }
 }

src/machine/preprocessor.rs

@@ -60,6 +60,24 @@ fn setup_op_decl(mut terms: Vec<Term>, atom_tbl: &AtomTable) -> Result<OpDecl, C
         }
     };
 
+    if name == "[]" || name == "{}" {
+        return Err(CompilationError::InvalidDecl(
+            DeclarationError::ShallNotCreate(name),
+        ));
+    }
+
+    if name == "," {
+        return Err(CompilationError::InvalidDecl(
+            DeclarationError::ShallNotModify(name),
+        ));
+    }
+
+    if name == "|" && (prec < 1001 || !spec.is_infix()) {
+        return Err(CompilationError::InvalidDecl(
+            DeclarationError::ShallNotCreate(name),
+        ));
+    }
+
     Ok(to_op_decl(prec, spec, name))
 }