vm.cpp

Go to the documentation of this file.

//
// Date:      15 November   2005   
//
// Copyright (c) Sergey Satskiy 2003 - 2005
//               <sergesatsky@yahoo.com>
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//


#include <math.h>


#include <iostream>
#include <string>
#include <vector>
#include <stdexcept>
using namespace std;

#include <boost/algorithm/string/trim.hpp>
using namespace boost;
using namespace boost::algorithm;




class SVMException : public std::exception
{
    private:
        const std::string      Message;

    public:
        SVMException( const std::string &  Msg ) : Message( Msg ) 
        {}

        SVMException( const char *         Msg ) : Message( Msg ) 
        {}

        virtual const char * what( void ) const throw() 
        { return Message.c_str(); }

        virtual ~SVMException() throw () {}

    private:
        SVMException();
};




class SCalculator
{
    public:
        SCalculator( const vector< string > &  code ) :
            Code( code )
        {
                // The stack size cannot be larger than the code size
            Stack.reserve( Code.size() );
        }
        
        double Calculate( const double &  Value ) 
        {
                // Clear the stack for reuse
            Stack.clear();
            
                // Walk the whole code
            for ( vector< string >::const_iterator  k( Code.begin() );
                  k != Code.end(); ++k )
            {
                if ( *k == "ADD" )
                {
                    double      Temp( Stack.back() );
                    Stack.pop_back();
                    Stack[ Stack.size() - 1 ] = Stack.back() + Temp;
                    continue;
                }
                if ( *k == "SUB" )
                {
                    double      Temp( Stack.back() );
                    Stack.pop_back();
                    Stack[ Stack.size() - 1 ] = Stack.back() - Temp;
                    continue;
                }
                if ( *k == "DIV" )
                {
                    double      Temp( Stack.back() );
                    Stack.pop_back();
                    Stack[ Stack.size() - 1 ] = Stack.back() / Temp;
                    continue;
                }
                if ( *k == "MULT" )
                {
                    double      Temp( Stack.back() );
                    Stack.pop_back();
                    Stack[ Stack.size() - 1 ] = Stack.back() * Temp;
                    continue;
                }
                if ( *k == "NEGATE" )
                {
                    Stack[ Stack.size() - 1 ] = - Stack.back();
                    continue;
                }
                if ( *k == "VALUE" )
                {
                    Stack.push_back( Value );
                    continue;
                }
                if ( *k == "SIN" )
                {
                    Stack[ Stack.size() - 1 ] = sin( Stack.back() );
                    continue;
                }
                if ( *k == "COS" )
                {
                    Stack[ Stack.size() - 1 ] = cos( Stack.back() );
                    continue;
                }
                if ( (*k).compare( 0, 4, "PUSH" ) == 0 ) 
                { 
                    Stack.push_back( atof( (*k).c_str() + sizeof( "PUSH" ) ) );
                    continue;
                }

                throw SVMException( "Unexpected virtual machine command '" + 
                                    *k + "'" );
            }

            if ( Stack.size() != 1 )
            {
                throw SVMException( "Unexpected size of stack at the end "
                                    "of calculation. " );
            }
            
            return Stack.back();
        }

    private:
        vector< string >    Code;       // Code storage
        vector< double >    Stack;      // Working space - stack of doubles
};





    // The VM takes a single argument: a value of the argument
int  main( int  argc, char **  argv )
{

        // Check the command line arguments first
    if ( argc >= 3 )
    {
            // Unexpected arguments
        cerr << "Unexpected arguments. Type " << argv[ 0 ]
             << " --help for usage." << endl;
        return 1;
    }


    
    if ( ( argc == 2 && string( argv[ 1 ] ) == "-h" )     ||
         ( argc == 2 && string( argv[ 1 ] ) == "--help" )    )
    {
        cout << "Usage: " << argv[ 0 ] << " <double value | -h | --help>" << endl;
        return 0;
    }



    double              Value( 0.0 );   // Default is 0.0
    if ( argc == 2 )
    {
        Value = atof( argv[ 1 ] );      // Input value
    }

    
        // Code storage
    vector< string >    Code;
    
    
        // Input the VM code into the vector
    for ( ; ; ) 
    {
        char        Buffer[ 256 ];      // Single line buffer

        cin.getline( Buffer, sizeof( Buffer ) );

        if ( cin.eof() )    break;
        if ( cin.fail() )
        {
            cerr << "Wrong input stream" << endl;
            return 2;
        }

        string      Line( Buffer );     // Temporary object - to make trim

        trim( Line );
        Code.push_back( Line );
    }
    

    try
    {
            // Instance of a calculator
            // Could be used many times in the real world application
        SCalculator     Calculator( Code );
        
            // Perform the calculation and print the result
        cout << Calculator.Calculate( Value ) << endl;
    }
    catch ( exception &  Exception )
    {
        cerr << Exception.what() << endl;
        return 3;
    }
    catch ( ... )
    {
        cerr << "Unknown exception." << endl;
        return 3;
    }

    return 0;
}

---