home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 01 / pattern / bp5.pro < prev    next >
Encoding:
Text File  |  1987-06-05  |  6.7 KB  |  263 lines
  1. /*********************************************
  2.    Programm BP5.PRO: PASCAL Pretty Printer 
  3. *********************************************/
  4.  
  5. include "MATCH.1" 
  6.  
  7. domains
  8.   file = input ; output
  9.  
  10. include "MATCH.2"
  11.  
  12. predicates
  13.   cleardatab
  14.   endsymbol(string, string)
  15.   pattern(symbol, patternlist)
  16.   main
  17.   literal(symbol, stringlist)
  18.   boost(string, string)
  19.   out(string)
  20.   treat(string)
  21.   handle(string, integer, integer)
  22.   repeat
  23.   do(string)
  24.   writeuntil(string, string)
  25.  
  26. goal
  27.   main.
  28.  
  29. include "MATCH.3" 
  30.  
  31. clauses
  32.   literal(ops, [":=","<=",">=","<>","=","<",">"]).
  33.   literal(keywords, [" BEGIN"," END;", " END.", " END",
  34.     " REPEAT", " UNTIL", " WHILE", " DO",
  35.     " IF", " THEN", " VAR"," CONST", " TYPE",
  36.     " PROCEDURE", " FUNCTION", " CASE", " OF", 
  37.     " ELSE", " RECORD", " PROGRAM", " FOR", " TO",
  38.     " IN", " WITH"]).
  39.   
  40.   pattern(middlekey, [break(Key), any(Key),
  41.     any([" ","=",":",";"]), rtab(0)]):-
  42.     literal(keywords, Key).
  43.   pattern(endkey, [break(Key), any(Key),
  44.     lit(""), rpos(0)]):-
  45.     literal(keywords, Key).
  46.   pattern(ops, [notany([' ']), any(Ops), 
  47.     notany([' ']), rtab(0)]):-
  48.     literal(ops, Ops).
  49.  
  50.   main :-
  51.     makewindow(1,7,7,"PRETTY PRINTER",0,0,25,80), 
  52.     write("Input File:  "), readln(Infile), 
  53.     write("Output File:  "), readln(Outfile), 
  54.     openread(input, Infile),
  55.     openwrite(output, Outfile),
  56.     cleardatab,
  57.     asserta(caseflag(0)),
  58.     asserta(indent(0)), 
  59.     asserta(head(1)), /* assume prog header */
  60.     readdevice(input),
  61.     repeat,
  62.     readln(In),
  63.     trim(In, Line),
  64.     writedevice(screen), write(Line), nl,
  65.     writedevice(output),
  66.     concat(" ", Line, Line1),
  67.     boost(Line1, Line2),
  68.     treat(Line2), 
  69.     fail.
  70.  
  71.   main:-
  72.     closefile(input), closefile(output),
  73.     openread(input, "Y"),
  74.     openwrite(output, "y1"),
  75.     readdevice(input), writedevice(output),
  76.     repeat,
  77.     readln(Line),
  78.     do(Line),
  79.     fail.
  80.   main:-
  81.     closefile(input), closefile(output),
  82.     renamefile("y1", "y"),
  83.     exit.
  84.     
  85.   endsymbol("(*", "*)").
  86.   endsymbol("{",  "}").
  87.   endsymbol("'",  "'").
  88.   
  89.   cleardatab :-
  90.     retract(indent(_)), fail.
  91.   cleardatab :-
  92.     retract(head(_)), fail.
  93.   cleardatab:-
  94.     retract(caseflag(_)), fail.
  95.   cleardatab.
  96.  
  97.   writeuntil(End, Str) :-
  98.     match(Str, [break([End]), lit(End), rtab(0)],
  99.       [Out, Out1, Rest]), !,
  100.     write(Out, Out1), 
  101.     treat(Rest).  
  102.   writeuntil(End, Str) :- !,
  103.     write(Str), nl,
  104.     readln(Next),
  105.     writedevice(screen),
  106.     write(Next), nl,
  107.     writedevice(output),
  108.     writeuntil(End, Next).
  109.   writeuntil(_, _).
  110.     
  111.   do(Str) :- 
  112.     Str > "                                     ",
  113.     write(Str), nl, !.
  114.   do(_).
  115.   
  116.   boost("", ""):- !.
  117.   boost(Str, Str1) :- 
  118.     pattern(ops, Pat),
  119.     match(Str, Pat, [W, Op, Z, Rest]),
  120.     concat(W, " ", W1), concat(Op, " ", Op1),
  121.     concat(W1, Op1, Exp),
  122.     concat(Z, Rest, Rest1),
  123.     boost(Rest1, Rest11),
  124.     concat(Exp, Rest11, Str1), !.
  125.   boost(S1, S2) :-
  126.     match(S1, [any([",",":", ";"]), notany([' ','=']), rtab(0)],
  127.       [A1, Nonblank, R]),
  128.     concat(A1, " ", A2),
  129.     concat(Nonblank, R, Rest),
  130.     boost(Rest, Rest1),
  131.     concat(A2, Rest1, S2), !.      
  132.   boost(S1, S2):-
  133.     frontchar(S1, A, Rest),
  134.     boost(Rest, Rest1),
  135.     str_char(A1, A),
  136.     concat(A1, Rest1, S2).
  137.  
  138.   
  139.   treat(""):- !.      
  140.   treat(Str) :-
  141.     match(Str, [ break(["{","(*","'"]), any(["{","(*","'"]), 
  142.        rtab(0) ], [W, Special, Z]),
  143.     treat(W),
  144.     write(Special),
  145.     endsymbol(Special, EndSpec),
  146.     writeuntil(EndSpec, Z), 
  147.     nl, indent(N), dupl(N, " ", Pref), 
  148.     write(Pref), !.
  149.   treat(Str):-
  150.     upper_lower(UpStr, Str),
  151.     pattern(middlekey, Pat),
  152.     match(UpStr, Pat, [UpW, Key, _, UpZ]),
  153.     /* write(Id), nl, */
  154.     str_len(UpW, LUpW),
  155.     frontstr(LUpW, Str, W, _),
  156.     match(W, [span([""," "]), rtab(0)], [_, W1]),
  157.     out(W1), 
  158.     indent(IN),
  159.     handle(Key, IN, Indent),
  160.     retract(indent(_)), 
  161.     assertz(indent(Indent)),
  162.     str_len(UpZ, LUpZ), str_len(Str, LStr),
  163.     Pos = LStr - (LUpZ + 1),
  164.     frontstr(Pos, Str, _, Z), !,
  165.     concat(" ", Z, Z1),
  166.     treat(Z1).
  167.   treat(Str) :-
  168.     upper_lower(UpStr, Str),
  169.     pattern(endkey, Pat),
  170.     match(UpStr, Pat, [UpW, Key, _, _]),
  171.     str_len(UpW, LUpW),
  172.     frontstr(LUpW, Str, W, _),
  173.     match(W, [span([""," "]), rtab(0)], [_, W1]),
  174.     out(W1), 
  175.     indent(IN),
  176.     handle(Key, IN, Indent),
  177.     retract(indent(_)), 
  178.     assertz(indent(Indent)), !. 
  179.   treat(Str):-
  180.     match(Str, [span([""," "]), rtab(0)], [_, NewStr]),
  181.     NewStr <> "",
  182.     out(NewStr).    
  183.   treat(_).
  184.  
  185.   handle(Key, _, 3) :-
  186.     member(Key, [" VAR", " CONST", " TYPE"]),
  187.     nl,
  188.     frontchar(Key, ' ', Key1),
  189.     write(Key1), nl, write("   ").
  190.   handle(Key, _, 0) :-
  191.     member(Key, [" PROGRAM", " PROCEDURE", " FUNCTION"]),
  192.     retract(head(_)),
  193.     assertz(head(1)),
  194.     nl, frontchar(Key, ' ', Key1),
  195.     write(Key1, " ").
  196.   handle(" BEGIN", _, 3) :-
  197.     head(1), 
  198.     retract(head(_)),
  199.     assertz(head(0)),
  200.     nl, write("BEGIN"), nl,
  201.     dupl(3, " ", Pref1),
  202.     write(Pref1).
  203.   handle(Key, N, N1) :-
  204.     member(Key, [" BEGIN", " REPEAT", " RECORD"]),
  205.     nl, frontchar(Key, ' ', Key1),
  206.     dupl(N, " ", Pref),
  207.     write(Pref, Key1), nl,
  208.     N1=N+3,
  209.     dupl(N1, " ", Pref1),
  210.     write(Pref1).
  211.   handle(Key, N, N1):-
  212.     member(Key, [" END;", " END", " END."]),
  213.     nl, frontchar(Key, ' ', Key1),
  214.     N1=N-3,  
  215.     dupl(N1, " ", Pref),
  216.     write(Pref, Key1), nl,
  217.     dupl(N1, " ", Pref1),
  218.     write(Pref1).
  219.   handle(Key, N, N1) :-
  220.     member(Key, [" UNTIL"]),
  221.     nl, frontchar(Key, ' ', Key1),
  222.     N1=N-3,  
  223.     dupl(N1, " ", Pref),
  224.     write(Pref, Key1, " ").
  225.   handle(Key, N, N) :-
  226.     member(Key, [" DO", " THEN", " IN"]),
  227.     write(Key, " ").
  228.   handle(Key, N, N) :-
  229.     member(Key, [" FOR", " WHILE", " IF", 
  230.     " ELSE", " WITH"]),
  231.     nl, frontchar(Key, ' ', Key1),
  232.     dupl(N, " ", Pref),
  233.     write(Pref, Key1, " ").
  234.   handle(" CASE", N, N) :-
  235.     nl, dupl(N, " ", Pref),
  236.     write(Pref, "CASE "),
  237.     retract(caseflag(_)),
  238.     asserta(caseflag(1)).
  239.   handle(" OF", N, N1) :-
  240.     caseflag(1),
  241.     retract(caseflag(_)), assertz(caseflag(0)),
  242.     write(" OF"), nl, N1 = N +3,
  243.     dupl(N1, " ", Pref), write(Pref).          
  244.   handle(" OF", N, N) :-
  245.     write(" OF ").
  246.             
  247.   out(""):- !.
  248.   out(Str) :-
  249.     frontchar(Str, ';', Rest),
  250.     write(";"), nl,
  251.     indent(M), dupl(M, " ", Pref),
  252.     write(Pref), !,
  253.     match(Rest, [span([""," "]), rtab(0)], [_, W1]),
  254.     out(W1).
  255.   out(Str) :-
  256.     frontchar(Str, A, Rest),
  257.     write(A), out(Rest).
  258.   
  259.   repeat.
  260.   repeat:- not(eof(input)),
  261.     repeat.
  262. /****************Ende BP5***********************/
  263.