static void list_top(char *fn)
{
int status,done;
#define BUFLEN 256
char buf[BUFLEN];
gmx_cpp_t handle;
char *cppopts[] = { NULL };
status = cpp_open_file(fn,&handle,cppopts);
if (status != 0)
gmx_fatal(FARGS,cpp_error(&handle,status));
do {
status = cpp_read_line(&handle,BUFLEN,buf);
done = (status == eCPP_EOF);
if (!done) {
if (status != eCPP_OK)
gmx_fatal(FARGS,cpp_error(&handle,status));
else
printf("%s\n",buf);
}
} while (!done);
status = cpp_close_file(&handle);
if (status != eCPP_OK)
gmx_fatal(FARGS,cpp_error(&handle,status));
}
/* Return one whole line from the file into buf which holds at most n
characters, for subsequent processing. Returns integer status. This
routine also does all the "intelligent" work like processing cpp
directives and so on. Note that often the routine is called
recursively and no cpp directives are printed. */
int cpp_read_line(gmx_cpp_t *handlep, int n, char buf[])
{
gmx_cpp_t handle = (gmx_cpp_t)*handlep;
int i, nn, len, status;
const char *ptr, *ptr2;
char *name;
char *dname, *dval;
gmx_bool bEOF;
if (!handle)
{
return eCPP_INVALID_HANDLE;
}
if (!handle->fp)
{
return eCPP_FILE_NOT_OPEN;
}
bEOF = feof(handle->fp);
if (!bEOF)
{
/* Read the actual line now. */
if (fgets2(buf, n-1, handle->fp) == NULL)
{
/* Recheck EOF, since we could have been at the end before
* the fgets2 call, but we need to read past the end to know.
*/
bEOF = feof(handle->fp);
if (!bEOF)
{
/* Something strange happened, fgets returned NULL,
* but we are not at EOF.
*/
return eCPP_UNKNOWN;
}
}
}
if (bEOF)
{
if (handle->parent == NULL)
{
return eCPP_EOF;
}
cpp_close_file(handlep);
*handlep = handle->parent;
handle->child = NULL;
return cpp_read_line(handlep, n, buf);
}
else
{
if (n > handle->line_len)
{
handle->line_len = n;
srenew(handle->line, n);
}
strcpy(handle->line, buf);
handle->line_nr++;
}
/* Now we've read a line! */
if (debug)
{
fprintf(debug, "%s : %4d : %s\n", handle->fn, handle->line_nr, buf);
}
/* Process directives if this line contains one */
if (find_directive(buf, &dname, &dval))
{
status = process_directive(handlep, dname, dval);
if (status != eCPP_OK)
{
return status;
}
/* Don't print lines with directives, go on to the next */
return cpp_read_line(handlep, n, buf);
}
/* Check whether we're not ifdeffed out. The order of this statement
is important. It has to come after #ifdef, #else and #endif, but
anything else should be ignored. */
if (is_ifdeffed_out(handle))
{
return cpp_read_line(handlep, n, buf);
}
/* Check whether we have any defines that need to be replaced. Note
that we have to use a best fit algorithm, rather than first come
first go. We do this by sorting the defines on length first, and
then on alphabetical order. */
for (i = 0; (i < ndef); i++)
{
if (defs[i].def)
{
nn = 0;
ptr = buf;
while ((ptr = strstrw(ptr, defs[i].name)) != NULL)
{
nn++;
ptr += strlen(defs[i].name);
}
if (nn > 0)
{
len = strlen(buf) + nn*max(4, 4+strlen(defs[i].def)-strlen(defs[i].name));
snew(name, len);
ptr = buf;
while ((ptr2 = strstrw(ptr, defs[i].name)) != NULL)
{
strncat(name, ptr, (int)(ptr2-ptr));
strcat(name, defs[i].def);
ptr = ptr2 + strlen(defs[i].name);
}
strcat(name, ptr);
strcpy(buf, name);
sfree(name);
}
}
}
return eCPP_OK;
}
