From 8c6fb7352f7b7fdca3ae8df5ced03e3985d85a4b Mon Sep 17 00:00:00 2001
From: k-hara <k.hara.pg@gmail.com>
Date: Thu, 19 Dec 2013 13:06:57 +0900
Subject: [PATCH] [Refactoring] Improve CastExp parsing by using `Type::addSTC`

---
 src/parse.c | 83 +++++++++++++++++++++++++++--------------------------
 1 file changed, 42 insertions(+), 41 deletions(-)

diff --git a/src/parse.c b/src/parse.c
index 7cf85320d0b2..8599a3412a42 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -6497,56 +6497,57 @@ Expression *Parser::parseUnaryExp()
             /* Look for cast(), cast(const), cast(immutable),
              * cast(shared), cast(shared const), cast(wild), cast(shared wild)
              */
-            unsigned char m;
-            if (token.value == TOKrparen)
-            {
-                m = 0;
-                goto Lmod1;
-            }
-            else if (token.value == TOKconst && peekNext() == TOKrparen)
-            {
-                m = MODconst;
-                goto Lmod2;
-            }
-            else if ((token.value == TOKimmutable || token.value == TOKinvariant) && peekNext() == TOKrparen)
-            {
-                if (token.value == TOKinvariant)
-                    error("use 'immutable' instead of 'invariant'");
-                m = MODimmutable;
-                goto Lmod2;
-            }
-            else if (token.value == TOKshared && peekNext() == TOKrparen)
-            {
-                m = MODshared;
-                goto Lmod2;
-            }
-            else if (token.value == TOKwild && peekNext() == TOKrparen)
-            {
-                m = MODwild;
-                goto Lmod2;
-            }
-            else if (token.value == TOKwild && peekNext() == TOKshared && peekNext2() == TOKrparen ||
-                     token.value == TOKshared && peekNext() == TOKwild && peekNext2() == TOKrparen)
+            unsigned char m = 0;
+            while (1)
             {
-                m = MODshared | MODwild;
-                goto Lmod3;
+                switch (token.value)
+                {
+                    case TOKconst:
+                        if (peekNext() == TOKlparen)
+                            break;              // const as type constructor
+                        m |= MODconst;          // const as storage class
+                        nextToken();
+                        continue;
+
+                    case TOKinvariant:
+                    case TOKimmutable:
+                        if (peekNext() == TOKlparen)
+                            break;
+                        if (token.value == TOKinvariant)
+                            error("use 'immutable' instead of 'invariant'");
+                        m |= MODimmutable;
+                        nextToken();
+                        continue;
+
+                    case TOKshared:
+                        if (peekNext() == TOKlparen)
+                            break;
+                        m |= MODshared;
+                        nextToken();
+                        continue;
+
+                    case TOKwild:
+                        if (peekNext() == TOKlparen)
+                            break;
+                        m |= MODwild;
+                        nextToken();
+                        continue;
+
+                    default:
+                        break;
+                }
+                break;
             }
-            else if (token.value == TOKconst && peekNext() == TOKshared && peekNext2() == TOKrparen ||
-                     token.value == TOKshared && peekNext() == TOKconst && peekNext2() == TOKrparen)
+            if (token.value == TOKrparen)
             {
-                m = MODshared | MODconst;
-              Lmod3:
-                nextToken();
-              Lmod2:
-                nextToken();
-              Lmod1:
                 nextToken();
                 e = parseUnaryExp();
                 e = new CastExp(loc, e, m);
             }
             else
             {
-                Type *t = parseType();          // ( type )
+                Type *t = parseType();  // cast( type )
+                t = t->addMod(m);       // cast( const type )
                 check(TOKrparen);
                 e = parseUnaryExp();
                 e = new CastExp(loc, e, t);