new file mode 100644
--- /dev/null
+++ b/host/tools/configtool/standalone/wxwin/memmap.cpp
@@ -0,0 +1,1738 @@
+//####COPYRIGHTBEGIN####
+//                                                                          
+// ----------------------------------------------------------------------------
+// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.
+//
+// This program is part of the eCos host tools.
+//
+// This program is free software; you can redistribute it and/or modify it 
+// under the terms of the GNU General Public License as published by the Free 
+// Software Foundation; either version 2 of the License, or (at your option) 
+// any later version.
+// 
+// This program is distributed in the hope that it will be useful, but WITHOUT 
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
+// more details.
+// 
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the Free Software Foundation, Inc., 
+// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+// ----------------------------------------------------------------------------
+//                                                                          
+//####COPYRIGHTEND####
+//=================================================================
+//
+//        memmap.cpp
+//
+//        Memory Layout Tool map data structure manipulation class
+//
+//=================================================================
+//#####DESCRIPTIONBEGIN####
+//
+// Author(s):     John Dallaway
+// Contact(s):    jld
+// Date:          1998/07/29 $RcsDate$ {or whatever}
+// Version:       0.00+  $RcsVersion$ {or whatever}
+// Purpose:       Provides functions to create and destroy memory regions
+//                and sections within the memory map.
+// Description:   Each function manipulates data structures representing
+//                memory regions, memory sections and the view of memory
+//                sections as presented to the user. The section view
+//                structure organises the sections by region and 
+//                will contain two instances of each relocated section 
+// Requires:      memmap.h
+// Provides:      create_memory_region()
+//                delete_memory_region()
+//                edit_memory_region()
+//                create_memory_section()
+//                delete_memory_section()
+//                edit_memory_section()
+//                delete_all_memory_sections()
+//                set_map_size()
+//                section_list
+//                region_list
+// See also:      memmap.h
+// Known bugs:    <UPDATE_ME_AT_RELEASE_TIME>
+// WARNING:       Do not modify data structures other than by using the
+//                provided functions
+// Usage:         #include "memmap.h"
+//                ...
+//                status = set_map_size (0x8000);
+//
+//####DESCRIPTIONEND####
+
+#pragma warning (disable:4514) /* unreferenced inline function */
+#pragma warning (disable:4710) /* function not inlined */
+
+// Includes other headers for precompiled compilation
+#include "ecpch.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+
+#include "memmap.h"
+
+using namespace std;
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+mem_map::mem_map()
+{
+	map_modified_flag = true;
+	map_size = (mem_address) 0;
+}
+
+mem_map::~mem_map()
+{
+
+}
+
+mem_section::mem_section()
+{
+
+}
+
+mem_section::~mem_section()
+{
+
+}
+
+///////////////////////////////////////////////////////////////////////
+// get_memory_region() retrieves the parameters of a memory region
+
+bool mem_map::get_memory_region (std::string region_name, mem_address * region_address, mem_address * region_size, mem_type * region_type, std::string * note)
+{
+    for (list <mem_region>::iterator region = region_list.begin (); region != region_list.end (); ++region)
+        if (region->name == region_name)
+        {
+            *region_address = region->address;
+            *region_size = region->size;
+            *region_type = region->type;
+            *note = region->note;
+            return true;
+        }
+
+    return false;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+// create_memory_region() inserts a new item into the memory region list
+// in order of memory address
+
+int mem_map::create_memory_region (std::string new_region_name, mem_address new_region_address, mem_address new_region_size, mem_type new_region_type, std::string note)
+{
+    const mem_address new_region_end = new_region_address + new_region_size; // the byte after the new region end
+
+    // check that the new region name is specified
+
+    if (new_region_name == "")
+        return ERR_MEMMAP_REGION_NONAME; // the new region name must be specified
+
+    // check that the new region lies within the memory map
+
+    if (new_region_end > map_size)
+        return ERR_MEMMAP_REGION_MAPSIZE; // the new region does not lie within the memory map
+
+    // check that the region end address hasn't exceeded the storage size
+
+    if (new_region_end < new_region_address)
+        return ERR_MEMMAP_REGION_MAPSIZE; // the new region does not lie within the memory map
+
+    // initialise the insertion point for the new region
+
+    list <mem_region>::iterator insertion_point = region_list.end ();
+
+    // check that the new region does not overlap existing regions and does not already exist
+
+    for (list <mem_region>::iterator region = region_list.begin (); region != region_list.end (); ++region)
+    {
+        const mem_address region_end = region->address + region->size; // the byte after the region end
+
+        if ((new_region_address >= region->address) && (new_region_address < region_end))
+        {
+            error_info = region->name;
+            return ERR_MEMMAP_REGION_INTERSECT; // the start of the new region is within an existing region
+        }
+
+        if ((new_region_end > region->address) && (new_region_end <= region_end))
+        {
+            error_info = region->name;
+            return ERR_MEMMAP_REGION_INTERSECT; // the end of the new region is within an existing region
+        }
+
+        if ((new_region_address < region->address) && (new_region_end > region_end))
+        {
+            error_info = region->name;
+            return ERR_MEMMAP_REGION_INTERSECT; // an existing region lies within the new region
+        }
+
+        if (region->name == new_region_name)
+            return ERR_MEMMAP_REGION_NAMEINUSE; // the new region name is not unique
+
+        if ((insertion_point == region_list.end ()) && (region->address > new_region_address))
+            insertion_point = region; // insert the new region here
+    }
+
+    // add the new region to the region list
+
+    list <mem_region>::iterator new_region = region_list.insert (insertion_point);
+    new_region->name = new_region_name;
+    new_region->address = new_region_address;
+    new_region->size = new_region_size;
+    new_region->type = new_region_type;
+    new_region->note = note;
+
+    // initialise the section list for the new region
+
+    calc_section_list (new_region);
+
+	map_modified_flag = true;
+    return 0;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+// edit_memory_region() edits an item in the memory region list
+
+int mem_map::edit_memory_region (std::string old_region_name, std::string new_region_name, mem_address new_region_address, mem_address new_region_size, mem_type new_region_type, std::string note)
+{
+    list <mem_region>::iterator edit_region = find_memory_region (old_region_name);
+    if (edit_region == NULL)
+        return ERR_MEMMAP_REGION_NOTFOUND; // the region to be modified does not exist
+
+    // check that the new region name is specified
+
+    if (new_region_name == "")
+        return ERR_MEMMAP_REGION_NONAME; // the new region name must be specified
+
+    // check that the region end address hasn't exceeded the storage size
+
+    if (new_region_address + new_region_size < new_region_address)
+        return ERR_MEMMAP_REGION_MAPSIZE; // the new region does not lie within the memory map
+
+    // check region name change
+
+    if ((old_region_name != new_region_name) &&
+        (find_memory_region (new_region_name) != NULL))
+        return ERR_MEMMAP_REGION_NAMEINUSE; // new region name is not unique
+
+    // check region address/size change wrt other regions
+
+    const mem_address new_region_end = new_region_address + new_region_size;
+    if ((new_region_address != edit_region->address) ||
+        (new_region_size != edit_region->size))
+    {
+        for (list <mem_region>::iterator region = region_list.begin (); region != region_list.end (); ++region)
+            if (region != edit_region)
+        {
+            const mem_address region_end = region->address + region->size; // the byte after the region end
+
+            if ((new_region_address >= region->address) && (new_region_address < region_end))
+            {
+                error_info = region->name;
+                return ERR_MEMMAP_REGION_INTERSECT; // the start of the modified region is within another region
+            }
+
+            if ((new_region_end > region->address) && (new_region_end <= region_end))
+            {
+                error_info = region->name;
+                return ERR_MEMMAP_REGION_INTERSECT; // the end of the modified region is within an existing region
+            }
+
+            if ((new_region_address < region->address) && (new_region_end > region_end))
+            {
+                error_info = region->name;
+                return ERR_MEMMAP_REGION_INTERSECT; // another region lies within the modified region
+            }
+        }
+    }
+
+    // check region size change wrt sections within region (if any)
+
+    for (list <mem_section_view>::iterator section_view = edit_region->section_view_list.begin (); section_view != edit_region->section_view_list.end (); ++section_view)
+        if (section_view->section != NULL)
+    {
+        if ((section_view->section_location == final_location) || (section_view->section_location == fixed_location))
+            if (section_view->section->final_location->anchor == absolute)
+                if (section_view->section->final_location->address + section_view->section->size - edit_region->address > new_region_size)
+                    return ERR_MEMMAP_REGION_SIZE; // region is now too small
+
+        if (section_view->section_location == initial_location)
+            if (section_view->section->initial_location->anchor == absolute)
+                if (section_view->section->initial_location->address + section_view->section->size - edit_region->address > new_region_size)
+                    return ERR_MEMMAP_REGION_SIZE; // region is now too small
+    }
+
+    // check region read-only change FIXME
+
+    // move sections within the region having absolute anchors
+
+    for (section_view = edit_region->section_view_list.begin (); section_view != edit_region->section_view_list.end (); ++section_view)
+        if (section_view->section != NULL)
+    {
+        if ((section_view->section_location == final_location) || (section_view->section_location == fixed_location))
+            if (section_view->section->final_location->anchor == absolute)
+                section_view->section->final_location->address += (new_region_address - edit_region->address);
+
+        if ((section_view->section_location == initial_location) || (section_view->section_location == fixed_location))
+            if (section_view->section->initial_location->anchor == absolute)
+                section_view->section->initial_location->address += (new_region_address - edit_region->address);
+    }
+
+    // deleteZ(the region and recreate it to make sure the region list is ordered correctly)
+
+    region_list.erase (edit_region);
+    if (create_memory_region (new_region_name, new_region_address, new_region_size, new_region_type, note))
+        return ERR_MEMMAP_ALLOC;
+
+	map_modified_flag = true;
+    return 0;
+}
+
+
+//////////////////////////////////////////////////////////////////
+// delete_memory_region() removes an existing item from the memory
+// region list
+
+bool mem_map::delete_memory_region (std::string name)
+{
+    // make sure that there are no used sections in this region before deleting it
+
+    for (list <mem_region>::iterator region = region_list.begin (); region != region_list.end (); ++region)
+    {
+        if ((region->name == name) && (region->section_view_list.size () == 1) &&  (region->section_view_list.front ().section == NULL))
+        {
+            region_list.erase (region);
+			map_modified_flag = true;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////
+// set_map_size() sets the maximum permitted address for the end
+// of any memory region
+
+bool mem_map::set_map_size (mem_address new_map_size)
+{
+    // check that the new size is sufficient for all previously defined memory regions
+
+    for (list <mem_region>::iterator region = region_list.begin (); region != region_list.end (); ++region)
+    {
+        if (region->address + region->size > new_map_size)
+            return false; // the new map size is too small
+    }
+
+    // set the map size
+
+    map_size = new_map_size;
+
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////
+// edit_memory_section() edits an item to the memory section map
+
+int mem_map::edit_memory_section (std::string old_section_name, std::string new_section_name, mem_address section_size, mem_address section_alignment, mem_anchor initial_section_anchor, std::string initial_anchor_section_name, mem_address initial_anchor_address, mem_anchor final_section_anchor, std::string final_anchor_section_name, mem_address final_anchor_address, bool relocates, bool anchor_to_initial_location, bool linker_defined, std::string note)
+{
+    // do all the parameter validation
+
+    if (new_section_name == "") // the new section name must be specified
+        return ERR_MEMMAP_SECTION_NONAME;
+
+    if ((new_section_name != old_section_name) &&
+        (find_memory_section (new_section_name) != NULL))
+        return ERR_MEMMAP_SECTION_NAMEINUSE; // the new section name is not unique
+
+    list <mem_section>::iterator section = find_memory_section (old_section_name);
+    if (section == NULL)
+        return ERR_MEMMAP_SECTION_NOTFOUND; // the specified old section name could not be found
+
+    // check that the LMA (if absolute) is within a memory region
+
+    list <mem_region>::iterator region;
+    if (initial_section_anchor == absolute)
+    {
+        region = find_region_by_address (initial_anchor_address);
+        if (region == NULL)
+            return ERR_MEMMAP_SECTION_LMA_NOTINREGION; // section LMA is not within a memory region
+        if ((section_size > 0) && (initial_anchor_address + section_size > region->address + region->size))
+            return ERR_MEMMAP_SECTION_LMA_NOTINREGION; // end of section is not within the memory region
+        if (relocates && (region->type == read_write))
+            return ERR_MEMMAP_SECTION_LMA_READWRITE; // section LMA must be in a read-only memory region
+    }
+
+    // check that the VMA (if absolute) is within a memory region
+
+    if (final_section_anchor == absolute)
+    {
+        region = find_region_by_address (final_anchor_address);
+        if (region == NULL)
+            return ERR_MEMMAP_SECTION_VMA_NOTINREGION; // section VMA is not within a memory region
+        if ((section_size > 0) && (final_anchor_address + section_size > region->address + region->size))
+            return ERR_MEMMAP_SECTION_VMA_NOTINREGION; // end of section is not within the memory region
+        if (relocates && (region->type == read_only))
+            return ERR_MEMMAP_SECTION_VMA_READONLY; // section VMA must be in a read/write memory region
+    }
+
+    // check relative location information as appropriate
+
+    if (relocates) // only check the initial parent section if the section relocates
+    {
+        if (initial_section_anchor == relative)
+        {
+            list <mem_section>::iterator parent_section = find_memory_section (initial_anchor_section_name);
+            if (parent_section == section_list.end ())
+                return ERR_MEMMAP_SECTION_LMA_ANCHORNOTFOUND; // initial anchor name not found
+
+            if ((parent_section->initial_location->following_section != section) && (parent_section->initial_location->following_section != NULL))
+                return ERR_MEMMAP_SECTION_LMA_ANCHORNOTAVAIL; // initial anchor specified has changed and is unavailable
+
+            if ((parent_section->size == 0) && (! parent_section->linker_defined))
+                return ERR_MEMMAP_SECTION_LMA_ANCHORNOTAVAIL; // initial anchor specified expands to fit available space
+
+            if (find_region_by_section (parent_section, initial_location)->type == read_write)
+                return ERR_MEMMAP_SECTION_LMA_READWRITE; // initial anchor must be in a read-only memory region
+        }
+    }
+
+    if (final_section_anchor == relative)
+    {
+        list <mem_section>::iterator parent_section = find_memory_section (final_anchor_section_name);
+        if (parent_section == NULL)
+            return ERR_MEMMAP_SECTION_VMA_ANCHORNOTFOUND; // final anchor name not found
+
+        if ((parent_section->size == 0) && (! parent_section->linker_defined))
+            return ERR_MEMMAP_SECTION_VMA_ANCHORNOTAVAIL; // final anchor specified expands to fit available space
+
+        if ((!relocates) && anchor_to_initial_location) // final anchor to initial location of parent section
+        {
+            if ((parent_section->initial_location->following_section != section) && (parent_section->initial_location->following_section != NULL))
+                return ERR_MEMMAP_SECTION_VMA_ANCHORNOTAVAIL; // final anchor specified has changed and is unavailable
+        }
+        else
+        {
+            if ((parent_section->final_location->following_section != section) && (parent_section->final_location->following_section != NULL))
+                return ERR_MEMMAP_SECTION_VMA_ANCHORNOTAVAIL; // final anchor specified has changed and is unavailable
+        }
+
+        if (relocates && (find_region_by_section (parent_section, final_location)->type == read_only))
+            return ERR_MEMMAP_SECTION_VMA_READONLY; // final anchor of relocating section must be in a read/write memory region
+    }
+
+	// check for a non-relocating section changing to relocating where the final
+	// location moves from a read_only region to a read_write region and there
+	// is a following non-relocating section
+
+    if (relocates && (! section->relocates) &&
+		(find_region_by_section (section, fixed_location)->type == read_only) &&
+		(section->final_location->following_section != NULL) &&
+		(! section->final_location->following_section->relocates))
+	{
+		return ERR_MEMMAP_SECTION_ILLEGAL_RELOCATION;
+	}
+
+    // FIXME check for overlap of absolute sections
+
+    // modify the initial section location data
+
+    if (section->initial_location->anchor == relative) // initial section anchor was relative
+        find_preceding_section (section, true)->initial_location->following_section = NULL;
+
+    if (initial_section_anchor == absolute) // initial location now absolute
+        section->initial_location->address = initial_anchor_address;
+    else // initial location now relative
+    {
+        list <mem_section>::iterator initial_parent = find_memory_section (initial_anchor_section_name);
+        if (relocates || (! initial_parent->relocates))
+            initial_parent->initial_location->following_section = section;
+    }
+
+    // modify the final section location data
+
+    if (section->final_location->anchor == relative) // final section anchor was relative
+        find_preceding_section (section, false)->final_location->following_section = NULL;
+
+    if (final_section_anchor == absolute) // final location now absolute
+        section->final_location->address = final_anchor_address;
+    else // final location now relative
+    {
+        list <mem_section>::iterator final_parent = find_memory_section (final_anchor_section_name);
+        final_parent->final_location->following_section = section;
+    }
+
+    // handle relocation changes
+
+    if (relocates && (! section->relocates)) // section was non-relocating but now relocates
+	{
+		if (find_region_by_section (section, fixed_location)->type == read_only) // the section was in a read_only region
+		   section->final_location->following_section = NULL; // there is now no section following the final location
+		else
+		   section->initial_location->following_section = NULL; // there is now no section following the initial location
+	}
+
+    else if ((! relocates) && section->relocates) // section was relocating but is now non-relocating
+	{
+		// determine the type of memory region in which the section now resides
+
+		mem_type type;
+		if ((final_section_anchor == relative) && anchor_to_initial_location)
+			type = find_region_by_section (find_memory_section (final_anchor_section_name), initial_location)->type;
+		else if (final_section_anchor == relative) // anchored to final location of preceding section
+			type = find_region_by_section (find_memory_section (final_anchor_section_name), final_location)->type;
+		else // final_section_anchor must be absolute
+			type = find_region_by_address (final_anchor_address)->type;
+
+		if (type == read_only) // the section is now in a read-only memory region
+		{
+			if ((section->initial_location->following_section != NULL) && ! section->initial_location->following_section->relocates)
+				section->final_location->following_section = section->initial_location->following_section;
+			else
+				section->final_location->following_section = NULL;
+		}
+		else // the section is now in a read-write memory region
+		{
+			if ((section->final_location->following_section != NULL) && ! section->final_location->following_section->relocates)
+				section->initial_location->following_section = section->final_location->following_section;
+			else
+				section->initial_location->following_section = NULL;
+		}
+	}
+
+    // modify the remaining section data
+
+    section->name = new_section_name;
+    section->size = section_size;
+    section->alignment = section_alignment;
+    section->relocates = relocates;
+    section->note = note;
+    section->linker_defined = linker_defined;
+    section->initial_location->anchor = initial_section_anchor;
+    section->final_location->anchor = final_section_anchor;
+
+    // recalculate section lists for all regions
+
+    calc_section_lists ();
+
+	map_modified_flag = true;
+    return 0;
+}
+
+
+////////////////////////////////////////////////////////////////////
+// create_memory_section() adds a new item to the memory section map
+// either a section name (for relative locations) or an anchor address
+// (for absolute locations) must be specified
+
+int mem_map::create_memory_section (std::string section_name, mem_address section_size, mem_address section_alignment, mem_anchor initial_section_anchor, std::string initial_anchor_section_name, mem_address initial_anchor_address, mem_anchor final_section_anchor, std::string final_anchor_section_name, mem_address final_anchor_address, bool relocates, bool anchor_to_initial_location, bool linker_defined, std::string note)
+{
+    list <mem_region>::iterator region;
+
+    // check that the new section name is specified
+
+    if (section_name == "")
+        return ERR_MEMMAP_SECTION_NONAME; // the new section name must be specified
+    
+    // check that the new section name is unique
+
+    if (find_memory_section (section_name) != NULL)
+        return ERR_MEMMAP_SECTION_NAMEINUSE; // the new section name is not unique
+
+    // check that the LMA (if absolute) is within a memory region
+
+    if (initial_section_anchor == absolute)
+    {
+        region = find_region_by_address (initial_anchor_address);
+        if (region == NULL)
+            return ERR_MEMMAP_SECTION_LMA_NOTINREGION; // section LMA is not within a memory region
+        if ((section_size > 0) && (initial_anchor_address + section_size > region->address + region->size))
+            return ERR_MEMMAP_SECTION_LMA_NOTINREGION; // end of section is not within the memory region
+        if (relocates && (region->type == read_write))
+            return ERR_MEMMAP_SECTION_LMA_READWRITE; // section LMA must be in a read-only memory region
+    }
+
+    // check that the VMA (if absolute) is within a memory region
+
+    if (final_section_anchor == absolute)
+    {
+        region = find_region_by_address (final_anchor_address);
+        if (region == NULL)
+            return ERR_MEMMAP_SECTION_VMA_NOTINREGION; // section VMA is not within a memory region
+        if ((section_size > 0) && (final_anchor_address + section_size > region->address + region->size))
+            return ERR_MEMMAP_SECTION_VMA_NOTINREGION; // end of section is not within the memory region
+        if (relocates && (region->type == read_only))
+            return ERR_MEMMAP_SECTION_VMA_READONLY; // section VMA must be in a read/write memory region
+    }
+
+    // FIXME check for overlap of absolute sections
+
+    // check that specified parent(s) (for relative anchors) are available
+
+    if (relocates) // only check the initial parent section if the section relocates
+    {
+        if (initial_section_anchor == relative)
+        {
+            list <mem_section>::iterator parent_section = find_memory_section (initial_anchor_section_name);
+            if (parent_section == section_list.end ())
+                return ERR_MEMMAP_SECTION_LMA_ANCHORNOTFOUND; // initial anchor name not found
+/*
+            if (parent_section->initial_location->following_section != NULL)
+                return ERR_MEMMAP_SECTION_LMA_ANCHORNOTAVAIL; // initial anchor specified is unavailable
+*/
+            if ((parent_section->size == 0) && (! parent_section->linker_defined))
+                return ERR_MEMMAP_SECTION_LMA_ANCHORNOTAVAIL; // initial anchor specified expands to fit available space
+
+            if (find_region_by_section (parent_section, initial_location)->type == read_write)
+                return ERR_MEMMAP_SECTION_LMA_READWRITE; // initial anchor must be in a read-only memory region
+        }
+    }
+
+    if (final_section_anchor == relative)
+    {
+        list <mem_section>::iterator parent_section = find_memory_section (final_anchor_section_name);
+        if (parent_section == NULL)
+            return ERR_MEMMAP_SECTION_VMA_ANCHORNOTFOUND; // final anchor name not found
+
+        if ((parent_section->size == 0) && (! parent_section->linker_defined))
+            return ERR_MEMMAP_SECTION_VMA_ANCHORNOTAVAIL; // final anchor specified expands to fit available space
+/*
+        if ((!relocates) && anchor_to_initial_location) // final anchor to initial location of parent section
+        {
+            if (parent_section->initial_location->following_section != NULL)
+                return ERR_MEMMAP_SECTION_VMA_ANCHORNOTAVAIL; // final anchor specified is unavailable
+        }
+        else
+        {
+            if (parent_section->final_location->following_section != NULL)
+                return ERR_MEMMAP_SECTION_VMA_ANCHORNOTAVAIL; // final anchor specified is unavailable
+        }
+*/
+        if (relocates && (find_region_by_section (parent_section, final_location)->type == read_only))
+            return ERR_MEMMAP_SECTION_VMA_READONLY; // final anchor of relocating section must be in a read/write memory region
+    }
+
+    // add the new section to the section map
+
+    mem_section new_mem_section;
+    list <mem_section>::iterator new_section = section_list.insert (section_list.begin (), new_mem_section);
+    new_section->name = section_name;
+    new_section->size = section_size;
+    new_section->alignment = section_alignment;
+    new_section->relocates = relocates;
+    new_section->note = note;
+    new_section->linker_defined = linker_defined;
+    new_section->initial_location = new mem_location;
+    new_section->final_location = new mem_location;
+    new_section->initial_location->following_section = NULL; // initialize struct
+    new_section->final_location->following_section = NULL; // initialize struct
+    new_section->initial_location->anchor = initial_section_anchor;
+    new_section->final_location->anchor = final_section_anchor;
+
+    if ((initial_section_anchor == relative) &&
+        (!relocates) && (find_memory_section (initial_anchor_section_name)->relocates))
+    {
+        // a non-relocating relative section anchored to a relocating section
+
+        if (anchor_to_initial_location) // new section is anchored to the initial location of a relocating section
+        {
+            list <mem_section>::iterator anchor_section = find_memory_section (initial_anchor_section_name);
+            new_section->initial_location->following_section = anchor_section->initial_location->following_section;
+            anchor_section->initial_location->following_section = new_section;
+        }
+        else // new section is anchored to the final location of a relocating section
+        {
+            list <mem_section>::iterator anchor_section = find_memory_section (initial_anchor_section_name);
+            new_section->final_location->following_section = anchor_section->final_location->following_section;
+            anchor_section->final_location->following_section = new_section;
+        }
+    }
+    else
+    {
+        // copy initial location data
+
+        if (initial_section_anchor == relative) // new section follows the named anchor section
+        {
+            list <mem_section>::iterator anchor_section = find_memory_section (initial_anchor_section_name);
+            new_section->initial_location->following_section = anchor_section->initial_location->following_section; // move anchor of the following section
+            anchor_section->initial_location->following_section = new_section; // anchor the new section
+        }
+        else // new section has an absolute anchor
+            new_section->initial_location->address = initial_anchor_address;
+    
+        // copy final location data
+
+        if (final_section_anchor == relative) // new section follows the named anchor section
+        {
+            list <mem_section>::iterator anchor_section = find_memory_section (final_anchor_section_name);
+            new_section->final_location->following_section = anchor_section->final_location->following_section; // move anchor of the following section
+            anchor_section->final_location->following_section = new_section; // anchor the new section
+        }
+        else // new section has an absolute anchor
+            new_section->final_location->address = final_anchor_address;
+    }
+
+    // recalculate section lists for all regions
+
+    calc_section_lists ();
+
+	map_modified_flag = true;
+    return 0;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// calc_section_lists() updates the lists of memory sections for all
+// memory regions
+
+bool mem_map::calc_section_lists ()
+{
+    for (list <mem_region>::iterator region = region_list.begin (); region != region_list.end(); ++region)
+        calc_section_list (region);
+
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// calc_section_list() updates the list of memory sections which reside 
+// in the specified memory region. It is called whenever the section
+// map is modified.
+
+bool mem_map::calc_section_list (list <mem_region>::iterator region)
+{
+    // clear the old list (if any)
+
+	//TRACE (_T("Calculating section list for region '%s'\n"), CString (region->name.c_str()));
+    region->section_view_list.clear ();
+
+    // add the initial and final locations of each absolute section as necessary
+
+    for (list <mem_section>::iterator section = section_list.begin (); section != section_list.end (); ++section)
+    {
+        if (section->relocates) // the section is relocated and must be added to the view twice
+        {
+            add_absolute_section_to_list (region, section, initial_location);
+            add_absolute_section_to_list (region, section, final_location);
+        }
+        else // the section is not relocated and must be added to the view once only
+            add_absolute_section_to_list (region, section, fixed_location);
+    }
+
+    // add unused sections to section view list where appropriate
+
+    list <mem_section_view>::iterator previous_section_view = region->section_view_list.begin ();
+
+    if (previous_section_view == region->section_view_list.end ()) // no used sections in this region
+    {
+        // add a single unused section to the section view list
+
+        mem_section_view new_section_view;
+        new_section_view.section = NULL; // an unused section
+        region->section_view_list.push_back (new_section_view); // add to the section list for this region
+    }
+    else // there are used sections in this region
+    {
+        list <mem_section_view>::iterator second_section_view = region->section_view_list.begin ();
+        ++second_section_view;
+
+        // add unused sections between used sections where they do not meet in either initial or final locations
+
+        for (list <mem_section_view>::iterator section_view = second_section_view; section_view != region->section_view_list.end (); ++section_view)
+        {
+            if (! (absolute_sections_meet (previous_section_view->section, section_view->section)))
+            {
+                list <mem_section_view>::iterator new_section_view = region->section_view_list.insert (section_view); // add an unused section
+                new_section_view->section = NULL;
+            }
+
+            previous_section_view = section_view;
+        }
+
+        // add an unused section to end of region if the last section does not reach the end of the region in initial or final locations
+
+        if (! at_end_of_region (region->section_view_list.back().section, region))
+        {
+            mem_section_view new_section_view;
+            new_section_view.section = NULL; // an unused section
+            region->section_view_list.push_back (new_section_view); // add an unused section
+        }
+
+        // add an unused section to start of region if the first section does not start at the start of the region in initial or final locations
+
+        if (! at_start_of_region (region->section_view_list.front().section, region))
+        {
+            mem_section_view new_section_view;
+            new_section_view.section = NULL; // an unused section
+            region->section_view_list.push_front (new_section_view); // add an unused section
+        }
+    }
+
+    // add the initial and final locations of the each relative section as necessary
+
+    for (list <mem_section_view>::iterator section_view = region->section_view_list.begin (); section_view != region->section_view_list.end (); ++section_view)
+        if (section_view->section != NULL) // if section is used
+    {
+        list <mem_section>::iterator section = section_view->section;
+/*
+		TRACE (_T("Calculating relative sections for section view '%s' %s\n"), CString (section->name.c_str ()),
+			section_view->section_location == final_location ? _T("(final)") :
+			section_view->section_location == initial_location ? _T("(initial)") : _T("(fixed)"));
+*/
+
+        if (section_view->section_location == final_location)
+        {
+            if (section->final_location->anchor == absolute)
+                add_relative_sections_to_list (region, section_view, final_location);            
+        }
+
+        else if (section_view->section_location == initial_location)
+        {
+            if (section->initial_location->anchor == absolute)
+                add_relative_sections_to_list (region, section_view, initial_location);
+        }
+
+        else // section_view->section_location == fixed_location
+        {
+            if (section->initial_location->anchor == absolute)
+                add_relative_sections_to_list (region, section_view, initial_location);
+            if (section->final_location->anchor == absolute)
+                add_relative_sections_to_list (region, section_view, final_location);
+        }
+    }
+
+    // remove unused sections where user-defined section of unknown size will be placed
+
+    section_view = region->section_view_list.begin ();
+    while (section_view != region->section_view_list.end ())
+    {
+        bool expanding_section = false;
+        if ((section_view->section != NULL) &&
+            (section_view->section->size == 0) &&
+            (! section_view->section->linker_defined))
+            expanding_section = true;
+
+        ++section_view;
+
+        if (expanding_section && (section_view != region->section_view_list.end ()) && (section_view->section == NULL))
+            section_view = region->section_view_list.erase (section_view);
+    }
+
+    return true;
+}
+
+/////////////////////////////////////////////////////////////////////
+// add_relative_sections_to_list() inserts the sections defined relative
+// to the specified section list item to the section list for the
+// specified region in the appropriate order
+
+bool mem_map::add_relative_sections_to_list (list <mem_region>::iterator region, list <mem_section_view>::iterator section_view, section_location_type location_type)
+{
+    // insert following relative sections of type 'location_type' in region_view.section_view_list
+
+    list <mem_section>::iterator new_section = section_view->section;
+    mem_location * new_section_location = (location_type == initial_location ? new_section->initial_location : new_section->final_location);
+    list <mem_section_view>::iterator insertion_point = section_view;
+    ++insertion_point;
+    bool no_relocation = true;
+
+    while (new_section_location->following_section != NULL)
+    {
+        // add the new section to the section view list
+
+        mem_section_view new_section_view;
+        new_section_view.section = new_section_location->following_section;
+		const bool section_relocates = new_section->relocates;
+        new_section = new_section_view.section;
+        new_section_view.section_location = (new_section->relocates ? location_type : fixed_location);
+        if ((new_section_view.section_location == fixed_location) && (location_type == final_location) && (! section_view->section->relocates) && (! section_relocates) && no_relocation)
+        {
+            // section already added to the view so add nothing but
+            // increment insertion point for following sections
+            // TRACE (_T("Skipping section %s %s location (relative) preceding %s\n"), CString (new_section_location->following_section->name.c_str()), location_type == initial_location ? _T("initial") : _T("final"), ((insertion_point != region->section_view_list.end ()) && (insertion_point->section != NULL)) ? CString (insertion_point->section->name.c_str()) : _T("(null)"));
+            ++insertion_point;
+        }
+        else
+        {
+            // TRACE (_T("Inserting section %s %s location (relative) preceding %s\n"), CString (new_section_location->following_section->name.c_str()), location_type == initial_location ? _T("initial") : _T("final"), ((insertion_point != region->section_view_list.end ()) && (insertion_point->section != NULL)) ? CString (insertion_point->section->name.c_str()) : _T("(null)"));
+            region->section_view_list.insert (insertion_point, new_section_view);
+            no_relocation = no_relocation && ! new_section_view.section->relocates;
+        }
+        new_section_location = (location_type == initial_location ? new_section->initial_location : new_section->final_location);
+    }    
+
+    return true;
+}
+
+/////////////////////////////////////////////////////////////////////
+// add_absolute_section_to_list() inserts the specified section to the
+// specified section list at the appropriate place if it has an
+// absolute location and that location is within the specified memory
+// region
+
+bool mem_map::add_absolute_section_to_list (list <mem_region>::iterator region, list <mem_section>::iterator additional_section, section_location_type location_type)
+{
+    // get location of new section
+    mem_location * new_section_location = (location_type == initial_location ? additional_section->initial_location : additional_section->final_location);
+
+    if ((new_section_location->anchor == absolute) && (new_section_location->address >= region->address) && (new_section_location->address < region->address + region->size))
+        {
+        // the section lies in the region
+
+        // initialise the insertion point for the new section
+        list <mem_section_view>::iterator insertion_point = region->section_view_list.end ();
+
+        for (list <mem_section_view>::iterator section = region->section_view_list.begin (); section != region->section_view_list.end (); ++section)
+        {
+            // get location of section
+            mem_location * section_location  = (section->section_location == initial_location ? section->section->initial_location : section->section->final_location);
+
+            // compare with location of new section
+            if ((new_section_location->anchor == absolute) && (section_location->address >= new_section_location->address))
+            {
+                // insert new section here if the current section has a higher address
+                insertion_point = section;
+                break;
+            }
+        }
+
+        // add the new section to the section view list
+
+		// TRACE (_T("Inserting section %s %s location (absolute) preceding %s\n"), CString (additional_section->name.c_str()), location_type == initial_location ? _T("initial") : _T("final"), insertion_point != region->section_view_list.end () ? CString (insertion_point->section->name.c_str()) : _T("(end)"));
+        mem_section_view new_section_view;
+        new_section_view.section = additional_section;
+        new_section_view.section_location = location_type;
+        region->section_view_list.insert (insertion_point, new_section_view);
+    }
+
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////
+// absolute_sections_meet() determines whether the specified
+// absolute memory sections meet. It assumes that section2 comes
+// after section1 in the memory map.
+
+bool mem_map::absolute_sections_meet(list <mem_section>::iterator section1, list <mem_section>::iterator section2)
+{
+    if (section1->size == 0) // size of section1 is unknown
+        return false;
+
+    // check if initial section locations meet
+
+    if ((section1->initial_location->anchor == absolute) && 
+        ((section2->initial_location->anchor == absolute) &&
+        section1->initial_location->address + section1->size == section2->initial_location->address))
+        return true;
+
+    // check if final section locations meet
+
+    if ((section1->final_location->anchor == absolute) && 
+        ((section2->final_location->anchor == absolute) &&
+        section1->final_location->address + section1->size == section2->final_location->address))
+        return true;
+
+    return false;
+}
+
+
+//////////////////////////////////////////////////////////////
+// at_start_of_region() determines whether the specified section
+// is located at the very start of the specified region
+
+bool mem_map::at_start_of_region (list <mem_section>::iterator section, list <mem_region>::iterator region)
+{
+    // check initial section location
+    
+    if ((section->initial_location->anchor == absolute) &&
+        (section->initial_location->address == region->address))
+        return true;
+
+    // check final section location
+    
+    if ((section->final_location->anchor == absolute) &&
+        (section->final_location->address == region->address))
+        return true;
+
+    return false;
+}
+
+//////////////////////////////////////////////////////////////
+// at_end_of_region() determines whether the specified section
+// is located at the very end of the specified region
+
+bool mem_map::at_end_of_region (list <mem_section>::iterator section, list <mem_region>::iterator region)
+{
+    if (section->size == 0) // size of section is unknown
+        return false;
+
+    // check initial section location
+    
+    if ((section->initial_location->anchor == absolute) &&
+        section->initial_location->address + section->size == region->address + region->size)
+        return true;
+
+    // check final section location
+    
+    if ((section->final_location->anchor == absolute) &&
+        section->final_location->address + section->size == region->address + region->size)
+        return true;
+
+    return false;
+}
+
+////////////////////////////////////////////////////////////////////////
+// find_preceding_section() finds the preceding section in the
+// memory section list
+
+list <mem_section>::iterator mem_map::find_preceding_section (list <mem_section>::iterator reference_section, bool initial_location)
+{
+    for (list <mem_section>::iterator section = section_list.begin (); section != section_list.end (); ++section)
+    {
+        if (reference_section == (reference_section->relocates && initial_location ? section->initial_location->following_section : section->final_location->following_section)) // if preceding section found
+            return section; // return the section iterator
+    }
+    return NULL; // section not found
+}
+
+////////////////////////////////////////////////////////////////////////
+// find_memory_section() finds an existing section in the
+// memory section list
+
+list <mem_section>::iterator mem_map::find_memory_section (std::string section_name)
+{
+    for (list <mem_section>::iterator section = section_list.begin (); section != section_list.end (); ++section)
+        if (section->name == section_name) // if section found
+            return section; // return the section iterator
+
+    return NULL; // section not found
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// find_memory_region() finds an existing region in the
+// memory region list
+
+list <mem_region>::iterator mem_map::find_memory_region (std::string region_name)
+{
+    for (list <mem_region>::iterator region = region_list.begin (); region != region_list.end (); ++region)
+        if (region->name == region_name) // if region found
+            return region; // return the region iterator
+
+    return NULL; // region not found
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// delete_memory_section() removes an existing item from the
+// memory section map
+
+bool mem_map::delete_memory_section (std::string name)
+{
+    // make sure that the section exists
+
+    list <mem_section>::iterator section = find_memory_section (name);
+    if (section == NULL)
+        return false; // there is no section with this name
+
+/*
+    // make sure that there are no sections defined relative to this section before deleting it
+
+    if (section->initial_location->following_section != NULL)
+        return false;
+
+    if (section->final_location->following_section != NULL)
+        return false;
+*/
+
+    // if section is absolute, copy the initial and final location information to
+    // the following sections (if any)
+
+    if ((section->initial_location->anchor == absolute) && (section->initial_location->following_section != NULL))
+    {
+        section->initial_location->following_section->initial_location->anchor = absolute;
+        section->initial_location->following_section->initial_location->address = section->initial_location->address;
+        // FIXME adjust new address of following section for alignment here
+    }
+
+    if ((section->final_location->anchor == absolute) && (section->final_location->following_section != NULL))
+    {
+        section->final_location->following_section->final_location->anchor = absolute;
+        section->final_location->following_section->final_location->address = section->final_location->address;
+        // FIXME adjust new address of following section for alignment here
+    }
+
+    // if section is relative, find the initial and final sections to which it is attached
+    // and set their pointers to the sections following the one to be deleted (if any)
+
+    list <mem_section>::iterator related_section;
+
+    if (section->initial_location->anchor == relative)
+        for (related_section = section_list.begin (); related_section != section_list.end (); ++related_section)
+            if (related_section->initial_location->following_section == section)
+                related_section->initial_location->following_section = section->initial_location->following_section;
+
+    if (section->final_location->anchor == relative)
+        for (related_section = section_list.begin (); related_section != section_list.end (); ++related_section)
+            if (related_section->final_location->following_section == section)
+                related_section->final_location->following_section = section->final_location->following_section;
+
+    // delete the section
+
+    delete section->initial_location;
+    section->initial_location = NULL;
+
+    delete section->final_location;
+    section->final_location = NULL;
+
+    section_list.erase (section);
+
+    // recalculate section lists for all regions
+
+    calc_section_lists ();
+
+	map_modified_flag = true;
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// delete_memory_sections() deletes all memory sections in preparation
+// for layout loading or application closure
+
+bool mem_map::delete_all_memory_sections ()
+{
+    // deleteZ(each section in turn)
+
+    while (section_list.size () > 0)
+    {
+        list <mem_section>::iterator section = section_list.begin ();
+        delete section->initial_location;
+        section->initial_location = NULL;
+
+        delete section->final_location;
+        section->final_location = NULL;
+
+        section_list.erase (section);
+    }
+//    section_list.clear ();
+
+    // recalculate section view lists for all regions
+
+    calc_section_lists ();
+
+	map_modified_flag = true;
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// export_sections() exports section-related info for regions of the
+// specified type to the linker script fragment and header file
+
+bool mem_map::export_sections (FILE * script_stream, FILE * header_stream, mem_type type)
+{
+    for (list <mem_region>::iterator region = region_list.begin (); region != region_list.end(); ++region)
+        if (region->type == type)
+    {
+        for (list <mem_section_view>::iterator section_view = region->section_view_list.begin (); section_view != region->section_view_list.end (); ++section_view)
+        {
+            if ((section_view->section != NULL) && (section_view->section_location != initial_location))
+            {
+                if (section_view->section->linker_defined) // section is linker-defined
+                {
+                    // output section name and region name
+                    fprintf (script_stream, "    SECTION_%s (%s, ",
+                        encode_section_name (section_view->section->name).c_str (), region->name.c_str ());
+
+                    // output VMA
+                    if (section_view->section->final_location->anchor == absolute) // an absolute VMA
+                        fprintf (script_stream, "%#lx, ", section_view->section->final_location->address); // specify absolute address
+                    else // a relative VMA
+                        fprintf (script_stream, "ALIGN (%#lx), ", section_view->section->alignment); // specify alignment
+
+                    // output LMA
+                    if (! section_view->section->relocates) // section does not relocate so LMA == VMA
+                        fprintf (script_stream, "LMA_EQ_VMA)");
+                    else if (section_view->section->initial_location->anchor == absolute) // an absolute LMA
+                        fprintf (script_stream, "AT (%#lx))", section_view->section->initial_location->address);
+                    else // a relative LMA
+                    {
+                        list <mem_section>::iterator parent_section;
+                        for (parent_section = section_list.begin (); parent_section != section_list.end (); ++parent_section)
+                            if (parent_section->initial_location->following_section == section_view->section)
+                                break;
+
+                        if (parent_section->linker_defined) // parent section is linker-defined
+                            fprintf (script_stream, "FOLLOWING (.%s))", parent_section->name.c_str ());
+                        else // parent section is user-defined
+                            fprintf (script_stream, "AT (__%s + %#lx))", parent_section->name.c_str (), parent_section->size);
+                    }
+                }
+                else // section is user-defined
+                {
+                    // output section symbol
+                    if (section_view->section->final_location->anchor == absolute) // an absolute VMA
+                        fprintf (script_stream, "    CYG_LABEL_DEFN(__%s) = %#lx;", section_view->section->name.c_str (), section_view->section->final_location->address);
+                    else // a relative VMA
+                        fprintf (script_stream, "    CYG_LABEL_DEFN(__%s) = ALIGN (%#lx);", section_view->section->name.c_str (), section_view->section->alignment);
+
+                    // update current location pointer
+                    if (section_view->section->size != 0) // size is known
+                        fprintf (script_stream, " . = CYG_LABEL_DEFN(__%s) + %#lx;", section_view->section->name.c_str (), section_view->section->size);
+
+                    // output reference to symbol in header file
+                    fprintf (header_stream, "#ifndef __ASSEMBLER__\nextern char CYG_LABEL_NAME (__%s) [];\n#endif\n", section_view->section->name.c_str ());
+                    fprintf (header_stream, "#define CYGMEM_SECTION_%s (CYG_LABEL_NAME (__%s))\n", section_view->section->name.c_str (), section_view->section->name.c_str ());
+                    if (section_view->section->size == 0) // a section of unknown size
+                    {
+                        mem_address section_end_address;
+
+                        ++section_view; // move to next section_view
+                        if (section_view == region->section_view_list.end ()) // section continues to end of region
+                            section_end_address = region->address + region->size;
+                        else // section continues to next section with an absolute location
+                            section_end_address = section_view->section->final_location->address;
+                        --section_view; // move back to previous section view
+
+                        fprintf (header_stream, "#define CYGMEM_SECTION_%s_SIZE (%#lx - (size_t) CYG_LABEL_NAME (__%s))\n", section_view->section->name.c_str (), section_end_address, section_view->section->name.c_str ());
+                    }
+                    else // a section of known size
+                        fprintf (header_stream, "#define CYGMEM_SECTION_%s_SIZE (%#lx)\n", section_view->section->name.c_str (), section_view->section->size);
+                }
+
+                // end of section description
+
+                fprintf (script_stream, "\n"); // new line
+            }
+        }
+    }
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// export_files() creates a fragment of linker script and a header file
+// describing the memory layout
+
+bool mem_map::export_files (const wxChar* script_name, const wxChar* header_name)
+{
+    FILE * script_stream;
+    FILE * header_stream;
+    list <mem_region>::iterator region;
+
+	// do not export files if the memory layout is empty
+	// assume that there are default LDI files available
+
+	if (region_list.size () == 0)
+		return false;
+
+    // open the script fragment file for writing
+
+    script_stream = _tfopen (script_name, _T("wt"));
+    if (script_stream == NULL)
+        return false;
+
+    // open the header file for writing
+
+    header_stream = _tfopen (header_name, _T("wt"));
+    if (header_stream == NULL)
+    {
+        fclose (script_stream);
+        return false;
+    }
+
+    // output the linker script fragment header
+
+    time_t export_time;
+    time (&export_time);
+    struct tm * local = localtime (&export_time);
+    fprintf (script_stream, "// eCos memory layout - %s\n%s\n\n", asctime (local), MLT_GENERATED_WARNING);
+    fprintf (script_stream, "#include <cyg/infra/cyg_type.inc>\n\n");
+
+    // output the header file header
+
+    fprintf (header_stream, "// eCos memory layout - %s\n%s\n\n", asctime (local), MLT_GENERATED_WARNING);
+	fprintf (header_stream, "#ifndef __ASSEMBLER__\n");
+	fprintf (header_stream, "#include <cyg/infra/cyg_type.h>\n"); // for the CYG_LABEL_NAME macro definition
+	fprintf (header_stream, "#include <stddef.h>\n\n"); // for size_t
+	fprintf (header_stream, "#endif\n");
+
+    // output the MEMORY block
+
+    fprintf (script_stream, "MEMORY\n{\n"); // start of MEMORY block
+    for (region = region_list.begin (); region != region_list.end(); ++region)
+    {
+        fprintf (script_stream, "    %s : ORIGIN = %#lx, LENGTH = %#lx\n", region->name.c_str(), region->address, region->size);
+        fprintf (header_stream, "#define CYGMEM_REGION_%s (%#lx)\n", region->name.c_str(), region->address);
+        fprintf (header_stream, "#define CYGMEM_REGION_%s_SIZE (%#lx)\n", region->name.c_str(), region->size);
+        fprintf (header_stream, "#define CYGMEM_REGION_%s_ATTR (CYGMEM_REGION_ATTR_R%s)\n", region->name.c_str(), (read_write == region->type) ? " | CYGMEM_REGION_ATTR_W" : "");
+    }
+    fprintf (script_stream, "}\n\n"); // end of MEMORY block
+
+    // output the SECTIONS block
+
+    fprintf (script_stream, "SECTIONS\n{\n"); // start of SECTIONS block
+    fprintf (script_stream, "    SECTIONS_BEGIN\n"); // SECTIONS block initial script macro call
+    export_sections (script_stream, header_stream, read_only); // export sections in read-only regions first
+    export_sections (script_stream, header_stream, read_write); // followed by sections in read-write regions
+    fprintf (script_stream, "    SECTIONS_END\n"); // SECTIONS block final script macro call
+    fprintf (script_stream, "}\n"); // end of SECTIONS block
+
+    // close the files
+
+    fclose (script_stream);
+    fclose (header_stream);
+
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// import_linker_defined_sections() reads a the linker-defined section
+// names from the "SECTION_*" CPP macro definitions within the linker
+// script
+
+bool mem_map::import_linker_defined_sections (const wxChar* filename)
+{
+    // clear the linker-defined section name list
+
+    linker_defined_section_list.clear ();
+
+    // open the linker script file for reading
+
+    FILE * stream;
+    stream = _tfopen (filename, _T("rt"));
+    if (stream == NULL)
+        return false;
+
+    bool macro = false; // not reading a CPP macro definition initially
+    char input_string [32];
+    while (! feof (stream))
+    {
+        if (macro)
+        {
+            if (fscanf (stream, "%8s", input_string) == EOF) // read the next 8 chars (not including whitespace)
+                break;
+
+            if (strcmp (input_string, "SECTION_") == 0) // an MLT section macro definition
+            {
+                if (fscanf (stream, "%31[^(]", input_string) == EOF) // read the section name up to the '(' character
+                    break;
+
+                std::string section_name = decode_section_name (input_string);
+                if (find (linker_defined_section_list.begin (), linker_defined_section_list.end (), section_name) == linker_defined_section_list.end ()) // if section name is unique
+                    linker_defined_section_list.push_back (section_name);
+            }
+
+            macro = false;
+        }
+
+        else
+        {
+            if (fscanf (stream, "%31s", input_string) == EOF)
+                break;
+
+            if (strcmp (input_string, "#define") == 0)
+                macro = true; // macro starts with "#define"
+        }
+
+    }
+
+    // close the file
+
+    if (fclose (stream))
+        return false;
+
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////
+// encode_note() encodes newlines in note
+
+std::string mem_map::encode_note (std::string in)
+{
+    std::string out = "!"; // dummy first character to ensure output string length > 0
+
+    for (unsigned int item = 0; item < in.size (); item++)
+        if (in [item] == _TCHAR('\n')) // an LF character
+            out += "\x07F"; // output substitution character 0x7F instead
+        else if (in [item] != _TCHAR('\r')) // ignore the CR (present under Win32 only)
+            out += in [item]; // copy other characters to output string unprocessed
+
+    return out;
+}
+
+////////////////////////////////////////////////////////////////////////
+// decode_note() decodes newlines in note
+
+std::string mem_map::decode_note (std::string in)
+{
+    std::string out;
+
+    for (unsigned int item = 1; item < in.size (); item++) // ignore dummy first character
+        if (in [item] == _TCHAR('\x07F')) // the newline substitution character
+            out += "\r\n"; // output CRLF instead
+        else
+            out += in [item];
+
+    return out;
+}
+
+////////////////////////////////////////////////////////////////////////
+// encode_section_name() encodes period -> double underscore in section name
+
+std::string mem_map::encode_section_name (std::string in)
+{
+    std::string out;
+
+    for (unsigned int item = 0; item < in.size (); item++)
+        if (in [item] == '.') // a period character
+			out += "__"; // output a double underscore instead
+        else
+            out += in [item];
+
+    return out;
+}
+
+////////////////////////////////////////////////////////////////////////
+// decode_section_name() decodes double underscore -> period in section name
+
+std::string mem_map::decode_section_name (std::string in)
+{
+    std::string out;
+
+    for (unsigned int item = 0; item < in.size (); item++)
+        if ((item + 1 < in.size ()) && (in [item] == '_') && (in [item + 1] == '_')) // two consecutive underscore characters
+		{
+			out += "."; // output a period instead
+			item++; // skip the second underscore
+		}
+        else
+            out += in [item];
+
+    return out;
+}
+
+////////////////////////////////////////////////////////////////////////
+// save_memory_layout() saves the memory layout to file for later use
+
+bool mem_map::save_memory_layout (const wxChar* filename)
+{
+    FILE * stream;
+    list <mem_region>::iterator region;
+
+    // open the save file for writing
+
+    stream = _tfopen (filename, _T("wt"));
+    if (stream == NULL)
+        return false;
+
+    // write the save file format version number
+
+	fprintf (stream, "version %u\n", (unsigned int) MLT_FILE_VERSION);
+
+    // save the memory region data in address order
+
+    for (region = region_list.begin (); region != region_list.end (); ++region)
+        fprintf (stream, "region %s %lx %lx %d %s\n", region->name.c_str (),
+            region->address, region->size, (region->type == read_only), encode_note (region->note).c_str ());
+
+    // save the memory section data in VMA order
+
+    for (region = region_list.begin (); region != region_list.end(); ++region)
+    {
+        for (list <mem_section_view>::iterator section_view = region->section_view_list.begin (); section_view != region->section_view_list.end (); ++section_view)
+        {
+            if ((section_view->section != NULL) && (section_view->section_location != initial_location))
+            {
+                list <mem_section>::iterator section = section_view->section;
+                fprintf (stream, "section %s %lx %lx %d %d %d %d %d %d",
+                    section->name.c_str (), section->size, section->alignment,
+                    section->relocates, section->linker_defined,
+                    section->final_location->anchor == absolute,
+                    section->final_location->following_section != NULL,
+                    section->initial_location->anchor == absolute,
+                    section->initial_location->following_section != NULL);
+
+                if (section->final_location->anchor == absolute)
+                    fprintf (stream, " %lx", section->final_location->address);
+
+                if (section->initial_location->anchor == absolute)
+                    fprintf (stream, " %lx", section->initial_location->address);
+
+                if (section->final_location->following_section != NULL)
+                    fprintf (stream, " %s", section->final_location->following_section->name.c_str ());
+
+                if (section->initial_location->following_section != NULL)
+                    fprintf (stream, " %s", section->initial_location->following_section->name.c_str ());
+
+                fprintf (stream, " %s", encode_note (section->note).c_str ());
+
+                // end of section description
+
+                fprintf (stream, "\n"); // new line
+            }
+        }
+    }
+
+    // close the file
+
+    if (fclose (stream))
+        return false;
+
+	map_modified_flag = false;
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// load_memory_layout() loads a previously saved memory layout from file
+
+bool mem_map::load_memory_layout (const wxChar* filename)
+{
+    FILE * stream;
+
+    // open the save file for reading
+
+    stream = _tfopen (filename, _T("rt"));
+    if (stream == NULL)
+        return false;
+
+	// read the file version
+
+	unsigned int file_version;
+	if ((fscanf (stream, "%*s %u", &file_version) != 1) ||
+		(file_version != MLT_FILE_VERSION))
+	{
+		fclose (stream); // missing or incorrect file version
+        return false;
+	}
+
+    new_memory_layout ();
+
+    // read the new memory layout (first pass)
+
+    while (! feof (stream))
+    {
+        char record_type [32];
+        if (fscanf (stream, "%31s", record_type) == EOF)
+            break;
+
+        if (strcmp (record_type, "section") == 0) // a section record
+        {
+            if (! load_memory_section_1 (stream))
+                break;
+        }
+        else if (strcmp (record_type, "region") == 0) // a region record
+        {
+            mem_address address, size;
+            bool read_only_region;
+            char name [32];
+            char note [1024];
+
+            fscanf (stream, "%s %lx %lx %d %1023[^\n]", name, &address, &size, &read_only_region, note);
+
+            if (create_memory_region (name, address, size, (read_only_region ? read_only : read_write), decode_note (note)))
+                break;
+        }   
+        else // an unknown record type
+            break;
+    }
+
+	// quit if the end of the file was not reached (due to an error)
+
+	if (! feof (stream))
+	{
+		new_memory_layout ();
+		fclose (stream);
+		return false;
+	}
+
+    // move the file pointer back to the beginning of the file
+
+    fseek (stream, 0, SEEK_SET);
+
+    while (! feof (stream)) // read the memory layout (second pass)
+    {
+        char record_type [32];
+        if (fscanf (stream, "%31s", record_type) == EOF)
+            break;
+
+        if ((strcmp (record_type, "section") == 0) && (! load_memory_section_2 (stream)))
+            break;
+    }
+    
+    // close the file
+
+    if (fclose (stream))
+	{
+		new_memory_layout ();
+        return false;
+	}
+
+    // recalculate section view lists for all regions
+
+    calc_section_lists ();
+
+	map_modified_flag = false;
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// load_memory_section_1() loads a previously saved memory section from
+// file (first pass)
+
+bool mem_map::load_memory_section_1 (FILE * stream)
+{
+    char section_name [32];
+    int relocates, linker_defined;
+    int final_absolute, initial_absolute, final_following, initial_following;
+    mem_section new_section;
+
+    new_section.initial_location = new mem_location;
+    new_section.initial_location->following_section = NULL;
+    new_section.final_location = new mem_location;
+    new_section.final_location->following_section = NULL;
+      
+    fscanf (stream,"%31s %lx %lx %d %d %d %d %d %d",
+        section_name, &new_section.size, &new_section.alignment,
+        &relocates, &linker_defined, &final_absolute, &final_following,
+        &initial_absolute, &initial_following);
+
+    new_section.name = section_name;
+    new_section.relocates = (relocates != 0);
+    new_section.linker_defined = (linker_defined != 0);
+
+    new_section.final_location->anchor = (final_absolute ? absolute : relative);
+    if (final_absolute) // final location is absolute
+        fscanf (stream, "%lx", &new_section.final_location->address);
+
+    new_section.initial_location->anchor = (initial_absolute ? absolute : relative);
+    if (initial_absolute) // initial location is absolute
+        fscanf (stream, "%lx", &new_section.initial_location->address);
+
+    if (final_following)
+        fscanf (stream, "%*s"); // skip the final following section field on first pass
+
+    if (initial_following)
+        fscanf (stream, "%*s"); // skip the initial following section field on first pass
+
+    char note [1024];
+    fscanf (stream, " %1023[^\n]", note);
+    new_section.note = decode_note (note);
+
+    // add the new section to the section map
+
+    section_list.push_front (new_section);
+
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// load_memory_section_2() loads a previously saved memory section from
+// file (second pass)
+
+bool mem_map::load_memory_section_2 (FILE * stream)
+{
+    char section_name [32];
+    char following_section_name [32];
+    int final_absolute, initial_absolute, final_following, initial_following;
+
+    fscanf (stream,"%31s %*lx %*lx %*d %*d %d %d %d %d",
+        section_name, &final_absolute, &final_following,
+        &initial_absolute, &initial_following);
+
+    if (final_absolute) // final location is absolute
+        fscanf (stream, "%*lx"); // skip the final location
+
+    if (initial_absolute) // initial location is absolute
+        fscanf (stream, "%*lx"); // skip the initial location
+
+    if (initial_following || final_following) // the section is a parent
+    {
+        list <mem_section>::iterator section = find_memory_section (section_name);
+
+        if (final_following)
+        {
+            fscanf (stream, "%31s", following_section_name); // read the final following section name
+            section->final_location->following_section =
+                find_memory_section (following_section_name);
+        }
+
+        if (initial_following)
+        {
+            fscanf (stream, "%31s", following_section_name); // read the initial following section name
+            section->initial_location->following_section =
+                find_memory_section (following_section_name);
+        }
+    }
+
+    fscanf (stream, "%*1023[^\n]"); // skip the note
+
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// new_memory_layout() clears the memory layout
+
+bool mem_map::new_memory_layout ()
+{
+    delete_all_memory_sections ();
+//    section_list.clear ();
+    region_list.clear ();
+
+	map_modified_flag = false; // no need to save an empty memory layout
+    return true;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// section_exists() determines if the specified section is defined
+
+bool mem_map::section_exists (std::string section_name)
+{
+    return (find_memory_section (section_name) != NULL);
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// find_region_by_address() finds the region containing the specified
+// memory address
+
+list <mem_region>::iterator mem_map::find_region_by_address (mem_address address)
+{
+    for (list <mem_region>::iterator region = region_list.begin (); region !=region_list.end(); ++region)
+        if ((address >= region->address) && (address < region->address + region->size))
+            return region;
+
+    return NULL; // the specified address is not in a memory region
+}
+
+
+////////////////////////////////////////////////////////////////////////
+// find_region_by_section() finds the region containing the specified
+// section
+
+list <mem_region>::iterator mem_map::find_region_by_section (list <mem_section>::iterator section, section_location_type location_type)
+{
+    for (list <mem_region>::iterator region = region_list.begin (); region !=region_list.end(); ++region)
+        for (list <mem_section_view>::iterator section_view = region->section_view_list.begin (); section_view != region->section_view_list.end (); ++section_view)
+            if ((section_view->section != NULL) && (section_view->section == section) &&
+                (section_view->section_location == (section_view->section->relocates ? location_type : fixed_location)))
+                return region;
+
+    return NULL; // the specified section location type was not found (you probably searched for the fixed_location of a relocating section)
+}