Various bugfixes, conveniences, and better DWARF4 support.

--HG--
rename : tests/iterator-comp/iterator-comp.cpp => tests/Rotted/iterator-comp/iterator-comp.cpp
rename : tests/visible-named/visible-named.cpp => tests/Rotted/visible-named/visible-named.cpp

Author: stephenrkell

examples/print_spec.cpp

@@ -3,5 +3,5 @@
 
 int main(int argc, char **argv)
 {
-	std::cout << dwarf::spec::dwarf3_def::inst;
+	std::cout << dwarf::spec::dwarf4;
 }

include/dwarfpp/adt.hpp

@@ -212,8 +212,7 @@ namespace dwarf
 			bool move_to_next_sibling(iterator_base& arg)
 			{
 				// handle root DIE specially
-				int start_depth = arg.path_from_root.size() - 1;
-				assert(start_depth >= 0);
+				unsigned start_depth = arg.path_from_root.size() - 1;
 				if (arg.p_d->get_offset() == 0) return false;
 				// handle CU DIEs specially
 				assert(start_depth >= 1);

include/dwarfpp/attr.hpp

@@ -132,6 +132,7 @@ namespace dwarf
 			 * address data type. */
 			{ 
 				Dwarf_Addr addr; 
+				address(Dwarf_Addr val) { this->addr = val; }
 				bool operator==(const address& arg) const { return this->addr == arg.addr; }
 				bool operator!=(const address& arg) const { return !(*this == arg); }
 				bool operator<(const address& arg) const { return this->addr < arg.addr; }
@@ -214,11 +215,17 @@ namespace dwarf
 		public:
 
 			Dwarf_Bool get_flag() const { assert(f == FLAG); return v_flag; }
-			Dwarf_Unsigned get_unsigned() const { assert(f == UNSIGNED); return v_u; }
-			Dwarf_Signed get_signed() const { assert(f == SIGNED); return v_s; }
+			// allow mix-and-match among signed and unsigned
+			Dwarf_Unsigned get_unsigned() const 
+			{ assert(f == UNSIGNED || f == SIGNED); return (f == UNSIGNED) ? v_u : static_cast<Dwarf_Unsigned>(v_s); }
+			Dwarf_Signed get_signed() const 
+			{ assert(f == SIGNED || f == UNSIGNED); return (f == SIGNED) ? v_s : static_cast<Dwarf_Signed>(v_u); }
 			const std::vector<unsigned char> *get_block() const { assert(f == BLOCK); return v_block; }
 			const std::string& get_string() const { assert(f == STRING); return *v_string; }
-			address get_address() const { assert(f == ADDR); return v_addr; }
+			/* I added the tolerance of UNSIGNED here because sometimes high_pc is an address, 
+			 * other times it's unsigned... BUT it means something different in the latter 
+			 * case (lopc-relative) so it's best to handle this difference higher up. */
+			address get_address() const { assert(f == ADDR/* || f == UNSIGNED*/); return/* (f == ADDR) ?*/ v_addr /*: address(static_cast<Dwarf_Addr>(v_u))*/; }
 			const loclist& get_loclist() const { assert(f == LOCLIST); return *v_loclist; }
 			const rangelist& get_rangelist() const { assert(f == RANGELIST); return *v_rangelist; }
 

include/dwarfpp/encap.hpp

@@ -695,9 +695,9 @@ namespace dwarf {
 				for (auto i = p_seq->begin(/*p_seq*/); i != p_seq->end(/*p_seq*/); i++)
 				{
 					Dwarf_Off target = i->second.get_ref().off;
-					bool abs = i->second.get_ref().abs;
-					
-					//assert(abs);
+
+					// bool abs = i->second.get_ref().abs;
+					// assert(abs);
 
 					bool is_valid = this->get_ds().map_find(target) != this->get_ds().map_end();
 					retval &= is_valid;

include/dwarfpp/expr.hpp

@@ -13,7 +13,7 @@
 
 namespace dwarf
 {
-	namespace core { struct LocdescList; struct RangesList; }
+	namespace core { struct LocdescList; struct Locdesc; struct RangesList; }
 	namespace encap
     {
     	using namespace dwarf::lib;
@@ -105,7 +105,7 @@ namespace dwarf
 
 			/* This template parses a location expression out of an array of unsigneds. */
 			template<size_t s> 
-            loc_expr(Dwarf_Unsigned (&arr)[s], Dwarf_Addr lopc, Dwarf_Addr hipc,
+            loc_expr(Dwarf_Unsigned const (&arr)[s], Dwarf_Addr lopc, Dwarf_Addr hipc,
             	const spec::abstract_def& spec = spec::dwarf3) 
             : spec(spec), hipc(hipc), lopc(lopc)
 			{
@@ -189,15 +189,15 @@ namespace dwarf
 			friend class ::dwarf::lib::evaluator;
 			friend class attribute_value;
 			static loclist NO_LOCATION;
-		private:
-			loclist() {}
-		public:
+
+			loclist() {} // empty loclist
 			loclist(const dwarf::lib::loclist& dll);
 			/* We can construct a loc_expr from a Loc_Desc. 
 			 * So we can construct a loclist from a LocdescList. */
 			loclist(const core::LocdescList& ll); 
 			// would ideally repeat all vector constructors
 			template <class In> loclist(In first, In last) : std::vector<loc_expr>(first, last) {}
+			loclist(const core::Locdesc& l); 
 			loclist(const std::vector<loc_expr>& v) : std::vector<loc_expr>(v) {}
 			loclist(const loc_expr& loc) : std::vector<loc_expr>(1, loc) {}
 			//bool operator==(const loclist& oll) const { return *this == oll; }