Nice. Up to 85.55 C / 157.52 asm. Is now definatly better code than gbdk.
[fw/sdcc] / support / tests / dhrystone / dhry.c
1 /** Sanatised version of the dhrystone-2.1 test.
2
3     Modifications Michael Hope <michaelh@earthling.net>
4
5     This is derrived from the dhrystone-2.1.tar.gz tarball available
6     all over the net.  I sourced it from the Red Hat src rpm.
7
8     Modifications:
9     * Made it more ANSI compliant.
10     * Changed any array function arguments to pointers to make my 
11       compiler work.
12     * Removed malloc's for a couple of static arrays.
13     * Into one file.
14     * Proc_8 is a bit messy.  It originally took a 2 dim array, but
15       sdcc doesnt support this.  So the offsets are hard coded...
16
17     Notes:
18     * The comment at the start of Func_1 about the input being
19       H, R on the first call is wrong - Func_1 is first called
20       from Func_2 where the input is R, Y.  The test still succeeds.
21
22     References:
23     * http://www.netlib.org/performance/html/dhry.intro.html
24     * http://www.netlib.org/performance/html/dhry.data.col0.html
25
26     I couldnt find a copyright in the original - the most relevent
27     part follows:
28
29     A SPECIAL THANKS
30     I didn't write the DHRYSTONE benchmark.  Rheinhold Weicker did. He has
31     certainly provided us with a useful tool for benchmarking, and is
32     to be congratulated.
33
34     Rick Richardson
35     PC Research, Inc.
36     (201) 389-8963 (9-17 EST)
37     (201) 542-3734 (7-9,17-24 EST)
38     ...!uunet!pcrat!rick        (normal mail)
39     ...!uunet!pcrat!dry2        (results only)
40 */
41
42 #include "dhry.h"
43 #include <string.h>
44 /** For printf */
45 #include <stdio.h>
46
47 /** Returns the current device time in ticks.  Check HZ in the Makefile
48     as well - HZ ticks = 1 second.
49 */
50 unsigned _clock(void);
51
52 /** Print the number of t-states this program has been executing for.
53     Optional :)
54 */
55 void _printTStates(void);
56
57 /** Set to one to print more messages about expected values etc. 
58  */
59 #define DEBUG   0
60
61 #if DEBUG
62 #define DPRINTF(_a)  printf _a
63 #else
64 #define DPRINTF(_a)
65 #endif
66
67 Rec_Pointer     Ptr_Glob,
68                 Next_Ptr_Glob;
69 int             Int_Glob;
70 Boolean         Bool_Glob;
71 char            Ch_1_Glob,
72                 Ch_2_Glob;
73 int             Arr_1_Glob [50];
74 int             Arr_2_Glob [50] [50];
75
76 /* Used instead of malloc() */
77 static Rec_Type _r[2];
78
79 void Proc_1 (REG Rec_Pointer Ptr_Val_Par);
80 void Proc_2 (One_Fifty *Int_Par_Ref);
81 void Proc_5 (void);
82 void Proc_4 (void);
83 void Proc_7 (One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val, One_Fifty *Int_Par_Ref);
84 void Proc_8 (int *Arr_1_Par_Ref, int *Arr_2_Par_Ref,
85              int Int_1_Par_Val, int Int_2_Par_Val);
86 void Proc_6 (Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par);
87 void Proc_3 (Rec_Pointer *Ptr_Ref_Par);
88 Enumeration Func_1 (Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val);
89 Boolean Func_2 (char *Str_1_Par_Ref, char *Str_2_Par_Ref);
90 Boolean Func_3 (Enumeration Enum_Par_Val);
91
92 #if SDCC
93 int _main(void) 
94 #else
95 int main(void)
96 #endif
97 {
98     One_Fifty       Int_1_Loc;
99     REG   One_Fifty       Int_2_Loc;
100     One_Fifty       Int_3_Loc;
101     REG   Capital_Letter Ch_Index;
102     Enumeration     Enum_Loc;
103     Str_30          Str_1_Loc;
104     Str_30          Str_2_Loc;
105     REG   int             Run_Index;
106     REG   int             Number_Of_Runs;
107     unsigned runTime;
108
109     //    printf("[dhry]\n");
110
111     Next_Ptr_Glob = &_r[0];
112     Ptr_Glob = &_r[1];
113
114
115     Ptr_Glob->Ptr_Comp                    = Next_Ptr_Glob;
116     Ptr_Glob->Discr                       = Ident_1;
117     Ptr_Glob->variant.var_1.Enum_Comp     = Ident_3;
118     Ptr_Glob->variant.var_1.Int_Comp      = 40;
119
120     strcpy (Ptr_Glob->variant.var_1.Str_Comp, 
121             "DHRYSTONE PROGRAM, SOME STRING");
122     strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
123
124     Arr_2_Glob [8][7] = 10;
125
126     /* Was missing in published program. Without this statement,    */
127     /* Arr_2_Glob [8][7] would have an undefined value.             */
128     /* Warning: With 16-Bit processors and Number_Of_Runs > 32000,  */
129     /* overflow may occur for this array element.                   */
130
131     /* 32766 is the highest value for a 16 bitter */
132     Number_Of_Runs = 32766;
133
134     runTime = _clock();
135
136     /* Main test loop */
137     for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index) {
138         DPRINTF(("Run_Index = %d\n", Run_Index));
139         Proc_5();
140         Proc_4();
141         /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
142         DPRINTF(("Ch_1_Glob '%c' == 'A', Ch_2_Glob '%c' == 'B', Bool_Glob %d == 1\n", Ch_1_Glob, Ch_2_Glob, Bool_Glob));
143
144         Int_1_Loc = 2;
145         Int_2_Loc = 3;
146         strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
147         Enum_Loc = Ident_2;
148         Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
149         /* Bool_Glob == 1 */
150         DPRINTF(("Bool_Glob %d == 1, Int_1_Loc %d == 2, Int_2_Loc %d == 3\n", Bool_Glob, Int_1_Loc, Int_2_Loc));
151         while (Int_1_Loc < Int_2_Loc)  /* loop body executed once */
152             {
153                 DPRINTF(("m.1 Executes once.\n"));
154                 Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
155                 /* Int_3_Loc == 7 */
156                 DPRINTF(("Int_3_Loc %d == 7\n", Int_3_Loc));
157                 DPRINTF(("Proc_7\n"));
158                 Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
159                 /* Int_3_Loc == 7 */
160                 Int_1_Loc += 1;
161             } /* while */
162         DPRINTF(("m.2 Check above executed once.\n"));
163         /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
164         DPRINTF(("Int_1_Loc %d == 3, Int_2_Loc %d == 3, Int_3_Loc %d == 7\n",
165                Int_1_Loc, Int_2_Loc, Int_3_Loc));
166
167         DPRINTF(("Proc_8\n"));
168         Proc_8 (Arr_1_Glob, (int *)Arr_2_Glob, Int_1_Loc, Int_3_Loc);
169         /* Int_Glob == 5 */
170         DPRINTF(("Int_Glob %d == 5\n", Int_Glob));
171         DPRINTF(("Proc_1\n"));
172         Proc_1 (Ptr_Glob);
173         for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
174             /* loop body executed twice */
175             {
176                 DPRINTF(("Func_1\n"));
177                 if (Enum_Loc == Func_1 (Ch_Index, 'C'))
178                     /* then, not executed */
179                     {
180                         DPRINTF(("Proc_6\n"));
181                         Proc_6 (Ident_1, &Enum_Loc);
182                         strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
183                         Int_2_Loc = Run_Index;
184                         Int_Glob = Run_Index;
185                     }
186             }
187         /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
188         DPRINTF(("Int_1_Loc %d == 3, Int_2_Loc %d == 3, Int_3_Loc %d == 7\n",
189                Int_1_Loc, Int_2_Loc, Int_3_Loc));
190
191         Int_2_Loc = Int_2_Loc * Int_1_Loc;
192         Int_1_Loc = Int_2_Loc / Int_3_Loc;
193         Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
194         /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
195         DPRINTF(("Int_1_Loc %d == 1, Int_2_Loc %d == 13, Int_3_Loc %d == 7\n",
196                Int_1_Loc, Int_2_Loc, Int_3_Loc));
197         DPRINTF(("Proc_2\n"));
198         Proc_2 (&Int_1_Loc);
199         /* Int_1_Loc == 5 */
200         DPRINTF(("Int_1_Loc %d == 5\n", Int_1_Loc));
201         DPRINTF(("Looping.\n"));
202     } /* loop "for Run_Index" */
203
204     _printTStates();
205
206     printf("Run_Index = %d\n", Run_Index);
207
208     runTime = _clock() - runTime;
209
210     printf ("Execution ends\n");
211     printf ("\n");
212     printf ("Final values of the variables used in the benchmark:\n");
213     printf ("\n");
214     printf ("Int_Glob:            %d\n", Int_Glob);
215     printf ("        should be:   %d\n", (int)5);
216     printf ("Bool_Glob:           %d\n", Bool_Glob);
217     printf ("        should be:   %d\n", (int)1);
218     printf ("Ch_1_Glob:           %c\n", Ch_1_Glob);
219     printf ("        should be:   %c\n", 'A');
220     printf ("Ch_2_Glob:           %c\n", Ch_2_Glob);
221     printf ("        should be:   %c\n", 'B');
222     printf ("Arr_1_Glob[8]:       %d\n", Arr_1_Glob[8]);
223     printf ("        should be:   %d\n", (int)7);
224     printf ("Arr_2_Glob[8][7]:    %d\n", Arr_2_Glob[8][7]);
225     printf ("        should be:   Number_Of_Runs + 10\n");
226     printf ("Ptr_Glob->\n");
227     printf ("  Ptr_Comp:          %d\n", (int) Ptr_Glob->Ptr_Comp);
228     printf ("        should be:   (implementation-dependent)\n");
229     printf ("  Discr:             %d\n", (int)Ptr_Glob->Discr);
230     printf ("        should be:   %d\n", (int)0);
231     printf ("  Enum_Comp:         %d\n", (int)Ptr_Glob->variant.var_1.Enum_Comp);
232     printf ("        should be:   %d\n", (int)2);
233     printf ("  Int_Comp:          %d\n", (int)Ptr_Glob->variant.var_1.Int_Comp);
234     printf ("        should be:   %d\n", (int)17);
235     printf ("  Str_Comp:          %s\n", (char *)Ptr_Glob->variant.var_1.Str_Comp);
236     printf ("        should be:   DHRYSTONE PROGRAM, SOME STRING\n");
237     printf ("Next_Ptr_Glob->\n");
238     printf ("  Ptr_Comp:          %d\n", (int) Next_Ptr_Glob->Ptr_Comp);
239     printf ("        should be:   (implementation-dependent), same as above\n");
240     printf ("  Discr:             %d\n", Next_Ptr_Glob->Discr);
241     printf ("        should be:   %d\n", (int)0);
242     printf ("  Enum_Comp:         %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
243     printf ("        should be:   %d\n", (int)1);
244     printf ("  Int_Comp:          %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp);
245     printf ("        should be:   %d\n", (int)18);
246     printf ("  Str_Comp:          %s\n",
247             Next_Ptr_Glob->variant.var_1.Str_Comp);
248     printf ("        should be:   DHRYSTONE PROGRAM, SOME STRING\n");
249     printf ("Int_1_Loc:           %d\n", Int_1_Loc);
250     printf ("        should be:   %d\n", (int)5);
251     printf ("Int_2_Loc:           %d\n", Int_2_Loc);
252     printf ("        should be:   %d\n", (int)13);
253     printf ("Int_3_Loc:           %d\n", Int_3_Loc);
254     printf ("        should be:   %d\n", (int)7);
255     printf ("Enum_Loc:            %d\n", Enum_Loc);
256     printf ("        should be:   %d\n", (int)1);
257     printf ("Str_1_Loc:           %s\n", Str_1_Loc);
258     printf ("        should be:   DHRYSTONE PROGRAM, 1'ST STRING\n");
259     printf ("Str_2_Loc:           %s\n", Str_2_Loc);
260     printf ("        should be:   DHRYSTONE PROGRAM, 2'ND STRING\n");
261     printf ("\n");
262
263     printf("Time: %u ticks\n", runTime);
264     printf("Dhrystones/s = %u\n", Number_Of_Runs / (runTime/HZ));
265     printf("MIPS = d/s/1757 = (sigh, need floats...)\n");
266     _printTStates();
267 }
268
269 void Proc_1 (REG Rec_Pointer Ptr_Val_Par)
270 /* executed once */
271 {
272     REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;  
273     /* == Ptr_Glob_Next */
274     /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp,    */
275     /* corresponds to "rename" in Ada, "with" in Pascal           */
276   
277     structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob); 
278     Ptr_Val_Par->variant.var_1.Int_Comp = 5;
279     Next_Record->variant.var_1.Int_Comp 
280         = Ptr_Val_Par->variant.var_1.Int_Comp;
281     Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
282     Proc_3 (&Next_Record->Ptr_Comp);
283     /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp 
284        == Ptr_Glob->Ptr_Comp */
285     if (Next_Record->Discr == Ident_1)
286         /* then, executed */
287         {
288             Next_Record->variant.var_1.Int_Comp = 6;
289             Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp, 
290                     &Next_Record->variant.var_1.Enum_Comp);
291             Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
292             Proc_7 (Next_Record->variant.var_1.Int_Comp, 10, 
293                     &Next_Record->variant.var_1.Int_Comp);
294         }
295     else /* not executed */
296         structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
297 } /* Proc_1 */
298
299
300 void Proc_2 (One_Fifty *Int_Par_Ref)
301     /******************/
302     /* executed once */
303     /* *Int_Par_Ref == 1, becomes 4 */
304 {
305     One_Fifty  Int_Loc;  
306     Enumeration   Enum_Loc;
307
308     DPRINTF(("-> Proc_2\n"));
309
310     Int_Loc = *Int_Par_Ref + 10;
311     do {
312         DPRINTF(("1\n"));
313         /* executed once */
314         if (Ch_1_Glob == 'A')
315             /* then, executed */
316             {
317                 DPRINTF(("2\n"));
318                 Int_Loc -= 1;
319                 *Int_Par_Ref = Int_Loc - Int_Glob;
320                 Enum_Loc = Ident_1;
321             } /* if */
322         DPRINTF(("3\n"));
323     } while (Enum_Loc != Ident_1); /* true */
324     DPRINTF(("Proc_2 done.\n"));
325 } /* Proc_2 */
326
327
328 void Proc_3 (Rec_Pointer *Ptr_Ref_Par)
329     /******************/
330     /* executed once */
331     /* Ptr_Ref_Par becomes Ptr_Glob */
332 {
333     if (Ptr_Glob != Null)
334         /* then, executed */
335         *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
336     Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
337 } /* Proc_3 */
338
339 void Proc_4 (void) /* without parameters */
340     /*******/
341     /* executed once */
342 {
343     Boolean Bool_Loc;
344
345     DPRINTF(("-> Proc_4\n"));
346     Bool_Loc = Ch_1_Glob == 'A';
347     Bool_Glob = Bool_Loc | Bool_Glob;
348     Ch_2_Glob = 'B';
349     DPRINTF(("Expect Ch_1_Glob '%c' == 'A'\n", (char)Ch_1_Glob));
350     DPRINTF(("       Ch_2_Glob '%c' == 'B'\n", (char)Ch_2_Glob));
351     DPRINTF(("       Bool_Loc %d == 1\n", (unsigned)Bool_Loc));
352     DPRINTF(("       Bool_Glob %d == 1\n", (unsigned)Bool_Glob));
353 } /* Proc_4 */
354
355
356 void Proc_5 () /* without parameters */
357     /*******/
358     /* executed once */
359 {
360     Ch_1_Glob = 'A';
361     Bool_Glob = false;
362 } /* Proc_5 */
363
364 void Proc_6 (Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par)
365     /*********************************/
366     /* executed once */
367     /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
368
369 {
370     *Enum_Ref_Par = Enum_Val_Par;
371     if (! Func_3 (Enum_Val_Par))
372         /* then, not executed */
373         *Enum_Ref_Par = Ident_4;
374     switch (Enum_Val_Par)
375         {
376         case Ident_1: 
377             *Enum_Ref_Par = Ident_1;
378             break;
379         case Ident_2: 
380             if (Int_Glob > 100)
381                 /* then */
382                 *Enum_Ref_Par = Ident_1;
383             else *Enum_Ref_Par = Ident_4;
384             break;
385         case Ident_3: /* executed */
386             *Enum_Ref_Par = Ident_2;
387             break;
388         case Ident_4: break;
389         case Ident_5: 
390             *Enum_Ref_Par = Ident_3;
391             break;
392         } /* switch */
393 } /* Proc_6 */
394
395
396 /*************************************************/
397 /* executed three times                                         */
398 /* first call:      Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R'    */
399 /* second call:     Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C'    */
400 /* third call:      Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C'    */
401 Enumeration Func_1 (Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val)
402 {
403     Capital_Letter        Ch_1_Loc;
404     Capital_Letter        Ch_2_Loc;
405
406     DPRINTF(("-> Func_1\n"));
407     DPRINTF(("  Inputs: Ch_1_Par_Val '%c' == { R, A, B }\n", (char)Ch_1_Par_Val));
408     DPRINTF(("          Ch_2_Par_Val '%c' == { Y, C, C }\n", (char)Ch_2_Par_Val));
409
410     Ch_1_Loc = Ch_1_Par_Val;
411     Ch_2_Loc = Ch_1_Loc;
412     if (Ch_2_Loc != Ch_2_Par_Val) {
413         /* then, executed */
414         return (Ident_1);
415     }
416     else  /* not executed */
417         {
418             Ch_1_Glob = Ch_1_Loc;
419             return (Ident_2);
420         }
421 } /* Func_1 */
422
423 Boolean Func_3 (Enumeration Enum_Par_Val)
424     /***************************/
425     /* executed once        */
426     /* Enum_Par_Val == Ident_3 */
427 {
428     Enumeration Enum_Loc;
429
430     Enum_Loc = Enum_Par_Val;
431     if (Enum_Loc == Ident_3)
432         /* then, executed */
433         return (true);
434     else /* not executed */
435         return (false);
436 } /* Func_3 */
437
438 void Proc_7 (One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val, One_Fifty *Int_Par_Ref)
439     /**********************************************/
440     /* executed three times                                      */ 
441     /* first call:      Int_1_Par_Val == 2, Int_2_Par_Val == 3,  */
442     /*                  Int_Par_Ref becomes 7                    */
443     /* second call:     Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
444     /*                  Int_Par_Ref becomes 17                   */
445     /* third call:      Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
446     /*                  Int_Par_Ref becomes 18                   */
447 {
448     One_Fifty Int_Loc;
449
450     Int_Loc = Int_1_Par_Val + 2;
451     *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
452 } /* Proc_7 */
453
454 /*void Proc_8 (Arr_1_Dim Arr_1_Par_Ref, Arr_2_Dim Arr_2_Par_Ref, 
455   int Int_1_Par_Val, int Int_2_Par_Val)*/
456 void Proc_8 (int *Arr_1_Par_Ref, int *Arr_2_Par_Ref,
457              int Int_1_Par_Val, int Int_2_Par_Val)
458 {
459     REG One_Fifty Int_Index;
460     REG One_Fifty Int_Loc;
461
462     DPRINTF(("-> Proc_8\n"));
463     Int_Loc = Int_1_Par_Val + 5;
464     Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
465     DPRINTF(("Int_Loc %d == 8 Int_2_Par_Val %d == 7\n", Int_Loc, Int_2_Par_Val));
466
467     Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
468     Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
469     for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
470         Arr_2_Par_Ref [Int_Loc*50 + Int_Index] = Int_Loc;
471     Arr_2_Par_Ref [Int_Loc * 50 + Int_Loc-1] += 1;
472     Arr_2_Par_Ref [(Int_Loc+20 *50) + Int_Loc] = Arr_1_Par_Ref [Int_Loc];
473     Int_Glob = 5;
474     DPRINTF(("Arr_1_Glob[8] %d == 7\n", Arr_1_Par_Ref[8]));
475 }
476
477 /*********************************************************************/
478 /* executed once      */
479 /* Int_Par_Val_1 == 3 */
480 /* Int_Par_Val_2 == 7 */
481 Boolean Func_2 (char *Str_1_Par_Ref, char *Str_2_Par_Ref)
482     /*************************************************/
483     /* executed once */
484     /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
485     /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
486 {
487     REG One_Thirty        Int_Loc;
488     Capital_Letter    Ch_Loc;
489
490     DPRINTF(("-> Func_2\n"));
491     DPRINTF(("  Inputs Str_1_Par_Ref \"%s\" = \"DHRYSTONE PROGRAM, 1'ST STRING\"\n", Str_1_Par_Ref));
492     DPRINTF(("         Str_2_Par_Ref \"%s\" = \"DHRYSTONE PROGRAM, 2'ND STRING\"\n", Str_2_Par_Ref));
493
494     Int_Loc = 2;
495
496     while (Int_Loc <= 2) {
497         if (Func_1 (Str_1_Par_Ref[Int_Loc],
498                     Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
499             /* then, executed */
500             {
501                 DPRINTF(("  2.3 Then OK.\n"));
502                 Ch_Loc = 'A';
503                 Int_Loc += 1;
504             } /* if, while */
505         else {
506             DPRINTF(("  2.2 Error.\n"));
507         }
508     }
509     if (Ch_Loc >= 'W' && Ch_Loc < 'Z') {
510         /* then, not executed */
511         DPRINTF((" 2.4 Error\n"));
512         Int_Loc = 7;
513     }
514     if (Ch_Loc == 'R') {
515         /* then, not executed */
516         DPRINTF((" 2.5 Error\n"));
517         return (true);
518     }
519     else /* executed */
520         {
521             DPRINTF(("Str_1_Par_Ref = \"%s\", Str_2_Par_Ref = \"%s\"\n",
522                    Str_1_Par_Ref, Str_2_Par_Ref));
523             if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
524                 /* then, not executed */
525                 {
526                     DPRINTF((" 2.5 Error diff=%d\n", strcmp(Str_1_Par_Ref, Str_2_Par_Ref)));
527                     Int_Loc += 7;
528                     Int_Glob = Int_Loc;
529                     return (true);
530                 }
531             else {
532                 /* executed */
533                 DPRINTF((" 2.6 OK\n"));
534                 return (false);
535             }
536         } /* if Ch_Loc */
537 } /* Func_2 */