STATUS FunctionList_AddLocalFunction(FunctionList fl, const char *func_name, const unsigned int address) { FunctionList f ; FunctionList tmp = fl; if(IS_NULL(func_name) || (strlen(func_name) == 0)) { LOG_ERROR("local function name is NULL"); return STATUS_FAILURE; } while(tmp->next != NULL) { if(!IS_NULL(tmp->func_name) && strcasecmp(tmp->func_name, func_name) == 0) { LOG_ERROR("function name '%s' already exists", func_name); return STATUS_FAILURE; } tmp = tmp->next; } f = FunctionList_Create(); if(!IS_NULL(f)) { f->func_name = (char*)Malloc(strlen(func_name)+1); strcpy(f->func_name, func_name); f->type = FUNCTION_TYPE_LOCAL; f->u.address = address; tmp->next = f; return STATUS_SUCCESS; } LOG_ERROR("FunctionList_Create() failed"); return STATUS_FAILURE; }
/** * init_link_slot_tab - 初始化LINK槽表 * * @nr_links: 总的连接数 * * return * 0 成功 * !0 失败 */ static int init_link_slot_tab(IN unsigned short nr_links) { int i; size_t size; struct link_slot_tab *obj = lnktable_object(); struct link_slot *slot; struct link_buff *buff; memset(obj, 0, sizeof(struct link_slot_tab)); obj->nr_links = nr_links; size = nr_links * sizeof(struct link_slot); obj->slot = zmalloc(size); if(IS_NULL(obj->slot)) return gen_errno(0, GCENOMEM); else slot = obj->slot; size = nr_links * 2 * sizeof(struct link_buff); obj->buff = zmalloc(size); if(IS_NULL(obj->buff)) return gen_errno(0, GCENOMEM); else buff = obj->buff; for(i = 0; i < nr_links*2; i++) init_link_buff(buff++); for(i = 0; i < nr_links; i++) init_link_slot(slot++); return 0; }
static METHOD knh__String_substring(Ctx *ctx, knh_sfp_t *sfp) { knh_bytes_t base = knh_String_tobytes(sfp[0].s); knh_bytes_t sub; if(knh_String_isASCII(sfp[0].s)) { size_t offset = IS_NULL(sfp[1].o) ? 0 : knh_array_index(ctx, sfp[1].ivalue, base.len); sub = knh_bytes_last(base, offset); if(IS_NOTNULL(sfp[2].o)) { size_t len = (size_t)sfp[2].ivalue; if(len < sub.len) sub = knh_bytes_first(sub, len); } } else { // multibytes size_t mlen = knh_bytes_mlen(base); size_t offset = IS_NULL(sfp[1].o) ? 0 : knh_array_index(ctx, sfp[1].ivalue, mlen); size_t length = IS_NULL(sfp[2].o) ? (mlen - offset) : (size_t)sfp[2].ivalue; sub = knh_bytes_mofflen(base, offset, length); } String *s; if(sub.len == 0) { s = TS_EMPTY; } else if(sub.len == base.len) { s = sfp[0].s; } else { s = new_String(ctx, sub, sfp[0].s); } KNH_RETURN(ctx, sfp, s); }
static BOOL _str_perform_match(CSTR pattern, CSTR string, BOOL caseSensitive) { CHAR ch; if (IS_NULL(pattern) || IS_NULL(string)) return FALSE; for (;;) { switch (ch = *pattern++) { case '\0': return (*string == c_NULL); case '?': if (*string == c_NULL) return FALSE; ++string; break; case '*': { CSTR str; while (*pattern == '?') { /* Skip a character for each '?'. */ if (*string == c_NULL) return FALSE; ++string; ++pattern; } if (*pattern == c_NULL) /* a trailing '*' matches everything else */ return TRUE; str = string; while (*str != c_NULL) { if ( (caseSensitive ? *str == *pattern : str_char_tolower(*str) == str_char_tolower(*pattern)) && _str_perform_match(pattern, str, caseSensitive) ) return TRUE; ++str; } break; } default: if (caseSensitive ? *string++ != ch : str_char_tolower(*string++) != str_char_tolower(ch)) return FALSE; break; } } }
int IFSEXPORT FS_OPENCREATE( struct cdfsi far * pcdfsi, struct cdfsd far * pcdfsd, char far * pszName, unsigned short iCurDirEnd, struct sffsi far * psffsi, struct sffsd far * psffsd, unsigned long flOpenMode, unsigned short fsOpenFlag, unsigned short far * pusAction, unsigned short fsAttr, PEAOP pEABuf, unsigned short far * pfsGenFlag ) { int rc; struct opencreate far * p = &pRequest->data.opencreate; if (rc = requestExchangeXS()) return rc; pRequest->rq = FSRQ_OPENCREATE; COPYPTR(&p->pVolData, queryVPFSD(pcdfsi->cdi_hVPB)); p->cdfsi = *pcdfsi; p->cdfsd = *pcdfsd; if (strlen(pszName) >= CCHMAXPATH) RELEASE_AND_EXIT(ERROR_INVALID_PARAMETER); strcpy(p->szName, pszName); p->iCurDirEnd = iCurDirEnd; p->sffsi = *psffsi; p->flOpenMode = flOpenMode; p->fsOpenFlag = fsOpenFlag; p->fsAttr = fsAttr; if (!IS_NULL(pEABuf)) { rc = copyEAOP(pEABuf, CEA_FEAS_TO_BUF, 0); if (rc) RELEASE_AND_EXIT(rc); p->fHasEAs = 1; } else p->fHasEAs = 0; if (rc = signalDaemonAndWait()) RELEASE_AND_EXIT(rc); *psffsi = p->sffsi; if (psffsi->sfi_type == STYPE_FILE) COPYPTR(psffsd, &p->pOpenFileData); *pusAction = p->usAction; *pfsGenFlag = p->fsGenFlag; if (!IS_NULL(pEABuf)) { rc = copyEAOP(pEABuf, CEA_SET_OERROR, p->oError); if (rc) RELEASE_AND_EXIT(rc); } RELEASE_AND_EXIT(pRequest->rc); }
STATUS FunctionList_AddNativeFunction(FunctionList fl, const char *func_name, NativeFunction func) { FunctionList f ; FunctionList tmp = fl; if(IS_NULL(func_name) || (strlen(func_name) == 0)) { LOG_ERROR("native function name is NULL"); return STATUS_FAILURE; } while(tmp->next != NULL) { if(!IS_NULL(tmp->func_name) && strcasecmp(tmp->func_name, func_name) == 0) { LOG_ERROR("function name '%s' already exists", func_name); return STATUS_FAILURE; } tmp = tmp->next; } f = FunctionList_Create(); if(!IS_NULL(f)) { f->func_name = (char*)Malloc(strlen(func_name)+1); strcpy(f->func_name, func_name); f->type = FUNCTION_TYPE_NATIVE; f->u.nFunc = func; tmp->next = f; return STATUS_SUCCESS; } LOG_ERROR("FunctionList_Create() failed"); return STATUS_FAILURE; }
int putGV(JNIEnv* env, jint gmask, jint baseIndex, jobject gvdata, const LayoutEngine* engine, int glyphCount) { int count = env->GetIntField(gvdata, gvdCountFID); jarray glyphArray = (jarray)env->GetObjectField(gvdata, gvdGlyphsFID); if (IS_NULL(glyphArray)) { JNU_ThrowInternalError(env, "glypharray null"); return 0; } jint capacity = env->GetArrayLength(glyphArray); if (count + glyphCount > capacity) { JNU_ThrowArrayIndexOutOfBoundsException(env, ""); return 0; } jarray posArray = (jarray)env->GetObjectField(gvdata, gvdPositionsFID); if (IS_NULL(glyphArray)) { JNU_ThrowInternalError(env, "positions array null"); return 0; } jarray inxArray = (jarray)env->GetObjectField(gvdata, gvdIndicesFID); if (IS_NULL(inxArray)) { JNU_ThrowInternalError(env, "indices array null"); return 0; } int countDelta = 0; // le_uint32 is the same size as jint... forever, we hope le_uint32* glyphs = (le_uint32*)env->GetPrimitiveArrayCritical(glyphArray, NULL); if (glyphs) { jfloat* positions = (jfloat*)env->GetPrimitiveArrayCritical(posArray, NULL); if (positions) { jint* indices = (jint*)env->GetPrimitiveArrayCritical(inxArray, NULL); if (indices) { LEErrorCode status = (LEErrorCode)0; engine->getGlyphs(glyphs + count, gmask, status); engine->getGlyphPositions(positions + (count * 2), status); engine->getCharIndices((le_int32*)(indices + count), baseIndex, status); countDelta = glyphCount; // !!! need engine->getFlags to signal positions, indices data /* "0" arg used instead of JNI_COMMIT as we want the carray * to be freed by any VM that actually passes us a copy. */ env->ReleasePrimitiveArrayCritical(inxArray, indices, 0); } env->ReleasePrimitiveArrayCritical(posArray, positions, 0); } env->ReleasePrimitiveArrayCritical(glyphArray, glyphs, 0); } if (countDelta) { count += countDelta; env->SetIntField(gvdata, gvdCountFID, count); } return 1; }
int memq(SCM key, SCM list) { SCM l = list; while (!IS_NULL(l)) { if (!(IS_PAIR(l) || IS_NULL(l))) wta_error ("memq", 2); if EQ(key, CAR(l)) return 1; l = CDR(l); } return 0; }
void _do_insert(List *L, ListNode *node) { node->next = L->head; if (!IS_NULL(L->head)) L->head->prev = node; L->head = node; node->prev = NULL; ++L->length; if (IS_NULL(L->head->next)) L->tail = node; }
void *_do_delete(List *L, ListNode *del_node) { void *val = del_node->value; if (!IS_NULL(del_node->prev)) del_node->prev->next = del_node->next; else L->head = del_node->next; if (!IS_NULL(del_node->next)) del_node->next->prev = del_node->prev; free(del_node); return val; }
BOOL str_creationinfo_set(CreationInfo *info, CSTR creator, CSTR reason, time_t time_set) { if (IS_NULL(info) || IS_NULL(creator) || IS_NULL(reason)) return FALSE; str_creator_set(&(info->creator), creator, time_set); if (IS_NOT_NULL(info->reason)) mem_free(info->reason); info->reason = str_duplicate(reason); return TRUE; }
void test_module_load(CTX) { module_load(_ctx, (kcontext_t*)_ctx, BUILD_DIR "mod_sample.dylib", "ksample"); ksampleshare_t *sharemod = (ksampleshare_t*) _ctx->modshare[MOD_SAMPLE]; assert(sharemod); sharemod->h.setup(_ctx, (kmodshare_t*)sharemod); ksamplemod_t *mod = (ksamplemod_t*) _ctx->mod[MOD_SAMPLE]; assert(mod); assert(IS_NULL(mod->array) == 0); MODGC_gc_invoke(_ctx, 0); assert(IS_NULL(mod->array) == 0); }
/** * @brief * try to readdir a directory opened by another user. should fail. * @return 1 if successful, 0 otherwise */ error_t readdirTest8(){ user_id uid1 = 1, uid2 = 2; NANDFS_DIR* ds; uint8_t *dir = "/"; SET_CURRENT_USER(uid1); ds = opendir(dir); VERIFY(!IS_NULL(ds)); SET_CURRENT_USER(uid2); VERIFY(IS_NULL(readdir(ds))); return 1; }
static RIOTC_RTN do_service_release_process(RIOTC_MASTER_CTX * ctx) { if (IS_NULL(ctx)) return RIOTC_RTN_FAIL_IS_NULL; if (!IS_NULL(ctx->evhr)) riotc_event_handler_release(ctx->evhr); if (!IS_NULL(ctx->scm)) riotc_master_scm_release(ctx->scm); free(ctx); return RIOTC_RTN_SUCCESS; }
int check_nargs(char *fname, SCM args, int min, int max) { if (!(IS_PAIR(args) || IS_NULL(args))) error0("wrong arguments"); int i; for (i = 0; IS_PAIR(args); i++) args = CDR(args); if (!IS_NULL(args)) error0("wrong arguments"); if (!((min <= i) && (i <= max))) wna_error(fname, i); return i; }
int GameEnd(int amPlayers) { int iwinner; int iPairs = 0; for (int i = 0; i < amPlayers; i++) if (pairs[i] > iPairs) { iwinner = i; iPairs = pairs[iwinner]; } int i = 0; while (!IS_NULL(objects[i++])); i--; char c[100]; char *c2 = (char *)malloc(sizeof(char)); sprintf(c2, "%d", iPairs); concat("The Winner with ", c2); if (iPairs == 1) concat(c, " pair is Player "); else concat(c, " pairs is Player "); sprintf(c2, "%d", iwinner); concat(c, c2); objects[i] = O_New_Label(objects[i], c, 300, 300); i++; objects[i] = O_New_Button(objects[i], "Continue", BContinue, 300, 400); }
/** * init_linkno_pool - 初始化LINKNO池 * * @nr_links: 总的LINKNO数 * * return * 0 成功 * !0 失败 */ static int init_linkno_pool(IN unsigned short nr_links) { int i; size_t size; struct linkno_s_pool *obj = lnk_pool_object(); struct linkno_s *ptr; memset(obj, 0, sizeof(struct linkno_s_pool)); obj->cur_using = 0; INIT_LIST_HEAD(&(obj->free_head)); pthread_mutex_init(&(obj->lock), NULL); obj->nr_links = nr_links; memset(obj->bitmap, 0, sizeof(obj->bitmap)); size = nr_links * sizeof(struct linkno_s); obj->base = zmalloc(size); if(IS_NULL(obj->base)) return gen_errno(0, GCENOMEM); ptr = obj->base; for(i = 0; i < nr_links; i++, ptr++) list_add_tail(&(ptr->list), &(obj->free_head)); return 0; }
void DataTableColumnType::createDefaultCell() { std::string value; IS_NULL(m_defaultCell); // If mangleValue does not update the input value string, // then the default cell will have a value of 0 for floats and ints // and a value of empty string for strings. IGNORE_RETURN(mangleValue(value)); switch(m_basicType) { case DT_Int: m_defaultCell = new DataTableCell(static_cast<int>(strtol(value.c_str(), NULL, 0))); break; case DT_Float: m_defaultCell = new DataTableCell(static_cast<float>(atof(value.c_str()))); break; case DT_String: case DT_Comment: case DT_Unknown: default: m_defaultCell = new DataTableCell(value.c_str()); break; } }
/* Read from STDIN and base32 encode the data as A records */ void sdt_loop_A(SDT_STATE *ss) { ssize_t n = 0; char *buf = NULL; int flags = 0; flags = fcntl(ss->fd_in, F_GETFL, 0); flags |= O_NONBLOCK; (void)fcntl(ss->fd_in, F_SETFL, flags); IS_NULL(buf = calloc(ss->bufsz, 1)); while ( (n = sdt_read(ss, buf, ss->bufsz)) > 0) { VERBOSE(3, "Sending A record: %d of %u bytes\n", (int32_t)n, (u_int32_t)ss->bufsz); sdt_send_A(ss, buf, n); ss->sum_up += n; if (woken != 0) break; VERBOSE(3, "A record: res timeout = %d, sleep = %f seconds\n", ss->backoff, (float)(ss->sleep * ss->backoff)/1000000); usleep(ss->sleep); } free(buf); VERBOSE (1, "*** Exiting from A record read loop\n"); }
/** * @brief * try to read from an illegal dirstream. should fail * @return 1 if successful, 0 otherwise */ error_t readdirTest7(){ NANDFS_DIR* ds = NULL; VERIFY(IS_NULL(readdir(ds))); return 1; }
STR str_compact(STR string) { char *ptr = string, *s, *t; if (IS_NULL(string)) return string; for (; *ptr; ptr++) { if (*ptr == '*') { if (*(t = s = ptr + 1) == '*') { while (*t == '*') t++; } else if (*t == '?') { for (t++, s++; *t == '*' || *t == '?'; t++) { if (*t == '?') *s++ = *t; } } while ((*s++ = *t++)); } } return string; }
// Transfer execution to [fiber] coming from the current fiber whose stack has // [args]. // // [isCall] is true if [fiber] is being called and not transferred. // // [hasValue] is true if a value in [args] is being passed to the new fiber. // Otherwise, `null` is implicitly being passed. static bool runFiber(WrenVM* vm, ObjFiber* fiber, Value* args, bool isCall, bool hasValue, const char* verb) { if (isCall) { if (fiber->caller != NULL) RETURN_ERROR("Fiber has already been called."); // Remember who ran it. fiber->caller = vm->fiber; } if (fiber->numFrames == 0) { RETURN_ERROR_FMT("Cannot $ a finished fiber.", verb); } if (!IS_NULL(fiber->error)) { RETURN_ERROR_FMT("Cannot $ an aborted fiber.", verb); } // When the calling fiber resumes, we'll store the result of the call in its // stack. If the call has two arguments (the fiber and the value), we only // need one slot for the result, so discard the other slot now. if (hasValue) vm->fiber->stackTop--; // If the fiber was paused, make yield() or transfer() return the result. if (fiber->stackTop > fiber->stack) { fiber->stackTop[-1] = hasValue ? args[1] : NULL_VAL; } vm->fiber = fiber; return false; }
void sds_sock_loop(SDS_STATE *ss) { SDS_PKT *pkt = NULL; IS_NULL(pkt = calloc(1, sizeof(SDS_PKT))); (void)sds_sock_init(ss); for ( ; ; ) { (void)memset(pkt, 0, sizeof(SDS_PKT)); if (docleanup == 1) { ss->cleanup(ss); docleanup = 0; } (void)alarm(ss->maxtimeout*2); if (sds_sock_recv(ss, pkt) < 0) continue; if (ss->handler(ss, pkt) < 0) continue; (void)sds_sock_send(ss, pkt); /* XXX need to re-send if failed */ } }
void *list_delete(List *L, const void *value) { ListNode *del_node = list_search(L, value); if (!IS_NULL(del_node)) return _do_delete(L, del_node); return NULL; }
void list_retraversal(List *L, void (*visit_func)(void *)) { ListNode *p = L->tail; while (!IS_NULL(p)) { visit_func(p->value); p = p->prev; } }
void list_traversal(List *L, void (*visit_func)(void *)) { ListNode *p = L->head; while (!IS_NULL(p)) { visit_func(p->value); p = p->next; } }
int str_compare(CSTR string1, CSTR string2) { register const unsigned char *str1 = (const unsigned char *) string1; register const unsigned char *str2 = (const unsigned char *) string2; register unsigned char ch1, ch2; if (IS_NULL(str1) || IS_NULL(str2)) return (int)(str1 - str2); do { ch1 = (unsigned char) *str1++; ch2 = (unsigned char) *str2++; } while ((ch1 != c_NULL) && (ch1 == ch2)); return ch1 - ch2; }
static METHOD knh__String_opSubsete(Ctx *ctx, knh_sfp_t *sfp) { if(IS_NOTNULL(sfp[2].o)) { size_t offset = IS_NULL(sfp[1].o) ? 0 : (size_t)sfp[1].ivalue; sfp[2].ivalue = sfp[2].ivalue - offset + 1; } knh__String_substring(ctx, sfp); }
//## Node Node.AppendParsedNode(Token[] tokenList, int beginIdx, int endIdx, String requiredTokenText); static KMETHOD Node_AppendParsedNode(KonohaContext *kctx, KonohaStack *sfp) { kNode *node = sfp[0].asNode; kArray *tokenList = sfp[1].asArray; int beginIdx = sfp[2].intValue; int endIdx = sfp[3].intValue; const char *requiredTokenText = IS_NULL(sfp[4].asString) ? NULL : kString_text(sfp[4].asString); KReturn(SUGAR AppendParsedNode(kctx, node, tokenList, beginIdx, endIdx, NULL, ParseExpressionOption, requiredTokenText)); }
extern int onig_set_default_syntax(OnigSyntaxType* syntax) { if (IS_NULL(syntax)) syntax = ONIG_SYNTAX_RUBY; OnigDefaultSyntax = syntax; return 0; }