Index: ddd/Logger.C
===================================================================
--- ddd/Logger.C	(Revision 7209)
+++ ddd/Logger.C	(Arbeitskopie)
@@ -30,4 +30,4 @@
 
 #include "Logger.h"
 
-int _Logger::depth = 0;
+int Logger::depth = 0;
Index: ddd/ScrolleGEP.h
===================================================================
--- ddd/ScrolleGEP.h	(Revision 7209)
+++ ddd/ScrolleGEP.h	(Arbeitskopie)
@@ -55,7 +55,7 @@
     XtPointer extension;
 } ScrolledGraphEditClassPart;
 
-typedef struct _GraphEditClassRec {
+typedef struct GraphEditClassRec {
     CoreClassPart              core_class;
     CompositeClassPart         composite_class;
     ConstraintClassPart        constraint_class;
@@ -69,12 +69,12 @@
 
 // The ScrolledGraphEdit instance record
 
-typedef struct _ScrolledGraphEditPart {
+typedef struct ScrolledGraphEditPart {
     // resources
     int mumble;
 } ScrolledGraphEditPart;
 
-typedef struct _ScrolledGraphEditRec {
+typedef struct ScrolledGraphEditRec {
     CorePart              core;
     CompositePart         composite;
     ConstraintPart        constraint;
Index: ddd/PannedGEP.h
===================================================================
--- ddd/PannedGEP.h	(Revision 7209)
+++ ddd/PannedGEP.h	(Arbeitskopie)
@@ -52,7 +52,7 @@
     XtPointer extension;
 } PannedGraphEditClassPart;
 
-typedef struct _PannedGraphEditClassRec {
+typedef struct PannedGraphEditClassRec_ {
     CoreClassPart              core_class;
     CompositeClassPart         composite_class;
     PortholeClassPart          porthole_class;
@@ -64,14 +64,14 @@
 
 // The PannedGraphEdit instance record
 
-typedef struct _PannedGraphEditPart {
+typedef struct PannedGraphEditPart_ {
     // resources
     Dimension minimumPannerWidth;
     Dimension minimumPannerHeight;
     Dimension maximumScale;
 } PannedGraphEditPart;
 
-typedef struct _PannedGraphEditRec {
+typedef struct PannedGraphEditRec_ {
     CorePart              core;
     CompositePart         composite;
     PortholePart          porthole;
Index: ddd/exit.C
===================================================================
--- ddd/exit.C	(Revision 7209)
+++ ddd/exit.C	(Arbeitskopie)
@@ -1111,7 +1111,7 @@
 	    std::cerr << message;
 	}
 
-	_DDDExitCB(gdb_w, XtPointer(EXIT_FAILURE), XtPointer(0));
+	DDDExitCB(gdb_w, XtPointer(EXIT_FAILURE), XtPointer(0));
     }
 
     // Don't care about any exceptions seen before the exit
@@ -1126,7 +1126,7 @@
 //-----------------------------------------------------------------------------
 
 // Exit callback
-void _DDDExitCB(Widget w, XtPointer client_data, XtPointer call_data)
+void DDDExitCB(Widget w, XtPointer client_data, XtPointer call_data)
 {
     ddd_cleanup();
 
@@ -1193,7 +1193,7 @@
     if (gdb && gdb->isReadyWithPrompt())
 	DDDDoneCB(w, client_data, call_data);
     else
-	_DDDExitCB(w, client_data, call_data);
+	DDDExitCB(w, client_data, call_data);
 }
 
 // Exit after confirmation
@@ -1206,7 +1206,7 @@
 
 
 // Restart unconditionally
-static void _DDDRestartCB(Widget w, XtPointer client_data, XtPointer call_data)
+static void DDDRestartCB(Widget w, XtPointer client_data, XtPointer call_data)
 {
     static string initial_session;
     initial_session = app_data.session;
@@ -1246,14 +1246,14 @@
 				   XMST("confirm_restart_dialog"),
 				   0, 0));
 	Delay::register_shell(dialog);
-	XtAddCallback(dialog, XmNokCallback, _DDDRestartCB,
+	XtAddCallback(dialog, XmNokCallback, DDDRestartCB,
 		      XtPointer(flags | MAY_KILL));
 	XtAddCallback(dialog, XmNhelpCallback, ImmediateHelpCB, 0);
     
 	manage_and_raise(dialog);
     }
     else
-	_DDDRestartCB(w, XtPointer(flags), call_data);
+	DDDRestartCB(w, XtPointer(flags), call_data);
 }
 
 static void debug_ddd(bool core_dumped)
Index: ddd/LabelHP.h
===================================================================
--- ddd/LabelHP.h	(Revision 7209)
+++ ddd/LabelHP.h	(Arbeitskopie)
@@ -39,13 +39,13 @@
 
 #include "LabelH.h"
 
-typedef struct _XmLabelHackClassPart
+typedef struct XmLabelHackClassPart
 {
 	int on;
 } XmLabelHackClassPart;
 
 
-typedef struct _XmLabelHackClassRec
+typedef struct XmLabelHackClassRec
 {
 	CoreClassPart core_class;
 	XmPrimitiveClassPart primitive_class;
@@ -55,7 +55,7 @@
 
 externalref XmLabelHackClassRec xmLabelHackWidgetClassRec;
 
-typedef struct _XmLabelHackPart
+typedef struct XmLabelHackPart
 {
 	Boolean insensitive3D;
 	GC topGC, bottomGC;
@@ -64,7 +64,7 @@
 
 /*  Full instance record declaration  */
 
-typedef struct _XmLabelHackRec
+typedef struct XmLabelHackRec
 {
 	CorePart core;
 	XmPrimitivePart primitive;
Index: ddd/Logger.h
===================================================================
--- ddd/Logger.h	(Revision 7209)
+++ ddd/Logger.h	(Arbeitskopie)
@@ -35,13 +35,13 @@
 #include "config.h"		// HAVE_PRETTY_FUNCTION
 #endif
 
-class _Logger {
+class Logger {
     string _function;
     string _args;
     static int depth;
 
 public:
-    _Logger(const string& function, const string& args)
+    Logger(const string& function, const string& args)
 	: _function(function), _args(args)
     {
 	std::clog << ++depth
@@ -49,7 +49,7 @@
 	     << "(" << _args << ")"
 	     << "...\n";
     }
-    ~_Logger()
+    ~Logger()
     {
 	std::clog << depth--
 	     << " " << _function 
@@ -59,11 +59,11 @@
 };
 
 #if HAVE_PRETTY_FUNCTION
-#define LOG(args) _Logger lOgGeR(__PRETTY_FUNCTION__, args)
+#define LOG(args) Logger lOgGeR(__PRETTY_FUNCTION__, args)
 #elif HAVE_FUNCTION
-#define LOG(args) _Logger lOgGeR(__FUNCTION__, args)
+#define LOG(args) Logger lOgGeR(__FUNCTION__, args)
 #else
-#define LOG(args) _Logger lOgGeR("function call", args)
+#define LOG(args) Logger lOgGeR("function call", args)
 #endif
 
 #endif // _DDD_Logger_h
Index: ddd/Agent.h
===================================================================
--- ddd/Agent.h	(Revision 7209)
+++ ddd/Agent.h	(Arbeitskopie)
@@ -57,7 +57,7 @@
     Agent::InputEOF -- EOF on input channel detected
     Agent::ErrorEOF -- EOF on error channel detected
     Agent::Died     -- the agent died
-    Agent::_Died    -- the agent has a new status (called asynchronously)
+    Agent::Died_    -- the agent has a new status (called asynchronously)
 
     A handler takes the form
     void handler(Agent *source, void *client_data, void *call_data)
@@ -66,9 +66,9 @@
     In Agent::Panic, char *s = (char *)call_data is the I/O error message,
     In Agent::Died, char *s = (char *)call_data is the reason for the 
 	agent to die (in plain text). lastStatus() gives the status itself.
-    In Agent::_Died, int status = (int)call_data is the new agent state.
+    In Agent::Died_, int status = (int)call_data is the new agent state.
 
-    Note that Agent::_Died is invoked asynchronously from signal();
+    Note that Agent::Died_ is invoked asynchronously from signal();
     thus the event handlers must not call any non-reentrant routines.
 
     For Agent writers, an alternative interface is provided with the
@@ -122,9 +122,9 @@
 const unsigned InputEOF = Stopped + 1;  // EOF on input detected
 const unsigned ErrorEOF = InputEOF + 1; // EOF on error detected
 const unsigned Died     = ErrorEOF + 1; // Process died
-const unsigned _Died    = Died + 1;     // New Status (async call)
+const unsigned Died_    = Died + 1;     // New Status (async call)
 
-const unsigned Agent_NTypes = _Died + 1;    // number of events
+const unsigned Agent_NTypes = Died_ + 1;    // number of events
 
 const int READ = 0;		// constants for pipe indexing
 const int WRITE = 1;
Index: ddd/ScrolledGE.h
===================================================================
--- ddd/ScrolledGE.h	(Revision 7209)
+++ ddd/ScrolledGE.h	(Arbeitskopie)
@@ -31,8 +31,8 @@
 #include "GraphEdit.h"
 
 // Declare specific GraphEdit class and instance datatypes
-typedef struct _ScrolledGraphEditClassRec *ScrolledGraphEditWidgetClass;
-typedef struct _ScrolledGraphEditRec      *ScrolledGraphEditWidget;
+typedef struct ScrolledGraphEditClassRec *ScrolledGraphEditWidgetClass;
+typedef struct ScrolledGraphEditRec      *ScrolledGraphEditWidget;
 
 // Declare the class constant
 extern WidgetClass scrolledGraphEditWidgetClass;
Index: ddd/SwallowerP.h
===================================================================
--- ddd/SwallowerP.h	(Revision 7209)
+++ ddd/SwallowerP.h	(Arbeitskopie)
@@ -44,18 +44,18 @@
 
 // The Swallower class record
 
-typedef struct _SwallowerClassPart {
+typedef struct SwallowerClassPart {
     XtPointer extension;
 } SwallowerClassPart;
 
-typedef struct _SwallowerClassRec {
+typedef struct SwallowerClassRec {
     CoreClassPart        core_class;
     SwallowerClassPart   swallower_class;
 } SwallowerClassRec;
 
 extern SwallowerClassRec swallowerClassRec;
 
-typedef struct _SwallowerPart {
+typedef struct SwallowerPart {
     // Resources
     Window window;		// Window of swallowed application
 
@@ -67,7 +67,7 @@
     SwallowerWidget next;	// Next swallower
 } SwallowerPart;
 
-typedef struct _SwallowerRec {
+typedef struct SwallowerRec {
     CorePart        core;
     SwallowerPart   swallower;
 } SwallowerRec;
Index: ddd/GraphEdit.C
===================================================================
--- ddd/GraphEdit.C	(Revision 7209)
+++ ddd/GraphEdit.C	(Arbeitskopie)
@@ -89,7 +89,7 @@
 // Resource list
 
 static XtResource resources[] = {
-#define offset(field) XtOffsetOf(_GraphEditRec::Res, graphEdit.field)
+#define offset(field) XtOffsetOf(GraphEditRec::Res, graphEdit.field)
     // {name, class, type, size, offset, default_type, default_addr}
     { XTRESSTR(XtNgraph), XTRESSTR(XtCGraph), XtRPointer, sizeof(Graph *),
         offset(graph), XtRImmediate, XtPointer(0) },
@@ -241,13 +241,13 @@
 static void SelectPrev  (Widget, XEvent *, String *, Cardinal *);
 static void UnselectAll (Widget, XEvent *, String *, Cardinal *);
 static void SnapToGrid  (Widget, XEvent *, String *, Cardinal *);
-static void _SnapToGrid (Widget, XEvent *, String *, Cardinal *);
+static void SnapToGrid_ (Widget, XEvent *, String *, Cardinal *);
 static void Rotate      (Widget, XEvent *, String *, Cardinal *);
-static void _Rotate     (Widget, XEvent *, String *, Cardinal *);
+static void Rotate_     (Widget, XEvent *, String *, Cardinal *);
 static void DoLayout    (Widget, XEvent *, String *, Cardinal *);
-static void _Layout     (Widget, XEvent *, String *, Cardinal *);
+static void Layout_     (Widget, XEvent *, String *, Cardinal *);
 static void Normalize   (Widget, XEvent *, String *, Cardinal *);
-static void _Normalize  (Widget, XEvent *, String *, Cardinal *);
+static void Normalize_  (Widget, XEvent *, String *, Cardinal *);
 
 
 // Actions table
@@ -270,13 +270,13 @@
     { XTARECSTR("select-prev"), 	SelectPrev },    // select-prev()
     { XTARECSTR("unselect-all"), 	UnselectAll },   // unselect-all()
     { XTARECSTR("snap-to-grid"),	SnapToGrid },    // snap-to-grid()
-    { XTARECSTR("_snap-to-grid"),	_SnapToGrid },
+    { XTARECSTR("_snap-to-grid"),	SnapToGrid_ },
     { XTARECSTR("rotate"),		Rotate },        // rotate([[+|-]DEGREES])
-    { XTARECSTR("_rotate"),	_Rotate },
+    { XTARECSTR("_rotate"),	Rotate_ },
     { XTARECSTR("layout"),		DoLayout },      // layout([regular|compact],
-    { XTARECSTR("_layout"),	_Layout },       //         [[+|-]DEGREES]])
+    { XTARECSTR("_layout"),	Layout_ },       //         [[+|-]DEGREES]])
     { XTARECSTR("normalize"),	Normalize },     // normalize()
-    { XTARECSTR("_normalize"),	_Normalize },
+    { XTARECSTR("_normalize"),	Normalize_ },
 };
 
 
@@ -1455,14 +1455,14 @@
 	if (after->res_.graphEdit.autoLayout)
 	{
 	    Cardinal zero = 0;
-	    _Layout(new_w, 0, 0, &zero);
+	    Layout_(new_w, 0, 0, &zero);
 	}
 
 	// Snap to grid if enabled
 	if (after->res_.graphEdit.snapToGrid)
 	{
 	    Cardinal zero = 0;
-	    _SnapToGrid(new_w, 0, 0, &zero);
+	    SnapToGrid_(new_w, 0, 0, &zero);
 	}
     }
 
@@ -1839,7 +1839,7 @@
 // Action functions
 
 // Select all nodes
-static Boolean _SelectAll(Widget w, XEvent *, String *, Cardinal *)
+static Boolean SelectAll_(Widget w, XEvent *, String *, Cardinal *)
 {
     const GraphEditWidget _w = GraphEditWidget(w);
     const Graph* graph       = _w->res_.graphEdit.graph;
@@ -1862,13 +1862,13 @@
 static void SelectAll(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    if (_SelectAll(w, event, params, num_params))
+    if (SelectAll_(w, event, params, num_params))
 	selectionChanged(w, event, False);
 }
 
 
 // Unselect all nodes
-static Boolean _UnselectAll(Widget w, XEvent *, String *, Cardinal *)
+static Boolean UnselectAll_(Widget w, XEvent *, String *, Cardinal *)
 {
     const GraphEditWidget _w = GraphEditWidget(w);
     const Graph* graph       = _w->res_.graphEdit.graph;
@@ -1891,7 +1891,7 @@
 static void UnselectAll(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    if (_UnselectAll(w, event, params, num_params))
+    if (UnselectAll_(w, event, params, num_params))
 	selectionChanged(w, event, False);
 }
 
@@ -1964,7 +1964,7 @@
 }
 
 // Begin selecting or moving
-static void _SelectOrMove(Widget w, XEvent *event, String *params,
+static void SelectOrMove_(Widget w, XEvent *event, String *params,
     Cardinal *num_params, SelectionMode mode, Boolean follow)
 {
     const GraphEditWidget _w = GraphEditWidget(w);
@@ -2043,7 +2043,7 @@
 	    if (!node->selected())
 	    {
 		// Create new selection
-		changed = _UnselectAll(w, event, params, num_params);
+		changed = UnselectAll_(w, event, params, num_params);
 	    }
 	    // FALL THROUGH
 
@@ -2103,37 +2103,37 @@
 static void SelectOrMove(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    _SelectOrMove(w, event, params, num_params, SetSelection, True);
+    SelectOrMove_(w, event, params, num_params, SetSelection, True);
 }
 
 static void ExtendOrMove(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    _SelectOrMove(w, event, params, num_params, ExtendSelection, True);
+    SelectOrMove_(w, event, params, num_params, ExtendSelection, True);
 }
 
 static void ToggleOrMove(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    _SelectOrMove(w, event, params, num_params, ToggleSelection, True);
+    SelectOrMove_(w, event, params, num_params, ToggleSelection, True);
 }
 
 static void Select(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    _SelectOrMove(w, event, params, num_params, SetSelection, False);
+    SelectOrMove_(w, event, params, num_params, SetSelection, False);
 }
 
 static void Extend(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    _SelectOrMove(w, event, params, num_params, ExtendSelection, False);
+    SelectOrMove_(w, event, params, num_params, ExtendSelection, False);
 }
 
 static void Toggle(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    _SelectOrMove(w, event, params, num_params, ToggleSelection, False);
+    SelectOrMove_(w, event, params, num_params, ToggleSelection, False);
 }
 
 // Keep on acting...
@@ -2538,7 +2538,7 @@
 static void SnapToGrid(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    _SnapToGrid(w, event, params, num_params);
+    SnapToGrid_(w, event, params, num_params);
     graphEditRedraw(w);
 }
 
@@ -2576,7 +2576,7 @@
 
 
 // Rotate nodes
-static void _Rotate(Widget w, XEvent *event, String *params,
+static void Rotate_(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
     const GraphEditWidget _w   = GraphEditWidget(w);
@@ -2617,8 +2617,8 @@
     rotation = new_rotation;
 
     Cardinal zero = 0;
-    _Normalize(w, event, 0, &zero);
-    _SnapToGrid(w, event, 0, &zero);
+    Normalize_(w, event, 0, &zero);
+    SnapToGrid_(w, event, 0, &zero);
 }
 
 static void Rotate(Widget w, XEvent *event, String *params,
@@ -2627,11 +2627,11 @@
     const GraphEditWidget _w   = GraphEditWidget(w);
     const Boolean autoLayout   = _w->res_.graphEdit.autoLayout;
 
-    _Rotate(w, event, params, num_params);
+    Rotate_(w, event, params, num_params);
     if (autoLayout)
     {
 	Cardinal zero = 0;
-	_Layout(w, event, 0, &zero);
+	Layout_(w, event, 0, &zero);
     }
     graphEditRedraw(w);
 }
@@ -2782,7 +2782,7 @@
     remove_all_hints(graph);
 }    
 
-static void _Layout(Widget w, XEvent *event, String *params,
+static void Layout_(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
     const GraphEditWidget _w   = GraphEditWidget(w);
@@ -2891,7 +2891,7 @@
     rotate_params[0] = rotation_s.chars();
 
     rotation = 0;
-    _Rotate(w, event, CONST_CAST(String*,rotate_params), &rotate_num_params);
+    Rotate_(w, event, CONST_CAST(String*,rotate_params), &rotate_num_params);
 
     // Layout is done
     XtCallCallbacks(w, XtNpostLayoutCallback, XtPointer(&info));
@@ -2904,13 +2904,13 @@
 static void DoLayout(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    _Layout(w, event, params, num_params);
+    Layout_(w, event, params, num_params);
     graphEditRedraw(w);
 }
 
 
 // Normalize graph
-static void _Normalize(Widget w, XEvent *, String *, Cardinal *)
+static void Normalize_(Widget w, XEvent *, String *, Cardinal *)
 {
     const GraphEditWidget _w   = GraphEditWidget(w);
     const Graph* graph         = _w->res_.graphEdit.graph;
@@ -2938,7 +2938,7 @@
 static void Normalize(Widget w, XEvent *event, String *params,
     Cardinal *num_params)
 {
-    _Normalize(w, event, params, num_params);
+    Normalize_(w, event, params, num_params);
     graphEditRedraw(w);
 }
 
Index: ddd/DocSpace.h
===================================================================
--- ddd/DocSpace.h	(Revision 7209)
+++ ddd/DocSpace.h	(Arbeitskopie)
@@ -65,8 +65,8 @@
 
 /* declare specific DocSpaceWidget class and instance datatypes */
 
-typedef struct _DocSpaceClassRec*   DocSpaceWidgetClass;
-typedef struct _DocSpaceRec*        DocSpaceWidget;
+typedef struct DocSpaceClassRec*   DocSpaceWidgetClass;
+typedef struct DocSpaceRec*        DocSpaceWidget;
 
 /* declare the class constant */
 
Index: ddd/GraphEdit.h
===================================================================
--- ddd/GraphEdit.h	(Revision 7209)
+++ ddd/GraphEdit.h	(Arbeitskopie)
@@ -135,8 +135,8 @@
 
 
 // Declare specific GraphEdit class and instance datatypes
-typedef struct _GraphEditClassRec *GraphEditWidgetClass;
-typedef struct _GraphEditRec      *GraphEditWidget;
+typedef struct GraphEditClassRec *GraphEditWidgetClass;
+typedef struct GraphEditRec      *GraphEditWidget;
 
 
 // Modes
Index: ddd/Delay.C
===================================================================
--- ddd/Delay.C	(Revision 7209)
+++ ddd/Delay.C	(Arbeitskopie)
@@ -42,7 +42,7 @@
 #undef XtIsRealized
 #endif
 
-DEFINE_TYPE_INFO_0(_Delay);
+DEFINE_TYPE_INFO_0(Delay_);
 DEFINE_TYPE_INFO_0(Delay);
 
 #define SMALL_HOURGLASS_CURSOR 1
@@ -65,10 +65,10 @@
 
 void (*Delay::shell_registered)(Widget w) = 0;
 
-Cursor _Delay::hourglass_cache = 0;
-Cursor _Delay::current_cursor = 0;
+Cursor Delay_::hourglass_cache = 0;
+Cursor Delay_::current_cursor = 0;
 
-Cursor _Delay::hourglass_cursor()
+Cursor Delay_::hourglass_cursor()
 {
     if (hourglass_cache != 0)
 	return hourglass_cache;
@@ -128,7 +128,7 @@
     return hourglass_cache;
 }
 
-_Delay::_Delay(Widget w):
+Delay_::Delay_(Widget w):
     widget(w), old_cursor(0)
 {
     if (widget == 0)
@@ -155,10 +155,10 @@
 	XFlush(display);
     }
 
-    XtAddCallback(widget, XtNdestroyCallback, _Delay::DestroyCB, this);
+    XtAddCallback(widget, XtNdestroyCallback, Delay_::DestroyCB, this);
 }
 
-_Delay::~_Delay()
+Delay_::~Delay_()
 {
   // TODO: race condition here
   // Need to flush the events, put a lock, do the test below, delete
@@ -177,14 +177,14 @@
     }
 
     current_cursor = old_cursor;
-    XtRemoveCallback(widget, XtNdestroyCallback, _Delay::DestroyCB, this);
+    XtRemoveCallback(widget, XtNdestroyCallback, Delay_::DestroyCB, this);
 }
 
 // Make sure we do not attempt to delete a delay on a destroyed widget
-void _Delay::DestroyCB(Widget, XtPointer client_data, XtPointer)
+void Delay_::DestroyCB(Widget, XtPointer client_data, XtPointer)
 {
-    _Delay *delay = (_Delay *)client_data;
-    assert(ptr_cast(_Delay, delay));
+    Delay_ *delay = (Delay_ *)client_data;
+    assert(ptr_cast(Delay_, delay));
 
     delay->widget     = 0;
     delay->old_cursor = 0;
@@ -196,7 +196,7 @@
 DelayArray Delay::delays;
 
 Delay::Delay(Widget w):
-    _Delay(w)
+    Delay_(w)
 {
     assert(delays.size() == _shells.size());
 
@@ -210,7 +210,7 @@
 #if LOG_DELAY
 		std::clog << "Slot " << i << ": ";
 #endif
-		delays[i] = new _Delay(_shells[i]);
+		delays[i] = new Delay_(_shells[i]);
 	    }
 	}
     }
@@ -254,14 +254,14 @@
 
     XtAddCallback(widget, XtNdestroyCallback, DestroyCB, XtPointer(0));
 
-    _Delay *new_delay = 0;
+    Delay_ *new_delay = 0;
     if (delay_count)
-	new_delay = new _Delay(widget);
+	new_delay = new Delay_(widget);
 
     if (i == _shells.size())
     {
 	_shells += Widget(0);
-	delays  += (_Delay *)0;
+	delays  += (Delay_ *)0;
     }
 
     assert(_shells[i] == 0);
Index: ddd/Delay.h
===================================================================
--- ddd/Delay.h	(Revision 7209)
+++ ddd/Delay.h	(Arbeitskopie)
@@ -35,8 +35,8 @@
 #include "VarArray.h"
 #include "assert.h"
 
-// _Delay defines a delay for a specific widget only
-class _Delay {
+// Delay_ defines a delay for a specific widget only
+class Delay_ {
 public:
     DECLARE_TYPE_INFO
 
@@ -47,23 +47,23 @@
     static Cursor current_cursor;
     static Cursor hourglass_cache;
 
-    _Delay(const _Delay&);
-    _Delay& operator = (const _Delay&);
+    Delay_(const Delay_&);
+    Delay& operator = (const Delay_&);
 
 protected:
     static void DestroyCB(Widget, XtPointer, XtPointer);
     virtual Cursor hourglass_cursor();
 
 public:
-    _Delay(Widget w);
-    virtual ~_Delay();
+    Delay_(Widget w);
+    virtual ~Delay_();
 };
 
 typedef VarArray<Widget>   WidgetArray;
-typedef VarArray<_Delay *> DelayArray;
+typedef VarArray<Delay_ *> DelayArray;
 
 // Delay also defines delays for all registered shells
-class Delay: public _Delay {
+class Delay : public Delay_ {
 public:
     DECLARE_TYPE_INFO
 
Index: ddd/LabelH.h
===================================================================
--- ddd/LabelH.h	(Revision 7209)
+++ ddd/LabelH.h	(Arbeitskopie)
@@ -55,8 +55,8 @@
 
 extern WidgetClass xmLabelHackWidgetClass;
 
-typedef struct _XmLabelHackClassRec *XmLabelHackWidgetClass;
-typedef struct _XmLabelHackRec  *XmLabelHackWidget;
+typedef struct XmLabelHackClassRec *XmLabelHackWidgetClass;
+typedef struct XmLabelHackRec  *XmLabelHackWidget;
 
 #ifndef XmNinsensitive3D
 #define XmNinsensitive3D "insensitive3D"
Index: ddd/GraphEditP.h
===================================================================
--- ddd/GraphEditP.h	(Revision 7209)
+++ ddd/GraphEditP.h	(Arbeitskopie)
@@ -52,7 +52,7 @@
     XtPointer extension;
 } GraphEditClassPart;
 
-typedef struct _GraphEditClassRec {
+typedef struct GraphEditClassRec {
     CoreClassPart        core_class;
     XmPrimitiveClassPart primitive_class;
     GraphEditClassPart   graphEdit_class;
@@ -72,7 +72,7 @@
 
 // The GraphEdit instance record
 
-typedef struct _GraphEditPart {
+typedef struct GraphEditPart {
     // Resources
 
     // Graph stuff
@@ -162,7 +162,7 @@
     XtCallbackList preSelectionProc;      // Called before selection
 } GraphEditPart;
 
-typedef struct _GraphEditPartPrivate {
+typedef struct GraphEditPartPrivate {
     // Private state
     GraphEditState state;	// Current state
 
@@ -192,7 +192,7 @@
 
 // This struct is split into two parts. The first is a POD and can therefore
 // be used with "offsetof". The second contains classes.
-typedef struct _GraphEditRec {
+typedef struct GraphEditRec {
   struct Res {
     CorePart        core;
     XmPrimitivePart primitive;
Index: ddd/PannedGE.C
===================================================================
--- ddd/PannedGE.C	(Revision 7209)
+++ ddd/PannedGE.C	(Arbeitskopie)
@@ -83,14 +83,14 @@
 
 // Class record initialization
 
-// Use `struct _PannedGraphEditClassRec' here instead of 
+// Use `struct PannedGraphEditClassRec_' here instead of 
 // the more appropriate `PannedGraphEditClassRec' due to a bug in GCC 2.96.
 // GCC 2.96 message is:
 // PannedGE.C: In function `void __static_initialization_and_destruction_0
 // (int, int)':
 // PannedGE.C:88: non-lvalue in unary `&'
 
-struct _PannedGraphEditClassRec pannedGraphEditClassRec = {
+struct PannedGraphEditClassRec_ pannedGraphEditClassRec = {
   {	 /* core fields */
     /* superclass               */  portholeWidgetClass,
     /* class_name               */  CONST_CAST(char *,"PannedGraphEdit"),
Index: ddd/PannedGE.h
===================================================================
--- ddd/PannedGE.h	(Revision 7209)
+++ ddd/PannedGE.h	(Arbeitskopie)
@@ -47,8 +47,8 @@
 
 
 // Declare specific GraphEdit class and instance datatypes
-typedef struct _PannedGraphEditClassRec *PannedGraphEditWidgetClass;
-typedef struct _PannedGraphEditRec      *PannedGraphEditWidget;
+typedef struct PannedGraphEditClassRec_ *PannedGraphEditWidgetClass;
+typedef struct PannedGraphEditRec_      *PannedGraphEditWidget;
 
 // Declare the class constant
 extern WidgetClass pannedGraphEditWidgetClass;
Index: ddd/VSLLib.C
===================================================================
--- ddd/VSLLib.C	(Revision 7209)
+++ ddd/VSLLib.C	(Arbeitskopie)
@@ -673,24 +673,24 @@
 	becomes much larger and evaluation speeds up slightly.
     */
 
-    if (mode & _Basics)
+    if (mode & Basics_)
     {
 	bind();
 	resolveNames();
 	compilePatterns();
     }
 
-    if (mode & _Cleanup)
+    if (mode & Cleanup_)
 	cleanup();
 
-    if (mode & _ResolveDefs)
+    if (mode & ResolveDefs_)
 	if (resolveDefs() > 0)
-	    if (mode & _Cleanup)
+	    if (mode & Cleanup_)
 		cleanup();
 
-    if (mode & _ResolveSynonyms)
+    if (mode & ResolveSynonyms_)
 	if (resolveSynonyms() > 0)
-	    if (mode & _Cleanup)
+	    if (mode & Cleanup_)
 		cleanup();
 	
     for (unsigned loop = 0; loop < (mode & loopMask); loop++)
@@ -698,26 +698,26 @@
 	int sum = 0;
 	int changes;
 
-	if (mode & _FoldOps)
+	if (mode & FoldOps_)
 	    if ((changes = foldOps()) > 0)
 	    {
 		sum += changes;
 		compilePatterns();
 	    }
 
-	if (mode & _FoldConsts)
+	if (mode & FoldConsts_)
 	    if ((changes = foldConsts()) > 0)
 	    {
 		sum += changes;
-		if (mode & _Cleanup)
+		if (mode & Cleanup_)
 		    cleanup();
 	    }
 
-	if (mode & _InlineFuncs)
+	if (mode & InlineFuncs_)
 	    if ((changes = inlineFuncs()) > 0)
 	    {
 		sum += changes;
-		if (mode & _Cleanup)
+		if (mode & Cleanup_)
 		    cleanup();
 	    }
 
@@ -725,9 +725,9 @@
 	    break;      // No more changes
     }
 
-    if (mode & _CountSelfReferences)
+    if (mode & CountSelfReferences_)
 	if (countSelfReferences() > 0)
-	    if (mode & _Cleanup)
+	    if (mode & Cleanup_)
 		cleanup();
 }
 
Index: ddd/VSLLib.h
===================================================================
--- ddd/VSLLib.h	(Revision 7209)
+++ ddd/VSLLib.h	(Arbeitskopie)
@@ -136,23 +136,23 @@
 const int hashSize = 4001;
 
 // Flags for optimizing (used internally)
-const unsigned _ResolveDefs             = (1 << 4);
-const unsigned _ResolveSynonyms         = (1 << 5);
-const unsigned _FoldOps                 = (1 << 6);
-const unsigned _FoldConsts              = (1 << 7);
-const unsigned _InlineFuncs             = (1 << 8);
-const unsigned _CountSelfReferences     = (1 << 9);
-const unsigned _Cleanup                 = (1 << 10);
-const unsigned _Basics                  = (1 << 11);
+const unsigned ResolveDefs_         = (1 << 4);
+const unsigned ResolveSynonyms_     = (1 << 5);
+const unsigned FoldOps_             = (1 << 6);
+const unsigned FoldConsts_          = (1 << 7);
+const unsigned InlineFuncs_         = (1 << 8);
+const unsigned CountSelfReferences_ = (1 << 9);
+const unsigned Cleanup_             = (1 << 10);
+const unsigned Basics_              = (1 << 11);
 
 // Public flags for optimizing
-const unsigned ResolveDefs          = _Basics | _ResolveDefs;
-const unsigned ResolveSynonyms      = ResolveDefs | _ResolveSynonyms;
-const unsigned FoldOps              = ResolveSynonyms | _FoldOps;
-const unsigned FoldConsts           = _Basics | _FoldConsts;
-const unsigned InlineFuncs          = ResolveDefs | _InlineFuncs;
-const unsigned CountSelfReferences  = _Basics | _CountSelfReferences;
-const unsigned Cleanup              = CountSelfReferences | _Cleanup;
+const unsigned ResolveDefs          = Basics_ | ResolveDefs_;
+const unsigned ResolveSynonyms      = ResolveDefs | ResolveSynonyms_;
+const unsigned FoldOps              = ResolveSynonyms | FoldOps_;
+const unsigned FoldConsts           = Basics_ | FoldConsts_;
+const unsigned InlineFuncs          = ResolveDefs | InlineFuncs_;
+const unsigned CountSelfReferences  = Basics_ | CountSelfReferences_;
+const unsigned Cleanup              = CountSelfReferences | Cleanup_;
 
 // Mask for building #iterations
 const unsigned loopMask         = (1 << 0 | 1 << 1 | 1 << 2 | 1 << 3);
Index: ddd/DocSpaceP.h
===================================================================
--- ddd/DocSpaceP.h	(Revision 7209)
+++ ddd/DocSpaceP.h	(Arbeitskopie)
@@ -43,7 +43,7 @@
     int empty;
 } DocSpaceClassPart;
 
-typedef struct _DocSpaceClassRec {
+typedef struct DocSpaceClassRec {
     CoreClassPart   core_class;
     DocSpaceClassPart   docSpace_class;
 } DocSpaceClassRec;
@@ -58,7 +58,7 @@
     /* private state */
 } DocSpacePart;
 
-typedef struct _DocSpaceRec {
+typedef struct DocSpaceRec {
     CorePart        core;
     DocSpacePart    docSpace;
 } DocSpaceRec;
Index: ddd/AsyncAgent.C
===================================================================
--- ddd/AsyncAgent.C	(Revision 7209)
+++ ddd/AsyncAgent.C	(Arbeitskopie)
@@ -132,7 +132,7 @@
 // Process "Death of child" signal as soon as possible
 void AsyncAgent::addDeathOfChildHandler()
 {
-    addHandler(_Died, childStatusChange, XtPointer(this));
+    addHandler(Died_, childStatusChange, XtPointer(this));
 }
 
 
Index: ddd/AgentM.C
===================================================================
--- ddd/AgentM.C	(Revision 7209)
+++ ddd/AgentM.C	(Arbeitskopie)
@@ -122,7 +122,7 @@
 
 	if (pid > 0 && waitpid(pid, &status, WNOHANG) == pid)
 	{
-	    c->callHandlers(_Died, (void *)status);
+	    c->callHandlers(Died_, (void *)status);
 	    gotit = true;
 	}
     }
Index: ddd/Assoc.h
===================================================================
--- ddd/Assoc.h	(Revision 7209)
+++ ddd/Assoc.h	(Arbeitskopie)
@@ -35,13 +35,13 @@
 #include <stdlib.h>		// abort()
 
 template<class K, class V> class AssocMark;
-template<class K, class V> class _Assoc;
+template<class K, class V> class Assoc_;
 template<class K, class V> class Assoc;
 template<class K, class V> class AssocIter;
 
 template<class K, class V>
 class AssocRec {
-    friend class _Assoc<K,V>;
+    friend class Assoc_<K,V>;
     friend class Assoc<K,V>;
     friend class AssocIter<K,V>;
 
@@ -66,7 +66,7 @@
 };
 
 template<class K, class V>
-class _Assoc {
+class Assoc_ {
     friend class AssocMark<K,V>;
 
 protected:
@@ -103,12 +103,12 @@
 
 public:
     // Constructors
-    _Assoc():
+    Assoc_():
 	entries(0)
     {}
 
     // Destructor
-    virtual ~_Assoc()
+    virtual ~Assoc_()
     {
 	destroyAll();
     }
@@ -178,7 +178,7 @@
     }
 
     // Copy constructor
-    _Assoc(const _Assoc<K,V>& m):
+    Assoc_(const _Assoc<K,V>& m):
 	entries(0)
     {
 	for (AssocRec<K,V> *e = m.entries; e != 0; e = e->next)
@@ -186,7 +186,7 @@
     }
 
     // Assignment
-    _Assoc<K, V>& operator = (const _Assoc<K,V>& m)
+    Assoc_<K, V>& operator = (const Assoc_<K,V>& m)
     {
 	if (this != &m)
 	{
@@ -281,17 +281,17 @@
 
 
 template<class K, class V>
-class Assoc: public _Assoc<K, V>
+class Assoc: public Assoc_<K, V>
 {
 protected:
     AssocRec<K,V> *lookup(const K& key) const
     {
-	return _Assoc<K, V>::lookup(key);
+	return Assoc_<K, V>::lookup(key);
     }
 
     AssocRec<K,V> *insert(const K& key)
     {
-	return _Assoc<K, V>::insert(key);
+	return Assoc_<K, V>::insert(key);
     }
 
 public:
@@ -313,7 +313,7 @@
 
     // Constructor
     Assoc()
-	: _Assoc<K, V>() 
+	: Assoc_<K, V>() 
     {}
 
     // Destructor
@@ -321,14 +321,14 @@
 
     // Copy
     Assoc(const Assoc<K, V>& m)
-	: _Assoc<K, V>(m)
+	: Assoc_<K, V>(m)
     {}
 
     // Assignment
     Assoc<K, V>& operator = (const Assoc<K, V>& m)
     {
         if (this != &m) {
-	  _Assoc<K, V>::operator =(m);
+	  Assoc_<K, V>::operator =(m);
 	}
 	return *this;
     }
Index: ddd/Swallower.h
===================================================================
--- ddd/Swallower.h	(Revision 7209)
+++ ddd/Swallower.h	(Arbeitskopie)
@@ -68,8 +68,8 @@
 
 
 // Declare specific Swallower class and instance datatypes
-typedef struct _SwallowerClassRec *SwallowerWidgetClass;
-typedef struct _SwallowerRec      *SwallowerWidget;
+typedef struct SwallowerClassRec *SwallowerWidgetClass;
+typedef struct SwallowerRec      *SwallowerWidget;
 
 // Declare the class constant
 extern WidgetClass swallowerWidgetClass;
Index: ddd/ddd.C
===================================================================
--- ddd/ddd.C	(Revision 7209)
+++ ddd/ddd.C	(Arbeitskopie)
@@ -6954,7 +6954,7 @@
 
 static Widget splash_shell  = 0;
 static Pixmap splash_pixmap = None;
-static _Delay *splash_delay = 0;
+static Delay_ *splash_delay = 0;
 
 static void popdown_splash_screen(XtPointer data, XtIntervalId *id)
 {
@@ -7034,7 +7034,7 @@
 
     XtRealizeWidget(splash_shell);
 
-    splash_delay = new _Delay(splash_shell);
+    splash_delay = new Delay_(splash_shell);
 
     popup_shell(splash_shell);
     wait_until_mapped(splash, splash_shell);
Index: ddd/HelpCB.C
===================================================================
--- ddd/HelpCB.C	(Revision 7209)
+++ ddd/HelpCB.C	(Arbeitskopie)
@@ -201,7 +201,7 @@
 static MString NoHelpText(Widget widget);
 static MString NoTipText(Widget widget, XEvent *event);
 static MString NoDocumentationText(Widget widget, XEvent *event);
-static void _MStringHelpCB(Widget widget, 
+static void MStringHelpCB_(Widget widget, 
 			   XtPointer client_data, 
 			   XtPointer call_data,
 			   bool help_on_help = false);
@@ -397,7 +397,7 @@
 
     // Get help on the help dialog
     MString text = get_help_string(help_dialog);
-    _MStringHelpCB(widget, XtPointer(text.xmstring()), call_data, true);
+    MStringHelpCB_(widget, XtPointer(text.xmstring()), call_data, true);
 
     PostHelpOnItemHook(help_dialog);
 }
@@ -476,7 +476,7 @@
     MString text = get_help_on_version_string(shell);
     text += helpOnVersionExtraText;
 
-    _MStringHelpCB(widget, XtPointer(text.xmstring()), call_data, false);
+    MStringHelpCB_(widget, XtPointer(text.xmstring()), call_data, false);
 
     // PostHelpOnItemHook(shell);
 }
@@ -534,10 +534,10 @@
 
 void MStringHelpCB(Widget widget, XtPointer client_data, XtPointer call_data)
 {
-    _MStringHelpCB(widget, client_data, call_data);
+    MStringHelpCB_(widget, client_data, call_data);
 }
 
-static void _MStringHelpCB(Widget widget, 
+static void MStringHelpCB_(Widget widget, 
 			   XtPointer client_data, 
 			   XtPointer,
 			   bool help_on_help)
Index: ddd/TypeInfo.h
===================================================================
--- ddd/TypeInfo.h	(Revision 7209)
+++ ddd/TypeInfo.h	(Arbeitskopie)
@@ -82,13 +82,13 @@
     static const TypeInfo *_type_info_direct_bases[];
 
 #if IMMEDIATE_TYPE_INFO
-#define _DEFINE_TYPE_INFO(T) \
+#define DEFINE_TYPE_INFO_(T) \
     TypeInfo T::type_info = \
         { #T, T::_type_info_direct_bases, &T::_type_info_all_bases }; \
     BaseList T::_type_info_all_bases = 0; \
     const TypeInfo *T::_type_info_direct_bases[] = 
 #else
-#define _DEFINE_TYPE_INFO(T) \
+#define DEFINE_TYPE_INFO_(T) \
     TypeInfo T::type_info(#T, T::_type_info_direct_bases, \
                           &T::_type_info_all_bases); \
     BaseList T::_type_info_all_bases = 0; \
@@ -96,43 +96,43 @@
 #endif
 
 #define DEFINE_TYPE_INFO_0(T) \
-    _DEFINE_TYPE_INFO(T) { 0 };
+    DEFINE_TYPE_INFO_(T) { 0 };
 
 #define DEFINE_TYPE_INFO_1(T, B1) \
-    _DEFINE_TYPE_INFO(T) { &B1::type_info, 0 };
+    DEFINE_TYPE_INFO_(T) { &B1::type_info, 0 };
 
 #define DEFINE_TYPE_INFO_2(T, B1, B2) \
-    _DEFINE_TYPE_INFO(T) { &B1::type_info, &B2::type_info, 0 };
+    DEFINE_TYPE_INFO_(T) { &B1::type_info, &B2::type_info, 0 };
 
 #define DEFINE_TYPE_INFO_3(T, B1, B2, B3) \
-    _DEFINE_TYPE_INFO(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
+    DEFINE_TYPE_INFO_(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
 			   0 };
 
 #define DEFINE_TYPE_INFO_4(T, B1, B2, B3, B4) \
-    _DEFINE_TYPE_INFO(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
+    DEFINE_TYPE_INFO_(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
 			   &B4::type_info, 0 };
 
 #define DEFINE_TYPE_INFO_5(T, B1, B2, B3, B4, B5) \
-    _DEFINE_TYPE_INFO(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
+    DEFINE_TYPE_INFO_(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
 			   &B4::type_info, &B5::type_info, 0 };
 
 #define DEFINE_TYPE_INFO_6(T, B1, B2, B3, B4, B5, B6) \
-    _DEFINE_TYPE_INFO(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
+    DEFINE_TYPE_INFO_(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
 			   &B4::type_info, &B5::type_info, &B6::type_info, \
 			   0 };
 
 #define DEFINE_TYPE_INFO_7(T, B1, B2, B3, B4, B5, B6, B7) \
-    _DEFINE_TYPE_INFO(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
+    DEFINE_TYPE_INFO_(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
 			   &B4::type_info, &B5::type_info, &B6::type_info, \
 			   &B7::type_info, 0 };
 
 #define DEFINE_TYPE_INFO_8(T, B1, B2, B3, B4, B5, B6, B7, B8) \
-    _DEFINE_TYPE_INFO(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
+    DEFINE_TYPE_INFO_(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
 			   &B4::type_info, &B5::type_info, &B6::type_info, \
 			   &B7::type_info, &B8::type_info, 0 };
 
 #define DEFINE_TYPE_INFO_9(T, B1, B2, B3, B4, B5, B6, B7, B8, B9) \
-    _DEFINE_TYPE_INFO(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
+    DEFINE_TYPE_INFO_(T) { &B1::type_info, &B2::type_info, &B3::type_info, \
 			   &B4::type_info, &B5::type_info, &B6::type_info, \
 			   &B7::type_info, &B8::type_info, &B9::type_info, \
 			   0 };
Index: ddd/layout.h
===================================================================
--- ddd/layout.h	(Revision 7209)
+++ ddd/layout.h	(Arbeitskopie)
@@ -34,21 +34,21 @@
 enum EDGEARROW { Here, Other };
 enum NODETYPE { Regular, Hint };
 
-typedef struct _EGDE EDGE;
-typedef struct _EDGELIST EDGELIST;
-typedef struct _REGULAR REGULAR;
-typedef struct _HINT HINT;
-typedef union _ATTRIBUTES ATTRIBUTES;
-typedef union _ID ID;
-typedef struct _NODE NODE;
-typedef struct _GRAPH GRAPH;
+typedef struct EGDE EDGE;
+typedef struct EDGELIST EDGELIST;
+typedef struct REGULAR REGULAR;
+typedef struct HINT HINT;
+typedef union ATTRIBUTES ATTRIBUTES;
+typedef union ID ID;
+typedef struct NODE NODE;
+typedef struct GRAPH GRAPH;
 
 #define PRIME 809
 #define SMALLPRIME 41
 typedef GRAPH *GRAPHTAB[SMALLPRIME];
 
 // More definitions
-struct _EGDE {
+struct EGDE {
     NODE *node;
     NODE *target;
     EDGEARROW arrow;        /* kind of edge */
@@ -56,19 +56,20 @@
     EDGE *prev;             /* previous entry */
 };
 
-struct _EDGELIST {
+struct EDGELIST {
     EDGE *head;             /* first entry */
     EDGE *tail;             /* last entry */
     int length;             /* number of elements */
 };
 
-struct _REGULAR {
+struct REGULAR {
     char *label;            /* the name of the node */
     int w,h;                /* regular nodes have width & height */
     EDGELIST up;            /* ancestors */
     EDGELIST down;          /* descendants */
 };
-struct _HINT {
+
+struct HINT {
     int id;                 /* hints are identified by ids */
     NODE *up;
     NODE *down;
@@ -76,17 +77,17 @@
     NODE *target;           /* the edge this hint belongs to */
 };
 
-union _ATTRIBUTES {
+union ATTRIBUTES {
     REGULAR node;
     HINT hint;
 };
 
-union _ID {
+union ID {
     int id;
     const char *label;
 };
 
-struct _NODE {
+struct NODE {
     int x,y;                /* position */
     int oldx,oldy;          /* previous position */
 
@@ -107,7 +108,7 @@
     ATTRIBUTES attr;
 };
 
-struct _GRAPH {
+struct GRAPH {
     NODE *hashtab[PRIME];
 
     int levels;
Index: ddd/ctest.c
===================================================================
--- ddd/ctest.c	(Revision 7209)
+++ ddd/ctest.c	(Arbeitskopie)
@@ -41,7 +41,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-typedef enum _DayOfWeek {Sun, Mon, Tue, Wed, Thu, Fri, Sat} DayOfWeek;
+typedef enum DayOfWeek {Sun, Mon, Tue, Wed, Thu, Fri, Sat} DayOfWeek;
 
 int a_global = 42;	/* Place watchpoints on this one */
 
@@ -80,7 +80,7 @@
 }
 
 /*--------------------------------------------------------------------------*/
-typedef struct _Holiday {
+typedef struct Holiday {
     Date date;
     char *name;
 } Holiday;
@@ -97,13 +97,13 @@
 }
 
 /*--------------------------------------------------------------------------*/
-typedef struct _Tree {
+typedef struct Tree {
     int   value;
     char *name;
 
     Date date;
-    struct _Tree *left;
-    struct _Tree *right;
+    struct Tree *left;
+    struct Tree *right;
 } Tree;
 
 Tree *new_tree(value, name)
@@ -131,11 +131,11 @@
 }
 
 /*--------------------------------------------------------------------------*/
-typedef struct _List {
+typedef struct List {
     int value;
 
-    struct _List *self;
-    struct _List *next;
+    struct List *self;
+    struct List *next;
 } List;
 
 List *new_list(value)
