static int parse_tile(xmlTextReaderPtr reader, tmx_tile **tile_headadr, const char *filename) { tmx_tile *res = NULL; int curr_depth; const char *name; char *value; curr_depth = xmlTextReaderDepth(reader); if (!(res = alloc_tile())) return 0; while (*tile_headadr) { tile_headadr = &((*tile_headadr)->next); } *tile_headadr = res; if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"id"))) { /* id */ res->id = atoi(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'id' attribute in the 'tile' element"); return 0; } do { if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */ if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) { name = (char*)xmlTextReaderConstName(reader); if (!strcmp(name, "properties")) { if (!parse_properties(reader, &(res->properties))) return 0; } else if (!strcmp(name, "image")) { if (!parse_image(reader, &(res->image), 0, filename)) return 0; } else { /* Unknow element, skip its tree */ if (xmlTextReaderNext(reader) != 1) return 0; } } } while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT || xmlTextReaderDepth(reader) != curr_depth); return 1; }
/* parses a tileset within the tmx file or in a dedicated tsx file */ static int parse_tileset_sub(xmlTextReaderPtr reader, tmx_tileset *ts_addr, const char *filename) { int curr_depth; const char *name; char *value; curr_depth = xmlTextReaderDepth(reader); /* parses each attribute */ if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */ ts_addr->name = value; } else { tmx_err(E_MISSEL, "xml parser: missing 'name' attribute in the 'tileset' element"); return 0; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tilewidth"))) { /* tile_width */ ts_addr->tile_width = atoi(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'tilewidth' attribute in the 'tileset' element"); return 0; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"tileheight"))) { /* tile_height */ ts_addr->tile_height = atoi(value); tmx_free_func(value); } else { tmx_err(E_MISSEL, "xml parser: missing 'tileheight' attribute in the 'tileset' element"); return 0; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"spacing"))) { /* spacing */ ts_addr->spacing = atoi(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"margin"))) { /* margin */ ts_addr->margin = atoi(value); tmx_free_func(value); } /* Parse each child */ do { if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */ if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) { name = (char*)xmlTextReaderConstName(reader); if (!strcmp(name, "image")) { if (!parse_image(reader, &(ts_addr->image), 1, filename)) return 0; } else if (!strcmp(name, "tileoffset")) { if (!parse_tileoffset(reader, &(ts_addr->x_offset), &(ts_addr->y_offset))) return 0; } else if (!strcmp(name, "properties")) { if (!parse_properties(reader, &(ts_addr->properties))) return 0; } else if (!strcmp(name, "tile")) { if (!parse_tile(reader, &(ts_addr->tiles), filename)) return 0; } else { /* Unknown element, skip its tree */ if (xmlTextReaderNext(reader) != 1) return 0; } } } while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT || xmlTextReaderDepth(reader) != curr_depth); return 1; }
/* parse layers and objectgroups */ static int parse_layer(xmlTextReaderPtr reader, tmx_layer **layer_headadr, int map_h, int map_w, enum tmx_layer_type type, const char *filename) { tmx_layer *res; tmx_object *obj; int curr_depth; const char *name; char *value; curr_depth = xmlTextReaderDepth(reader); if (!(res = alloc_layer())) return 0; res->type = type; while(*layer_headadr) { layer_headadr = &((*layer_headadr)->next); } *layer_headadr = res; /* parses each attribute */ if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"name"))) { /* name */ res->name = value; } else { tmx_err(E_MISSEL, "xml parser: missing 'name' attribute in the 'layer' element"); return 0; } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"visible"))) { /* visible */ res->visible = (char)atoi(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"opacity"))) { /* opacity */ res->opacity = (float)strtod(value, NULL); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"color"))) { /* color */ res->color = get_color_rgb(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"x"))) { /* x_offset */ res->x_offset = (int)atoi(value); tmx_free_func(value); } if ((value = (char*)xmlTextReaderGetAttribute(reader, (xmlChar*)"y"))) { /* y_offset */ res->y_offset = (int)atoi(value); tmx_free_func(value); } do { if (xmlTextReaderRead(reader) != 1) return 0; /* error_handler has been called */ if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT) { name = (char*)xmlTextReaderConstName(reader); if (!strcmp(name, "properties")) { if (!parse_properties(reader, &(res->properties))) return 0; } else if (!strcmp(name, "data")) { if (!parse_data(reader, &(res->content.gids), map_h * map_w)) return 0; } else if (!strcmp(name, "image")) { if (!parse_image(reader, &(res->content.image), 0, filename)) return 0; } else if (!strcmp(name, "object")) { if (!(obj = alloc_object())) return 0; obj->next = res->content.head; res->content.head = obj; if (!parse_object(reader, obj)) return 0; } else { /* Unknow element, skip its tree */ if (xmlTextReaderNext(reader) != 1) return 0; } } } while (xmlTextReaderNodeType(reader) != XML_READER_TYPE_END_ELEMENT || xmlTextReaderDepth(reader) != curr_depth); return 1; }
/** * @brief Parse gif from a file * * @param f file to parse from * * @return true on success */ bool Gif::parse(FILE * f) { /* * Read header */ if (fread(&m_header, kHeaderSize, 1, f) != 1) { err() << "Failed to read header!\n"; return false; } /* * Check correct GIF img */ if (! is_gif()) { err() << "Input file is not a GIF file!\n"; return false; } if (! is_gif89a()) { err() << "Unsupported GIF version!\n"; return false; } //if (! is_gif8bit()) { err() << "Not GIF 8bit!\n"; return false; } /* * Read color table */ if (has_global_color_table()) { struct color_item_t item; for (size_t i = 0; i < get_global_table_size(); ++i) { if (fread(&item.data, kColorTableSize, 1, f) != 1) { err() << "Failed to read global table!\n"; return false; } item.cc = item.eoi = false; global_color_table.push_back(item); } //dbg_global_color(); } /* * Check start byte. Note than *_extension() functions access data without * entry byte! */ int c; while ((c = fgetc(f)) != EOF) { switch (c) { case kExtensionStartByte: /* FALLTRHU*/ case kImageDescriptor: if (c != kImageDescriptor) c = fgetc(f); switch((c)) { case kExtensionComment: if (! parse_comment_extension(f)) return false; break; case kExtensionApplication: if (! parse_application_extension(f)) return false; break; case kExtensionGraphicControl: if (! parse_graphic_control_extension(f)) return false; break; case kImageDescriptor: /* FALLTRHU*/ case kExtensionPlainText: if (c == kImageDescriptor) { if (! parse_image(f)) return false; } else if (c == kExtensionPlainText) { if (! parse_plain_text_extension(f)) return false; } break; default: err() << "Unknown extension type '" << std::hex << (unsigned) c << "'!\n"; UNREACHABLE(); return false; } break; case kStopByte: if (fgetc(f) != EOF) { err() << "Stop byte is not last byte!\n"; return false; } break; default: err() << "Unknown start byte '" << std::hex << (unsigned) c << "', extension or EOF expected!\n"; return false; } } //dbg_imgs(); return true; }
static GList* feed_rss_handler_parse (FeedHandler *self, GrssFeedChannel *feed, xmlDocPtr doc, gboolean do_items, GError **error) { gchar *tmp; gboolean rdf; time_t now; GList *items; xmlNodePtr cur; GrssFeedItem *item; FeedRssHandler *parser; items = NULL; rdf = FALSE; now = time (NULL); parser = FEED_RSS_HANDLER (self); cur = xmlDocGetRootElement (doc); while (cur && xmlIsBlankNode (cur)) cur = cur->next; if (!xmlStrcmp (cur->name, BAD_CAST"rss")) { cur = cur->xmlChildrenNode; rdf = FALSE; } else if (!xmlStrcmp (cur->name, BAD_CAST"rdf") || !xmlStrcmp (cur->name, BAD_CAST"RDF")) { cur = cur->xmlChildrenNode; rdf = TRUE; } else if (!xmlStrcmp (cur->name, BAD_CAST"Channel")) { rdf = FALSE; } else { g_set_error (error, FEED_RSS_HANDLER_ERROR, FEED_RSS_HANDLER_PARSE_ERROR, "Could not find RDF/RSS header!"); return NULL; } while (cur && xmlIsBlankNode (cur)) cur = cur->next; while (cur) { if (!cur->name) { g_warning ("invalid XML: parser returns NULL value -> tag ignored!"); cur = cur->next; continue; } if ((!xmlStrcmp (cur->name, BAD_CAST"channel")) || (!xmlStrcmp (cur->name, BAD_CAST"Channel"))) { parse_channel (parser, feed, doc, cur); if (rdf == FALSE) cur = cur->xmlChildrenNode; break; } cur = cur->next; } /* For RDF (rss 0.9 or 1.0), cur now points to the item after the channel tag. */ /* For RSS, cur now points to the first item inside of the channel tag */ /* This ends up being the thing with the items, (and images/textinputs for RDF) */ /* parse channel contents */ while (cur) { if (cur->type != XML_ELEMENT_NODE || NULL == cur->name) { cur = cur->next; continue; } /* save link to channel image */ if ((!xmlStrcmp (cur->name, BAD_CAST"image"))) { if (NULL != (tmp = parse_image (cur))) { grss_feed_channel_set_image (feed, tmp); g_free (tmp); } } else if (do_items == TRUE && (!xmlStrcmp (cur->name, BAD_CAST"items"))) { /* RSS 1.1 */ xmlNodePtr iter = cur->xmlChildrenNode; while (iter) { item = parse_rss_item (parser, feed, doc, iter); if (item != NULL) { if (grss_feed_item_get_publish_time (item) == 0) grss_feed_item_set_publish_time (item, now); items = g_list_append (items, item); } iter = iter->next; } } else if (do_items == TRUE && (!xmlStrcmp (cur->name, BAD_CAST"item"))) { /* RSS 1.0, 2.0 */ item = parse_rss_item (parser, feed, doc, cur); if (item != NULL) { if (grss_feed_item_get_publish_time (item) == 0) grss_feed_item_set_publish_time (item, now); items = g_list_append (items, item); } } cur = cur->next; } grss_feed_channel_set_format (feed, "application/rss+xml"); if (items != NULL) items = g_list_reverse (items); return items; }
int main(int argc, char *argv[]) { FILE *fp; struct disk_side *sides, *curr_side; struct disk_track *curr_track; struct disk_sector *curr_sector; DSK_GEOMETRY geom; DSK_PDRIVER newdisk; DSK_FORMAT *format; dsk_err_t err; int i; char *secdata; if (argc != 3) { fprintf(stderr, "usage: %s infile outfile\n", argv[0]); exit(1); } fp = fopen(argv[1], "r"); if (fp == NULL) { fprintf(stderr, "unable to open file: %s\n", argv[1]); exit(1); } sides = parse_image(fp); memset(&geom, 0, sizeof(DSK_GEOMETRY)); geom.dg_cylinders = max_tracks; geom.dg_heads = max_sides; geom.dg_sectors = max_sectors; geom.dg_secbase = 1; /* perhaps this should be determined from file? */ geom.dg_secsize = sector_size; format = malloc(geom.dg_sectors*sizeof(DSK_FORMAT)); secdata = malloc(geom.dg_secsize); if ((format == NULL) || (secdata == NULL)) { fprintf(stderr, "main: out of memory\n"); exit(1); } if (dsk_creat(&newdisk, argv[2], "dsk", NULL) != DSK_ERR_OK) { fprintf(stderr, "main: error in dsk_creat\n"); exit(1); } for (i=0; i<max_sides; i++) if (dsk_apform(newdisk, &geom, 0, i, 0xE5) != DSK_ERR_OK) { fprintf(stderr, "main: error formatting inital cylinder\n"); exit(1); } curr_side = sides; while (curr_side != NULL) { /* printf("Side = %i\n", curr_side->id); */ curr_track = curr_side->tracks; while (curr_track != NULL) { /*printf(" Track = %i\n", curr_track->id); */ curr_sector = curr_track->sectors; i = 0; while (curr_sector != NULL) { /* printf(" Sector = %i\n", curr_sector->id);*/ format[i].fmt_cylinder = curr_sector->logical_track; format[i].fmt_head = curr_sector->logical_side; format[i].fmt_sector = curr_sector->id; format[i].fmt_secsize = curr_sector->length; curr_sector = curr_sector->next; i++; } if ((err = dsk_pformat(newdisk, &geom, curr_track->id, curr_side->id, format, 0xE5)) != DSK_ERR_OK) { fprintf(stderr, "main: error in dsk_pformat(%i)\n", err); exit(1); } curr_sector = curr_track->sectors; while (curr_sector != NULL) { fseek(fp, curr_sector->ofs, SEEK_SET); if (fread(secdata, 1, curr_sector->length, fp) != curr_sector->length) { fprintf(stderr, "main: error reading input file sector\n"); exit(1); } if ((err = dsk_xwrite(newdisk, &geom, secdata, curr_track->id, curr_side->id, curr_sector->logical_track, curr_sector->logical_side, curr_sector->id, curr_sector->length, 0)) != DSK_ERR_OK) { fprintf(stderr, "main: error in dsk_pwrite (%i, sec=%i, side=%i, track=%i) \n", err, curr_sector->id, curr_sector->logical_side, curr_sector->logical_track); exit(1); } curr_sector = curr_sector->next; } curr_track = curr_track->next; } curr_side = curr_side->next; } printf("Sides: %2i Tracks: %2i Sectors: %2i\n", max_sides, max_tracks, max_sectors); dsk_close(&newdisk); fclose(fp); return 0; }
std::string load_shader_impl(ShaderInitializationParams& params, const std::vector<std::string>& data, const std::string& tag, LoadContext& load_context) { std::string actual_data; enum { state_not_found, state_found, state_incorrect_found }; int state = state_not_found; for (size_t i = 0; i < data.size(); ++i) { const std::string& s = utils::trim_copy(data[i]); if (s.find(include_tag) != std::string::npos) { ++load_context.level; actual_data += parse_include(params, s, tag, load_context); --load_context.level; continue; } if (s.find(defs_tag) != std::string::npos) continue; if (s.find(sampler_tag) != std::string::npos) { actual_data += parse_sampler(params, s); continue; } if (s.find(uniform_tag) != std::string::npos) { actual_data += parse_uniform(params, s); continue; } if (s.find(image_tag) != std::string::npos) { actual_data += parse_image(params, s); continue; } if (s.find(var_tag) != std::string::npos) { actual_data += parse_variable(params, s); continue; } if (s.find(version_tag) != std::string::npos) { actual_data += parse_version(params, s); continue; } if (s == tag) state = state_found; else { for (size_t j = 0; j < 4; ++j) { if (s == tags[j]) { if (state == state_found) return actual_data; else state = state_incorrect_found; break; } } if (state != state_incorrect_found) actual_data += (s + "\n"); } } if (state == state_found) load_context.tag_found = true; if (!load_context.tag_found && load_context.level == 0) actual_data.clear(); return actual_data; }
int main(int argc, char **argv) { int c, opt; char *cwd; struct stat sb; FILE *devtable = NULL; struct filesystem_entry *root; char *compr_name = NULL; int compr_prior = -1; jffs2_compressors_init(); while ((opt = getopt_long(argc, argv, "D:d:r:s:o:qUPfh?vVe:lbp::nc:m:x:X:Lty:i:", long_options, &c)) >= 0) { switch (opt) { case 'D': devtable = xfopen(optarg, "r"); if (fstat(fileno(devtable), &sb) < 0) perror_msg_and_die(optarg); if (sb.st_size < 10) error_msg_and_die("%s: not a proper device table file", optarg); break; case 'r': case 'd': /* for compatibility with mkfs.jffs, genext2fs, etc... */ if (rootdir != default_rootdir) { error_msg_and_die("root directory specified more than once"); } rootdir = xstrdup(optarg); break; case 's': page_size = strtol(optarg, NULL, 0); break; case 'o': if (out_fd != -1) { error_msg_and_die("output filename specified more than once"); } out_fd = open(optarg, O_CREAT | O_TRUNC | O_RDWR, 0644); if (out_fd == -1) { perror_msg_and_die("open output file"); } break; case 'q': squash_uids = 1; squash_perms = 1; break; case 'U': squash_uids = 1; break; case 'P': squash_perms = 1; break; case 'f': fake_times = 1; break; case 'h': case '?': error_msg_and_die(helptext); case 'v': verbose = 1; break; case 'V': error_msg_and_die("revision %.*s\n", (int) strlen(revtext) - 13, revtext + 11); case 'e': { char *next; unsigned units = 0; erase_block_size = strtol(optarg, &next, 0); if (!erase_block_size) error_msg_and_die("Unrecognisable erase size\n"); if (*next) { if (!strcmp(next, "KiB")) { units = 1024; } else if (!strcmp(next, "MiB")) { units = 1024 * 1024; } else { error_msg_and_die("Unknown units in erasesize\n"); } } else { if (erase_block_size < 0x1000) units = 1024; else units = 1; } erase_block_size *= units; /* If it's less than 8KiB, they're not allowed */ if (erase_block_size < 0x2000) { fprintf(stderr, "Erase size 0x%x too small. Increasing to 8KiB minimum\n", erase_block_size); erase_block_size = 0x2000; } break; } case 'l': target_endian = __LITTLE_ENDIAN; break; case 'b': target_endian = __BIG_ENDIAN; break; case 'p': if (optarg) pad_fs_size = strtol(optarg, NULL, 0); else pad_fs_size = -1; break; case 'n': add_cleanmarkers = 0; break; case 'c': cleanmarker_size = strtol(optarg, NULL, 0); if (cleanmarker_size < sizeof(cleanmarker)) { error_msg_and_die("cleanmarker size must be >= 12"); } if (cleanmarker_size >= erase_block_size) { error_msg_and_die("cleanmarker size must be < eraseblock size"); } break; case 'm': if (jffs2_set_compression_mode_name(optarg)) { error_msg_and_die("Unknown compression mode %s", optarg); } break; case 'x': if (jffs2_disable_compressor_name(optarg)) { error_msg_and_die("Unknown compressor name %s",optarg); } break; case 'X': if (jffs2_enable_compressor_name(optarg)) { error_msg_and_die("Unknown compressor name %s",optarg); } break; case 'L': error_msg_and_die("\n%s",jffs2_list_compressors()); break; case 't': jffs2_compression_check_set(1); break; case 'y': compr_name = malloc(strlen(optarg)); sscanf(optarg,"%d:%s",&compr_prior,compr_name); if ((compr_prior>=0)&&(compr_name)) { if (jffs2_set_compressor_priority(compr_name, compr_prior)) exit(EXIT_FAILURE); } else { error_msg_and_die("Cannot parse %s",optarg); } free(compr_name); break; case 'i': if (in_fd != -1) { error_msg_and_die("(incremental) filename specified more than once"); } in_fd = open(optarg, O_RDONLY); if (in_fd == -1) { perror_msg_and_die("cannot open (incremental) file"); } break; case 1000: /* --with-xattr */ enable_xattr |= (1 << JFFS2_XPREFIX_USER) | (1 << JFFS2_XPREFIX_SECURITY) | (1 << JFFS2_XPREFIX_ACL_ACCESS) | (1 << JFFS2_XPREFIX_ACL_DEFAULT) | (1 << JFFS2_XPREFIX_TRUSTED); break; case 1001: /* --with-selinux */ enable_xattr |= (1 << JFFS2_XPREFIX_SECURITY); break; case 1002: /* --with-posix-acl */ enable_xattr |= (1 << JFFS2_XPREFIX_ACL_ACCESS) | (1 << JFFS2_XPREFIX_ACL_DEFAULT); break; } } if (out_fd == -1) { if (isatty(1)) { error_msg_and_die(helptext); } out_fd = 1; } if (lstat(rootdir, &sb)) { perror_msg_and_die("%s", rootdir); } if (chdir(rootdir)) perror_msg_and_die("%s", rootdir); if (!(cwd = getcwd(0, GETCWD_SIZE))) perror_msg_and_die("getcwd failed"); if(in_fd != -1) parse_image(); root = recursive_add_host_directory(NULL, "/", cwd); if (devtable) parse_device_table(root, devtable); create_target_filesystem(root); cleanup(root); if (rootdir != default_rootdir) free(rootdir); close(out_fd); if (verbose) { char *s = jffs2_stats(); fprintf(stderr,"\n\n%s",s); free(s); } if ((verbose)||(jffs2_compression_check_get()&&(jffs2_compression_check_errorcnt_get()))) { fprintf(stderr,"Compression errors: %d\n",jffs2_compression_check_errorcnt_get()); } jffs2_compressors_exit(); return 0; }