Add the "SameType" and "SameShape" builtins, to assist with unit

testing type coercions.

diff --git a/ChangeLog b/ChangeLog
index 66b0df268db81f5e134296440d492cc7210e06ad..b557b11bc4a95f5db64f2b4ca8bf4cb803775c82 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -5,6 +5,10 @@
        non.libs versions of the so paths, because some versions of libtool
        add .libs implicitly and others don't.
 
+       * dpas/dpas-builtin.c, dpas/dpas-parser.y, dpas/dpas-types.c,
+       dpas/dpas-types.h: add the "SameType" and "SameShape" builtins,
+       to assist with unit testing type coercions.
+
 2004-05-11  Rhys Weatherley  <rweather@southern-storm.com.au>
 
        * include/jit/jit-insn.h, jit/jit-insn.c, jit/jit-interp.cpp,

diff --git a/dpas/dpas-builtin.c b/dpas/dpas-builtin.c
index d1fe7845339c33cb737808f5b2af5d83d99ff201..3f9102e27ba6b243c31b994c733ecabd95b336a8 100644 (file)
--- a/dpas/dpas-builtin.c
+++ b/dpas/dpas-builtin.c
@@ -348,6 +348,66 @@ static dpas_semvalue dpas_dispose(dpas_semvalue *args, int num_args)
        return result;
 }
 
+/*
+ * Determine if two values/types have identical types.
+ */
+static dpas_semvalue dpas_same_type(dpas_semvalue *args, int num_args)
+{
+       dpas_semvalue result;
+       if((!dpas_sem_is_rvalue(args[0]) && !dpas_sem_is_type(args[0])) ||
+          (!dpas_sem_is_rvalue(args[1]) && !dpas_sem_is_type(args[1])))
+       {
+               dpas_error("invalid operands to `SameType'");
+               dpas_sem_set_error(result);
+       }
+       else if(dpas_type_identical(dpas_sem_get_type(args[0]),
+                                                               dpas_sem_get_type(args[1]), 0))
+       {
+               dpas_sem_set_rvalue
+                       (result, dpas_type_boolean,
+                        jit_value_create_nint_constant
+                               (dpas_current_function(), dpas_type_boolean, 1));
+       }
+       else
+       {
+               dpas_sem_set_rvalue
+                       (result, dpas_type_boolean,
+                        jit_value_create_nint_constant
+                               (dpas_current_function(), dpas_type_boolean, 0));
+       }
+       return result;
+}
+
+/*
+ * Determine if two values/types have the same basic shape.
+ */
+static dpas_semvalue dpas_same_shape(dpas_semvalue *args, int num_args)
+{
+       dpas_semvalue result;
+       if((!dpas_sem_is_rvalue(args[0]) && !dpas_sem_is_type(args[0])) ||
+          (!dpas_sem_is_rvalue(args[1]) && !dpas_sem_is_type(args[1])))
+       {
+               dpas_error("invalid operands to `SameShape'");
+               dpas_sem_set_error(result);
+       }
+       else if(dpas_type_identical(dpas_sem_get_type(args[0]),
+                                                               dpas_sem_get_type(args[1]), 1))
+       {
+               dpas_sem_set_rvalue
+                       (result, dpas_type_boolean,
+                        jit_value_create_nint_constant
+                               (dpas_current_function(), dpas_type_boolean, 1));
+       }
+       else
+       {
+               dpas_sem_set_rvalue
+                       (result, dpas_type_boolean,
+                        jit_value_create_nint_constant
+                               (dpas_current_function(), dpas_type_boolean, 0));
+       }
+       return result;
+}
+
 /*
  * Builtins that we currently recognize.
  */
@@ -357,6 +417,8 @@ static dpas_semvalue dpas_dispose(dpas_semvalue *args, int num_args)
 #define        DPAS_BUILTIN_TERMINATE          4
 #define        DPAS_BUILTIN_NEW                        5
 #define        DPAS_BUILTIN_DISPOSE            6
+#define        DPAS_BUILTIN_SAMETYPE           7
+#define        DPAS_BUILTIN_SAMESHAPE          8
 
 /*
  * Table that defines the builtins.
@@ -376,6 +438,8 @@ static dpas_builtin const builtins[] = {
        {"Terminate",   DPAS_BUILTIN_TERMINATE, dpas_terminate,  1},
        {"New",                 DPAS_BUILTIN_NEW,               dpas_new,                1},
        {"Dispose",             DPAS_BUILTIN_DISPOSE,   dpas_dispose,    1},
+       {"SameType",    DPAS_BUILTIN_SAMETYPE,  dpas_same_type,  2},
+       {"SameShape",   DPAS_BUILTIN_SAMESHAPE, dpas_same_shape, 2},
 };
 #define        num_builtins    (sizeof(builtins) / sizeof(dpas_builtin))
 

diff --git a/dpas/dpas-parser.y b/dpas/dpas-parser.y
index 3561095059c6a069657eae601796bb1571eee085..b606faf8b0b4dd880a578cba2c1b97690be7d110 100644 (file)
--- a/dpas/dpas-parser.y
+++ b/dpas/dpas-parser.y
@@ -2408,13 +2408,7 @@ Power
        ;
 
 Factor
-       : Variable                                              {
-                               if(!dpas_sem_is_rvalue($1) && !dpas_sem_is_error($1))
-                               {
-                                       dpas_error("invalid r-value used in expression");
-                               }
-                               $$ = $1;
-                       }
+       : Variable                                              { $$ = $1; }
        | BasicConstant                                 {
                                jit_value_t value = jit_value_create_constant
                                        (dpas_current_function(), &($1));

diff --git a/dpas/dpas-types.c b/dpas/dpas-types.c
index 0bc1ae827ffa0cedaa7f692aa73607854f0eb6cf..d93348071665677865a72e65d54514e593ac03a9 100644 (file)
--- a/dpas/dpas-types.c
+++ b/dpas/dpas-types.c
@@ -130,7 +130,7 @@ void dpas_init_types(void)
        dpas_type_nil = jit_type_create_tagged
                (jit_type_void_ptr, DPAS_TAG_NIL, 0, 0, 1);
        dpas_type_size_t = get_uint_type(sizeof(size_t));
-       dpas_type_ptrdiff_t = get_uint_type(sizeof(ptrdiff_t));
+       dpas_type_ptrdiff_t = get_int_type(sizeof(ptrdiff_t));
 
        /*
         * Register all of the builtin types.
@@ -1192,3 +1192,96 @@ jit_type_t dpas_type_is_var(jit_type_t type)
        }
        return 0;
 }
+
+int dpas_type_identical(jit_type_t type1, jit_type_t type2, int normalize)
+{
+       if(normalize)
+       {
+               type1 = jit_type_normalize(type1);
+               type2 = jit_type_normalize(type2);
+       }
+       if(jit_type_get_kind(type1) != jit_type_get_kind(type2))
+       {
+               return 0;
+       }
+       switch(jit_type_get_kind(type1))
+       {
+               case JIT_TYPE_STRUCT:
+               case JIT_TYPE_UNION:
+               {
+                       if(jit_type_get_size(type1) != jit_type_get_size(type2))
+                       {
+                               return 0;
+                       }
+               }
+               break;
+
+               case JIT_TYPE_SIGNATURE:
+               {
+                       /* TODO */
+               }
+               break;
+
+               case JIT_TYPE_PTR:
+               {
+                       return dpas_type_identical
+                               (jit_type_get_ref(type1), jit_type_get_ref(type2), 0);
+               }
+               /* Not reached */
+
+               case JIT_TYPE_FIRST_TAGGED + DPAS_TAG_NAME:
+               {
+                       if(jit_stricmp((char *)jit_type_get_tagged_data(type1),
+                                                  (char *)jit_type_get_tagged_data(type2)) != 0)
+                       {
+                               return 0;
+                       }
+               }
+               break;
+
+               case JIT_TYPE_FIRST_TAGGED + DPAS_TAG_VAR:
+               {
+                       return dpas_type_identical
+                               (jit_type_get_tagged_type(type1),
+                                jit_type_get_tagged_type(type2), 0);
+               }
+               /* Not reached */
+
+               case JIT_TYPE_FIRST_TAGGED + DPAS_TAG_SUBRANGE:
+               {
+               }
+               break;
+
+               case JIT_TYPE_FIRST_TAGGED + DPAS_TAG_ENUM:
+               {
+                       if(jit_stricmp
+                               (((dpas_enum *)jit_type_get_tagged_data(type1))->name,
+                                ((dpas_enum *)jit_type_get_tagged_data(type2))->name) != 0)
+                       {
+                               return 0;
+                       }
+               }
+               break;
+
+               case JIT_TYPE_FIRST_TAGGED + DPAS_TAG_SET:
+               {
+                       return dpas_type_identical
+                               ((jit_type_t)jit_type_get_tagged_data(type1),
+                                (jit_type_t)jit_type_get_tagged_data(type2), 0);
+               }
+               /* Not reached */
+
+               case JIT_TYPE_FIRST_TAGGED + DPAS_TAG_ARRAY:
+               {
+                       /* TODO */
+               }
+               break;
+
+               case JIT_TYPE_FIRST_TAGGED + DPAS_TAG_CONFORMANT_ARRAY:
+               {
+                       /* TODO */
+               }
+               break;
+       }
+       return 1;
+}

diff --git a/dpas/dpas-types.h b/dpas/dpas-types.h
index 95f4fe5f7e44739dc5443049c852fc1968b861e0..e7cc9a320800496579811dcdda478d74853f2edc 100644 (file)
--- a/dpas/dpas-types.h
+++ b/dpas/dpas-types.h
@@ -196,6 +196,11 @@ int dpas_type_is_record(jit_type_t type);
  */
 jit_type_t dpas_type_is_var(jit_type_t type);
 
+/*
+ * Determine if two types are identical.
+ */
+int dpas_type_identical(jit_type_t type1, jit_type_t type2, int normalize);
+
 #ifdef __cplusplus
 };
 #endif