Allow parenthesized expressions as the value of defines

For example, this now works:

#define A (1 + 2)

Note that we still don't support defines with argument lists, so this is
still illegal:

#define A(X) (X + 2)

Also in this change: The compiler test script allows command-line
arguments to disable testing on ARM and to disable testing the output
of the old OTCC compiler.

Disabling testing on ARM is handy for developing front-end code when no
device or emulator is available.

Disabling testing OTCC output is handy for some 64-bit Linux environments,
because the original OTCC needs some tweaking to be fully compatible, and
I don't have time to investigate this problem right now.
diff --git a/libacc/tests/test.py b/libacc/tests/test.py
index 9691c27..ed20334 100644
--- a/libacc/tests/test.py
+++ b/libacc/tests/test.py
@@ -4,9 +4,28 @@
 import unittest
 import subprocess
 import os
-import sets
+import sys
 
 gArmInitialized = False
+gUseArm = True
+gUseX86 = True
+gRunOTCCOutput = True
+
+
+def parseArgv():
+    global gUseArm
+    global gRunOTCCOutput
+    for arg in sys.argv[1:]:
+        if arg == "--noarm":
+            print "--noarm detected, not testing on ARM"
+            gUseArm = False
+        elif arg == "--norunotcc":
+            print "--norunotcc detected, not running OTCC output"
+            gRunOTCCOutput = False
+        else:
+            print "Unknown parameter: ", arg
+            raise "Unknown parameter"
+    sys.argv = sys.argv[0:1]
 
 def compile(args):
     proc = subprocess.Popen(["acc"] + args, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
@@ -131,11 +150,13 @@
 
     def compileCheck(self, args, stdErrResult, stdOutResult="",
                      targets=['arm', 'x86']):
-        targetSet = sets.ImmutableSet(targets)
-        if False and 'x86' in targetSet:
+        global gUseArm
+        global gUseX86
+        targetSet = frozenset(targets)
+        if gUseX86 and 'x86' in targetSet:
             out, err = compile(args)
             self.checkResult(out, err, stdErrResult, stdOutResult)
-        if 'arm' in targetSet:
+        if gUseArm and 'arm' in targetSet:
             out = compileArm(rewritePaths(args))
             self.checkResult(out, "", stdErrResult, stdOutResult)
 
@@ -157,13 +178,17 @@
         "Executing compiled code:\nresult: 13\n", "Hello, world\n")
 
     def testRunOTCCANSI(self):
-        self.compileCheck(["-R", "data/otcc-ansi.c", "data/returnval.c"],
-            "Executing compiled code:\notcc-ansi.c: About to execute compiled code:\natcc-ansi.c: result: 42\nresult: 42\n", "",
-             ['x86'])
+        global gRunOTCCOutput
+        if gRunOTCCOutput:
+            self.compileCheck(["-R", "data/otcc-ansi.c", "data/returnval.c"],
+                "Executing compiled code:\notcc-ansi.c: About to execute compiled code:\natcc-ansi.c: result: 42\nresult: 42\n", "",
+                 ['x86'])
 
     def testRunOTCCANSI2(self):
-        self.compileCheck(["-R", "data/otcc-ansi.c", "data/otcc.c", "data/returnval.c"],
-            "Executing compiled code:\notcc-ansi.c: About to execute compiled code:\notcc.c: about to execute compiled code.\natcc-ansi.c: result: 42\nresult: 42\n", "",['x86'])
+        global gRunOTCCOutput
+        if gRunOTCCOutput:
+            self.compileCheck(["-R", "data/otcc-ansi.c", "data/otcc.c", "data/returnval.c"],
+                "Executing compiled code:\notcc-ansi.c: About to execute compiled code:\notcc.c: about to execute compiled code.\natcc-ansi.c: result: 42\nresult: 42\n", "",['x86'])
 
     def testRunConstants(self):
         self.compileCheck(["-R", "data/constants.c"],
@@ -409,8 +434,17 @@
 result: 0
 ""","""""")
 
-if __name__ == '__main__':
+    def testDefines(self):
+        self.compileCheck(["-R", "data/defines.c"], """Executing compiled code:
+result: 3
+""","""""")
+
+def main():
+    parseArgv()
     if not outputCanRun():
-        print "Many tests are expected to fail, because acc is not a 32-bit x86 Linux executable."
+        print "Can't run output of acc compiler."
     unittest.main()
 
+if __name__ == '__main__':
+    main()
+