ssize_t utf8_to_utf32(uint32_t *out, const uint8_t *in, size_t len) { ssize_t rc = 0; ssize_t units; uint32_t code; do { units = decode_utf8(&code, in); if(units == -1) return -1; if(code > 0) { in += units; if(out != NULL) { if(rc < len) *out++ = code; } if(SSIZE_MAX - 1 >= rc) ++rc; else return -1; } } while(code > 0); return rc; }
void TextEngine::renderText(float x, float y, float scaleX, float scaleY, bool baseline, const char* text) { ssize_t units; uint32_t code; // Configure buffers C3D_BufInfo* bufInfo = C3D_GetBufInfo(); BufInfo_Init(bufInfo); BufInfo_Add(bufInfo, textVtxArray, sizeof(textVertex_s), 2, 0x10); const uint8_t* p = (const uint8_t*)text; float firstX = x; u32 flags = GLYPH_POS_CALC_VTXCOORD | (baseline ? GLYPH_POS_AT_BASELINE : 0); int lastSheet = -1; do { if (!*p) break; units = decode_utf8(&code, p); if (units == -1) break; p += units; if (code == '\n') { x = firstX; y += scaleY*fontGetInfo()->lineFeed; } else if (code > 0) { int glyphIdx = fontGlyphIndexFromCodePoint(code); fontGlyphPos_s data; fontCalcGlyphPos(&data, glyphIdx, flags, scaleX, scaleY); // Bind the correct texture sheet if (data.sheetIndex != lastSheet) { lastSheet = data.sheetIndex; C3D_TexBind(0, &glyphSheets[lastSheet]); } int arrayIndex = textVtxArrayPos; if ((arrayIndex+4) >= TEXT_VTX_ARRAY_COUNT) break; // We can't render more characters // Add the vertices to the array addTextVertex(x+data.vtxcoord.left, y+data.vtxcoord.bottom, data.texcoord.left, data.texcoord.bottom); addTextVertex(x+data.vtxcoord.right, y+data.vtxcoord.bottom, data.texcoord.right, data.texcoord.bottom); addTextVertex(x+data.vtxcoord.left, y+data.vtxcoord.top, data.texcoord.left, data.texcoord.top); addTextVertex(x+data.vtxcoord.right, y+data.vtxcoord.top, data.texcoord.right, data.texcoord.top); // Draw the glyph C3D_DrawArrays(GPU_TRIANGLE_STRIP, arrayIndex, 4); x += data.xAdvance; } } while (code > 0); }
bool LoadMETA(Puzzle * puz, const std::string & data) { std::istringstream stream(data); istream_wrapper f(stream); while (! f.CheckEof()) puz->SetMeta(decode_utf8(f.ReadString()), decode_utf8(f.ReadString())); return true; }
string_t Parser::GetText(node n) { Visit(n); std::ostringstream stream; TextToStream(n, stream); return decode_utf8(stream.str()); }
String jsonnet_string_escape(const String &str, bool single) { StringStream ss; for (std::size_t i=0 ; i<str.length() ; ++i) { char32_t c = str[i]; switch (c) { case U'\"': ss << (single ? U"\"" : U"\\\""); break; case U'\'': ss << (single ? U"\\\'" : U"\'"); break; case U'\\': ss << U"\\\\"; break; case U'\b': ss << U"\\b"; break; case U'\f': ss << U"\\f"; break; case U'\n': ss << U"\\n"; break; case U'\r': ss << U"\\r"; break; case U'\t': ss << U"\\t"; break; case U'\0': ss << U"\\u0000"; break; default: { if (c < 0x20 || (c >= 0x7f && c <= 0x9f)) { //Unprintable, use \u std::stringstream ss8; ss8 << "\\u" << std::hex << std::setfill('0') << std::setw(4) << (unsigned long)(c); ss << decode_utf8(ss8.str()); } else { // Printable, write verbatim ss << c; } } } } return ss.str(); }
void desugarFile(AST *&ast) { desugar(ast, 0); // Now, implement the std library by wrapping in a local construct. Tokens tokens = jsonnet_lex("std.jsonnet", STD_CODE); AST *std_ast = jsonnet_parse(alloc, tokens); desugar(std_ast, 0); auto *std_obj = dynamic_cast<DesugaredObject*>(std_ast); if (std_obj == nullptr) { std::cerr << "INTERNAL ERROR: std.jsonnet not an object." << std::endl; std::abort(); } // Bind 'std' builtins that are implemented natively. DesugaredObject::Fields &fields = std_obj->fields; for (unsigned long c=0 ; c <= max_builtin ; ++c) { const auto &decl = jsonnet_builtin_decl(c); Identifiers params; for (const auto &p : decl.params) params.push_back(alloc->makeIdentifier(p)); fields.emplace_back( ObjectField::HIDDEN, str(decl.name), alloc->make<BuiltinFunction>(E, c, params)); } fields.emplace_back( ObjectField::HIDDEN, str(U"thisFile"), str(decode_utf8(ast->location.file))); ast = alloc->make<Local>(ast->location, EF, singleBind(id(U"std"), std_obj), ast); }
string_t Parser::GetInnerXML(node n) { Visit(n); std::ostringstream stream; for (node child = n.first_child(); child; child = child.next_sibling()) child.print(stream, "", pugi::format_raw); return decode_utf8(stream.str()); }
int MainCaitra::letter_string_edit_distance( Word wordId1, Word wordId2 ) { wstring word1; decode_utf8(surface[ wordId1 ], word1); wstring word2; decode_utf8(surface[ wordId2 ], word2); int **cost = (int**) calloc( sizeof( int* ), word1.size() ); for( int i=0; i<word1.size(); i++ ) { cost[i] = (int*) calloc( sizeof( int ), word2.size() ); for( int j=0; j<word2.size(); j++ ) { if (i==0 && j==0) { cost[i][j] = 0; } else { cost[i][j] = 999; if (j>0 && cost[i][j-1]+1 < cost[i][j]) { cost[i][j] = cost[i][j-1]+1; } if (i>0 && cost[i-1][j]+1 < cost[i][j]) { cost[i][j] = cost[i-1][j]+1; } if (i>0 && j>0) { if (word1[i] != word2[j]) { if (cost[i-1][j-1]+1 < cost[i][j]) { cost[i][j] = cost[i-1][j-1]+1; } } else { if (cost[i-1][j-1] < cost[i][j]) { cost[i][j] = cost[i-1][j-1]; } } } } } } int distance = cost[word1.size()-1][word2.size()-1]; for( int i=0; i<word1.size(); i++ ) { free( cost[i] ); } free( cost ); return distance; }
UTF8Iterator::UTF8Iterator(const std::string& text_) : text(text_), pos(0), chr() { try { chr = decode_utf8(text, pos); } catch (std::exception) { log_debug << "Malformed utf-8 sequence beginning with " << *((uint32_t*)(text.c_str() + pos)) << " found " << std::endl; chr = 0; } }
UTF8Iterator& UTF8Iterator::operator++() { try { chr = decode_utf8(text, pos); } catch (std::exception) { log_debug << "Malformed utf-8 sequence beginning with " << *((uint32_t*)(text.c_str() + pos)) << " found " << std::endl; chr = 0; ++pos; } return *this; }
static int get_utf8(const unsigned char *p, size_t len, ICONV_CHAR *out) { uint32_t uc, state = 0; size_t l = 1; do { switch (decode_utf8(&state, &uc, *p++)) { case 0: *out = uc; return l; case UTF8_REJECT: return -EILSEQ; } } while (l++ < len); return -EINVAL; }
void FontRenderer::DrawChar(FontFaceType type, Canvas canvas, Position pos, Colour colour, const char c) { FT_Face face = m_ftFaces[type]; u32 utf8Char = 0; ssize_t unitCount = decode_utf8(&utf8Char, (const uint8_t*)&c); if (unitCount <= 0) return; FT_UInt glyphIndex = FT_Get_Char_Index(face, utf8Char); if (R_FAILED(FT_Load_Glyph(face, glyphIndex, FT_LOAD_DEFAULT))) return; if (R_FAILED(FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL))) return; FT_GlyphSlot slot = face->glyph; u32 x = pos.x + slot->bitmap_left; u32 y = pos.y - slot->bitmap_top; FT_Bitmap* bitmap = &slot->bitmap; u8* imageptr = bitmap->buffer; if (bitmap->pixel_mode != FT_PIXEL_MODE_GRAY) return; for (u32 tmpy = 0; tmpy < bitmap->rows; tmpy++) { for (u32 tmpx = 0; tmpx < bitmap->width; tmpx++) { colour.a = imageptr[tmpx]; // Skip blanks if (!colour.a) continue; canvas.DrawPixelBlend(x + tmpx, y + tmpy, colour); } imageptr += bitmap->pitch; } }
// From CamelCase to snake_case string_t snake_case(const char * name) { // Read the char string into a std::string, replacing // capital letters with '_' plus the lower case letter // utf-8 issues shouldn't be a problem since isupper is only // true for < 128 std::string str; for (int i = 0; name[i]; ++i) { if (::isupper(name[i])) { if (i > 0) str.push_back('_'); str.push_back(::tolower(name[i])); } else str.push_back(name[i]); } return decode_utf8(str); }
static void string_reverse_implementation(sqlite3_context* ctx, int argc, sqlite3_value** argv) { const unsigned char* input = 0; int input_type; sqlite_uint64 input_length; char* result; int* decoded; if (argc < 1) { sqlite3_result_error(ctx, "not enough parameters", -1); return; } if (argc > 1) { sqlite3_result_error(ctx, "too many parameters", -1); return; } input_type = sqlite3_value_type(argv[0]); if (input_type != SQLITE_NULL) { input = sqlite3_value_text(argv[0]); } if (input == 0) { sqlite3_result_null(ctx); return; } input_length = strlen_utf8(input); result = sqlite3_malloc(4 * input_length + 1); decoded = sqlite3_malloc(sizeof(int) * input_length); decode_utf8(input, decoded); reverse_string(decoded, result, input_length); sqlite3_free(decoded); sqlite3_result_text(ctx, result, -1, result_string_destructor); }
/*! Initialize SDMC device */ Result sdmcInit(void) { ssize_t units; uint32_t code; char *p; FS_Path sdmcPath = { PATH_EMPTY, 1, (u8*)"" }; Result rc = 0; if(sdmcInitialised) return rc; rc = FSUSER_OpenArchive(&sdmcArchive, ARCHIVE_SDMC, sdmcPath); if(R_SUCCEEDED(rc)) { fsExemptFromSession(sdmcArchive); int dev = AddDevice(&sdmc_devoptab); if(dev != -1) { setDefaultDevice(dev); if(__system_argc != 0 && __system_argv[0] != NULL) { if(FindDevice(__system_argv[0]) == dev) { strncpy(__fixedpath,__system_argv[0],PATH_MAX); if(__fixedpath[PATH_MAX] != 0) { __fixedpath[PATH_MAX] = 0; } else { char *last_slash = NULL; p = __fixedpath; do { units = decode_utf8(&code, (const uint8_t*)p); if(units < 0) { last_slash = NULL; break; } if(code == '/') last_slash = p; p += units; } while(code != 0); if(last_slash != NULL) { last_slash[0] = 0; chdir(__fixedpath); } } } } } } sdmcInitialised = true; return rc; }
static const char* sdmc_fixpath(struct _reent *r, const char *path) { ssize_t units; uint32_t code; const uint8_t *p = (const uint8_t*)path; // Move the path pointer to the start of the actual path do { units = decode_utf8(&code, p); if(units < 0) { r->_errno = EILSEQ; return NULL; } p += units; } while(code != ':' && code != 0); // We found a colon; p points to the actual path if(code == ':') path = (const char*)p; // Make sure there are no more colons and that the // remainder of the filename is valid UTF-8 p = (const uint8_t*)path; do { units = decode_utf8(&code, p); if(units < 0) { r->_errno = EILSEQ; return NULL; } if(code == ':') { r->_errno = EINVAL; return NULL; } p += units; } while(code != 0); if(path[0] == '/') strncpy(__fixedpath, path, PATH_MAX); else { strncpy(__fixedpath, __cwd, PATH_MAX); __fixedpath[PATH_MAX] = '\0'; strncat(__fixedpath, path, PATH_MAX); } if(__fixedpath[PATH_MAX] != 0) { __fixedpath[PATH_MAX] = 0; r->_errno = ENAMETOOLONG; return NULL; } return __fixedpath; }
void GfxTextBuffer::addFormattedString (const std::string &text, const Vector3 &top_colour, float top_alpha, const Vector3 &bot_colour, float bot_alpha) { Vector3 ansi_colour[] = { Vector3(0,0,0), Vector3(.8,0,0), Vector3(0,.8,0), Vector3(.8,.8,0), Vector3(0,0,.93), Vector3(.8,0,.8), Vector3(0,.8,.8), Vector3(.75,.75,.75), }; Vector3 ansi_bold_colour[] = { Vector3(0.5,0.5,0.5), Vector3(1,0,0), Vector3(0,1,0), Vector3(1,1,0), Vector3(.36,.36,1), Vector3(1,0,1), Vector3(0,1,1), Vector3(1,1,1), }; ColouredChar c(0, top_colour, top_alpha, bot_colour, bot_alpha); unsigned long original_size = colouredText.size(); bool bold = false; unsigned default_colour = 7; // FIXME: this assumes a 'white on black' console unsigned last_colour = default_colour; for (size_t i=0 ; i<text.length() ; ++i) { GfxFont::codepoint_t cp = decode_utf8(text, i); if (cp == UNICODE_ESCAPE_CODEPOINT) { if (++i >= text.length()) break; cp = decode_utf8(text, i); if (cp == '[') { // continue until 'm' unsigned code = 0; do { if (++i >= text.length()) break; cp = decode_utf8(text, i); if (cp == 'm' || cp == ';') { // act on code if (code == 0) { bold = false; last_colour = default_colour; c.topColour = top_colour; c.bottomColour = bot_colour; } else if (code == 1) { bold = true; Vector3 col = bold ? ansi_bold_colour[last_colour] : ansi_colour[last_colour]; c.topColour = col; c.bottomColour = col; } else if (code == 22) { bold = false; Vector3 col = bold ? ansi_bold_colour[last_colour] : ansi_colour[last_colour]; c.topColour = col; c.bottomColour = col; } else if (code >= 30 && code <= 37) { last_colour = code - 30; Vector3 col = bold ? ansi_bold_colour[last_colour] : ansi_colour[last_colour]; c.topColour = col; c.bottomColour = col; } code = 0; } if (cp == 'm') break; if (cp >= '0' && cp <= '9') { unsigned digit = cp - '0'; code = 10*code + digit; } } while (true); if (cp == 'm') continue; } } // This char is not part of an ansi terminal colour code. c.cp = cp; colouredText.push_back(c); } recalculatePositions(original_size); }
void decode_cell(pTHX_ unsigned char *input, STRLEN len, STRLEN *pos, struct cc_type *type, SV *output) { unsigned char *bytes; STRLEN bytes_len; if (unpack_bytes(aTHX_ input, len, pos, &bytes, &bytes_len) != 0) { sv_setsv(output, &PL_sv_undef); return; } switch (type->type_id) { case CC_TYPE_ASCII: case CC_TYPE_CUSTOM: case CC_TYPE_BLOB: decode_blob(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_BOOLEAN: decode_boolean(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_VARCHAR: case CC_TYPE_TEXT: decode_utf8(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_INET: decode_inet(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_SET: case CC_TYPE_LIST: decode_list(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_UUID: case CC_TYPE_TIMEUUID: decode_uuid(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_FLOAT: decode_float(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_DOUBLE: decode_double(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_DECIMAL: decode_decimal(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_VARINT: case CC_TYPE_BIGINT: case CC_TYPE_COUNTER: case CC_TYPE_TIMESTAMP: case CC_TYPE_SMALLINT: case CC_TYPE_TINYINT: case CC_TYPE_INT: decode_varint(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_DATE: decode_date(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_TIME: decode_time(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_MAP: decode_map(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_UDT: decode_udt(aTHX_ bytes, bytes_len, type, output); break; case CC_TYPE_TUPLE: decode_tuple(aTHX_ bytes, bytes_len, type, output); break; default: sv_setsv(output, &PL_sv_undef); warn("Decoder doesn't yet understand type %d, returning undef instead", type->type_id); break; } }
inline string_t Parser::GetAttribute(const node n, const char * name) { return decode_utf8(n.attribute(name).value()); }
uint32_t UTF8::decode_utf8(const std::string& text) { size_t p = 0; return decode_utf8(text, p); }
OutputIterator utf8_wchar(InputIterator first, InputIterator last, OutputIterator dest) { for(; first!=last; ++dest) *dest = decode_utf8(first, last); return dest; }
/* * v_key_name -- * Return the string that will display the key. This routine * is the backup for the KEY_NAME() macro. * * PUBLIC: char *v_key_name __P((SCR *, ARG_CHAR_T)); */ char * v_key_name( SCR *sp, ARG_CHAR_T ach) { static const char hexdigit[] = "0123456789abcdef"; static const char octdigit[] = "01234567"; int ch; size_t len; char *chp; /* * Cache the last checked character. It won't be a problem * since nvi will rescan the mapping when settings changed. */ if (ach && sp->lastc == ach) return (sp->cname); sp->lastc = ach; #ifdef USE_WIDECHAR len = wctomb(sp->cname, ach); if (len > MB_CUR_MAX) #endif sp->cname[(len = 1)-1] = (u_char)ach; ch = (u_char)sp->cname[0]; sp->cname[len] = '\0'; /* See if the character was explicitly declared printable or not. */ if ((chp = O_STR(sp, O_PRINT)) != NULL) if (strstr(chp, sp->cname) != NULL) goto done; if ((chp = O_STR(sp, O_NOPRINT)) != NULL) if (strstr(chp, sp->cname) != NULL) goto nopr; /* * Historical (ARPA standard) mappings. Printable characters are left * alone. Control characters less than 0x20 are represented as '^' * followed by the character offset from the '@' character in the ASCII * character set. Del (0x7f) is represented as '^' followed by '?'. * * XXX * The following code depends on the current locale being identical to * the ASCII map from 0x40 to 0x5f (since 0x1f + 0x40 == 0x5f). I'm * told that this is a reasonable assumption... * * XXX * The code prints non-printable wide characters in 4 or 5 digits * Unicode escape sequences, so only supports plane 0 to 15. */ if (ISPRINT(ach)) goto done; nopr: if (iscntrl(ch) && (ch < 0x20 || ch == 0x7f)) { sp->cname[0] = '^'; sp->cname[1] = ch == 0x7f ? '?' : '@' + ch; len = 2; goto done; } #ifdef USE_WIDECHAR if (INTISWIDE(ach)) { int uc = -1; if (!strcmp(codeset(), "UTF-8")) uc = decode_utf8(sp->cname); #ifdef USE_ICONV else { char buf[sizeof(sp->cname)] = ""; size_t left = sizeof(sp->cname); char *in = sp->cname; char *out = buf; iconv(sp->conv.id[IC_IE_TO_UTF16], (iconv_src_t)&in, &len, &out, &left); iconv(sp->conv.id[IC_IE_TO_UTF16], NULL, NULL, NULL, NULL); uc = decode_utf16(buf, 1); } #endif if (uc >= 0) { len = snprintf(sp->cname, sizeof(sp->cname), uc < 0x10000 ? "\\u%04x" : "\\U%05X", uc); goto done; } } #endif if (O_ISSET(sp, O_OCTAL)) { sp->cname[0] = '\\'; sp->cname[1] = octdigit[(ch & 0300) >> 6]; sp->cname[2] = octdigit[(ch & 070) >> 3]; sp->cname[3] = octdigit[ ch & 07 ]; } else {