C++ print_object函数代码示例

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();
    }
}