bool LibxmlSaxParser::parseBuffer( const char* uri, const char* buffer, int length )
{
mParserContext = xmlCreateMemoryParserCtxt( buffer, length );
if ( !mParserContext )
{
ParserError error(ParserError::SEVERITY_CRITICAL,
ParserError::ERROR_COULD_NOT_OPEN_FILE,
0,
0,
0,
0,
uri);
IErrorHandler* errorHandler = getParser()->getErrorHandler();
if ( errorHandler )
{
errorHandler->handleError(error);
}
return false;
}
// We let libxml replace the entities
mParserContext->replaceEntities = 1;
if (mParserContext->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
{
xmlFree(mParserContext->sax);
}
mParserContext->sax = &SAXHANDLER;
mParserContext->userData = (void*)this;
initializeParserContext();
xmlParseDocument(mParserContext);
mParserContext->sax = 0;
if ( mParserContext->myDoc )
{
xmlFreeDoc(mParserContext->myDoc);
mParserContext->myDoc = 0;
}
xmlFreeParserCtxt(mParserContext);
mParserContext = 0;
return true;
}
bool FunctionParsersManager::parse(std::vector<foundInfo> & foundInfos, generic_string ext)
{
if (!_pXmlFuncListDoc)
return false;
// Serch the right parser from the given ext in the map
FunctionParser *fp = getParser(ext);
if (!fp)
return false;
// parse
int docLen = (*_ppEditView)->getCurrentDocLen();
fp->parse(foundInfos, 0, docLen, _ppEditView);
return true;
}
static
void parseTwo(BinInputStream* inStream
, const char* const xmlFile)
{
//we don't use janitor here
MemoryManager* theMemMgr = new MemoryManagerImpl();
XMLGrammarPool* theGramPool = new XMLGrammarPoolImpl(theMemMgr);
bool errorSeen = false;
//de-serialize grammar pool
try
{
theGramPool->deserializeGrammars(inStream);
}
catch(const XSerializationException& e)
{
XERCES_STD_QUALIFIER cerr << "An error occurred during de-serialization\n Message: "
<< StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl;
errorSeen = true;
}
catch (...)
{
//do emit error here so that we know serialization failure
XERCES_STD_QUALIFIER cerr << "An error occurred during de-serialization\n" << XERCES_STD_QUALIFIER endl;
errorSeen = true;
}
if (!errorSeen)
{
SAX2XMLReader* theParser = getParser(theGramPool, true); //set the handler
theParser->setFeature(XMLUni::fgXercesUseCachedGrammarInParse, true);
parseFile(theParser, xmlFile);
delete theParser;
}
//the order is important
delete theGramPool;
delete theMemMgr;
return;
}
/*********************************************************************
** METHOD :
** PURPOSE :
** INPUT :
** OUTPUT :
** RETURN :
** REMARKS :
*********************************************************************/
IProperties* Tool::run (int argc, char* argv[])
{
DEBUG (("Tool::run(argc,argv) => tool='%s' \n", getName().c_str() ));
try
{
/** We parse the user parameters. */
IProperties* props = getParser()->parse (argc, argv);
/** We run the tool. */
return run (props);
}
catch (OptionFailure& e)
{
e.displayErrors (std::cout);
return NULL;
}
}
bool LibxmlSaxParser::parseFile( const char* fileName )
{
mParserContext = xmlCreateFileParserCtxt(fileName);
if ( !mParserContext )
{
ParserError error(ParserError::SEVERITY_CRITICAL,
ParserError::ERROR_COULD_NOT_OPEN_FILE,
0,
0,
0,
0,
fileName);
getParser()->getErrorHandler()->handleError(error);
return false;
}
if (mParserContext->sax != (xmlSAXHandlerPtr) &xmlDefaultSAXHandler)
{
xmlFree(mParserContext->sax);
}
mParserContext->sax = &SAXHANDLER;
mParserContext->userData = (void*)this;
initializeParserContext();
xmlParseDocument(mParserContext);
mParserContext->sax = 0;
if ( mParserContext->myDoc )
{
xmlFreeDoc(mParserContext->myDoc);
mParserContext->myDoc = 0;
}
xmlFreeParserCtxt(mParserContext);
mParserContext = 0;
return true;
}
//-------------------------------------------------------------------------
ParserPos &ParserPos::operator-=(size_t inDistance)
{
ParserPtr parser(getParser());
if (NULL == mPos)
{
ParserPos temp(*this);
temp.setSOF();
temp += strlen(temp.mPos);
(*this) = temp;
}
while (0 != inDistance)
{
if (isSOF())
return *this;
// assuming column and row should be accurate at this point, but could become inaccurate
// if we run into a special character
--mPos;
--inDistance;
switch (*mPos)
{
case '\r':
case '\n':
case '\t':
{
if ('\n' == *mPos)
{
ZS_THROW_BAD_STATE_IF(mRow < 2) // how did the count become inaccurate
--mRow;
}
if ('\r' == *mPos)
{
if ('\n' != (*(mPos+1)))
{
// this is a MAC EOL
ZS_THROW_BAD_STATE_IF(mRow < 2) // how did the count become inaccurate
--mRow;
}
}
ZS_THROW_BAD_STATE_IF(!parser)
ZS_THROW_BAD_STATE_IF(NULL == parser->mSOF)
// these characters cause the column to get messed up, simplest method is to
// recalculate the column position from the start of the line
mColumn = internal::calculateColumnFromSOL(mPos, parser->mSOF, parser->mTabSize);
break;
}
default:
{
ZS_THROW_BAD_STATE_IF(mColumn < 2) // how did the count become inaccurate
--mColumn;
break;
}
}
}
return *this;
}
void Application::newConnection()
{
QLocalSocket *socket = m_localServer->nextPendingConnection();
if (!socket)
{
return;
}
socket->waitForReadyRead(1000);
MainWindow *window = (getWindows().isEmpty() ? NULL : getWindow());
QString data;
QTextStream stream(socket);
stream >> data;
const QStringList encodedArguments = QString(QByteArray::fromBase64(data.toUtf8())).split(QLatin1Char(' '));
QStringList decodedArguments;
for (int i = 0; i < encodedArguments.count(); ++i)
{
decodedArguments.append(QString(QByteArray::fromBase64(encodedArguments.at(i).toUtf8())));
}
QCommandLineParser *parser = getParser();
parser->parse(decodedArguments);
const QString session = parser->value(QLatin1String("session"));
const bool isPrivate = parser->isSet(QLatin1String("privatesession"));
if (session.isEmpty())
{
if (!window || !SettingsManager::getValue(QLatin1String("Browser/OpenLinksInNewTab")).toBool() || (isPrivate && !window->getWindowsManager()->isPrivate()))
{
window = createWindow(isPrivate);
}
}
else
{
const SessionInformation sessionData = SessionsManager::getSession(session);
if (sessionData.clean || QMessageBox::warning(NULL, tr("Warning"), tr("This session was not saved correctly.\nAre you sure that you want to restore this session anyway?"), QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes)
{
for (int i = 0; i < sessionData.windows.count(); ++i)
{
createWindow(isPrivate, false, sessionData.windows.at(i));
}
}
}
if (window)
{
if (!parser->positionalArguments().isEmpty())
{
const QStringList urls = parser->positionalArguments();
for (int i = 0; i < urls.count(); ++i)
{
window->openUrl(QUrl(urls.at(i)));
}
}
else if (session.isEmpty())
{
window->openUrl();
}
}
delete socket;
if (window)
{
window->raise();
window->activateWindow();
}
delete parser;
}
int emain()
{
bool cl=false;
bool sl=false;
bool al=false;
bool cdist=false;
epregister(cl);
epregister(sl);
epregister(al);
epregister(cdist);
epregisterFunc(help);
dfuncpart.choice=0;
dfuncpart.add("gap",edistfunc(part_calc_dists_u<estrarray,eseqdist,dist_compressed2>,dist_compressed2));
dfuncpart.add("nogap",edistfunc(part_calc_dists_u<estrarray,eseqdist,dist_nogap_compressed2>,dist_nogap_compressed2));
dfuncpart.add("gap2",edistfunc(part_calc_dists_u<estrarray,eseqdist,dist_compressed>,dist_compressed));
dfuncpart.add("nogap2",edistfunc(part_calc_dists_u<estrarray,eseqdist,dist_nogap_compressed>,dist_nogap_compressed));
dfuncpart.add("nogapsingle",edistfunc(part_calc_dists_u<estrarray,eseqdist,dist_nogapsingle_compressed>,dist_nogapsingle_compressed));
dfuncpart.add("tamura",edistfunc(part_calc_dists_u<estrarray,eseqdist,dist_tamura_compressed>,dist_tamura_compressed));
epregister(dfuncpart);
dfunc.choice=0;
dfunc.add("gap",edistfunc(t_calc_dists_u<estrarray,eseqdist,eblockarray<eseqdist>,dist_compressed2>,dist_compressed2));
dfunc.add("nogap",edistfunc(t_calc_dists_u<estrarray,eseqdist,eblockarray<eseqdist>,dist_nogap_compressed2>,dist_nogap_compressed2));
dfunc.add("gap2",edistfunc(t_calc_dists_u<estrarray,eseqdist,eblockarray<eseqdist>,dist_compressed>,dist_compressed));
dfunc.add("nogap2",edistfunc(t_calc_dists_u<estrarray,eseqdist,eblockarray<eseqdist>,dist_nogap_compressed>,dist_nogap_compressed));
dfunc.add("nogapsingle",edistfunc(t_calc_dists_u<estrarray,eseqdist,eblockarray<eseqdist>,dist_nogapsingle_compressed>,dist_nogapsingle_compressed));
dfunc.add("tamura",edistfunc(t_calc_dists_u<estrarray,eseqdist,eblockarray<eseqdist>,dist_tamura_compressed>,dist_tamura_compressed));
epregisterClass(eoption<edistfunc>);
epregisterClassMethod4(eoption<edistfunc>,operator=,int,(const estr& val),"=");
epregister(dfunc);
epregister(winlen);
estr ofile;
estr dfile;
estr dupfile;
epregister(dupfile);
epregister(ignoreUnique);
epregister(t);
epregister(nthreads);
epregister(ofile);
epregister(dfile);
epregister(ignoreMemThres);
getParser()->actions.add("makereps",actionMakeReps);
getParser()->actions.add("makeotus",actionMakeOtus);
getParser()->actions.add("makeotus_mothur",actionMakeOtusMothur);
getParser()->actions.add("makepart",actionMakePart);
eparseArgs(argvc,argv);
// cout << "# initializing identity lookup table" << endl;
// initLookupTable();
if(argvc<2) {
cout << "syntax: "+efile(argv[0]).basename()+" <-sl true|-cl true|-al true> <seqali>" << endl;
cout << "\""+efile(argv[0]).basename()+ " --help\" for more help" << endl;
exit(-1);
}
if(!cl && !sl && !al) {
cout << "syntax: "+efile(argv[0]).basename()+" <-sl true|-cl true|-al true> <seqali>" << endl;
cout << "please choose at least one clustering method <-sl true|-cl true|-al true>" << endl;
cout << "\""+efile(argv[0]).basename()+ " --help\" for more help" << endl;
exit(-1);
}
cout << "# " << date() << endl;
cout << "# " << args2str(argvc,argv) << endl;
cout << "# system RAM: " << getSystem()->getTotalRam()/1024 << "Mb" << endl;
cout << "# free system RAM: " << (getSystem()->getFreeRam()+getSystem()->getBufferRam())/1024 << "Mb" << endl;
cout << "# process memory limit: " << ((getSystem()->getMemLimit()&0x3fffffffffffff)==0x3fffffffffffff?estr("unlimited"):estr(getSystem()->getMemLimit()/1024/1024)+"Mb") << endl;
warnMemThres=MIN(MIN(getSystem()->getTotalRam(),getSystem()->getMemLimit()/1024),getSystem()->getFreeRam()+getSystem()->getBufferRam())*0.6/1024;
exitMemThres=MIN(MIN(getSystem()->getTotalRam(),getSystem()->getMemLimit()/1024),getSystem()->getFreeRam()+getSystem()->getBufferRam())*0.65/1024;
cout << "# warning memory threshold: " << warnMemThres << "Mb" << endl;
cout << "# exit memory threshold: " << exitMemThres << "Mb" << endl;
cout << "# distance function: " << dfunc.key() << endl;
if (ofile.len()==0)
ofile=argv[1];
epregisterClass(eseqdist);
epregisterClassSerializeMethod(eseqdist);
epregisterClassProperty(eseqdist,dist);
epregisterClassProperty(eseqdist,x);
epregisterClassProperty(eseqdist,y);
epregisterClass(ebasicarray<eseqdist>);
epregisterClassInheritance(ebasicarray<eseqdist>,ebasearray);
epregisterClassMethod(ebasicarray<eseqdist>,subset);
epregisterClassSerializeMethod(ebasicarray<eseqdist>);
long i,j;
cout << "# loading seqs file: " << argv[1] << endl;
load_seqs_compressed(argv[1],arr,seqlen);
#ifndef HPC_CLUST_USE_LONGIND
ldieif(arr.size() > (2l<<31),"To cluster more than 2 million sequences please recompile hpc-clust with the --enable-longind flag.");
#endif
ebasicarray<INDTYPE> uniqind;
earray<ebasicarray<INDTYPE> > dupslist;
finduniq(uniqind,dupslist);
cout << "# unique seqs: " << uniqind.size() << endl;
if (dupfile.len()){
efile dupf(dupfile,"w");
for (i=0; i<dupslist.size(); ++i){
dupf.write(estr(dupslist[i][0])+" "+estr(dupslist[i].size()));
for (j=1; j<dupslist[i].size(); ++j)
dupf.write(estr(" ")+dupslist[i][j]);
dupf.write("\n");
}
dupf.close();
}
long maxdists=uniqind.size()*(uniqind.size()-1)/2;
long maxmem=maxdists*sizeof(eseqdist)/1024/1024;
cout << "# maximum number of distance pairs: " << maxdists << " (" << maxmem << "Mb)" << endl;
if (maxmem > warnMemThres){
cout << "# WARNING: Number of sequences provided may require more memory than is currently available on this system." << endl;
cout << "# Please monitor the memory usage of this program and check the log at the end. This program will" << endl;
cout << "# automatically exit if it reaches the exitMemThres value shown above. You can force the program" << endl;
cout << "# to ignore this threshold using the argument: -ignoreMemThres true" << endl;
cout << "# Memory requirements can be reduced by increasing the clustering threshold, or reducing the number" << endl;
cout << "# of sequences to be clustered. For more information and tips on optimizing hpc-clust memory" << endl;
cout << "# usage please refer to the documentation." << endl;
}
float dtime,stime;
etimer t1;
t1.reset();
efile df(dfile);
cout << "# computing distances" << endl;
// if ((arr.size()-1l)*arr.size()/2l/partsTotal > 10000l) partsTotal=(arr.size()-1l)*arr.size()/2l/10000l; // make more tasks if too many calculations per task
if (partsTotal>(arr.size()-1l)*arr.size()/20l) partsTotal=(arr.size()-1l)*arr.size()/20l; // make fewer tasks if to few calculations per task
// cout << "partsTotal: " << partsTotal << endl;
cerr << endl; // needed for keeping track of the progress
for (i=0; i<partsTotal; ++i)
taskman.addTask(dfunc.value().calcfunc,evararray(mutex,uniqind,arr,dists,(const int&)seqlen,(const long int&)i,(const long int&)partsTotal,(const float&)t,(const int&)winlen));
taskman.createThread(nthreads);
taskman.wait();
cerr << endl;
dtime=t1.lap()*0.001;
cout << "# time calculating distances: " << dtime << endl;
cout << "# distances within threshold: " << dists.size() << endl;
cout << "# number of tasks: " << taskman.tasks.size() << endl;
fradix256sort<eblockarray<eseqdist>,radixKey>(dists);
cout << "# number of tasks: " << taskman.tasks.size() << endl;
stime=t1.lap()*0.001;
if (dfile.len()){
cout << "# saving distances to file: "<<dfile << endl;
for (i=0; i<dists.size(); ++i)
df.write(estr(arr.keys(dists[i].x))+"\t"+arr.keys(dists[i].y)+"\t"+(1.0-dists[i].dist)+"\n");
/*
for (i=0; i<dupslist.size(); ++i){
for (j=1; j<dupslist[i].size(); ++j)
df.write(estr(dupslist[i][0])+" "+dupslist[i][j]+" 1.0\n");
}
*/
df.close();
}
// }else{
// cout << "# loading distances from file: "<<dfile << endl;
/*
estr str;
df.read(str);
ldieif(mindists.unserial(str,0)==-1,"problem loading distance file: "+dfile);
df.close();
*/
// }
totaldists=dists.size();
cout << "# time sorting distances: " << stime << endl;
cout << "# initializing cluster"<<endl;
if (cl)
clcluster.init(arr.size(),ofile+".cl",argv[1],dupslist);
if (sl)
slcluster.init(arr.size(),ofile+".sl",argv[1],dupslist);
if (al)
alcluster.init(arr.size(),ofile+".al",argv[1],dupslist,t,dfunc.value().calcfunc_single,arr,seqlen);
cout << "# starting clustering"<<endl;
t1.reset();
for (i=dists.size()-1; i>=0; --i){
if (cl)
clcluster.add(dists[i]);
if (al)
alcluster.add(dists[i]);
if (sl)
slcluster.add(dists[i]);
}
if (al)
alcluster.finalize();
float clustime=t1.lap()*0.001;
cout << "# time calculating distances: " << dtime << endl;
cout << "# time sorting distances: " << stime << endl;
cout << "# time clustering: " << clustime << endl;
cout << "# total time: " << dtime+clustime+stime << endl;
cout << "# distances within threshold: " << totaldists << endl;
if (cdist){
efile fsl,fcl,fal;
if (sl) fsl.open(ofile+".sl.dist","w");
if (cl) fcl.open(ofile+".cl.dist","w");
if (al) fal.open(ofile+".cl.dist","w");
for (i=dists.size()-1; i>=0; --i){
if (sl) fsl.write(estr(dists[i].x)+" "+dists[i].y+" "+dists[i].dist+" "+slcluster.clusterData.getMergeDistance(dists[i].x,dists[i].y)+"\n");
if (cl) fcl.write(estr(dists[i].x)+" "+dists[i].y+" "+dists[i].dist+" "+clcluster.clusterData.getMergeDistance(dists[i].x,dists[i].y)+"\n");
if (al) fal.write(estr(dists[i].x)+" "+dists[i].y+" "+dists[i].dist+" "+alcluster.clusterData.getMergeDistance(dists[i].x,dists[i].y)+"\n");
}
}
return(0);
}
void epregisterFunctions()
{
if (doneRegister) return;
doneRegister=true;
epregisterClass(eregexp);
epregisterClassConstructor(eregexp,(const estr&));
epregisterClassConverterCast(eregexp,estr);
epregisterClassMethod(eregexp,compile);
epregisterClassMethod2D(eregexp,match,int,(const estr&,int,int) const,evararray(0x00));
epregisterClassMethod2D(eregexp,match,int,(const estr&,int,int&,int&,int) const,evararray(0x00));
// epregisterClassProperty(eregexp,b);
// epregisterClassProperty(eregexp,e);
epregisterClass(eudpsocket);
// epregisterClassMethodD(eudpsocket,listen,"0.0.0.0");
epregisterClassMethodD(eudpsocket,listen,evararray("0.0.0.0"));
epregisterClassMethod(eudpsocket,setReuseAddress);
epregisterClassMethod(eudpsocket,close);
epregisterClassMethod(eudpsocket,shutdown);
epregisterClassMethod(eudpsocket,recvfrom);
epregisterClassMethod(eudpsocket,sendto);
epregisterClassProperty(eudpsocket,onReceive);
epregisterClass(esocket);
epregisterClassMethod(esocket,connect);
epregisterClassMethod(esocket,close);
epregisterClassMethod(esocket,shutdown);
epregisterClassMethod2(esocket,recv,int,(estr&,int));
epregisterClassMethod2(esocket,send,int,(const estr&));
epregisterClassProperty(esocket,onReceive);
epregisterClass(earray<esocket>);
epregisterClassInheritance(earray<esocket>,ebasearray);
/*
epregisterClass(eserver<esocket>);
epregisterClassConstructor(eserver<esocket>,());
epregisterClassMethodD(eserver<esocket>,listen,"0.0.0.0");
epregisterClassMethod2(eserver<esocket>,accept,esocket*,());
epregisterClassProperty(eserver<esocket>,onIncoming);
epregisterClassProperty(eserver<esocket>,sockets);
*/
epregisterClassMethod2(ebasearrayof,addvar,void,(evar&,evar&));
epregisterClassMethod2(ebasearrayof,getvar,evar,(int));
epregisterClassMethod2(ebasearrayof,getvarkey,evar,(int));
epregisterClassMethod2A(ebasearrayof,addvar,"add",void,(evar&,evar&));
epregisterClassMethod2A(ebasearrayof,getvarByKey,"[]",evar,(const evar&));
epregisterClassMethod2A(ebasearrayof,getvar,"values",evar,(int));
epregisterClassMethod2A(ebasearrayof,getvarkey,"keys",evar,(int));
epregisterClassMethod2(ebasearrayof,size,int,());
epregister2(getClasses(),"classes");
epregisterClassProperty(eclassBase,properties);
epregisterClassProperty(eclassBase,methods);
epregisterClassProperty(eclassBase,parents);
epregisterClassConstructor(estrarray,(const estr&));
epregisterClassMethod2(estrarray,add,estr&,(const estr&));
epregisterClassMethod2(estrarray,add,estr&,(const estr&,const estr&));
epregisterClassMethod(estrarray,load);
epregisterClassMethod(estrarray,save);
epregisterClassMethod(estrarray,join);
epregisterClassMethodD(estrarray,find,evararray(0,estrarray::equal));
epregisterClassMethodD(estrarray,ifind,evararray(0));
epregisterClassMethodD(estrarray,refind,evararray(0));
epregisterClassMethodD(estrarray,findkey,evararray(0));
epregisterClassMethodD(estrarray,ifindkey,evararray(0));
epregisterClassMethodD(estrarray,refindkey,evararray(0));
epregisterClassMethod(estrarray,ifindall);
epregisterClassMethod(estrarray,ifindallkey);
epregisterClassMethod(estrarray,refindall);
epregisterClassMethod(estrarray,refindallkey);
epregisterClassMethod2(estrarray,keys,const estr&,(size_t) const);
epregisterClassMethod2(estrarray,values,estr&,(size_t));
epregisterClassMethod4(estrarray,operator[],estr&,(size_t),"[]");
epregisterClassMethod4(estrarray,operator[],estr&,(const estr&),"[]");
epregisterClassMethod4(estrarray,operator[],estrarray,(const eintarray&) const,"[]");
epregisterClassMethod4(estrarray,operator-=,estrarray&,(const estrarray&),"-=");
epregisterClassMethod4(estrarray,operator-,estrarray,(const estrarray&),"-");
epregisterClassMethod3<estrarray>((estr& (estrarray::*)(const estr&)) &estrarray::add,"+=");
epregisterClassMethod2(ebasearray,addvar,void,(evar&));
epregisterClassMethod2(ebasearray,getvar,evar,(size_t));
epregisterClassMethod2(ebasearray,size,size_t,());
epregisterClassMethod2A(ebasearray,addvar,"add",void,(evar&));
epregisterClassMethod2A(ebasearray,getvar,"[]",evar,(size_t));
epregisterClass(etimer);
epregisterClassMethod(etimer,lap);
epregisterClassMethod(etimer,check);
epregisterClassMethod(etimer,reset);
epregisterClassMethod2(evararray,add,evar&,(const evar&));
epregisterClassMethod4(evararray,operator[],evar&,(size_t),"[]");
epregisterClass(efile);
epregisterClassCout(efile);
epregisterClassConstructor(efile,(const estr&));
epregisterClassConstructor(efile,(const estr&,const estr&));
epregisterClassMethod2(efile,open,bool,() const);
epregisterClassMethod2(efile,open,bool,(const estr&,const estr&));
epregisterClassMethod(efile,fileno);
epregisterClassMethod2D(efile,read,int,(estr&,long int) const,evararray(-1l));
epregisterClassMethod2(efile,read,evar,() const);
epregisterClassMethod(efile,readln);
epregisterClassMethod2(efile,write,int,(const estr&) const);
epregisterClassMethod2(efile,write,int,(const evar&) const);
epregisterClassProperty(efile,name);
epregisterClassMethod(efile,size);
epregisterClassMethod(efile,exists);
epregisterClassMethod(efile,basename);
epregisterClassMethod(efile,close);
epregisterClass(edir);
epregisterClassCout(edir);
epregisterClassConstructor(edir,(const estr&));
epregisterClassProperty(edir,dirs);
epregisterClassProperty(edir,files);
epregisterClass(estrarrayof<efile>);
epregisterClassInheritance(estrarrayof<efile>,ebasearrayof);
epregisterClassMethod(estrarrayof<efile>,size);
epregisterClassMethod4(estrarrayof<efile>,operator[],efile&,(const estr&),"[]");
epregisterClassMethod4(estrarrayof<efile>,operator[],efile&,(size_t),"[]");
epregisterClass(estrarrayof<edir>);
epregisterClassInheritance(estrarrayof<edir>,ebasearrayof);
epregisterClassMethod(estrarrayof<edir>,size);
epregisterClassMethod2(estrarrayof<edir>,keys,estr&,(size_t));
epregisterClassMethod2(estrarrayof<edir>,values,edir&,(size_t));
epregisterClassMethod4(estrarrayof<edir>,operator[],edir&,(const estr&),"[]");
epregisterClassMethod4(estrarrayof<edir>,operator[],edir&,(size_t),"[]");
epregisterFuncD(ls,evararray("."));
epregisterFuncD(cd,evararray("~"));
epregisterFunc(pwd);
epregisterFunc2(env,estrarray,());
epregisterClassMethod(ernd,uniform);
#ifdef EUTILS_HAVE_LIBGSL
epregisterClassMethod(ernd,gamma);
epregisterClassMethod(ernd,gaussian);
epregisterClassMethod(ernd,exponential);
epregisterClassMethod(ernd,geometric);
#endif
epregisterFunc2(grep,estr,(estr&,const eregexp&,int));
epregisterFunc3(getParser(),epinterpret,"eval");
epregisterFunc3(getParser(),varexec,"exec");
epregisterFunc3(getParser(),varprint,"print");
epregisterFunc3(getParser(),vartype,"type");
epregisterFunc3(getParser(),varaddress,"addr");
epregisterFunc2(serial,void,(const evar&,estr&));
epregisterFunc2(unserial,evar,(const estr&));
epregister(rnd);
epregister2(getSystem(),"sys");
epregisterClassMethodI(esystem,getTotalRam,"return total amount of RAM in system");
epregisterClassMethodI(esystem,getFreeRam,"return free amount RAM in system");
epregisterClassMethodI(esystem,getBufferRam,"return amount of RAM used by buffers");
epregisterClassMethodI(esystem,getMemLimit,"return maximum memory limit set for process");
}
