예제 #1
0
파일: Maker.cpp 프로젝트: jossk/OrangeC
std::string Maker::GetFileTime(const std::string &goal, const std::string &preferredPath, Time &timeval)
{
    std::string rv;
    if (goal.find_first_of(CmdFiles::DIR_SEP) != std::string::npos)
    {
        std::fstream fil(goal.c_str(), std::ios::in);
        if (fil != NULL)
        {
            fil.close();
            timeval = OS::GetFileTime(goal);
        }
    }
    else
    {
        std::string vpath = preferredPath + std::string(" .\\ ") + Eval::GetVPATH(goal);
        std::string sep = std::string(" ") + CmdFiles::PATH_SEP;
        while (vpath.size())
        {
            std::string cur = Eval::ExtractFirst(vpath, sep);
            if (cur[cur.size() -1] != CmdFiles::DIR_SEP[0])
                cur += CmdFiles::DIR_SEP;
            std::string name ;
            if (goal[0] != CmdFiles::DIR_SEP[0] && goal[1] != ':')
                name = cur + goal;
            else
                name = goal;
            if (cur != ".\\")
                filePaths[goal] = cur; // tentatively enter this as the goal path
                                    // this will collide if there are multiple paths and no file exists
                                    // and choose the last one
            std::fstream fil(name.c_str(), std::ios::in);
            if (fil != NULL)
            {
                fil.close();
                rv = cur; // return value is the path, with a slash on the end
                timeval = OS::GetFileTime(name);
                filePaths[goal] = cur;
                break;
            }
        }
    }
    if (ScanList(newFiles, goal) || ScanList(newFiles, rv + goal))
    {
        timeval = OS::GetCurrentTime();
    }
    else if (ScanList(oldFiles, goal) || ScanList(oldFiles, rv + goal))
    {
        timeval.Clear();
    }
    return rv;
}
예제 #2
0
/****************************************
function: writeToFile of WritingJSON

Inputs: N/A

Outputs: N/A

Description: read result vector and convert them into JSON and write them into txt file.
****************************************/
void WritingJSON::writeToFile(void){
	vector<result*>::iterator it;			//iterator of vector of pointers of result
	vector<listing*>::iterator il;			//iterator for listing vector in each result object
	vector<listing*> list;					//temp var to store listing of current result object in the loop
	string title;
	string manufacturer;
	string currency;
	string price;
	Json::FastWriter fast_writer;			//FastWriter function of json
	
	//cout<<"result set size is "<<res.size()<<endl;
	std::ofstream fil("result.txt", std::ios::out);							//generate result.txt file
																			//iterate the whole vector of pointers of result
	for(it = res.begin(); it != res.end(); it++){							
		Json::Value value;													//for each record of result, generate a new json data and according to the result object
		Json::Value arrayobj;
		value["product_name"] = (*it)->getPDname();
		list = (*it)->getList();
		//cout<<(*it)->getPDname()<<endl;
		
		for(il = list.begin(); il !=list.end(); il++){						//this loop is used to read the related listing of each result object and put them in array of json.
			Json::Value item;
			item["title"] = (*il)->getTit();
			item["manufacturer"] = (*il)->getManuf();
			item["currency"] = (*il)->getCur();
			item["price"] = (*il)->getPrice();
			arrayobj.append(item);
		}
		value["listing"] = arrayobj;
		
		fil<<reOrder(fast_writer.write(value))<<endl;						//convert json data to string and write into result.text
	}
	fil.close();
	
}
예제 #3
0
/****************************************
function: ProductDecode of ReadingJSON

Inputs: N/A 

Outputs: a vector which stores all addresses of product objects.

Description: open product file according to the product file path,
and read each line of JSON to convert it into a product object.
After this function, all product data is stored in vector and easy to headle with.
****************************************/
vector<product*> ReadingJSON::ProductDecode(void){
	//cout<<"123"<<endl;
	Json::Reader reader;
	std::vector<product*> opt;
	
	std::ifstream fil(product_path, std::ios::in);
    char line[10240]={0};
    std::string x = "";
	
    while(fil.getline(line, sizeof(line))){
    	std::stringstream st;
		st<<line;
    	x = st.str();
		Json::Value value;
		
    	if (reader.parse(x, value)){
			product *p = new product();

			(*p).setPDname(value["product_name"].asString());
			(*p).setManuf(value["manufacturer"].asString());
			(*p).setFamily(value["family"].asString());
			(*p).setModel(value["model"].asString());
			(*p).setAnn(value["announced-date"].asString());
			
			opt.push_back(p);
			
    	}
	}
	fil.close();
	return opt;
}
예제 #4
0
/****************************************
function: ListingDecode of ReadingJSON

Inputs: N/A 

Outputs: a vector which stores all addresses of listing objects.

Description: open listing file according to the listing file path,
and read each line of JSON to convert it into a listing object.
After this function, all listing data is stored in vector and easy to headle with.
****************************************/
vector<listing*> ReadingJSON::ListingDecode(void){
	Json::Reader reader;
    Json::Value value;
	vector<listing*> opt;
	
	std::ifstream fil(list_path, std::ios::in);
    char line[10240]={0};
    std::string x = "";
    while(fil.getline(line, sizeof(line))){
    	std::stringstream st;
		st<<line;
    	x = st.str();
		//cout<<x<<endl;
    	if (reader.parse(x, value)){
			listing *l = new listing();

			(*l).setTit(value["title"].asString());
			(*l).setManuf(value["manufacturer"].asString());
			(*l).setCur(value["currency"].asString());
			(*l).setPrice(value["price"].asString());

			opt.push_back(l);
			
    	}
	}
	fil.close();
	return opt;
}
예제 #5
0
파일: fir.cpp 프로젝트: dskinner/sndobj
int main(int argc, char** argv) {
 
   // lowpass response
   // cf = sr/10
   // trans bw = sr/10
   float max = 1.f;
   float min = 0.f;
   float cf = 0.1f;
   float tbw = 0.1f;
   
   // magnitude response curve
   float points[3]= {max,min,min};
   float lens[3]= {cf,tbw,1-(cf+tbw)};
   
   // using Hamming window
   // filter order = 3.33*sr/tbw
   int order = 333;
   HammingTable window(order, 0.54f);
   ImpulseTable imp(order,3, 1.f, points, lens, 0.f,&window); 
   
   // test signal wavetable
   HarmTable t1(1024, 50, SAW);
   SndWave  output("test.wav", OVERWRITE); /* output */
   Oscili oscil(&t1, 100.f, 32767.f);  /* test signal */
   Convol fil(&imp, &oscil, 16.f);  /* filter */

  int dur = 5;
  for(int i=0; i<dur*(DEF_SR/DEF_VECSIZE); i++) {
	oscil.DoProcess();
	fil.DoProcess();
	fil >> output;
  }
  return 0;
}
예제 #6
0
int File_inport::inport(Glib::ustring file) {
	//convert adress to file name
	int poz = file.rfind("/");
	Glib::ustring subor = Glib::ustring(file.c_str()+poz);
	File_load fil(file);
	if(fil.getType().compare(CUSTOMVIDEO)==0){
		return 1;
	}

	std::fstream vys;
	vys.open((confDir+subor).c_str(), std::fstream::in);
	if(vys.good()){
//		std::cout<<"exist"<<std::endl;
		return -1;
	}
	Glib::ustring command = "cp -n \"" + file + "\" " + confDir;
	if(system(command.c_str())!=0){
		return -2;
	}
	vys.close();
	vys.open(confFile.c_str(), std::fstream::out | std::fstream::app);
	vys<<confDir+subor<<std::endl;
	vys.close();
	return 0;
}
예제 #7
0
GdbServer::GdbServer(QObject *parent, QStLink * st, bool notverify, int portnumber, QByteArray & file) :
    QObject(parent),
    stlink(st),
    server(new QTcpServer(this)),
    port(portnumber),
    NotVerify(notverify),
    VeriFile(file)
{
    Q_ASSERT(stlink);

    //VeriFile = "/home/kubanec/workspace/ARMCM4-STM32F407-DISCOVERY/build/test.bin";
    new Kelnet(*stlink,parent);


    connect(server,SIGNAL(newConnection()),this,SLOT(newConnection()));
    connect(stlink,SIGNAL(CoreHalted(quint32)),this,SLOT(CoreHalted(quint32)));
    bool ok = server->listen(QHostAddress::Any,port);


    printMCUInfo();

    QFile fil(VeriFile);
    if (fil.exists())
    {
        qDebug() << QString("Binary file: " + fil.fileName());
        //VeriFile.append(fil.absolutePath());
    }

    if (ok)
    {
        INFO(QString("Listening on port %1").arg(port));
        qDebug() << QString("Listening on port %1").arg(port);
    }
    else
    {
        ERR("Cannot open listening port");
    }

    connect(stlink,SIGNAL(Erasing(int)),this,SLOT(Erasing(int)));
    connect(stlink,SIGNAL(Flashing(int)),this,SLOT(Flashing(int)));
    connect(stlink,SIGNAL(Verifing(int)),this,SLOT(Verify(int)));

    threaed.insert(THD_MAIN,QStLink::Thread);
    threaed.insert(THD_HAN,QStLink::Handler);
    threaed.insert(0,QStLink::Unknown);
    QTimer * timer = new QTimer;
    timer->start(1000);
    connect(timer,SIGNAL(timeout()),this,SLOT(timeout()));
    soc = NULL;

    qsThreadInfo = 0;

    switched = false;
    std::cout << std::endl << std::flush;
}
예제 #8
0
QString readTemplate(const QString& template_file_name){
    // ://templates/numero.js

    QFile fil(template_file_name);
    if (!fil.open(QIODevice::ReadOnly | QIODevice::Text))
        return "";

    QTextStream file_utf8(&fil);
    return file_utf8.readAll();

}
예제 #9
0
wxTreeItemId DirectoryTree::AddChild(const wxTreeItemId& tidParent, const wxString& sPath)
  {
  DirectoryTreeItem * dti = new DirectoryTreeItem(sPath);
  
	wxTreeItemId tid;
	if(sPath == FILE_SYSTEM_ROOT)
		{
		// TBI: ASSERT tree is empty
		tid = AddRoot(FILE_SYSTEM_ROOT, 0, 1, dti);
		}
  else
		{
		if(!tidParent.IsOk())
			{
      wxLogDebug(wxT("DirectoryTree::AddChild(): invalid parent wxTreeItemId %u"), (int) tidParent);
			return wxTreeItemId();
			}
#ifdef __WXMSW__
    // Treat drives differently
		wxString sDirectory;
    if(sPath.Length() == 3)
      sDirectory = sPath;
    else
      {
		  wxFileName fil(sPath);
		  sDirectory = fil.GetFullName();
      }
#else
		wxFileName fil(sPath);
		wxString sDirectory = fil.GetFullName();
#endif // def __WXMSW__
		tid = AppendItem(tidParent, sDirectory, 0, 1, dti);
		}

	// Show the '+' button
	SetItemHasChildren(tid, true);
	
  return tid;
  }
예제 #10
0
int main(int, char *argv[]) {
  unsigned char *tab=new unsigned char[24];
  for(int i=0; i<3*8; i+=3) {
    tab[i]=tab[i+1]=tab[i+2]=((char)~0)<<(i/3);
  }
  int w=3, h=8;
  fil(tab, w, h, 3);
  /**
   *in gdb ./main: 
   (gdb) disass main
   shows that arguments in 64-bit goes to registers
      0x0000000000400934 <+93>:    mov    -0x38(%rbp),%edx
   0x0000000000400937 <+96>:    mov    -0x34(%rbp),%ebx
   0x000000000040093a <+99>:    lea    -0x30(%rbp),%rax
   0x000000000040093e <+103>:   mov    $0x3,%ecx
   0x0000000000400943 <+108>:   mov    %ebx,%esi
   0x0000000000400945 <+110>:   mov    %rax,%rdi
   0x0000000000400948 <+113>:   callq  0x4008c4 <_Z3filPhiii>
   (gdb) disass fil
   shows that even simple function stores those arguments just after being called on stack
   Dump of assembler code for function _Z3filPhiii:
   0x00000000004008c4 <+0>:     push   %rbp
   0x00000000004008c5 <+1>:     mov    %rsp,%rbp
   0x00000000004008c8 <+4>:     mov    %rdi,-0x8(%rbp)
   0x00000000004008cc <+8>:     mov    %esi,-0xc(%rbp)
   0x00000000004008cf <+11>:    mov    %edx,-0x10(%rbp)
   0x00000000004008d2 <+14>:    mov    %ecx,-0x14(%rbp)
   0x00000000004008d5 <+17>:    leaveq
   0x00000000004008d6 <+18>:    retq
   :next steps examine stack: 
   (gdb) x/w $rbp-0x8
   0x7fffffffea08: 4294961728
   (gdb) x/w $rbp-0xc
   0x7fffffffea04: 3
   (gdb) x/w $rbp-0x10
   0x7fffffffea00: 4
   (gdb) x/w $rbp-0x14
   0x7fffffffe9fc: 3
   function arguments are on stack and in registers 
%rdi(buf), 
%esi(w), 
%edx(h), 
%ecx(bpp) 
it is useful for writing asm 64-bit insertions to 64-bit c++
   **/
  print(tab, w*h);
  filter(tab, w, h, 3);
  print(tab, w*h);
  return 0;
} 
예제 #11
0
void WidgetToolBar::SaveDataToFile()
{
    QString cesta = QFileInfo( QCoreApplication::applicationFilePath() ).absolutePath();
    cesta += "/jmeno.txt";
    QFile fil(cesta);
    if (!fil.open(QFile::WriteOnly))
        return;

    fil.write(ui->editName->text().toUtf8() + '\n');
    fil.write(ui->spinCislo->text().toUtf8()+ '\n');
    fil.write(ui->spinDovolena->text().toUtf8()+ '\n');

    fil.close();
}
예제 #12
0
파일: mainwindow.cpp 프로젝트: gen1izh/cpp
/**
  * Open image file and parse it by MD
  */
void MainWindow::on_pbOpenImageFile_clicked() {
    quint8              data;
    int                 currPosX, currPosY;

    doperations.init();

    QString tmp = QDir::currentPath();
    QFile fil("imgpath.txt");
    if( fil.open( QIODevice::ReadOnly ) ) {
        QDataStream stream(&fil);
        stream.setVersion (QDataStream::Qt_4_2) ;
        stream >> tmp;
        fil.close();
    }
예제 #13
0
Kart::Kart( QString url )
{
    kou = 0;
    QFile fil( url );

    if ( fil.open( QIODevice::ReadOnly | QIODevice::Text ) )
    {
        QTextStream in( &fil );

        // Putter pekere til klosser inn i en 2D QList, som forestiller et 2D kart.
        for ( int i = 0; !in.atEnd(); i++ )
        {
            QString line = fil.readLine();

            // # er kommentarfelt, og $ er ekstrainformasjon om kartet. De hopper vi over nå.
            if ( line.at( 0 ) != '#' && line.at( 0 ) != '$' )
            {
                QList<QPixmap*> tmpliste;

                for ( int j = 0; j < line.size(); j++ )
                {
                    tmpliste.append( finnUrl( line.at( j ).toAscii(), j, bildekart.size() ) );
                }

                bildekart.append( tmpliste );
            }

            else if ( line.at( 0 ) == '$' )
            {
                if ( line.startsWith( "$bakgrunn" ) )
                {
                    QString bg = line.remove( "$bakgrunn=" );
                    bg = bg.remove( "\n" );
                    bakgrunn.load( bg );
                }

                else if ( line.startsWith( "$tid" ) )
                {
                    QString bg = line.remove( "$tid=" );
                    bg = bg.remove( "\n" );
                    tid = bg.toInt();
                }
            }
        }
    }

    fil.close();
}
예제 #14
0
bool Entity::executeComment(){

    QFile fil(fileInfo.absoluteFilePath());
    if (!fil.open(QIODevice::ReadOnly | QIODevice::Text))
        return -1;

    QTextStream file_utf8(&fil);
    file_utf8.setAutoDetectUnicode(true);

    Comment dummyStartTag(DUMMY,-1,-1);
    Comment dummyEndTag(DUMMY,fil.size(),fil.size());

    qDebug() << fil.size();

    QBuffer mem;
    mem.open(QBuffer::WriteOnly|QBuffer::Text);
    handleTag(&dummyStartTag, &dummyEndTag, file_utf8,mem );
    mem.close();

    check();

    QFileInfo outputfileInfo(outputSite,fileInfo.baseName()+".html");

    QFile output(outputfileInfo.absoluteFilePath());

    if (!output.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate))
        return -1;

    outputStringList(output,static_header_1);

    if (!embedded_styles.isEmpty()){
        output.write(QString("<style>").toUtf8());
        outputStringList(output,embedded_styles);
        output.write(QString("</style>").toUtf8());
    }

    outputStringList(output,static_header_2);

    output.write(mem.buffer());

    generatePageFooter(output);

    output.close();

}
예제 #15
0
ExperimentModel::ExperimentModel(QDir dir,QObject *parent)
	: QAbstractListModel(parent), dir(dir)
{
	qDebug() << dir;
	QFileInfoList folders = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);

	for (int i = 0; i < folders.size(); ++i) {
		qDebug() << folders[i].absoluteFilePath();
		QFileInfoList fil(QDir(folders[i].absoluteFilePath()).entryInfoList(
			QStringList("*.ebs2")));
		if (fil.size() > 0) {
			qDebug() << fil[0].absoluteFilePath();
			this->insertRow(this->rowCount(), *new Experiment(QFileInfo(fil[0].absoluteFilePath()), this));
		}
	}

	qDebug() << "ExperimentModel construction";
}
예제 #16
0
void DocumentsDir::generateTemplateDir()
{
   QFileInfoList fil( QDir(":/templates/").entryInfoList() );
   QDir templatesDir( getTemplatesDirName() );

   if( !templatesDir.mkpath( "." ) )
   {
      return;
   }

   foreach( const QFileInfo &fi, fil )
   {
      QString srcFile( fi.absoluteFilePath() );
      QString destFile( templatesDir.absoluteFilePath( fi.fileName() ) );
      if( QFile::copy( srcFile, destFile ) )
      {
         QFile::setPermissions( destFile, QFile::permissions( destFile ) | QFile::WriteUser );
      }
   }
예제 #17
0
int main(int argc, char *argv[])
{
	if (argc < 2)
		return -1;
	try
	{
		File fil("httpget.out", "w");
		StdoutLog log;
		SocketHandler h(&log);
		HttpGetSocket sock(h, argv[1], "empty.html");
		sock.SetTrafficMonitor(&fil);
		h.Add(&sock);
		while (h.GetCount())
			h.Select();
	}
	catch (const Exception& e)
	{
		std::cerr << e.ToString() << std::endl;
	}
}
예제 #18
0
void Entity::extractCommentPosition(){

    QFile fil(fileInfo.absoluteFilePath());
    if (!fil.open(QIODevice::ReadOnly | QIODevice::Text))
        return ;

    QTextStream file_utf8(&fil);
    file_utf8.setAutoDetectUnicode(true);


    QChar c1='\0',c2='\0',c3='\0',c4='\0';
    bool inComment=false;
    QByteArray qb;
    qint64 commentStart;
    qint64 commentEnd;

    while (!file_utf8.atEnd()) {
        c4=c3;
        c3=c2;
        c2=c1;
        file_utf8 >> c1;
        if (!inComment && (c4=='<')&& (c3=='!')&&(c2=='-')&&(c1=='-')){
            inComment=true;
            qb.clear();
            qb.append("<!--");
            commentStart=file_utf8.pos()-4;
        } else if (inComment && (c3=='-')&& (c2=='-')&&(c1=='>')){
            inComment=false;
            commentEnd=file_utf8.pos()-1;
            qb.append(">");
            createComment(qb,commentStart,commentEnd);
        }
        else {
            if (inComment){
                qb.append(c1);
            }
        }
    }

    qDebug() << file_utf8.pos();
}
예제 #19
0
void WidgetToolBar::LoadDataFromFile()
{
    QString cesta = QFileInfo( QCoreApplication::applicationFilePath() ).absolutePath();
    cesta += "/jmeno.txt";
    QFile fil(cesta);
    if (!fil.open(QFile::ReadOnly))
        return;

    QByteArray buffer;
    buffer = fil.readLine().trimmed();
    ui->editName->setText(QString::fromUtf8(buffer));
    buffer = fil.readLine().trimmed();
    bool ok;
    ui->spinCislo->setValue(buffer.toInt(&ok));
    Q_ASSERT(ok);
    buffer = fil.readLine().trimmed();
    ui->spinDovolena->setValue(buffer.toInt(&ok));
    Q_ASSERT(ok);

    fil.close();
}
예제 #20
0
void Window::readWriteScore()
{
    QFile fil("score.dat");
    fil.open(QIODevice::ReadOnly);
    QDataStream in(&fil);
    str;
    in >> str;

    QFile files("score.dat");
    files.open(QIODevice::WriteOnly);
    QDataStream out(&files);

    nome = edit->text();
    scoreTxt = QString::number(scr);
    txtSave = str + "\n" + nome + " - " + scoreTxt;

    out << QString(txtSave);
    qDebug() << "Score";
    qDebug() << txtSave;

    newWindow->close();

    chamaOpenScore();
}
예제 #21
0
void SaveISISNexus::selog() {
  // find log files with names <RawFilenameWithoutExt>_LogName.txt and save them
  // in potentialLogFiles
  std::vector<std::string> potentialLogFiles;
  Poco::File l_path(inputFilename);
  std::string l_filenamePart = Poco::Path(l_path.path()).getFileName();
  std::string::size_type i = l_filenamePart.find_last_of('.');
  if (i != std::string::npos) // remove the file extension
  {
    l_filenamePart.erase(i);
  }
  std::string base_name = l_filenamePart;
  boost::regex regex(l_filenamePart + "_.*\\.txt",
                     boost::regex_constants::icase);
  Poco::DirectoryIterator end_iter;
  for (Poco::DirectoryIterator dir_itr(Poco::Path(inputFilename).parent());
       dir_itr != end_iter; ++dir_itr) {
    if (!Poco::File(dir_itr->path()).isFile())
      continue;

    l_filenamePart = Poco::Path(dir_itr->path()).getFileName();

    if (boost::regex_match(l_filenamePart, regex)) {
      potentialLogFiles.push_back(dir_itr->path());
    }
  }

  Progress prog(this, 0.5, 1, potentialLogFiles.size());

  NXmakegroup(handle, "selog", "IXselog");
  NXopengroup(handle, "selog", "IXselog");

  // create a log for each of the found log files
  std::size_t nBase = base_name.size() + 1;
  for (auto &potentialLogFile : potentialLogFiles) {
    std::string logName = Poco::Path(potentialLogFile).getFileName();
    logName.erase(0, nBase);
    logName.erase(logName.size() - 4);
    if (logName.size() > 3) {
      std::string icp = logName.substr(0, 3);
      std::transform(icp.begin(), icp.end(), icp.begin(), toupper);
      if (icp == "ICP")
        continue;
    }

    std::ifstream fil(potentialLogFile.c_str());
    if (!fil) {
      g_log.warning("Cannot open log file " + potentialLogFile);
      continue;
    }

    start_time_str[10] =
        ' '; // make it compatible with boost::posix_time::ptime
    boost::posix_time::ptime start_time(
        boost::posix_time::time_from_string(start_time_str));
    start_time_str[10] = 'T'; // revert
    std::vector<float> time_vec;
    std::vector<std::string> str_vec;
    std::vector<float> flt_vec;
    std::string line;
    bool isNotNumeric = false;
    while (std::getline(fil, line)) {
      if (line.empty())
        continue;
      std::string date_time_str = line.substr(0, 19);
      date_time_str[10] = ' ';
      boost::posix_time::ptime time(
          boost::posix_time::time_from_string(date_time_str));
      boost::posix_time::time_duration dt = time - start_time;
      time_vec.push_back(float(dt.total_seconds()));
      std::istringstream istr(line.substr(20));
      // check if the data are numeric then save them in flt_vec
      if (!isNotNumeric) {
        float flt;
        istr >> flt;
        if (istr.bad() || istr.fail()) {
          isNotNumeric = true;
        } else {
          flt_vec.push_back(flt);
        }
      }
      str_vec.push_back(istr.str());
    }
    fil.close();
    NXmakegroup(handle, &logName[0], "IXseblock");
    NXopengroup(handle, &logName[0], "IXseblock");

    {
      saveString("vi_name", " ");
      saveString("set_control", " ");
      saveString("read_control", " ");
      float tmp = 0.0;
      saveFloatOpen("setpoint", &tmp, 1);
      putAttr("units", "mV");
      close();
    }

    NXmakegroup(handle, "value_log", "NXlog");
    NXopengroup(handle, "value_log", "NXlog");

    saveFloatOpen("time", &time_vec[0], static_cast<int>(time_vec.size()));
    putAttr("start", start_time_str);
    putAttr("units", "seconds");
    close();

    if (flt_vec.size() == str_vec.size()) {
      saveFloatOpen("value", &flt_vec[0], static_cast<int>(flt_vec.size()));
    } else {
      saveStringVectorOpen("value", str_vec);
    }
    putAttr("units", " ");
    close();

    saveString("name", " ");

    NXclosegroup(handle); // value_log

    NXclosegroup(handle); // logName

    prog.report();
  }
예제 #22
0
/**
  * Create and write run logs form \<RawFilename\>_ICPstatus.txt log file
  */
void SaveISISNexus::runlog() {
  progress(0);
  std::string ICPstatus_filename = inputFilename;
  std::string ICPevent_filename;
  std::string::size_type i = ICPstatus_filename.find_last_of('.');
  if (i != std::string::npos) // remove the file extension
  {
    ICPstatus_filename.erase(i);
  }
  ICPevent_filename = ICPstatus_filename + "_ICPevent.txt";
  ICPstatus_filename += "_ICPstatus.txt";

  std::ifstream fil(ICPstatus_filename.c_str());
  if (!fil) {
    g_log.warning("Cannot find the ICPstatus file. Skipping runlog");
    progress(0.5);
    return;
  }

  std::vector<float> time_vec;
  std::vector<int> period_vec;
  std::vector<int> is_running_vec;
  std::vector<int> is_waiting_vec;
  std::vector<int> good_frames_vec;
  std::vector<int> raw_frames_vec;
  std::vector<int> monitor_sum_1_vec;
  std::vector<int> total_counts_vec;
  std::vector<int> run_status_vec;
  std::vector<float> proton_charge_vec;
  std::vector<float> proton_charge_raw_vec;
  std::vector<float> dae_beam_current_vec;
  std::vector<float> count_rate_vec;
  std::vector<float> np_ratio_vec;

  start_time_str[10] = ' '; // make it compatible with boost::posix_time::ptime
  boost::posix_time::ptime start_time(
      boost::posix_time::time_from_string(start_time_str));
  start_time_str[10] = 'T'; // revert
  std::string line;
  std::getline(fil, line); // skip the first line
  while (std::getline(fil, line)) {
    std::string date_time_str;
    int period;
    int is_running;
    int is_waiting;
    int good_frames;
    int raw_frames;
    int monitor_sum_1;
    int total_counts;
    float proton_charge;
    float proton_charge_raw;
    float dae_beam_current;
    float count_rate;
    float np_ratio;
    std::istringstream istr(line);
    istr >> date_time_str >> period >> is_running >> is_waiting >>
        good_frames >> raw_frames >> proton_charge >> proton_charge_raw >>
        monitor_sum_1 >> dae_beam_current >> total_counts >> count_rate >>
        np_ratio;
    date_time_str[10] = ' ';
    boost::posix_time::ptime time(
        boost::posix_time::time_from_string(date_time_str));
    boost::posix_time::time_duration dt = time - start_time;
    time_vec.push_back(float(dt.total_seconds()));
    period_vec.push_back(period);
    is_running_vec.push_back(is_running);
    is_waiting_vec.push_back(is_waiting);
    good_frames_vec.push_back(good_frames);
    raw_frames_vec.push_back(raw_frames);
    monitor_sum_1_vec.push_back(monitor_sum_1);
    total_counts_vec.push_back(total_counts);
    proton_charge_vec.push_back(proton_charge);
    proton_charge_raw_vec.push_back(proton_charge_raw);
    dae_beam_current_vec.push_back(dae_beam_current);
    count_rate_vec.push_back(count_rate);
    np_ratio_vec.push_back(np_ratio);
  }
  fil.close();

  run_status_vec.resize(time_vec.size());
  std::transform(is_running_vec.begin(), is_running_vec.end(),
                 run_status_vec.begin(), std::bind2nd(std::plus<int>(), 1));

  NXmakegroup(handle, "runlog", "IXrunlog");
  NXopengroup(handle, "runlog", "IXrunlog");

  int time_vec_size = static_cast<int>(time_vec.size());

  write_runlog("period", &time_vec[0], &period_vec[0], NX_INT32, time_vec_size,
               "none");
  write_runlog("is_running", &time_vec[0], &is_running_vec[0], NX_INT32,
               time_vec_size, "none");
  write_runlog("is_waiting", &time_vec[0], &is_waiting_vec[0], NX_INT32,
               time_vec_size, "none");
  write_runlog("good_frames", &time_vec[0], &good_frames_vec[0], NX_INT32,
               time_vec_size, "frames");
  write_runlog("raw_frames", &time_vec[0], &raw_frames_vec[0], NX_INT32,
               time_vec_size, "frames");
  write_runlog("monitor_sum_1", &time_vec[0], &monitor_sum_1_vec[0], NX_INT32,
               time_vec_size, "counts");
  write_runlog("total_counts", &time_vec[0], &total_counts_vec[0], NX_INT32,
               time_vec_size, "counts");
  write_runlog("proton_charge", &time_vec[0], &proton_charge_vec[0], NX_FLOAT32,
               time_vec_size, "uAh");
  write_runlog("proton_charge_raw", &time_vec[0], &proton_charge_raw_vec[0],
               NX_FLOAT32, time_vec_size, "uAh");
  write_runlog("dae_beam_current", &time_vec[0], &dae_beam_current_vec[0],
               NX_FLOAT32, time_vec_size, "uAh");
  write_runlog("count_rate", &time_vec[0], &count_rate_vec[0], NX_FLOAT32,
               time_vec_size, "counts");
  write_runlog("np_ratio", &time_vec[0], &np_ratio_vec[0], NX_FLOAT32,
               time_vec_size, "nones");

  write_runlog("run_status", &time_vec[0], &run_status_vec[0], NX_INT32,
               time_vec_size, "none");

  // read in ICPevent file and create icp_event log
  std::ifstream icpevent_fil(ICPevent_filename.c_str());
  if (!icpevent_fil) {
    g_log.warning("Cannot find the ICPevent file");
    progress(0.5);
    return;
  }

  time_vec.clear();
  std::vector<std::string> event_vec;
  while (std::getline(icpevent_fil, line)) {
    if (line.empty())
      continue;
    std::string date_time_str = line.substr(0, 19);
    date_time_str[10] = ' ';
    boost::posix_time::ptime time(
        boost::posix_time::time_from_string(date_time_str));
    boost::posix_time::time_duration dt = time - start_time;
    time_vec.push_back(float(dt.total_seconds()));
    event_vec.push_back(line.substr(20));
  }
  icpevent_fil.close();

  NXmakegroup(handle, "icp_event", "NXlog");
  NXopengroup(handle, "icp_event", "NXlog");

  saveFloatOpen("time", &time_vec[0], static_cast<int>(time_vec.size()));
  putAttr("start", start_time_str);
  putAttr("units", "seconds");
  close();

  saveStringVectorOpen("value", event_vec, 72);
  putAttr("units", " ");
  close();
  NXclosegroup(handle); // icp_event

  NXclosegroup(handle); // runlog
  progress(0.5);
}
void TorrentDownloader::WriteTorrent(void){

	// Do some sanity checks
	// TODO: evaluate if this is the right thing to do
	if(!this->status==FAILED){
		syslog(LOG_NOTICE,"Torrent had failures, not writing torrent data");
		return;
	}

	// Find directory to write to
	string wp="/home/"+User::UIDToUser(this->user);
	string suf="/torrents/";
	try{
		FtdConfig& cfg=FtdConfig::Instance();
		suf="/"+cfg.GetString("torrent","torrentdir")+"/";
	}catch(std::runtime_error& err){
		syslog(LOG_ERR,"Unable to read torrent dir");
	}

	if(!Stat::DirExists(wp+suf)){
		FileUtils::MkPath(wp+suf);
		FileUtils::Chown(wp+suf,this->user,"users");
		DirWatcher::Instance().AddWatch(wp+suf);
	}

	string fn=wp+suf+".ftdtrXXXXXX";

	int fd;
	char *pt=(char*)malloc(fn.length()+1);
	if(!pt){
		syslog(LOG_CRIT,"Failed to allocate memory for path %s because %m"
				,wp.c_str());
		return;
	}
	sprintf(pt,"%s",fn.c_str());
	if((fd=mkstemp(pt))<0){
		syslog(LOG_ERR,"Failed to create torrent file in %s because %m",fn.c_str());
		return;
	}

	this->torrentfilename=pt;
	FILE* file=fdopen(fd,"w");
	// This is definetly not portable....
	__gnu_cxx::stdio_filebuf<char> fb(file,std::ios_base::out);
	iostream fil(&fb);

	fil<< m_dlstream.str();
	fil.flush();
	fb.close();

	// Rewind stream for output later use
	m_dlstream.seekg (0, ios::beg);


	uid_t user=this->user==0xffff?0:this->user;
	gid_t group=this->group==0xffff?0:this->group;
	if(chown(pt,user,group)){
		syslog(LOG_NOTICE,"Failed to chown file %s because %m",wp.c_str());
	}
	free(pt);
	close(fd);
}
예제 #24
0
	float operator()(float in){
		return delay(
			fil( delay() + in )
		);
	}
예제 #25
0
void calcu(int x,int y)
{if(r==15)
{sa[0]=x-r;sa[1]=y;sa[2]=x+r;sa[3]=y;}
if(r==30)
{sa[0]=x-r/2;sa[1]=y;sa[2]=x+r+r/2;sa[3]=y;
if(x>300)
{sa[0]=x-r-r/2;sa[2]=x+r/2;}}
if(r==60)
{sa[0]=x-15;sa[1]=y;sa[2]=x+105;sa[3]=y;
if(x>100)
{sa[0]=x-40;sa[2]=x+80;  }
if(x>200)
{sa[0]=x-60;sa[2]=x+60;}
if(x>300)
{sa[0]=x-80;sa[2]=x+40; }
if(x>=450)
{sa[0]=x-105;sa[2]=x+15;}}
if(p==0)
{sa1[0]=(sa[0]+sa[2])/2;sa1[1]=y-5;}
if(p==1)
{if(sa1[0]>=sa[0]&&sa1[0]<=sa[2])
 if(sa1[1]+r1>=sa[1])
 {a=sa[0]+r;
 sa1[2]=(sa1[0]-a)/4;
 sa1[3]=-sa1[3];}
}
if(p==1)
{if(sa1[0]-r1<=40)
 sa1[2]=-sa1[2];
 if(sa1[1]-r1<=40)
 {
 sa1[3]=-sa1[3];  }
 if(sa1[0]+r1>=600)
 sa1[2]=-sa1[2];
}

if(p==1)
{for(i=0;i<30;i++)
 { if(bool3[i]==1)
   {   a=bool1[i]-sa1[0];
       if(a<0)
       a=-a;
       a=a*a;
      b=bool2[i]-sa1[1];
      if(b<0)
      b=-b;
      b=b*b;
      c=a+b;
      c=sqrt(c);
      a=(r1+28);
     if(c<=a)
     {bool3[i]=0;d=d-5;score=score+50;
     if(bool4[i]!=0)
     {sin1[kk]=bool1[i];sin2[kk]=bool2[i];sin3[kk]=bool4[i];
      kk++; }   }

   }
 }
 if(d<5)
 {d=powe;sa1[3]=-sa1[3];}
}
if(p==1)
{a=0;
for(i=0;i<30;i++)
if(bool3[i]==0)
a=a+1;
if(a>10)
{powe=10;oo=10;}
if(a>20)
{powe=15;oo=15;}
if(a>25)
{powe=20;oo=20;}
if(a==30)
{ lave=lave+1;
  switch(lave)
  {case 1:bo2();break;
  case 2:bo3();break;
  case 3:bo4();break;
  case 4:bo5();break;
  case 5:outtextxy(40,40,"YOU WON THE GAME AND YOUR SCORE:");
	 printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n          %ld",score);
	 delay(5000);
	 getch();
	 fil();
	 li=0;
	  break;
  }
   get();}
}
if(p==1)
{if(sa1[1]>=460)
 { outtextxy(150,350,"LIFE LOSE");
   li=li-1;
   delay(5000);
   if(li==0)
   {outtextxy(370,150,"GAME OVER");
    outtextxy(380,250,"YOUR SCORE");
    printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n             %ld",score);
    delay(4000);

    fil();
	   }
   if(li!=0)
   {get();  }
	    }
  }
if(p==1)
{sa1[0]=sa1[0]+sa1[2];
sa1[1]=sa1[1]+sa1[3];
}
   }
void ConfigManager::Read() {
	wxTextFile fil(filename);
	if (!fil.Exists()) return;
	fil.Open();
	wxString key, value;
	long l;
	for ( wxString str = fil.GetFirstLine(); !fil.Eof(); str = fil.GetNextLine() ) {
		if (str[0]=='#') {
			continue;
		} else {
			key=str.BeforeFirst('=');
			value=str.AfterFirst('=');
			if (key=="version") { value.ToLong(&l); version=l; lang.Reset(version); }
			else if (key=="font_size") { value.ToLong(&l); font_size=l; }
			else if (key=="tabWidth") { value.ToLong(&l); tabw=l; }
			else if (key=="size_x") { value.ToLong(&l); size_x=l; }
			else if (key=="size_y") { value.ToLong(&l); size_y=l; }
			else if (key=="pos_x") { value.ToLong(&l); pos_x=l; }
			else if (key=="pos_y") { value.ToLong(&l); pos_y=l; }
			else if (key=="debug_port") { value.ToLong(&l); debug_port=l; }
			else if (key=="comm_port") { value.ToLong(&l); comm_port=l; }
			else if (key=="use_psterm") use_psterm=utils->IsTrue(value);
			else if (key=="use_dark_psterm") use_dark_psterm=utils->IsTrue(value);
			else if (key=="check_for_updates") check_for_updates=utils->IsTrue(value);
			else if (key=="fixed_port") fixed_port=utils->IsTrue(value);
			else if (key=="stepstep_tspeed") { value.ToLong(&l); stepstep_tspeed=l; }
			else if (key=="rt_syntax") rt_syntax=utils->IsTrue(value);
			else if (key=="smart_indent") smart_indent=utils->IsTrue(value);
			else if (key=="show_commands") show_commands=utils->IsTrue(value);
			else if (key=="show_vars") show_vars=utils->IsTrue(value);
			else if (key=="show_opers") show_opers=utils->IsTrue(value);
			else if (key=="show_debug_panel") show_debug_panel=utils->IsTrue(value);
			else if (key=="show_toolbar") show_toolbar=utils->IsTrue(value);
			else if (key=="auto_quickhelp") auto_quickhelp=utils->IsTrue(value);
			else if (key=="calltip_helps") calltip_helps=utils->IsTrue(value);
			else if (key=="autocomp") autocomp=utils->IsTrue(value);
			else if (key=="highlight_blocks") highlight_blocks=utils->IsTrue(value);
			else if (key=="autoclose") autoclose=utils->IsTrue(value);
			else if (key=="shape_colors") shape_colors=utils->IsTrue(value);
			else if (key=="colour_sintax") colour_sintax=utils->IsTrue(value);
			else if (key=="use_colors") use_colors=utils->IsTrue(value);
			else if (key=="animate_gui") animate_gui=utils->IsTrue(value);
			else if (key=="reorganize_for_debug") reorganize_for_debug=utils->IsTrue(value);
			else if (key=="images_path") images_path=value;
			else if (key=="help_dir") help_dir=value;
			else if (key=="proxy") proxy=value;
			else if (key=="profiles_dir") profiles_dir=value;
			else if (key=="profile") profile=value;
			else if (key=="examples_dir") examples_dir=value;
			else if (key=="last_dir") last_dir=value;
			else if (key=="temp_dir") temp_dir=value;
//			else if (key=="pseint_command") pseint_command=value;
//			else if (key=="psterm_command") psterm_command=value;
//			else if (key=="psexport_command") psexport_command=value;
//			else if (key=="psdrawe_command") psdrawe_command=value;
//			else if (key=="psdraw3_command") psdraw3_command=value;
			else if (key=="terminal") { tty_command=value; }
			else if (key=="history") last_files.Add(value);
			else lang.ProcessConfigLine(key.c_str(),value.c_str());
		}
	}
	fil.Close();
	LoadProfile(profile); 
	lang.Fix();
	if (version<20130805) use_psterm=true;
}
예제 #27
0
int main(int argc, char**argv)
{
	try
	{
		if (argc!=2)
		{
			std::cerr << "Usage: " << argv[0] << " <DATASET.rawlog>\n";
			return 1;
		}


		std::cout << "Opening: " << argv[1] << std::endl;
		mrpt::io::CFileGZInputStream  fil(argv[1]);
		bool rawlog_eof = false;

		pcl::visualization::CloudViewer viewer("Cloud Viewer from MRPT's rawlog");

		//This will only get called once
		viewer.runOnVisualizationThreadOnce (viewerOneOff);

		//This will get called once per visualization iteration
		viewer.runOnVisualizationThread (viewerUpdate);

		while (!viewer.wasStopped ())
		{
			mrpt::obs::CActionCollection::Ptr	actions;
			mrpt::obs::CSensoryFrame::Ptr		SF;
			mrpt::obs::CObservation::Ptr			obs;

			if (!rawlog_eof)
			{
				if (!mrpt::obs::CRawlog::getActionObservationPairOrObservation(fil, actions, SF, obs,rawlogEntry))
				{
					rawlog_eof = true;
					std::cerr << "End of rawlog file!! Close the window to exit\n";
				}
				else
				{
					// Can generate a point cloud from this data?
					// TODO: Process Kinect observations differently to extract RGB data.
					mrpt::maps::CPointsMap::Ptr  new_map;
					if (SF)
					{
						new_map = mrpt::make_aligned_shared<mrpt::maps::CSimplePointsMap>();
						// new_map->insertionOptions.minDistBetweenLaserPoints = 0;
						SF->insertObservationsInto(new_map);
					}
					else if (obs)
					{
						new_map = mrpt::make_aligned_shared<mrpt::maps::CSimplePointsMap>();
						// new_map->insertionOptions.minDistBetweenLaserPoints = 0;
						new_map->insertObservation(obs.get());
					}

					if (new_map)
					{
						pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud (new pcl::PointCloud<pcl::PointXYZRGB>);

						// Convert MRPT point maps -> PCL point cloud.
						new_map->getPCLPointCloud(*cloud);

						{  // Mutex protected
							std::lock_guard<std::mutex> lock(td_cs);
							td.new_timestamp = mrpt::system::now();
							td.new_cloud = cloud;
						}

						std::this_thread::sleep_for(30ms);  // Delay to allow the point cloud to show up.
					}

				}
			}

			std::this_thread::sleep_for(1ms);
		}
		return 0;
	}
	catch (std::exception &e)
	{
		std::cerr << e.what() << std::endl;
		return 1;
	}
}
예제 #28
0
    /** Get a workspace identified by an InputData structure. 
      * @param data :: InputData with name and either spec or i fields defined. 
      * @return InputData structure with the ws field set if everything was OK.
      */
    PlotPeakByLogValue::InputData PlotPeakByLogValue::getWorkspace(const InputData& data)
    {
      InputData out(data);
      if (API::AnalysisDataService::Instance().doesExist(data.name))
      {
        DataObjects::Workspace2D_sptr ws = boost::dynamic_pointer_cast<DataObjects::Workspace2D>(
          API::AnalysisDataService::Instance().retrieve(data.name));
        if (ws)
        {
          out.ws = ws;
        }
        else
        {
          return data;
        }
      }
      else
      {
        std::ifstream fil(data.name.c_str());
        if (!fil)
        {
          g_log.warning() << "File "<<data.name<<" does not exist\n";
          return data;
        }
        fil.close();
        std::string::size_type i = data.name.find_last_of('.');
        if (i == std::string::npos)
        {
          g_log.warning() << "Cannot open file "<<data.name<<"\n";
          return data;
        }
        std::string ext = data.name.substr(i);
        try
        {
          API::IAlgorithm_sptr load = createSubAlgorithm("Load");
          load->initialize();
          load->setPropertyValue("FileName",data.name);
          load->execute();
          if (load->isExecuted())
          {
            API::Workspace_sptr rws = load->getProperty("OutputWorkspace");
            if (rws)
            {
              DataObjects::Workspace2D_sptr ws = boost::dynamic_pointer_cast<DataObjects::Workspace2D>(rws);
              if (ws) 
              {
                out.ws = ws;
              }
              else
              {
                API::WorkspaceGroup_sptr gws = boost::dynamic_pointer_cast<API::WorkspaceGroup>(rws);
                if (gws)
                {
                  std::vector<std::string> wsNames = gws->getNames();
                  std::string propName = "OUTPUTWORKSPACE_" + boost::lexical_cast<std::string>(data.period);
                  if (load->existsProperty(propName))
                  {
                    Workspace_sptr rws1 = load->getProperty(propName);
                    out.ws = boost::dynamic_pointer_cast<DataObjects::Workspace2D>(rws1);
                  }
                }
              }
            }
          }
        }
        catch(std::exception& e)
        {
          g_log.error(e.what());
          return data;
        }
      }

      if (!out.ws) return data;

      API::Axis* axis = out.ws->getAxis(1);
      if (axis->isSpectra())
      {// spectra axis
        if (out.spec < 0)
        {
          if (out.i >= 0)
          {
            out.spec = axis->spectraNo(out.i);
          }
          else
          {// i < 0 && spec < 0 => use start and end
            for(size_t i=0;i<axis->length();++i)
            {
              double s = double(axis->spectraNo(i));
              if (s >= out.start && s <= out.end)
              {
                out.indx.push_back(static_cast<int>(i));
              }
            }
          }
        }
        else
        {
          for(size_t i=0;i<axis->length();++i)
          {
            int j = axis->spectraNo(i);
            if (j == out.spec)
            {
              out.i = static_cast<int>(i);
              break;
            }
          }
        }
        if (out.i < 0 && out.indx.empty())
        {
          return data;
        }
      }
      else
      {// numeric axis
        out.spec = -1;
        if (out.i >= 0)
        {
          out.indx.clear();
        }
        else
        {
          if (out.i < -1)
          {
            out.start = (*axis)(0);
            out.end = (*axis)(axis->length()-1);
          }
          for(size_t i=0;i<axis->length();++i)
          {
            double s = (*axis)(i);
            if (s >= out.start && s <= out.end)
            {
              out.indx.push_back(static_cast<int>(i));
            }
          }
        }
      }

      return out;
    }
예제 #29
0
int Spawner::Run(Command &commands, RuleList *ruleList, Rule *rule)
{
    int rv = 0;
    for (Command::iterator it = commands.begin(); it != commands.end() && !rv ; ++it)
    {
        bool curSilent = silent;
        bool curIgnore = ignoreErrors;
        bool curDontRun = dontRun;
        const std::string &a = (*it);
        int i;
        for (i=0; i < a.size(); i++)
            if (a[i] == '+')
                curDontRun = false;
            else if (a[i] == '@')
                curSilent = true;
            else if (a[i] == '-')
                curIgnore = true;
            else
                break;
        if (a.find("$(MAKE)") != std::string::npos || a.find("${MAKE}") != std::string::npos)
            curDontRun = false;
        std::string cmd = a.substr(i);
        Eval c(cmd, false, ruleList, rule);
        cmd = c.Evaluate(); // deferred evaluation
        size_t n = cmd.find("&&");
        std::string makeName;
        if (n == cmd.size() - 3)
        {
            char match = cmd[n+2];
            cmd.erase(n);
            std::strstream str;
            str << "maketemp." << std::setw(3) << std::setfill('0') << tempNum++;
            str >> makeName;
            std::fstream fil(makeName.c_str(), std::ios::out);
            bool done = false;
            std::string tail;
            do
            {
                ++it;
                std::string current = *it;
                size_t n = current.find(match);
                if (n != std::string::npos)
                {
                    done = true;
                    if (n+1 < current.size())
                        tail = current.substr(n+1);
                    current.erase(n);
                }
                Eval ce(current, false, ruleList, rule);
                fil << ce.Evaluate() << std::endl;
            } while (!done);						
            fil.close();
            cmd += makeName + tail;
        }
        cmd = QualifyFiles(cmd);
        rv = Run(cmd, curIgnore, curSilent, curDontRun);
        if (curIgnore)
            rv = 0;
        if (makeName.size())
            OS::RemoveFile(makeName);
    }
void ConfigManager::Save() {
	wxTextFile fil(filename);
	if (fil.Exists())
		fil.Open();
	else
		fil.Create();
	fil.Clear();
	
	fil.AddLine(wxString("# generado por PSeInt ")<<VERSION<<"-"ARCHITECTURE);
	fil.AddLine(wxString("version=")<<VERSION);
	fil.AddLine(wxString("images_path=")<<images_path);
//	fil.AddLine(wxString("pseint_command=")<<pseint_command);
//	fil.AddLine(wxString("psterm_command=")<<psterm_command);
//	fil.AddLine(wxString("psexport_command=")<<psexport_command);
//	fil.AddLine(wxString("psdrawe_command=")<<psdrawe_command);
//	fil.AddLine(wxString("psdraw3_command=")<<psdraw3_command);
	if (tty_command!=_no_tty) fil.AddLine(wxString("terminal=")<<tty_command);
	fil.AddLine(wxString("temp_dir=")<<temp_dir);
	fil.AddLine(wxString("last_dir=")<<last_dir);
	fil.AddLine(wxString("help_dir=")<<help_dir);
	fil.AddLine(wxString("proxy=")<<proxy);
	fil.AddLine(wxString("profiles_dir=")<<profiles_dir);
	fil.AddLine(wxString("profile=")<<profile);
	fil.AddLine(wxString("examples_dir=")<<examples_dir);
	fil.AddLine(wxString("rt_syntax=")<<(rt_syntax?1:0));
	fil.AddLine(wxString("smart_indent=")<<(smart_indent?1:0));
	fil.AddLine(wxString("shape_colors=")<<(shape_colors?1:0));
	fil.AddLine(wxString("colour_sintax=")<<(colour_sintax?1:0));
	fil.AddLine(wxString("show_vars=")<<(show_vars?1:0));
	fil.AddLine(wxString("show_opers=")<<(show_opers?1:0));
	fil.AddLine(wxString("show_commands=")<<(show_commands?1:0));
	fil.AddLine(wxString("show_debug_panel=")<<(show_debug_panel?1:0));
	fil.AddLine(wxString("show_toolbar=")<<(show_toolbar?1:0));
	fil.AddLine(wxString("calltip_helps=")<<(calltip_helps?1:0));
	fil.AddLine(wxString("autocomp=")<<(autocomp?1:0));
	fil.AddLine(wxString("highlight_blocks=")<<(highlight_blocks?1:0));
	fil.AddLine(wxString("autoclose=")<<(autoclose?1:0));
	fil.AddLine(wxString("auto_quickhelp=")<<(auto_quickhelp?1:0));
	fil.AddLine(wxString("use_colors=")<<(use_colors?1:0));
	fil.AddLine(wxString("animate_gui=")<<(animate_gui?1:0));
	fil.AddLine(wxString("reorganize_for_debug=")<<(reorganize_for_debug?1:0));
	for(int i=0;i<LS_COUNT;i++) fil.AddLine(lang.GetConfigLine(i).c_str());
	fil.AddLine(wxString("maximized=")<<(maximized?1:0));
	fil.AddLine(wxString("font_size=")<<font_size);
	fil.AddLine(wxString("tabw=")<<tabw);
	fil.AddLine(wxString("stepstep_tspeed=")<<stepstep_tspeed);
	fil.AddLine(wxString("size_x=")<<size_x);
	fil.AddLine(wxString("size_y=")<<size_y);
	fil.AddLine(wxString("pos_x=")<<pos_x);
	fil.AddLine(wxString("pos_y=")<<pos_y);
	fil.AddLine(wxString("maximized=")<<maximized);	
	if (fixed_port) {
		fil.AddLine(wxString("debug_port=")<<debug_port);	
		fil.AddLine(wxString("comm_port=")<<comm_port);	
	}
	fil.AddLine(wxString("use_psterm=")<<(use_psterm?1:0));	
	fil.AddLine(wxString("use_dark_psterm=")<<(use_dark_psterm?1:0));	
	fil.AddLine(wxString("check_for_updates=")<<(check_for_updates?1:0));	
	fil.AddLine(wxString("fixed_port=")<<(fixed_port?1:0));	
	for (unsigned int i=0;i<last_files.GetCount();i++)
		fil.AddLine(wxString("history=")<<last_files[i]);
	fil.AddLine("");
	
	fil.Write();
	fil.Close();
	
}