function.cpp

// function.cpp
// Revision 10-jul-2004

#include "function.h"
#include "error.h"

#include <vector>
#include <map>

class ParameterList::Internal {
public:
	static Internal * getnew ();
	void addref ();
	void delref ();
	void push_back (const std::string & name);
	size_t size () const;
	//const std::string & get (size_t n) const;
	std::string get (size_t n) const;
private:
	Internal ();
	Internal (const Internal &); // Forbidden
	~Internal () { }
	void operator= (const Internal &); // Forbidden
	size_t counter;
	std::vector <std::string> element;
};

ParameterList::Internal::Internal () :
	counter (1)
{
}

void ParameterList::Internal::addref ()
{
	++counter;
}

void ParameterList::Internal::delref ()
{
	if (--counter == 0)
		delete this;
}

ParameterList::Internal * ParameterList::Internal::getnew ()
{
	return new Internal;
}

void ParameterList::Internal::push_back (const std::string & name)
{
	element.push_back (name);
}

size_t ParameterList::Internal::size () const
{
	return element.size ();
}

//const std::string & ParameterList::Internal::get (size_t n) const
std::string ParameterList::Internal::get (size_t n) const
{
	if (n >= element.size () )
		throw ErrBlassicInternal;
	return element [n];
}

ParameterList::ParameterList () :
	pin (Internal::getnew () )
{
}

ParameterList::ParameterList (const ParameterList & pl) :
	pin (pl.pin)
{
	pin->addref ();
}

ParameterList::~ParameterList ()
{
	pin->delref ();
}

ParameterList & ParameterList::operator= (const ParameterList & pl)
{
	pl.pin->addref ();
	pin->delref ();
	pin= pl.pin;
	return * this;
}

void ParameterList::push_back (const std::string & name)
{
	pin->push_back (name);
}

size_t ParameterList::size () const
{
	return pin->size ();
}

//const std::string & ParameterList::operator [] (size_t n) const
std::string ParameterList::operator [] (size_t n) const
{
	return pin->get (n);
}

class Function::Internal {
public:
	void addref ();
	void delref ();
	static Internal * getnew
		(const std::string & strdef, const ParameterList & param)
	{
		return new Internal (strdef, param);
	}
	static Internal * getnew
		(ProgramPos posfn, const ParameterList & param)
	{
		return new Internal (posfn, param);
	}
	DefType getdeftype () const { return deftype; }
	CodeLine & getcode () { return code; }
	ProgramPos getpos () const { return pos; }
	const ParameterList & getparam () { return param; }
protected:
	// Protected to avoid a warning on certain versions of gcc.
	Internal (const std::string & strdef, const ParameterList & param);
	~Internal () { }
private:
	Internal (ProgramPos posfn, const ParameterList & param);
	Internal (const Internal &); // Forbidden
	void operator = (const Internal &); // Forbidden
	size_t counter;
	DefType deftype;
	CodeLine code;
	ProgramPos pos;
	ParameterList param;
};

Function::Internal::Internal
		(const std::string & strdef, const ParameterList & param) :
	counter (1),
	deftype (DefSingle),
	param (param)
{
	code.scan (strdef);
}

Function::Internal::Internal
		(ProgramPos posfn, const ParameterList & param) :
	counter (1),
	deftype (DefMulti),
	pos (posfn),
	param (param)
{
}

void Function::Internal::addref ()
{
	++counter;
}

void Function::Internal::delref ()
{
	if (--counter == 0)
		delete this;
}

Function::Function (const std::string & strdef, const ParameterList & param) :
	pin (Internal::getnew (strdef, param) )
{
}

Function::Function (ProgramPos posfn, const ParameterList & param) :
	pin (Internal::getnew (posfn, param) )
{
}

Function::Function (const Function & f) :
	pin (f.pin)
{
	pin->addref ();
}

Function::~Function ()
{
	pin->delref ();
}

Function & Function::operator= (const Function & f)
{
	f.pin->addref ();
	pin->delref ();
	pin= f.pin;
	return * this;
}

Function::DefType Function::getdeftype () const
{
	return pin->getdeftype ();
}

CodeLine & Function::getcode ()
{
	return pin->getcode ();
}

ProgramPos Function::getpos () const
{
	return pin->getpos ();
}

const ParameterList & Function::getparam ()
{
	return pin->getparam ();
}

namespace {

typedef std::map <std::string, Function> mapfunction_t;
mapfunction_t mapfunction;

} // namespace

void Function::clear ()
{
	mapfunction.clear ();
}

void Function::insert (const std::string & name)
{
	mapfunction_t::iterator it=
		mapfunction.find (name);
	if (it != mapfunction.end () )
		it->second= * this;
	else
		mapfunction.insert (std::make_pair (name, * this) );
}

Function & Function::get (const std::string & name)
{
	mapfunction_t::iterator it=
		mapfunction.find (name);
	if (it != mapfunction.end () )
		return it->second;
	throw ErrFunctionNoDefined;
}

// Fin de function.cpp