//-------------------------------------------------------------------------- bool groupman_t::parse_nodeset( psupergroup_t sg, char *grpstr) { // Find node group bounds for ( /*init*/ char *p_group_start = NULL, *p_group_end = NULL; /* cond*/(p_group_start = strchr(grpstr, '(')) != NULL && (p_group_start = skip_spaces(p_group_start+1), (p_group_end = strchr(p_group_start, ')')) != NULL); /*incr*/) { // Terminate the string with the closing parenthesis *p_group_end = '\0'; // Advance to next group grpstr = skip_spaces(p_group_end + 1); // Add a new group pnodegroup_t ng = sg->add_nodegroup(); for (/*init*/ char *saved_ptr, *p = p_group_start, *token = qstrtok(p, ",", &saved_ptr); /*cond*/ p != NULL; /*incr*/ p = qstrtok(NULL, ",", &saved_ptr)) { p = skip_spaces(p); int nid; ea_t start = 0, end = 0; if (qsscanf(p, "%d : %a : %a", &nid, &start, &end) <= 0) continue; // Create an ND nodedef_t *nd = ng->add_node(); nd->nid = nid; nd->start = start; nd->end = end; // Map this node map_nodedef(nid, nd); } } return true; }
void Board_write_message(int board_type, struct char_data * ch, char *arg) { char *tmstr; int len; time_t ct; char buf[MAX_INPUT_LENGTH], buf2[MAX_INPUT_LENGTH]; if (WRITE_LVL(board_type) != 0 && !COM_FLAGGED(ch, WRITE_LVL(board_type))) { send_to_char("You are not holy enough to write on this board.\r\n", ch); return; } if (num_of_msgs[board_type] >= MAX_BOARD_MESSAGES) { send_to_char("The board is full.\r\n", ch); return; } if ((NEW_MSG_INDEX(board_type).slot_num = find_slot()) == -1) { send_to_char("The board is malfunctioning - sorry.\r\n", ch); stderr_log("SYSERR: Board: failed to find empty slot on write."); return; } /* skip blanks */ skip_spaces(&arg); delete_doubledollar(arg); if (!*arg) { send_to_char("We must have a headline!\r\n", ch); return; } ct = time(0); tmstr = (char *) asctime(localtime(&ct)); *(tmstr + strlen(tmstr) - 1) = '\0'; sprintf(buf2, "(%s)", GET_NAME(ch)); sprintf(buf, "%6.10s %-12s :: %s", tmstr, buf2, arg); len = strlen(buf) + 1; if (!(NEW_MSG_INDEX(board_type).heading = (char *) malloc(sizeof(char) * len))) { send_to_char("The board is malfunctioning - sorry.\r\n", ch); return; } strcpy(NEW_MSG_INDEX(board_type).heading, buf); NEW_MSG_INDEX(board_type).heading[len - 1] = '\0'; NEW_MSG_INDEX(board_type).level = GET_LEVEL(ch); sprintf(logbuffer, "%s writing new message (%s) on board in #%d", GET_NAME(ch), buf, world[ch->in_room].number); mudlog(logbuffer, 'B', COM_ADMIN, FALSE); send_to_char("Write your message. (/s saves /h for help)\r\n\r\n", ch); act("$n starts to write a message.", TRUE, ch, 0, 0, TO_ROOM); if (!IS_NPC(ch)) SET_BIT(PLR_FLAGS(ch), PLR_WRITING); ch->desc->str = &(msg_storage[NEW_MSG_INDEX(board_type).slot_num]); ch->desc->max_str = MAX_MESSAGE_LENGTH; ch->desc->mail_to = (char*) board_type + BOARD_MAGIC; num_of_msgs[board_type]++; }
void perform_net_load(struct descriptor_data *d, char *arg) { int skill_num, percent; long int cost; skip_spaces(&arg); if (!*arg) { d_printf(d, "Usage: load <program>\r\n"); return; } skill_num = find_skill_num(arg); if (skill_num < 1) { d_printf(d, "Error: program '%s' not found\r\n", arg); return; } if ((SPELL_GEN(skill_num, CLASS_CYBORG) > 0 && GET_CLASS(d->creature) != CLASS_CYBORG) || (GET_REMORT_GEN(d->creature) < SPELL_GEN(skill_num, CLASS_CYBORG)) || (GET_LEVEL(d->creature) < SPELL_LEVEL(skill_num, CLASS_CYBORG))) { d_printf(d, "Error: resources unavailable to load '%s'\r\n", arg); return; } if (GET_SKILL(d->creature, skill_num) >= LEARNED(d->creature)) { d_printf(d, "Program fully installed on local system.\r\n"); return; } cost = GET_SKILL_COST(d->creature, skill_num); d_printf(d, "Program cost: %10ld Account balance; %'" PRId64 "\r\n", cost, d->account->bank_future); if (d->account->bank_future < cost) { d_printf(d, "Error: insufficient funds in your account\r\n"); return; } withdraw_future_bank(d->account, cost); percent = MIN(MAXGAIN(d->creature), MAX(MINGAIN(d->creature), GET_INT(d->creature) * 2)); percent = MIN(LEARNED(d->creature) - GET_SKILL(d->creature, skill_num), percent); SET_SKILL(d->creature, skill_num, GET_SKILL(d->creature, skill_num) + percent); d_printf(d, "Program download: %s terminating, %d percent transfer.\r\n", spell_to_str(skill_num), percent); if (GET_SKILL(d->creature, skill_num) >= LEARNED(d->creature)) d_printf(d, "Program fully installed on local system.\r\n"); else d_printf(d, "Program %d%% installed on local system.\r\n", GET_SKILL(d->creature, skill_num)); }
void config_file::init(const string& filename, istream& is) { string cur_sect; int lineno = 1; for (string line; getline(is, line); ++lineno) { const char* p = line.c_str(); const char* st = p; p = skip_spaces(p); if (*p=='\0') continue; if (*p==';') continue; if (*p=='[') { const char* q = strchr(p, ']'); if (q == NULL) throw parse_error(filename, lineno, line.length(), "']' missing"); cur_sect = string(p+1, q); q = skip_spaces(q+1); if (*q != '\0') throw parse_error(filename, lineno, q-st, "invalid character"); (void)dat[cur_sect]; continue; } const char* q = strchr(p, '='); if (q == NULL) throw parse_error(filename, lineno, line.length(), "'=' missing"); string key(trim(string(p, q))); string val(trim(q+1)); if (val.length() >= 2) { if (val[0] == '"' && val[val.length()-1] == '"') val.assign(val, 1, val.length()-2); } dat[cur_sect][key] = val; } }
static int check_newline(struct dsa *dsa) { if (skip_spaces(dsa, 0)) return 1; if (!(dsa->c == EOF || dsa->c == '\n')) { xprintf("%s:%d: extra symbols detected\n", dsa->fname, dsa->seqn); return 1; } if (get_char(dsa)) return 1; return 0; }
static int check_colon(struct dsa *dsa) { if (skip_spaces(dsa, 0)) return 1; if (dsa->c != ':') { xprintf("%s:%d: missing colon after `%s'\n", dsa->fname, dsa->seqn, dsa->token); return 1; } if (get_char(dsa)) return 1; return 0; }
static int fs_cmd_user(struct fs_info *session) { /* Usage: user <user-name> */ int ret; char *tmp, *arg_username, *password; if (!session->is_connected) { fprintf(stderr, "Not connected.\n"); return FTP_RET_FAIL; } /* Get args */ tmp = &session->cmd_buff[0]; skip_spaces(tmp); skip_word(tmp); skip_spaces(tmp); arg_username = tmp; split_word(arg_username); if (*arg_username == '\0') { fprintf(stderr, "User name is not specified.\n"); errno = EINVAL; return FTP_RET_ERROR; } /* --- END OF Get args --- */ ret = fs_execute(session, "USER %s\r\n", arg_username); if (ret != FTP_RET_OK) { return ret; } password = getpass("Password: "******"Cant get password for %s.\n", arg_username); errno = EINVAL; return FTP_RET_ERROR; } ret = fs_execute(session, "PASS %s\r\n", password); if (ret != FTP_RET_OK) { return ret; } return FTP_RET_OK; }
Token *ScannerImp::nextToken() { if(skip_spaces())return NULL; runMachines(); TType typ = manager->getType(); skip_comment(&typ); int wortlaenge = manager->getLexemLength(); int wrongChars = manager->ungetCtr(); buffer->ungetChar(wrongChars); return createToken(typ,wortlaenge,x,y); }
char *spk_s2uchar(char *start, char *dest) { int val; /* Do not replace with kstrtoul: here we need start to be updated */ val = simple_strtoul(skip_spaces(start), &start, 10); if (*start == ',') start++; *dest = (u_char)val; return start; }
static inline int empty_elsed(const char *in) { in = skip_spaces(in); in += LEN("#elsed"); while (*in == ' ' || *in == '\t') in++; if (*in == '\n') return 1; else return 0; }
void parse(const char* json, JsonObject& object) { CE_ASSERT_NOT_NULL(json); json = skip_spaces(json); if (*json == '{') parse_object(json, object); else parse_root_object(json, object); }
void ScannerImp::skip_comment(TType *typ) { if(*typ == CommentBegin) { while (*typ != CommentEnd || skip_spaces()) { runMachines(); *typ = manager->getType(); } buffer->ungetChar(1); runMachines(); *typ = manager->getType(); } }
void parse(const char* json, JsonObject& object) { CE_ENSURE(NULL != json); json = skip_spaces(json); if (*json == '{') parse_object(json, object); else parse_root_object(json, object); }
int get_number_or_range (struct get_number_or_range_state *state) { if (*state->string != '-') { /* Default case: state->string is pointing either to a solo number, or to the first number of a range. */ state->last_retval = get_number_trailer (&state->string, '-'); if (*state->string == '-') { char **temp; /* This is the start of a range (<number1> - <number2>). Skip the '-', parse and remember the second number, and also remember the end of the final token. */ temp = &state->end_ptr; state->end_ptr = skip_spaces (state->string + 1); state->end_value = get_number (temp); if (state->end_value < state->last_retval) { error (_("inverted range")); } else if (state->end_value == state->last_retval) { /* Degenerate range (number1 == number2). Advance the token pointer so that the range will be treated as a single number. */ state->string = state->end_ptr; } else state->in_range = 1; } } else if (! state->in_range) error (_("negative value")); else { /* state->string points to the '-' that betokens a range. All number-parsing has already been done. Return the next integer value (one greater than the saved previous value). Do not advance the token pointer until the end of range is reached. */ if (++state->last_retval == state->end_value) { /* End of range reached; advance token pointer. */ state->string = state->end_ptr; state->in_range = 0; } } state->finished = *state->string == '\0'; return state->last_retval; }
static void __init dm_substitute_devices(char *str, size_t str_len) { char *candidate = str; char *candidate_end = str; char old_char; size_t len = 0; dev_t dev; if (str_len < 3) return; while (str && *str) { candidate = strchr(str, '/'); if (!candidate) break; /* Avoid embedded slashes */ if (candidate != str && *(candidate - 1) != DM_FIELD_SEP) { str = strchr(candidate, DM_FIELD_SEP); continue; } len = get_dm_option(candidate, &candidate_end, DM_FIELD_SEP); str = skip_spaces(candidate_end); if (len < 3 || len > 37) /* name_to_dev_t max; maj:mix min */ continue; /* Temporarily terminate with a nul */ candidate_end--; old_char = *candidate_end; *candidate_end = '\0'; DMDEBUG("converting candidate device '%s' to dev_t", candidate); /* Use the boot-time specific device naming */ dev = name_to_dev_t(candidate); *candidate_end = old_char; DMDEBUG(" -> %u", dev); /* No suitable replacement found */ if (!dev) continue; /* Rewrite the /dev/path as a major:minor */ len = snprintf(candidate, len, "%u:%u", MAJOR(dev), MINOR(dev)); if (!len) { DMERR("error substituting device major/minor."); break; } candidate += len; /* Pad out with spaces (fixing our nul) */ while (candidate < candidate_end) *(candidate++) = DM_FIELD_SEP; } }
static int skip_code(parser_ctx_t *ctx, BOOL exec_else) { int if_depth = 1; const WCHAR *ptr; while(1) { ptr = strchrW(ctx->ptr, '@'); if(!ptr) { WARN("No @end\n"); return lex_error(ctx, JS_E_EXPECTED_CCEND); } ctx->ptr = ptr+1; if(!check_keyword(ctx, endW, NULL)) { if(--if_depth) continue; return 0; } if(exec_else && !check_keyword(ctx, elifW, NULL)) { if(if_depth > 1) continue; if(!skip_spaces(ctx) || *ctx->ptr != '(') return lex_error(ctx, JS_E_MISSING_LBRACKET); if(!parse_cc_expr(ctx)) return -1; if(!get_ccbool(ctx->ccval)) continue; /* skip block of code */ /* continue parsing */ ctx->cc_if_depth++; return 0; } if(exec_else && !check_keyword(ctx, elseW, NULL)) { if(if_depth > 1) continue; /* parse else block */ ctx->cc_if_depth++; return 0; } if(!check_keyword(ctx, ifW, NULL)) { if_depth++; continue; } ctx->ptr++; } }
static char * __init dm_setup_parse_device_args(char *str) { char *next = NULL; size_t len = 0; /* Grab the logical name of the device to be exported to udev */ len = get_dm_option(str, &next, DM_FIELD_SEP); if (!len) { DMERR("failed to parse device name"); goto parse_fail; } len = min(len + 1, sizeof(dm_setup_args.name)); strlcpy(dm_setup_args.name, str, len); /* includes nul */ str = skip_spaces(next); /* Grab the UUID value or "none" */ len = get_dm_option(str, &next, DM_FIELD_SEP); if (!len) { DMERR("failed to parse device uuid"); goto parse_fail; } len = min(len + 1, sizeof(dm_setup_args.uuid)); strlcpy(dm_setup_args.uuid, str, len); str = skip_spaces(next); /* Determine if the table/device will be read only or read-write */ if (!strncmp("ro,", str, 3)) { dm_setup_args.ro = 1; } else if (!strncmp("rw,", str, 3)) { dm_setup_args.ro = 0; } else { DMERR("failed to parse table mode"); goto parse_fail; } str = skip_spaces(str + 3); return str; parse_fail: return NULL; }
bool parse_attr_value( const char * &str, char * buf ) { int pos = 0; skip_spaces( str ); if (*str=='\"') { str++; for ( ; str[pos] && str[pos]!='\"'; pos++) { if (pos>=64) return false; } if (str[pos]!='\"') return false; for (int i=0; i<pos; i++) buf[i] = str[i]; buf[pos] = 0; str += pos+1; skip_spaces( str ); if (*str != ']') return false; str++; return true; } else { for ( ; str[pos] && str[pos]!=' ' && str[pos]!='\t' && str[pos]!=']'; pos++) { if (pos>=64) return false; } if (str[pos]!=']') return false; for (int i=0; i<pos; i++) buf[i] = str[i]; buf[pos] = 0; str+=pos; str++; return true; } }
int command_mtrigger(char_data *actor, char *cmd, char *argument) { char_data *ch, *ch_next; trig_data *t; char buf[MAX_INPUT_LENGTH]; /* prevent people we like from becoming trapped :P */ if (!valid_dg_target(actor, 0)) return 0; for (ch = world[IN_ROOM(actor)].people; ch; ch = ch_next) { ch_next = ch->next_in_room; if (SCRIPT_CHECK(ch, MTRIG_COMMAND) && !AFF_FLAGGED(ch, AFF_CHARM) && ((actor != ch) || CONFIG_SCRIPT_PLAYERS)) { for (t = TRIGGERS(SCRIPT(ch)); t; t = t->next) { if (!TRIGGER_CHECK(t, MTRIG_COMMAND)) continue; if (!GET_TRIG_ARG(t) || !*GET_TRIG_ARG(t)) { mudlog(NRM, LVL_BUILDER, TRUE, "SYSERR: Command Trigger #%d has no text argument!", GET_TRIG_VNUM(t)); continue; } if (*GET_TRIG_ARG(t) == '*' || !strn_cmp(GET_TRIG_ARG(t), cmd, strlen(GET_TRIG_ARG(t)))) { ADD_UID_VAR(buf, t, actor, "actor", 0); skip_spaces(&argument); add_var(&GET_TRIG_VARS(t), "arg", argument, 0); skip_spaces(&cmd); add_var(&GET_TRIG_VARS(t), "cmd", cmd, 0); if (script_driver(&ch, t, MOB_TRIGGER, TRIG_NEW)) return 1; } } } } return 0; }
static int fs_cmd_mv(struct fs_info *session) { /* Usage: mv <from-name> <to-name> */ int ret; char *tmp, *arg_fromname, *arg_toname; if (!session->is_connected) { fprintf(stderr, "Not connected.\n"); return FTP_RET_FAIL; } /* Get args */ tmp = &session->cmd_buff[0]; skip_spaces(tmp); skip_word(tmp); skip_spaces(tmp); arg_fromname = tmp; skip_word(tmp); skip_spaces(tmp); arg_toname = tmp; split_word(arg_fromname); split_word(arg_toname); if ((*arg_fromname == '\0') || (*arg_toname == '\0')) { fprintf(stderr, "Please specify source and destonation names.\n"); errno = EINVAL; return FTP_RET_ERROR; } /* --- END OF Get args --- */ fprintf(stdout, "from: '%s`, to: '%s`\n", arg_fromname, arg_toname); ret = fs_execute(session, "RNFR %s\r\n", arg_fromname); if (ret != FTP_RET_OK) { return ret; } ret = fs_execute(session, "RNTO %s\r\n", arg_toname); if (ret != FTP_RET_OK) { return ret; } return FTP_RET_OK; }
/* * Parses one line from {fs,m}tab */ static int mnt_parse_table_line(struct libmnt_fs *fs, char *s) { int rc, n = 0; char *src, *fstype, *optstr; rc = sscanf(s, UL_SCNsA" " /* (1) source */ UL_SCNsA" " /* (2) target */ UL_SCNsA" " /* (3) FS type */ UL_SCNsA" " /* (4) options */ "%n", /* byte count */ &src, &fs->target, &fstype, &optstr, &n); if (rc == 4) { unmangle_string(src); unmangle_string(fs->target); unmangle_string(fstype); unmangle_string(optstr); rc = __mnt_fs_set_source_ptr(fs, src); if (!rc) rc = __mnt_fs_set_fstype_ptr(fs, fstype); if (!rc) rc = mnt_fs_set_options(fs, optstr); free(optstr); } else { DBG(TAB, mnt_debug("tab parse error: [sscanf rc=%d]: '%s'", rc, s)); rc = -EINVAL; } if (rc) return rc; /* error */ fs->passno = fs->freq = 0; s = skip_spaces(s + n); if (*s) { if (next_number(&s, &fs->freq) != 0) { if (*s) { DBG(TAB, mnt_debug("tab parse error: [freq]")); rc = -EINVAL; } } else if (next_number(&s, &fs->passno) != 0 && *s) { DBG(TAB, mnt_debug("tab parse error: [passno]")); rc = -EINVAL; } } return rc; }
static void read_line () { Argc = 0; Next = Line; while (!Done) { skip_spaces(); if (Done) break; get_arg(); } Done = FALSE; }
/* generic fn for modifying a bitvector */ void olc_bitvector(int *bv, const char **names, char *arg) { int newbv, flagnum, remove = 0; char *this_name; skip_spaces(&arg); if (!*arg) { send_to_char("Flag list or flag modifiers required.\r\n", olc_ch); return; } /* determine if this is 'absolute' or 'relative' mode */ if (*arg == '+' || *arg == '-') newbv = *bv; else newbv = 0; while (*arg) { arg = one_argument(arg, buf); /* get next argument */ /* change to upper-case */ for (this_name = buf; *this_name; this_name++) CAP(this_name); /* determine if this is an add or a subtract */ if (*buf == '+' || *buf == '-') { this_name = buf + 1; if (*buf == '-') remove = TRUE; else remove = FALSE; } else { this_name = buf; remove = FALSE; } /* figure out which one we're dealing with */ if ((flagnum = search_block(this_name, names, TRUE)) < 0) { sprintf(buf2, "Unknown flag: %s\r\n", this_name); send_to_char(buf2, olc_ch); } else { if (remove) REMOVE_BIT(newbv, (1 << flagnum)); else SET_BIT(newbv, (1 << flagnum)); } } *bv = newbv; sprintbit(newbv, names, buf); sprintf(buf2, "Flags now set to: %s\r\n", buf); send_to_char(buf2, olc_ch); }
static void parse_header(Socket_t *sock) { char *p; if ((p = match(sock, "CONTENT-LENGTH:")) != NULL) { sock->length = atoi(skip_spaces(p)); #ifdef REQUEST_DEBUG printf("Length: %d\n", sock->length); #endif } if (sock->handler) (*sock->handler)(sock, HP_HEADER); }
void list_wands_staves (struct char_data *ch, char *input) { int type=0; int i=0; int j=0; int k=0; char *wsbuf = get_buffer(MAX_STRING_LENGTH); skip_spaces(&input); switch (input[0]) { case 'T': case 't': type = ITEM_STAFF; break; case 'W': case 'w': type = ITEM_WAND; break; default: extended_mudlog(NRM, SYSL_BUGS, TRUE, "Default reached in list_scrolls_potions (arg = %s)", input); release_buffer(wsbuf); return; } /*switch...*/ wsbuf[0]='\0'; for (i=0;i<top_of_objt;i++) { j=obj_proto[i].obj_flags.type_flag; /*look for specific sort of item*/ if (j == type) { /*found one*/ sprintf(wsbuf+strlen(wsbuf),"[%5d] %-30s", /*print vnum, short description*/ GET_OBJ_VNUM(&obj_proto[i]), obj_proto[i].short_description); /* * values 0-3: * Potion, Scroll - up to three spells [values 1-3] */ sprintf(wsbuf+strlen(wsbuf), " Spells: "); if (type==ITEM_STAFF) { /*staves have only one spell*/ if ((GET_OBJ_VAL(&obj_proto[i], 3)) != (-1)) sprintf(wsbuf+strlen(wsbuf), "%s ", skill_name(GET_OBJ_VAL(&obj_proto[i], 3))); } else { for (k=1; k < 4; k++) { if ((GET_OBJ_VAL(&obj_proto[i], k)) != (-1)) sprintf(wsbuf+strlen(wsbuf), "%s ", skill_name(GET_OBJ_VAL(&obj_proto[i], k))); } sprintf(wsbuf+strlen(wsbuf), "\r\n"); } } /*if j == type*/ } /*for i...*/ page_string (ch->desc, wsbuf, 1); release_buffer(wsbuf); }
static css_decl_code parse_property_name( const char * & res ) { const char * str = res; for (int i=1; css_decl_name[i]; i++) { if (substr_compare( css_decl_name[i], str )) { // found! skip_spaces(str); if ( substr_compare( ":", str )) { #ifdef DUMP_CSS_PARSING CRLog::trace("property name: %s", lString8(res, str-res).c_str() ); #endif skip_spaces(str); res = str; return (css_decl_code)i; } } } return cssd_unknown; }
/** * aa_split_fqname - split a fqname into a profile and namespace name * @fqname: a full qualified name in namespace profile format (NOT NULL) * @ns_name: pointer to portion of the string containing the ns name (NOT NULL) * * Returns: profile name or NULL if one is not specified * * Split a namespace name from a profile name (see policy.c for naming * description). If a portion of the name is missing it returns NULL for * that portion. * * NOTE: may modify the @fqname string. The pointers returned point * into the @fqname string. */ char *aa_split_fqname(char *fqname, char **ns_name) { char *name = strim(fqname); *ns_name = NULL; if (name[0] == ':') { char *split = strchr(&name[1], ':'); *ns_name = skip_spaces(&name[1]); if (split) { /* overwrite ':' with \0 */ *split = 0; name = skip_spaces(split + 1); } else /* a ns name without a following profile is allowed */ name = NULL; } if (name && *name == 0) name = NULL; return name; }
Parser::Arg Parser::getFullArg(char left, char right, bool allow_escaping) { skip_spaces(true); // This is needed if a partial file ends with a command without arguments, // e. g. \medskip if (! good()) return make_pair(false, string()); int group_level = 0; string result; Token t = get_token(); if (t.cat() == catComment || t.cat() == catEscape || t.character() != left) { putback(); return make_pair(false, string()); } else { while (good()) { t = get_token(); // honor grouping if (left != '{' && t.cat() == catBegin) { ++group_level; continue; } if (left != '{' && t.cat() == catEnd) { --group_level; continue; } // Ignore comments if (t.cat() == catComment) { if (!t.cs().empty()) cerr << "Ignoring comment: " << t.asInput(); continue; } if (allow_escaping) { if (t.cat() != catEscape && t.character() == right && group_level == 0) break; } else { if (t.character() == right) { if (t.cat() == catEscape) result += '\\'; if (group_level == 0) break; } } result += t.asInput(); } } return make_pair(true, result); }
static struct cnfnode *parse_snmp_table(const char *name, const char *p, char **cols, int ncols) { struct cnfnode *cn_table, *cn_top; cn_top = create_cnfnode(name); skip_spaces(&p); cn_table = parse_table_line(&p, cols, ncols, -1); append_node(cn_top, cn_table); return cn_top; }
/* Parse one or more whitespace characters starting from '*pp' * until 'end' is reached. Updates '*pp' on exit. * * Return 0 on success, -1 on failure. */ static int parse_spaces(const char** pp, const char* end) { const char* p = *pp; if (p >= end || !is_space(*p)) { errno = EINVAL; return -1; } p = skip_spaces(p, end); *pp = p; return 0; }