Index: trunk/lib/regfi.c
===================================================================
--- trunk/lib/regfi.c	(revision 202)
+++ trunk/lib/regfi.c	(revision 203)
@@ -833,5 +833,7 @@
   }
   else if(buf[0] == 'l' && buf[1] == 'i')
+  {
     elem_size = sizeof(uint32_t);
+  }
   else if((buf[0] == 'l') && (buf[1] == 'f' || buf[1] == 'h'))
     elem_size = sizeof(REGFI_SUBKEY_LIST_ELEM);
@@ -973,8 +975,8 @@
  *
  ******************************************************************************/
-REGFI_SK_REC* regfi_parse_sk(REGFI_FILE* file, uint32_t offset, uint32_t max_size, 
+REGFI_SK* regfi_parse_sk(REGFI_FILE* file, uint32_t offset, uint32_t max_size, 
 			     bool strict)
 {
-  REGFI_SK_REC* ret_val = NULL;
+  REGFI_SK* ret_val = NULL;
   uint8_t* sec_desc_buf = NULL;
   uint32_t cell_length, length;
@@ -1000,5 +1002,5 @@
   }
 
-  ret_val = talloc(NULL, REGFI_SK_REC);
+  ret_val = talloc(NULL, REGFI_SK);
   if(ret_val == NULL)
     goto fail_locked;
@@ -1174,5 +1176,5 @@
 
 
-void regfi_interpret_valuename(REGFI_FILE* file, REGFI_VK_REC* vk, 
+void regfi_interpret_valuename(REGFI_FILE* file, REGFI_VK* vk, 
 			       REGFI_ENCODING output_encoding, bool strict)
 {
@@ -1224,8 +1226,8 @@
 /******************************************************************************
  ******************************************************************************/
-REGFI_VK_REC* regfi_load_value(REGFI_FILE* file, uint32_t offset, 
+REGFI_VK* regfi_load_value(REGFI_FILE* file, uint32_t offset, 
 			       REGFI_ENCODING output_encoding, bool strict)
 {
-  REGFI_VK_REC* ret_val = NULL;
+  REGFI_VK* ret_val = NULL;
   int32_t max_size;
 
@@ -1270,5 +1272,5 @@
 
 
-void regfi_interpret_keyname(REGFI_FILE* file, REGFI_NK_REC* nk, 
+void regfi_interpret_keyname(REGFI_FILE* file, REGFI_NK* nk, 
 			     REGFI_ENCODING output_encoding, bool strict)
 {
@@ -1319,8 +1321,8 @@
  *
  ******************************************************************************/
-REGFI_NK_REC* regfi_load_key(REGFI_FILE* file, uint32_t offset,
+REGFI_NK* regfi_load_key(REGFI_FILE* file, uint32_t offset,
 			     REGFI_ENCODING output_encoding, bool strict)
 {
-  REGFI_NK_REC* nk;
+  REGFI_NK* nk;
   uint32_t off;
   int32_t max_size;
@@ -1410,7 +1412,7 @@
 /******************************************************************************
  ******************************************************************************/
-const REGFI_SK_REC* regfi_load_sk(REGFI_FILE* file, uint32_t offset, bool strict)
-{
-  REGFI_SK_REC* ret_val = NULL;
+const REGFI_SK* regfi_load_sk(REGFI_FILE* file, uint32_t offset, bool strict)
+{
+  REGFI_SK* ret_val = NULL;
   int32_t max_size;
   void* failure_ptr = NULL;
@@ -1427,5 +1429,5 @@
 
   /* First look if we have already parsed it */
-  ret_val = (REGFI_SK_REC*)lru_cache_find(file->sk_cache, &offset, 4);
+  ret_val = (REGFI_SK*)lru_cache_find(file->sk_cache, &offset, 4);
 
   /* Bail out if we have previously cached a parse failure at this offset. */
@@ -1463,8 +1465,8 @@
 /******************************************************************************
  ******************************************************************************/
-REGFI_NK_REC* regfi_find_root_nk(REGFI_FILE* file, const REGFI_HBIN* hbin, 
+REGFI_NK* regfi_find_root_nk(REGFI_FILE* file, const REGFI_HBIN* hbin, 
 				 REGFI_ENCODING output_encoding)
 {
-  REGFI_NK_REC* nk = NULL;
+  REGFI_NK* nk = NULL;
   uint32_t cell_length;
   uint32_t cur_offset = hbin->file_off+REGFI_HBIN_HEADER_SIZE;
@@ -1576,10 +1578,10 @@
 
   /* Read file header */
-  if ((rb = regfi_parse_regf(file_cb, false)) == NULL) 
+  if ((rb = regfi_parse_regf(file_cb, false)) == NULL)
   {
     regfi_log_add(REGFI_LOG_ERROR, "Failed to read REGF block.");
     return NULL;
   }
-  rb->file_length = file_length;  
+  rb->file_length = file_length;
   rb->cb = file_cb;
 
@@ -1662,7 +1664,7 @@
  * rest of the file if that fails.
  ******************************************************************************/
-REGFI_NK_REC* regfi_rootkey(REGFI_FILE* file, REGFI_ENCODING output_encoding)
-{
-  REGFI_NK_REC* nk = NULL;
+REGFI_NK* regfi_rootkey(REGFI_FILE* file, REGFI_ENCODING output_encoding)
+{
+  REGFI_NK* nk = NULL;
   REGFI_HBIN* hbin;
   uint32_t root_offset, i, num_hbins;
@@ -1718,5 +1720,5 @@
 				   REGFI_ENCODING output_encoding)
 {
-  REGFI_NK_REC* root;
+  REGFI_NK* root;
   REGFI_ITERATOR* ret_val;
 
@@ -1773,5 +1775,5 @@
 bool regfi_iterator_down(REGFI_ITERATOR* i)
 {
-  REGFI_NK_REC* subkey;
+  REGFI_NK* subkey;
   REGFI_ITER_POSITION* pos;
 
@@ -1780,5 +1782,5 @@
     return false;
 
-  subkey = (REGFI_NK_REC*)regfi_iterator_cur_subkey(i);
+  subkey = (REGFI_NK*)regfi_iterator_cur_subkey(i);
   if(subkey == NULL)
   {
@@ -1840,5 +1842,5 @@
 bool regfi_iterator_find_subkey(REGFI_ITERATOR* i, const char* subkey_name)
 {
-  REGFI_NK_REC* subkey;
+  REGFI_NK* subkey;
   bool found = false;
   uint32_t old_subkey = i->cur_subkey;
@@ -1899,5 +1901,5 @@
 /******************************************************************************
  *****************************************************************************/
-const REGFI_NK_REC* regfi_iterator_cur_key(REGFI_ITERATOR* i)
+const REGFI_NK* regfi_iterator_cur_key(REGFI_ITERATOR* i)
 {
   return i->cur_key;
@@ -1907,5 +1909,5 @@
 /******************************************************************************
  *****************************************************************************/
-const REGFI_SK_REC* regfi_iterator_cur_sk(REGFI_ITERATOR* i)
+const REGFI_SK* regfi_iterator_cur_sk(REGFI_ITERATOR* i)
 {
   if(i->cur_key == NULL || i->cur_key->sk_off == REGFI_OFFSET_NONE)
@@ -1929,5 +1931,5 @@
 /******************************************************************************
  *****************************************************************************/
-const REGFI_NK_REC* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
+const REGFI_NK* regfi_iterator_cur_subkey(REGFI_ITERATOR* i)
 {
   uint32_t nk_offset;
@@ -1961,5 +1963,5 @@
 bool regfi_iterator_find_value(REGFI_ITERATOR* i, const char* value_name)
 {
-  const REGFI_VK_REC* cur;
+  const REGFI_VK* cur;
   bool found = false;
   uint32_t old_value = i->cur_value;
@@ -2007,7 +2009,7 @@
 /******************************************************************************
  *****************************************************************************/
-const REGFI_VK_REC* regfi_iterator_cur_value(REGFI_ITERATOR* i)
-{
-  REGFI_VK_REC* ret_val = NULL;
+const REGFI_VK* regfi_iterator_cur_value(REGFI_ITERATOR* i)
+{
+  REGFI_VK* ret_val = NULL;
   uint32_t voffset;
 
@@ -2037,5 +2039,5 @@
  *****************************************************************************/
 const REGFI_CLASSNAME* regfi_iterator_fetch_classname(REGFI_ITERATOR* i,
-						      const REGFI_NK_REC* key)
+						      const REGFI_NK* key)
 {
   REGFI_CLASSNAME* ret_val;
@@ -2101,5 +2103,5 @@
  *****************************************************************************/
 const REGFI_DATA* regfi_iterator_fetch_data(REGFI_ITERATOR* i, 
-					    const REGFI_VK_REC* value)
+					    const REGFI_VK* value)
 {
   REGFI_DATA* ret_val = NULL;
@@ -2565,13 +2567,13 @@
 /*******************************************************************
  *******************************************************************/
-REGFI_NK_REC* regfi_parse_nk(REGFI_FILE* file, uint32_t offset, 
-			     uint32_t max_size, bool strict)
+REGFI_NK* regfi_parse_nk(REGFI_FILE* file, uint32_t offset, 
+			 uint32_t max_size, bool strict)
 {
   uint8_t nk_header[REGFI_NK_MIN_LENGTH];
-  REGFI_NK_REC* ret_val;
+  REGFI_NK* ret_val;
   uint32_t length,cell_length;
   bool unalloc = false;
 
-  ret_val = talloc(NULL, REGFI_NK_REC);
+  ret_val = talloc(NULL, REGFI_NK);
   if(ret_val == NULL)
   {
@@ -2784,13 +2786,13 @@
 /******************************************************************************
 *******************************************************************************/
-REGFI_VK_REC* regfi_parse_vk(REGFI_FILE* file, uint32_t offset, 
+REGFI_VK* regfi_parse_vk(REGFI_FILE* file, uint32_t offset, 
 			     uint32_t max_size, bool strict)
 {
-  REGFI_VK_REC* ret_val;
+  REGFI_VK* ret_val;
   uint8_t vk_header[REGFI_VK_MIN_LENGTH];
   uint32_t raw_data_size, length, cell_length;
   bool unalloc = false;
 
-  ret_val = talloc(NULL, REGFI_VK_REC);
+  ret_val = talloc(NULL, REGFI_VK);
   if(ret_val == NULL)
     goto fail;
