struct base_variable
{
    virtual ~base_variable() = 0 {};
};

template<typename T>
struct basic_variable : base_variable
{
    basic_variable()
        : val_()
    {
    }

    explicit basic_variable(T v)
        : val_(v)
    {
    }

    T val() const
    {
        return val_;
    }
private:
    T val_;
};

struct base_caller
{
    typedef boost::shared_ptr<base_variable> bv;
    typedef std::stack<bv> vs;

    virtual void call(vs & s) = 0;
};

template<typename T>
struct basic_caller;

template<typename R>
struct basic_caller<R()> : base_caller
{
    basic_caller(R (*f_)())
        : f(f_)
    {
    }

    void call(vs & s)
    {
        if (s.size() != 0)
        {
            throw std::invalid_argument("");
        }
        s.push(boost::shared_ptr<base_variable>(new basic_variable<R>(f())));
    }
private:
    R (*f)();
};

template<typename R, typename P1>
struct basic_caller<R (P1)> : base_caller
{
    basic_caller(R (*f_)(P1))
        : f(f_)
    {
    }

    void call(vs & s)
    {
        if (s.size() != 1)
        {
            throw std::invalid_argument("");
        }
        boost::shared_ptr<basic_variable<P1> > p1(boost::shared_dynamic_cast<basic_variable<P1> >(s.top()));
        s.pop();

        s.push(boost::shared_ptr<base_variable>(new basic_variable<R>(f(p1->val()))));
    }
private:
    R (*f)(P1);
};

template<typename R, typename P1, typename P2>
struct basic_caller<R (P1, P2)> : base_caller
{
    basic_caller(R (*f_)(P1, P2))
        : f(f_)
    {
    }

    void call(vs & s)
    {
        if (s.size() != 2)
        {
            throw std::invalid_argument("");
        }
        boost::shared_ptr<basic_variable<P1> > p1(boost::shared_dynamic_cast<basic_variable<P1> >(s.top()));
        s.pop();
        boost::shared_ptr<basic_variable<P2> > p2(boost::shared_dynamic_cast<basic_variable<P2> >(s.top()));
        s.pop();

        s.push(boost::shared_ptr<base_variable>(new basic_variable<R>(f(p1->val(), p2->val()))));
    }
private:
    R (*f)(P1, P2);
};

long foo0(){ return 1; }
double foo1(char){ return 1.1; }
int foo2(int, char) { return 42; }

int main(int argc, char* argv[])
{
    std::map<std::string, base_caller*> all_functions;
    all_functions["foo2"] = new basic_caller<int (int, char)>(&foo2);
    
    base_caller::vs stack;
    stack.push(boost::shared_ptr<basic_variable<char> >(new basic_variable<char>()));
    stack.push(boost::shared_ptr<basic_variable<int> >(new basic_variable<int>()));
    

    all_functions["foo2"]->call(stack);

bool is_bigendian()
{
    const int t = 1;
    return (*(char*)&t) == 0;
}

 long l = 10;
_asm {
  push l;  
}
 byte check;
   _asm {
     pop check;
   }
   if( check = 10 )
   {
     //left endian
   } 
   else
   {
     //right endian
   }

bool IsLittleEndian ()
{
    int littleEndian = true;
    return *((char*)&littleEndian);
}

C>bool is_bigendian()
C>{
C>    const int t = 1;
C>    return (*(char*)&t) == 0;
C>}
C>

union {
        long val;
        unsigned char bytes[sizeof(long)];
    } test;
    test.val = 1;
    if (test.bytes[0] == 1) {
        printf("little endian\n");
    } else
        printf("big endian\n");

int
main ()
{

  /* Are we little or big endian?  From Harbison&Steele.  */
  union
  {
    long int l;
    char c[sizeof (long int)];
  } u;
  u.l = 1;
  return u.c[sizeof (long int) - 1] == 1;

  ;
  return 0;
}

template<>
struct basic_caller<base_caller::bv(base_caller::vs&)> : base_caller
{
    basic_caller(base_caller::bv (*f_)(base_caller::vs&))
        : f(f_)
    {
    }

    void call(vs & s)
    {
        s.push(f(s));
    }
private:
    bv (*f)(base_caller::vs&);
};

base_caller::bv writeln(base_caller::vs & s)
{
    ...
}