bool cookie::parse_char(char c, std::string& name, std::string& value)
{
std::string* name_ptr = &name;
std::string* value_ptr = &value;
auto value_state = COOKIE_ATTR_VALUE;
switch (state_)
{
case COOKIE_NAME:
name_ptr = &name_;
value_state = COOKIE_VALUE;
case COOKIE_ATTR_NAME:
if (std::isalpha(c) || ('-' == c))
name_ptr->push_back(static_cast<char>(std::tolower(c)));
else if ('=' == c)
state_ = value_state;
else if (!is_space_or_tab(c))
return false;
break;
case COOKIE_VALUE:
value_ptr = &value_;
case COOKIE_ATTR_VALUE:
if (';' == c && state_ == COOKIE_ATTR_VALUE)
{
parse_attr(name, value);
state_ = COOKIE_ATTR_NAME;
}
else if (!is_space_or_tab(c))
value_ptr->push_back(c);
break;
default:
return false;
}
return true;
}
// Parse received rule entry into custom object (rule_val).
// Parameters:
// nl_header : object that contain rule entry.
// p_val : custom object that contain parsed rule data.
// return true if its not related to local or default table, false otherwise.
bool rule_table_mgr::parse_enrty(nlmsghdr *nl_header, rule_val *p_val)
{
int len;
struct rtmsg *rt_msg;
struct rtattr *rt_attribute;
// get rule entry header
rt_msg = (struct rtmsg *) NLMSG_DATA(nl_header);
// we are not concerned about the local and default rule table
if (rt_msg->rtm_family != AF_INET || rt_msg->rtm_table == RT_TABLE_LOCAL || rt_msg->rtm_table == RT_TABLE_DEFAULT)
return false;
p_val->set_protocol(rt_msg->rtm_protocol);
p_val->set_scope(rt_msg->rtm_scope);
p_val->set_type(rt_msg->rtm_type);
p_val->set_tos(rt_msg->rtm_tos);
p_val->set_table_id(rt_msg->rtm_table);
len = RTM_PAYLOAD(nl_header);
rt_attribute = (struct rtattr *) RTM_RTA(rt_msg);
for (;RTA_OK(rt_attribute, len);rt_attribute=RTA_NEXT(rt_attribute,len)) {
parse_attr(rt_attribute, p_val);
}
p_val->set_state(true);
p_val->set_str();
return true;
}
/**
* set an attribute on a room.
*/
static int room_attr_set(struct room *r, const char *name, const char *value) {
int res;
assert(r != NULL);
assert(name != NULL);
assert(value != NULL);
if(!r) return 0;
if(!strcasecmp("id", name))
res=parse_uint(name, value, &r->id);
else if(!strcasecmp("name.short", name))
res=parse_str(name, value, &r->name.short_str);
else if(!strcasecmp("name.long", name))
res=parse_str(name, value, &r->name.long_str);
else if(!strcasecmp("desc.short", name))
res=parse_str(name, value, &r->desc.short_str);
else if(!strcasecmp("desc.long", name))
res=parse_str(name, value, &r->desc.long_str);
else if(!strcasecmp("creator", name))
res=parse_str(name, value, &r->creator);
else if(!strcasecmp("owner", name))
res=parse_str(name, value, &r->owner);
else
res=parse_attr(name, value, &r->extra_values);
if(res)
r->dirty_fl=1;
return res;
}
static void line_set(term_line *l, unsigned int pos, const char *str, bool insert_mode) {
term_char_t ch = TERM_CHAR_NULL;
term_attr attr = { };
term_age_t age = TERM_AGE_NULL;
char c;
while ((c = *str++))
parse_attr(c, &ch, &attr, &age);
term_line_write(l, pos, ch, 1, &attr, age, insert_mode);
}
/// Parse an individual http cookie and extract the parameters
/// If valid it will refer to the next char of data to be read.
/// @param s the set-cookie header value
/// @return true if a valid HTTP header, false otherwise.
bool parse(const std::string& s)
{
std::string name, value;
for (auto begin = s.cbegin(), end = s.cend(); begin != end; ++begin)
{
if (!parse_char(*begin, name, value))
return false;
}
if (state_ == COOKIE_ATTR_VALUE && !parse_attr(name, value))
return false;
return !(state_ == COOKIE_ATTR_NAME && !name.empty());
}
/* Parse netlink message to set options */
static int netem_change(struct Qdisc *sch, struct nlattr *opt)
{
struct netem_sched_data *q = qdisc_priv(sch);
struct nlattr *tb[TCA_NETEM_MAX + 1];
struct tc_netem_qopt *qopt;
int ret;
if (opt == NULL)
return -EINVAL;
qopt = nla_data(opt);
ret = parse_attr(tb, TCA_NETEM_MAX, opt, netem_policy, sizeof(*qopt));
if (ret < 0)
return ret;
ret = fifo_set_limit(q->qdisc, qopt->limit);
if (ret) {
pr_debug("netem: can't set fifo limit\n");
return ret;
}
q->latency = qopt->latency;
q->jitter = qopt->jitter;
q->limit = qopt->limit;
q->gap = qopt->gap;
q->counter = 0;
q->loss = qopt->loss;
q->duplicate = qopt->duplicate;
/* for compatibility with earlier versions.
* if gap is set, need to assume 100% probability
*/
if (q->gap)
q->reorder = ~0;
if (tb[TCA_NETEM_CORR])
get_correlation(sch, tb[TCA_NETEM_CORR]);
if (tb[TCA_NETEM_DELAY_DIST]) {
ret = get_dist_table(sch, tb[TCA_NETEM_DELAY_DIST]);
if (ret)
return ret;
}
if (tb[TCA_NETEM_REORDER])
get_reorder(sch, tb[TCA_NETEM_REORDER]);
if (tb[TCA_NETEM_CORRUPT])
get_corrupt(sch, tb[TCA_NETEM_CORRUPT]);
return 0;
}
static void parsing(const char **format, t_opt *opt, int *ret)
{
*ret = 0;
if (parse_attr(format, &(opt->attri)))
*ret = 1;
if (parse_width(format, opt))
*ret = 1;
if (parse_pres(format, opt))
*ret = 1;
if (ft_check_charset(**format, "lhjz"))
{
if (parse_modifier(format, opt))
*ret = 1;
}
}
static void line_assert(MY_ASSERT_ARGS, term_line *l, const char *str, unsigned int fill) {
unsigned int cell_i;
term_char_t ch = TERM_CHAR_NULL;
term_attr attr = { };
term_age_t age = TERM_AGE_NULL;
char c;
assert_se(l->fill == fill);
/* skip leading whitespace */
while (*str == ' ')
++str;
/* skip leading '|' */
if (*str == '|')
++str;
cell_i = 0;
while ((c = *str++)) {
switch (c) {
case '|':
/* end of cell-description; compare it */
assert_se(cell_i < l->n_cells);
cell_assert(MY_ASSERT_FORW,
&l->cells[cell_i],
ch,
&attr,
age);
++cell_i;
ch = term_char_free(ch);
zero(attr);
age = TERM_AGE_NULL;
break;
default:
parse_attr(c, &ch, &attr, &age);
break;
}
}
assert_se(cell_i == l->n_cells);
}
/*
* history <file1> ... <fileN>
*/
void
hammer_cmd_history(const char *offset_str, char **av, int ac)
{
int i;
int old_behavior = 0;
cmd_attr_t ca;
bzero(&ca, sizeof(ca));
if (parse_attr(offset_str, &ca) == 0)
old_behavior = 1;
for (i = 0; i < ac; ++i) {
if (!old_behavior)
parse_attr_path(av[i], &ca);
if (ca.path == NULL)
ca.path = strdup(av[i]);
hammer_do_history(ca.path, ca.offset, ca.length);
free(ca.path);
ca.path = NULL;
}
}
static int
parse_attr_path(const char *s, cmd_attr_t *ca)
{
int length, ret;
char *p;
struct stat st;
ca->path = NULL;
if (stat(s, &st) == 0)
return(-1); /* real path */
p = strstr(s, "@");
if (p == NULL || p == s)
return(-1); /* no attr specified */
ret = parse_attr(p, ca);
length = p - s + 1;
ca->path = calloc(1, length);
strncpy(ca->path, s, length - 1);
return(ret);
}
void color_parse_mem(const char *value, int value_len, const char *var,
char *dst)
{
const char *ptr = value;
int len = value_len;
int attr = -1;
int fg = -2;
int bg = -2;
if (!strncasecmp(value, "reset", len)) {
strcpy(dst, GIT_COLOR_RESET);
return;
}
/* [fg [bg]] [attr] */
while (len > 0) {
const char *word = ptr;
int val, wordlen = 0;
while (len > 0 && !isspace(word[wordlen])) {
wordlen++;
len--;
}
ptr = word + wordlen;
while (len > 0 && isspace(*ptr)) {
ptr++;
len--;
}
val = parse_color(word, wordlen);
if (val >= -1) {
if (fg == -2) {
fg = val;
continue;
}
if (bg == -2) {
bg = val;
continue;
}
goto bad;
}
val = parse_attr(word, wordlen);
if (val < 0 || attr != -1)
goto bad;
attr = val;
}
if (attr >= 0 || fg >= 0 || bg >= 0) {
int sep = 0;
*dst++ = '\033';
*dst++ = '[';
if (attr >= 0) {
*dst++ = '0' + attr;
sep++;
}
if (fg >= 0) {
if (sep++)
*dst++ = ';';
if (fg < 8) {
*dst++ = '3';
*dst++ = '0' + fg;
} else {
dst += sprintf(dst, "38;5;%d", fg);
}
}
if (bg >= 0) {
if (sep++)
*dst++ = ';';
if (bg < 8) {
*dst++ = '4';
*dst++ = '0' + bg;
} else {
dst += sprintf(dst, "48;5;%d", bg);
}
}
*dst++ = 'm';
}
*dst = 0;
return;
bad:
die("bad color value '%.*s' for variable '%s'", value_len, value, var);
}
LVal parse_tags(FILE* fp,LVal before,int mode) {
LVal current=tagalloc();
char str[2]={'\0','\0'};
int c,i=0;
char* buf=q("");
switch(mode) {
case 0: /* wait for '<' */
((struct tag*)firstp(current))->type=0;
while((c=fgetc(fp))!=EOF) {
if(c=='<') {
if(strlen(buf)==0) {
tagfree(current);
s(buf);
return parse_tags(fp,before,1);
}else {
((struct Cons*)current)->next=parse_tags(fp,current,1);
s(buf);
return current;
}
}else
str[0]=c,buf=s_cat2(buf,q(str));
}
break;
case 1: /* wait for '>' */
((struct tag*)firstp(current))->type=0;
while((c=fgetc(fp))!=EOF) {
if(i==0) {
if(c=='/')
((struct tag*)firstp(current))->type=2;
else {
((struct tag*)firstp(current))->type=1;
str[0]=c;
buf=s_cat2(buf,q(str));
}
++i;
continue;
}
if(c=='>') {
char *buf2;
if(((struct tag*)firstp(current))->type==2) {
int pos=position_char(" \t\r\n",buf);
if(pos!=-1) {
buf2=subseq(buf,0,pos);
s(buf);
buf=buf2;
((struct tag*)firstp(current))->name=q(buf);
}else {
((struct tag*)firstp(current))->name=buf;
buf=q("");
}
}else if(((struct tag*)firstp(current))->type==1) {
int pos=position_char(" \t\r\n",buf);
if(pos!=-1) {
((struct tag*)firstp(current))->name=subseq(buf,0,pos);
buf2=subseq(buf,pos,0);
((struct tag*)firstp(current))->attr=(struct Cons*)parse_attr(buf2);
s(buf);
buf=buf2;
}else {
((struct tag*)firstp(current))->name=buf;
buf=q("");
}
}
if(strcmp(((struct tag*)firstp(current))->name,"script")==0) {
((struct Cons*)current)->next=parse_tags(fp,current,2);
}else{
((struct Cons*)current)->next=parse_tags(fp,current,0);
}
s(buf);
return current;
}else {
str[0]=c;
buf=s_cat2(buf,q(str));
}
++i;
}
break;
case 2: /* wait for '</' */
((struct tag*)firstp(current))->type=0;
while((c=fgetc(fp))!=EOF) {
if(c=='<') {
if((c=fgetc(fp))!=EOF && c=='/') {
ungetc('/',fp);
if(strlen(buf)==0) {
tagfree(current);
s(buf);
return parse_tags(fp,current,1);
}else {
((struct Cons*)current)->next=parse_tags(fp,current,1);
s(buf);
return current;
}
}
ungetc('/',fp);
}else {
str[0]=c;
buf=s_cat2(buf,q(str));
}
}
break;
}
s(buf);
return current;
}
bool LVCssSelector::parse( const char * &str, lxmlDocBase * doc )
{
if (!str || !*str)
return false;
for (;;)
{
skip_spaces( str );
if ( *str == '*' ) // universal selector
{
str++;
skip_spaces( str );
_id = 0;
}
else if ( *str == '.' ) // classname follows
{
_id = 0;
}
else if ( css_is_alpha( *str ) )
{
// ident
char ident[64];
if (!parse_ident( str, ident ))
return false;
_id = doc->getElementNameIndex( lString16(ident).c_str() );
skip_spaces( str );
}
else
{
return false;
}
if ( *str == ',' || *str == '{' )
return true;
// one or more attribute rules
bool attr_rule = false;
while ( *str == '[' || *str=='.' || *str=='#' )
{
LVCssSelectorRule * rule = parse_attr( str, doc );
if (!rule)
return false;
insertRuleStart( rule ); //insertRuleAfterStart
//insertRuleAfterStart( rule ); //insertRuleAfterStart
/*
if ( _id!=0 ) {
LVCssSelectorRule * rule = new LVCssSelectorRule(cssrt_parent);
rule->setId(_id);
insertRuleStart( rule );
_id=0;
}
*/
skip_spaces( str );
attr_rule = true;
//continue;
}
// element relation
if (*str == '>')
{
str++;
LVCssSelectorRule * rule = new LVCssSelectorRule(cssrt_parent);
rule->setId(_id);
insertRuleStart( rule );
_id=0;
continue;
}
else if (*str == '+')
{
str++;
LVCssSelectorRule * rule = new LVCssSelectorRule(cssrt_predecessor);
rule->setId(_id);
insertRuleStart( rule );
_id=0;
continue;
}
else if (css_is_alpha( *str ))
{
LVCssSelectorRule * rule = new LVCssSelectorRule(cssrt_ancessor);
rule->setId(_id);
insertRuleStart( rule );
_id=0;
continue;
}
if ( !attr_rule )
return false;
else if ( *str == ',' || *str == '{' )
return true;
}
}
*/ REBFLG MT_Struct(REBVAL *out, REBVAL *data, enum Reb_Kind type)
/*
* Format:
* make struct! [
* field1 [type1]
* field2: [type2] field2-init-value
* field3: [struct [field1 [type1]]]
* field4: [type1[3]]
* ...
* ]
***********************************************************************/
{
//RL_Print("%s\n", __func__);
REBINT max_fields = 16;
VAL_STRUCT_FIELDS(out) = Make_Series(
max_fields, sizeof(struct Struct_Field), MKS_NONE
);
MANAGE_SERIES(VAL_STRUCT_FIELDS(out));
if (IS_BLOCK(data)) {
//if (Reduce_Block_No_Set_Throws(VAL_SERIES(data), 0, NULL))...
//data = DS_POP;
REBVAL *blk = VAL_BLK_DATA(data);
REBINT field_idx = 0; /* for field index */
u64 offset = 0; /* offset in data */
REBCNT eval_idx = 0; /* for spec block evaluation */
REBVAL *init = NULL; /* for result to save in data */
REBOOL expect_init = FALSE;
REBINT raw_size = -1;
REBUPT raw_addr = 0;
REBCNT alignment = 0;
VAL_STRUCT_SPEC(out) = Copy_Array_Shallow(VAL_SERIES(data));
VAL_STRUCT_DATA(out) = Make_Series(
1, sizeof(struct Struct_Data), MKS_NONE
);
EXPAND_SERIES_TAIL(VAL_STRUCT_DATA(out), 1);
VAL_STRUCT_DATA_BIN(out) = Make_Series(max_fields << 2, 1, MKS_NONE);
VAL_STRUCT_OFFSET(out) = 0;
// We tell the GC to manage this series, but it will not cause a
// synchronous garbage collect. Still, when's the right time?
ENSURE_SERIES_MANAGED(VAL_STRUCT_SPEC(out));
MANAGE_SERIES(VAL_STRUCT_DATA(out));
MANAGE_SERIES(VAL_STRUCT_DATA_BIN(out));
/* set type early such that GC will handle it correctly, i.e, not collect series in the struct */
SET_TYPE(out, REB_STRUCT);
if (IS_BLOCK(blk)) {
parse_attr(blk, &raw_size, &raw_addr);
++ blk;
}
while (NOT_END(blk)) {
REBVAL *inner;
struct Struct_Field *field = NULL;
u64 step = 0;
EXPAND_SERIES_TAIL(VAL_STRUCT_FIELDS(out), 1);
DS_PUSH_NONE;
inner = DS_TOP; /* save in stack so that it won't be GC'ed when MT_Struct is recursively called */
field = (struct Struct_Field *)SERIES_SKIP(VAL_STRUCT_FIELDS(out), field_idx);
field->offset = (REBCNT)offset;
if (IS_SET_WORD(blk)) {
field->sym = VAL_WORD_SYM(blk);
expect_init = TRUE;
if (raw_addr) {
/* initialization is not allowed for raw memory struct */
raise Error_Invalid_Arg(blk);
}
} else if (IS_WORD(blk)) {
field->sym = VAL_WORD_SYM(blk);
expect_init = FALSE;
}
else
raise Error_Has_Bad_Type(blk);
++ blk;
if (!IS_BLOCK(blk))
raise Error_Invalid_Arg(blk);
if (!parse_field_type(field, blk, inner, &init)) { return FALSE; }
++ blk;
STATIC_assert(sizeof(field->size) <= 4);
STATIC_assert(sizeof(field->dimension) <= 4);
step = (u64)field->size * (u64)field->dimension;
if (step > VAL_STRUCT_LIMIT)
raise Error_1(RE_SIZE_LIMIT, out);
EXPAND_SERIES_TAIL(VAL_STRUCT_DATA_BIN(out), step);
if (expect_init) {
REBVAL safe; // result of reduce or do (GC saved during eval)
init = &safe;
if (IS_BLOCK(blk)) {
if (Reduce_Block_Throws(init, VAL_SERIES(blk), 0, FALSE))
raise Error_No_Catch_For_Throw(init);
++ blk;
} else {
DO_NEXT_MAY_THROW(
eval_idx,
init,
VAL_SERIES(data),
blk - VAL_BLK_DATA(data)
);
if (eval_idx == THROWN_FLAG)
raise Error_No_Catch_For_Throw(init);
blk = VAL_BLK_SKIP(data, eval_idx);
}
if (field->array) {
if (IS_INTEGER(init)) { /* interpreted as a C pointer */
void *ptr = cast(void *, cast(REBUPT, VAL_INT64(init)));
/* assuming it's an valid pointer and holding enough space */
memcpy(SERIES_SKIP(VAL_STRUCT_DATA_BIN(out), (REBCNT)offset), ptr, field->size * field->dimension);
} else if (IS_BLOCK(init)) {
REBCNT n = 0;
if (VAL_LEN(init) != field->dimension)
raise Error_Invalid_Arg(init);
/* assign */
for (n = 0; n < field->dimension; n ++) {
if (!assign_scalar(&VAL_STRUCT(out), field, n, VAL_BLK_SKIP(init, n))) {
//RL_Print("Failed to assign element value\n");
goto failed;
}
}
}
else
raise Error_Unexpected_Type(REB_BLOCK, VAL_TYPE(blk));
} else {
/* scalar */
if (!assign_scalar(&VAL_STRUCT(out), field, 0, init)) {
//RL_Print("Failed to assign scalar value\n");
goto failed;
}
}
} else if (raw_addr == 0) {
int color_parse_mem(const char *value, int value_len, char *dst)
{
const char *ptr = value;
int len = value_len;
char *end = dst + COLOR_MAXLEN;
unsigned int attr = 0;
struct color fg = { COLOR_UNSPECIFIED };
struct color bg = { COLOR_UNSPECIFIED };
while (len > 0 && isspace(*ptr)) {
ptr++;
len--;
}
if (!len) {
dst[0] = '\0';
return 0;
}
if (!strncasecmp(ptr, "reset", len)) {
xsnprintf(dst, end - dst, GIT_COLOR_RESET);
return 0;
}
/* [fg [bg]] [attr]... */
while (len > 0) {
const char *word = ptr;
struct color c = { COLOR_UNSPECIFIED };
int val, wordlen = 0;
while (len > 0 && !isspace(word[wordlen])) {
wordlen++;
len--;
}
ptr = word + wordlen;
while (len > 0 && isspace(*ptr)) {
ptr++;
len--;
}
if (!parse_color(&c, word, wordlen)) {
if (fg.type == COLOR_UNSPECIFIED) {
fg = c;
continue;
}
if (bg.type == COLOR_UNSPECIFIED) {
bg = c;
continue;
}
goto bad;
}
val = parse_attr(word, wordlen);
if (0 <= val)
attr |= (1 << val);
else
goto bad;
}
#undef OUT
#define OUT(x) do { \
if (dst == end) \
die("BUG: color parsing ran out of space"); \
*dst++ = (x); \
} while(0)
if (attr || !color_empty(&fg) || !color_empty(&bg)) {
int sep = 0;
int i;
OUT('\033');
OUT('[');
for (i = 0; attr; i++) {
unsigned bit = (1 << i);
if (!(attr & bit))
continue;
attr &= ~bit;
if (sep++)
OUT(';');
dst += xsnprintf(dst, end - dst, "%d", i);
}
if (!color_empty(&fg)) {
if (sep++)
OUT(';');
/* foreground colors are all in the 3x range */
dst = color_output(dst, end - dst, &fg, '3');
}
if (!color_empty(&bg)) {
if (sep++)
OUT(';');
/* background colors are all in the 4x range */
dst = color_output(dst, end - dst, &bg, '4');
}
OUT('m');
}
OUT(0);
return 0;
bad:
return error(_("invalid color value: %.*s"), value_len, value);
#undef OUT
}
/*
* Parse SDP message.
*/
PJ_DEF(pj_status_t) pjmedia_sdp_parse( pj_pool_t *pool,
char *buf, pj_size_t len,
pjmedia_sdp_session **p_sdp)
{
pj_scanner scanner;
pjmedia_sdp_session *session;
pjmedia_sdp_media *media = NULL;
pjmedia_sdp_attr *attr;
pjmedia_sdp_conn *conn;
pjmedia_sdp_bandw *bandw;
pj_str_t dummy;
int cur_name = 254;
parse_context ctx;
PJ_USE_EXCEPTION;
ctx.last_error = PJ_SUCCESS;
init_sdp_parser();
pj_scan_init(&scanner, buf, len, 0, &on_scanner_error);
session = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_session);
PJ_ASSERT_RETURN(session != NULL, PJ_ENOMEM);
/* Ignore leading newlines */
while (*scanner.curptr=='\r' || *scanner.curptr=='\n')
pj_scan_get_char(&scanner);
PJ_TRY {
while (!pj_scan_is_eof(&scanner)) {
cur_name = *scanner.curptr;
switch (cur_name) {
case 'a':
attr = parse_attr(pool, &scanner, &ctx);
if (attr) {
if (media) {
if (media->attr_count < PJMEDIA_MAX_SDP_ATTR)
pjmedia_sdp_media_add_attr(media, attr);
else
PJ_PERROR(2, (THIS_FILE, PJ_ETOOMANY,
"Error adding media attribute, "
"attribute is ignored"));
} else {
if (session->attr_count < PJMEDIA_MAX_SDP_ATTR)
pjmedia_sdp_session_add_attr(session, attr);
else
PJ_PERROR(2, (THIS_FILE, PJ_ETOOMANY,
"Error adding session attribute"
", attribute is ignored"));
}
}
break;
case 'o':
parse_origin(&scanner, session, &ctx);
break;
case 's':
parse_generic_line(&scanner, &session->name, &ctx);
break;
case 'c':
conn = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_conn);
parse_connection_info(&scanner, conn, &ctx);
if (media) {
media->conn = conn;
} else {
session->conn = conn;
}
break;
case 't':
parse_time(&scanner, session, &ctx);
break;
case 'm':
media = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_media);
parse_media(&scanner, media, &ctx);
if (session->media_count < PJMEDIA_MAX_SDP_MEDIA)
session->media[ session->media_count++ ] = media;
else
PJ_PERROR(2,(THIS_FILE, PJ_ETOOMANY,
"Error adding media, media is ignored"));
break;
case 'v':
parse_version(&scanner, &ctx);
break;
case 13:
case 10:
pj_scan_get_char(&scanner);
/* Allow empty newlines at the end of the message */
while (!pj_scan_is_eof(&scanner)) {
if (*scanner.curptr != 13 && *scanner.curptr != 10) {
ctx.last_error = PJMEDIA_SDP_EINSDP;
on_scanner_error(&scanner);
}
pj_scan_get_char(&scanner);
}
break;
case 'b':
bandw = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_bandw);
parse_bandwidth_info(&scanner, bandw, &ctx);
if (media) {
if (media->bandw_count < PJMEDIA_MAX_SDP_BANDW)
media->bandw[media->bandw_count++] = bandw;
else
PJ_PERROR(2, (THIS_FILE, PJ_ETOOMANY,
"Error adding media bandwidth "
"info, info is ignored"));
} else {
if (session->bandw_count < PJMEDIA_MAX_SDP_BANDW)
session->bandw[session->bandw_count++] = bandw;
else
PJ_PERROR(2, (THIS_FILE, PJ_ETOOMANY,
"Error adding session bandwidth "
"info, info is ignored"));
}
break;
default:
if (cur_name >= 'a' && cur_name <= 'z')
parse_generic_line(&scanner, &dummy, &ctx);
else {
ctx.last_error = PJMEDIA_SDP_EINSDP;
on_scanner_error(&scanner);
}
break;
}
}
ctx.last_error = PJ_SUCCESS;
}
PJ_CATCH_ANY {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(ctx.last_error, errmsg, sizeof(errmsg));
PJ_LOG(4, (THIS_FILE, "Error parsing SDP in line %d col %d: %s",
scanner.line, pj_scan_get_col(&scanner),
errmsg));
session = NULL;
pj_assert(ctx.last_error != PJ_SUCCESS);
}
PJ_END;
pj_scan_fini(&scanner);
if (session)
apply_media_direction(session);
*p_sdp = session;
return ctx.last_error;
}
static NEOERR* _hdf_read_string (HDF *hdf, const char **str, STRING *line,
const char *path, int *lineno,
int include_handle)
{
NEOERR *err;
HDF *lower;
char *s;
char *name, *value;
HDF_ATTR *attr = NULL;
while (**str != '\0')
{
/* Reset string length, but don't free the reserved buffer */
line->len = 0;
err = _copy_line_advance(str, line);
if (err) return nerr_pass(err);
attr = NULL;
(*lineno)++;
s = line->buf;
SKIPWS(s);
if (!strncmp(s, "#include ", 9) && include_handle != INCLUDE_IGNORE)
{
if (include_handle == INCLUDE_ERROR)
{
return nerr_raise (NERR_PARSE,
"[%d]: #include not supported in string parse",
*lineno);
}
else if (include_handle < INCLUDE_MAX_DEPTH)
{
int l;
s += 9;
name = neos_strip(s);
l = strlen(name);
if (name[0] == '"' && name[l-1] == '"')
{
name[l-1] = '\0';
name++;
}
err = hdf_read_file_internal(hdf, name, include_handle + 1);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else
{
return nerr_raise (NERR_MAX_RECURSION,
"[%d]: Too many recursion levels.",
*lineno
);
}
}
else if (s[0] == '#')
{
/* comment: pass */
}
else if (s[0] == '}') /* up */
{
s = neos_strip(s);
if (strcmp(s, "}"))
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Trailing garbage on line following }: %s", path, *lineno,
line->buf);
return err;
}
return STATUS_OK;
}
else if (s[0])
{
/* Valid hdf name is [0-9a-zA-Z_.]+ */
name = s;
while (*s && (isalnum(*s) || *s == '_' || *s == '.' || *(unsigned char*)s > 127)) s++;
SKIPWS(s);
if (s[0] == '[') /* attributes */
{
*s = '\0';
name = neos_strip(name);
s++;
err = parse_attr(&s, &attr);
if (err)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
SKIPWS(s);
}
if (s[0] == '=') /* assignment */
{
*s = '\0';
name = neos_strip(name);
s++;
value = neos_strip(s);
err = _set_value (hdf, name, value, 1, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == ':' && s[1] == '=') /* copy */
{
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
value = hdf_get_value(hdf->top, value, "");
err = _set_value (hdf, name, value, 1, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == ':') /* link */
{
*s = '\0';
name = neos_strip(name);
s++;
value = neos_strip(s);
err = _set_value (hdf, name, value, 1, 1, 1, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '{') /* deeper */
{
*s = '\0';
name = neos_strip(name);
lower = hdf_get_obj (hdf, name);
if (lower == NULL)
{
err = _set_value (hdf, name, NULL, 1, 1, 0, attr, &lower);
}
else
{
err = _set_value (lower, NULL, lower->value, 1, 1, 0, attr, NULL);
}
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
err = _hdf_read_string (lower, str, line, path, lineno, include_handle);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '<' && s[1] == '<') /* multi-line assignment */
{
char *m;
int msize = 0;
int mmax = 128;
int l;
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
l = strlen(value);
if (l == 0)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] No multi-assignment terminator given: %s", path, *lineno,
line->buf);
return err;
}
m = (char *) malloc (mmax * sizeof(char));
if (m == NULL)
{
return nerr_raise(NERR_NOMEM,
"[%s:%d] Unable to allocate memory for multi-line assignment to %s",
path, *lineno, name);
}
while (_copy_line (str, m+msize, mmax-msize) != 0)
{
(*lineno)++;
if (!strncmp(value, m+msize, l) && isspace(m[msize+l]))
{
m[msize] = '\0';
break;
}
msize += strlen(m+msize);
if (msize + l + 10 > mmax)
{
void *new_ptr;
mmax += 128;
new_ptr = realloc (m, mmax * sizeof(char));
if (new_ptr == NULL)
{
free(m);
return nerr_raise(NERR_NOMEM,
"[%s:%d] Unable to allocate memory for multi-line assignment to %s: size=%d",
path, *lineno, name, mmax);
}
m = (char *) new_ptr;
}
}
err = _set_value (hdf, name, m, 0, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
free (m);
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else
{
err = nerr_raise(NERR_PARSE, "[%s:%d] Unable to parse line %s", path,
*lineno, line->buf);
return err;
}
}
}
return STATUS_OK;
}
static aqwin_param *parse_cfg(const char *cfg) {
char *cp;
aqwin_param *param;
aqwin_tuple *last;
if ((param = malloc(sizeof *param)) == NULL) {
complain("aqwin_open: nomem param\n");
goto e0_nomem_param;
}
memset(param, 0, sizeof *param);
if ((param->buf = malloc(strlen(cfg))) == NULL) {
complain("aqwin_open: nomem param buf\n");
goto e1_nomem_parambuf;
}
strcpy(param->buf, cfg);
if ((param->attr = malloc(sizeof *(param->attr))) == NULL) {
complain("aqwin_open: nomem param attr\n");
goto e2_nomem_paramattr;
}
memset(param->attr, 0, sizeof *(param->attr));
last = param->attr;
cp = param->buf;
for(eatwhite(&cp); *cp; cp++) {
skip_inc:
if(*cp == '=' && last->key == NULL) {
complain("aqwin_open: keys cannot begin with '='\n");
goto e3_parse_error;
}
else if(*cp == '=') {
*cp = '\0';
last->val = cp + 1;
}
else if(*cp == '\'') {
*cp++ = '\0';
if (last->val) {
last->val = cp;
} else {
complain("aqwin_open: quoted key\n");
goto e3_parse_error;
}
if (charff(&cp, '\'')) {
*cp++ = '\0';
} else {
complain("aqwin_open: unterminated string\n");
goto e3_parse_error;
}
eatwhite(&cp);
if((last->next = malloc(sizeof *last)) == NULL) {
complain("aqwin_open: nomem next param\n");
goto e3_nomem_paramnext;
}
last = last->next;
memset(last, 0, sizeof *last);
goto skip_inc;
}
else if(isws(*cp)) {
*cp = '\0';
last->val = last->val ? last->val : cp;
if (parse_attr(last)) {
goto e3_parse_error;
}
cp++;
eatwhite(&cp);
if((last->next = malloc(sizeof *last)) == NULL) {
complain("aqwin_open: nomem next param\n");
goto e3_nomem_paramnext;
}
last = last->next;
memset(last, 0, sizeof *last);
goto skip_inc;
}
else if(last->key == NULL) {
last->key = cp;
}
}
return param;
e3_nomem_paramnext:
e3_parse_error:
aqwin_tuple_free(param->attr);
e2_nomem_paramattr:
free(param->buf);
e1_nomem_parambuf:
free(param);
e0_nomem_param:
return NULL;
}
/*
* Parse SDP message.
*/
PJ_DEF(pj_status_t) pjmedia_sdp_parse( pj_pool_t *pool,
char *buf, pj_size_t len,
pjmedia_sdp_session **p_sdp)
{
pj_scanner scanner;
pjmedia_sdp_session *session;
pjmedia_sdp_media *media = NULL;
void *attr;
pjmedia_sdp_conn *conn;
pj_str_t dummy;
int cur_name = 254;
parse_context ctx;
PJ_USE_EXCEPTION;
ctx.last_error = PJ_SUCCESS;
init_sdp_parser();
pj_scan_init(&scanner, buf, len, 0, &on_scanner_error);
session = pj_pool_calloc(pool, 1, sizeof(pjmedia_sdp_session));
PJ_ASSERT_RETURN(session != NULL, PJ_ENOMEM);
PJ_TRY {
while (!pj_scan_is_eof(&scanner)) {
cur_name = *scanner.curptr;
switch (cur_name) {
case 'a':
attr = parse_attr(pool, &scanner, &ctx);
if (attr) {
if (media) {
media->attr[media->attr_count++] = attr;
} else {
session->attr[session->attr_count++] = attr;
}
}
break;
case 'o':
parse_origin(&scanner, session, &ctx);
break;
case 's':
parse_generic_line(&scanner, &session->name, &ctx);
break;
case 'c':
conn = pj_pool_calloc(pool, 1, sizeof(*conn));
parse_connection_info(&scanner, conn, &ctx);
if (media) {
media->conn = conn;
} else {
session->conn = conn;
}
break;
case 't':
parse_time(&scanner, session, &ctx);
break;
case 'm':
media = pj_pool_calloc(pool, 1, sizeof(*media));
parse_media(&scanner, media, &ctx);
session->media[ session->media_count++ ] = media;
break;
case 'v':
parse_version(&scanner, &ctx);
break;
case 13:
/* Allow empty newline at the end of the message */
pj_scan_get_char(&scanner);
/* Continue below */
case 10:
pj_scan_get_char(&scanner);
if (!pj_scan_is_eof(&scanner)) {
on_scanner_error(&scanner);
}
break;
default:
if (cur_name >= 'a' && cur_name <= 'z')
parse_generic_line(&scanner, &dummy, &ctx);
else {
ctx.last_error = PJMEDIA_SDP_EINSDP;
on_scanner_error(&scanner);
}
break;
}
}
ctx.last_error = PJ_SUCCESS;
}
PJ_CATCH(SYNTAX_ERROR) {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(ctx.last_error, errmsg, sizeof(errmsg));
PJ_LOG(4, (THIS_FILE, "Error parsing SDP in line %d col %d: %s",
scanner.line, pj_scan_get_col(&scanner),
errmsg));
session = NULL;
pj_assert(ctx.last_error != PJ_SUCCESS);
}
PJ_END;
pj_scan_fini(&scanner);
*p_sdp = session;
return ctx.last_error;
}
// Parse global prefs, overriding whatever is currently in the structure.
//
// If host_venue is nonempty and we find an element of the form
// <venue name="X">
// ...
// </venue>
// where X==host_venue, then parse that and ignore the rest.
// Otherwise ignore <venue> elements.
//
// The start tag may or may not have already been parsed
//
int GLOBAL_PREFS::parse_override(
XML_PARSER& xp, const char* host_venue, bool& found_venue, GLOBAL_PREFS_MASK& mask
) {
char buf2[256], attrs[256];
bool in_venue = false, in_correct_venue=false;
double dtemp;
int itemp;
found_venue = false;
mask.clear();
while (!xp.get_tag(attrs, sizeof(attrs))) {
if (!xp.is_tag) continue;
if (xp.match_tag("global_preferences")) continue;
if (xp.match_tag("/global_preferences")) {
return 0;
}
if (in_venue) {
if (xp.match_tag("/venue")) {
if (in_correct_venue) {
return 0;
} else {
in_venue = false;
continue;
}
} else {
if (!in_correct_venue) continue;
}
} else {
if (strstr(xp.parsed_tag, "venue")) {
in_venue = true;
parse_attr(attrs, "name", buf2, sizeof(buf2));
if (!strcmp(buf2, host_venue)) {
defaults();
clear_bools();
mask.clear();
in_correct_venue = true;
found_venue = true;
} else {
in_correct_venue = false;
}
continue;
}
}
if (xp.parse_str("source_project", source_project, sizeof(source_project))) continue;
if (xp.parse_str("source_scheduler", source_scheduler, sizeof(source_scheduler))) {
continue;
}
if (xp.parse_double("mod_time", mod_time)) {
double now = dtime();
if (mod_time > now) {
mod_time = now;
}
continue;
}
if (xp.parse_double("battery_charge_min_pct", battery_charge_min_pct)) {
mask.battery_charge_min_pct = true;
continue;
}
if (xp.parse_double("battery_max_temperature", battery_max_temperature)) {
mask.battery_max_temperature = true;
continue;
}
if (xp.parse_bool("run_on_batteries", run_on_batteries)) {
mask.run_on_batteries = true;
continue;
}
if (xp.parse_bool("run_if_user_active", run_if_user_active)) {
mask.run_if_user_active = true;
continue;
}
if (xp.parse_bool("run_gpu_if_user_active", run_gpu_if_user_active)) {
mask.run_gpu_if_user_active = true;
continue;
}
if (xp.parse_double("idle_time_to_run", idle_time_to_run)) {
mask.idle_time_to_run = true;
continue;
}
if (xp.parse_double("suspend_if_no_recent_input", suspend_if_no_recent_input)) {
mask.suspend_if_no_recent_input = true;
continue;
}
if (xp.parse_double("suspend_cpu_usage", suspend_cpu_usage)) {
mask.suspend_cpu_usage = true;
continue;
}
if (xp.parse_double("start_hour", cpu_times.start_hour)) {
mask.start_hour = true;
continue;
}
if (xp.parse_double("end_hour", cpu_times.end_hour)) {
mask.end_hour = true;
continue;
}
if (xp.parse_double("net_start_hour", net_times.start_hour)) {
mask.net_start_hour = true;
continue;
}
if (xp.parse_double("net_end_hour", net_times.end_hour)) {
mask.net_end_hour = true;
continue;
}
if (xp.match_tag("day_prefs")) {
parse_day(xp);
continue;
}
if (xp.parse_bool("leave_apps_in_memory", leave_apps_in_memory)) {
mask.leave_apps_in_memory = true;
continue;
}
if (xp.parse_bool("confirm_before_connecting", confirm_before_connecting)) {
mask.confirm_before_connecting = true;
continue;
}
if (xp.parse_bool("hangup_if_dialed", hangup_if_dialed)) {
mask.hangup_if_dialed = true;
continue;
}
if (xp.parse_bool("dont_verify_images", dont_verify_images)) {
mask.dont_verify_images = true;
continue;
}
if (xp.parse_double("work_buf_min_days", work_buf_min_days)) {
if (work_buf_min_days < 0) work_buf_min_days = 0;
mask.work_buf_min_days = true;
continue;
}
if (xp.parse_double("work_buf_additional_days", work_buf_additional_days)) {
if (work_buf_additional_days < 0) work_buf_additional_days = 0;
mask.work_buf_additional_days = true;
continue;
}
if (xp.parse_double("max_ncpus_pct", max_ncpus_pct)) {
if (max_ncpus_pct < 0) max_ncpus_pct = 0;
if (max_ncpus_pct > 100) max_ncpus_pct = 100;
mask.max_ncpus_pct = true;
continue;
}
if (xp.parse_int("max_cpus", max_ncpus)) {
if (max_ncpus < 0) max_ncpus = 0;
mask.max_ncpus = true;
continue;
}
if (xp.parse_double("disk_interval", disk_interval)) {
if (disk_interval<0) disk_interval = 0;
mask.disk_interval = true;
continue;
}
if (xp.parse_double("cpu_scheduling_period_minutes", cpu_scheduling_period_minutes)) {
if (cpu_scheduling_period_minutes < 0.0001) cpu_scheduling_period_minutes = 60;
mask.cpu_scheduling_period_minutes = true;
continue;
}
if (xp.parse_double("disk_max_used_gb", disk_max_used_gb)) {
mask.disk_max_used_gb = true;
continue;
}
if (xp.parse_double("disk_max_used_pct", disk_max_used_pct)) {
mask.disk_max_used_pct = true;
continue;
}
if (xp.parse_double("disk_min_free_gb", disk_min_free_gb)) {
mask.disk_min_free_gb = true;
continue;
}
if (xp.parse_double("vm_max_used_pct", dtemp)) {
vm_max_used_frac = dtemp/100;
mask.vm_max_used_frac = true;
continue;
}
if (xp.parse_double("ram_max_used_busy_pct", dtemp)) {
if (!dtemp) dtemp = 100;
ram_max_used_busy_frac = dtemp/100;
mask.ram_max_used_busy_frac = true;
continue;
}
if (xp.parse_double("ram_max_used_idle_pct", dtemp)) {
if (!dtemp) dtemp = 100;
ram_max_used_idle_frac = dtemp/100;
mask.ram_max_used_idle_frac = true;
continue;
}
if (xp.parse_double("max_bytes_sec_up", max_bytes_sec_up)) {
if (max_bytes_sec_up < 0) max_bytes_sec_up = 0;
mask.max_bytes_sec_up = true;
continue;
}
if (xp.parse_double("max_bytes_sec_down", max_bytes_sec_down)) {
if (max_bytes_sec_down < 0) max_bytes_sec_down = 0;
mask.max_bytes_sec_down = true;
continue;
}
if (xp.parse_double("cpu_usage_limit", dtemp)) {
if (dtemp > 0 && dtemp <= 100) {
cpu_usage_limit = dtemp;
mask.cpu_usage_limit = true;
}
continue;
}
if (xp.parse_double("daily_xfer_limit_mb", dtemp)) {
if (dtemp >= 0) {
daily_xfer_limit_mb = dtemp;
mask.daily_xfer_limit_mb = true;
}
continue;
}
if (xp.parse_int("daily_xfer_period_days", itemp)) {
if (itemp >= 0) {
daily_xfer_period_days = itemp;
mask.daily_xfer_period_days = true;
}
continue;
}
if (xp.parse_bool("network_wifi_only", network_wifi_only)) {
continue;
}
if (xp.parse_bool("host_specific", host_specific)) {
continue;
}
// false means don't print anything
xp.skip_unexpected(false, "GLOBAL_PREFS::parse_override");
}
return ERR_XML_PARSE;
}
void color_parse(const char *value, const char *var, char *dst)
{
const char *ptr = value;
int attr = -1;
int fg = -2;
int bg = -2;
if (!strcasecmp(value, "reset")) {
strcpy(dst, "\033[m");
return;
}
/* [fg [bg]] [attr] */
while (*ptr) {
const char *word = ptr;
int val, len = 0;
while (word[len] && !isspace(word[len]))
len++;
ptr = word + len;
while (*ptr && isspace(*ptr))
ptr++;
val = parse_color(word, len);
if (val >= -1) {
if (fg == -2) {
fg = val;
continue;
}
if (bg == -2) {
bg = val;
continue;
}
goto bad;
}
val = parse_attr(word, len);
if (val < 0 || attr != -1)
goto bad;
attr = val;
}
if (attr >= 0 || fg >= 0 || bg >= 0) {
int sep = 0;
*dst++ = '\033';
*dst++ = '[';
if (attr >= 0) {
*dst++ = '0' + attr;
sep++;
}
if (fg >= 0) {
if (sep++)
*dst++ = ';';
if (fg < 8) {
*dst++ = '3';
*dst++ = '0' + fg;
} else {
dst += sprintf(dst, "38;5;%d", fg);
}
}
if (bg >= 0) {
if (sep++)
*dst++ = ';';
if (bg < 8) {
*dst++ = '4';
*dst++ = '0' + bg;
} else {
dst += sprintf(dst, "48;5;%d", bg);
}
}
*dst++ = 'm';
}
*dst = 0;
return;
bad:
die("bad config value '%s' for variable '%s'", value, var);
}
static struct match_attr *parse_attr_line(const char *line, const char *src,
int lineno, int macro_ok)
{
int namelen;
int num_attr, i;
const char *cp, *name, *states;
struct match_attr *res = NULL;
int is_macro;
struct strbuf pattern = STRBUF_INIT;
cp = line + strspn(line, blank);
if (!*cp || *cp == '#')
return NULL;
name = cp;
if (*cp == '"' && !unquote_c_style(&pattern, name, &states)) {
name = pattern.buf;
namelen = pattern.len;
} else {
namelen = strcspn(name, blank);
states = name + namelen;
}
if (strlen(ATTRIBUTE_MACRO_PREFIX) < namelen &&
starts_with(name, ATTRIBUTE_MACRO_PREFIX)) {
if (!macro_ok) {
fprintf(stderr, "%s not allowed: %s:%d\n",
name, src, lineno);
goto fail_return;
}
is_macro = 1;
name += strlen(ATTRIBUTE_MACRO_PREFIX);
name += strspn(name, blank);
namelen = strcspn(name, blank);
if (!attr_name_valid(name, namelen)) {
report_invalid_attr(name, namelen, src, lineno);
goto fail_return;
}
}
else
is_macro = 0;
states += strspn(states, blank);
/* First pass to count the attr_states */
for (cp = states, num_attr = 0; *cp; num_attr++) {
cp = parse_attr(src, lineno, cp, NULL);
if (!cp)
goto fail_return;
}
res = xcalloc(1,
sizeof(*res) +
sizeof(struct attr_state) * num_attr +
(is_macro ? 0 : namelen + 1));
if (is_macro) {
res->u.attr = git_attr_internal(name, namelen);
} else {
char *p = (char *)&(res->state[num_attr]);
memcpy(p, name, namelen);
res->u.pat.pattern = p;
parse_exclude_pattern(&res->u.pat.pattern,
&res->u.pat.patternlen,
&res->u.pat.flags,
&res->u.pat.nowildcardlen);
if (res->u.pat.flags & EXC_FLAG_NEGATIVE) {
warning(_("Negative patterns are ignored in git attributes\n"
"Use '\\!' for literal leading exclamation."));
goto fail_return;
}
}
res->is_macro = is_macro;
res->num_attr = num_attr;
/* Second pass to fill the attr_states */
for (cp = states, i = 0; *cp; i++) {
cp = parse_attr(src, lineno, cp, &(res->state[i]));
}
strbuf_release(&pattern);
return res;
fail_return:
strbuf_release(&pattern);
free(res);
return NULL;
}
static NEOERR* _hdf_read_string (HDF *hdf, const char **str, STRING *line,
const char *path, int *lineno,
int include_handle, int expect_end_brace) {
NEOERR *err;
HDF *lower;
char *s;
char *name, *value;
HDF_ATTR *attr = NULL;
while (**str != '\0')
{
/* Reset string length, but don't free the reserved buffer */
line->len = 0;
err = _copy_line_advance(str, line);
if (err) return nerr_pass(err);
attr = NULL;
(*lineno)++;
s = line->buf;
SKIPWS(s);
if ((!strncmp(s, "#include ", 9) || !strncmp(s, "-include ", 9)) && include_handle != INCLUDE_IGNORE)
{
int required = !strncmp(s, "#include ", 9);
if (include_handle == INCLUDE_ERROR)
{
return nerr_raise (NERR_PARSE,
"[%d]: #include not supported in string parse",
*lineno);
}
else if (include_handle < INCLUDE_MAX_DEPTH)
{
int l;
s += 9;
name = neos_strip(s);
l = strlen(name);
if (name[0] == '"' && name[l-1] == '"')
{
name[l-1] = '\0';
name++;
}
char fullpath[PATH_MAX];
if (name[0] != '/') {
memset(fullpath, 0, PATH_MAX);
char *p = strrchr(path, '/');
if (p == NULL) {
char pwd[PATH_MAX];
memset(pwd, 0, PATH_MAX);
getcwd(pwd, PATH_MAX);
snprintf(fullpath, PATH_MAX, "%s/%s", pwd, name);
} else {
int dir_len = p - path + 1;
snprintf(fullpath, PATH_MAX, "%s", path);
snprintf(fullpath + dir_len, PATH_MAX - dir_len, "%s", name);
}
name = fullpath;
}
err = hdf_read_file_internal(hdf, name, include_handle + 1);
if (err != STATUS_OK && required)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else {
return nerr_raise (NERR_MAX_RECURSION,
"[%d]: Too many recursion levels.",
*lineno
);
}
}
else if (s[0] == '#')
{
/* comment: pass */
}
else if (s[0] == '}') /* up */
{
s = neos_strip(s);
if (strcmp(s, "}"))
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Trailing garbage on line following }: %s", path, *lineno,
line->buf);
return err;
}
return STATUS_OK;
}
else if (s[0])
{
/* Valid hdf name is [0-9a-zA-Z_.]+ */
int splice = *s == '@';
if (splice) s++;
name = s;
while (*s && (isalnum(*s) || *s == '_' || *s == '.' || *s == '*')) s++;
SKIPWS(s);
char num[16];
static int counter = 0;
if (*name == '*') {
snprintf(num, sizeof(num), "%d", counter++);
name = num;
}
if (s[0] == '[') /* attributes */
{
*s = '\0';
name = neos_strip(name);
s++;
err = parse_attr(&s, &attr);
if (err)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
SKIPWS(s);
}
if (splice) {
name = neos_strip(name);
HDF *h = hdf_get_obj(hdf->top, name);
if (h) {
HDF *c = hdf_obj_child(h);
while (c) {
err = hdf_copy (hdf, hdf_obj_name(c), c);
if (err != STATUS_OK) break;
c = hdf_obj_next(c);
}
}
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
} else if (s[0] == '=') /* assignment */
{
*s = '\0';
name = neos_strip(name);
s++;
value = neos_strip(s);
err = _set_value (hdf, name, value, 1, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == ':' && s[1] == '=') /* copy */
{
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
HDF *h = hdf_get_obj(hdf->top, value);
if (!h)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Failed to copy a node that is not loaded "
"yet: %s", path, *lineno, value);
return err;
}
err = hdf_copy(hdf, name, h);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '!' && s[1] == '=') /* exec */
{
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
FILE *f = popen(value, "r");
if (f == NULL)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Failed to exec specified command: %s",
path, *lineno, line->buf);
return err;
}
char *content = _read_file(f);
fclose(f);
int len = strlen(content);
if (len > 0 && content[len - 1] == '\n') {
content[len - 1] = '\0'; // remove \n artifact
}
err = _set_value (hdf, name, content, 1, 1, 0, attr, NULL);
free(content);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == ':') /* link */
{
*s = '\0';
name = neos_strip(name);
s++;
value = neos_strip(s);
err = _set_value (hdf, name, value, 1, 1, 1, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '{') /* deeper */
{
*s = '\0';
name = neos_strip(name);
lower = hdf_get_obj (hdf, name);
if (lower == NULL)
{
err = _set_value (hdf, name, NULL, 1, 1, 0, attr, &lower);
}
else
{
err = _set_value (lower, NULL, lower->value, 1, 1, 0, attr, NULL);
}
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
err = _hdf_read_string (lower, str, line, path, lineno, include_handle,
1);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '<' && s[1] == '<') /* multi-line assignment */
{
char *m;
int msize = 0;
int mmax = 128;
int l;
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
l = strlen(value);
if (l == 0)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] No multi-assignment terminator given: %s", path, *lineno,
line->buf);
return err;
}
m = (char *) malloc (mmax * sizeof(char));
if (m == NULL)
{
return nerr_raise(NERR_NOMEM,
"[%s:%d] Unable to allocate memory for multi-line assignment to %s",
path, *lineno, name);
}
while (_copy_line (str, m+msize, mmax-msize) != 0)
{
(*lineno)++;
if (!strncmp(value, m+msize, l) && isspace(m[msize+l]))
{
m[msize] = '\0';
break;
}
msize += strlen(m+msize);
if (msize + l + 10 > mmax)
{
void *new_ptr;
mmax += 128;
new_ptr = realloc (m, mmax * sizeof(char));
if (new_ptr == NULL)
{
free(m);
return nerr_raise(NERR_NOMEM,
"[%s:%d] Unable to allocate memory for multi-line assignment to %s: size=%d",
path, *lineno, name, mmax);
}
m = (char *) new_ptr;
}
}
err = _set_value (hdf, name, m, 0, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
free (m);
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else
{
err = nerr_raise(NERR_PARSE, "[%s:%d] Unable to parse line %s", path,
*lineno, line->buf);
return err;
}
}
}
if (expect_end_brace) {
err = nerr_raise(NERR_PARSE, "[%s:%d] Missing matching }", path, *lineno);
return err;
}
return STATUS_OK;
}
