bool Get_list::execute () {
vector<string> server_image_list;
Parameter *parameter = new Parameter;
parameter->type = String;
parameter->data.String = "";
if (!make_file_list (path, &server_image_list)) return false;
if ((int) server_image_list.size() > 0) {
parameter->data.String = server_image_list[0];
for (int i = 1; i < (int) server_image_list.size(); i++) parameter->data.String += "\n" + server_image_list[i];
}
if (!responce.set_parameter(0, parameter)) return false;
delete parameter;
return true;
}
/*
* Do completion on a list of objects, listing instead of completing.
*/
static int
complt_list(int flags, char *buf, int cpos)
{
struct list *lh, *lh2, *lh3;
struct list *wholelist = NULL;
struct buffer *bp;
int i, maxwidth, width;
int preflen = 0;
int oldrow = ttrow;
int oldcol = ttcol;
int oldhue = tthue;
char *linebuf;
size_t linesize, len;
char *cp;
lh = NULL;
ttflush();
/* The results are put into a completion buffer. */
bp = bfind("*Completions*", TRUE);
if (bclear(bp) == FALSE)
return (FALSE);
/*
* First get the list of objects. This list may contain only
* the ones that complete what has been typed, or may be the
* whole list of all objects of this type. They are filtered
* later in any case. Set wholelist if the list has been
* cons'ed up just for us, so we can free it later. We have
* to copy the buffer list for this function even though we
* didn't for complt. The sorting code does destructive
* changes to the list, which we don't want to happen to the
* main buffer list!
*/
if ((flags & EFBUF) != 0)
wholelist = lh = copy_list(&(bheadp->b_list));
else if ((flags & EFFUNC) != 0) {
buf[cpos] = '\0';
wholelist = lh = complete_function_list(buf);
} else if ((flags & EFFILE) != 0) {
buf[cpos] = '\0';
wholelist = lh = make_file_list(buf);
/*
* We don't want to display stuff up to the / for file
* names preflen is the list of a prefix of what the
* user typed that should not be displayed.
*/
cp = strrchr(buf, '/');
if (cp)
preflen = cp - buf + 1;
} else
panic("broken complt call: flags");
/*
* Sort the list, since users expect to see it in alphabetic
* order.
*/
lh2 = lh;
while (lh2 != NULL) {
lh3 = lh2->l_next;
while (lh3 != NULL) {
if (strcmp(lh2->l_name, lh3->l_name) > 0) {
cp = lh2->l_name;
lh2->l_name = lh3->l_name;
lh3->l_name = cp;
}
lh3 = lh3->l_next;
}
lh2 = lh2->l_next;
}
/*
* First find max width of object to be displayed, so we can
* put several on a line.
*/
maxwidth = 0;
lh2 = lh;
while (lh2 != NULL) {
for (i = 0; i < cpos; ++i) {
if (buf[i] != lh2->l_name[i])
break;
}
if (i == cpos) {
width = strlen(lh2->l_name);
if (width > maxwidth)
maxwidth = width;
}
lh2 = lh2->l_next;
}
maxwidth += 1 - preflen;
/*
* Now do the display. Objects are written into linebuf until
* it fills, and then put into the help buffer.
*/
linesize = MAX(ncol, maxwidth) + 1;
if ((linebuf = malloc(linesize)) == NULL) {
free_file_list(wholelist);
return (FALSE);
}
width = 0;
/*
* We're going to strlcat() into the buffer, so it has to be
* NUL terminated.
*/
linebuf[0] = '\0';
for (lh2 = lh; lh2 != NULL; lh2 = lh2->l_next) {
for (i = 0; i < cpos; ++i) {
if (buf[i] != lh2->l_name[i])
break;
}
/* if we have a match */
if (i == cpos) {
/* if it wraps */
if ((width + maxwidth) > ncol) {
addline(bp, linebuf);
linebuf[0] = '\0';
width = 0;
}
len = strlcat(linebuf, lh2->l_name + preflen,
linesize);
width += maxwidth;
if (len < width && width < linesize) {
/* pad so the objects nicely line up */
memset(linebuf + len, ' ',
maxwidth - strlen(lh2->l_name + preflen));
linebuf[width] = '\0';
}
}
}
if (width > 0)
addline(bp, linebuf);
free(linebuf);
/*
* Note that we free lists only if they are put in wholelist lists
* that were built just for us should be freed. However when we use
* the buffer list, obviously we don't want it freed.
*/
free_file_list(wholelist);
popbuftop(bp, WEPHEM); /* split the screen and put up the help
* buffer */
update(CMODE); /* needed to make the new stuff actually
* appear */
ttmove(oldrow, oldcol); /* update leaves cursor in arbitrary place */
ttcolor(oldhue); /* with arbitrary color */
ttflush();
return (0);
}
/*
* Do completion on a list of objects.
* c is SPACE, TAB, or CR
* return TRUE if matched (or partially matched)
* FALSE is result is ambiguous,
* ABORT on error.
*/
static int
complt(int flags, int c, char *buf, size_t nbuf, int cpos, int *nx)
{
struct list *lh, *lh2;
struct list *wholelist = NULL;
int i, nxtra, nhits, bxtra, msglen, nshown;
int wflag = FALSE;
char *msg;
lh = lh2 = NULL;
if ((flags & EFFUNC) != 0) {
buf[cpos] = '\0';
wholelist = lh = complete_function_list(buf);
} else if ((flags & EFBUF) != 0) {
lh = &(bheadp->b_list);
} else if ((flags & EFFILE) != 0) {
buf[cpos] = '\0';
wholelist = lh = make_file_list(buf);
} else
panic("broken complt call: flags");
if (c == ' ')
wflag = TRUE;
else if (c != '\t' && c != CCHR('M'))
panic("broken complt call: c");
nhits = 0;
nxtra = HUGE;
for (; lh != NULL; lh = lh->l_next) {
if (memcmp(buf, lh->l_name, cpos) != 0)
continue;
if (nhits == 0)
lh2 = lh;
++nhits;
if (lh->l_name[cpos] == '\0')
nxtra = -1; /* exact match */
else {
bxtra = getxtra(lh, lh2, cpos, wflag);
if (bxtra < nxtra)
nxtra = bxtra;
lh2 = lh;
}
}
if (nhits == 0)
msg = " [No match]";
else if (nhits > 1 && nxtra == 0)
msg = " [Ambiguous. Ctrl-G to cancel]";
else {
/*
* Being lazy - ought to check length, but all things
* autocompleted have known types/lengths.
*/
if (nxtra < 0 && nhits > 1 && c == ' ')
nxtra = 1; /* ??? */
for (i = 0; i < nxtra && cpos < nbuf; ++i) {
buf[cpos] = lh2->l_name[cpos];
eputc(buf[cpos++]);
}
/* XXX should grow nbuf */
ttflush();
free_file_list(wholelist);
*nx = nxtra;
if (nxtra < 0 && c != CCHR('M')) /* exact */
*nx = 0;
return (TRUE);
}
/*
* wholelist is NULL if we are doing buffers. Want to free lists
* that were created for us, but not the buffer list!
*/
free_file_list(wholelist);
/* Set up backspaces, etc., being mindful of echo line limit. */
msglen = strlen(msg);
nshown = (ttcol + msglen + 2 > ncol) ?
ncol - ttcol - 2 : msglen;
eputs(msg);
ttcol -= (i = nshown); /* update ttcol! */
while (i--) /* move back before msg */
ttputc('\b');
ttflush(); /* display to user */
i = nshown;
while (i--) /* blank out on next flush */
eputc(' ');
ttcol -= (i = nshown); /* update ttcol on BS's */
while (i--)
ttputc('\b'); /* update ttcol again! */
*nx = nxtra;
return ((nhits > 0) ? TRUE : FALSE);
}
int main (int argc, char *argv[])
{
char *nistfile = NULL;
char *tolstr = NULL;
int i, err = 0;
/* parse option flags */
while (1) {
int c = getopt(argc, argv, "avf:t:");
if (c == -1) break;
switch (c) {
case 'a':
use_derivs = 1;
break;
case 'v':
verbose = 1;
break;
case 'f':
nistfile = optarg;
break;
case 't':
tolstr = optarg;
break;
case ':': case '?':
exit(EXIT_FAILURE);
break;
default:
break;
}
}
print_options(argv[0], nistfile, tolstr);
if (tolstr != NULL) {
toler = atof(tolstr);
if (toler <= 0.0) {
fprintf(stderr, "Invalid tolerance '%s'\n", tolstr);
err = 1;
}
}
if (nistfile != NULL) {
nfiles = 1;
} else {
err = make_file_list();
}
if (err) {
exit(EXIT_FAILURE);
}
libgretl_init();
for (i=0; i<nfiles; i++) {
char *thisfile;
if (nistfile) {
thisfile = nistfile;
} else {
thisfile = file_list[i];
}
printf("\nReading %s...\n", thisfile);
err = read_nist_nls_data(thisfile);
if (!err) {
err = run_gretl_nls_check();
}
free_Z(Z, datainfo);
free_datainfo(datainfo);
Z = NULL;
datainfo = NULL;
}
if (nfiles > 1) {
print_nls_summary();
free_file_list();
}
libgretl_cleanup();
return err;
}