diff --git a/libacc/acc.cpp b/libacc/acc.cpp
index 313bf1c..0a16489 100644
--- a/libacc/acc.cpp
+++ b/libacc/acc.cpp
@@ -139,16 +139,17 @@
         TY_VOID,      // 3
         TY_FLOAT,     // 4
         TY_DOUBLE,    // 5
-        TY_POINTER, // 6
-        TY_ARRAY,   // 7
-        TY_STRUCT,  // 8
-        TY_FUNC,    // 9
-        TY_PARAM    // 10
+        TY_POINTER,   // 6
+        TY_ARRAY,     // 7
+        TY_STRUCT,    // 8
+        TY_FUNC,      // 9
+        TY_PARAM      // 10
     };
 
     struct Type {
         TypeTag tag;
-        tokenid_t id; // For function arguments (stores length for array)
+        tokenid_t id; // For function arguments, local vars
+        int length; // length of array
         Type* pHead;
         Type* pTail;
     };
@@ -405,7 +406,16 @@
         /**
          * Convert R0 to the given type.
          */
-        virtual void convertR0(Type* pType) = 0;
+
+        void convertR0(Type* pType) {
+            convertR0Imp(pType, false);
+        }
+
+        void castR0(Type* pType) {
+            convertR0Imp(pType, true);
+        }
+
+        virtual void convertR0Imp(Type* pType, bool isCast) = 0;
 
         /* Emit code to adjust the stack for a function call. Return the
          * label for the address of the instruction that adjusts the
@@ -622,14 +632,40 @@
             return collapseType(getR0Type()->tag);
         }
 
-        bool isFloatType(Type* pType) {
+        static bool isFloatType(Type* pType) {
             return isFloatTag(pType->tag);
         }
 
-        bool isFloatTag(TypeTag tag) {
+        static bool isFloatTag(TypeTag tag) {
             return tag == TY_FLOAT || tag == TY_DOUBLE;
         }
 
+        static bool isPointerType(Type* pType) {
+            return isPointerTag(pType->tag);
+        }
+
+        static bool isPointerTag(TypeTag tag) {
+            return tag == TY_POINTER || tag == TY_ARRAY;
+        }
+
+        Type* getPointerArithmeticResultType(Type* a, Type* b) {
+            TypeTag aTag = a->tag;
+            TypeTag bTag = b->tag;
+            if (aTag == TY_POINTER) {
+                return a;
+            }
+            if (bTag == TY_POINTER) {
+                return b;
+            }
+            if (aTag == TY_ARRAY) {
+                return a->pTail;
+            }
+            if (bTag == TY_ARRAY) {
+                return b->pTail;
+            }
+            return NULL;
+        }
+
         Type* mkpInt;
 
     private:
@@ -848,8 +884,8 @@
             bool isFloatTOS = isFloatTag(tagTOS);
             if (!isFloatR0 && !isFloatTOS) {
                 setupIntPtrArgs();
-                bool isPtrR0 = tagR0 == TY_POINTER;
-                bool isPtrTOS = tagTOS == TY_POINTER;
+                bool isPtrR0 = isPointerTag(tagR0);
+                bool isPtrTOS = isPointerTag(tagTOS);
                 if (isPtrR0 || isPtrTOS) {
                     if (isPtrR0 && isPtrTOS) {
                         if (op != OP_MINUS) {
@@ -871,7 +907,8 @@
                         if (! (op == OP_PLUS || (op == OP_MINUS && isPtrR0))) {
                             error("Unsupported pointer-scalar operation %d", op);
                         }
-                        Type* pPtrType = isPtrR0 ? pR0Type : pTOSType;
+                        Type* pPtrType = getPointerArithmeticResultType(
+                                pR0Type, pTOSType);
                         int size = sizeOf(pPtrType->pHead);
                         if (size != 1) {
                             // TODO: Optimize for power-of-two.
@@ -1131,7 +1168,8 @@
         virtual void loadR0FromR0() {
             Type* pPointerType = getR0Type();
             assert(pPointerType->tag == TY_POINTER);
-            switch (pPointerType->pHead->tag) {
+            TypeTag tag = pPointerType->pHead->tag;
+            switch (tag) {
                 case TY_POINTER:
                 case TY_INT:
                 case TY_FLOAT:
@@ -1147,7 +1185,7 @@
                     o4(0xE1C000D0); // ldrd   r0, [r0]
                     break;
                 default:
-                    error("loadR0FromR0: unimplemented type");
+                    error("loadR0FromR0: unimplemented type %d", tag);
                     break;
             }
             setR0Type(pPointerType->pHead);
@@ -1197,9 +1235,27 @@
             return result;
         }
 
-        virtual void convertR0(Type* pType){
+        virtual void convertR0Imp(Type* pType, bool isCast){
             Type* pR0Type = getR0Type();
-            if (bitsSame(pType, pR0Type)) {
+            if (isPointerType(pType) && isPointerType(pR0Type)) {
+                Type* pA = pR0Type;
+                Type* pB = pType;
+                // Array decays to pointer
+                if (pA->tag == TY_ARRAY && pB->tag == TY_POINTER) {
+                    pA = pA->pTail;
+                }
+                if (typeEqual(pA, pB)) {
+                    return; // OK
+                }
+                if (pB->pHead->tag == TY_VOID) {
+                    return; // convert to void* is OK.
+                }
+                if (pA->tag == TY_POINTER && pB->tag == TY_POINTER
+                        && isCast) {
+                    return; // OK
+                }
+                error("Incompatible pointer or array types");
+            } else if (bitsSame(pType, pR0Type)) {
                 // do nothing special
             } else {
                 TypeTag r0Tag = collapseType(pR0Type->tag);
@@ -1423,14 +1479,17 @@
                     return 2;
                 case TY_CHAR:
                     return 1;
-                default:
-                    return 0;
                 case TY_FLOAT:
                     return 4;
                 case TY_DOUBLE:
                     return 8;
                 case TY_POINTER:
                     return 4;
+                case TY_ARRAY:
+                    return pType->length * sizeOf(pType->pHead);
+                default:
+                    error("Unsupported type %d", pType->tag);
+                    return 0;
             }
         }
 
@@ -1438,6 +1497,8 @@
             switch(pType->tag) {
                 case TY_DOUBLE:
                     return 8;
+                case TY_ARRAY:
+                    return stackAlignmentOf(pType->pHead);
                 default:
                     return 4;
             }
@@ -1447,6 +1508,11 @@
             switch(pType->tag) {
                 case TY_DOUBLE:
                     return 8;
+                case TY_ARRAY:
+                    return sizeOf(pType);
+                case TY_FUNC:
+                    error("stackSizeOf func not supported");
+                    return 4;
                 default:
                     return 4;
             }
@@ -1911,8 +1977,8 @@
             bool isFloatR0 = isFloatTag(tagR0);
             bool isFloatTOS = isFloatTag(tagTOS);
             if (!isFloatR0 && !isFloatTOS) {
-                bool isPtrR0 = tagR0 == TY_POINTER;
-                bool isPtrTOS = tagTOS == TY_POINTER;
+                bool isPtrR0 = isPointerTag(tagR0);
+                bool isPtrTOS = isPointerTag(tagTOS);
                 if (isPtrR0 || isPtrTOS) {
                     if (isPtrR0 && isPtrTOS) {
                         if (op != OP_MINUS) {
@@ -1936,7 +2002,8 @@
                         if (! (op == OP_PLUS || (op == OP_MINUS && isPtrR0))) {
                             error("Unsupported pointer-scalar operation %d", op);
                         }
-                        Type* pPtrType = isPtrR0 ? pR0Type : pTOSType;
+                        Type* pPtrType = getPointerArithmeticResultType(
+                                pR0Type, pTOSType);
                         o(0x59); /* pop %ecx */
                         int size = sizeOf(pPtrType->pHead);
                         if (size != 1) {
@@ -2146,7 +2213,8 @@
         virtual void loadR0FromR0() {
             Type* pPointerType = getR0Type();
             assert(pPointerType->tag == TY_POINTER);
-            switch (pPointerType->pHead->tag) {
+            TypeTag tag = pPointerType->pHead->tag;
+            switch (tag) {
                 case TY_POINTER:
                 case TY_INT:
                     o2(0x008b); /* mov (%eax), %eax */
@@ -2166,7 +2234,7 @@
                     o2(0x00dd); // fldl (%eax)
                     break;
                 default:
-                    error("loadR0FromR0: unsupported type");
+                    error("loadR0FromR0: unsupported type %d", tag);
                     break;
             }
             setR0Type(pPointerType->pHead);
@@ -2183,14 +2251,32 @@
             return getPC() - 4;
         }
 
-        virtual void convertR0(Type* pType){
+        virtual void convertR0Imp(Type* pType, bool isCast){
             Type* pR0Type = getR0Type();
             if (pR0Type == NULL) {
                 assert(false);
                 setR0Type(pType);
                 return;
             }
-            if (bitsSame(pType, pR0Type)) {
+            if (isPointerType(pType) && isPointerType(pR0Type)) {
+                Type* pA = pR0Type;
+                Type* pB = pType;
+                // Array decays to pointer
+                if (pA->tag == TY_ARRAY && pB->tag == TY_POINTER) {
+                    pA = pA->pTail;
+                }
+                if (typeEqual(pA, pB)) {
+                    return; // OK
+                }
+                if (pB->pHead->tag == TY_VOID) {
+                    return; // convert to void* is OK.
+                }
+                if (pA->tag == TY_POINTER && pB->tag == TY_POINTER
+                        && isCast) {
+                    return; // OK
+                }
+                error("Incompatible pointer or array types");
+            } else if (bitsSame(pType, pR0Type)) {
                 // do nothing special
             } else if (isFloatType(pType) && isFloatType(pR0Type)) {
                 // do nothing special, both held in same register on x87.
@@ -2326,6 +2412,11 @@
                 return 1;
             case TY_SHORT:
                 return 2;
+            case TY_ARRAY:
+                return alignmentOf(pType->pHead);
+            case TY_FUNC:
+                error("alignment of func not supported");
+                return 1;
             default:
                 return 4;
             }
@@ -2342,14 +2433,17 @@
                     return 2;
                 case TY_CHAR:
                     return 1;
-                default:
-                    return 0;
                 case TY_FLOAT:
                     return 4;
                 case TY_DOUBLE:
                     return 8;
                 case TY_POINTER:
                     return 4;
+                case TY_ARRAY:
+                    return pType->length * sizeOf(pType->pHead);
+                default:
+                    error("Unsupported type %d", pType->tag);
+                    return 0;
             }
         }
 
@@ -2361,6 +2455,11 @@
             switch(pType->tag) {
                 case TY_DOUBLE:
                     return 8;
+                case TY_ARRAY:
+                    return sizeOf(pType);
+                case TY_FUNC:
+                    error("stackSizeOf func not supported");
+                    return 4;
                 default:
                     return 4;
             }
@@ -3911,7 +4010,7 @@
                     skip(')');
                     unary();
                     pGen->forceR0RVal();
-                    pGen->convertR0(pCast);
+                    pGen->castR0(pCast);
                 } else {
                     commaExpr();
                     skip(')');
@@ -3959,10 +4058,18 @@
                     }
                 }
                 // load a variable
-                Type* pVal = createPtrType(pVI->pType);
+                Type* pVal;
+                ExpressionType et;
+                if (pVI->pType->tag == TY_ARRAY) {
+                    pVal = pVI->pType;
+                    et = ET_RVALUE;
+                } else {
+                    pVal = createPtrType(pVI->pType);
+                    et = ET_LVALUE;
+                }
                 if (n) {
-                    ExpressionType et = ET_LVALUE;
-                    if (pVal->pHead->tag == TY_FUNC) {
+                    int tag = pVal->pHead->tag;
+                    if (tag == TY_FUNC) {
                         et = ET_RVALUE;
                     }
                     pGen->leaR0(n, pVal, et);
@@ -4251,6 +4358,8 @@
         }
         if (at == TY_POINTER) {
             return typeEqual(a->pHead, b->pHead);
+        } else if (at == TY_ARRAY) {
+            return a->length == b->length && typeEqual(a->pHead, b->pHead);
         } else if (at == TY_FUNC || at == TY_PARAM) {
             return typeEqual(a->pHead, b->pHead)
                 && typeEqual(a->pTail, b->pTail);
@@ -4345,6 +4454,9 @@
                 }
                 buffer.append('*');
                 break;
+            case TY_ARRAY:
+                decodeTypeImpPrefix(buffer, pType->pHead);
+                break;
             case TY_FUNC:
                 decodeTypeImp(buffer, pType->pHead);
                 break;
@@ -4369,6 +4481,13 @@
                 }
                 decodeTypeImpPostfix(buffer, pType->pHead);
                 break;
+            case TY_ARRAY:
+                {
+                    String temp;
+                    temp.printf("[%d]", pType->length);
+                    buffer.append(temp);
+                }
+                break;
             case TY_FUNC:
                 buffer.append('(');
                 for(Type* pArg = pType->pTail; pArg; pArg = pArg->pTail) {
@@ -4418,9 +4537,13 @@
                                   nameRequired, reportFailure);
         if (declName) {
             // Clone the parent type so we can set a unique ID
+            Type* pOldType = pType;
             pType = createType(pType->tag, pType->pHead, pType->pTail);
 
             pType->id = declName;
+            pType->length = pOldType->length;
+        } else if (nameRequired) {
+            error("Expected a variable name");
         }
         // fprintf(stderr, "Parsed a declaration:       ");
         // printType(pType);
@@ -4490,11 +4613,27 @@
             error("Expected name. Got %s", temp.getUnwrapped());
             reportFailure = true;
         }
-        while (accept('(')) {
-            // Function declaration
-            Type* pTail = acceptArgs(nameAllowed);
-            pType = createType(TY_FUNC, pType, pTail);
-            skip(')');
+        for(;;) {
+            if (accept('(')) {
+                // Function declaration
+                Type* pTail = acceptArgs(nameAllowed);
+                pType = createType(TY_FUNC, pType, pTail);
+                skip(')');
+            } if (accept('[')) {
+                if (tok != ']') {
+                    if (tok != TOK_NUM || tokc <= 0) {
+                        error("Expected positive integer constant");
+                    } else {
+                        Type* pDecayType = createPtrType(pType);
+                        pType = createType(TY_ARRAY, pType, pDecayType);
+                        pType->length = tokc;
+                    }
+                    next();
+                }
+                skip(']');
+            } else {
+                break;
+            }
         }
 
         if (pNewHead) {
diff --git a/libacc/tests/data/array.c b/libacc/tests/data/array.c
new file mode 100644
index 0000000..3af5e31
--- /dev/null
+++ b/libacc/tests/data/array.c
@@ -0,0 +1,77 @@
+// Array allocation tests
+
+void testLocalInt()
+{
+    int a[3];
+    a[0] = 1;
+    a[1] = 2;
+    a[2] = a[0] + a[1];
+    printf("localInt: %d\n", a[2]);
+}
+
+char a[3];
+double d[3];
+
+void testGlobalChar()
+{
+    a[0] = 1;
+    a[1] = 2;
+    a[2] = a[0] + a[1];
+    printf("globalChar: %d\n", a[2]);
+}
+
+void testGlobalDouble()
+{
+    d[0] = 1;
+    d[1] = 2;
+    d[2] = d[0] + d[1];
+    printf("globalDouble: %g\n", d[2]);
+}
+
+void testLocalDouble()
+{
+    double d[3];
+    float  m[12];
+    m[0] = 1.0f;
+    m[1] = 2.0f;
+    d[0] = 1.0;
+    d[1] = 2.0;
+    d[2] = d[0] + d[1];
+    m[2] = m[0] + m[1];
+    printf("localDouble: %g %g\n", d[2], m[2]);
+}
+
+void vectorAdd(int* a, int* b, float* c, int len) {
+    int i;
+    for(i = 0; i < len; i++) {
+        c[i] = a[i] + b[i];
+    }
+}
+
+void testArgs() {
+    int a[3], b[3];
+    float c[3];
+    int i;
+    int len = 3;
+    for(i = 0; i < len; i++) {
+        a[i] = i;
+        b[i] = i;
+        c[i] = 0;
+    }
+    vectorAdd(a,b,c, len);
+    printf("testArgs:");
+    for(i = 0; i < len; i++) {
+        printf(" %g", c[i]);
+    }
+    printf("\n");
+}
+
+int main()
+{
+    testLocalInt();
+    testLocalDouble();
+    testGlobalChar();
+    testGlobalDouble();
+    testArgs();
+    return 0;
+}
diff --git a/libacc/tests/test.py b/libacc/tests/test.py
index a3114ad..4ad2e13 100644
--- a/libacc/tests/test.py
+++ b/libacc/tests/test.py
@@ -387,6 +387,16 @@
 result: -2
 ""","""""")
 
+    def testArray(self):
+        self.compileCheck(["-R", "data/array.c"], """Executing compiled code:
+localInt: 3
+localDouble: 3 3
+globalChar: 3
+globalDouble: 3
+testArgs: 0 2 4
+result: 0
+""","""""")
+
 if __name__ == '__main__':
     if not outputCanRun():
         print "Many tests are expected to fail, because acc is not a 32-bit x86 Linux executable."