Changeset 213

Timestamp:

10/14/09 17:09:50 (2 years ago)

Author:

walter

Message:

1.050 and 2.035

Files:

• trunk/src/mtype.c (modified) (1 diff)
• trunk/src/mtype.h (modified) (1 diff)
• trunk/src/parse.c (modified) (3 diffs)

trunk/src/mtype.c

@@ -6848 +6848 @@
-    }
-    else
-    {
-     Ldefault:
-    Type::resolve(loc, sc, pe, pt, ps);
-    }
-}
-
-void TypeSlice::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
-{
-    if (mod != this->mod)
-    {   toCBuffer3(buf, hgs, mod);
-    return;
-    }
-    next->toCBuffer2(buf, hgs, this->mod);
-
-    buf->printf("[%s .. ", lwr->toChars());
-    buf->printf("%s]", upr->toChars());
-}
-
+/***************************** TypeNewArray *****************************/
+
+/* T[new]
+ */
+
+TypeNewArray::TypeNewArray(Type *next)
+    : TypeNext(Tnarray, next)
+{
+    //printf("TypeNewArray\n");
+}
+
+void TypeNewArray::toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod)
+{
+    if (mod != this->mod)
+    {   toCBuffer3(buf, hgs, mod);
+    return;
+    }
+    next->toCBuffer2(buf, hgs, this->mod);
+    buf->writestring("[new]");
+}
+
-/***************************** Argument *****************************/
-
-Argument::Argument(unsigned storageClass, Type *type, Identifier *ident, Expression *defaultArg)
-{
-    this->type = type;
-    this->ident = ident;
-    this->storageClass = storageClass;
-    this->defaultArg = defaultArg;
-}
-
-Argument *Argument::syntaxCopy()
-{
-    Argument *a = new Argument(storageClass,
-        type ? type->syntaxCopy() : NULL,
-        ident,
-        defaultArg ? defaultArg->syntaxCopy() : NULL);
-    return a;
-}
-
-Arguments *Argument::arraySyntaxCopy(Arguments *args)

trunk/src/mtype.h

@@ -781 +781 @@
-    int equals(Object *o);
-    Type *reliesOnTident();
-    void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod);
-    void toDecoBuffer(OutBuffer *buf, int flag);
-    Expression *getProperty(Loc loc, Identifier *ident);
-    TypeInfoDeclaration *getTypeInfoDeclaration();
-};
-
-struct TypeSlice : TypeNext
-{
-    Expression *lwr;
-    Expression *upr;
-
-    TypeSlice(Type *next, Expression *lwr, Expression *upr);
-    Type *syntaxCopy();
-    Type *semantic(Loc loc, Scope *sc);
-    void resolve(Loc loc, Scope *sc, Expression **pe, Type **pt, Dsymbol **ps);
-    void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod);
-};
-
+struct TypeNewArray : TypeNext
+{
+    TypeNewArray(Type *next);
+    void toCBuffer2(OutBuffer *buf, HdrGenState *hgs, int mod);
+};
+
-/**************************************************************/
-
-//enum InOut { None, In, Out, InOut, Lazy };
-
-struct Argument : Object
-{
-    //enum InOut inout;
-    unsigned storageClass;
-    Type *type;
-    Identifier *ident;
-    Expression *defaultArg;
-
-    Argument(unsigned storageClass, Type *type, Identifier *ident, Expression *defaultArg);
-    Argument *syntaxCopy();
-    Type *isLazyArray();
-    void toDecoBuffer(OutBuffer *buf);
-    static Arguments *arraySyntaxCopy(Arguments *args);
-    static char *argsTypesToChars(Arguments *args, int varargs);
-    static void argsCppMangle(OutBuffer *buf, CppMangleState *cms, Arguments *arguments, int varargs);
-    static void argsToCBuffer(OutBuffer *buf, HdrGenState *hgs, Arguments *arguments, int varargs);

trunk/src/parse.c

@@ -2206 +2206 @@
-    //printf("parseBasicType2()\n");
-    while (1)
-    {
-    switch (token.value)
-    {
-        case TOKmul:
-        t = new TypePointer(t);
-        nextToken();
-        continue;
-
-        case TOKlbracket:
-        // Handle []. Make sure things like
-        //     int[3][1] a;
-        // is (array[1] of array[3] of int)
-        nextToken();
-        if (token.value == TOKrbracket)
-        {
-            t = new TypeDArray(t);          // []
-            nextToken();
-        }
+        else if (token.value == TOKnew && peekNext() == TOKrbracket)
+        {
+            t = new TypeNewArray(t);            // [new]
+            nextToken();
+            nextToken();
+        }
-        else if (isDeclaration(&token, 0, TOKrbracket, NULL))
-        {   // It's an associative array declaration
-
-            //printf("it's an associative array\n");
-            Type *index = parseType();      // [ type ]
-            t = new TypeAArray(t, index);
-            check(TOKrbracket);
-        }
-        else
-        {
-            //printf("it's type[expression]\n");
-            inBrackets++;
-            Expression *e = parseExpression();      // [ expression ]
-            if (token.value == TOKslice)
-            {
-            nextToken();
-            Expression *e2 = parseExpression(); // [ exp .. exp ]
-            t = new TypeSlice(t, e, e2);
-            }
-            else
@@ -2326 +2332 @@
-    }
-
-    // parse DeclaratorSuffixes
-    while (1)
-    {
-    switch (token.value)
-    {
-#if CARRAYDECL
-        /* Support C style array syntax:
-         *   int ident[]
-         * as opposed to D-style:
-         *   int[] ident
-         */
-        case TOKlbracket:
-        {   // This is the old C-style post [] syntax.
-        TypeNext *ta;
-        nextToken();
-        if (token.value == TOKrbracket)
-        {   // It's a dynamic array
-            ta = new TypeDArray(t);     // []
+            nextToken();
+        }
+        else if (token.value == TOKnew && peekNext() == TOKrbracket)
+        {
+            t = new TypeNewArray(t);        // [new]
+            nextToken();
-            nextToken();
-        }
-        else if (isDeclaration(&token, 0, TOKrbracket, NULL))
-        {   // It's an associative array
-
-            //printf("it's an associative array\n");
-            Type *index = parseType();      // [ type ]
-            check(TOKrbracket);
-            ta = new TypeAArray(t, index);
-        }
-        else
-        {
-            //printf("It's a static array\n");
-            Expression *e = parseExpression();  // [ expression ]
-            ta = new TypeSArray(t, e);
-            check(TOKrbracket);
-        }
-
-        /* Insert ta into
-         *   ts -> ... -> t
@@ -4248 +4260 @@
-
-    //printf("Parser::isDeclarator()\n");
-    //t->print();
-    if (t->value == TOKassign)
-    return FALSE;
-
-    while (1)
-    {
-    parens = FALSE;
-    switch (t->value)
-    {
-        case TOKmul:
-        //case TOKand:
-        t = peek(t);
-        continue;
-
-        case TOKlbracket:
-        t = peek(t);
-        if (t->value == TOKrbracket)
-        {
+            t = peek(t);
+        }
+        else if (t->value == TOKnew && peek(t)->value == TOKrbracket)
+        {
+            t = peek(t);
-            t = peek(t);
-        }
-        else if (isDeclaration(t, 0, TOKrbracket, &t))
-        {   // It's an associative array declaration
-            t = peek(t);
-        }
-        else
-        {
-            // [ expression ]
-            // [ expression .. expression ]
-            if (!isExpression(&t))
-            return FALSE;
-            if (t->value == TOKslice)
-            {   t = peek(t);
-            if (!isExpression(&t))
-                return FALSE;
-            }
-            if (t->value != TOKrbracket)
-            return FALSE;
-            t = peek(t);