sort.out

this is a lp0 compilator new

::::::::::::::
sort.pas
::::::::::::::
PROGRAM Main;

TYPE
   SortArray = ARRAY [1..10] OF INTEGER;

VAR
   X            : INTEGER;
   Key     	: SortArray;

PROCEDURE MergeSort ( n : INTEGER;
                      VAR Key : SortArray;
		      X : INTEGER );

VAR 
   CopyKey	: SortArray;
   K		: INTEGER;

PROCEDURE MergeArray ( n : INTEGER;
                       VAR Destination : SortArray;
		       Source1, Source2 : SortArray;
		       VAR D, S1, S2 : INTEGER;
  		       Mid, Upper : INTEGER );

BEGIN { PROCEDURE MergeArray }

   IF ( ( S1 <= Mid ) AND ( S2 <= Upper ) ) THEN
      BEGIN
         IF ( Source[S1] < Source[S2] ) THEN
            BEGIN
               Destination[D] := Source[S1];
               S1 := S1 + 1;
            END
         ELSE
            BEGIN
               Destination[D] := Source[S2];
               S2 := S2 + 1;
            END;
         D := D + 1;
         MergeArray ( n-1, Destination, Source1, Source2, D, S1, S2, Mid, Upper );
      END;

END; { of Procedure MergeArray }

PROCEDURE Merge ( n : INTEGER;
                  Source : SortArray;
	          VAR Destination : SortArray;
	          Lower, Mid, Upper : INTEGER );
VAR
   S1, S2, D	: INTEGER;

BEGIN { PROCEDURE Merge }
   { Initialize Pointers }
   S1 := Lower;
   S2 := Mid + 1;
   D := Lower;

   { Repeat comparison or current items from each list }
   MergeArray ( n, Destination, Source1, Source2, D, S1, S2, Mid, Upper );

   { Move what is left of remaining list }
   IF ( S1 > Mid ) THEN
      BEGIN
         FOR S2 := S2 TO Upper DO 
            BEGIN
               Destination[D] := Source[S2];
               D := D + 1;
            END;
      END
   ELSE
      BEGIN
         FOR S1 := S1 TO Upper DO 
            BEGIN
               Destination[D] := Source[S1];
               D := D + 1;
            END;
      END;

END; { of Procedure Merge }

PROCEDURE Order ( n : INTEGER;
                  Source : SortArray ;
                  VAR Destination : SortArray;
                  Lower, Upper : INTEGER );
VAR
   Mid 		: INTEGER;

BEGIN { PROCEDURE Order }
   IF Lower <> Upper THEN

      BEGIN
         Mid := ( Lower + Upper ) DIV 2;
         Order ( n/2, Destination, Source, Lower, Mid );
         Order ( n/2, Destination, Source, Mid + 1, Upper );
         Merge ( n, Source, Destination, Lower, Mid, Upper );
      END

END;   { of Procedure Order }

BEGIN { PROCEDURE MergeSort }
   FOR K := 1 TO X DO
      CopyKey[K] := Key[K];
   Order ( n, Copykey, Key, 1, X );
END;   { of Procedure MergeSort }

BEGIN { PROGRAM Main }

   MergeSort ( n, Key, X );

END.   { of PROGRAM Main }


::::::::::::::
compx.sym
::::::::::::::


Symbol Table for Pascal source code...
-----------------------------------
1(undefined)
10(undefined)
2(undefined)
copykey(variable)
d(variable)
destination(undefined)
integer(undefined)
k(variable)
key(undefined)
lower(undefined)
main(program)
merge(procedure)	[Maple Function Name = c(n)]
mergearray(procedure)	[Maple Function Name = b(n)]
mergesort(procedure)	[Maple Function Name = a(n)]
mid(variable)
n(undefined)
order(procedure)	[Maple Function Name = d(n)]
s1(variable)
s2(variable)
sortarray(undefined)
source(undefined)
source1(undefined)
source2(undefined)
upper(undefined)
x(undefined)

::::::::::::::
compx.mpl
::::::::::::::
assign ( rsolve ( c(n)=1+1+1+1+1+1+1+b(n)+1+1+sum (1+1+1+1+1+1+1, s2=s2..upper)+1+1+sum (1+1+1+1+1+1+1, s1=s1..upper), c(n) ) );
assign ( rsolve ( b(n)=1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+b(n-1), b(n) ) );
assign ( rsolve ( a(n)=1+1+sum (1+1+1+1, k=1..x)+d(n), a(n) ) );
assign ( rsolve ( d(n)=1+1+1+1+1+1+d(n/2)+d(n/2)+c(n), d(n) ) );
assign ( rsolve ( f(n)=a(n), f(n) ) );