// PERMUTE_ARGS: -O -fPIC

extern(C) int printf(const char*, ...);

/****************************************************/

class Abc : Exception
{
    this()
    {
        super("");
    }
    int i;
}

int y;

alias int boo;

void foo(int x)
{
    y = cast(boo)1;
L6:
    try
    {
        printf("try 1\n");
        y += 4;
        if (y == 5)
            goto L6;
        y += 3;
    }
    finally
    {
        y += 5;
        printf("finally 1\n");
    }
    try
    {
        printf("try 2\n");
        y = 1;
        if (y == 4)
            goto L6;
        y++;
    }
    catch (Abc c)
    {
        printf("catch 2\n");
        y = 2 + c.i;
    }
    y++;
    printf("done\n");
}

/****************************************************/


class IntException : Exception
{
    this(int i)
    {
        m_i = i;
    super("");
    }

    int getValue()
    {
        return m_i;
    }

    int m_i;
}


void test2()
{
    int     cIterations =   10;

    int     i;
    long    total_x     =   0;
    long    total_nox   =   0;

    for(int WARMUPS = 2; WARMUPS-- > 0; )
    {
        for(total_x = 0, i = 0; i < cIterations; ++i)
        {
            total_nox += fn2_nox();
        }
printf("foo\n");

        for(total_nox = 0, i = 0; i < cIterations; ++i)
        {
printf("i = %d\n", i);
            try
            {
                int z = 1;

                throw new IntException(z);
            }
            catch(IntException x)
            {
printf("catch, i = %d\n", i);
                total_x += x.getValue();
            }
        }
    }

    printf("iterations %d totals: %lld, %lld\n", cIterations, total_x, total_nox);
}

int fn2_nox()
{
    return 47;
}


/****************************************************/

void test3()
{
    static int x;
    try
    {
    }
    finally
    {
        printf("a\n");
        assert(x == 0);
        x++;
    }
    printf("--\n");
    assert(x == 1);
    try
    {
        printf("tb\n");
        assert(x == 1);
    }
    finally
    {
        printf("b\n");
        assert(x == 1);
        x++;
    }
    assert(x == 2);
}

/****************************************************/

class Tester
{
    this(void delegate() dg_) { dg = dg_; }
    void delegate() dg;
    void stuff() { dg(); }
}

void test4()
{
    printf("Starting test\n");

    int a = 0;
    int b = 0;
    int c = 0;
    int d = 0;

    try
    {
        a++;
        throw new Exception("test1");
        a++;
    }
    catch(Exception e)
    {
        auto es = e.toString();
                printf("%.*s\n", cast(int)es.length, es.ptr);
        b++;
    }
    finally
    {
        c++;
    }

    printf("initial test.\n");

    assert(a == 1);
    assert(b == 1);
    assert(c == 1);

    printf("pass\n");

    Tester t = new Tester(
    delegate void()
    {
        try
        {
            a++;
            throw new Exception("test2");
            a++;
        }
        catch(Exception e)
        {
            b++;
            throw e;
            b++;
        }
    });

    try
    {
        c++;
        t.stuff();
        c++;
    }
    catch(Exception e)
    {
        d++;
        string es = e.toString;
        printf("%.*s\n", cast(int)es.length, es.ptr);
    }

    assert(a == 2);
    assert(b == 2);
    assert(c == 2);
    assert(d == 1);


    int q0 = 0;
    int q1 = 0;
    int q2 = 0;
    int q3 = 0;

    Tester t2 = new Tester(
    delegate void()
    {
        try
        {
            q0++;
            throw new Exception("test3");
            q0++;
        }
        catch(Exception e)
        {
            printf("Never called.\n");
            q1++;
            throw e;
            q1++;
        }
    });

    try
    {
        q2++;
        t2.stuff();
        q2++;
    }
    catch(Exception e)
    {
        q3++;
                string es = e.toString;
        printf("%.*s\n", cast(int)es.length, es.ptr);
    }

    assert(q0 == 1);
    assert(q1 == 1);
    assert(q2 == 1);
    assert(q3 == 1);

    printf("Passed!\n");
}

/****************************************************/

void test5()
{
    char[] result;
    int i = 3;
    while(i--)
    {
        try
        {
            printf("i: %d\n", i);
            result ~= 't';
            if (i == 1)
                continue;
        }
        finally
        {
            printf("finally\n");
            result ~= cast(char)('a' + i);
        }
    }
    printf("--- %.*s", cast(int)result.length, result.ptr);
    if (result != "tctbta")
        assert(0);
}

/****************************************************/

void test6()
{
    char[] result;

    while (true)
    {
        try
        {
            printf("one\n");
            result ~= 'a';
            break;
        }
        finally
        {
            printf("two\n");
            result ~= 'b';
        }
    }
    printf("three\n");
    result ~= 'c';
    if (result != "abc")
        assert(0);
}

/****************************************************/

string a7;

void doScan(int i)
{
    a7 ~= "a";
    try
    {
        try
        {
            a7 ~= "b";
            return;
        }
        finally
        {
            a7 ~= "c";
        }
    }
    finally
    {
        a7 ~= "d";
    }
}

void test7()
{
    doScan(0);
    assert(a7 == "abcd");
}


/****************************************************
 * Exception chaining tests. See also test4.d
 * Don writes about the complexity:

I can explain this, since I did the original implementation.
When I originally implemented this, I discovered that the idea of
"chained exceptions" was hopeless naive. The idea was that while
processing one exception, if you encounter a second one, and you
chain them together. Then you get a third, fourth, etc.

The problem is that it's much more complicated than that. Each of
the exceptions can be a chain of exceptions themselves. This means
that you don't end up with a chain of exceptions, but rather a tree
of exceptions. That's why there are those really nasty test cases
in the test suite.

The examples in the test suite are very difficult to understand if
you expect it to be a simple chain!

On the one hand, I was very proud that I was able to work out the
barely-documented behaviour of Windows SEH, and it was really
thorough. In the initial implementation, all the complexity
was covered. It wasn't the bugfix-driven-development which dmd
usually operates under <g>.

But on the other hand, once you can see all of the complexity,
exception chaining becomes much less convincing as a concept. Sure,
the full exception tree is available in the final exception which
you catch. But, is it of any use? I doubt it very much.
It's pretty clearly a nett loss to the language, it increases
complexity with negligible benefit. Fortunately in this case, the
cost isn't really high.

https://digitalmars.com/d/archives/digitalmars/D/Dicebot_on_leaving_D_It_is_anarchy_driven_development_in_all_its_317950.html#N318305
 ****************************************************/
int result1513;

void bug1513a()
{
     throw new Exception("d");
}

void bug1513b()
{
    try
    {
        try
        {
            bug1513a();
        }
        finally
        {
            result1513 |=4;
           throw new Exception("f");
        }
    }
    catch(Exception e)
    {
        assert(e.msg == "d");
        assert(e.next.msg == "f");
        assert(!e.next.next);
        int i;
        foreach (u; e)
        {
            if (i)
                assert(u.msg == "f");
            else
                assert(u.msg == "d");
            ++i;
        }
    }
}

void bug1513c()
{
    try
    {
        try
        {
            throw new Exception("a");
        }
        finally
        {
            result1513 |= 1;
            throw new Exception("b");
        }
    }
    finally
    {
        bug1513b();
        result1513 |= 2;
        throw new Exception("c");
    }
}

void bug1513()
{
    result1513 = 0;
    try
    {
        bug1513c();
    }
    catch(Exception e)
    {
        assert(result1513 == 7);
        assert(e.msg == "a");
        assert(e.next.msg == "b");
        assert(e.next.next.msg == "c");
    }
}

void collideone()
{
    try
    {
        throw new Exception("x");
    }
    finally
    {
        throw new Exception("y");
    }
}

void doublecollide()
{
    try
    {
        try
        {
            try
            {
                throw new Exception("p");
            }
            finally
            {
                throw new Exception("q");
            }
        }
        finally
        {
            collideone();
        }
    }
    catch(Exception e)
    {
            assert(e.msg == "p");
            assert(e.next.msg == "q");
            assert(e.next.next.msg == "x");
            assert(e.next.next.next.msg == "y");
            assert(!e.next.next.next.next);
    }
}

void collidetwo()
{
       try
        {
            try
            {
                throw new Exception("p2");
            }
            finally
            {
                throw new Exception("q2");
            }
        }
        finally
        {
            collideone();
        }
}

void collideMixed()
{
    int works = 6;
    try
    {
        try
        {
            try
            {
                throw new Exception("e");
            }
            finally
            {
                throw new Error("t");
            }
        }
        catch(Exception f)
        {    // Doesn't catch, because Error is chained to it.
            works += 2;
        }
    }
    catch(Error z)
    {
        works += 4;
        assert(z.msg=="t"); // Error comes first
        assert(z.next is null);
        assert(z.bypassedException.msg == "e");
    }
    assert(works == 10);
}

class AnotherException : Exception
{
    this(string s)
    {
        super(s);
    }
}

void multicollide()
{
    try
    {
       try
        {
            try
            {
                try
                {
                    throw new Exception("m2");
                }
                finally
                {
                    throw new AnotherException("n2");
                }
            }
            catch(AnotherException s)
            {   // Not caught -- we needed to catch the root cause "m2", not
                // just the collateral "n2" (which would leave m2 uncaught).
                assert(0);
            }
        }
        finally
        {
            collidetwo();
        }
    }
    catch(Exception f)
    {
        assert(f.msg == "m2");
        assert(f.next.msg == "n2");
        Throwable e = f.next.next;
        assert(e.msg == "p2");
        assert(e.next.msg == "q2");
        assert(e.next.next.msg == "x");
        assert(e.next.next.next.msg == "y");
        assert(!e.next.next.next.next);
    }
}

/****************************************************/

void use9568(char [] x, char [] y) {}

int bug9568()
{
    try
        return 7;
     finally
        use9568(null,null);
}

void test9568()
{
    assert( bug9568() == 7 );
}

/****************************************************/

version (DigitalMars)
{
void test8a()
{
  int a;
  goto L2;    // L2 is not addressable.

  try {
      a += 2;
  }
  catch (Exception) {
      a += 3;
L2: ;
      a += 100;
  }
  assert(a == 100);
}

void test8b()
{
  int a;
  goto L2;    // L2 is not addressable.

  try {
  }
  catch (Exception) {
      a += 3;
L2: ;
      a += 100;
  }
  assert(a == 100);
}

void test8c()
{
  int a;
  goto L2;    // L2 is not addressable.

  try
    static assert(true);
  catch (Exception) {
      a += 3;
L2: ;
      a += 100;
  }
  assert(a == 100);
}

void test8()
{
  test8a();
  test8b();
  test8c();
}
}

/****************************************************/

uint foo9(uint i)
{
    try
    {
        ++i;
        return 3;
    }
    catch (Exception e)
    {
        debug printf("Exception happened\n");
    }
    return 4;
}

void test9()
{
    assert(foo9(7) == 3);
}

/****************************************************/
// https://issues.dlang.org/show_bug.cgi?id=10964

void test10964()
{
    static struct S
    {
        this(this)
        {
            throw new Exception("BOOM!");
        }
    }

    S    ss;
    S[1] sa;
    int result;

    result = 0;
    try
    {
        ss = ss;
    }
    catch (Exception e) result = 1;
    catch (Error     e) result = 2;
    catch (Throwable e) result = 3;
    assert(result == 1);

    try
    {
        sa = ss;
    }
    catch (Exception e) result = 1;
    catch (Error     e) result = 2;
    catch (Throwable e) result = 3;
    assert(result == 1);

    try
    {
        sa = sa;
    }
    catch (Exception e) result = 1;
    catch (Error     e) result = 2;
    catch (Throwable e) result = 3;
    assert(result == 1);
}

/****************************************************/

alias Action = void delegate();

class A10
{
    invariant()
    {
    }

    public Action foo(Action a)
    {
        synchronized
        {
            B10 elements = new B10;
            Action[] actions = [a];

            elements.bar(actions);

            if (actions.length > 1)
                elements.bar(actions);
            return actions[0];
        }
        return null;
    }
}

class B10
{
    public bool bar(ref Action[])
    {
        return false;
    }
}

class D10
{
    void baz()
    {
    }
}

void test12989()
{
    auto a = new A10;
    auto d = new D10;

    assert(a.foo(&d.baz) == &d.baz);
}

/****************************************************/

int bar10(int c)
{
    if (c <= 0xFFFF)
    {
    L3:
        return 3;
    }
    throw new Exception("msg");
    goto L3;
}

void test10()
{
    int x;
    try
    {
        bar10(0x110000);
    }
    catch (Exception e)
    {
        printf("caught\n");
        x = 1;
    }
    assert(x == 1);
    printf("test10 success\n");
}

/****************************************************/

class ParseException : Exception
{
    @safe pure nothrow this( string msg )
    {
        super( msg );
    }
}

class OverflowException : Exception
{
    @safe pure nothrow this( string msg )
    {
        super( msg );
    }
}

void test11()
{
    int x;
    try
    {
        printf("test11()\n");
        throw new ParseException("msg");
    }
    catch( OverflowException e )
    {
        printf( "catch OverflowException\n" );
    }
    catch( ParseException e )
    {
        printf( "catch ParseException: %.*s\n", cast(int) e.msg.length, e.msg.ptr );
        x = 1;
    }
    assert(x == 1);
}

/****************************************************/
// https://issues.dlang.org/show_bug.cgi?id=17481

class C17481
{
    synchronized void trigger(){ new ubyte[1]; }
}

void test17481()
{
    auto k = new shared C17481;
    k.trigger;
}

/****************************************************/

// a nothrow function, even though it is not marked as nothrow
void test12()
{
    int i = 3;
    try
    {
        try
        {
            ++i;
            goto L10;
        }
        finally
        {
            i *= 2;
            printf("f1\n");
        }
    }
    finally
    {
        i += 5;
        printf("f2\n");
    }

L10:
    printf("3\n");
    assert(i == (3 + 1) * 2 + 5);
}

/****************************************************/

void foo13() { }

void test13()
{
    int i = 3;
    try
    {
        try
        {
            foo13(); // compiler assumes it throws
            ++i;
            goto L10;
        }
        finally
        {
            i *= 2;
            printf("f1\n");
        }
    }
    finally
    {
        i += 5;
        printf("f2\n");
    }

L10:
    printf("3\n");
    assert(i == (3 + 1) * 2 + 5);
}

/****************************************************/

// https://issues.dlang.org/show_bug.cgi?id=10966

void bug10966a(void* p)
{
    void* pstart = p;

    try
    {
        p = null;
        throw new Exception("dummy");
    }
    catch (Throwable o)
    {
        assert(p != pstart);
    }
}

void bug10966b()
{
    int x = 0;
    int i = 0;
    try
    {
        i = 1;
        throw new Exception("dummy");
    }
    catch (Throwable o)
    {
        x = i;
    }
    assert(x == 1);
}

void test10966()
{
    int s;
    bug10966a(&s);
    bug10966b();
}

/****************************************************/

// https://issues.dlang.org/show_bug.cgi?id=11049

void test11049()
{
    int[] arr = [1,2,3];

#line 4100 "foo"
    try { auto n = arr[3]; }
    catch (Error e)
    {
        //printf("e.file = %s\n", e.file.ptr);
        assert(e.file == "foo");  // fails
        assert(e.line == 4100);
    }

#line 4200 "bar"
    try { auto a = arr[3..9]; }
    catch (Error e)
    {
        //printf("e.file = %s\n", e.file.ptr);
        assert(e.file == "bar");  // fails
        assert(e.line == 4200);
    }
}

/****************************************************/

int main()
{
    printf("start\n");
    foo(3);
    test2();
    test3();
    test4();
    test5();
    test6();
    test7();

    bug1513();
    doublecollide();
    collideMixed();
    multicollide();
    test9568();

    version(DigitalMars) test8();
    test9();
    test10964();
    test12989();
    test10();
    test11();
    test17481();
    test12();
    test13();
    test10966();
    test11049();

    printf("finish\n");
    return 0;
}