ALPS_DECL params make_parameters_from_xml(boost::filesystem::path const & arg) {
Parameters par;
boost::filesystem::ifstream infile(arg.string());
// read outermost tag (e.g. <SIMULATION>)
XMLTag tag = parse_tag(infile, true);
std::string closingtag = "/" + tag.name;
// scan for <PARAMETERS> and read them
tag = parse_tag(infile, true);
while (tag.name != "PARAMETERS" && tag.name != closingtag) {
std::cerr << "skipping tag with name " << tag.name << "\n";
skip_element(infile, tag);
tag = parse_tag(infile, true);
}
par.read_xml(tag, infile, true);
if (!par.defined("SEED"))
par["SEED"] = 0;
params res;
for (Parameters::const_iterator it = par.begin(); it != par.end(); ++it)
res[it->key()] = it->value();
return res;
}
static int replace_name(struct commit_name *e,
int prio,
const unsigned char *sha1,
struct tag **tag)
{
if (!e || e->prio < prio)
return 1;
if (e->prio == 2 && prio == 2) {
/* Multiple annotated tags point to the same commit.
* Select one to keep based upon their tagger date.
*/
struct tag *t;
if (!e->tag) {
t = lookup_tag(e->sha1);
if (!t || parse_tag(t))
return 1;
e->tag = t;
}
t = lookup_tag(sha1);
if (!t || parse_tag(t))
return 0;
*tag = t;
if (e->tag->date < t->date)
return 1;
}
return 0;
}
static gboolean
xmms_html_browse (xmms_xform_t *xform, const gchar *url,
xmms_error_t *error)
{
gchar buffer[XMMS_XFORM_MAX_LINE_SIZE];
const gchar *plsurl;
gchar *tagbeg, *aurl, *full;
xmms_error_reset (error);
plsurl = xmms_xform_get_url (xform);
while (xmms_xform_read_line (xform, buffer, error)) {
tagbeg = buffer;
while ((tagbeg = strchr (tagbeg, '<'))) {
if ((aurl = parse_tag (++tagbeg, plsurl))) {
full = xmms_build_playlist_url (plsurl,
aurl);
xmms_xform_browse_add_symlink (xform,
NULL, full);
g_free (full);
g_free (aurl);
}
}
}
return TRUE;
}
Section* Parser::parse_section(){
if(!maybe_char(OPEN_SECTION)){
return NULL;
}
SafePointer<Section> section(new Section());
//These aren't safe pointers because the moment they have a value,
//they're immediately handed to another owner.
Text* text;
Tag* tag;
do{
if(text=parse_section_text()){
section->add(text);
}
if(tag=parse_tag()){
section->add(tag);
}
}while(text or tag);
if(!maybe_char(CLOSE_SECTION)){
if(it==end){
throw ParseError(SECTION_EOF,line,col);
}
throw ParseError(EXPECTED_CLOSE_SECTION,line,col);
}
return section.yield();
}
bool class_source_parser::parse_tag(){
while (!f_.eof()){
std::string line;
if (! getline(line) ) { return false; }
if (check_valid(line)) {
if (check_tag_begin(line)){
parse_tag();
}
if (check_tag_end(line)){
return true;
}
if (check_keys_begin(line)){
parse_keys();
}
if (check_allow_link(line)){
continue;
}
if (check_allow_global(line)){
continue;
}
if (check_remove_key(line)){
}
}else{
if (!current_.empty()){
// adding error messages for each unclosed entity
add_open_tag_error();
close_opened_tags();
}
return true;
}
}
return true;
}
bool class_source_parser::parse_block(){
while (!f_.eof()){
std::string line;
if (! getline(line) ) { return false; }
if ( check_valid(line)) {
if (check_allow_type(line)) continue;
if (check_remove_type(line)) continue;
if (check_parent_begin(line)) continue;
if (check_tag_begin(line)){
parse_tag();
continue;
}
check_parent_end(line);
}
else{
// wiki-block is closed. checking stack of opened tags
if (!current_.empty()){
add_open_tag_error();
close_opened_tags();
// continue working
}
// block is closed and all tags are closed.
return true;
}
}// end while
return false;
}
xml::Tag read_tag(std::istream& stream) {
std::string line;
std::getline(stream, line);
xml::Tag st;
CHECK(parse_tag(line, &st));
return st;
}
struct object *parse_object(unsigned char *sha1)
{
unsigned long mapsize;
void *map = map_sha1_file(sha1, &mapsize);
if (map) {
char type[100];
unsigned long size;
void *buffer = unpack_sha1_file(map, mapsize, type, &size);
if (!buffer)
return NULL;
if (check_sha1_signature(sha1, buffer, size, type) < 0)
printf("sha1 mismatch %s\n", sha1_to_hex(sha1));
munmap(map, mapsize);
if (!strcmp(type, "blob")) {
struct blob *ret = lookup_blob(sha1);
parse_blob(ret);
return &ret->object;
} else if (!strcmp(type, "tree")) {
struct tree *ret = lookup_tree(sha1);
parse_tree(ret);
return &ret->object;
} else if (!strcmp(type, "commit")) {
struct commit *ret = lookup_commit(sha1);
parse_commit(ret);
return &ret->object;
} else if (!strcmp(type, "tag")) {
struct tag *ret = lookup_tag(sha1);
parse_tag(ret);
return &ret->object;
} else {
return NULL;
}
}
return NULL;
}
/*
* Parse all tags in the list, checking both the global and architecture
* specific tag tables.
*/
static void __init parse_tags(const struct tag *t)
{
for (; t->hdr.size; t = tag_next(t))
if (!parse_tag(t))
pr_warn("Ignoring unrecognised tag 0x%08x\n",
t->hdr.tag);
}
/*
** parse_hsc
**
** parse input chars with full hsc support
**
** params: inpf...input file
**
** result: TRUE, if no error
*/
BOOL parse_hsc( INFILE *inpf )
{
if ( !fatal_error ) {
char *nxtwd;
nxtwd = infgetw( inpf );
if ( nxtwd ) {
if ( !strcmp(nxtwd, "<") ) /* parse tag */
parse_tag( inpf );
else if ( !strcmp(nxtwd, "&") ) /* parse entity */
parse_amp( inpf );
else { /* handle text */
if ( !strcmp(nxtwd, ">") ) { /* unmatched ">"? */
message( ERROR_UNMA_GT, inpf ); /* Y->error message */
errstr( "unmatched \">\"\n" );
}
outstr( infgetcws( inpf ) ); /* output word */
if (!infeof(inpf))
outstr( infgetcw( inpf ) );
}
}
}
return (BOOL)( !fatal_error );
}
static int parse_format(const char *format, va_list *args)
{
int count;
char c;
char *ptr;
int tag_length;
ptr = (char *)format;
count = 0;
while (*ptr)
{
c = *ptr++;
if (c == '%')
{
if ((tag_length = parse_tag(&ptr, args)) == -1)
return (-1);
count += tag_length;
}
else
{
count++;
ft_putchar(c);
}
}
return (count);
}
/*
* Parse a single line of data, and return a newly allocated dev struct.
* Add the new device to the cache struct, if one was read.
*
* Lines are of the form <device [TAG="value" ...]>/dev/foo</device>
*
* Returns -ve value on error.
* Returns 0 otherwise.
* If a valid device was read, *dev_p is non-NULL, otherwise it is NULL
* (e.g. comment lines, unknown XML content, etc).
*/
static int blkid_parse_line(blkid_cache cache, blkid_dev *dev_p, char *cp)
{
blkid_dev dev;
int ret;
if (!cache || !dev_p)
return -BLKID_ERR_PARAM;
*dev_p = NULL;
DBG(READ, ul_debug("line: %s", cp));
if ((ret = parse_dev(cache, dev_p, &cp)) <= 0)
return ret;
dev = *dev_p;
while ((ret = parse_tag(cache, dev, &cp)) > 0) {
;
}
if (dev->bid_type == NULL) {
DBG(READ, ul_debug("blkid: device %s has no TYPE",dev->bid_name));
blkid_free_dev(dev);
goto done;
}
done:
return ret;
}
int
map_collect_data_osm(FILE *in, struct maptool_osm *osm)
{
int size=BUFFER_SIZE;
char buffer[BUFFER_SIZE];
char *p;
sig_alrm(0);
if (!fgets(buffer, size, in) || !xml_declaration_in_line(buffer)){
fprintf(stderr,"FATAL: First line does not start with XML declaration;\n"
"this does not look like a valid OSM file.\n");
exit(EXIT_FAILURE);
}
while (fgets(buffer, size, in)) {
p=strchr(buffer,'<');
if (! p) {
fprintf(stderr,"FATAL: wrong line in input data (does not start with '<'): %s\n", buffer);
fprintf(stderr,"This does not look like a valid OSM file.\n"
"Note that maptool can only process OSM files without wrapped or empty lines.\n");
exit(EXIT_FAILURE);
}
if (!strncmp(p, "<osm ",5)) {
} else if (!strncmp(p, "<bound ",7)) {
} else if (!strncmp(p, "<node ",6)) {
if (!parse_node(p))
fprintf(stderr,"WARNING: failed to parse %s\n", buffer);
processed_nodes++;
} else if (!strncmp(p, "<tag ",5)) {
if (!parse_tag(p))
fprintf(stderr,"WARNING: failed to parse %s\n", buffer);
} else if (!strncmp(p, "<way ",5)) {
if (!parse_way(p))
fprintf(stderr,"WARNING: failed to parse %s\n", buffer);
processed_ways++;
} else if (!strncmp(p, "<nd ",4)) {
if (!parse_nd(p))
fprintf(stderr,"WARNING: failed to parse %s\n", buffer);
} else if (!strncmp(p, "<relation ",10)) {
if (!parse_relation(p))
fprintf(stderr,"WARNING: failed to parse %s\n", buffer);
processed_relations++;
} else if (!strncmp(p, "<member ",8)) {
if (!parse_member(p))
fprintf(stderr,"WARNING: failed to parse %s\n", buffer);
} else if (!strncmp(p, "</node>",7)) {
osm_end_node(osm);
} else if (!strncmp(p, "</way>",6)) {
osm_end_way(osm);
} else if (!strncmp(p, "</relation>",11)) {
osm_end_relation(osm);
} else if (!strncmp(p, "</osm>",6)) {
} else {
fprintf(stderr,"WARNING: unknown tag in %s\n", buffer);
}
}
sig_alrm(0);
sig_alrm_end();
return 1;
}
enum html_tag
html_parse_tag(const struct array *tag)
{
if (tag && tag->data) {
return parse_tag(*tag);
} else {
return HTML_TAG_UNKNOWN;
}
}
static const char *parse_field(struct buffer *self, int tag)
{
if (parse_tag(self) != tag) {
next_tag(self);
return NULL;
}
return parse_value(self);
}
static int fsck_walk_tag(struct tag *tag, void *data, struct fsck_options *options)
{
char *name = get_object_name(options, &tag->object);
if (parse_tag(tag))
return -1;
if (name)
put_object_name(options, tag->tagged, "%s", name);
return options->walk(tag->tagged, OBJ_ANY, data, options);
}
static void
html_render_tag(struct render_context *ctx, const struct array tag)
{
if (tag.size > 0) {
ctx->closing = html_tag_is_closing(&tag);
html_output_tag(ctx->output, tag);
if (HTML_TAG_PRE == parse_tag(tag)) {
ctx->preformatted = !ctx->closing;
}
}
}
static const char *parse_field_promisc(struct buffer *self, int *tag)
{
*tag = parse_tag(self);
if (!(*tag)) {
next_tag(self);
return NULL;
}
return parse_value(self);
}
/* astreich, 06/17 */
Parameters Task::parse_ext_task_file(std::string infilename)
{
Parameters res;
boost::filesystem::ifstream infile(infilename);
// read outermost tag (e.g. <SIMULATION>)
XMLTag tag=parse_tag(infile,true);
std::string closingtag = "/"+tag.name;
// scan for <PARAMETERS> and read them
tag=parse_tag(infile,true);
while (tag.name!="PARAMETERS" && tag.name != closingtag) {
std::cerr << "skipping tag with name " << tag.name << "\n";
skip_element(infile,tag);
tag=parse_tag(infile,true);
}
res.read_xml(tag,infile,true);
if (!res.defined("SEED"))
res["SEED"]=0;
return res;
}
Flake* Parser::parse_value(){
Flake* f;
if(f=parse_text()){
return f;
}
if(f=parse_tag()){
return f;
}
if(f=parse_section()){
return f;
}
//Error checking
/*
Snow errors are very predictable, so check for common
mistakes. By this point, we know the next character is
one of the quote characters, ], }, whitespace, a control
character, or EOF (if not, something is HORRIBLY wrong)
*/
if(it==end){
throw ParseError(TAG_EOF,line,col);
}
char c=*it;
if(c==CLOSE_SECTION){
throw ParseError(UNEXPECTED_CLOSE_SECTION,line,col-1);
}
if(c==CLOSE_TAG){
throw ParseError(UNNAMED_ATTR,colonline,coloncol);
}
if(c==NAMED_ATTR){
throw ParseError(ILLEGAL_NAMED,line,col-1);
}
if(isspace(c)){
//This should NEVER happen. Guarantees a problem with the parser.
throw ParseError(UNEXPECTED_SPACE,line,col);
}
//Reserved for cosmic ray errors
throw ParseError(COSMIC_RAY_ERR,line,col);
}
static void display_name(struct commit_name *n)
{
if (n->prio == 2 && !n->tag) {
n->tag = lookup_tag(n->sha1);
if (!n->tag || parse_tag(n->tag) || !n->tag->tag)
die("annotated tag %s not available", n->path);
if (strcmp(n->tag->tag, n->path))
warning("tag '%s' is really '%s' here", n->tag->tag, n->path);
}
if (n->tag)
printf("%s", n->tag->tag);
else
printf("%s", n->path);
}
static int parse_field_promisc(struct buffer *self, int *tag, const char **value)
{
int ret;
ret = parse_tag(self, tag);
if (ret)
goto fail;
return parse_value(self, value);
fail:
next_tag(self);
return ret;
}
void cgit_print_tag(char *revname)
{
unsigned char sha1[20];
struct object *obj;
struct tag *tag;
struct taginfo *info;
if (get_sha1(revname, sha1)) {
cgit_print_error(fmt("Bad tag reference: %s", revname));
return;
}
obj = parse_object(sha1);
if (!obj) {
cgit_print_error(fmt("Bad object id: %s", sha1_to_hex(sha1)));
return;
}
if (obj->type == OBJ_TAG) {
tag = lookup_tag(sha1);
if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) {
cgit_print_error(fmt("Bad tag object: %s", revname));
return;
}
html("<table class='commit-info'>\n");
htmlf("<tr><td>Tag name</td><td>%s (%s)</td></tr>\n",
revname, sha1_to_hex(sha1));
if (info->tagger_date > 0) {
html("<tr><td>Tag date</td><td>");
cgit_print_date(info->tagger_date, FMT_LONGDATE, ctx.cfg.local_time);
html("</td></tr>\n");
}
if (info->tagger) {
html("<tr><td>Tagged by</td><td>");
html_txt(info->tagger);
if (info->tagger_email) {
html(" ");
html_txt(info->tagger_email);
}
html("</td></tr>\n");
}
html("<tr><td>Tagged object</td><td>");
cgit_object_link(tag->tagged);
html("</td></tr>\n");
html("</table>\n");
print_tag_content(info->msg);
}
return;
}
void ff_id3v1_read(AVFormatContext *s)
{
int ret, filesize;
uint8_t buf[ID3v1_TAG_SIZE];
if (!url_is_streamed(s->pb)) {
/* XXX: change that */
filesize = url_fsize(s->pb);
if (filesize > 128) {
avio_seek(s->pb, filesize - 128, SEEK_SET);
ret = avio_read(s->pb, buf, ID3v1_TAG_SIZE);
if (ret == ID3v1_TAG_SIZE) {
parse_tag(s, buf);
}
avio_seek(s->pb, 0, SEEK_SET);
}
}
}
void ff_id3v1_read(AVFormatContext *s)
{
int ret;
uint8_t buf[ID3v1_TAG_SIZE];
int64_t filesize, position = avio_tell(s->pb);
if (s->pb->seekable) {
/* XXX: change that */
filesize = avio_size(s->pb);
if (filesize > 128) {
avio_seek(s->pb, filesize - 128, SEEK_SET);
ret = avio_read(s->pb, buf, ID3v1_TAG_SIZE);
if (ret == ID3v1_TAG_SIZE) {
parse_tag(s, buf);
}
avio_seek(s->pb, position, SEEK_SET);
}
}
}
static int parse_field(struct buffer *self, int tag, const char **value)
{
int ptag, ret;
ret = parse_tag(self, &ptag);
if (ret)
goto fail;
else if (ptag != tag) {
ret = FIX_MSG_STATE_GARBLED;
goto fail;
}
return parse_value(self, value);
fail:
next_tag(self);
return ret;
}
static void display_name(struct commit_name *n)
{
if (n->prio == 2 && !n->tag) {
n->tag = lookup_tag(n->sha1);
if (!n->tag || parse_tag(n->tag))
die(_("annotated tag %s not available"), n->path);
}
if (n->tag && !n->name_checked) {
if (!n->tag->tag)
die(_("annotated tag %s has no embedded name"), n->path);
if (strcmp(n->tag->tag, all ? n->path + 5 : n->path))
warning(_("tag '%s' is really '%s' here"), n->tag->tag, n->path);
n->name_checked = 1;
}
if (n->tag)
printf("%s", n->tag->tag);
else
printf("%s", n->path);
}
static GHashTable *
parse_tags (const xmlNode *tag_child)
{
GHashTable *tags;
const xmlNode *cur_node;
tags = g_hash_table_new (g_str_hash, g_str_equal);
for (cur_node = tag_child; cur_node; cur_node = cur_node->next)
{
/* skip non-element nodes */
if (cur_node->type != XML_ELEMENT_NODE)
continue;
if (g_str_equal (cur_node->name, "tag"))
parse_tag (cur_node->properties, tags);
}
return tags;
}
// Parse an item description (name, tags, child items, ...)
golem_item *parse_item(golem_tokenizer *tokenizer) {
log("> parse item [%d]\n", tokenizer->token);
golem_item *item = new_item(NULL), *child, *children;
golem_tag *tag;
int token;
for (;;) {
token = tokenizer->token;
switch (token) {
case token_name:
append_to_item_name(item, get_token_string(tokenizer));
break;
case '+':
case '-':
tag = parse_tag(tokenizer);
tag_item(item, tag);
break;
case '[':
token = get_token(tokenizer);
children = parse_item_children(tokenizer, item);
for (child = item->first_child; child && child->next_sibling;
child = child->next_sibling);
if (child) {
child->next_sibling = children;
} else {
item->first_child = children;
}
break;
case ',':
case ';':
case ':':
case '.':
case ']':
log("< parsed item “%s” [%d]\n", item->name, tokenizer->token);
return item;
default:
die("parse item: expected name, tag, children or rule separator.");
}
token = get_token(tokenizer);
}
die("parse item: unfinished item");
}
/*----------------------------------------------------------------------------*/
static int
task_is_add(tres_res_t *task, const char *str)
{
tres_is_t *is;
is = memb_alloc(&is_mem);
if(is == NULL) {
return ERR_IS_NONE_FREE;
}
str = parse_url(str, is->addr, is->path, TRES_PATH_LEN_MAX);
if(str == NULL) {
memb_free(&is_mem, is);
return ERR_IS_INVALID_URL;
}
str = parse_tag(is->tag, str, TRES_TAG_MAX_LEN);
if(str == NULL) {
memb_free(&is_mem, is);
return ERR_IS_INVALID_TAG;
}
PRINTF("TAG: %s\n", is->tag);
list_add(task->is_list, is);
return ERR_NONE;
}
