int parse_initialized_ipset(const char *text,ipset *is){
int invert,i,inbracket = 0;
const char *start = text;
is->rangecount = 0;
parse_whitespace(&text);
// is the ! operator being used to invert the selection?
invert = 0;
if(*text == '!'){
invert = 1;
++text;
}
parse_whitespace(&text);
// are we allowing a comma-separated list of ip ranges?
if(*text == '['){
inbracket = 1;
++text;
}
// accept the any keyword
if(strncasecmp(text,"any",3) == 0){
if(add_iprange(is,&IPRANGE_ALL) < 0){
return -1;
}
text += 3;
}else{
if((i = parse_ipranges(text,is)) <= 0){
return -1;
}
text += i;
}
parse_whitespace(&text);
if(inbracket){
if(*text != ']'){
bitch("Missing right bracket: %s\n",start);
free_ipset(is);
return -1;
}
++text;
}
// frees everything associated on error
if(postparse_ipset(is,invert)){
return -1;
}
return text - start;
}
bool parse_comma_wsp(const char*& c, const char* const end)
{
if(!ws_p(*c) && *c != ',')
return false;
if(parse_whitespace(c, end) && c == end)
return true;
if(*c == ',' && ++c == end)
return true;
parse_whitespace(c, end);
return true;
}
/**
* Skips the next bit of whatever and returns the type of block.
*
* pc.str is the input text.
* pc.len in the output length.
* pc.type is the output type
* pc.column is output column
*
* @param pc The structure to update, str is an input.
* @return true/false - whether anything was parsed
*/
static bool parse_next(tok_ctx& ctx, chunk_t& pc)
{
const chunk_tag_t *punc;
int ch, ch1;
if (!ctx.more())
{
//fprintf(stderr, "All done!\n");
return(false);
}
/* Save off the current column */
pc.orig_line = ctx.c.row;
pc.column = ctx.c.col;
pc.orig_col = ctx.c.col;
pc.type = CT_NONE;
pc.nl_count = 0;
pc.flags = 0;
/* If it is turned off, we put everything except newlines into CT_UNKNOWN */
if (cpd.unc_off)
{
if (parse_ignored(ctx, pc))
{
return(true);
}
}
/**
* Parse whitespace
*/
if (parse_whitespace(ctx, pc))
{
return(true);
}
/**
* Handle unknown/unhandled preprocessors
*/
if ((cpd.in_preproc > CT_PP_BODYCHUNK) &&
(cpd.in_preproc <= CT_PP_OTHER))
{
pc.str.clear();
tok_info ss;
ctx.save(ss);
/* Chunk to a newline or comment */
pc.type = CT_PREPROC_BODY;
int last = 0;
while (ctx.more())
{
int ch = ctx.peek();
if ((ch == '\n') || (ch == '\r'))
{
/* Back off if this is an escaped newline */
if (last == '\\')
{
ctx.restore(ss);
pc.str.pop_back();
}
break;
}
/* Quit on a C++ comment start */
if ((ch == '/') && (ctx.peek(1) == '/'))
{
break;
}
last = ch;
ctx.save(ss);
pc.str.append(ctx.get());
}
if (pc.str.size() > 0)
{
return(true);
}
}
/**
* Detect backslash-newline
*/
if ((ctx.peek() == '\\') && parse_bs_newline(ctx, pc))
{
return(true);
}
/**
* Parse comments
*/
if (parse_comment(ctx, pc))
{
return(true);
}
/* Parse code placeholders */
if (parse_code_placeholder(ctx, pc))
{
return(true);
}
/* Check for C# literal strings, ie @"hello" and identifiers @for*/
if ((cpd.lang_flags & LANG_CS) && (ctx.peek() == '@'))
{
if (ctx.peek(1) == '"')
{
parse_cs_string(ctx, pc);
return(true);
}
/* check for non-keyword identifiers such as @if @switch, etc */
if (CharTable::IsKw1(ctx.peek(1)))
{
parse_word(ctx, pc, true);
return(true);
}
}
/* Check for C# Interpolated strings */
if ((cpd.lang_flags & LANG_CS) && (ctx.peek() == '$') && (ctx.peek(1) == '"'))
{
parse_cs_interpolated_string(ctx, pc);
return(true);
}
/* handle VALA """ strings """ */
if ((cpd.lang_flags & LANG_VALA) &&
(ctx.peek() == '"') &&
(ctx.peek(1) == '"') &&
(ctx.peek(2) == '"'))
{
parse_verbatim_string(ctx, pc);
return(true);
}
/* handle C++0x strings u8"x" u"x" U"x" R"x" u8R"XXX(I'm a "raw UTF-8" string.)XXX" */
ch = ctx.peek();
if ((cpd.lang_flags & LANG_CPP) &&
((ch == 'u') || (ch == 'U') || (ch == 'R')))
{
int idx = 0;
bool is_real = false;
if ((ch == 'u') && (ctx.peek(1) == '8'))
{
idx = 2;
}
else if (unc_tolower(ch) == 'u')
{
idx++;
}
if (ctx.peek(idx) == 'R')
{
idx++;
is_real = true;
}
if (ctx.peek(idx) == '"')
{
if (is_real)
{
if (parse_cr_string(ctx, pc, idx))
{
return(true);
}
}
else
{
if (parse_string(ctx, pc, idx, true))
{
parse_suffix(ctx, pc, true);
return(true);
}
}
}
}
/* PAWN specific stuff */
if (cpd.lang_flags & LANG_PAWN)
{
if ((cpd.preproc_ncnl_count == 1) &&
((cpd.in_preproc == CT_PP_DEFINE) ||
(cpd.in_preproc == CT_PP_EMIT)))
{
parse_pawn_pattern(ctx, pc, CT_MACRO);
return(true);
}
/* Check for PAWN strings: \"hi" or !"hi" or !\"hi" or \!"hi" */
if ((ctx.peek() == '\\') || (ctx.peek() == '!'))
{
if (ctx.peek(1) == '"')
{
parse_string(ctx, pc, 1, (ctx.peek() == '!'));
return(true);
}
else if (((ctx.peek(1) == '\\') || (ctx.peek(1) == '!')) &&
(ctx.peek(2) == '"'))
{
parse_string(ctx, pc, 2, false);
return(true);
}
}
/* handle PAWN preprocessor args %0 .. %9 */
if ((cpd.in_preproc == CT_PP_DEFINE) &&
(ctx.peek() == '%') &&
unc_isdigit(ctx.peek(1)))
{
pc.str.clear();
pc.str.append(ctx.get());
pc.str.append(ctx.get());
pc.type = CT_WORD;
return(true);
}
}
/**
* Parse strings and character constants
*/
if (parse_number(ctx, pc))
{
return(true);
}
if (cpd.lang_flags & LANG_D)
{
/* D specific stuff */
if (d_parse_string(ctx, pc))
{
return(true);
}
}
else
{
/* Not D stuff */
/* Check for L'a', L"abc", 'a', "abc", <abc> strings */
ch = ctx.peek();
ch1 = ctx.peek(1);
if ((((ch == 'L') || (ch == 'S')) &&
((ch1 == '"') || (ch1 == '\''))) ||
(ch == '"') ||
(ch == '\'') ||
((ch == '<') && (cpd.in_preproc == CT_PP_INCLUDE)))
{
parse_string(ctx, pc, unc_isalpha(ch) ? 1 : 0, true);
return(true);
}
if ((ch == '<') && (cpd.in_preproc == CT_PP_DEFINE))
{
if (chunk_get_tail()->type == CT_MACRO)
{
/* We have "#define XXX <", assume '<' starts an include string */
parse_string(ctx, pc, 0, false);
return(true);
}
}
}
/* Check for Objective C literals and VALA identifiers ('@1', '@if')*/
if ((cpd.lang_flags & (LANG_OC | LANG_VALA)) && (ctx.peek() == '@'))
{
int nc = ctx.peek(1);
if ((nc == '"') || (nc == '\''))
{
/* literal string */
parse_string(ctx, pc, 1, true);
return(true);
}
else if ((nc >= '0') && (nc <= '9'))
{
/* literal number */
pc.str.append(ctx.get()); /* store the '@' */
parse_number(ctx, pc);
return(true);
}
}
/* Check for pawn/ObjectiveC/Java and normal identifiers */
if (CharTable::IsKw1(ctx.peek()) ||
((ctx.peek() == '@') && CharTable::IsKw1(ctx.peek(1))))
{
parse_word(ctx, pc, false);
return(true);
}
/* see if we have a punctuator */
char punc_txt[4];
punc_txt[0] = ctx.peek();
punc_txt[1] = ctx.peek(1);
punc_txt[2] = ctx.peek(2);
punc_txt[3] = ctx.peek(3);
if ((punc = find_punctuator(punc_txt, cpd.lang_flags)) != NULL)
{
int cnt = strlen(punc->tag);
while (cnt--)
{
pc.str.append(ctx.get());
}
pc.type = punc->type;
pc.flags |= PCF_PUNCTUATOR;
return(true);
}
/* throw away this character */
pc.type = CT_UNKNOWN;
pc.str.append(ctx.get());
LOG_FMT(LWARN, "%s:%d Garbage in col %d: %x\n",
cpd.filename, pc.orig_line, (int)ctx.c.col, pc.str[0]);
cpd.error_count++;
return(true);
} // parse_next
static bool parse_ignored(tok_ctx& ctx, chunk_t& pc)
{
int nl_count = 0;
/* Parse off newlines/blank lines */
while (parse_newline(ctx))
{
nl_count++;
}
if (nl_count > 0)
{
pc.nl_count = nl_count;
pc.type = CT_NEWLINE;
return(true);
}
/* See if the UO_enable_processing_cmt text is on this line */
ctx.save();
pc.str.clear();
while (ctx.more() &&
(ctx.peek() != '\r') &&
(ctx.peek() != '\n'))
{
pc.str.append(ctx.get());
}
if (pc.str.size() == 0)
{
/* end of file? */
return(false);
}
/* Note that we aren't actually making sure this is in a comment, yet */
const char *ontext = cpd.settings[UO_enable_processing_cmt].str;
if (ontext == NULL)
{
ontext = UNCRUSTIFY_ON_TEXT;
}
if (pc.str.find(ontext) < 0)
{
pc.type = CT_IGNORED;
return(true);
}
ctx.restore();
/* parse off whitespace leading to the comment */
if (parse_whitespace(ctx, pc))
{
pc.type = CT_IGNORED;
return(true);
}
/* Look for the ending comment and let it pass */
if (parse_comment(ctx, pc) && !cpd.unc_off)
{
return(true);
}
/* Reset the chunk & scan to until a newline */
pc.str.clear();
while (ctx.more() &&
(ctx.peek() != '\r') &&
(ctx.peek() != '\n'))
{
pc.str.append(ctx.get());
}
if (pc.str.size() > 0)
{
pc.type = CT_IGNORED;
return(true);
}
return(false);
} // parse_ignored
static int
parse_ipv4range(const char *buf,iprange *ir){
const char *start = buf;
int i;
parse_whitespace(&buf);
if(*buf == '-' || *buf == ':'){
++buf;
ir->lower = 0;
if((i = parse_ipv4address(buf,&ir->upper)) <= 0){
goto err;
}
buf += i;
goto done;
}
if((i = parse_ipv4address(buf,&ir->lower)) <= 0){
goto err;
}
buf += i;
ir->lower = ntohl(ir->lower);
if(*buf == '/'){
++buf;
parse_whitespace(&buf);
if(sscanf(buf,"%d",&i) != 1){
goto err;
}
if(i > 0){
ir->lower &= (~0U) << (32 - i);
ir->upper = ir->lower | ((1U << (32 - i)) - 1);
}else if(i == 0){
ir->lower = htonl(0U);
ir->upper = htonl(~0U);
}else{
goto err;
}
while(isdigit(*buf)){
++buf;
}
}else if(*buf == '-' || *buf == ':'){
++buf;
if(!isdigit(*buf)){
ir->upper = htonl(~0U);
goto done;
}
if((i = parse_ipv4address(buf,&ir->upper)) <= 0){
goto err;
}
buf += i;
ir->upper = ntohl(ir->upper);
if(ir->lower > ir->upper){
uint32_t ut;
ut = ir->lower;
ir->lower = ir->upper;
ir->upper = ut;
}
}else{
ir->upper = ir->lower;
}
done:
if(isspace(*buf) || *buf == ',' || *buf == '\0' || *buf == ']' || *buf == '@'){
return buf - start;
}
err:
bitch("Wanted IPv4 address range, got %s\n",start);
return -1;
}
