int print_data( pwr_sAttrRef *arp, FILE *fp)
{
int sts;
char *s;
pwr_tClassId classid;
char *object_p;
pwr_tAName dataname;
pwr_tAName objectname;
pwr_tAName attributename;
pwr_tAttrRef aref;
int object_backup;
int array_element = 0;
int index;
int nr;
sts = gdh_AttrrefToName( arp, dataname, sizeof(dataname), cdh_mNName);
if ( EVEN(sts)) return sts;
strcpy( objectname, dataname);
if ( !arp->Flags.b.ObjectAttr && (s = strchr( objectname, '.'))) {
*s = 0;
object_backup = 0;
strcpy( attributename, dataname);
if ( (s = strchr( dataname, '['))) {
array_element = 1;
nr = sscanf( s+1, "%d", &index);
if ( nr != 1) return 0;
}
}
else {
object_backup = 1;
}
sts = gdh_NameToAttrref( pwr_cNOid, objectname, &aref);
if ( EVEN(sts)) return sts;
sts = gdh_AttrRefToPointer( &aref, (void **)&object_p);
if ( EVEN(sts)) return sts;
sts = gdh_GetAttrRefTid( &aref, &classid);
if ( EVEN(sts)) return sts;
if ( object_backup) {
print_object( &aref, classid, object_p, 0, objectname, fp);
}
else {
print_attribute( &aref, classid, object_p, attributename, array_element, index, fp);
}
return 1;
}
static int meta_print_eopt(FILE *fd, struct tcf_ematch_hdr *hdr, void *data,
int data_len)
{
struct rtattr *tb[TCA_EM_META_MAX+1];
struct tcf_meta_hdr *meta_hdr;
if (parse_rtattr(tb, TCA_EM_META_MAX, data, data_len) < 0)
return -1;
if (tb[TCA_EM_META_HDR] == NULL) {
fprintf(stderr, "Missing meta header\n");
return -1;
}
if (RTA_PAYLOAD(tb[TCA_EM_META_HDR]) < sizeof(*meta_hdr)) {
fprintf(stderr, "Meta header size mismatch\n");
return -1;
}
meta_hdr = RTA_DATA(tb[TCA_EM_META_HDR]);
if (print_object(fd, &meta_hdr->left, tb[TCA_EM_META_LVALUE]) < 0)
return -1;
switch (meta_hdr->left.op) {
case TCF_EM_OPND_EQ:
fprintf(fd, " eq ");
break;
case TCF_EM_OPND_LT:
fprintf(fd, " lt ");
break;
case TCF_EM_OPND_GT:
fprintf(fd, " gt ");
break;
}
return print_object(fd, &meta_hdr->right, tb[TCA_EM_META_RVALUE]);
}
int main(int argc, char **argv) {
while(1) {
object_t exp = read_stream(stdin);
printf("--\n");
print_object(exp);
if(iscons(exp) && isproperlist(exp))
printf(" proper list");
else
printf(" symbol or improper list");
printf("\n");
}
}
void print_object(object *obj)
{
int first = 1;
if (!obj)
return;
switch (TYPE(obj)) {
case OBJ_SYMBOL:
printf("%s", STR(obj));
break;
case OBJ_NUMBER:
printf("%d", NUM(obj));
break;
case OBJ_BOOLEAN:
printf("%s", (NUM(obj) ? "#t" : "#f"));
break;
case OBJ_PAIR:
printf("(");
while (TYPE(obj) == OBJ_PAIR &&
obj != null_object) {
if (!first)
putchar(' ');
print_object(CAR(obj));
obj = CDR(obj);
first = 0;
}
if (obj != null_object) {
printf(" . ");
print_object(obj);
}
printf(")");
break;
case OBJ_PRIMITIVE_PROCEDURE:
case OBJ_COMPOUND_PROCEDURE:
printf("#<procedure>");
break;
}
}
void print_schema(reflection_Schema_table_t S)
{
reflection_Object_vec_t Objs;
reflection_Enum_vec_t Enums;
size_t i;
Objs = reflection_Schema_objects(S);
printf("{");
printf("\"objects\":[");
for (i = 0; i < reflection_Object_vec_len(Objs); ++i) {
if (i > 0) {
printf(",");
}
print_object(reflection_Object_vec_at(Objs, i));
}
printf("]");
Enums = reflection_Schema_enums(S);
printf(",\"enums\":[");
for (i = 0; i < reflection_Enum_vec_len(Enums); ++i) {
if (i > 0) {
printf(",");
}
print_enum(reflection_Enum_vec_at(Enums, i));
}
printf("]");
if (reflection_Schema_file_ident_is_present(S)) {
printf(",\"file_ident\":\"%s\"", reflection_Schema_file_ident(S));
}
if (reflection_Schema_file_ext_is_present(S)) {
printf(",\"file_ext\":\"%s\"", reflection_Schema_file_ext(S));
}
if (reflection_Schema_root_table_is_present(S)) {
printf(",\"root_table\":");
print_object(reflection_Schema_root_table(S));
}
printf("}\n");
}
void new_index(char *hash) {
char *indexpath = get_repo_troll_dir();
indexpath = (char *) realloc(indexpath, strlen(indexpath) + 5);
strcat(indexpath, "index");
printf("New index at %s\n",indexpath);
int index = open(indexpath, O_WRONLY | O_TRUNC, 0644);
free(indexpath);
lseek(index, 0, SEEK_SET);
int sout = dup(STDOUT_FILENO);
dup2(index,STDOUT_FILENO);
print_object(hash);
dup2(sout,STDOUT_FILENO);
}
int main(int argc, char **argv) {
while(1) {
printf("> ");
struct node *lines = read_sexp(stdin);
object_t sexp = parse_sexp(lines);
if(*(char*)lines->data == 'q') {
auxfor_each(lines, &free_node_and_string);
return 0;
}
print_object(sexp);
printf("\n");
auxfor_each(lines, &free_node_and_string);
}
}
// Render a value to text.
char *print_value(JSON *item,int depth,int fmt)
{
char *out=0;
if (!item) return 0;
switch ((item->type)&255)
{
case JSON_NULL: out = tr50_json_strdup("null"); break;
case JSON_FALSE: out = tr50_json_strdup("false"); break;
case JSON_TRUE: out = tr50_json_strdup("true"); break;
case JSON_NUMBER: out=print_number(item);break;
case JSON_STRING: out=print_string(item);break;
case JSON_ARRAY: out=print_array(item,depth,fmt);break;
case JSON_OBJECT: out=print_object(item,depth,fmt);break;
}
return out;
}
/* Render a value to text. */
static char *print_value(cJSON *item,int depth,int fmt)
{
char *out=0;
if (!item) return 0;
switch ((item->type)&255)
{
case cJSON_NULL: out=cJSON_strdup("null"); break;
case cJSON_False: out=cJSON_strdup("false");break;
case cJSON_True: out=cJSON_strdup("true"); break;
case cJSON_Number: out=print_number(item);break;
case cJSON_String: out=print_string(item);break;
case cJSON_Array: out=print_array(item,depth,fmt);break;
case cJSON_Object: out=print_object(item,depth,fmt);break;
}
return out;
}
void print_object(FILE *fp, UnionType o)
{
if (!fp) fp = stdout;
//fprintf(stderr, "type = [%d]\n", TYPE(o));
switch (TYPE(o.o)) {
case Int:
fprintf(fp, "%d", (int)to_Int(o.o));
break;
case Double:
fprintf(fp, "%f", o.d);
break;
case String:
fprintf(fp, "%s", (to_String(o.o))->s);
break;
case Array:
if (fp != stdout) {
_print_with_handler(fp, to_Array(o.o));
} else {
print(to_Array(o.o));
}
break;
case ArrayRef:
fprintf(fp, "ARRAY(%p)", to_Ptr(o.o));
break;
case Hash:
print_hash(fp, to_Hash(o.o));
break;
case HashRef:
fprintf(fp, "HASH(%p)", to_Ptr(o.o));
break;
case CodeRef:
fprintf(fp, "CODE(%p)", to_Ptr(o.o));
break;
case ObjectType: {
Object *object = to_Object(o.o);
print_object(fp, object->v);
break;
}
case BlessedObjectType:
fprintf(fp, "%s=HASH(%p)", (to_BlessedObject(o.o))->pkg_name, to_Ptr(o.o));
break;
default:
break;
}
}
/* Render a value to text. */
static char *print_value(cJSON *item,int depth,int fmt, ngx_pool_t *pool)
{
char *out=0;
if (!item) return 0;
switch ((item->type)&255)
{
case cJSON_NULL: out=cJSON_strdup("null", pool); break;
case cJSON_False: out=cJSON_strdup("false", pool);break;
case cJSON_True: out=cJSON_strdup("true", pool); break;
case cJSON_Number: out=print_number(item, pool);break;
case cJSON_VerFloat: out=print_verfloat(item, pool);break;
case cJSON_String: out=print_string(item, pool);break;
case cJSON_Array: out=print_array(item,depth,fmt, pool);break;
case cJSON_Object: out=print_object(item,depth,fmt, pool);break;
case cJSON_2dFloatArray: out=print_2dfloat_array(item, fmt, pool);break;
}
return out;
}
void hoard::print_object(size_t n) {
char buffer[32];
size_t divisor = 1;
while (divisor <= (n / 10))
divisor *= 10;
char *p = buffer;
do {
*p++ = (char) (((n / divisor) % 10) + '0');
divisor /= 10;
}
while (divisor != 0);
*p = '\0';
print_object(buffer);
}
/// Internal: Render a value to text.
static char *print_value(JSON *item, int depth, bool fmt)
{
char *out = 0;
if(!item) return 0;
if(item->original) { //imported item
item = item->original;
}
switch (item->type)
{
case JSON_NULL: out = newstring("null"); break;
case JSON_FALSE: out = newstring("false"); break;
case JSON_TRUE: out = newstring("true"); break;
case JSON_NUMBER: out = print_number(item); break;
case JSON_STRING: out = print_string(item); break;
case JSON_ARRAY: out = print_array( item, depth, fmt);break;
case JSON_OBJECT: out = print_object(item, depth, fmt);break;
}
return out;
}
static int walk_tree(const unsigned char *sha1, const char *base, int baselen,
const char *pathname, unsigned mode, int stage,
void *cbdata)
{
if (baselen == match_baselen) {
if (S_ISREG(mode))
print_object(sha1, pathname);
else if (S_ISDIR(mode)) {
print_dir(sha1, pathname, base);
return READ_TREE_RECURSIVE;
}
}
else if (baselen > match_baselen)
print_dir_entry(sha1, pathname, mode);
else if (S_ISDIR(mode))
return READ_TREE_RECURSIVE;
return 0;
}
void print_object(object_t root) {
switch (root.tag) {
case OBJECT_FIXNUM_TAG:
printf("%d", fixnum_unbox(root));
break;
case OBJECT_WORD_TAG:
printf("%s", string_unbox(word_name(root)));
break;
case OBJECT_LIST_TAG:
printf("[ ");
while (!object_eq(root, list_nil)) {
print_object(list_head(root));
printf(" ");
root = list_tail(root);
}
printf("]");
break;
case OBJECT_STRING_TAG:
printf("\"%s\"", string_unbox(root));
break;
case OBJECT_PRIMITIVE_TAG:
printf("0x%p", (void *)primitive_unbox(root));
break;
case OBJECT_BOOLEAN_TAG:
if (object_eq(root, boolean_t))
printf("t");
else
printf("f");
break;
case OBJECT_WRAPPER_TAG:
printf("\\ %s", string_unbox(word_name(wrapper_unbox(root))));
break;
case OBJECT_CONTINUATION_TAG:
printf("0x%p", continuation_unbox(root));
break;
case OBJECT_BLOCK_TAG:
printf("0x%p", block_unbox(root));
break;
default:
fail();
}
}
word_t heap_what_points_to_in(struct object_heap* oh, struct Object* x, byte_t* memory, word_t memorySize, bool_t print) {
struct Object* obj = (struct Object*) memory;
word_t count = 0;
while (object_in_memory(oh, obj, memory, memorySize)) {
word_t offset, limit;
offset = object_first_slot_offset(obj);
limit = object_last_oop_offset(obj) + sizeof(word_t);
for (; offset != limit; offset += sizeof(word_t)) {
struct Object* val = object_slot_value_at_offset(obj, offset);
if (val == x) {
if (!object_is_free(obj)) count++;
if (print && !object_is_free(obj)) {
fprintf(stderr, "pointed to by "); print_object(obj);
}
break;
}
}
obj = object_after(oh, obj);
}
return count;
}
/* Render a value to text. */
static char *print_value(struct json *item, int depth, int fmt)
{
char *out = NULL;
if (!item)
return 0;
if (fmt == item->print_fmt && item->print_out)
return item->print_out;
switch ((item->type) & 255) {
case JSON_T_NULL:
out = json_strdup("null");
break;
case JSON_T_FALSE:
out = json_strdup("false");
break;
case JSON_T_TRUE:
out = json_strdup("true");
break;
case JSON_T_NUMBER:
out = print_number(item);
break;
case JSON_T_STRING:
out = print_string(item);
break;
case JSON_T_ARRAY:
out = print_array(item, depth, fmt);
break;
case JSON_T_OBJECT:
out = print_object(item, depth, fmt);
break;
}
if (item->print_out)
json_free(item->print_out);
item->print_out = out;
item->print_fmt = fmt;
return out;
}
void copy_out() {
char *indexpath = get_repo_troll_dir();
indexpath = (char *) realloc(indexpath, strlen(indexpath) + 5);
strcat(indexpath, "index");
FILE *findex = fopen(indexpath, "r");
free(indexpath);
fseek(findex, 0, SEEK_SET);
char hash[41];
int newfile;
char *trollpath = get_repo_troll_dir();
char *repo_path = (char *) malloc(strlen(trollpath) - 7);
strncat(repo_path,trollpath,strlen(trollpath) - 7);
free(trollpath);
char *newpath;
char name[256];
int sout;
char *lastchar;
sout = dup(STDOUT_FILENO);
while(fgets(hash, 41, findex)) {
fseek(findex,1,SEEK_CUR);
fgets(name, 256, findex);
newpath = (char *) malloc(strlen(repo_path) + strlen(name));
strcat(newpath, repo_path);
strcat(newpath, name);
lastchar = strstr(newpath,"\n");
*lastchar = '\0';
newfile = open(newpath, O_WRONLY | O_TRUNC, 0644);
printf("%s\n",newpath);
dup2(newfile,STDOUT_FILENO);
print_object(hash);
dup2(sout,STDOUT_FILENO);
close(newfile);
}
}
void hoard::print_object(void *px) {
static char const *hexdigits = "0123456789abcdef";
static char buffer[32];
size_t n = (size_t) px;
char *p = buffer;
*p++ = '0';
*p++ = 'x';
int shift = sizeof(void *) * 8;
do {
shift -= 4;
*p++ = hexdigits[(n >> shift) & 15];
}
while (shift != 0);
*p = '\0';
print_object(buffer);
}
int see_lists(t_all *all)
{
t_object *objects;
t_spot *spots;
objects = all->objects;
spots = all->spots;
if (print_global(all) < 0 || printf("\nObjects:\n\n") < 0 ||
print_object(objects) < 0 || printf("\nSpots:\n\n") < 0)
return (-1);
while (spots != NULL)
{
if (printf("Spots pos : x = %f, y = %f, z = %f\n",
spots->pos.x, spots->pos.y, spots->pos.z) < 0 ||
printf("Spots color : r = %f, g = %f, b = %f\n",
spots->color.r, spots->color.g, spots->color.b) < 0 ||
printf("Orientation = %f\nIntensity = %f\nRadius = %f\n\n",
spots->orientation, spots->intensity, spots->radius) < 0)
return (-1);
spots = spots->next;
}
return ((printf("\n") < 0) ? -1 : 0);
}
static int walk_tree(const unsigned char *sha1, struct strbuf *base,
const char *pathname, unsigned mode, int stage, void *cbdata)
{
struct walk_tree_context *walk_tree_ctx = cbdata;
if (base->len == walk_tree_ctx->match_baselen) {
if (S_ISREG(mode)) {
if (print_object(sha1, pathname))
walk_tree_ctx->match = 1;
} else if (S_ISDIR(mode)) {
print_dir(sha1, base->buf, base->len, pathname);
walk_tree_ctx->match = 2;
return READ_TREE_RECURSIVE;
}
} else if (base->len > walk_tree_ctx->match_baselen) {
print_dir_entry(sha1, base->buf, base->len, pathname, mode);
walk_tree_ctx->match = 2;
} else if (S_ISDIR(mode)) {
return READ_TREE_RECURSIVE;
}
return 0;
}
void evaluate_stack()
{
// std::cout << "EVALUATE_STACK: " << optic_stack.size() << std::endl;
// print_stack();
global_state.type = VOID;
while(optic_stack.size())
{
evaluate_top();
if(optic_stack.size())
{
global_state = optic_stack.back();
optic_stack.pop_back();
}
}
if(global_state.type != VOID)
{
out() << "optic: ";
print_object(global_state);
mem_free(global_state);
}
}
void print_vector (STREAM stream, D instance, BOOL escape_p, int print_depth) {
int size = vector_size(instance);
int first = TRUE, i = 0;
D element;
int max_size = MIN(size, dylan_print_length);
put_string("#[", stream);
if (print_depth < dylan_print_depth) {
for (; i < max_size; i++) {
if (first)
first = FALSE;
else
put_string(", ", stream);
element = vector_ref(instance, i);
print_object(stream, element, escape_p, print_depth + 1);
}
}
if (size > max_size || print_depth >= dylan_print_depth) {
if (i > 0)
put_string(", ", stream);
format(stream, "... 0x%lx", instance);
}
put_string("]", stream);
}
static void test_handles(void)
{
HWINSTA w1, w2, w3;
HDESK d1, d2, d3;
HANDLE hthread;
DWORD id, flags, le;
ATOM atom;
char buffer[20];
/* win stations */
w1 = GetProcessWindowStation();
ok( GetProcessWindowStation() == w1, "GetProcessWindowStation returned different handles\n" );
ok( !CloseWindowStation(w1), "closing process win station succeeded\n" );
SetLastError( 0xdeadbeef );
ok( !CloseHandle(w1), "closing process win station handle succeeded\n" );
ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() );
print_object( w1 );
flags = 0;
ok( GetHandleInformation( w1, &flags ), "GetHandleInformation failed\n" );
ok( !(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE) ||
broken(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE), /* set on nt4 */
"handle %p PROTECT_FROM_CLOSE set\n", w1 );
ok( DuplicateHandle( GetCurrentProcess(), w1, GetCurrentProcess(), (PHANDLE)&w2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseWindowStation(w2), "closing dup win station failed\n" );
ok( DuplicateHandle( GetCurrentProcess(), w1, GetCurrentProcess(), (PHANDLE)&w2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseHandle(w2), "closing dup win station handle failed\n" );
w2 = CreateWindowStation("WinSta0", 0, WINSTA_ALL_ACCESS, NULL );
le = GetLastError();
ok( w2 != 0 || le == ERROR_ACCESS_DENIED, "CreateWindowStation failed (%u)\n", le );
if (w2 != 0)
{
ok( w2 != w1, "CreateWindowStation returned default handle\n" );
SetLastError( 0xdeadbeef );
ok( !CloseDesktop( (HDESK)w2 ), "CloseDesktop succeeded on win station\n" );
ok( GetLastError() == ERROR_INVALID_HANDLE || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
w2 = CreateWindowStation("WinSta0", 0, WINSTA_ALL_ACCESS, NULL );
ok( CloseHandle( w2 ), "CloseHandle failed\n" );
}
else if (le == ERROR_ACCESS_DENIED)
win_skip( "Not enough privileges for CreateWindowStation\n" );
w2 = OpenWindowStation("winsta0", TRUE, WINSTA_ALL_ACCESS );
ok( w2 != 0, "OpenWindowStation failed\n" );
ok( w2 != w1, "OpenWindowStation returned default handle\n" );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
w2 = OpenWindowStation("dummy name", TRUE, WINSTA_ALL_ACCESS );
ok( !w2, "open dummy win station succeeded\n" );
CreateMutexA( NULL, 0, "foobar" );
w2 = CreateWindowStation("foobar", 0, WINSTA_ALL_ACCESS, NULL );
le = GetLastError();
ok( w2 != 0 || le == ERROR_ACCESS_DENIED, "create foobar station failed (%u)\n", le );
if (w2 != 0)
{
w3 = OpenWindowStation("foobar", TRUE, WINSTA_ALL_ACCESS );
ok( w3 != 0, "open foobar station failed\n" );
ok( w3 != w2, "open foobar station returned same handle\n" );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
ok( CloseWindowStation( w3 ), "CloseWindowStation failed\n" );
w3 = OpenWindowStation("foobar", TRUE, WINSTA_ALL_ACCESS );
ok( !w3, "open foobar station succeeded\n" );
w2 = CreateWindowStation("foobar1", 0, WINSTA_ALL_ACCESS, NULL );
ok( w2 != 0, "create foobar station failed\n" );
w3 = CreateWindowStation("foobar2", 0, WINSTA_ALL_ACCESS, NULL );
ok( w3 != 0, "create foobar station failed\n" );
ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
ok( GetHandleInformation( w3, &flags ), "GetHandleInformation failed\n" );
SetProcessWindowStation( w2 );
atom = GlobalAddAtomA("foo");
ok( GlobalGetAtomNameA( atom, buffer, sizeof(buffer) ) == 3, "GlobalGetAtomName failed\n" );
ok( !lstrcmpiA( buffer, "foo" ), "bad atom value %s\n", buffer );
ok( !CloseWindowStation( w2 ), "CloseWindowStation succeeded\n" );
ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
SetProcessWindowStation( w3 );
ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
ok( GlobalGetAtomNameA( atom, buffer, sizeof(buffer) ) == 3, "GlobalGetAtomName failed\n" );
ok( !lstrcmpiA( buffer, "foo" ), "bad atom value %s\n", buffer );
}
else if (le == ERROR_ACCESS_DENIED)
win_skip( "Not enough privileges for CreateWindowStation\n" );
/* desktops */
d1 = GetThreadDesktop(GetCurrentThreadId());
initial_desktop = d1;
ok( GetThreadDesktop(GetCurrentThreadId()) == d1,
"GetThreadDesktop returned different handles\n" );
flags = 0;
ok( GetHandleInformation( d1, &flags ), "GetHandleInformation failed\n" );
ok( !(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE), "handle %p PROTECT_FROM_CLOSE set\n", d1 );
SetLastError( 0xdeadbeef );
ok( !CloseDesktop(d1), "closing thread desktop succeeded\n" );
ok( GetLastError() == ERROR_BUSY || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
SetLastError( 0xdeadbeef );
if (CloseHandle( d1 )) /* succeeds on nt4 */
{
win_skip( "NT4 desktop handle management is completely different\n" );
return;
}
ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() );
ok( DuplicateHandle( GetCurrentProcess(), d1, GetCurrentProcess(), (PHANDLE)&d2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseDesktop(d2), "closing dup desktop failed\n" );
ok( DuplicateHandle( GetCurrentProcess(), d1, GetCurrentProcess(), (PHANDLE)&d2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseHandle(d2), "closing dup desktop handle failed\n" );
d2 = OpenDesktop( "dummy name", 0, TRUE, DESKTOP_ALL_ACCESS );
ok( !d2, "open dummy desktop succeeded\n" );
d2 = CreateDesktop( "foobar", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
ok( d2 != 0, "create foobar desktop failed\n" );
SetLastError( 0xdeadbeef );
ok( !CloseWindowStation( (HWINSTA)d2 ), "CloseWindowStation succeeded on desktop\n" );
ok( GetLastError() == ERROR_INVALID_HANDLE || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
SetLastError( 0xdeadbeef );
d3 = CreateDesktop( "foobar", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
ok( d3 != 0, "create foobar desktop again failed\n" );
ok( GetLastError() == 0xdeadbeef, "bad last error %d\n", GetLastError() );
ok( CloseDesktop( d3 ), "CloseDesktop failed\n" );
d3 = OpenDesktop( "foobar", 0, TRUE, DESKTOP_ALL_ACCESS );
ok( d3 != 0, "open foobar desktop failed\n" );
ok( d3 != d2, "open foobar desktop returned same handle\n" );
ok( CloseDesktop( d2 ), "CloseDesktop failed\n" );
ok( CloseDesktop( d3 ), "CloseDesktop failed\n" );
d3 = OpenDesktop( "foobar", 0, TRUE, DESKTOP_ALL_ACCESS );
ok( !d3, "open foobar desktop succeeded\n" );
ok( !CloseHandle(d1), "closing thread desktop handle succeeded\n" );
d2 = GetThreadDesktop(GetCurrentThreadId());
ok( d1 == d2, "got different handles after close\n" );
register_class();
trace( "thread 1 desktop: %p\n", d1 );
print_object( d1 );
hthread = CreateThread( NULL, 0, thread, (LPVOID)2, 0, &id );
Sleep(1000);
trace( "get other thread desktop: %p\n", GetThreadDesktop(id) );
WaitForSingleObject( hthread, INFINITE );
CloseHandle( hthread );
}
void print_SignallingIndication(enum SignallingIndication* signallingIndication, Print print) {
print_object(signallingIndication, &SIGNALLINGINDICATION_TYPE, print);
}
void print_InformationRequestType(struct InformationRequestType* informationRequestType, Print print) {
print_object(informationRequestType, &INFORMATIONREQUESTTYPE_TYPE, print);
}
void z_show_status (void)
{
zword global0;
zword global1;
zword global2;
zword addr;
bool brief = FALSE;
/* One V5 game (Wishbringer Solid Gold) contains this opcode by
accident, so just return if the version number does not fit */
if (h_version >= V4)
return;
/* Read all relevant global variables from the memory of the
Z-machine into local variables */
addr = h_globals;
LOW_WORD (addr, global0)
addr += 2;
LOW_WORD (addr, global1)
addr += 2;
LOW_WORD (addr, global2)
/* Frotz uses window 7 for the status line. Don't forget to select
reverse and fixed width text style */
set_window (7);
print_char (ZC_NEW_STYLE);
print_char (REVERSE_STYLE | FIXED_WIDTH_STYLE);
/* If the screen width is below 55 characters then we have to use
the brief status line format */
if (h_screen_cols < 55)
brief = TRUE;
/* Print the object description for the global variable 0 */
print_char (' ');
print_object (global0);
/* A header flag tells us whether we have to display the current
time or the score/moves information */
if (h_config & CONFIG_TIME) { /* print hours and minutes */
zword hours = (global1 + 11) % 12 + 1;
pad_status_line (brief ? 15 : 20);
print_string ("Time: ");
if (hours < 10)
print_char (' ');
print_num (hours);
print_char (':');
if (global2 < 10)
print_char ('0');
print_num (global2);
print_char (' ');
print_char ((global1 >= 12) ? 'p' : 'a');
print_char ('m');
} else { /* print score and moves */
pad_status_line (brief ? 15 : 30);
print_string (brief ? "S: " : "Score: ");
print_num (global1);
pad_status_line (brief ? 8 : 14);
print_string (brief ? "M: " : "Moves: ");
print_num (global2);
}
/* Pad the end of the status line with spaces */
pad_status_line (0);
/* Return to the lower window */
set_window (0);
}/* z_show_status */
template <class T> void do_oop_work(T* p) {
assert(_containing_obj != NULL, "Precondition");
assert(!_g1h->is_obj_dead_cond(_containing_obj, _use_prev_marking),
"Precondition");
T heap_oop = oopDesc::load_heap_oop(p);
if (!oopDesc::is_null(heap_oop)) {
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
bool failed = false;
if (!_g1h->is_in_closed_subset(obj) ||
_g1h->is_obj_dead_cond(obj, _use_prev_marking)) {
if (!_failures) {
gclog_or_tty->print_cr("");
gclog_or_tty->print_cr("----------");
}
if (!_g1h->is_in_closed_subset(obj)) {
HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
gclog_or_tty->print_cr("Field "PTR_FORMAT
" of live obj "PTR_FORMAT" in region "
"["PTR_FORMAT", "PTR_FORMAT")",
p, (void*) _containing_obj,
from->bottom(), from->end());
print_object(gclog_or_tty, _containing_obj);
gclog_or_tty->print_cr("points to obj "PTR_FORMAT" not in the heap",
(void*) obj);
} else {
HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
HeapRegion* to = _g1h->heap_region_containing((HeapWord*)obj);
gclog_or_tty->print_cr("Field "PTR_FORMAT
" of live obj "PTR_FORMAT" in region "
"["PTR_FORMAT", "PTR_FORMAT")",
p, (void*) _containing_obj,
from->bottom(), from->end());
print_object(gclog_or_tty, _containing_obj);
gclog_or_tty->print_cr("points to dead obj "PTR_FORMAT" in region "
"["PTR_FORMAT", "PTR_FORMAT")",
(void*) obj, to->bottom(), to->end());
print_object(gclog_or_tty, obj);
}
gclog_or_tty->print_cr("----------");
_failures = true;
failed = true;
_n_failures++;
}
if (!_g1h->full_collection()) {
HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
HeapRegion* to = _g1h->heap_region_containing(obj);
if (from != NULL && to != NULL &&
from != to &&
!to->isHumongous()) {
jbyte cv_obj = *_bs->byte_for_const(_containing_obj);
jbyte cv_field = *_bs->byte_for_const(p);
const jbyte dirty = CardTableModRefBS::dirty_card_val();
bool is_bad = !(from->is_young()
|| to->rem_set()->contains_reference(p)
|| !G1HRRSFlushLogBuffersOnVerify && // buffers were not flushed
(_containing_obj->is_objArray() ?
cv_field == dirty
: cv_obj == dirty || cv_field == dirty));
if (is_bad) {
if (!_failures) {
gclog_or_tty->print_cr("");
gclog_or_tty->print_cr("----------");
}
gclog_or_tty->print_cr("Missing rem set entry:");
gclog_or_tty->print_cr("Field "PTR_FORMAT
" of obj "PTR_FORMAT
", in region %d ["PTR_FORMAT
", "PTR_FORMAT"),",
p, (void*) _containing_obj,
from->hrs_index(),
from->bottom(),
from->end());
_containing_obj->print_on(gclog_or_tty);
gclog_or_tty->print_cr("points to obj "PTR_FORMAT
" in region %d ["PTR_FORMAT
", "PTR_FORMAT").",
(void*) obj, to->hrs_index(),
to->bottom(), to->end());
obj->print_on(gclog_or_tty);
gclog_or_tty->print_cr("Obj head CTE = %d, field CTE = %d.",
cv_obj, cv_field);
gclog_or_tty->print_cr("----------");
_failures = true;
if (!failed) _n_failures++;
}
}
}
}
}
/* Render a value to text. */
static char* print_value(cJSON *item, int depth, int fmt, printbuffer *p)
{
char *out = 0;
if(!item)
{
printf("[cJSON] Invalid Item!!\n");
return 0;
}
if(p)
{
switch((item->type) & 255)
{
case cJSON_NULL:
{
out = ensure(p, 5);
if(out)
strcpy(out, "null");
break;
}
case cJSON_False:
{
out = ensure(p, 6);
if(out)
strcpy(out, "false");
break;
}
case cJSON_True:
{
out = ensure(p, 5);
if(out)
strcpy(out, "true");
break;
}
case cJSON_Number:
out = print_number(item, p);
break;
case cJSON_String:
out = print_string(item, p);
break;
case cJSON_Array:
out = print_array(item, depth, fmt, p);
break;
case cJSON_Object:
out = print_object(item, depth, fmt, p);
break;
case cJSON_Object_Serialized:
out = print_serialized_obj_val_as_is(item, p);
break;
default:
printf("[cJSON] Unknown Item Type!!\n");
break;
}
}
else
{
switch((item->type) & 255)
{
case cJSON_NULL:
out = cJSON_strdup("null");
break;
case cJSON_False:
out = cJSON_strdup("false");
break;
case cJSON_True:
out = cJSON_strdup("true");
break;
case cJSON_Number:
out = print_number(item, 0);
break;
case cJSON_String:
out = print_string(item, 0);
break;
case cJSON_Array:
out = print_array(item, depth, fmt, 0);
break;
case cJSON_Object:
out = print_object(item, depth, fmt, 0);
break;
case cJSON_Object_Serialized:
out = print_serialized_obj_val_as_is(item, 0);
break;
default:
printf("[cJSON] Unknown Item Type!!\n");
break;
}
}
return out;
}
static void print_object (stix_t* stix, stix_oow_t mask, stix_oop_t oop)
{
if (oop == stix->_nil)
{
stix_logbfmt (stix, mask, "nil");
}
else if (oop == stix->_true)
{
stix_logbfmt (stix, mask, "true");
}
else if (oop == stix->_false)
{
stix_logbfmt (stix, mask, "false");
}
else if (STIX_OOP_IS_SMOOI(oop))
{
stix_logbfmt (stix, mask, "%zd", STIX_OOP_TO_SMOOI(oop));
}
else if (STIX_OOP_IS_CHAR(oop))
{
stix_logbfmt (stix, mask, "$%.1C", STIX_OOP_TO_CHAR(oop));
}
else if (STIX_OOP_IS_RSRC(oop))
{
stix_logbfmt (stix, mask, "%zX", stix->rsrc.ptr[STIX_OOP_TO_RSRC(oop)]);
}
else
{
stix_oop_class_t c;
stix_oow_t i;
STIX_ASSERT (STIX_OOP_IS_POINTER(oop));
c = (stix_oop_class_t)STIX_OBJ_GET_CLASS(oop); /*STIX_CLASSOF(stix, oop);*/
if ((stix_oop_t)c == stix->_large_negative_integer)
{
stix_oow_t i;
stix_logbfmt (stix, mask, "-16r");
for (i = STIX_OBJ_GET_SIZE(oop); i > 0;)
{
stix_logbfmt (stix, mask, "%0*lX", (int)(STIX_SIZEOF(stix_liw_t) * 2), (unsigned long)((stix_oop_liword_t)oop)->slot[--i]);
}
}
else if ((stix_oop_t)c == stix->_large_positive_integer)
{
stix_oow_t i;
stix_logbfmt (stix, mask, "16r");
for (i = STIX_OBJ_GET_SIZE(oop); i > 0;)
{
stix_logbfmt (stix, mask, "%0*lX", (int)(STIX_SIZEOF(stix_liw_t) * 2), (unsigned long)((stix_oop_liword_t)oop)->slot[--i]);
}
}
else if (STIX_OBJ_GET_FLAGS_TYPE(oop) == STIX_OBJ_TYPE_CHAR)
{
if ((stix_oop_t)c == stix->_symbol)
{
stix_logbfmt (stix, mask, "#%.*S", STIX_OBJ_GET_SIZE(oop), ((stix_oop_char_t)oop)->slot);
}
else /*if ((stix_oop_t)c == stix->_string)*/
{
stix_ooch_t ch;
int escape = 0;
for (i = 0; i < STIX_OBJ_GET_SIZE(oop); i++)
{
ch = ((stix_oop_char_t)oop)->slot[i];
if (ch < ' ')
{
escape = 1;
break;
}
}
if (escape)
{
stix_ooch_t escaped;
stix_logbfmt (stix, mask, "S'");
for (i = 0; i < STIX_OBJ_GET_SIZE(oop); i++)
{
ch = ((stix_oop_char_t)oop)->slot[i];
if (ch < ' ')
{
switch (ch)
{
case '\0':
escaped = '0';
break;
case '\n':
escaped = 'n';
break;
case '\r':
escaped = 'r';
break;
case '\t':
escaped = 't';
break;
case '\f':
escaped = 'f';
break;
case '\b':
escaped = 'b';
break;
case '\v':
escaped = 'v';
break;
case '\a':
escaped = 'a';
break;
default:
escaped = ch;
break;
}
if (escaped == ch)
stix_logbfmt (stix, mask, "\\x%X", ch);
else
stix_logbfmt (stix, mask, "\\%C", escaped);
}
else
{
stix_logbfmt (stix, mask, "%C", ch);
}
}
stix_logbfmt (stix, mask, "'");
}
else
{
stix_logbfmt (stix, mask, "'%.*S'", STIX_OBJ_GET_SIZE(oop), ((stix_oop_char_t)oop)->slot);
}
}
}
else if (STIX_OBJ_GET_FLAGS_TYPE(oop) == STIX_OBJ_TYPE_BYTE)
{
stix_logbfmt (stix, mask, "#[");
for (i = 0; i < STIX_OBJ_GET_SIZE(oop); i++)
{
stix_logbfmt (stix, mask, " %d", ((stix_oop_byte_t)oop)->slot[i]);
}
stix_logbfmt (stix, mask, "]");
}
else if (STIX_OBJ_GET_FLAGS_TYPE(oop) == STIX_OBJ_TYPE_HALFWORD)
{
stix_logbfmt (stix, mask, "#[["); /* TODO: fix this symbol/notation */
for (i = 0; i < STIX_OBJ_GET_SIZE(oop); i++)
{
stix_logbfmt (stix, mask, " %zX", (stix_oow_t)((stix_oop_halfword_t)oop)->slot[i]);
}
stix_logbfmt (stix, mask, "]]");
}
else if (STIX_OBJ_GET_FLAGS_TYPE(oop) == STIX_OBJ_TYPE_WORD)
{
stix_logbfmt (stix, mask, "#[[["); /* TODO: fix this symbol/notation */
for (i = 0; i < STIX_OBJ_GET_SIZE(oop); i++)
{
stix_logbfmt (stix, mask, " %zX", ((stix_oop_word_t)oop)->slot[i]);
}
stix_logbfmt (stix, mask, "]]]");
}
else if ((stix_oop_t)c == stix->_array)
{
stix_logbfmt (stix, mask, "#(");
for (i = 0; i < STIX_OBJ_GET_SIZE(oop); i++)
{
stix_logbfmt (stix, mask, " ");
print_object (stix, mask, ((stix_oop_oop_t)oop)->slot[i]);
}
stix_logbfmt (stix, mask, ")");
}
else if ((stix_oop_t)c == stix->_class)
{
/* print the class name */
stix_logbfmt (stix, mask, "%.*S", STIX_OBJ_GET_SIZE(((stix_oop_class_t)oop)->name), ((stix_oop_class_t)oop)->name->slot);
}
else if ((stix_oop_t)c == stix->_association)
{
stix_logbfmt (stix, mask, "%O -> %O", ((stix_oop_association_t)oop)->key, ((stix_oop_association_t)oop)->value);
}
else
{
stix_logbfmt (stix, mask, "instance of %.*S(%p)", STIX_OBJ_GET_SIZE(c->name), ((stix_oop_char_t)c->name)->slot, oop);
}
}
}
