Z3 sources

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

lib/smt_literal.h

@@ -0,0 +1,122 @@
+/*++
+Copyright (c) 2006 Microsoft Corporation
+
+Module Name:
+
+    smt_literal.h
+
+Abstract:
+
+    <abstract>
+
+Author:
+
+    Leonardo de Moura (leonardo) 2008-02-18.
+
+Revision History:
+
+--*/
+#ifndef _SMT_LITERAL_H_
+#define _SMT_LITERAL_H_
+
+#include"ast.h"
+#include"smt_types.h"
+#include"approx_set.h"
+
+namespace smt {
+    /**
+       \brief The literal b is represented by the value 2*b, and
+       the literal (not b) by the value 2*b + 1
+       
+    */
+    class literal {
+        int  m_val;
+        
+    public:
+        literal():m_val(-2) {
+            SASSERT(var() == null_bool_var && !sign());
+        }
+        
+        explicit literal(bool_var v, bool sign = false):
+            m_val((v << 1) + static_cast<int>(sign)) {
+        }
+        
+        bool_var var() const { 
+            return m_val >> 1; 
+        }
+        
+        bool sign() const {
+            return m_val & 1; 
+        }
+        
+        int index() const {
+            return m_val;
+        }
+        
+        void neg() {
+            m_val = m_val ^ 1;
+        }
+        
+        friend literal operator~(literal l);
+        
+        friend literal to_literal(int x);
+
+        void display(std::ostream & out, ast_manager & m, expr * const * bool_var2expr_map) const;
+
+        void display_compact(std::ostream & out, expr * const * bool_var2expr_map) const;
+
+        unsigned hash() const { return m_val; }
+    };
+
+    inline bool operator==(literal l1, literal l2) {
+        return l1.index() == l2.index();
+    }
+    
+    inline bool operator!=(literal l1, literal l2) {
+        return l1.index() != l2.index();
+    }
+    
+    inline bool operator<(literal l1, literal l2) {
+        return l1.index() < l2.index();
+    }
+    
+    inline literal operator~(literal l) {
+        literal r;
+        r.m_val = l.m_val ^ 1;
+        return r;
+    }
+    
+    inline literal to_literal(int x) {
+        literal l;
+        l.m_val = x;
+        return l;
+    }
+    
+    const literal null_literal;
+    const literal true_literal(true_bool_var, false); 
+    const literal false_literal(true_bool_var, true);
+
+    typedef svector<literal> literal_vector;
+    typedef sbuffer<literal> literal_buffer;
+    std::ostream & operator<<(std::ostream & out, literal l);
+    std::ostream & operator<<(std::ostream & out, const literal_vector & v);
+
+    void display_compact(std::ostream & out, unsigned num_lits, literal const * lits, expr * const * bool_var2expr_map);
+
+    void display_verbose(std::ostream & out, ast_manager& m, unsigned num_lits, literal const * lits, expr * const * bool_var2expr_map);
+
+    template<typename T>
+    void neg_literals(unsigned num_lits, literal const * lits, T & result) {
+        for (unsigned i = 0; i < num_lits; ++i) 
+            result.push_back(~lits[i]);
+    }
+
+    struct literal2unsigned { unsigned operator()(literal l) const { return l.index(); } };
+
+    typedef approx_set_tpl<literal, literal2unsigned> literal_approx_set;
+
+    bool backward_subsumption(unsigned num_lits1, literal const * lits1, unsigned num_lits2, literal const * lits2);
+};
+
+#endif /* _SMT_LITERAL_H_ */
+