1!* Copyright (c) 1999, NVIDIA CORPORATION.  All rights reserved.
2!*
3!* Licensed under the Apache License, Version 2.0 (the "License");
4!* you may not use this file except in compliance with the License.
5!* You may obtain a copy of the License at
6!*
7!*     http://www.apache.org/licenses/LICENSE-2.0
8!*
9!* Unless required by applicable law or agreed to in writing, software
10!* distributed under the License is distributed on an "AS IS" BASIS,
11!* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12!* See the License for the specific language governing permissions and
13!* limitations under the License.
14
15!* Attribute oriented initializations using intrinsic functions
16
17program e10
18
19   parameter(NTEST=76)
20   integer :: result(NTEST)
21   integer :: expect(NTEST) = (/  &
22   !idx1
23       5,		&
24   !idx2
25       5,		&
26   !idx3
27       6,		&
28   !idx4
29       6,		&
30   !idx5
31       5,		&
32   !idx6
33       5,		&
34   !idx7
35       5,		&
36   !idx8
37       5,		&
38   !idx9
39       2,		&
40   !idxarry1
41       2, 3, 4, 5,		&
42   !idxarry2
43       2, 3,		&
44   !lentrim1
45       6,		&
46   !lentrim2
47       13,		&
48   !lentrim3
49       6,		&
50   !lentrim4
51       3,		&
52   !lentrimarry1
53       4, 4, 5, 6,		&
54   !lentrimarry2
55       3, 4,		&
56   !scan1
57       5,		&
58   !scan2
59       6,		&
60   !scan3
61       6,		&
62   !scan4
63       6,		&
64   !scan5
65       5,		&
66   !scan6
67       6,		&
68   !scan7
69       6,		&
70   !scan8
71       5,		&
72   !scan9
73       2,		&
74   !scanarry1
75       2, 3, 4, 5,		&
76   !scanarry2
77       2, 4,		&
78   !vrfy1
79       0,		&
80   !vrfy2
81       10,		&
82   !vrfy3
83       1,		&
84   !vrfy4
85       1,		&
86   !vrfy5
87       1,		&
88   !vrfy6
89       3,		&
90   !vrfy7
91       4,		&
92   !vrfy8
93       1,		&
94   !vrfy9
95       1,		&
96   !vrfyarry1
97       4, 0, 0, 0,		&
98   !vrfyarry2
99       4, 1,		&
100   !char1
101       65,		&
102   !char2
103       66,		&
104   !chararry1
105       48, 49, 50, 51, 52, 53,  &
106    !index kind
107       2,4,8,           &
108    !scan kind
109       2,4,8,           &
110    !verify kind
111       2,4,8,           &
112    !len_trim kind
113       2,4,8,           &
114    !char kind
115       1 &
116   /)
117
118   integer, parameter :: iparam = 8
119   integer, parameter :: iparamarry(5) = (/(i,i=1,5)/)
120   character(len=6), parameter :: strparamarry1(4) = &
121                    (/"abcz  ", " abc  ", "  abc ", "   abc" /)
122   character(len=6), parameter :: strparam1 = "   abc"
123   character(len=2), parameter :: strparam2 = "bc"
124
125   character(len=6), parameter :: strparam3 = "   abc"
126
127  type t1
128    character(len=6) :: str1
129  end type
130  type (t1), parameter:: t1_param1 = t1( adjustl("   abc") )
131
132
133  integer :: idx1 = index("xxyybcwwvv", "bc", KIND=4)
134  integer :: idx2 = index("xxyybcwwvv", "bc", .TRUE., KIND=4)
135  integer :: idx3 = index("zxxyybcwwvvzz", "bc", .FALSE., KIND=4)
136  integer :: idx4 = index("zxxyybcwwvvzz", strparam2, .FALSE., KIND=4)
137  integer :: idx5 = index(strparam1, "bc", KIND=4)
138  integer :: idx6 = index(strparam1, "bc", .TRUE., KIND=4)
139  integer :: idx7 = index(strparam1, strparam2, .TRUE., KIND=4)
140  integer :: idx8 = index(strparam1, "bc", .FALSE., KIND=4)
141  integer :: idx9 = index(t1_param1%str1, "bc", .FALSE., KIND=8)
142  integer :: idxarry1(4) = index(strparamarry1, "bc", KIND=4)
143  integer :: idxarry2(2) = index((/"abc   ", " abc  "/), "bc", KIND=4)
144
145  integer :: scan1 = scan("xxyybcwwvv", "bc", KIND=4)
146  integer :: scan2 = scan("xxyybcwwvv", "bc", .TRUE., KIND=4)
147  integer :: scan3 = scan("zxxyybcwwvvzz", "bc", .FALSE., KIND=4)
148  integer :: scan4 = scan("zxxyybcwwvvzz", strparam2, .FALSE., KIND=4)
149  integer :: scan5 = scan(strparam1, "bc", KIND=4)
150  integer :: scan6 = scan(strparam1, "bc", .TRUE.,KIND=4)
151  integer :: scan7 = scan(strparam1, strparam2, .TRUE.,KIND=4)
152  integer :: scan8 = scan(strparam1, "bc", .FALSE.,KIND=4)
153  integer :: scan9 = scan(t1_param1%str1, "bc", .FALSE.,KIND=4)
154  integer :: scanarry1(4) = scan(strparamarry1, "bc",KIND=4)
155  integer :: scanarry2(2) = scan((/"abc   ", " aac  "/), "bc",KIND=4)
156
157  integer :: vrfy1 = verify("bbbbc", "bc", KIND=4)
158  integer :: vrfy2 = verify("xxyybcwwvv", "xywzbc", .TRUE.,KIND=4)
159  integer :: vrfy3 = verify("zxxyybcwwvvzz", "bc", .FALSE., KIND=4)
160  integer :: vrfy4 = verify("zxxyybcwwvvzz", strparam2, .FALSE., KIND=4)
161  integer :: vrfy5 = verify(strparam1, "abc", KIND=4)
162  integer :: vrfy6 = verify(strparam1, "bac", .TRUE.,KIND=4)
163  integer :: vrfy7 = verify(strparam1, strparam2, .TRUE.,KIND=4)
164  integer :: vrfy8 = verify(strparam1, "abc", .FALSE.,KIND=4)
165  integer :: vrfy9 = verify(t1_param1%str1, "bc", .FALSE.,KIND=4)
166  integer :: vrfyarry1(4) = verify(strparamarry1, " abc",KIND=4)
167  integer :: vrfyarry2(2) = verify((/"abc   ", " abc  "/), "abc",KIND=4)
168
169  integer :: lentrim1 = len_trim("xxyybc    ",KIND=4)
170  integer :: lentrim2 = len_trim("zxxyybcwwvvzz",KIND=4)
171  integer :: lentrim3 = len_trim(strparam3,KIND=4)
172  integer :: lentrim4 = len_trim(t1_param1%str1,KIND=4)
173  integer :: lentrimarry1(4) = len_trim(strparamarry1,KIND=4)
174  integer :: lentrimarry2(2) = len_trim((/"abc   ", " abc  "/),KIND=4)
175
176  integer, parameter :: iparam2 = 66
177  character :: char1 = char(65, KIND=1)
178  character :: char2 = char(iparam2, KIND=1)
179  character :: chararry1(6) = char((/48,49,50,51,52,53/),KIND=1)
180
181
182!  print *,"! idx1"
183!  print *,idx1;
184  result(1) = idx1
185!  print *,"! idx2"
186!  print *,idx2;
187  result(2) = idx2
188!  print *,"! idx3"
189!  print *,idx3;
190  result(3) = idx3
191!  print *,"! idx4"
192!  print *,idx4;
193  result(4) = idx4
194!  print *,"! idx5"
195!  print *,idx5;
196  result(5) = idx5
197!  print *,"! idx6"
198!  print *,idx6;
199  result(6) = idx6
200!  print *,"! idx7"
201!  print *,idx7;
202  result(7) = idx7
203!  print *,"! idx8"
204!  print *,idx8;
205  result(8) = idx8
206!  print *,"! idx9"
207!  print *,idx9;
208  result(9) = idx9
209!  print *,"! idxarry1"
210!  print *,idxarry1;
211  result(10:13) = idxarry1
212!  print *,"! idxarry2"
213!  print *,idxarry2;
214  result(14:15) = idxarry2
215!  print *,"! lentrim1"
216!  print *,lentrim1;
217  result(16) = lentrim1
218!  print *,"! lentrim2"
219!  print *,lentrim2;
220  result(17) = lentrim2
221!  print *,"! lentrim3"
222!  print *,lentrim3;
223  result(18) = lentrim3
224!  print *,"! lentrim4"
225!  print *,lentrim4;
226  result(19) = lentrim4
227!  print *,"! lentrimarry1"
228!  print *,lentrimarry1;
229  result(20:23) = lentrimarry1
230!  print *,"! lentrimarry2"
231!  print *,lentrimarry2;
232  result(24:25) = lentrimarry2
233
234!  print *,"! scan1"
235!  print *,scan1;
236  result(26) = scan1
237!  print *,"! scan2"
238!  print *,scan2;
239  result(27) = scan2
240!  print *,"! scan3"
241!  print *,scan3;
242  result(28) = scan3
243!  print *,"! scan4"
244!  print *,scan4;
245  result(29) = scan4
246!  print *,"! scan5"
247!  print *,scan5;
248  result(30) = scan5
249!  print *,"! scan6"
250!  print *,scan6;
251  result(31) = scan6
252!  print *,"! scan7"
253!  print *,scan7;
254  result(32) = scan7
255!  print *,"! scan8"
256!  print *,scan8;
257  result(33) = scan8
258!  print *,"! scan9"
259!  print *,scan9;
260  result(34) = scan9
261!  print *,"! scanarry1"
262!  print *,scanarry1;
263  result(35:38) = scanarry1
264!  print *,"! scanarry2"
265!  print *,scanarry2;
266  result(39:40) = scanarry2
267
268!  print *,"! vrfy1"
269!  print *,vrfy1;
270  result(41) = vrfy1
271!  print *,"! vrfy2"
272!  print *,vrfy2;
273  result(42) = vrfy2
274!  print *,"! vrfy3"
275!  print *,vrfy3;
276  result(43) = vrfy3
277!  print *,"! vrfy4"
278!  print *,vrfy4;
279  result(44) = vrfy4
280!  print *,"! vrfy5"
281!  print *,vrfy5;
282  result(45) = vrfy5
283!  print *,"! vrfy6"
284!  print *,vrfy6;
285  result(46) = vrfy6
286!  print *,"! vrfy7"
287!  print *,vrfy7;
288  result(47) = vrfy7
289!  print *,"! vrfy8"
290!  print *,vrfy8;
291  result(48) = vrfy8
292!  print *,"! vrfy9"
293!  print *,vrfy9;
294  result(49) = vrfy9
295!  print *,"! vrfyarry1"
296!  print *,vrfyarry1;
297  result(50:53) = vrfyarry1
298!  print *,"! vrfyarry2"
299!  print *,vrfyarry2;
300  result(54:55) = vrfyarry2
301
302!   print *, char1
303  result(56) = ichar(char1)
304!   print *, char2
305  result(57) =ichar(char2)
306!   print *, chararry1(1)
307!   print *, chararry1(2)
308!   print *, chararry1(3)
309!   print *, chararry1(4)
310!   print *, chararry1(5)
311!   print *, chararry1(6)
312  result(58:63) =ichar(chararry1)
313
314!check kind
315result(64) = kind(index("xxyybcwwvv", "bc", KIND=2));
316!print *, result(64)
317result(65) = kind(index("xxyybcwwvv", "bc", KIND=4));
318!print *, result(65)
319result(66) = kind(index("xxyybcwwvv", "bc", KIND=8));
320!print *, result(66)
321result(67) = kind(scan("xxyybcwwvv", "bc", KIND=2))
322!print *, result(67)
323result(68) = kind(scan("xxyybcwwvv", "bc", KIND=4))
324!print *, result(68)
325result(69) = kind(scan("xxyybcwwvv", "bc", KIND=8))
326!print *, result(69)
327result(70) = kind(verify("bbbbc", "bc", KIND=2))
328!print *, result(70)
329result(71) = kind(verify("bbbbc", "bc", KIND=4))
330!print *, result(71)
331result(72) = kind(verify("bbbbc", "bc", KIND=8))
332!print *, result(72)
333result(73) = kind(len_trim("xxyybc    ",KIND=2))
334!print *, result(73)
335result(74) = kind(len_trim("xxyybc    ",KIND=4))
336!print *, result(74)
337result(75) = kind(len_trim("xxyybc    ",KIND=8))
338!print *, result(75)
339result(76) = kind(char(65, KIND=1))
340!print *, result(76)
341
342  call check(result,expect,NTEST)
343
344end program
345