libgpython/runtime/gpy-object-integer.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
  26 #include <gpython/gpython.h>
  27 #include <gpython/vectors.h>
  28 #include <gpython/objects.h>
  29
  30 struct gpy_obj_integer_t {
  31   int Int;
  32   /* other possible members */
  33 };
  34
  35 gpy_object_t * gpy_obj_integer_new (gpy_typedef_t * type,
  36                                     gpy_object_t ** args)
  37 {
  38   gpy_object_t * retval = NULL_OBJECT;
  39
  40   bool check = gpy_args_check_fmt (args, "i.");
  41   gpy_assert (check);
  42
  43   int val = gpy_args_lit_parse_int (args[0]);
  44   struct gpy_obj_integer_t * self = (struct gpy_obj_integer_t *)
  45     gpy_malloc (sizeof (struct gpy_obj_integer_t));
  46   self->Int = val;
  47
  48   retval = gpy_create_object_state (type, self);
  49
  50   return retval;
  51 }
  52
  53 /* Destroys self (type) not the object state */
  54 void gpy_obj_integer_destroy (gpy_object_t * self)
  55 {
  56   gpy_assert (self->T == TYPE_OBJECT_STATE);
  57   gpy_object_state_t * x = self->o.object_state;
  58   struct gpy_obj_integer_t *x1 = (struct gpy_obj_integer_t *)
  59     x->state;
  60
  61   gpy_free (x1);
  62   x->state = NULL;
  63 }
  64
  65 void gpy_obj_integer_print (gpy_object_t * self, FILE * fd, bool newline)
  66 {
  67   gpy_assert (self->T == TYPE_OBJECT_STATE);
  68   gpy_object_state_t * x = self->o.object_state;
  69   struct gpy_obj_integer_t *x1 = (struct gpy_obj_integer_t *)
  70     x->state;
  71
  72   fprintf (fd, "%i ", x1->Int);
  73
  74   if (newline)
  75     fprintf (fd, "\n");
  76 }
  77
  78 int gpy_obj_integer_getInt (gpy_object_t * self)
  79 {
  80   gpy_assert (self->T == TYPE_OBJECT_STATE);
  81   gpy_object_state_t * x = self->o.object_state;
  82   gpy_assert (!strcmp (x->definition->identifier, "Int"));
  83
  84   struct gpy_obj_integer_t *x1 = (struct gpy_obj_integer_t *)
  85     x->state;
  86   return (x1->Int);
  87 }
  88
  89 gpy_object_t *
  90 gpy_obj_integer_add (gpy_object_t * o1, gpy_object_t * o2)
  91 {
  92   gpy_object_t * retval = NULL_OBJECT;
  93
  94   gpy_object_state_t * x = o1->o.object_state;
  95   gpy_object_state_t * y = o2->o.object_state;
  96
  97   if (!strcmp (x->identifier, "Int"))
  98     {
  99       if (!strcmp (y->identifier, "Int"))
 100         {
 101           struct gpy_obj_integer_t *t1 = (struct gpy_obj_integer_t*) x->state;
 102           struct gpy_obj_integer_t *t2 = (struct gpy_obj_integer_t*) y->state;
 103
 104           int z = t1->Int + t2->Int;
 105           retval = gpy_rr_fold_integer (z);
 106         }
 107       else
 108         {
 109           fatal ("invalid object type <%s>!\n", y->identifier);
 110         }
 111     }
 112   else
 113     {
 114       fatal ("invalid object type <%s>!\n", x->identifier);
 115     }
 116   return retval;
 117 }
 118
 119 gpy_object_t *
 120 gpy_obj_integer_minus (gpy_object_t * o1, gpy_object_t * o2)
 121 {
 122   gpy_object_t * retval = NULL_OBJECT;
 123
 124   gpy_object_state_t * x = o1->o.object_state;
 125   gpy_object_state_t * y = o2->o.object_state;
 126
 127   if (!strcmp (x->identifier, "Int"))
 128     {
 129       if (!strcmp (y->identifier, "Int"))
 130         {
 131           struct gpy_obj_integer_t *t1 = (struct gpy_obj_integer_t*) x->state;
 132           struct gpy_obj_integer_t *t2 = (struct gpy_obj_integer_t*) y->state;
 133
 134           int z = t1->Int - t2->Int;
 135           retval = gpy_rr_fold_integer (z);
 136         }
 137       else
 138         {
 139           fatal ("invalid object type <%s>!\n", y->identifier);
 140         }
 141     }
 142   else
 143     {
 144       fatal ("invalid object type <%s>!\n", x->identifier);
 145     }
 146   return retval;
 147 }
 148
 149 gpy_object_t *
 150 gpy_obj_integer_mult (gpy_object_t * o1, gpy_object_t * o2)
 151 {
 152   gpy_object_t * retval = NULL_OBJECT;
 153
 154   gpy_object_state_t * x = o1->o.object_state;
 155   gpy_object_state_t * y = o2->o.object_state;
 156
 157   if (!strcmp (x->identifier, "Int"))
 158     {
 159       if (!strcmp (y->identifier, "Int"))
 160         {
 161           struct gpy_obj_integer_t *t1 = (struct gpy_obj_integer_t*) x->state;
 162           struct gpy_obj_integer_t *t2 = (struct gpy_obj_integer_t*) y->state;
 163
 164           int z = t1->Int * t2->Int;
 165           retval = gpy_rr_fold_integer (z);
 166         }
 167       else
 168         {
 169           fatal ("invalid object type <%s>!\n", y->identifier);
 170         }
 171     }
 172   else
 173     {
 174       fatal ("invalid object type <%s>!\n", x->identifier);
 175     }
 176   return retval;
 177 }
 178
 179
 180 gpy_object_t *
 181 gpy_obj_integer_less_than (gpy_object_t * o1, gpy_object_t * o2)
 182 {
 183   gpy_object_t * retval = NULL_OBJECT;
 184
 185   gpy_object_state_t * x = o1->o.object_state;
 186   gpy_object_state_t * y = o2->o.object_state;
 187
 188   if (!strcmp (x->identifier, "Int"))
 189     {
 190       if (!strcmp (y->identifier, "Int"))
 191         {
 192           struct gpy_obj_integer_t *t1 = (struct gpy_obj_integer_t*) x->state;
 193           struct gpy_obj_integer_t *t2 = (struct gpy_obj_integer_t*) y->state;
 194
 195           int x = t1->Int;
 196           int y = t2->Int;
 197           int z = 0;
 198
 199           if (x < y)
 200             z = 1;
 201           retval = gpy_rr_fold_integer (z);
 202         }
 203       else
 204         {
 205           fatal ("invalid object type <%s>!\n", y->identifier);
 206         }
 207     }
 208   else
 209     {
 210       fatal ("invalid object type <%s>!\n", x->identifier);
 211     }
 212   return retval;
 213 }
 214
 215 gpy_object_t *
 216 gpy_obj_integer_greater_than (gpy_object_t * o1, gpy_object_t * o2)
 217 {
 218   gpy_object_t * retval = NULL_OBJECT;
 219
 220   gpy_object_state_t * x = o1->o.object_state;
 221   gpy_object_state_t * y = o2->o.object_state;
 222
 223   if (!strcmp (x->identifier, "Int"))
 224     {
 225       if (!strcmp (y->identifier, "Int"))
 226         {
 227           struct gpy_obj_integer_t *t1 = (struct gpy_obj_integer_t*) x->state;
 228           struct gpy_obj_integer_t *t2 = (struct gpy_obj_integer_t*) y->state;
 229
 230           int x = t1->Int;
 231           int y = t2->Int;
 232           int z = 0;
 233
 234           if (x > y)
 235             z = 1;
 236           retval = gpy_rr_fold_integer (z);
 237         }
 238       else
 239         {
 240           fatal ("invalid object type <%s>!\n", y->identifier);
 241         }
 242     }
 243   else
 244     {
 245       fatal ("invalid object type <%s>!\n", x->identifier);
 246     }
 247   return retval;
 248 }
 249
 250 gpy_object_t *
 251 gpy_obj_integer_equal_to (gpy_object_t * o1, gpy_object_t * o2)
 252 {
 253   gpy_object_t * retval = NULL_OBJECT;
 254
 255   gpy_object_state_t * x = o1->o.object_state;
 256   gpy_object_state_t * y = o2->o.object_state;
 257
 258   if (!strcmp (x->identifier, "Int"))
 259     {
 260       if (!strcmp (y->identifier, "Int"))
 261         {
 262           struct gpy_obj_integer_t *t1 = (struct gpy_obj_integer_t*) x->state;
 263           struct gpy_obj_integer_t *t2 = (struct gpy_obj_integer_t*) y->state;
 264
 265           int x = t1->Int;
 266           int y = t2->Int;
 267           int z = 0;
 268
 269           if (x == y)
 270             z = 1;
 271           retval = gpy_rr_fold_integer (z);
 272         }
 273       else
 274         {
 275           fatal ("invalid object type <%s>!\n", y->identifier);
 276         }
 277     }
 278   else
 279     {
 280       fatal ("invalid object type <%s>!\n", x->identifier);
 281     }
 282   return retval;
 283 }
 284
 285 gpy_object_t *
 286 gpy_obj_integer_not_eq_to (gpy_object_t * o1, gpy_object_t * o2)
 287 {
 288   gpy_object_t * retval = NULL_OBJECT;
 289
 290   gpy_object_state_t * x = o1->o.object_state;
 291   gpy_object_state_t * y = o2->o.object_state;
 292
 293   if (!strcmp (x->identifier, "Int"))
 294     {
 295       if (!strcmp (y->identifier, "Int"))
 296         {
 297           struct gpy_obj_integer_t * t1 = (struct gpy_obj_integer_t *)
 298             x->state;
 299           struct gpy_obj_integer_t * t2 = (struct gpy_obj_integer_t *)
 300             y->state;
 301
 302           int x = t1->Int;
 303           int y = t2->Int;
 304           int z = 0;
 305
 306           if (x != y)
 307             z = 1;
 308           retval = gpy_rr_fold_integer (z);
 309         }
 310       else
 311         {
 312           fatal ("invalid object type <%s>!\n", y->identifier);
 313         }
 314     }
 315   else
 316     {
 317       fatal ("invalid object type <%s>!\n", x->identifier);
 318     }
 319   return retval;
 320 }
 321
 322 bool gpy_obj_integer_eval_bool (gpy_object_t * x)
 323 {
 324   bool retval = false;
 325   gpy_object_state_t * t = x->o.object_state;
 326   struct gpy_obj_integer_t *state = (struct gpy_obj_integer_t*) t->state;
 327
 328   if (state->Int)
 329     retval = true;
 330
 331   return retval;
 332 }
 333
 334 static struct gpy_number_prot_t integer_binary_ops = {
 335   &gpy_obj_integer_add,
 336   &gpy_obj_integer_minus,
 337   NULL,
 338   &gpy_obj_integer_mult,
 339   NULL,
 340   &gpy_obj_integer_less_than,
 341   NULL,
 342   &gpy_obj_integer_greater_than,
 343   NULL,
 344   &gpy_obj_integer_equal_to,
 345   &gpy_obj_integer_not_eq_to,
 346   NULL,
 347   NULL,
 348 };
 349
 350 static struct gpy_typedef_t integer_obj = {
 351   "Int",
 352   sizeof (struct gpy_obj_integer_t),
 353   &gpy_obj_integer_new,
 354   &gpy_obj_integer_destroy,
 355   &gpy_obj_integer_print,
 356   NULL,
 357   NULL,
 358   &gpy_obj_integer_eval_bool,
 359   &integer_binary_ops,
 360   NULL
 361 };
 362
 363 /*
 364   Should be used for handling any Field initilizers!
 365 */
 366 void gpy_obj_integer_mod_init (gpy_vector_t * const vec)
 367 {
 368   gpy_vec_push (vec, &integer_obj);
 369 }