static void bt_print_node(bt* tree, bt_node* node, char* indent, void (*print_element)(void* val)) { printf("%s", indent); printf("(%p) ", node); printf("N=%i", node_N(node)); if (!isleaf(node)) { char* subind; char* addind = " "; printf(", leftmost (%p)", node->branch.firstleaf); printf(", Nleft=%i, Nright=%i, balance %i.\n", node_N(node->branch.children[0]), node_N(node->branch.children[1]), node->branch.balance); subind = malloc(strlen(indent) + strlen(addind) + 1); sprintf(subind, "%s%s", indent, addind); printf("%sLeft child:\n", indent); bt_print_node(tree, node->branch.children[0], subind, print_element); printf("%sRight child:\n", indent); bt_print_node(tree, node->branch.children[1], subind, print_element); free(subind); } else { int i; printf(". Leaf."); if (print_element) { printf(" [ "); for (i=0; i<node_N(node); i++) print_element(get_element(tree, &node->leaf, i)); } printf("]\n"); } }
int main () { int notpassed = 0; int passed = 0; struct array array1; check (init_array (&array1)) test (add_element (&array1, 1), NO_ERRORS) test (add_element (&array1, 8), NO_ERRORS) test (change_element(&array1, 12, 33), WRITE_TO_UNALLOCATED_MEMORY) test (change_element(&array1, 1, 33), NO_ERRORS) test (add_element (&array1, 41), NO_ERRORS) test (add_element (&array1, 3), NO_ERRORS) test (add_element (&array1, 9), NO_ERRORS) test (elements_sum (&array1), NO_ERRORS) test (add_element (&array1, 13), NO_ERRORS) test (verbose_full_print (&array1), NO_ERRORS) test (remove_element (&array1, 4), NO_ERRORS) test (print_array (&array1), NO_ERRORS) test (find_element(&array1, 120), ELEMENT_NOT_FOUND) test (print_array (&array1), NO_ERRORS) test (print_array (&array1), NO_ERRORS) test (print_element(&array1, 40), GARBAGE_READ) test (zero_array (&array1), NO_ERRORS) test (print_array (&array1), NO_ERRORS) printf ("datalen = %i, memlen = %i\n", get_datalen (&array1), get_memlen (&array1)); for (int i = 0; i < 305; i ++) check (add_element (&array1, 41)); printf ("Passed %i, not passed %i.\n", passed, notpassed); test (delete_array (&array1), NO_ERRORS) print_exit_message (); return 0; }
/* Removal of tail recursion is so simple that some compilers do it automatically. Even so, it is best not to find out that yours does not. */ void print_list( lista *L ) { /*1*/ if( L != NULL ) { /*2*/ print_element( L->element ); /*3*/ print_list( L -> next ); } }
//============================================ // 楕円曲線の確認用 //============================================ void test_feature(const EC_GROUP ec) { fprintf(stdout, "---\n"); fprintf(stdout, "Elliptic Curve Type: %s\n", curve_get_name(ec)); fprintf(stdout, " Y^2 = X^3 + aX + b\n"); fprintf(stdout, " a: "); print_element(ec->a); fprintf(stdout, " b: "); print_element(ec->b); gmp_fprintf(stdout, " field order: %Zx^%d\n", *field_get_char(ec->field), field_get_degree(ec->field)); fprintf(stdout, " generator of curve: "); print_point(ec->generator); gmp_fprintf(stdout, " order: %Zx\n", ec->order); gmp_fprintf(stdout, " trace: %Zx\n", ec->trace); gmp_fprintf(stdout, " cofactor: %Zx\n", ec->cofactor); fprintf(stdout, "---\n"); }
void print_set(scp_operand set) { set.param_type = SCP_FIXED; scp_operand arc, element; MAKE_DEFAULT_ARC_ASSIGN(arc); MAKE_DEFAULT_OPERAND_ASSIGN(element); scp_iterator3 *iterator = scp_iterator3_new(s_default_ctx, &set, &arc, &element); while(SCP_RESULT_TRUE == scp_iterator3_new(s_default_ctx, &set, &arc, &element)) print_element(element); }
/** * @brief Return the XML representation of a XmlDocument. */ std::string XmlWriter::to_string( const XmlDocument& document ) { std::string res = ""; if (!document.xml_tag.empty() || !document.declarations.empty()) { res = "<?" + document.xml_tag + print_attributes_list(document.declarations) + "?>\n"; } print_element(res, &document, 0); return res + "\n"; }
int picreate (int credCreate, void *(*start)(void*), void *arg){ //printf("DBG - chamado picriate(). ID: %d\n", id); if (inicializada != 0) //Primeira chamada a funcao. { printf("DBG - Inicializando biblioteca - thread main.\n"); tcb[id] = (TCB_t *) malloc(sizeof(TCB_t)); //Aloca TCB da main //*/Ajusta o TCB da main/*/ tcb[id]->tid = 0; tcb[id]->state = 1; //Criada //TCBmain->context = context; tcb[id]->credCreate = 100; tcb[id]->credReal = 100; tcb[id]->next = NULL; tcb[id]->prev = NULL; //printf("Contexto da main construido.\n"); //*/Ajusta o TCB da main/*/ //getcontext(&context); //Salva o contexto da main //printf("Primeiro ID: %d\n", id); inicializada = 0; getcontext(&(tcb[id]->context)); //Salva o contexto da main //print_element(tcb[id]); //tcb[id]->context = context; printf("Contexto da main construido.\n"); } printf("Criando nova thread. "); //printf("Executando picreate na biblioteca. Creditos: %d\n", credCreate); id = id+1; printf("Incrementado ID.\n"); tcb[id] = (TCB_t *) malloc(sizeof(TCB_t)); //Aloca um novo TCB tcb[id]->tid = id; tcb[id]->state = 1; tcb[id]->credCreate = credCreate; tcb[id]->credReal = credCreate; //tcb[id]->context = context; tcb[(id-1)]->next = tcb[id]; tcb[id]->prev = tcb[id-1]; tcb[id]->next = NULL; //getcontext(&context); //Salva o contexto da main //getcontext(&(tcb[id]->context)); //thrcontext.uc_link = NULL; thrcontext.uc_link = &context; thrcontext.uc_stack.ss_sp = thr_stack; thrcontext.uc_stack.ss_size = sizeof(thr_stack); //printf("argumento = 0x%08x\n",*(int*)arg); //makecontext(&(tcb[id]->context), (void (*)(void)) start, 1, arg); //tcb[id]->context = thrcontext; //swapcontext(&context, &thrcontext); //setcontext(&thrcontext); //TCBmain->context = context; //setcontext(&context); //void dispatcher(); //printf("Saindo do create() com ID=%d\n", id); print_element(tcb[id]); return id; }
int print_array () { for (int i = 0; i < datalen; i ++) { print_element (i); printf (" "); } printf ("\n"); return 1; }
/* DCE code. Must scan the entire live-out data. Can be used also to check the correctness of the output. */ static void print_array(int nx, DATA_TYPE POLYBENCH_1D(y,NX,nx)) { int i; char *printmat = malloc(nx*16 + 1); printmat[nx*16] = 0; for (i = 0; i < nx; i++) print_element(y[i], i*16, printmat); fputs(printmat, stderr); free(printmat); }
/* DCE code. Must scan the entire live-out data. Can be used also to check the correctness of the output. */ static void print_array(int ni, int nj, DATA_TYPE POLYBENCH_2D(C,NI,NJ,ni,nj)) { int i, j; char *printmat = malloc(nj*8); for (i = 0; i < ni; i++) { for (j = 0; j < nj; j++) print_element(C[i][j], j*8, printmat); fputs(printmat, stderr); } free(printmat); }
gboolean gdata_parser_error_unhandled_element (xmlNode *element, GError **error) { gchar *element_string = print_element (element); /* Translators: the parameter is the name of an XML element, including the angle brackets ("<" and ">"). * * For example: * Unhandled <entry/yt:aspectRatio> element. */ g_set_error (error, GDATA_PARSER_ERROR, GDATA_PARSER_ERROR_UNHANDLED_XML_ELEMENT, _("Unhandled %s element."), element_string); g_free (element_string); return FALSE; }
/* DCE code. Must scan the entire live-out data. Can be used also to check the correctness of the output. */ static void print_array(int ni, DATA_TYPE POLYBENCH_2D(B,NI,NI,ni,ni)) { int i, j; char *printmat = malloc(ni*16 + 1); printmat[ni*16] = 0; for (i = 0; i < ni; i++) { for (j = 0; j < ni; j++) print_element(B[i][j], j*16, printmat); fputs(printmat, stderr); } free(printmat); }
gboolean gdata_parser_error_required_content_missing (xmlNode *element, GError **error) { gchar *element_string = print_element (element); /* Translators: the parameter is the name of an XML element, including the angle brackets ("<" and ">"). * * For example: * A <title> element was missing required content. */ g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR, _("A %s element was missing required content."), element_string); g_free (element_string); return FALSE; }
gboolean gdata_parser_error_duplicate_element (xmlNode *element, GError **error) { gchar *element_string = print_element (element); /* Translators: the parameter is the name of an XML element, including the angle brackets ("<" and ">"). * * For example: * A singleton element (<feed/title>) was duplicated. */ g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR, _("A singleton element (%s) was duplicated."), element_string); g_free (element_string); return FALSE; }
static void print_element (scew_element *element, unsigned int indent) { XML_Char const *contents = NULL; scew_list *list = NULL; if (element == NULL) { return; } /* Prints the starting element tag with its attributes. */ print_indent (indent); scew_printf (_XT("<%s"), scew_element_name (element)); print_attributes (element); scew_printf (_XT(">")); contents = scew_element_contents (element); if (contents == NULL) { scew_printf (_XT("\n")); } /** * Call print_element function again for each child of the current * element. */ list = scew_element_children (element); while (list != NULL) { scew_element *child = scew_list_data (list); print_element (child, indent + 1); list = scew_list_next (list); } /* Prints element's content. */ if (contents != NULL) { scew_printf (_XT("%s"), contents); } else { print_indent (indent); } /* Prints the closing element tag. */ scew_printf (_XT("</%s>\n"), scew_element_name (element)); }
/* DCE code. Must scan the entire live-out data. Can be used also to check the correctness of the output. */ static void print_array(int n, DATA_TYPE POLYBENCH_2D(A,N,N,n,n)) { int i, j; char *printmat = malloc(n*8); for (i = 0; i < n; i++) { for (j = 0; j < n; j++) print_element(A[i][j], j*8, printmat); fputs(printmat, stderr); } free(printmat); }
gboolean gdata_parser_error_not_iso8601_format (xmlNode *element, const gchar *actual_value, GError **error) { gchar *element_string = print_element (element); g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR, /* Translators: the first parameter is the name of an XML element (including the angle brackets ("<" and ">")), and the second parameter is * the erroneous value (which was not in ISO 8601 format). * * For example: * The content of a <media:group/media:uploaded> element ("2009-05-06 26:30Z") was not in ISO 8601 format. */ _("The content of a %s element (\"%s\") was not in ISO 8601 format."), element_string, actual_value); g_free (element_string); return FALSE; }
gboolean gdata_parser_error_unknown_content (xmlNode *element, const gchar *actual_content, GError **error) { gchar *element_string = print_element (element); g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR, /* Translators: the first parameter is the name of an XML element (including the angle brackets ("<" and ">")), * and the second parameter is the unknown content of that element. * * For example: * The content of a <gphoto:access> element ("protected") was unknown. */ _("The content of a %s element (\"%s\") was unknown."), element_string, actual_content); g_free (element_string); return FALSE; }
void * thread_it(void *p) { struct xmlsd_document *xd; struct xmlsd_element *xe; int f; char *b, *filename = (char *)p; struct stat sb; if (xmlsd_doc_alloc(&xd) != XMLSD_ERR_SUCCES) errx(1,"xmlsd_doc_alloc"); f = open(filename, O_RDONLY, 0); if (f == -1) err(1, "open"); if (fstat(f, &sb) == -1) err(1, "stat"); if (sb.st_size > XMLSD_MEM_MAXSIZE) errx(1, "file too big"); b = malloc(sb.st_size); if (b == NULL) err(1, "malloc"); memset(b, 0, sb.st_size); if (read(f, b, sb.st_size) != sb.st_size) err(1, "read"); if (xmlsd_parse_mem(b, sb.st_size, xd) != XMLSD_ERR_SUCCES) errx(1, "xmlsd_parse"); if (verbose) { if ((xe = xmlsd_doc_get_first_elem(xd)) != NULL) print_element(xe); } xmlsd_doc_free(xd); free(b); close(f); f = 0; pthread_mutex_lock(&mtx); completed++; pthread_mutex_unlock(&mtx); return (NULL); }
static void print_element(struct xmlsd_element *xe) { struct xmlsd_element *xc; struct xmlsd_attribute *xa; fprintf(stderr, "%d %s = %s (parent = %s)\n", xmlsd_elem_get_depth(xe), xmlsd_elem_get_name(xe), xmlsd_elem_get_value(xe) ? xmlsd_elem_get_value(xe) : "NOVAL", xmlsd_elem_get_parent(xe) ? xmlsd_elem_get_name(xmlsd_elem_get_parent(xe)) :"NOPARENT"); XMLSD_ELEM_FOREACH_ATTR(xa, xe) fprintf(stderr, "\t%s = %s\n", xmlsd_attr_get_name(xa), xmlsd_attr_get_value(xa)); XMLSD_ELEM_FOREACH_CHILDREN(xc, xe) print_element(xc); }
/* * fonction qui retourne un tableau d'entier trier en ordre décroissant. * @param tab un tableau de structure Element * @param size un entier représentant la taille de tab */ void get_tab_trier(struct Element tab[], int size) { int tableau_taille[size]; for(int i = 0; i<size; i++) tableau_taille[i] = tab[i].taille_element; tri_bulle(tableau_taille,size); for(int i = 0; i < size; i++) for(int j = 0; j < size; j++) { if(tableau_taille[i] == tab[j].taille_element && tab[i].file_path != NULL) { print_element(tableau_taille[i], tab[j].file_path); break; } } };
gboolean gdata_parser_error_unknown_property_value (xmlNode *element, const gchar *property_name, const gchar *actual_value, GError **error) { gchar *property_string, *element_string; property_string = g_strdup_printf ("@%s", property_name); element_string = print_element (element); g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR, /* Translators: the first parameter is the name of an XML property, the second is the name of an XML element * (including the angle brackets ("<" and ">")) to which the property belongs, and the third is the unknown value. * * For example: * The value of the @time property of a <media:group/media:thumbnail> element ("00:01:42.500") was unknown. */ _("The value of the %s property of a %s element (\"%s\") was unknown."), property_string, element_string, actual_value); g_free (property_string); g_free (element_string); return FALSE; }
gboolean gdata_parser_error_required_property_missing (xmlNode *element, const gchar *property_name, GError **error) { gchar *property_string, *element_string; property_string = g_strdup_printf ("@%s", property_name); element_string = print_element (element); g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR, /* Translators: the first parameter is the name of an XML element (including the angle brackets ("<" and ">")), * and the second is the name of an XML property which it should have contained. * * For example: * A required property of a <entry/gAcl:role> element (@value) was not present. */ _("A required property of a %s element (%s) was not present."), property_string, element_string); g_free (property_string); g_free (element_string); return FALSE; }
/** * @brief Print an XML element. */ void XmlWriter::print_element (std::string& xml, const XmlElement* value, const int indent_level) { // Prepare indention and opening tag. std::string in0 (indent_level * indent, ' '); xml += in0 + "<" + value->tag + print_attributes_list(value->attributes); // If it's an empty element, close it, and we are done. if (value->content.size() == 0) { xml += " />"; return; } // If the element only contains a single markup, don't add new lines. However, if it contains // more data, put each element in a new line. xml += ">"; if (value->content.size() == 1 && value->content[0]->is_markup()) { print_markup(xml, xml_value_to_markup(value->content[0].get())); } else { std::string in1 ((indent_level + 1) * indent, ' '); xml += "\n"; for (auto& v : value->content) { if (v->is_comment()) { xml += in1; print_comment(xml, xml_value_to_comment(v.get())); } else if (v->is_markup()) { xml += in1; print_markup(xml, xml_value_to_markup(v.get())); } else if (v->is_element()) { print_element(xml, xml_value_to_element(v.get()), indent_level + 1); } else { // there are no other cases assert(0); } xml += "\n"; } xml += in0; } xml += "</" + value->tag + ">"; }
static void ft_print_elems_in_columns(t_select *env) { t_dlst *tmp; unsigned int i; size_t e; i = 0; tmp = env->page.start_page_element; while (tmp && i < env->page.elems_per_page) { e = 0; while (tmp && e < env->page.columns_infos.column_nb) { ++e; print_element(env, (t_elem*)tmp->content); tmp = tmp->next; ++i; } if (i != env->page.elems_per_page && tmp) ft_bufferize(STDIN_FILENO, "\n", 0); } }
void print_tuple(struct tuple *s) { int i, n, flag = 0; if (logptr >= LOGBUFSIZE-128) return; logptr += sprintf(logbuf + logptr, "("); n = s->num_elts; assert(n); if (n > 10) { n = 10; flag = 1; } for (i = 0; i < n; i++) { if (i > 0) logptr += sprintf(logbuf + logptr, ", "); print_element(&s->elements[i]); } if (flag) { logptr += sprintf(logbuf + logptr, ".... "); } logptr += sprintf(logbuf + logptr, ")\n"); }
gboolean gdata_parser_error_mutexed_properties (xmlNode *element, const gchar *property1_name, const gchar *property2_name, GError **error) { gchar *property1_string, *property2_string, *element_string; property1_string = g_strdup_printf ("@%s", property1_name); property2_string = g_strdup_printf ("@%s", property2_name); element_string = print_element (element); g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR, /* Translators: the first two parameters are the names of XML properties of an XML element given in the third * parameter (including the angle brackets ("<" and ">")). * * For example: * Values were present for properties @rel and @label of a <entry/gContact:relation> element when only one of the * two is allowed. */ _("Values were present for properties %s and %s of a %s element when only one of the two is allowed."), property1_string, property2_string, element_string); g_free (property1_string); g_free (property2_string); g_free (element_string); return FALSE; }
static void bt_print_struct_node(bt* tree, bt_node* node, char* indent, void (*print_element)(void* val)) { printf("%s", indent); if (!isleaf(node)) { char* subind; char* addind = "|--"; printf("(bal %i)\n", node->branch.balance); subind = malloc(strlen(indent) + strlen(addind) + 1); sprintf(subind, "%s%s", indent, addind); bt_print_struct_node(tree, node->branch.children[0], subind, print_element); bt_print_struct_node(tree, node->branch.children[1], subind, print_element); } else { int i; printf("(leaf)"); if (print_element) { printf(" [ "); for (i=0; i<node_N(node); i++) print_element(get_element(tree, &node->leaf, i)); printf("]"); } printf("\n"); } }
/* * Main function. */ int main(int argc, char **argv) { uFlags = 0; progname = argv[0]; while (--argc > 0 && **(++argv) == '-') { while (*(++(*argv))) { switch (**argv) { case 'a': uFlags = (SYSNAME | NODENAME | RELEASE | ARCH | VERSION | MACHINE); break; case 'm': uFlags |= MACHINE; break; case 'n': uFlags |= NODENAME; break; case 'p': uFlags |= ARCH; break; case 'r': uFlags |= RELEASE; break; case 's': uFlags |= SYSNAME; break; case 'v': uFlags |= VERSION; break; default: usage(); } } } if (uFlags == 0) uFlags = SYSNAME; detectOpSysVersion(); detectHardware(); print_element(SYSNAME, sysname); print_element(NODENAME, nodename); print_element(RELEASE, release); print_element(VERSION, version); print_element(MACHINE, machine); print_element(ARCH, processor); exit(EXIT_SUCCESS); }
int main (int argc, char *argv[]) { scew_reader *reader = NULL; scew_parser *parser = NULL; scew_tree *tree = NULL; scew_writer *writer = NULL; scew_printer *printer = NULL; #if defined(_MSC_VER) && defined(XML_UNICODE_WCHAR_T) /* Change stdout to Unicode before writing anything. */ _setmode(_fileno(stdout), _O_U16TEXT); #endif /* _MSC_VER && XML_UNICODE_WCHAR_T */ if (argc < 2) { scew_printf (_XT("Usage: scew_print file.xml\n")); return EXIT_FAILURE; } /* Creates an SCEW parser. This is the first function to call. */ parser = scew_parser_create (); scew_parser_ignore_whitespaces (parser, SCEW_TRUE); /* Loads an XML file. */ reader = scew_reader_file_create (argv[1]); if (reader == NULL) { scew_error code = scew_error_code (); scew_printf (_XT("Unable to load file (error #%d: %s)\n"), code, scew_error_string (code)); return EXIT_FAILURE; } tree = scew_parser_load (parser, reader); if (tree == NULL) { scew_error code = scew_error_code (); scew_printf (_XT("Unable to parse file (error #%d: %s)\n"), code, scew_error_string (code)); if (code == scew_error_expat) { enum XML_Error expat_code = scew_error_expat_code (parser); scew_printf (_XT("Expat error #%d (line %d, column %d): %s\n"), expat_code, scew_error_expat_line (parser), scew_error_expat_column (parser), scew_error_expat_string (expat_code)); } /* Frees the SCEW parser and reader. */ scew_reader_free (reader); scew_parser_free (parser); return EXIT_FAILURE; } /* Prints full tree. */ scew_printf (_XT("\n*** Manual print:\n\n")); print_element (scew_tree_root (tree), 0); /* Prints full tree using SCEW writer. */ scew_printf (_XT("\n\n*** SCEW writer (stdout) print:\n\n")); writer = scew_writer_fp_create (stdout); printer = scew_printer_create (writer); scew_printer_print_tree (printer, tree); scew_printf (_XT("\n")); /* Remember to free tree (scew_parser_free does not free it). */ scew_tree_free (tree); /* Also free the printer and writer. */ scew_writer_free (writer); scew_printer_free (printer); /* Frees the SCEW parser and reader. */ scew_reader_free (reader); scew_parser_free (parser); return 0; }