Huint _create_system_thread( hthread_t *th, hthread_attr_t *attr, hthread_start_t start, void *arg ) { Huint threadStatus; Huint threadID; // Create the thread id for the new thread if( attr->detached ) threadStatus = _create_detached(); else threadStatus = _create_joinable(); // Check if there was an error while creating the new thread. If // there was then it means that all of the available threads are // being used, so we return an error. if( has_error(threadStatus) ) return EAGAIN; // If there was no error then we need to get the new thread's id // out of the return status. threadID = extract_id( threadStatus ); // Initialize the software structures used to keep track of the thread. _setup_thread( threadID, attr, start, arg ); // Set the scheduling parameter for the thread. _set_schedparam( threadID, attr->sched_param ); // Return the thread ID to the caller. At this point the thread has // been successfully created and added to the queue so that we know // a valid thread ID will be returned to the user. *th = threadID; // The thread was created and added to the ready-to-run queue // successfully. Return the success code. return SUCCESS; }
static void OnbonusShortClick (const char *name, const char *sprite, const char *image, const RoadMapGpsPosition *gps_position, const RoadMapGuiPoint *offset, BOOL is_visible, int scale, int opacity, const char *id, const char *text) { RealtimeBonus_PopUp (extract_id (id)); }
static void OnbonusShortClick (const char *name, const char *sprite, RoadMapDynamicString *images, int image_count, const RoadMapGpsPosition *gps_position, const RoadMapGuiPoint *offset, BOOL is_visible, int scale, int opacity, int scale_y, const char *id, ObjectText *texts, int text_count, int rotation) { RealtimeBonus_PopUp (extract_id (id)); }
static size_t find_first_id(const char* path) { struct dirent* entry; DIR* dp = opendir(path); if (dp == NULL) { exit(EXIT_FAILURE); } size_t file_id = ULLONG_MAX, current_id = 0; while ((entry = readdir(dp))) { if (extract_id(entry->d_name, ¤t_id)) { if (current_id < file_id) { file_id = current_id; } } } closedir(dp); return file_id == ULLONG_MAX ? 0 : file_id; }
static size_t find_first_id(const char *path) { struct dirent *entry; DIR *dp = opendir(path); if (dp == NULL) { hs_log(g_module, 0, "path does not exist: %s", path); exit(EXIT_FAILURE); } unsigned long long file_id = ULLONG_MAX, current_id = 0; while ((entry = readdir(dp))) { if (extract_id(entry->d_name, ¤t_id)) { if (current_id < file_id) { file_id = current_id; } } } closedir(dp); return file_id == ULLONG_MAX ? 0 : file_id; }
void token_names::read_token_names(std::istream& is) { m_names.clear(); std::string str; int lineno=0; while (!is.eof()) { std::getline(is, str); lineno++; try { // cout << getId(str) << " = " << getName(str) << endl; int id = extract_id(str); m_names[id] = extract_name(str); } catch(int a) { // ignore the line, = was not found //std::cerr << "ignoring line: " << lineno << std::endl; } } }
/** \internal * \brief The system call which implements the hthread_create functionality. * * \author Wesley Peck <*****@*****.**> * * This function is the system call routine which implements the * hthread_create functionality for hthreads. The user space function * hthread_create invokes this function to create a new thread. * * \param th If the thread was created successfully then the new * thread will be stored in the location pointed to * by this argument. * \param attr The attributes to apply to the newly created thread. * See the documentation for hthread_attr_t for more on * the allowable attributes. * \param start A function pointer which is used as the beginning of * the new threads execution. If this function ever returns * then the new thread will be terminated. * \param arg An arbitrary pointer which is used as the first and * only argument to the start routine. * \return The return value is one of the following: * - EAGAIN : There was an error when attempting to create * the new thread. Trying the attempt again might * have a different result. * - ENOMEM : Not enough memory is available to satisfy the * request. Attempting again after more memory * is free might have different results. * - EINVAL : One of the parameters used when calling this * function is invalid. * - FAILURE : A generic failure occurred in the hardware * when attempting to setup the thread. * - SUCCESS : The thread was created successfully */ Hint _syscall_create( hthread_t *th, hthread_attr_t *attr, hthread_start_t start, void *arg ) { Huint threadStatus; Huint threadID; Huint addStatus; Huint setupStatus; Huint schedStatus; // Print out a trace message about this system call TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (THR=0x%8.8x) (ATTR=0x%8.8x) (STRT=0x%8.8x) (ARG=0x%8.8x)\n", (Huint)th, (Huint)attr, (Huint)start, (Huint)arg ); // Ask the thread manager to create a new thread for us. If it // is successful then the thread id will be encoded into the return // value. if( attr->detached ) threadStatus = _create_detached(); else threadStatus = _create_joinable(); TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (DET = 0x%8.8x)\n",(Huint)attr->detached ); // Check if there was an error while creating the new thread. If // there was then it means that all of the available threads are // being used, so we return an error. if( has_error(threadStatus) ) { TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (STA=0x%8.8x) (ERR=CREATE)\n", threadStatus ); return EAGAIN; } // If there was no error then we need to get the new thread's id // out of the return status. threadID = extract_id( threadStatus ); TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (TID=0x%8.8x)\n", threadID ); // Initialize the software structures used to keep track of the thread. setupStatus = _setup_thread( threadID, attr, start, arg ); if( setupStatus != SUCCESS ) { TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (STA=0x%8.8x) (ERR=SETUP)\n", setupStatus ); return setupStatus; } // Set the scheduling parameter for the thread. if( attr->hardware != Htrue ) { TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (Software Thread Sched. Param = 0x%8.8x)\n",attr->sched_param); schedStatus = _set_schedparam( threadID, attr->sched_param ); } else { TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (Hardware Thread Sched. Param = 0x%8.8x)\n",attr->hardware_addr); schedStatus = _set_schedparam( threadID, attr->hardware_addr ); } if( schedStatus != SUCCESS ) { TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (STA=0x%8.8x) (ERR=SCHED)\n", schedStatus ); return schedStatus; } // Now that we have the new thread setup so that it can run we // can add the thread in the ready-to-run queue. addStatus = _add_thread( threadID ); // Check if there was an error when adding the thread into the // ready-to-run queue. If there was then we need to clean up the // new thread and return an error condition. if( has_error(addStatus) ) { TRACE_PRINTF( TRACE_DBG, TRACE_SYSCALL, "SYSCALL: (OP=CREATE) (STA=0x%8.8x) (ERR=ADD)\n", addStatus ); addStatus = _read_sched_status(threadID); _decode_sched_status(addStatus); // Clean up the software structures used by the thread. _destroy_thread( threadID ); // Remove the thread. _clear_thread( threadID ); // Return an error condition. return EAGAIN; } // Return the thread ID to the caller. At this point the thread has // been successfully created and added to the queue so that we know // a valid thread ID will be returned to the user. *th = threadID; // Print out a trace message about this system call TRACE_PRINTF( TRACE_FINE, TRACE_SYSCALL, "SYSCALL DONE: (OP=CREATE) (THR=0x%8.8x) (ATTR=0x%8.8x) (STRT=0x%8.8x) (ARG=0x%8.8x)\n", (Huint)th, (Huint)attr, (Huint)start, (Huint)arg ); // The thread was created and added to the ready-to-run queue // successfully. Return the success code. return SUCCESS; }