//stop homie PUBLIC RETCODE HomieStop(hHOMIE homie, hGMAP map) { CLEARFLAG(homie->status, HOMIE_MOVING); CLEARFLAG(homie->status, HOMIE_STUCK); //adjust to current tile hTILE tile = &CELL(map->tiles, homie->indY, homie->indX, map->indSizeX); //check if the tile is one of the arrows if(tile->type >= eTILE_ARROW_N && tile->type <= eTILE_ARROW_W) { SETFLAG(homie->status, HOMIE_STUCK); OBJSetState(homie->obj, eHOMIESTATE_STAND); } //else if(tile->type == eTILE_FLOOR) // OBJSetState(homie->obj, eHOMIESTATE_STAND); else if(tile->type == eTILE_GOAL && tile->homieType == homie->type) OBJSetState(homie->obj, eHOMIESTATE_CELEBRATE); else OBJSetState(homie->obj, eHOMIESTATE_STAND); float homieLoc[eMaxPt]; OBJGetLoc(homie->obj, homieLoc); float tileLoc[eMaxPt]; OBJGetLoc(tile->obj, tileLoc); OBJSetLoc(homie->obj, tileLoc[eX], homieLoc[eY], tileLoc[eZ]); SETFLAG(tile->status, TILE_OCCUPIED); return RETCODE_SUCCESS; }
void builtin_fg(t_cmd *cmd, UNSEDP t_fds *fd, t_sh *shell) { int pgid; int i; int nb; i = 0; nb = 0; if (shell->process_group == NULL || !shell->jobcontrol) return ; if (cmd->argv[1] != NULL) nb = my_getnbr(cmd->argv[1]) - 1; while ((shell->process_group[i] != NULL) && (i < nb)) i++; if (shell->process_group[i] != NULL) { pgid = shell->process_group[i]->pid.pgid; if (pgid != -1) { SETFLAG(shell->process_group[i]->flags, FLAGPOS(FGRP_FORGROUND)); SETFLAG(shell->process_group[i]->flags, FLAGPOS(FGRP_RUNNING)); if (set_forground_pgrp(pgid) == -1) set_forground_pgrp(shell->pid.pgid); kill(-pgid, SIGCONT); } } }
///////////////////////////////////// // Name: // Purpose: // Output: // Return: ///////////////////////////////////// PUBLIC RETCODE OBJAddChild(hOBJ obj, hOBJ child, int parentJointInd, bool syncState) { //remove child from it's refered list if(TESTFLAGS(child->status, OBJ_CHILD)) { OBJDestroy(&child); //this will just subtract the child ref //OBJRemoveFromParent(child); } child->listRef->remove((unsigned int)child); obj->objNode->push_back((unsigned int)child); child->listRef = obj->objNode; OBJAddRef(child); //set flags SETFLAG(child->status, OBJ_CHILD); //set parent ID key child->parentKey = obj->key; //set parent joint child->parentJointInd = parentJointInd; if(syncState) //will the child synchronize state with parent? { SETFLAG(child->status, OBJ_SYNCSTATE); child->curState = obj->curState; } return RETCODE_SUCCESS; }
void sig_handler(int sig) { t_sh *shell; shell = get_sh_info(NULL); SETFLAG(shell->signal, FLAGPOS(sig)); if (sig == SIGINT) { my_putstr("\n", 1, -1); my_putstr(shell->param.str_prompt, 1, -1); if (shell->param.fallback == 1) { if (shell->param.cmd != NULL) shell->param.cmd[0] = '\0'; shell->param.pos = 0; refresh_view(&(shell->param)); view(shell->param.cmd, &(shell->param)); } } if (sig == SIGWINCH && shell->param.fallback == 1) clear_cmd(shell->param.cmd, &(shell->param)); if ((sig == SIGHUP) || (sig == SIGTERM) || (sig == SIGQUIT)) { SETFLAG(shell->beepbeepexit, FLAGPOS(EXIT_F_POS)); close(0); } init_sig(&sig_handler); }
/*** redraw - Mark a range of lines in file dirty * * Marks a range of lines in a file as needing to be updated. Each window that * they occur in is marked. * * Input: * pFile = File handle containing dirty lines * linFirst, linLast = Range of lines to mark * * Output: * Returns nothing * *************************************************************************/ void redraw ( PFILE pFile, LINE linFirst, LINE linLast ) { LINE linFirstUpd, linLastUpd; REGISTER PINS pInsTmp; int iWinTmp; REGISTER struct windowType *pWinTmp; if (linFirst > linLast) { linFirstUpd = linLast; linLast = linFirst; linFirst = linFirstUpd; } for (iWinTmp = 0, pWinTmp = WinList; iWinTmp < cWin; iWinTmp++, pWinTmp++) { if (pWinTmp->pInstance) { if (pFile == pWinTmp->pInstance->pFile) { pInsTmp = pWinTmp->pInstance; linFirstUpd = WINYPOS(pWinTmp) + lmax (0L, linFirst-YWIN(pInsTmp)-1); linLastUpd = WINYPOS(pWinTmp) + lmin ((long) (WINYSIZE(pWinTmp) - 1), linLast - YWIN(pInsTmp)); while (linFirstUpd <= linLastUpd) { SETFLAG (fChange[linFirstUpd++],FMODIFY); } } } } SETFLAG (fDisplay, RTEXT); }
/*** makedirty * * * Input: * * Output: * *************************************************************************/ void makedirty ( REGISTER PFILE pFileDirty ) { if (!TESTFLAG(FLAGS(pFileDirty),DIRTY)) { if (pFileDirty == pFileHead) { SETFLAG (fDisplay, RSTATUS); } SETFLAG (FLAGS(pFileDirty), DIRTY); } }
/*** newscreen - Mark entire screen dirty * * Forces entire screen to be redrawn. * * Input: * none * * Output: * Returns nothing * *************************************************************************/ void newscreen ( void ) { REGISTER int iLine = YSIZE; while (iLine--) { SETFLAG ( fChange[iLine], FMODIFY ); } SETFLAG (fDisplay, RTEXT); }
static void doBIT (Z80Context* ctx, int b, byte val) { if (val & (1 << b)) RESFLAG(F_Z | F_PV); else SETFLAG(F_Z | F_PV); SETFLAG(F_H); RESFLAG(F_N); RESFLAG(F_S); if ((b == 7) && !GETFLAG(F_Z)) SETFLAG(F_S); }
//move homie PUBLIC RETCODE HomieMove(hHOMIE homie, eDIR dir, hGMAP map) { if(!TESTFLAGS(homie->status, HOMIE_MOVING) && !TESTFLAGS(homie->status, HOMIE_STUCK) && !TESTFLAGS(homie->status, HOMIE_DEAD)) { switch(dir) { case eDIR_SOUTH: OBJSetOrientation(homie->obj, 0, 0, GCFGGetHomieSpd()); break; case eDIR_NORTH: OBJSetOrientation(homie->obj, 0, 0, -GCFGGetHomieSpd()); break; case eDIR_EAST: OBJSetOrientation(homie->obj, -GCFGGetHomieSpd(), 0, 0); break; case eDIR_WEST: OBJSetOrientation(homie->obj, GCFGGetHomieSpd(), 0, 0); break; } OBJSetState(homie->obj, eHOMIESTATE_MOVE); SETFLAG(homie->status, HOMIE_MOVING); hTILE tile = &CELL(map->tiles, homie->indY, homie->indX, map->indSizeX); CLEARFLAG(tile->status, TILE_OCCUPIED); } return RETCODE_SUCCESS; }
///////////////////////////////////// // Name: OBJPause // Purpose: pause / resume object // (true) (false) // Output: Obj flag is set // Return: none ///////////////////////////////////// PUBLIC void OBJPause(hOBJ obj, bool bPause) { if(bPause) SETFLAG(obj->status, OBJ_PAUSE); else CLEARFLAG(obj->status, OBJ_PAUSE); }
///////////////////////////////////// // Purpose: enable/disable model // If disabled, model will // not perform collision // and will not be displayed // Output: model status set // Return: none ///////////////////////////////////// void IgfxQBSP::ModelEnable(u32 modelInd, u8 bEnable) { if(bEnable) CLEARFLAG(m_models[modelInd].status, QBSP_MODEL_FLAG_DISABLE); else SETFLAG(m_models[modelInd].status, QBSP_MODEL_FLAG_DISABLE); }
int exec_process(t_cmd *cmd, t_fds *fd, t_sh *shell, int (*f)(char *cmd, char **argv, t_sh *shell)) { int ret_exec; if ((cmd->pid.pid = check_perror("Fork", fork())) == 0) { if (cmd->pid.pgid != -1) { if (check_perror("Setpgid", setpgid(0, cmd->pid.pgid)) == -1) check_perror("Setpgid", setpgid(0, 0)); } else check_perror("Setpgid", setpgid(0, 0)); check_perror("Dup2", dup2(fd->stdin, 0)); check_perror("Dup2", dup2(fd->stdout, 1)); check_perror("Dup2", dup2(fd->stderr, 2)); if ((ret_exec = f(cmd->cmd_fpath, cmd->argv, shell)) == -1) my_perror(cmd->cmd_fpath); my_exit(ret_exec); SETFLAG(shell->beepbeepexit, FLAGPOS(EXIT_FORK)); } else if (cmd->pid.pid != -1) check_grp_set(cmd->pid.pid, (cmd->pid.pgid == -1) ? cmd->pid.pid : cmd->pid.pgid); return (cmd->pid.pid); }
/** Puts a value in a flag */ static void valFlag(Z80Context* ctx, Z80Flags flag, int val) { if (val) SETFLAG(flag); else RESFLAG(flag); }
PUBLIC RETCODE OBJUpdateFrame(hOBJ obj) { if(!TESTFLAGS(obj->status, OBJ_PAUSE)) { if(obj->states) { //do the tick count if(TimerEllapse(&obj->ticker)) { int & theFrame = obj->states[obj->curState].curFrame; theFrame++; if(/*theFrame < Sprite->States[Sprite->CurState].firstframe ||*/ theFrame > obj->states[obj->curState].endFrame) { if(TESTFLAGS(obj->status, OBJ_PAUSE_ON_END)) { SETFLAG(obj->status, OBJ_PAUSE); theFrame = obj->states[obj->curState].endFrame; } else theFrame = obj->states[obj->curState].startFrame; } obj->curMesh = obj->theMdl->frames[theFrame].frameMesh; } } for(LISTPTR::iterator i = obj->objNode->begin(); i != obj->objNode->end(); ++i) OBJUpdateFrame((hOBJ)(*i)); } return RETCODE_SUCCESS; }
///////////////////////////////////// // Name: LightEnableRender // Purpose: enable/disable lighting // Output: light enabled/disabled // Return: none ///////////////////////////////////// void F_API LightEnableRender(u8 bYes) { if(bYes) SETFLAG(g_FLAGS, GFX_LIGHTENABLE); else CLEARFLAG(g_FLAGS, GFX_LIGHTENABLE); g_p3DDevice->SetRenderState(D3DRS_LIGHTING,bYes); }
///////////////////////////////////// // Name: // Purpose: // Output: // Return: ///////////////////////////////////// PUBLIC void OBJPauseOnStateEnd(hOBJ obj, bool bPause) { if(bPause) SETFLAG(obj->status, OBJ_PAUSE_ON_END); else CLEARFLAG(obj->status, OBJ_PAUSE_ON_END); }
static void set_coordinate_frame(rift_priv* priv, rift_coordinate_frame coordframe) { priv->coordinate_frame = coordframe; // set the RIFT_SCF_SENSOR_COORDINATES in the sensor config to match whether coordframe is hmd or sensor SETFLAG(priv->sensor_config.flags, RIFT_SCF_SENSOR_COORDINATES, coordframe == RIFT_CF_SENSOR); // encode send the new config to the Rift unsigned char buf[FEATURE_BUFFER_SIZE]; int size = encode_sensor_config(buf, &priv->sensor_config); if(send_feature_report(priv, buf, size) == -1){ ohmd_set_error(priv->base.ctx, "send_feature_report failed in set_coordinate frame"); return; } // read the state again, set the hw_coordinate_frame to match what // the hardware actually is set to just incase it doesn't stick. size = get_feature_report(priv, RIFT_CMD_SENSOR_CONFIG, buf); if(size <= 0){ LOGW("could not set coordinate frame"); priv->hw_coordinate_frame = RIFT_CF_HMD; return; } decode_sensor_config(&priv->sensor_config, buf, size); priv->hw_coordinate_frame = (priv->sensor_config.flags & RIFT_SCF_SENSOR_COORDINATES) ? RIFT_CF_SENSOR : RIFT_CF_HMD; if(priv->hw_coordinate_frame != coordframe) { LOGW("coordinate frame didn't stick"); } }
///////////////////////////////////// // Purpose: enable/disable shadow // volume for given object // Output: set/clear shadow flag // Return: none ///////////////////////////////////// void IgfxObject::EnableShadow(u8 bYes) { if(bYes) SETFLAG(m_flag, OBJECT_SHADOW); else CLEARFLAG(m_flag, OBJECT_SHADOW); }
///////////////////////////////////// // Purpose: enable/disable shadow // receiving // Output: set/clear shadow flag // Return: none ///////////////////////////////////// void IgfxObject::ReceiveShadow(u8 bYes) { if(bYes) CLEARFLAG(m_flag, OBJECT_NORECSHADOW); else SETFLAG(m_flag, OBJECT_NORECSHADOW); }
/* fSyncFile - Attempt to make logical file and physical file the same * * When editing in a network or multi-tasking environment, we need to make * sure that changes made underneath us are properly reflected to the * user. We do this by snapshotting the time-of-last-write and periodically * comparing it with the version on disk. When a mismatch is found, we * prompt the user and give him the opportunity to reread the file * * pFileLoc file structure of interest * fPrompt TRUE => prompt user for permission to refresh, else just * refresh. * * returns TRUE iff the logical file and the physical file are the same. */ flagType fSyncFile ( PFILE pFileLoc, flagType fPrompt ) { if (pFileLoc == NULL) { pFileLoc = pFileHead; } switch (FileStatus (pFileLoc, NULL)) { case FILECHANGED: if (!confirmx("%s has been changed. Refresh? ", pFileLoc->pName)) { /* No, validate this edit session */ SetModTime (pFileLoc); return FALSE; } FileRead (strcpy( buf, pFileLoc->pName ), pFileLoc, TRUE); RSETFLAG (FLAGS (pFileLoc), DIRTY); SETFLAG (fDisplay, RSTATUS); return TRUE; case FILEDELETED: domessage ("File has been deleted"); break; default: break; } return TRUE; }
static int pack_key2values(struct ddb_packed *pack, const struct ddb_entry *keys, const struct ddb_map *keys_map, int unique_items) { valueid_t *values = NULL; uint64_t values_size = 0; char *dbuf = NULL; uint64_t dbuf_size = 0; int i, ret = -1; uint32_t num = pack->head->num_keys; if (buffer_new_section(pack, num + 1)) goto end; for (i = 0; i < num; i++){ uintptr_t *ptr = ddb_map_lookup_str(keys_map, &keys[i]); uint64_t size, num_values; uint32_t num_written; int duplicates = 0; const struct ddb_deltalist *d = (const struct ddb_deltalist*)*ptr; if (ddb_deltalist_to_array(d, &num_values, &values, &values_size)) goto end; if (num_values > UINT32_MAX) goto end; if (ddb_delta_encode(values, (uint32_t)num_values, &dbuf, &dbuf_size, &size, &num_written, &duplicates, unique_items)) goto end; pack->head->num_values += num_written; if (duplicates){ SETFLAG(pack->head, F_MULTISET); } buffer_toc_mark(pack); if (buffer_write_data(pack, (const char*)&keys[i].length, 4)) goto end; if (buffer_write_data(pack, keys[i].data, keys[i].length)) goto end; if (buffer_write_data(pack, dbuf, size)) goto end; } buffer_toc_mark(pack); ret = 0; end: free(values); free(dbuf); return ret; }
void builtin_exit(t_cmd *cmd, UNSEDP t_fds *fd, t_sh *shell) { if (cmd->argv[1] != NULL) shell->beepbeepexit = my_getnbr(cmd->argv[1]); else shell->beepbeepexit = 0; SETFLAG(shell->beepbeepexit, FLAGPOS(EXIT_F_POS)); UNSETFLAG(shell->beepbeepexit, FLAGPOS(EXIT_FORK)); }
///////////////////////////////////// // Name: OBJDeactivate // Purpose: deactivates obj // Output: stuff happens // Return: none ///////////////////////////////////// PUBLIC void OBJDeactivate(hOBJ obj) { //remove object from previous list obj->listRef->remove((unsigned int)obj); //add object to deactivated object list g_OBJDEACTIVATELIST.insert(g_OBJDEACTIVATELIST.end(), (unsigned int)obj); obj->listRef = &g_OBJDEACTIVATELIST; SETFLAG(obj->status, OBJ_DEACTIVATE); }
/** ****************************************************************************** ** ** Function Name : LCD_WriteControl ** ** Description : Write a control instruction to the LCD ** ** Passed Parameters : data ** ** Modified Data : None ** ** Return Value : None ** ****************************************************************************** */ static void LCD_WriteControl( uint8 line, uint8 data ) { uint8 localCount; uint8 com; LCD_BKLIT_ON; SETFLAG(LCD_BACKLIT_ON); BacklitTimeoutTimer = MS_TIMER + 30000; com = data; // RS=0, R/W=0, E=0 LCD_RS_LOW; LCD_RW_LOW; if( line == 1 ) { LCD_EN1_HIGH; } else { LCD_EN2_HIGH; } for( localCount=0; localCount<8; localCount++ ) { if( com & 0x80 ) { SET_PORT1_PIN_HIGH( LCD_DATA ); SET_PORT1_PIN_HIGH( LCD_DATA ); SET_PORT1_PIN_HIGH( LCD_DATA ); SET_PORT1_PIN_HIGH( LCD_DATA ); } else { SET_PORT1_PIN_LOW( LCD_DATA ); SET_PORT1_PIN_LOW( LCD_DATA ); SET_PORT1_PIN_LOW( LCD_DATA ); SET_PORT1_PIN_LOW( LCD_DATA ); } LCD_CLK_LOW; LCD_CLK_HIGH; com = com << 1; } // RS=0, R/W=0, E=1 LCD_RS_LOW; LCD_RW_LOW; if( line == 1 ) { LCD_EN1_HIGH; } else { LCD_EN2_HIGH; } Delay(5); // RS=0, R/W=0, E=0 LCD_RS_LOW; LCD_RW_LOW; if( line == 1 ) { LCD_EN1_LOW; } else { LCD_EN2_LOW; } Delay(5); // RS=0, R/W=1, E=0*/ LCD_RS_LOW; LCD_RW_HIGH; if( line == 1) { LCD_EN1_LOW; } else { LCD_EN2_LOW; } Delay(5); }
///////////////////////////////////// // Name: // Purpose: // Output: // Return: ///////////////////////////////////// PUBLIC RETCODE OBJAddChild(hOBJ obj, hOBJ child, bool syncState) { //remove child from it's refered list child->listRef->remove((unsigned int)child); obj->objNode->insert(obj->objNode->end(), (unsigned int)child); child->listRef = obj->objNode; OBJAddRef(child); //set flags SETFLAG(child->status, OBJ_CHILD); if(syncState) //will the child synchronize state with parent? { SETFLAG(child->status, OBJ_SYNCSTATE); child->curState = obj->curState; } return RETCODE_SUCCESS; }
/******************************************************************** * parseServerMessage: parses the current message and * * updates the values sent from the Server * ********************************************************************/ int parseServerMessage() { // Message formatting: // <F=%d,H=%d,T=%d,P=%d,VS=%d><EOF> // Flow,Freq,Temp,Pres,State int id = 0; char valstr[32]; memset(valstr, 0, sizeof(valstr)); //strtok breaks up the message into tokens, delimited by commas char* token = strtok(messageFromServer, DELIMS); while(token != NULL) { if(strcmp(token, EOFSTR) != 0) { parseToken(token, &id, valstr); switch(id) { case ID_STATE: //Current VFD State update.VFDState = atoi(valstr); // update flag LOCK(&flagMutex); SETFLAG(update.updateFlag, UPDATE_STATE); UNLOCK(&flagMutex); break; case ID_DESIREDFLOW: update.desiredFlowRate = atof(valstr); // update flag LOCK(&flagMutex); SETFLAG(update.updateFlag, UPDATE_FLOW); UNLOCK(&flagMutex); break; default: printf("UNKNOWN TAG ENCOUNTERED, TOKEN: ""%s""\n", token); } } token = strtok(NULL, DELIMS); } return 1; }
/*** SetScreen * * Purpose: * SetScreen () - Set up the editor's internal structures to match the screen * size described by ySize and xSize. Set the hardware to the mode in * Zvideo. * * Input: * * Output: * *************************************************************************/ void SetScreen ( void ) { fChange = ZEROREALLOC (fChange, YSIZE * sizeof (*fChange)); SETFLAG (fDisplay, RSTATUS); if (cWin == 1) { WINXSIZE(pWinCur) = XSIZE; WINYSIZE(pWinCur) = YSIZE; } newscreen (); // SetVideoState(Zvideo); }
/******************************************************************** * updateFlowRate: * * determines whether to change the frequency on the VFD to * * match the desired flow rate * ********************************************************************/ void updateFlowRate() { float prevFreq = update.frequency; // Save the previous frequency // Save off desired flow in case server updates while in this function // If this happens, it will be updated on the next pass float currentDesiredFlow = update.desiredFlowRate; // If desired flow was updated via server // start with frequency based on lookup table if(CHKFLAG(update.updateFlag, UPDATE_FLOW)) { //TODO: Change/update LUT for how frequency is first determined update.frequency = currentDesiredFlow*(60/3.5); //TEMPORARY printf("Update Flow set, flow: %f, freq: %f\n", currentDesiredFlow, update.frequency); // clear update flow flag LOCK(&flagMutex); CLRFLAG(update.updateFlag, UPDATE_FLOW); UNLOCK(&flagMutex); } else //adjust flow rate based on how off it is from actual { // float difference = 0; // difference = data.flowRate - currentDesiredFlow; // if (difference > FLOW_THRESH || difference < -FLOW_THRESH) // { // //TODO: Change how frequency is calculated // update.frequency -= (difference*10); //TEMPORARY // if (update.frequency > MAX_FREQ) // { // update.frequency = MAX_FREQ; // printf("frequency calculated above %d\n", MAX_FREQ); // } // else if (update.frequency < MIN_FREQ) // { // update.frequency = MIN_FREQ; // printf("frequency calculated below %d\n", MIN_FREQ); // } // } } // update flag if frequency changed if (prevFreq != update.frequency) { LOCK(&flagMutex); SETFLAG(update.updateFlag, UPDATE_FREQ); UNLOCK(&flagMutex); } }
/*** fFMtoPfile - Attach a FILEMARKS structure to a pFile. * * Purpose: * * To attach some marks to a file. * * Input: * pFile - File to get the marks * pfm - The marks * * Output: * * Returns TRUE if there were any marks, FALSE if not. * *************************************************************************/ flagType fFMtoPfile ( PFILE pFile, FILEMARKS * pfm ) { SETFLAG (FLAGS(pFile), VALMARKS); if (pFile->vaMarks != NULL) { FREE(pFile->vaMarks); pFile->vaMarks = NULL; } return (flagType)((pFile->vaMarks = FMtoVM (pfm)) != NULL); }
///////////////////////////////////// // Name: GFXEnableLight // Purpose: enable/disable light // also set ambient color // Output: light is enabled/disabled // Return: none ///////////////////////////////////// PUBLIC void GFXEnableLight(bool do_you_want_light) { //set light if(do_you_want_light) { g_p3DDevice->SetRenderState(D3DRS_LIGHTING,TRUE); CLEARFLAG(g_FLAGS, GFX_LIGHTDISABLE); } else { g_p3DDevice->SetRenderState(D3DRS_LIGHTING,FALSE); SETFLAG(g_FLAGS, GFX_LIGHTDISABLE); } }