diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..3dc4f3e6780e6a13e6e72b105f172dd4a5e77ce9
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,8 @@
+.sconsign.dblite
+src/.sconsign.dblite
+lib/libehp.a
+src/libehp.a
+src/.*.swp
+src/*.o
+include/.*.swp
+
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000000000000000000000000000000000000..00fd958118f839bee35d0a386d5c9d8ecb18548d
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "third-party/elfio-code"]
+	path = third-party/elfio-code
+	url = https://git.code.sf.net/p/elfio/code
diff --git a/include/ehp.hpp b/include/ehp.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..5b45e410f780e804a4cc53459d53ddd5a29fd895
--- /dev/null
+++ b/include/ehp.hpp
@@ -0,0 +1,158 @@
+#ifndef ehp_hpp
+#define ehp_hpp
+
+#include <limits>
+#include <map>
+#include <memory>
+#include <set>
+
+
+namespace EHP
+{
+
+using namespace std;
+
+using EHProgramInstructionByteVector_t = vector<uint8_t>;
+class EHProgramInstruction_t 
+{
+	protected:
+	EHProgramInstruction_t() {}
+	EHProgramInstruction_t(const EHProgramInstruction_t&) {}
+	public: 
+	virtual ~EHProgramInstruction_t() =0;
+	virtual void print(uint64_t &pc, int64_t caf=1) const=0;
+	virtual bool isNop() const =0;
+	virtual bool isRestoreState() const =0;
+	virtual bool isRememberState() const =0;
+	virtual const EHProgramInstructionByteVector_t& getBytes() const =0;
+};
+
+using EHProgramInstructionVector_t = vector<shared_ptr<EHProgramInstruction_t> >;
+class EHProgram_t
+{
+	protected:
+	EHProgram_t() {}
+	EHProgram_t(const EHProgram_t&) {}
+	public:
+	virtual ~EHProgram_t() {}
+	virtual void print(const uint64_t start_addr=0) const=0;
+	virtual shared_ptr<EHProgramInstructionVector_t> getInstructions() const =0;
+};
+
+class CIEContents_t 
+{
+	protected:
+	CIEContents_t() {} 
+	CIEContents_t(const CIEContents_t&) {} 
+	public:
+	virtual ~CIEContents_t() {}
+	virtual const EHProgram_t& getProgram() const =0;
+	virtual uint64_t getCAF() const =0;
+	virtual int64_t getDAF() const =0;
+	virtual uint64_t getPersonality() const =0;
+	virtual uint64_t getReturnRegister() const =0;
+	virtual string getAugmentation() const =0;
+	virtual uint8_t getLSDAEncoding() const =0;
+	virtual uint8_t getFDEEncoding() const =0;
+	virtual void print() const =0;
+};
+
+class LSDACallSiteAction_t 
+{
+	protected:
+	LSDACallSiteAction_t() {} 
+	LSDACallSiteAction_t(const LSDACallSiteAction_t&) {} 
+	public:
+	virtual ~LSDACallSiteAction_t() {}
+	virtual int64_t getAction() const =0;
+	virtual void print() const=0;
+};
+
+class LSDATypeTableEntry_t 
+{
+	protected:
+	LSDATypeTableEntry_t() {}
+	LSDATypeTableEntry_t(const LSDATypeTableEntry_t&) {}
+	public:
+	virtual ~LSDATypeTableEntry_t() {} 
+	virtual uint64_t getTypeInfoPointer() const =0;
+	virtual uint64_t getEncoding() const =0;
+	virtual uint64_t getTTEncodingSize() const =0;
+	virtual void print() const=0;
+	
+};
+
+using LSDCallSiteActionVector_t=vector<shared_ptr<LSDACallSiteAction_t> >;
+class LSDACallSite_t 
+{
+	protected:
+	LSDACallSite_t() {}
+	LSDACallSite_t(const LSDACallSite_t&) {}
+	public:
+	virtual ~LSDACallSite_t() {}
+	virtual shared_ptr<LSDCallSiteActionVector_t> getActionTable() const =0;
+	virtual uint64_t getLandingPadAddress() const  =0;
+	virtual void print() const=0;
+};
+
+using CallSiteVector_t = vector<shared_ptr<LSDACallSite_t> > ;
+class LSDA_t 
+{
+	protected:
+	LSDA_t() {}
+	LSDA_t(const LSDA_t&) {}
+	public:
+	virtual ~LSDA_t() {}
+	virtual uint8_t getTTEncoding() const =0;
+	virtual void print() const=0;
+        virtual shared_ptr<CallSiteVector_t> getCallSites() const =0;
+};
+
+class FDEContents_t 
+{
+	protected:
+	FDEContents_t() {}
+	FDEContents_t(const FDEContents_t&) {}
+	public:
+	virtual ~FDEContents_t() {}
+	virtual uint64_t getStartAddress() const =0;
+	virtual uint64_t getEndAddress() const =0;
+	virtual const CIEContents_t& getCIE() const =0;
+	virtual const EHProgram_t& getProgram() const =0;
+	virtual shared_ptr<LSDA_t> getLSDA() const =0;
+	virtual void print() const=0;	// move to ostream?  toString?
+
+};
+
+
+using FDEVector_t = vector<shared_ptr<FDEContents_t> > ;
+using CIEVector_t = vector<shared_ptr<CIEContents_t> > ;
+class EHFrameParser_t 
+{
+	protected:
+	EHFrameParser_t() {}
+	EHFrameParser_t(const EHFrameParser_t&) {}
+	public:
+	virtual ~EHFrameParser_t() {}
+	virtual bool parse()=0;
+	virtual void print() const=0;
+	virtual const shared_ptr<FDEVector_t> getFDEs() const =0;
+	virtual const shared_ptr<CIEVector_t> getCIEs() const =0;
+
+	static unique_ptr<EHFrameParser_t> factory(const char* const filename);
+	static unique_ptr<EHFrameParser_t> factory(
+		uint8_t ptrsize,
+		const string eh_frame_data, const uint64_t eh_frame_data_start_addr,
+		const string eh_frame_hdr_data, const uint64_t eh_frame_hdr_data_start_addr,
+		const string gcc_except_table_data, const uint64_t gcc_except_table_data_start_addr
+		);
+};
+
+// e.g.
+// const auto & ehparser=EHFrameParse_t::factory("a.ncexe");
+// for(auto &b : ehparser->getFDES()) { ... } 
+
+
+}
+#endif
+
diff --git a/src/SConscript b/src/SConscript
index c6e12cac9d1dad532ff3750bec244af7ef3f6b56..231f1e62cd11a32a96c38446eac353a2d94f061a 100644
--- a/src/SConscript
+++ b/src/SConscript
@@ -16,9 +16,10 @@ LIBPATH="$SECURITY_TRANSFORMS_HOME/lib"
 LIBS=Split("")
 
 myenv=myenv.Clone(CPPPATH=Split(cpppath))
-myenv.Append(CXXFLAGS = " -std=c++11 -Wall -Werror -fmax-errors=2")
+myenv.Append(CXXFLAGS = " -std=c++11 -Wall -Werror -fmax-errors=1")
 
 lib=myenv.Library("ehp",  Split(files), LIBPATH=LIBPATH, LIBS=LIBS)
-Default(lib)
+install=myenv.Install("../lib/", lib)
+Default(install)
 
-Return('lib')
+Return('install')
diff --git a/src/ehp.cpp b/src/ehp.cpp
index 62ead1e253c469b56e20dcf43c9fd3576678a77b..161b22b4412aabc97a5b426322c2920cf3e122ce 100644
--- a/src/ehp.cpp
+++ b/src/ehp.cpp
@@ -11,11 +11,13 @@
 #include <memory>
 
 #include "ehp.hpp"
+#include "ehp_priv.hpp"
+#include "scoop_replacement.hpp"
 
 using namespace std;
 using namespace EHP;
 
-#define WHOLE_CONTAINER(s) begin(s), end(s)
+#define ALLOF(s) begin(s), end(s)
 
 template <int ptrsize>
 template <class T> 
@@ -783,10 +785,10 @@ bool eh_program_insn_t<ptrsize>::Advance(uint64_t &cur_addr, uint64_t CAF) const
 }
 
 template <int ptrsize>
-const vector<uint8_t>& eh_program_insn_t<ptrsize>::GetBytes() const { return program_bytes; }
+const vector<uint8_t>& eh_program_insn_t<ptrsize>::getBytes() const { return program_bytes; }
 
 template <int ptrsize>
-vector<uint8_t>& eh_program_insn_t<ptrsize>::GetBytes() { return program_bytes; }
+vector<uint8_t>& eh_program_insn_t<ptrsize>::getBytes() { return program_bytes; }
 
 
 
@@ -796,7 +798,7 @@ vector<uint8_t>& eh_program_insn_t<ptrsize>::GetBytes() { return program_bytes;
 template <int ptrsize>
 bool operator<(const eh_program_insn_t<ptrsize>& a, const eh_program_insn_t<ptrsize>& b)
 {
-	return a.GetBytes() < b.GetBytes(); 
+	return a.getBytes() < b.getBytes(); 
 }
 
 template <int ptrsize>
@@ -840,15 +842,15 @@ bool eh_program_t<ptrsize>::parse_program(
 }
 
 template <int ptrsize>
-const vector<eh_program_insn_t <ptrsize> >& eh_program_t<ptrsize>::GetInstructions() const { return instructions; }
+const vector<eh_program_insn_t <ptrsize> >& eh_program_t<ptrsize>::getInstructionsInternal() const { return instructions; }
 
 template <int ptrsize>
-vector<eh_program_insn_t <ptrsize> >& eh_program_t<ptrsize>::GetInstructions() { return instructions; }
+vector<eh_program_insn_t <ptrsize> >& eh_program_t<ptrsize>::getInstructionsInternal() { return instructions; }
 
 template <int ptrsize>
 bool operator<(const eh_program_t<ptrsize>& a, const eh_program_t<ptrsize>& b)
 {
-	return a.GetInstructions() < b.GetInstructions(); 
+	return a.getInstructionsInternal() < b.getInstructionsInternal(); 
 }
 
 template <int ptrsize>
@@ -869,29 +871,29 @@ cie_contents_t<ptrsize>::cie_contents_t() :
 
 
 template <int ptrsize>
-const eh_program_t<ptrsize>& cie_contents_t<ptrsize>::GetProgram() const { return eh_pgm; }
+const eh_program_t<ptrsize>& cie_contents_t<ptrsize>::getProgram() const { return eh_pgm; }
 
 template <int ptrsize>
-uint64_t cie_contents_t<ptrsize>::GetCAF() const { return code_alignment_factor; }
+uint64_t cie_contents_t<ptrsize>::getCAF() const { return code_alignment_factor; }
 
 template <int ptrsize>
-int64_t cie_contents_t<ptrsize>::GetDAF() const { return data_alignment_factor; }
+int64_t cie_contents_t<ptrsize>::getDAF() const { return data_alignment_factor; }
 
 template <int ptrsize>
-uint64_t cie_contents_t<ptrsize>::GetPersonality() const { return personality; }
+uint64_t cie_contents_t<ptrsize>::getPersonality() const { return personality; }
 
 template <int ptrsize>
-uint64_t cie_contents_t<ptrsize>::GetReturnRegister() const { return return_address_register_column; }
+uint64_t cie_contents_t<ptrsize>::getReturnRegister() const { return return_address_register_column; }
 
 
 template <int ptrsize>
-string cie_contents_t<ptrsize>::GetAugmentation() const { return augmentation; }
+string cie_contents_t<ptrsize>::getAugmentation() const { return augmentation; }
 
 template <int ptrsize>
-uint8_t cie_contents_t<ptrsize>::GetLSDAEncoding() const { return lsda_encoding;}
+uint8_t cie_contents_t<ptrsize>::getLSDAEncoding() const { return lsda_encoding;}
 
 template <int ptrsize>
-uint8_t cie_contents_t<ptrsize>::GetFDEEncoding() const { return fde_encoding;}
+uint8_t cie_contents_t<ptrsize>::getFDEEncoding() const { return fde_encoding;}
 
 
 template <int ptrsize>
@@ -1041,7 +1043,7 @@ lsda_call_site_action_t<ptrsize>::lsda_call_site_action_t() :
 
 
 template <int ptrsize>
-int64_t lsda_call_site_action_t<ptrsize>::GetAction() const { return action;}
+int64_t lsda_call_site_action_t<ptrsize>::getAction() const { return action;}
 
 
 template <int ptrsize>
@@ -1072,7 +1074,7 @@ void lsda_call_site_action_t<ptrsize>::print() const
 template <int ptrsize>
 bool operator< (const lsda_call_site_action_t <ptrsize> &lhs, const lsda_call_site_action_t <ptrsize> &rhs)
 { 	
-	return lhs.GetAction() < rhs.GetAction(); 
+	return lhs.getAction() < rhs.getAction(); 
 }
 
 template <int ptrsize>
@@ -1082,13 +1084,13 @@ lsda_type_table_entry_t<ptrsize>::lsda_type_table_entry_t() :
 
 
 template <int ptrsize>
-uint64_t lsda_type_table_entry_t<ptrsize>::GetTypeInfoPointer() const { return pointer_to_typeinfo; }
+uint64_t lsda_type_table_entry_t<ptrsize>::getTypeInfoPointer() const { return pointer_to_typeinfo; }
 
 template <int ptrsize>
-uint64_t lsda_type_table_entry_t<ptrsize>::GetEncoding() const { return tt_encoding; }
+uint64_t lsda_type_table_entry_t<ptrsize>::getEncoding() const { return tt_encoding; }
 
 template <int ptrsize>
-uint64_t lsda_type_table_entry_t<ptrsize>::GetTTEncodingSize() const { return tt_encoding_size; }
+uint64_t lsda_type_table_entry_t<ptrsize>::getTTEncodingSize() const { return tt_encoding_size; }
 
 
 template <int ptrsize>
@@ -1236,7 +1238,7 @@ void lsda_call_site_t<ptrsize>::print() const
 
 
 template <int ptrsize>
-uint8_t lsda_t<ptrsize>::GetTTEncoding() const { return type_table_encoding; }
+uint8_t lsda_t<ptrsize>::getTTEncoding() const { return type_table_encoding; }
 
 template <int ptrsize>
 lsda_t<ptrsize>::lsda_t() :
@@ -1257,21 +1259,21 @@ template <int ptrsize>
 bool lsda_t<ptrsize>::parse_lsda(
                                  const uint64_t lsda_addr, 
                                  //const DataScoop_t* gcc_except_scoop, 
-                                 const uint8_t* gcc_except_scoop_data, 
+                                 const ScoopReplacement_t *gcc_except_scoop, 
                                  const uint64_t fde_region_start
                                 )
 {
 	// make sure there's a scoop and that we're in the range.
 	if(!gcc_except_scoop)
 		return true;
-	if(lsda_addr<gcc_except_scoop->GetStart()->GetVirtualOffset())
+	if(lsda_addr<gcc_except_scoop->getStart())
 		return true;
-	if(lsda_addr>=gcc_except_scoop->GetEnd()->GetVirtualOffset())
+	if(lsda_addr>=gcc_except_scoop->getEnd())
 		return true;
 
-	const auto &data=gcc_except_scoop->GetContents();
-	const auto data_addr=gcc_except_scoop->GetStart()->GetVirtualOffset();
-	const auto max=gcc_except_scoop->GetContents().size();
+	const auto &data=gcc_except_scoop->getContents();
+	const auto data_addr=gcc_except_scoop->getStart();
+	const auto max=gcc_except_scoop->getContents().size();
 	auto pos=uint32_t(lsda_addr-data_addr);
 	auto start_pos=pos;
 
@@ -1332,9 +1334,9 @@ bool lsda_t<ptrsize>::parse_lsda(
 	{
 		for(const auto cs_tab_entry : call_site_table)
 		{
-			for(const auto act_tab_entry : cs_tab_entry.GetActionTable())
+			for(const auto act_tab_entry : cs_tab_entry.getActionTableInternal())
 			{
-				const auto type_filter=act_tab_entry.GetAction();
+				const auto type_filter=act_tab_entry.getAction();
 				const auto parse_and_insert_tt_entry = [&] (const unsigned long index) -> bool
 				{
 					// cout<<"Parsing TypeTable at -"<<index<<endl;
@@ -1421,16 +1423,16 @@ fde_contents_t<ptrsize>::fde_contents_t() :
 
 
 template <int ptrsize>
-const cie_contents_t<ptrsize>& fde_contents_t<ptrsize>::GetCIE() const { return cie_info; }
+const cie_contents_t<ptrsize>& fde_contents_t<ptrsize>::getCIE() const { return cie_info; }
 
 template <int ptrsize>
-cie_contents_t<ptrsize>& fde_contents_t<ptrsize>::GetCIE() { return cie_info; }
+cie_contents_t<ptrsize>& fde_contents_t<ptrsize>::getCIE() { return cie_info; }
 
 template <int ptrsize>
-const eh_program_t<ptrsize>& fde_contents_t<ptrsize>::GetProgram() const { return eh_pgm; }
+const eh_program_t<ptrsize>& fde_contents_t<ptrsize>::getProgram() const { return eh_pgm; }
 
 template <int ptrsize>
-eh_program_t<ptrsize>& fde_contents_t<ptrsize>::GetProgram() { return eh_pgm; }
+eh_program_t<ptrsize>& fde_contents_t<ptrsize>::getProgram() { return eh_pgm; }
 
 template <int ptrsize>
 bool fde_contents_t<ptrsize>::parse_fde(
@@ -1439,7 +1441,7 @@ bool fde_contents_t<ptrsize>::parse_fde(
 	const uint8_t* const data, 
 	const uint64_t max, 
 	const uint64_t eh_addr,
-	const uint8_t* gcc_except_scoop_data)
+	const ScoopReplacement_t* gcc_except_scoop)
 //	const DataScoop_t* gcc_except_scoop)
 {
 	auto &c=*this;
@@ -1462,25 +1464,25 @@ bool fde_contents_t<ptrsize>::parse_fde(
 		return true;
 
 	auto fde_start_addr=uint64_t(0);
-	if(this->read_type_with_encoding(c.GetCIE().GetFDEEncoding(),fde_start_addr, pos, eh_frame_scoop_data, max, eh_addr))
+	if(this->read_type_with_encoding(c.getCIE().getFDEEncoding(),fde_start_addr, pos, eh_frame_scoop_data, max, eh_addr))
 		return true;
 
 	auto fde_range_len=uint64_t(0);
-	if(this->read_type_with_encoding(c.GetCIE().GetFDEEncoding() & 0xf /* drop pc-rel bits */,fde_range_len, pos, eh_frame_scoop_data, max, eh_addr))
+	if(this->read_type_with_encoding(c.getCIE().getFDEEncoding() & 0xf /* drop pc-rel bits */,fde_range_len, pos, eh_frame_scoop_data, max, eh_addr))
 		return true;
 
 	auto fde_end_addr=fde_start_addr+fde_range_len;
 
 	auto augmentation_data_length=uint64_t(0);
-	if(c.GetCIE().GetAugmentation().find("z") != string::npos)
+	if(c.getCIE().getAugmentation().find("z") != string::npos)
 	{
 		if(this->read_uleb128(augmentation_data_length, pos, eh_frame_scoop_data, max))
 			return true;
 	}
 	auto lsda_addr=uint64_t(0);
-	if(c.GetCIE().GetLSDAEncoding()!= DW_EH_PE_omit)
+	if(c.getCIE().getLSDAEncoding()!= DW_EH_PE_omit)
 	{
-		if(this->read_type_with_encoding(c.GetCIE().GetLSDAEncoding(), lsda_addr, pos, eh_frame_scoop_data, max, eh_addr))
+		if(this->read_type_with_encoding(c.getCIE().getLSDAEncoding(), lsda_addr, pos, eh_frame_scoop_data, max, eh_addr))
 			return true;
 		if(c.lsda.parse_lsda(lsda_addr,gcc_except_scoop, fde_start_addr))
 			return true;
@@ -1513,7 +1515,7 @@ void fde_contents_t<ptrsize>::print() const
 	cout<<"		FDE len:		"<<dec<<fde_range_len<<endl;
 	cout<<"		FDE LSDA:		"<<hex<<lsda_addr<<endl;
 	eh_pgm.print(fde_start_addr);
-	if(GetCIE().GetLSDAEncoding()!= DW_EH_PE_omit)
+	if(getCIE().getLSDAEncoding()!= DW_EH_PE_omit)
 		lsda.print();
 	else
 		cout<<"		No LSDA for this FDE."<<endl;
@@ -1527,10 +1529,10 @@ void fde_contents_t<ptrsize>::print() const
 template <int ptrsize>
 bool split_eh_frame_impl_t<ptrsize>::iterate_fdes()
 {
-	auto eh_frame_scoop_data=(const uint8_t* const)eh_frame_scoop->GetContents().c_str();
+	auto eh_frame_scoop_data=(const uint8_t* const)eh_frame_scoop->getContents().c_str();
 	auto data=eh_frame_scoop_data;
-	auto eh_addr= eh_frame_scoop->GetStart()->GetVirtualOffset();
-	auto max=eh_frame_scoop->GetContents().size();
+	auto eh_addr= eh_frame_scoop->getStart();
+	auto max=eh_frame_scoop->getContents().size();
 	auto position=uint32_t(0);
 
 	//cout << "----------------------------------------"<<endl;
@@ -1568,7 +1570,7 @@ bool split_eh_frame_impl_t<ptrsize>::iterate_fdes()
 			fde_contents_t<ptrsize> f;
 			auto cie_position = cie_offset_position - cie_offset;
 			//cout << "FDE length="<< dec << act_length << " cie=[" << setw(6) << hex << cie_position << "]" << endl;
-			if(f.parse_fde(old_position, cie_position, data, max, eh_addr, gcc_except_table_scoop))
+			if(f.parse_fde(old_position, cie_position, data, max, eh_addr, gcc_except_table_scoop.get()))
 				return true;
 			//const auto old_fde_size=fdes.size();
 			fdes.insert(f);
@@ -1611,5 +1613,51 @@ void split_eh_frame_impl_t<ptrsize>::print() const
 	});
 }
 
+template <int ptrsize>
+const shared_ptr<FDEVector_t>  split_eh_frame_impl_t<ptrsize>::getFDEs() const
+{
+	auto ret=shared_ptr<FDEVector_t>(new FDEVector_t());
+	transform(ALLOF(fdes), back_inserter(*ret), 
+		[](const fde_contents_t<ptrsize> &a) { return shared_ptr<FDEContents_t>(new fde_contents_t<ptrsize>(a));});
+	return shared_ptr<FDEVector_t>(ret);
+}
+
+template <int ptrsize>
+const shared_ptr<CIEVector_t>  split_eh_frame_impl_t<ptrsize>::getCIEs() const
+{
+	auto ret=shared_ptr<CIEVector_t>(new CIEVector_t());
+	transform(ALLOF(cies), back_inserter(*ret), 
+		[](const cie_contents_t<ptrsize> &a){ return shared_ptr<CIEContents_t>(new cie_contents_t<ptrsize>(a));});
+	return ret;
+}
+	
+
+
+unique_ptr<EHFrameParser_t> EHFrameParser_t::factory(const char* const filename)
+{
+	assert(0);
+}
+
+unique_ptr<EHFrameParser_t> EHFrameParser_t::factory(
+	uint8_t ptrsize,
+	const string eh_frame_data, const uint64_t eh_frame_data_start_addr,
+	const string eh_frame_hdr_data, const uint64_t eh_frame_hdr_data_start_addr,
+	const string gcc_except_table_data, const uint64_t gcc_except_table_data_start_addr
+	)
+{
+	const auto eh_frame_sr=ScoopReplacement_t(eh_frame_data,eh_frame_data_start_addr);
+	const auto eh_frame_hdr_sr=ScoopReplacement_t(eh_frame_hdr_data,eh_frame_hdr_data_start_addr);
+	const auto gcc_except_table_sr=ScoopReplacement_t(gcc_except_table_data,gcc_except_table_data_start_addr);
+	if(ptrsize==4)
+		return unique_ptr<EHFrameParser_t>(new split_eh_frame_impl_t<4>(eh_frame_sr,eh_frame_hdr_sr,gcc_except_table_sr));
+	else if(ptrsize==8)
+		return unique_ptr<EHFrameParser_t>(new split_eh_frame_impl_t<8>(eh_frame_sr,eh_frame_hdr_sr,gcc_except_table_sr));
+	else
+		throw std::out_of_range("ptrsize must be 4 or 8");
+	
+}
+
+	
+
 
 
diff --git a/src/ehp.hpp b/src/ehp_priv.hpp
similarity index 65%
rename from src/ehp.hpp
rename to src/ehp_priv.hpp
index 420a0d747cd5a42b82f47a2e825c68274241a1b5..832384d68af152e093a5fddeee214a6b6cd357f7 100644
--- a/src/ehp.hpp
+++ b/src/ehp_priv.hpp
@@ -1,5 +1,5 @@
-#ifndef ehp_hpp
-#define ehp_hpp
+#ifndef ehp_priv_hpp
+#define ehp_priv_hpp
 
 #include <iostream>
 #include <iomanip>
@@ -15,6 +15,7 @@
 #include <set>
 
 #include "ehp_dwarf2.hpp"
+#include "scoop_replacement.hpp"
 
 
 namespace EHP
@@ -24,7 +25,7 @@ using namespace std;
 
 
 template <int ptrsize>
-class eh_frame_util_t
+class eh_frame_util_t 
 {
 	public: 
 	template <class T> 
@@ -66,7 +67,7 @@ class eh_frame_util_t
 };
 
 template <int ptrsize>
-class eh_program_insn_t 
+class eh_program_insn_t  : public EHProgramInstruction_t
 {
 	public: 
 	
@@ -99,8 +100,8 @@ class eh_program_insn_t
 
 	bool Advance(uint64_t &cur_addr, uint64_t CAF) const ;
 
-	const std::vector<uint8_t>& GetBytes() const ;
-	std::vector<uint8_t>& GetBytes() ;
+	const std::vector<uint8_t>& getBytes() const ;
+	std::vector<uint8_t>& getBytes() ;
 
 	private:
 
@@ -111,7 +112,7 @@ template <int ptrsize>
 bool operator<(const eh_program_insn_t<ptrsize>& a, const eh_program_insn_t<ptrsize>& b);
 
 template <int ptrsize>
-class eh_program_t
+class eh_program_t : public EHProgram_t
 {
 	public:
 	void push_insn(const eh_program_insn_t<ptrsize> &i); 
@@ -122,8 +123,10 @@ class eh_program_t
 		const uint32_t& program_start_position, 
 		const uint8_t* const data, 
 		const uint32_t &max_program_pos);
-	const std::vector<eh_program_insn_t <ptrsize> >& GetInstructions() const ;
-	std::vector<eh_program_insn_t <ptrsize> >& GetInstructions() ;
+        virtual shared_ptr<EHProgramInstructionVector_t> getInstructions() const { assert(0); }
+	std::vector<eh_program_insn_t <ptrsize> >& getInstructionsInternal() ;
+	const std::vector<eh_program_insn_t <ptrsize> >& getInstructionsInternal() const ;
+
 	private:
 	std::vector<eh_program_insn_t <ptrsize> > instructions;
 };
@@ -132,7 +135,7 @@ template <int ptrsize>
 bool operator<(const eh_program_t<ptrsize>& a, const eh_program_t<ptrsize>& b);
 
 template <int ptrsize>
-class cie_contents_t : eh_frame_util_t<ptrsize>
+class cie_contents_t : public CIEContents_t, private eh_frame_util_t<ptrsize>
 {
 	private:
 	uint64_t cie_position;
@@ -154,15 +157,15 @@ class cie_contents_t : eh_frame_util_t<ptrsize>
 
 	cie_contents_t() ;
 	
-	const eh_program_t<ptrsize>& GetProgram() const ;
-	uint64_t GetCAF() const ;
-	int64_t GetDAF() const ;
-	uint64_t GetPersonality() const ;
-	uint64_t GetReturnRegister() const ;
+	const eh_program_t<ptrsize>& getProgram() const ;
+	uint64_t getCAF() const ;
+	int64_t getDAF() const ;
+	uint64_t getPersonality() const ;
+	uint64_t getReturnRegister() const ;
 
-	std::string GetAugmentation() const ;
-	uint8_t GetLSDAEncoding() const ;
-	uint8_t GetFDEEncoding() const ;
+	std::string getAugmentation() const ;
+	uint8_t getLSDAEncoding() const ;
+	uint8_t getFDEEncoding() const ;
 
 	bool parse_cie(
 		const uint32_t &cie_position, 
@@ -173,14 +176,14 @@ class cie_contents_t : eh_frame_util_t<ptrsize>
 };
 
 template <int ptrsize>
-class lsda_call_site_action_t : private eh_frame_util_t<ptrsize>
+class lsda_call_site_action_t : public LSDACallSiteAction_t, private eh_frame_util_t<ptrsize>
 {
 	private:
 	int64_t action;
 
 	public:
 	lsda_call_site_action_t() ;
-	int64_t GetAction() const ;
+	int64_t getAction() const ;
 
 	bool parse_lcsa(uint32_t& pos, const uint8_t* const data, const uint64_t max, bool &end);
 	void print() const;
@@ -190,7 +193,7 @@ template <int ptrsize>
 bool operator< (const lsda_call_site_action_t <ptrsize> &lhs, const lsda_call_site_action_t <ptrsize> &rhs);
 
 template <int ptrsize>
-class lsda_type_table_entry_t: private eh_frame_util_t<ptrsize>
+class lsda_type_table_entry_t: public LSDATypeTableEntry_t, private eh_frame_util_t<ptrsize>
 {
 	private:
 	uint64_t pointer_to_typeinfo;
@@ -200,9 +203,9 @@ class lsda_type_table_entry_t: private eh_frame_util_t<ptrsize>
 	public:
 	lsda_type_table_entry_t() ; 
 
-	uint64_t GetTypeInfoPointer() const ;
-	uint64_t GetEncoding() const ;
-	uint64_t GetTTEncodingSize() const ;
+	uint64_t getTypeInfoPointer() const ;
+	uint64_t getEncoding() const ;
+	uint64_t getTTEncodingSize() const ;
 
 	bool parse(
 		const uint64_t p_tt_encoding, 	
@@ -218,7 +221,7 @@ class lsda_type_table_entry_t: private eh_frame_util_t<ptrsize>
 };
 
 template <int ptrsize>
-class lsda_call_site_t : private eh_frame_util_t<ptrsize>
+class lsda_call_site_t : public LSDACallSite_t, private eh_frame_util_t<ptrsize>
 {
 	private:
 	uint64_t call_site_offset;
@@ -236,10 +239,11 @@ class lsda_call_site_t : private eh_frame_util_t<ptrsize>
 	public:
 	lsda_call_site_t() ;
 
-	const std::vector<lsda_call_site_action_t <ptrsize> >& GetActionTable() const { return action_table; }
-	      std::vector<lsda_call_site_action_t <ptrsize> >& GetActionTable()       { return action_table; }
+	shared_ptr<LSDCallSiteActionVector_t> getActionTable() const       { assert(0); }
+	const std::vector<lsda_call_site_action_t <ptrsize> >& getActionTableInternal() const { return action_table; }
+	      std::vector<lsda_call_site_action_t <ptrsize> >& getActionTableInternal()       { return action_table; }
 
-	uint64_t GetLandingPadAddress() const  { return landing_pad_addr ; } 
+	uint64_t getLandingPadAddress() const  { return landing_pad_addr ; } 
 
 	bool parse_lcs(	
 		const uint64_t action_table_start_addr, 	
@@ -263,7 +267,7 @@ class lsda_call_site_t : private eh_frame_util_t<ptrsize>
 template <int ptrsize>  using call_site_table_t = std::vector<lsda_call_site_t <ptrsize> > ;
 
 template <int ptrsize>
-class lsda_t : private eh_frame_util_t<ptrsize>
+class lsda_t : private LSDA_t, private eh_frame_util_t<ptrsize>
 {
 	private:
 	uint8_t landing_pad_base_encoding;
@@ -282,25 +286,25 @@ class lsda_t : private eh_frame_util_t<ptrsize>
 
 	public:
 
-	uint8_t GetTTEncoding() const ;
+	uint8_t getTTEncoding() const ;
 	
 	lsda_t() ;
 
 	bool parse_lsda(const uint64_t lsda_addr, 
-	                /*const libIRDB::DataScoop_t* gcc_except_scoop,  */
-			const uint8_t *gcc_except_scoop_data,
+			const ScoopReplacement_t* gcc_except_scoop_data,
 	                const uint64_t fde_region_start
 	                );
 	void print() const;
 
-        const call_site_table_t<ptrsize> GetCallSites() const { return call_site_table;}
+        shared_ptr<CallSiteVector_t> getCallSites() const { assert(0); } 
+        const call_site_table_t<ptrsize> getCallSitesInternal() const { return call_site_table;}
 
 };
 
 
 
 template <int ptrsize>
-class fde_contents_t : eh_frame_util_t<ptrsize>
+class fde_contents_t : public FDEContents_t, eh_frame_util_t<ptrsize> 
 {
 	uint32_t fde_position;
 	uint32_t cie_position;
@@ -326,16 +330,20 @@ class fde_contents_t : eh_frame_util_t<ptrsize>
 
 //	bool appliesTo(const libIRDB::Instruction_t* insn) const;
 
-	uint64_t GetFDEStartAddress() const { return fde_start_addr; } 
-	uint64_t GetFDEEndAddress() const {return fde_end_addr; }
+	uint64_t getStartAddress() const { return fde_start_addr; } 
+	uint64_t getEndAddress() const {return fde_end_addr; }
+
+	uint64_t getFDEStartAddress() const { return fde_start_addr; } 
+	uint64_t getFDEEndAddress() const {return fde_end_addr; }
 
-	const cie_contents_t<ptrsize>& GetCIE() const ;
-	cie_contents_t<ptrsize>& GetCIE() ;
+	const cie_contents_t<ptrsize>& getCIE() const ;
+	cie_contents_t<ptrsize>& getCIE() ;
 
-	const eh_program_t<ptrsize>& GetProgram() const ;
-	eh_program_t<ptrsize>& GetProgram() ;
+	const eh_program_t<ptrsize>& getProgram() const ;
+	eh_program_t<ptrsize>& getProgram() ;
 
-	const lsda_t<ptrsize>& GetLSDA() const { return lsda; }
+	shared_ptr<LSDA_t> getLSDA() const { assert(0); }
+	const lsda_t<ptrsize>& getLSDAInternal() const { return lsda; }
 
 	bool parse_fde(
 		const uint32_t &fde_position, 
@@ -343,8 +351,7 @@ class fde_contents_t : eh_frame_util_t<ptrsize>
 		const uint8_t* const data, 
 		const uint64_t max, 
 		const uint64_t eh_addr,
-		const uint8_t *gcc_except_scoop_data
-		/* const libIRDB::DataScoop_t* gcc_except_scoop*/);
+		const ScoopReplacement_t *gcc_except_scoop);
 
 	void print() const;
 
@@ -352,30 +359,18 @@ class fde_contents_t : eh_frame_util_t<ptrsize>
 };
 
 template <int ptrsize>
-bool operator<(const fde_contents_t<ptrsize>& a, const fde_contents_t<ptrsize>& b) { return a.GetFDEEndAddress()-1 < b.GetFDEStartAddress(); }
-
-
-class split_eh_frame_t 
-{
-	public:
+bool operator<(const fde_contents_t<ptrsize>& a, const fde_contents_t<ptrsize>& b) { return a.getFDEEndAddress()-1 < b.getFDEStartAddress(); }
 
-		virtual bool parse()=0;
-		virtual void print() const=0;
-
-};
 
 template <int ptrsize>
-class split_eh_frame_impl_t : public split_eh_frame_t
+class split_eh_frame_impl_t : public EHFrameParser_t
 {
 	private: 
 
-/*
-	libIRDB::FileIR_t* firp;
-	libIRDB::DataScoop_t* eh_frame_scoop;
-	libIRDB::DataScoop_t* eh_frame_hdr_scoop;
-	libIRDB::DataScoop_t* gcc_except_table_scoop;
-	OffsetMap_t offset_to_insn_map;
-*/
+	unique_ptr<ScoopReplacement_t> eh_frame_scoop;
+	unique_ptr<ScoopReplacement_t> eh_frame_hdr_scoop;
+	unique_ptr<ScoopReplacement_t> gcc_except_table_scoop;
+
 	std::vector<cie_contents_t <ptrsize> > cies;
 	std::set<fde_contents_t <ptrsize> > fdes;
 
@@ -384,14 +379,25 @@ class split_eh_frame_impl_t : public split_eh_frame_t
 
 	public:
 
-/*
-	split_eh_frame_impl_t(libIRDB::FileIR_t* p_firp);
-*/
+	split_eh_frame_impl_t
+		(
+		const ScoopReplacement_t &eh_frame,
+		const ScoopReplacement_t &eh_frame_hdr,
+		const ScoopReplacement_t &gcc_except_table 
+		)
+		:
+			eh_frame_scoop(new ScoopReplacement_t(eh_frame)),
+			eh_frame_hdr_scoop(new ScoopReplacement_t(eh_frame_hdr)),
+			gcc_except_table_scoop(new ScoopReplacement_t(gcc_except_table))
+	{
+	}
 
 	bool parse();
-
 	void print() const;
 
+        virtual const shared_ptr<FDEVector_t> getFDEs() const;
+        virtual const shared_ptr<CIEVector_t> getCIEs() const;
+
 
 };
 
diff --git a/src/scoop_replacement.hpp b/src/scoop_replacement.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4883fe637debfdd82836a62ee9a8073c87368d5
--- /dev/null
+++ b/src/scoop_replacement.hpp
@@ -0,0 +1,39 @@
+#ifndef scoop_replacement_hpp
+#define scoop_replacement_hpp
+
+#include <string>
+
+namespace EHP
+{
+
+using namespace std;
+
+typedef uint64_t addr_t;
+
+class ScoopReplacement_t
+{
+	public:
+
+	ScoopReplacement_t(const string& in_data, const addr_t in_start)
+		:
+		data(in_data),
+		start(in_start),
+		end(0)
+	{ 
+		end=in_start+data.size()-1;
+	}
+
+	string getContents()  { return data; }
+	const string& getContents()  const { return data; }
+
+	addr_t getEnd() const { return end; }
+	addr_t getStart() const { return start; } 
+
+	private:
+	string data;
+	addr_t start, end;
+};
+
+	
+}
+#endif
diff --git a/third-party/elfio-code b/third-party/elfio-code
new file mode 160000
index 0000000000000000000000000000000000000000..4b9ff89770804f981385c79bcb6058baf3a743eb
--- /dev/null
+++ b/third-party/elfio-code
@@ -0,0 +1 @@
+Subproject commit 4b9ff89770804f981385c79bcb6058baf3a743eb