Deriving input stream ?

[fabricemarchant]

Hi !

I've translated Andru Luvisi small LISP interpreter sl3.c
http://www.sonoma.edu/users/l/luvisi/sl3.c

in C++ in order to understand how it works and to experiment with small
LISP.
http://fabrice.marchant.free.fr/LISP/slf/060521/

(For now, my C++ code isn't the result of an object analysis, just a
translation from C, eliminating "switches" or "if ladders" for
example.)

As a LISP, the main loop is a "read, eval, print".

Please, could you give me hints about the way to define a ">>" operator
to replace the "readObj" function of LISP objects ?

// Main loop, in slf.c++
while( notExitFlag )
cout << *readObj( )->eval( top_env ) << '\n';

Thanks for advance.

Fabrice

[Ivan Vecerina]

<fa************ *@free.fr> wrote in message
news:11******** **************@ u72g2000cwu.goo glegroups.com.. .
: Please, could you give me hints about the way to define a ">>" operator
: to replace the "readObj" function of LISP objects ?
:
: // Main loop, in slf.c++
: while( notExitFlag )
: cout << *readObj( )->eval( top_env ) << '\n';

Since you're asking only about how to implement >>, I guess that you
have "implemente d" << using a conversion to string ?

The proper way to define streaming operators is:
ostream& operator << ( ostream& s, MyClass const& obj ) { ... }
istream& operator >> ( istream& s, MyClass& obj ) { ... }
They are non-member functions. [ NB: both have to "return s;" ]

But you can declare them within the class, as friends, if
these functions need access to private members:
friend ostream& operator << ( ostream& s, MyClass const& obj );
friend istream& operator >> ( istream& s, MyClass& obj );
Amicalement --Ivan
--
http://ivan.vecerina.com/contact/?subject=NG_POST <- email contact form

[fabricemarchant]

Thanks for your explanations, Ivan.

---------- About output -----------

Since you're asking only about how to implement >>, I guess that you
have "implemente d" << using a conversion to string ?
No, I did this way :

class obj {

public:
....
virtual ostream&
print( ostream& os ) const { return os; }
....
};

ostream& operator<<( ostream& os, const obj& ob ) {

return ob.print( os );
}

These are printable classes that derives from base "obj" :

class nilObj: public obj {
public:
....
ostream&
print( ostream& os ) const { return os << "()"; }
....
};

class symbol: public obj {
public:
....
print( ostream& os ) const { return os << name(); }

string
name( void ) const { return _M_name; }

private:
string _M_name;
};

And so on, for other derived objects.

You speak about string conversion, please how could I use this here ?

---------- About input -----------
The proper way to define streaming operators is:
ostream& operator << ( ostream& s, MyClass const& obj ) { ... }
istream& operator >> ( istream& s, MyClass& obj ) { ... }
They are non-member functions. [ NB: both have to "return s;" ] But you can declare them within the class, as friends, if
these functions need access to private members:
friend ostream& operator << ( ostream& s, MyClass const& obj );
friend istream& operator >> ( istream& s, MyClass& obj );

I know these but do not see how to implement things in the aim to be
used like this :

obj i;
cin >> i; // <- How to prepare the job for this ?
cout << *i.eval( top_env ) << '\n';

I wanted to be able to write the read of different kind of objects (
nil, symbol, cons, proc ) this simple way.

Regards

Fabrice

[Jim Langston]

<fa************ *@free.fr> wrote in message
news:11******** **************@ u72g2000cwu.goo glegroups.com.. .

The proper way to define streaming operators is:
ostream& operator << ( ostream& s, MyClass const& obj ) { ... }
istream& operator >> ( istream& s, MyClass& obj ) { ... }
They are non-member functions. [ NB: both have to "return s;" ]

But you can declare them within the class, as friends, if
these functions need access to private members:
friend ostream& operator << ( ostream& s, MyClass const& obj );
friend istream& operator >> ( istream& s, MyClass& obj );

I know these but do not see how to implement things in the aim to be
used like this :

obj i;
cin >> i; // <- How to prepare the job for this ?
cout << *i.eval( top_env ) << '\n';

I wanted to be able to write the read of different kind of objects (
nil, symbol, cons, proc ) this simple way.

You just input them. I do this quite a bit in my program, I'll try to show
a rather simple example.

This one is not simple but I'll cut out a lot of stuff just so you get the
idea. So it may not compile as is.

class CHealth
{
public:
// Snipped - Not needed for example
private:
// Lot of other stuff snipped here
int OverallMax_; int Overall_;
int HeadMax_;
int Head_;
int TorsoMax_;
int Torso_;
int LeftArmMax_;
int LeftArm_;
int RightArmMax_;
int RightArm_;
int LeftLegMax_;
int LeftLeg_;
int RightLegMax_;
int RightLeg_;
int LeftWingMax_;
int LeftWing_;
int RightWingMax_;
int RightWing_;
};

std::istream& operator>>( std::istream& is, CHealth& Health)
{
is >> Health.OverallM ax_ >> Health.Overall_ >> Health.HeadMax_ >>
Health.Head_ >> Health.TorsoMax _ >> Health.Torso_ >>
Health.LeftArmM ax_ >> Health.LeftArm_ >> Health.RightArm Max_ >>
Health.RightArm _ >>
Health.LeftLegM ax_ >> Health.LeftLeg_ >> Health.RightLeg Max_ >>
Health.RightLeg _ >>
Health.LeftWing Max_ >> Health.LeftWing _ >> Health.RightWin gMax_ >>
Health.RightWin g_;

// Snipped checking of some values and setting values in class that were
also snipped,
// such as Dead_, LeftArmDisabled _, etc...

return is;
}

std::ostream& operator<<( std::ostream& os, CHealth& Health)
{
os << Health.OverallM ax_ << " " << Health.Overall_ << " " <<
Health.HeadMax_ << " " << Health.Head_ << " " <<
Health.TorsoMax _ << " " << Health.Torso_ << " " <<
Health.LeftArmM ax_ << " " << Health.LeftArm_ << " " <<
Health.RightArm Max_ << " " << Health.RightArm _ << " " <<
Health.LeftLegM ax_ << " " << Health.LeftLeg_ << " " <<
Health.RightLeg Max_ << " " << Health.RightLeg _ << " " <<
Health.LeftWing Max_ << " " << Health.LeftWing _ << " " <<
Health.RightWin gMax_ << " " << Health.RightWin g_;
return os;

}

[fabricemarchant]

Hi Jim !

Thanks for your answer.

Apologizes for the delay.
I understand what you do for the input of your numerous fields
structure but I can't imagine how to apply this in my case where the
input objects - all derived from the "obj" base type - can be "cons" (
lists ) or symbols or nil...

http://fabrice.marchant.free.fr/LISP...0521/input.c++

Regards fabrice