From 95deed38e493608522d02a9e5ba4caeb00518338 Mon Sep 17 00:00:00 2001
From: Minero Aoki <mineroaoki@gmail.com>
Date: Sun, 17 Feb 2008 18:33:18 +0000
Subject: [PATCH] * net/loveruby/cflat/compiler/TypeChecker.java (checkCond):
 cond expr might be an array, which is a parameter. *
 net/loveruby/cflat/compiler/TypeChecker.java (isInvalidReturnType): array is
 returnable. * net/loveruby/cflat/compiler/TypeChecker.java
 (isInvalidLHSType): "unallocated array" means an array which is parameter. 
 Length does not matter. *
 net/loveruby/cflat/compiler/DereferenceChecker.java: should check an operand
 of ++/-- is assignable.

git-svn-id: file:///Users/aamine/c/gitwork/public/cbc/trunk@3911 1b9489fe-b721-0410-924e-b54b9192deb8
---
 ChangeLog                                       | 15 +++++++++++++++
 .../cflat/compiler/DereferenceChecker.java      | 15 ++++++++++++++-
 net/loveruby/cflat/compiler/TypeChecker.java    | 17 ++++++++---------
 3 files changed, 37 insertions(+), 10 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index a219714..8e9fe31 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,18 @@
+Mon Feb 18 03:33:12 2008  Minero Aoki  <aamine@loveruby.net>
+
+	* net/loveruby/cflat/compiler/TypeChecker.java (checkCond): cond
+	  expr might be an array, which is a parameter.
+
+	* net/loveruby/cflat/compiler/TypeChecker.java
+	  (isInvalidReturnType): array is returnable.
+
+	* net/loveruby/cflat/compiler/TypeChecker.java (isInvalidLHSType):
+	  "unallocated array" means an array which is parameter.  Length
+	  does not matter.
+
+	* net/loveruby/cflat/compiler/DereferenceChecker.java: should
+	  check an operand of ++/-- is assignable.
+
 Mon Feb 18 02:33:16 2008  Minero Aoki  <aamine@loveruby.net>
 
 	* net/loveruby/cflat/ast/UndefinedVariable.java: should always be
diff --git a/net/loveruby/cflat/compiler/DereferenceChecker.java b/net/loveruby/cflat/compiler/DereferenceChecker.java
index 1ab6c59..ae22ac0 100644
--- a/net/loveruby/cflat/compiler/DereferenceChecker.java
+++ b/net/loveruby/cflat/compiler/DereferenceChecker.java
@@ -97,6 +97,20 @@ class DereferenceChecker extends Visitor {
     // Expressions
     //
 
+    public void visit(PrefixOpNode node) {
+        super.visit(node);
+        if (! node.expr().isAssignable()) {
+            semanticError(node.expr(), "cannot increment/decrement");
+        }
+    }
+
+    public void visit(SuffixOpNode node) {
+        super.visit(node);
+        if (! node.expr().isAssignable()) {
+            semanticError(node.expr(), "cannot increment/decrement");
+        }
+    }
+
     public void visit(FuncallNode node) {
         super.visit(node);
         if (! node.expr().isCallable()) {
@@ -109,7 +123,6 @@ class DereferenceChecker extends Visitor {
         if (! node.expr().isDereferable()) {
             semanticError(node, "indexing non-array/pointer expression");
         }
-        check(node.index());
     }
 
     public void visit(MemberNode node) {
diff --git a/net/loveruby/cflat/compiler/TypeChecker.java b/net/loveruby/cflat/compiler/TypeChecker.java
index fe6871d..ead0730 100644
--- a/net/loveruby/cflat/compiler/TypeChecker.java
+++ b/net/loveruby/cflat/compiler/TypeChecker.java
@@ -106,11 +106,7 @@ class TypeChecker extends Visitor {
     }
 
     protected void checkCond(ExprNode cond) {
-        Type t = cond.type();
-        if (!t.isInteger() && !t.isPointer()) {
-            notIntegerError(cond, t);
-            return;
-        }
+        mustBeScalar(cond);
     }
 
     public void visit(SwitchNode node) {
@@ -193,11 +189,11 @@ class TypeChecker extends Visitor {
     }
 
     protected boolean isInvalidReturnType(Type t) {
-        return t.isStruct() || t.isUnion() || t.isArray();
+        return isNotScalarType(t);
     }
 
     protected boolean isInvalidParameterType(Type t) {
-        return isInvalidLHSType(t);
+        return isNotScalarType(t);
     }
 
     protected boolean isInvalidVariableType(Type t) {
@@ -205,11 +201,14 @@ class TypeChecker extends Visitor {
     }
 
     protected boolean isInvalidLHSType(Type t) {
-        return t.isStruct() || t.isUnion()
-                || t.isAllocatedArray() || t.isVoid();
+        return isNotScalarType(t);
     }
 
     protected boolean isInvalidRHSType(Type t) {
+        return isNotScalarType(t);
+    }
+
+    protected boolean isNotScalarType(Type t) {
         return t.isStruct() || t.isUnion() || t.isVoid();
     }