From 891e5e58d346306b2a749cb9cfd6111d81b24119 Mon Sep 17 00:00:00 2001 From: Rhys Weatherley Date: Wed, 12 May 2004 00:05:41 +0000 Subject: [PATCH] Add the "SameType" and "SameShape" builtins, to assist with unit testing type coercions. --- ChangeLog | 4 ++ dpas/dpas-builtin.c | 64 ++++++++++++++++++++++++++++++ dpas/dpas-parser.y | 8 +--- dpas/dpas-types.c | 95 ++++++++++++++++++++++++++++++++++++++++++++- dpas/dpas-types.h | 5 +++ 5 files changed, 168 insertions(+), 8 deletions(-) diff --git a/ChangeLog b/ChangeLog index 66b0df2..b557b11 100644 --- 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 * 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 d1fe784..3f9102e 100644 --- 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 3561095..b606faf 100644 --- 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 0bc1ae8..d933480 100644 --- 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 95f4fe5..e7cc9a3 100644 --- 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 -- 2.47.3