Хотел бы попросить помочь разобраться в куске кода

Всю программу приводить смысла нету, программа представляет собой интерпретатор формул на с++.
Есть файл, в котором определены лексемы, функции и операторы
namespace ForInt {




// **************************************** *************************************
// определение лексем
typedef enum {
ID, // идентификатор
S_OP, // операция суммирования
M_OP, // операция умножения
E_OP, // операция возведения в степень
F_OP, // вызов функции
R_PAR, // правая скобка
L_PAR, // левая скобка
Num_OP // число
} LexemType;

// весовые коэффициенты операций
const int PRIO_SUMM = 2;
const int PRIO_MULT = 3;
const int PRIO_FUNC = 7;
const int PRIO_UMINUS = 6;
const int PRIO_IDENT = 0;
const int PRIO_PAR = 1;
const int PRIO_EXP = 5;
class FuncOP : public Lexem {
friend class Identifier;
public:
FuncOP() : Lexem() {};
FuncOP(const char *name_) : Lexem(name_) {};

LexemType getType() const { return F_OP; };
virtual int getPrio() const { return PRIO_FUNC; };

};

// вычисление синуса
class SinOP : public FuncOP {
public:
SinOP() : FuncOP("sin") {};
double eval(double x) const { return sin(x); };
};
// вычисление cos
class CosOP : public FuncOP {
public:
CosOP() : FuncOP("cos") {};
double eval(double x) const { return cos(x); };
};
// вычисление tg
class TgOP : public FuncOP {
public:
TgOP() : FuncOP("tg") {};
double eval(double x) const { return tan(x); };
};


Сложность вызывает следующее... в этом же файле есть такие классы
typedef Factory::Hire<std::string, FuncOP> FuncHire;
class Math : public FuncHire {
private:
Math() {
registerProduct("abs", new AbsOP());
registerProduct("exp", new EExpOP());
registerProduct("sin", new SinOP());
registerProduct("cos", new CosOP());
registerProduct("tg", new TgOP());
registerProduct("tan", new TgOP());
registerProduct("ctg", new CtgOP());
registerProduct("sqrt", new SqrtOP());
registerProduct("lg", new LgOP());
registerProduct("ln", new LnOP());
registerProduct("arcsin", new ArcsinOP());
registerProduct("arccos", new ArccosOP());
registerProduct("arctg", new ArctgOP());
registerProduct("atan", new ArctgOP());
registerProduct("Round", new RoundOP());
registerProduct("Floor", new FloorOP());
registerProduct("/-/", new UnaryMinusOP());
};
~Math() {};
friend class Singleton::Singleton<Math>;
};



typedef Singleton::Singleton<Math> MathSpace;
template <> MathSpace* MathSpace:Instance = NULL;

аналогично тут же еще один отдельный класс

typedef Factory::Hire<std::string, Lexem> LexemHire;
class SignFactory : public LexemHire {
private:
SignFactory() : LexemHire () {
registerProduct("+", new PlusOP());
registerProduct("-", new MinusOP());
registerProduct("*", new ProdOP());
registerProduct("/", new DivOP());
registerProduct("^", new ExpOP());
registerProduct("(", new LeftPar());
registerProduct(")", new RightPar());
};
~SignFactory() {};
friend class Singleton::Singleton<SignFactory>;
};

typedef Singleton::Singleton<SignFactory> BinarySigns;
template <> BinarySigns* BinarySigns:Instance = 0;

Lexem*
ProdOP::_toadd() {
if (nsign == 2) {
SignFactory& signfactory = BinarySigns::getInstance();
Lexem* item = signfactory.pcreate("^");
return item;
} else
return this;
};


Фабрика и синглетон приведены в двух отдельных файлах, Помогите пожалуйста разобраться как это все работает...
#ifndef FACTORY_HPP_
#define FACTORY_HPP_


# include <list>
# include <map>
# include <cstdlib>

namespace Factory {

// **************************************** *********************************
// фабрика с одним продуктом и сборщиком мусора
template <class Product>
class GCFactory {
typedef std::list<Product *> Collection_T;
public:
GCFactory() {};
~GCFactory() {
typename Collection_T::reverse_iterator I;
for (I = collection.rbegin(); I != collection.rend(); ++I) {
delete *I;
};
};

Product* pcreate() { // создание продукта; указатель
Product *product = new Product();
collection.push_back(product);
return product;
};

Product& rcreate() { // создание продукта; ссылка
Product * product = new Product();
collection.push_back(product);
return *product;
};

protected:
Collection_T collection;
};
//
// **************************************** *********************************


// **************************************** *********************************
// "прокат" объектов
//
// предполагается, что все объекты являются "собственностью" класса-проката
//
template <class IdType, class ProductType>
class Hire {
typedef std::map<IdType, ProductType*> ProductMap_T;
public:
Hire() {};
~Hire() {
std::cout << "прокат сдыхает" << std::endl;
typename ProductMap_T::iterator I;
for (I = products_.begin(); I != products_.end(); ++I)
if (I->second) delete I->second;
};

ProductType*
pcreate(IdType id) const { // "создание" продукта; ссылка
const typename ProductMap_T::const_iterator& I = products_.find(id);
return I->second;
};


ProductType&
rcreate(IdType id) const { // "создание" продукта; указатель
const typename ProductMap_T::const_iterator& I = products_.find(id);
return *(I->second);
};

bool has_name(const IdType& id) const {
const typename ProductMap_T::const_iterator& I = products_.find(id);
return (I != products_.end());
};

protected:
void registerProduct(IdType id, ProductType * product) { // регистрация продукта
products_[id] = product;
};

private:
ProductMap_T products_;
};
// /Hire
// **************************************** *********************************

};
#endif /* FACTORY_HPP_ */


# ifndef SINGLETON_HPP_
# define SINGLETON_HPP_

namespace Singleton {

template <class T>
class Singleton : public T {
private:
static Singleton<T> *pInstance;

Singleton<T>() : T() {};
Singleton(const Singleton&);
Singleton operator=(const Singleton&);

static void instanceCreate() {
static Singleton<T> instance;
pInstance = &instance;
}

public:
static Singleton<T>& getInstance() {
if (pInstance == 0) instanceCreate();
return *pInstance;
};


};

};

# endif

Как это работает как бы становится понятно только из того кода там где это работает
А принцип работы отличаться от принципа работы простого лексера и парсера существенно не должен ...

0