static void finishClass(void) { SYMBOL *self = makeID(sc_localstatic, &stdpointer, NULL, "$self"); HASHREC *lst; if (lambdas->captureThis && lambdas->next) { SYMBOL *parent = makeID(sc_member, &stdpointer, NULL, "$parent"); lambda_insert(parent, lambdas); } self->label = nextLabel++; insert(self, lambdas->cls->tp->syms); insertInitSym(self); createConstructorsForLambda(lambdas->cls); insertFunc(lambdas->cls, lambdas->func); createConverter(self); if (!lambdas->isMutable) { TYPE *tp2 = Alloc(sizeof(TYPE)); tp2->type = bt_const; tp2->size = lambdas->func->tp->size; tp2->btp = lambdas->func->tp; lambdas->func->tp = tp2; } createCaller(); }
cacheItem* WCache<cacheItem, cacheActual>::Retrieve(int id, const string& filename, int style, int submode) { //Check cache. mError = CACHE_ERROR_NONE; //Reset error status. cacheItem* tc = Get(id, filename, style, submode); //Retrieve resource only works on permanent items. if (style == RETRIEVE_RESOURCE && tc && !tc->isPermanent()) { mError = CACHE_ERROR_NOT_MANAGED; return NULL; } //Perform lock or unlock on entry. if (tc) { switch (style) { case RETRIEVE_LOCK: tc->lock(); break; case RETRIEVE_UNLOCK: tc->unlock(); break; case RETRIEVE_MANAGE: if (!tc->isPermanent()) { //Unlink the managed resource from the cache. UnlinkCache(tc); //Post it in managed resources. managed[makeID(id, filename, submode)] = tc; tc->deadbolt(); } break; } } //Resource exists! if (tc) { if (tc->isGood()) { tc->hit(); return tc; //Everything fine. } //Something went wrong. RemoveItem(tc); mError = CACHE_ERROR_BAD; } //Record managed failure. Cache failure is recorded in Get(). if ((style == RETRIEVE_MANAGE || style == RETRIEVE_RESOURCE) && mError == CACHE_ERROR_404) managed[makeID(id, filename, submode)] = NULL; return NULL; }
bool MidiImport::tryImport( TrackContainer* tc ) { if( openFile() == false ) { return false; } #ifdef LMMS_HAVE_FLUIDSYNTH if( gui != NULL && ConfigManager::inst()->defaultSoundfont().isEmpty() ) { QMessageBox::information( gui->mainWindow(), tr( "Setup incomplete" ), tr( "You do not have set up a default soundfont in " "the settings dialog (Edit->Settings). " "Therefore no sound will be played back after " "importing this MIDI file. You should download " "a General MIDI soundfont, specify it in " "settings dialog and try again." ) ); } #else if( gui ) { QMessageBox::information( gui->mainWindow(), tr( "Setup incomplete" ), tr( "You did not compile LMMS with support for " "SoundFont2 player, which is used to add default " "sound to imported MIDI files. " "Therefore no sound will be played back after " "importing this MIDI file." ) ); } #endif switch( readID() ) { case makeID( 'M', 'T', 'h', 'd' ): printf( "MidiImport::tryImport(): found MThd\n"); return readSMF( tc ); case makeID( 'R', 'I', 'F', 'F' ): printf( "MidiImport::tryImport(): found RIFF\n"); return readRIFF( tc ); default: printf( "MidiImport::tryImport(): not a Standard MIDI " "file\n" ); return false; } }
static void addEngineering (UnitData* eng) { char fields[4][16] = {"DataCx", "DataDx", "DataEx", "DataFx"}; int levels = eng->getIntData ("levels"); for (int i = 0; i < levels; i++) { for (int j = 0; j < 4; j++) { fields[j][5] = '1' + i; char const* src = eng->getStringData (fields[j], 0); char const* dst = eng->getStringData (fields[j], 1); int srci = getValue (dir, src); int abil = (srci - 1) / 5; if (srci > 0 && abil < numAbilities) { int abil = (srci - 1) / 5; int dstv = makeID (dst); bool hasID = false; for (int k = 0; k < abilities[abil].numIds; k++) if (abilities[abil].ids[k] == dstv) hasID = true; if (!hasID) { abilities[abil].ids[abilities[abil].numIds++] = dstv; dir = addString (dir, dst, srci); } } } } }
static void createCaller(void) { FUNCTIONCALL *params = Alloc(sizeof(FUNCTIONCALL)); TYPE *args = realArgs(lambdas->func); SYMBOL *func = makeID(sc_member, args, NULL, overloadNameTab[CI_FUNC]); SYMBOL *lambdaCall = search(isstructured(basetype(lambdas->func->tp)->btp) ? "__lambdaCallS" : "__lambdaCall", globalNameSpace->syms); BLOCKDATA block1, block2; STATEMENT *st; lambdaCall = (SYMBOL *)lambdaCall->tp->syms->table[0]->p; func->parentClass = lambdas->cls; func->linkage = lk_virtual; func->isInline = FALSE; func->omitFrame = TRUE; memset(&block1, 0, sizeof(BLOCKDATA)); memset(&block2, 0, sizeof(BLOCKDATA)); insertFunc(lambdas->cls, func); InsertInline(func); st = stmtNode(NULL, &block2, isstructured(basetype(lambdas->func->tp)->btp) ? st_expr : st_return); st->select = varNode(en_func, NULL); st->select->v.func = params; params->arguments = Alloc(sizeof(INITLIST)); params->arguments->exp = varNode(en_pc, lambdas->func); params->arguments->tp = &stdpointer; params->ascall = TRUE; params->sp = func; params->fcall = varNode(en_pc, lambdaCall); params->functp = func->tp; st = stmtNode(NULL, &block1, st_block); st->lower = block2.head; st->blockTail = block2.blockTail; func->inlineFunc.stmt = stmtNode(NULL, NULL, st_block); func->inlineFunc.stmt->lower = block1.head; func->inlineFunc.stmt->blockTail = block1.blockTail; }
covise::WSLink::WSLink(covise::WSPort *from, covise::WSPort *to) : QObject(0) , fromPort(from) , toPort(to) { this->id = makeID(from, to); connect(from, SIGNAL(destroyed()), this, SLOT(portDeleted())); connect(to, SIGNAL(destroyed()), this, SLOT(portDeleted())); }
uint64 PortalsPeer::makeID(shared_ptr<IPAddress> address) { if(address == nullptr) { OS_ASSERTFALSE(); return 0; } return makeID(address->toString(), address->getPort()); }
bool MidiImport::readRIFF( TrackContainer* tc ) { // skip file length skip( 4 ); // check file type ("RMID" = RIFF MIDI) if( readID() != makeID( 'R', 'M', 'I', 'D' ) ) { invalid_format: qWarning( "MidiImport::readRIFF(): invalid file format" ); return false; } // search for "data" chunk while( 1 ) { const int id = readID(); const int len = read32LE(); if( file().atEnd() ) { data_not_found: qWarning( "MidiImport::readRIFF(): data chunk not found" ); return false; } if( id == makeID( 'd', 'a', 't', 'a' ) ) { break; } if( len < 0 ) { goto data_not_found; } skip( ( len + 1 ) & ~1 ); } // the "data" chunk must contain data in SMF format if( readID() != makeID( 'M', 'T', 'h', 'd' ) ) { goto invalid_format; } return readSMF( tc ); }
MSE2Collector * MS_E2_ZS_CollectorOverLanes::buildCollector(size_t c, size_t r, MSLane *l, SUMOReal start, SUMOReal end) throw() { std::string id = makeID(l->getID(), c, r); if (start+end<l->getLength()) { start = l->getLength() - end - (SUMOReal) 0.1; } return new MSE2Collector(id, myUsage, l, start, end, haltingTimeThresholdM, haltingSpeedThresholdM, jamDistThresholdM); }
uint64 PortalsPeer::makeID(const String &ip, uint32 port) { try { return makeID(boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(ip.to_ascii()), port)); } catch(std::exception &) { OS_ASSERTFALSE(); } return 0; }
static void createConverter(SYMBOL *self) { SYMBOL *caller = createPtrCaller(self); TYPE *args = realArgs(lambdas->func); SYMBOL *func = makeID(sc_member, Alloc(sizeof(TYPE)), NULL, overloadNameTab[CI_CAST]); BLOCKDATA block1, block2; STATEMENT *st; EXPRESSION *exp; SYMBOL *sym = makeID(sc_parameter, &stdvoid, NULL, AnonymousName()); HASHREC *hr = Alloc(sizeof(HASHREC)); func->tp->type = bt_func; func->tp->btp = Alloc(sizeof(TYPE)); func->tp->btp->type = bt_pointer; func->tp->btp->size = getSize(bt_pointer); func->tp->btp->btp = args; func->tp->syms = CreateHashTable(1); func->linkage = lk_virtual; func->isInline = FALSE; hr->p = (struct _hrintern_ *)sym; func->tp->syms->table[0] = hr; func->parentClass = lambdas->cls; memset(&block1, 0, sizeof(BLOCKDATA)); memset(&block2, 0, sizeof(BLOCKDATA)); func->castoperator = TRUE; insertFunc(lambdas->cls, func); InsertInline(func); InsertInline(caller); st = stmtNode(NULL, &block2, st_return); st->select = varNode(en_pc, caller); st = stmtNode(NULL, &block1, st_block); st->lower = block2.head; st->blockTail = block2. blockTail; func->inlineFunc.stmt = stmtNode(NULL, NULL, st_block); func->inlineFunc.stmt->lower = block1.head; func->inlineFunc.stmt->blockTail = block1.blockTail; }
// fill a ladspa descriptor with the information collected on ports void fillPortDescription (LADSPA_Descriptor * descriptor) { const char* name = sym(mydsp); descriptor->PortCount = fCtrlCount+fInsCount+fOutsCount; descriptor->PortDescriptors = fPortDescs; descriptor->PortNames = fPortNames; descriptor->PortRangeHints = fPortHints; descriptor->Label = strdup(name); descriptor->UniqueID = makeID(name); // descriptor->Label = strdup(fPluginName.c_str()); // descriptor->UniqueID = makeID(fPluginName.c_str()); descriptor->Properties = LADSPA_PROPERTY_HARD_RT_CAPABLE; descriptor->Name = name; // descriptor->Name = strdup(fPluginName.c_str()); descriptor->Maker = "undefined"; descriptor->Copyright = "undefined"; }
// these next two rely on the CONST specifier on the func not being set up yet. static SYMBOL *createPtrCaller(SYMBOL *self) { // if the closure is copied then used on another thread yes the resulting // code can get into a race condition... INITLIST *args; FUNCTIONCALL *params = Alloc(sizeof(FUNCTIONCALL)); TYPE *pargs = realArgs(lambdas->func); SYMBOL *func = makeID(sc_static, pargs, NULL, "$ptrcaller"); SYMBOL *lambdaCall = search(isstructured(basetype(lambdas->func->tp)->btp) ? "__lambdaPtrCallS" : "__lambdaPtrCall", globalNameSpace->syms); BLOCKDATA block1, block2; STATEMENT *st; EXPRESSION *exp = varNode(en_label, self); lambdaCall = (SYMBOL *)lambdaCall->tp->syms->table[0]->p; func->parentClass = lambdas->cls; func->linkage = lk_virtual; func->isInline = FALSE; func->omitFrame = TRUE; deref(&stdpointer, &exp); memset(&block1, 0, sizeof(BLOCKDATA)); memset(&block2, 0, sizeof(BLOCKDATA)); insertFunc(lambdas->cls, func); st = stmtNode(NULL, &block2, isstructured(basetype(lambdas->func->tp)->btp) ? st_expr : st_return); st->select = varNode(en_func, NULL); st->select->v.func = params; params->arguments = Alloc(sizeof(INITLIST)); params->arguments->exp = varNode(en_pc, lambdas->func); params->arguments->tp = &stdpointer; args = Alloc(sizeof(INITLIST)); args->next = params->arguments; params->arguments = args; params->arguments->exp = exp; params->arguments->tp = &stdpointer; params->ascall = TRUE; params->sp = func; params->fcall = varNode(en_pc, lambdaCall); params->functp = func->tp; st = stmtNode(NULL, &block1, st_block); st->lower = block2.head; st->blockTail = block2. blockTail; func->inlineFunc.stmt = stmtNode(NULL, NULL, st_block); func->inlineFunc.stmt->lower = block1.head; func->inlineFunc.stmt->blockTail = block1.blockTail; return func; }
static STATEMENT *SetupArguments(FUNCTIONCALL *params) { STATEMENT *st = NULL, **stp = &st; ARGLIST *al = params->arguments; HASHREC *hr = params->sp->inlineFunc.syms->table[0]; while (al && hr) { SYMBOL *sx; if (al == params->arguments && (params->sp->storage_class == sc_member || params->sp->storage_class == sc_virtual)) { LIST *l = Alloc(sizeof(LIST)); l->next = thisptrs; thisptrs = l; l->data = (void *)(sx = makeID(sc_auto, &stdpointer, NULL, "__$this$__")); } else { sx = (SYMBOL *)hr->p; } if (!sx->altered && !sx->addressTaken && !sideEffects(al->exp)) { // well if the expression is too complicated it gets evaluated over and over // but maybe the backend can clean it up again... sx->inlineFunc.stmt = (STATEMENT *)al->exp; } else { EXPRESSION *tnode = varNode(en_auto, anonymousVar(sc_auto, sx->tp)); deref(sx->tp, &tnode); sx->inlineFunc.stmt = (STATEMENT *)tnode; tnode = exprNode(en_assign, tnode, al->exp); *stp = Alloc(sizeof(STATEMENT)); memset(*stp, 0 , sizeof(STATEMENT)); (*stp)->type = st_expr; (*stp)->select = tnode; stp = &(*stp)->next; } al = al->next; if (hr) hr = hr->next; } return st; }
static void addHero (ObjectData* data, UnitData* hero, int tavern) { DotaHero* ptr = &heroes[numHeroes]; ptr->index = numHeroes++; ptr->tavern = tavern; ptr->ids[0] = hero->getID (); ptr->numIds = 1; ptr->slot = atoi (hero->getStringData ("Buttonpos", 0)) + 4 * atoi (hero->getStringData ("Buttonpos", 1)); ptr->point = atoi (hero->getStringData ("points")); strcpy (ptr->name, hero->getStringData ("Name")); strcpy (ptr->oname, hero->getStringData ("Propernames", 0)); _splitpath (hero->getStringData ("Art"), NULL, NULL, ptr->imgTag, NULL); addNewImage (hero->getStringData ("Art"), true); if (!strcmp (ptr->name, "Silencer")) int asd = 0; for (int i = 0; i < 5; i++) { char const* abils = hero->getStringData ("heroAbilList", i); if (*abils) { int slot = getValue (dir, abils); if (slot == 0) { UnitData* abil = data->getUnitById (abils); if (abil) slot = addAbility (abil); dir = addString (dir, abils, slot + 1); } else slot--; if (slot >= 0) ptr->abils[slot % 5] = makeID (abils); } } }
bool FlpImport::tryFLPImport( trackContainer * _tc ) { const int mappedFilter[] = { basicFilters<>::LowPass,// fast LP basicFilters<>::LowPass, basicFilters<>::BandPass_CSG, basicFilters<>::HiPass, basicFilters<>::Notch, basicFilters<>::NumFilters+basicFilters<>::LowPass, basicFilters<>::LowPass, basicFilters<>::NumFilters+basicFilters<>::LowPass } ; const Arpeggiator::ArpDirections mappedArpDir[] = { Arpeggiator::ArpDirUp, Arpeggiator::ArpDirUp, Arpeggiator::ArpDirDown, Arpeggiator::ArpDirUpAndDown, Arpeggiator::ArpDirUpAndDown, Arpeggiator::ArpDirRandom } ; QMap<QString, int> mappedPluginTypes; // instruments mappedPluginTypes["sampler"] = FL_Plugin::Sampler; mappedPluginTypes["ts404"] = FL_Plugin::TS404; mappedPluginTypes["3x osc"] = FL_Plugin::Fruity_3x_Osc; mappedPluginTypes["beepmap"] = FL_Plugin::BeepMap; mappedPluginTypes["buzz generator adapter"] = FL_Plugin::BuzzGeneratorAdapter; mappedPluginTypes["fruit kick"] = FL_Plugin::FruitKick; mappedPluginTypes["fruity drumsynth live"] = FL_Plugin::FruityDrumSynthLive; mappedPluginTypes["fruity dx10"] = FL_Plugin::FruityDX10; mappedPluginTypes["fruity granulizer"] = FL_Plugin::FruityGranulizer; mappedPluginTypes["fruity slicer"] = FL_Plugin::FruitySlicer; mappedPluginTypes["fruity soundfont player"] = FL_Plugin::FruitySoundfontPlayer; mappedPluginTypes["fruity vibrator"] = FL_Plugin::FruityVibrator; mappedPluginTypes["midi out"] = FL_Plugin::MidiOut; mappedPluginTypes["plucked!"] = FL_Plugin::Plucked; mappedPluginTypes["simsynth"] = FL_Plugin::SimSynth; mappedPluginTypes["sytrus"] = FL_Plugin::Sytrus; mappedPluginTypes["wasp"] = FL_Plugin::WASP; // effects mappedPluginTypes["fruity 7 band EQ"] = FL_Plugin::Fruity7BandEq; mappedPluginTypes["fruity balance"] = FL_Plugin::FruityBalance; mappedPluginTypes["fruity bass boost"] = FL_Plugin::FruityBassBoost; mappedPluginTypes["fruity big clock"] = FL_Plugin::FruityBigClock; mappedPluginTypes["fruity blood overdrive"] = FL_Plugin::FruityBloodOverdrive; mappedPluginTypes["fruity center"] = FL_Plugin::FruityCenter; mappedPluginTypes["fruity chorus"] = FL_Plugin::FruityChorus; mappedPluginTypes["fruity compressor"] = FL_Plugin::FruityCompressor; mappedPluginTypes["fruity db meter"] = FL_Plugin::FruityDbMeter; mappedPluginTypes["fruity delay"] = FL_Plugin::FruityDelay; mappedPluginTypes["fruity delay 2"] = FL_Plugin::FruityDelay2; mappedPluginTypes["fruity fast dist"] = FL_Plugin::FruityFastDist; mappedPluginTypes["fruity fast lp"] = FL_Plugin::FruityFastLP; mappedPluginTypes["fruity filter"] = FL_Plugin::FruityFilter; mappedPluginTypes["fruity flanger"] = FL_Plugin::FruityFlanger; mappedPluginTypes["fruity formula controller"] = FL_Plugin::FruityFormulaController; mappedPluginTypes["fruity free filter"] = FL_Plugin::FruityFreeFilter; mappedPluginTypes["fruity html notebook"] = FL_Plugin::FruityHTMLNotebook; mappedPluginTypes["fruity lsd"] = FL_Plugin::FruityLSD; mappedPluginTypes["fruity mute 2"] = FL_Plugin::FruityMute2; mappedPluginTypes["fruity notebook"] = FL_Plugin::FruityNotebook; mappedPluginTypes["fruity panomatic"] = FL_Plugin::FruityPanOMatic; mappedPluginTypes["fruity parametric eq"] = FL_Plugin::FruityParametricEQ; mappedPluginTypes["fruity peak controller"] = FL_Plugin::FruityPeakController; mappedPluginTypes["fruity phase inverter"] = FL_Plugin::FruityPhaseInverter; mappedPluginTypes["fruity phaser"] = FL_Plugin::FruityPhaser; mappedPluginTypes["fruity reeverb"] = FL_Plugin::FruityReeverb; mappedPluginTypes["fruity scratcher"] = FL_Plugin::FruityScratcher; mappedPluginTypes["fruity send"] = FL_Plugin::FruitySend; mappedPluginTypes["fruity soft clipper"] = FL_Plugin::FruitySoftClipper; mappedPluginTypes["fruity spectroman"] = FL_Plugin::FruitySpectroman; mappedPluginTypes["fruity stereo enhancer"] = FL_Plugin::FruityStereoEnhancer; mappedPluginTypes["fruity x-y controller"] = FL_Plugin::FruityXYController; FL_Project p; if( openFile() == false ) { return false; } if( readID() != makeID( 'F', 'L', 'h', 'd' ) ) { qWarning( "FlpImport::tryImport(): not a valid FL project\n" ); return false; } const int header_len = read32LE(); if( header_len != 6 ) { qWarning( "FlpImport::tryImport(): invalid file format\n" ); return false; } const int type = read16LE(); if( type != 0 ) { qWarning( "FlpImport::tryImport(): type %d format is not " "supported\n", type ); return false; } p.numChannels = read16LE(); if( p.numChannels < 1 || p.numChannels > 1000 ) { qWarning( "FlpImport::tryImport(): invalid number of channels " "(%d)\n", p.numChannels ); return false; } const int ppq = read16LE(); if( ppq < 0 ) { qWarning( "FlpImport::tryImport(): invalid ppq\n" ); return false; } QProgressDialog progressDialog( trackContainer::tr( "Importing FLP-file..." ), trackContainer::tr( "Cancel" ), 0, p.numChannels ); progressDialog.setWindowTitle( trackContainer::tr( "Please wait..." ) ); progressDialog.show(); bool valid = false; // search for FLdt chunk while( 1 ) { Sint32 id = readID(); const int len = read32LE(); if( file().atEnd() ) { qWarning( "FlpImport::tryImport(): unexpected " "end of file\n" ); return false; } if( len < 0 || len >= 0x10000000 ) { qWarning( "FlpImport::tryImport(): invalid " "chunk length %d\n", len ); return false; } if( id == makeID( 'F', 'L', 'd', 't' ) ) { valid = true; break; } skip( len ); } if( valid == false ) { return false; } for( int i = 0; i < p.numChannels; ++i ) { p.channels += FL_Channel(); } qDebug( "channels: %d\n", p.numChannels ); char * text = NULL; int text_len = 0; FL_Plugin::PluginTypes last_plugin_type = FL_Plugin::UnknownPlugin; int cur_channel = -1; const bool is_journ = engine::projectJournal()->isJournalling(); engine::projectJournal()->setJournalling( false ); while( file().atEnd() == false ) { FLP_Events ev = static_cast<FLP_Events>( readByte() ); Uint32 data = readByte(); if( ev >= FLP_Word && ev < FLP_Text ) { data = data | ( readByte() << 8 ); } if( ev >= FLP_Int && ev < FLP_Text ) { data = data | ( readByte() << 16 ); data = data | ( readByte() << 24 ); } if( ev >= FLP_Text ) { text_len = data & 0x7F; Uint8 shift = 0; while( data & 0x80 ) { data = readByte(); text_len = text_len | ( ( data & 0x7F ) << ( shift += 7 ) ); } delete[] text; text = new char[text_len+1]; if( readBlock( text, text_len ) <= 0 ) { qWarning( "could not read string (len: %d)\n", text_len ); } text[text_len] = 0; } const unsigned char * puc = (const unsigned char*) text; const int * pi = (const int *) text; FL_Channel * cc = cur_channel >= 0 ? &p.channels[cur_channel] : NULL; switch( ev ) { // BYTE EVENTS case FLP_Byte: qDebug( "undefined byte %d\n", data ); break; case FLP_NoteOn: qDebug( "note on: %d\n", data ); // data = pos how to handle? break; case FLP_Vol: qDebug( "vol %d\n", data ); break; case FLP_Pan: qDebug( "pan %d\n", data ); break; case FLP_LoopActive: qDebug( "active loop: %d\n", data ); break; case FLP_ShowInfo: qDebug( "show info: %d\n", data ); break; case FLP_Shuffle: qDebug( "shuffle: %d\n", data ); break; case FLP_MainVol: p.mainVolume = data * 100 / 128; break; case FLP_PatLength: qDebug( "pattern length: %d\n", data ); break; case FLP_BlockLength: qDebug( "block length: %d\n", data ); break; case FLP_UseLoopPoints: cc->sampleUseLoopPoints = true; break; case FLP_LoopType: qDebug( "loop type: %d\n", data ); break; case FLP_ChanType: qDebug( "channel type: %d\n", data ); if( cc ) { switch( data ) { case 0: cc->pluginType = FL_Plugin::Sampler; break; case 1: cc->pluginType = FL_Plugin::TS404; break; // case 2: cc->pluginType = FL_Plugin::Fruity_3x_Osc; break; case 3: cc->pluginType = FL_Plugin::Layer; break; default: break; } } break; case FLP_MixSliceNum: cc->fxChannel = data+1; break; case FLP_EffectChannelMuted: if( p.currentEffectChannel <= NumFLFxChannels ) { p.effectChannels[p.currentEffectChannel].isMuted = ( data & 0x08 ) > 0 ? false : true; } break; // WORD EVENTS case FLP_NewChan: cur_channel = data; qDebug( "new channel: %d\n", data ); break; case FLP_NewPat: p.currentPattern = data - 1; if( p.currentPattern > p.maxPatterns ) { p.maxPatterns = p.currentPattern; } break; case FLP_Tempo: p.tempo = data; break; case FLP_CurrentPatNum: p.activeEditPattern = data; break; case FLP_FX: qDebug( "FX: %d\n", data ); break; case FLP_Fade_Stereo: if( data & 0x02 ) { cc->sampleReversed = true; } else if( data & 0x100 ) { cc->sampleReverseStereo = true; } qDebug( "fade stereo: %d\n", data ); break; case FLP_CutOff: qDebug( "cutoff (sample): %d\n", data ); break; case FLP_PreAmp: cc->sampleAmp = 100 + data * 100 / 256; break; case FLP_Decay: qDebug( "decay (sample): %d\n", data ); break; case FLP_Attack: qDebug( "attack (sample): %d\n", data ); break; case FLP_MainPitch: p.mainPitch = data; break; case FLP_Resonance: qDebug( "reso (sample): %d\n", data ); break; case FLP_LoopBar: qDebug( "loop bar: %d\n", data ); break; case FLP_StDel: qDebug( "stdel (delay?): %d\n", data ); break; case FLP_FX3: qDebug( "FX 3: %d\n", data ); break; case FLP_ShiftDelay: qDebug( "shift delay: %d\n", data ); break; case FLP_Dot: cc->dots.push_back( ( data & 0xff ) + ( p.currentPattern << 8 ) ); break; case FLP_LayerChans: p.channels[data].layerParent = cur_channel; // DWORD EVENTS case FLP_Color: cc->color = data; break; case FLP_PlayListItem: { FL_PlayListItem i; i.position = ( data & 0xffff ) * DefaultTicksPerTact; i.length = DefaultTicksPerTact; i.pattern = ( data >> 16 ) - 1; p.playListItems.push_back( i ); if( i.pattern > p.maxPatterns ) { p.maxPatterns = i.pattern; } break; } case FLP_FXSine: qDebug( "fx sine: %d\n", data ); break; case FLP_CutCutBy: qDebug( "cut cut by: %d\n", data ); break; case FLP_MiddleNote: cc->baseNote = data+9; break; case FLP_DelayReso: qDebug( "delay resonance: %d\n", data ); break; case FLP_Reverb: qDebug( "reverb (sample): %d\n", data ); break; case FLP_IntStretch: qDebug( "int stretch (sample): %d\n", data ); break; // TEXT EVENTS case FLP_Text_ChanName: cc->name = text; break; case FLP_Text_PatName: p.patternNames[p.currentPattern] = text; break; case FLP_Text_CommentRTF: { QByteArray ba( text, text_len ); QBuffer buf( &ba ); buf.open( QBuffer::ReadOnly ); lineno = 0; attr_clear_all(); op = html_init(); hash_init(); Word * word = word_read( &buf ); QString out; word_print( word, out ); word_free( word ); op_free( op ); p.projectNotes = out; outstring = ""; break; } case FLP_Text_Title: p.projectTitle = text; break; case FLP_Text_SampleFileName: { QString f = ""; QString f_name = text; /* if( f.mid( 1, 11 ) == "Instruments" ) { f = "\\Patches\\Packs" + f.mid( 12 ); }*/ bool foundFile = false; f_name.replace( '\\', QDir::separator() ); if( QFileInfo( configManager::inst()->flDir() + "/Data/" ).exists() ) { f = configManager::inst()->flDir() + "/Data/" + f_name; foundFile = QFileInfo( f ).exists(); } else { // FL 3 compat f = configManager::inst()->flDir() + "/Samples/" + f_name; foundFile = QFileInfo( f ).exists(); } if( ! foundFile ) { // look in same directory as .flp file f = m_fileBase + "/" + QFileInfo( f_name ).fileName(); printf("looking in %s for samples\n", qPrintable(f)); foundFile = QFileInfo( f ).exists(); } cc->sampleFileName = f; break; } case FLP_Text_Version: { qDebug( "FLP version: %s\n", text ); p.versionString = text; QStringList l = p.versionString.split( '.' ); p.version = ( l[0].toInt() << 8 ) + ( l[1].toInt() << 4 ) + ( l[2].toInt() << 0 ); if( p.version >= 0x600 ) { p.versionSpecificFactor = 100; } break; } case FLP_Text_PluginName: if( mappedPluginTypes. contains( QString( text ).toLower() ) ) { const FL_Plugin::PluginTypes t = static_cast<FL_Plugin::PluginTypes>( mappedPluginTypes[QString( text ).toLower()] ); if( t > FL_Plugin::EffectPlugin ) { qDebug( "recognized new effect %s\n", text ); p.effects.push_back( FL_Effect( t ) ); } else if( cc ) { qDebug( "recognized new plugin %s\n", text ); cc->pluginType = t; } last_plugin_type = t; } else { qDebug( "unsupported plugin: %s!\n", text ); } break; case FLP_Text_EffectChanName: ++p.currentEffectChannel; if( p.currentEffectChannel <= NumFLFxChannels ) { p.effectChannels[p.currentEffectChannel].name = text; } break; case FLP_Text_Delay: qDebug( "delay data: " ); // pi[1] seems to be volume or similiar and // needs to be divided // by p.versionSpecificFactor dump_mem( text, text_len ); break; case FLP_Text_TS404Params: if( cc && cc->pluginType == FL_Plugin::UnknownPlugin && cc->pluginSettings == NULL ) { cc->pluginSettings = new char[text_len]; memcpy( cc->pluginSettings, text, text_len ); cc->pluginSettingsLength = text_len; cc->pluginType = FL_Plugin::TS404; } break; case FLP_Text_NewPlugin: if( last_plugin_type > FL_Plugin::EffectPlugin ) { FL_Effect * e = &p.effects.last(); e->fxChannel = puc[0]; e->fxPos = puc[4]; qDebug( "new effect: " ); } else { qDebug( "new plugin: " ); } dump_mem( text, text_len ); break; case FLP_Text_PluginParams: if( cc && cc->pluginSettings == NULL ) { cc->pluginSettings = new char[text_len]; memcpy( cc->pluginSettings, text, text_len ); cc->pluginSettingsLength = text_len; } qDebug( "plugin params: " ); dump_mem( text, text_len ); break; case FLP_Text_ChanParams: cc->arpDir = mappedArpDir[pi[10]]; cc->arpRange = pi[11]; cc->selectedArp = pi[12]; if( cc->selectedArp < 8 ) { const int mappedArps[] = { 0, 1, 5, 6, 2, 3, 4 } ; cc->selectedArp = mappedArps[cc->selectedArp]; } cc->arpTime = ( ( pi[13]+1 ) * p.tempo ) / ( 4*16 ) + 1; cc->arpGate = ( pi[14] * 100.0f ) / 48.0f; cc->arpEnabled = pi[10] > 0; qDebug( "channel params: " ); dump_mem( text, text_len ); break; case FLP_Text_EnvLfoParams: { const float scaling = 1.0 / 65536.0f; FL_Channel_Envelope e; switch( cc->envelopes.size() ) { case 1: e.target = InstrumentSoundShaping::Volume; break; case 2: e.target = InstrumentSoundShaping::Cut; break; case 3: e.target = InstrumentSoundShaping::Resonance; break; default: e.target = InstrumentSoundShaping::NumTargets; break; } e.predelay = pi[2] * scaling; e.attack = pi[3] * scaling; e.hold = pi[4] * scaling; e.decay = pi[5] * scaling; e.sustain = 1-pi[6] / 128.0f; e.release = pi[7] * scaling; if( e.target == InstrumentSoundShaping::Volume ) { e.amount = pi[1] ? 1 : 0; } else { e.amount = pi[8] / 128.0f; } // e.lfoAmount = pi[11] / 128.0f; cc->envelopes.push_back( e ); qDebug( "envelope and lfo params:\n" ); dump_mem( text, text_len ); break; } case FLP_Text_BasicChanParams: cc->volume = ( pi[1] / p.versionSpecificFactor ) * 100 / 128; cc->panning = ( pi[0] / p.versionSpecificFactor ) * 200 / 128 - PanningRight; if( text_len > 12 ) { cc->filterType = mappedFilter[puc[20]]; cc->filterCut = puc[12] / ( 255.0f * 2.5f ); cc->filterRes = 0.01f + puc[16] / ( 256.0f * 2 ); cc->filterEnabled = ( puc[13] == 0 ); if( puc[20] >= 6 ) { cc->filterCut *= 0.5f; } } qDebug( "basic chan params: " ); dump_mem( text, text_len ); break; case FLP_Text_OldFilterParams: cc->filterType = mappedFilter[puc[8]]; cc->filterCut = puc[0] / ( 255.0f * 2.5 ); cc->filterRes = 0.1f + puc[4] / ( 256.0f * 2 ); cc->filterEnabled = ( puc[1] == 0 ); if( puc[8] >= 6 ) { cc->filterCut *= 0.5; } qDebug( "old filter params: " ); dump_mem( text, text_len ); break; case FLP_Text_AutomationData: { const int bpae = 12; const int imax = text_len / bpae; qDebug( "automation data (%d items)\n", imax ); for( int i = 0; i < imax; ++i ) { FL_Automation a; a.pos = pi[3*i+0] / ( 4*ppq / DefaultTicksPerTact ); a.value = pi[3*i+2]; a.channel = pi[3*i+1] >> 16; a.control = pi[3*i+1] & 0xffff; if( a.channel >= 0 && a.channel < p.numChannels ) { qDebug( "add channel %d at %d val %d control:%d\n", a.channel, a.pos, a.value, a.control ); p.channels[a.channel].automationData += a; } // dump_mem( text+i*bpae, bpae ); } break; } case FLP_Text_PatternNotes: { //dump_mem( text, text_len ); const int bpn = 20; const int imax = ( text_len + bpn - 1 ) / bpn; for( int i = 0; i < imax; ++i ) { int ch = *( puc + i*bpn + 6 ); int pan = *( puc + i*bpn + 16 ); int vol = *( puc + i*bpn + 17 ); int pos = *( (int *)( puc + i*bpn ) ); int key = *( puc + i*bpn + 12 ); int len = *( (int*)( puc + i*bpn + 8 ) ); pos /= (4*ppq) / DefaultTicksPerTact; len /= (4*ppq) / DefaultTicksPerTact; note n( len, pos, key, vol * 100 / 128, pan*200 / 128 - 100 ); if( ch < p.numChannels ) { p.channels[ch].notes.push_back( qMakePair( p.currentPattern, n ) ); } else { qDebug( "invalid " ); } qDebug( "note: " ); dump_mem( text+i*bpn, bpn ); } break; } case FLP_Text_ChanGroupName: qDebug( "channel group name: %s\n", text ); break; // case 216: pi[2] /= p.versionSpecificFactor // case 229: pi[1] /= p.versionSpecificFactor case 225: { enum FLP_EffectParams { EffectParamVolume = 0x1fc0 } ; const int bpi = 12; const int imax = text_len / bpi; for( int i = 0; i < imax; ++i ) { const int param = pi[i*3+1] & 0xffff; const int ch = ( pi[i*3+1] >> 22 ) & 0x7f; if( ch < 0 || ch > NumFLFxChannels ) { continue; } const int val = pi[i*3+2]; if( param == EffectParamVolume ) { p.effectChannels[ch].volume = ( val / p.versionSpecificFactor ) * 100 / 128; } else { qDebug( "FX-ch: %d param: %x value:%x\n", ch, param, val ); } } break; } case 233: // playlist items { const int bpi = 28; const int imax = text_len / bpi; for( int i = 0; i < imax; ++i ) { const int pos = pi[i*bpi/sizeof(int)+0] / ( (4*ppq) / DefaultTicksPerTact ); const int len = pi[i*bpi/sizeof(int)+2] / ( (4*ppq) / DefaultTicksPerTact ); const int pat = pi[i*bpi/sizeof(int)+3] & 0xfff; if( pat > 2146 && pat <= 2278 ) // whatever these magic numbers are for... { FL_PlayListItem i; i.position = pos; i.length = len; i.pattern = 2278 - pat; p.playListItems += i; } else { qDebug( "unknown playlist item: " ); dump_mem( text+i*bpi, bpi ); } } break; } default: if( ev >= FLP_Text ) { qDebug( "!! unhandled text (ev: %d, len: %d): ", ev, text_len ); dump_mem( text, text_len ); } else { qDebug( "!! handling of FLP-event %d not implemented yet " "(data=%d).\n", ev, data ); } break; } } // now create a project from FL_Project data structure engine::getSong()->clearProject(); // configure the mixer for( int i=0; i<NumFLFxChannels; ++i ) { engine::fxMixer()->createChannel(); } engine::fxMixerView()->refreshDisplay(); // set global parameters engine::getSong()->setMasterVolume( p.mainVolume ); engine::getSong()->setMasterPitch( p.mainPitch ); engine::getSong()->setTempo( p.tempo ); // set project notes engine::getProjectNotes()->setText( p.projectNotes ); progressDialog.setMaximum( p.maxPatterns + p.channels.size() + p.effects.size() ); int cur_progress = 0; // create BB tracks QList<bbTrack *> bb_tracks; QList<InstrumentTrack *> i_tracks; while( engine::getBBTrackContainer()->numOfBBs() <= p.maxPatterns ) { const int cur_pat = bb_tracks.size(); bbTrack * bbt = dynamic_cast<bbTrack *>( track::create( track::BBTrack, engine::getSong() ) ); if( p.patternNames.contains( cur_pat ) ) { bbt->setName( p.patternNames[cur_pat] ); } bb_tracks += bbt; progressDialog.setValue( ++cur_progress ); qApp->processEvents(); } // create instrument-track for each channel for( QList<FL_Channel>::Iterator it = p.channels.begin(); it != p.channels.end(); ++it ) { InstrumentTrack * t = dynamic_cast<InstrumentTrack *>( track::create( track::InstrumentTrack, engine::getBBTrackContainer() ) ); engine::getBBTrackContainer()->updateAfterTrackAdd(); i_tracks.push_back( t ); switch( it->pluginType ) { case FL_Plugin::Fruity_3x_Osc: it->instrumentPlugin = t->loadInstrument( "tripleoscillator" ); break; case FL_Plugin::Plucked: it->instrumentPlugin = t->loadInstrument( "vibedstrings" ); break; case FL_Plugin::FruitKick: it->instrumentPlugin = t->loadInstrument( "kicker" ); break; case FL_Plugin::TS404: it->instrumentPlugin = t->loadInstrument( "lb302" ); break; case FL_Plugin::FruitySoundfontPlayer: it->instrumentPlugin = t->loadInstrument( "sf2player" ); break; case FL_Plugin::Sampler: case FL_Plugin::UnknownPlugin: default: it->instrumentPlugin = t->loadInstrument( "audiofileprocessor" ); break; } processPluginParams( &( *it ) ); t->setName( it->name ); t->volumeModel()->setValue( it->volume ); t->panningModel()->setValue( it->panning ); t->baseNoteModel()->setValue( it->baseNote ); t->effectChannelModel()->setValue( it->fxChannel ); InstrumentSoundShaping * iss = &t->m_soundShaping; iss->m_filterModel.setValue( it->filterType ); iss->m_filterCutModel.setValue( it->filterCut * ( iss->m_filterCutModel.maxValue() - iss->m_filterCutModel.minValue() ) + iss->m_filterCutModel.minValue() ); iss->m_filterResModel.setValue( it->filterRes * ( iss->m_filterResModel.maxValue() - iss->m_filterResModel.minValue() ) + iss->m_filterResModel.minValue() ); iss->m_filterEnabledModel.setValue( it->filterEnabled ); for( QList<FL_Channel_Envelope>::iterator jt = it->envelopes.begin(); jt != it->envelopes.end(); ++jt ) { if( jt->target != InstrumentSoundShaping::NumTargets ) { EnvelopeAndLfoParameters * elp = iss->m_envLfoParameters[jt->target]; elp->m_predelayModel.setValue( jt->predelay ); elp->m_attackModel.setValue( jt->attack ); elp->m_holdModel.setValue( jt->hold ); elp->m_decayModel.setValue( jt->decay ); elp->m_sustainModel.setValue( jt->sustain ); elp->m_releaseModel.setValue( jt->release ); elp->m_amountModel.setValue( jt->amount ); elp->updateSampleVars(); } } Arpeggiator * arp = &t->m_arpeggiator; arp->m_arpDirectionModel.setValue( it->arpDir ); arp->m_arpRangeModel.setValue( it->arpRange ); arp->m_arpModel.setValue( it->selectedArp ); arp->m_arpTimeModel.setValue( it->arpTime ); arp->m_arpGateModel.setValue( it->arpGate ); arp->m_arpEnabledModel.setValue( it->arpEnabled ); // process all dots for( QList<int>::ConstIterator jt = it->dots.begin(); jt != it->dots.end(); ++jt ) { const int pat = *jt / 256; const int pos = *jt % 256; pattern * p = dynamic_cast<pattern *>( t->getTCO( pat ) ); if( p == NULL ) { continue; } p->setStep( pos, true ); } // TODO: use future layering feature if( it->layerParent >= 0 ) { it->notes += p.channels[it->layerParent].notes; } // process all notes for( FL_Channel::noteVector::ConstIterator jt = it->notes.begin(); jt != it->notes.end(); ++jt ) { const int pat = jt->first; if( pat > 100 ) { continue; } pattern * p = dynamic_cast<pattern *>( t->getTCO( pat ) ); if( p != NULL ) { p->addNote( jt->second, false ); } } // process automation data for( QList<FL_Automation>::ConstIterator jt = it->automationData.begin(); jt != it->automationData.end(); ++jt ) { AutomatableModel * m = NULL; float value = jt->value; bool scale = false; switch( jt->control ) { case FL_Automation::ControlVolume: m = t->volumeModel(); value *= ( 100.0f / 128.0f ) / p.versionSpecificFactor; break; case FL_Automation::ControlPanning: m = t->panningModel(); value = ( value / p.versionSpecificFactor ) *200/128 - PanningRight; break; case FL_Automation::ControlPitch: m = t->pitchModel(); break; case FL_Automation::ControlFXChannel: m = t->effectChannelModel(); value = value*200/128 - PanningRight; break; case FL_Automation::ControlFilterCut: scale = true; m = &t->m_soundShaping.m_filterCutModel; value /= ( 255 * 2.5f ); break; case FL_Automation::ControlFilterRes: scale = true; m = &t->m_soundShaping.m_filterResModel; value = 0.1f + value / ( 256.0f * 2 ); break; case FL_Automation::ControlFilterType: m = &t->m_soundShaping.m_filterModel; value = mappedFilter[jt->value]; break; default: qDebug( "handling automation data of " "control %d not implemented " "yet\n", jt->control ); break; } if( m ) { if( scale ) { value = m->minValue<float>() + value * ( m->maxValue<float>() - m->minValue<float>() ); } AutomationPattern * p = AutomationPattern::globalAutomationPattern( m ); p->putValue( jt->pos, value, false ); } } progressDialog.setValue( ++cur_progress ); qApp->processEvents(); } // process all effects EffectKeyList effKeys; Plugin::DescriptorList pluginDescs; Plugin::getDescriptorsOfAvailPlugins( pluginDescs ); for( Plugin::DescriptorList::ConstIterator it = pluginDescs.begin(); it != pluginDescs.end(); ++it ) { if( it->type != Plugin::Effect ) { continue; } if( it->subPluginFeatures ) { it->subPluginFeatures->listSubPluginKeys( &( *it ), effKeys ); } else { effKeys << EffectKey( &( *it ), it->name ); } } for( int fx_ch = 0; fx_ch <= NumFLFxChannels ; ++fx_ch ) { FxChannel * ch = engine::fxMixer()->effectChannel( fx_ch ); if( !ch ) { continue; } FL_EffectChannel * flch = &p.effectChannels[fx_ch]; if( !flch->name.isEmpty() ) { ch->m_name = flch->name; } ch->m_volumeModel.setValue( flch->volume / 100.0f ); ch->m_muteModel.setValue( flch->isMuted ); } for( QList<FL_Effect>::ConstIterator it = p.effects.begin(); it != p.effects.end(); ++it ) { QString effName; switch( it->pluginType ) { case FL_Plugin::Fruity7BandEq: effName = "C* Eq2x2"; break; case FL_Plugin::FruityBassBoost: effName = "BassBooster"; break; case FL_Plugin::FruityChorus: effName = "TAP Chorus"; break; case FL_Plugin::FruityCompressor: //effName = "C* Compress"; effName = "Fast Lookahead limiter"; break; case FL_Plugin::FruityDelay: case FL_Plugin::FruityDelay2: // effName = "Feedback Delay Line (Maximum Delay 5s)"; break; case FL_Plugin::FruityBloodOverdrive: case FL_Plugin::FruityFastDist: case FL_Plugin::FruitySoftClipper: effName = "C* Clip"; break; case FL_Plugin::FruityFastLP: effName = "Low Pass Filter"; break; case FL_Plugin::FruityPhaser: effName = "C* PhaserI"; break; case FL_Plugin::FruityReeverb: effName = "C* Plate2x2"; break; case FL_Plugin::FruitySpectroman: effName = "Spectrum Analyzer"; break; default: break; } if( effName.isEmpty() || it->fxChannel < 0 || it->fxChannel > NumFLFxChannels ) { continue; } EffectChain * ec = &engine::fxMixer()-> effectChannel( it->fxChannel )->m_fxChain; qDebug( "adding %s to %d\n", effName.toUtf8().constData(), it->fxChannel ); for( EffectKeyList::Iterator jt = effKeys.begin(); jt != effKeys.end(); ++jt ) { if( QString( jt->desc->displayName ).contains( effName ) || ( jt->desc->subPluginFeatures != NULL && jt->name.contains( effName ) ) ) { qDebug( "instantiate %s\n", jt->desc->name ); ::Effect * e = Effect::instantiate( jt->desc->name, ec, &( *jt ) ); ec->appendEffect( e ); ec->setEnabled( true ); break; } } progressDialog.setValue( ++cur_progress ); qApp->processEvents(); } // process all playlist-items for( QList<FL_PlayListItem>::ConstIterator it = p.playListItems.begin(); it != p.playListItems.end(); ++it ) { if( it->pattern > p.maxPatterns ) { continue; } trackContentObject * tco = bb_tracks[it->pattern]->createTCO( midiTime() ); tco->movePosition( it->position ); if( it->length != DefaultTicksPerTact ) { tco->changeLength( it->length ); } } // set current pattern if( p.activeEditPattern < engine::getBBTrackContainer()->numOfBBs() ) { engine::getBBTrackContainer()->setCurrentBB( p.activeEditPattern ); } // restore journalling settings engine::projectJournal()->setJournalling( is_journ ); return true; }
uint64 PortalsPeer::getID() const { OS_LOCK(*m_mutex); return makeID(m_endpoint); }
LEXEME *expression_lambda(LEXEME *lex, SYMBOL *funcsp, TYPE *atp, TYPE **tp, EXPRESSION **exp, int flags) { LAMBDA *self; SYMBOL *vpl, *ths; HASHREC *hrl; TYPE *ltp; STRUCTSYM ssl; if (funcsp) funcsp->noinline = TRUE; IncGlobalFlag(); self = Alloc(sizeof(LAMBDA)); ltp = Alloc(sizeof(TYPE)); ltp->type = bt_struct; ltp->syms = CreateHashTable(1); ltp->tags = CreateHashTable(1); ltp->size = 0; self->captured = CreateHashTable(1); self->oldSyms = localNameSpace->syms; self->oldTags = localNameSpace->tags; self->index = lambdaIndex; self->captureMode = cmNone; self->isMutable = FALSE; self->captureThis = FALSE; self->cls = makeID(sc_type, ltp, NULL, LambdaName()); ltp->sp = self->cls; SetLinkerNames(self->cls, lk_cdecl); self->cls->islambda = TRUE; self->cls->structAlign = getAlign(sc_global, &stdpointer); self->func = makeID(sc_member, ltp, NULL, "$internalFunc"); self->func->parentClass = self->cls; self->functp = &stdauto; self->enclosingFunc = theCurrentFunc; if (lambdas) lambdas->prev = self; self->next = lambdas; lambdas = self; localNameSpace->syms = CreateHashTable(1); localNameSpace->tags = CreateHashTable(1); if (lambdas->next) { self->lthis = lambdas->next->lthis; } else if (funcsp && funcsp->parentClass) { self->lthis = ((SYMBOL *)funcsp->tp->syms->table[0]->p); } lex = getsym(); // past [ if (funcsp) { // can have a capture list; if (MATCHKW(lex, assign)) { lex = getsym(); if (MATCHKW(lex, comma) || MATCHKW(lex, closebr)) { self->captureMode = cmValue; skip(&lex, comma); } else { lex = backupsym(); } } else if (MATCHKW(lex, and)) { lex = getsym(); if (MATCHKW(lex, comma) || MATCHKW(lex, closebr)) { self->captureMode = cmRef; skip(&lex, comma); } else { lex = backupsym(); } } if (!MATCHKW(lex, comma) && !MATCHKW(lex, closebr)) { do { enum e_cm localMode = self->captureMode; if (MATCHKW(lex, comma)) skip(&lex, comma); if (MATCHKW(lex, kw_this)) { lex = getsym(); if (localMode == cmValue || !self->lthis) { error(ERR_CANNOT_CAPTURE_THIS); } else { if (self->captureThis) { error(ERR_CAPTURE_ITEM_LISTED_MULTIPLE_TIMES); } self->captureThis = TRUE; lambda_capture(NULL, cmThis, TRUE); } continue; } else if (MATCHKW(lex, and)) { if (localMode == cmRef) { error(ERR_INVALID_LAMBDA_CAPTURE_MODE); } localMode = cmRef; lex = getsym(); } else { if (localMode == cmValue) { error(ERR_INVALID_LAMBDA_CAPTURE_MODE); } localMode = cmValue; } if (ISID(lex)) { SYMBOL *sp = search(lex->value.s.a, localNameSpace->syms); LAMBDA *current = lambdas; while (current && !sp) { sp = search(lex->value.s.a, current->oldSyms); current = current->next; } lex = getsym(); if (sp) { if (sp->packed) { if (!MATCHKW(lex, ellipse)) error(ERR_PACK_SPECIFIER_REQUIRED_HERE); else lex = getsym(); } if (sp->packed) { int n; TEMPLATEPARAMLIST * templateParam = sp->tp->templateParam->p->byPack.pack; HASHREC *hr; for (n=0; templateParam; templateParam = templateParam->next, n++); hr = funcsp->tp->syms->table[0]; while (hr && ((SYMBOL *)hr->p) != sp) hr = hr->next; while (hr && n) { lambda_capture((SYMBOL *)hr->p, localMode, TRUE); hr = hr->next; n--; } } else { lambda_capture(sp, localMode, TRUE); } } else errorstr(ERR_UNDEFINED_IDENTIFIER, lex->value.s.a); } else { error(ERR_INVALID_LAMBDA_CAPTURE_MODE); } } while (MATCHKW(lex, comma)); } needkw(&lex, closebr); } else { if (!MATCHKW(lex, closebr)) { error(ERR_LAMBDA_CANNOT_CAPTURE); } else { lex = getsym(); } } if (MATCHKW(lex, openpa)) { TYPE *tpx = &stdvoid; HASHREC *hr; lex = getFunctionParams(lex, NULL, &self->func, &tpx, FALSE, sc_auto); self->funcargs = self->func->tp->syms->table[0]; hr = self->func->tp->syms->table[0]; while (hr) { SYMBOL *sym = (SYMBOL *)hr->p; if (sym->init) { error(ERR_CANNOT_DEFAULT_PARAMETERS_WITH_LAMBDA); } hr = hr->next; } if (MATCHKW(lex, kw_mutable)) { HASHREC *hr = self->captured->table[0]; while (hr) { LAMBDASP *lsp = (LAMBDASP *)hr->p; if (lsp->sym->lambdaMode == cmValue) { lsp->sym->tp = basetype(lsp->sym->tp); } hr = hr->next; } self->isMutable = TRUE; lex = getsym(); } ParseAttributeSpecifiers(&lex, funcsp, TRUE); if (MATCHKW(lex, pointsto)) { lex = getsym(); lex = get_type_id(lex, &self->functp, funcsp, sc_cast, FALSE, TRUE); } } else { TYPE *tp1 = Alloc(sizeof(TYPE)); SYMBOL *spi; tp1->type = bt_func; tp1->size = getSize(bt_pointer); tp1->btp = &stdvoid; tp1->sp = self->func; self->func->tp = tp1; spi = makeID(sc_parameter, tp1, NULL, AnonymousName()); spi->anonymous = TRUE; spi->tp = Alloc(sizeof(TYPE)); spi->tp->type = bt_void; insert(spi, localNameSpace->syms); SetLinkerNames(spi, lk_cpp); self->func->tp->syms = localNameSpace->syms; self->funcargs = self->func->tp->syms->table[0]; self->func->tp->syms->table[0] = NULL; } vpl = makeID(sc_parameter, &stdpointer, NULL, AnonymousName()); vpl->assigned = vpl->used = TRUE; SetLinkerNames(vpl, lk_cdecl); hrl = Alloc(sizeof(HASHREC)); hrl->p = (struct _hrintern_ *)vpl; hrl->next = lambdas->func->tp->syms->table[0]; lambdas->func->tp->syms->table[0] = hrl; vpl = makeID(sc_parameter, &stdpointer, NULL, AnonymousName()); vpl->assigned = vpl->used = TRUE; SetLinkerNames(vpl, lk_cdecl); hrl = Alloc(sizeof(HASHREC)); hrl->p = (struct _hrintern_ *)vpl; hrl->next = lambdas->func->tp->syms->table[0]; lambdas->func->tp->syms->table[0] = hrl; SetLinkerNames(lambdas->func, lk_cdecl); injectThisPtr(lambdas->func, basetype(lambdas->func->tp)->syms); lambdas->func->tp->btp = self->functp; lambdas->func->linkage = lk_virtual; lambdas->func->isInline = TRUE; ssl.str = self->cls; ssl.tmpl = NULL; addStructureDeclaration(&ssl); ths = makeID(sc_member, &stdpointer, NULL, "$this"); lambda_insert(ths, lambdas); if (MATCHKW(lex, begin)) { lex = body(lex, self->func); } else { error(ERR_LAMBDA_FUNCTION_BODY_EXPECTED); } dropStructureDeclaration(); localNameSpace->syms = self->oldSyms; localNameSpace->tags = self->oldTags; inferType(); finishClass(); *exp = createLambda(0); *tp = lambdas->cls->tp; lambdas = lambdas->next; if (lambdas) lambdas->prev = NULL; DecGlobalFlag(); return lex; }
static EXPRESSION *createLambda(BOOLEAN noinline) { EXPRESSION *rv = NULL, **cur = &rv; HASHREC *hr; EXPRESSION *clsThs, *parentThs; SYMBOL *cls = makeID(lambdas->enclosingFunc ? sc_auto : sc_localstatic, lambdas->cls->tp, NULL, AnonymousName()); SetLinkerNames(cls, lk_cdecl); cls->allocate = TRUE; if (lambdas->enclosingFunc) { insert(cls, localNameSpace->syms); clsThs = varNode(en_auto, cls); // this ptr } else { insert(cls, globalNameSpace->syms); // well if we could put this as an auto in the init func that would be good but there is no way to do that here... clsThs = varNode(en_label, cls); // this ptr cls->label = nextLabel++; insertInitSym(cls); } { INITIALIZER *init = NULL; EXPRESSION *exp = clsThs; callDestructor(cls, NULL, &exp, NULL, TRUE, FALSE, FALSE); initInsert(&init, cls->tp, exp, 0, TRUE); if (cls->storage_class != sc_auto) { insertDynamicDestructor(cls, init); } else { cls->dest = init; } } parentThs = varNode(en_auto, (SYMBOL *)basetype(lambdas->func->tp)->syms->table[0]->p); // this ptr hr = lambdas->cls->tp->syms->table[0]; while (hr) { SYMBOL *sp = (SYMBOL *)hr->p; EXPRESSION *en = NULL, *en1 = NULL; if (!strcmp(sp->name, "$self")) { en1 = clsThs; en = varNode(en_label, sp); deref(&stdpointer, &en); en = exprNode(en_assign, en, en1); } else if (!strcmp(sp->name, "$parent")) { en1 = parentThs; // get parent from function call deref(&stdpointer, &en1); en = exprNode(en_add, clsThs, intNode(en_c_i, sp->offset)) ; deref(&stdpointer, &en); en = exprNode(en_assign, en, en1); } else if (!strcmp(sp->name, "$this")) { if (!lambdas->next || !lambdas->captureThis) { en1 = parentThs; // get parent from function call } else { SYMBOL *parent = search("$parent", lambdas->cls->tp->syms); en1 = varNode(en_auto, cls); deref(&stdpointer, &en1); en1 = exprNode(en_add, en1, intNode(en_c_i, parent->offset)); } deref(&stdpointer, &en1); en = exprNode(en_add, clsThs, intNode(en_c_i, sp->offset)) ; deref(&stdpointer, &en); en = exprNode(en_assign, en, en1); } else if (sp->lambdaMode) { LAMBDASP *lsp = (LAMBDASP *)search(sp->name, lambdas->captured); if (lsp) { en1 = exprNode(en_add, clsThs, intNode(en_c_i, sp->offset)); if (sp->lambdaMode == cmRef) { SYMBOL *capture = lsp->parent; deref(&stdpointer, &en1); if (capture->lambdaMode) { en = parentThs; deref(&stdpointer, &en); en = exprNode(en_add, en, intNode(en_c_i, capture->offset)); } else // must be an sc_auto { en = varNode(en_auto, capture); } if (isref(capture->tp)) { deref(&stdpointer, &en); } en = exprNode(en_assign, en1, en); } else // cmValue { SYMBOL *capture = lsp->parent; TYPE *ctp = capture->tp; if (capture->lambdaMode) { en = parentThs; deref(&stdpointer, &en); en = exprNode(en_add, en, intNode(en_c_i, capture->offset)); } else // must be an sc_auto { en = varNode(en_auto, capture); } if (isref(ctp)) { ctp = basetype(ctp)->btp; deref(&stdpointer, &en); } if (isstructured(ctp)) { FUNCTIONCALL *params = (FUNCTIONCALL *)Alloc(sizeof(FUNCTIONCALL)); params->arguments = (INITLIST *)Alloc(sizeof(INITLIST)); params->arguments->tp = ctp; params->arguments->exp = en; if (!callConstructor(&ctp, &en1, params, FALSE, NULL, TRUE, FALSE, TRUE, FALSE, FALSE)) errorsym(ERR_NO_APPROPRIATE_CONSTRUCTOR, lsp->sym); en = en1; } else { deref(ctp, &en1); deref(ctp, &en); en = exprNode(en_assign, en1, en); } } } else { diag("createLambda: no capture var"); } } if (en) { *cur = exprNode(en_void, en, NULL); cur = &(*cur)->right; } hr = hr->next; } *cur = clsThs; // this expression will be used in copy constructors, or discarded if unneeded return rv; }
void parseSLK (MPQLOADER mpq, char const* path) { MPQFILE slk = MPQLoadFile (mpq, path); if (slk) { zero_abils (); int curid = 0; char abils[256] = ""; int y = 0; int x = 0; int xID = 0; int xAbil = 0; char lineb[256]; while (MPQFileGets (slk, sizeof lineb, lineb)) { char* line = lineb; while (*line == ' ') line++; int i = 0; while (line[i]) i++; while (i && (line[i - 1] == ' ' || line[i - 1] == '\r' || line[i - 1] == '\t' || line[i - 1] == '\n')) line[--i] = 0; SLKEntry s; line = SLKReadEntry (line, s); if (s.type == 'C') { line = SLKReadEntry (line, s); while (s.type == 'X' || s.type == 'Y') { if (s.type == 'X') x = atoi (s.val); else { y = atoi (s.val); curid = 0; abils[0] = 0; } line = SLKReadEntry (line, s); } if (x && s.type == 'K') { if (y == 1) { if (!strcmp (s.val, "unitAbilID")) xID = x; else if (!strcmp (s.val, "heroAbilList")) xAbil = x; } else if (x == xID) { curid = makeID (s.val); if (abils[0]) { set_abils (curid, abils); curid = 0; abils[0] = 0; } } else if (x == xAbil) { strcpy (abils, s.val); if (curid) { set_abils (curid, abils); curid = 0; abils[0] = 0; } } } } } MPQCloseFile (slk); } }
cacheItem* WCache<cacheItem, cacheActual>::Get(int id, const string& filename, int style, int submode) { typename map<int, cacheItem*>::iterator it; int lookup = makeID(id, filename, submode); //Check for managed resources first. Always it = managed.find(lookup); //Something is managed. if (it != managed.end()) { return it->second; //A hit. } //Not managed, so look in cache. if (style != RETRIEVE_MANAGE) { boost::mutex::scoped_lock lock(sCacheMutex); //DebugTrace("Cache lock acquired, looking up index " << lookup); it = cache.find(lookup); //Well, we've found something... if (it != cache.end()) { if (!it->second) { mError = CACHE_ERROR_404; //DebugTrace("cache hit, no item??"); //assert(false); } return it->second; //A hit, or maybe a miss. } } // not hit in the cache, respect the RETRIEVE_EXISTING flag if present if (style == RETRIEVE_EXISTING) { return NULL; } // no hit in cache, clear space before attempting to load a new one // note: Cleanup() should ONLY be ever called on the main (UI) thread! Cleanup(); // check if we're doing a card lookup ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // commented out for the following reason: //cardgui updates so quick that the only reason a person would notice a cache miss is because it takes the //engine longer to switch the card quad from kGeneric to the actual image, than it does to just let the update pass. #if defined (PSP) if (submode & TEXTURE_SUB_CARD) { // processing a cache miss, return a generic card & queue up an async read // side note: using a string reference here to a global predefined string, as basic_string is not thread safe for allocations! const std::string& cardPath = (submode & TEXTURE_SUB_THUMB) ? kGenericThumbCard : kGenericCard; int genericCardId = makeID(0, cardPath, CACHE_NORMAL); it = managed.find(genericCardId); assert(it != managed.end()); CacheEngine::Instance()->QueueRequest(filename, submode, lookup); return it->second; } #endif /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Space in cache, make new texture return LoadIntoCache(lookup, filename, submode, style); }