Lichen

templates/ops.c

934:2989aab1b4f7
7 months ago Paul Boddie Renamed the utf8string class to unicode, eliminating the unicode function. This means that the simple case of merely returning an object if it is already a Unicode object no longer occurs when using the unicode callable, but such behaviour might be better supported with more general customised instantiation functionality.
     1 /* Common operations.     2      3 Copyright (C) 2015, 2016, 2017, 2018 Paul Boddie <paul@boddie.org.uk>     4      5 This program is free software; you can redistribute it and/or modify it under     6 the terms of the GNU General Public License as published by the Free Software     7 Foundation; either version 3 of the License, or (at your option) any later     8 version.     9     10 This program is distributed in the hope that it will be useful, but WITHOUT    11 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS    12 FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more    13 details.    14     15 You should have received a copy of the GNU General Public License along with    16 this program.  If not, see <http://www.gnu.org/licenses/>.    17 */    18     19 #include "gc.h" /* GC_MALLOC, GC_REALLOC */    20 #include "types.h"    21 #include "ops.h"    22 #include "progops.h" /* for raising errors */    23 #include "progconsts.h"    24 #include "progtypes.h"    25     26 /* Get object reference from attribute. */    27     28 __ref __VALUE(__attr attr)    29 {    30     if (!__INTEGER(attr))    31         return attr.value;    32     else    33         return &__common_integer_obj;    34 }    35     36 /* Basic structure tests. */    37     38 static inline int __HASATTR(__ref obj, int pos, int code)    39 {    40     return (pos < obj->table->size) && (obj->table->attrs[pos] == code);    41 }    42     43 /* Direct access and manipulation of static objects. */    44     45 __attr __load_static_ignore(__ref obj)    46 {    47     return __ATTRVALUE(obj);    48 }    49     50 __attr __load_static_replace(__attr context, __ref obj)    51 {    52     return __update_context(context, __ATTRVALUE(obj));    53 }    54     55 __attr __load_static_test(__attr context, __ref obj)    56 {    57     return __test_context(context, __ATTRVALUE(obj));    58 }    59     60 /* Direct retrieval operations, returning and setting attributes. */    61     62 __attr __load_via_object__(__ref obj, int pos)    63 {    64     return obj->attrs[pos];    65 }    66     67 __attr __load_via_class__(__ref obj, int pos)    68 {    69     return __load_via_object__(__get_class(obj), pos);    70 }    71     72 __attr __get_class_and_load__(__ref obj, int pos)    73 {    74     if (__is_instance(obj))    75         return __load_via_class__(obj, pos);    76     else    77         return __load_via_object__(obj, pos);    78 }    79     80 /* Direct storage operations. */    81     82 int __store_via_object__(__ref obj, int pos, __attr value)    83 {    84     obj->attrs[pos] = value;    85     return 1;    86 }    87     88 int __store_via_class__(__ref obj, int pos, __attr value)    89 {    90     return __store_via_object__(__get_class(obj), pos, value);    91 }    92     93 int __get_class_and_store__(__ref obj, int pos, __attr value)    94 {    95     /* Forbid class-relative assignments. */    96     97     __raise_type_error();    98     return 0;    99 }   100    101 /* Introspection. */   102    103 int __is_instance(__ref obj)   104 {   105     return obj->pos == __INSTANCEPOS;   106 }   107    108 int __is_subclass(__ref obj, __attr cls)   109 {   110     return __HASATTR(obj, __TYPEPOS(__VALUE(cls)), __TYPECODE(__VALUE(cls)));   111 }   112    113 int __is_instance_subclass(__ref obj, __attr cls)   114 {   115     return __is_instance(obj) && __HASATTR(__get_class(obj), __TYPEPOS(__VALUE(cls)), __TYPECODE(__VALUE(cls)));   116 }   117    118 int __is_type_instance(__ref obj)   119 {   120     return __HASATTR(__get_class(obj), __TYPE_CLASS_POS, __TYPE_CLASS_CODE);   121 }   122    123 __ref __get_class(__ref obj)   124 {   125     return __VALUE(__load_via_object(obj, __class__));   126 }   127    128 __attr __get_class_attr(__ref obj)   129 {   130     return __load_via_object(obj, __class__);   131 }   132    133 /* Attribute testing operations. */   134    135 __ref __test_specific_instance(__ref obj, __ref type)   136 {   137     return __get_class(obj) == type ? obj : 0;   138 }   139    140 __ref __test_specific_object(__ref obj, __ref type)   141 {   142     return __test_specific_type(obj, type) || __test_specific_instance(obj, type) ? obj : 0;   143 }   144    145 __ref __test_specific_type(__ref obj, __ref type)   146 {   147     return obj == type ? obj : 0;   148 }   149    150 __ref __test_common_instance__(__ref obj, int pos, int code)   151 {   152     return __HASATTR(__get_class(obj), pos, code) ? obj : 0;   153 }   154    155 __ref __test_common_object__(__ref obj, int pos, int code)   156 {   157     return __test_common_type__(obj, pos, code) || __test_common_instance__(obj, pos, code) ? obj : 0;   158 }   159    160 __ref __test_common_type__(__ref obj, int pos, int code)   161 {   162     return __HASATTR(obj, pos, code) ? obj : 0;   163 }   164    165 /* Attribute testing and retrieval operations. */   166    167 __attr __check_and_load_via_object_null(__ref obj, int pos, int code)   168 {   169     if (__HASATTR(obj, pos, code))   170         return __load_via_object__(obj, pos);   171     else   172         return __NULL;   173 }   174    175 __attr __check_and_load_via_class__(__ref obj, int pos, int code)   176 {   177     return __check_and_load_via_object__(__get_class(obj), pos, code);   178 }   179    180 __attr __check_and_load_via_object__(__ref obj, int pos, int code)   181 {   182     if (__HASATTR(obj, pos, code))   183         return __load_via_object__(obj, pos);   184    185     __raise_type_error();   186     return __NULL;   187 }   188    189 __attr __check_and_load_via_any__(__ref obj, int pos, int code)   190 {   191     __attr out = __check_and_load_via_object_null(obj, pos, code);   192     if (__ISNULL(out))   193         out = __check_and_load_via_class__(obj, pos, code);   194     return out;   195 }   196    197 /* Attribute testing and storage operations. */   198    199 int __check_and_store_via_class__(__ref obj, int pos, int code, __attr value)   200 {   201     /* Forbid class-relative assignments. */   202    203     __raise_type_error();   204     return 0;   205 }   206    207 int __check_and_store_via_object__(__ref obj, int pos, int code, __attr value)   208 {   209     if (__HASATTR(obj, pos, code))   210     {   211         __store_via_object__(obj, pos, value);   212         return 1;   213     }   214    215     /* No suitable attribute. */   216    217     __raise_type_error();   218     return 0;   219 }   220    221 int __check_and_store_via_any__(__ref obj, int pos, int code, __attr value)   222 {   223     if (__check_and_store_via_object__(obj, pos, code, value))   224         return 1;   225    226     /* Forbid class-relative assignments. */   227    228     __raise_type_error();   229     return 0;   230 }   231    232 /* Context-related operations. */   233    234 int __test_context_update(__attr context, __attr attr, int invoke)   235 {   236     /* Return whether the context should be updated for the attribute. */   237    238     __attr attrcontext = __CONTEXT_AS_VALUE(attr);   239     __ref attrcontextvalue = __VALUE(attrcontext);   240    241     /* Preserve any existing null or instance context. */   242    243     if (__ISNULL(attrcontext) || __is_instance(attrcontextvalue))   244         return 0;   245    246     /* Test any instance context against the context employed by the   247        attribute. */   248    249     if (__is_instance(__VALUE(context)))   250     {   251         /* Obtain the special class attribute position and code identifying the   252            attribute context's class, inspecting the context instance for   253            compatibility. */   254    255         if (__test_common_instance__(__VALUE(context), __TYPEPOS(attrcontextvalue), __TYPECODE(attrcontextvalue)))   256             return 1;   257         else   258             __raise_type_error();   259     }   260    261     /* Without a null or instance context, an invocation cannot be performed. */   262    263     if (invoke)   264         __raise_unbound_method_error();   265    266     /* Test for access to a type class attribute using a type instance. */   267    268     if (__test_specific_type(attrcontextvalue, &__TYPE_CLASS_TYPE) && __is_type_instance(__VALUE(context)))   269         return 1;   270    271     /* Otherwise, preserve the attribute as retrieved. */   272    273     return 0;   274 }   275    276 __attr __test_context(__attr context, __attr attr)   277 {   278     /* Update the context or return the unchanged attribute. */   279    280     if (__test_context_update(context, attr, 0))   281         return __update_context(context, attr);   282     else   283         return attr;   284 }   285    286 __attr __update_context(__attr context, __attr attr)   287 {   288     return __new_wrapper(context, attr);   289 }   290    291 __attr __test_context_revert(int target, __attr context, __attr attr, __attr contexts[])   292 {   293     /* Revert the local context to that employed by the attribute if the   294        supplied context is not appropriate. */   295    296     if (!__test_context_update(context, attr, 1))   297         contexts[target] = __CONTEXT_AS_VALUE(attr);   298     return attr;   299 }   300    301 __attr __test_context_static(int target, __attr context, __ref value, __attr contexts[])   302 {   303     /* Set the local context to the specified context if appropriate. */   304    305     if (__test_context_update(context, __ATTRVALUE(value), 1))   306         contexts[target] = context;   307     return __ATTRVALUE(value);   308 }   309    310 /* Context testing for invocations. */   311    312 int __type_method_invocation(__attr context, __attr target)   313 {   314     __attr targetcontext = __CONTEXT_AS_VALUE(target);   315    316     /* Require instances, not classes, where methods are function instances. */   317    318     if (!__is_instance(__VALUE(target)))   319         return 0;   320    321     /* Access the context of the callable and test if it is the type object. */   322    323     return (!__ISNULL(targetcontext) && __test_specific_type(__VALUE(targetcontext), &__TYPE_CLASS_TYPE) && __is_type_instance(__VALUE(context)));   324 }   325    326 __attr __unwrap_callable(__attr callable)   327 {   328     __attr value = __check_and_load_via_object_null(__VALUE(callable), __ATTRPOS(__value__), __ATTRCODE(__value__));   329     return __VALUE(value) ? value : callable;   330 }   331    332 __attr (*__get_function_unchecked(__attr target))()   333 {   334     return __load_via_object(__VALUE(__unwrap_callable(target)), __fn__).fn;   335 }   336    337 __attr (*__get_function(__attr context, __attr target))()   338 {   339     return __get_function_unwrapped(context, __unwrap_callable(target));   340 }   341    342 __attr (*__get_function_unwrapped(__attr context, __attr target))()   343 {   344     /* Require null or instance contexts for functions and methods respectively,   345        or type instance contexts for type methods. */   346    347     if (__ISNULL(context) || __is_instance(__VALUE(context)) || __type_method_invocation(context, target))   348         return __get_function_member(target);   349     else   350         return __unbound_method;   351 }   352    353 __attr (*__get_function_member(__attr target))()   354 {   355     return __load_via_object(__VALUE(target), __fn__).fn;   356 }   357    358 __attr (*__check_and_get_function(__attr context, __attr target))()   359 {   360     return __check_and_get_function_unwrapped(context, __unwrap_callable(target));   361 }   362    363 __attr (*__check_and_get_function_unwrapped(__attr context, __attr target))()   364 {   365     /* Require null or instance contexts for functions and methods respectively,   366        or type instance contexts for type methods. */   367    368     if (__ISNULL(context) || __is_instance(__VALUE(context)) || __type_method_invocation(context, target))   369         return __check_and_load_via_object__(__VALUE(target), __ATTRPOS(__fn__), __ATTRCODE(__fn__)).fn;   370     else   371         return __unbound_method;   372 }   373    374 /* Parameter position operations. */   375    376 int __HASPARAM(const __ptable *ptable, int ppos, int pcode)   377 {   378     __param param;   379    380     if (ppos < ptable->size)   381     {   382         param = ptable->params[ppos];   383         if (param.code == pcode)   384             return param.pos;   385     }   386    387     return -1;   388 }   389    390 /* Conversions. */   391    392 __attr __CONTEXT_AS_VALUE(__attr attr)   393 {   394     return __check_and_load_via_object_null(__VALUE(attr), __ATTRPOS(__context__), __ATTRCODE(__context__));   395 }   396    397 /* Type testing. */   398    399 __ref __ISFUNC(__ref obj)   400 {   401     return __test_specific_instance(obj, &__FUNCTION_TYPE);   402 }   403    404 /* Attribute codes and positions for type objects. */   405    406 unsigned int __TYPECODE(__ref obj)   407 {   408     return obj->table->attrs[obj->pos];   409 }   410    411 unsigned int __TYPEPOS(__ref obj)   412 {   413     return obj->pos;   414 }   415    416 /* Memory allocation. */   417    418 void *__ALLOCATE(size_t nmemb, size_t size)   419 {   420     void *ptr = GC_MALLOC(nmemb * size); /* sets memory to zero */   421     if (ptr == NULL)   422         __raise_memory_error();   423     return ptr;   424 }   425    426 void *__ALLOCATEIM(size_t nmemb, size_t size)   427 {   428     void *ptr = GC_MALLOC_ATOMIC(nmemb * size); /* sets memory to zero */   429     if (ptr == NULL)   430         __raise_memory_error();   431     return ptr;   432 }   433    434 void *__REALLOCATE(void *ptr, size_t size)   435 {   436     void *nptr = GC_REALLOC(ptr, size);   437     if (nptr == NULL)   438         __raise_memory_error();   439     return nptr;   440 }   441    442 /* Copying of structures. */   443    444 __ref __COPY(__ref obj, int size)   445 {   446     __ref copy = (__ref) __ALLOCATE(1, size);   447     memcpy(copy, obj, size);   448     return copy;   449 }