cpphash.c (_cpp_init_hashtable): Update.

	* cpphash.c (_cpp_init_hashtable): Update.
	* cpphash.h (struct spec_nodes): Remove n_L.
	* cpplex.c (_cpp_lex_direct): Check for prefix L separately.

	* Makefile.in: Update, and add c-objc-common.o dependencies.
	* c-lang.c: Remove unnecessary includes.
	(c_init): Move bulk of code to c_objc_common_init, and call it.
	(c_tree_printer, c_missing_noreturn_ok_p, c_disregard_inline_limits,
	inline_forbidden_p, c_cannot_inline_tree_fn): Move to
	c-objc-common.c.
	* c-objc-common.c: New.  Mostly pulled from c-lang.c.
	* c-tree.h (c_disregard_inline_limits, c_cannot_inline_fn,
	c_objc_common_init, c_missing_noreturn_ok_p): New.
	* toplev.c: Update comment.
	* doc/passes.texi: Update.
	* objc/ojbc-act.c (LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN,
	LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS,
	LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P): Override.
	(objc_init): Update to use c_objc_common_init.

From-SVN: r47388

10 files changed, 340 insertions, 267 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 577c2a3..f69310c 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,28 @@
+2001-11-27  Neil Booth  <neil@daikokuya.demon.co.uk>
+
+	* Makefile.in: Update, and add c-objc-common.o dependencies.
+	* c-lang.c: Remove unnecessary includes.
+	(c_init): Move bulk of code to c_objc_common_init, and call it.
+	(c_tree_printer, c_missing_noreturn_ok_p, c_disregard_inline_limits,
+	inline_forbidden_p, c_cannot_inline_tree_fn): Move to
+	c-objc-common.c.
+	* c-objc-common.c: New.  Mostly pulled from c-lang.c.
+	* c-tree.h (c_disregard_inline_limits, c_cannot_inline_fn,
+	c_objc_common_init, c_missing_noreturn_ok_p): New.
+	* toplev.c: Update comment.
+	* doc/passes.texi: Update.
+objc:
+	* ojbc-act.c (LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN,
+	LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS,
+	LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P): Override.
+	(objc_init): Update to use c_objc_common_init.
+
+2001-11-27  Neil Booth  <neil@daikokuya.demon.co.uk>
+
+	* cpphash.c (_cpp_init_hashtable): Update.
+	* cpphash.h (struct spec_nodes): Remove n_L.
+	* cpplex.c (_cpp_lex_direct): Check for prefix L separately.
+
 2001-11-17  Richard Henderson  <rth@redhat.com>
 
 	* unroll.c (loop_iterations): Move last change ...
diff --git a/gcc/c-lang.c b/gcc/c-lang.c
index 0578cb2..dceede5 100644
--- a/gcc/c-lang.c
+++ b/gcc/c-lang.c
@@ -23,33 +23,22 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "config.h"
 #include "system.h"
 #include "tree.h"
-#include "tree-inline.h"
 #include "function.h"
-#include "input.h"
 #include "toplev.h"
-#include "diagnostic.h"
-#include "output.h"
 #include "flags.h"
 #include "ggc.h"
 #include "rtl.h"
 #include "expr.h"
 #include "c-tree.h"
-#include "c-common.h"
-#include "c-lex.h"
-#include "cpplib.h"
-#include "insn-config.h"
-#include "integrate.h"
 #include "varray.h"
 #include "langhooks.h"
 #include "langhooks-def.h"
 
-static int c_tree_printer PARAMS ((output_buffer *));
-static int c_missing_noreturn_ok_p PARAMS ((tree));
 static const char *c_init PARAMS ((const char *));
 static void c_init_options PARAMS ((void));
 static void c_post_options PARAMS ((void));
-static int c_disregard_inline_limits PARAMS ((tree));
-static int c_cannot_inline_tree_fn PARAMS ((tree *));
+
+/* ### When changing hooks, consider if ObjC needs changing too!! ### */
 
 #undef LANG_HOOKS_NAME
 #define LANG_HOOKS_NAME "GNU C"
@@ -82,6 +71,8 @@ static int c_cannot_inline_tree_fn PARAMS ((tree *));
 #define LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P \
   anon_aggr_type_p
 
+/* ### When changing hooks, consider if ObjC needs changing too!! ### */
+
 /* Each front end provides its own.  */
 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
 
@@ -104,29 +95,7 @@ static const char *
 c_init (filename)
      const char *filename;
 {
-  c_init_decl_processing ();
-
-  filename = c_common_init (filename);
-
-  add_c_tree_codes ();
-
-  /* If still unspecified, make it match -std=c99
-     (allowing for -pedantic-errors).  */
-  if (mesg_implicit_function_declaration < 0)
-    {
-      if (flag_isoc99)
-	mesg_implicit_function_declaration = flag_pedantic_errors ? 2 : 1;
-      else
-	mesg_implicit_function_declaration = 0;
-    }
-
-  save_lang_status = &push_c_function_context;
-  restore_lang_status = &pop_c_function_context;
-  mark_lang_status = &mark_c_function_context;
-  lang_expand_expr = &c_expand_expr;
-  diagnostic_format_decoder (global_dc) = &c_tree_printer;
-  lang_expand_decl_stmt = &c_expand_decl_stmt;
-  lang_missing_noreturn_ok_p = &c_missing_noreturn_ok_p;
+  filename = c_objc_common_init (filename);
 
   VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
   ggc_add_tree_varray_root (&deferred_fns, 1);
@@ -305,199 +274,3 @@ finish_file ()
       }
   }
 }
-
-/* Called during diagnostic message formatting process to print a
-   source-level entity onto BUFFER.  The meaning of the format specifiers
-   is as follows:
-   %D: a general decl,
-   %F: a function declaration,
-   %T: a type.
-
-   These format specifiers form a subset of the format specifiers set used
-   by the C++ front-end.
-   Please notice when called, the `%' part was already skipped by the
-   diagnostic machinery.  */
-static int
-c_tree_printer (buffer)
-     output_buffer *buffer;
-{
-  tree t = va_arg (output_buffer_format_args (buffer), tree);
-
-  switch (*output_buffer_text_cursor (buffer))
-    {
-    case 'D':
-    case 'F':
-    case 'T':
-      {
-        const char *n = DECL_NAME (t)
-          ? (*decl_printable_name) (t, 2)
-          : "({anonymous})";
-        output_add_string (buffer, n);
-      }
-      return 1;
-
-    default:
-      return 0;
-    }
-}
-
-static int
-c_missing_noreturn_ok_p (decl)
-     tree decl;
-{
-  /* A missing noreturn is not ok for freestanding implementations and
-     ok for the `main' function in hosted implementations.  */
-  return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
-}
-
-/* We want to inline `extern inline' functions even if this would
-   violate inlining limits.  Some glibc and linux constructs depend on
-   such functions always being inlined when optimizing.  */
-
-static int
-c_disregard_inline_limits (fn)
-     tree fn;
-{
-  return DECL_DECLARED_INLINE_P (fn) && DECL_EXTERNAL (fn);
-}
-
-static tree inline_forbidden_p PARAMS ((tree *, int *, void *));
-
-static tree
-inline_forbidden_p (nodep, walk_subtrees, fn)
-     tree *nodep;
-     int *walk_subtrees ATTRIBUTE_UNUSED;
-     void *fn;
-{
-  tree node = *nodep;
-  tree t;
-
-  switch (TREE_CODE (node))
-    {
-    case CALL_EXPR:
-      t = get_callee_fndecl (node);
-
-      if (! t)
-	break;
-
-      /* We cannot inline functions that call setjmp.  */
-      if (setjmp_call_p (t))
-	return node;
-
-      switch (DECL_FUNCTION_CODE (t))
-	{
-	  /* We cannot inline functions that take a variable number of
-	     arguments.  */
-	case BUILT_IN_VARARGS_START:
-	case BUILT_IN_STDARG_START:
-#if 0
-	  /* Functions that need information about the address of the
-             caller can't (shouldn't?) be inlined.  */
-	case BUILT_IN_RETURN_ADDRESS:
-#endif
-	  return node;
-
-	default:
-	  break;
-	}
-
-      break;
-
-    case DECL_STMT:
-      /* We cannot inline functions that contain other functions.  */
-      if (TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
-	  && DECL_INITIAL (TREE_OPERAND (node, 0)))
-	return node;
-      break;
-
-    case GOTO_STMT:
-    case GOTO_EXPR:
-      t = TREE_OPERAND (node, 0);
-
-      /* We will not inline a function which uses computed goto.  The
-	 addresses of its local labels, which may be tucked into
-	 global storage, are of course not constant across
-	 instantiations, which causes unexpected behaviour.  */
-      if (TREE_CODE (t) != LABEL_DECL)
-	return node;
-
-      /* We cannot inline a nested function that jumps to a nonlocal
-         label.  */
-      if (TREE_CODE (t) == LABEL_DECL
-	  && DECL_CONTEXT (t) && DECL_CONTEXT (t) != fn)
-	return node;
-
-      break;
-
-    default:
-      break;
-    }
-
-  return NULL_TREE;
-}
-
-static int
-c_cannot_inline_tree_fn (fnp)
-     tree *fnp;
-{
-  tree fn = *fnp;
-  tree t;
-
-  if (! function_attribute_inlinable_p (fn))
-    {
-      DECL_UNINLINABLE (fn) = 1;
-      return 1;
-    }
-
-  /* If a function has pending sizes, we must not defer its
-     compilation, and we can't inline it as a tree.  */
-  if (fn == current_function_decl)
-    {
-      t = get_pending_sizes ();
-      put_pending_sizes (t);
-
-      if (t)
-	{
-	  DECL_UNINLINABLE (fn) = 1;
-	  return 1;
-	}
-    }
-
-  if (DECL_CONTEXT (fn))
-    {
-      /* If a nested function has pending sizes, we may have already
-         saved them.  */
-      if (DECL_LANG_SPECIFIC (fn)->pending_sizes)
-	{
-	  DECL_UNINLINABLE (fn) = 1;
-	  return 1;
-	}
-    }
-  else
-    {
-      /* We rely on the fact that this function is called upfront,
-	 just before we start expanding a function.  If FN is active
-	 (i.e., it's the current_function_decl or a parent thereof),
-	 we have to walk FN's saved tree.  Otherwise, we can safely
-	 assume we have done it before and, if we didn't mark it as
-	 uninlinable (in which case we wouldn't have been called), it
-	 is inlinable.  Unfortunately, this strategy doesn't work for
-	 nested functions, because they're only expanded as part of
-	 their enclosing functions, so the inlinability test comes in
-	 late.  */
-      t = current_function_decl;
-
-      while (t && t != fn)
-	t = DECL_CONTEXT (t);
-      if (! t)
-	return 0;
-    }
-    
-  if (walk_tree (&DECL_SAVED_TREE (fn), inline_forbidden_p, fn, NULL))
-    {
-      DECL_UNINLINABLE (fn) = 1;
-      return 1;
-    }
-
-  return 0;
-}
diff --git a/gcc/c-objc-common.c b/gcc/c-objc-common.c
new file mode 100644
index 0000000..be3b847
--- /dev/null
+++ b/gcc/c-objc-common.c
@@ -0,0 +1,266 @@
+/* Some code common to C and ObjC front ends.
+   Copyright (C) 2001 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING.  If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA.  */
+
+#include "config.h"
+#include "system.h"
+#include "tree.h"
+#include "rtl.h"
+#include "insn-config.h"
+#include "integrate.h"
+#include "expr.h"
+#include "c-tree.h"
+#include "function.h"
+#include "flags.h"
+#include "toplev.h"
+#include "diagnostic.h"
+#include "tree-inline.h"
+
+static int c_tree_printer PARAMS ((output_buffer *));
+static tree inline_forbidden_p PARAMS ((tree *, int *, void *));
+
+int
+c_missing_noreturn_ok_p (decl)
+     tree decl;
+{
+  /* A missing noreturn is not ok for freestanding implementations and
+     ok for the `main' function in hosted implementations.  */
+  return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
+}
+
+/* We want to inline `extern inline' functions even if this would
+   violate inlining limits.  Some glibc and linux constructs depend on
+   such functions always being inlined when optimizing.  */
+
+int
+c_disregard_inline_limits (fn)
+     tree fn;
+{
+  return DECL_DECLARED_INLINE_P (fn) && DECL_EXTERNAL (fn);
+}
+
+static tree
+inline_forbidden_p (nodep, walk_subtrees, fn)
+     tree *nodep;
+     int *walk_subtrees ATTRIBUTE_UNUSED;
+     void *fn;
+{
+  tree node = *nodep;
+  tree t;
+
+  switch (TREE_CODE (node))
+    {
+    case CALL_EXPR:
+      t = get_callee_fndecl (node);
+
+      if (! t)
+	break;
+
+      /* We cannot inline functions that call setjmp.  */
+      if (setjmp_call_p (t))
+	return node;
+
+      switch (DECL_FUNCTION_CODE (t))
+	{
+	  /* We cannot inline functions that take a variable number of
+	     arguments.  */
+	case BUILT_IN_VARARGS_START:
+	case BUILT_IN_STDARG_START:
+#if 0
+	  /* Functions that need information about the address of the
+             caller can't (shouldn't?) be inlined.  */
+	case BUILT_IN_RETURN_ADDRESS:
+#endif
+	  return node;
+
+	default:
+	  break;
+	}
+
+      break;
+
+    case DECL_STMT:
+      /* We cannot inline functions that contain other functions.  */
+      if (TREE_CODE (TREE_OPERAND (node, 0)) == FUNCTION_DECL
+	  && DECL_INITIAL (TREE_OPERAND (node, 0)))
+	return node;
+      break;
+
+    case GOTO_STMT:
+    case GOTO_EXPR:
+      t = TREE_OPERAND (node, 0);
+
+      /* We will not inline a function which uses computed goto.  The
+	 addresses of its local labels, which may be tucked into
+	 global storage, are of course not constant across
+	 instantiations, which causes unexpected behaviour.  */
+      if (TREE_CODE (t) != LABEL_DECL)
+	return node;
+
+      /* We cannot inline a nested function that jumps to a nonlocal
+         label.  */
+      if (TREE_CODE (t) == LABEL_DECL
+	  && DECL_CONTEXT (t) && DECL_CONTEXT (t) != fn)
+	return node;
+
+      break;
+
+    default:
+      break;
+    }
+
+  return NULL_TREE;
+}
+
+int
+c_cannot_inline_tree_fn (fnp)
+     tree *fnp;
+{
+  tree fn = *fnp;
+  tree t;
+
+  if (! function_attribute_inlinable_p (fn))
+    {
+      DECL_UNINLINABLE (fn) = 1;
+      return 1;
+    }
+
+  /* If a function has pending sizes, we must not defer its
+     compilation, and we can't inline it as a tree.  */
+  if (fn == current_function_decl)
+    {
+      t = get_pending_sizes ();
+      put_pending_sizes (t);
+
+      if (t)
+	{
+	  DECL_UNINLINABLE (fn) = 1;
+	  return 1;
+	}
+    }
+
+  if (DECL_CONTEXT (fn))
+    {
+      /* If a nested function has pending sizes, we may have already
+         saved them.  */
+      if (DECL_LANG_SPECIFIC (fn)->pending_sizes)
+	{
+	  DECL_UNINLINABLE (fn) = 1;
+	  return 1;
+	}
+    }
+  else
+    {
+      /* We rely on the fact that this function is called upfront,
+	 just before we start expanding a function.  If FN is active
+	 (i.e., it's the current_function_decl or a parent thereof),
+	 we have to walk FN's saved tree.  Otherwise, we can safely
+	 assume we have done it before and, if we didn't mark it as
+	 uninlinable (in which case we wouldn't have been called), it
+	 is inlinable.  Unfortunately, this strategy doesn't work for
+	 nested functions, because they're only expanded as part of
+	 their enclosing functions, so the inlinability test comes in
+	 late.  */
+      t = current_function_decl;
+
+      while (t && t != fn)
+	t = DECL_CONTEXT (t);
+      if (! t)
+	return 0;
+    }
+    
+  if (walk_tree (&DECL_SAVED_TREE (fn), inline_forbidden_p, fn, NULL))
+    {
+      DECL_UNINLINABLE (fn) = 1;
+      return 1;
+    }
+
+  return 0;
+}
+
+/* Initialization common to C and Objective-C front ends.  */
+const char *
+c_objc_common_init (filename)
+     const char *filename;
+{
+  c_init_decl_processing ();
+
+  filename = c_common_init (filename);
+
+  add_c_tree_codes ();
+
+  save_lang_status = &push_c_function_context;
+  restore_lang_status = &pop_c_function_context;
+  mark_lang_status = &mark_c_function_context;
+  lang_expand_expr = c_expand_expr;
+  lang_expand_decl_stmt = c_expand_decl_stmt;
+
+  /* These were not defined in the Objective-C front end, but I'm
+     putting them here anyway.  The diagnostic format decoder might
+     want an enhanced ObjC implementation.  */
+  diagnostic_format_decoder (global_dc) = &c_tree_printer;
+  lang_missing_noreturn_ok_p = &c_missing_noreturn_ok_p;
+
+  /* If still unspecified, make it match -std=c99
+     (allowing for -pedantic-errors).  */
+  if (mesg_implicit_function_declaration < 0)
+    {
+      if (flag_isoc99)
+	mesg_implicit_function_declaration = flag_pedantic_errors ? 2 : 1;
+      else
+	mesg_implicit_function_declaration = 0;
+    }
+
+  return filename;
+}
+
+/* Called during diagnostic message formatting process to print a
+   source-level entity onto BUFFER.  The meaning of the format specifiers
+   is as follows:
+   %D: a general decl,
+   %F: a function declaration,
+   %T: a type.
+
+   These format specifiers form a subset of the format specifiers set used
+   by the C++ front-end.
+   Please notice when called, the `%' part was already skipped by the
+   diagnostic machinery.  */
+static int
+c_tree_printer (buffer)
+     output_buffer *buffer;
+{
+  tree t = va_arg (output_buffer_format_args (buffer), tree);
+
+  switch (*output_buffer_text_cursor (buffer))
+    {
+    case 'D':
+    case 'F':
+    case 'T':
+      {
+        const char *n = DECL_NAME (t)
+          ? (*decl_printable_name) (t, 2)
+          : "({anonymous})";
+        output_add_string (buffer, n);
+      }
+      return 1;
+
+    default:
+      return 0;
+    }
+}
diff --git a/gcc/c-tree.h b/gcc/c-tree.h
index 865e734..e686ed4 100644
--- a/gcc/c-tree.h
+++ b/gcc/c-tree.h
@@ -152,6 +152,7 @@ extern int maybe_objc_comptypes                 PARAMS ((tree, tree, int));
 extern tree maybe_building_objc_message_expr    PARAMS ((void));
 extern int recognize_objc_keyword		PARAMS ((void));
 extern tree lookup_objc_ivar			PARAMS ((tree));
+
 /* in c-lang.c and objc/objc-act.c */
 extern int defer_fn				PARAMS ((tree));
 
@@ -169,6 +170,12 @@ extern void c_print_identifier			PARAMS ((FILE *, tree, int));
 extern tree build_array_declarator              PARAMS ((tree, tree, int, int));
 extern tree build_enumerator                    PARAMS ((tree, tree));
 
+/* in c-objc-common.c */
+extern int c_disregard_inline_limits		PARAMS ((tree));
+extern int c_cannot_inline_tree_fn		PARAMS ((tree *));
+extern const char *c_objc_common_init		PARAMS ((const char *));
+extern int c_missing_noreturn_ok_p		PARAMS ((tree));
+
 #define c_build_type_variant(TYPE, CONST_P, VOLATILE_P)		  \
   c_build_qualified_type (TYPE,				  \
 			  ((CONST_P) ? TYPE_QUAL_CONST : 0) |	  \
diff --git a/gcc/cpphash.c b/gcc/cpphash.c
index 1bb1275..39a3de7 100644
--- a/gcc/cpphash.c
+++ b/gcc/cpphash.c
@@ -71,7 +71,6 @@ _cpp_init_hashtable (pfile, table)
   _cpp_init_internal_pragmas (pfile);
 
   s = &pfile->spec_nodes;
-  s->n_L                = cpp_lookup (pfile, DSC("L"));
   s->n_defined		= cpp_lookup (pfile, DSC("defined"));
   s->n_true		= cpp_lookup (pfile, DSC("true"));
   s->n_false		= cpp_lookup (pfile, DSC("false"));
diff --git a/gcc/cpphash.h b/gcc/cpphash.h
index ccb9a47..2f558c6 100644
--- a/gcc/cpphash.h
+++ b/gcc/cpphash.h
@@ -159,7 +159,6 @@ struct lexer_state
 /* Special nodes - identifiers with predefined significance.  */
 struct spec_nodes
 {
-  cpp_hashnode *n_L;			/* L"str" */
   cpp_hashnode *n_defined;		/* defined operator */
   cpp_hashnode *n_true;			/* C++ keyword true */
   cpp_hashnode *n_false;		/* C++ keyword false */
diff --git a/gcc/cpplex.c b/gcc/cpplex.c
index 08223bd..dc17f63 100644
--- a/gcc/cpplex.c
+++ b/gcc/cpplex.c
@@ -978,11 +978,23 @@ _cpp_lex_direct (pfile)
       parse_number (pfile, &result->val.str, c, 0);
       break;
 
-    case '$':
-      if (!CPP_OPTION (pfile, dollars_in_ident))
-	goto random_char;
-      /* Fall through...  */
+    case 'L':
+      /* 'L' may introduce wide characters or strings.  */
+	{
+	  const unsigned char *pos = buffer->cur;
 
+	  c = get_effective_char (pfile);
+	  if (c == '\'' || c == '"')
+	    {
+	      result->type = (c == '"' ? CPP_WSTRING: CPP_WCHAR);
+	      parse_string (pfile, result, c);
+	      break;
+	    }
+	  buffer->cur = pos;
+	}
+	/* Fall through.  */
+
+    start_ident:
     case '_':
     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
     case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
@@ -990,26 +1002,15 @@ _cpp_lex_direct (pfile)
     case 's': case 't': case 'u': case 'v': case 'w': case 'x':
     case 'y': case 'z':
     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
-    case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
+    case 'G': case 'H': case 'I': case 'J': case 'K':
     case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
     case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
     case 'Y': case 'Z':
       result->type = CPP_NAME;
       result->val.node = parse_identifier (pfile);
 
-      /* 'L' may introduce wide characters or strings.  */
-      if (result->val.node == pfile->spec_nodes.n_L)
-	{
-	  c = *buffer->cur;
-	  if (c == '\'' || c == '"')
-	    {
-	      buffer->cur++;
-	      result->type = (c == '"' ? CPP_WSTRING: CPP_WCHAR);
-	      parse_string (pfile, result, c);
-	    }
-	}
       /* Convert named operators to their proper types.  */
-      else if (result->val.node->flags & NODE_OPERATOR)
+      if (result->val.node->flags & NODE_OPERATOR)
 	{
 	  result->flags |= NAMED_OP;
 	  result->type = result->val.node->value.operator;
@@ -1273,6 +1274,11 @@ _cpp_lex_direct (pfile)
       /* @ is a punctuator in Objective C.  */
     case '@': result->type = CPP_ATSIGN; break;
 
+    case '$':
+      if (CPP_OPTION (pfile, dollars_in_ident))
+	goto start_ident;
+      /* Fall through...  */
+
     random_char:
     default:
       result->type = CPP_OTHER;
diff --git a/gcc/doc/passes.texi b/gcc/doc/passes.texi
index 731a1d01..51dab87 100644
--- a/gcc/doc/passes.texi
+++ b/gcc/doc/passes.texi
@@ -83,6 +83,7 @@ The source files to parse C are
 @file{c-decl.c},
 @file{c-errors.c},
 @file{c-lang.c},
+@file{c-objc-common.c},
 @file{c-parse.in},
 @file{c-aux-info.c},
 and
diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c
index 474df1a..2e02b7c 100644
--- a/gcc/objc/objc-act.c
+++ b/gcc/objc/objc-act.c
@@ -468,6 +468,16 @@ static int print_struct_values = 0;
 #define LANG_HOOKS_PRINT_IDENTIFIER c_print_identifier
 #undef LANG_HOOKS_SET_YYDEBUG
 #define LANG_HOOKS_SET_YYDEBUG c_set_yydebug
+/* Inlining hooks same as the C front end.  */
+#undef LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN
+#define LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN \
+  c_cannot_inline_tree_fn
+#undef LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS
+#define LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS \
+  c_disregard_inline_limits
+#undef LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P
+#define LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P \
+  anon_aggr_type_p
 
 /* Each front end provides its own.  */
 const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
@@ -554,11 +564,9 @@ static const char *
 objc_init (filename)
      const char *filename;
 {
-  c_init_decl_processing ();
+  filename = c_objc_common_init (filename);
 
-  filename = c_common_init (filename);
-
-  add_c_tree_codes ();
+  decl_printable_name = objc_printable_name;
 
   /* Force the line number back to 0; check_newline will have
      raised it to 1, which will make the builtin functions appear
@@ -8087,14 +8095,6 @@ init_objc ()
   errbuf = (char *)xmalloc (BUFSIZE);
   hash_init ();
   synth_module_prologue ();
-
-  /* Change the default error function */
-  save_lang_status = &push_c_function_context;
-  restore_lang_status = &pop_c_function_context;
-  mark_lang_status = &mark_c_function_context;
-  decl_printable_name = objc_printable_name;
-  lang_expand_expr = c_expand_expr;
-  lang_expand_decl_stmt = c_expand_decl_stmt;
 }
 
 static void
diff --git a/gcc/toplev.c b/gcc/toplev.c
index e0e8a96..e2c2e25 100644
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -4988,10 +4988,7 @@ lang_independent_init ()
     = ((lang_hooks.identifier_size - sizeof (struct tree_common))
        / sizeof (tree));
 
-  /* Initialize the garbage-collector, and string pools.  FIXME: We
-     should do this later, in independent_init () when we know we
-     actually want to compile something, but cpplib currently wants to
-     use the hash table immediately in cpp_create_reader.  */
+  /* Initialize the garbage-collector, and string pools.  */
   init_ggc ();
   ggc_add_rtx_root (&stack_limit_rtx, 1);
   ggc_add_tree_root (&current_function_decl, 1);