Overload Features

The following overload features are unsupported at this time.

Overloadable Declarations
Usually, two function declarations of the same name with parameter types that only differ in a parameter that is an enumeration in one declaration, and a different enumeration in the other, can be overloaded. This feature is unsupported at this time. Example:
```
      enum e1 {a, b, c};

      enum e2 {d, e};

      int g(e1) { return 3; }

      int g(e2) { return 4; }

----------------^--------------------ERROR:function redefinition
```
Address of Overloaded Function
Usually, in the context of a pointer-to-function parameter of a user-defined operator, using a function name without arguments selects the non-member function that matches the target. This feature is unsupported at this time. Example:
```
const int F_char  = 100;

int func(char)

{

      return F_char;

}

struct A {} a;

int operator+(A, int (*pfc)(char))

{

      return pfc(0);

}

if (a + func != F_char){}

-----------^----------------- Arithmetic types expected
```
Usually, in the context of a pointer-to-member-function return value of a function, using a function name without arguments selects the member function that matches the target. This feature is unsupported at this time. Example:
```
struct X {

      void f (void)  {}

      void f (int) {}

} x;

typedef void (X::*mfvp)(void);

mfvp f03() {

              return &X::f; 

----------------------^-------ERROR:Cannot take address of this object

}
```
Usually, when an overloaded name is a function template and template argument deduction succeeds, the resulting template argument list is used to generate an overload resolution candidate that should be a function template specialization. This feature is unsupported at this time. Example:
```
template <class T> int f(T) { return F_char; }

int f(int) { return F_int; }

int (*p00)(char) = f;

--------------------------------^-----------ERROR: Indirection to different types ('int (*)(int)' instead of 'int (*)(char )')
```

Overloading operators is unsupported at this time. Example:

struct S {

      int m;

      template <class T> void operator+=(T t) { m += t; } // 

ERROR at template

};