int kill_to_end_of_line( void )
{
int nd;
int count = arg;
bool merge = last_proc == kill_to_end_of_line;
if( cur_exec != 0 && cur_exec->p_nargs > 0 )
count = count * numeric_arg (1);
do
{
arg = 1;
nd = dot;
end_of_line ();
nd = dot - nd;
if( nd <= 0 )
nd = -1;
if( !merge )
replace_to_buf (-nd, kill_buffer_str);
else
append_to_buf (-nd, kill_buffer_str);
merge = true;
count--;
}
while( count > 0 );
return 0;
}
char *my_read(int fd)
{
static int i = -1;
static char buff[BUFF_SIZE + 1];
int ret;
if (i == -1 || buff[i] == '\0')
{
i = 0;
while (buff[i + 1])
buff[i++] = '\0';
ret = read(fd, buff, BUFF_SIZE);
if (ret < 0)
{
msg_error("read error.\n");
return (NULL);
}
if (ret == 0)
return (NULL);
buff[ret] = '\0';
}
ret = i;
i = end_of_line(buff + i) + i + 1;
return (read_one_line(buff, ret));
}
void AlphanumericState::next_state(LexingAutomation &automation, SymbolTypes symbol_type)
{
switch (symbol_type)
{
case kUnderscore:
case kLetter:
case kDigit:
break;
case kOperationSymbol:
{
automation.set_result(handle_alphanumeric(automation.get_buffer_prefix(), automation.line(), automation.column()));
automation.set_buffer_to_last_char();
automation.set_state(state_ptr(new OperationState()));
}
break;
case kSeparator:
{
automation.set_result(handle_alphanumeric(automation.get_buffer_prefix(), automation.line(), automation.column()));
string buffer = automation.buffer();
char lexeme_symbol = buffer[buffer.length() - 1];
Lexeme result = handle_separator(lexeme_symbol, automation.line(), automation.column());
automation.set_result(result);
automation.clear_buffer();
automation.set_state(state_ptr(new EmptyState()));
}
break;
case kLinefeed:
{
automation.set_result(handle_alphanumeric(automation.get_buffer_prefix(), automation.line(), automation.column()));
automation.set_result(end_of_line(automation.line(), automation.column()));
automation.clear_buffer();
automation.set_state(state_ptr(new EmptyState()));
}
break;
case kWhitespace:
{
automation.set_result(handle_alphanumeric(automation.get_buffer_prefix(), automation.line(), automation.column()));
automation.clear_buffer();
automation.set_state(state_ptr(new EmptyState()));
}
break;
case kHashSymbol:
{
automation.set_result(handle_alphanumeric(automation.get_buffer_prefix(), automation.line(),automation.column()));
automation.set_state(state_ptr(new CommentState()));
}
break;
default:
ErrorHandler::report_syntax_error(automation.line());
automation.set_state(state_ptr(new ErrorState()));
break;
}
}
char *get_next_line(int fd)
{
char *str;
char *tmp;
str = my_read(fd);
if (str == NULL)
return (NULL);
while (end_of_line(str) < 0 && my_strlen(str) < BUFF_SIZE * 10)
{
tmp = my_read(fd);
if (tmp == NULL)
return (NULL);
str = my_strcatdup(str, tmp);
if (str == NULL)
return (NULL);
}
str[end_of_line(str)] = '\0';
return (str);
}
void parse_mem_work(struct sdp_work *curr, const char *filename, const char *p)
{
struct mem_work *wp;
struct mem_work **link;
struct mem_work w;
unsigned int i;
const char *start = p;
p = skip(p,':');
memset(&w, 0, sizeof(w));
if (strncmp(p, "read", 4) == 0) {
p += 4;
p = skip(p,',');
i = MEM_TYPE_READ;
} else if (strncmp(p, "write", 5) == 0) {
p += 5;
p = skip(p,',');
i = MEM_TYPE_WRITE;
} else if (strncmp(p, "modify", 6) == 0) {
p += 6;
p = skip(p,',');
i = MEM_TYPE_MODIFY;
} else {
printf("%s: syntax error: %s {%s}\n", filename, p, start);
}
w.type = i;
i = 0;
for (;;) {
w.vals[i] = get_val(&p, 16);
if (i >= w.type)
break;
p = skip(p,',');
if ((*p == 0) || (*p == '#')) {
printf("%s: missing argment: %s {%s}\n", filename, p, start);
return;
}
i++;
}
if (!end_of_line(p)) {
printf("%s: syntax error: %s {%s}\n", filename, p, start);
return;
}
wp = (struct mem_work *)malloc(sizeof(struct mem_work));
if (!wp)
return;
link = &curr->mem;
while (*link)
link = &(*link)->next;
*wp = w;
*link = wp;
}
void EmptyState::next_state(LexingAutomation& automation, SymbolTypes symbol_type)
{
switch (symbol_type)
{
case kLetter:
automation.set_state(state_ptr(new AlphanumericState()));
break;
case kDigit:
automation.set_state(state_ptr(new NumericState()));
break;
case kOperationSymbol:
automation.set_state(state_ptr(new OperationState()));
break;
case kSeparator:
{
string buffer = automation.buffer();
char lexeme_symbol = buffer[buffer.length() - 1];
Lexeme result = handle_separator(lexeme_symbol, automation.line(), automation.column());
automation.set_result(result);
automation.clear_buffer();
}
break;
case kLinefeed:
automation.set_result(end_of_line(automation.line(), automation.column()));
automation.clear_buffer();
break;
case kWhitespace:
if (automation.buffer().length() != 1)
automation.set_state(state_ptr(new ErrorState()));
else
automation.clear_buffer();
break;
case kHashSymbol:
automation.set_state(state_ptr(new CommentState()));
break;
default:
ErrorHandler::report_syntax_error(automation.line());
automation.set_state(state_ptr(new ErrorState()));
break;
}
}
static int fill_the_line(const int fd, char *tmp[fd], char **line)
{
int end;
char *temp;
end = end_of_line(tmp[fd]);
*line = ft_strsub(tmp[fd], 0, end);
if (!(temp = (char *)malloc(sizeof(temp) * (ft_strlen(tmp[fd]) + 1))))
return (-1);
ft_strcpy(temp, &tmp[fd][end + 1]);
ft_strclr(tmp[fd]);
tmp[fd] = ft_strcpy(tmp[fd], temp);
free(temp);
return (1);
}
/*
** If string received from my_read contains delimitor ('\n'):
** => return line (without '\n').
** Else while there isn't a '\n' it appends string with next string.
** Display line before to return it.
*/
char *get_next_line(int fd)
{
char *str;
char *tmp;
str = my_read(fd);
if (str == NULL)
return (NULL);
while (str[end_of_line(str)] != '\n' && my_strlen(str) < BUFF_SIZE * 10)
{
tmp = my_read(fd);
if (tmp == NULL)
return (NULL);
str = my_strcatdup(str, tmp);
if (str == NULL)
return (NULL);
}
str[end_of_line(str)] = '\0';
if (my_str_isprintable(str))
return (str);
my_putstr(str);
my_putchar('\n');
return (str);
}
char *read_one_line(char buff[BUFF_SIZE + 1], int i)
{
int cpt;
int pos;
char *str;
cpt = 0;
pos = end_of_line(buff + i) + i;
if (pos < 0)
pos = my_strlen(buff);
if ((str = malloc(sizeof(*str) * (pos - i) + 2)) == NULL)
return (NULL);
while (i <= pos)
str[cpt++] = buff[i++];
str[cpt] = '\0';
return (str);
}
int get_next_line(int const fd, char **line)
{
static t_stock *stocks[MAX_FD];
if (fd >= MAX_FD || fd < 0 || line == NULL)
return (-1);
if (stocks[fd] && stocks[fd]->read_ret == 0)
return (0);
if (!stocks[fd] && setup(&stocks[fd]))
return (-1);
while (stocks[fd]->read_ret > 0 && !((end_of_line(stocks[fd]))))
{
while (stocks[fd]->lu + BUF_SIZE > stocks[fd]->length)
if (increase_spill_size(stocks[fd]))
return (-1);
stocks[fd]->read_ret = read(fd, stocks[fd]->spill + stocks[fd]->lu
, BUF_SIZE);
stocks[fd]->lu += stocks[fd]->read_ret;
}
return (deal_with_returns(&stocks[fd], stocks[fd], line));
}
static int grep_buffer_1(struct grep_opt *opt, const char *name,
char *buf, unsigned long size, int collect_hits)
{
char *bol = buf;
unsigned long left = size;
unsigned lno = 1;
unsigned last_hit = 0;
int binary_match_only = 0;
unsigned count = 0;
int try_lookahead = 0;
enum grep_context ctx = GREP_CONTEXT_HEAD;
xdemitconf_t xecfg;
opt->last_shown = 0;
if (!opt->output)
opt->output = std_output;
if (buffer_is_binary(buf, size)) {
switch (opt->binary) {
case GREP_BINARY_DEFAULT:
binary_match_only = 1;
break;
case GREP_BINARY_NOMATCH:
return 0; /* Assume unmatch */
break;
default:
break;
}
}
memset(&xecfg, 0, sizeof(xecfg));
if (opt->funcname && !opt->unmatch_name_only && !opt->status_only &&
!opt->name_only && !binary_match_only && !collect_hits) {
struct userdiff_driver *drv = userdiff_find_by_path(name);
if (drv && drv->funcname.pattern) {
const struct userdiff_funcname *pe = &drv->funcname;
xdiff_set_find_func(&xecfg, pe->pattern, pe->cflags);
opt->priv = &xecfg;
}
}
try_lookahead = should_lookahead(opt);
while (left) {
char *eol, ch;
int hit;
/*
* look_ahead() skips quicly to the line that possibly
* has the next hit; don't call it if we need to do
* something more than just skipping the current line
* in response to an unmatch for the current line. E.g.
* inside a post-context window, we will show the current
* line as a context around the previous hit when it
* doesn't hit.
*/
if (try_lookahead
&& !(last_hit
&& lno <= last_hit + opt->post_context)
&& look_ahead(opt, &left, &lno, &bol))
break;
eol = end_of_line(bol, &left);
ch = *eol;
*eol = 0;
if ((ctx == GREP_CONTEXT_HEAD) && (eol == bol))
ctx = GREP_CONTEXT_BODY;
hit = match_line(opt, bol, eol, ctx, collect_hits);
*eol = ch;
if (collect_hits)
goto next_line;
/* "grep -v -e foo -e bla" should list lines
* that do not have either, so inversion should
* be done outside.
*/
if (opt->invert)
hit = !hit;
if (opt->unmatch_name_only) {
if (hit)
return 0;
goto next_line;
}
if (hit) {
count++;
if (opt->status_only)
return 1;
if (binary_match_only) {
opt->output(opt, "Binary file ", 12);
output_color(opt, name, strlen(name),
opt->color_filename);
opt->output(opt, " matches\n", 9);
return 1;
}
if (opt->name_only) {
show_name(opt, name);
return 1;
}
/* Hit at this line. If we haven't shown the
* pre-context lines, we would need to show them.
* When asked to do "count", this still show
* the context which is nonsense, but the user
* deserves to get that ;-).
*/
if (opt->pre_context)
show_pre_context(opt, name, buf, bol, lno);
else if (opt->funcname)
show_funcname_line(opt, name, buf, bol, lno);
if (!opt->count)
show_line(opt, bol, eol, name, lno, ':');
last_hit = lno;
}
else if (last_hit &&
lno <= last_hit + opt->post_context) {
/* If the last hit is within the post context,
* we need to show this line.
*/
show_line(opt, bol, eol, name, lno, '-');
}
next_line:
bol = eol + 1;
if (!left)
break;
left--;
lno++;
}
if (collect_hits)
return 0;
if (opt->status_only)
return 0;
if (opt->unmatch_name_only) {
/* We did not see any hit, so we want to show this */
show_name(opt, name);
return 1;
}
xdiff_clear_find_func(&xecfg);
opt->priv = NULL;
/* NEEDSWORK:
* The real "grep -c foo *.c" gives many "bar.c:0" lines,
* which feels mostly useless but sometimes useful. Maybe
* make it another option? For now suppress them.
*/
if (opt->count && count) {
char buf[32];
output_color(opt, name, strlen(name), opt->color_filename);
output_sep(opt, ':');
snprintf(buf, sizeof(buf), "%u\n", count);
opt->output(opt, buf, strlen(buf));
}
return !!last_hit;
}
static int grep_source_1(struct grep_opt *opt, struct grep_source *gs, int collect_hits)
{
char *bol;
unsigned long left;
unsigned lno = 1;
unsigned last_hit = 0;
int binary_match_only = 0;
unsigned count = 0;
int try_lookahead = 0;
int show_function = 0;
struct userdiff_driver *textconv = NULL;
enum grep_context ctx = GREP_CONTEXT_HEAD;
xdemitconf_t xecfg;
if (!opt->output)
opt->output = std_output;
if (opt->pre_context || opt->post_context || opt->file_break ||
opt->funcbody) {
/* Show hunk marks, except for the first file. */
if (opt->last_shown)
opt->show_hunk_mark = 1;
/*
* If we're using threads then we can't easily identify
* the first file. Always put hunk marks in that case
* and skip the very first one later in work_done().
*/
if (opt->output != std_output)
opt->show_hunk_mark = 1;
}
opt->last_shown = 0;
if (opt->allow_textconv) {
grep_source_load_driver(gs);
/*
* We might set up the shared textconv cache data here, which
* is not thread-safe.
*/
grep_attr_lock();
textconv = userdiff_get_textconv(gs->driver);
grep_attr_unlock();
}
/*
* We know the result of a textconv is text, so we only have to care
* about binary handling if we are not using it.
*/
if (!textconv) {
switch (opt->binary) {
case GREP_BINARY_DEFAULT:
if (grep_source_is_binary(gs))
binary_match_only = 1;
break;
case GREP_BINARY_NOMATCH:
if (grep_source_is_binary(gs))
return 0; /* Assume unmatch */
break;
case GREP_BINARY_TEXT:
break;
default:
die("bug: unknown binary handling mode");
}
}
memset(&xecfg, 0, sizeof(xecfg));
opt->priv = &xecfg;
try_lookahead = should_lookahead(opt);
if (fill_textconv_grep(textconv, gs) < 0)
return 0;
bol = gs->buf;
left = gs->size;
while (left) {
char *eol, ch;
int hit;
/*
* look_ahead() skips quickly to the line that possibly
* has the next hit; don't call it if we need to do
* something more than just skipping the current line
* in response to an unmatch for the current line. E.g.
* inside a post-context window, we will show the current
* line as a context around the previous hit when it
* doesn't hit.
*/
if (try_lookahead
&& !(last_hit
&& (show_function ||
lno <= last_hit + opt->post_context))
&& look_ahead(opt, &left, &lno, &bol))
break;
eol = end_of_line(bol, &left);
ch = *eol;
*eol = 0;
if ((ctx == GREP_CONTEXT_HEAD) && (eol == bol))
ctx = GREP_CONTEXT_BODY;
hit = match_line(opt, bol, eol, ctx, collect_hits);
*eol = ch;
if (collect_hits)
goto next_line;
/* "grep -v -e foo -e bla" should list lines
* that do not have either, so inversion should
* be done outside.
*/
if (opt->invert)
hit = !hit;
if (opt->unmatch_name_only) {
if (hit)
return 0;
goto next_line;
}
if (hit) {
count++;
if (opt->status_only)
return 1;
if (opt->name_only) {
show_name(opt, gs->name);
return 1;
}
if (opt->count)
goto next_line;
if (binary_match_only) {
opt->output(opt, "Binary file ", 12);
output_color(opt, gs->name, strlen(gs->name),
opt->color_filename);
opt->output(opt, " matches\n", 9);
return 1;
}
/* Hit at this line. If we haven't shown the
* pre-context lines, we would need to show them.
*/
if (opt->pre_context || opt->funcbody)
show_pre_context(opt, gs, bol, eol, lno);
else if (opt->funcname)
show_funcname_line(opt, gs, bol, lno);
show_line(opt, bol, eol, gs->name, lno, ':');
last_hit = lno;
if (opt->funcbody)
show_function = 1;
goto next_line;
}
if (show_function && match_funcname(opt, gs, bol, eol))
show_function = 0;
if (show_function ||
(last_hit && lno <= last_hit + opt->post_context)) {
/* If the last hit is within the post context,
* we need to show this line.
*/
show_line(opt, bol, eol, gs->name, lno, '-');
}
next_line:
bol = eol + 1;
if (!left)
break;
left--;
lno++;
}
if (collect_hits)
return 0;
if (opt->status_only)
return 0;
if (opt->unmatch_name_only) {
/* We did not see any hit, so we want to show this */
show_name(opt, gs->name);
return 1;
}
xdiff_clear_find_func(&xecfg);
opt->priv = NULL;
/* NEEDSWORK:
* The real "grep -c foo *.c" gives many "bar.c:0" lines,
* which feels mostly useless but sometimes useful. Maybe
* make it another option? For now suppress them.
*/
if (opt->count && count) {
char buf[32];
if (opt->pathname) {
output_color(opt, gs->name, strlen(gs->name),
opt->color_filename);
output_sep(opt, ':');
}
snprintf(buf, sizeof(buf), "%u\n", count);
opt->output(opt, buf, strlen(buf));
return 1;
}
return !!last_hit;
}
static int grep_buffer_1(struct grep_opt *opt, const char *name,
char *buf, unsigned long size, int collect_hits)
{
char *bol = buf;
unsigned long left = size;
unsigned lno = 1;
unsigned last_hit = 0;
int binary_match_only = 0;
unsigned count = 0;
enum grep_context ctx = GREP_CONTEXT_HEAD;
xdemitconf_t xecfg;
opt->last_shown = 0;
if (buffer_is_binary(buf, size)) {
switch (opt->binary) {
case GREP_BINARY_DEFAULT:
binary_match_only = 1;
break;
case GREP_BINARY_NOMATCH:
return 0; /* Assume unmatch */
break;
default:
break;
}
}
memset(&xecfg, 0, sizeof(xecfg));
if (opt->funcname && !opt->unmatch_name_only && !opt->status_only &&
!opt->name_only && !binary_match_only && !collect_hits) {
struct userdiff_driver *drv = userdiff_find_by_path(name);
if (drv && drv->funcname.pattern) {
const struct userdiff_funcname *pe = &drv->funcname;
xdiff_set_find_func(&xecfg, pe->pattern, pe->cflags);
opt->priv = &xecfg;
}
}
while (left) {
char *eol, ch;
int hit;
eol = end_of_line(bol, &left);
ch = *eol;
*eol = 0;
if ((ctx == GREP_CONTEXT_HEAD) && (eol == bol))
ctx = GREP_CONTEXT_BODY;
hit = match_line(opt, bol, eol, ctx, collect_hits);
*eol = ch;
if (collect_hits)
goto next_line;
/* "grep -v -e foo -e bla" should list lines
* that do not have either, so inversion should
* be done outside.
*/
if (opt->invert)
hit = !hit;
if (opt->unmatch_name_only) {
if (hit)
return 0;
goto next_line;
}
if (hit) {
count++;
if (opt->status_only)
return 1;
if (binary_match_only) {
printf("Binary file %s matches\n", name);
return 1;
}
if (opt->name_only) {
show_name(opt, name);
return 1;
}
/* Hit at this line. If we haven't shown the
* pre-context lines, we would need to show them.
* When asked to do "count", this still show
* the context which is nonsense, but the user
* deserves to get that ;-).
*/
if (opt->pre_context)
show_pre_context(opt, name, buf, bol, lno);
else if (opt->funcname)
show_funcname_line(opt, name, buf, bol, lno);
if (!opt->count)
show_line(opt, bol, eol, name, lno, ':');
last_hit = lno;
}
else if (last_hit &&
lno <= last_hit + opt->post_context) {
/* If the last hit is within the post context,
* we need to show this line.
*/
show_line(opt, bol, eol, name, lno, '-');
}
next_line:
bol = eol + 1;
if (!left)
break;
left--;
lno++;
}
if (collect_hits)
return 0;
if (opt->status_only)
return 0;
if (opt->unmatch_name_only) {
/* We did not see any hit, so we want to show this */
show_name(opt, name);
return 1;
}
xdiff_clear_find_func(&xecfg);
opt->priv = NULL;
/* NEEDSWORK:
* The real "grep -c foo *.c" gives many "bar.c:0" lines,
* which feels mostly useless but sometimes useful. Maybe
* make it another option? For now suppress them.
*/
if (opt->count && count)
printf("%s%c%u\n", name,
opt->null_following_name ? '\0' : ':', count);
return !!last_hit;
}
int glp_read_prob(glp_prob *P, int flags, const char *fname)
{ DMX _csa, *csa = &_csa;
int mip, m, n, nnz, ne, i, j, k, type, kind, ret, *ln = NULL,
*ia = NULL, *ja = NULL;
double lb, ub, temp, *ar = NULL;
char *rf = NULL, *cf = NULL;
if (P == NULL || P->magic != GLP_PROB_MAGIC)
xerror("glp_read_prob: P = %p; invalid problem object\n",
P);
if (flags != 0)
xerror("glp_read_prob: flags = %d; invalid parameter\n",
flags);
if (fname == NULL)
xerror("glp_read_prob: fname = %d; invalid parameter\n",
fname);
glp_erase_prob(P);
if (setjmp(csa->jump))
{ ret = 1;
goto done;
}
csa->fname = fname;
csa->fp = NULL;
csa->count = 0;
csa->c = '\n';
csa->field[0] = '\0';
csa->empty = csa->nonint = 0;
xprintf("Reading problem data from '%s'...\n", fname);
csa->fp = glp_open(fname, "r");
if (csa->fp == NULL)
{ xprintf("Unable to open '%s' - %s\n", fname, get_err_msg());
longjmp(csa->jump, 1);
}
/* read problem line */
read_designator(csa);
if (strcmp(csa->field, "p") != 0)
error(csa, "problem line missing or invalid");
read_field(csa);
if (strcmp(csa->field, "lp") == 0)
mip = 0;
else if (strcmp(csa->field, "mip") == 0)
mip = 1;
else
error(csa, "wrong problem designator; 'lp' or 'mip' expected");
read_field(csa);
if (strcmp(csa->field, "min") == 0)
glp_set_obj_dir(P, GLP_MIN);
else if (strcmp(csa->field, "max") == 0)
glp_set_obj_dir(P, GLP_MAX);
else
error(csa, "objective sense missing or invalid");
read_field(csa);
if (!(str2int(csa->field, &m) == 0 && m >= 0))
error(csa, "number of rows missing or invalid");
read_field(csa);
if (!(str2int(csa->field, &n) == 0 && n >= 0))
error(csa, "number of columns missing or invalid");
read_field(csa);
if (!(str2int(csa->field, &nnz) == 0 && nnz >= 0))
error(csa, "number of constraint coefficients missing or inval"
"id");
if (m > 0)
{ glp_add_rows(P, m);
for (i = 1; i <= m; i++)
glp_set_row_bnds(P, i, GLP_FX, 0.0, 0.0);
}
if (n > 0)
{ glp_add_cols(P, n);
for (j = 1; j <= n; j++)
{ if (!mip)
glp_set_col_bnds(P, j, GLP_LO, 0.0, 0.0);
else
glp_set_col_kind(P, j, GLP_BV);
}
}
end_of_line(csa);
/* allocate working arrays */
rf = xcalloc(1+m, sizeof(char));
memset(rf, 0, 1+m);
cf = xcalloc(1+n, sizeof(char));
memset(cf, 0, 1+n);
ln = xcalloc(1+nnz, sizeof(int));
ia = xcalloc(1+nnz, sizeof(int));
ja = xcalloc(1+nnz, sizeof(int));
ar = xcalloc(1+nnz, sizeof(double));
/* read descriptor lines */
ne = 0;
for (;;)
{ read_designator(csa);
if (strcmp(csa->field, "i") == 0)
{ /* row descriptor */
read_field(csa);
if (str2int(csa->field, &i) != 0)
error(csa, "row number missing or invalid");
if (!(1 <= i && i <= m))
error(csa, "row number out of range");
read_field(csa);
if (strcmp(csa->field, "f") == 0)
type = GLP_FR;
else if (strcmp(csa->field, "l") == 0)
type = GLP_LO;
else if (strcmp(csa->field, "u") == 0)
type = GLP_UP;
else if (strcmp(csa->field, "d") == 0)
type = GLP_DB;
else if (strcmp(csa->field, "s") == 0)
type = GLP_FX;
else
error(csa, "row type missing or invalid");
if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
{ read_field(csa);
if (str2num(csa->field, &lb) != 0)
error(csa, "row lower bound/fixed value missing or in"
"valid");
}
else
lb = 0.0;
if (type == GLP_UP || type == GLP_DB)
{ read_field(csa);
if (str2num(csa->field, &ub) != 0)
error(csa, "row upper bound missing or invalid");
}
else
ub = 0.0;
if (rf[i] & 0x01)
error(csa, "duplicate row descriptor");
glp_set_row_bnds(P, i, type, lb, ub), rf[i] |= 0x01;
}
else if (strcmp(csa->field, "j") == 0)
{ /* column descriptor */
read_field(csa);
if (str2int(csa->field, &j) != 0)
error(csa, "column number missing or invalid");
if (!(1 <= j && j <= n))
error(csa, "column number out of range");
if (!mip)
kind = GLP_CV;
else
{ read_field(csa);
if (strcmp(csa->field, "c") == 0)
kind = GLP_CV;
else if (strcmp(csa->field, "i") == 0)
kind = GLP_IV;
else if (strcmp(csa->field, "b") == 0)
{ kind = GLP_IV;
type = GLP_DB, lb = 0.0, ub = 1.0;
goto skip;
}
else
error(csa, "column kind missing or invalid");
}
read_field(csa);
if (strcmp(csa->field, "f") == 0)
type = GLP_FR;
else if (strcmp(csa->field, "l") == 0)
type = GLP_LO;
else if (strcmp(csa->field, "u") == 0)
type = GLP_UP;
else if (strcmp(csa->field, "d") == 0)
type = GLP_DB;
else if (strcmp(csa->field, "s") == 0)
type = GLP_FX;
else
error(csa, "column type missing or invalid");
if (type == GLP_LO || type == GLP_DB || type == GLP_FX)
{ read_field(csa);
if (str2num(csa->field, &lb) != 0)
error(csa, "column lower bound/fixed value missing or"
" invalid");
}
else
lb = 0.0;
if (type == GLP_UP || type == GLP_DB)
{ read_field(csa);
if (str2num(csa->field, &ub) != 0)
error(csa, "column upper bound missing or invalid");
}
else
ub = 0.0;
skip: if (cf[j] & 0x01)
error(csa, "duplicate column descriptor");
glp_set_col_kind(P, j, kind);
glp_set_col_bnds(P, j, type, lb, ub), cf[j] |= 0x01;
}
else if (strcmp(csa->field, "a") == 0)
{ /* coefficient descriptor */
read_field(csa);
if (str2int(csa->field, &i) != 0)
error(csa, "row number missing or invalid");
if (!(0 <= i && i <= m))
error(csa, "row number out of range");
read_field(csa);
if (str2int(csa->field, &j) != 0)
error(csa, "column number missing or invalid");
if (!((i == 0 ? 0 : 1) <= j && j <= n))
error(csa, "column number out of range");
read_field(csa);
if (i == 0)
{ if (str2num(csa->field, &temp) != 0)
error(csa, "objective %s missing or invalid",
j == 0 ? "constant term" : "coefficient");
if (cf[j] & 0x10)
error(csa, "duplicate objective %s",
j == 0 ? "constant term" : "coefficient");
glp_set_obj_coef(P, j, temp), cf[j] |= 0x10;
}
else
{ if (str2num(csa->field, &temp) != 0)
error(csa, "constraint coefficient missing or invalid"
);
if (ne == nnz)
error(csa, "too many constraint coefficient descripto"
"rs");
ln[++ne] = csa->count;
ia[ne] = i, ja[ne] = j, ar[ne] = temp;
}
}
else if (strcmp(csa->field, "n") == 0)
{ /* symbolic name descriptor */
read_field(csa);
if (strcmp(csa->field, "p") == 0)
{ /* problem name */
read_field(csa);
if (P->name != NULL)
error(csa, "duplicate problem name");
glp_set_prob_name(P, csa->field);
}
else if (strcmp(csa->field, "z") == 0)
{ /* objective name */
read_field(csa);
if (P->obj != NULL)
error(csa, "duplicate objective name");
glp_set_obj_name(P, csa->field);
}
else if (strcmp(csa->field, "i") == 0)
{ /* row name */
read_field(csa);
if (str2int(csa->field, &i) != 0)
error(csa, "row number missing or invalid");
if (!(1 <= i && i <= m))
error(csa, "row number out of range");
read_field(csa);
if (P->row[i]->name != NULL)
error(csa, "duplicate row name");
glp_set_row_name(P, i, csa->field);
}
else if (strcmp(csa->field, "j") == 0)
{ /* column name */
read_field(csa);
if (str2int(csa->field, &j) != 0)
error(csa, "column number missing or invalid");
if (!(1 <= j && j <= n))
error(csa, "column number out of range");
read_field(csa);
if (P->col[j]->name != NULL)
error(csa, "duplicate column name");
glp_set_col_name(P, j, csa->field);
}
else
error(csa, "object designator missing or invalid");
}
else if (strcmp(csa->field, "e") == 0)
break;
else
error(csa, "line designator missing or invalid");
end_of_line(csa);
}
if (ne < nnz)
error(csa, "too few constraint coefficient descriptors");
xassert(ne == nnz);
k = glp_check_dup(m, n, ne, ia, ja);
xassert(0 <= k && k <= nnz);
if (k > 0)
{ csa->count = ln[k];
error(csa, "duplicate constraint coefficient");
}
glp_load_matrix(P, ne, ia, ja, ar);
/* print some statistics */
if (P->name != NULL)
xprintf("Problem: %s\n", P->name);
if (P->obj != NULL)
xprintf("Objective: %s\n", P->obj);
xprintf("%d row%s, %d column%s, %d non-zero%s\n",
m, m == 1 ? "" : "s", n, n == 1 ? "" : "s", nnz, nnz == 1 ?
"" : "s");
if (glp_get_num_int(P) > 0)
{ int ni = glp_get_num_int(P);
int nb = glp_get_num_bin(P);
if (ni == 1)
{ if (nb == 0)
xprintf("One variable is integer\n");
else
xprintf("One variable is binary\n");
}
else
{ xprintf("%d integer variables, ", ni);
if (nb == 0)
xprintf("none");
else if (nb == 1)
xprintf("one");
else if (nb == ni)
xprintf("all");
else
xprintf("%d", nb);
xprintf(" of which %s binary\n", nb == 1 ? "is" : "are");
}
}
xprintf("%d lines were read\n", csa->count);
/* problem data has been successfully read */
glp_sort_matrix(P);
ret = 0;
done: if (csa->fp != NULL) glp_close(csa->fp);
if (rf != NULL) xfree(rf);
if (cf != NULL) xfree(cf);
if (ln != NULL) xfree(ln);
if (ia != NULL) xfree(ia);
if (ja != NULL) xfree(ja);
if (ar != NULL) xfree(ar);
if (ret) glp_erase_prob(P);
return ret;
}
static int grep_buffer_1(struct grep_opt *opt, const char *name,
char *buf, unsigned long size, int collect_hits)
{
char *bol = buf;
unsigned long left = size;
unsigned lno = 1;
struct pre_context_line {
char *bol;
char *eol;
} *prev = NULL, *pcl;
unsigned last_hit = 0;
unsigned last_shown = 0;
int binary_match_only = 0;
const char *hunk_mark = "";
unsigned count = 0;
enum grep_context ctx = GREP_CONTEXT_HEAD;
if (buffer_is_binary(buf, size)) {
switch (opt->binary) {
case GREP_BINARY_DEFAULT:
binary_match_only = 1;
break;
case GREP_BINARY_NOMATCH:
return 0; /* Assume unmatch */
break;
default:
break;
}
}
if (opt->pre_context)
prev = xcalloc(opt->pre_context, sizeof(*prev));
if (opt->pre_context || opt->post_context)
hunk_mark = "--\n";
while (left) {
char *eol, ch;
int hit;
eol = end_of_line(bol, &left);
ch = *eol;
*eol = 0;
if ((ctx == GREP_CONTEXT_HEAD) && (eol == bol))
ctx = GREP_CONTEXT_BODY;
hit = match_line(opt, bol, eol, ctx, collect_hits);
*eol = ch;
if (collect_hits)
goto next_line;
/* "grep -v -e foo -e bla" should list lines
* that do not have either, so inversion should
* be done outside.
*/
if (opt->invert)
hit = !hit;
if (opt->unmatch_name_only) {
if (hit)
return 0;
goto next_line;
}
if (hit) {
count++;
if (opt->status_only)
return 1;
if (binary_match_only) {
printf("Binary file %s matches\n", name);
return 1;
}
if (opt->name_only) {
show_name(opt, name);
return 1;
}
/* Hit at this line. If we haven't shown the
* pre-context lines, we would need to show them.
* When asked to do "count", this still show
* the context which is nonsense, but the user
* deserves to get that ;-).
*/
if (opt->pre_context) {
unsigned from;
if (opt->pre_context < lno)
from = lno - opt->pre_context;
else
from = 1;
if (from <= last_shown)
from = last_shown + 1;
if (last_shown && from != last_shown + 1)
printf(hunk_mark);
while (from < lno) {
pcl = &prev[lno-from-1];
show_line(opt, pcl->bol, pcl->eol,
name, from, '-');
from++;
}
last_shown = lno-1;
}
if (last_shown && lno != last_shown + 1)
printf(hunk_mark);
if (!opt->count)
show_line(opt, bol, eol, name, lno, ':');
last_shown = last_hit = lno;
}
else if (last_hit &&
lno <= last_hit + opt->post_context) {
/* If the last hit is within the post context,
* we need to show this line.
*/
if (last_shown && lno != last_shown + 1)
printf(hunk_mark);
show_line(opt, bol, eol, name, lno, '-');
last_shown = lno;
}
if (opt->pre_context) {
memmove(prev+1, prev,
(opt->pre_context-1) * sizeof(*prev));
prev->bol = bol;
prev->eol = eol;
}
next_line:
bol = eol + 1;
if (!left)
break;
left--;
lno++;
}
free(prev);
if (collect_hits)
return 0;
if (opt->status_only)
return 0;
if (opt->unmatch_name_only) {
/* We did not see any hit, so we want to show this */
show_name(opt, name);
return 1;
}
/* NEEDSWORK:
* The real "grep -c foo *.c" gives many "bar.c:0" lines,
* which feels mostly useless but sometimes useful. Maybe
* make it another option? For now suppress them.
*/
if (opt->count && count)
printf("%s%c%u\n", name,
opt->null_following_name ? '\0' : ':', count);
return !!last_hit;
}
status_t
parse_article(const char* file_name, lang_t* lang, article_t* article)
{
string_t word, word_core, word_stem;
sentence_t* sentence;
word_t* word_entry;
stream_t* stream = &article->stream;
bool_t is_new, is_para_end = SMRZR_FALSE;
PROF_START;
if(SMRZR_OK != stream_create(file_name, stream))
ERROR_RET;
while(!STREAM_END(stream)) {
STREAM_FIND_WORD(stream);
if(STREAM_END(stream)) break;
sentence = sentence_new(&article->sentences, article->stream.curr);
assert(NULL != sentence);
if(SMRZR_TRUE == is_para_end) {
sentence->is_para_begin = SMRZR_TRUE;
is_para_end = SMRZR_FALSE;
}
while(!STREAM_END(stream)) {
STREAM_GET_WORD(stream, word, is_para_end);
sentence->num_words++;
if(NULL == (word_core = get_word_core(&article->stack, lang, word)))
ERROR_RET;
if(NULL == array_search(lang->exclude, word_core, comp_strings)) {
if(NULL == (word_stem = get_word_stem(&article->stack, lang,
word_core, SMRZR_TRUE)))
ERROR_RET;
if(NULL == (word_entry = array_search_or_alloc(&article->words,
word_stem, comp_word_by_stem, &is_new)))
ERROR_RET;
if(SMRZR_TRUE == is_new) {
word_entry->num_occ = 1;
word_entry->stem = word_stem;
} else {
++(word_entry->num_occ);
array_pop_free(article->stack, word_stem);
}
} else {
array_pop_free(article->stack, word_core);
}
if(end_of_line(lang, word)) {
sentence->end = word + strlen(word);
article->num_words += sentence->num_words;
break;
}
}
}
PROF_END("article parsing");
/*fprintf(stdout, "Number of sentences - %lu\n", ARR_SZ(article->sentences));
fprintf(stdout, "Number of words - %lu\n", ARR_SZ(article->words));*/
return(SMRZR_OK);
}
int glp_read_maxflow(glp_graph *G, int *_s, int *_t, int a_cap,
const char *fname)
{ struct csa _csa, *csa = &_csa;
glp_arc *a;
int i, j, k, s, t, nv, na, ret = 0;
double cap;
if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
xerror("glp_read_maxflow: a_cap = %d; invalid offset\n",
a_cap);
glp_erase_graph(G, G->v_size, G->a_size);
if (setjmp(csa->jump))
{ ret = 1;
goto done;
}
csa->fname = fname;
csa->fp = NULL;
csa->count = 0;
csa->c = '\n';
csa->field[0] = '\0';
csa->empty = csa->nonint = 0;
xprintf("Reading maximum flow problem data from `%s'...\n",
fname);
csa->fp = xfopen(fname, "r");
if (csa->fp == NULL)
{ xprintf("Unable to open `%s' - %s\n", fname, xerrmsg());
longjmp(csa->jump, 1);
}
/* read problem line */
read_designator(csa);
if (strcmp(csa->field, "p") != 0)
error(csa, "problem line missing or invalid");
read_field(csa);
if (strcmp(csa->field, "max") != 0)
error(csa, "wrong problem designator; `max' expected");
read_field(csa);
if (!(str2int(csa->field, &nv) == 0 && nv >= 2))
error(csa, "number of nodes missing or invalid");
read_field(csa);
if (!(str2int(csa->field, &na) == 0 && na >= 0))
error(csa, "number of arcs missing or invalid");
xprintf("Flow network has %d node%s and %d arc%s\n",
nv, nv == 1 ? "" : "s", na, na == 1 ? "" : "s");
if (nv > 0) glp_add_vertices(G, nv);
end_of_line(csa);
/* read node descriptor lines */
s = t = 0;
for (;;)
{ read_designator(csa);
if (strcmp(csa->field, "n") != 0) break;
read_field(csa);
if (str2int(csa->field, &i) != 0)
error(csa, "node number missing or invalid");
if (!(1 <= i && i <= nv))
error(csa, "node number %d out of range", i);
read_field(csa);
if (strcmp(csa->field, "s") == 0)
{ if (s > 0)
error(csa, "only one source node allowed");
s = i;
}
else if (strcmp(csa->field, "t") == 0)
{ if (t > 0)
error(csa, "only one sink node allowed");
t = i;
}
else
error(csa, "wrong node designator; `s' or `t' expected");
if (s > 0 && s == t)
error(csa, "source and sink nodes must be distinct");
end_of_line(csa);
}
if (s == 0)
error(csa, "source node descriptor missing\n");
if (t == 0)
error(csa, "sink node descriptor missing\n");
if (_s != NULL) *_s = s;
if (_t != NULL) *_t = t;
/* read arc descriptor lines */
for (k = 1; k <= na; k++)
{ if (k > 1) read_designator(csa);
if (strcmp(csa->field, "a") != 0)
error(csa, "wrong line designator; `a' expected");
read_field(csa);
if (str2int(csa->field, &i) != 0)
error(csa, "starting node number missing or invalid");
if (!(1 <= i && i <= nv))
error(csa, "starting node number %d out of range", i);
read_field(csa);
if (str2int(csa->field, &j) != 0)
error(csa, "ending node number missing or invalid");
if (!(1 <= j && j <= nv))
error(csa, "ending node number %d out of range", j);
read_field(csa);
if (!(str2num(csa->field, &cap) == 0 && cap >= 0.0))
error(csa, "arc capacity missing or invalid");
check_int(csa, cap);
a = glp_add_arc(G, i, j);
if (a_cap >= 0)
memcpy((char *)a->data + a_cap, &cap, sizeof(double));
end_of_line(csa);
}
xprintf("%d lines were read\n", csa->count);
done: if (ret) glp_erase_graph(G, G->v_size, G->a_size);
if (csa->fp != NULL) xfclose(csa->fp);
return ret;
}
int glp_read_mincost(glp_graph *G, int v_rhs, int a_low, int a_cap,
int a_cost, const char *fname)
{ struct csa _csa, *csa = &_csa;
glp_vertex *v;
glp_arc *a;
int i, j, k, nv, na, ret = 0;
double rhs, low, cap, cost;
char *flag = NULL;
if (v_rhs >= 0 && v_rhs > G->v_size - (int)sizeof(double))
xerror("glp_read_mincost: v_rhs = %d; invalid offset\n",
v_rhs);
if (a_low >= 0 && a_low > G->a_size - (int)sizeof(double))
xerror("glp_read_mincost: a_low = %d; invalid offset\n",
a_low);
if (a_cap >= 0 && a_cap > G->a_size - (int)sizeof(double))
xerror("glp_read_mincost: a_cap = %d; invalid offset\n",
a_cap);
if (a_cost >= 0 && a_cost > G->a_size - (int)sizeof(double))
xerror("glp_read_mincost: a_cost = %d; invalid offset\n",
a_cost);
glp_erase_graph(G, G->v_size, G->a_size);
if (setjmp(csa->jump))
{ ret = 1;
goto done;
}
csa->fname = fname;
csa->fp = NULL;
csa->count = 0;
csa->c = '\n';
csa->field[0] = '\0';
csa->empty = csa->nonint = 0;
xprintf("Reading min-cost flow problem data from `%s'...\n",
fname);
csa->fp = xfopen(fname, "r");
if (csa->fp == NULL)
{ xprintf("Unable to open `%s' - %s\n", fname, xerrmsg());
longjmp(csa->jump, 1);
}
/* read problem line */
read_designator(csa);
if (strcmp(csa->field, "p") != 0)
error(csa, "problem line missing or invalid");
read_field(csa);
if (strcmp(csa->field, "min") != 0)
error(csa, "wrong problem designator; `min' expected");
read_field(csa);
if (!(str2int(csa->field, &nv) == 0 && nv >= 0))
error(csa, "number of nodes missing or invalid");
read_field(csa);
if (!(str2int(csa->field, &na) == 0 && na >= 0))
error(csa, "number of arcs missing or invalid");
xprintf("Flow network has %d node%s and %d arc%s\n",
nv, nv == 1 ? "" : "s", na, na == 1 ? "" : "s");
if (nv > 0) glp_add_vertices(G, nv);
end_of_line(csa);
/* read node descriptor lines */
flag = xcalloc(1+nv, sizeof(char));
memset(&flag[1], 0, nv * sizeof(char));
if (v_rhs >= 0)
{ rhs = 0.0;
for (i = 1; i <= nv; i++)
{ v = G->v[i];
memcpy((char *)v->data + v_rhs, &rhs, sizeof(double));
}
}
for (;;)
{ read_designator(csa);
if (strcmp(csa->field, "n") != 0) break;
read_field(csa);
if (str2int(csa->field, &i) != 0)
error(csa, "node number missing or invalid");
if (!(1 <= i && i <= nv))
error(csa, "node number %d out of range", i);
if (flag[i])
error(csa, "duplicate descriptor of node %d", i);
read_field(csa);
if (str2num(csa->field, &rhs) != 0)
error(csa, "node supply/demand missing or invalid");
check_int(csa, rhs);
if (v_rhs >= 0)
{ v = G->v[i];
memcpy((char *)v->data + v_rhs, &rhs, sizeof(double));
}
flag[i] = 1;
end_of_line(csa);
}
xfree(flag), flag = NULL;
/* read arc descriptor lines */
for (k = 1; k <= na; k++)
{ if (k > 1) read_designator(csa);
if (strcmp(csa->field, "a") != 0)
error(csa, "wrong line designator; `a' expected");
read_field(csa);
if (str2int(csa->field, &i) != 0)
error(csa, "starting node number missing or invalid");
if (!(1 <= i && i <= nv))
error(csa, "starting node number %d out of range", i);
read_field(csa);
if (str2int(csa->field, &j) != 0)
error(csa, "ending node number missing or invalid");
if (!(1 <= j && j <= nv))
error(csa, "ending node number %d out of range", j);
read_field(csa);
if (!(str2num(csa->field, &low) == 0 && low >= 0.0))
error(csa, "lower bound of arc flow missing or invalid");
check_int(csa, low);
read_field(csa);
if (!(str2num(csa->field, &cap) == 0 && cap >= low))
error(csa, "upper bound of arc flow missing or invalid");
check_int(csa, cap);
read_field(csa);
if (str2num(csa->field, &cost) != 0)
error(csa, "per-unit cost of arc flow missing or invalid");
check_int(csa, cost);
a = glp_add_arc(G, i, j);
if (a_low >= 0)
memcpy((char *)a->data + a_low, &low, sizeof(double));
if (a_cap >= 0)
memcpy((char *)a->data + a_cap, &cap, sizeof(double));
if (a_cost >= 0)
memcpy((char *)a->data + a_cost, &cost, sizeof(double));
end_of_line(csa);
}
xprintf("%d lines were read\n", csa->count);
done: if (ret) glp_erase_graph(G, G->v_size, G->a_size);
if (csa->fp != NULL) xfclose(csa->fp);
if (flag != NULL) xfree(flag);
return ret;
}
int self_insert( EmacsChar_t c )
{
int p;
int repeat_count = arg;
arg = 1;
if( input_mode == 1 ) gui_input_mode_before_insert();
if( bf_cur->b_mode.md_abbrevon && ! bf_cur->char_is( c, SYNTAX_WORD )
&& (p = dot - 1) >= bf_cur->first_character()
&& bf_cur->char_at_is( p, SYNTAX_WORD ) )
if( abbrev_expand () != 0 )
return 0;
do
{
if( c > ' '
&& ((p = dot) > bf_cur->num_characters() || bf_cur->char_at (p) == '\n') )
if( p > bf_cur->first_character() && cur_col() > bf_cur->b_mode.md_rightmargin )
{
EmacsChar_t bfc;
if( bf_cur->b_mode.md_auto_fill_proc != 0 )
{
bf_cur->b_mode.md_auto_fill_proc->execute();
if( ml_value.exp_type() == ISINTEGER
&& ml_value.asInt() == 0 )
return 0;
}
else
{
while( (p = dot - 1) >= bf_cur->first_character())
{
bfc = bf_cur->char_at( p );
if( bfc == '\n' )
{
p = 0;
break;
}
if( !control_character( bfc ) )
{
dot_col--;
dot--;
}
else
dot_left (1);
if( (bfc == ' ' || bfc == '\t')
&& cur_col() <= bf_cur->b_mode.md_rightmargin )
break;
}
if( p >= bf_cur->first_character() )
{
delete_white_space ();
arg = 1;
bf_cur->insert_at( dot, '\n' );
dot_right (1);
to_col (bf_cur->b_mode.md_leftmargin);
if( bf_cur->b_mode.md_prefixstring.isNull() )
bf_cur->ins_cstr( bf_cur->b_mode.md_prefixstring );
}
end_of_line ();
}
}
if( bf_cur->b_mode.md_replace
&& bf_cur->char_at( dot ) != '\n'
&& c != '\n' )
{
bf_cur->del_frwd( dot, 1 );
bf_cur->insert_at( dot, c );
if( bf_cur->b_modified == 0 )
{
redo_modes = 1;
cant_1line_opt = 1;
}
bf_cur->b_modified++;
}
else
bf_cur->insert_at( dot, c );
dot_right (1);
}
while( (repeat_count = repeat_count - 1) > 0 );
return 0;
}
CSVLine::CSVLine(const char *line):
data(line), end(end_of_line(line)) {}