예제 #1
0
static unsigned char *
str_rd(struct option *opt, unsigned char **file, int *line)
{
	unsigned char *str = *file;
	struct string str2;

	if (!init_string(&str2)) return NULL;

	/* We're getting used in some parser functions in conf.c as well, and
	 * that's w/ opt == NULL; so don't rely on opt to point anywhere. */
	if (!commandline) {
		if (!isquote(*str)) {
			done_string(&str2);
			return NULL;
		}
		str++;
	}

	while (*str && (commandline || !isquote(*str))) {
		if (*str == '\\') {
			/* FIXME: This won't work on crlf systems. */
			if (str[1] == '\n') { str[1] = ' '; str++; (*line)++; }
			/* When there's quote char, we will just move on there,
			 * thus we will never test for it in while () condition
			 * and we will treat it just as '"', ignoring the
			 * backslash itself. */
			else if (isquote(str[1])) str++;
			/* \\ means \. */
			else if (str[1] == '\\') str++;
		}

		if (*str == '\n') (*line)++;

		add_char_to_string(&str2, *str);
		str++;
	}

	if (!commandline && !*str) {
		done_string(&str2);
		*file = str;
		return NULL;
	}

	str++; /* Skip the quote. */
	if (!commandline) *file = str;

	if (opt && opt->max && str2.length >= opt->max) {
		done_string(&str2);
		return NULL;
	}

	return str2.source;
}
예제 #2
0
/*
 * accumulate a blockquote.
 *
 * one sick horrible thing about blockquotes is that even though
 * it just takes ^> to start a quote, following lines, if quoted,
 * assume that the prefix is ``> ''.   This means that code needs
 * to be indented *5* spaces from the leading '>', but *4* spaces
 * from the start of the line.   This does not appear to be 
 * documented in the reference implementation, but it's the
 * way the markdown sample web form at Daring Fireball works.
 */
static Line *
quoteblock(Paragraph *p, DWORD flags)
{
    Line *t, *q;
    int qp;

    for ( t = p->text; t ; t = q ) {
	if ( isquote(t) ) {
	    /* clip leading spaces */
	    for (qp = 0; T(t->text)[qp] != '>'; qp ++)
		/* assert: the first nonblank character on this line
		 * will be a >
		 */;
	    /* clip '>' */
	    qp++;
	    /* clip next space, if any */
	    if ( T(t->text)[qp] == ' ' )
		qp++;
	    CLIP(t->text, 0, qp);
	    UNCHECK(t);
	    t->dle = mkd_firstnonblank(t);
	}

	q = skipempty(t->next);

	if ( (q == 0) || ((q != t->next) && (!isquote(q) || isdivmarker(q,1,flags))) ) {
	    ___mkd_freeLineRange(t, q);
	    t = q;
	    break;
	}
    }
    if ( isdivmarker(p->text,0,flags) ) {
	char *prefix = "class";
	int i;
	
	q = p->text;
	p->text = p->text->next;

	if ( (i = szmarkerclass(1+T(q->text))) == 3 )
	    /* and this would be an "%id:" prefix */
	    prefix="id";
	    
	if ( p->ident = malloc(4+strlen(prefix)+S(q->text)) )
	    sprintf(p->ident, "%s=\"%.*s\"", prefix, S(q->text)-(i+2),
						     T(q->text)+(i+1) );

	___mkd_freeLine(q);
    }
    return t;
}
예제 #3
0
static gmx_bool parse_string(char **string, int *nr, int ngrps, char **grpname)
{
    char *s, *sp;
    char  c;

    while ((*string)[0] == ' ')
    {
        (*string)++;
    }

    (*nr) = NOTSET;
    if (isquote((*string)[0]))
    {
        c = (*string)[0];
        (*string)++;
        s  = strdup((*string));
        sp = strchr(s, c);
        if (sp != NULL)
        {
            (*string) += sp-s + 1;
            sp[0]      = '\0';
            (*nr)      = find_group(s, ngrps, grpname);
        }
    }

    return (*nr) != NOTSET;
}
예제 #4
0
파일: run4.c 프로젝트: jazzyb/run4
/*
 * Set each of the char*'s in args to point to each of the words in cmd,
 * ignoring empty strings and preserving quoted strings.
 */
void
convert_to_argument_list (char **args, char *cmd)
{
    int i;
    int count;
    int size;
    char within_quotes;

    args[0] = cmd;
    within_quotes = 0;
    size = strlen(cmd);
    for (count = i = 0; i < size; i++) {
	if (isquote(cmd[i])) {
	    if (cmd[i] == within_quotes) {
		within_quotes = 0;
		add_arg_to_list(cmd, i, args, &count);

	    } else if (!within_quotes) {
		within_quotes = cmd[i];
		add_arg_to_list(cmd, i, args, &count);
	    }

	} else if (isspace(cmd[i]) && !within_quotes) {
	    add_arg_to_list(cmd, i, args, &count);

	    if (count > ARG_MAX) {
		fprintf(stderr, "warning: the command exceeds the maximum number of\n"
				"         arguments (%d) allowed by run4; truncating\n",
				ARG_MAX);
		break;
	    }
	}
    }
    args[count+1] = NULL;
}
예제 #5
0
static signed gettoken (char * string)

{
	extern unsigned line;
	signed c;
	do 
	{
		c = getc (stdin);
		if (c == '\n')
		{
			line++;
		}
	}
	while (isspace (c));
	if (isalpha (c) || (c == '_'))
	{
		do 
		{
			* string++ = c;
			c = getc (stdin);
		}
		while (isalnum (c) || (c == '.') || (c == ':') || (c == '_') || (c == '-'));
		ungetc (c, stdin);
		c = 'A';
	}
	else if (isdigit (c))
	{
		do 
		{
			* string++ = c;
			c = getc (stdin);
		}
		while (isdigit (c) || (c == '.'));
		ungetc (c, stdin);
		c = '0';
	}
	else if (isquote (c))
	{
		char o = getc (stdin);;
		while ((o != c) && (c != EOF))
		{
			if (o == '\\')
			{
				o = getc (stdin);
			}
			* string++ = o;
			o = getc (stdin);
		}
	}
	else 
	{
		* string++ = c;
	}
	* string++ = (char) (0);
	return (c);
}
예제 #6
0
/** Skip to the next newline or comment that is not part of a quoted
 * string.  When ELinks hits a parse error in the configuration file,
 * it calls this in order to find the place where is should resume
 * parsing.  This is intended to prevent ELinks from treating words
 * in strings as commands.  */
static void
skip_to_unquoted_newline_or_comment(struct conf_parsing_pos *pos)
{
	while (*pos->look && *pos->look != '#' && *pos->look != '\n') {
		if (isquote(*pos->look))
			skip_quoted(pos);
		else
			pos->look++;
	}
}
예제 #7
0
파일: conv.c 프로젝트: rkd77/elinks-tv
/* TODO Optimize later --pasky */
struct string *
add_quoted_to_string(struct string *string, const unsigned char *src, int len)
{
	for (; len; len--, src++) {
		if (isquote(*src) || *src == '\\')
			add_char_to_string(string, '\\');
		add_char_to_string(string, *src);
	}

	return string;
}
예제 #8
0
/** Skip a quoted string.
 * This function allows "mismatching quotes' because str_rd() does so.  */
static void
skip_quoted(struct conf_parsing_pos *pos)
{
	assert(isquote(*pos->look));
	if_assert_failed return;
	pos->look++;

	for (;;) {
		if (!*pos->look)
			return;
		if (isquote(*pos->look)) {
			pos->look++;
			return;
		}
		if (*pos->look == '\\' && pos->look[1])
			pos->look++;
		if (*pos->look == '\n')
			pos->line++;
		pos->look++;
	}
}
예제 #9
0
/** Skip the value of an option.
 *
 * This job is normally done by the reader function that corresponds
 * to the type of the option.  However, if ELinks does not recognize
 * the name of the option, it cannot look up the type and has to use
 * this function instead.  */
static void
skip_option_value(struct conf_parsing_pos *pos)
{
	if (isquote(*pos->look)) {
		/* Looks like OPT_STRING, OPT_CODEPAGE, OPT_LANGUAGE,
		 * or OPT_COLOR.  */
		skip_quoted(pos);
	} else {
		/* Looks like OPT_BOOL, OPT_INT, or OPT_LONG.  */
		while (isasciialnum(*pos->look) || *pos->look == '.'
		       || *pos->look == '+' || *pos->look == '-')
			pos->look++;
	}
}
예제 #10
0
파일: header.c 프로젝트: Efreak/elinks
/* Parse string param="value", return value as new string or NULL if any
 * error. */
unsigned char *
get_header_param(unsigned char *e, unsigned char *name)
{
	unsigned char *n, *start;

again:
	while (*e && c_toupper(*e++) != c_toupper(*name));
	if (!*e) return NULL;

	n = name + 1;
	while (*n && c_toupper(*e) == c_toupper(*n)) e++, n++;
	if (*n) goto again;

	skip_space(e);
	if (*e++ != '=') return NULL;

	skip_space(e);
	start = e;

	if (!isquote(*e)) {
		skip_nonspace(e);
	} else {
		unsigned char uu = *e++;

		start++;
		while (*e != uu) {
			if (!*e) return NULL;
			e++;
		}
	}

	while (start < e && *start == ' ') start++;
	while (start < e && *(e - 1) == ' ') e--;
	if (start == e) return NULL;

	n = mem_alloc(e - start + 1);
	if (n) {
		int i = 0;

		while (start < e) {
			n[i++] = (*start < ' ') ? '.' : *start;
			start++;
		}
		n[i] = '\0';
	}

	return n;
}
예제 #11
0
static int
endoftextblock(Line *t, int toplevelblock, DWORD flags)
{
    int z;

    if ( end_of_block(t) || isquote(t) )
	return 1;

    /* HORRIBLE STANDARDS KLUDGES:
     * 1. non-toplevel paragraphs absorb adjacent code blocks
     * 2. Toplevel paragraphs eat absorb adjacent list items,
     *    but sublevel blocks behave properly.
     * (What this means is that we only need to check for code
     *  blocks at toplevel, and only check for list items at
     *  nested levels.)
     */
    return toplevelblock ? 0 : islist(t,&z,flags,&z);
}
예제 #12
0
static int
endoftextblock(Line *t, int toplevelblock, DWORD flags)
{
    int z;

    if ( blankline(t)||isquote(t)||ishdr(t,&z)||ishr(t) )
	return 1;

    /* HORRIBLE STANDARDS KLUDGE: non-toplevel paragraphs absorb adjacent
     * code blocks
     */
    if ( toplevelblock && iscode(t) )
	return 1;

    /* HORRIBLE STANDARDS KLUDGE: Toplevel paragraphs eat absorb adjacent
     * list items, but sublevel blocks behave properly.
     */
    return toplevelblock ? 0 : islist(t,&z,flags, &z);
}
예제 #13
0
static bool
needSpace(int c, IOSTREAM *s)
{ if ( c == EOF )
  { s->lastc = EOF;
    return FALSE;
  }

  if ( s->lastc == PREFIX_SIGN )	/* avoid passing to is*W() functions */
  { if ( isDigit(c) || isSymbolW(c) )
      return TRUE;
    return FALSE;
  }

  if ( s->lastc != EOF &&
       ((isAlphaW(s->lastc) && isAlphaW(c)) ||
	(isSymbolW(s->lastc) && isSymbolW(c)) ||
	(s->lastc != '(' && !isBlank(s->lastc) && c == '(') ||
	(c == '\'' && (isDigit(s->lastc))) ||
	(isquote(c) && s->lastc == c)
       ) )
    return TRUE;

  return FALSE;
}
예제 #14
0
/*
 * break a collection of markdown input into
 * blocks of lists, code, html, and text to
 * be marked up.
 */
static Paragraph *
compile(Line *ptr, int toplevel, MMIOT *f)
{
    ParagraphRoot d = { 0, 0 };
    Paragraph *p = 0;
    Line *r;
    int para = toplevel;
    int blocks = 0;
    int hdr_type, list_type, list_class, indent;

    ptr = consume(ptr, &para);

    while ( ptr ) {
	if ( iscode(ptr) ) {
	    p = Pp(&d, ptr, CODE);
	    
	    if ( f->flags & MKD_1_COMPAT) {
		/* HORRIBLE STANDARDS KLUDGE: the first line of every block
		 * has trailing whitespace trimmed off.
		 */
		___mkd_tidy(&p->text->text);
	    }
	    
	    ptr = codeblock(p);
	}
#if WITH_FENCED_CODE
	else if ( iscodefence(ptr,3,0) && (p=fencedcodeblock(&d, &ptr)) )
	    /* yay, it's already done */ ;
#endif
	else if ( ishr(ptr) ) {
	    p = Pp(&d, 0, HR);
	    r = ptr;
	    ptr = ptr->next;
	    ___mkd_freeLine(r);
	}
	else if ( list_class = islist(ptr, &indent, f->flags, &list_type) ) {
	    if ( list_class == DL ) {
		p = Pp(&d, ptr, DL);
		ptr = definition_block(p, indent, f, list_type);
	    }
	    else {
		p = Pp(&d, ptr, list_type);
		ptr = enumerated_block(p, indent, f, list_class);
	    }
	}
	else if ( isquote(ptr) ) {
	    p = Pp(&d, ptr, QUOTE);
	    ptr = quoteblock(p, f->flags);
	    p->down = compile(p->text, 1, f);
	    p->text = 0;
	}
	else if ( ishdr(ptr, &hdr_type) ) {
	    p = Pp(&d, ptr, HDR);
	    ptr = headerblock(p, hdr_type);
	}
	else {
	    p = Pp(&d, ptr, MARKUP);
	    ptr = textblock(p, toplevel, f->flags);
	    /* tables are a special kind of paragraph */
	    if ( actually_a_table(f, p->text) )
		p->typ = TABLE;
	}

	if ( (para||toplevel) && !p->align )
	    p->align = PARA;

	blocks++;
	para = toplevel || (blocks > 1);
	ptr = consume(ptr, &para);

	if ( para && !p->align )
	    p->align = PARA;

    }
    return T(d);
}
예제 #15
0
파일: scanner.c 프로젝트: Efreak/elinks
static inline void
scan_css_token(struct scanner *scanner, struct scanner_token *token)
{
	const unsigned char *string = scanner->position;
	unsigned char first_char = *string;
	enum css_token_type type = CSS_TOKEN_GARBAGE;
	int real_length = -1;

	assert(first_char);
	token->string = string++;

	if (is_css_char_token(first_char)) {
		type = first_char;

	} else if (is_css_digit(first_char) || first_char == '.') {
		scan_css(scanner, string, CSS_CHAR_DIGIT);

		/* First scan the full number token */
		if (*string == '.') {
			string++;

			if (is_css_digit(*string)) {
				type = CSS_TOKEN_NUMBER;
				scan_css(scanner, string, CSS_CHAR_DIGIT);
			}
		}

		/* Check what kind of number we have */
		if (*string == '%') {
			if (first_char != '.')
				type = CSS_TOKEN_PERCENTAGE;
			string++;

		} else if (!is_css_ident_start(*string)) {
			type = CSS_TOKEN_NUMBER;

		} else {
			const unsigned char *ident = string;

			scan_css(scanner, string, CSS_CHAR_IDENT);
			type = map_scanner_string(scanner, ident, string,
						  CSS_TOKEN_DIMENSION);
		}

	} else if (is_css_ident_start(first_char)) {
		scan_css(scanner, string, CSS_CHAR_IDENT);

		if (*string == '(') {
			const unsigned char *function_end = string + 1;

			/* Make sure that we have an ending ')' */
			skip_css(scanner, function_end, ')');
			if (*function_end == ')') {
				type = map_scanner_string(scanner, token->string,
						string, CSS_TOKEN_FUNCTION);

				/* If it is not a known function just skip the
				 * how arg stuff so we don't end up generating
				 * a lot of useless tokens. */
				if (type == CSS_TOKEN_FUNCTION) {
					string = function_end;

				} else if (type == CSS_TOKEN_URL) {
					/* Extracting the URL first removes any
					 * leading or ending whitespace and
					 * then see if the url is given in a
					 * string. If that is the case the
					 * string delimiters are also trimmed.
					 * This is not totally correct because
					 * we should of course handle escape
					 * sequences .. but that will have to
					 * be fixed later.  */
					const unsigned char *from = string + 1;
					const unsigned char *to = function_end - 1;

					scan_css(scanner, from, CSS_CHAR_WHITESPACE);
					scan_back_css(scanner, to, CSS_CHAR_WHITESPACE);

					if (isquote(*from)) from++;
					if (isquote(*to)) to--;

					token->string = from;
					/* Given "url( )", @to and @from will
					 * cross when they scan forwards and
					 * backwards, respectively, for a non-
					 * whitespace character, and @to - @from
					 * will be negative.  If there is
					 * anything between the parentheses,
					 * @to and @from will not cross and @to
					 * - @from will not become negative. */
					real_length = int_max(0, to - from + 1);
					string = function_end;
				}

				assert(type != CSS_TOKEN_RGB || *string == '(');
				assert(type != CSS_TOKEN_URL || *string == ')');
				assert(type != CSS_TOKEN_FUNCTION || *string == ')');
			}

			string++;

		} else {
			type = CSS_TOKEN_IDENT;
		}

	} else if (!is_css_token_start(first_char)) {
		/* TODO: Better composing of error tokens. For now we just
		 * split them down into char tokens */

	} else if (first_char == '#') {
		/* Check whether it is hexcolor or hash token */
		if (is_css_hexdigit(*string)) {
			int hexdigits;

			scan_css(scanner, string, CSS_CHAR_HEX_DIGIT);

			/* Check that the hexdigit sequence is either 3 or 6
			 * chars and it isn't just start of some non-hex ident
			 * string. */
			hexdigits = string - token->string - 1;
			if ((hexdigits == 3 || hexdigits == 6)
			    && !is_css_ident(*string)) {
				type = CSS_TOKEN_HEX_COLOR;
			} else {
				scan_css(scanner, string, CSS_CHAR_IDENT);
				type = CSS_TOKEN_HASH;
			}

		} else if (is_css_ident(*string)) {
			/* Not *_ident_start() because hashes are #<name>. */
			scan_css(scanner, string, CSS_CHAR_IDENT);
			type = CSS_TOKEN_HASH;
		}

	} else if (first_char == '@') {
		/* Compose token containing @<ident> */
		if (is_css_ident_start(*string)) {
			const unsigned char *ident = string;

			/* Scan both ident start and ident */
			scan_css(scanner, string, CSS_CHAR_IDENT);
			type = map_scanner_string(scanner, ident, string,
						  CSS_TOKEN_AT_KEYWORD);
		}

	} else if (first_char == '*') {
		if (*string == '=') {
			type = CSS_TOKEN_SELECT_CONTAINS;
			string++;
		} else {
			type = CSS_TOKEN_IDENT;
		}

	} else if (first_char == '^') {
		if (*string == '=') {
			type = CSS_TOKEN_SELECT_BEGIN;
			string++;
		}

	} else if (first_char == '$') {
		if (*string == '=') {
			type = CSS_TOKEN_SELECT_END;
			string++;
		}

	} else if (first_char == '|') {
		if (*string == '=') {
			type = CSS_TOKEN_SELECT_HYPHEN_LIST;
			string++;
		}

	} else if (first_char == '!') {
		scan_css(scanner, string, CSS_CHAR_WHITESPACE);
		if (!c_strncasecmp(string, "important", 9)) {
			type = CSS_TOKEN_IMPORTANT;
			string += 9;
		}

	} else if (isquote(first_char)) {
		/* TODO: Escaped delimiters --jonas */
		int size = scanner->end - string;
		unsigned char *string_end = memchr(string, first_char, size);

		if (string_end) {
			/* We don't want the delimiters in the token */
			token->string++;
			real_length = string_end - token->string;
			string = string_end + 1;
			type = CSS_TOKEN_STRING;
		}

	} else if (first_char == '<' || first_char == '-') {
		/* Try to navigate SGML tagsoup */

		if (*string == '/') {
			/* Some kind of SGML tag end ... better bail out screaming */
			type = CSS_TOKEN_NONE;

		} else {
			const unsigned char *sgml = string;

			/* Skip anything looking like SGML "<!--" and "-->"
			 * comments + <![CDATA[ and ]]> notations. */
			scan_css(scanner, sgml, CSS_CHAR_SGML_MARKUP);

			if (sgml - string >= 2
			    && ((first_char == '<' && *string == '!')
				|| (first_char == '-' && sgml[-1] == '>'))) {
				type = CSS_TOKEN_SKIP;
				string = sgml;
			}
		}

	} else if (first_char == '/') {
		/* Comments */
		if (*string == '*') {
			type = CSS_TOKEN_SKIP;

			for (string++; string < scanner->end; string++)
				if (*string == '*' && string[1] == '/') {
					string += 2;
					break;
				}
		}

	} else {
		INTERNAL("Someone forgot to put code for recognizing tokens "
			 "which start with '%c'.", first_char);
	}

	token->type = type;
	token->length = real_length > 0 ? real_length : string - token->string;
	token->precedence = get_css_precedence(type);
	scanner->position = string;
}
예제 #16
0
void Tscriptsourceview::draw(CDC *dc, RECT &updaterect)
{
	int xp,yp,kwstart,kwend;
	StrChar ch;
	bool insel;
	QString kw;
	TQXColor curtextcol,keywordcol;
	bool inkeyword,instring,istextstring,incomment,textstarted;

	TQXColor backcolor=G_QXSys().G_color(TQXSys::CL_WINDOWBACK1);
	TQXColor textcolor=G_QXSys().G_color(TQXSys::CL_TEXT);
//	TQXColor selcolor(0.6f,0.8f,1.0f);
	TQXColor selcolor=G_QXSys().G_color(TQXSys::CL_WINDOWHIGHLIGHT);
	TQXColor stringcolor1(0,0.6f,0);
	TQXColor stringcolor2(0.3f,0.6f,0);
	TQXColor commentcolor(0.7f,0,0);
	TQXColor signcolor=2*backcolor+textcolor;
	dc->SelectObject(G_QXSys().G_font(TQXSys::FNT_FIXED));
	dc->SetBkMode(TRANSPARENT);
//	dc->FillSolidRect(0-G_offsetx(),0,300,300,RGB(255,0,0));

	TQXColor debugbackcol=3*backcolor+TQXColor(0,1,0);

	stringcolor1=TQXColor(0,0.75,0.25)+textcolor;
	stringcolor2=TQXColor(0.5,1,0)+textcolor;
	commentcolor=TQXColor(1,0,0)+textcolor;



	if (script==NULL)
	{
		dc->FillSolidRect(&updaterect,G_QXSys().G_color(TQXSys::CL_WINDOWBACK2));
		return;
	}

	TSC_source &source=script->G_source();
	if (source.readonly)
	{
		textcolor=G_QXSys().G_color(TQXSys::CL_TEXT)+backcolor;
	}
	dc->SetTextColor(textcolor);

	int sel1line,sel1col,sel2line,sel2col;
	source.G_sel(sel1line,sel1col,sel2line,sel2col);


	if (Isactiveview())
	{
		yp=source.G_cursor_linenr()*ysep-G_offsety();
		xp=marginx+source.G_cursor_colnr()*xsep-G_offsetx();
		dc->FillSolidRect(xp-0,yp,1,ysep,textcolor);
	}

	for (int linenr=0; linenr<source.G_linecount(); linenr++)
	{
		yp=linenr*ysep-G_offsety();
		if ((yp>=updaterect.top-20)&&(yp<=updaterect.bottom+20))
		{
			if (linenr==source.G_debugline())
				dc->FillSolidRect(0,yp,10000,ysep,debugbackcol);
			const QString *line=source.G_line(linenr);
			dc->FillSolidRect(marginx-G_offsetx()-8,yp+ysep/2,4,1,signcolor);
			dc->FillSolidRect(marginx-G_offsetx()-6,yp+ysep/2-1,1,1,signcolor);
			dc->FillSolidRect(marginx-G_offsetx()-6,yp+ysep/2+1,1,1,signcolor);
			inkeyword=false;instring=false;incomment=false;istextstring=false;
			textstarted=false;
			for (int colnr=0; colnr<line->G_length(); colnr++)
			{
				curtextcol=textcolor;
				xp=marginx+colnr*xsep-G_offsetx();
				insel=true;
				if (linenr<sel1line) insel=false;
				if ((linenr==sel1line)&&(colnr<sel1col)) insel=false;
				if (linenr>sel2line) insel=false;
				if ((linenr==sel2line)&&(colnr>sel2col)) insel=false;
				if (insel) dc->FillSolidRect(xp,yp,xsep,ysep,selcolor);
				ch=line->G_char(colnr);
				if (ch!=' ') textstarted=true;
				if ((!instring)&&(ch=='#')/*&&(line->G_char(colnr+1)=='/')*/)
				{
					incomment=true;
				}
				if (incomment) curtextcol=commentcolor;
				if (instring)
				{
					curtextcol=stringcolor1;
					if (istextstring) curtextcol=stringcolor2;
				}
				if ((!incomment)&&(isquote(ch)))
				{
					if (!instring)
					{
						instring=true;istextstring=false;
						curtextcol=stringcolor1;
						if (isquotesingle(ch))
						{
							istextstring=true;
							curtextcol=stringcolor2;
						}
					}
					else
					{
						if ((colnr==0)||(line->G_char(colnr-1)!=ESCCHAR)) instring=false;
					}
				}
				if ((!instring)&&(!incomment))
				{
					if (Qisalphanumerical(ch))
					{
						if ((colnr==0)||(!Qisalphanumerical(line->G_char(colnr-1))))
						{
							kwstart=colnr;kwend=colnr;
							while ((kwend<line->G_length()-1)&&(Qisalphanumerical(line->G_char(kwend+1)))) kwend++;
							if (kwend>kwstart)
							{
								kw.clear();
								for (int kwct=kwstart; kwct<=kwend; kwct++) kw+=line->G_char(kwct);
								if (script->G_keyword(kw,keywordcol)) inkeyword=true;
							}
						}
					}
					else
					{
						inkeyword=false;
					}
					if (inkeyword) curtextcol=keywordcol;
				}
				if (source.readonly) dc->SetTextColor(2*curtextcol+backcolor);
				else dc->SetTextColor(curtextcol);
				dc->TextOut(xp,yp+4,&ch,1);
				if (ch==' ')
				{
					dc->FillSolidRect(xp+xsep/2,yp+ysep/2,1,1,signcolor);
					if ((!textstarted)&&(colnr%3==2))
						dc->FillSolidRect(xp+xsep/2,yp,1,ysep,signcolor);
				}
			}
		}
	}

}
예제 #17
0
int
parse(int *argc, char ***argv, char *str)
{
    int ac;
    char *val, *p, *q, *copy = NULL;
    size_t i = 0;
    char token, tmp, quote, *buf;
    enum { STR, VAR, WHITE } state;

    ac = *argc = 0;
    quote = 0;
    if (!str || (p = copy = backslash(str)) == NULL)
	return 1;

    /* Initialize vector and state */
    clean();
    state = STR;
    buf = (char *)alloc(PARSE_BUFSIZE);
    token = 0;

    /* And awaaaaaaaaay we go! */
    while (*p) {
	switch (state) {
	case STR:
	    if ((*p == '\\') && p[1]) {
		p++;
		PARSE_FAIL(i == (PARSE_BUFSIZE - 1));
		buf[i++] = *p++;
	    } else if (isquote(*p)) {
		quote = quote ? 0 : *p;
		++p;
	    }
	    else if (isspace(*p) && !quote) {
		state = WHITE;
		if (i) {
		    buf[i] = '\0';
		    PARSE_FAIL(insert(&ac, buf));
		    i = 0;
		}
		++p;
	    } else if (*p == '$') {
		token = isdelim(*(p + 1));
		if (token)
		    p += 2;
		else
		    ++p;
		state = VAR;
	    } else {
		PARSE_FAIL(i == (PARSE_BUFSIZE - 1));
		buf[i++] = *p++;
	    }
	    break;

	case WHITE:
	    if (isspace(*p))
		++p;
	    else
		state = STR;
	    break;

	case VAR:
	    if (token) {
		PARSE_FAIL((q = strchr(p, token)) == NULL);
	    } else {
		q = p;
		while (*q && !isspace(*q))
		    ++q;
	    }
	    tmp = *q;
	    *q = '\0';
	    if ((val = variable_lookup(p)) != NULL) {
		size_t len = strlen(val);

		strncpy(buf + i, val, PARSE_BUFSIZE - (i + 1));
		i += min(len, PARSE_BUFSIZE - 1);
	    }
	    *q = tmp;	/* restore value */
	    p = q + (token ? 1 : 0);
	    state = STR;
	    break;
	}
    }
    /* If at end of token, add it */
    if (i && state == STR) {
	buf[i] = '\0';
	PARSE_FAIL(insert(&ac, buf));
    }
    args[ac] = NULL;
    *argc = ac;
    *argv = (char **)alloc((sizeof(char *) * ac + 1));
    bcopy(args, *argv, sizeof(char *) * ac + 1);
    free(buf);
    free(copy);
    return 0;
}
예제 #18
0
파일: cinc.c 프로젝트: wol22/MotleyTools
void function (char * fullpath, char const * vector []) 

{ 
	FILE * fp; 
	char buffer [CSOURCE]; 
	char * sp; 
	char * cp; 
	signed c; 
	if ((fp = efopen (fullpath, "rb"))) 
	{ 
		char pathname [FILENAME_MAX]; 
		for (sp = cp = strcpy (pathname, fullpath); * cp; ++ cp) 
		{ 
			if (* cp == '/') 
			{ 
				sp = cp; 
			} 
		} 
		* sp = (char)(0); 
		c = getc (fp); 
		while (c != EOF) 
		{ 
			sp = buffer; 
			if (isspace (c)) 
			{ 
				do 
				{ 
					putc (c, stdout); 
					c = getc (fp); 
				} 
				while (isspace (c)); 
				continue; 
			} 
			if (isalpha (c)) 
			{ 
				do 
				{ 
					putc (c, stdout); 
					c = getc (fp); 
				} 
				while (isalnum (c)); 
				continue; 
			} 
			if (isdigit (c)) 
			{ 
				do 
				{ 
					putc (c, stdout); 
					c = getc (fp); 
				} 
				while (isdigit (c)); 
				continue; 
			} 
			if (c == '#') 
			{ 
				* sp++ = (char)(c); 
				c = getc (fp); 
				while (isblank (c)) 
				{ 
					* sp++ = (char)(c); 
					c = getc (fp); 
				} 
				cp = sp; 
				while (isalpha (c)) 
				{ 
					* sp++ = (char) (c); 
					c = getc (fp); 
				} 
				* sp = (char)(0); 
				if (strcmp ("include", cp)) 
				{ 
					while (nobreak (c)) 
					{ 
						* sp++ = (char) (c); 
						c = getc (fp); 
					} 
					* sp++ = (char)(c); 
					for (cp = buffer; cp < sp; putc (* cp++, stdout)); 
					c = getc (fp); 
					continue; 
				} 
				while (isblank (c)) 
				{ 
					* sp++ = (char) (c); 
					c = getc (fp); 
				} 
				if (c == '\"') 
				{ 
					size_t index; 
					char filename [FILENAME_MAX]; 
					cp = filename; 
					c = getc (fp); 
					while ((c != '\"') && (c != EOF)) 
					{ 
						* cp++ = * sp++ = (char) (c); 
						c = getc (fp); 
					} 
					* cp = (char) (0); 
					makepath (fullpath, pathname, filename); 
					for (index = 0; vector [index] != (char *)(0); index++) 
					{ 
						if (!strcmp (fullpath, vector [index])) 
						{ 
							break; 
						} 
					} 
					if (vector [index] == (char *)(0)) 
					{ 
						vector [index++] = strdup (fullpath); 
						vector [index] = (char *)(0); 
						function (fullpath, vector); 
					} 
					while (nobreak (c)) 
					{ 
						* sp++ = (char) (c); 
						c = getc (fp); 
					} 
					* sp++ = (char) (c); 
				} 
				else 
				{ 
					while (nobreak (c)) 
					{ 
						* sp++ = (char) (c); 
						c = getc (fp); 
					} 
					* sp++ = (char) (c); 
					for (cp = buffer; cp < sp; putc (* cp++, stdout)); 
				} 
				c = getc (fp); 
				continue; 
			} 
			if (isquote (c)) 
			{ 
				signed o = getc (fp); 
				putc (c, stdout); 
				while ((o != c) && (c != EOF)) 
				{ 
					if (o == '\\') 
					{ 
						putc (o, stdout); 
						o = getc (fp); 
					} 
					putc (o, stdout); 
					o = getc (fp); 
				} 
				putc (c, stdout); 
				c = getc (fp); 
				continue; 
			} 
			if (c == '/') 
			{ 
				putc (c, stdout); 
				c = getc (fp); 
				if (c == '/') 
				{ 
					while (nobreak (c)) 
					{ 
						putc (c, stdout); 
						c = getc (fp); 
					} 
					putc ('\n', stdout); 
					c = getc (fp); 
					continue; 
				} 
				if (c == '*') 
				{ 
					while (nomatch (c, '/')) 
					{ 
						while (nomatch (c, '*')) 
						{ 
							putc (c, stdout); 
							c = getc (fp); 
						} 
						putc (c, stdout); 
						c = getc (fp); 
					} 
					putc ('/', stdout); 
					c = getc (fp); 
					continue; 
				} 
				putc (c, stdout); 
				c = getc (fp); 
				continue; 
			} 
			putc (c, stdout); 
			c = getc (fp); 
		} 
		fclose (fp); 
	} 
	return; 
} 
예제 #19
0
int G_site_put_new(FILE * fptr, Site * s, int has_cat)

/* Writes a site to file open on fptr. */
{
    char ebuf[MAX_SITE_STRING], nbuf[MAX_SITE_STRING];
    char xbuf[MAX_SITE_STRING], buf[MAX_SITE_LEN];
    static int format_double();
    int fmt, i, j, k;
    int G_format_northing(), G_format_easting(), G_projection();

    fmt = G_projection();

    G_format_northing(s->north, nbuf, fmt);
    G_format_easting(s->east, ebuf, fmt);
    sprintf(buf, "%s|%s|", ebuf, nbuf);
    for (i = 0; i < s->dim_alloc; ++i) {
	format_double(s->dim[i], nbuf);
	sprintf(xbuf, "%s|", nbuf);
	strcat(buf, xbuf);
    }

    if (has_cat) {
	switch (s->cattype) {
	case CELL_TYPE:
	    sprintf(xbuf, "#%d ", s->ccat);
	    strcat(buf, xbuf);
	    break;
	case FCELL_TYPE:
	    sprintf(xbuf, "#%g ", s->fcat);
	    strcat(buf, xbuf);
	    break;
	case DCELL_TYPE:
	    sprintf(xbuf, "#%g ", s->dcat);
	    strcat(buf, xbuf);
	    break;
	}
    }
    else {			/* no cat there, so data in plain x,y,z format will be imported   12/99 MN */

	/* we create a #cat entry in site_list from the current site number 11/99 */
	sprintf(xbuf, "#%d ", loop);
	loop++;
	strcat(buf, xbuf);
    }

    /* now import attributes */
    for (i = 0; i < s->dbl_alloc; ++i) {
	format_double(s->dbl_att[i], nbuf);
	sprintf(xbuf, "%%%s ", nbuf);
	strcat(buf, xbuf);
    }

    for (i = 0; i < s->str_alloc; ++i) {
	if (strlen(s->str_att[i]) != 0) {
	    /* escape double quotes */
	    j = k = 0;
	    if (G_index(s->str_att[i], DQUOTE) != (char *)NULL) {
		while (!isnull(s->str_att[i][j])) {
		    if (isquote(s->str_att[i][j])) {
			xbuf[k++] = BSLASH;
			xbuf[k++] = DQUOTE;
		    }
		    else if (isbslash(s->str_att[i][j])) {
			xbuf[k++] = BSLASH;
			xbuf[k++] = BSLASH;
		    }
		    else
			xbuf[k++] = s->str_att[i][j];
		    j++;
		}
		xbuf[k] = (char)NULL;
	    }
	    else
		strcpy(xbuf, s->str_att[i]);

	    strcpy(s->str_att[i], xbuf);

	    if (G_index(s->str_att[i], SPACE) != (char *)NULL)
		sprintf(xbuf, "@\"%s\" ", s->str_att[i]);
	    else
		sprintf(xbuf, "@%s ", s->str_att[i]);

	    strcat(buf, xbuf);
	}
    }
    fprintf(fptr, "%s\n", buf);
    return 0;
}
예제 #20
0
파일: rc.c 프로젝트: vkhromov/freebsd
/*
 * Parse the configuration file and set up variables
 */
int
dlg_parse_rc(void)
{
    int i;
    int l = 1;
    PARSE_LINE parse;
    char str[MAX_LEN + 1];
    char *var;
    char *value;
    char *tempptr;
    int result = 0;
    FILE *rc_file = 0;
    char *params;

    /*
     *  At startup, dialog determines the settings to use as follows:
     *
     *  a) if the environment variable $DIALOGRC is set, its value determines
     *     the name of the configuration file.
     *
     *  b) if the file in (a) can't be found, use the file $HOME/.dialogrc
     *     as the configuration file.
     *
     *  c) if the file in (b) can't be found, try using the GLOBALRC file.
     *     Usually this will be /etc/dialogrc.
     *
     *  d) if the file in (c) cannot be found, use the compiled-in defaults.
     */

    /* try step (a) */
    if ((tempptr = getenv("DIALOGRC")) != NULL)
        rc_file = fopen(tempptr, "rt");

    if (rc_file == NULL) {	/* step (a) failed? */
        /* try step (b) */
        if ((tempptr = getenv("HOME")) != NULL
                && strlen(tempptr) < MAX_LEN - (sizeof(DIALOGRC) + 3)) {
            if (tempptr[0] == '\0' || lastch(tempptr) == '/')
                sprintf(str, "%s%s", tempptr, DIALOGRC);
            else
                sprintf(str, "%s/%s", tempptr, DIALOGRC);
            rc_file = fopen(tempptr = str, "rt");
        }
    }

    if (rc_file == NULL) {	/* step (b) failed? */
        /* try step (c) */
        strcpy(str, GLOBALRC);
        if ((rc_file = fopen(tempptr = str, "rt")) == NULL)
            return 0;		/* step (c) failed, use default values */
    }

    DLG_TRACE(("opened rc file \"%s\"\n", tempptr));
    /* Scan each line and set variables */
    while ((result == 0) && (fgets(str, MAX_LEN, rc_file) != NULL)) {
        DLG_TRACE(("rc:%s", str));
        if (*str == '\0' || lastch(str) != '\n') {
            /* ignore rest of file if line too long */
            fprintf(stderr, "\nParse error: line %d of configuration"
                    " file too long.\n", l);
            result = -1;	/* parse aborted */
            break;
        }

        lastch(str) = '\0';
        if (begins_with(str, "bindkey", &params)) {
            if (!dlg_parse_bindkey(params)) {
                fprintf(stderr, "\nParse error: line %d of configuration\n", l);
                result = -1;
            }
            continue;
        }
        parse = parse_line(str, &var, &value);	/* parse current line */

        switch (parse) {
        case LINE_EMPTY:	/* ignore blank lines and comments */
            break;
        case LINE_EQUALS:
            /* search table for matching config variable name */
            if ((i = find_vars(var)) >= 0) {
                switch (vars[i].type) {
                case VAL_INT:
                    *((int *) vars[i].var) = atoi(value);
                    break;
                case VAL_STR:
                    if (!isquote(value[0]) || !isquote(lastch(value))
                            || strlen(value) < 2) {
                        fprintf(stderr, "\nParse error: string value "
                                "expected at line %d of configuration "
                                "file.\n", l);
                        result = -1;	/* parse aborted */
                    } else {
                        /* remove the (") quotes */
                        value++;
                        lastch(value) = '\0';
                        strcpy((char *) vars[i].var, value);
                    }
                    break;
                case VAL_BOOL:
                    if (!dlg_strcmp(value, "ON"))
                        *((bool *) vars[i].var) = TRUE;
                    else if (!dlg_strcmp(value, "OFF"))
                        *((bool *) vars[i].var) = FALSE;
                    else {
                        fprintf(stderr, "\nParse error: boolean value "
                                "expected at line %d of configuration "
                                "file (found %s).\n", l, value);
                        result = -1;	/* parse aborted */
                    }
                    break;
                }
#ifdef HAVE_COLOR
            } else if ((i = find_color(var)) >= 0) {
                int fg = 0;
                int bg = 0;
                int hl = 0;
                if (str_to_attr(value, &fg, &bg, &hl) == -1) {
                    fprintf(stderr, "\nParse error: attribute "
                            "value expected at line %d of configuration "
                            "file.\n", l);
                    result = -1;	/* parse aborted */
                } else {
                    dlg_color_table[i].fg = fg;
                    dlg_color_table[i].bg = bg;
                    dlg_color_table[i].hilite = hl;
                }
            } else {
#endif /* HAVE_COLOR */
                fprintf(stderr, "\nParse error: unknown variable "
                        "at line %d of configuration file:\n\t%s\n", l, var);
                result = -1;	/* parse aborted */
            }
            break;
        case LINE_ERROR:
            fprintf(stderr, "\nParse error: syntax error at line %d of "
                    "configuration file.\n", l);
            result = -1;	/* parse aborted */
            break;
        }
        l++;			/* next line */
    }

    (void) fclose(rc_file);
    return result;
}
예제 #21
0
파일: run4.c 프로젝트: jazzyb/run4
inline int isseparator (char c) { return (isspace(c) || isquote(c) || c == '\0'); }
예제 #22
0
static signed program (signed c, signed e)

{
	extern unsigned level;
	c = preamble (c);
	while ((c != e) && (c != EOF))
	{
		if (c == '#')
		{
			c = fortran (c);
			continue;
		}
		if (c == '/')
		{
			c = comment (c);
			continue;
		}
		if (c == '{')
		{
			level++;
			c = keep (c);
			c = program (c, '}');
			c = keep (c);
			level--;
			c = preamble (c);
			continue;
		}
		if (c == '(')
		{
			c = context ('(', ')');
			continue;
		}
		if (c == '[')
		{
			c = context ('[', ']');
			continue;
		}
		if (isquote (c))
		{
			c = literal (c);
			continue;
		}
		if (isalnum (c) || (c == '_') || (c == '.'))
		{
			char string [100];
			char * sp = string;
			do 
			{
				* sp++ = c;
				c = keep (c);
			}
			while (isalnum (c) || (c == '_') || (c == '.'));
			* sp = (char) (0);
			if (! strcmp (string, "while"))
			{
				c = condition (c);
				c = statement (c);
				continue;
			}
			if (! strcmp (string, "for"))
			{
				c = condition (c);
				c = statement (c);
				continue;
			}
			if (! strcmp (string, "if"))
			{
				c = condition (c);
				c = statement (c);
				continue;
			}
			if (! strcmp (string, "else"))
			{
				c = statement (c);
				continue;
			}
			if (! strcmp (string, "do"))
			{
				c = statement (c);
				continue;
			}
			if (! strcmp (string, "return"))
			{
				c = condition (c);
				continue;
			}
			if (! strcmp (string, "exit"))
			{
				c = condition (c);
				continue;
			}
			continue;
		}
		c = keep (c);
	}
	return (e);
}
예제 #23
0
/*
 * break a collection of markdown input into
 * blocks of lists, code, html, and text to
 * be marked up.
 */
static Paragraph *
compile(Line *ptr, int toplevel, MMIOT *f)
{
    ParagraphRoot d = { 0, 0 };
    Paragraph *p = 0;
    Line *r;
    int para = toplevel;
    int blocks = 0;
    int hdr_type, list_type, list_class, indent;

    ptr = consume(ptr, &para);

    while ( ptr ) {
	if ( iscode(ptr) ) {
	    p = Pp(&d, ptr, CODE);
	    
	    if ( f->flags & MKD_1_COMPAT) {
		/* HORRIBLE STANDARDS KLUDGE: the first line of every block
		 * has trailing whitespace trimmed off.
		 */
		___mkd_tidy(&p->text->text);
	    }
	    
	    ptr = codeblock(p);
	}
	else if ( ishr(ptr) ) {
	    p = Pp(&d, 0, HR);
	    r = ptr;
	    ptr = ptr->next;
	    ___mkd_freeLine(r);
	}
	else if (( list_class = islist(ptr, &indent, f->flags, &list_type) )) {
	    if ( list_class == DL ) {
		p = Pp(&d, ptr, DL);
		ptr = definition_block(p, indent, f, list_type);
	    }
	    else {
		p = Pp(&d, ptr, list_type);
		ptr = enumerated_block(p, indent, f, list_class);
	    }
	}
	else if ( isquote(ptr) ) {
	    p = Pp(&d, ptr, QUOTE);
	    ptr = quoteblock(p, f->flags);
	    p->down = compile(p->text, 1, f);
	    p->text = 0;
	}
	else if ( ishdr(ptr, &hdr_type) ) {
	    p = Pp(&d, ptr, HDR);
	    ptr = headerblock(p, hdr_type);
	}
	else if ( istable(ptr) && !(f->flags & (MKD_STRICT|MKD_NOTABLES)) ) {
	    p = Pp(&d, ptr, TABLE);
	    ptr = tableblock(p);
	}
	else {
	    p = Pp(&d, ptr, MARKUP);
	    ptr = textblock(p, toplevel, f->flags);
	}

	if ( (para||toplevel) && !p->align )
	    p->align = PARA;

	blocks++;
	para = toplevel || (blocks > 1);
	ptr = consume(ptr, &para);

	if ( para && !p->align )
	    p->align = PARA;

    }
    return T(d);
}
예제 #24
0
unsigned function (char const * oldname, char const * newname)

{
	unsigned count = 0;
	signed c = getc (stdin);
	while (c != EOF)
	{
		if (isspace (c))
		{
			do 
			{
				putc (c, stdout);
				c = getc (stdin);
			}
			while (isspace (c));
			continue;
		}
		if (isalpha (c) || (c == '_'))
		{
			char string [255];
			char * sp = string;
			do 
			{
				* sp++ = (char) (c);
				c = getc (stdin);
			}
			while (isalnum (c) || (c == '_'));
			* sp = (char) (0);
			if (! strcmp (string, oldname))
			{
				count++;
				fputs (newname, stdout);
				continue;
			}
			fputs (string, stdout);
			continue;
		}
		if (isdigit (c))
		{
			do 
			{
				putc (c, stdout);
				c = getc (stdin);
			}
			while (isdigit (c) || (c == '.'));
			if ((c == 'x') || (c == 'X'))
			{
				do 
				{
					putc (c, stdout);
					c = getc (stdin);
				}
				while (isxdigit (c));
			}
			if ((c == 'e') || (c == 'E'))
			{
				putc (c, stdout);
				c = getc (stdin);
				if ((c == '+') || (c == '-'))
				{
					putc (c, stdout);
					c = getc (stdin);
				}
				while (isdigit (c))
				{
					putc (c, stdout);
					c = getc (stdin);
				}
			}
			continue;
		}
		if (isquote (c))
		{
			signed o;
			putc (c, stdout);
			o = getc (stdin);
			while (nomatch (o, c))
			{
				if ((char) (o) == '\\')
				{
					putc (o, stdout);
					o = getc (stdin);
				}
				putc (o, stdout);
				o = getc (stdin);
			}
			putc (c, stdout);
			c = getc (stdin);
			continue;
		}
		if (c == '/')
		{
			putc (c, stdout);
			c = getc (stdin);
			if (c == '/')
			{
				while (nobreak (c))
				{
					putc (c, stdout);
					c = getc (stdin);
				}
				putc ('\n', stdout);
				c = getc (stdin);
				continue;
			}
			if (c == '*')
			{
				while (nomatch (c, '/'))
				{
					while (nomatch (c, '*'))
					{
						putc (c, stdout);
						c = getc (stdin);
					}
					putc (c, stdout);
					c = getc (stdin);
				}
				putc ('/', stdout);
				c = getc (stdin);
				continue;
			}
			continue;
		}
		putc (c, stdout);
		c = getc (stdin);
	}
	return (count);
}
예제 #25
0
int handle_quoted_text(FILE *fp, struct emailinfo *email, const struct body *bp, char *line, int inquote, int quote_num, bool replace_quoted, int maybe_reply)
{
    char *url1;
    int quoting_msgnum = email->msgnum;
    const struct body *last_quoted_line = bp;
    int count_quoted_lines = 0;
    char *fmt2;
    char *cvtd_line = ConvURLsString(unquote(line), email->msgid, email->subject, email->charset);
    char *buffer1;
	trio_asprintf(&fmt2, set_iquotes ? "<em class=\"%s\">%%s</em><br>" : "<span class=\"%s\">%%s</span><br>", find_quote_class(line));
    trio_asprintf(&buffer1, fmt2, cvtd_line ? cvtd_line : "");
    if (cvtd_line)
	free(cvtd_line);
    found_quote = (quote_num > 0);
    while (last_quoted_line && isquote(last_quoted_line->line)) {
	++count_quoted_lines;
	last_quoted_line = last_quoted_line->next;
    }
    cvtd_line = unquote_and_strip(line);
    if (strlen(cvtd_line) < 5 && (!replace_quoted || !inquote)) {
	char *parsed = ConvURLsString(line, email->msgid, email->subject, email->charset);
	if (parsed) {
	    fprintf(fp, fmt2, parsed);
	    free(parsed);
	}
    }
    else if ((!inquote || !found_quote)
		 && (url1 = url_replying_to(email, buffer1, cvtd_line, bp, ++quote_num, &quoting_msgnum, count_quoted_lines, maybe_reply))) {
	static const char *fmt1 = "<a href=\"%s\">%s</a>%s<br>\n";
	char *tmpline;
	char *p2;
		bool replacing = replace_quoted && set_quote_link_string && set_quote_link_string[0];
	char *part2 = strcasestr(line, "<a href=");
	if (!part2) {
	    part2 = "";
	    tmpline = strsav(line);
	}
	else {
	    tmpline = (char *)emalloc(part2 - line + 1);
	    strncpy(tmpline, line, part2 - line);
	    tmpline[part2 - line] = 0;
	}
	if (set_link_to_replies)
	    fprintf(fp, "<a name=\"qlink%d\"></a>", quote_num);
	p2 = ConvURLsString(part2, email->msgid, email->subject, email->charset);
	if (replacing)
	    fprintf(fp, fmt1, url1, set_quote_link_string, p2 ? p2 : "");
	else {
	    char *tmpptr = convchars(tmpline, email->charset);
	    if (tmpptr) {
		fprintf(fp, fmt1, url1, tmpptr, p2 ? p2 : "");
		free(tmpptr);
	    }
	}
	free(url1);
	free(tmpline);
	if (p2)
	    free(p2);
	free(cvtd_line);
	free(buffer1);
	free(fmt2);
	return 1;
    }
    else if (!replace_quoted || !inquote) {
	char *parsed = ConvURLsString(bp->line, email->msgid, email->subject, email->charset);
	if (parsed) {
	    fprintf(fp, quoting_msgnum >= 0 ? fmt2 : "%s<br>\n", parsed);
	    free(parsed);
	}
    }
    free(cvtd_line);
    free(buffer1);
    free(fmt2);
    return 0;
}
예제 #26
0
파일: rc.c 프로젝트: AhmadTux/DragonFlyBSD
/*
 * Parse the configuration file and set up variables
 */
int parse_rc(void)
{
  int i, l = 1, parse, fg, bg, hl;
  unsigned char str[MAX_LEN+1], *var, *value, *tempptr;
  FILE *rc_file = NULL;

  /*
   *
   *  At start, 'dialog' determines the settings to use as follows:
   *
   *  a) if environment variable DIALOGRC is set, it's value determines the
   *     name of the configuration file.
   *
   *  b) if the file in (a) can't be found, use the file $HOME/.dialogrc
   *     as the configuration file.
   *
   *  c) if the file in (b) can't be found, use compiled in defaults.
   *
   */

  if ((tempptr = getenv("DIALOGRC")) != NULL)
    rc_file = fopen(tempptr, "rt");

  if (tempptr == NULL || rc_file == NULL) {    /* step (a) failed? */
    /* try step (b) */
    if ((tempptr = getenv("HOME")) == NULL)
      return 0;    /* step (b) failed, use default values */

    if (tempptr[0] == '\0' || lastch(tempptr) == '/')
      sprintf(str, "%s%s", tempptr, DIALOGRC);
    else
      sprintf(str, "%s/%s", tempptr, DIALOGRC);

    if ((rc_file = fopen(str, "rt")) == NULL)
      return 0;    /* step (b) failed, use default values */
  }

  /* Scan each line and set variables */
  while (fgets(str, MAX_LEN, rc_file) != NULL) {
    if (lastch(str) != '\n') {    /* ignore rest of file if line too long */
      fprintf(stderr, "\nParse error: line %d of configuration file too long.\n", l);
      fclose(rc_file);
      return -1;    /* parse aborted */
    }
    else {
      lastch(str) = '\0';
      parse = parse_line(str, &var, &value);    /* parse current line */

      switch (parse) {
	case LINE_BLANK:    /* ignore blank lines and comments */
        case LINE_COMMENT:
          break;
        case LINE_OK:
          /* search table for matching config variable name */
          for (i = 0; i < VAR_COUNT && strcmp(vars[i].name, var); i++);

          if (i == VAR_COUNT) {    /* no match */
            fprintf(stderr, "\nParse error: unknown variable at line %d of configuration file.\n", l);
            return -1;    /* parse aborted */
          }
          else {    /* variable found in table, set run time variables */
            switch (vars[i].type) {
              case VAL_INT:
                *((int *) vars[i].var) = atoi(value);
                break;
              case VAL_STR:
                if (!isquote(value[0]) || !isquote(lastch(value)) || strlen(value) < 2) {
                  fprintf(stderr, "\nParse error: string value expected at line %d of configuration file.\n", l);
                  return -1;    /* parse aborted */
                }
                else {
                  /* remove the (") quotes */
                  value++;
                  lastch(value) = '\0';
                  strcpy((unsigned char *) vars[i].var, value);
		}
                break;
              case VAL_BOOL:
                if (!strcasecmp(value, "ON"))
                  *((bool *) vars[i].var) = TRUE;
                else if (!strcasecmp(value, "OFF"))
                  *((bool *) vars[i].var) = FALSE;
                else {
                  fprintf(stderr, "\nParse error: boolean value expected at line %d of configuration file.\n", l);
                  return -1;    /* parse aborted */
                }
                break;
              case VAL_ATTR:
                if (str_to_attr(value, &fg, &bg, &hl) == -1) {
                  fprintf(stderr, "\nParse error: attribute value expected at line %d of configuration file.\n", l);
                  return -1;    /* parse aborted */
                }
                ((int *) vars[i].var)[0] = fg;
                ((int *) vars[i].var)[1] = bg;
                ((int *) vars[i].var)[2] = hl;
                break;
            }
          }
          break;
        case LINE_ERROR:
          fprintf(stderr, "\nParse error: syntax error at line %d of configuration file.\n", l);
          return -1;    /* parse aborted */
      }
    }

    l++;    /* next line */
  }

  fclose(rc_file);
  return 0;    /* parse successful */
}
예제 #27
0
int
get_delim_str(char **rtokptr, const char **rval, const char **err)
{
    char *tokptr = *rtokptr;
    char endc;
    char *rv = NULL;

    while (isspace(*tokptr))
	tokptr++;
    if (*tokptr == '\0') {
	*err = "missing string value";
	return -1;
    }
    for (;;) {
	const char *val;

	if (*tokptr == '$') {
	    char oldc;

	    tokptr++;
	    val = tokptr;
	    while (*tokptr && *tokptr != '$' &&
		   !isspace(*tokptr) && !isquote(*tokptr)) {
		tokptr++;
	    }
	    oldc = *tokptr;
	    *tokptr = '\0';
	    val = find_variable(val);
	    if (!val)
		return -1;
	    *tokptr = oldc;
	} else if (isquote(*tokptr)) {
	    endc = *tokptr;
	    tokptr++;
	    val = tokptr;
	    while (*tokptr != endc) {
		if (*tokptr == '\0') {
		    *err = "End of line in string";
		    return -1;
		}
		tokptr++;
	    }
	    *tokptr = '\0';
	    tokptr++;
	} else {
	    *err = "string value must start with '\"' or '''";
	    return -1;
	}

	if (rv) {
	    char *newrv = malloc(strlen(rv) + strlen(val) + 1);
	    if (!newrv) {
		*err = "Out of memory copying string";
		return -1;
	    }
	    strcpy(newrv, rv);
	    strcat(newrv, val);
	    free(rv);
	    rv = newrv;
	} else {
	    rv = strdup(val);
	    if (!rv) {
		*err = "Out of memory copying string";
		return -1;
	    }
	}

	if (*tokptr == '\0' || isspace(*tokptr))
	    break;
    }
    *rtokptr = tokptr;
    *rval = rv;
    return 0;
}
예제 #28
0
int
parse_sysconf(const char* file)
{
  FILE* fp;
  char line[1024];
  char* p;
  if ((fp = fopen(file, "r")) == 0)
    {
      fprintf(stderr, "error opening: %s: %s\n", file, strerror(errno));
      return 0;
    }
  while (readline(fp, line, sizeof(line)))
    {
      if (!*line)
	continue;
      for (p = line; *p == ' '; ++p);
      if (!*p || *p == '#')
	continue;
      if (!strncmp(p, "PERMISSION_SECURITY=", 20))
	{
	  if (force_level)
	    continue;

	  p+=20;
	  if (isquote(*p))
	    ++p;
	  p = strtok(p, " ");
	  if (p && !isquote(*p))
	    {
	      do
		{
		  if (isquote(p[strlen(p)-1]))
		    {
		      p[strlen(p)-1] = '\0';
		    }
		  if (*p && strcmp(p, "local"))
		      add_level(p);
		}
	      while ((p = strtok(NULL, " ")));
	    }
	}
      else if (!strncmp(p, "CHECK_PERMISSIONS=", 18))
	{
	  p+=18;
	  if (isquote(*p))
	    ++p;
	  if (!strncmp(p, "set", 3))
	    {
	      p+=3;
	      if (isquote(*p) || !*p)
		default_set=1;
	    }
	  else if ((!strncmp(p, "no", 2) && (!p[3] || isquote(p[3]))) || !*p || isquote(*p))
	    {
	      p+=2;
	      if (isquote(*p) || !*p)
		{
		  default_set = -1;
		}
	    }
	  else
	    {
	      //fprintf(stderr, "invalid value for CHECK_PERMISSIONS (must be 'set', 'warn' or 'no')\n");
	    }
	}
#define FSCAPSENABLE "PERMISSION_FSCAPS="
      else if (have_fscaps == -1 && !strncmp(p, FSCAPSENABLE, strlen(FSCAPSENABLE)))
	{
	  p+=strlen(FSCAPSENABLE);
	  if (isquote(*p))
	    ++p;
	  if (!strncmp(p, "yes", 3))
	    {
	      p+=3;
	      if (isquote(*p) || !*p)
		have_fscaps=1;
	    }
	  else if (!strncmp(p, "no", 2))
	    {
	      p+=2;
	      if (isquote(*p) || !*p)
		have_fscaps=0;
	    } else
	        have_fscaps=1; /* default */
	}
    }
  fclose(fp);
  return 0;
}
예제 #29
0
// parse CIF contents
bool cif_file::parse() {
  char *p = contents;
  char quote;
  char prev = '\0';

  std::vector<bool> keypossible;

  // tokenize
  while (true) {
    while (iswhitespace(*p))
      prev = *(p++);

    if (!*p)
      break;

    if (*p == '#') {
      while (!(islinefeed0(*++p)));
      prev = *p;
    } else if (isquote(*p)) { // will NULL the closing quote
      quote = *p;
      keypossible.push_back(false);
      tokens.push_back(p + 1);
      while (*++p && !(*p == quote && iswhitespace0(p[1])));
      if (*p)
        *(p++) = 0;
      prev = *p;
    } else if (*p == ';' && islinefeed(prev)) { // will NULL the line feed before the closing semicolon
      keypossible.push_back(false);
      tokens.push_back(p + 1);
      while (*++p && !(islinefeed(*p) && p[1] == ';'));
      if (*p) {
        *p = 0;
        p += 2;
      }
      prev = ';';
    } else { // will null the whitespace
      char * q = p++;
      while (!iswhitespace0(*p)) ++p;
      prev = *p;
      if (p - q == 1 && (*q == '?' || *q == '.')) {
        // store values '.' (inapplicable) and '?' (unknown) as null-pointers
        q = nullptr;
        keypossible.push_back(false);
      } else {
        if (*p)
          *(p++) = 0;
        keypossible.push_back(true);
      }
      tokens.push_back(q);
    }
  }

  cif_data *current_data = nullptr, *current_frame = nullptr, *global_block = nullptr;

  // parse into dictionary
  for (unsigned int i = 0, n = tokens.size(); i < n; i++) {
    if (!keypossible[i]) {
      std::cout << "ERROR" << std::endl;
      break;
    } else if (tokens[i][0] == '_') {
      if (i + 1 == n) {
        std::cout << "ERROR truncated" << std::endl;
        break;
      }

      if (current_frame) {
        tolowerinplace(tokens[i]);
        current_frame->dict[tokens[i]].set_value(tokens[i + 1]);
      }

      i++;
    } else if (strcasecmp("loop_", tokens[i]) == 0) {
      int ncols = 0;
      int nrows = 0;
      cif_loop *loop = nullptr;

      // loop data
      if (current_frame) {
        loop = new cif_loop;

        // add to loops list
        current_frame->loops.push_back(loop);
      }

      // columns
      while (++i < n && keypossible[i] && tokens[i][0] == '_') {
        tolowerinplace(tokens[i]);

        if (current_frame) {
          current_frame->dict[tokens[i]].set_loop(loop, ncols);
        }

        ncols++;
      }

      if (loop) {
        // loop data
        loop->values = (const char **) &tokens[i];
        loop->ncols = ncols;
      }

      // rows
      while (i < n && !(keypossible[i] && isspecial(tokens[i]))) {
        i += ncols;

        if (i > n) {
          std::cout << "ERROR truncated loop" << std::endl;
          break;
        }

        nrows++;
      }

      // loop data
      if (loop) {
        loop->nrows = nrows;
      }

      i--;

    } else if (strncasecmp("data_", tokens[i], 5) == 0) {
      const char * key(tokens[i] + 5);
      datablocks[key] = current_data = current_frame = new cif_data;

    } else if (strncasecmp("global_", tokens[i], 5) == 0) {
      // STAR feature, not supported in CIF
      global_block = current_data = current_frame = new cif_data;

    } else if (strncasecmp("save_", tokens[i], 5) == 0) {
      if (tokens[i][5] && current_data) {
        // begin
        const char * key(tokens[i] + 5);
        current_data->saveframes[key] = current_frame = new cif_data;
      } else {
        // end
        current_frame = current_data;
      }
    } else {
      std::cout << "ERROR" << std::endl;
      break;
    }
  }

  if (global_block)
    delete global_block;

  return true;
}