int main(int argc, char**argv)
{
ProtobufCService *service;
ProtobufC_RPC_Client *client;
ProtobufC_RPC_AddressType address_type=0;
const char *name = NULL;
unsigned i;
for (i = 1; i < (unsigned) argc; i++)
{
if (starts_with (argv[i], "--tcp="))
{
address_type = PROTOBUF_C_RPC_ADDRESS_TCP;
name = strchr (argv[i], '=') + 1;
}
else if (starts_with (argv[i], "--unix="))
{
address_type = PROTOBUF_C_RPC_ADDRESS_LOCAL;
name = strchr (argv[i], '=') + 1;
}
else
usage ();
}
if (name == NULL)
die ("missing --tcp=HOST:PORT or --unix=PATH");
service = protobuf_c_rpc_client_new (address_type, name, &foo__dir_lookup__descriptor, NULL);
if (service == NULL)
die ("error creating client");
client = (ProtobufC_RPC_Client *) service;
fprintf (stderr, "Connecting... ");
while (!protobuf_c_rpc_client_is_connected (client))
protobuf_c_dispatch_run (protobuf_c_dispatch_default ());
fprintf (stderr, "done.\n");
for (;;)
{
char buf[1024];
Foo__Name query = FOO__NAME__INIT;
protobuf_c_boolean is_done = 0;
fprintf (stderr, ">> ");
if (fgets (buf, sizeof (buf), stdin) == NULL)
break;
if (is_whitespace (buf))
continue;
chomp_trailing_whitespace (buf);
query.name = buf;
foo__dir_lookup__by_name (service, &query, handle_query_response, &is_done);
while (!is_done)
protobuf_c_dispatch_run (protobuf_c_dispatch_default ());
}
return 0;
}
bool ep_parse(struct effect_parser *ep, gs_effect_t effect,
const char *effect_string, const char *file)
{
bool success;
const char *graphics_preprocessor = gs_preprocessor_name();
if (graphics_preprocessor) {
struct cf_def def;
cf_def_init(&def);
def.name.str.array = graphics_preprocessor;
def.name.str.len = strlen(graphics_preprocessor);
strref_copy(&def.name.unmerged_str, &def.name.str);
cf_preprocessor_add_def(&ep->cfp.pp, &def);
}
ep->effect = effect;
if (!cf_parser_parse(&ep->cfp, effect_string, file))
return false;
while (ep->cfp.cur_token && ep->cfp.cur_token->type != CFTOKEN_NONE) {
if (cf_token_is(&ep->cfp, ";") ||
is_whitespace(*ep->cfp.cur_token->str.array)) {
/* do nothing */
ep->cfp.cur_token++;
} else if (cf_token_is(&ep->cfp, "struct")) {
ep_parse_struct(ep);
} else if (cf_token_is(&ep->cfp, "technique")) {
ep_parse_technique(ep);
} else if (cf_token_is(&ep->cfp, "sampler_state")) {
ep_parse_sampler_state(ep);
} else if (cf_token_is(&ep->cfp, "{")) {
/* add error and pass braces */
cf_adderror(&ep->cfp, "Unexpected code segment",
LEX_ERROR, NULL, NULL, NULL);
cf_pass_pair(&ep->cfp, '{', '}');
} else {
/* parameters and functions */
ep_parse_other(ep);
}
}
success = !error_data_has_errors(&ep->cfp.error_list);
if (success)
success = ep_compile(ep);
return success;
}
std::optional<Range> Item::Range () const noexcept {
std::optional<Unicode::Range> retr;
auto begin=this->begin();
auto end=this->end();
// Get and check the beginning of the range
auto first=get_integer<Unicode::CodePoint::Type>(begin,end);
if (
!first ||
(begin==end) ||
is_whitespace(begin,end)
) return retr;
// Get the range separator
for (std::size_t i=0;i<2;++i) {
if (*begin=='.') {
++begin;
continue;
}
if (is_whitespace(begin,end)) return retr;
}
// Get and check the end of the range
auto second=get_integer<Unicode::CodePoint::Type>(begin,end);
if (!(
second &&
(
(begin==end) ||
is_whitespace(begin,end)
)
)) return retr;
return Unicode::Range{*first,*second};
}
/* Windows XCOPY uses a simplified command line parsing algorithm
that lacks the escaped-quote logic of build_argv(), because
literal double quotes are illegal in any of its arguments.
Example: 'XCOPY "c:\DIR A" "c:DIR B\"' is OK. */
static int find_end_of_word(const WCHAR *word, WCHAR **end)
{
BOOL in_quotes = FALSE;
const WCHAR *ptr = word;
for (;;) {
for (; *ptr != '\0' && *ptr != '"' &&
(in_quotes || !is_whitespace(*ptr)); ptr++);
if (*ptr == '"') {
in_quotes = !in_quotes;
ptr++;
}
/* Odd number of double quotes is illegal for XCOPY */
if (in_quotes && *ptr == '\0')
return RC_INITERROR;
if (*ptr == '\0' || (!in_quotes && is_whitespace(*ptr)))
break;
}
*end = (WCHAR*)ptr;
return RC_OK;
}
static thing_th *read_literals(FILE *src, text_buffer *tb, int inputChar) {
while(!literal_terminator_char(inputChar)) {
tb_append(tb, inputChar);
inputChar=get_character(src);
}
if(!is_whitespace(inputChar))
ungetc(inputChar, src);
if(is_decimal_text(tb->txt))
return read_subcons(Number(tb->txt), src, tb);
return read_subcons(Atom(tb->txt), src, tb);
}
bool is_token(const std::string& token)
{
if (is_comment_token(token)) return true;
else if (is_string_token(token)) return true;
else if (is_char_token(token)) return true;
else if (is_whitespace(token[token.size() - 1])) return false;
else if (symbols.count(token) == 1) return true;
else if (keywords.count(token) == 1) return true;
else if (is_number_token(token)) return true;
else return is_identifier_token(token);
}
//---------------------------------------------------------------------------
// Reads next word from input string
//
// Word is stored in state.word_buffer and its length in state.word_len
//
// Return value:
// * 0: Success
// * -1: No word
// * -2: Word is longer than MAX_WORD_LEN
//---------------------------------------------------------------------------
int FMC_read_word(struct FMState *state) {
#define M_cur_char() (state->input_string[state->input_index])
state->word_len = 0; // Reset word
if (state->input_string == NULL) { // If no input string, no word
return -1;
}
// Skip whitespace
while (M_cur_char() != NUL && is_whitespace(M_cur_char())) {
state->input_index++;
}
if (M_cur_char() == NUL) { // If at end of string, no word
return -1;
}
// Copy word into buffer
while(state->word_len <= MAX_WORD_LEN) {
if (is_whitespace(M_cur_char())) { // Stop if hit whitespace,
state->input_index++; // but advance past whitespace char first
break;
}
if (M_cur_char() == NUL) { // Stop if hit EOS
break;
}
if (state->word_len == MAX_WORD_LEN) { // If we're about to exceed word_buffer...
state->word_len = 0; // reset word,
FMC_abort(state, "Dictionary full", __FILE__, __LINE__);
return -2; // and indicate error
}
state->word_buffer[state->word_len++] = // Store next character
M_cur_char();
state->input_index++; // Go to next char in input
}
state->word_buffer[state->word_len] = NUL; // When done, NUL terminate word,
return 0; // and indicate success
}
/*
* Reads a token from opened token file. The token must be initialized.
* If token was found function returns TOK_OK and valid data are in the token structure.
* Otherwise an error occured and there may be anything in the token structure.
*/
int fgetToken(TOKEN_FILE *tf, TOKEN *token) {
// Check params.
if (!tf || !token)
return TOK_INVALID_PARAMS;
// Set token to empty string.
token->len = 0;
token->str[0] = '\0';
// Skip leading whitespace.
int c = tfpeek(tf);
token->newline = 0;
while ((c != EOF) && is_whitespace(c)) {
if (c == '\n') token->newline = 1;
tfgetc(tf);
c = tfpeek(tf);
}
// If there are no more data or error occured, announce it.
if (c == EOF) return (tferror(tf) == 0) ? TOK_EOF : TOK_READING_ERROR;
// Read the token.
while ((c != EOF) && !is_whitespace(c)) {
// Ensure that token string capacity is sufficient.
if (token->len == token->capacity) {
if (reallocToken(token) != TOK_OK)
return TOK_OUT_OF_MEMORY;
}
// Add char to the token and read another one.
token->str[ token->len++ ] = tfgetc(tf);
c = tfpeek(tf);
}
// Add trailing null char into token string.
token->str[token->len] = '\0';
return (tferror(tf) == 0) ? TOK_OK : TOK_READING_ERROR;
}
static void skip_whitespace(FILE *fp)
{
for (;;) {
int c;
c = getc(fp);
if (feof(fp)) return;
if (!is_whitespace(c)) {
ungetc(c, fp);
break;
}
}
}
static char *
read_expression (struct parsebuf *p)
{
int start;
int end;
skip_whitespace (p);
if (peek_char (p) == '"')
{
/* Read as a quoted string.
The quotation marks are not included in the expression value. */
/* Skip opening quotation mark. */
read_char (p);
start = p->pos;
while (has_more (p) && peek_char (p) != '"')
read_char (p);
end = p->pos;
/* Skip the terminating quotation mark. */
read_char (p);
}
else if (peek_char (p) == '(')
{
/* Read as a parenthesized string -- for tuples/coordinates. */
/* The parentheses are included in the expression value. */
int c;
start = p->pos;
do
{
c = read_char (p);
}
while (c != -1 && c != ')');
end = p->pos;
}
else if (has_more (p))
{
/* Read as a single word -- for numeric values or words without
whitespace. */
start = p->pos;
while (has_more (p) && ! is_whitespace (peek_char (p)))
read_char (p);
end = p->pos;
}
else
{
/* The end of the theme file has been reached. */
grub_error (GRUB_ERR_IO, "%s:%d:%d expression expected in theme file",
p->filename, p->line_num, p->col_num);
return 0;
}
return grub_new_substring (p->buf, start, end);
}
int validate_expr(char *expression)
{
char x, op;
int vt, opt, level;
char ops[STACK_SIZE];
vt = -1; opt = -1;
while ((x = *expression++) != '\0')
if (is_value(x)) {
vt += 1;
} else if (is_op(x)) {
level = op_level(x);
while (opt >= 0 && level < op_level(ops[opt]) && \
ops[opt] != LEFTP) {
op = ops[opt];
opt -= 1;
if (op == PLUS || op == MULT)
vt -= 1;
if (vt < 0)
return 0;
}
if (x == RIGHP) {
while (opt >=0 && ops[opt] != LEFTP) {
op = ops[opt];
if (op == PLUS || op == MULT)
vt -= 1;
if (vt < 0)
return 0;
opt -= 1;
}
if (opt < 0)
return 0;
opt -= 1;
} else {
ops[++opt] = x;
}
} else if (!is_whitespace(x)){
return 0;
}
while (opt >= 0) {
op = ops[opt];
if (op == LEFTP)
return 0;
if (op == PLUS || op == MULT)
vt -= 1;
if (vt < 0)
return 0;
opt -= 1;
}
return vt == 0 && opt == -1;
}
char last_non_whitespace(char* string, int start)
{
int x;
if(start>0) // start from inside array and work backwards
{
for(x=start; x; x--)
{
if(!is_whitespace(string[x]))
return string[x];
}
}
else // start from beginning and work forwards
{
for(x=0; x<(signed)strlen(string); x++)
{
if(!is_whitespace(string[x]))
return string[x];
}
}
return 'x';
}
static char*
e5_trim(
char* input, int left, int right, size_t maxlen)
{
size_t n = 0;
char* start = input;
while (left && is_whitespace(*start))
start++;
n = start - input;
char* ptr = start;
char* end = start;
while (right && *ptr++ != '\0' && n++ < (maxlen-1))
{
if (!is_whitespace(*ptr))
end = ptr;
}
*(++end) = '\0';
return start;
}
int translate_range_string_to_vector(const char *range_string, std::vector<int> &indices)
{
char *str = strdup(range_string);
char *ptr = str;
int prev;
int curr;
while (*ptr != '\0')
{
prev = strtol(ptr, &ptr, 10);
if (*ptr == '-')
{
ptr++;
curr = strtol(ptr, &ptr, 10);
while (prev <= curr)
{
indices.push_back(prev);
prev++;
}
if ((*ptr == ',') ||
(is_whitespace(*ptr)))
ptr++;
}
else
{
indices.push_back(prev);
if ((*ptr == ',') ||
(is_whitespace(*ptr)))
ptr++;
}
}
free(str);
return(PBSE_NONE);
}
static int parse_word(lua_State *L, parse_state *state, const char *word, const char *err_msg) {
const char *ptr = state->ptr;
while (*ptr == *word && *ptr != 0 && *word != 0) {
ptr++;
word++;
}
if (*word == 0 && (is_whitespace(*ptr) || is_punct(*ptr) || *ptr == 0)) {
state->ptr = ptr;
return 1;
} else {
return push_parse_error(L, state, err_msg);
}
}
int
is_delimiter(char c)
{
if (is_whitespace(c) || c == '!' || c == '<' || c == '>' ||
c == ';' || c == '=' || c == '{' || c == '}' ||
c == '(' || c == ')' || c == '&' || c == '|' ||
c == EOF)
{
return 1;
}
else
return 0;
}
void lexer::skip() {
bool inComment = false;
for (; current != end; current++, column++) {
if (!inComment && *current == ';') {
inComment = true;
} else if (!inComment && !is_whitespace(*current)) {
break;
} else if (inComment && *current == '\n') {
break;
}
}
}
/* Check if a line is a label, returns 1 if it is, and 0 if not */
int is_label_line(char *line) {
int i;
char *p, *colon;
char *alphanumeric;
assert(line != NULL);
colon = strchr(line, ':');
/* should have a : marking the end of the label name */
if (colon == NULL)
return 0;
/* only characters that should come after the colon are spaces */
for (i = 1; i < strlen(colon); i++)
if (!is_whitespace(colon[i]))
return 0;
/* and everything before it should be alphanumeric or a space or underscore */
for (p = line; p < colon; p++)
if (!is_alphanumeric(*p) && !is_whitespace(*p) && *p != '_')
return 0;
/* ...but we cannot have a space in the middle of the label (e.g. "LA BEL:" disallowed)
AND we must have atleast one alphanumeric character for the label name */
alphanumeric = get_first_alphanumeric(line);
if (alphanumeric == NULL)
return 0;
/* from the first alphanumeric character to the : */
for (p = alphanumeric; p < colon; p++) {
if (!is_alphanumeric(*p) && *p != '_') /* we should only have alphanumeric characters or underscores */
return 0;
p++;
}
return 1;
}
END_TEST
START_TEST(trim_whitespace_test)
{
char *strs[] = { (char *)" one ", (char *)" \ntwo", (char *)"three ", (char *)" four", (char *)"five ", (char *)" six ", (char *)"\t" };
char firsts[] = { 'o', 't', 't', 'f', 'f', 's', '\0' };
char lasts[] = { 'e', 'o', 'e', 'r', 'e', 'x' };
int num_strs = 7;
int i;
int last;
char *duped;
char *retd;
fail_unless(is_whitespace(' ') == TRUE, "doesn't think a space is whitespace");
fail_unless(is_whitespace('\n') == TRUE, "doesn't think a newline is whitespace");
fail_unless(is_whitespace('\f') == TRUE, "doesn't think a formfeed is whitespace");
fail_unless(is_whitespace('\t') == TRUE, "doesn't think a tab is whitespace");
fail_unless(is_whitespace('\r') == TRUE, "doesn't think a carriage return is whitespace");
for (i = 0; i < num_strs; i++)
{
duped = strdup(strs[i]);
retd = trim(duped);
snprintf(buf, sizeof(buf), "didn't trim the front correctly, found '%s' but expected to start with %c",
retd, firsts[i]);
fail_unless(retd[0] == firsts[i], buf);
last = strlen(retd) - 1;
if (last > 0)
{
snprintf(buf, sizeof(buf), "didn't trim the back correctly, found '%s' but expected to end with %c",
retd, lasts[i]);
fail_unless(retd[last] == lasts[i], buf);
}
}
fail_unless(trim(NULL) == NULL, "returned a non-null for null string");
}
static thing_th *read_expressions(FILE *src, text_buffer *tb) {
int inputChar;
tb_clear(tb);
while(is_whitespace(inputChar=get_character(src)));
if(inputChar==EOF || is_closer(inputChar))
return NULL;
if(character_is_break_out_token(inputChar))
return read_subcons(breakout_character(inputChar), src, tb);
if(is_quotation(inputChar))
return read_string(inputChar, src, tb);
if(is_opener(inputChar))
return read_subcons(open_sub_cons(src, tb, inputChar), src, tb);
return read_literals(src, tb, inputChar);
}
void DocumentView::trim_trailing_whitespace() {
//FIXME: Don't strip whitespace if the language doesn't like it (e.g. 'diff')
auto current = buffer()->begin();
while(current != buffer()->end()) {
current.forward_to_line_end(); //Move to the newline character
auto line_end = current; //Store the end of the line
while(is_whitespace(--current)) {} //Move backward until we get to non-whitespace
current = buffer()->erase(++current, line_end);
current.forward_line(); //Move to the next line, or the end of the final line
}
}
static int parse_literal(parsebuf_p pb, char **start, char **stop, int terminator)
{
int c;
DEBUG();
*start = pb->s + pb->i;
for(; (c = __parsebuf_next(pb)) > 0 && is_symbolchar(c) && (c != terminator););
if (c <= 0) return -1;
__parsebuf_prev(pb);
*stop = pb->s + pb->i;
if (*start >= *stop) return -1;
if (!is_whitespace(c) && c != terminator) return -1;
return 0;
}
static boolean is_else (const char* line)
{
uintL n = strlen(line);
uintL i = 0;
/* Skip whitespace. */
for (; i < n && is_whitespace(line[i]); i++) {}
/* Parse a '#'. */
if (i < n && line[i] == '#')
i++;
else
return FALSE;
/* Skip whitespace. */
for (; i < n && is_whitespace(line[i]); i++) {}
/* Check for "else". */
if (i+4 <= n
&& line[i+0] == 'e'
&& line[i+1] == 'l'
&& line[i+2] == 's'
&& line[i+3] == 'e'
&& (i+4 == n || is_whitespace(line[i+4]))) {
return TRUE;
}
return FALSE;
}
void run(struct iso *context)
{
char cmd[MAX_COMMAND_SIZE + 1];
while (running && prompt(cmd, MAX_COMMAND_SIZE + 1))
{
int argc = 0;
char *argv[MAX_COMMAND_SIZE];
ssize_t read_b = 0;
for (char *s = cmd; *s; ++s)
++read_b;
char *s = cmd + read_b - 1;
for (; read_b > 0; --read_b, --s)
{
for (; read_b > 0 && is_whitespace(*s); --read_b, --s)
continue;
if (read_b)
{
*(s + 1) = '\0';
for (; read_b > 0 && !is_whitespace(*s); --read_b, --s)
continue;
argv[argc++] = s + 1;
}
}
if (!argc)
continue;
for (int i = 0; i < argc / 2; ++i)
swap(argv, i, argc - i - 1);
get_command(argv[0])(context, argc, argv);
}
}
static int get_indent(const std::string text) {
auto range = codepoint_range(text);
auto it = range.end();
std::size_t indent = 0;
while (it != range.begin()) {
auto ch = *--it;
if (!is_whitespace(ch)) break;
if (ch == '\n') return indent;
++indent;
}
while (it != range.begin()) {
auto ch = *--it;
if (ch == '\n') return 0;
}
return -1;
}
void move_past_whitespace(
char **str)
{
if ((str == NULL) ||
(*str == NULL))
return;
char *current = *str;
while (is_whitespace(*current) == TRUE)
current++;
*str = current;
} // END move_past_whitespace()
void skip_whitespace(muj_source source)
{
char byte;
for(;;)
{
bool success = muj_peek_byte(source, &byte);
if (!success)
break;
if (is_whitespace(byte))
{
muj_read_byte(source, &byte); // will always succeed because peek did
}
else
break;
}
}
static gboolean
find_whitepace_region (const GtkTextIter *center,
GtkTextIter *start,
GtkTextIter *end)
{
*start = *center;
*end = *center;
if (gtk_text_iter_backward_find_char (start, is_not_whitespace, NULL, NULL))
gtk_text_iter_forward_char (start); /* we want the first whitespace... */
if (is_whitespace (gtk_text_iter_get_char (end), NULL))
gtk_text_iter_forward_find_char (end, is_not_whitespace, NULL, NULL);
return ! gtk_text_iter_equal (start, end);
}
void handle_alias_glob(char **expr, int **t_ind, int **l_ind)
{
t_norm_hag t;
(t.i) = 0;
(t.first_time) = TRUE;
(t.len) = ft_strlen((*expr));
while ((t.i) < (t.len))
{
(t.continu) = FALSE;
if (is_whitespace((*expr)[(t.i)]) &&
!is_intouchable((t.i), (*t_ind), (*l_ind)))
(t.i)++;
else
handle_alias_glob2(expr, t_ind, l_ind, &t);
}
}
static int parse_number(lua_State *L, parse_state *state) {
char *end;
double n = strtod(state->ptr, &end);
if (state->ptr == end || (*end != 0 && !is_whitespace(*end) && !is_punct(*end))) {
return push_parse_error(L, state, "invalid number");
} else {
state->ptr = end;
if ((double)((int)n) == n) {
// in case we're using different representation for
// integers in the lua vm
lua_pushinteger(L, (int)n);
} else {
lua_pushnumber(L, n);
}
return 1;
}
}
