static void print_help PARAMS ((void));
static void path_include PARAMS ((cpp_reader *,
- struct cpp_pending *,
char *, int));
static void initialize_builtins PARAMS ((cpp_reader *));
static void append_include_chain PARAMS ((cpp_reader *,
- struct cpp_pending *,
char *, int, int));
+struct file_name_list * remove_dup_dir PARAMS ((cpp_reader *,
+ struct file_name_list *));
+struct file_name_list * remove_dup_dirs PARAMS ((cpp_reader *,
+ struct file_name_list *));
static void merge_include_chains PARAMS ((cpp_reader *));
static void initialize_dependency_output PARAMS ((cpp_reader *));
cl_directive_handler));
#ifdef HOST_EBCDIC
static int opt_comp PARAMS ((const void *, const void *));
-static void sort_options PARAMS ((void));
#endif
static int parse_option PARAMS ((const char *));
-static int dump_macros_helper PARAMS ((cpp_reader *, cpp_hashnode *));
/* Fourth argument to append_include_chain: chain to use */
enum { QUOTE = 0, BRACKET, SYSTEM, AFTER };
-/* If we have designated initializers (GCC >2.7) this table can be
- initialized, constant data. Otherwise, it has to be filled in at
+/* If we have designated initializers (GCC >2.7) these tables can be
+ initialized, constant data. Otherwise, they have to be filled in at
runtime. */
+#if HAVE_DESIGNATED_INITIALIZERS
-#if (GCC_VERSION >= 2007)
#define init_IStable() /* nothing */
-#define ISTABLE __extension__ const unsigned char _cpp_IStable[256] = {
+#define ISTABLE __extension__ const U_CHAR _cpp_IStable[UCHAR_MAX + 1] = {
+
+#define init_trigraph_map() /* nothing */
+#define TRIGRAPH_MAP \
+__extension__ const U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = {
+
#define END };
#define s(p, v) [p] = v,
+
#else
-#define ISTABLE unsigned char _cpp_IStable[256] = { 0 }; \
+
+#define ISTABLE unsigned char _cpp_IStable[UCHAR_MAX + 1] = { 0 }; \
static void init_IStable PARAMS ((void)) { \
unsigned char *x = _cpp_IStable;
+
+#define TRIGRAPH_MAP U_CHAR _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
+ static void init_trigraph_map PARAMS ((void)) { \
+ unsigned char *x = _cpp_trigraph_map;
+
#define END }
#define s(p, v) x[p] = v;
+
#endif
#define A(x) s(x, ISidnum|ISidstart)
S('\0') S('\v') S('\f')
END
+TRIGRAPH_MAP
+ s('=', '#') s(')', ']') s('!', '|')
+ s('(', '[') s('\'', '^') s('>', '}')
+ s('/', '\\') s('<', '{') s('-', '~')
+END
+
#undef A
#undef N
#undef H
#undef s
#undef ISTABLE
#undef END
+#undef TRIGRAPH_MAP
/* Given a colon-separated list of file names PATH,
add all the names to the search path for include files. */
static void
-path_include (pfile, pend, list, path)
+path_include (pfile, list, path)
cpp_reader *pfile;
- struct cpp_pending *pend;
char *list;
int path;
{
name[q - p] = 0;
}
- append_include_chain (pfile, pend, name, path, 0);
+ append_include_chain (pfile, name, path, 0);
/* Advance past this name. */
if (*q == 0)
/* Append DIR to include path PATH. DIR must be permanently allocated
and writable. */
static void
-append_include_chain (pfile, pend, dir, path, cxx_aware)
+append_include_chain (pfile, dir, path, cxx_aware)
cpp_reader *pfile;
- struct cpp_pending *pend;
char *dir;
int path;
int cxx_aware;
{
+ struct cpp_pending *pend = CPP_OPTION (pfile, pending);
struct file_name_list *new;
struct stat st;
unsigned int len;
}
}
+/* Handle a duplicated include path. PREV is the link in the chain
+ before the duplicate. The duplicate is removed from the chain and
+ freed. Returns PREV. */
+struct file_name_list *
+remove_dup_dir (pfile, prev)
+ cpp_reader *pfile;
+ struct file_name_list *prev;
+{
+ struct file_name_list *cur = prev->next;
+
+ if (CPP_OPTION (pfile, verbose))
+ fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"), cur->name);
+
+ prev->next = cur->next;
+ free (cur->name);
+ free (cur);
+
+ return prev;
+}
+
+/* Remove duplicate directories from a chain. Returns the tail of the
+ chain, or NULL if the chain is empty. This algorithm is quadratic
+ in the number of -I switches, which is acceptable since there
+ aren't usually that many of them. */
+struct file_name_list *
+remove_dup_dirs (pfile, head)
+ cpp_reader *pfile;
+ struct file_name_list *head;
+{
+ struct file_name_list *prev = NULL, *cur, *other;
+
+ for (cur = head; cur; cur = cur->next)
+ {
+ for (other = head; other != cur; other = other->next)
+ if (INO_T_EQ (cur->ino, other->ino) && cur->dev == other->dev)
+ {
+ cur = remove_dup_dir (pfile, prev);
+ break;
+ }
+ prev = cur;
+ }
+
+ return prev;
+}
+
/* Merge the four include chains together in the order quote, bracket,
system, after. Remove duplicate dirs (as determined by
INO_T_EQ()). The system_include and after_include chains are never
merge_include_chains (pfile)
cpp_reader *pfile;
{
- struct file_name_list *prev, *cur, *other;
- struct file_name_list *quote, *brack, *systm, *after;
- struct file_name_list *qtail, *btail, *stail, *atail;
+ struct file_name_list *quote, *brack, *systm, *qtail;
struct cpp_pending *pend = CPP_OPTION (pfile, pending);
- qtail = pend->quote_tail;
- btail = pend->brack_tail;
- stail = pend->systm_tail;
- atail = pend->after_tail;
-
quote = pend->quote_head;
brack = pend->brack_head;
systm = pend->systm_head;
- after = pend->after_head;
+ qtail = pend->quote_tail;
- /* Paste together bracket, system, and after include chains. */
- if (stail)
- stail->next = after;
+ /* Paste together bracket, system, and after include chains. */
+ if (systm)
+ pend->systm_tail->next = pend->after_head;
else
- systm = after;
- if (btail)
- btail->next = systm;
+ systm = pend->after_head;
+
+ if (brack)
+ pend->brack_tail->next = systm;
else
brack = systm;
- /* This is a bit tricky.
- First we drop dupes from the quote-include list.
- Then we drop dupes from the bracket-include list.
- Finally, if qtail and brack are the same directory,
- we cut out qtail.
+ /* This is a bit tricky. First we drop dupes from the quote-include
+ list. Then we drop dupes from the bracket-include list.
+ Finally, if qtail and brack are the same directory, we cut out
+ brack.
We can't just merge the lists and then uniquify them because
then we may lose directories from the <> search path that should
be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
- -Ibar -I- -Ifoo -Iquux.
+ -Ibar -I- -Ifoo -Iquux. */
- Note that this algorithm is quadratic in the number of -I switches,
- which is acceptable since there aren't usually that many of them. */
-
- for (cur = quote, prev = NULL; cur; cur = cur->next)
- {
- for (other = quote; other != cur; other = other->next)
- if (INO_T_EQ (cur->ino, other->ino)
- && cur->dev == other->dev)
- {
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"),
- cur->name);
-
- prev->next = cur->next;
- free (cur->name);
- free (cur);
- cur = prev;
- break;
- }
- prev = cur;
- }
- qtail = prev;
-
- for (cur = brack; cur; cur = cur->next)
- {
- for (other = brack; other != cur; other = other->next)
- if (INO_T_EQ (cur->ino, other->ino)
- && cur->dev == other->dev)
- {
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"),
- cur->name);
-
- prev->next = cur->next;
- free (cur->name);
- free (cur);
- cur = prev;
- break;
- }
- prev = cur;
- }
+ remove_dup_dirs (pfile, brack);
+ qtail = remove_dup_dirs (pfile, quote);
if (quote)
{
- if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
- {
- if (quote == qtail)
- {
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"),
- quote->name);
+ qtail->next = brack;
- free (quote->name);
- free (quote);
- quote = brack;
- }
- else
- {
- cur = quote;
- while (cur->next != qtail)
- cur = cur->next;
- cur->next = brack;
- if (CPP_OPTION (pfile, verbose))
- fprintf (stderr, _("ignoring duplicate directory \"%s\"\n"),
- qtail->name);
-
- free (qtail->name);
- free (qtail);
- }
- }
- else
- qtail->next = brack;
+ /* If brack == qtail, remove brack as it's simpler. */
+ if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
+ brack = remove_dup_dir (pfile, qtail);
}
else
quote = brack;
CPP_OPTION (pfile, bracket_include) = brack;
}
+/* cpp_init initializes library global state. It might not need to do
+ anything depending on the platform and compiler, so we have a static
+ flag to make sure it gets called before cpp_reader_init. */
+
+static int cpp_init_completed = 0;
-/* Initialize a cpp_reader structure. */
void
-cpp_reader_init (pfile)
- cpp_reader *pfile;
+cpp_init ()
{
#ifdef HOST_EBCDIC
- sort_options ();
+ /* For non-ASCII hosts, the cl_options array needs to be sorted at
+ runtime. */
+ qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
#endif
- memset ((char *) pfile, 0, sizeof (cpp_reader));
+ /* Set up the trigraph map and the IStable. These don't need to do
+ anything if we were compiled with a compiler that supports C99
+ designated initializers. */
+ init_trigraph_map ();
+ init_IStable ();
- pfile->token_buffer_size = 200;
- pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size);
- CPP_SET_WRITTEN (pfile, 0);
+ cpp_init_completed = 1;
+}
+
+/* Initialize a cpp_reader structure. */
+void
+cpp_reader_init (pfile)
+ cpp_reader *pfile;
+{
+ memset ((char *) pfile, 0, sizeof (cpp_reader));
CPP_OPTION (pfile, dollars_in_ident) = 1;
CPP_OPTION (pfile, cplusplus_comments) = 1;
CPP_OPTION (pfile, pending) =
(struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
+ /* If cpp_init hasn't been called, generate a fatal error (by hand)
+ and call it here. */
+ if (!cpp_init_completed)
+ {
+ fputs ("cpp_reader_init: internal error: cpp_init not called.\n", stderr);
+ pfile->errors = CPP_FATAL_LIMIT;
+ cpp_init ();
+ }
+
_cpp_init_macros (pfile);
_cpp_init_stacks (pfile);
_cpp_init_includes (pfile);
+ _cpp_init_internal_pragmas (pfile);
}
/* Initialize a cpp_printer structure. As a side effect, open the
cpp_cleanup (pfile)
cpp_reader *pfile;
{
+ struct file_name_list *dir, *next;
+
while (CPP_BUFFER (pfile) != NULL)
cpp_pop_buffer (pfile);
- if (pfile->token_buffer)
- {
- free (pfile->token_buffer);
- pfile->token_buffer = NULL;
- }
-
if (pfile->deps)
deps_free (pfile->deps);
_cpp_cleanup_includes (pfile);
_cpp_cleanup_stacks (pfile);
_cpp_cleanup_macros (pfile);
+
+ for (dir = CPP_OPTION (pfile, quote_include); dir; dir = next)
+ {
+ next = dir->next;
+ free (dir->name);
+ free (dir);
+ }
}
#ifndef NO_BUILTIN_WCHAR_TYPE
C("__WCHAR_TYPE__", WCHAR_TYPE),
#endif
+#ifndef NO_BUILTIN_WINT_TYPE
+ C("__WINT_TYPE__", WINT_TYPE),
+#endif
/* Named operators known to the preprocessor. These cannot be #defined
and always have their stated meaning. They are treated like normal
cpp_reader *pfile;
{
const struct builtin *b;
+
for(b = builtin_array; b < builtin_array_end; b++)
{
if (b->flags & CPLUS && ! CPP_OPTION (pfile, cplusplus))
if (b->flags & VERS)
{
- /* Allocate enough space for 'name="value"\0'. */
- str = xmalloc (b->len + strlen (version_string) + 4);
- sprintf (str, "%s=\"%s\"", b->name, version_string);
+ /* Allocate enough space for 'name "value"\n\0'. */
+ str = alloca (b->len + strlen (version_string) + 5);
+ sprintf (str, "%s \"%s\"\n", b->name, version_string);
}
else
{
if (b->flags & ULP)
- val = user_label_prefix;
+ val = CPP_OPTION (pfile, user_label_prefix);
else
val = b->value;
- /* Allocate enough space for "name=value\0". */
- str = xmalloc (b->len + strlen (val) + 2);
- sprintf(str, "%s=%s", b->name, val);
+ /* Allocate enough space for "name value\n\0". */
+ str = alloca (b->len + strlen (val) + 3);
+ sprintf(str, "%s %s\n", b->name, val);
}
- cpp_define (pfile, str);
+
+ _cpp_define_builtin (pfile, str);
}
else
{
GET_ENV_PATH_LIST (path, "CPATH");
if (path != 0 && *path != 0)
- path_include (pfile, CPP_OPTION (pfile, pending), path, BRACKET);
+ path_include (pfile, path, BRACKET);
switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
{
break;
}
if (path != 0 && *path != 0)
- path_include (pfile, CPP_OPTION (pfile, pending), path, SYSTEM);
+ path_include (pfile, path, SYSTEM);
/* Search "translated" versions of GNU directories.
These have /usr/local/lib/gcc... replaced by specd_prefix. */
&& !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
{
/* Does this dir start with the prefix? */
- if (!strncmp (p->fname, default_prefix, default_len))
+ if (!memcmp (p->fname, default_prefix, default_len))
{
/* Yes; change prefix and add to search list. */
int flen = strlen (p->fname);
p->fname + default_len,
flen - default_len + 1);
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- str, SYSTEM, p->cxx_aware);
+ append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
}
}
}
{
/* XXX Potential memory leak! */
char *str = xstrdup (update_path (p->fname, p->component));
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- str, SYSTEM, p->cxx_aware);
+ append_include_chain (pfile, str, SYSTEM, p->cxx_aware);
}
}
}
if (CPP_OPTION (pfile, cplusplus))
CPP_OPTION (pfile, warn_traditional) = 0;
- /* Do not warn about illegal token pasting if -lang-asm. */
+ /* Do not warn about invalid token pasting if -lang-asm. */
if (CPP_OPTION (pfile, lang_asm))
CPP_OPTION (pfile, warn_paste) = 0;
/* Set this if it hasn't been set already. */
- if (user_label_prefix == NULL)
- user_label_prefix = USER_LABEL_PREFIX;
+ if (CPP_OPTION (pfile, user_label_prefix) == NULL)
+ CPP_OPTION (pfile, user_label_prefix) = USER_LABEL_PREFIX;
/* Figure out if we need to save function macro parameter spellings.
We don't use CPP_PEDANTIC() here because that depends on whether
|| CPP_OPTION (pfile, dump_macros) == dump_definitions
|| CPP_OPTION (pfile, dump_macros) == dump_only;
- /* Set up the IStable. This doesn't do anything if we were compiled
- with a compiler that supports C99 designated initializers. */
- init_IStable ();
-
/* Set up the tables used by read_and_prescan. */
_cpp_init_input_buffer (pfile);
initialize_dependency_output (pfile);
- /* -D and friends may produce output, which should be identified
- as line 0. */
-
- CPP_BUFFER (pfile)->lineno = 0;
- if (print)
- {
- print->last_fname = CPP_BUFFER (pfile)->nominal_fname;
- print->last_id = pfile->include_depth;
- print->written = CPP_WRITTEN (pfile);
- print->lineno = 0;
- }
-
/* Install __LINE__, etc. */
initialize_builtins (pfile);
}
pfile->done_initializing = 1;
- /* Now flush any output recorded during initialization, and advance
- to line 1 of the main input file. */
- CPP_BUFFER (pfile)->lineno = 1;
-
- if (print && ! CPP_OPTION (pfile, no_output))
- cpp_output_tokens (pfile, print, 1);
+ /* We start at line 1 of the main input file. */
+ if (print)
+ {
+ print->last_fname = CPP_BUFFER (pfile)->nominal_fname;
+ print->lineno = 1;
+ }
/* The -imacros files can be scanned now, but the -include files
have to be pushed onto the include stack and processed later,
p = CPP_OPTION (pfile, pending)->include_head;
while (p)
{
- if (cpp_read_file (pfile, p->arg)
- && print && ! CPP_OPTION (pfile, no_output))
- cpp_output_tokens (pfile, print, 1); /* record entry to file */
+ cpp_read_file (pfile, p->arg);
q = p->next;
free (p);
p = q;
return 1;
}
-
-/* Dump out the hash table. */
-static int
-dump_macros_helper (pfile, hp)
- cpp_reader *pfile;
- cpp_hashnode *hp;
-{
- if (hp->type == T_MACRO)
- _cpp_dump_definition (pfile, hp);
- return 1;
-}
-
/* This is called at the end of preprocessing. It pops the
last buffer and writes dependency output. It should also
clear macro definitions, such that you could call cpp_start_read
}
}
- if (CPP_OPTION (pfile, dump_macros) == dump_only)
- cpp_forall_identifiers (pfile, dump_macros_helper);
-
/* Flush any pending output. */
if (print)
{
- cpp_output_tokens (pfile, print, print->lineno);
+ if (pfile->need_newline)
+ putc ('\n', print->outf);
if (ferror (print->outf) || fclose (print->outf))
cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
}
#undef DEF_OPT
#undef COMMAND_LINE_OPTIONS
-#ifdef HOST_EBCDIC
-static void
-sort_options (void)
-{
- static int opts_sorted = 0;
-
- if (!opts_sorted)
- {
- opts_sorted = 1;
- /* For non-ASCII hosts, the array needs to be sorted at runtime */
- qsort (cl_options, N_OPTS, sizeof (struct cl_option), opt_comp);
- }
-}
-#endif
-
-
/* Perform a binary search to find which, if any, option the given
command-line matches. Returns its index in the option array,
negative on failure. Complications arise since some options can be
md = (mn + mx) / 2;
opt_len = cl_options[md].opt_len;
- comp = strncmp (input, cl_options[md].opt_text, opt_len);
+ comp = memcmp (input, cl_options[md].opt_text, opt_len);
if (comp > 0)
mn = md + 1;
for (; mn < N_OPTS; mn++)
{
opt_len = cl_options[mn].opt_len;
- if (strncmp (input, cl_options[mn].opt_text, opt_len))
+ if (memcmp (input, cl_options[mn].opt_text, opt_len))
break;
if (input[opt_len] == '\0')
return mn;
case N_OPTS: /* shut GCC up */
break;
case OPT_fleading_underscore:
- user_label_prefix = "_";
+ CPP_OPTION (pfile, user_label_prefix) = "_";
break;
case OPT_fno_leading_underscore:
- user_label_prefix = "";
+ CPP_OPTION (pfile, user_label_prefix) = "";
break;
case OPT_fpreprocessed:
CPP_OPTION (pfile, preprocessed) = 1;
CPP_OPTION (pfile, c99) = 1;
CPP_OPTION (pfile, digraphs) = 1;
CPP_OPTION (pfile, objc) = 0;
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STDC_VERSION__=199901L", cpp_define);
+ new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
break;
case OPT_std_iso9899_199409:
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STDC_VERSION__=199409L", cpp_define);
+ new_pending_directive (pend, "__STDC_VERSION__=199409L", cpp_define);
/* Fall through */
case OPT_std_iso9899_1990:
case OPT_std_c89:
CPP_OPTION (pfile, objc) = 0;
CPP_OPTION (pfile, digraphs) = 1;
CPP_OPTION (pfile, trigraphs) = 1;
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STRICT_ANSI__", cpp_define);
- new_pending_directive (CPP_OPTION (pfile, pending),
- "__STDC_VERSION__=199901L", cpp_define);
+ new_pending_directive (pend, "__STRICT_ANSI__", cpp_define);
+ new_pending_directive (pend, "__STDC_VERSION__=199901L", cpp_define);
break;
case OPT_o:
if (CPP_OPTION (pfile, out_fname) != NULL)
{
struct pending_option *o1, *o2;
- o1 = CPP_OPTION (pfile, pending)->directive_head;
+ o1 = pend->directive_head;
while (o1)
{
o2 = o1->next;
free (o1);
o1 = o2;
}
- CPP_OPTION (pfile, pending)->directive_head = NULL;
- CPP_OPTION (pfile, pending)->directive_tail = NULL;
+ pend->directive_head = NULL;
+ pend->directive_tail = NULL;
}
else
- new_pending_directive (CPP_OPTION (pfile, pending),
- arg + 1, cpp_unassert);
+ new_pending_directive (pend, arg + 1, cpp_unassert);
}
else
- new_pending_directive (CPP_OPTION (pfile, pending),
- arg, cpp_assert);
+ new_pending_directive (pend, arg, cpp_assert);
break;
case OPT_U:
- new_pending_directive (CPP_OPTION (pfile, pending), arg, cpp_undef);
+ new_pending_directive (pend, arg, cpp_undef);
break;
case OPT_I: /* Add directory to path for includes. */
if (!strcmp (arg, "-"))
the default setup; -I. uses the compiler's working dir.) */
if (! CPP_OPTION (pfile, ignore_srcdir))
{
- struct cpp_pending *pend = CPP_OPTION (pfile, pending);
pend->quote_head = pend->brack_head;
pend->quote_tail = pend->brack_tail;
pend->brack_head = 0;
}
}
else
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- xstrdup (arg), BRACKET, 0);
+ append_include_chain (pfile, xstrdup (arg), BRACKET, 0);
break;
case OPT_isystem:
/* Add directory to beginning of system include path, as a system
include directory. */
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- xstrdup (arg), SYSTEM, 0);
+ append_include_chain (pfile, xstrdup (arg), SYSTEM, 0);
break;
case OPT_include:
{
/* This list has to be built in reverse order so that
when cpp_start_read pushes all the -include files onto
the buffer stack, they will be scanned in forward order. */
- o->next = CPP_OPTION (pfile, pending)->include_head;
- CPP_OPTION (pfile, pending)->include_head = o;
+ o->next = pend->include_head;
+ pend->include_head = o;
}
break;
case OPT_imacros:
o->arg = arg;
o->next = NULL;
- APPEND (CPP_OPTION (pfile, pending), imacros, o);
+ APPEND (pend, imacros, o);
}
break;
case OPT_iwithprefix:
else
fname = xstrdup (arg);
- append_include_chain (pfile, CPP_OPTION (pfile, pending), fname,
+ append_include_chain (pfile, fname,
opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
}
break;
case OPT_idirafter:
/* Add directory to end of path for includes. */
- append_include_chain (pfile, CPP_OPTION (pfile, pending),
- xstrdup (arg), AFTER, 0);
+ append_include_chain (pfile, xstrdup (arg), AFTER, 0);
break;
case OPT_W:
/* Silently ignore unrecognised options */
OSDN Git Service
