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 / ddd / vsl.C < prev    next >
C/C++ Source or Header  |  1998-11-23  |  7KB  |  303 lines
  1. // $Id: vsl.C,v 1.13 1998/11/23 17:43:48 zeller Exp $ 
  2. // Read and evaluate VSL library
  3.  
  4. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of DDD.
  8. // 
  9. // DDD is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU 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. // DDD 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 General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU General Public
  20. // License along with DDD -- see the file COPYING.
  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. char vsl_rcsid[] = 
  30.     "$Id: vsl.C,v 1.13 1998/11/23 17:43:48 zeller Exp $";
  31.  
  32. #include "assert.h"
  33. #include <iostream.h>
  34. #include "strclass.h"
  35. #include <stdlib.h>
  36. #include <sys/types.h>
  37. #include <time.h>
  38.  
  39. #include <X11/Intrinsic.h>      // X Toolkit
  40. #include <X11/Xlib.h>           // X Library
  41. #include <X11/Xaw/Viewport.h>   // Viewport Widget
  42. #include <X11/StringDefs.h>     // String Definitions
  43. #include <X11/Xaw/Cardinals.h>  // Definition ZERO
  44. #include "DocSpace.h"           // DocSpace Widget
  45.  
  46. #include "bool.h"
  47. #include "VSLLib.h"
  48. #include "VSLDef.h"
  49. #include "VSEFlags.h"
  50.  
  51. #include "Box.h"
  52. #include "StringBox.h"
  53. #include "ListBox.h"
  54.  
  55. #ifndef EXIT_SUCCESS
  56. #define EXIT_SUCCESS 0
  57. #endif
  58.  
  59. #ifndef EXIT_FAILURE
  60. #define EXIT_FAILURE 1
  61. #endif
  62.  
  63.  
  64.  
  65. // Graphics functions
  66. void Flush(Widget w)
  67. {
  68.     Display *display = XtDisplay(w);
  69.     
  70.     XFlush(display);
  71. }
  72.  
  73. // Standard resources
  74. String fallback_resources[] = 
  75.     { "*Viewport.width:    400", "*Viewport.height: 400", NULL };
  76.  
  77. // These should be part of ExposeCB...
  78. static Box *thebox = 0;
  79.  
  80. // clock() function
  81. #if !HAVE_CLOCK_DECL
  82. extern "C" clock_t clock();
  83. #endif
  84.  
  85. #ifndef CLOCKS_PER_SEC
  86. #define CLOCKS_PER_SEC 1000000
  87. #endif
  88.  
  89. // Redraw
  90. void redraw(Widget w, BoxRegion r, BoxRegion exposed)
  91. {
  92.     if (VSEFlags::verbose)
  93.     {
  94.     cout << "Redraw: " << exposed;
  95.     cout.flush();
  96.     }
  97.  
  98.     clock_t starttime = clock();
  99.     thebox->draw(w, r, exposed);
  100.     clock_t endtime = clock();
  101.  
  102.     if (VSEFlags::show_eval_time)
  103.     cout << " (" << (endtime - starttime) * 1000 / CLOCKS_PER_SEC
  104.          << " ms)\n";
  105.  
  106.     Flush(w);
  107. }
  108.  
  109. // Expose Callback
  110. void ExposeCB(Widget w, XtPointer, XtPointer call_data)
  111. {
  112.     // Set size
  113.     Arg arglist[10];
  114.     int a = 0;
  115.     XtSetArg(arglist[a], XtNwidth,  thebox->size(X)); a++;
  116.     XtSetArg(arglist[a], XtNheight, thebox->size(Y)); a++;
  117.     XtSetValues(w, arglist, a);
  118.  
  119.     // Get region
  120.     XExposeEvent* event = (XExposeEvent *)call_data;
  121.     BoxPoint expose_origin = BoxPoint(event->x, event->y);
  122.     BoxSize  expose_space  = BoxSize(event->width, event->height);
  123.     BoxRegion exposed(expose_origin, expose_space);
  124.  
  125.     redraw(w, BoxRegion(BoxPoint(0,0), thebox->size()), exposed);
  126. }
  127.  
  128. // When selecting: redraw all (for statistics)
  129. void SelectCB(Widget w, XtPointer, XtPointer)
  130. {
  131.     XClearArea(XtDisplay(w), XtWindow(w), 0, 0, 0, 0, false);
  132.  
  133.     redraw(w, 
  134.     BoxRegion(BoxPoint(0,0), thebox->size()), 
  135.     BoxRegion(BoxPoint(0,0), BoxSize(1000000, 1000000)));
  136. }
  137.  
  138.  
  139. XtAppContext app_con;
  140.  
  141. // Callback when done
  142. void QuitCB(Widget, XtPointer, XtPointer)
  143. {
  144.     if (VSEFlags::verbose)
  145.     {
  146.     cout << "Quit!\n";
  147.     cout.flush();
  148.     }
  149.     XtDestroyApplicationContext(app_con);
  150.  
  151.     // Clear box
  152.     if (thebox) 
  153.     thebox->unlink();
  154.  
  155.     // Check if we really deleted everything
  156.     if (UniqueId::inUse() > 0)
  157.     cerr << "Warning: " << UniqueId::inUse() << " IDs still in use\n";
  158.  
  159.     exit(EXIT_SUCCESS);
  160. }
  161.  
  162. // Create argument list
  163. ListBox *vsl_args(int argc, char *argv[])
  164. {
  165.     ListBox *args = new ListBox;
  166.     for (int i = 0; i < argc; i++)
  167.     {
  168.     Box *a = new StringBox(argv[i]);
  169.     *args += a;
  170.     a->unlink();
  171.     }
  172.  
  173.     return args;
  174. }
  175.  
  176. // Main VSL program
  177. int main(int argc, char *argv[])
  178. {
  179.     // Set flags
  180.     VSEFlags::parse(argc, argv, "vsllib");
  181.  
  182.     // Init toolkit
  183.     Widget toplevel = XtAppInitialize(&app_con, "Vsl", NULL, ZERO, 
  184.                       &argc, argv, fallback_resources, 
  185.                       NULL, ZERO);
  186.  
  187.     // Create Viewport
  188.     Arg arglist[10];        // Arguments
  189.     int a = 0;              // Argument counter
  190.     XtSetArg(arglist[a], XtNallowHoriz, true); a++;
  191.     XtSetArg(arglist[a], XtNallowVert,  true); a++;
  192.     Widget viewport = XtCreateManagedWidget("viewport", viewportWidgetClass, 
  193.                         toplevel, arglist, a);
  194.  
  195.     // Create DocSpace
  196.     a = 0;
  197.     Widget docSpace = XtCreateManagedWidget("docSpace", docSpaceWidgetClass, 
  198.                         viewport, arglist, a);
  199.     XtAddCallback(docSpace, XtNcallback, SelectCB, 0);
  200.     XtAddCallback(docSpace, XtNexposeCallback, ExposeCB, 0);
  201.     XtAddCallback(docSpace, XtNquitCallback, QuitCB, 0);
  202.  
  203.     // Set font table
  204.     StringBox::fontTable = new FontTable(XtDisplay(toplevel));
  205.  
  206.     // Fetch name
  207.     string library_file = VSEFlags::library_file;
  208.     if (argc > 1)
  209.     {
  210.     library_file = argv[1];
  211.     if (library_file[0] == '-')
  212.     {
  213.         cout << argv[0] << ": usage: " << argv[0] << " [options] "
  214.         << "vsllib\n\n" << VSEFlags::explain();
  215.  
  216.         exit(EXIT_FAILURE);
  217.     }
  218.     }
  219.     
  220.     // Create pic in THEBOX
  221.     {
  222.     // Read library
  223.     long starttime = clock();
  224.     VSLLib lib(library_file, VSEFlags::optimize_mode());
  225.     long endtime = clock();
  226.  
  227.     if (VSEFlags::show_optimizing_time)
  228.         cout << "\nRead & optimizing time: " 
  229.         << (endtime - starttime) / 1000 << " ms\n";
  230.  
  231.     if (VSEFlags::assert_library_ok)
  232.         assert(lib.OK());
  233.  
  234.     if (VSEFlags::dump_library)
  235.         cout << lib;
  236.  
  237.     if (VSEFlags::dump_tree)
  238.         lib.dumpTree(cout);
  239.  
  240.     if (VSEFlags::suppress_eval)
  241.         return EXIT_SUCCESS;
  242.  
  243.     // Fetch last function def (typically "main")
  244.     VSLDef* def = lib.lastdef();
  245.  
  246.     if (def == 0)
  247.     {
  248.         cerr << argv[0] << ": cannot find last definition (sorry)\n";
  249.         return EXIT_FAILURE;
  250.     }
  251.  
  252.     // Eval function
  253.     ListBox *arg = vsl_args(argc, argv);
  254.  
  255.     starttime = clock();
  256.     for (int loop = 1; loop < VSEFlags::loops; loop++)
  257.     {
  258.         Box *result = (Box *)def->eval(arg);
  259.         lib.output(result);
  260.         result->unlink();
  261.     }
  262.     Box *result = (Box *)def->eval(arg);
  263.     lib.output(result);
  264.     endtime = clock();
  265.     arg->unlink();
  266.  
  267.     // Show eval time
  268.     if (VSEFlags::show_eval_time)
  269.         cout << "\nEvaluation time: " 
  270.         << (endtime - starttime) / 1000 << " ms\n";
  271.  
  272.     if (result && VSEFlags::dump_picture)
  273.         cout << "#!" << argv[0] << "\n#include <std.vsl>\n\nmain() -> "
  274.         << *result << ";\n";
  275.  
  276.     thebox = result;
  277.  
  278.     // Stack and library are destroyed upon leaving this block
  279.     }
  280.  
  281.     if (thebox && !thebox->size().isValid())
  282.     {
  283.     cerr << argv[0] << ": result has no size (maybe list?)\n";
  284.     thebox->unlink();
  285.     thebox = 0;
  286.     }
  287.  
  288.     if (thebox == 0)
  289.     {
  290.     cerr << argv[0] << ": evaluation failed (sorry)\n";
  291.     return EXIT_FAILURE;
  292.     }
  293.  
  294.     // Realize Widget
  295.     XtRealizeWidget(toplevel);
  296.  
  297.     // Process events
  298.     XtAppMainLoop(app_con);
  299.  
  300.     // Never reached...
  301.     return EXIT_SUCCESS;
  302. }
  303.