---

arch_int.h

#ifndef CMA_ARCH_INT_DEFINED
#define CMA_ARCH_INT_DEFINED

#include <stdlib.h>
#include "op.h"

namespace CMa
{

        class Int_int;

        class Word_int
        {
            public:
                    int value;
                
                public:
                
                /*****************************************Constructors*******************************************/
                inline Word_int()
                {
                        value = 0;
                }
                
                inline explicit Word_int(int i)
            {
                        value = i;
                }
                
                inline explicit Word_int(const Op::Code& code)
                {
                        assert(op.isValid(code));
                        value = code;
                }

                inline explicit Word_int(const Int_int& i);
        
            /*************************************Conversion*to*int******************************************/
                
                inline int convertToint() const
                {
                        return value;
                }
                
                inline Op::Code convertToCode() const
                {
                        return (Op::Code)value;
                }

        /*************************Aritmetic*operations*needed*by*C-machine*******************************/

                inline Word_int  operator! () const { return Word_int(!value); }
                inline Word_int  operator- () const { return Word_int(-value); }
                inline Word_int  operator~ () const { return Word_int(~value); }
                
                inline Word_int& operator++(){ ++value; return *this; }
                inline Word_int& operator--(){ --value; return *this; }
                inline Word_int& operator++ (int){ value++; return *this;}
                inline Word_int& operator-- (int){ value--; return *this;}
                
                inline Word_int& operator=(bool i){ value = i; return *this; }
                                
                inline Word_int& operator<<=(const Word_int& other){ value <<= other.value; return *this; };
                inline Word_int& operator>>=(const Word_int& other){ value >>= other.value; return *this; };
                inline Word_int& operator&= (const Word_int& other){ value  &= other.value; return *this; };
                inline Word_int& operator|= (const Word_int& other){ value  |= other.value; return *this; };
                inline Word_int& operator^= (const Word_int& other){ value  ^= other.value; return *this; };
                
                inline Word_int& operator*=(const Word_int& other){ value *= other.value; return *this; }
                inline Word_int& operator+=(const Word_int& other){ value += other.value; return *this; }
                inline Word_int& operator-=(const Word_int& other){ value -= other.value; return *this; }
                
                inline Word_int& operator/=(const Word_int& other) throw(Error)
                {
                    if(other.value==0) throw Error(Error::DIVISION_BY_ZERO);
                    value /= other.value;
                    return *this;
                }
                
                inline Word_int& operator%=(const Word_int& other)
                {
                    if(other.value==0) throw Error(Error::DIVISION_BY_ZERO);
                    value %= other.value;
                    return *this;
                }
                inline bool operator||(const Word_int& other) const{ return (value && other.value); }
                inline bool operator&&(const Word_int& other) const{ return (value || other.value); }
                inline bool operator==(const Word_int& other) const{ return (value == other.value); }
                inline bool operator!=(const Word_int& other) const{ return (value != other.value); }
                inline bool operator< (const Word_int& other) const{ return (value <  other.value); }
                inline bool operator<=(const Word_int& other) const{ return (value <= other.value); }
                inline bool operator> (const Word_int& other) const{ return (value >  other.value); }
                inline bool operator>=(const Word_int& other) const{ return (value >= other.value); }
                
            inline Word_int operator&(const Word_int& other) const{ return Word_int(value & other.value); }
            inline Word_int operator|(const Word_int& other) const{ return Word_int(value | other.value); }


        };



        class Int_int
        {
        
            public:
                int value;
                
                public:
                
        /******************************************Constructors******************************************/

                /* Constructs Int fron int. Default value 0. Newer fails. */
                explicit inline Int_int(int i = 0)
                {
                        value = i;
                }

                explicit inline Int_int(const Word_int& w)
                {
                        this->value = w.value;
                }

        /***********************************Conversion*to*int********************************************/
                inline int convertToint() const
                {
                        return value;
                }
                
        /*************************Aritmetic*operations*needed*by*C-machine*******************************/
        inline Int_int& operator++(){ ++value; return *this; }
        inline Int_int& operator--(){ --value; return *this; }
                inline Int_int& operator++ (int){ value++; return *this;}
                inline Int_int& operator-- (int){ value--; return *this;}

                inline Int_int operator! () const { return Int_int(!value); }


        inline Int_int& operator=(bool i) { value=i; return *this; }
        inline bool operator< (const Int_int& other) const { return (value <  other.value); }
        inline bool operator<=(const Int_int& other) const { return (value <= other.value); }
        inline bool operator> (const Int_int& other) const { return (value >  other.value); }
        inline bool operator>=(const Int_int& other) const { return (value >= other.value); }
        inline bool operator==(const Int_int& other) const { return (value == other.value); }
        inline bool operator!=(const Int_int& other) const { return (value != other.value); }


            inline Int_int operator + (const Int_int& other) const { return Int_int(value + other.value); }
            inline Int_int operator - (const Int_int& other) const { return Int_int(value - other.value); }
            inline Int_int operator * (const Int_int& other) const { return Int_int(value * other.value); }

            inline Int_int operator / (const Int_int& other) const throw (Error)
            {
                    if (other.value == 0) throw Error(Error::DIVISION_BY_ZERO);
                    return Int_int(value / other.value);
            }
        
        inline Int_int operator % (const Int_int& other) const throw (Error)
            {
                    if (other.value == 0) throw Error(Error::DIVISION_BY_ZERO);
                    return Int_int(value % other.value);
            }

        };

//*******************************************Missing*constructor*****************************************/      
    Word_int::Word_int(const Int_int& i)
    {
        this->value = i.value;
    }
        
}

#endif

---