DEF_TEST(BBoxHierarchy, reporter) {
// RTree
{
SkRTree* rtree = SkRTree::Create(RTREE_MIN_CHILDREN, RTREE_MAX_CHILDREN);
SkAutoUnref au(rtree);
tree_test_main(rtree, RTREE_MIN_CHILDREN, RTREE_MAX_CHILDREN, reporter);
// Rtree that orders input rectangles on deferred insert.
SkRTree* unsortedRtree = SkRTree::Create(RTREE_MIN_CHILDREN, RTREE_MAX_CHILDREN, 1, false);
SkAutoUnref auo(unsortedRtree);
tree_test_main(unsortedRtree, RTREE_MIN_CHILDREN, RTREE_MAX_CHILDREN, reporter);
}
// QuadTree
{
SkQuadTree* quadtree = SkQuadTree::Create(
SkIRect::MakeLTRB(-MAX_SIZE, -MAX_SIZE, MAX_SIZE, MAX_SIZE));
SkAutoUnref au(quadtree);
tree_test_main(quadtree, QUADTREE_MIN_CHILDREN, QUADTREE_MAX_CHILDREN, reporter);
// QuadTree that orders input rectangles on deferred insert.
SkQuadTree* unsortedQuadTree = SkQuadTree::Create(
SkIRect::MakeLTRB(-MAX_SIZE, -MAX_SIZE, MAX_SIZE, MAX_SIZE));
SkAutoUnref auo(unsortedQuadTree);
tree_test_main(unsortedQuadTree, QUADTREE_MIN_CHILDREN, QUADTREE_MAX_CHILDREN, reporter);
}
}
struct zvolume *archive_directory_lha (struct zfile *zf)
{
struct zvolume *zv;
struct zarchive_info zai;
LzHeader hdr;
int i;
_tzset();
zv = zvolume_alloc (zf, ArchiveFormatLHA, NULL, NULL);
while (get_header(zf, &hdr)) {
struct znode *zn;
int method;
for (i = 0; methods[i]; i++) {
if (!strcmp (methods[i], hdr.method))
method = i;
}
memset (&zai, 0, sizeof zai);
zai.name = au (hdr.name);
zai.size = hdr.original_size;
zai.flags = hdr.attribute;
if (hdr.extend_type != 0) {
zai.tv.tv_sec = hdr.unix_last_modified_stamp -= _timezone;
} else {
struct tm t;
uae_u32 v = hdr.last_modified_stamp;
t.tm_sec = (v & 0x1f) * 2;
t.tm_min = (v >> 5) & 0x3f;
t.tm_hour = (v >> 11) & 0x1f;
t.tm_mday = (v >> 16) & 0x1f;
t.tm_mon = ((v >> 21) & 0xf) - 1;
t.tm_year = ((v >> 25) & 0x7f) + 80;
zai.tv.tv_sec = mktime (&t) - _timezone;
}
if (hdr.name[strlen(hdr.name) + 1] != 0)
zai.comment = au (&hdr.name[strlen(hdr.name) + 1]);
if (method == LZHDIRS_METHOD_NUM) {
zvolume_adddir_abs (zv, &zai);
} else {
zn = zvolume_addfile_abs (zv, &zai);
zn->offset = zfile_ftell(zf);
zn->packedsize = hdr.packed_size;
zn->method = method;
}
xfree (zai.name);
xfree (zai.comment);
zfile_fseek (zf, hdr.packed_size, SEEK_CUR);
}
return zv;
}
int fsdb_used_as_nname (a_inode *base, const TCHAR *nname)
{
FILE *f;
uae_u8 buf[1 + 4 + 257 + 257 + 81];
f = get_fsdb (base, _T("r+b"));
if (f == 0) {
// if (currprefs.filesys_custom_uaefsdb && (base->volflags & MYVOLUMEINFO_STREAMS))
// return custom_fsdb_used_as_nname (base, nname);
return 0;
}
for (;;) {
TCHAR *s;
if (fread (buf, 1, sizeof buf, f) < sizeof buf)
break;
if (buf[0] == 0)
continue;
s = au ((char*)buf + 5 + 257);
if (_tcscmp (s, nname) == 0) {
xfree (s);
fclose (f);
return 1;
}
xfree (s);
}
fclose (f);
return 0;
}
FILE *moduleripper_fopen (const char *aname, const char *amode)
{
TCHAR tmp2[MAX_DPATH];
TCHAR tmp[MAX_DPATH];
TCHAR *name, *mode;
FILE *f;
fetch_ripperpath (tmp, sizeof tmp);
name = au (aname);
mode = au (amode);
_stprintf (tmp2, _T("%s%s"), tmp, name);
f = uae_tfopen (tmp2, mode);
xfree (mode);
xfree (name);
return f;
}
int32_t uaenet_open (struct uaenetdata *sd, struct netdriverdata *tc, struct s2devstruct *user,
uaenet_gotfunc *gotfunc, uaenet_getfunc *getfunc, int32_t promiscuous)
{
char *s;
s = ua (tc->name);
sd->fp = pcap_open_live (s, 65536, promiscuous, 100, sd->errbuf);
xfree (s);
if (sd->fp == NULL) {
TCHAR *ss = au (sd->errbuf);
write_log ("'%s' failed to open: %s\n", tc->name, ss);
xfree (ss);
return 0;
}
sd->tc = tc;
sd->user = user;
sd->mtu = tc->mtu;
sd->readbuffer = xmalloc (uint8_t, sd->mtu);
sd->writebuffer = xmalloc (uint8_t, sd->mtu);
sd->gotfunc = gotfunc;
sd->getfunc = getfunc;
uae_sem_init (&sd->change_sem, 0, 1);
uae_sem_init (&sd->sync_semr, 0, 0);
uae_start_thread ("uaenet_r", uaenet_trap_threadr, sd, &sd->tidr);
uae_sem_wait (&sd->sync_semr);
uae_sem_init (&sd->sync_semw, 0, 0);
uae_start_thread ("uaenet_w", uaenet_trap_threadw, sd, &sd->tidw);
uae_sem_wait (&sd->sync_semw);
write_log ("uaenet initialized\n");
return 1;
}
Z3_ast_vector Z3_API Z3_algebraic_roots(Z3_context c, Z3_ast p, unsigned n, Z3_ast a[]) {
Z3_TRY;
LOG_Z3_algebraic_roots(c, p, n, a);
RESET_ERROR_CODE();
polynomial::manager & pm = mk_c(c)->pm();
polynomial_ref _p(pm);
polynomial::scoped_numeral d(pm.m());
expr2polynomial converter(mk_c(c)->m(), pm, 0, true);
if (!converter.to_polynomial(to_expr(p), _p, d) ||
static_cast<unsigned>(max_var(_p)) >= n + 1) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
algebraic_numbers::manager & _am = am(c);
scoped_anum_vector as(_am);
if (!to_anum_vector(c, n, a, as)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
scoped_anum_vector roots(_am);
{
cancel_eh<algebraic_numbers::manager> eh(_am);
api::context::set_interruptable si(*(mk_c(c)), eh);
scoped_timer timer(mk_c(c)->params().m_timeout, &eh);
vector_var2anum v2a(as);
_am.isolate_roots(_p, v2a, roots);
}
Z3_ast_vector_ref* result = alloc(Z3_ast_vector_ref, mk_c(c)->m());
mk_c(c)->save_object(result);
for (unsigned i = 0; i < roots.size(); i++) {
result->m_ast_vector.push_back(au(c).mk_numeral(roots.get(i), false));
}
RETURN_Z3(of_ast_vector(result));
Z3_CATCH_RETURN(0);
}
Z3_ast Z3_API Z3_algebraic_root(Z3_context c, Z3_ast a, unsigned k) {
Z3_TRY;
LOG_Z3_algebraic_root(c, a, k);
RESET_ERROR_CODE();
CHECK_IS_ALGEBRAIC_X(a, 0);
if (k % 2 == 0) {
if ((is_rational(c, a) && get_rational(c, a).is_neg()) ||
(!is_rational(c, a) && am(c).is_neg(get_irrational(c, a)))) {
SET_ERROR_CODE(Z3_INVALID_ARG);
RETURN_Z3(0);
}
}
algebraic_numbers::manager & _am = am(c);
scoped_anum _r(_am);
if (is_rational(c, a)) {
scoped_anum av(_am);
_am.set(av, get_rational(c, a).to_mpq());
_am.root(av, k, _r);
}
else {
algebraic_numbers::anum const & av = get_irrational(c, a);
_am.root(av, k, _r);
}
expr * r = au(c).mk_numeral(_r, false);
mk_c(c)->save_ast_trail(r);
RETURN_Z3(of_ast(r));
Z3_CATCH_RETURN(0);
}
static SkShader* ComposeShader_create2(JNIEnv* env, jobject,
SkShader* shaderA, SkShader* shaderB, SkPorterDuff::Mode mode)
{
SkAutoUnref au(SkPorterDuff::CreateXfermode(mode));
return new SkComposeShader(shaderA, shaderB, (SkXfermode*)au.get());
}
void AboutWidget::showEvent(QShowEvent *)
{
QMPlay2GUI.restoreGeometry("AboutWidget/Geometry", this, 55);
refreshLog();
QFile cl(QMPlay2Core.getShareDir() + "ChangeLog");
if (cl.open(QFile::ReadOnly))
{
clE->setPlainText(cl.readAll());
cl.close();
}
QFile au(QMPlay2Core.getShareDir() + "AUTHORS");
if (au.open(QFile::ReadOnly))
{
auE->setPlainText(au.readAll());
au.close();
}
QFile f(QMPlay2Core.getLogFilePath());
if (!f.exists() && f.open(QFile::WriteOnly)) //tworzy pusty plik dziennika, jeżeli nie istnieje
f.close();
if (f.exists())
logWatcher.addPath(QMPlay2Core.getLogFilePath());
}
a_inode *fsdb_lookup_aino_aname (a_inode *base, const TCHAR *aname)
{
FILE *f;
f = get_fsdb (base, _T("r+b"));
if (f == 0) {
// if (currprefs.filesys_custom_uaefsdb && (base->volflags & MYVOLUMEINFO_STREAMS))
// return custom_fsdb_lookup_aino_aname (base, aname);
return 0;
}
for (;;) {
uae_u8 buf[1 + 4 + 257 + 257 + 81];
TCHAR *s;
if (fread (buf, 1, sizeof buf, f) < sizeof buf)
break;
s = au ((char*)buf + 5);
if (buf[0] != 0 && same_aname (s, aname)) {
long pos = ftell (f) - sizeof buf;
fclose (f);
xfree (s);
return aino_from_buf (base, buf, pos);
}
xfree (s);
}
fclose (f);
return 0;
}
static a_inode *custom_fsdb_lookup_aino (a_inode *base, const TCHAR *aname, int offset, int dontcreate)
{
uae_u8 fsdb[UAEFSDB2_LEN];
TCHAR *tmp1;
HANDLE h;
WIN32_FIND_DATA fd;
static a_inode dummy;
tmp1 = build_nname (base->nname, UAEFSDB_BEGINSX);
if (!tmp1)
return NULL;
h = FindFirstFile (tmp1, &fd);
if (h != INVALID_HANDLE_VALUE) {
do {
if (read_uaefsdb (base->nname, fd.cFileName, fsdb)) {
TCHAR *s = au ((char*)fsdb + offset);
if (same_aname (s, aname)) {
int winmode;
FindClose (h);
xfree (tmp1);
xfree (s);
if (dontcreate)
return &dummy;
return aino_from_buf (base, fsdb, &winmode);
}
xfree (s);
}
} while (FindNextFile (h, &fd));
FindClose (h);
}
xfree (tmp1);
return NULL;
}
int SkFontHost::CountTables(SkFontID fontID) {
SkStream* stream = SkFontHost::OpenStream(fontID);
if (NULL == stream) {
return 0;
}
SkAutoUnref au(stream);
return count_tables(stream);
}
// Ensure that the 'getConservativeBounds' calls are returning bounds clamped
// to the render target
static void test_clip_bounds(skiatest::Reporter* reporter, GrContext* context) {
static const int kXSize = 100;
static const int kYSize = 100;
GrTextureDesc desc;
desc.fFlags = kRenderTarget_GrTextureFlagBit;
desc.fConfig = kAlpha_8_GrPixelConfig;
desc.fWidth = kXSize;
desc.fHeight = kYSize;
GrTexture* texture = context->createUncachedTexture(desc, NULL, 0);
if (!texture) {
return;
}
SkAutoUnref au(texture);
SkIRect intScreen = SkIRect::MakeWH(kXSize, kYSize);
SkRect screen;
screen = SkRect::MakeWH(SkIntToScalar(kXSize),
SkIntToScalar(kYSize));
SkRect clipRect(screen);
clipRect.outset(10, 10);
// create a clip stack that will (trivially) reduce to a single rect that
// is larger than the screen
SkClipStack stack;
stack.clipDevRect(clipRect, SkRegion::kReplace_Op, false);
bool isIntersectionOfRects = true;
SkRect devStackBounds;
stack.getConservativeBounds(0, 0, kXSize, kYSize,
&devStackBounds,
&isIntersectionOfRects);
// make sure that the SkClipStack is behaving itself
REPORTER_ASSERT(reporter, screen == devStackBounds);
REPORTER_ASSERT(reporter, isIntersectionOfRects);
// wrap the SkClipStack in a GrClipData
GrClipData clipData;
clipData.fClipStack = &stack;
SkIRect devGrClipDataBound;
clipData.getConservativeBounds(texture,
&devGrClipDataBound,
&isIntersectionOfRects);
// make sure that GrClipData is behaving itself
REPORTER_ASSERT(reporter, intScreen == devGrClipDataBound);
REPORTER_ASSERT(reporter, isIntersectionOfRects);
}
static int inquiry (struct dev_info_spti *di, int unitnum, uae_u8 *inquirydata)
{
uae_u8 cmd[6] = { 0x12,0,0,0,36,0 }; /* INQUIRY */
uae_u8 out[INQUIRY_SIZE] = { 0 };
int outlen = sizeof (out);
uae_u8 *p = execscsicmd_in_internal (di, unitnum, cmd, sizeof (cmd), &outlen);
int inqlen = 0;
di->isatapi = 0;
di->removable = 0;
di->type = 0x1f;
if (!p) {
if (log_scsi)
write_log (L"SPTI: INQUIRY failed\n");
return 0;
}
inqlen = outlen > INQUIRY_SIZE ? INQUIRY_SIZE : outlen;
if (outlen >= 1) {
di->type = p[0] & 31;
di->removable = (p[1] & 0x80) ? 1 : 0;
}
if (outlen >= 2 && (p[0] & 31) == 5 && (p[2] & 7) == 0)
di->isatapi = 1;
memcpy (inquirydata, p, inqlen);
if (log_scsi) {
if (outlen >= INQUIRY_SIZE) {
char tmp[20];
TCHAR *s1, *s2;
memcpy (tmp, p + 8, 8);
tmp[8] = 0;
s1 = au (tmp);
memcpy (tmp, p + 16, 16);
tmp[16] = 0;
s2 = au (tmp);
write_log (L"SPTI: INQUIRY: %02X%02X%02X %d '%s' '%s'\n",
p[0], p[1], p[2], di->isatapi, s1, s2);
xfree (s2);
xfree (s1);
}
}
return inqlen;
}
DEF_TEST(RTree, reporter) {
SkRTree* rtree = SkRTree::Create(MIN_CHILDREN, MAX_CHILDREN);
SkAutoUnref au(rtree);
rtree_test_main(rtree, reporter);
// Rtree that orders input rectangles on deferred insert.
SkRTree* unsortedRtree = SkRTree::Create(MIN_CHILDREN, MAX_CHILDREN, 1, false);
SkAutoUnref auo(unsortedRtree);
rtree_test_main(unsortedRtree, reporter);
}
//<-- Changed by andkaz 08.04.2004 10:10:35
//! Check whether Output debug string is enabled
static bool IsDebugOutEnabled()
{
bool bResult = false;
if(klTraceCricSec)
{
TraceAutoUnlock au(klTraceCricSec);
bResult = klTraceInfo && ((klTraceInfo->traceFlags & TF_ENABLE_DEBUGOUT) != 0);
};
return bResult;
}
// multi_thread_checkpoint
bool multi_atomic(void)
{ bool ok = true;
// OpenMP setup
size_t num_threads = 4; // number of threads
omp_set_dynamic(0); // turn off dynamic thread adjustment
omp_set_num_threads( int(num_threads) ); // set number of OMP threads
// check that multi-threading is possible on this machine
if( omp_get_max_threads() < 2 )
{ std::cout << "This machine does not support multi-threading: ";
}
// create checkpoint version of algorithm
size_t n(1), m(1);
ad_vector ax(n), ay(m);
ax[0] = 2.0;
size_t length_of_sum = 5000;
long_sum_atomic atom_fun("long_sum", length_of_sum);
// setup for using CppAD in paralle mode
CppAD::thread_alloc::parallel_setup(num_threads, in_parallel, thread_num);
CppAD::thread_alloc::hold_memory(true);
CppAD::parallel_ad<double>();
// place to hold result for each thread
d_vector y(num_threads);
for(size_t thread = 0; thread < num_threads; thread++)
y[thread] = 0.0;
# pragma omp parallel for
for(int thread = 0; thread < int(num_threads); thread++)
{ ad_vector au(n), av(m);
au[0] = 1.0;
CppAD::Independent(au);
atom_fun(au, av);
CppAD::ADFun<double> f(au, av);
//
d_vector x(n), v(m);
x[0] = double( thread + 1 );
v = f.Forward(0, x);
//
// this assigment has false sharing; i.e., will case cache resets
// (conversion avoids boost vector conversion warning)
y[size_t(thread)] = v[0];
}
// check the results
for(size_t thread = 0; thread < num_threads; thread++)
{ double check = double( length_of_sum * (thread + 1) );
ok &= check == y[thread];
}
return ok;
}
Int32 CComposeShader::NativeCreate2(
/* [in] */ Int32 nativeShaderA,
/* [in] */ Int32 nativeShaderB,
/* [in] */ Int32 porterDuffMode)
{
SkAutoUnref au(SkPorterDuff::CreateXfermode((SkPorterDuff::Mode)porterDuffMode));
return (Int32)new SkComposeShader(
(SkShader*)nativeShaderA,
(SkShader*)nativeShaderB,
(SkXfermode*)au.get());
}
void tst_arith_rewriter() {
ast_manager m;
m.register_decl_plugins();
arith_rewriter ar(m);
arith_util au(m);
expr_ref t1(m), t2(m), result(m);
t1 = au.mk_numeral(rational(0),false);
t2 = au.mk_numeral(rational(-3),false);
expr* args[2] = { t1, t2 };
ar.mk_mul(2, args, result);
std::cout << mk_pp(result, m) << "\n";
}
void tst_model_retrieval()
{
memory::initialize(0);
front_end_params params;
params.m_model = true;
ast_manager m;
m.register_decl_plugins();
family_id array_fid = m.get_family_id(symbol("array"));
array_util au(m);
array_decl_plugin& ad = *static_cast<array_decl_plugin *>(m.get_plugin(array_fid));
// arr_s and select_fn creation copy-pasted from z3.cpp
parameter sparams[2] = { parameter(to_sort(m.mk_bool_sort())), parameter(to_sort(m.mk_bool_sort())) };
sort_ref arr_s(m.mk_sort(array_fid, ARRAY_SORT, 2, sparams), m);
sort * domain2[2] = {arr_s, m.mk_bool_sort()};
func_decl_ref select_fn(
m.mk_func_decl(array_fid, OP_SELECT, 2, arr_s->get_parameters(), 2, domain2), m);
app_ref a1(m.mk_const(symbol("a1"), arr_s), m);
app_ref a2(m.mk_const(symbol("a2"), arr_s), m);
// (= true (select a1 true))
app_ref fml(m.mk_eq(m.mk_true(),
m.mk_app(select_fn.get(), a1, m.mk_true())), m);
smt::context ctx(m, params);
ctx.assert_expr(fml);
lbool check_result = ctx.check();
std::cout<<((check_result==l_true) ? "satisfiable" :
(check_result==l_false) ? "unsatisfiable" : "unknown")<<"\n";
ref<model> model;
ctx.get_model(model);
model_v2_pp(std::cout, *model, false);
expr_ref a1_val(model->get_const_interp(a1->get_decl()), m);
app_ref fml2(m.mk_eq(a2, a1_val), m);
ctx.assert_expr(fml2);
std::cout<<"--------------------------\n";
ctx.display(std::cout);
std::cout<<"--------------------------\n";
check_result = ctx.check();
ctx.display(std::cout);
std::cout<<"--------------------------\n";
std::cout<<((check_result==l_true) ? "satisfiable" :
(check_result==l_false) ? "unsatisfiable" : "unknown")<<"\n";
}
static uae_u32 open_library (const char *name, uae_u32 min_version)
{
syncdivisor = (3580000.0 * CYCLE_UNIT) / (double) syncbase;
for (const char *c = name; *c; c++) {
if (*c == '/' || *c == '\\' || *c == ':') {
return UNI_ERROR_ILLEGAL_LIBRARY_NAME;
}
}
TCHAR *tname = au (name);
write_log (_T("uni: open native library '%s'\n"), tname);
TCHAR *path = get_native_library_path (tname);
free (tname);
if (path == NULL) {
write_log(_T("uni: library not found\n"));
return UNI_ERROR_LIBRARY_NOT_FOUND;
}
write_log (_T("uni: found library at %s - opening\n"), path);
#ifdef _WIN32
void *dl = LoadLibrary (path);
#else
void *dl = dlopen (path, RTLD_NOW);
#endif
free(path);
if (dl == NULL) {
write_log (_T("uni: error opening library errno %d\n"), errno);
return UNI_ERROR_COULD_NOT_OPEN_LIBRARY;
}
// FIXME: check min version
set_library_globals(dl);
void *function_address = dl_symbol(dl, "uni_init");
if (function_address) {
int error = ((uni_init_function) function_address)();
if (error) {
dl_close(dl);
return error;
}
}
struct library_data *library_data = (struct library_data *) malloc(
sizeof(struct library_data));
memset(library_data, 0, sizeof(struct library_data));
library_data->dl_handle = dl;
uae_u32 handle = register_handle (library_data, NULL);
write_log(_T("uni: opened library %08x (%p)\n"), handle, dl);
return handle;
}
FILE *moduleripper_fopen (const char *aname, const char *amode)
{
TCHAR outname[MAX_DPATH];
TCHAR *mode;
FILE *f;
moduleripper_filename(aname, outname, true);
mode = au (amode);
f = uae_tfopen (outname, mode);
xfree (mode);
return f;
}
Int64 CComposeShader::NativeCreate2(
/* [in] */ Int64 shaderAHandle,
/* [in] */ Int64 shaderBHandle,
/* [in] */ Int32 porterDuffModeHandle)
{
SkShader* shaderA = reinterpret_cast<SkShader *>(shaderAHandle);
SkShader* shaderB = reinterpret_cast<SkShader *>(shaderBHandle);
SkPorterDuff::Mode porterDuffMode = static_cast<SkPorterDuff::Mode>(porterDuffModeHandle);
SkAutoUnref au(SkPorterDuff::CreateXfermode(porterDuffMode));
SkXfermode* mode = (SkXfermode*) au.get();
SkShader* shader = new SkComposeShader(shaderA, shaderB, mode);
return reinterpret_cast<Int64>(shader);
}
DEF_TEST(BBoxHierarchy, reporter) {
// RTree
{
SkRTree* rtree = SkRTree::Create(RTREE_MIN_CHILDREN, RTREE_MAX_CHILDREN);
SkAutoUnref au(rtree);
tree_test_main(rtree, RTREE_MIN_CHILDREN, RTREE_MAX_CHILDREN, reporter);
// Rtree that orders input rectangles on deferred insert.
SkRTree* unsortedRtree = SkRTree::Create(RTREE_MIN_CHILDREN, RTREE_MAX_CHILDREN, 1, false);
SkAutoUnref auo(unsortedRtree);
tree_test_main(unsortedRtree, RTREE_MIN_CHILDREN, RTREE_MAX_CHILDREN, reporter);
}
}
static a_inode *aino_from_buf (a_inode *base, uae_u8 *buf, long off)
{
uae_u32 mode;
a_inode *aino = xcalloc (a_inode, 1);
TCHAR *s;
mode = do_get_mem_long ((uae_u32 *)(buf + 1));
buf += 5;
aino->aname = au ((char*)buf);
buf += 257;
s = au ((char*)buf);
aino->nname = build_nname (base->nname, s);
xfree (s);
buf += 257;
aino->comment = *buf != '\0' ? au ((char*)buf) : 0;
fsdb_fill_file_attrs (base, aino);
aino->amigaos_mode = mode;
aino->has_dbentry = 1;
aino->dirty = 0;
aino->db_offset = off;
return aino;
}
void write_log (const char *format, ...)
{
char buffer[WRITE_LOG_BUF_SIZE];
va_list parms;
TCHAR *b;
va_start (parms, format);
vsprintf (buffer, format, parms);
b = au (buffer);
write_log (b);
xfree (b);
va_end (parms);
}
static void premsg (void)
{
#if 0
static int done;
char *as;
char ast[32];
TCHAR *ws;
if (done)
return;
done = 1;
ast[0] = 'A';
ast[1] = 0x7f;
ast[2] = 0x80;
ast[3] = 0x81;
ast[4] = 0x9f;
ast[5] = 0;
ws = au_fs (ast);
MessageBoxA(NULL, "español", "ANSI", MB_OK);
MessageBoxW(NULL, _T("español"), _T("UTF-16"), MB_OK);
as = ua (_T("español"));
MessageBoxA(NULL, as, "ANSI:2", MB_OK);
ws = au (as);
MessageBoxW(NULL, ws, _T("UTF-16:2"), MB_OK);
xfree (ws);
xfree (as);
ws = au ("español");
MessageBoxW(NULL, ws, _T("UTF-16:3"), MB_OK);
as = ua (ws);
MessageBoxA(NULL, as, "ANSI:3", MB_OK);
xfree (ws);
xfree (as);
#endif
}
static int openprinter_ps (void)
{
TCHAR *gsargv[] = {
L"-dNOPAUSE", L"-dBATCH", L"-dNOPAGEPROMPT", L"-dNOPROMPT", L"-dQUIET", L"-dNoCancel",
L"-sDEVICE=mswinpr2", NULL
};
int gsargc, gsargc2, i;
TCHAR *tmpparms[100];
TCHAR tmp[MAX_DPATH];
char *gsparms[100];
if (ptr_gsapi_new_instance (&gsinstance, NULL) < 0)
return 0;
cmdlineparser (currprefs.ghostscript_parameters, tmpparms, 100 - 10);
gsargc2 = 0;
gsparms[gsargc2++] = ua (L"WinUAE");
for (gsargc = 0; gsargv[gsargc]; gsargc++) {
gsparms[gsargc2++] = ua (gsargv[gsargc]);
}
for (i = 0; tmpparms[i]; i++)
gsparms[gsargc2++] = ua (tmpparms[i]);
if (currprefs.prtname[0]) {
_stprintf (tmp, L"-sOutputFile=%%printer%%%s", currprefs.prtname);
gsparms[gsargc2++] = ua (tmp);
}
if (postscript_print_debugging) {
for (i = 0; i < gsargc2; i++) {
TCHAR *parm = au (gsparms[i]);
write_log (L"GSPARM%d: '%s'\n", i, parm);
xfree (parm);
}
}
__try {
int rc = ptr_gsapi_init_with_args (gsinstance, gsargc2, gsparms);
for (i = 0; i < gsargc2; i++) {
xfree (gsparms[i]);
}
if (rc != 0) {
write_log (L"GS failed, returncode %d\n", rc);
return 0;
}
ptr_gsapi_run_string_begin (gsinstance, 0, &gs_exitcode);
} __except (ExceptionFilter (GetExceptionInformation (), GetExceptionCode ())) {
write_log (L"GS crashed\n");
return 0;
}
psmode = 1;
return 1;
}
static uae_u32 REGPARAM2 res_getfunc (TrapContext *ctx)
{
uaecptr funcname = m68k_areg (regs, 0);
uae_char tmp[256];
uae_u32 p;
TCHAR *s;
if (funcname == 0)
return 0;
strcpyah_safe (tmp, funcname, sizeof tmp);
s = au (tmp);
p = find_trap (s);
xfree (s);
return p;
}
static void printbandiz(UCHAR *m, USHORT len){
UCHAR *i,*j;
i=j=m;
while (i<m+len) {
if (*i == 10) {
TCHAR *u;
*i=0;
u = au ((char*)j);
write_log (L"%s\n",u);
xfree (u);
j=i+1;
}
i++;
}
}
