Initial commit from Polytechnique Montreal

1 files changed, 691 insertions, 0 deletions

diff --git a/Skin++/src/Lifo.cxx b/Skin++/src/Lifo.cxx
new file mode 100755
index 0000000..4451d90
--- /dev/null
+++ b/Skin++/src/Lifo.cxx
@@ -0,0 +1,691 @@
+
+/*****************************************/
+/*    C++ LIFO STACK OBJECT WRAPPER      */
+/*    AUTHOR: A. HEBERT ; 2012/10/07     */
+/*****************************************/
+
+/*
+Copyright (C) 2012 Ecole Polytechnique de Montreal
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+*/
+
+#include "Lifo.hxx"
+
+using namespace std;
+using namespace ganlib;
+static ostringstream hsmg;
+
+ganlib::Lifo::Lifo() {
+  cout << "New Lifo object constructed.'" << endl;
+  try {
+    cleopn(&(this->addr));
+  } catch(...) {
+    throw LifoException("Exception catched by cleopn");
+  }
+  this->global_list = new vector<ClcmPtr>;
+}
+
+ganlib::Lifo::~Lifo() {
+  cout << "Lifo destructor called (" << this->getMax() << " nodes remaining)." << endl;
+  int_32 nitma = clecls(&(this->addr));
+  if(nitma != 0) {
+    char hsmg[132];
+    snprintf(hsmg,42,"%s\n","Lifo destruction failure: Lifo not empty");
+    xabort_c(hsmg);
+  }
+  delete this->global_list;
+}
+
+//----------------------------------------------------------------------
+//--                               pop                                --
+//----------------------------------------------------------------------
+
+void ganlib::Lifo::pop() {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to pop from stack(0)");
+  try {
+    myNode = clepos(&(this->addr), this->addr->nup-1);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(1)");
+  }
+  clepop(&(this->addr));
+  free(myNode);
+}
+
+void ganlib::Lifo::pop(int_32 &myInteger) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to pop from stack(1)");
+  try {
+    myNode = clepos(&(this->addr), this->addr->nup-1);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(1)");
+  }
+  if (myNode->type != 11) {
+    hsmg << "pop() expecting an integer value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myInteger = myNode->value.ival;
+  clepop(&(this->addr));
+  free(myNode);
+}
+
+void ganlib::Lifo::pop(float_32 &myFloat) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to pop from stack(2)");
+  try {
+    myNode = clepos(&(this->addr), this->addr->nup-1);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(2)");
+  }
+  if (myNode->type != 12) {
+    hsmg << "pop() expecting a real value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myFloat = myNode->value.fval;
+  clepop(&(this->addr));
+  free(myNode);
+}
+
+void ganlib::Lifo::pop(string &myString) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to pop from stack(3)");
+  try {
+    myNode = clepos(&(this->addr), this->addr->nup-1);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(3)");
+  }
+  if (myNode->type != 13) {
+    hsmg << "pop() expecting a string value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myString = string(myNode->value.hval);
+  clepop(&(this->addr));
+  free(myNode);
+}
+
+void ganlib::Lifo::pop(double &myDouble) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to pop from stack(4)");
+  try {
+    myNode = clepos(&(this->addr), this->addr->nup-1);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(4)");
+  }
+  if (myNode->type != 14) {
+    hsmg << "pop() expecting a double precision value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myDouble = myNode->value.dval;
+  clepop(&(this->addr));
+  free(myNode);
+}
+
+void ganlib::Lifo::pop(bool &myBool) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to pop from stack(5)");
+  try {
+    myNode = clepos(&(this->addr), this->addr->nup-1);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(5)");
+  }
+  if (myNode->type != 15) {
+    hsmg << "pop() expecting a boolean value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myBool = (myNode->value.ival == 1);
+  clepop(&(this->addr));
+  free(myNode);
+}
+
+void ganlib::Lifo::pop(ClcmPtr &myClcm) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to pop from stack(6)");
+  try {
+    myNode = clepos(&(this->addr), this->addr->nup-1);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(6)");
+  }
+  if ((myNode->type != 3) && (myNode->type != 4)) {
+    hsmg << "pop() expecting a LCM or XSM object (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  lcm *myLcm = myNode->value.mylcm;
+  myClcm = ClcmPtr(new Clcm(myLcm, myNode->type, myNode->access, myNode->OSname));
+  clepop(&(this->addr));
+  free(myNode);
+}
+
+void ganlib::Lifo::pop(string myFile, string stype) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to pop from stack(7)");
+  try {
+    myNode = clepos(&(this->addr), this->addr->nup-1);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(7)");
+  }
+  if (myNode->type == 5) {
+    stype = "BINARY";
+  } else if (myNode->type == 6) {
+    stype = "ASCII";
+  } else if (myNode->type == 7) {
+    stype = "DA";
+  } else {
+    hsmg << "pop(): unknown file type";
+    throw LifoException(hsmg.str());
+  }
+  myFile = string(myNode->value.hval);
+  clepop(&(this->addr));
+  free(myNode);
+}
+
+//----------------------------------------------------------------------
+//--                              push                                --
+//----------------------------------------------------------------------
+
+void ganlib::Lifo::push(string sname, const int_32 myInteger) {
+  lifo_node * myNode = (lifo_node *) malloc(sizeof(lifo_node));
+  strcpy(myNode->name, (char *)sname.c_str()); myNode->type = 11; myNode->value.ival = myInteger;
+  try {
+    clepush(&(this->addr), myNode);
+  } catch(...) {
+    throw LifoException("Exception catched by clepush(1)");
+  }
+}
+
+void ganlib::Lifo::push(string sname, const float_32 myFloat) {
+  lifo_node * myNode = (lifo_node *) malloc(sizeof(lifo_node));
+  strcpy(myNode->name, (char *)sname.c_str()); myNode->type = 12; myNode->value.fval = myFloat;
+  try {
+    clepush(&(this->addr), myNode);
+  } catch(...) {
+    throw LifoException("Exception catched by clepush(2)");
+  }
+}
+
+void ganlib::Lifo::push(string sname, const string myString) {
+  lifo_node * myNode = (lifo_node *) malloc(sizeof(lifo_node));
+  strcpy(myNode->name, (char *)sname.c_str()); myNode->type = 13;
+  strcpy(myNode->value.hval, (char *)myString.c_str());
+  try {
+    clepush(&(this->addr), myNode);
+  } catch(...) {
+    throw LifoException("Exception catched by clepush(3)");
+  }
+}
+
+void ganlib::Lifo::push(string sname, const double myDouble) {
+  lifo_node * myNode = (lifo_node *) malloc(sizeof(lifo_node));
+  strcpy(myNode->name, (char *)sname.c_str()); myNode->type = 14; myNode->value.dval = myDouble;
+  try {
+    clepush(&(this->addr), myNode);
+  } catch(...) {
+    throw LifoException("Exception catched by clepush(4)");
+  }
+}
+
+void ganlib::Lifo::push(string sname, bool myBool) {
+  lifo_node * myNode = (lifo_node *) malloc(sizeof(lifo_node));
+  int_32 ibool = 0; if (myBool) ibool = 1;
+  strcpy(myNode->name, (char *)sname.c_str()); myNode->type = 15; myNode->value.ival = ibool;
+  try {
+    clepush(&(this->addr), myNode);
+  } catch(...) {
+    throw LifoException("Exception catched by clepush(5)");
+  }
+}
+
+void ganlib::Lifo::push(string sname, ClcmPtr myClcm) {
+  lifo_node * myNode = (lifo_node *) malloc(sizeof(lifo_node));
+  strcpy(myNode->name, (char *)sname.c_str());
+  myNode->type = myClcm->getType()+2;
+  myNode->access = myClcm->getAccess();
+  lcm *myLcm = myClcm->extract();
+  myNode->value.mylcm = myLcm;
+  strcpy(myNode->OSname, (char *)myClcm->getName().c_str());
+  try {
+    clepush(&(this->addr), myNode);
+  } catch(...) {
+    throw LifoException("Exception catched by clepush(6)");
+  }
+  (this->global_list)->push_back(myClcm);
+}
+
+void ganlib::Lifo::push(string sname, string myFile, string stype) {
+  lifo_node * myNode = (lifo_node *) malloc(sizeof(lifo_node));
+  strcpy(myNode->name, (char *)sname.c_str());
+  if (stype == "BINARY") {
+    myNode->type = 5;
+  } else if (stype == "ASCII") {
+    myNode->type = 6;
+  } else if (stype == "DA") {
+    myNode->type = 7;
+  } else {
+    hsmg << "push() unknown file type (" << stype << ")";
+    throw LifoException(hsmg.str());
+  }
+  strcpy(myNode->value.hval, (char *)myFile.c_str());
+  strcpy(myNode->OSname, (char *)myFile.c_str());
+  try {
+    clepush(&(this->addr), myNode);
+  } catch(...) {
+    throw LifoException("Exception catched by clepush(7)");
+  }
+}
+
+void ganlib::Lifo::push(string sname, string myFile, string stype, string OSname) {
+  lifo_node * myNode = (lifo_node *) malloc(sizeof(lifo_node));
+  strcpy(myNode->name, (char *)sname.c_str());
+  if (stype == "BINARY") {
+    myNode->type = 5;
+  } else if (stype == "ASCII") {
+    myNode->type = 6;
+  } else if (stype == "DA") {
+    myNode->type = 7;
+  } else {
+    hsmg << "push(): unknown file type (" << stype << ")";
+    throw LifoException(hsmg.str());
+  }
+  strcpy(myNode->value.hval, (char *)myFile.c_str());
+  strcpy(myNode->OSname, (char *)OSname.c_str());
+  try {
+    clepush(&(this->addr), myNode);
+  } catch(...) {
+    throw LifoException("Exception catched by clepush(8)");
+  }
+}
+
+//----------------------------------------------------------------------
+//--                            pushEmpty                             --
+//----------------------------------------------------------------------
+
+void ganlib::Lifo::pushEmpty(string sname, string nodeType) {
+  lifo_node * myNode = (lifo_node *) malloc(sizeof(lifo_node)); 
+  strcpy(myNode->name, (char *)sname.c_str());
+  if (nodeType == "I") {
+    myNode->type = -11 ;
+  } else if (nodeType == "F") {
+    myNode->type = -12 ;
+  } else if (nodeType == "D") {
+    myNode->type = -13 ;
+  } else if (nodeType == "S") {
+    myNode->type = -14 ;
+  } else if (nodeType == "B") {
+    myNode->type = -15 ;
+  } else if (nodeType == "LCM") {
+    myNode->type = -3 ;
+    myNode->access = 0 ;
+    strcpy(myNode->OSname, (char *)sname.c_str());
+  } else if (nodeType == "XSM") {
+    myNode->type = -4 ;
+    myNode->access = 0 ;
+    strcpy(myNode->OSname, (char *)sname.c_str());
+  } else if (nodeType == "BINARY") {
+    myNode->type = -5 ;
+    myNode->access = 0 ;
+  } else if (nodeType == "ASCII") {
+    myNode->type = -6 ;
+    myNode->access = 0 ;
+  } else if (nodeType == "DA") {
+    myNode->type = -7 ;
+    myNode->access = 0 ;
+  } else {
+    hsmg << nodeType << "is an invalid type in pushEmpty";
+    throw LifoException(hsmg.str());
+  }
+  try {
+    clepush(&(this->addr), myNode);
+  } catch(...) {
+    throw LifoException("Exception catched by clepush(9)");
+  }
+}
+
+void ganlib::Lifo::pushEmpty(string sname, string nodeType, string OSname) {
+  lifo_node * myNode = (lifo_node *) malloc(sizeof(lifo_node)); 
+  strcpy(myNode->name, (char *)sname.c_str());
+  if (nodeType == "XSM") {
+    myNode->type = -4 ;
+    myNode->access = 0 ;
+  } else if (nodeType == "BINARY") {
+    myNode->type = -5 ;
+    myNode->access = 0 ;
+  } else if (nodeType == "ASCII") {
+    myNode->type = -6 ;
+    myNode->access = 0 ;
+  } else if (nodeType == "DA") {
+    myNode->type = -7 ;
+    myNode->access = 0 ;
+  } else {
+    hsmg << nodeType << "is an invalid type in pushEmpty";
+    throw LifoException(hsmg.str());
+  }
+  strcpy(myNode->OSname, (char *)OSname.c_str());
+  try {
+    clepush(&(this->addr), myNode);
+  } catch(...) {
+    throw LifoException("Exception catched by clepush(9)");
+  }
+}
+
+//----------------------------------------------------------------------
+//--                        node by position                          --
+//----------------------------------------------------------------------
+
+void ganlib::Lifo::node(int_32 ipos, int_32 &myInteger) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(11)");
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(11)");
+  }
+  if (myNode->type != 11) {
+    hsmg << "node() expecting an integer value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myInteger = myNode->value.ival;
+}
+
+void ganlib::Lifo::node(int_32 ipos, float_32 &myFloat) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(12)");
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(12)");
+  }
+  if (myNode->type != 12) {
+    hsmg << "node() expecting a real value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myFloat = myNode->value.fval;
+}
+
+void ganlib::Lifo::node(int_32 ipos, string &myString) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(13)");
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(13)");
+  }
+  if (myNode->type != 13) {
+    hsmg << "node() expecting a string value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myString = string(myNode->value.hval);
+}
+
+void ganlib::Lifo::node(int_32 ipos, double &myDouble) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(14)");
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(14)");
+  }
+  if (myNode->type != 14) {
+    hsmg << "node() expecting a double precision value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myDouble = myNode->value.dval;
+}
+
+void ganlib::Lifo::node(int_32 ipos, bool &myBool) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(15)");
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(15)");
+  }
+  if (myNode->type != 11) {
+    hsmg << "node() expecting a boolean value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myBool = (myNode->value.ival == 1);
+}
+
+void ganlib::Lifo::node(int_32 ipos, ClcmPtr &myClcm) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(16)");
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(16)");
+  }
+  if ((myNode->type != 3) && (myNode->type != 4)) {
+    hsmg << "node() expecting a LCM or XSM object (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  lcm *myLcm = myNode->value.mylcm;
+  myClcm = ClcmPtr(new Clcm(myLcm, myNode->type, myNode->access, myNode->OSname));
+}
+
+void ganlib::Lifo::node(int_32 ipos, string myFile, string stype) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to pop from stack(17)");
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(17)");
+  }
+  if (myNode->type == 5) {
+    stype = "BINARY";
+  } else if (myNode->type == 6) {
+    stype = "ASCII";
+  } else if (myNode->type == 7) {
+    stype = "DA";
+  } else {
+    hsmg << "node(): unknown file type";
+    throw LifoException(hsmg.str());
+  }
+  myFile = string(myNode->value.hval);
+}
+
+//----------------------------------------------------------------------
+//--                          node by name                            --
+//----------------------------------------------------------------------
+
+void ganlib::Lifo::node(string sname, int_32 &myInteger) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(21)");
+  try {
+    myNode = clenode(&(this->addr), sname.c_str());
+  } catch(...) {
+    throw LifoException("Exception catched by clenode(21)");
+  }
+  if (myNode->type != 11) {
+    hsmg << "node() expecting an integer value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myInteger = myNode->value.ival;
+}
+
+void ganlib::Lifo::node(string sname, float_32 &myFloat) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(22)");
+  try {
+    myNode = clenode(&(this->addr), sname.c_str());
+  } catch(...) {
+    throw LifoException("Exception catched by clenode(22)");
+  }
+  if (myNode->type != 12) {
+    hsmg << "node() expecting a real value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myFloat = myNode->value.fval;
+}
+
+void ganlib::Lifo::node(string sname, string &myString) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(23)");
+  try {
+    myNode = clenode(&(this->addr), sname.c_str());
+  } catch(...) {
+    throw LifoException("Exception catched by clenode(23)");
+  }
+  if (myNode->type != 13) {
+    hsmg << "node() expecting a string value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myString = string(myNode->value.hval);
+}
+
+void ganlib::Lifo::node(string sname, double &myDouble) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(24)");
+  try {
+    myNode = clenode(&(this->addr), sname.c_str());
+  } catch(...) {
+    throw LifoException("Exception catched by clenode(24)");
+  }
+  if (myNode->type != 14) {
+    hsmg << "node() expecting a double precision value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myDouble = myNode->value.dval;
+}
+
+void ganlib::Lifo::node(string sname, bool &myBool) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(25)");
+  try {
+    myNode = clenode(&(this->addr), sname.c_str());
+  } catch(...) {
+    throw LifoException("Exception catched by clenode(25)");
+  }
+  if (myNode->type != 11) {
+    hsmg << "node() expecting a boolean value (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  myBool = (myNode->value.ival == 1);
+}
+
+void ganlib::Lifo::node(string sname, ClcmPtr &myClcm) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to recover from stack(26)");
+  try {
+    myNode = clenode(&(this->addr), sname.c_str());
+  } catch(...) {
+    throw LifoException("Exception catched by clenode(26)");
+  }
+  if ((myNode->type != 3) && (myNode->type != 4)) {
+    hsmg << "node() expecting a LCM or XSM object (" << myNode->type << " found)";
+    throw LifoException(hsmg.str());
+  }
+  lcm *myLcm = myNode->value.mylcm;
+  myClcm = ClcmPtr(new Clcm(myLcm, myNode->type, myNode->access, myNode->OSname));
+}
+
+void ganlib::Lifo::node(string sname, string myFile, string stype) {
+  lifo_node *myNode;
+  if (this->addr->nup == 0)  throw LifoException("no nodes to pop from stack(27)");
+  try {
+    myNode = clenode(&(this->addr), sname.c_str());
+  } catch(...) {
+    throw LifoException("Exception catched by clenode(27)");
+  }
+  if (myNode->type == 5) {
+    stype = "BINARY";
+  } else if (myNode->type == 6) {
+    stype = "ASCII";
+  } else if (myNode->type == 7) {
+    stype = "DA";
+  } else {
+    hsmg << "node(): unknown file type";
+    throw LifoException(hsmg.str());
+  }
+  myFile = string(myNode->value.hval);
+}
+
+//----------------------------------------------------------------------
+
+int_32 ganlib::Lifo::getMax() {
+  return this->addr->nup;
+}
+
+int_32 ganlib::Lifo::typeNode(int_32 ipos) {
+  lifo_node *myNode;
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(51)");
+  }
+  return myNode->type;
+}
+
+int_32 ganlib::Lifo::accessNode(int_32 ipos) {
+  lifo_node *myNode;
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(52)");
+  }
+  return myNode->access;
+}
+
+string ganlib::Lifo::OSName(int_32 ipos) {
+  lifo_node *myNode;
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(53)");
+  }
+  return myNode->OSname;
+}
+
+string ganlib::Lifo::Name(int_32 ipos) {
+  lifo_node *myNode;
+  try {
+    myNode = clepos(&(this->addr), ipos);
+  } catch(...) {
+    throw LifoException("Exception catched by clepos(54)");
+  }
+  return myNode->name;
+}
+
+int_32 ganlib::Lifo::typeNode(string sname) {
+  lifo_node *myNode;
+  try {
+    myNode = clenode(&(this->addr), sname.c_str());
+  } catch(...) {
+    throw LifoException("Exception catched by clenode(55)");
+  }
+  return myNode->type;
+}
+
+int_32 ganlib::Lifo::accessNode(string sname) {
+  lifo_node *myNode;
+  try {
+    myNode = clenode(&(this->addr), sname.c_str());
+  } catch(...) {
+    throw LifoException("Exception catched by clenode(56)");
+  }
+  return myNode->access;
+}
+
+string ganlib::Lifo::OSName(string sname) {
+  lifo_node *myNode;
+  try {
+    myNode = clenode(&(this->addr), sname.c_str());
+  } catch(...) {
+    throw LifoException("Exception catched by clenode(57)");
+  }
+  return myNode->OSname;
+}
+
+void ganlib::Lifo::lib() {
+  try {
+    clelib(&(this->addr));
+  } catch(...) {
+    throw LifoException("Exception catched by clelib");
+  }
+}
+
+lifo *ganlib::Lifo::extract() {
+  return this->addr;
+}