libgpython/runtime/gpy-type-utils.c

   1 /* This file is part of GCC.
   2
   3 GCC is free software; you can redistribute it and/or modify it under
   4 the terms of the GNU General Public License as published by the Free
   5 Software Foundation; either version 3, or (at your option) any later
   6 version.
   7
   8 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
   9 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  11 for more details.
  12
  13 You should have received a copy of the GNU General Public License
  14 along with GCC; see the file COPYING3.  If not see
  15 <http://www.gnu.org/licenses/>.  */
  16
  17 #ifdef HAVE_CONFIG_H
  18 #include "config.h"
  19 #endif
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <stdbool.h>
  25 #include <stdarg.h>
  26
  27 #include <gpython/gpython.h>
  28 #include <gpython/vectors.h>
  29 #include <gpython/objects.h>
  30 #include <gpython/runtime.h>
  31
  32 #define GPY_ARG_LIT_CHECK(A,I,X)                                \
  33   gpy_assert (A[I].T == TYPE_OBJECT_LIT);                       \
  34   gpy_assert (A[I].o.literal.type == X);                        \
  35   ++I;
  36
  37 bool gpy_args_check_fmt (gpy_object_t * args, const char * fmt)
  38 {
  39   bool retval = true;
  40
  41   int idx = 0;
  42   const char * i = fmt;
  43   for (i = fmt; *i != '\0'; ++i)
  44     {
  45       switch (*i)
  46         {
  47         case ',':
  48           break;
  49
  50         case '.':
  51           goto exit;
  52           break;
  53
  54         case 'i':
  55           {
  56             GPY_ARG_LIT_CHECK (args, idx, TYPE_INTEGER);
  57           }
  58           break;
  59
  60         case 's':
  61           {
  62             GPY_ARG_LIT_CHECK (args, idx, TYPE_STRING);
  63           }
  64           break;
  65
  66         case 'p':
  67           {
  68             GPY_ARG_LIT_CHECK (args, idx, TYPE_ADDR);
  69           }
  70           break;
  71
  72         case 'A':
  73           {
  74             GPY_ARG_LIT_CHECK (args, idx, TYPE_ATTRIB_L);
  75           }
  76           break;
  77
  78         case 'V':
  79           {
  80             GPY_ARG_LIT_CHECK (args, idx, TYPE_VEC);
  81           }
  82           break;
  83
  84         case 'S':
  85           {
  86             GPY_ARG_LIT_CHECK (args, idx, TYPE_STR_ARRY);
  87           }
  88           break;
  89
  90         default:
  91           {
  92             error ("unhandled literal argument type <%c>!\n", *i);
  93             retval = false;
  94           }
  95           break;
  96         }
  97     }
  98  exit:
  99   return retval;
 100 }
 101
 102 char ** gpy_args_lit_parse_sarray (gpy_object_t * arg)
 103 {
 104   char ** retval = NULL;
 105   gpy_assert (arg->T == TYPE_OBJECT_LIT);
 106   gpy_assert (arg->o.literal.type == TYPE_STR_ARRY);
 107
 108   retval = arg->o.literal.literal.sarray;
 109   return retval;
 110 }
 111
 112 int gpy_args_lit_parse_int (gpy_object_t * arg)
 113 {
 114   int retval = -1;
 115   gpy_assert (arg->T == TYPE_OBJECT_LIT);
 116   gpy_assert (arg->o.literal.type == TYPE_INTEGER);
 117
 118   retval = arg->o.literal.literal.integer;
 119
 120   return retval;
 121 }
 122
 123 char * gpy_args_lit_parse_string (gpy_object_t * arg)
 124 {
 125   char * retval = NULL;
 126   gpy_assert (arg->T == TYPE_OBJECT_LIT);
 127   gpy_assert (arg->o.literal.type == TYPE_STRING);
 128
 129   retval = strdup (arg->o.literal.literal.string);
 130
 131   return retval;
 132 }
 133
 134 unsigned char * gpy_args_lit_parse_pointer (gpy_object_t * arg)
 135 {
 136   unsigned char * retval = NULL;
 137   gpy_assert (arg->T == TYPE_OBJECT_LIT);
 138   gpy_assert (arg->o.literal.type == TYPE_ADDR);
 139
 140   retval = arg->o.literal.literal.addr;
 141
 142   return retval;
 143 }
 144
 145 gpy_object_attrib_t ** gpy_args_lit_parse_attrib_table (gpy_object_t * arg)
 146 {
 147   gpy_object_attrib_t ** retval = NULL;
 148   gpy_assert (arg->T == TYPE_OBJECT_LIT);
 149   gpy_assert (arg->o.literal.type == TYPE_ATTRIB_L);
 150
 151   retval = arg->o.literal.literal.attribs;
 152
 153   return retval;
 154 }
 155
 156 gpy_object_t ** gpy_args_lit_parse_vec (gpy_object_t * arg)
 157 {
 158   gpy_object_t ** retval = NULL;
 159   gpy_assert (arg->T == TYPE_OBJECT_LIT);
 160   gpy_assert (arg->o.literal.type == TYPE_VEC);
 161
 162   retval = arg->o.literal.literal.vec;
 163
 164   return retval;
 165 }
 166
 167 gpy_object_t * gpy_create_object_decl (gpy_typedef_t * type,
 168                                        void * self)
 169 {
 170   gpy_object_t * retval = (gpy_object_t *)
 171     gpy_malloc (sizeof(gpy_object_t));
 172
 173   retval->T = TYPE_OBJECT_DECL;
 174   OBJECT_STATE (retval).identifier = strdup (type->identifier);
 175   OBJECT_STATE (retval).ref_count = 0;
 176   OBJECT_STATE (retval).state = self;
 177   OBJECT_STATE (retval).definition = type;
 178
 179   return retval;
 180 }
 181
 182 gpy_object_t * gpy_create_object_state (gpy_typedef_t * type,
 183                                         void * self)
 184 {
 185   gpy_object_t * retval = (gpy_object_t *)
 186     gpy_malloc (sizeof (gpy_object_t));
 187
 188   retval->T = TYPE_OBJECT_STATE;
 189   OBJECT_STATE (retval).identifier = strdup (type->identifier);
 190   OBJECT_STATE (retval).ref_count = 0;
 191   OBJECT_STATE (retval).state = self;
 192   OBJECT_STATE (retval).definition = type;
 193
 194   return retval;
 195 }
 196
 197 void gpy_wrap_builtins (gpy_typedef_t * const type, size_t len)
 198 {
 199   struct gpy_builtinAttribs_t * builtins = type->builtins;
 200   struct gpy_builtinAttribs_t atm;
 201
 202   if (len > 1)
 203     {
 204       gpy_object_t ** folded = (gpy_object_t **)
 205         gpy_calloc (len -1, sizeof (gpy_object_t *));
 206
 207       int idx;
 208       for (idx = 0; builtins[idx].identifier != NULL; ++idx)
 209         {
 210           atm = builtins [idx];
 211           gpy_object_t * builtin = NULL_OBJECT;
 212           gpy_object_t args[4];
 213
 214           gpy_literal_t i;
 215           i.type = TYPE_STRING;
 216           i.literal.string = (char *)atm.identifier;
 217
 218           gpy_literal_t p;
 219           p.type = TYPE_ADDR;
 220           p.literal.addr = (unsigned char *) atm.addr;
 221
 222           gpy_literal_t n;
 223           n.type = TYPE_INTEGER;
 224           n.literal.integer = atm.nargs;
 225
 226           gpy_object_t a1 = { .T = TYPE_OBJECT_LIT, .o.literal = i };
 227           gpy_object_t a2 = { .T = TYPE_OBJECT_LIT, .o.literal = p };
 228           gpy_object_t a3 = { .T = TYPE_OBJECT_LIT, .o.literal = n };
 229
 230           args[0] = a1;
 231           args[1] = a2;
 232           args[2] = a3;
 233           args[3] = NULL_OBJECT_REF;
 234
 235           gpy_typedef_t * def = __gpy_func_type_node;
 236           builtin = def->tp_new (def, args);
 237           gpy_assert (builtin->T == TYPE_OBJECT_DECL);
 238
 239           folded [idx] = builtin;
 240         }
 241       /* Now to append/create the attribute access table .. */
 242       struct gpy_object_attrib_t ** members = (struct gpy_object_attrib_t **)
 243         gpy_calloc (len, sizeof (struct gpy_object_attrib_t *));
 244
 245       for (idx = 0; idx < len - 1; ++idx)
 246         {
 247           atm = builtins [idx];
 248           struct gpy_object_attrib_t * fattr = (struct gpy_object_attrib_t *)
 249             gpy_malloc (sizeof (struct gpy_object_attrib_t));
 250
 251           fattr->identifier = strdup (atm.identifier);
 252           fattr->T = GPY_CATTR;
 253           fattr->offset = 0;
 254           fattr->addr = folded [idx];
 255
 256           members[idx] = fattr;
 257         }
 258       // sentinal
 259       members[idx] = NULL;
 260       type->members_defintion = members;
 261       gpy_free (folded);
 262     }
 263 }