int f(int);
int f(x) char x; { return x; } 

struct A {
	  A(int);
	  A operator=(A&);
	  A operator+(const A&);
};
int main () {
	  A b(1);
	  b = A(1) + A(2);   // Allowed as anachronism
          return 0;
}

class B;
class A {
	  friend B;  // Should be "friend class B"
}; 

class A {
	  const int size = 10;
	  int a[size];
}; 

struct A { 
	  int A::f();  // Should be int f(); 
};

typedef union {
	  int i, j;
} U;            // U identifies a reusable anonymous union.
class A {
	  U;// Okay -- references to A::i and A::j are allowed.
}; 

struct A {
	  struct {
	    int i, j;
	  };// Okay -- references to A::i and A::j are allowed.
};

struct A { };
struct B : public A {
	  B& operator=(A&);
}; 

extern "C" void f();// f's type has extern "C" linkage
void (*pf)()        // pf points to an extern "C++" function
	    = &f;// error unless implicit conversion is allowed 

1. A member in a base class must have the same name as an identifier at the global scope. The member may be a function, static data member, or nonstatic data member. Member type names don't apply because a nested type will be promoted to the global scope by cfront which disallows a later declaration of a type with the same name at the global scope.
   
   
2. The declaration of the global scope name must occur between the declaration of the derived class and the declaration of an out-of-line constructor or destructor. The global scope name must be a type name.
   
   
3. No other member function definition-even one for an unrelated class-may appear between the destructor and the offending reference. This has the effect that the nonstandard lookup applies to only one class at any given point in time. For example:
   
   

   struct B   {
   	void func(const char*);
   };
   struct D : public B {
   public:
   	D();
        void Init(const char* );
   };
   struct func {
   	func( const char* msg);
   };
   D::D(){}
   void D::Init(const char* t)
   {
   	// Should call B::func --
   	// calls func::func instead.
   	new func(t);
   } 

   
   The global scope name must be present in a base class (B::func in this example) for the nonstandard lookup to occur. Even if the derived class were to have a member named func, it is still the presence of B::func that determines how the lookup will be performed.
   
   

	 int a1;
	 int e1;
	 void f1();
	 class A {
	  int a1;
	  void f1();
	  friend void f()
	  {
	    int i1 = a1;   // cfront uses global a1
	    f1();          // cfront uses global f1
	  }
	 }; 

	 int a1;
	 int b1;
	 struct A {
	   static int a1;
	   class B {
	     static int b1;
	     friend void f()
	     {
	       int i1 = a1;  // cfront uses A::a1
	       int j1 = b1;  // cfront uses global b1
	     }
	   };
	 }; 

class A {
	  A() const;         // No error in cfront 2.1 mode
}; 

struct A {
	  void f() const;
};
void (A::*fp)() = &A::f; 

struct A { 
	  friend B; 
}; 

int *p;
const int *&r = p;  // No temporary used 

	 struct A {
	   void f(int);
	   static void sf(int);
	   typedef void A::T3(int);  // nonstd typedef decl
	   typedef void T2(int);     // std typedef
	 };
	 typedef void A::T(int);  // nonstd typedef decl
	 T* pmf = &A::f;          // nonstd ptr-to-member decl
	 A::T2* pf = A::sf;       // std ptr to static mem decl
	 A::T3* pmf2 = &A::f;     // nonstd ptr-to-member decl 

	 class B { protected: int i; };
	 class D : public B { void mf(); };
	 void D::mf() {
	  int B::* pmi1 = &B::i;  // error, OK in cfront mode
	  int D::* pmi2 = &D::i;  // OK
	 } 

	 class A { 
	      ~A(); 
	 }; 
	 class B : public A { 
	      ~B(); 
	 }; 
	 B::~B(){}    // Error except in cfront mode 

	 class A { A(); };
	 double d;
	 A x(int(d));
	 A(x2); 

int xyz(int()); 

typedef class A T; 
class T *pa;               // No error in cfront mode 

short short int i;         // No warning in cfront mode 

	 struct A {
	  virtual void f() {}
	  A() {}
	  ~A() {}
	 };
	 struct B : public A {
	  B() {}
	  ~B() {f();} // Should call A::f according to ARM 12.7
	 };
	 struct C : public B {
	  void f() {}
	 } c; 

f(1, 2, ); 

	 struct A {int f();};
	 int main () {
	  int (*p)();
	  p = (int (*)())A::f;  // Okay, with warning
          return 0;
	 } 

	 typedef struct { int i, j; } S;
	 struct S x;         // No error in cfront mode 

	  class A {
	  void f(int) const;
	  static void f(int);      // No error in cfront mode
	 }; 

	  int f(int i) {
	  for (int j = 0; j < i; ++j) { /* ... */ }
	  return j;                  // No error in cfront mode
	 } 

	 typedef void (*PF)(); 
	 extern "C" typedef void (*PCF)(); 
	 void f(PF); 
	 void f(PCF);