This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[gomp] rename c_lex to pragma_lex
- From: Richard Henderson <rth at redhat dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Sun, 9 Oct 2005 21:01:58 -0700
- Subject: [gomp] rename c_lex to pragma_lex
A name change to emphasize the fact that this function is only used
by the pragma parsing routines.
r~
* c-lex.c (pragma_lex): Rename from c_lex.
* c-pch.c, c-pragma.c, c-pragma.h, config/darwin-c.c, config/sol2-c.c,
config/c4x/c4x-c.c, config/ia64/ia64-c.c, config/m32c/m32c-pragma.c,
config/rs6000/rs6000-c.c, config/v850/v850-c.c: Update to match.
cp/
* lex.c (parse_strconst_pragma): Update for c_lex name change.
(handle_pragma_java_exceptions): Likewise.
* parser.c (cp_lexer_new_main): Likewise.
Index: c-lex.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-lex.c,v
retrieving revision 1.249.4.4
diff -u -p -r1.249.4.4 c-lex.c
--- c-lex.c 29 Sep 2005 09:04:51 -0000 1.249.4.4
+++ c-lex.c 10 Oct 2005 03:55:31 -0000
@@ -485,8 +485,10 @@ c_lex_with_flags (tree *value, location_
return type;
}
+/* The interface the pragma parsers have to the lexer. */
+
enum cpp_ttype
-c_lex (tree *value)
+pragma_lex (tree *value)
{
location_t loc;
return c_lex_with_flags (value, &loc, NULL);
Index: c-pch.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-pch.c,v
retrieving revision 1.32.4.1
diff -u -p -r1.32.4.1 c-pch.c
--- c-pch.c 6 Jul 2005 17:37:37 -0000 1.32.4.1
+++ c-pch.c 10 Oct 2005 03:55:32 -0000
@@ -447,7 +447,7 @@ c_common_pch_pragma (cpp_reader *pfile)
const char *name;
int fd;
- if (c_lex (&name_t) != CPP_STRING)
+ if (pragma_lex (&name_t) != CPP_STRING)
{
error ("malformed #pragma GCC pch_preprocess, ignored");
return;
Index: c-pragma.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-pragma.c,v
retrieving revision 1.87.4.3
diff -u -p -r1.87.4.3 c-pragma.c
--- c-pragma.c 29 Sep 2005 09:04:52 -0000 1.87.4.3
+++ c-pragma.c 10 Oct 2005 03:55:32 -0000
@@ -147,10 +147,10 @@ handle_pragma_pack (cpp_reader * ARG_UNU
enum cpp_ttype token;
enum { set, push, pop } action;
- if (c_lex (&x) != CPP_OPEN_PAREN)
+ if (pragma_lex (&x) != CPP_OPEN_PAREN)
GCC_BAD ("missing %<(%> after %<#pragma pack%> - ignored");
- token = c_lex (&x);
+ token = pragma_lex (&x);
if (token == CPP_CLOSE_PAREN)
{
action = set;
@@ -160,7 +160,7 @@ handle_pragma_pack (cpp_reader * ARG_UNU
{
align = TREE_INT_CST_LOW (x);
action = set;
- if (c_lex (&x) != CPP_CLOSE_PAREN)
+ if (pragma_lex (&x) != CPP_CLOSE_PAREN)
GCC_BAD ("malformed %<#pragma pack%> - ignored");
}
else if (token == CPP_NAME)
@@ -179,9 +179,9 @@ handle_pragma_pack (cpp_reader * ARG_UNU
else
GCC_BAD2 ("unknown action %qs for %<#pragma pack%> - ignored", op);
- while ((token = c_lex (&x)) == CPP_COMMA)
+ while ((token = pragma_lex (&x)) == CPP_COMMA)
{
- token = c_lex (&x);
+ token = pragma_lex (&x);
if (token == CPP_NAME && id == 0)
{
id = x;
@@ -203,7 +203,7 @@ handle_pragma_pack (cpp_reader * ARG_UNU
else
GCC_BAD ("malformed %<#pragma pack%> - ignored");
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of %<#pragma pack%>");
if (flag_pack_struct)
@@ -333,14 +333,14 @@ handle_pragma_weak (cpp_reader * ARG_UNU
value = 0;
- if (c_lex (&name) != CPP_NAME)
+ if (pragma_lex (&name) != CPP_NAME)
GCC_BAD ("malformed #pragma weak, ignored");
- t = c_lex (&x);
+ t = pragma_lex (&x);
if (t == CPP_EQ)
{
- if (c_lex (&value) != CPP_NAME)
+ if (pragma_lex (&value) != CPP_NAME)
GCC_BAD ("malformed #pragma weak, ignored");
- t = c_lex (&x);
+ t = pragma_lex (&x);
}
if (t != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of %<#pragma weak%>");
@@ -410,11 +410,11 @@ handle_pragma_redefine_extname (cpp_read
tree oldname, newname, decl, x;
enum cpp_ttype t;
- if (c_lex (&oldname) != CPP_NAME)
+ if (pragma_lex (&oldname) != CPP_NAME)
GCC_BAD ("malformed #pragma redefine_extname, ignored");
- if (c_lex (&newname) != CPP_NAME)
+ if (pragma_lex (&newname) != CPP_NAME)
GCC_BAD ("malformed #pragma redefine_extname, ignored");
- t = c_lex (&x);
+ t = pragma_lex (&x);
if (t != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of %<#pragma redefine_extname%>");
@@ -480,9 +480,9 @@ handle_pragma_extern_prefix (cpp_reader
tree prefix, x;
enum cpp_ttype t;
- if (c_lex (&prefix) != CPP_STRING)
+ if (pragma_lex (&prefix) != CPP_STRING)
GCC_BAD ("malformed #pragma extern_prefix, ignored");
- t = c_lex (&x);
+ t = pragma_lex (&x);
if (t != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of %<#pragma extern_prefix%>");
@@ -603,7 +603,7 @@ handle_pragma_visibility (cpp_reader *du
enum { bad, push, pop } action = bad;
static VEC (visibility, heap) *visstack;
- token = c_lex (&x);
+ token = pragma_lex (&x);
if (token == CPP_NAME)
{
const char *op = IDENTIFIER_POINTER (x);
@@ -631,9 +631,9 @@ handle_pragma_visibility (cpp_reader *du
}
else
{
- if (c_lex (&x) != CPP_OPEN_PAREN)
+ if (pragma_lex (&x) != CPP_OPEN_PAREN)
GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored");
- token = c_lex (&x);
+ token = pragma_lex (&x);
if (token != CPP_NAME)
{
GCC_BAD ("malformed #pragma GCC visibility push");
@@ -657,11 +657,11 @@ handle_pragma_visibility (cpp_reader *du
}
visibility_options.inpragma = 1;
}
- if (c_lex (&x) != CPP_CLOSE_PAREN)
+ if (pragma_lex (&x) != CPP_CLOSE_PAREN)
GCC_BAD ("missing %<(%> after %<#pragma GCC visibility push%> - ignored");
}
}
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of %<#pragma GCC visibility%>");
}
Index: c-pragma.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-pragma.h,v
retrieving revision 1.47.8.1
diff -u -p -r1.47.8.1 c-pragma.h
--- c-pragma.h 6 Jul 2005 17:37:38 -0000 1.47.8.1
+++ c-pragma.h 10 Oct 2005 03:55:32 -0000
@@ -64,7 +64,11 @@ extern void maybe_apply_pending_pragma_w
extern tree maybe_apply_renaming_pragma (tree, tree);
extern void add_to_renaming_pragma_list (tree, tree);
-extern enum cpp_ttype c_lex (tree *);
+extern enum cpp_ttype pragma_lex (tree *);
+
+/* This is not actually available to pragma parsers. It's merely a
+ convenient location to declare this function for c-lex, after
+ having enum cpp_ttype declared. */
extern enum cpp_ttype c_lex_with_flags (tree *, location_t *, unsigned char *);
/* If 1, then lex strings into the execution character set.
Index: config/darwin-c.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/darwin-c.c,v
retrieving revision 1.20.4.2
diff -u -p -r1.20.4.2 darwin-c.c
--- config/darwin-c.c 12 Jul 2005 14:21:11 -0000 1.20.4.2
+++ config/darwin-c.c 10 Oct 2005 03:55:33 -0000
@@ -101,17 +101,17 @@ darwin_pragma_options (cpp_reader *pfile
const char *arg;
tree t, x;
- if (c_lex (&t) != CPP_NAME)
+ if (pragma_lex (&t) != CPP_NAME)
BAD ("malformed '#pragma options', ignoring");
arg = IDENTIFIER_POINTER (t);
if (strcmp (arg, "align"))
BAD ("malformed '#pragma options', ignoring");
- if (c_lex (&t) != CPP_EQ)
+ if (pragma_lex (&t) != CPP_EQ)
BAD ("malformed '#pragma options', ignoring");
- if (c_lex (&t) != CPP_NAME)
+ if (pragma_lex (&t) != CPP_NAME)
BAD ("malformed '#pragma options', ignoring");
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (0, "junk at end of '#pragma options'");
arg = IDENTIFIER_POINTER (t);
@@ -133,19 +133,19 @@ darwin_pragma_unused (cpp_reader *pfile
tree decl, x;
int tok;
- if (c_lex (&x) != CPP_OPEN_PAREN)
+ if (pragma_lex (&x) != CPP_OPEN_PAREN)
BAD ("missing '(' after '#pragma unused', ignoring");
while (1)
{
- tok = c_lex (&decl);
+ tok = pragma_lex (&decl);
if (tok == CPP_NAME && decl)
{
tree local = lookup_name (decl);
if (local && (TREE_CODE (local) == PARM_DECL
|| TREE_CODE (local) == VAR_DECL))
TREE_USED (local) = 1;
- tok = c_lex (&x);
+ tok = pragma_lex (&x);
if (tok != CPP_COMMA)
break;
}
@@ -154,7 +154,7 @@ darwin_pragma_unused (cpp_reader *pfile
if (tok != CPP_CLOSE_PAREN)
BAD ("missing ')' after '#pragma unused', ignoring");
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (0, "junk at end of '#pragma unused'");
}
Index: config/sol2-c.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/sol2-c.c,v
retrieving revision 1.8.4.1
diff -u -p -r1.8.4.1 sol2-c.c
--- config/sol2-c.c 6 Jul 2005 17:44:06 -0000 1.8.4.1
+++ config/sol2-c.c 10 Oct 2005 03:55:33 -0000
@@ -88,8 +88,8 @@ solaris_pragma_align (cpp_reader *pfile
enum cpp_ttype ttype;
HOST_WIDE_INT low;
- if (c_lex (&x) != CPP_NUMBER
- || c_lex (&t) != CPP_OPEN_PAREN)
+ if (pragma_lex (&x) != CPP_NUMBER
+ || pragma_lex (&t) != CPP_OPEN_PAREN)
{
warning (0, "malformed %<#pragma align%>, ignoring");
return;
@@ -104,7 +104,7 @@ solaris_pragma_align (cpp_reader *pfile
return;
}
- ttype = c_lex (&t);
+ ttype = pragma_lex (&t);
if (ttype != CPP_NAME)
{
warning (0, "malformed %<#pragma align%>, ignoring");
@@ -121,10 +121,10 @@ solaris_pragma_align (cpp_reader *pfile
solaris_pending_aligns = tree_cons (t, build_tree_list (NULL, x),
solaris_pending_aligns);
- ttype = c_lex (&t);
+ ttype = pragma_lex (&t);
if (ttype == CPP_COMMA)
{
- ttype = c_lex (&t);
+ ttype = pragma_lex (&t);
if (ttype != CPP_NAME)
{
warning (0, "malformed %<#pragma align%>");
@@ -133,7 +133,7 @@ solaris_pragma_align (cpp_reader *pfile
}
else if (ttype == CPP_CLOSE_PAREN)
{
- if (c_lex (&t) != CPP_EOF)
+ if (pragma_lex (&t) != CPP_EOF)
warning (0, "junk at end of %<#pragma align%>");
return;
}
@@ -153,13 +153,13 @@ solaris_pragma_init (cpp_reader *pfile A
tree t;
enum cpp_ttype ttype;
- if (c_lex (&t) != CPP_OPEN_PAREN)
+ if (pragma_lex (&t) != CPP_OPEN_PAREN)
{
warning (0, "malformed %<#pragma init%>, ignoring");
return;
}
- ttype = c_lex (&t);
+ ttype = pragma_lex (&t);
if (ttype != CPP_NAME)
{
warning (0, "malformed %<#pragma init%>, ignoring");
@@ -179,10 +179,10 @@ solaris_pragma_init (cpp_reader *pfile A
else
solaris_pending_inits = tree_cons (t, NULL, solaris_pending_inits);
- ttype = c_lex (&t);
+ ttype = pragma_lex (&t);
if (ttype == CPP_COMMA)
{
- ttype = c_lex (&t);
+ ttype = pragma_lex (&t);
if (ttype != CPP_NAME)
{
warning (0, "malformed %<#pragma init%>");
@@ -191,7 +191,7 @@ solaris_pragma_init (cpp_reader *pfile A
}
else if (ttype == CPP_CLOSE_PAREN)
{
- if (c_lex (&t) != CPP_EOF)
+ if (pragma_lex (&t) != CPP_EOF)
warning (0, "junk at end of %<#pragma init%>");
return;
}
@@ -211,13 +211,13 @@ solaris_pragma_fini (cpp_reader *pfile A
tree t;
enum cpp_ttype ttype;
- if (c_lex (&t) != CPP_OPEN_PAREN)
+ if (pragma_lex (&t) != CPP_OPEN_PAREN)
{
warning (0, "malformed %<#pragma fini%>, ignoring");
return;
}
- ttype = c_lex (&t);
+ ttype = pragma_lex (&t);
if (ttype != CPP_NAME)
{
warning (0, "malformed %<#pragma fini%>, ignoring");
@@ -237,10 +237,10 @@ solaris_pragma_fini (cpp_reader *pfile A
else
solaris_pending_finis = tree_cons (t, NULL, solaris_pending_finis);
- ttype = c_lex (&t);
+ ttype = pragma_lex (&t);
if (ttype == CPP_COMMA)
{
- ttype = c_lex (&t);
+ ttype = pragma_lex (&t);
if (ttype != CPP_NAME)
{
warning (0, "malformed %<#pragma fini%>");
@@ -249,7 +249,7 @@ solaris_pragma_fini (cpp_reader *pfile A
}
else if (ttype == CPP_CLOSE_PAREN)
{
- if (c_lex (&t) != CPP_EOF)
+ if (pragma_lex (&t) != CPP_EOF)
warning (0, "junk at end of %<#pragma fini%>");
return;
}
Index: config/c4x/c4x-c.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/c4x/c4x-c.c,v
retrieving revision 1.8.4.2
diff -u -p -r1.8.4.2 c4x-c.c
--- config/c4x/c4x-c.c 28 Jul 2005 19:31:11 -0000 1.8.4.2
+++ config/c4x/c4x-c.c 10 Oct 2005 03:55:33 -0000
@@ -68,25 +68,25 @@ c4x_parse_pragma (name, func, sect)
{
tree f, s, x;
- if (c_lex (&x) != CPP_OPEN_PAREN)
+ if (pragma_lex (&x) != CPP_OPEN_PAREN)
BAD ("missing '(' after '#pragma %s' - ignored", name);
- if (c_lex (&f) != CPP_NAME)
+ if (pragma_lex (&f) != CPP_NAME)
BAD ("missing function name in '#pragma %s' - ignored", name);
if (sect)
{
- if (c_lex (&x) != CPP_COMMA)
+ if (pragma_lex (&x) != CPP_COMMA)
BAD ("malformed '#pragma %s' - ignored", name);
- if (c_lex (&s) != CPP_STRING)
+ if (pragma_lex (&s) != CPP_STRING)
BAD ("missing section name in '#pragma %s' - ignored", name);
*sect = s;
}
- if (c_lex (&x) != CPP_CLOSE_PAREN)
+ if (pragma_lex (&x) != CPP_CLOSE_PAREN)
BAD ("missing ')' for '#pragma %s' - ignored", name);
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of '#pragma %s'", name);
*func = f;
Index: config/ia64/ia64-c.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/ia64/ia64-c.c,v
retrieving revision 1.9.4.2
diff -u -p -r1.9.4.2 ia64-c.c
--- config/ia64/ia64-c.c 28 Jul 2005 19:31:24 -0000 1.9.4.2
+++ config/ia64/ia64-c.c 10 Oct 2005 03:55:33 -0000
@@ -40,13 +40,13 @@ ia64_hpux_handle_builtin_pragma (cpp_rea
enum cpp_ttype type;
tree x;
- type = c_lex (&x);
+ type = pragma_lex (&x);
while (type == CPP_NAME)
{
ia64_hpux_add_pragma_builtin (x);
- type = c_lex (&x);
+ type = pragma_lex (&x);
if (type == CPP_COMMA)
- type = c_lex (&x);
+ type = pragma_lex (&x);
}
if (type != CPP_EOF)
warning (OPT_Wpragmas, "malformed #pragma builtin");
Index: config/m32c/m32c-pragma.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/m32c/m32c-pragma.c,v
retrieving revision 1.1.4.1
diff -u -p -r1.1.4.1 m32c-pragma.c
--- config/m32c/m32c-pragma.c 28 Jul 2005 19:31:31 -0000 1.1.4.1
+++ config/m32c/m32c-pragma.c 10 Oct 2005 03:55:33 -0000
@@ -52,14 +52,14 @@ m32c_pragma_memregs (cpp_reader * reader
HOST_WIDE_INT i;
static char new_number[3];
- type = c_lex (&val);
+ type = pragma_lex (&val);
if (type == CPP_NUMBER)
{
if (host_integerp (val, 1))
{
i = tree_low_cst (val, 1);
- type = c_lex (&val);
+ type = pragma_lex (&val);
if (type != CPP_EOF)
warning (0, "junk at end of #pragma GCC memregs [0..16]");
Index: config/rs6000/rs6000-c.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/rs6000/rs6000-c.c,v
retrieving revision 1.20.4.2
diff -u -p -r1.20.4.2 rs6000-c.c
--- config/rs6000/rs6000-c.c 28 Jul 2005 19:31:45 -0000 1.20.4.2
+++ config/rs6000/rs6000-c.c 10 Oct 2005 03:55:33 -0000
@@ -62,17 +62,17 @@ rs6000_pragma_longcall (cpp_reader *pfil
/* If we get here, generic code has already scanned the directive
leader and the word "longcall". */
- if (c_lex (&x) != CPP_OPEN_PAREN)
+ if (pragma_lex (&x) != CPP_OPEN_PAREN)
SYNTAX_ERROR ("missing open paren");
- if (c_lex (&n) != CPP_NUMBER)
+ if (pragma_lex (&n) != CPP_NUMBER)
SYNTAX_ERROR ("missing number");
- if (c_lex (&x) != CPP_CLOSE_PAREN)
+ if (pragma_lex (&x) != CPP_CLOSE_PAREN)
SYNTAX_ERROR ("missing close paren");
if (n != integer_zero_node && n != integer_one_node)
SYNTAX_ERROR ("number must be 0 or 1");
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of #pragma longcall");
rs6000_default_long_calls = (n == integer_one_node);
Index: config/v850/v850-c.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/config/v850/v850-c.c,v
retrieving revision 1.10.4.2
diff -u -p -r1.10.4.2 v850-c.c
--- config/v850/v850-c.c 28 Jul 2005 19:32:02 -0000 1.10.4.2
+++ config/v850/v850-c.c 10 Oct 2005 03:55:33 -0000
@@ -125,7 +125,7 @@ ghs_pragma_section (cpp_reader * pfile A
const char *sect, *alias;
enum GHS_section_kind kind;
- type = c_lex (&x);
+ type = pragma_lex (&x);
if (type == CPP_EOF && !repeat)
goto reset;
@@ -135,14 +135,14 @@ ghs_pragma_section (cpp_reader * pfile A
goto bad;
repeat = 0;
- if (c_lex (&x) != CPP_EQ)
+ if (pragma_lex (&x) != CPP_EQ)
goto bad;
- if (c_lex (&x) != CPP_NAME)
+ if (pragma_lex (&x) != CPP_NAME)
goto bad;
alias = IDENTIFIER_POINTER (x);
- type = c_lex (&x);
+ type = pragma_lex (&x);
if (type == CPP_COMMA)
repeat = 1;
else if (type != CPP_EOF)
@@ -196,7 +196,7 @@ ghs_pragma_interrupt (cpp_reader * pfile
{
tree x;
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of #pragma ghs interrupt");
mark_current_function_as_interrupt ();
@@ -207,7 +207,7 @@ ghs_pragma_starttda (cpp_reader * pfile
{
tree x;
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of #pragma ghs starttda");
push_data_area (DATA_AREA_TDA);
@@ -218,7 +218,7 @@ ghs_pragma_startsda (cpp_reader * pfile
{
tree x;
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (OPT_Wpragmas, "junk at end of #pragma ghs startsda");
push_data_area (DATA_AREA_SDA);
Index: cp/lex.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/lex.c,v
retrieving revision 1.360.4.1
diff -u -p -r1.360.4.1 lex.c
--- cp/lex.c 6 Jul 2005 17:47:16 -0000 1.360.4.1
+++ cp/lex.c 10 Oct 2005 03:55:34 -0000
@@ -460,11 +460,11 @@ parse_strconst_pragma (const char* name,
tree result, x;
enum cpp_ttype t;
- t = c_lex (&x);
+ t = pragma_lex (&x);
if (t == CPP_STRING)
{
result = x;
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (0, "junk at end of #pragma %s", name);
return result;
}
@@ -580,10 +580,10 @@ handle_pragma_implementation (cpp_reader
/* Indicate that this file uses Java-personality exception handling. */
static void
-handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED )
+handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED)
{
tree x;
- if (c_lex (&x) != CPP_EOF)
+ if (pragma_lex (&x) != CPP_EOF)
warning (0, "junk at end of #pragma GCC java_exceptions");
choose_personality_routine (lang_java);
Index: cp/parser.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/parser.c,v
retrieving revision 1.340.4.7
diff -u -p -r1.340.4.7 parser.c
--- cp/parser.c 7 Oct 2005 12:49:35 -0000 1.340.4.7
+++ cp/parser.c 10 Oct 2005 03:55:34 -0000
@@ -250,7 +250,7 @@ cp_lexer_new_main (void)
/* Tell cpplib we want CPP_PRAGMA tokens. */
/* FIXME: cpp_get_options (parse_in)->defer_pragmas = true; */
- /* Tell c_lex not to merge string constants. */
+ /* Tell c_lex_with_flags not to merge string constants. */
c_lex_return_raw_strings = true;
c_common_no_more_pch ();
@@ -293,8 +293,8 @@ cp_lexer_new_main (void)
lexer->next_token = lexer->buffer_length ? buffer : (cp_token *)&eof_token;
/* Pragma processing (via cpp_handle_deferred_pragma) may result in
- direct calls to c_lex. Those callers all expect c_lex to do
- string constant concatenation. */
+ direct calls to pragma_lex. Those callers all expect pragma_lex
+ to do string constant concatenation. */
c_lex_return_raw_strings = false;
gcc_assert (lexer->next_token->type != CPP_PURGED);