culibs: cudyn/typetpl.h Source File

00001 /* Part of the culibs project, <http://www.eideticdew.org/culibs/>.
00002  * Copyright (C) 2005--2007  Petter Urkedal <urkedal@nbi.dk>
00003  *
00004  * This program is free software: you can redistribute it and/or modify
00005  * it under the terms of the GNU General Public License as published by
00006  * the Free Software Foundation, either version 3 of the License, or
00007  * (at your option) any later version.
00008  *
00009  * This program is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  * GNU General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU General Public License
00015  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
00016  */
00017 
00018 #ifndef CUDYN_TYPETPL_H
00019 #define CUDYN_TYPETPL_H
00020 
00021 #include <cudyn/fwd.h>
00022 #include <cufo/fwd.h>
00023 #include <cufo/tagdefs.h>
00024 
00025 CU_BEGIN_DECLARATIONS
00026 /* \defgroup cudyn_typetpl_h cudyn/typetpl.h: Type Definition Template Macros
00027  * @{ \ingroup cudyn_mod */
00028 
00029 #ifdef CUCONF_HAVE_LIBFFI
00030 #  define CUDYN_LIBFFI_ARG(x) , x
00031 #else
00032 #  define CUDYN_LIBFFI_ARG(x)
00033 #endif
00034 
00035 /* Elementary Type Templates
00036  * ------------------------- */
00037 
00038 /*!Template to create the declarations for dynamic implementation of
00039  * \a type_t, using \a NAME as a basis for function names.
00040  * This declares the following functions:
00041  * <pre>
00042  *     cuex_t cudyn_<i>NAME</i>(\a type_t \a x);
00043  *     // Convert \a x to a (hashconsed) dynamically typed representation
00044  *     // of \a x.
00045  *
00046  *     cu_bool_t cudyn_is_<i>NAME</i>(cuex_t \a e);
00047  *     // Returns true iff \a e was created with cudyn_NAME, or an alias
00048  *     // defined with \c CUDYN_ETYPE_ALIAS.
00049  *
00050  *     \a type_t cudyn_to_<i>NAME</i>(cuex_t \a e);
00051  *     // If \a e was created with cudyn_<i>NAME</i>(\a x) for some \a x,
00052  *     // returns \a x, otherwise undefined behaviour.
00053  *
00054  *     cuoo_type_t cudyn_<i>NAME</i>_type(void);
00055  *     // Returns the dynamic type of \a type_t.
00056  * </pre>
00057  */
00058 #define CUDYN_ETYPE_DCLN(NAME, type_t)                                  \
00059     extern cudyn_elmtype_t cudynP_##NAME##_type;                        \
00060                                                                         \
00061     CU_SINLINE cuoo_type_t                                              \
00062     cudyn_##NAME##_type()                                               \
00063     {                                                                   \
00064         return cudyn_elmtype_to_type(cudynP_##NAME##_type);             \
00065     }                                                                   \
00066                                                                         \
00067     CU_SINLINE cu_bool_t                                                \
00068     cudyn_is_##NAME(cuex_t e)                                           \
00069     {                                                                   \
00070         return cuex_meta(e) == cuoo_type_to_meta(cudyn_##NAME##_type());\
00071     }                                                                   \
00072                                                                         \
00073     CU_SINLINE cuex_t                                                   \
00074     cudyn_##NAME(type_t x)                                              \
00075     {                                                                   \
00076         if (sizeof(type_t) >= sizeof(cu_word_t))                        \
00077             return cuoo_halloc(cudyn_##NAME##_type(), sizeof(type_t), &x);\
00078         else {                                                          \
00079             struct {                                                    \
00080                 type_t xp;                                              \
00081                 char padding[sizeof(cu_word_t) > sizeof(type_t)         \
00082                              ? sizeof(cu_word_t) - sizeof(type_t) : 1]; \
00083             } tpl = { x };                                              \
00084             return cuoo_halloc(cudyn_##NAME##_type(),                   \
00085                                 sizeof(cu_word_t), &tpl);               \
00086         }                                                               \
00087     }                                                                   \
00088                                                                         \
00089     CU_SINLINE type_t                                                   \
00090     cudyn_to_##NAME(cuex_t e)                                           \
00091     {                                                                   \
00092         return *(type_t *)(cu_ptr_add(e, CUOO_HCOBJ_SHIFT));            \
00093     }
00094 
00095 #define CUDYN_ETYPE_DEFN(NAME, type_t)                                  \
00096     cudyn_elmtype_t cudynP_##NAME##_type;                               \
00097     struct cudynP_##NAME##_aligntest { char ch; type_t x; };
00098 
00099 #define CUDYN_ETYPE_INIT(NAME, UCNAME, type_t, kind, ffitype)           \
00100     cudynP_##NAME##_type =                                              \
00101         cudyn_elmtype_new(CUOO_SHAPE_SCALAR_##UCNAME,                   \
00102                           cudynP_##NAME##_impl, sizeof(type_t),         \
00103                           offsetof(struct cudynP_##NAME##_aligntest, x) \
00104                           CUDYN_LIBFFI_ARG(ffitype));                   \
00105     cuoo_prop_define_ptr(cuoo_raw_c_name_prop(),                        \
00106                           cudynP_##NAME##_type,                         \
00107                           cu_idr_by_cstr(#type_t));
00108 
00109 #define CUDYN_ETYPE_DEFN_PRINT(NAME, type_t, format)                    \
00110     CUDYN_ETYPE_DEFN(NAME, type_t)                                      \
00111                                                                         \
00112     static void cudynP_##NAME##_print(cuex_t e, FILE *out)              \
00113     { fprintf(out, "%"format, cudyn_to_##NAME(e)); }                    \
00114                                                                         \
00115     static void                                                         \
00116     cudynP_##NAME##_foprint(cufo_stream_t fos, cufo_prispec_t spec, void *e) \
00117     { cufo_printf(fos, "%<%"format"%>", cufoT_literal, cudyn_to_##NAME(e)); }
00118 
00119 #define CUDYN_ETYPE_DEFN_PRINTIND(NAME, type_t, PRI, IND)               \
00120     CUDYN_ETYPE_DEFN(NAME, type_t)                                      \
00121                                                                         \
00122     static void cudynP_##NAME##_print(cuex_t e, FILE *out)              \
00123     { fprintf(out, "%"PRI""IND, cudyn_to_##NAME(e)); }                  \
00124                                                                         \
00125     static void                                                         \
00126     cudynP_##NAME##_foprint(cufo_stream_t fos, cufo_prispec_t spec, cuex_t e) \
00127     {                                                                   \
00128         cufo_printf(fos, "%<%"PRI"%<"IND"%>%>",                         \
00129                     cufoT_literal, cudyn_to_##NAME(e), cufoT_special);  \
00130     }
00131 
00132 
00133 /*!Template to set up function aliases for dynamic implemetation of
00134  * \a type_t with name \a NAME in terms of \a IMPLNAME. */
00135 #define CUDYN_ETYPE_ALIAS(NAME, type_t, IMPLNAME)                       \
00136     CU_SINLINE cuoo_type_t cudyn_##NAME##_type()                        \
00137     { return cudyn_##IMPLNAME##_type(); }                               \
00138     CU_SINLINE cu_bool_t cudyn_is_##NAME(cuex_t e)                      \
00139     { return cudyn_is_##IMPLNAME(e); }                                  \
00140     CU_SINLINE cuex_t cudyn_##NAME(type_t x)                            \
00141     { return cudyn_##IMPLNAME(x); }                                     \
00142     CU_SINLINE type_t cudyn_to_##NAME(cuex_t e)                         \
00143     { return (type_t)cudyn_to_##IMPLNAME(e); }
00144 
00145 #define cudyn_condsize_none ((size_t)-1)
00146 
00147 
00148 /* Array Type Templates
00149  * -------------------- */
00150 
00151 /*!Template to create the declarations for dynamic implementations of
00152  * \a type_t including array variants, using \a NAME as a basis for
00153  * function names.  In addition to what \ref CUDYN_ETYPE_DCLN declares,
00154  * <pre>
00155  *     cuex_t cudyn_<i>NAME</i>arr(size_t \a cnt, \a type_t *\a arr);
00156  *     // Convert an array \a arr of \a cnt elements to a dynamic
00157  *     // representation.
00158  *
00159  *     size_t cudyn_<i>NAME</i>arr_condsize(cuex_t \a e)
00160  *     // If \a e is an array of \a type_t, return its size, else return
00161  *     // cudyn_condsize_none.
00162  *
00163  *     \a type_t *cudyn_to_<i>NAME</i>arr(cuex_t \a e);
00164  *     // If \a e was created with cudyn_<i>NAME</i>arr(size, arr) for some
00165  *     // size and arr, return arr, else undefined behaviour.
00166  *
00167  *     cuoo_type_t cudyn_<i>NAME</i>arr_type(size_t \a cnt);
00168  *     // Returns the dynamic type of \a type_t[\a cnt]
00169  * </pre>
00170  */
00171 #define CUDYN_ARRTYPE_DCLN(NAME, type_t)                                \
00172     CU_SINLINE cuoo_type_t                                              \
00173     cudyn_##NAME##arr_type(size_t size)                                 \
00174     {                                                                   \
00175         return cudyn_arrtype_to_type(                                   \
00176                    cudyn_arrtype(cudyn_##NAME##_type(), size));         \
00177     }                                                                   \
00178                                                                         \
00179     size_t cudyn_##NAME##arr_condsize(cuex_t);                          \
00180                                                                         \
00181     CU_SINLINE size_t                                                   \
00182     cudyn_##NAME##arr_size(cuex_t ex)                                   \
00183     {                                                                   \
00184         return cudyn_arrtype_elt_cnt(cudyn_arrtype_from_meta(cuex_meta(ex)));\
00185     }                                                                   \
00186                                                                         \
00187     CU_SINLINE cuex_t                                                   \
00188     cudyn_##NAME##arr(size_t cnt, type_t *arr)                          \
00189     {                                                                   \
00190         if (sizeof(type_t) >= sizeof(cu_word_t))                        \
00191             return cuoo_halloc(cudyn_##NAME##arr_type(cnt),             \
00192                                 sizeof(type_t)*cnt, arr);               \
00193         else                                                            \
00194             cu_bugf("unimplemented");                                   \
00195     }                                                                   \
00196                                                                         \
00197     CU_SINLINE type_t *                                                 \
00198     cudyn_##NAME##arr_arr(cuex_t e)                                     \
00199     { return (type_t *)(cu_ptr_add(e, CUOO_HCOBJ_SHIFT)); }             \
00200                                                                         \
00201     CU_SINLINE type_t                                                   \
00202     cudyn_##NAME##arr_at(cuex_t e, size_t i)                            \
00203     { return cudyn_##NAME##arr_arr(e)[i]; }
00204 
00205 #define CUDYN_ARRTYPE_DEFN(NAME, type_t)                                \
00206     size_t                                                              \
00207     cudyn_##NAME##arr_condsize(cuex_t e)                                \
00208     {                                                                   \
00209         cuex_meta_t meta = cuex_meta(e);                                \
00210         cudyn_arrtype_t t;                                              \
00211         if (!cuex_meta_is_type(meta)                                    \
00212             ||!cuoo_type_is_arrtype(cuoo_type_from_meta(meta)))         \
00213             return cudyn_condsize_none;                                 \
00214         t = cudyn_arrtype_from_meta(meta);                              \
00215         if (cudyn_arrtype_elt_type(t) != cudyn_##NAME##_type())         \
00216             return cudyn_condsize_none;                                 \
00217         return cudyn_arrtype_elt_cnt(t);                                \
00218     }
00219 
00220 #define CUDYN_ETYPEARR_DCLN(NAME, type_t)                               \
00221     CUDYN_ETYPE_DCLN(NAME, type_t)                                      \
00222     CUDYN_ARRTYPE_DCLN(NAME, type_t)
00223 
00224 #define CUDYN_ETYPEARR_DEFN(NAME, type_t)                               \
00225     CUDYN_ETYPE_DEFN(NAME, type_t)                                      \
00226     CUDYN_ARRTYPE_DEFN(NAME, type_t)
00227 
00228 #define CUDYN_ETYPEARR_INIT CUDYN_ETYPE_INIT
00229 
00230 #define CUDYN_ETYPEARR_DEFN_PRINT CUDYN_ETYPE_DEFN_PRINT
00231 #define CUDYN_ETYPEARR_DEFN_PRINTIND CUDYN_ETYPE_DEFN_PRINTIND
00232 
00233 /*!Template to set up function aliases for dynamic implementation of
00234  * \a type_t with name \a NAME in terms of \a IMPLNAME including array
00235  * versions.  The two types must have the same size and be layout
00236  * compatible. */
00237 #define CUDYN_ETYPEARR_ALIAS(NAME, type_t, IMPLNAME)                    \
00238     CUDYN_ETYPE_ALIAS(NAME, type_t, IMPLNAME)                           \
00239     CU_SINLINE cuoo_type_t cudyn_##NAME##arr_type(size_t cnt)           \
00240     { return cudyn_##IMPLNAME##arr_type(cnt); }                         \
00241     CU_SINLINE int cudyn_##NAME##_condsize(cuex_t e)                    \
00242     { return cudyn_##IMPLNAME##arr_condsize(e); }                       \
00243     CU_SINLINE cuex_t cudyn_##NAME##arr(size_t cnt, type_t *arr)        \
00244     { return cudyn_##IMPLNAME##arr(cnt, (IMPLNAME##_t *)arr); }         \
00245     CU_SINLINE type_t *cudyn_##NAME##arr_arr(cuex_t e)                  \
00246     { return (type_t *)cudyn_##IMPLNAME##arr_arr(e); }
00247 
00248 /*!@}*/
00249 CU_END_DECLARATIONS
00250 
00251 #endif