mirror of
https://github.com/byteworksinc/ORCA-C.git
synced 2024-05-28 12:41:35 +00:00
4ad7a65de6
This means that floating-point constants can now have the range and precision of the extended type (aka long double), and floating-point constant expressions evaluated within the compiler also have that same range and precision (matching expressions evaluated at run time). This new behavior is intended to match the behavior specified in the C99 and later standards for FLT_EVAL_METHOD 2. This fixes the previous problem where long double constants and constant expressions of type long double were not represented and evaluated with the full range and precision that they should be. It also gives extra range and precision to constants and constant expressions of type double or float. This may have pluses and minuses, but at any rate it is consistent with the existing behavior for expressions evaluated at run time, and with one of the possible models of floating point evaluation specified in the C standards.
159 lines
6.3 KiB
ObjectPascal
159 lines
6.3 KiB
ObjectPascal
{$optimize 7}
|
|
{---------------------------------------------------------------}
|
|
{ }
|
|
{ ORCA Code Generator Common }
|
|
{ }
|
|
{ This unit contains the command constants, types, }
|
|
{ variables and procedures used throughout the code }
|
|
{ generator, but which are not available to the compiler. }
|
|
{ }
|
|
{---------------------------------------------------------------}
|
|
{ }
|
|
{ These routines are defined in the compiler, but used from }
|
|
{ the code generator. }
|
|
{ }
|
|
{ Error - flag an error }
|
|
{ CMalloc - Clear and allocate memory from a pool. }
|
|
{ Malloc - Allocate memory from a pool. }
|
|
{ }
|
|
{---------------------------------------------------------------}
|
|
|
|
unit CGC;
|
|
|
|
interface
|
|
|
|
{$LibPrefix '0/obj/'}
|
|
|
|
uses CCommon, CGI;
|
|
|
|
{$segment 'CG'}
|
|
|
|
type
|
|
{pcode code generation}
|
|
{---------------------}
|
|
realrec = record {used to convert from real to in-SANE}
|
|
itsReal: extended;
|
|
inSANE: packed array[1..10] of byte;
|
|
inCOMP: packed array[1..8] of byte;
|
|
end;
|
|
|
|
var
|
|
{misc}
|
|
{----}
|
|
blkcnt: longint; {number of bytes in current segment}
|
|
|
|
{buffers}
|
|
{-------}
|
|
cbufflen: 0..maxcbuff; {number of bytes now in cbuff}
|
|
segDisp: longint; {disp in the current segment}
|
|
|
|
{-- Global subroutines -----------------------------------------}
|
|
|
|
procedure CnvSC (rec: realrec); extern;
|
|
|
|
{ convert a real number to SANE comp format }
|
|
{ }
|
|
{ parameters: }
|
|
{ rec - record containing the value to convert; also }
|
|
{ has space for the result }
|
|
|
|
|
|
procedure CnvSX (rec: realrec); extern;
|
|
|
|
{ convert a real number to SANE extended format }
|
|
{ }
|
|
{ parameters: }
|
|
{ rec - record containing the value to convert; also }
|
|
{ has space for the result }
|
|
|
|
|
|
procedure CnvXLL (var result: longlong; val: extended); extern;
|
|
|
|
{ convert a real number to long long }
|
|
{ }
|
|
{ parameters: }
|
|
{ result - longlong to hold the converted value }
|
|
{ val - the real value }
|
|
|
|
|
|
procedure CnvXULL (var result: longlong; val: extended); extern;
|
|
|
|
{ convert a real number to unsigned long long }
|
|
{ }
|
|
{ parameters: }
|
|
{ result - longlong to hold the converted value }
|
|
{ val - the real value }
|
|
|
|
|
|
function CnvLLX (val: longlong): extended; extern;
|
|
|
|
{ convert a long long to a real number }
|
|
{ }
|
|
{ parameters: }
|
|
{ val - the long long value }
|
|
|
|
|
|
function CnvULLX (val: longlong): extended; extern;
|
|
|
|
{ convert an unsigned long long to a real number }
|
|
{ }
|
|
{ parameters: }
|
|
{ val - the unsigned long long value }
|
|
|
|
|
|
procedure InitLabels; extern;
|
|
|
|
{ initialize the labels array for a procedure }
|
|
{ }
|
|
{ Note: also defined in CGI.pas }
|
|
|
|
{-- These routines are defined in the compiler, but used from cg --}
|
|
|
|
function Calloc (bytes: integer): ptr; extern;
|
|
|
|
{ Allocate memory from a pool and clear it. }
|
|
{ }
|
|
{ Parameters: }
|
|
{ bytes - number of bytes to allocate }
|
|
{ ptr - points to the first byte of the allocated memory }
|
|
{ }
|
|
{ Globals: }
|
|
{ useGlobalPool - should the memory come from the global }
|
|
{ (or local) pool }
|
|
|
|
|
|
procedure Error (err: integer); extern;
|
|
|
|
{ flag an error }
|
|
{ }
|
|
{ err - error number }
|
|
|
|
|
|
{procedure Error2 (loc, err: integer); extern; {debug} {in scanner.pas}
|
|
|
|
{ flag an error }
|
|
{ }
|
|
{ loc - error location }
|
|
{ err - error number }
|
|
|
|
|
|
function Malloc (bytes: integer): ptr; extern;
|
|
|
|
{ Allocate memory from a pool. }
|
|
{ }
|
|
{ Parameters: }
|
|
{ bytes - number of bytes to allocate }
|
|
{ ptr - points to the first byte of the allocated memory }
|
|
{ }
|
|
{ Globals: }
|
|
{ useGlobalPool - should the memory come from the global }
|
|
{ (or local) pool }
|
|
|
|
{---------------------------------------------------------------}
|
|
|
|
implementation
|
|
|
|
end.
|
|
|
|
{$append 'CGC.asm'}
|