LILV_API LilvState* lilv_state_new_from_string(LilvWorld* world, const LV2_URID_Map* map, const char* str) { if (!str) { return NULL; } SerdNode base = SERD_NODE_NULL; SerdEnv* env = serd_env_new(&base); SordModel* model = sord_new(world->world, SORD_SPO|SORD_OPS, false); SerdReader* reader = sord_new_reader(model, env, SERD_TURTLE, NULL); set_prefixes(env); serd_reader_read_string(reader, USTR(str)); SordNode* o = sord_new_uri(world->world, USTR(LV2_PRESETS__Preset)); SordNode* s = sord_get(model, NULL, world->uris.rdf_a, o, NULL); LilvState* state = new_state_from_model(world, map, model, s, NULL); sord_node_free(world->world, s); sord_node_free(world->world, o); serd_reader_free(reader); sord_free(model); serd_env_free(env); return state; }
static uchar *hlc_resolve_symbol( void *addr, uchar *out, int *outSize ) { #ifdef _WIN32 static HANDLE stack_process_handle = NULL; DWORD64 index; IMAGEHLP_LINEW64 line; struct { SYMBOL_INFOW sym; uchar buffer[256]; } data; data.sym.SizeOfStruct = sizeof(data.sym); data.sym.MaxNameLen = 255; if( !stack_process_handle ) { stack_process_handle = GetCurrentProcess(); SymSetOptions(SYMOPT_LOAD_LINES); SymInitialize(stack_process_handle,NULL,TRUE); } if( SymFromAddrW(stack_process_handle,(DWORD64)(int_val)addr,&index,&data.sym) ) { DWORD offset = 0; line.SizeOfStruct = sizeof(line); line.FileName = USTR("\\?"); line.LineNumber = 0; SymGetLineFromAddrW64(stack_process_handle, (DWORD64)(int_val)addr, &offset, &line); *outSize = usprintf(out,*outSize,USTR("%s(%s:%d)"),data.sym.Name,wcsrchr(line.FileName,'\\')+1,(int)line.LineNumber); return out; } #endif return NULL; }
OSL_SHADEOP int osl_regex_impl (void *sg_, const char *subject_, void *results, int nresults, const char *pattern, int fullmatch) { ShaderGlobals *sg = (ShaderGlobals *)sg_; ShadingContext *ctx = sg->context; const std::string &subject (ustring::from_unique(subject_).string()); match_results<std::string::const_iterator> mresults; const regex ®ex (ctx->find_regex (USTR(pattern))); if (nresults > 0) { std::string::const_iterator start = subject.begin(); int res = fullmatch ? regex_match (subject, mresults, regex) : regex_search (subject, mresults, regex); int *m = (int *)results; for (int r = 0; r < nresults; ++r) { if (r/2 < (int)mresults.size()) { if ((r & 1) == 0) m[r] = mresults[r/2].first - start; else m[r] = mresults[r/2].second - start; } else { m[r] = USTR(pattern).length(); } } return res; } else { return fullmatch ? regex_match (subject, regex) : regex_search (subject, regex); } }
HL_PRIM wref *HL_NAME(ui_winlog_new)( const uchar *title, int width, int height ) { HWND wnd, text; RECT rc; RECT dtop; DWORD style = WS_SYSMENU | WS_OVERLAPPED | WS_CAPTION; DWORD exstyle = 0; wref *ref; // SIZE rc.left = 0; rc.right = width; rc.top = 0; rc.bottom = height; AdjustWindowRectEx(&rc, style, FALSE, exstyle); GetWindowRect(GetDesktopWindow(),&dtop); // WINDOW wnd = CreateWindowEx( exstyle, CLASS_NAME, title, style, (dtop.right - rc.right) / 2, (dtop.bottom - rc.bottom) / 2, rc.right - rc.left, rc.bottom - rc.top, GetActiveWindow(), NULL, GetModuleHandle(NULL), NULL ); // FONT if( font == NULL ) { LOGFONT f; f.lfHeight = -8; f.lfWidth = 0; f.lfEscapement = 0; f.lfOrientation = 0; f.lfWeight = FW_NORMAL; f.lfItalic = FALSE; f.lfUnderline = FALSE; f.lfStrikeOut = FALSE; f.lfCharSet = DEFAULT_CHARSET; f.lfOutPrecision = OUT_DEFAULT_PRECIS; f.lfClipPrecision = 0; f.lfQuality = DEFAULT_QUALITY; f.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE; wcscpy(f.lfFaceName,USTR("MS Sans Serif")); font = CreateFontIndirect(&f); } // TEXT text = CreateWindowEx(WS_EX_CLIENTEDGE,USTR("RICHEDIT20A"),USTR(""),ES_MULTILINE | ES_DISABLENOSCROLL | ES_READONLY | WS_VSCROLL | WS_VISIBLE | WS_CHILD,5,5,width - 10,height - 50,wnd,NULL,NULL,NULL); SendMessage(text,WM_SETFONT,(WPARAM)font,TRUE); SetProp(wnd,PTEXT,text); SetTimer(wnd,0,1000,NULL); // prevent lock in ui_loop ShowWindow(wnd,SW_SHOW); ref = alloc_ref(wnd); ref->width = width; ref->height = height; return ref; }
HL_PRIM wref *HL_NAME(ui_button_new)( wref *w, const uchar *txt, vclosure *callb ) { HWND but = CreateWindowEx(0,USTR("BUTTON"),USTR(""),WS_VISIBLE | WS_CHILD,w->width - 80,w->height - 30,75,25,w->h,NULL,NULL,NULL); wref *ref = alloc_ref(but); w->width -= 80; ref->callb = callb; SendMessage(but,WM_SETFONT,(WPARAM)font,TRUE); SetWindowText(but,txt); return ref; }
status_t DrmKernel_NvDrmPlugin_onSaveRights(int uniqueId, const struct NV_DrmRights_st *drmRights, const char *rightsPath, const char *contentId) { ALOGV("DrmKernel_NvDrmPlugin_onSaveRights - Entry"); ALOGV("uniqueId = %d", uniqueId); ALOGV("rightsPath = '%s'", rightsPath); ALOGV("contentId = '%s'", contentId); status_t retVal = NV_DRM_ERROR_UNKNOWN; SecureRecord record; uint8_t *dataptr = (uint8_t *)drmRights->data->data; record._key = contentId; dataptr += strlen(contentId) +1; ALOGV("DrmKernel_NvDrmPlugin_onSaveRights - index = %d", (dataptr - (uint8_t *)drmRights->data->data)); record._keyId = dataptr; dataptr += AES_BLOCK_SIZE; ALOGV("DrmKernel_NvDrmPlugin_onSaveRights - index = %d", (dataptr - (uint8_t *)drmRights->data->data)); record._contentKeySize = *dataptr << 8; dataptr++; ALOGV("DrmKernel_NvDrmPlugin_onSaveRights - index = %d", (dataptr - (uint8_t *)drmRights->data->data)); record._contentKeySize += *dataptr; dataptr++; ALOGV("DrmKernel_NvDrmPlugin_onSaveRights - index = %d", (dataptr - (uint8_t *)drmRights->data->data)); ALOGV("DrmKernel_NvDrmPlugin_onSaveRights - key size = %d", record._contentKeySize); record._contentKey = USTR(dataptr); dataptr += record._contentKeySize; ALOGV("DrmKernel_NvDrmPlugin_onSaveRights - index = %d", (dataptr - (uint8_t *)drmRights->data->data)); record._tag = USTR(dataptr); record._tagSize = (unsigned int)drmRights->data->length - (dataptr - (uint8_t *)drmRights->data->data); ALOGV("DrmKernel_NvDrmPlugin_onSaveRights - index = %d", (dataptr - (uint8_t *)drmRights->data->data)); ALOGV("DrmKernel_NvDrmPlugin_onSaveRights - tag size = %d", record._tagSize); ALOGV("record.key = %s", record._key); ALOGV("record.contentKeySize = %d", record._contentKeySize); ALOGV("record.tagSize = %d", record._tagSize); if (insertRecord(&mDatabaseConnection, &record)) { retVal = NV_NO_ERROR; ALOGV("DrmKernel_NvDrmPlugin_onSaveRights() - Rights saved"); } else ALOGE("DrmKernel_NvDrmPlugin_onSaveRights() - Unable to save rights"); ALOGV("DrmKernel_NvDrmPlugin_onSaveRights - Exit (%d)", retVal); return retVal; }
/** request : 'db -> sql:string -> 'result <doc>Executes the SQL request and returns its result</doc> **/ HL_PRIM sqlite_result *HL_NAME(request)(sqlite_database *db, vbyte *sql ) { sqlite_result *r; const char *tl; int i,j; r = (sqlite_result*)hl_gc_alloc_finalizer(sizeof(sqlite_result)); r->finalize = HL_NAME(finalize_result); r->db = db; if( sqlite3_prepare16_v2(db->db, sql, -1, &r->r, &tl) != SQLITE_OK ) { HL_NAME(error)(db->db, false); } if( *tl ) { sqlite3_finalize(r->r); hl_error("SQLite error: Cannot execute several SQL requests at the same time"); } r->ncols = sqlite3_column_count(r->r); r->names = (int*)hl_gc_alloc(sizeof(int)*r->ncols); r->bools = (int*)hl_gc_alloc(sizeof(int)*r->ncols); r->first = 1; r->done = 0; for(i=0;i<r->ncols;i++) { int id = hl_hash_gen((uchar*)sqlite3_column_name16(r->r,i), true); const char *dtype = sqlite3_column_decltype(r->r,i); for(j=0;j<i;j++) if( r->names[j] == id ) { if( strcmp(sqlite3_column_name16(r->r,i), sqlite3_column_name16(r->r,j)) == 0 ) { sqlite3_finalize(r->r); hl_buffer *b = hl_alloc_buffer(); hl_buffer_str(b, USTR("SQLite error: Same field is two times in the request: ")); hl_buffer_str(b, (uchar*)sql); hl_error_msg(hl_buffer_content(b, NULL)); } else { hl_buffer *b = hl_alloc_buffer(); hl_buffer_str(b, USTR("SQLite error: Same field ids for: ")); hl_buffer_str(b, sqlite3_column_name16(r->r,i)); hl_buffer_str(b, USTR(" and ")); hl_buffer_str(b, sqlite3_column_name16(r->r,j)); sqlite3_finalize(r->r); hl_error_msg(hl_buffer_content(b, NULL)); } } r->names[i] = id; r->bools[i] = dtype?(strcmp(dtype,"BOOL") == 0):0; } // changes in an update/delete if( db->last != NULL ) HL_NAME(finalize_request)(db->last, false); db->last = r; return db->last; }
LILV_API int lilv_state_save(LilvWorld* world, LV2_URID_Map* map, LV2_URID_Unmap* unmap, const LilvState* state, const char* uri, const char* dir, const char* filename) { if (!filename || !dir || lilv_mkdir_p(dir)) { return 1; } char* abs_dir = absolute_dir(dir); char* const path = lilv_path_join(abs_dir, filename); FILE* fd = fopen(path, "w"); if (!fd) { LILV_ERRORF("Failed to open %s (%s)\n", path, strerror(errno)); free(abs_dir); free(path); return 4; } // FIXME: make parameter non-const? if (state->dir && strcmp(state->dir, abs_dir)) { free(state->dir); ((LilvState*)state)->dir = lilv_strdup(abs_dir); } // Create symlinks to files if necessary lilv_state_make_links(state, abs_dir); // Write state to Turtle file SerdNode file = serd_node_new_file_uri(USTR(path), NULL, NULL, false); SerdEnv* env = NULL; SerdWriter* writer = ttl_file_writer(fd, &file, &env); SerdNode node = uri ? serd_node_from_string(SERD_URI, USTR(uri)) : file; int ret = lilv_state_write( world, map, unmap, state, writer, (const char*)node.buf, dir); serd_node_free(&file); serd_writer_free(writer); serd_env_free(env); fclose(fd); char* const manifest = lilv_path_join(abs_dir, "manifest.ttl"); add_state_to_manifest(state->plugin_uri, manifest, uri, path); free(manifest); free(abs_dir); free(path); return ret; }
OSL_SHADEOP int osl_split (const char *str, ustring *results, const char *sep, int maxsplit, int resultslen) { maxsplit = OIIO::clamp (maxsplit, 0, resultslen); std::vector<std::string> splits; Strutil::split (USTR(str).string(), splits, USTR(sep).string(), maxsplit); int n = std::min (maxsplit, (int)splits.size()); for (int i = 0; i < n; ++i) results[i] = ustring(splits[i]); return n; }
OSL_SHADEOP int osl_endswith_iss (const char *s_, const char *substr_) { ustring substr (USTR(substr_)); size_t substr_len = substr.length(); if (substr_len == 0) // empty substr always matches return 1; ustring s (USTR(s_)); size_t s_len = s.length(); if (substr_len > s_len) // longer needle than haystack can't return 0; // match (including empty s) return strncmp (s.c_str()+s_len-substr_len, substr.c_str(), substr_len) == 0; }
HL_PRIM ereg *regexp_regexp_new_options( vbyte *str, vbyte *opts ) { ereg *r; const char *error; int err_offset; int errorcode; pcre16 *p; uchar *o = (uchar*)opts; int options = 0; while( *o ) { switch( *o++ ) { case 'i': options |= PCRE_CASELESS; break; case 's': options |= PCRE_DOTALL; break; case 'm': options |= PCRE_MULTILINE; break; case 'u': options |= PCRE_UTF8; break; case 'g': options |= PCRE_UNGREEDY; break; default: return NULL; } } p = pcre16_compile2((PCRE_SPTR16)str,options,&errorcode,&error,&err_offset,NULL); if( p == NULL ) { hl_buffer *b = hl_alloc_buffer(); hl_buffer_str(b,USTR("Regexp compilation error : ")); hl_buffer_cstr(b,error); hl_buffer_str(b,USTR(" in ")); hl_buffer_str(b,(uchar*)str); hl_error_msg(USTR("%s"),hl_buffer_content(b,NULL)); } r = (ereg*)hl_gc_alloc_finalizer(sizeof(ereg)); r->finalize = regexp_finalize; r->p = p; r->nmatches = 0; r->matched = 0; pcre16_fullinfo(p,NULL,PCRE_INFO_CAPTURECOUNT,&r->nmatches); r->nmatches++; r->matches = (int*)malloc(sizeof(int) * 3 * r->nmatches); limit.flags = PCRE_EXTRA_MATCH_LIMIT_RECURSION; limit.match_limit_recursion = 3500; // adapted based on Windows 1MB stack size return r; }
HL_PRIM vbyte *hl_sys_string() { #if defined(HL_WIN) || defined(HL_CYGWIN) || defined(HL_MINGW) return (vbyte*)USTR("Windows"); #elif defined(HL_GNUKBSD) return (vbyte*)USTR("GNU/kFreeBSD"); #elif defined(HL_LINUX) return (vbyte*)USTR("Linux"); #elif defined(HL_BSD) return (vbyte*)USTR("BSD"); #elif defined(HL_MAC) return (vbyte*)USTR("Mac"); #else #error Unknow system string #endif }
OSL_SHADEOP void osl_spline_dffdf(void *out, const char *spline_, void *x, float *knots, int knot_count, int knot_arraylen) { const Spline::SplineBasis *spline = Spline::getSplineBasis(USTR(spline_)); Spline::spline_evaluate<Dual2<float>, float, Dual2<float>, float, true> (spline, DFLOAT(out), *(float *)x, knots, knot_count, knot_arraylen); }
OSL_SHADEOP void osl_spline_dvdfdv(void *out, const char *spline_, void *x, Vec3 *knots, int knot_count) { const Spline::SplineBasis *spline = Spline::getSplineBasis(USTR(spline_)); Spline::spline_evaluate<Dual2<Vec3>, Dual2<float>, Dual2<Vec3>, Vec3, true> (spline, DVEC(out), DFLOAT(x), knots, knot_count); }
OSL_SHADEOP void osl_spline_dvdfv(void *out, const char *spline_, void *x, Vec3 *knots, int knot_count) { const Spline::SplineBasis *spline = Spline::getSplineBasis(USTR(spline_)); Spline::spline_evaluate<Vec3, float, Vec3, Vec3, false> (spline, *(Vec3 *)out, *(float *)x, knots, knot_count); }
OSL_SHADEOP void osl_spline_dfdff(void *out, const char *spline_, void *x, float *knots, int knot_count) { const Spline::SplineBasis *spline = Spline::getSplineBasis(USTR(spline_)); Spline::spline_evaluate<Dual2<float>, Dual2<float>, float, float, false> (spline, DFLOAT(out), DFLOAT(x), knots, knot_count); }
LILV_API char* lilv_state_to_string(LilvWorld* world, LV2_URID_Map* map, LV2_URID_Unmap* unmap, const LilvState* state, const char* uri, const char* base_uri) { if (!uri) { LILV_ERROR("Attempt to serialise state with no URI\n"); return NULL; } SerdChunk chunk = { NULL, 0 }; SerdEnv* env = NULL; SerdNode base = serd_node_from_string(SERD_URI, USTR(base_uri)); SerdWriter* writer = ttl_writer(serd_chunk_sink, &chunk, &base, &env); lilv_state_write(world, map, unmap, state, writer, uri, NULL); serd_writer_free(writer); serd_env_free(env); return (char*)serd_chunk_sink_finish(&chunk); }
OSL_SHADEOP void osl_texture_set_interp (void *opt, const char *modename) { int mode = tex_interp_to_code (USTR(modename)); if (mode >= 0) ((TextureOpt *)opt)->interpmode = (TextureOpt::InterpMode)mode; }
OSL_SHADEOP void osl_spline_fff(void *out, const char *spline_, void *x, float *knots, int knot_count, int knot_arraylen) { const Spline::SplineBasis *spline = Spline::getSplineBasis(USTR(spline_)); Spline::spline_evaluate<float, float, float, float, false> (spline, *(float *)out, *(float *)x, knots, knot_count, knot_arraylen); }
OSL_SHADEOP void osl_spline_dvfdv(void *out, const char *spline_, void *x, Vec3 *knots, int knot_count, int knot_arraylen) { const Spline::SplineBasis *spline = Spline::getSplineBasis(USTR(spline_)); Spline::spline_evaluate<Dual2<Vec3>, float, Dual2<Vec3>, Vec3, true> (spline, DVEC(out), *(float *)x, knots, knot_count, knot_arraylen); }
OSL_SHADEOP void osl_splineinverse_fff(void *out, const char *spline_, void *x, float *knots, int knot_count, int knot_arraylen) { // Version with no derivs const Spline::SplineBasis *spline = Spline::getSplineBasis(USTR(spline_)); Spline::spline_inverse<float> (spline, *(float *)out, *(float *)x, knots, knot_count, knot_arraylen); }
OSL_SHADEOP void osl_prepend_color_from (void *sg, void *c_, const char *from) { ShadingContext *ctx (((ShaderGlobals *)sg)->context); Color3 &c (*(Color3*)c_); c = ctx->shadingsys().to_rgb (USTR(from), c[0], c[1], c[2]); }
OSL_SHADEOP void osl_texture_set_stwrap (void *opt, const char *x) { TextureOpt::Wrap code = TextureOpt::decode_wrapmode(USTR(x)); ((TextureOpt *)opt)->swrap = code; ((TextureOpt *)opt)->twrap = code; }
int wmain(int argc, uchar *argv[]) { #else int main(int argc, char *argv[]) { #endif hl_trap_ctx ctx; vdynamic *exc; hl_global_init(&ctx); hl_setup_exception(hlc_resolve_symbol,hlc_capture_stack); hl_setup_callbacks(hlc_static_call, hlc_get_wrapper); hl_sys_init((void**)(argv + 1),argc - 1); hl_trap(ctx, exc, on_exception); # ifdef HL_VCC __try { # endif hl_entry_point(); # ifdef HL_VCC } __except( throw_handler(GetExceptionCode()) ) {} # endif hl_global_free(); return 0; on_exception: { varray *a = hl_exception_stack(); int i; uprintf(USTR("Uncaught exception: %s\n"), hl_to_string(exc)); for(i=0;i<a->size;i++) uprintf(USTR("Called from %s\n"), hl_aptr(a,uchar*)[i]); hl_debug_break(); } hl_global_free(); return 1; }
Aurora::KEYDataFile *ResourceTree::getKEYDataFile(const QString &file) { auto keyDataFileIter = _keyDataFiles.find(file); if (keyDataFileIter != _keyDataFiles.end()) return keyDataFileIter->second.get(); Common::UString path = Common::FilePath::normalize(USTR(_root->childAt(0)->getPath() + "/" + file)); if (path.empty()) throw Common::Exception("No such file or directory \"%s\"", (_root->getPath() + "/" + file).toStdString().c_str()); Aurora::FileType type = TypeMan.getFileType(file.toStdString().c_str()); Aurora::KEYDataFile *dataFile = nullptr; switch (type) { case Aurora::kFileTypeBIF: dataFile = new Aurora::BIFFile(new Common::ReadFile(path)); break; case Aurora::kFileTypeBZF: dataFile = new Aurora::BZFFile(new Common::ReadFile(path)); break; default: throw Common::Exception("Unknown KEY data file type %d\n", type); } _keyDataFiles.insert(std::make_pair(file, std::unique_ptr<Aurora::KEYDataFile>(dataFile))); return dataFile; }
BOOL Initialize(PVOID BaseAddress) { LdrDisableThreadCalloutsForDll(BaseAddress); ml::MlInitialize(); BaseAddress = FindLdrModuleByName(&USTR(L"js.dll"))->DllBase; MEMORY_PATCH p[] = { PATCH_MEMORY(0x00, 4, 0x73779), PATCH_MEMORY(0xEB, 1, 0x6D382), // ping PATCH_MEMORY(0xEB, 1, 0x6D56D), PATCH_MEMORY(0xEB, 1, 0x6D477), PATCH_MEMORY(1, 4, 0x6FA73), // timer }; MEMORY_FUNCTION_PATCH f[] = { INLINE_HOOK_CALL_RVA_NULL(0x72A17, SaveNodeIndex), INLINE_HOOK_CALL_RVA(0x730C3, InitNodeName, StubAppendString), INLINE_HOOK_CALL_RVA(0x72F0C, InitNodeName, StubAppendString), INLINE_HOOK_JUMP(sendto, xy_sendto, stubsendto), INLINE_HOOK_JUMP(recvfrom, xy_recvfrom, stubrecvfrom), }; Nt_PatchMemory(p, countof(p), f, countof(f), BaseAddress); return TRUE; }
OSL_SHADEOP void osl_splineinverse_dfdff(void *out, const char *spline_, void *x, float *knots, int knot_count, int knot_arraylen) { // x has derivs, so return derivs as well const Spline::SplineBasis *spline = Spline::getSplineBasis(USTR(spline_)); Spline::spline_inverse<Dual2<float> > (spline, DFLOAT(out), DFLOAT(x), knots, knot_count, knot_arraylen); }
/** result_next : 'result -> object? <doc>Returns the next row in the result or [null] if no more result.</doc> **/ HL_PRIM varray *HL_NAME(result_next)( sqlite_result *r ) { if( r->done ) return NULL; switch( sqlite3_step(r->r) ) { case SQLITE_ROW: r->first = 0; varray *a = hl_alloc_array(&hlt_dyn, r->ncols); int i; for(i=0;i<r->ncols;i++) { vdynamic *v; switch( sqlite3_column_type(r->r,i) ) { case SQLITE_NULL: v = NULL; break; case SQLITE_INTEGER: { int vint = sqlite3_column_int(r->r, i); if (r->bools[i]) v = hl_make_dyn(&vint, &hlt_bool); else v = hl_make_dyn(&vint, &hlt_i32); break; } case SQLITE_FLOAT: { double d = sqlite3_column_double(r->r, i); v = hl_make_dyn(&d, &hlt_f64); break; } case SQLITE_TEXT: { uchar *text16 = (uchar *)sqlite3_column_text16(r->r, i); v = hl_make_dyn(&text16, &hlt_bytes); break; } case SQLITE_BLOB: { vbyte *blob = (vbyte *)sqlite3_column_blob(r->r, i); v = hl_make_dyn(&blob, &hlt_bytes); break; } default: hl_error_msg(USTR("SQLite error: Unknown type #%d"), sqlite3_column_type(r->r,i)); } hl_aptr(a, vdynamic*)[i] = v; } return a; case SQLITE_DONE: HL_NAME(finalize_request)(r, true); return NULL; case SQLITE_BUSY: hl_error("SQLite error: Database is busy"); case SQLITE_ERROR: HL_NAME(error)(r->db->db, false); default: return NULL; } return NULL; }
int main(int argc, char *argv[]) { struct Ustr *s1 = USTR(""); static const char txt[] = "123456789 "; size_t beg = 0; size_t end = 6; size_t count = 0; if (argc == 3) { beg = atoi(argv[1]); end = atoi(argv[2]); } while (count < beg) { ustr_add_rep_chr(&s1, txt[count++ % 10], 1); } while (count < end) { ustr_add_rep_chr(&s1, txt[count++ % 10], 1); printf("String: %lu \"%s\"\n", CLU(ustr_len(s1)), ustr_cstr(s1)); tst_ustr(ustr_cstr(s1), 0, 0, USTR_TRUE); tst_ustr(ustr_cstr(s1), 1, 0, USTR_FALSE); tst_ustr(ustr_cstr(s1), 2, 1, USTR_TRUE); tst_ustr(ustr_cstr(s1), 3, 1, USTR_FALSE); tst_ustr(ustr_cstr(s1), 4, 2, USTR_TRUE); tst_ustr(ustr_cstr(s1), 5, 2, USTR_FALSE); tst_ustr(ustr_cstr(s1), 6, 4, USTR_TRUE); tst_ustr(ustr_cstr(s1), 7, 4, USTR_FALSE); if (USTR_CONF_HAVE_68bit_SIZE_MAX) { tst_ustr(ustr_cstr(s1), 8, 8, USTR_TRUE); tst_ustr(ustr_cstr(s1), 9, 8, USTR_FALSE); } printf("\t strdup() = (%8lu / %-8lu = %5.2f%% )\n", CLU(ustr_len(s1) + 1), CLU(ustr_len(s1)), 100. * ((1 + ustr_len(s1)) / ustr_len(s1))); printf("\t NM_Ustr = (%8lu / %-8lu = %5.2f%% )\n", CLU(sizeof(struct NM_Ustr) + ustr_len(s1) + 1), CLU(sizeof(struct NM_Ustr) + ustr_len(s1)), (100. * (sizeof(struct NM_Ustr) + ustr_len(s1) + 1)) / ustr_len(s1)); printf("\t NM_Ustr x2 = (%8lu / %-8lu = %5.2f%% )\n", CLU(sizeof(struct NM_Ustr) + min_pow(ustr_len(s1) + 1)), CLU(sizeof(struct NM_Ustr) + ustr_len(s1)), (100. * (sizeof(struct NM_Ustr) + min_pow(ustr_len(s1) + 1))) / ustr_len(s1)); printf("\t NM_Ustr xUstr = (%8lu / %-8lu = %5.2f%% )\n", CLU(sizeof(struct NM_Ustr) + min_size(ustr_len(s1) + 1)), CLU(sizeof(struct NM_Ustr) + ustr_len(s1)), (100. * (sizeof(struct NM_Ustr) + min_size(ustr_len(s1) + 1))) / ustr_len(s1)); } ustr_sc_free(&s1); return 0; }
static void HL_NAME(error)( sqlite3 *db, bool close ) { hl_buffer *b = hl_alloc_buffer(); hl_buffer_str(b, USTR("SQLite error: ")); hl_buffer_str(b, sqlite3_errmsg16(db)); if ( close ) sqlite3_close(db); hl_error_msg(hl_buffer_content(b, NULL)); }