void Oscillator::processOneSample() { // for now we are doing a sine wave. // we are given sample rate // we want index to go from 0 to 2*PI // frequency times per srate samples. if (outputs.size() > 0) { double output; if (isLinked("level")) { level = getLinkParameter("level"); } if (isLinked("freq")) { freq = getLinkParameter("freq"); } deriveIncrement(); if (type == WAVE_SINE) { output = sin(index); } else if (type == WAVE_SQUARE) { if (index < PI) { output = 1.0; } else { output = -1.0; } } output *= level; for (int i = 0 ; i < outputs.size() ; i++) { outputs.at(i)->putData(output); } index += increment; if (index >= (2 * PI)) index -= (2 * PI); } }
bool PatchView::doUpdate(bool force) { const RevFile* files = NULL; bool newFiles = false; if (st.isChanged(StateInfo::SHA) || force) { if (!isLinked()) { QString caption(git->getShortLog(st.sha())); if (caption.length() > 30) caption = caption.left(30 - 3).trimmed().append("..."); setTabCaption(caption); } on_updateRevDesc(); } if (st.isChanged(StateInfo::ANY & ~StateInfo::FILE_NAME) || force) { updatePatch(); patchTab->fileList->clear(); files = git->getFiles(st.sha(), st.diffToSha(), st.allMergeFiles()); newFiles = true; } // call always to allow a simple refresh patchTab->fileList->update(files, newFiles); if (st.isChanged() || force) patchTab->textEditDiff->centerOnFileHeader(st); return true; }
//"ADJP|ADVP < (FW $- (IN=target < in|In) )" inline const bool &nn4(const unsigned long &cons){ if (cons==PENN_CON_ADJP || cons==PENN_CON_ADVP){ CStateNodeList* childsAd=node.m_umbinarizedSubNodes; while(childsAd!=0){ if ((*words)[childsAd->node->lexical_head].tag.code()==PENN_TAG_FW){ if (childsAd->previous!=0){ const CStateNode* inTarg=childsAd->previous->node; if (((*words)[inTarg->lexical_head].tag.code()==PENN_TAG_IN)&&!(isLinked(&node,inTarg))){ CStateNodeList* childsIn=inTarg->m_umbinarizedSubNodes; //while(childsIn!=0){ if ((*words)[inTarg->lexical_head].word==g_word_in||(*words)[inTarg->lexical_head].word==g_word_In){ // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_NN); if (buildStanfordLink(STANFORD_DEP_NN, inTarg->lexical_head, node.lexical_head)) { addLinked(&node,inTarg); return true; } } //childsIn=childsIn->next; //} } } } childsAd=childsAd->next; } } return false; }
void Program::release() const { if (!isLinked()) return; glUseProgram(0); }
bool ProgramManager::validate() { if (!isLinked()) return false; GLint status; glValidateProgram(handle); glGetProgramiv(handle, GL_VALIDATE_STATUS, &status); if (GL_FALSE == status) { int length = 0; logString = ""; glGetProgramiv(handle, GL_INFO_LOG_LENGTH, &length); if (length > 0) { char * c_log = new char[length + 1]; int written = 0; glGetProgramInfoLog(handle, length, &written, c_log); c_log[length] = '\0'; logString = c_log; delete[] c_log; } return false; } return true; }
//"/^(?:VP|ADJP|JJP|WHADJP|SQ?|SBARQ?|SINV|XS|RRC|(?:WH)?NP(?:-TMP|-ADV)?)$/ < (RB|RBR|RBS|WRB|ADVP|WHADVP=target !< " + NOT_PAT + ")", inline const bool &advmod1(const unsigned long &cons){ if (cons==PENN_CON_VP || cons==PENN_CON_ADJP || cons==PENN_CON_S || //S (SBAR) is there because because SQ? (SBARQ?) matches SQ and S, being Q optional cons==PENN_CON_SQ || cons==PENN_CON_SBAR || cons==PENN_CON_SBARQ || cons==PENN_CON_WHNP || cons==PENN_CON_SBARQ || cons==PENN_CON_SINV || cons==PENN_CON_RRC || cons==PENN_CON_SBARQ){ CStateNodeList* childs = node.m_umbinarizedSubNodes; while(childs!=0){ const CStateNode* targ=childs->node; if (((*words)[targ->lexical_head].tag.code()==PENN_TAG_ADVERB || (*words)[targ->lexical_head].tag.code()==PENN_TAG_ADVERB_COMPARATIVE || (*words)[targ->lexical_head].tag.code()==PENN_TAG_ADVERB_SUPERLATIVE || (*words)[targ->lexical_head].tag.code()==PENN_TAG_WRB || CConstituent::clearTmp(targ->constituent.code())==PENN_CON_WHADVP) && !isLinked(&node,targ)){ CStateNodeList* childsT=targ->m_umbinarizedSubNodes; bool notCond=true; if (((*words)[targ->lexical_head].word==g_word_not) ||((*words)[targ->lexical_head].word==g_word_nt)){ notCond=false; } if (notCond){ // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_ADVMOD); if (buildStanfordLink(STANFORD_DEP_ADVMOD, targ->lexical_head, node.lexical_head)) { addLinked(&node,targ); return true; } } } childs=childs->next; } } return false; }
void AdobeDRM::link(const QString& userID, const QString& password) { qDebug() << Q_FUNC_INFO; if (isLinked()) { emit linkOK(); return; } if (!m_proc) { emit linkKO(2); return; } m_DRM_ID = userID; m_DRM_PW = password; #ifdef Q_WS_QWS connect(m_client, SIGNAL(workflowDone(unsigned int)), this, SLOT(linkWorkflowDone(unsigned int)), Qt::UniqueConnection); connect(m_client, SIGNAL(workflowError(int, QString)), this, SLOT(linkWorkflowError(int, QString)), Qt::UniqueConnection); #endif QTimer::singleShot(110, this, SLOT(processLink())); }
//"ADJP < (S=target <, (VP <, TO))", inline const bool & buildXComp2(const unsigned long &cons) { if (cons==PENN_CON_ADJP){ CStateNodeList* childsADJP=node.m_umbinarizedSubNodes; while(childsADJP!=0){ const CStateNode* sTarg=childsADJP->node; if (CConstituent::clearTmp(sTarg->constituent.code())==PENN_CON_S && (!isLinked(&node,sTarg))){ //A <, B B is the first child of A CStateNodeList* childsS=sTarg->m_umbinarizedSubNodes; if (childsS!=0){//only first child const CStateNode* vpChildS=childsS->node; if (CConstituent::clearTmp(vpChildS->constituent.code())==PENN_CON_VP){ CStateNodeList* childsVp=vpChildS->m_umbinarizedSubNodes; if (childsVp!=0){//only first child if (((*words)[childsVp->node->lexical_head].tag.code()==PENN_TAG_TO)){ // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_XCOMP); if (buildStanfordLink(STANFORD_DEP_XCOMP, sTarg->lexical_head, node.lexical_head)) { addLinked(&node,sTarg); return true; } } } } } } childsADJP=childsADJP->next; } } return false; }
void CallLinkInfo::visitWeak(RepatchBuffer& repatchBuffer) { if (isLinked()) { if (stub) { if (!Heap::isMarked(stub->executable())) { if (Options::verboseOSR()) { dataLog( "Clearing closure call from ", *repatchBuffer.codeBlock(), " to ", stub->executable()->hashFor(specializationKind()), ", stub routine ", RawPointer(stub.get()), ".\n"); } unlink(repatchBuffer); } } else if (!Heap::isMarked(callee.get())) { if (Options::verboseOSR()) { dataLog( "Clearing call from ", *repatchBuffer.codeBlock(), " to ", RawPointer(callee.get()), " (", callee.get()->executable()->hashFor(specializationKind()), ").\n"); } unlink(repatchBuffer); } } if (!!lastSeenCallee && !Heap::isMarked(lastSeenCallee.get())) lastSeenCallee.clear(); }
//"WHNP|WHNP-TMP|WHNP-ADV|NP|NP-TMP|NP-ADV < PDT=target <- DT" inline const bool &predet3(const unsigned long &cons){ if (cons==PENN_CON_WHNP || cons==PENN_CON_NP){ CStateNodeList* childs=node.m_umbinarizedSubNodes; bool lastCond=false; while(childs!=0){ if (((*words)[childs->node->lexical_head].tag.code()==PENN_TAG_DT) && childs->next==0){ lastCond=true; } childs=childs->next; } if (lastCond){ childs=node.m_umbinarizedSubNodes; while(childs!=0){ const CStateNode* targ=childs->node; if (((*words)[targ->lexical_head].tag.code()==PENN_TAG_PDT) && !isLinked(&node,targ)){ // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_PREDET); if (buildStanfordLink(STANFORD_DEP_PREDET, targ->lexical_head, node.lexical_head)) { addLinked(&node,targ); return true; } } childs=childs->next; } } } return false; }
//"__ < /^(?:\\.|:|,|''|``|\\*|-LRB-|-RRB-|HYPH)$/=target" inline const bool & buildPunct1(const unsigned long &cons) { CStateNodeList* childs=node.m_umbinarizedSubNodes; while(childs!=0){ const CStateNode* child=childs->node; if ((((*words)[child->lexical_head].word==g_word_order) || ((*words)[child->lexical_head].word==g_word_two_dots) || ((*words)[child->lexical_head].word==g_word_dot) || ((*words)[child->lexical_head].tag.code()==PENN_TAG_R_QUOTE) || ((*words)[child->lexical_head].word==g_word_comma) || ((*words)[child->lexical_head].tag.code()==PENN_TAG_L_QUOTE) || ((*words)[child->lexical_head].word==g_word_asterisc) || ((*words)[child->lexical_head].word==g_word_hyphen) || ((*words)[child->lexical_head].word==g_word_hyphen2) || ((*words)[child->lexical_head].word==g_word_lowhyphen) || ((*words)[child->lexical_head].tag.code()==PENN_TAG_L_BRACKET) || ((*words)[child->lexical_head].tag.code()==PENN_TAG_R_BRACKET) || ((*words)[child->lexical_head].word==g_word_order)) && (!isLinked(&node,child))){ // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_PUNCT); if (buildStanfordLink(STANFORD_DEP_PUNCT, child->lexical_head, node.lexical_head)) { addLinked(&node,child); return true; } } childs=childs->next; } }
/* *"SQ|SINV < (/^(?:VB|MD|AUX)/=target $++ /^(?:VP|ADJP)/)", * * */ inline const bool &buildAux2(const unsigned long &cons){ if (cons==PENN_CON_SQ || cons==PENN_CON_SINV) { CStateNodeList* childs=node.m_umbinarizedSubNodes; while (childs!=0) { const CStateNode* targ=childs->node; if ((((*words)[targ->lexical_head].tag.code()==PENN_TAG_VERB) || ((*words)[targ->lexical_head].tag.code()==PENN_TAG_MD)) && (!isLinked(&node, targ))) { CStateNodeList* rightSisters=childs; while(rightSisters!=0){ const CStateNode* rSis=rightSisters->node; if ((CConstituent::clearTmp(rSis->constituent.code())==PENN_CON_VP) || (CConstituent::clearTmp(rSis->constituent.code())==PENN_CON_ADJP)) { // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_AUX); if (buildStanfordLink(STANFORD_DEP_AUX, targ->lexical_head, node.lexical_head)){ addLinked(&node,targ); //std::cout<<"nSubj13"<<" (head: "<<node.lexical_head<<")"<<"(npTarg->lexical_head<<")\n"; return true; } } rightSisters=rightSisters->next; } } childs=childs->next; } } return false; }
void Shader::validate() const { if (!isLinked()) { throw ShaderException("Program is not linked"); } GLint success; glValidateProgram(id_); glGetProgramiv(id_, GL_VALIDATE_STATUS, &success); if (!success) { int length = 0; std::string logString; glGetProgramiv(id_, GL_INFO_LOG_LENGTH, &length); if (length > 0) { char *c_log = new char[length]; int written = 0; glGetProgramInfoLog(id_, length, &written, c_log); logString = c_log; delete[] c_log; } throw ShaderException(std::string("Program failed to validate\n") + logString); } }
bool Tree::link(Planet* target) { if(target == planet) return false; if(isLinked(target)) return false; links.push_back( new Link(this, target) ); planet->playFX(SND_NEW_ROOTLET); return true; }
void Program::use() const { checkDirty(); if (!isLinked()) return; glUseProgram(id()); }
//"WHNP|WHNP-TMP|WHNP-ADV|NP|NP-TMP|NP-ADV < (PDT|DT=target $+ DT $++ (/^JJ/ !$+ /^NN/)) !$++ CC", inline const bool &predet2(const unsigned long &cons){ CStateNodeList* childsN=node.m_umbinarizedSubNodes; while(childsN!=0){ const CStateNode* head=childsN->node; if (CConstituent::clearTmp(head->constituent.code())==PENN_CON_WHNP || CConstituent::clearTmp(head->constituent.code())==PENN_CON_NP){ bool rightSisCond=true; CStateNodeList* rightSisters=childsN->next; while(rightSisters!=0){ if (((*words)[rightSisters->node->lexical_head].tag.code()==PENN_TAG_CC)){ rightSisCond=false; } rightSisters=rightSisters->next; } if (rightSisCond){ CStateNodeList* childs=head->m_umbinarizedSubNodes; while(childs!=0){ const CStateNode* targ=childs->node; if (((*words)[targ->lexical_head].tag.code()==PENN_TAG_DT) ||((*words)[targ->lexical_head].tag.code()==PENN_TAG_PDT) && !isLinked(&node,targ)){ CStateNodeList* rightSis=childs->next; bool firstCond=false; bool secCond=false; if (rightSis!=0){ if (((*words)[rightSis->node->lexical_head].tag.code()==PENN_TAG_ADJECTIVE) ||((*words)[rightSis->node->lexical_head].tag.code()==PENN_TAG_ADJECTIVE_COMPARATIVE) ||((*words)[rightSis->node->lexical_head].tag.code()==PENN_TAG_ADJECTIVE_SUPERLATIVE)){ firstCond=true; } if (firstCond){ while(rightSis!=0){ //PENN_TAG_NOUN, PENN_TAG_NOUN_PROPER, PENN_TAG_NOUN_PROPER_PLURAL, PENN_TAG_NOUN_PLURAL, if (((*words)[rightSis->node->lexical_head].tag.code()==PENN_TAG_NOUN) ||((*words)[rightSis->node->lexical_head].tag.code()==PENN_TAG_NOUN_PROPER) ||((*words)[rightSis->node->lexical_head].tag.code()==PENN_TAG_NOUN_PROPER_PLURAL) ||((*words)[rightSis->node->lexical_head].tag.code()==PENN_TAG_NOUN_PLURAL)){ secCond=true; } rightSis=rightSis->next; } if (firstCond && secCond){ // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_PREDET); if (buildStanfordLink(STANFORD_DEP_PREDET, targ->lexical_head, head->lexical_head)) { addLinked(&node,targ); return true; } } } } } childs=childs->next; } } } childsN=childsN->next; } return false; }
//"__ [ < INTJ=target | < (PRN=target <1 /^(?:,|-LRB-)$/ <2 INTJ [ !<3 __ | <3 /^(?:,|-RRB-)$/ ] ) ]" inline const bool & discourse3(const unsigned long &cons){ bool cond1=false; bool cond2=false; CStateNodeList* childs=node.m_umbinarizedSubNodes; while(childs!=0){ const CStateNode* targ=childs->node; if (CConstituent::clearTmp(targ->constituent.code())==PENN_CON_INTJ && !isLinked(&node,targ)){ cond1=true; } else if (CConstituent::clearTmp(targ->constituent.code())==PENN_CON_PRN && !isLinked(&node,targ)){ bool child1=false; bool child2=false; bool child3=false; CStateNodeList* childsT=targ->m_umbinarizedSubNodes; if (childsT!=0){ if ((*words)[childsT->node->lexical_head].word==g_word_comma || (*words)[childsT->node->lexical_head].tag.code()==PENN_TAG_L_BRACKET){ child1=true; } if (child1 && childsT->next!=0){ if (CConstituent::clearTmp(childsT->next->node->constituent.code())==PENN_CON_INTJ){ child2=true; } if (child2 && childsT->next->next!=0){ if ((*words)[childsT->next->next->node->lexical_head].word==g_word_comma || (*words)[childsT->next->next->node->lexical_head].tag.code()==PENN_TAG_R_BRACKET){ child3=true; } } } } cond2=child1 && child2 && child3; } if (cond1||cond2){ // CDependencyLabel* label=new CDependencyLabel(0); if (buildStanfordLink(0, targ->lexical_head, node.lexical_head)) { addLinked(&node,targ); return true; } } childs=childs->next; } }
bool AdobeDRM::init() { done(); qDebug() << Q_FUNC_INFO; dpdev::DeviceProvider* dev_provider = dpdev::DeviceProvider::getProvider(0); if (!dev_provider) return false; qDebug() << Q_FUNC_INFO << "DeviceProvider created."; // getDevice will force generating device.xml. It's written inside the constructor of a static variable, hence it's created only once. m_device = dev_provider->getDevice(0); if (!m_device) return false; qDebug() << Q_FUNC_INFO << "Device created" << m_device->getDeviceName().utf8() << ", fingerprint: " << dp::String::base64Encode(m_device->getFingerprint()).utf8() // << ", activation record: " << dp::String::base64Encode(m_device->getActivationRecord()).utf8() << ", devicekey: " << dp::String::base64Encode(m_device->getDeviceKey()).utf8(); dpdrm::DRMProvider* drm_provider = dpdrm::DRMProvider::getProvider(); if (!drm_provider) return false; qDebug() << Q_FUNC_INFO << "DRM Provider created"; m_client = new AdobeDRMProcessorClient(); m_proc = drm_provider->createDRMProcessor(m_client, m_device); if(!m_proc) return false; qDebug() << Q_FUNC_INFO << "m_proc created"; // TODO: Establecer las descargas en /mnt/public // char tmp[2048]; // ::strcpy( tmp, "file://"); // ::strcat( tmp, qgetenv("ADEPT_ACTIVATION_FILE")); // dp::String url = dp::String(tmp); // qDebug() << Q_FUNC_INFO << "Setting AdobeDRM partition: " << url.utf8(); // dpio::Partition* partition = dpio::Partition::findPartitionForURL(url); // if( partition != NULL ) // { // qDebug() << Q_FUNC_INFO << "Setting AdobeDRM partition: " << partition->getPartitionName().utf8(); // m_proc->setPartition(partition); // } m_netProvider = new NETPROVIDERIMPL(0); dpnet::NetProvider::setProvider(m_netProvider); #ifdef Q_WS_QWS if( isLinked() ) { gatherCredentials(); } #endif return true; }
void tskNTP(void const * argument) { /* * Wait Signal(from Ethernet manager) * DNS request. * NTP Run() -> X: N Retry using the other NTP Server(DNS retry) || O: Time Update(); */ time_t now; uint8_t NTPServerNum; uint8_t temp; #if defined(NTP_SERVER_LIST) NTPServerNum = NTP_SERVER_NUM; uint8_t* NTPServerList[] = NTP_SERVER_LIST; #else NTPServerNum = NTP_SERVER_NUM_DEFAULT; uint8_t* NTPServerList[] = NTP_SERVER_LIST_DEFAULT; #endif while(1) { if(!isLinked() || (NetInfo.dhcp == NETINFO_DHCP && leaseTime == 0)) continue; temp = 0; do{ now = NTPTimeOut(NTPServerList[temp],NETINFO_NTP_TIMEOUT); if(now > 0) { DHCPLeasedTime = now - 2208988800 - time(NULL) + DHCPLeasedTime; time_dat = now - 2208988800; srand(now^randomKey); #if WIZSYSTEM_DEBUG printf("NTP Time updated.\r\n"); printfTime(9); #endif osSignalSet(userTaskId,0x0001); osDelay(1000*60);//NETINFO_NTP_PERIODIC); break; } else { #if WIZSYSTEM_DEBUG printf("Retry update time using other NTP Server. Retry Count = %d\r\n",temp); #endif if(++temp == NETINFO_NTP_RETRY) { /*todo*/ //Signal transmit to ethernet manager? #if WIZSYSTEM_DEBUG printf("NTP Failed. Retry NTP time update after 10 minutes.\r\n"); #endif osDelay(600000);//Retry NTP time update after 10 minutes. } } }while(temp < NTPServerNum); } }
void PluggableWare::initializeWare(const WareID_t& ID) { if (!isLinked()) throw openfluid::base::FrameworkException( openfluid::base::FrameworkException::computeContext(OPENFLUID_CODE_LOCATION) .addInfos({{"wareid",ID}}), "initialized ware that is not fully linked"); m_WareID = ID; };
void tskEthernetManager(void const * argument) { uint8_t preLinkStatus; uint8_t curLinkStatus; int8_t ret; sockMutexId = osMutexCreate(osMutex(sockMutex)); spiMutexId = osMutexCreate(osMutex(spiMutex)); NetMemPoolId = osPoolCreate(osPool(NetMemPool)); #if NETINFO_NTP_USE osThreadDef(ntptask, tskNTP, osPriorityBelowNormal, 0, 512); tskNTPId = osThreadCreate(osThread(ntptask), NULL); #endif //NETINFO_NTP_USE wizSystemInit(); #if WIZSYSTEM_DEBUG printf("TASK: Ethernet manager start.\r\n"); #endif while(1) { osDelay(1000);// Every sec curLinkStatus = isLinked(); if(preLinkStatus != curLinkStatus) { preLinkStatus = curLinkStatus; if(curLinkStatus) { leaseTime = 0; } else { #if WIZSYSTEM_DEBUG printf("Ethernet Unliked. W5500 Reinitialize.\r\n"); wizSystemInit(); //W5500 initialize #endif } } if(NetInfo.dhcp == NETINFO_DHCP && DHCPLeasedTime+leaseTime < time(NULL)) { ret = DHCPTimeOut(NETINFO_DHCP_TIMEOUT); if(ret == DHCP_IP_LEASED) { DHCPLeasedTime = time(NULL); return; } else { leaseTime = 0; } } } }
//"@NP <1 (@NP <<# /^%$/) <2 (@NP=target <<# days|month|months) !<3 __", inline const bool &npadvmod4(const unsigned long &cons){ if (cons==PENN_CON_NP){ CStateNodeList* childsNp=node.m_umbinarizedSubNodes; if (childsNp!=0){ bool firstCond=false; if (CConstituent::clearTmp(childsNp->node->constituent.code())==PENN_CON_NP){ // CStateNodeList* desc=new CStateNodeList(); listDescendants(childsNp->node->m_umbinarizedSubNodes, desc); if (desc->node==0) { desc->clear(); desc=0; } while(desc!=0){ if (((*words)[desc->node->lexical_head].word==g_word_perc) && (childsNp->node->lexical_head==desc->node->lexical_head)){ firstCond=true; } desc=desc->next; } } childsNp=childsNp->next; if (childsNp!=0 && firstCond){ bool secCond=false; const CStateNode* targ=childsNp->node; if (CConstituent::clearTmp(targ->constituent.code())==PENN_CON_NP && !isLinked(&node,targ)){ CStateNodeList* desc2=new CStateNodeList(); listDescendants(targ->m_umbinarizedSubNodes, desc2); if (desc2->node==0) { desc2->clear(); desc2=0; } while(desc2!=0){ if (((*words)[desc2->node->lexical_head].word==g_word_days || (*words)[desc2->node->lexical_head].word==g_word_month || (*words)[desc2->node->lexical_head].word==g_word_months) && (targ->lexical_head==desc2->node->lexical_head)){ secCond=true; } desc2=desc2->next; } } childsNp=childsNp->next; if (childsNp==0 && secCond){ //there is no 3rd child // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_NPADVMOD); if (buildStanfordLink(STANFORD_DEP_NPADVMOD, targ->lexical_head, node.lexical_head)) { addLinked(&node,targ); return true; } } } } } return false; }
inline const bool & buildXComp6(const unsigned long &cons) { if (cons==PENN_CON_VP){ CStateNodeList* childsfstVp=node.m_umbinarizedSubNodes; while(childsfstVp!=0){ const CStateNode* vpNode=childsfstVp->node; if (CConstituent::clearTmp(vpNode->constituent.code())==PENN_CON_VP){ CStateNodeList* childsVp=vpNode->m_umbinarizedSubNodes; while(childsVp!=0){ const CStateNode* sTarg=childsVp->node; if (CConstituent::clearTmp(sTarg->constituent.code())==PENN_CON_S && (!isLinked(vpNode,sTarg))) { bool firstCondition=true; //A $- B A is the immediate right sister of B if (childsVp->previous!=0){ const CStateNode* leftSisterS=childsVp->previous->node; if (((*words)[leftSisterS->lexical_head].tag.code()==PENN_TAG_NOUN)) { //CStateNodeList* childsNN=leftSisterS->m_umbinarizedSubNodes; //while(childsNN!=0){ //const CStateNode* orderChild=childsNN->node; if ((*words)[leftSisterS->lexical_head].word==g_word_order){ firstCondition=false; } //childsNN=childsNN->next; //} } } if (firstCondition){ //S=target <: NP //A <: B B is the only child of A CStateNodeList* childsS=sTarg->m_umbinarizedSubNodes; if (childsS!=0){ if ((CConstituent::clearTmp(childsS->node->constituent.code())==PENN_CON_NP) && (childsS->next ==0)){ // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_XCOMP); if (buildStanfordLink(STANFORD_DEP_XCOMP, sTarg->lexical_head, vpNode->lexical_head)) { //addLinked(vpNode,sTarg); addLinked(&node,sTarg); //I think this is not correct, in this specific case. return true; } } } } } childsVp=childsVp->next; } } childsfstVp=childsfstVp->next; } } return false; }
void GLSLShader::initialize() { //#0 PREPARE SHADER GLuint vertexShader; GLuint fragmentShader; vertexShader = prepareShader("basicNew.vert", GLSL::VERTEX); fragmentShader = prepareShader("basicNew.frag", GLSL::FRAGMENT); //#1 CREATE PROGRAM HANDLER programHandle = glCreateProgram(); //programHandle = glCreateProgram(); if(0 == programHandle) { logString += "Error creating program object\n"; exit(1); } //#2 ATTACH SHADER TO PROGRAM glAttachShader( programHandle, fragmentShader ); glAttachShader( programHandle, vertexShader ); ///////////////////////////////////////////////////////////////////////////////////////////////////// std::vector<Eigen::Vector4f> vdata; vdata.push_back(Eigen::Vector4f(-1, -1, 0, 1)); vdata.push_back(Eigen::Vector4f(1, -1, 0, 1)); vdata.push_back(Eigen::Vector4f(0, 1, 0, 1)); std::vector<Eigen::Vector4f> vdataColor; vdataColor.push_back(Eigen::Vector4f(1, 0, 0, 1)); vdataColor.push_back(Eigen::Vector4f(0, 1, 0, 1)); vdataColor.push_back(Eigen::Vector4f(0, 0, 1, 1)); createVertexAttribute(0, "in_Vertex_Position", vdata); // createVertexTFAttribute(0, "in_Vertex_Position", vdata); size = vdata.size() * 4; createVertexTFAttribute2("Color"); // createVertexAttribute(1, "in_Vertex_Color", vdataColor); ////////////////////////////////////////////////////////////////////// //#3 LINK PROGRAM link(); //#4 USE PROGRAM if(isLinked())use(); printActiveAttribs(); }
void ShaderProgram::deleteProgram(void) { // Don't do anything if we haven't linked the shader program. if(!isLinked()) { glDeleteProgram(programID); return; } // If we have, reset the variable... linked = false; // ... and tell OpenGL to delete the program. glDeleteProgram(programID); }
//"@ADVP|ADJP|WHADJP|WHADVP|PP|WHPP <# (JJ|JJR|IN|RB|RBR !< notwithstanding $- (@NP=target !< NNP|NNPS))", inline const bool &npadvmod1(const unsigned long &cons){ if (cons==PENN_CON_ADVP||cons==PENN_CON_ADJP||cons==PENN_CON_WHADJP||cons==PENN_CON_WHADJP||cons==PENN_CON_PP||cons==PENN_CON_WHPP) { CStateNodeList* childs=node.m_umbinarizedSubNodes; while(childs!=0){ if (((*words)[childs->node->lexical_head].tag.code()==PENN_TAG_ADJECTIVE || (*words)[childs->node->lexical_head].tag.code()==PENN_TAG_ADJECTIVE_COMPARATIVE || (*words)[childs->node->lexical_head].tag.code()==PENN_TAG_IN || (*words)[childs->node->lexical_head].tag.code()==PENN_TAG_ADVERB || (*words)[childs->node->lexical_head].tag.code()==PENN_TAG_ADVERB_COMPARATIVE) && childs->node->lexical_head==node.lexical_head) { bool inCond=true; //CStateNodeList* childsJ=childs->node->m_umbinarizedSubNodes; //while(childsJ!=0){ if ((*words)[childs->node->lexical_head].word==g_word_notwithstanding){ inCond=false; } // childsJ=childsJ->next; //} if (inCond){ if (childs->previous!=0){ const CStateNode* npTarg=childs->previous->node; if (CConstituent::clearTmp(npTarg->constituent.code())==PENN_CON_NP && !isLinked(&node,npTarg)){ bool lastCond=true; CStateNodeList* childsNp=npTarg->m_umbinarizedSubNodes; while(childsNp!=0){ if ((*words)[childsNp->node->lexical_head].tag.code()==PENN_TAG_NOUN_PROPER || (*words)[childsNp->node->lexical_head].tag.code()==PENN_TAG_NOUN_PLURAL){ lastCond=false; } childsNp=childsNp->next; } if (lastCond){ // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_NPADVMOD); if (buildStanfordLink(STANFORD_DEP_NPADVMOD, npTarg->lexical_head, node.lexical_head)) { addLinked(&node,npTarg); return true; } } } } } } childs=childs->next; } } return false; }
//"VP < (S=target !$- (NN < order) < (VP < TO))", // used to have !> (VP < (VB|AUX < be)) inline const bool & buildXComp1(const unsigned long &cons) { if (cons==PENN_CON_VP){ CStateNodeList* childsVp=node.m_umbinarizedSubNodes; while(childsVp!=0){ const CStateNode* sTarg=childsVp->node; if (CConstituent::clearTmp(sTarg->constituent.code())==PENN_CON_S && (!isLinked(&node,sTarg))){ //A $- B: A is the immediate right sister of B // std::cerr<<"S"<<((*words)[sTarg->lexical_head].word)<<"\n"; bool sisterCondition=false; if (childsVp->previous!=0){ const CStateNode* leftSisterS=childsVp->previous->node; if (((*words)[leftSisterS->lexical_head].tag.code()==PENN_TAG_NOUN)) { if ((*words)[leftSisterS->lexical_head].word==g_word_order){ sisterCondition=true; // std::cerr<<"NN order"<<((*words)[leftSisterS->lexical_head].word)<<"\n"; } } } // std::cerr<<"-->"<<sisterCondition<<"\n"; if (!sisterCondition){ CStateNodeList* childsS=sTarg->m_umbinarizedSubNodes; while(childsS!=0){ const CStateNode* vpChild=childsS->node; if (CConstituent::clearTmp(vpChild->constituent.code())==PENN_CON_VP){ // std::cerr<<"VP"<<((*words)[vpChild->lexical_head].word)<<"\n"; CStateNodeList* childsVps=vpChild->m_umbinarizedSubNodes; while(childsVps!=0){ if ((*words)[childsVps->node->lexical_head].tag.code()==PENN_TAG_TO) { // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_XCOMP); // std::cerr<<"TO"<<((*words)[childsVps->node->lexical_head].word)<<"\n"; if (buildStanfordLink(STANFORD_DEP_XCOMP, sTarg->lexical_head, node.lexical_head)) { addLinked(&node,sTarg); return true; } } childsVps=childsVps->next; } } childsS=childsS->next; } } } childsVp=childsVp->next; } } return false; }
bool eFBCTunerManager::isLinkedByIndex(int fe_idx) { bool linked = false; eSmartPtrList<eDVBRegisteredFrontend> &frontends = m_res_mgr->m_frontend; for (eSmartPtrList<eDVBRegisteredFrontend>::iterator it(frontends.begin()); it != frontends.end(); ++it) { if (FE_SLOT_ID(it) == fe_idx) { linked = isLinked(*it); break; } } return linked; }
void CallLinkInfo::unlink(VM& vm) { if (!isLinked()) { // We could be called even if we're not linked anymore because of how polymorphic calls // work. Each callsite within the polymorphic call stub may separately ask us to unlink(). RELEASE_ASSERT(!isOnList()); return; } unlinkFor(vm, *this); // It will be on a list if the callee has a code block. if (isOnList()) remove(); }
//"VP < (S=target !$- (NN < order) < (NP $+ NP|ADJP))", inline const bool &buildXComp3(const unsigned long &cons) { if (cons==PENN_CON_VP){ CStateNodeList* childsVp=node.m_umbinarizedSubNodes; while(childsVp!=0){ const CStateNode* sTarg=childsVp->node; if (CConstituent::clearTmp(sTarg->constituent.code())==PENN_CON_S && (!isLinked(&node,sTarg))){ //A $- B: A is the immediate right sister of B bool sisterCondition=false; if (childsVp->previous!=0){ const CStateNode* leftSisterS=childsVp->previous->node; if (((*words)[leftSisterS->lexical_head].tag.code()==PENN_TAG_NOUN)) { //CStateNodeList* childsNN=leftSisterS->m_umbinarizedSubNodes; //while(childsNN!=0){ //const CStateNode* orderChild=childsNN->node; if ((*words)[leftSisterS->lexical_head].word==g_word_order){ sisterCondition=true; } //childsNN=childsNN->next; //} } } if (sisterCondition){ CStateNodeList* childsS=sTarg->m_umbinarizedSubNodes; while(childsS!=0){ const CStateNode* npChildS=childsS->node; if (CConstituent::clearTmp(npChildS->constituent.code())==PENN_CON_NP){ //A $+ B A is the immediate left sister of B if (childsS->next!=0){ if (CConstituent::clearTmp(childsS->next->node->constituent.code())==PENN_CON_NP ||CConstituent::clearTmp(childsS->next->node->constituent.code())==PENN_CON_ADJP){ // CDependencyLabel* label=new CDependencyLabel(STANFORD_DEP_XCOMP); if (buildStanfordLink(STANFORD_DEP_XCOMP, sTarg->lexical_head, node.lexical_head)) { addLinked(&node,sTarg); return true; } } } } childsS=childsS->next; } } } childsVp=childsVp->next; } } return false; }