gcc/cp/decl.c

149    that is not necessarily in scope at the moment.  */
153 /* The node that holds the "name" of the global scope.  */
159    which reside in the global scope.  The decl is stored in
181      or the inner scope popped.  These are the decls that will *not* be
186   /* True if an OpenMP structured block scope has been closed since
188      illegally exit an OpenMP scope.  */
206      defined, or the inner scope popped.  These are the decls that will
218      to the label will illegally enter a scope of the given flavor.  */
228    (Zero if we are at namespace scope, one inside the body of a
255    explicit scope qualifications.  */
270       /* If we see a specialization scope inside a parameter scope,
343 /* Exit the current scope.  */
351 /* When a label goes out of scope, check to see if that label was used
381    go out of scope.  BLOCK is the top-level block for the
438    _setjmp()/_longjmp() calls.  All variables in the current scope,
445   struct cp_binding_level *scope;
447   for (scope = current_binding_level;
448        scope && scope != enclosing_blk;
449        scope = scope->level_chain)
453       for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
457       if (scope->kind == sk_function_parms)
462 /* Update data for defined and undefined labels when leaving a scope.  */
598   /* We still support the old for-scope rules, whereby the variables
599      in a for-init statement were in scope after the for-statement
633 	  if (ob && ob->scope == current_binding_level->level_chain)
639 	       and we are leaving the `for' scope.  There's no reason to
652 	       We must pop the for-scope binding so we know what's a
678 		 its SCOPE since the scope is going away now.  */
679 	      IDENTIFIER_BINDING (name)->scope
1000       /* Need to check scope for variable declaration (VAR_DECL).
1001 	 For typedef (TYPE_DECL), scope is ignored.  */
1343 	     or type in the same scope.  */
1436 	 A namespace-name defined at global scope shall not be
1437 	 declared as the name of any other entity in any global scope
1598 	  warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
2171       /* The objects have been declared at namespace scope.  If either
2196       /* Objects declared with block scope:  */
2273   /* You can't use labels at global scope.  */
2297      this scope we can restore the old value of IDENTIFIER_TYPE_VALUE.  */
2345    the jump context; NAMES are the names in scope in LEVEL at the jump
2382 	    pedwarn ("  enters scope of non-POD %q+#D", new_decls);
2497 	pedwarn ("  enters scope of non-POD %q+#D", b);
2711   tree scope;
2730 	  && TYPE_CONTEXT (t1) == t2->scope
2757   ti.scope = FROB_CONTEXT (context);
2764   hash =  (htab_hash_pointer (ti.scope)
2775       TYPE_CONTEXT (t) = ti.scope;
2853      even if CONTEXT is a currently open scope.  */
3753    from a containing scope, shadow that tag name for the current scope
4099   /* Create a new scope to hold this declaration if necessary.
4100      Whether or not a new scope is necessary cannot be determined
4994   /* We try to defer namespace-scope static constants so that they are
5675      any access checks will be done relative to the current scope,
5676      rather than the scope of the anonymous function.  */
5991      class definition shall appear in a namespace scope enclosing
5997      namespace scope enclosing the member's class definition.  */
6144   /* If this decl has namespace scope, set that up.  */
6197 	 or enumeration declared in a local scope) shall not be used to
6378      with ordinary namespace-scope variables.  */
6387    the innermost enclosings scope.  */
6395 	     tree scope)
6402   /* Compute the scope in which to place the variable, but remember
6403      whether or not that scope was explicitly specified by the user.   */
6404   explicit_scope = scope;
6405   if (!scope)
6407       /* An explicit "extern" specifier indicates a namespace-scope
6410 	scope = current_namespace;
6412 	scope = current_scope ();
6415   if (scope
6416       && (/* If the variable is a namespace-scope variable declared in a
6418 	  (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6419 	  /* Similarly for namespace-scope variables with language linkage
6421 	  || (TREE_CODE (scope) == NAMESPACE_DECL
6424 	  || TYPE_P (scope)))
6432     DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6475 	 or enumeration declared in a local scope) shall not be used to
6615      member is a member constant.  The file-scope definition is always
6765 /* Returns the scope (if any) in which the entity declared by
6775   /* If the declarator-id is a SCOPE_REF, the scope in which the
6782      be declared in the current scope.  */
6974    CURRENT_CLASS_TYPE) should reflect the scope in which the
6975    declaration occurs, not the scope in which the new declaration will
7043      namespace scope.  */
7100 		       scope.  */
7238      Since we now wait to push a class scope until we are sure that
7618       error ("function-scope %qs implicitly auto and declared %<__thread%>",
7730 		/* We are within a class's scope. If our declarator name
8263 		error ("trying to make class %qT a friend of global scope",
8659 		       "declared out of global scope", name);
8662 		       "declared out of global scope", name);
8811        /* Any other non-local variable must be at namespace scope.  */
9281        in a namespace scope other than global scope or declared static
9282        in global scope.
9671 /* Lookup NAME in elaborate type specifier in scope according to
9678 		      tag_scope scope, bool template_header_p)
9682   if (scope == ts_global)
9688 	 non-class, non-function-prototype scope according to 3.3.1/5.
9690 	 scope.  So lookup again but not ignoring hidden names.
9697     decl = lookup_type_scope (name, scope);
9708       if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
9750    scope.)  It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
9751    declaration.  Only look beginning from the current scope outward up
9752    till the nearest non-class scope.  Otherwise it is TS_GLOBAL.
9759 	  tag_scope scope, bool template_header_p)
9791 			       scope, template_header_p);
9796   if (scope != ts_current && t && current_class_type
9855 	  t = pushtag (name, t, scope);
9875       if (scope != ts_within_enclosing_non_class
9893 xref_tag_from_type (tree old, tree id, tag_scope scope)
9905   return xref_tag (tag_kind, id, scope, false);
10542      the (lexical) scope of the class in which it is defined.  */
10575   /* Set up current_class_type, and enter the scope of the class, if
10582   /* Now that we have entered the scope of the class, we must restore
10608      class scope, current_class_type will be NULL_TREE until set above
10618   /* We are now in the scope of the function being defined.  */
10967 	 pushed into scope by the loop above.  */
10974      as the decl-chain of the current lexical scope.
11081       be looked up in the scope of the destructor's class and if
11308 	  /* Only allow this for variables declared in the outer scope of
11319   /* Remember that we were in class scope.  */
11326   /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11387   /* Leave the scope of the class.  */