Пример #1
0
void Kandy::fileSaveAs()
{
    QString filename = KFileDialog::getSaveFileName();
    save(filename);
}
Пример #2
0
void IntegerEdit::setValue(int value) {
    edit = value;
    save();
}
Пример #3
0
void save(void *_obj, const cfgParam *params, ostream &out)
{
    const cfgParam *saveParam = params;
    char *obj = (char*)_obj;
    string *s;
    string v;
    list<unsigned long> *l;
    list<unsigned long>::iterator it;
    for (;;){
        const cfgParam *p;
        for (p = params; *p->name; p++){
            const cfgParam *pp = saveParam;
            for (;;){
                for (; *pp->name; pp++)
                    if (strcmp(pp->name, p->name) == 0) break;
                if (*pp->name) break;
                if (pp->defValue == 0) break;
                pp = (const cfgParam*)(pp->defValue);
            }
            if (pp != p) continue;
            bool writeEmpty = false;
            string value;
            switch (p->type){
            case PARAM_ULONG:
                if (*((unsigned long*)(obj + p->offs)) != p->defValue){
                    char buf[32];
                    snprintf(buf, sizeof(buf), "%lu", *((unsigned long*)(obj + p->offs)));
                    value = buf;
                }
                break;
            case PARAM_USHORT:
                if (*((unsigned short*)(obj + p->offs)) != (unsigned short)(p->defValue)){
                    char buf[32];
                    snprintf(buf, sizeof(buf), "%u", *((unsigned short*)(obj + p->offs)));
                    value = buf;
                }
                break;
            case PARAM_SHORT:
                if (*((short*)(obj + p->offs)) != (short)(p->defValue)){
                    char buf[32];
                    snprintf(buf, sizeof(buf), "%u", *((short*)(obj + p->offs)));
                    value = buf;
                }
                break;
            case PARAM_STRING:
                s = (string*)(obj + p->offs);
                v = "";
                if (p->defValue)
                    v = (const char*)(p->defValue);
                if (*s != v){
                    value = *s;
                    writeEmpty = true;
                }
                break;
            case PARAM_BOOL:
                if (*((bool*)(obj + p->offs)) != (bool)(p->defValue))
                    value = *((bool*)(obj + p->offs)) ? "true" : "false";
                break;
            case PARAM_I18N:
                s = (string*)(obj + p->offs);
                v = "";
                if (p->defValue)
                    v = i18n((const char*)(p->defValue)).local8Bit();
                if (*s != v) value = v;
                break;
            case PARAM_ULONGS:
                l = (list<unsigned long>*)(obj + p->offs);
                if (l->size()){
                    for (it = l->begin(); it != l->end(); ++it){
                        char b[15];
                        snprintf(b, sizeof(b), "%lu", *it);
                        if (value.length()) value += ",";
                        value += b;
                    }
                }
                break;
            case PARAM_CHAR:
                if (obj[p->offs] != (char)(p->defValue)){
                    char buf[32];
                    snprintf(buf, sizeof(buf), "%u", *((char*)(obj + p->offs)));
                    value = buf;
                }
                break;
            default:
                l = (list<unsigned long>*)(obj + p->offs);
                for (it = l->begin(); it != l->end(); ++it){
                    out << "[" << p->name << "]\n";
                    save((void*)(*it), (const cfgParam*)(p->defValue), out);
                }
                if (l->size())
                    out << "[]\n";
            }
            if ((value.size() == 0) && !writeEmpty) continue;
            value = quoteString(value);
            out << p->name << "=" << value << "\n";
        }
        if (p->defValue == 0) break;
        params = (const cfgParam*)(p->defValue);
        if (p->offs) obj = *((char**)(obj + p->offs));
    }
}
Пример #4
0
//! Creates a list of files and directories in the current working directory
IFileList* CFileSystem::createFileList()
{
	FileEntry e2;
	FileEntry e3;

	if ( FileSystemType == FILESYSTEM_NATIVE )
		return new CFileList();

	CFileList* r = new CFileList( "virtual" );
	r->Path = WorkingDirectory [ FILESYSTEM_VIRTUAL ];

	for ( u32 i = 0; i != FileArchives.size(); ++i)
	{
		CFileList* flist[2] = { 0, 0 };

		//! merge relative folder file archives
		if ( FileArchives[i]->getArchiveType() == "mount" )
		{
			EFileSystemType currentType = setFileListSystem ( FILESYSTEM_NATIVE );

			core::string<c16> save ( getWorkingDirectory () );
			core::string<c16> current;

			current = FileArchives[i]->getArchiveName() + WorkingDirectory [ FILESYSTEM_VIRTUAL ];
			flattenFilename ( current );

			if ( changeWorkingDirectoryTo ( current ) )
			{
				flist[0] = new CFileList( "mountpoint" );
				flist[0]->constructNative ();
				changeWorkingDirectoryTo ( save );
			}

			setFileListSystem ( currentType );
		}
		else
		if ( FileArchives[i]->getArchiveType() == "zip" )
		{
			flist[0] = new CFileList( "zip" );
			flist[1] = new CFileList( "zip directory" );

			// add relative navigation
			e2.isDirectory = 1;
			e2.Name = ".";
			e2.FullName = r->Path + e2.Name;
			e2.Size = 0;
			flist[1]->Files.push_back ( e2 );

			e2.Name = "..";
			e2.FullName = r->Path + e2.Name;
			flist[1]->Files.push_back ( e2 );

			for ( u32 g = 0; g < FileArchives[i]->getFileCount(); ++g)
			{
				const SZipFileEntry *e = (SZipFileEntry*) FileArchives[i]->getFileInfo(g);
				s32 test = isInSameDirectory ( r->Path, e->zipFileName );
				if ( test < 0 || test > 1 )
					continue;

				e2.Size = e->header.DataDescriptor.UncompressedSize;
				e2.isDirectory = e2.Size == 0;

				// check missing directories
				if ( !e2.isDirectory && test == 1 )
				{
					e3.Size = 0;
					e3.isDirectory = 1;
					e3.FullName = e->path;
					e3.Name = e->path.subString ( r->Path.size(), e->path.size() - r->Path.size() - 1 );

					if ( flist[1]->Files.binary_search ( e3 ) < 0 )
						flist[1]->Files.push_back ( e3 );
				}
				else
				{
					e2.FullName = e->zipFileName;
					e2.Name = e->simpleFileName;

					if ( !e2.isDirectory )
						core::deletePathFromFilename ( e2.Name );
					flist[0]->Files.push_back ( e2 );
				}
			}
		}

		// add file to virtual directory
		for ( u32 g = 0; g < 2; ++g )
		{
			if ( !flist[g] )
				continue;
			for ( u32 j = 0; j != flist[g]->Files.size(); ++j )
				r->Files.push_back ( flist[g]->Files[j] );

			flist[g]->drop();
		}
	}

	r->Files.sort();
	return r;
}
Пример #5
0
static void read_string (LexState *LS, int del, SemInfo *seminfo) {
  lua_State *L = LS->L;
  size_t l = 0;
  checkbuffer(L, 10, l);
  save_and_next(L, LS, l);
  while (LS->current != del) {
    checkbuffer(L, 10, l);
    switch (LS->current) {
      case EOZ:  case '\n':
        save(L, '\0', l);
        luaX_error(LS, "unfinished string", TK_STRING);
        break;  /* to avoid warnings */
      case '\\':
        next(LS);  /* do not save the '\' */
        switch (LS->current) {
          case 'a': save(L, '\a', l); next(LS); break;
          case 'b': save(L, '\b', l); next(LS); break;
          case 'f': save(L, '\f', l); next(LS); break;
          case 'n': save(L, '\n', l); next(LS); break;
          case 'r': save(L, '\r', l); next(LS); break;
          case 't': save(L, '\t', l); next(LS); break;
          case 'v': save(L, '\v', l); next(LS); break;
          case '\n': save(L, '\n', l); inclinenumber(LS); break;
          case '0': case '1': case '2': case '3': case '4':
          case '5': case '6': case '7': case '8': case '9': {
            int c = 0;
            int i = 0;
            do {
              c = 10*c + (LS->current-'0');
              next(LS);
            } while (++i<3 && isdigit(LS->current));
            if (c != (unsigned char)c) {
              save(L, '\0', l);
              luaX_error(LS, "escape sequence too large", TK_STRING);
            }
            save(L, c, l);
            break;
          }
          default:  /* handles \\, \", \', and \? */
            save_and_next(L, LS, l);
        }
        break;
      default:
        save_and_next(L, LS, l);
    }
  }
  save_and_next(L, LS, l);  /* skip delimiter */
  save(L, '\0', l);
  seminfo->ts = luaS_newlstr(L, L->Mbuffer+1, l-3);
}
 void 
 save(const version_type & t){
     save(static_cast<const unsigned int>(t));
 }
Пример #7
0
void c_hoice(){

	str_in1 = strlen(in1);
	str_in2 = strlen(in2);
	str_in3 = strlen(in3);

	var_in(); if (chosen == 1) return ;

	else
	{
		if (str_in1 == 1)
		{	if (str_in2 == 0)
			{
				if (in1[0] >= 'A' && in1[0] <= 'Z')
				{
					for (int i = 0; i <= 9; i ++)
					{
						if (in1[0] == var[i])
						{
							begin_chosen = i;
							printf("        = "); comma(var_var[begin_chosen]); chosen = 1; return;

						}
						else
							begin_chosen = 100;
					}
				}

				else if (in1[0] >= 'a' && in1[0] <= 'z')
				{
					in1[0] -= 32;
					for (int i = 0; i <= 9; i ++)
					{
						if (in1[0] == var[i])
						{
							begin_chosen = i;
							printf("        = "); comma(var_var[begin_chosen]); chosen = 1; return;

						}
						else
							begin_chosen = 100;
					}
				}
			}}

		else 
		{
			choice = strcmp (in1, c_lear);
			if (choice == 0) {system("clear"); chosen = 1; return ;}
			else { choice = strcmp (in1, e_nd); 
				if (choice == 0) exit(1);
				else { choice = strcmp (in1, V_AR);
					if (choice == 0) {VAR(); chosen = 1; return ;}
					else { choice = strcmp (in1, s_ave);
						if (choice == 0) {save(); chosen = 1; return;}
						else { choice = strcmp (in1, l_oad);
							if (choice == 0) {load(); chosen = 1; return;}
						}}}}
		}
		if (begin_chosen == 100)
		{printf("        = undefined."); chosen = 1; return;}
	}

} // choice 함수
Пример #8
0
void Sim::SFM::Airframe::save(Variant & variant, const Desc & desc)
{
	save(variant["force"], desc.force);
	save(variant["torque"], desc.torque);
}
Пример #9
0
void LogSensorStream::save(const std::string& _filename){
    std::ofstream outfile;
    outfile.open(_filename.c_str());
    save(outfile);
    outfile.close();
}
void MainWindow::createActions()
{
    newAction = new QAction(tr("&New"), this);
    newAction->setIcon(QIcon(":/images/new.png"));
    newAction->setShortcut(QKeySequence::New);
    newAction->setStatusTip(tr("Create a new spreadsheet file"));
    connect(newAction, SIGNAL(triggered()), this, SLOT(newFile()));

    openAction = new QAction(tr("&Open..."), this);
    openAction->setIcon(QIcon(":/images/open.png"));
    openAction->setShortcut(QKeySequence::Open);
    openAction->setStatusTip(tr("Open an existing spreadsheet file"));
    connect(openAction, SIGNAL(triggered()), this, SLOT(open()));

    saveAction = new QAction(tr("&Save"), this);
    saveAction->setIcon(QIcon(":/images/save.png"));
    saveAction->setShortcut(QKeySequence::Save);
    saveAction->setStatusTip(tr("Save the spreadsheet to disk"));
    connect(saveAction, SIGNAL(triggered()), this, SLOT(save()));

    saveAsAction = new QAction(tr("Save &As..."), this);
    saveAsAction->setStatusTip(tr("Save the spreadsheet under a new "
                                  "name"));
    connect(saveAsAction, SIGNAL(triggered()), this, SLOT(saveAs()));

    for (int i = 0; i < MaxRecentFiles; ++i) {
        recentFileActions[i] = new QAction(this);
        recentFileActions[i]->setVisible(false);
        connect(recentFileActions[i], SIGNAL(triggered()),
                this, SLOT(openRecentFile()));
    }

    exitAction = new QAction(tr("E&xit"), this);
    exitAction->setShortcut(tr("Ctrl+Q"));
    exitAction->setStatusTip(tr("Exit the application"));
    connect(exitAction, SIGNAL(triggered()), this, SLOT(close()));

    cutAction = new QAction(tr("Cu&t"), this);
    cutAction->setIcon(QIcon(":/images/cut.png"));
    cutAction->setShortcut(QKeySequence::Cut);
    cutAction->setStatusTip(tr("Cut the current selection's contents "
                               "to the clipboard"));
    connect(cutAction, SIGNAL(triggered()), spreadsheet, SLOT(cut()));

    copyAction = new QAction(tr("&Copy"), this);
    copyAction->setIcon(QIcon(":/images/copy.png"));
    copyAction->setShortcut(QKeySequence::Copy);
    copyAction->setStatusTip(tr("Copy the current selection's contents "
                                "to the clipboard"));
    connect(copyAction, SIGNAL(triggered()), spreadsheet, SLOT(copy()));

    pasteAction = new QAction(tr("&Paste"), this);
    pasteAction->setIcon(QIcon(":/images/paste.png"));
    pasteAction->setShortcut(QKeySequence::Paste);
    pasteAction->setStatusTip(tr("Paste the clipboard's contents into "
                                 "the current selection"));
    connect(pasteAction, SIGNAL(triggered()),
            spreadsheet, SLOT(paste()));

    deleteAction = new QAction(tr("&Delete"), this);
    deleteAction->setShortcut(QKeySequence::Delete);
    deleteAction->setStatusTip(tr("Delete the current selection's "
                                  "contents"));
    connect(deleteAction, SIGNAL(triggered()),
            spreadsheet, SLOT(del()));

    selectRowAction = new QAction(tr("&Row"), this);
    selectRowAction->setStatusTip(tr("Select all the cells in the "
                                     "current row"));
    connect(selectRowAction, SIGNAL(triggered()),
            spreadsheet, SLOT(selectCurrentRow()));

    selectColumnAction = new QAction(tr("&Column"), this);
    selectColumnAction->setStatusTip(tr("Select all the cells in the "
                                        "current column"));
    connect(selectColumnAction, SIGNAL(triggered()),
            spreadsheet, SLOT(selectCurrentColumn()));

    selectAllAction = new QAction(tr("&All"), this);
    selectAllAction->setShortcut(QKeySequence::SelectAll);
    selectAllAction->setStatusTip(tr("Select all the cells in the "
                                     "spreadsheet"));
    connect(selectAllAction, SIGNAL(triggered()),
            spreadsheet, SLOT(selectAll()));

    findAction = new QAction(tr("&Find..."), this);
    findAction->setIcon(QIcon(":/images/find.png"));
    findAction->setShortcut(QKeySequence::Find);
    findAction->setStatusTip(tr("Find a matching cell"));
    connect(findAction, SIGNAL(triggered()), this, SLOT(find()));

    goToCellAction = new QAction(tr("&Go to Cell..."), this);
    goToCellAction->setIcon(QIcon(":/images/gotocell.png"));
    goToCellAction->setShortcut(tr("Ctrl+G"));
    goToCellAction->setStatusTip(tr("Go to the specified cell"));
    connect(goToCellAction, SIGNAL(triggered()),
            this, SLOT(goToCell()));

    recalculateAction = new QAction(tr("&Recalculate"), this);
    recalculateAction->setShortcut(tr("F9"));
    recalculateAction->setStatusTip(tr("Recalculate all the "
                                       "spreadsheet's formulas"));
    connect(recalculateAction, SIGNAL(triggered()),
            spreadsheet, SLOT(recalculate()));

    sortAction = new QAction(tr("&Sort..."), this);
    sortAction->setStatusTip(tr("Sort the selected cells or all the "
                                "cells"));
    connect(sortAction, SIGNAL(triggered()), this, SLOT(sort()));

    showGridAction = new QAction(tr("&Show Grid"), this);
    showGridAction->setCheckable(true);
    showGridAction->setChecked(spreadsheet->showGrid());
    showGridAction->setStatusTip(tr("Show or hide the spreadsheet's "
                                    "grid"));
    connect(showGridAction, SIGNAL(toggled(bool)),
            spreadsheet, SLOT(setShowGrid(bool)));
#if QT_VERSION < 0x040102
    // workaround for a QTableWidget bug in Qt 4.1.1
    connect(showGridAction, SIGNAL(toggled(bool)),
            spreadsheet->viewport(), SLOT(update()));
#endif

    autoRecalcAction = new QAction(tr("&Auto-Recalculate"), this);
    autoRecalcAction->setCheckable(true);
    autoRecalcAction->setChecked(spreadsheet->autoRecalculate());
    autoRecalcAction->setStatusTip(tr("Switch auto-recalculation on or "
                                      "off"));
    connect(autoRecalcAction, SIGNAL(toggled(bool)),
            spreadsheet, SLOT(setAutoRecalculate(bool)));

    aboutAction = new QAction(tr("&About"), this);
    aboutAction->setStatusTip(tr("Show the application's About box"));
    connect(aboutAction, SIGNAL(triggered()), this, SLOT(about()));

    aboutQtAction = new QAction(tr("About &Qt"), this);
    aboutQtAction->setStatusTip(tr("Show the Qt library's About box"));
    connect(aboutQtAction, SIGNAL(triggered()), qApp, SLOT(aboutQt()));
}
Пример #11
0
void FrameState::update(const IRInstruction* inst) {
  if (auto* taken = inst->taken()) {
    save(taken);
  }

  auto const opc = inst->op();

  getLocalEffects(inst, *this);

  switch (opc) {
  case DefInlineFP:    trackDefInlineFP(inst);  break;
  case InlineReturn:   trackInlineReturn(inst); break;

  case Call:
    m_spValue = inst->dst();
    m_frameSpansCall = true;
    // A call pops the ActRec and pushes a return value.
    m_spOffset -= kNumActRecCells;
    m_spOffset += 1;
    assert(m_spOffset >= 0);
    clearCse();
    break;

  case CallArray:
    m_spValue = inst->dst();
    m_frameSpansCall = true;
    // A CallArray pops the ActRec an array arg and pushes a return value.
    m_spOffset -= kNumActRecCells;
    assert(m_spOffset >= 0);
    clearCse();
    break;

  case ContEnter:
    clearCse();
    break;

  case DefFP:
  case FreeActRec:
    m_fpValue = inst->dst();
    break;

  case ReDefGeneratorSP:
    m_spValue = inst->dst();
    break;

  case ReDefSP:
    m_spValue = inst->dst();
    m_spOffset = inst->extra<ReDefSP>()->spOffset;
    break;

  case DefInlineSP:
  case DefSP:
    m_spValue = inst->dst();
    m_spOffset = inst->extra<StackOffset>()->offset;
    break;

  case AssertStk:
  case AssertStkVal:
  case CastStk:
  case CoerceStk:
  case CheckStk:
  case GuardStk:
  case ExceptionBarrier:
    m_spValue = inst->dst();
    break;

  case SpillStack: {
    m_spValue = inst->dst();
    // Push the spilled values but adjust for the popped values
    int64_t stackAdjustment = inst->src(1)->getValInt();
    m_spOffset -= stackAdjustment;
    m_spOffset += spillValueCells(inst);
    break;
  }

  case SpillFrame:
  case CufIterSpillFrame:
    m_spValue = inst->dst();
    m_spOffset += kNumActRecCells;
    break;

  case InterpOne:
  case InterpOneCF: {
    m_spValue = inst->dst();
    auto const& extra = *inst->extra<InterpOneData>();
    int64_t stackAdjustment = extra.cellsPopped - extra.cellsPushed;
    // push the return value if any and adjust for the popped values
    m_spOffset -= stackAdjustment;
    break;
  }

  case AssertLoc:
  case GuardLoc:
  case CheckLoc:
    m_fpValue = inst->dst();
    break;

  case LdThis:
    m_thisAvailable = true;
    break;

  default:
    break;
  }

  if (inst->modifiesStack()) {
    m_spValue = inst->modifiedStkPtr();
  }

  // update the CSE table
  if (m_enableCse && inst->canCSE()) {
    cseInsert(inst);
  }

  // if the instruction kills any of its sources, remove them from the
  // CSE table
  if (inst->killsSources()) {
    for (int i = 0; i < inst->numSrcs(); ++i) {
      if (inst->killsSource(i)) {
        cseKill(inst->src(i));
      }
    }
  }
}
Пример #12
0
void BookmarkGroup::reparent( BookmarkGroupPtr parent )
{
    m_parent = parent;
    save();
}
Пример #13
0
void BookmarkGroup::setDescription( const QString &description )
{
    m_description = description;
    save();
}
Пример #14
0
void BookmarkGroup::rename(const QString & name)
{
    m_name = name;
    save();
}
Пример #15
0
void SimpleDBStorage::save(void)
{
    save(table);
}
Пример #16
0
/**
 *\fn int main(int argc, char *argv[])
 * Main
 *\param[in,out] argc argc
 *\param[in,out] argv argv
 */
int main(int argc, char *argv[])
{
    SDL_Surface *screen = NULL;

    int go = 1;
    int ret,ret1, ret2 = 0, ret3, ret4;

    char level_name[MAX_SIZE_FILE_NAME];
    char player_name[MAX_SIZE_FILE_NAME];
    int nb_lvl;
    /*sound*/
    Sound *sound_system;
    sound_system = createSound();

    /*keyboard config*/
    SDLKey kc[NB_KEY-1];

    /*input*/
    Input in;

    SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER|SDL_INIT_JOYSTICK);

    Player *current_player;

    current_player = (Player *)malloc(sizeof(Player));

    /*screen initialization*/
    screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);

    initInput(&in);

    /*configurations loading */
    loadSoundOptions("configuration/sound.conf",sound_system);


    SDL_WM_SetCaption("Super Martin", NULL); //window name

    SDL_ShowCursor(SDL_DISABLE); //delete the mouse

    while (go) //main loop
    {
        if(titleMenu(screen,&go,sound_system, &in))
        {

            while( (ret3 = menuPlayers(screen, player_name, &go, sound_system, &in)) != -1 && go)
            {
                switch(ret3)
                {
                    case -1:
                        break;
                    case 2  :
                        ret2 = newPlayer(screen, player_name, sound_system, &go);
                        if(ret2 == 1)
                        {
                            current_player->levelMax = 1;
                            current_player->nbCoins = 0;
                            current_player->nbLifes = 3;
                            current_player->nbProjectile = 5;
                            savePlayer("save/.save", player_name, current_player);
                            loadInputOptions("default",kc,&in);
                            saveInputOptions(player_name, kc, &in);
                        }
                        else
                            break;

                    case 1  :
                        loadPlayer("save/.save", player_name, current_player);
                        loadInputOptions(player_name,kc,&in);
                        while(go && (ret1 = mainMenu(screen,&go,sound_system, player_name, &in)) != -1)
                        {
                            switch(ret1)
                            {
                                case -1:
                                    break;
                                case 0:

                                    while( (ret4 = menuLevel(screen,level_name,sound_system, player_name, current_player, &go, &nb_lvl, &in)) != -1 && go)
                                    {
                                        while(play(screen,level_name,sound_system,&go,kc, &in, current_player, player_name, ret4+1, nb_lvl) && go);
                                    }
                                    break;

                                case 1 :
                                    save(screen, "save/.save", player_name, current_player, &go);
                                    loadPlayer("save/.save", player_name, current_player);
                                    break;

                                case 2 :
                                    while((ret = optionMenu(screen,&go,sound_system,kc, &in)) != -1 && go)
                                    {
                                        switch(ret)
                                        {
                                            case -1:
                                                break;
                                            case 0:
                                                soundOptions(screen,&go,sound_system, &in);
                                                break;
                                            case 1:
                                                keyBoardOptions(screen,&go,kc,&in,player_name);
                                                break;
                                            default:;
                                        }
                                    }
                                    break;

                                case 3 :
                                    deletePlayer(screen, "save/players", player_name);
                                    go = 0;
                                    break;

                                default: ;
                            }
                        }
                        go = 1;
                        break;

                    default : ;

                }
            }

        }

        SDL_FillRect(screen,NULL,SDL_MapRGB(screen->format,255,255,255)); //clear screen

        SDL_Flip(screen);
    }


    freeSound(sound_system);
    free((void*)current_player);
    freeInput(&in);
    SDL_Quit();

    return EXIT_SUCCESS;
}
Пример #17
0
void ItemShortcut::setItem(const int index)
{
    mItems[index] = mItemSelected;
    mItemColors[index] = mItemColorSelected;
    save();
}
Пример #18
0
int
split_quoted (const char *s, int *argc, char *argv[], int argv_sz)
{
    char arg_buff[MAX_ARG_LEN]; /* current argument buffer */
    char *ap, *ae;              /* arg_buff current ptr & end-guard */
    const char *c;              /* current input charcter ptr */
    char qc;                    /* current quote character */
    enum states state;          /* current state */
    enum err_codes err;         /* error end-code */
    int flags;                  /* warning flags */

    ap = &arg_buff[0];
    ae = &arg_buff[MAX_ARG_LEN - 1];
    c = &s[0];
    state = ST_DELIM;
    err = ERR_OK;
    flags = 0;
    qc = SQ; /* silence compiler waring */

    while ( state != ST_END ) {
        switch (state) {
        case ST_DELIM:
            while ( is_delim(*c) ) c++;
            if ( *c == SQ || *c == DQ ) {
                qc = *c; c++; state = ST_QUOTE; 
                break;
            }
            if ( *c == EOS ) {
                state = ST_END;
                break;
            }
            if ( *c == BS ) {
                c++;
                if ( *c == NL ) {
                    c++;
                    break;
                }
                if ( *c == EOS ) {
                    state = ST_END; err = ERR_BS_AT_EOS;
                    break;
                }
            }
            /* All other cases incl. character after BS */
            save(); c++; state = ST_ARG;
            break;
        case ST_QUOTE:
            while ( *c != qc && ( *c != BS || qc == SQ ) && *c != EOS ) {
                save(); c++;
            }
            if ( *c == qc ) {
                c++; state = ST_ARG;
                break;
            }
            if ( *c == BS ) {
                assert (qc == DQ);
                c++;
                if ( *c == NL) {
                    c++;
                    break;
                }
                if (*c == EOS) {
                    state = ST_END; err = ERR_BS_AT_EOS;
                    break;
                }
                if ( ! is_dq_escapable(*c) ) {
                    c--; save(); c++;
                }
                save(); c++;
                break;
            }
            if ( *c == EOS ) {
                state = ST_END; err = ERR_SQ_OPEN_AT_EOS;
                break;
            }
            assert(0);
        case ST_ARG:
            if ( *c == SQ || *c == DQ ) {
                qc = *c; c++; state = ST_QUOTE;
                break;
            }
            if ( is_delim(*c) || *c == EOS ) {
                push();
                state = (*c == EOS) ? ST_END : ST_DELIM;
                c++;
                break;
            }
            if ( *c == BS ) {
                c++;
                if ( *c == NL ) {
                    c++;
                    break;
                }
                if ( *c == EOS ) {
                    state = ST_END; err = ERR_BS_AT_EOS;
                    break;
                }
            }
            /* All other cases, incl. character after BS */
            save(); c++;
            break;
        default:
            assert(0);
        }
    }
    
    return ( err != ERR_OK ) ? -1 : flags;
}
 void 
 save(const lslboost::serialization::item_version_type & t){
     save(static_cast<const unsigned int>(t));
 }
Пример #20
0
void CCellView::ResizeCol(BPoint where, int colNr)
{
	float x, minX, maxRow;
	BPoint newP, lastP;
	BRect bounds(Bounds()), r, b;
	ulong buttons, cnt;
	bool multi;
	int mCol = colNr;
	CRunArray backup(fCellWidths);

	StPenState save(this);
	ClearAnts();

	cnt = fSelection.right - fSelection.left + 1;

	while (fCellWidths[colNr + 1] == fCellWidths[colNr])
		colNr++;

	multi = fSelection.left != fSelection.right
					&& colNr >= fSelection.left
					&& colNr <= fSelection.right;

	if (colNr <= fFrozen.h)
	{
		x = fBorderWidth + fCellWidths[colNr];
		minX = fBorderWidth + fCellWidths[multi?fSelection.left - 1 : colNr - 1];
	}
	else
	{
		x = fBorderWidth + fCellWidths[colNr] + fCellWidths[fFrozen.h] - 
			fCellWidths[fPosition.h - 1];
		minX = fBorderWidth + fCellWidths[fFrozen.h] - fCellWidths[fPosition.h - 1] + 
			fCellWidths[multi?fSelection.left - 1 : colNr - 1];
	}
	
	r.top = 1;
	r.bottom = fBorderHeight - 1;
	r.left = minX + 1;
	if (multi)
		r.right = minX + fCellWidths[fSelection.right] - 
			fCellWidths[fSelection.left - 1] - 1;
	else
		r.right = minX + fCellWidths[colNr] - fCellWidths[colNr - 1] - 1;
		
	b = bounds;
	b.left = r.right;
	
	maxRow = fPosition.v;
	while (fCellHeights[++maxRow] - fCellHeights[fPosition.v] < bounds.bottom - fBorderHeight)
		;
	
	lastP = where;
	newP = where;
	do
	{
		if (newP.x != lastP.x)
		{
			float dx;
			int k = colNr;
			
			dx = newP.x - lastP.x;
			
			if (lastP.x + dx < bounds.left + fBorderWidth)
				dx = std::min(lastP.x - bounds.left - fBorderWidth, (float)0);
			if (lastP.x + dx > bounds.right)
				dx = std::max(bounds.right - lastP.x, (float)0);
			
			if (multi && x + dx < minX)
				dx = minX - x;

			if (multi)
			{
				float w, t;
				
				w = x + dx - minX;
				if (w > 0)
					w = Round(w / (colNr - fSelection.left + 1));
				
				t = fCellWidths[fSelection.right];				
				fCellWidths.SetValue(fSelection.left, fSelection.right, w);
				dx = fCellWidths[fSelection.right] - t;
			}
			else if (x + dx < minX)
			{
				int t = k;
				
				fCellWidths.SetValue(colNr, 0);

				while (k > 1 && backup[k - 1] + fBorderWidth >= x + dx)
					k--;

				ASSERT(k<colNr);

				if (k <= mCol)
					while (mCol > k)
						fCellWidths.SetValue(mCol--, 0);
				else
				{
					t = mCol;
					for (;mCol<k;mCol++)
						fCellWidths.SetValue(mCol, backup[mCol] - backup[mCol - 1]);
				}

				float kw = x + dx - fBorderWidth;
				kw -= backup[k - 1];
				fCellWidths.SetValue(k, std::max(kw, (float)0));

				mCol = k;
				k = t;
			}
			else
			{
				k = mCol;
				for (; mCol < colNr; mCol++)
					fCellWidths.SetValue(mCol, backup[mCol] - backup[mCol - 1]);

				fCellWidths.SetValue(colNr, x + dx - minX);
			}
					
			if (dx != 0)
			{
				x += dx;
				lastP.x += dx;

				if (dx < 0)
					b.left += dx;
				
				StPenState save(this);
				StClipCells clip(this);
				ScrollRect(b, dx, 0);
				Window()->UpdateIfNeeded();
				
				if (dx > 0)
					b.left += dx;
				
				if (multi)
				{
					int h = fSelection.left, v;
					do
					{
						for (v = 1; v < fFrozen.v; v++)
							DrawCell(cell(h, v));
						for (v = fPosition.v; v < maxRow; v++)
							DrawCell(cell(h, v));
						DrawBorderCell(h++, true);
					}
					while (h <= fSelection.right && bounds.left + fCellWidths[h] + fBorderWidth < bounds.right);
				}
				else
				{
					int v;
					for (v = 1; v < fFrozen.v; v++)
						DrawCell(cell(mCol, v));
					for (v = fPosition.v; v < maxRow; v++)
						DrawCell(cell(mCol, v));
					DrawBorderCell(mCol, true);
				}
				
				for (; k < colNr; k++)
				{
					int v;
					for (v = 1; v < fFrozen.v; v++)
						DrawCell(cell(k, v));
					for (v = fPosition.v; v < maxRow; v++)
						DrawCell(cell(k, v));
					DrawBorderCell(k, true);
				}
			}
			
			if (dx < 0)
			{
				float X;
				int h;
				
				X = bounds.right + dx - fBorderWidth;
				h = fSelection.right;
				do h++;
				while (fCellWidths[h] < X);
				
				while (h <= kColCount && bounds.left + fCellWidths[h] + fBorderWidth < bounds.right)
				{
					int v;
					for (v = 1; v < fFrozen.v; v++)
						DrawCell(cell(h, v));
					for (v = fPosition.v; v < maxRow; v++)
						DrawCell(cell(h, v));
					DrawBorderCell(h++, true);
				}
			}
			
			if (dx && fFirstGraphic)
				fFirstGraphic->HandleUpdate(bounds);
		}
		GetMouse(&newP, &buttons);
	}
	while (buttons);

	if (!(backup == fCellWidths))
	{
		CRunArray temp(fCellWidths);
		fCellWidths = backup;
		
		((CCellWindow*)Window())->RegisterCommand(new CResizeCommand(this, temp, false));
		((CCellWindow*)Window())->SetDirty(true);
	}
} /* ResizeCol */
Пример #21
0
 /* save before trying to parse something that may fail */
 void save()
 {
    save(s);
 }
Пример #22
0
void CCellView::ResizeRow(BPoint where, int rowNr)
{
	float y, minY;
	BPoint newP, lastP;
	BRect bounds(Bounds()), r, b;
	BRegion rgn;
	ulong buttons, cnt;
	bool multi;
	int mRow = rowNr;
	CRunArray backup(fCellHeights);
	
	StPenState save(this);
	ClearAnts();
	
	rgn.Include(bounds);

	cnt = fSelection.bottom-fSelection.top+1;

	while (where.y > fCellHeights[rowNr+1]+2)
		rowNr++;

	multi = fSelection.top != fSelection.bottom
					&& rowNr >= fSelection.top
					&& rowNr <= fSelection.bottom;

	if (rowNr <= fFrozen.v)
	{
		y = fBorderHeight+fCellHeights[rowNr];
		minY = fBorderHeight+fCellHeights[multi?fSelection.top-1:rowNr-1];
	}
	else
	{
		y = fBorderHeight+fCellHeights[rowNr]+fCellHeights[fFrozen.v]-
			fCellHeights[fPosition.v-1];
		minY = fBorderHeight+fCellHeights[fFrozen.v]-fCellHeights[fPosition.v-1]+
			fCellHeights[multi?fSelection.top-1:rowNr-1];
	}
	
	r.left = 0;
	r.right = fBorderWidth-1;
	r.top = minY+1;
	if (multi)
		r.bottom = minY+fCellHeights[fSelection.bottom]-
			fCellHeights[fSelection.top-1]-1;
	else
		r.bottom = minY+fCellHeights[rowNr]-fCellHeights[rowNr-1]-1;

	b = bounds;
	b.top = r.bottom;
	
	lastP = where;
	newP = where;
	do
	{
		if (newP.y != lastP.y)
		{
			float dy;
			int k = rowNr;
			
			dy = newP.y - lastP.y;

			if (lastP.y + dy < bounds.top + fBorderHeight)
				dy = std::min(lastP.y - bounds.top - fBorderHeight, (float)0);
			if (lastP.y + dy > bounds.bottom)
				dy = std::max(bounds.bottom - lastP.y, (float)0);
			
			if (multi && y + dy < minY)
				dy = minY - y;

			if (multi)
			{
				float h, t;
				
				h = y + dy - minY;
				if (h > 0)
					h = Round(h/(rowNr-fSelection.top+1));
				
				t = fCellHeights[fSelection.bottom];				
				fCellHeights.SetValue(fSelection.top, fSelection.bottom, h);
				dy = fCellHeights[fSelection.bottom] - t;
			}
			else if (y + dy < minY)
			{
				int t = k;
				
				fCellHeights.SetValue(rowNr, 0);

				while (k > 1 && backup[k - 1] + fBorderHeight >= y + dy)
					k--;

				ASSERT(k<rowNr);

				if (k <= mRow)
					while (mRow > k)
						fCellHeights.SetValue(mRow--, 0);
				else
				{
					t = mRow;
					for (; mRow < k; mRow++)
						fCellHeights.SetValue(mRow, backup[mRow] - backup[mRow - 1]);
				}

				float kh = y + dy - fBorderHeight;
				kh -= backup[k - 1];
				fCellHeights.SetValue(k, std::max(kh, (float)0));

				mRow = k;
				k = t;
			}
			else
			{
				k = mRow;
				for (; mRow < rowNr; mRow++)
					fCellHeights.SetValue(mRow, backup[mRow] - backup[mRow - 1]);

				fCellHeights.SetValue(rowNr, y + dy - minY);
			}
					
			if (dy != 0)
			{
				y += dy;
				lastP.y += dy;

				if (dy < 0)
					b.top += dy;
				
				StPenState save(this);
				StClipCells clip(this);
				ScrollRect(b, 0, dy);
				Window()->UpdateIfNeeded();
				
				if (dy > 0)
					b.top += dy;

				if (multi)
				{
					int v = fSelection.top;
					do
					{
						TouchLine(v);
						DrawBorderCell(v++, false);
					}
					while (v <= fSelection.bottom && bounds.top + fCellHeights[v] + fBorderHeight < bounds.bottom);
				}
				else
				{
					TouchLine(mRow);
					DrawBorderCell(mRow, false);
				}
				
				for (; k < rowNr; k++)
				{
					TouchLine(k);
					DrawBorderCell(k, false);
				}
			}
			
			if (dy < 0)
			{
				float Y;
				int v;
				
				Y = bounds.bottom + dy - fBorderHeight;
				v = fSelection.bottom;
				do v++;
				while (fCellHeights[v] < Y)
					;

				StPenState save(this);
				
				while (v <= kRowCount && bounds.top + fCellHeights[v] + fBorderHeight < bounds.bottom)
				{
					TouchLine(v);
					DrawBorderCell(v++, false);
				}
			}
			
			if (dy)
			{
				DrawAllLines();
				if (fFirstGraphic)
					fFirstGraphic->HandleUpdate(bounds);
			}
		}
		GetMouse(&newP, &buttons);
	}
	while (buttons);
	
	if (!(backup == fCellHeights))
	{
		CRunArray temp(fCellHeights);
		fCellHeights = backup;
		
		((CCellWindow*)Window())->RegisterCommand(new CResizeCommand(this, temp, true));
		((CCellWindow*)Window())->SetDirty(true);
	}
} /* ResizeRow */
Пример #23
0
	void save(size_t sz)
	{
		void* bp;
		get_bp(bp);
		save(sz, bp);
	}
bool GurlsClassificationInterface::read(yarp::os::ConnectionReader& connection) {
  yarp::os::idl::WireReader reader(connection);
  reader.expectAccept();
  if (!reader.readListHeader()) { reader.fail(); return false; }
  yarp::os::ConstString tag = reader.readTag();
  while (!reader.isError()) {
    // TODO: use quick lookup, this is just a test
    if (tag == "add_sample") {
      std::string className;
      yarp::sig::Vector sample;
      if (!reader.readString(className)) {
        reader.fail();
        return false;
      }
      if (!reader.read(sample)) {
        reader.fail();
        return false;
      }
      bool _return;
      _return = add_sample(className,sample);
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "save") {
      std::string className;
      if (!reader.readString(className)) {
        reader.fail();
        return false;
      }
      bool _return;
      _return = save(className);
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "train") {
      bool _return;
      _return = train();
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "forget") {
      std::string className;
      if (!reader.readString(className)) {
        reader.fail();
        return false;
      }
      bool _return;
      _return = forget(className);
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "classList") {
      std::vector<std::string>  _return;
      _return = classList();
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        {
          if (!writer.writeListBegin(BOTTLE_TAG_STRING, static_cast<uint32_t>(_return.size()))) return false;
          std::vector<std::string> ::iterator _iter16;
          for (_iter16 = _return.begin(); _iter16 != _return.end(); ++_iter16)
          {
            if (!writer.writeString((*_iter16))) return false;
          }
          if (!writer.writeListEnd()) return false;
        }
      }
      reader.accept();
      return true;
    }
    if (tag == "stop") {
      bool _return;
      _return = stop();
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "recognize") {
      bool _return;
      _return = recognize();
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "classify_sample") {
      yarp::sig::Vector sample;
      if (!reader.read(sample)) {
        reader.fail();
        return false;
      }
      std::string _return;
      _return = classify_sample(sample);
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeString(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "get_scores_for_sample") {
      yarp::sig::Vector sample;
      if (!reader.read(sample)) {
        reader.fail();
        return false;
      }
      std::vector<ClassScore>  _return;
      _return = get_scores_for_sample(sample);
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        {
          if (!writer.writeListBegin(BOTTLE_TAG_LIST, static_cast<uint32_t>(_return.size()))) return false;
          std::vector<ClassScore> ::iterator _iter17;
          for (_iter17 = _return.begin(); _iter17 != _return.end(); ++_iter17)
          {
            if (!writer.writeNested((*_iter17))) return false;
          }
          if (!writer.writeListEnd()) return false;
        }
      }
      reader.accept();
      return true;
    }
    if (tag == "get_parameter") {
      std::string parameterName;
      if (!reader.readString(parameterName)) {
        reader.fail();
        return false;
      }
      std::string _return;
      _return = get_parameter(parameterName);
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeString(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "set_parameter") {
      std::string parameterName;
      std::string parameterValue;
      if (!reader.readString(parameterName)) {
        reader.fail();
        return false;
      }
      if (!reader.readString(parameterValue)) {
        reader.fail();
        return false;
      }
      bool _return;
      _return = set_parameter(parameterName,parameterValue);
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (reader.noMore()) { reader.fail(); return false; }
    yarp::os::ConstString next_tag = reader.readTag();
    if (next_tag=="") break;
    tag = tag + "_" + next_tag;
  }
  return false;
}
Пример #25
0
void IntegerEdit::accept() {
    save();
}
Пример #26
0
void AcceptDialog::apply(ICQUser*)
{
    save(pClient->owner);
}
Пример #27
0
QString Path::save(int game)
{
	return save(QString::number(game) + ".xml");
}
Пример #28
0
int main_train(int argc, char **argv)
{
    char *posSplFile = NULL;
    char *negSplFile = NULL;
    char *modelFile = NULL;

    int stage = 15;
    int width = 0, height = 0;
    int numPos = 0, numNeg = 0;
    const int numVal = 400;

    float tarfpr = 0.05;
    float maxfnr = 0.05;

    std::vector<std::string> negImgList;

    if((argc - 1) / 2 != 10)
    {
        print_train_usage(argv[0]);
        return 1;
    }

    for(int i = 1; i < argc; i++)
    {
        if(strcmp(argv[i], "--stage") == 0)
            stage = atoi(argv[++i]);

        else if(strcmp(argv[i], "-X") == 0)
            width = atoi(argv[++i]);

        else if(strcmp(argv[i], "-Y") == 0)
            height = atoi(argv[++i]);

        else if(strcmp(argv[i], "--false_alarm_rate") == 0)
            tarfpr = atof(argv[++i]);

        else if(strcmp(argv[i], "--missing_rate") == 0)
            maxfnr = atof(argv[++i]);

        else if(strcmp(argv[i], "--pos") == 0)
            posSplFile = argv[++i];

        else if(strcmp(argv[i], "--neg") == 0)
            negSplFile = argv[++i];

        else if(strcmp(argv[i], "-m") == 0)
            modelFile = argv[++i];

        else if(strcmp(argv[i], "--numPos"))
            numPos = atoi(argv[++i]);

        else if(strcmp(argv[i], "--numNeg"))
            numNeg = atoi(argv[++i]);

        else
        {
            printf("Can't recognize params %s\n", argv[i]);
            print_train_usage(argv[0]);
            return 1;
        }
    }

    if(posSplFile == NULL || negSplFile == NULL || width == 0 || height == 0 || numPos <= 0 || numNeg <= 0){
        print_train_usage(argv[0]);
        return 1;
    }

    std::list<float *> positiveSet, negativeSet, validateSet;
    int ret;
    std::vector<Feature*> featureSet;
    float *stepFPR;
    float npRatio = 1.0 * numNeg / numPos;

    CascadeClassifier *cc = new CascadeClassifier();
    StrongClassifier* sc;
    float maxfpr = 1.0;

    std::list<StrongClassifier *> scs;
    init_cascade_classifier(cc, scs, width, height);

    printf("GENERATE POSITIVE SAMPLES\n");
    ret = generate_positive_samples(posSplFile, positiveSet, width, height, numPos);
    if(ret != 0) return 2;

    printf("GENERATE NEGATIVE SAMPLES\n");
    read_image_list(negSplFile, negImgList);

    for(int i = 0; i < numNeg; i ++)
    {
        float *data = NULL;
        read_neg_sample_from_file(negImgList, width, height, &data);

#ifdef USE_HAAR_FEATURE
        integral_image(data, width, height);
#endif
        negativeSet.push_back(data);
    }


    printf("GENERATE VALIDATE SAMPLES\n");
    generate_validate_samples(negImgList, width, height, validateSet, numPos);

    printf("Positive sample size: %ld\n", positiveSet.size());
    printf("Negative sample size: %ld\n", negativeSet.size());
    printf("Validate sample size: %d\n", numVal);

    printf("GENERATE FEATURE TEMPLATE\n");
    generate_feature_set(featureSet, width, height);

    printf("SELECT FEATURE TEMPLATE\n");
    select_feature(featureSet, positiveSet, validateSet, width);

    init_steps_false_positive(&stepFPR, stage, tarfpr);

    clock_t startTime = clock();
    char outname[128];

    for(int i = 0; i < stage; i++)
    {
        printf("\n--------------cascade stage %d-----------------\n", i+1);

        int correctSize = 0;

        std::list<float*>::iterator iter, iterEnd;

        numNeg = numPos * npRatio;
        printf("READ NEGATIVE SAMPLES\n");
        ret = generate_negative_samples(negImgList, width, height, cc, negativeSet, numNeg);
        if(ret != numNeg) {
            printf("Can't generate enough negatvie samples %d:%d\n", ret, numNeg);
            break;
        }

        printf("READ VALIDATE SAMPLES\n");
        ret = generate_negative_samples(negImgList, width, height, cc, validateSet, numVal);
        if(ret != numVal) {
            printf("Can't generate enough validate samples %d:%d\n", ret, numVal);
            break;
        }

        maxfpr *= stepFPR[i];

        printf("Positive sample size: %d\n", numPos);
        printf("Negative sample size: %d\n", numNeg);
        printf("Target false positive rate: %f\n", maxfpr);
        printf("Target false negative rate: %f\n", maxfnr);

        sc = adaboost_learning(cc, positiveSet, numPos, negativeSet, numNeg, validateSet, featureSet, maxfpr, maxfnr);
        add(cc, sc);

        iter = positiveSet.begin();
        iterEnd = positiveSet.end();

        while(iter != iterEnd)
        {
            if(classify(cc, *iter, width, 0, 0) == 0)
            {
                std::list<float*>::iterator iterTmp = iter;
                iter++;
                delete[] (*iterTmp);
                positiveSet.erase(iterTmp);
                iter--;
            }

            iter++;
        }

        numPos = positiveSet.size();
        printf("cascade TP: %d\n", numPos);

        iter = negativeSet.begin();
        iterEnd = negativeSet.end();

        correctSize = negativeSet.size();

        while(iter != iterEnd)
        {
            if(classify(cc, *iter, width, 0, 0) == 0)
            {
                std::list<float*>::iterator iterTmp = iter;
                iter++;
                delete[] (*iterTmp);
                negativeSet.erase(iterTmp);
                iter--;
            }

            iter++;
        }

        printf("cascade TN: %ld\n", correctSize - negativeSet.size());

        iter = validateSet.begin();
        iterEnd = validateSet.end();
        while(iter != iterEnd)
        {
            if(classify(cc, *iter, width, 0, 0) == 0)
            {
                std::list<float*>::iterator iterTmp = iter;
                iter++;
                delete[] (*iterTmp);
                validateSet.erase(iterTmp);
                iter--;
            }

            iter++;
        }

        printf("----------------------------------------\n");

        sprintf(outname, "model/cascade_%d.dat", i+1);
        save(cc, outname);

#ifdef SHOW_FEATURE
        print_feature(cc);
#endif
    }

    save(cc, modelFile);

    clock_t trainTime = clock() - startTime;

    printf("Train time:");
    print_time(trainTime);
    printf("\n");
    clear(cc);

    clear_list(positiveSet);
    clear_list(negativeSet);
    clear_list(validateSet);

    clear_features(featureSet);

    return 0;
}
Пример #29
0
static void read_string (LexState *LS, int del, SemInfo *seminfo) {
  size_t l = 0;
  checkbuffer(LS, l);
  save_and_next(LS, l);
  while (LS->current != del) {
    checkbuffer(LS, l);
    switch (LS->current) {
      case EOZ:
        save(LS, '\0', l);
        luaX_lexerror(LS, "unfinished string", TK_EOS);
        break;  /* to avoid warnings */
      case '\n':
        save(LS, '\0', l);
        luaX_lexerror(LS, "unfinished string", TK_STRING);
        break;  /* to avoid warnings */
      case '\\':
        next(LS);  /* do not save the `\' */
        switch (LS->current) {
          case 'a': save(LS, '\a', l); next(LS); break;
          case 'b': save(LS, '\b', l); next(LS); break;
          case 'f': save(LS, '\f', l); next(LS); break;
          case 'n': save(LS, '\n', l); next(LS); break;
          case 'r': save(LS, '\r', l); next(LS); break;
          case 't': save(LS, '\t', l); next(LS); break;
          case 'v': save(LS, '\v', l); next(LS); break;
          case '\n': save(LS, '\n', l); inclinenumber(LS); break;
          case EOZ: break;  /* will raise an error next loop */
          default: {
            if (!isdigit(LS->current))
              save_and_next(LS, l);  /* handles \\, \", \', and \? */
            else {  /* \xxx */
              int c = 0;
              int i = 0;
              do {
                c = 10*c + (LS->current-'0');
                next(LS);
              } while (++i<3 && isdigit(LS->current));
              if (c > UCHAR_MAX) {
                save(LS, '\0', l);
                luaX_lexerror(LS, "escape sequence too large", TK_STRING);
              }
              save(LS, c, l);
            }
          }
        }
        break;
      default:
        save_and_next(LS, l);
    }
  }
  save_and_next(LS, l);  /* skip delimiter */
  save(LS, '\0', l);
  seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 1, l - 3);
}
Пример #30
0
void Kandy::fileSave()
{
    if(mFilename.isEmpty()) fileSaveAs();
    else save(mFilename);
}