void DecodeRLE(const uint8_t* data, std::size_t size, Dump& result) { Dump tmp; tmp.reserve(MAX_SECTOR_SIZE); ByteStream stream(data, size); while (!stream.Eof()) { const uint_t len = 2 * stream.GetByte(); Require(!stream.Eof()); const uint_t count = stream.GetByte(); Require(count != 0); const bool isRLE = len != 0; const uint_t blockSize = isRLE ? len : count; Require(stream.GetRestBytes() >= blockSize); for (uint_t idx = 0; idx != blockSize; ++idx) { tmp.push_back(stream.GetByte()); } if (isRLE) { Require(CopyFromBack(len, tmp, len * (count - 1))); } } result.swap(tmp); }
void ApplyInsertions(Dump& result) const { if (0 == SizeAddon) { return; } Dump tmp(result.size() + SizeAddon); Dump::const_iterator src = result.begin(); const Dump::const_iterator srcEnd = result.end(); auto dst = tmp.begin(); std::size_t oldOffset = 0; for (const auto& ins : Insertions) { if (const std::size_t toCopy = ins.first - oldOffset) { const Dump::const_iterator nextEnd = src + toCopy; dst = std::copy(src, nextEnd, dst); src = nextEnd; oldOffset += toCopy; } dst = std::copy(ins.second.begin(), ins.second.end(), dst); } std::copy(src, srcEnd, dst); result.swap(tmp); }
void DisplayDevice::dump(Dump& d) { d.append("-------------------------------------------------------------\n"); d.append("Device Name: %s (%s)\n", mName, mConnection ? "connected" : "disconnected"); d.append("Display configs (count = %d):\n", mDisplayConfigs.size()); d.append(" CONFIG | VSYNC_PERIOD | WIDTH | HEIGHT | DPI_X | DPI_Y \n"); d.append("--------+--------------+-------+--------+-------+-------\n"); for (size_t i = 0; i < mDisplayConfigs.size(); i++) { DisplayConfig *config = mDisplayConfigs.itemAt(i); if (config) { d.append("%s %2d | %4d | %5d | %4d | %3d | %3d \n", (i == (size_t)mActiveDisplayConfig) ? "* " : " ", i, config->getRefreshRate(), config->getWidth(), config->getHeight(), config->getDpiX(), config->getDpiY()); } } // dump layer list if (mLayerList) mLayerList->dump(d); }
void dsp::SingleThread::insert_dump_point (const std::string& transform_name) { typedef HasInput<TimeSeries> Xform; for (unsigned iop=0; iop < operations.size(); iop++) { if (operations[iop]->get_name() == transform_name) { Xform* xform = dynamic_cast<Xform*>( operations[iop].get() ); if (!xform) throw Error (InvalidParam, "dsp::SingleThread::insert_dump_point", transform_name + " does not have TimeSeries input"); string filename = "pre_" + transform_name; if (config->get_total_nthread() > 1) filename += "." + tostring (thread_id); filename += ".dump"; cerr << "dspsr: dump output in " << filename << endl; Dump* dump = new Dump; dump->set_output( fopen(filename.c_str(), "w") ); dump->set_input( xform->get_input() ) ; dump->set_output_binary (true); operations.insert (operations.begin()+iop, dump); iop++; } } }
void GetResult(Dump& data) const override { Dump rawDump; Delegate->GetResult(rawDump); Require(0 == rawDump.size() % Registers::TOTAL); const uint32_t framesCount = rawDump.size() / Registers::TOTAL; const uint_t storedRegisters = Registers::TOTAL; const String& title = Params->Title(); const String author = Params->Author(); const uint32_t headerSize = sizeof(FYMHeader) + (title.size() + 1) + (author.size() + 1); const std::size_t contentSize = framesCount * storedRegisters; Binary::DataBuilder builder(headerSize + contentSize); FYMHeader& header = builder.Add<FYMHeader>(); header.HeaderSize = fromLE(headerSize); header.FramesCount = fromLE(framesCount); header.LoopFrame = fromLE(static_cast<uint32_t>(Params->LoopFrame())); header.PSGFreq = fromLE(static_cast<uint32_t>(Params->ClockFreq())); header.IntFreq = fromLE(static_cast<uint32_t>(Time::GetFrequencyForPeriod(Params->FrameDuration()))); builder.AddCString(title); builder.AddCString(author); for (uint_t reg = 0; reg < storedRegisters; ++reg) { uint8_t* const result = static_cast<uint8_t*>(builder.Allocate(framesCount)); for (uint_t frm = 0, inOffset = reg; frm < framesCount; ++frm, inOffset += Registers::TOTAL) { result[frm] = rawDump[inOffset]; } } Dump result; builder.CaptureResult(result); Binary::Compression::Zlib::Compress(result, data); }
bool DecodeData() { const uint8_t* const rawData = static_cast<const uint8_t*>(Header.ID); const std::size_t dataOffset = fromLE(Header.DataOffset); const uint_t cylinders = fromLE(Header.Cylinders); const uint_t sides = fromLE(Header.Sides); Dump result; result.reserve(FDI_MAX_SIZE); std::size_t trackInfoOffset = sizeof(Header) + fromLE(Header.InfoSize); std::size_t rawSize = dataOffset; for (uint_t cyl = 0; cyl != cylinders; ++cyl) { for (uint_t sid = 0; sid != sides; ++sid) { if (trackInfoOffset + sizeof(RawTrack) > Limit) { return false; } const RawTrack* const trackInfo = safe_ptr_cast<const RawTrack*>(rawData + trackInfoOffset); typedef std::vector<SectorDescr> SectorDescrs; //collect sectors reference SectorDescrs sectors; sectors.reserve(trackInfo->SectorsCount); for (std::size_t secNum = 0; secNum != trackInfo->SectorsCount; ++secNum) { const RawTrack::Sector* const sector = trackInfo->Sectors + secNum; const std::size_t secSize = 128 << sector->Size; //since there's no information about head number (always 0), do not check it //assert(sector->Head == sid); if (sector->Cylinder != cyl) { return false; } const std::size_t offset = dataOffset + fromLE(sector->Offset) + fromLE(trackInfo->Offset); if (offset + secSize > Limit) { return false; } sectors.push_back(SectorDescr(sector->Number, rawData + offset, rawData + offset + secSize)); rawSize = std::max(rawSize, offset + secSize); } //sort by number std::sort(sectors.begin(), sectors.end()); //and gather data for (SectorDescrs::const_iterator it = sectors.begin(), lim = sectors.end(); it != lim; ++it) { result.insert(result.end(), it->Begin, it->End); } //calculate next track by offset trackInfoOffset += sizeof(*trackInfo) + (trackInfo->SectorsCount - 1) * sizeof(trackInfo->Sectors); } } UsedSize = rawSize; Decoded.swap(result); return true; }
bool IsInfoEmpty(const Dump& info) { assert(info.size() == 53); //28 is fixed //25 is title const Dump::const_iterator titleStart = info.begin() + 28; return info.end() == std::find_if(titleStart, info.end(), std::bind2nd(std::greater<Char>(), Char(' '))); }
void WriteDump::command(int narg, char **arg) { if (narg < 3) error->all(FLERR,"Illegal write_dump command"); // modindex = index in args of "modify" keyword // will be narg if "modify" is not present int modindex; for (modindex = 0; modindex < narg; modindex++) if (strcmp(arg[modindex],"modify") == 0) break; // create the Dump instance // create dump command line with extra required args Dump *dump; char **dumpargs = new char*[modindex+2]; dumpargs[0] = (char *) "WRITE_DUMP"; // dump id dumpargs[1] = arg[0]; // group dumpargs[2] = arg[1]; // dump style dumpargs[3] = (char *) "0"; // dump frequency for (int i = 2; i < modindex; ++i) dumpargs[i+2] = arg[i]; if (0) return; // dummy line to enable else-if macro expansion #define DUMP_CLASS #define DumpStyle(key,Class) \ else if (strcmp(arg[1],#key) == 0) dump = new Class(lmp,modindex+2,dumpargs); #include "style_dump.h" #undef DUMP_CLASS else error->all(FLERR,"Unknown dump style"); if (modindex < narg) dump->modify_params(narg-modindex-1,&arg[modindex+1]); // write out one frame and then delete the dump again // set multifile_override for DumpImage so that filename needs no "*" if (strcmp(arg[1],"image") == 0) ((DumpImage *) dump)->multifile_override = 1; if (strcmp(arg[1],"cfg") == 0) ((DumpCFG *) dump)->multifile_override = 1; dump->init(); dump->write(); // delete the Dump instance and local storage delete dump; delete [] dumpargs; }
void DecodeR2P(const uint8_t* data, std::size_t size, Dump& result) { Require(size % sizeof(R2PEntry) == 0); Dump tmp; tmp.reserve(MAX_SECTOR_SIZE); for (const R2PEntry* it = safe_ptr_cast<const R2PEntry*>(data), *lim = it + size / sizeof(*it); it != lim; ++it) { const uint_t count = fromLE(it->Count); Require(count != 0); tmp.push_back(it->Data[0]); tmp.push_back(it->Data[1]); Require(CopyFromBack(sizeof(it->Data), tmp, sizeof(it->Data) * (count - 1))); } result.swap(tmp); }
void BufferManager::dump(Dump& d) { d.append("Buffer Manager status: pool size %d\n", mBufferPool->getCacheSize()); d.append("-------------------------------------------------------------\n"); for (size_t i = 0; i < mBufferPool->getCacheSize(); i++) { BufferMapper *mapper = mBufferPool->getMapper(i); d.append("Buffer %d: handle %#x, (%dx%d), format %d, refCount %d\n", i, mapper->getHandle(), mapper->getWidth(), mapper->getHeight(), mapper->getFormat(), mapper->getRef()); } return; }
void ApplyOverwrites(Dump& result) const { for (const auto& over : Overwrites) { std::copy(over.second.begin(), over.second.end(), result.begin() + over.first); } }
void DecodeBlock(Binary::InputStream& stream, std::size_t srcSize, Dump& dst) { const std::size_t LOOKUP = 1; const uint8_t* const src = stream.ReadData(LOOKUP); const std::size_t used = DecodeBlock(src, srcSize, &dst[0], dst.size()); stream.ReadData(used - LOOKUP); }
void OnSector(const Formats::CHS& loc, const uint8_t* rawData, std::size_t rawSize, SectorDataType type, std::size_t targetSize) override { Dump result; switch (type) { case RAW_SECTOR: result.assign(rawData, rawData + rawSize); break; case R2P_SECTOR: DecodeR2P(rawData, rawSize, result); break; case RLE_SECTOR: DecodeRLE(rawData, rawSize, result); break; } Require(result.size() == targetSize); Builder->SetSector(loc, result); }
Container::Ptr Decode(const Binary::Container& rawData) const override { using namespace CompiledSTP; if (!Player->Match(rawData)) { return Container::Ptr(); } const Binary::TypedContainer typedData(rawData); const std::size_t availSize = rawData.Size(); const typename Version::RawPlayer& rawPlayer = *typedData.GetField<typename Version::RawPlayer>(0); const std::size_t playerSize = rawPlayer.GetSize(); if (playerSize >= std::min(availSize, CompiledSTP::MAX_PLAYER_SIZE)) { Dbg("Invalid player"); return Container::Ptr(); } Dbg("Detected player in first %1% bytes", playerSize); const std::size_t modDataSize = std::min(CompiledSTP::MAX_MODULE_SIZE, availSize - playerSize); const Binary::Container::Ptr modData = rawData.GetSubcontainer(playerSize, modDataSize); const Dump metainfo = rawPlayer.GetInfo(); if (CompiledSTP::IsInfoEmpty(metainfo)) { Dbg("Player has empty metainfo"); if (const Binary::Container::Ptr originalModule = Formats::Chiptune::SoundTrackerPro::ParseCompiled(*modData, Formats::Chiptune::SoundTrackerPro::GetStubBuilder())) { const std::size_t originalSize = originalModule->Size(); return CreateContainer(originalModule, playerSize + originalSize); } } else if (const Binary::Container::Ptr fixedModule = Formats::Chiptune::SoundTrackerPro::InsertMetaInformation(*modData, metainfo)) { if (Formats::Chiptune::SoundTrackerPro::ParseCompiled(*fixedModule, Formats::Chiptune::SoundTrackerPro::GetStubBuilder())) { const std::size_t originalSize = fixedModule->Size() - metainfo.size(); return CreateContainer(fixedModule, playerSize + originalSize); } Dbg("Failed to parse fixed module"); } Dbg("Failed to find module after player"); return Container::Ptr(); }
void AddData(const Dump& registers) override { Devices::AYM::Registers& data = Data->Allocate(); const uint_t availRegs = std::min<uint_t>(registers.size(), Devices::AYM::Registers::ENV + 1); for (uint_t reg = 0, mask = 1; reg != availRegs; ++reg, mask <<= 1) { const uint8_t val = registers[reg]; if (reg != Devices::AYM::Registers::ENV || val != 0xff) { data[static_cast<Devices::AYM::Registers::Index>(reg)] = val; } } }
void HwcLayerList::dump(Dump& d) { d.append("Layer list: (number of layers %d):\n", mLayers.size()); d.append(" LAYER | TYPE | PLANE INDEX \n"); d.append("-------+------------+----------------\n"); for (size_t i = 0; i < mLayers.size(); i++) { HwcLayer *hwcLayer = mLayers.itemAt(i); IDisplayPlane *plane; int planeIndex = -1; const char *type; if (hwcLayer) { switch (hwcLayer->getType()) { case HwcLayer::LAYER_FB: type = "FB"; break; case HwcLayer::LAYER_SPRITE: type = "Sprite"; break; case HwcLayer::LAYER_OVERLAY: type = "Overlay"; break; case HwcLayer::LAYER_PRIMARY: type = "Primary"; break; default: type = "Unknown"; } plane = hwcLayer->getPlane(); if (plane) planeIndex = plane->getIndex(); d.append(" %2d | %8s |%10D \n", i, type, planeIndex); } } }
void DisplayPlaneManager::dump(Dump& d) { d.append("Display Plane Manager state:\n"); d.append("-------------------------------------------------------------\n"); d.append(" PLANE TYPE | COUNT | FREE | RECLAIMED \n"); d.append("------------+-------+----------+-----------\n"); d.append(" SPRITE | %2d | %08x | %08x\n", mPlaneCount[DisplayPlane::PLANE_SPRITE], mFreePlanes[DisplayPlane::PLANE_SPRITE], mReclaimedPlanes[DisplayPlane::PLANE_SPRITE]); d.append(" OVERLAY | %2d | %08x | %08x\n", mPlaneCount[DisplayPlane::PLANE_OVERLAY], mFreePlanes[DisplayPlane::PLANE_OVERLAY], mReclaimedPlanes[DisplayPlane::PLANE_OVERLAY]); d.append(" PRIMARY | %2d | %08x | %08x\n", mPlaneCount[DisplayPlane::PLANE_PRIMARY], mFreePlanes[DisplayPlane::PLANE_PRIMARY], mReclaimedPlanes[DisplayPlane::PLANE_PRIMARY]); d.append(" CURSOR | %2d | %08x | %08x\n", mPlaneCount[DisplayPlane::PLANE_CURSOR], mFreePlanes[DisplayPlane::PLANE_CURSOR], mReclaimedPlanes[DisplayPlane::PLANE_CURSOR]); }
int main( int argc , char ** argv ) { Dump d; return d.main( argc , argv ); }
int main( int argc , char ** argv, char ** envp ) { mongo::runGlobalInitializersOrDie(argc, argv, envp); Dump d; return d.main( argc , argv ); }
void OverwriteData(std::size_t offset, const Dump& data) override { Require(offset + data.size() <= Source.Size()); Require(Overwrites.insert(BlobsMap::value_type(offset, data)).second); }
void InsertData(std::size_t offset, const Dump& data) override { Require(Insertions.insert(BlobsMap::value_type(offset, data)).second); SizeAddon += data.size(); }
void AddData(const Dump& str) { std::copy(str.begin(), str.end(), std::back_inserter(Data)); }
int main(int argc, char *argv[]) { synth = new SYNTH_T; config.init(); dump.startnow(); int noui = 0; cerr << "\nZynAddSubFX - Copyright (c) 2002-2011 Nasca Octavian Paul and others" << endl; cerr << "Compiled: " << __DATE__ << " " << __TIME__ << endl; cerr << "This program is free software (GNU GPL v.2 or later) and \n"; cerr << "it comes with ABSOLUTELY NO WARRANTY.\n" << endl; if(argc == 1) cerr << "Try 'zynaddsubfx --help' for command-line options." << endl; /* Get the settings from the Config*/ synth->samplerate = config.cfg.SampleRate; synth->buffersize = config.cfg.SoundBufferSize; synth->oscilsize = config.cfg.OscilSize; swaplr = config.cfg.SwapStereo; Nio::preferedSampleRate(synth->samplerate); synth->alias(); //build aliases sprng(time(NULL)); /* Parse command-line options */ struct option opts[] = { { "load", 2, NULL, 'l' }, { "load-instrument", 2, NULL, 'L' }, { "sample-rate", 2, NULL, 'r' }, { "buffer-size", 2, NULL, 'b' }, { "oscil-size", 2, NULL, 'o' }, { "dump", 2, NULL, 'D' }, { "swap", 2, NULL, 'S' }, { "no-gui", 2, NULL, 'U' }, { "dummy", 2, NULL, 'Y' }, { "help", 2, NULL, 'h' }, { "version", 2, NULL, 'v' }, { "named", 1, NULL, 'N' }, { "auto-connect", 0, NULL, 'a' }, { "output", 1, NULL, 'O' }, { "input", 1, NULL, 'I' }, { "exec-after-init", 1, NULL, 'e' }, { 0, 0, 0, 0 } }; opterr = 0; int option_index = 0, opt, exitwithhelp = 0, exitwithversion = 0; string loadfile, loadinstrument, execAfterInit; while(1) { int tmp = 0; /**\todo check this process for a small memory leak*/ opt = getopt_long(argc, argv, "l:L:r:b:o:I:O:N:e:hvaSDUY", opts, &option_index); char *optarguments = optarg; #define GETOP(x) if(optarguments) \ x = optarguments #define GETOPNUM(x) if(optarguments) \ x = atoi(optarguments) if(opt == -1) break; switch(opt) { case 'h': exitwithhelp = 1; break; case 'v': exitwithversion = 1; break; case 'Y': /* this command a dummy command (has NO effect) and is used because I need for NSIS installer (NSIS sometimes forces a command line for a program, even if I don't need that; eg. when I want to add a icon to a shortcut. */ break; case 'U': noui = 1; break; case 'l': GETOP(loadfile); break; case 'L': GETOP(loadinstrument); break; case 'r': GETOPNUM(synth->samplerate); if(synth->samplerate < 4000) { cerr << "ERROR:Incorrect sample rate: " << optarguments << endl; exit(1); } break; case 'b': GETOPNUM(synth->buffersize); if(synth->buffersize < 2) { cerr << "ERROR:Incorrect buffer size: " << optarguments << endl; exit(1); } break; case 'o': if(optarguments) synth->oscilsize = tmp = atoi(optarguments); if(synth->oscilsize < MAX_AD_HARMONICS * 2) synth->oscilsize = MAX_AD_HARMONICS * 2; synth->oscilsize = (int) powf(2, ceil(logf(synth->oscilsize - 1.0f) / logf(2.0f))); if(tmp != synth->oscilsize) cerr << "synth->oscilsize is wrong (must be 2^n) or too small. Adjusting to " << synth->oscilsize << "." << endl; break; case 'S': swaplr = 1; break; case 'D': dump.startnow(); break; case 'N': Nio::setPostfix(optarguments); break; case 'I': if(optarguments) Nio::setDefaultSource(optarguments); break; case 'O': if(optarguments) Nio::setDefaultSink(optarguments); break; case 'a': Nio::autoConnect = true; break; case 'e': GETOP(execAfterInit); break; case '?': cerr << "ERROR:Bad option or parameter.\n" << endl; exitwithhelp = 1; break; } } synth->alias(); if(exitwithversion) { cout << "Version: " << VERSION << endl; return 0; } if(exitwithhelp != 0) { cout << "Usage: zynaddsubfx [OPTION]\n\n" << " -h , --help \t\t\t\t Display command-line help and exit\n" << " -v , --version \t\t\t Display version and exit\n" << " -l file, --load=FILE\t\t\t Loads a .xmz file\n" << " -L file, --load-instrument=FILE\t Loads a .xiz file\n" << " -r SR, --sample-rate=SR\t\t Set the sample rate SR\n" << " -b BS, --buffer-size=SR\t\t Set the buffer size (granularity)\n" << " -o OS, --oscil-size=OS\t\t Set the ADsynth oscil. size\n" << " -S , --swap\t\t\t\t Swap Left <--> Right\n" << " -D , --dump\t\t\t\t Dumps midi note ON/OFF commands\n" << " -U , --no-gui\t\t\t\t Run ZynAddSubFX without user interface\n" << " -N , --named\t\t\t\t Postfix IO Name when possible\n" << " -a , --auto-connect\t\t\t AutoConnect when using JACK\n" << " -O , --output\t\t\t\t Set Output Engine\n" << " -I , --input\t\t\t\t Set Input Engine\n" << " -e , --exec-after-init\t\t Run post-initialization script\n" << endl; return 0; } //produce denormal buf denormalkillbuf = new float [synth->buffersize]; for(int i = 0; i < synth->buffersize; ++i) denormalkillbuf[i] = (RND - 0.5f) * 1e-16; initprogram(); if(!loadfile.empty()) { int tmp = master->loadXML(loadfile.c_str()); if(tmp < 0) { cerr << "ERROR: Could not load master file " << loadfile << "." << endl; exit(1); } else { master->applyparameters(); cout << "Master file loaded." << endl; } } if(!loadinstrument.empty()) { int loadtopart = 0; int tmp = master->part[loadtopart]->loadXMLinstrument( loadinstrument.c_str()); if(tmp < 0) { cerr << "ERROR: Could not load instrument file " << loadinstrument << '.' << endl; exit(1); } else { master->part[loadtopart]->applyparameters(); cout << "Instrument file loaded." << endl; } } //Run the Nio system bool ioGood = Nio::start(); if(!execAfterInit.empty()) { cout << "Executing user supplied command: " << execAfterInit << endl; if(system(execAfterInit.c_str()) == -1) cerr << "Command Failed..." << endl; } #ifndef DISABLE_GUI #ifdef NTK_GUI fl_register_images(); Fl_Tooltip::textcolor(0x0); Fl_Dial::default_style(Fl_Dial::PIXMAP_DIAL); if(Fl_Shared_Image *img = Fl_Shared_Image::get(PIXMAP_PATH "/knob.png")) Fl_Dial::default_image(img); else Fl_Dial::default_image(Fl_Shared_Image::get(SOURCE_DIR "/../pixmaps/knob.png")); if(Fl_Shared_Image *img = Fl_Shared_Image::get(PIXMAP_PATH "/window_backdrop.png")) Fl::scheme_bg(new Fl_Tiled_Image(img)); else Fl::scheme_bg(new Fl_Tiled_Image(Fl_Shared_Image::get(SOURCE_DIR "/../pixmaps/window_backdrop.png"))); if(Fl_Shared_Image *img = Fl_Shared_Image::get(PIXMAP_PATH "/module_backdrop.png")) module_backdrop = new Fl_Tiled_Image(img); else module_backdrop = new Fl_Tiled_Image(Fl_Shared_Image::get(SOURCE_DIR "/../pixmaps/module_backdrop.png")); Fl::background( 50, 50, 50 ); Fl::background2( 70, 70, 70 ); Fl::foreground( 255,255,255 ); #endif ui = new MasterUI(master, &Pexitprogram); if ( !noui) { ui->showUI(); if(!ioGood) fl_alert( "Default IO did not initialize.\nDefaulting to NULL backend."); } #endif #ifndef DISABLE_GUI #if USE_NSM char *nsm_url = getenv("NSM_URL"); if(nsm_url) { nsm = new NSM_Client; if(!nsm->init(nsm_url)) nsm->announce("ZynAddSubFX", ":switch:", argv[0]); else { delete nsm; nsm = NULL; } } #endif #endif #if USE_NSM if(!nsm) #endif { #if LASH lash = new LASHClient(&argc, &argv); #ifndef DISABLE_GUI ui->sm_indicator1->value(1); ui->sm_indicator2->value(1); ui->sm_indicator1->tooltip("LASH"); ui->sm_indicator2->tooltip("LASH"); #endif #endif } while(Pexitprogram == 0) { #ifndef DISABLE_GUI #if USE_NSM if(nsm) { nsm->check(); goto done; } #endif #if LASH { string filename; switch(lash->checkevents(filename)) { case LASHClient::Save: ui->do_save_master(filename.c_str()); lash->confirmevent(LASHClient::Save); break; case LASHClient::Restore: ui->do_load_master(filename.c_str()); lash->confirmevent(LASHClient::Restore); break; case LASHClient::Quit: Pexitprogram = 1; default: break; } } #endif //LASH #if USE_NSM done: #endif Fl::wait(0.02f); #else usleep(100000); #endif } exitprogram(); return 0; }