Dave writes:
> I would be interested in implementing a couple of data types not currently
> supported. I don't know whether this is the type of feature that could be
> readily handled by a pre-processor.
A pre-processor won't solve your problem for additional datatypes -- if
you're simply using the pre-processor to emit FORTRAN code into your standard
FORTRAN compiler. Rather, you're going to have to write equivalency routines
to convert the datatypes within your FORTRAN code itself for the datatypes
that you want to support.
We had to do the same thing with BASIC fifteen years ago when we first
started writing general-purpose code IMAGE code. For the ten years prior to
that, because we designed all of our customers' databases from scratch, we
simply limited the datatypes we used in our databases to those that BASIC
supported.
I've included below our SPL-based equivalency routines. In all of these, we
take the non-BASIC-supported datatypes and convert them into R4 real numbers.
Only the I4 numbers are compromised by this procedure. An I4 number can range
from +/- 2^63, which is approx. equivalent to +/- 10^21 (21 accurate
decimals). An R4 number only supports 16 accurate places, even though it has
a much greater range. Nevertheless, we've never found that to be much of a
problem.
All non-supported datatypes are converted to R4's on the way in, processed
within BASIC in that format, and then backconverted on the way out. While the
routines below had to be written in a callable format for use in BASIC, they
can be integrated directly into FORTRAN's code, simply because FORTRAN can
perform direct intrinsic calls and BASIC can't.
The nature of the individual routines should be obvious, especially if you
look at the documentation for the particular intrinsics they call.
Wirt Atmar
========================================
/t qcequvrt
/l all
1 $CONTROL USLINIT,CODE,SEGMENT=EQUIVALENCE
2 << >>
3 << These functions perform bit equivalencing for >>
4 << the following types: INTEGER, DOUBLE, REAL, and >>
5 << LONG. >>
6 << >>
7 BEGIN
8 <<>>
9 <<>>
10 PROCEDURE STATUS2RECNUM(STATUS,BITPATTERN);
11 INTEGER ARRAY STATUS;
12 BYTE ARRAY BITPATTERN;
13 BEGIN
14 BYTE ARRAY PATTERN(*)=STATUS;
15 MOVE BITPATTERN(0):=PATTERN(4),(4);
16 BITPATTERN(-1):=4;
17 END;
18 <<>>
19 <<>>
20 PROCEDURE STRINGTOINT(BITPATTERN,NUMBER);
21 BYTE ARRAY BITPATTERN;
22 REAL NUMBER;
23 BEGIN
24 BYTE ARRAY PATTERN(0:1);
25 INTEGER ARRAY NUMBER2(*)=PATTERN;
26 MOVE PATTERN(0):=BITPATTERN(0),(2);
27 NUMBER:=REAL(NUMBER2(0));
28 END;
29 <<>>
30 <<>>
31 PROCEDURE INTTOSTRING(NUMBER,BITPATTERN);
32 REAL NUMBER;
33 BYTE ARRAY BITPATTERN;
34 BEGIN
35 INTEGER NUMBER2;
36 BYTE ARRAY PATTERN(*)=NUMBER2;
37 NUMBER2:=INTEGER(FIXT(NUMBER));
38 MOVE BITPATTERN(0):=PATTERN(0),(2);
39 BITPATTERN(-1):=2;
40 END;
41 <<>>
42 <<>>
43 PROCEDURE STRINGTOLOGICAL(BITPATTERN,NUMBER);
44 BYTE ARRAY BITPATTERN;
45 REAL NUMBER;
46 BEGIN
47 LOGICAL ARRAY NUMBER2(*)=BITPATTERN;
48 NUMBER:=REAL(DOUBLE(NUMBER2(0)));
49 END;
50 <<>>
51 <<>>
52 PROCEDURE LOGICALTOSTRING(NUMBER,BITPATTERN);
53 REAL NUMBER;
54 BYTE ARRAY BITPATTERN;
55 BEGIN
56 LOGICAL NUMBER2;
57 BYTE ARRAY PATTERN(*)=NUMBER2;
58 NUMBER2:=LOGICAL(FIXT(NUMBER));
59 MOVE BITPATTERN(0):=PATTERN(0),(2);
60 BITPATTERN(-1):=2;
61 END;
62 <<>>
63 <<>>
64 PROCEDURE STRINGTODBLE(BITPATTERN,NUMBER);
65 BYTE ARRAY BITPATTERN;
66 REAL NUMBER;
67 BEGIN
68 DOUBLE ARRAY NUMBER2(*)=BITPATTERN;
69 NUMBER:=REAL(NUMBER2);
70 END;
71 <<>>
72 <<>>
73 PROCEDURE DBLETOSTRING(NUMBER,BITPATTERN);
74 REAL NUMBER;
75 BYTE ARRAY BITPATTERN;
76 BEGIN
77 DOUBLE NUMBER2;
78 BYTE ARRAY PATTERN(*)=NUMBER2;
79 NUMBER2:=FIXT(NUMBER);
80 MOVE BITPATTERN(0):=PATTERN(0),(4);
81 BITPATTERN(-1):=4;
82 END;
83 <<>>
84 <<>>
85 PROCEDURE STRINGTOREAL(BITPATTERN,NUMBER);
86 BYTE ARRAY BITPATTERN;
87 REAL NUMBER;
88 BEGIN
89 REAL ARRAY NUMBER2(*)=BITPATTERN;
90 NUMBER:=NUMBER2;
91 END;
92 <<>>
93 <<>>
94 PROCEDURE REALTOSTRING(NUMBER,BITPATTERN);
95 REAL NUMBER;
96 BYTE ARRAY BITPATTERN;
97 BEGIN
98 REAL NUMBER2;
99 BYTE ARRAY PATTERN(*)=NUMBER2;
100 NUMBER2:=NUMBER;
101 MOVE BITPATTERN(0):=PATTERN(0),(4);
102 BITPATTERN(-1):=4;
103 END;
104 <<>>
105 <<>>
106 PROCEDURE STRINGTOLONG(BITPATTERN,NUMBER);
107 BYTE ARRAY BITPATTERN;
108 LONG NUMBER;
109 BEGIN
110 LONG ARRAY NUMBER2(*)=BITPATTERN;
111 NUMBER:=NUMBER2;
112 END;
113 <<>>
114 <<>>
115 PROCEDURE LONGTOSTRING(NUMBER,BITPATTERN);
116 LONG NUMBER;
117 BYTE ARRAY BITPATTERN;
118 BEGIN
119 BYTE ARRAY PATTERN(*)=NUMBER;
120 MOVE BITPATTERN(0):=PATTERN(0),(8);
121 BITPATTERN(-1):=8;
122 END;
123 <<>>
124 <<>>
125 PROCEDURE BYTE2INT(BITPATTERN,NUMBER);
126 BYTE BITPATTERN;
127 INTEGER NUMBER;
128 BEGIN
129 NUMBER:=INTEGER(BITPATTERN);
130 END;
131 <<>>
132 <<>>
133 PROCEDURE STRING2INT(BITPATTERN,NUMBER);
134 BYTE ARRAY BITPATTERN;
135 INTEGER NUMBER;
136 BEGIN
137 INTEGER ARRAY NUMBER2(*)=BITPATTERN;
138 NUMBER:=INTEGER(NUMBER2(0));
139 END;
140 <<>>
141 <<>>
142 PROCEDURE INT2STRING(NUMBER,BITPATTERN);
143 INTEGER NUMBER;
144 BYTE ARRAY BITPATTERN;
145 BEGIN
146 BYTE ARRAY NUMBER2(*)=NUMBER;
147 MOVE BITPATTERN(0):=NUMBER2(0),(2);
148 BITPATTERN(-1):=2;
149 END;
150 <<>>
151 <<>>
152 PROCEDURE IEEEREAL(BITPAT1,BITPAT2,SFORMAT,DFORMAT);
153 INTEGER SFORMAT,DFORMAT;
154 BYTE ARRAY BITPAT1,BITPAT2;
155 BEGIN
156 INTRINSIC HPFPCONVERT;
157 HPFPCONVERT(BITPAT1,BITPAT2,SFORMAT,DFORMAT);
158 END;
159 <<>>
160 <<>>
161 PROCEDURE MOVESTR2LOGICAL(BITPATTERN,BUFFER);
162 BYTE ARRAY BITPATTERN;
163 LOGICAL ARRAY BUFFER;
164 BEGIN
165 LOGICAL ARRAY BUFF2(*)=BITPATTERN(0);
166 MOVE BUFFER(0):=BUFF2(0),(BITPATTERN(-1));
167 END;
168 <<>>
169 <<>>
170 END.
/
=======================================
|
