genie-denotation.c

     
   1  //! @file genie-denotation.c
   2  //! @author J. Marcel van der Veer
   3  
   4  //! @section Copyright
   5  //!
   6  //! This file is part of Algol68G - an Algol 68 interpreter.
   7  //! Copyright 2001-2026 J. Marcel van der Veer [algol68g@algol68genie.nl].
   8  
   9  //! @section License
  10  //!
  11  //! This program is free software; you can redistribute it and/or modify it 
  12  //! under the terms of the GNU General Public License as published by the 
  13  //! Free Software Foundation; either version 3 of the License, or 
  14  //! (at your option) any later version.
  15  //!
  16  //! This program is distributed in the hope that it will be useful, but 
  17  //! WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
  18  //! or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 
  19  //! more details. You should have received a copy of the GNU General Public 
  20  //! License along with this program. If not, see [http://www.gnu.org/licenses/].
  21  
  22  //! @section Synopsis
  23  //!
  24  //! Interpreter routines for denotations.
  25  
  26  #include "a68g.h"
  27  #include "a68g-conversion.h"
  28  #include "a68g-genie.h"
  29  #include "a68g-frames.h"
  30  #include "a68g-prelude.h"
  31  #include "a68g-mp.h"
  32  #include "a68g-transput.h"
  33  
  34  //! @brief Push routine text.
  35  
  36  PROP_T genie_routine_text (NODE_T *p)
  37  {
  38    static PROP_T self;
  39    A68G_PROCEDURE z = *(A68G_PROCEDURE *) (FRAME_OBJECT (OFFSET (TAX (p))));
  40    PUSH_PROCEDURE (p, z);
  41    UNIT (&self) = genie_routine_text;
  42    SOURCE (&self) = p;
  43    return self;
  44  }
  45  
  46  
  47  //! @brief Push format text.
  48  
  49  PROP_T genie_format_text (NODE_T *p)
  50  {
  51    static PROP_T self;
  52    A68G_FORMAT z = *(A68G_FORMAT *) (FRAME_OBJECT (OFFSET (TAX (p))));
  53    PUSH_FORMAT (p, z);
  54    UNIT (&self) = genie_format_text;
  55    SOURCE (&self) = p;
  56    return self;
  57  }
  58  
  59  
  60  //! @brief Push NIL.
  61  
  62  PROP_T genie_nihil (NODE_T *p)
  63  {
  64    PROP_T self;
  65    PUSH_REF (p, nil_ref);
  66    UNIT (&self) = genie_nihil;
  67    SOURCE (&self) = p;
  68    return self;
  69  }
  70  
  71  
  72  //! @brief Push constant stored in the tree.
  73  
  74  PROP_T genie_constant (NODE_T *p)
  75  {
  76    PUSH (p, CONSTANT (GINFO (p)), SIZE (GINFO (p)));
  77    return GPROP (p);
  78  }
  79  
  80  
  81  //! @brief Push value of denotation.
  82  
  83  PROP_T genie_denotation (NODE_T *p)
  84  {
  85    MOID_T *moid = MOID (p);
  86    PROP_T self;
  87    UNIT (&self) = genie_denotation;
  88    SOURCE (&self) = p;
  89    if (moid == M_INT) {
  90      // INT denotation.
  91      A68G_INT z;
  92      NODE_T *s = IS (SUB (p), SHORTETY) ? NEXT_SUB (p) : SUB (p);
  93      if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
  94        diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
  95        exit_genie (p, A68G_RUNTIME_ERROR);
  96      }
  97      UNIT (&self) = genie_constant;
  98      STATUS (&z) = INIT_MASK;
  99      CONSTANT (GINFO (p)) = (void *) get_heap_space (SIZE (M_INT));
 100      SIZE (GINFO (p)) = SIZE (M_INT);
 101      COPY (CONSTANT (GINFO (p)), &z, SIZE (M_INT));
 102      PUSH_VALUE (p, VALUE ((A68G_INT *) (CONSTANT (GINFO (p)))), A68G_INT);
 103      return self;
 104    }
 105    if (moid == M_REAL) {
 106      // REAL denotation.
 107      A68G_REAL z;
 108      NODE_T *s = IS (SUB (p), SHORTETY) ? NEXT_SUB (p) : SUB (p);
 109      if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
 110        diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
 111        exit_genie (p, A68G_RUNTIME_ERROR);
 112      }
 113      STATUS (&z) = INIT_MASK;
 114      UNIT (&self) = genie_constant;
 115      CONSTANT (GINFO (p)) = (void *) get_heap_space (SIZE_ALIGNED (A68G_REAL));
 116      SIZE (GINFO (p)) = SIZE_ALIGNED (A68G_REAL);
 117      COPY (CONSTANT (GINFO (p)), &z, SIZE_ALIGNED (A68G_REAL));
 118      PUSH_VALUE (p, VALUE ((A68G_REAL *) (CONSTANT (GINFO (p)))), A68G_REAL);
 119      return self;
 120    }
 121  #if (A68G_LEVEL >= 3)
 122    if (moid == M_LONG_INT) {
 123      // LONG INT denotation.
 124      A68G_LONG_INT z;
 125      size_t len = SIZE_ALIGNED (A68G_LONG_INT);
 126      NODE_T *s = IS (SUB (p), LONGETY) ? NEXT_SUB (p) : SUB (p);
 127      if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
 128        diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
 129        exit_genie (p, A68G_RUNTIME_ERROR);
 130      }
 131      UNIT (&self) = genie_constant;
 132      STATUS (&z) = INIT_MASK;
 133      CONSTANT (GINFO (p)) = (void *) get_heap_space (len);
 134      SIZE (GINFO (p)) = len;
 135      COPY (CONSTANT (GINFO (p)), &z, len);
 136      PUSH_VALUE (p, VALUE ((A68G_LONG_INT *) (CONSTANT (GINFO (p)))), A68G_LONG_INT);
 137      return self;
 138    }
 139    if (moid == M_LONG_REAL) {
 140      // LONG REAL denotation.
 141      A68G_LONG_REAL z;
 142      NODE_T *s = IS (SUB (p), LONGETY) ? NEXT_SUB (p) : SUB (p);
 143      if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
 144        diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
 145        exit_genie (p, A68G_RUNTIME_ERROR);
 146      }
 147      STATUS (&z) = INIT_MASK;
 148      UNIT (&self) = genie_constant;
 149      CONSTANT (GINFO (p)) = (void *) get_heap_space (SIZE_ALIGNED (A68G_LONG_REAL));
 150      SIZE (GINFO (p)) = SIZE_ALIGNED (A68G_LONG_REAL);
 151      COPY (CONSTANT (GINFO (p)), &z, SIZE_ALIGNED (A68G_LONG_REAL));
 152      PUSH_VALUE (p, VALUE ((A68G_LONG_REAL *) (CONSTANT (GINFO (p)))), A68G_LONG_REAL);
 153      return self;
 154    }
 155    // LONG BITS denotation.
 156    if (moid == M_LONG_BITS) {
 157      A68G_LONG_BITS z;
 158      NODE_T *s = IS (SUB (p), LONGETY) ? NEXT_SUB (p) : SUB (p);
 159      if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
 160        diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
 161        exit_genie (p, A68G_RUNTIME_ERROR);
 162      }
 163      UNIT (&self) = genie_constant;
 164      STATUS (&z) = INIT_MASK;
 165      CONSTANT (GINFO (p)) = (void *) get_heap_space (SIZE_ALIGNED (A68G_LONG_BITS));
 166      SIZE (GINFO (p)) = SIZE_ALIGNED (A68G_LONG_BITS);
 167      COPY (CONSTANT (GINFO (p)), &z, SIZE_ALIGNED (A68G_LONG_BITS));
 168      PUSH_VALUE (p, VALUE ((A68G_LONG_BITS *) (CONSTANT (GINFO (p)))), A68G_LONG_BITS);
 169      return self;
 170    }
 171  #endif
 172    if (moid == M_LONG_INT || moid == M_LONGER_INT) {
 173      // [LONG] LONG INT denotation.
 174      int digits = LIMBS (moid);
 175      size_t size = SIZE (moid);
 176      NODE_T *number;
 177      if (IS (SUB (p), SHORTETY) || IS (SUB (p), LONGETY)) {
 178        number = NEXT_SUB (p);
 179      } else {
 180        number = SUB (p);
 181      }
 182      MP_T *z = nil_mp (p, digits);
 183      if (genie_string_to_value_internal (p, moid, NSYMBOL (number), (BYTE_T *) z) == A68G_FALSE) {
 184        diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
 185        exit_genie (p, A68G_RUNTIME_ERROR);
 186      }
 187      SET_INIT_MP (z);
 188      UNIT (&self) = genie_constant;
 189      CONSTANT (GINFO (p)) = (void *) get_heap_space (size);
 190      SIZE (GINFO (p)) = size;
 191      COPY (CONSTANT (GINFO (p)), z, size);
 192      return self;
 193    }
 194    if (moid == M_LONG_REAL || moid == M_LONGER_REAL) {
 195      // [LONG] LONG REAL denotation.
 196      int digits = LIMBS (moid);
 197      size_t size = SIZE (moid);
 198      NODE_T *number;
 199      if (IS (SUB (p), SHORTETY) || IS (SUB (p), LONGETY)) {
 200        number = NEXT_SUB (p);
 201      } else {
 202        number = SUB (p);
 203      }
 204      MP_T *z = nil_mp (p, digits);
 205      if (genie_string_to_value_internal (p, moid, NSYMBOL (number), (BYTE_T *) z) == A68G_FALSE) {
 206        diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
 207        exit_genie (p, A68G_RUNTIME_ERROR);
 208      }
 209      SET_INIT_MP (z);
 210      UNIT (&self) = genie_constant;
 211      CONSTANT (GINFO (p)) = (void *) get_heap_space (size);
 212      SIZE (GINFO (p)) = size;
 213      COPY (CONSTANT (GINFO (p)), z, size);
 214      return self;
 215    }
 216    if (moid == M_BITS) {
 217      // BITS denotation.
 218      A68G_BITS z;
 219      NODE_T *s = IS (SUB (p), SHORTETY) ? NEXT_SUB (p) : SUB (p);
 220      if (genie_string_to_value_internal (p, moid, NSYMBOL (s), (BYTE_T *) & z) == A68G_FALSE) {
 221        diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
 222        exit_genie (p, A68G_RUNTIME_ERROR);
 223      }
 224      UNIT (&self) = genie_constant;
 225      STATUS (&z) = INIT_MASK;
 226      CONSTANT (GINFO (p)) = (void *) get_heap_space (SIZE_ALIGNED (A68G_BITS));
 227      SIZE (GINFO (p)) = SIZE_ALIGNED (A68G_BITS);
 228      COPY (CONSTANT (GINFO (p)), &z, SIZE_ALIGNED (A68G_BITS));
 229      PUSH_VALUE (p, VALUE ((A68G_BITS *) (CONSTANT (GINFO (p)))), A68G_BITS);
 230    }
 231    if (moid == M_LONG_BITS || moid == M_LONGER_BITS) {
 232      // [LONG] LONG BITS denotation.
 233      int digits = LIMBS (moid);
 234      size_t size = SIZE (moid);
 235      NODE_T *number;
 236      if (IS (SUB (p), SHORTETY) || IS (SUB (p), LONGETY)) {
 237        number = NEXT_SUB (p);
 238      } else {
 239        number = SUB (p);
 240      }
 241      MP_T *z = nil_mp (p, digits);
 242      if (genie_string_to_value_internal (p, moid, NSYMBOL (number), (BYTE_T *) z) == A68G_FALSE) {
 243        diagnostic (A68G_RUNTIME_ERROR, p, ERROR_IN_DENOTATION, moid);
 244        exit_genie (p, A68G_RUNTIME_ERROR);
 245      }
 246      SET_INIT_MP (z);
 247      UNIT (&self) = genie_constant;
 248      CONSTANT (GINFO (p)) = (void *) get_heap_space (size);
 249      SIZE (GINFO (p)) = size;
 250      COPY (CONSTANT (GINFO (p)), z, size);
 251      return self;
 252    }
 253    if (moid == M_BOOL) {
 254      // BOOL denotation.
 255      A68G_BOOL z;
 256      ASSERT (genie_string_to_value_internal (p, M_BOOL, NSYMBOL (p), (BYTE_T *) & z) == A68G_TRUE);
 257      PUSH_VALUE (p, VALUE (&z), A68G_BOOL);
 258      return self;
 259    } else if (moid == M_CHAR) {
 260      // CHAR denotation.
 261      PUSH_VALUE (p, TO_UCHAR (NSYMBOL (p)[0]), A68G_CHAR);
 262      return self;
 263    } else if (moid == M_ROW_CHAR) {
 264      // [] CHAR denotation - permanent string in the heap.
 265      A68G_REF z;
 266      A68G_ARRAY *arr;
 267      A68G_TUPLE *tup;
 268      z = c_to_a_string (p, NSYMBOL (p), DEFAULT_WIDTH);
 269      GET_DESCRIPTOR (arr, tup, &z);
 270      BLOCK_GC_HANDLE (&z);
 271      BLOCK_GC_HANDLE (&(ARRAY (arr)));
 272      UNIT (&self) = genie_constant;
 273      CONSTANT (GINFO (p)) = (void *) get_heap_space (A68G_REF_SIZE);
 274      SIZE (GINFO (p)) = A68G_REF_SIZE;
 275      COPY (CONSTANT (GINFO (p)), &z, A68G_REF_SIZE);
 276      PUSH_REF (p, *(A68G_REF *) (CONSTANT (GINFO (p))));
 277      (void) tup;
 278      return self;
 279    }
 280    if (moid == M_VOID) {
 281      // VOID denotation: EMPTY.
 282      return self;
 283    }
 284    return self;
 285  }
 286  
     

This website is archived by the National Library of the Netherlands.

© J.M. van der Veer   •   jmvdveer@algol68genie.nl