home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / vsllib / flow.vsl < prev    next >
Text File  |  1998-11-23  |  10KB  |  390 lines
  1. // $Id: flow.vsl,v 1.7 1998/11/23 13:52:59 zeller Exp $
  2. // Drawing flow charts
  3.  
  4. // Copyright (C) 1993 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of the DDD Library.
  8. // 
  9. // The DDD Library is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU Library General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // The DDD Library is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU Library General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU Library General Public
  20. // License along with the DDD Library -- see the file COPYING.LIB.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // DDD is the data display debugger.
  25. // For details, see the DDD World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ddd/',
  27. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  28.  
  29. #include "std.vsl"
  30. #include "slopes.vsl"
  31. #include "arcs.vsl"
  32.  
  33. // Flow charts
  34.  
  35. // Version
  36. flow_version() = "$Revision: 1.7 $";
  37.  
  38. // Constants
  39.  
  40. // Minimum with of junction line
  41. flow_space() = box(hspace(" "), whitethickness() * 5);    
  42.  
  43.  
  44. // Junction lines
  45.  
  46. // Corner lines
  47.  
  48. // Half lines
  49. nn_flow() = hcenter(vrule() | vfill()) ^ flow_space();
  50. ss_flow() = hcenter(vfill() | vrule()) ^ flow_space();
  51. ee_flow() = vcenter(hfill() & hrule()) ^ flow_space();
  52. ww_flow() = vcenter(hrule() & hfill()) ^ flow_space();
  53.  
  54. nn_flow(c) = ((hspace(c) | vfill()) & (vrule() | vfill()) & fill()) ^ flow_space();
  55. ss_flow(c) = ((hspace(c) | vfill()) & (vfill() | vrule()) & fill()) ^ flow_space();
  56. ee_flow(c) = vcenter(hspace(c) & hrule()) ^ flow_space();
  57. ww_flow(c) = vcenter((hrule() | hspace(c)) & fill()) ^ flow_space();
  58.  
  59. // Corners (XY_flow() = from X to Y)
  60. ne_flow(...) = nn_flow(...) ^ ee_flow(...);
  61. nw_flow(...) = nn_flow(...) ^ ww_flow(...);
  62. ns_flow(...) = nn_flow(...) ^ ss_flow(...);
  63.  
  64. wn_flow(...) = ww_flow(...) ^ nn_flow(...);
  65. we_flow(...) = ww_flow(...) ^ ee_flow(...);
  66. ws_flow(...) = ww_flow(...) ^ ss_flow(...);
  67.  
  68. se_flow(...) = ss_flow(...) ^ ee_flow(...);
  69. sw_flow(...) = ss_flow(...) ^ ww_flow(...);
  70. sn_flow(...) = ss_flow(...) ^ nn_flow(...);
  71.  
  72. es_flow(...) = ee_flow(...) ^ ss_flow(...);
  73. ew_flow(...) = ee_flow(...) ^ ww_flow(...);
  74. en_flow(...) = ee_flow(...) ^ nn_flow(...);
  75.  
  76.  
  77. // T lines
  78. n_tee(...) = nn_flow(...) ^ we_flow(...);
  79. w_tee(...) = ww_flow(...) ^ ns_flow(...);
  80. s_tee(...) = ss_flow(...) ^ we_flow(...);
  81. e_tee(...) = ee_flow(...) ^ ns_flow(...);
  82.  
  83.  
  84. // Junction arrows
  85.  
  86. // Half, incoming arrows
  87. nn_aflow() = hcenter(s_arrow() | vfill()) ^ flow_space();
  88. ss_aflow() = hcenter(vfill() | n_arrow()) ^ flow_space();
  89. ee_aflow() = vcenter(hfill() & w_arrow()) ^ flow_space();
  90. ww_aflow() = vcenter(e_arrow() & hfill()) ^ flow_space();
  91.  
  92. nn_aflow(c) = hspace(c) & (s_arrow() | vfill()) & hfill();
  93. ss_aflow(c) = hspace(c) & (vfill() | n_arrow()) & hfill();
  94. ee_aflow(c) = hspace(c) & vcenter(w_arrow());
  95. ww_aflow(c) = (hspace(c) | vcenter(e_arrow())) & hfill();
  96.  
  97. // T arrows (arrow head meets bar)
  98. n_addflow(...) = nn_aflow(...) ^ we_flow(...);
  99. w_addflow(...) = ww_aflow(...) ^ ns_flow(...);
  100. s_addflow(...) = ss_aflow(...) ^ we_flow(...);
  101. e_addflow(...) = ee_aflow(...) ^ ns_flow(...);
  102.  
  103.  
  104.  
  105.  
  106. // Symbols
  107.  
  108. // All xxxFlow() fnctions return a tuple (BOX, CONNECT, LABELS, GOTOS)
  109. // BOX is the created image; CONNECT is the horizontal distance of
  110. // the connecting line.
  111.  
  112. // Helpers
  113.  
  114. fallbackFlow(box);
  115.  
  116. // Compute maximum of all CONNECTs
  117. max_connect((_, connect, _...)) = connect;
  118. max_connect((stmt1, connect1, _...), (stmt2, connect2, _...), ...) = 
  119.   if connect1 > connect2 then max_connect((stmt1, connect1), ...)
  120.                          else max_connect((stmt2, connect2), ...) fi;
  121.  
  122. // Helpers for not yet created flows
  123. max_connect((stmt1, connect1, _...), box, ...) = 
  124.     max_connect((stmt1, connect1), fallbackFlow(box), ...);
  125. max_connect(box, ...) = max_connect(fallbackFlow(box), ...);
  126.  
  127.  
  128. // Align a box according to TARGETCONNECT
  129. align((box, boxconnect, _...), targetconnect) = 
  130.   (hspace(targetconnect - boxconnect)) & box;
  131. align(box, targetconnect) =
  132.   align(fallbackFlow(box), targetconnect);
  133.  
  134.  
  135. // Add extensible connections on top and on bottom
  136.  
  137. attach((box, boxconnect, a...)) = 
  138. (
  139.   align((vrule(), 0), boxconnect)
  140. | box
  141. | align((vrule(), 0), boxconnect), boxconnect, a...);
  142.  
  143. attach(box, boxconnect) = attach((box, boxconnect, [], []));
  144.  
  145. attach(anybox) = attach(heven(anybox), hspace(heven(anybox)) / 2);
  146.  
  147.  
  148. // Simple symbols
  149.  
  150. // Ordinary statement
  151.  
  152. statFlow(stmt) = 
  153.   attach(fix(frame(stmt)));
  154.  
  155.  
  156. // Use if param is no flow symbol
  157.  
  158. fallbackFlow(box) = statFlow("BAD BOX: " & frame(box));
  159.  
  160.  
  161. // Procedure call
  162.  
  163. callFlow(stmt) = 
  164. attach(
  165.     hrule() 
  166.   | w_rule() & w_rule() & (hwhite() | stmt | hwhite()) & e_rule() & e_rule()
  167.   | hrule()
  168. );
  169.  
  170.  
  171. // Printing symbol
  172.  
  173. printFlow(stmt) = 
  174. attach(
  175.     (sheet ^ square(vspace(stmt))) & 
  176.         (hrule() | whiteframe(stmt) | hrule()) & vrule()
  177.     where sheet = hrule() | (sw_arc90() & fill()) | fill() & ne_arc90()
  178. );
  179.  
  180.  
  181. // Punch card symbol
  182.  
  183. punchFlow(stmt) = attach(punchcard(stmt));
  184.  
  185.  
  186. // Oval (for start and end)
  187.  
  188. ovalFlow(label) = attach(oval(label));
  189.  
  190.  
  191. // Rhomb (for tests)
  192.  
  193. rhombFlow(cond, truelabel, falselabel) =
  194.   attach(rhomb(cond) ^ ne_flush(truelabel) ^ sw_flush(falselabel));
  195.  
  196.  
  197.  
  198. // Composite symbols
  199.  
  200. // Sequence
  201.  
  202. __seqFlow(max, (stmt, connect, _...)) = align((fix(stmt), connect), max);
  203. __seqFlow(max, (stmt, connect, _...), ...) =
  204.   __seqFlow(max, (stmt, connect))
  205. | align((vrule() & vspace(flow_space()), 0), max)
  206. | __seqFlow(max, ...);
  207. __seqFlow(max, box, ...) =
  208.   __seqFlow(max, fallbackFlow(box), ...);
  209.  
  210. _seqFlow(max, ...) = 
  211.   attach(__seqFlow(max, ...), max);
  212.  
  213. seqFlow(...) = 
  214.   _seqFlow(max_connect(...), ...);
  215.   
  216.  
  217.  
  218.  
  219.  
  220. // Test
  221.  
  222. __testFlow(c1, c2, rhomb, truebody, falsebody) =
  223. attach(
  224.   ( vfix(align(rhomb, c1)) & vcenter(hrule())
  225.   | ns_flow(c1)
  226.   | align(falsebody, c1)
  227.   | ns_flow(c1)
  228.   | vfix(e_addflow(c1))
  229.   ) &
  230.   ( vspace(align(rhomb, c1) / 2)
  231.   | vfix(hrule() | hspace(c2))
  232.   | ns_flow(c2)
  233.   | align(truebody, c2)
  234.   | ns_flow(c2)
  235.   | vfix(hrule() | hspace(c2))
  236.   | vspace(e_addflow(c1) / 2 - 1)
  237.   )
  238. , c1);
  239.  
  240. _testFlow(rhomb, truebody, falsebody) =
  241.   __testFlow(
  242.     max_connect(rhomb, falsebody), max_connect(truebody),
  243.       rhomb, truebody, falsebody);
  244.  
  245. testFlow(cond, truebody, falsebody, tl, fl) =
  246.   _testFlow(rhombFlow(cond, tl, fl), truebody, falsebody);
  247.  
  248. testFlow(cond, truebody, falsebody) = 
  249.   testFlow(cond, truebody, falsebody, "T", "F");
  250.  
  251. testFlow(cond, (tb, tc, a...)) =
  252.   testFlow(cond, (tb, tc, a...), (ns_flow(tc), tc));
  253.  
  254. testFlow(cond, box) = 
  255.   testFlow(cond, fallbackFlow(box));
  256.  
  257.  
  258.  
  259.  
  260.  
  261. // A while loop
  262.  
  263. __positiveTopLoopFlow(c1, c2, rhomb, loopbody) =
  264. attach(
  265.   ( vfix(e_addflow(c1))
  266.   | vfix(align(rhomb, c1)) & vcenter(hrule())
  267.   | ns_flow(c1)
  268.   ) &
  269.   ( vfix(ew_flow(c2))
  270.   | vspace(align(rhomb, c1) / 2)
  271.   | fix(hrule() | hspace(c2))
  272.   | vfix(ns_flow(c2))
  273.   | align(loopbody, c2)
  274.   | vfix(ne_flow(c2))
  275.   ) &
  276.   ( fix(sw_flow())
  277.   | hfix(sn_flow())
  278.   | fix(wn_flow())
  279.   )
  280. , c1);
  281.  
  282. _positiveTopLoopFlow(rhomb, loopbody) =
  283.   __positiveTopLoopFlow(
  284.     max_connect(rhomb), max_connect(loopbody), rhomb, loopbody);
  285.  
  286. positiveTopLoopFlow(cond, loopbody, tl, fl) =
  287.   _positiveTopLoopFlow(rhombFlow(cond, tl, fl), loopbody);
  288.  
  289. positiveTopLoopFlow(cond, loopbody) =
  290.   positiveTopLoopFlow(cond, loopbody, "T", "F");
  291.  
  292.  
  293.  
  294. // An `unless' loop
  295.  
  296. __negativeTopLoopFlow(c, rhomb, loopbody) =
  297. attach(
  298.   ( fix(se_flow())
  299.   | hfix(sn_flow())
  300.   | fix(en_flow())
  301.   | vspace(es_flow(c))
  302.   ) &
  303.   ( vfix(w_addflow(c))
  304.   | align(rhomb, c) & vcenter(hrule())
  305.   | vfix(ns_flow(c))
  306.   | align(loopbody, c)
  307.   | vfix(nw_flow(c))
  308.   | vfix(es_flow(c))
  309.   ) &
  310.   ( vspace(w_addflow(c))
  311.   | vspace(align(rhomb, c) / 2)
  312.   | hfix((hrule() & hfill()) ^ hspace(flow_space()))
  313.   | hfix(ns_flow())
  314.   | fix(nw_flow())
  315.   )
  316. , hspace(se_flow() & c));
  317.  
  318. _negativeTopLoopFlow(rhomb, loopbody) =
  319.   __negativeTopLoopFlow(
  320.     max_connect(rhomb, loopbody), rhomb, loopbody);
  321.  
  322. negativeTopLoopFlow(cond, loopbody, tl, fl) =
  323.   _negativeTopLoopFlow(rhombFlow(cond, tl, fl), loopbody);
  324.  
  325. negativeTopLoopFlow(cond, loopbody) =
  326.   negativeTopLoopFlow(cond, loopbody, "T", "F");
  327.  
  328.  
  329.  
  330. // A `do-while' loop
  331.  
  332. __positiveBottomLoopFlow(c, rhomb, loopbody) =
  333. attach(
  334.   ( vfix(e_addflow(c))
  335.   | align(loopbody, c)
  336.   | vfix(ns_flow(c))
  337.   | align(rhomb, c) & vcenter(hrule())
  338.   ) &
  339.   ( vfix(sw_flow())
  340.   | hfix(sn_flow())
  341.   | (hrule() & hfill()) ^ hspace(flow_space())
  342.   | vspace(align(rhomb, c) / 2)
  343.   )
  344. , c);
  345.  
  346. _positiveBottomLoopFlow(rhomb, loopbody) =
  347.   __positiveBottomLoopFlow(
  348.     max_connect(rhomb, loopbody), rhomb, loopbody);
  349.  
  350. positiveBottomLoopFlow(cond, loopbody, tl, fl) =
  351.   _positiveBottomLoopFlow(rhombFlow(cond, tl, fl), loopbody);
  352.  
  353. positiveBottomLoopFlow(cond, body) =
  354.   positiveBottomLoopFlow(cond, body, "T", "F");
  355.  
  356.  
  357. // A `do-unless' loop
  358.  
  359. __negativeBottomLoopFlow(c, rhomb, loopbody) =
  360. attach(
  361.   ( vfix(se_flow())
  362.   | sn_flow()
  363.   | vfix(en_flow())
  364.   | vspace(es_flow(c))
  365.   ) &
  366.   ( vfix(w_addflow(c))
  367.   | align(loopbody, c)
  368.   | vfix(ns_flow(c))
  369.   | ( align(rhomb, c)
  370.     | vfix(nw_flow(c))
  371.     | vfix(es_flow(c))
  372.     ) &
  373.     ( vspace(align(rhomb, c) / 2)
  374.     | fix((hrule() & hfill()) ^ hspace(flow_space()))
  375.     | hfix(ns_flow())
  376.     | fix(nw_flow())
  377.     )
  378.   )
  379. , hspace(se_flow() & c));
  380.  
  381. _negativeBottomLoopFlow(rhomb, loopbody) =
  382.   __negativeBottomLoopFlow(
  383.     max_connect(rhomb, loopbody), rhomb, loopbody);
  384.  
  385. negativeBottomLoopFlow(cond, loopbody, tl, fl) =
  386.   _negativeBottomLoopFlow(rhombFlow(cond, tl, fl), loopbody);
  387.  
  388. negativeBottomLoopFlow(cond, body) =
  389.   negativeBottomLoopFlow(cond, body, "T", "F");
  390.