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; }