libs/java/RTS.java

   1
   2 /** This is part of the body of the GPCP runtime support.
   3  *
   4  *  Written November 1998, John Gough.
   5  *
   6  *  CP*rts contains the runtime helpers, this class has
   7  *  adapters for hooking into the various Native libraries.
   8  *  These are the user accessible parts of the runtime.  The
   9  *  facilities in CP*rts are known to each code-emitter, but
  10  *  have no CP-accessible functions.  The interface to the
  11  *  user-accessible functions are defined in RTS.cp, and the
  12  *  code is defined in this file.
  13  *
  14  *  Version of 29 March 2000 (kjg) --
  15  *  There is a swindle involved here, for the bootstrap version
  16  *  of the compiler: any functions with OUT scalars will have
  17  *  a different signature in the old and new versions.  This
  18  *  module implements both, by overloading the methods.
  19  *
  20  *  Version of October 2011 -- JVM version brought into line
  21  *  with the CP definition used by the current .NET version.
  22  *  Only the required methods are defined, the bootstrap
  23  *  versions have been removed.
  24  */
  25
  26 package CP.RTS;
  27
  28 import java.io.*;
  29 import CP.CPJ.*;
  30 import CP.CPJrts.*;
  31 import java.text.NumberFormat;
  32
  33 /* ------------------------------------------------------------ */
  34 /*                      Support for RTS.cp                      */
  35 /* ------------------------------------------------------------ */
  36 /*  The text of RTS.cp is interleaved here to associate the     */
  37 /*  java with the promises of the Component Pascal source.      */
  38 /* ------------------------------------------------------------ */
  39 //
  40 //  SYSTEM MODULE RTS;
  41
  42 public final class RTS
  43 {
  44       /* Some Initializations ... */
  45       private static NumberFormat localFormat = NumberFormat.getInstance();
  46
  47 //
  48 //    VAR defaultTarget- : ARRAY 4 OF CHAR;
  49 //        fltNegInfinity-   : SHORTREAL;
  50 //        fltPosInfinity-   : SHORTREAL;
  51 //        dblNegInfinity-   : REAL;
  52 //        dblPosInfinity-   : REAL;
  53
  54         public static char[] defaultTarget = {'j','v','m','\0'};
  55         public static float fltNegInfinity = Float.NEGATIVE_INFINITY;
  56         public static float fltPosInfinity = Float.POSITIVE_INFINITY;
  57         public static double dblNegInfinity = Double.NEGATIVE_INFINITY;
  58         public static double dblPosInfinity = Double.POSITIVE_INFINITY;
  59 //
  60 //    TYPE  CharOpen*       = POINTER TO ARRAY OF CHAR;
  61 //
  62 //    TYPE  NativeType* = POINTER TO ABSTRACT RECORD END;
  63 //          NativeObject*   = POINTER TO ABSTRACT RECORD END;
  64 //          NativeString*   = POINTER TO RECORD END;
  65 //          NativeException*= POINTER TO EXTENSIBLE RECORD END;
  66 //
  67 //    VAR   eol- : POINTER TO ARRAY OF CHAR; (* OS-specific end of line string *)
  68 //
  69         public static char[] eol = { '\n', '\0' };
  70 //
  71 //    (* ========================================================== *)
  72 //    (* ============= Support for native exceptions ==============     *)
  73 //    (* ========================================================== *)
  74 //    PROCEDURE getStr*(x : NativeException) : CharOpen;
  75
  76         public static char[] getStr(java.lang.Exception x) {
  77             String str = x.toString();
  78             return CPJrts.JavaStrToChrOpen(str);
  79         }
  80
  81 //
  82 //  --------------------------------------------------------------
  83 //    PROCEDURE Throw*(IN s : ARRAY OF CHAR);
  84 //    (** Abort execution with an error *)
  85
  86         public static void Throw(char[] s) throws Exception {
  87                 throw new Exception(new String(s));
  88         }
  89
  90 /* ------------------------------------------------------------ */
  91 //   PROCEDURE TypeName*(str : NativeType) : CharOpen;
  92 //  (* Get the character at zero-based index idx *)
  93 //
  94     public static char[] TypeName(java.lang.Class t) {
  95       return CPJrts.JavaStrToChrOpen(t.getSimpleName());
  96     }
  97
  98 /* ------------------------------------------------------------ */
  99 //   PROCEDURE CharAtIndex*(str : NativeString; idx : INTEGER) : CHAR;
 100 //  (* Get the character at zero-based index idx *)
 101 //
 102     public static char CharAtIndex( String s, int i ) { return s.charAt(i); }
 103
 104 /* ------------------------------------------------------------ */
 105 //  PROCEDURE Length*(str : NativeString) : INTEGER;
 106 //  (* Get the length of the native string *)
 107 //
 108     public static int Length( String s ) { return s.length(); }
 109
 110
 111
 112 //
 113 //    (* ========================================================== *)
 114 //    (* ============= Conversions FROM array of char ============= *)
 115 //    (* ========================================================== *)
 116 //    PROCEDURE StrToBool*(IN s : ARRAY OF CHAR; OUT b : BOOLEAN; OUT ok : BOOLEAN);
 117 //    (** Parse array into a BOOLEAN TRUE/FALSE *)
 118 //
 119         public static boolean StrToBool(char[] str,
 120                                         boolean[] r)    // OUT param
 121         {
 122             try {
 123                 r[0] = true;
 124                 return Boolean.parseBoolean(CPJ.MkStr(str));
 125             } catch(Exception e) {
 126                 r[0] = false;
 127                 return false;
 128             }
 129         }
 130 //
 131 //  --------------------------------------------------------------
 132 //    PROCEDURE StrToByte*(IN s : ARRAY OF CHAR; OUT b : BYTE; OUT ok : BOOLEAN);
 133 //    (** Parse array into a BYTE integer (unsigned byte in CP *)
 134 //
 135         public static byte StrToByte(char[] str,
 136                                      boolean[] r)       // OUT param
 137         {
 138             try {
 139                 r[0] = true;
 140                 int value = Integer.parseInt(CPJ.MkStr(str));
 141                 if (value >= -128 && value < 128)
 142                     return (byte)value;
 143             } catch(Exception e) {
 144             }
 145             r[0] = false;
 146             return 0;
 147         }
 148 //
 149 //  --------------------------------------------------------------
 150 //    PROCEDURE StrToUByte*(IN s : ARRAY OF CHAR; OUT b : BYTE; OUT ok : BOOLEAN);
 151 //    (** Parse array into a BYTE integer *)
 152 //
 153         public static byte StrToUByte(char[] str,
 154                                       boolean[] r)      // OUT param
 155         {
 156             try {
 157                 r[0] = true;
 158                 int value = Integer.parseInt(CPJ.MkStr(str));
 159                 if (value >= 0 && value < 256)
 160                     return (byte)value;
 161             } catch(Exception e) {
 162             }
 163             r[0] = false;
 164             return 0;
 165         }
 166 //
 167 //  --------------------------------------------------------------
 168 //    PROCEDURE StrToShort*(IN s : ARRAY OF CHAR; OUT si : SHORTINT; OUT ok : BOOLEAN);
 169 //    (** Parse an array into a CP SHORTINT *)
 170 //
 171         public static short StrToShort(char[] str,
 172                                        boolean[] r)     // OUT param
 173         {
 174             try {
 175                 r[0] = true;
 176                 int value = Integer.parseInt(CPJ.MkStr(str));
 177                 if (value >= -0x8000 && value < 0x7fff)
 178                     return (short)value;
 179             } catch(Exception e) {
 180             }
 181             r[0] = false;
 182             return 0;
 183         }
 184 //
 185 //  --------------------------------------------------------------
 186 //    PROCEDURE StrToUShort*(IN s:ARRAY OF CHAR; OUT si:SHORTINT; OUT ok:BOOLEAN);
 187 //    (** Parse an array into a CP Unsigned SHORTINT *)
 188 //
 189         public static short StrToUShort(char[] str,
 190                                         boolean[] r)    // OUT param
 191         {
 192             try {
 193                 r[0] = true;
 194                 int value = Integer.parseInt(CPJ.MkStr(str));
 195                 if (value > 0 && value < 0xffff)
 196                     return (short)value;
 197             } catch(Exception e) {
 198             }
 199             r[0] = false;
 200             return 0;
 201         }
 202 //
 203 //  --------------------------------------------------------------
 204 //    PROCEDURE StrToInt*(IN s:ARRAY OF CHAR; OUT i:INTEGER; OUT ok:BOOLEAN);
 205 //    (** Parse an array into a CP INTEGER *)
 206 //    (*  Note that first OUT or VAR scalar becomes return value if a pure procedure *)
 207 //
 208         public static int StrToInt(char[] str,
 209                                    boolean[] r) // OUT param
 210         {
 211             try {
 212                 r[0] = true;
 213                 return Integer.parseInt(CPJ.MkStr(str));
 214             } catch(Exception e) {
 215                 r[0] = false;
 216                 return 0;
 217             }
 218         }
 219 //
 220 //  --------------------------------------------------------------
 221 //    PROCEDURE StrToUInt*(IN s:ARRAY OF CHAR; OUT i:INTEGER; OUT ok:BOOLEAN);
 222 //    (** Parse an array into a CP INTEGER *)
 223 //
 224         public static int StrToUInt(char[] str,
 225                                     boolean[] r) // OUT param
 226         {
 227             try {
 228                 r[0] = true;
 229                 long value = Long.parseLong(CPJ.MkStr(str));
 230                 if (value > 0 && value < 0xffffffff)
 231                     return (int)value;
 232             } catch(Exception e) {
 233             }
 234             r[0] = false;
 235             return 0;
 236         }
 237 //
 238 //  --------------------------------------------------------------
 239 //    PROCEDURE StrToLong*(IN s:ARRAY OF CHAR; OUT i:LONGINT; OUT ok:BOOLEAN);
 240 //    (** Parse an array into a CP LONGINT *)
 241 //
 242         public static long StrToLong(char[] str,
 243                                      boolean[] r) // OUT param
 244         {
 245             try {
 246                 r[0] = true;
 247                 return Long.parseLong(CPJ.MkStr(str));
 248             } catch(Exception e) {
 249                 r[0] = false;
 250                 return 0;
 251             }
 252         }
 253 //
 254 //  --------------------------------------------------------------
 255 //    PROCEDURE StrToULong*(IN s:ARRAY OF CHAR; OUT i:LONGINT; OUT ok:BOOLEAN);
 256 //    (** Parse an array into a CP LONGINT *)
 257 //
 258       // Throw method not found exception.
 259 //
 260 //  --------------------------------------------------------------
 261 //    PROCEDURE HexStrToUByte*(IN s:ARRAY OF CHAR; OUT b:BYTE; OUT ok:BOOLEAN);
 262 //    (** Parse hexadecimal array into a BYTE integer *)
 263 //
 264         public static byte HexStrToUByte(char[] str,
 265                                          boolean[] r)   // OUT param
 266         {
 267             try {
 268                 r[0] = true;
 269                 return Byte.decode(CPJ.MkStr(str)).byteValue();
 270             } catch(Exception e) {
 271                 r[0] = false;
 272                 return 0;
 273             }
 274         }
 275 //
 276 //  (* ------------------- Low-level String Conversions -------------------- *)
 277 //  (* Three versions for different cultures.  *Invar uses invariant culture *)
 278 //  (*                                         *Local uses current locale    *)
 279 //  (* StrToReal & RealToStr do not behave the same on JVM and CLR.          *)
 280 //  (* They is provided for compatability with versions < 1.3.1              *)
 281 //  (* ------------------- Low-level String Conversions -------------------- *)
 282 //
 283 //    PROCEDURE StrToReal*(IN  s  : ARRAY OF CHAR;
 284 //                         OUT r  : REAL;
 285 //                         OUT ok : BOOLEAN);
 286 //    (** Parse array into an ieee double REAL *)
 287 //
 288         public static double StrToReal(char[] str,
 289                                        boolean[] r) // OUT param
 290         {
 291             try {
 292                 r[0] = true;
 293                 return Double.valueOf(CPJ.MkStr(str)).doubleValue();
 294             } catch(Exception e) {
 295                 r[0] = false;
 296                 return 0.0;
 297             }
 298         }
 299 //
 300 //  --------------------------------------------------------------
 301 //    PROCEDURE StrToRealInvar*(IN  s  : ARRAY OF CHAR;
 302 //                              OUT r  : REAL;
 303 //                              OUT ok : BOOLEAN);
 304 //    (** Parse array using invariant culture, into an ieee double REAL *)
 305 //
 306         public static double StrToRealInvar(char[] str,
 307                                             boolean[] r) // OUT param
 308         {
 309             try {
 310                 r[0] = true;
 311                 return Double.valueOf(CPJ.MkStr(str)).doubleValue();
 312             } catch(Exception e) {
 313                 r[0] = false;
 314                 return 0.0;
 315             }
 316         }
 317 //
 318 //  --------------------------------------------------------------
 319 //    PROCEDURE StrToRealLocal*(IN  s  : ARRAY OF CHAR;
 320 //                              OUT r  : REAL;
 321 //                              OUT ok : BOOLEAN);
 322 //    (** Parse array using current locale, into an ieee double REAL *)
 323 //
 324         public static double StrToRealLocal(char[] str,
 325                                             boolean[] r) // OUT param
 326         {
 327             try {
 328                 r[0] = true;
 329                 return localFormat.parse(CPJ.MkStr(str)).doubleValue();
 330             } catch(Exception e) {
 331                 r[0] = false;
 332                 return 0.0;
 333             }
 334         }
 335 //
 336 //  --------------------------------------------------------------
 337 //    PROCEDURE StrToSReal*(IN  s  : ARRAY OF CHAR;
 338 //                          OUT r  : SHORTREAL;
 339 //                          OUT ok : BOOLEAN);
 340 //
 341         public static float StrToSReal(char[] str,
 342                                        boolean[] r) // OUT param
 343         {
 344             try {
 345                 r[0] = true;
 346                 return Float.valueOf(CPJ.MkStr(str)).floatValue();
 347             } catch(Exception e) {
 348                 r[0] = false;
 349                 return 0.0F;
 350             }
 351         }
 352 //
 353 //  --------------------------------------------------------------
 354 //    PROCEDURE StrToSRealInvar*(IN  s  : ARRAY OF CHAR;
 355 //                               OUT r  : SHORTREAL;
 356 //                               OUT ok : BOOLEAN);
 357 //
 358         public static float StrToSRealInvar(char[] str,
 359                                             boolean[] r) // OUT param
 360         {
 361             try {
 362                 r[0] = true;
 363                 return Float.valueOf(CPJ.MkStr(str)).floatValue();
 364             } catch(Exception e) {
 365                 r[0] = false;
 366                 return 0.0F;
 367             }
 368         }
 369 //
 370 //  --------------------------------------------------------------
 371 //    PROCEDURE StrToSRealLocal*(IN  s  : ARRAY OF CHAR;
 372 //                          OUT r  : SHORTREAL;
 373 //                          OUT ok : BOOLEAN);
 374 //    (** Parse array into a short REAL *)
 375 //
 376         public static float StrToSRealLocal(char[] str,
 377                                              boolean[] r) // OUT param
 378         {
 379             try {
 380                 r[0] = true;
 381                 return localFormat.parse(CPJ.MkStr(str)).floatValue();
 382             } catch(Exception e) {
 383                 r[0] = false;
 384                 return 0.0F;
 385             }
 386         }
 387 //
 388 //    (* ========================================================== *)
 389 //    (* ============== Conversions TO array of char ============== *)
 390 //    (* ========================================================== *)
 391 //    PROCEDURE RealToStr*(r : REAL; OUT s : ARRAY OF CHAR);
 392 //    (** Decode a CP REAL into an array *)
 393 //
 394         public static void RealToStr(double num,
 395                                      char[] str)
 396         {
 397             String jls = String.valueOf(num);
 398             int    len = jls.length();
 399             if (len >= str.length)
 400                 len = str.length - 1;
 401             jls.getChars(0, len, str, 0);
 402             str[len] = '\0';
 403         }
 404 //
 405 //  --------------------------------------------------------------
 406 //    PROCEDURE RealToStrInvar*(r : REAL; OUT s : ARRAY OF CHAR);
 407 //    (** Decode a CP REAL into an array in invariant culture *)
 408 //
 409         public static void RealToStrInvar(double num,
 410                                           char[] str)
 411         {
 412             String jls = String.valueOf(num);
 413             int    len = jls.length();
 414             if (len >= str.length)
 415                 len = str.length - 1;
 416             jls.getChars(0, len, str, 0);
 417             str[len] = '\0';
 418         }
 419 //
 420 //  --------------------------------------------------------------
 421 //    PROCEDURE RealToStrLocal*(r : REAL; OUT s : ARRAY OF CHAR);
 422 //    (** Decode a CP REAL into an array in the current locale *)
 423 //
 424         public static void RealToStrLocal(double num,
 425                                           char[] str)
 426         {
 427             String jls = localFormat.format(num);
 428             int    len = jls.length();
 429             if (len >= str.length)
 430                 len = str.length - 1;
 431             jls.getChars(0, len, str, 0);
 432             str[len] = '\0';
 433         }
 434 //
 435 //  --------------------------------------------------------------
 436 //    PROCEDURE SRealToStr*(r : SHORTREAL; OUT s : ARRAY OF CHAR);
 437 //
 438         public static void SRealToStr(float num,
 439                                       char[] str)
 440         {
 441             String jls = Float.toString(num);
 442             int    len = jls.length();
 443             if (len >= str.length)
 444                 len = str.length - 1;
 445             jls.getChars(0, len, str, 0);
 446             str[len] = '\0';
 447         }
 448 //
 449 //  --------------------------------------------------------------
 450 //    PROCEDURE SRealToStrInvar*(r : SHORTREAL; OUT s : ARRAY OF CHAR);
 451 //
 452         public static void SRealToStrInvar(float num,
 453                                            char[] str)
 454         {
 455             String jls = Float.toString(num);
 456             int    len = jls.length();
 457             if (len >= str.length)
 458                 len = str.length - 1;
 459             jls.getChars(0, len, str, 0);
 460             str[len] = '\0';
 461         }
 462 //
 463 //  --------------------------------------------------------------
 464 //    PROCEDURE SRealToStrLocal*(r : SHORTREAL; OUT s : ARRAY OF CHAR);
 465 //    (** Decode a CP SHORTREAL into an array *)
 466 //
 467         public static void SRealToStrLocal(float num,
 468                                            char[] str)
 469         {
 470             String jls = localFormat.format(num);
 471             int    len = jls.length();
 472             if (len >= str.length)
 473                 len = str.length - 1;
 474             jls.getChars(0, len, str, 0);
 475             str[len] = '\0';
 476         }
 477 //
 478 //  --------------------------------------------------------------
 479 //    PROCEDURE IntToStr*(i : INTEGER; OUT s : ARRAY OF CHAR);
 480 //    (** Decode a CP INTEGER into an array *)
 481 //
 482         public static void IntToStr(int num,
 483                                     char[] str)
 484         {
 485             String jls = String.valueOf(num);
 486             int    len = jls.length();
 487             if (len >= str.length)
 488                 len = str.length - 1;
 489             jls.getChars(0, len, str, 0);
 490             str[len] = '\0';
 491         }
 492 //
 493 //  --------------------------------------------------------------
 494 //    PROCEDURE ObjToStr*(obj : ANYPTR; OUT s : ARRAY OF CHAR);
 495 //    (** Decode a CP INTEGER into an array *)
 496 //
 497         public static void ObjToStr(Object obj, char[] str) {
 498             CPJ.MkArr(obj.getClass().getName(), str);
 499         }
 500 //
 501 //  --------------------------------------------------------------
 502 //    PROCEDURE LongToStr*(i : LONGINT; OUT s : ARRAY OF CHAR);
 503 //    (** Decode a CP INTEGER into an array *)
 504 //
 505         public static void LongToStr(long num,
 506                                     char[] str)
 507         {
 508             String jls = String.valueOf(num);
 509             int    len = jls.length();
 510             if (len >= str.length)
 511                 len = str.length - 1;
 512             jls.getChars(0, len, str, 0);
 513             str[len] = '\0';
 514         }
 515 //
 516 //    (* ========================================================== *)
 517 //    (* ========== Casts with no representation change =========== *)
 518 //    (* ========================================================== *)
 519 //    PROCEDURE realToLongBits*(r : REAL) : LONGINT;
 520 //    (** Convert an ieee double into a longint with same bit pattern *)
 521 //
 522         public static long realToLongBits(double r) {
 523             return java.lang.Double.doubleToLongBits(r);
 524         }
 525 //
 526 //  --------------------------------------------------------------
 527 //    PROCEDURE longBitsToReal*(l : LONGINT) : REAL;
 528 //    (** Convert an ieee double into a longint with same bit pattern *)
 529 //
 530         public static double longBitsToReal(long l) {
 531             return java.lang.Double.longBitsToDouble(l);
 532         }
 533 //
 534 //  --------------------------------------------------------------
 535 //    PROCEDURE shortRealToIntBits*(r : SHORTREAL) : INTEGER;
 536 //    (** Convert an ieee float into an int with same bit pattern *)
 537 //
 538         public static int shortRealToIntBits(float f) {
 539             return Float.floatToIntBits(f);
 540         }
 541 //
 542 //  --------------------------------------------------------------
 543 //    PROCEDURE intBitsToShortReal*(i : INTEGER) : SHORTREAL;
 544 //    (** Convert an int into an ieee float with same bit pattern *)
 545 //
 546         public static float intBitsToShortReal(int i) {
 547             return Float.intBitsToFloat(i);
 548         }
 549 //
 550 //  --------------------------------------------------------------
 551 //    PROCEDURE hiByte*(i : SHORTINT) : BYTE;
 552 //    (** Get hi-significant word of short *)
 553 //
 554         public static byte hiByte(short s) {
 555             return (byte) (s >> 8);
 556         }
 557 //
 558 //  --------------------------------------------------------------
 559 //    PROCEDURE loByte*(i : SHORTINT) : BYTE;
 560 //    (** Get lo-significant word of short *)
 561 //
 562         public static byte loByte(short s) {
 563             return (byte) s;
 564         }
 565 //
 566 //  --------------------------------------------------------------
 567 //    PROCEDURE hiShort*(i : INTEGER) : SHORTINT;
 568 //    (** Get hi-significant word of integer *)
 569 //
 570         public static short hiShort(int i) {
 571             return (short) (i >> 16);
 572         }
 573 //
 574 //  --------------------------------------------------------------
 575 //    PROCEDURE loShort*(i : INTEGER) : SHORTINT;
 576 //    (** Get lo-significant word of integer *)
 577 //
 578         public static short loShort(int i) {
 579             return (short) i;
 580         }
 581 //
 582 //  --------------------------------------------------------------
 583 //    PROCEDURE hiInt*(l : LONGINT) : INTEGER;
 584 //    (** Get hi-significant word of long integer *)
 585 //
 586         public static int hiInt(long l) {
 587             return (int) (l >> 32);
 588         }
 589 //
 590 //  --------------------------------------------------------------
 591 //    PROCEDURE loInt*(l : LONGINT) : INTEGER;
 592 //    (** Get lo-significant word of long integer *)
 593 //
 594         public static int loInt(long l) {
 595             return (int) l;
 596         }
 597 //
 598 //    (* ========================================================== *)
 599 //    (* ============= Various utility procedures ================= *)
 600 //    (* ========================================================== *)
 601 //
 602 //    PROCEDURE GetMillis*() : LONGINT;
 603 //    (** Get time in milliseconds *)
 604
 605         public static long GetMillis() {
 606             return System.currentTimeMillis();
 607         }
 608 //
 609 //  --------------------------------------------------------------
 610 //    PROCEDURE GetDateString*(OUT str : ARRAY OF CHAR);
 611 //    (** Get a date string in some native format *)
 612 //
 613         public static void GetDateString(char[] str) {
 614             String date = new java.util.Date().toString();
 615             int len = date.length();
 616             date.getChars(0, len, str, 0);
 617             str[len] = '\0';
 618         }
 619 //
 620 //  --------------------------------------------------------------
 621 //    PROCEDURE ClassMarker*(o : ANYPTR);
 622 //    (** Write class name to standard output *)
 623 //
 624         public static void ClassMarker(Object o) {
 625             System.out.print(o.getClass().getName());
 626         }
 627 //
 628 //  END RTS.
 629   /* ------------------------------------------------------------ */
 630   /* ------------------------------------------------------------ */
 631   /* ------------------------------------------------------------ */
 632 }
 633