Google Git
Sign in
apache / nuttx / 6b3aa3b6b92591925c402d9714d7eb406168d6d9 / . / tools / kconfig2html.c
blob: 422f292c1c1a0ced63c45d5ac428bd19bdcdba57 [file] [log] [blame]
/****************************************************************************
* tools/kconfig2html.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#define _GNU_SOURCE 1
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <ctype.h>
#include <libgen.h>
#include <errno.h>
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#undef USE_JQUERY
#define LINE_SIZE 1024
#define SCRATCH_SIZE 2048
#define MAX_DEPENDENCIES 128
#define MAX_LEVELS 100
#define MAX_SELECT 64
#define MAX_DEFAULTS 196
#define TAB_SIZE 4
#define VAR_SIZE 80
#define HTML_VAR_SIZE (2*VAR_SIZE + 64)
#define BODYFILE_NAME ".k2h-body.dat"
#define APNDXFILE_NAME ".k2h-apndx.dat"
/****************************************************************************
* Private Types
****************************************************************************/
enum token_type_e
{
TOKEN_NONE = 0,
TOKEN_NOTRESERVED,
TOKEN_COMMENT,
TOKEN_CONFIG,
TOKEN_MENUCONFIG,
TOKEN_BOOL,
TOKEN_TRISTATE,
TOKEN_INT,
TOKEN_HEX,
TOKEN_STRING,
TOKEN_DEFAULT,
TOKEN_RANGE,
TOKEN_SELECT,
TOKEN_DEPENDS,
TOKEN_ON,
TOKEN_OPTION,
TOKEN_HELP,
TOKEN_MAINMENU,
TOKEN_MENU,
TOKEN_ENDMENU,
TOKEN_CHOICE,
TOKEN_ENDCHOICE,
TOKEN_PROMPT,
TOKEN_IF,
TOKEN_ENDIF,
TOKEN_SOURCE
};
enum config_type_e
{
VALUE_NONE = 0,
VALUE_INT,
VALUE_HEX,
VALUE_BOOL,
VALUE_TRISTATE,
VALUE_STRING
};
enum error_e
{
ERROR_UNRECOGNIZED_OPTION = 1,
ERROR_MISSING_OPTION_ARGUMENT,
ERROR_UNEXPECTED_OPTION,
ERROR_TOO_MANY_ARGUMENTS,
ERROR_OUTFILE_OPEN_FAILURE,
ERROR_BODYFILE_OPEN_FAILURE,
ERROR_APNDXFILE_OPEN_FAILURE,
ERROR_KCONFIG_OPEN_FAILURE,
ERROR_APPENDFILE_OPEN_FAILURE,
ERROR_MENU_LEVEL_UNDERRUN,
ERROR_TOO_MANY_DEFAULTS,
ERROR_MISSING_DEFAULT_VALUE,
ERROR_GARBAGE_AFTER_DEFAULT,
ERROR_DEFAULT_UNDERFLOW,
ERROR_TOO_MANY_SELECT,
ERROR_TOO_MANY_DEPENDENCIES,
ERROR_DEPENDENCIES_UNDERFLOW,
ERRROR_MISSING_ON_AFTER_DEPENDS,
ERRROR_ON_AFTER_DEPENDS,
ERROR_NESTING_TOO_DEEP,
ERROR_NESTING_UNDERFLOW
};
typedef void (*output_t)(const char *fmt, ...);
struct reserved_s
{
enum token_type_e ttype;
const char *tname;
};
struct default_item_s
{
char *d_default;
char *d_dependency;
};
struct default_s
{
int d_nitems;
struct default_item_s d_item[MAX_DEFAULTS];
};
struct select_s
{
int s_nvar;
char *s_varname[MAX_SELECT];
};
struct config_s
{
enum config_type_e c_type;
char *c_name;
char *c_desc;
char *c_lower;
char *c_upper;
struct default_s c_default;
struct select_s c_select;
int c_ndependencies;
};
struct choice_s
{
char *c_prompt;
struct default_s c_default;
int c_ndependencies;
};
struct menu_s
{
char *m_name;
int m_ndependencies;
};
/****************************************************************************
* Private Data
****************************************************************************/
static char g_line[LINE_SIZE + 1];
static char g_scratch[SCRATCH_SIZE + 1];
static FILE *g_outfile;
static FILE *g_bodyfile;
static FILE *g_apndxfile;
static char *g_lnptr;
static bool g_debug;
static bool g_preread;
static const char *g_kconfigroot;
static const char *g_appsdir;
static int g_paranum[MAX_LEVELS];
static int g_level;
static char *g_dependencies[MAX_DEPENDENCIES];
static int g_ndependencies;
static int g_inchoice;
static int g_menu_number;
static int g_choice_number;
static int g_toggle_number;
static const char g_delimiters[] =
" ,";
static struct reserved_s g_reserved[] =
{
{TOKEN_COMMENT, "comment"},
{TOKEN_CONFIG, "config"},
{TOKEN_MENUCONFIG, "menuconfig"},
{TOKEN_BOOL, "bool"},
{TOKEN_TRISTATE, "tristate"},
{TOKEN_INT, "int"},
{TOKEN_HEX, "hex"},
{TOKEN_STRING, "string"},
{TOKEN_DEFAULT, "default"},
{TOKEN_RANGE, "range"},
{TOKEN_SELECT, "select"},
{TOKEN_DEPENDS, "depends"},
{TOKEN_ON, "on"},
{TOKEN_OPTION, "option"},
{TOKEN_HELP, "help"},
{TOKEN_HELP, "---help---"},
{TOKEN_MAINMENU, "mainmenu"},
{TOKEN_MENU, "menu"},
{TOKEN_ENDMENU, "endmenu"},
{TOKEN_CHOICE, "choice"},
{TOKEN_ENDCHOICE, "endchoice"},
{TOKEN_PROMPT, "prompt"},
{TOKEN_SOURCE, "source"},
{TOKEN_IF, "if"},
{TOKEN_ENDIF, "endif"},
{TOKEN_NOTRESERVED, NULL}
};
/****************************************************************************
* Public Data
****************************************************************************/
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: debug
*
* Description:
* Debug output (conditional)
*
****************************************************************************/
static void debug(const char *fmt, ...)
{
va_list ap;
if (g_debug)
{
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
}
}
/****************************************************************************
* Name: error
*
* Description:
* Error output (unconditional)
*
****************************************************************************/
static void error(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
}
/****************************************************************************
* Name: output
*
* Description:
* Output to the final HTML file
*
****************************************************************************/
static void output(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(g_outfile, fmt, ap);
va_end(ap);
}
/****************************************************************************
* Name: body
*
* Description:
* HTML body output to a temporary file.
*
****************************************************************************/
static void body(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(g_bodyfile, fmt, ap);
va_end(ap);
}
/****************************************************************************
* Name: appendix
*
* Description:
* Output to a appendix file.
*
****************************************************************************/
static void appendix(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(g_apndxfile, fmt, ap);
va_end(ap);
}
/****************************************************************************
* Name: append_file
*
* Description:
* Append the specified file to the output file and remove it.
*
****************************************************************************/
static void append_file(const char *filename)
{
FILE *stream;
int ch;
/* Open the file for reading */
stream = fopen(filename, "r");
if (!stream)
{
error("open %s failed: %s\n", filename, strerror(errno));
exit(ERROR_APPENDFILE_OPEN_FAILURE);
}
/* Copy the file to the output */
while ((ch = getc(stream)) != EOF)
{
putc(ch, g_outfile);
}
/* Close and remove the file */
fclose(stream);
unlink(filename);
}
/****************************************************************************
* Name: show_usage
*
* Description:
* Show usage of this program and exit with the specified error code
*
****************************************************************************/
static void show_usage(const char *progname, int exitcode)
{
error("USAGE: "
"%s [-d] [-a <apps directory>] {-o <out file>] [<Kconfig root>]\n",
progname);
error(" %s [-h]\n\n", progname);
error("Where:\n\n");
error("\t-a : Select relative path to the apps/ directory."
" Theis path is relative\n");
error("\t to the <Kconfig directory>. Default: ../apps\n");
error("\t-o : Send output to <out file>. "
"Default: Output goes to stdout\n");
error("\t-d : Enable debug output\n");
error("\t-h : Prints this message and exits\n");
error("\t<Kconfig root> "
"is the directory containing the root Kconfig file.\n");
error("\t Default <Kconfig directory>: .\n");
exit(exitcode);
}
/****************************************************************************
* Name: skip_space
*
* Description:
* Skip over any spaces
*
****************************************************************************/
static char *skip_space(char *ptr)
{
while (*ptr && isspace((int)*ptr)) ptr++;
return ptr;
}
/****************************************************************************
* Name: dequote
*
* Description:
* Remove quotation marks from a string.
*
****************************************************************************/
static char *dequote(char *ptr)
{
int len;
/* Check if there is a trailing quote */
len = strlen(ptr);
if (ptr[len - 1] == '"')
{
/* Yes... replace it with a terminator */
ptr[len - 1] = '\0';
len--;
}
/* Is there a leading quote? */
if (ptr[0] == '"')
{
/* Yes.. skip over the leading quote */
ptr++;
len--;
}
/* Handle the case where nothing is left after dequoting */
if (len <= 0)
{
ptr = NULL;
}
return ptr;
}
/****************************************************************************
* Name: htmlize_character
*
* Description:
* Transfer and HTML-ize a character. Convert characters:
*
* " &quot; quotation mark
* ' &apos; apostrophe
* & &amp; ampersand
* < &lt; less-than
* > &gt; greater-than
*
****************************************************************************/
static int htmlize_character(char *dest, char ch)
{
const char *str;
/* Transfer the character from into the destination buffer, perform the
* conversion only if the character is one of the special characters.
*/
str = NULL;
switch (ch)
{
case '"':
str = "&quot;";
break;
case '\'':
str = "&apos;";
break;
case '&':
str = "&amp;";
break;
case '<':
str = "&lt;";
break;
case '>':
str = "&gt;";
break;
default:
*dest++ = ch;
*dest = '\0';
return 1;
}
/* Transfer a string */
*dest = '\0';
strcat(dest, str);
return strlen(str);
}
/****************************************************************************
* Name: htmlize_text
*
* Description:
* HTML-ize a free-text string. This function performs the conversions of
* in htmlize_character() for a text string.
*
****************************************************************************/
static char *htmlize_text(const char *src)
{
char *dest = g_scratch;
/* We may get here with the source pointer equal to NULL (or a pointer to
* a NUL string). Return the
* disfavor.
*/
if (!src || !*src)
{
return NULL;
}
/* Transfer each character from the source string into the scratch buffer */
for (; *src; src++)
{
/* Expand characters as necessary. NOTE: There is no check if the
* HTML-expanded text overflows the g_scratch[] buffer. If you see
* errors, be suspicious.
*/
dest += htmlize_character(dest, *src);
}
return g_scratch;
}
/****************************************************************************
* Name: htmlize_expression
*
* Description:
* HTML-ize an expression of configuration variables. This function
* performs the same conversions as in htmlize_character(), but also
* expands and adds hyper links for configuration variables.
*
****************************************************************************/
static char *htmlize_expression(const char *src)
{
char varname[VAR_SIZE + 1];
char htmlvar[HTML_VAR_SIZE + 1];
char *dest = g_scratch;
char ch = '\0';
char lastc;
/* We may get here with the source pointer equal to NULL. Return the
* disfavor.
*/
if (!src)
{
return NULL;
}
/* Transfer each character from the source string into the scratch buffer */
dest = g_scratch;
*dest = '\0';
while (*src)
{
/* Remember the last character and advance to the next character */
lastc = ch;
ch = *src;
/* Skip control characters and out-of-range 7-bit ASCII characters */
if (*src < 0x20 || *src > 0x7e)
{
src++;
continue;
}
/* Output no more than one consecutive space character. This depends
* on the fact that kconfig_line has replaces all of the forms of
* whitespace with a space character.
*/
if (*src == ' ')
{
if (lastc != ' ')
{
*dest++ = *src;
*dest = '\0';
}
src++;
continue;
}
/* Concatenate variable name strings. There strings probably begin
* with a uppercase letter, but here all alphanumeric values (plus '_'_
* are concatenated.
*/
if (isalnum(((int)*src)) || *src == '_')
{
int namlen = 0;
do
{
/* Don't overflow the tiny variable name buffer */
if (namlen >= VAR_SIZE)
{
error("Configuration variable name too long\n");
break;
}
/* Add the next character to the name */
varname[namlen] = *src++;
namlen++;
varname[namlen] = '\0';
}
while (isalnum(((int)*src)) || *src == '_');
/* HTML-ize the name into our bigger, local scratch buffer */
snprintf(htmlvar, HTML_VAR_SIZE,
"<a href=\"#CONFIG_%s\"><code>CONFIG_%s</code></a>",
varname, varname);
/* Then transfer the string into the scratch buffer */
strcat(dest, htmlvar);
dest += strlen(htmlvar);
}
/* All that remains are space and the punctuation characters */
else
{
/* Expand characters as necessary */
dest += htmlize_character(dest, *src);
src++;
}
}
return g_scratch;
}
/****************************************************************************
* Name: read_line
*
* Description:
* Read a new line from the Kconfig file into the g_line[] buffer, using
* the g_scratch buffer if necessary to concatenate lines that end with a
* line continuation character (backslash).
*
****************************************************************************/
static char *read_line(FILE *stream)
{
char *ptr;
int len;
g_lnptr = NULL;
/* Read the next line */
g_line[LINE_SIZE] = '\0';
if (!fgets(g_line, LINE_SIZE, stream))
{
return NULL;
}
/* Loop to handle continuation lines */
for (; ; )
{
/* How long is the line so far? */
len = strlen(g_line);
/* Remove any newline character at the end of the buffer */
if (g_line[len - 1] == '\n')
{
len--;
g_line[len] = '\0';
}
/* Does this continue on the next line? Note that this check
* could erroneoulsy combine two lines if a comment line ends with
* a line continuation... Don't do that!
*/
if (g_line[len - 1] != '\\')
{
/* No.. return now */
g_lnptr = g_line;
return g_line;
}
/* Yes.. Replace the backslash with a space delimiter */
g_line[len - 1] = ' ';
/* Read the next line into the scratch buffer */
g_scratch[SCRATCH_SIZE] = '\0';
if (!fgets(g_scratch, SCRATCH_SIZE, stream))
{
return NULL;
}
/* Skip any leading whitespace and copy the rest of the next line
* into the line buffer. Note that the leading white space is
* replaced with a single character to serve as a delimiter.
*/
ptr = skip_space(g_scratch);
strncpy(&g_line[len], ptr, LINE_SIZE - len);
}
}
/****************************************************************************
* Name: kconfig_line
*
* Description:
* Read a new line, skipping over leading white space and ignore lines
* that contain only comments.
*
****************************************************************************/
static char *kconfig_line(FILE *stream)
{
char *ptr;
for (; ; )
{
/* Read the next line from the Kconfig file */
/* Is there already valid data in the line buffer? This can happen
* while parsing help text and we read one line too far.
*/
if (!g_preread)
{
/* Read the next line */
if (!read_line(stream))
{
return NULL;
}
}
g_preread = false;
/* Replace all whitespace characters with spaces to simplify parsing */
for (ptr = g_line; *ptr; ptr++)
{
if (isspace(((int)*ptr)))
{
*ptr = ' ';
}
}
/* Skip any leading whitespace. Ignore empty lines and lines that
* contain only comments.
*/
ptr = skip_space(g_line);
if (*ptr && *ptr != '#' && *ptr != '\n')
{
g_lnptr = ptr;
return ptr;
}
}
}
/****************************************************************************
* Name: tokenize
*
* Description:
* Check if this string corresponds to a string in the reserved word table.
*
****************************************************************************/
static enum token_type_e tokenize(const char *token)
{
struct reserved_s *ptr;
for (ptr = g_reserved; ptr->tname; ptr++)
{
if (strcmp(token, ptr->tname) == 0)
{
break;
}
}
return ptr->ttype;
}
/****************************************************************************
* Name: findchar
*
* Description:
* Find a character in a string. This differs from strchr() because it
* skips over quoted characters. For example, if you are searching for
* '"', encountering '"' will terminate the search, but "\"" will not.
*
****************************************************************************/
static char *findchar(char *ptr, char ch)
{
bool escaped = false;
/* Search for the leading quotation marked */
for (; *ptr; ptr++)
{
if (escaped)
{
/* Skip over this character and reset the escaped flag */
escaped = false;
}
else if (*ptr == '\\')
{
/* Set the escaped flag to skip over the next character */
escaped = true;
}
else if (*ptr == ch)
{
/* We have found the (unescaped) character we are looking for */
return ptr;
}
}
return NULL;
}
/****************************************************************************
* Name: get_token
*
* Description:
* Get the next delimited token from the line buffer.
*
****************************************************************************/
static char *get_token(void)
{
char *pbegin;
char *pend = NULL;
/* The position to begin/resume parsing is in g_lnptr. */
if (g_lnptr && *g_lnptr)
{
pbegin = g_lnptr;
}
else
{
return NULL;
}
/* Find the beginning of the next token */
for (;
*pbegin && strchr(g_delimiters, *pbegin) != NULL;
pbegin++);
/* If we are at the end of the string with nothing
* but delimiters found, then return NULL.
*/
if (!*pbegin)
{
g_lnptr = pbegin;
return NULL;
}
/* Get if the token is a quoted string */
if (*pbegin == '"')
{
/* Search for the trailing quotation mark */
pend = findchar(pbegin + 1, '"');
/* Did we find the trailing quotation mark */
if (pend)
{
/* Yes.. skip over it */
pend++;
}
}
else
{
/* Find the end of the token */
for (pend = pbegin + 1;
*pend && strchr(g_delimiters, *pend) == NULL;
pend++);
}
/* pend either points to the end of the string or to
* the first delimiter after the string.
*/
if (*pend)
{
/* Turn the delimiter into a null terminator */
*pend++ = '\0';
}
/* Save the pointer where we left off and return the
* beginning of the token.
*/
g_lnptr = pend;
return pbegin;
}
/****************************************************************************
* Name: get_html_string
*
* Description:
* Extract a quoted string from the line buffer, dequote it, and make it
* HTML ready.
*
****************************************************************************/
static char *get_html_string(void)
{
char *pbegin;
char *pend;
int len;
/* Search for the leading quotation mark in the line buffer */
pbegin = strchr(g_lnptr, '"');
if (pbegin)
{
/* We found the leading quote. Skip over the leading quote */
pbegin++;
}
else
{
/* The string is unquoted. The beginning of the string is here,
* skipping over any leading whitespace.
*/
pbegin = skip_space(g_lnptr);
}
/* Search for the trailing quotation mark. If there is none, then
* the string goes to the end of the line.
*/
pend = findchar(pbegin, '"');
if (pend)
{
/* Replace the final quote with a NUL. g_lnptr is set to
* the next valid character after the terminating quote.
*/
*pend = '\0';
g_lnptr = pend + 1;
}
else
{
/* Get the length of the string. Return NULL if all that is
* left on the line is a NUL string.
*/
len = strlen(pbegin);
if (len < 1)
{
return NULL;
}
/* Use the rest of the line. g_lnptr is set to point at the
* terminating NUL.
*/
pend = pbegin + len;
g_lnptr = pend;
}
return htmlize_text(pbegin);
}
/****************************************************************************
* Name: push_dependency
*
* Description:
* Add the new dependency to the current list of dependencies.
*
****************************************************************************/
static void push_dependency(const char *dependency)
{
int ndx = g_ndependencies;
if (ndx >= MAX_DEPENDENCIES)
{
error("Too many dependencies, aborting\n");
exit(ERROR_TOO_MANY_DEPENDENCIES);
}
g_dependencies[ndx] = strdup(dependency);
g_ndependencies = ndx + 1;
}
/****************************************************************************
* Name: pop_dependency
*
* Description:
* Remove the last, pushed dependency
*
****************************************************************************/
static void pop_dependency(void)
{
int ndx = g_ndependencies - 1;
if (ndx < 0)
{
error("Dependency underflow, aborting\n");
exit(ERROR_DEPENDENCIES_UNDERFLOW);
}
if (g_dependencies[ndx])
{
free(g_dependencies[ndx]);
g_dependencies[ndx] = NULL;
}
g_ndependencies = ndx;
}
/****************************************************************************
* Name: incr_level
*
* Description:
* Increment the paragraph numbering level
*
****************************************************************************/
static void incr_level(void)
{
int ndx = g_level;
if (ndx >= MAX_LEVELS)
{
error("Nesting level is too deep, aborting\n");
exit(ERROR_NESTING_TOO_DEEP);
}
g_paranum[ndx] = 1;
g_level = ndx + 1;
}
/****************************************************************************
* Name: decr_level
*
* Description:
* Decrease the paragraph numbering level.
*
****************************************************************************/
static void decr_level(void)
{
int ndx = g_level;
g_paranum[ndx] = '\0';
ndx--;
if (ndx < 0)
{
error("Nesting level underflow, aborting\n");
exit(ERROR_NESTING_UNDERFLOW);
}
g_level = ndx;
}
/****************************************************************************
* Name: incr_paranum
*
* Description:
* Increment the paragraph number at this level
*
****************************************************************************/
static void incr_paranum(void)
{
int ndx = g_level - 1;
if (ndx < 0)
{
error("Nesting level underflow, aborting\n");
exit(ERROR_NESTING_UNDERFLOW);
}
g_paranum[ndx]++;
}
/****************************************************************************
* Name: get_paranum
*
* Description:
* Return a string for this paragraph (uses g_scratch[]).
*
****************************************************************************/
static const char *get_paranum(void)
{
char buffer[16];
int i;
g_scratch[0] = '\0';
for (i = 0; i < g_level; i++)
{
if (i > 0)
{
strcat(g_scratch, ".");
}
snprintf(buffer, 16, "%d", g_paranum[i]);
strcat(g_scratch, buffer);
}
return g_scratch;
}
/****************************************************************************
* Name: type2str
*
* Description:
* Return a string given a member of the configuration variable type
* enumeration.
*
****************************************************************************/
static const char *type2str(enum config_type_e valtype)
{
switch (valtype)
{
case VALUE_BOOL:
return "Boolean";
case VALUE_TRISTATE:
return "Tristate";
case VALUE_INT:
return "Integer";
case VALUE_HEX:
return "Hexadecimal";
case VALUE_STRING:
return "String";
default:
break;
}
return "Unknown";
}
/****************************************************************************
* Name: process_help
*
* Description:
* Read and generate HTML for the help text that is expected after the
* configuration configuration variable description.
*
****************************************************************************/
static inline void process_help(FILE *stream, output_t outfunc)
{
char *ptr;
int help_indent = 0;
int indent;
bool blank;
bool done;
bool newpara;
bool preformatted;
/* Read each comment line */
newpara = true;
preformatted = false;
for (; ; )
{
/* Read the next line of comment text */
if (!read_line(stream))
{
break;
}
/* What is the indentation level? The first help line sets the
* indentation level. The first line encounter with lower
* indentation terminates the help.
*/
ptr = g_line;
indent = 0;
blank = false;
done = false;
while (!done)
{
int ch = (int)*ptr;
switch (ch)
{
case ' ':
indent++;
ptr++;
break;
case '\t':
indent += TAB_SIZE;
ptr++;
break;
case '#':
#if 0
blank = true;
#endif
done = true;
break;
case '\n':
case '\0':
blank = true;
done = true;
break;
default:
done = true;
break;
}
}
/* Blank lines are a special case */
if (blank)
{
/* Avoid putting an empty paragraph at the end of the help */
if (preformatted)
{
outfunc("</pre></ul>\n");
preformatted = false;
}
if (!newpara)
{
outfunc("</p>\n");
newpara = true;
}
continue;
}
/* Check the indentation level */
if (indent == 0)
{
g_preread = true;
break;
}
else if (!help_indent)
{
help_indent = indent;
}
else if (indent < help_indent)
{
g_preread = true;
break;
}
/* Add the next line of help text */
if (newpara)
{
outfunc("<p>\n");
newpara = false;
}
/* Lines that are indented at greater levels are assumed to be
* pre-formatted text. This is not part of the Kconfig language but
* rather simply a NuttX Kconfig convention.
*/
if (indent > help_indent)
{
if (!preformatted)
{
outfunc(" <ul><pre>\n");
newpara = false;
preformatted = true;
}
outfunc("%s\n", htmlize_text(ptr));
}
else
{
if (preformatted)
{
outfunc("</pre></ul>\n");
preformatted = false;
}
outfunc(" %s", htmlize_text(ptr));
}
}
if (!newpara)
{
outfunc("\n</p>\n");
}
if (preformatted)
{
outfunc("</pre></ul>\n");
}
}
/****************************************************************************
* Name: process_default
*
* Description:
* Read and parse the Kconfig default statement.
*
****************************************************************************/
static void process_default(FILE *stream, struct default_s *defp)
{
enum token_type_e tokid;
char *token;
int ndx;
/* Check if we have space for another default value */
ndx = defp->d_nitems;
if (ndx >= MAX_DEFAULTS)
{
error("Too many default values\n");
exit(ERROR_TOO_MANY_DEFAULTS);
}
/* Get the next token which will be the value of the default */
token = get_token();
if (!token)
{
error("Missing default value\n");
exit(ERROR_MISSING_DEFAULT_VALUE);
}
defp->d_item[ndx].d_default = strdup(token);
defp->d_item[ndx].d_dependency = NULL;
/* Check if the default value is followed by "depends on" */
token = get_token();
if (token)
{
/* Yes.. something follows the default value. */
tokid = tokenize(token);
if (tokid != TOKEN_IF)
{
error("Unrecognized garbage after default value\n");
exit(ERROR_GARBAGE_AFTER_DEFAULT);
}
/* The rest of the line is the dependency */
defp->d_item[ndx].d_dependency = strdup(g_lnptr);
}
/* Update the number of defaults we have encountered in this block */
defp->d_nitems++;
}
/****************************************************************************
* Name: print_default
*
* Description:
* Output and the list of defaults to the HTML body file.
*
****************************************************************************/
static void print_default(struct default_s *defp, output_t outfunc)
{
struct default_item_s *item;
int i;
/* Check if there are any default value */
if (defp->d_nitems > 0)
{
/* Yes, output the defaults differently if there is only one */
if (defp->d_nitems == 1)
{
/* Output the Default */
item = &defp->d_item[0];
outfunc(" <li>\n");
outfunc(" <i>Default</i>: %s\n", item->d_default);
/* Output the dependency */
if (item->d_dependency)
{
outfunc(" <p>\n");
outfunc(" <i>Dependency:</i>\n");
outfunc(" %s\n", htmlize_expression(item->d_dependency));
outfunc(" </p>\n");
}
outfunc(" </li>\n");
}
else
{
/* Output a sub-list of defaults. */
outfunc(" <li>\n");
outfunc(" <i>Default Values</i>:\n");
outfunc(" <ul>\n");
for (i = 0; i < defp->d_nitems; i++)
{
/* Output the Default */
item = &defp->d_item[i];
outfunc(" <li>\n");
outfunc(" <i>Default</i>: %s\n", item->d_default);
/* Output the dependency */
if (item->d_dependency)
{
outfunc(" <p>\n");
outfunc(" <i>Dependency:</i>\n");
outfunc(" %s\n",
htmlize_expression(item->d_dependency));
outfunc(" </p>\n");
}
}
outfunc(" </ul>\n");
outfunc(" </li>\n");
}
}
}
/****************************************************************************
* Name: free_default
*
* Description:
* Output and the list of defaults to the HTML body file.
*
****************************************************************************/
static void free_default(struct default_s *defp)
{
struct default_item_s *item;
int i;
/* Free strings for each default */
for (i = 0; i < defp->d_nitems; i++)
{
/* Free the default value string */
item = &defp->d_item[i];
free(item->d_default);
/* Free any dependency on the default */
if (item->d_dependency)
{
free(item->d_dependency);
}
}
}
/****************************************************************************
* Name: process_dependson
*
* Description:
* Parse a "depends on" dependency and add the new dependency to the
* stack of dependencies.
*
****************************************************************************/
static void process_dependson(void)
{
char *value = get_token();
if (strcmp(value, "on") != 0)
{
error("Expected \"on\" after \"depends\"\n");
exit(ERRROR_ON_AFTER_DEPENDS);
}
push_dependency(htmlize_expression(g_lnptr));
}
/****************************************************************************
* Name: print_dependencies
*
* Description:
* Output the current stack of dependencies
*
****************************************************************************/
static void print_dependencies(output_t outfunc)
{
int i;
if (g_ndependencies > 0)
{
outfunc(" <li><i>Dependencies</i>: %s", g_dependencies[0]);
for (i = 1; i < g_ndependencies; i++)
{
outfunc(", %s\n", g_dependencies[i]);
}
outfunc("</li>\n");
}
}
/****************************************************************************
* Name: free_dependencies
*
* Description:
* Pop dependencies from the stack.
*
****************************************************************************/
static void free_dependencies(int ndependencies)
{
int i;
for (i = 0; i < ndependencies; i++)
{
pop_dependency();
}
}
/****************************************************************************
* Name: process_config
*
* Description:
* Process one configuration variable paragraph
*
****************************************************************************/
static inline char *process_config(FILE *stream, const char *varname,
const char *kconfigdir,
const char *kconfigname)
{
enum token_type_e tokid;
struct config_s config;
output_t outfunc;
bool help;
bool hidden;
const char *paranum;
char *token;
char *ptr;
int i;
/* Get the configuration information */
memset(&config, 0, sizeof(struct config_s));
config.c_name = strdup(varname);
/* Process each line in the configuration */
help = false;
token = NULL;
while ((ptr = kconfig_line(stream)) != NULL)
{
/* Process the first token on the Kconfig file line */
token = get_token();
if (token != NULL)
{
tokid = tokenize(token);
switch (tokid)
{
case TOKEN_BOOL:
case TOKEN_TRISTATE:
{
/* Save the type of the configuration variable */
config.c_type = tokid ==
TOKEN_BOOL ? VALUE_BOOL : VALUE_TRISTATE;
/* Get the description following the type */
ptr = get_html_string();
if (ptr)
{
config.c_desc = strdup(ptr);
}
/* Indicate that the line has been consumed */
token = NULL;
}
break;
case TOKEN_INT:
{
/* Save the type of the configuration variable */
config.c_type = VALUE_INT;
/* Get the description following the type */
ptr = get_html_string();
if (ptr)
{
config.c_desc = strdup(ptr);
}
/* Indicate that the line has been consumed */
token = NULL;
}
break;
case TOKEN_HEX:
{
/* Save the type of the configuration variable */
config.c_type = VALUE_HEX;
/* Get the description following the type */
ptr = get_html_string();
if (ptr)
{
config.c_desc = strdup(ptr);
}
/* Indicate that the line has been consumed */
token = NULL;
}
break;
case TOKEN_STRING:
{
/* Save the type of the configuration variable */
config.c_type = VALUE_STRING;
/* Get the description following the type */
ptr = get_html_string();
if (ptr)
{
config.c_desc = strdup(ptr);
}
/* Indicate that the line has been consumed */
token = NULL;
}
break;
case TOKEN_DEFAULT:
{
process_default(stream, &config.c_default);
token = NULL;
}
break;
case TOKEN_RANGE:
{
char *value = get_token();
if (value)
{
config.c_lower = strdup(value);
value = get_token();
if (value)
{
config.c_upper = strdup(value);
}
}
token = NULL;
}
break;
case TOKEN_SELECT:
{
char *value;
int ndx;
ndx = config.c_select.s_nvar;
if (ndx >= MAX_SELECT)
{
error("Too many 'select' lines\n");
exit(ERROR_TOO_MANY_SELECT);
}
value = get_token();
config.c_select.s_varname[ndx] = strdup(value);
config.c_select.s_nvar = ndx + 1;
token = NULL;
}
break;
case TOKEN_DEPENDS:
{
process_dependson();
config.c_ndependencies++;
token = NULL;
}
break;
case TOKEN_OPTION:
{
token = NULL; /* Ignored */
}
break;
case TOKEN_HELP:
{
help = true;
token = NULL;
}
break;
default:
{
debug("CONFIG_%s: Terminating token: %s\n",
config.c_name, token);
}
break;
}
/* Break out on the help token (or the first unhandled token) */
if (help || token != NULL)
{
break;
}
}
}
/* Is this an internal configuration variable with no description?
* If so, send the output to the appendix file.
*/
hidden = (config.c_desc == NULL);
outfunc = hidden ? appendix : body;
hidden |= g_inchoice;
/* Print the configuration variable name and the short description */
outfunc("<h3><a name=\"CONFIG_%s\">", config.c_name);
/* If we are not in a choice block, than give the variable a paragraph
* number and put it in the table of contents.
*/
if (!hidden)
{
paranum = get_paranum();
output("<li><a href=\"#CONFIG_%s\">%s <code>CONFIG_%s</code>",
config.c_name, paranum, config.c_name);
outfunc("%s ", paranum);
incr_paranum();
}
outfunc("<code>CONFIG_%s</code>", config.c_name);
/* Output the short description in the paragraph title (if we have one) */
if (config.c_desc)
{
if (!hidden)
{
output(": %s", config.c_desc);
}
outfunc(": %s", config.c_desc);
}
outfunc("</a></h3>\n");
if (!hidden)
{
output("</a></li>\n");
}
/* Configuration description is indented */
outfunc("<ul>\n");
/* Print the type of the configuration variable */
if (config.c_type != VALUE_NONE)
{
outfunc(" <li><i>Type</i>: %s</li>\n", type2str(config.c_type));
}
/* Print the default values of the configuration variable */
print_default(&config.c_default, outfunc);
/* Print the range of values of the configuration variable */
if (config.c_lower || config.c_upper)
{
outfunc(" <li><i>Range</i>:\n");
if (config.c_lower)
{
outfunc(" %s", config.c_lower);
}
outfunc(" -", config.c_lower);
if (config.c_upper)
{
outfunc(" %s", config.c_upper);
}
outfunc("</li>\n");
}
/* Print the default value of the configuration variable auto-selected by
* this setting
*/
if (config.c_select.s_nvar > 0)
{
outfunc(" <li><i>Selects</i>: <a href=\"#CONFIG_%s\">"
"<code>CONFIG_%s</code></a>",
config.c_select.s_varname[0], config.c_select.s_varname[0]);
for (i = 1; i < config.c_select.s_nvar; i++)
{
outfunc(", <a href=\"#CONFIG_%s\"><code>CONFIG_%s</code></a>",
config.c_select.s_varname[i],
config.c_select.s_varname[i]);
}
outfunc("</li>\n");
}
/* Print the list of dependencies (if any) */
print_dependencies(outfunc);
/* Show the configuration file. */
outfunc(" <li><i>Kconfig file</i>: <code>%s/%s</code>\n",
kconfigdir, kconfigname);
/* Print any help text */
if (help)
{
process_help(stream, outfunc);
token = NULL;
}
/* End of configuration description */
outfunc("</ul>\n");
/* Free allocated memory */
free_dependencies(config.c_ndependencies);
free_default(&config.c_default);
if (config.c_name)
{
free(config.c_name);
}
if (config.c_desc)
{
free(config.c_desc);
}
if (config.c_lower)
{
free(config.c_lower);
}
if (config.c_upper)
{
free(config.c_upper);
}
if (config.c_select.s_nvar > 0)
{
for (i = 0; i < config.c_select.s_nvar; i++)
{
free(config.c_select.s_varname[i]);
}
}
return token;
}
/****************************************************************************
* Name: process_choice
*
* Description:
* Process a choice paragraph
*
****************************************************************************/
static char *parse_kconfigfile(FILE *stream, const char *kconfigdir,
const char *kconfigfile); /* Forward reference */
static inline char *process_choice(FILE *stream, const char *kconfigdir,
const char *kconfigname)
{
enum token_type_e tokid;
struct choice_s choice;
const char *paranum;
char *token = NULL;
char *ptr;
bool help = false;
/* Get the choice information */
memset(&choice, 0, sizeof(struct choice_s));
/* Process each line in the choice */
while ((ptr = kconfig_line(stream)) != NULL)
{
/* Process the first token on the Kconfig file line */
token = get_token();
if (token != NULL)
{
tokid = tokenize(token);
switch (tokid)
{
case TOKEN_PROMPT:
{
/* Get the prompt string */
ptr = get_html_string();
if (ptr)
{
choice.c_prompt = strdup(ptr);
}
/* Indicate that the line has been consumed */
token = NULL;
}
break;
case TOKEN_DEFAULT:
{
process_default(stream, &choice.c_default);
token = NULL;
}
break;
case TOKEN_DEPENDS:
{
process_dependson();
choice.c_ndependencies++;
token = NULL;
}
break;
case TOKEN_HELP:
{
help = true;
token = NULL;
}
break;
default:
{
debug("Choice: Terminating token: %s\n", token);
}
break;
}
/* Break out on the help token (or the first unhandled token) */
if (help || token != NULL)
{
break;
}
}
}
paranum = get_paranum();
output("<li><a href=\"#choice_%d\">%s Choice", g_choice_number, paranum);
body("\n<h3><a name=\"choice_%d\">%s Choice", g_choice_number, paranum);
if (choice.c_prompt)
{
output(": %s", choice.c_prompt);
body(": %s", choice.c_prompt);
}
output("</a></li>\n");
body("</a></h3>\n");
g_choice_number++;
/* Print the default values of the configuration variable */
body("<ul>\n");
print_default(&choice.c_default, body);
/* Print the list of dependencies (if any) */
print_dependencies(body);
/* Show the configuration file.
* REVISIT: Shows wrong file name if the name of the Kconfig file is not
* Kconfig.
*/
body(" <li><i>Kconfig file</i>: <code>%s/%s</code>\n</li>",
kconfigdir, kconfigname);
/* Print any help text */
if (help)
{
process_help(stream, body);
token = NULL;
}
body("</ul>\n");
/* Then show the choice options */
body("<p><b>Choice Options:</b></p>");
body("<ul>\n");
/* Free allocated memory */
free_dependencies(choice.c_ndependencies);
free_default(&choice.c_default);
if (choice.c_prompt)
{
free(choice.c_prompt);
}
/* Increment the paragraph level */
incr_level();
debug("process_choice: TOKEN_CHOICE\n");
debug(" kconfigdir: %s\n", kconfigdir);
debug(" kconfigname: %s\n", kconfigname);
debug(" level: %d\n", g_level);
/* Then return in choice mode */
g_inchoice++;
return token;
}
/****************************************************************************
* Name: process_menu
*
* Description:
* Process a menu paragraph
*
****************************************************************************/
static inline char *process_menu(FILE *stream, const char *kconfigdir,
const char *kconfigname)
{
enum token_type_e tokid;
struct menu_s menu;
const char *paranum;
char *menuname;
char *token = NULL;
/* Get the menu information */
memset(&menu, 0, sizeof(struct menu_s));
/* Get the menu name */
menuname = get_html_string();
menu.m_name = strdup(menuname);
/* Process each line in the choice */
while (kconfig_line(stream) != NULL)
{
/* Process the first token on the Kconfig file line */
token = get_token();
if (token != NULL)
{
tokid = tokenize(token);
switch (tokid)
{
case TOKEN_DEPENDS:
{
process_dependson();
menu.m_ndependencies++;
token = NULL;
}
break;
default:
{
debug("Menu: Terminating token: %s\n", token);
}
break;
}
/* Break out on the first unhandled token */
if (token != NULL)
{
break;
}
}
}
/* Output menu information */
paranum = get_paranum();
if (menu.m_name)
{
output("<li><a name=\"menu_%d_toc\">"
"<a href=\"#menu_%d\">%s Menu: %s</a></a></li>\n",
g_menu_number, g_menu_number, paranum, menu.m_name);
body("\n<h1><a name=\"menu_%d\">%s Menu: %s</a></h1>\n",
g_menu_number, paranum, menu.m_name);
}
else
{
output("<li><a name=\"menu_%d_toc\">"
"<a href=\"#menu_%d\">%s Menu</a></a></li>\n",
g_menu_number, g_menu_number, paranum);
body("\n<h1><a name=\"menu_%d\">%s Menu</a></h1>\n",
g_menu_number, paranum);
}
/* Output logic to toggle the contents below the menu in the table of
* contents.
*/
#ifdef USE_JQUERY
output("<a id=\"link_%d\" "
"href=\"#menu_%d_toc\" onclick=\"toggle('toggle_%d', 'link_%d')\">"
"Expand</a>\n",
g_menu_number, g_toggle_number, g_toggle_number);
#else
output("<a href=\"#menu_%d_toc\" onclick=\"toggle('toggle_%d', this)\">"
"Expand</a>\n",
g_menu_number, g_toggle_number);
#endif
output("<ul id=\"toggle_%d\" style=\"display:none\">\n",
g_toggle_number);
g_menu_number++;
g_toggle_number++;
/* Print the list of dependencies (if any) */
body("<ul>\n");
print_dependencies(body);
/* Show the configuration file */
body(" <li><i>Kconfig file</i>: <code>%s/%s</code>\n",
kconfigdir, kconfigname);
body("</ul>\n");
/* Free any allocated memory */
free_dependencies(menu.m_ndependencies);
if (menu.m_name)
{
free(menu.m_name);
}
/* Increment the paragraph level */
incr_level();
debug("process_menu: TOKEN_MENU\n");
debug(" kconfigdir: %s\n", kconfigdir);
debug(" kconfigname: %s\n", kconfigname);
debug(" level: %d\n", g_level);
/* Return the terminating token */
return token;
}
/****************************************************************************
* Name: parse_kconfigfile
*
* Description:
* Parse a Kconfig file.
*
****************************************************************************/
static void process_kconfigfile(const char *kconfigdir,
const char *kconfigname); /* Forward reference */
static char *parse_kconfigfile(FILE *stream, const char *kconfigdir,
const char *kconfigname)
{
enum token_type_e tokid;
char *token = NULL;
/* Process each line in the Kconfig file */
while (kconfig_line(stream) != NULL)
{
/* Process the first token on the Kconfig file line */
token = get_token();
while (token != NULL)
{
tokid = tokenize(token);
switch (tokid)
{
case TOKEN_SOURCE:
{
/* Get the relative path from the Kconfig file line */
char *source = get_token();
/* Remove optional quoting */
source = dequote(source);
if (source)
{
char *configname = basename(source);
char *subdir = dirname(source);
char *dirpath;
/* Check for an absolute path */
if (source[0] == '/')
{
dirpath = strdup(subdir);
}
else
{
/* Check if the directory path contains $APPSDIR */
char *appsdir = strstr(subdir, "$APPSDIR");
if (appsdir)
{
char *tmp = appsdir + strlen("$APPSDIR");
*appsdir = '\0';
asprintf(&dirpath, "%s/%s%s%s",
g_kconfigroot, subdir,
g_appsdir, tmp);
}
else
{
asprintf(&dirpath, "%s/%s",
g_kconfigroot, subdir);
}
}
configname = strdup(configname);
debug("parse_kconfigfile: "
"Recursing for TOKEN_SOURCE\n");
debug(" source: %s\n", source);
debug(" subdir: %s\n", subdir);
debug(" dirpath: %s\n", dirpath);
debug(" configname: %s\n", configname);
/* Then recurse */
process_kconfigfile(dirpath, configname);
token = NULL;
free(dirpath);
free(configname);
}
/* Set the token string to NULL to indicate that
* we need to read the next line
*/
token = NULL;
}
break;
case TOKEN_CONFIG:
case TOKEN_MENUCONFIG:
{
char *varname = get_token();
token = process_config(stream, varname, kconfigdir,
kconfigname);
}
break;
case TOKEN_COMMENT:
case TOKEN_MAINMENU:
{
token = NULL; /* ignored */
}
break;
case TOKEN_MENU:
{
token = process_menu(stream, kconfigdir, kconfigname);
}
break;
case TOKEN_CHOICE:
{
token = process_choice(stream, kconfigdir, kconfigname);
}
break;
case TOKEN_ENDCHOICE:
{
/* Reduce body indentation level */
body("</ul>\n");
g_inchoice--;
/* Decrement the paragraph level */
decr_level();
incr_paranum();
token = NULL;
}
break;
case TOKEN_ENDMENU:
{
/* Reduce table of contents indentation level. NOTE that
* this also terminates the toggle block that
* began with the matching <ul>
*/
output("</ul>\n");
/* Decrement the paragraph level */
decr_level();
incr_paranum();
token = NULL;
}
break;
case TOKEN_IF:
{
char *dependency = get_token();
push_dependency(htmlize_expression(dependency));
token = NULL;
}
break;
case TOKEN_ENDIF:
{
pop_dependency();
token = NULL;
}
break;
default:
{
/* Set token to NULL to skip to the next line. */
error("File %s/%s Unhandled token: %s\n",
kconfigdir, kconfigname, token);
token = NULL;
}
break;
}
}
}
return token;
}
/****************************************************************************
* Name: process_kconfigfile
*
* Description:
* Open and parse a Kconfig file
*
****************************************************************************/
static void process_kconfigfile(const char *kconfigdir,
const char *kconfigname)
{
FILE *stream;
char *kconfigpath;
/* Create the full path to the Kconfig file */
asprintf(&kconfigpath, "%s/%s", kconfigdir, kconfigname);
debug("process_kconfigfile: Entry\n");
debug(" kconfigdir: %s\n", kconfigdir);
debug(" kconfigpath: %s\n", kconfigpath);
debug(" level: %d\n", g_level);
/* Open the Kconfig file */
stream = fopen(kconfigpath, "r");
if (!stream)
{
error("open %s failed: %s\n", kconfigpath, strerror(errno));
exit(ERROR_KCONFIG_OPEN_FAILURE);
}
/* Process each line in the Kconfig file */
parse_kconfigfile(stream, kconfigdir, kconfigname);
/* Close the Kconfig file and release the memory holding the full path */
fclose(stream);
free(kconfigpath);
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: main
*
* Description:
* Program entry point.
*
****************************************************************************/
int main(int argc, char **argv, char **envp)
{
char *outfile;
const char *paranum;
time_t now;
struct tm *ptm;
int ch;
/* Parse command line options */
g_debug = false;
g_kconfigroot = ".";
g_appsdir = "../apps";
g_outfile = stdout;
outfile = NULL;
while ((ch = getopt(argc, argv, ":dhia:o:")) > 0)
{
switch (ch)
{
case 'a' :
g_appsdir = optarg;
break;
case 'o' :
outfile = optarg;
break;
case 'h' :
show_usage(argv[0], 0);
case 'd' :
g_debug = true;
break;
case '?' :
error("Unrecognized option: %c\n", optopt);
show_usage(argv[0], ERROR_UNRECOGNIZED_OPTION);
case ':' :
error("Missing option argument, option: %c\n", optopt);
show_usage(argv[0], ERROR_MISSING_OPTION_ARGUMENT);
default:
error("Unexpected option: %c\n", ch);
show_usage(argv[0], ERROR_UNEXPECTED_OPTION);
}
}
if (optind < argc)
{
g_kconfigroot = argv[optind];
optind++;
}
debug("Using <Kconfig directory>: %s\n", g_kconfigroot);
debug("Using <apps directory>: %s\n", g_appsdir);
debug("Using <out file>: %s\n", outfile ? outfile : "stdout");
if (optind < argc)
{
error("Unexpected garbage at the end of the line\n");
show_usage(argv[0], ERROR_TOO_MANY_ARGUMENTS);
}
/* Open the output file (if any). The output file will hold the
* Table of Contents as the HTML document is generated.
*/
if (outfile)
{
g_outfile = fopen(outfile, "w");
if (!g_outfile)
{
error("open %s failed: %s\n", outfile, strerror(errno));
exit(ERROR_OUTFILE_OPEN_FAILURE);
}
}
/* Open the temporary file that holds the HTML body. The HTML
* body will be appended after the Table of contents.
*/
g_bodyfile = fopen(BODYFILE_NAME, "w");
if (!g_bodyfile)
{
error("open %s failed: %s\n", BODYFILE_NAME, strerror(errno));
exit(ERROR_BODYFILE_OPEN_FAILURE);
}
/* Open the temporary file that holds the appendix. The appendix
* will be appended after the HTML body.
*/
g_apndxfile = fopen(APNDXFILE_NAME, "w");
if (!g_apndxfile)
{
error("open %s failed: %s\n", APNDXFILE_NAME, strerror(errno));
exit(ERROR_APNDXFILE_OPEN_FAILURE);
}
/* Get the current date string in the scratch buffer */
now = time(NULL);
ptm = localtime(&now);
strftime(g_scratch, SCRATCH_SIZE, "%B %d, %Y", ptm);
/* Output header boilerplater */
output("<html>\n");
output("<head>\n");
output("<title>NuttX Configuration Options</title>\n");
output("</head>\n");
output("<body background=\"backgd.gif\">\n");
output("<hr><hr>\n");
output("<table width =\"100%%\">\n");
output("<tr align=\"center\" bgcolor=\"#e4e4e4\">\n");
output("<td>\n");
output("<h1><big><font color=\"#3c34ec\">"
"<i>NuttX Configuration Variables</i></font></big></h1>\n");
output("<p>Last Updated: %s</p>\n", g_scratch);
output("</td>\n");
output("</tr>\n");
output("</table>\n");
#ifdef USE_JQUERY
output("<script src=\"http://code.jquery.com/jquery-1.9.1.js\">"
"</script>\n");
output("<script type=\"text/javascript\">\n");
output("function toggle(list_id, link_id) {\n");
output(" var list = $('#' + list_id);\n");
output(" var link = $('#' + link_id);\n");
output(" if (list.is(\":visible\")) {\n");
output(" list.hide();\n");
output(" link.text('Expand');\n");
output(" } else {\n");
output(" list.show();\n");
output(" link.text('Collapse');\n");
output(" }\n");
output("}\n");
output("</script>\n");
#else
output("<script type=\"text/javascript\">\n");
output("function toggle(id, link) {\n");
output(" var e = document.getElementById(id);\n");
output(" if (e.style.display == '') {\n");
output(" e.style.display = 'none';\n");
output(" link.innerHTML = 'Expand';\n");
output(" } else {\n");
output(" e.style.display = '';\n");
output(" link.innerHTML = 'Collapse';\n");
output(" }\n");
output("}\n");
output("</script>\n");
#endif
output("<hr><hr>\n");
output("<table width =\"100%%\">\n");
output(" <tr bgcolor=\"#e4e4e4\">\n");
output(" <td>\n");
output(" <h1>Table of Contents</h1>\n");
output(" </td>\n");
output(" </tr>\n");
output("</table>\n");
output("<ul>\n");
incr_level();
paranum = get_paranum();
output("<li><a href=\"#menu_%d\">%s Menu: Main</a></li>\n",
g_menu_number, paranum);
body("<table width =\"100%%\">\n");
body(" <tr bgcolor=\"#e4e4e4\">\n");
body(" <td>\n");
body(" <a name=\"menu_%d\"><h1>%s Menu: Main</h1></a>\n",
g_menu_number, paranum);
body(" </td>\n");
body(" </tr>\n");
body("</table>\n");
g_menu_number++;
/* Increment the paragraph level again:
* Everything is included within the main menu.
*/
incr_level();
/* Tell the reader that this is an auto-generated file */
body("<p>\n");
body(" <b>Overview</b>.\n");
body(" The NuttX RTOS is highly configurable.\n");
body(" The NuttX configuration files are maintained using the "
"kconfig-frontends</a> tool.\n");
body(" That configuration tool uses <code>Kconfig</code> "
"files that can be found through the NuttX source tree.\n");
body(" Each <code>Kconfig</code> files contains "
"declarations of configuration variables.\n");
body(" Each configuration variable provides one configuration "
"option for the NuttX RTOS.\n");
body(" This configurable options are described in this document.\n");
body("</p>\n");
body("<p>\n");
body(" <b>Main Menu</b>.\n");
body(" The normal way to start the NuttX configuration is to enter "
"this command line from the NuttX build directory: "
"<code>make menuconfig</code>.\n");
body(" Note that NuttX must first be configured <i>before</i> "
"this command so that the configuration file (<code>.config</code>) "
"is present in the top-level build directory.\n");
body(" The main menu is the name give to the opening menu display "
"after this command is executed.\n");
body("</p>\n");
body("<p>\n");
body(" <b>Maintenance Note</b>.\n");
body(" This documentation was auto-generated using the "
"kconfig2html tool\n");
body(" That tool analyzes the NuttX <code>Kconfig</code> "
"files and generates this HTML document.\n");
body(" This HTML document file should not be edited manually.\n");
body(" In order to make changes to this document, "
"you should instead modify the <code>Kconfig</code> file(s) "
"that were used to generated this document and then execute the "
"<code>kconfig2html</code> again "
"to regenerate the HTML document file.\n");
body("</p>\n");
/* Process the Kconfig files through recursive descent */
process_kconfigfile(g_kconfigroot, "Kconfig");
/* Terminate the table of contents */
output("<li><a href=\"#appendixa\">"
"Appendix A: Hidden Configuration Variables</a></li>\n");
output("</ul>\n");
/* Close the HMTL body file and copy it to the output file */
fclose(g_bodyfile);
append_file(BODYFILE_NAME);
/* Output introductory information for the appendix */
output("<table width =\"100%%\">\n");
output(" <tr bgcolor=\"#e4e4e4\">\n");
output(" <td>\n");
output(" <a name=\"appendixa\">"
"<h1>Appendix A: Hidden Configuration Variables</h1></a>\n");
output(" </td>\n");
output(" </tr>\n");
output("</table>\n");
output("<p>\n");
output(" This appendix holds internal configurations variables that "
"are not visible to the user.\n");
output(" These settings are presented out-of-context because "
"they cannot be directly controlled by the user.\n");
output(" Many of these settings are selected automatically and "
"indirectly when other, visible configuration variables "
"are selected.\n");
output(" One purpose of these hidden configuration variables "
"is to control menuing in the kconfig-frontends "
"configuration tool.\n");
output(" Many configuration variables with a form like "
"<code>CONFIG_ARCH_HAVE_</code><i>feature</i>, for example, "
"are used only to indicate that the selected architecture supports "
"<i>feature</i> and so addition selection associated with "
"<i>feature</i> will become accessible to the user.\n");
output("</p>\n");
output("<ul>\n");
/* Close the appendix file and copy it to the output file */
fclose(g_apndxfile);
append_file(APNDXFILE_NAME);
/* Output trailer boilerplater */
output("</ul>\n");
output("</body>\n");
output("</html>\n");
/* Close the output file (if any) and the temporary file */
if (outfile)
{
fclose(g_outfile);
}
return 0;
}