void var_buffer_addUTF16( access_t *p_access, var_buffer_t *p_buf, const char *p_str )
{
uint16_t *p_out;
size_t i_out;
if( p_str != NULL )
#ifdef WORDS_BIGENDIAN
p_out = ToCharset( "UTF-16BE", p_str, &i_out );
#else
p_out = ToCharset( "UTF-16LE", p_str, &i_out );
#endif
else
void LngSetAdd(const char *id, int lang, const char *txt, bool addid)
{
CriticalSection::Lock __(slng);
CharS ids;
ids.s = PermanentCopy(id);
String text = ToCharset(CHARSET_UTF8, txt, GetLNGCharset(lang));
lang = SetLNGCharset(lang, CHARSET_UTF8);
Array<LngModule>& ma = sMod();
for(int i = 0; i < ma.GetCount(); i++) {
LngModule& m = ma[i];
int q = m.map.Find(ids);
if(q >= 0) {
char *t = PermanentCopy(text);
Vector<LngRec>& r = m.map[q];
for(int i = 0; i < r.GetCount(); i++)
if(r[i].lang == lang) {
r[i].text = t;
return;
}
LngRec& rec = r.Add();
rec.lang = lang;
rec.text = t;
return;
}
}
if(addid) {
if(ma.GetCount() == 0)
ma.Add();
LngRec& r = ma.Top().map.Add(ids).Add();
char *t = PermanentCopy(text);
strcpy(t, text);
r.lang = lang;
r.text = t;
}
}
/**
* converts a string from UTF-8 to the system locale character encoding,
* the result is always allocated on the heap.
*
* @param utf8 nul-terminated string to convert
*
* @return a nul-terminated string, or null in case of error.
* The result must be freed using free() - as with the strdup() function.
*/
char *ToLocaleDup (const char *utf8)
{
#ifdef ASSUME_UTF8
return strdup (utf8);
#else
size_t outsize;
return ToCharset ("", utf8, &outsize);
#endif
}
/**
* ToLocale: converts an UTF-8 string to local system encoding.
*
* @param utf8 nul-terminated string to be converted
*
* @return a nul-terminated string, or NULL in case of error.
* To avoid memory leak, you have to pass the result to LocaleFree()
* when it is no longer needed.
*/
char *ToLocale (const char *utf8)
{
#ifdef ASSUME_UTF8
return (char *)utf8;
#else
size_t outsize;
return utf8 ? ToCharset ("", utf8, &outsize) : NULL;
#endif
}
bool SaveStreamBOMUtf8(Stream& out, const String& data) {
if(!out.IsOpen() || out.IsError())
return false;
static unsigned char bom[] = {0xEF, 0xBB, 0xBF};
out.Put(bom, 3);
out.Put(ToCharset(CHARSET_UTF8, data));
out.Close();
return out.IsOK();
}
NAMESPACE_UPP
static void sLoadBom(Stream& in, String *t, WString *wt, byte def_charset)
{
if(in.IsOpen()) {
String s;
if(in.GetLeft() > 3) {
word header = in.Get16le();
if(header == 0xfffe || header == 0xfeff) {
int n = (int)in.GetLeft() / 2;
WStringBuffer ws(n);
ws.SetLength(in.Get(~ws, 2 * n) / 2);
if(header == 0xfffe)
EndianSwap((word *)~ws, ws.GetCount());
if(wt)
*wt = ws;
else
*t = FromUnicode(ws);
return;
}
int c = in.Get();
if(c < 0)
return;
byte *h = (byte *)&header;
if(h[0] == 0xef && h[1] == 0xbb && c == 0xbf) {
if(wt)
*wt = FromUtf8(LoadStream(in));
else
*t = ToCharset(CHARSET_DEFAULT, LoadStream(in), CHARSET_UTF8);
return;
}
s.Cat(h, 2);
s.Cat(c);
}
s.Cat(LoadStream(in));
if(wt)
*wt = ToUnicode(s, def_charset);
else
*t = ToCharset(CHARSET_DEFAULT, s, def_charset);
return;
}
return;
}
// write to stream
bool DXFBlockRef::Write(Stream &s)
{
// call base class write
if(!DXFEntity::Write(s))
return false;
// output line points
s << "100\nAcDbBlockReference\n";
s << "2\n" << ToCharset(CHARSET_WIN1252, name) << "\n";
s << "10\n" << insertPoint.x << "\n20\n" << insertPoint.y << "\n30\n" << 0.0 << "\n";
s << "41\n" << scale << "\n42\n" << scale << "\n43\n" << scale << "\n";
s << "50\n" << angle * 180.0 / M_PI << "\n";
return true;
}
String GetLngString_(int lang, const char *id)
{
if(!lang)
lang = current_lang;
const LngRec *r = sFindLngRec(id, lang);
if(r) {
int dch = GetLNGCharset(lang);
if(dch == CHARSET_UTF8)
return r->text;
else
return ToCharset(dch, r->text, CHARSET_UTF8);
}
return GetENUSc(id);
}
static dword sGetLanguageDetails(int language, String *english_name, String *native_name)
{
int q = 0;
byte cs = GetLNGCharset(language);
language &= ~LNGC_(0, 0, 0, 0, ~0);
for(const int *ptr = LanguageList; *ptr; ptr++, q++)
if(*ptr == language) {
const char *f = LanguageInfoList[q];
const char *a = strchr(f, '\t');
const char *b = strchr(a + 1, '\t');
if(english_name)
*english_name = String(f, a);
if(native_name)
*native_name = ToCharset(cs, String(a + 1, b), CHARSET_UTF8);
return MAKEWORD(b[2], b[1]);
}
return 0;
}
const char *t_GetLngString_(const char *id)
{
VectorMap<const char *, const char *>& map = sCurrentLangMap();
int q = map.Find(id);
if(q >= 0)
return map[q];
const LngRec *r = sFindLngRec(id, current_lang);
if(r) {
int dch = GetLNGCharset(current_lang);
if(dch == CHARSET_UTF8) {
map.Add(id, r->text);
return r->text;
}
String text = ToCharset(dch, r->text, CHARSET_UTF8);
char *q = Single<ZoneAlloc>().Alloc(text.GetLength() + 1);
strcpy(q, ~text);
map.Add(id, q);
return q;
}
const char *txt = GetENUSc(id);
map.Add(id, txt);
return txt;
}
/**
* Probe the X server.
*/
static int Open(vout_display_t *vd, const vout_display_cfg_t *cfg,
video_format_t *fmtp, vlc_video_context *ctx)
{
vlc_object_t *obj = VLC_OBJECT(vd);
vout_display_sys_t *sys = vlc_obj_malloc(obj, sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
vd->sys = sys;
/* Connect to X */
xcb_connection_t *conn;
const xcb_screen_t *screen;
if (vlc_xcb_parent_Create(vd, cfg, &conn, &screen) == NULL)
return VLC_EGENERIC;
sys->conn = conn;
sys->root = screen->root;
sys->format.argb = 0;
sys->format.alpha = 0;
if (!CheckRender(vd, conn))
goto error;
xcb_render_query_pict_formats_cookie_t pic_fmt_ck =
xcb_render_query_pict_formats(conn);
xcb_render_query_pict_formats_reply_t *pic_fmt_r =
xcb_render_query_pict_formats_reply(conn, pic_fmt_ck, NULL);
if (pic_fmt_r == NULL)
goto error;
const xcb_setup_t *setup = xcb_get_setup(conn);
const xcb_render_pictforminfo_t *const pic_fmts =
xcb_render_query_pict_formats_formats(pic_fmt_r);
xcb_visualid_t visual = 0;
for (unsigned i = 0; i < pic_fmt_r->num_formats; i++) {
const xcb_render_pictforminfo_t *const pic_fmt = pic_fmts + i;
const xcb_render_directformat_t *const d = &pic_fmt->direct;
if (pic_fmt->depth == 8 && pic_fmt->direct.alpha_mask == 0xff) {
/* Alpha mask format */
sys->format.alpha = pic_fmt->id;
continue;
}
xcb_visualid_t vid = FindVisual(setup, screen, pic_fmt_r, pic_fmt->id);
if (vid == 0)
continue;
/* Use only ARGB for now. 32-bits is guaranteed to work. */
if (pic_fmt->depth != 32)
continue;
vlc_fourcc_t chroma = ParseFormat(setup, pic_fmt);
if (chroma == 0)
continue;
fmtp->i_chroma = chroma;
fmtp->i_rmask = ((uint32_t)d->red_mask) << d->red_shift;
fmtp->i_gmask = ((uint32_t)d->green_mask) << d->green_shift;
fmtp->i_bmask = ((uint32_t)d->blue_mask) << d->blue_shift;
sys->format.argb = pic_fmt->id;
visual = vid;
}
free(pic_fmt_r);
if (unlikely(sys->format.argb == 0 || sys->format.alpha == 0))
goto error; /* Buggy server */
msg_Dbg(obj, "using RENDER picture format %u", sys->format.argb);
msg_Dbg(obj, "using X11 visual 0x%"PRIx32, visual);
char *filter = var_InheritString(obj, "x11-render-filter");
if (filter != NULL) {
msg_Dbg(obj, "using filter \"%s\"", filter);
sys->filter = ToCharset("ISO 8859-1", filter, &(size_t){ 0 });
free(filter);
} else
sys->filter = NULL;
sys->drawable.source = xcb_generate_id(conn);
sys->drawable.crop = xcb_generate_id(conn);
sys->drawable.scale = xcb_generate_id(conn);
sys->drawable.subpic = xcb_generate_id(conn);
sys->drawable.alpha = xcb_generate_id(conn);
sys->drawable.dest = xcb_generate_id(conn);
sys->picture.source = xcb_generate_id(conn);
sys->picture.crop = xcb_generate_id(conn);
sys->picture.scale = xcb_generate_id(conn);
sys->picture.subpic = xcb_generate_id(conn);
sys->picture.alpha = xcb_generate_id(conn);
sys->picture.dest = xcb_generate_id(conn);
sys->gc = xcb_generate_id(conn);
if (XCB_shm_Check(obj, conn))
sys->segment = xcb_generate_id(conn);
else
sys->segment = 0;
xcb_colormap_t cmap = xcb_generate_id(conn);
uint32_t cw_mask =
XCB_CW_BACK_PIXEL |
XCB_CW_BORDER_PIXEL |
XCB_CW_EVENT_MASK |
XCB_CW_COLORMAP;
const uint32_t cw_list[] = {
/* XCB_CW_BACK_PIXEL */
screen->black_pixel,
/* XCB_CW_BORDER_PIXEL */
screen->black_pixel,
/* XCB_CW_EVENT_MASK */
0,
/* XCB_CW_COLORMAP */
cmap,
};
xcb_create_colormap(conn, XCB_COLORMAP_ALLOC_NONE, cmap, screen->root,
visual);
xcb_create_pixmap(conn, 32, sys->drawable.source, screen->root,
vd->source.i_width, vd->source.i_height);
xcb_create_gc(conn, sys->gc, sys->drawable.source, 0, NULL);
xcb_create_window(conn, 32, sys->drawable.dest, cfg->window->handle.xid,
0, 0, cfg->display.width, cfg->display.height, 0,
XCB_WINDOW_CLASS_INPUT_OUTPUT, visual, cw_mask, cw_list);
xcb_render_create_picture(conn, sys->picture.source, sys->drawable.source,
sys->format.argb, 0, NULL);
xcb_render_create_picture(conn, sys->picture.dest, sys->drawable.dest,
sys->format.argb, 0, NULL);
CreateBuffers(vd, cfg);
xcb_map_window(conn, sys->drawable.dest);
sys->spu_chromas[0] = fmtp->i_chroma;
sys->spu_chromas[1] = 0;
vd->info.subpicture_chromas = sys->spu_chromas;
vd->prepare = Prepare;
vd->display = Display;
vd->control = Control;
(void) ctx;
return VLC_SUCCESS;
error:
xcb_disconnect(conn);
return VLC_EGENERIC;
}
bool Sqlite3Connection::Execute() {
Cancel();
if(statement.GetLength() == 0) {
session.SetError("Empty statement", String("Preparing: ") + statement);
return false;
}
String utf8_stmt = ToCharset(CHARSET_UTF8, statement, CHARSET_DEFAULT);
if (SQLITE_OK != sqlite3_prepare(db,utf8_stmt,utf8_stmt.GetLength(),¤t_stmt,NULL)) {
LLOG("Sqlite3Connection::Compile(" << statement << ") -> error");
session.SetError(sqlite3_errmsg(db), String("Preparing: ") + statement);
return false;
}
current_stmt_string = statement;
int nparams = ParseForArgs(current_stmt_string);
ASSERT(nparams == param.GetCount());
for (int i = 0; i < nparams; ++i)
BindParam(i+1,param[i]);
param.Clear();
// Make sure that compiling the statement never fails.
ASSERT(NULL != current_stmt);
int retcode;
dword ticks_start = GetTickCount();
int sleep_ms = 1;
do{
retcode = sqlite3_step(current_stmt);
if(retcode!=SQLITE_BUSY && retcode!=SQLITE_LOCKED) break;
if(session.busy_timeout == 0) break;
if(session.busy_timeout>0){
if((int)(GetTickCount()-ticks_start)>session.busy_timeout){
break;
}
}//else infinite retry
if(retcode==SQLITE_LOCKED) sqlite3_reset(current_stmt);
Sleep(sleep_ms);
if(sleep_ms<128) sleep_ms += sleep_ms;
}while(1);
if ((retcode != SQLITE_DONE) && (retcode != SQLITE_ROW)) {
session.SetError(sqlite3_errmsg(db), current_stmt_string);
return false;
}
got_first_row = got_row_data = (retcode==SQLITE_ROW);
// if (got_row_data) { // By WebChaot, 2009-01-15
int numfields = sqlite3_column_count(current_stmt);
info.SetCount(numfields);
for (int i = 0; i < numfields; ++i) {
SqlColumnInfo& field = info[i];
field.name = sqlite3_column_name(current_stmt,i);
field.binary = false;
String coltype = sqlite3_column_decltype(current_stmt,i);
switch (sqlite3_column_type(current_stmt,i)) {
case SQLITE_INTEGER:
field.type = INT_V;
break;
case SQLITE_FLOAT:
field.type = DOUBLE_V;
break;
case SQLITE_TEXT:
if(coltype == "date")
field.type = DATE_V;
else
if(coltype == "datetime")
field.type = TIME_V;
else
field.type = WSTRING_V;
break;
case SQLITE_NULL:
if(coltype == "date")
field.type = DATE_V;
else
if(coltype == "datetime")
field.type = TIME_V;
else
if(coltype.Find("char") >= 0 || coltype.Find("text") >= 0 )
field.type = WSTRING_V;
else
if(coltype.Find("integer") >= 0)
field.type = INT_V;
else
if(coltype.Find("real") >= 0)
field.type = DOUBLE_V;
else
field.type = VOID_V;
break;
case SQLITE_BLOB:
field.type = STRING_V;
field.binary = true;
break;
default:
NEVER();
break;
}
}
// }
return true;
}
