1 /* Routines for handling XML memory maps provided by target.
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
24 #include "memory-map.h"
25 #include "gdb_assert.h"
26 #include "exceptions.h"
28 #include "gdb_string.h"
30 #if !defined(HAVE_LIBEXPAT)
33 parse_memory_map (const char *memory_map
)
35 static int have_warned
;
40 warning (_("Can not parse XML memory map; XML support was disabled "
47 #else /* HAVE_LIBEXPAT */
49 #include "xml-support.h"
51 #include "gdb_expat.h"
53 /* Internal parsing data passed to all Expat callbacks. */
54 struct memory_map_parsing_data
56 VEC(mem_region_s
) **memory_map
;
57 struct mem_region
*currently_parsing
;
59 const char *property_name
;
64 free_memory_map_parsing_data (void *p_
)
66 struct memory_map_parsing_data
*p
= p_
;
68 xfree (p
->character_data
);
71 /* Callback called by Expat on start of element.
72 DATA_ is pointer to memory_map_parsing_data
73 NAME is the name of element
74 ATTRS is the zero-terminated array of attribute names and
77 This function handles the following elements:
78 - 'memory' -- creates a new memory region and initializes it
79 from attributes. Sets DATA_.currently_parsing to the new region.
80 - 'properties' -- sets DATA.capture_text. */
83 memory_map_start_element (void *data_
, const XML_Char
*name
,
84 const XML_Char
**attrs
)
86 static const XML_Char
*type_names
[] = {"ram", "rom", "flash", 0};
87 static int type_values
[] = { MEM_RW
, MEM_RO
, MEM_FLASH
};
88 struct memory_map_parsing_data
*data
= data_
;
89 struct gdb_exception ex
;
91 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
93 if (strcmp (name
, "memory") == 0)
97 r
= VEC_safe_push (mem_region_s
, *data
->memory_map
, NULL
);
100 r
->lo
= xml_get_integer_attribute (attrs
, "start");
101 r
->hi
= r
->lo
+ xml_get_integer_attribute (attrs
, "length");
102 r
->attrib
.mode
= xml_get_enum_value (attrs
, "type", type_names
,
104 r
->attrib
.blocksize
= -1;
106 data
->currently_parsing
= r
;
108 else if (strcmp (name
, "property") == 0)
110 if (!data
->currently_parsing
)
111 throw_error (XML_PARSE_ERROR
,
112 _("memory map: found 'property' element outside 'memory'"));
114 data
->capture_text
= 1;
116 data
->property_name
= xml_get_required_attribute (attrs
, "name");
121 (ex
.error
, _("While parsing element %s:\n%s"), name
, ex
.message
);
124 /* Callback called by Expat on start of element. DATA_ is a pointer
125 to our memory_map_parsing_data. NAME is the name of the element.
127 This function handles the following elements:
128 - 'property' -- check that the property name is 'blocksize' and
129 sets DATA->currently_parsing->attrib.blocksize
130 - 'memory' verifies that flash block size is set. */
133 memory_map_end_element (void *data_
, const XML_Char
*name
)
135 struct memory_map_parsing_data
*data
= data_
;
136 struct gdb_exception ex
;
138 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
140 if (strcmp (name
, "property") == 0)
142 if (strcmp (data
->property_name
, "blocksize") == 0)
144 if (!data
->character_data
)
145 throw_error (XML_PARSE_ERROR
,
146 _("Empty content of 'property' element"));
148 data
->currently_parsing
->attrib
.blocksize
149 = strtoul (data
->character_data
, &end
, 0);
151 throw_error (XML_PARSE_ERROR
,
152 _("Invalid content of the 'blocksize' property"));
155 throw_error (XML_PARSE_ERROR
,
156 _("Unknown memory region property: %s"), name
);
158 data
->capture_text
= 0;
160 else if (strcmp (name
, "memory") == 0)
162 if (data
->currently_parsing
->attrib
.mode
== MEM_FLASH
163 && data
->currently_parsing
->attrib
.blocksize
== -1)
164 throw_error (XML_PARSE_ERROR
,
165 _("Flash block size is not set"));
167 data
->currently_parsing
= 0;
168 data
->character_data
= 0;
173 (ex
.error
, _("while parsing element %s: \n%s"), name
, ex
.message
);
176 /* Callback called by expat for all character data blocks.
177 DATA_ is the pointer to memory_map_parsing_data.
178 S is the point to character data.
179 LEN is the length of data; the data is not zero-terminated.
181 If DATA_->CAPTURE_TEXT is 1, appends this block of characters
182 to DATA_->CHARACTER_DATA. */
184 memory_map_character_data (void *data_
, const XML_Char
*s
,
187 struct memory_map_parsing_data
*data
= data_
;
188 int current_size
= 0;
190 if (!data
->capture_text
)
193 /* Expat interface does not guarantee that a single call to
194 a handler will be made. Actually, one call for each line
195 will be made, and character data can possibly span several
198 Take care to realloc the data if needed. */
199 if (!data
->character_data
)
200 data
->character_data
= xmalloc (len
+ 1);
203 current_size
= strlen (data
->character_data
);
204 data
->character_data
= xrealloc (data
->character_data
,
205 current_size
+ len
+ 1);
208 memcpy (data
->character_data
+ current_size
, s
, len
);
209 data
->character_data
[current_size
+ len
] = '\0';
213 clear_result (void *p
)
215 VEC(mem_region_s
) **result
= p
;
216 VEC_free (mem_region_s
, *result
);
221 parse_memory_map (const char *memory_map
)
223 VEC(mem_region_s
) *result
= NULL
;
224 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
225 struct cleanup
*before_deleting_result
;
226 struct cleanup
*saved
;
227 volatile struct gdb_exception ex
;
230 struct memory_map_parsing_data data
= {};
232 XML_Parser parser
= XML_ParserCreateNS (NULL
, '!');
236 make_cleanup_free_xml_parser (parser
);
237 make_cleanup (free_memory_map_parsing_data
, &data
);
238 /* Note: 'clear_result' will zero 'result'. */
239 before_deleting_result
= make_cleanup (clear_result
, &result
);
241 XML_SetElementHandler (parser
, memory_map_start_element
,
242 memory_map_end_element
);
243 XML_SetCharacterDataHandler (parser
, memory_map_character_data
);
244 XML_SetUserData (parser
, &data
);
245 data
.memory_map
= &result
;
247 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
249 if (XML_Parse (parser
, memory_map
, strlen (memory_map
), 1)
252 enum XML_Error err
= XML_GetErrorCode (parser
);
254 throw_error (XML_PARSE_ERROR
, "%s", XML_ErrorString (err
));
257 if (ex
.reason
!= GDB_NO_ERROR
)
259 if (ex
.error
== XML_PARSE_ERROR
)
260 /* Just report it. */
261 warning (_("Could not parse XML memory map: %s"), ex
.message
);
263 throw_exception (ex
);
266 /* Parsed successfully, don't need to delete the result. */
267 discard_cleanups (before_deleting_result
);
270 do_cleanups (back_to
);
274 #endif /* HAVE_LIBEXPAT */