/* Parses command line switches, updates *argc, *argv to point first remaining
* argument. */
static bool parse_opts(int *argc, char ***argv)
{
char *argv0 = (*argv)[0];
char *argv0slash = strrchr(argv0, '/');
if (argv0slash != NULL)
argv0 = argv0slash + 1;
bool ok = true;
while (ok)
{
switch (getopt(*argc, *argv, "+hRCDo:aS:qckn:zZdTs:t:b:p:f:"))
{
case 'h': usage(argv0); exit(0);
case 'R': matlab_format = false; break;
case 'C': continuous_capture = true; break;
case 'D': continuous_capture = true;
decimated_capture = true; break;
case 'o': output_filename = optarg; break;
case 'a': all_data = true; break;
case 'S': server_name = optarg; break;
case 'q': show_progress = false; break;
case 'c': request_contiguous = true; break;
case 'k': squeeze_matlab = false; break;
case 'n': data_name = optarg; break;
case 'z': check_id0 = true; break;
case 'Z': offset_matlab_times = false; break;
case 'd': subtract_day_zero = true; break;
case 'T': save_id0 = true; break;
case 's': ok = parse_start(parse_datetime, optarg); break;
case 't': ok = parse_start(parse_today, optarg); break;
case 'b': ok = parse_start(parse_before, optarg); break;
case 'p':
ok = DO_PARSE("server port", parse_int, optarg, &port);
break;
case 'f':
ok = DO_PARSE("data format",
parse_data_format, optarg, &data_format);
break;
default:
fprintf(stderr, "Try `capture -h` for usage\n");
return false;
case -1:
*argc -= optind;
*argv += optind;
return true;
}
}
return false;
}
/***********************************************************************//**
* @brief Segment constructor
*
* @param[in] segment XML segment.
*
* Constructs a XML element from a text @p segment. The text segment is
* parsed and the element name and attributes are extracted using the
* parse_start() method.
***************************************************************************/
GXmlElement::GXmlElement(const std::string& segment) : GXmlNode()
{
// Initialise members
init_members();
// Parse start element
parse_start(segment);
// Return
return;
}
/*
* Allocate a new device struct with device name filled in. Will handle
* finding the device on lines of the form:
* <device foo=bar>devname</device>
* <device>devname<foo>bar</foo></device>
*/
static int parse_dev(blkid_cache cache, blkid_dev *dev, char **cp)
{
char *start, *tmp, *end, *name;
int ret;
if ((ret = parse_start(cp)) <= 0)
return ret;
start = tmp = strchr(*cp, '>');
if (!start) {
DBG(READ, ul_debug("blkid: short line parsing dev: %s", *cp));
return -BLKID_ERR_CACHE;
}
start = skip_over_blank(start + 1);
end = skip_over_word(start);
DBG(READ, ul_debug("device should be %*s",
(int)(end - start), start));
if (**cp == '>')
*cp = end;
else
(*cp)++;
*tmp = '\0';
if (!(tmp = strrchr(end, '<')) || parse_end(&tmp) < 0) {
DBG(READ, ul_debug("blkid: missing </device> ending: %s", end));
} else if (tmp)
*tmp = '\0';
if (end - start <= 1) {
DBG(READ, ul_debug("blkid: empty device name: %s", *cp));
return -BLKID_ERR_CACHE;
}
name = strndup(start, end - start);
if (name == NULL)
return -BLKID_ERR_MEM;
DBG(READ, ul_debug("found dev %s", name));
if (!(*dev = blkid_get_dev(cache, name, BLKID_DEV_CREATE))) {
free(name);
return -BLKID_ERR_MEM;
}
free(name);
return 1;
}
void SLNFilterParseOptions(strarg_t const qs, SLNFilterPosition *const start, uint64_t *const count, int *const dir, bool *const wait) {
static strarg_t const fields[] = {
"start",
"count",
"dir",
"wait",
};
str_t *values[numberof(fields)] = {};
QSValuesParse(qs, values, fields, numberof(fields));
if(start) parse_start(values[0], start);
if(count) *count = parse_count(values[1], *count);
if(dir) *dir = parse_dir(values[2], *dir);
if(wait) *wait = parse_wait(values[3]);
QSValuesCleanup(values, numberof(values));
}
void
catalog_reader_parse (abstract_catalog_reader_ty *pop, FILE *fp,
const char *real_filename, const char *logical_filename,
catalog_input_format_ty input_syntax)
{
error_message_count = 0;
/* Parse the stream's content. */
parse_start (pop);
input_syntax->parse (pop, fp, real_filename, logical_filename);
parse_end (pop);
if (error_message_count > 0)
po_xerror (PO_SEVERITY_FATAL_ERROR, NULL,
/*real_filename*/ NULL, (size_t)(-1), (size_t)(-1), false,
xasprintf (ngettext ("found %d fatal error",
"found %d fatal errors",
error_message_count),
error_message_count));
}
void mission_type::load( JsonObject &jo, const std::string &src )
{
const bool strict = src == "dda";
mandatory( jo, was_loaded, "name", name );
mandatory( jo, was_loaded, "difficulty", difficulty );
mandatory( jo, was_loaded, "value", value );
if( jo.has_member( "origins" ) ) {
origins.clear();
for( auto &m : jo.get_tags( "origins" ) ) {
origins.emplace_back( io::string_to_enum_look_up( io::origin_map, m ) );
}
}
if( std::any_of( origins.begin(), origins.end(), []( mission_origin origin ) {
return origin == ORIGIN_ANY_NPC || origin == ORIGIN_OPENER_NPC || origin == ORIGIN_SECONDARY;
} ) ) {
auto djo = jo.get_object( "dialogue" );
// TODO: There should be a cleaner way to do it
mandatory( djo, was_loaded, "describe", dialogue[ "describe" ] );
mandatory( djo, was_loaded, "offer", dialogue[ "offer" ] );
mandatory( djo, was_loaded, "accepted", dialogue[ "accepted" ] );
mandatory( djo, was_loaded, "rejected", dialogue[ "rejected" ] );
mandatory( djo, was_loaded, "advice", dialogue[ "advice" ] );
mandatory( djo, was_loaded, "inquire", dialogue[ "inquire" ] );
mandatory( djo, was_loaded, "success", dialogue[ "success" ] );
mandatory( djo, was_loaded, "success_lie", dialogue[ "success_lie" ] );
mandatory( djo, was_loaded, "failure", dialogue[ "failure" ] );
}
optional( jo, was_loaded, "urgent", urgent );
optional( jo, was_loaded, "item", item_id );
optional( jo, was_loaded, "count", item_count, 1 );
goal = jo.get_enum_value<decltype( goal )>( "goal" );
assign_function( jo, "place", place, tripoint_function_map );
if( jo.has_string( "start" ) ) {
assign_function( jo, "start", start, mission_function_map );
} else if( jo.has_member( "start" ) ) {
JsonObject j_start = jo.get_object( "start" );
parse_start( j_start );
}
assign_function( jo, "end", end, mission_function_map );
assign_function( jo, "fail", fail, mission_function_map );
assign( jo, "deadline_low", deadline_low, false, 1_days );
assign( jo, "deadline_high", deadline_high, false, 1_days );
if( jo.has_member( "followup" ) ) {
follow_up = mission_type_id( jo.get_string( "followup" ) );
}
if( jo.has_member( "monster_species" ) ) {
monster_species = species_id( jo.get_string( "monster_species" ) );
}
if( jo.has_member( "monster_type" ) ) {
monster_type = mtype_id( jo.get_string( "monster_type" ) );
}
if( jo.has_member( "monster_kill_goal" ) ) {
monster_kill_goal = jo.get_int( "monster_kill_goal" );
}
assign( jo, "destination", target_id, strict );
}
static char*
parse_buf(pTHX_ PSTATE* p_state, char *beg, char *end, U32 utf8, SV* self)
{
char *s = beg;
char *t = beg;
char *new_pos;
while (!p_state->eof) {
/*
* At the start of this loop we will always be ready for eating text
* or a new tag. We will never be inside some tag. The 't' points
* to where we started and the 's' is advanced as we go.
*/
while (p_state->literal_mode) {
char *l = p_state->literal_mode;
bool skip_quoted_end = (strEQ(l, "script") || strEQ(l, "style"));
char inside_quote = 0;
bool escape_next = 0;
char *end_text;
while (s < end) {
if (*s == '<' && !inside_quote)
break;
if (skip_quoted_end) {
if (escape_next) {
escape_next = 0;
}
else {
if (*s == '\\')
escape_next = 1;
else if (inside_quote && *s == inside_quote)
inside_quote = 0;
else if (*s == '\r' || *s == '\n')
inside_quote = 0;
else if (!inside_quote && (*s == '"' || *s == '\''))
inside_quote = *s;
}
}
s++;
}
if (s == end) {
s = t;
goto DONE;
}
end_text = s;
s++;
/* here we rely on '\0' termination of perl svpv buffers */
if (*s == '/') {
s++;
while (*l && toLOWER(*s) == *l) {
s++;
l++;
}
if (!*l && (strNE(p_state->literal_mode, "plaintext") || p_state->closing_plaintext)) {
/* matched it all */
token_pos_t end_token;
end_token.beg = end_text + 2;
end_token.end = s;
while (isHSPACE(*s))
s++;
if (*s == '>') {
s++;
if (t != end_text)
report_event(p_state, E_TEXT, t, end_text, utf8,
0, 0, self);
report_event(p_state, E_END, end_text, s, utf8,
&end_token, 1, self);
p_state->literal_mode = 0;
p_state->is_cdata = 0;
t = s;
}
}
}
}
#ifdef MARKED_SECTION
while (p_state->ms == MS_CDATA || p_state->ms == MS_RCDATA) {
while (s < end && *s != ']')
s++;
if (*s == ']') {
char *end_text = s;
s++;
if (*s == ']') {
s++;
if (*s == '>') {
s++;
/* marked section end */
if (t != end_text)
report_event(p_state, E_TEXT, t, end_text, utf8,
0, 0, self);
report_event(p_state, E_NONE, end_text, s, utf8, 0, 0, self);
t = s;
SvREFCNT_dec(av_pop(p_state->ms_stack));
marked_section_update(p_state);
continue;
}
}
}
if (s == end) {
s = t;
goto DONE;
}
}
#endif
/* first we try to match as much text as possible */
while (s < end && *s != '<') {
#ifdef MARKED_SECTION
if (p_state->ms && *s == ']') {
char *end_text = s;
s++;
if (*s == ']') {
s++;
if (*s == '>') {
s++;
report_event(p_state, E_TEXT, t, end_text, utf8,
0, 0, self);
report_event(p_state, E_NONE, end_text, s, utf8,
0, 0, self);
t = s;
SvREFCNT_dec(av_pop(p_state->ms_stack));
marked_section_update(p_state);
continue;
}
}
}
#endif
s++;
}
if (s != t) {
if (*s == '<') {
report_event(p_state, E_TEXT, t, s, utf8, 0, 0, self);
t = s;
}
else {
s--;
if (isHSPACE(*s)) {
/* wait with white space at end */
while (s >= t && isHSPACE(*s))
s--;
}
else {
/* might be a chopped up entities/words */
while (s >= t && !isHSPACE(*s))
s--;
while (s >= t && isHSPACE(*s))
s--;
}
s++;
if (s != t)
report_event(p_state, E_TEXT, t, s, utf8, 0, 0, self);
break;
}
}
if (end - s < 3)
break;
/* next char is known to be '<' and pointed to by 't' as well as 's' */
s++;
#ifdef USE_PFUNC
new_pos = parsefunc[(unsigned char)*s](p_state, t, end, utf8, self);
#else
if (isHNAME_FIRST(*s))
new_pos = parse_start(p_state, t, end, utf8, self);
else if (*s == '/')
new_pos = parse_end(p_state, t, end, utf8, self);
else if (*s == '!')
new_pos = parse_decl(p_state, t, end, utf8, self);
else if (*s == '?')
new_pos = parse_process(p_state, t, end, utf8, self);
else
new_pos = 0;
#endif /* USE_PFUNC */
if (new_pos) {
if (new_pos == t) {
/* no progress, need more data to know what it is */
s = t;
break;
}
t = s = new_pos;
}
/* if we get out here then this was not a conforming tag, so
* treat it is plain text at the top of the loop again (we
* have already skipped past the "<").
*/
}
DONE:
return s;
}
