libsframe: rename encoder to ectx for readability

Addressing (an old) review comment suggesting this housekeeping item.
Use consistent naming style in libsframe.  sframe_decoder_ctx objects
are named 'dctx', so use 'ectx' for sframe_encoder_ctx objects.

Make necessary changes in all the applicable declarations and definitions.

Reviewed-by: Jens Remus <jremus@linux.ibm.com>

include/sframe-api.h

@@ -244,73 +244,75 @@ extern sframe_encoder_ctx *
 sframe_encode (uint8_t ver, uint8_t flags, uint8_t abi_arch,
 	       int8_t fixed_fp_offset, int8_t fixed_ra_offset, int *errp);
 
-/* Free the encoder context.  */
+/* Free the encoder context ECTXP.  */
 extern void
-sframe_encoder_free (sframe_encoder_ctx **encoder);
+sframe_encoder_free (sframe_encoder_ctx **ectxp);
 
-/* Get the size of the SFrame header from the encoder ctx ENCODER.  */
+/* Get the size of the SFrame header from the encoder context ECTX.  */
 extern unsigned int
-sframe_encoder_get_hdr_size (sframe_encoder_ctx *encoder);
+sframe_encoder_get_hdr_size (sframe_encoder_ctx *ectx);
 
-/* Get the abi/arch info from the SFrame encoder context CTX.  */
+/* Get the SFrame abi/arch info from the encoder context ECTX.  */
 extern uint8_t
-sframe_encoder_get_abi_arch (sframe_encoder_ctx *encoder);
+sframe_encoder_get_abi_arch (sframe_encoder_ctx *ectx);
 
-/* Get the format version from the SFrame encoder context ENCODER.  */
+/* Get the SFrame format version from the encoder context ECTX.  */
 extern uint8_t
-sframe_encoder_get_version (sframe_encoder_ctx *encoder);
+sframe_encoder_get_version (sframe_encoder_ctx *ectx);
 
-/* Get the section flags from the SFrame encoder context ENCODER.  */
+/* Get the SFrame flags from the encoder context ECTX.  */
 extern uint8_t
-sframe_encoder_get_flags (sframe_encoder_ctx *encoder);
+sframe_encoder_get_flags (sframe_encoder_ctx *ectx);
 
 /* Get the offset of the sfde_func_start_address field (from the start of the
    on-disk layout of the SFrame section) of the FDE at FUNC_IDX in the encoder
-   context ENCODER.
+   context ECTX.
 
    If FUNC_IDX is more than the number of SFrame FDEs in the section, sets
    error code in ERRP, but returns the (hypothetical) offset.  This is useful
    for the linker when arranging input FDEs into the output section to be
    emitted.  */
 uint32_t
-sframe_encoder_get_offsetof_fde_start_addr (sframe_encoder_ctx *encoder,
+sframe_encoder_get_offsetof_fde_start_addr (sframe_encoder_ctx *ectx,
 					    uint32_t func_idx, int *errp);
 
-/* Return the number of function descriptor entries in the SFrame encoder
-   ENCODER.  */
+/* Return the number of SFrame function descriptor entries in the encoder
+   context ECTX.  */
 extern uint32_t
-sframe_encoder_get_num_fidx (sframe_encoder_ctx *encoder);
+sframe_encoder_get_num_fidx (sframe_encoder_ctx *ectx);
 
-/* Add an FRE to function at FUNC_IDX'th function descriptor index entry in
-   the encoder context.  */
+/* Add an SFrame FRE to function at FUNC_IDX'th function descriptor entry in
+   the encoder context ECTX.  */
 extern int
-sframe_encoder_add_fre (sframe_encoder_ctx *encoder,
+sframe_encoder_add_fre (sframe_encoder_ctx *ectx,
 			unsigned int func_idx,
 			sframe_frame_row_entry *frep);
 
-/* Add a new function descriptor entry with START_ADDR, FUNC_SIZE and NUM_FRES
-   to the encoder.  */
+/* Add a new SFrame function descriptor entry with START_ADDR, FUNC_SIZE and
+   FUNC_INFO to the encoder context ECTX.  */
 extern int
-sframe_encoder_add_funcdesc (sframe_encoder_ctx *encoder,
+sframe_encoder_add_funcdesc (sframe_encoder_ctx *ectx,
 			     int32_t start_addr,
 			     uint32_t func_size,
 			     unsigned char func_info,
 			     uint32_t num_fres);
 
-/* Add a new function descriptor entry with START_ADDR, FUNC_SIZE, FUNC_INFO
-   and REP_BLOCK_SIZE to the encoder.  */
+/* Add a new SFrame function descriptor entry with START_ADDR, FUNC_SIZE,
+   FUNC_INFO and REP_BLOCK_SIZE to the encoder context ECTX.  This API is valid
+   only for SFrame format version 2.  */
 extern int
-sframe_encoder_add_funcdesc_v2 (sframe_encoder_ctx *encoder,
+sframe_encoder_add_funcdesc_v2 (sframe_encoder_ctx *ectx,
 				int32_t start_addr,
 				uint32_t func_size,
 				unsigned char func_info,
 				uint8_t rep_block_size,
 				uint32_t num_fres);
 
-/* Serialize the contents of the encoder and return the buffer.  ENCODED_SIZE
-   is updated to the size of the buffer.  Sets ERRP if failure.  */
+/* Serialize the contents of the encoder context ECTX and return the buffer.
+   ENCODED_SIZE is updated to the size of the buffer.
+   Sets ERRP if failure.  */
 extern char  *
-sframe_encoder_write (sframe_encoder_ctx *encoder,
+sframe_encoder_write (sframe_encoder_ctx *ectx,
 		      size_t *encoded_size, int *errp);
 
 #ifdef	__cplusplus

libsframe/sframe.c

@@ -1494,25 +1494,25 @@ sframe_decoder_get_fre (sframe_decoder_ctx *ctx,
 
 /* SFrame Encoder.  */
 
-/* Get a reference to the ENCODER's SFrame header.  */
+/* Get a reference to the SFrame header, given the encoder context ECTX.  */
 
 static sframe_header *
-sframe_encoder_get_header (sframe_encoder_ctx *encoder)
+sframe_encoder_get_header (sframe_encoder_ctx *ectx)
 {
   sframe_header *hp = NULL;
-  if (encoder)
-    hp = &encoder->sfe_header;
+  if (ectx)
+    hp = &ectx->sfe_header;
   return hp;
 }
 
 static sframe_func_desc_entry *
-sframe_encoder_get_funcdesc_at_index (sframe_encoder_ctx *encoder,
+sframe_encoder_get_funcdesc_at_index (sframe_encoder_ctx *ectx,
 				      uint32_t func_idx)
 {
   sframe_func_desc_entry *fde = NULL;
-  if (func_idx < sframe_encoder_get_num_fidx (encoder))
+  if (func_idx < sframe_encoder_get_num_fidx (ectx))
     {
-      sf_fde_tbl *func_tbl = encoder->sfe_funcdesc;
+      sf_fde_tbl *func_tbl = ectx->sfe_funcdesc;
       fde = func_tbl->entry + func_idx;
     }
   return fde;
@@ -1527,18 +1527,18 @@ sframe_encode (uint8_t ver, uint8_t flags, uint8_t abi_arch,
 	       int8_t fixed_fp_offset, int8_t fixed_ra_offset, int *errp)
 {
   sframe_header *hp;
-  sframe_encoder_ctx *encoder;
+  sframe_encoder_ctx *ectx;
 
   if (ver != SFRAME_VERSION)
     return sframe_ret_set_errno (errp, SFRAME_ERR_VERSION_INVAL);
 
-  if ((encoder = malloc (sizeof (sframe_encoder_ctx))) == NULL)
+  if ((ectx = malloc (sizeof (sframe_encoder_ctx))) == NULL)
     return sframe_ret_set_errno (errp, SFRAME_ERR_NOMEM);
 
-  memset (encoder, 0, sizeof (sframe_encoder_ctx));
+  memset (ectx, 0, sizeof (sframe_encoder_ctx));
 
   /* Get the SFrame header and update it.  */
-  hp = sframe_encoder_get_header (encoder);
+  hp = sframe_encoder_get_header (ectx);
   hp->sfh_preamble.sfp_version = ver;
   hp->sfh_preamble.sfp_magic = SFRAME_MAGIC;
   hp->sfh_preamble.sfp_flags = flags;
@@ -1553,17 +1553,17 @@ sframe_encode (uint8_t ver, uint8_t flags, uint8_t abi_arch,
   hp->sfh_cfa_fixed_fp_offset = fixed_fp_offset;
   hp->sfh_cfa_fixed_ra_offset = fixed_ra_offset;
 
-  return encoder;
+  return ectx;
 }
 
-/* Free the encoder context.  */
+/* Free the encoder context ECTXP.  */
 
 void
-sframe_encoder_free (sframe_encoder_ctx **encoder)
+sframe_encoder_free (sframe_encoder_ctx **ectxp)
 {
-  if (encoder != NULL)
+  if (ectxp != NULL)
     {
-      sframe_encoder_ctx *ectx = *encoder;
+      sframe_encoder_ctx *ectx = *ectxp;
       if (ectx == NULL)
 	return;
 
@@ -1583,58 +1583,58 @@ sframe_encoder_free (sframe_encoder_ctx **encoder)
 	  ectx->sfe_data = NULL;
 	}
 
-      free (*encoder);
-      *encoder = NULL;
+      free (*ectxp);
+      *ectxp = NULL;
     }
 }
 
-/* Get the size of the SFrame header from the encoder ctx ENCODER.  */
+/* Get the size of the SFrame header from the encoder context ECTX.  */
 
 unsigned int
-sframe_encoder_get_hdr_size (sframe_encoder_ctx *encoder)
+sframe_encoder_get_hdr_size (sframe_encoder_ctx *ectx)
 {
-  const sframe_header *ehp = sframe_encoder_get_header (encoder);
+  const sframe_header *ehp = sframe_encoder_get_header (ectx);
   return sframe_get_hdr_size (ehp);
 }
 
-/* Get the abi/arch info from the SFrame encoder context ENCODER.  */
+/* Get the SFrame abi/arch info from the encoder context ECTX.  */
 
 uint8_t
-sframe_encoder_get_abi_arch (sframe_encoder_ctx *encoder)
+sframe_encoder_get_abi_arch (sframe_encoder_ctx *ectx)
 {
   uint8_t abi_arch = 0;
-  const sframe_header *ehp = sframe_encoder_get_header (encoder);
+  const sframe_header *ehp = sframe_encoder_get_header (ectx);
   if (ehp)
     abi_arch = ehp->sfh_abi_arch;
   return abi_arch;
 }
 
-/* Get the format version from the SFrame encoder context ENCODER.  */
+/* Get the SFrame format version from the encoder context ECTX.  */
 
 uint8_t
-sframe_encoder_get_version (sframe_encoder_ctx *encoder)
+sframe_encoder_get_version (sframe_encoder_ctx *ectx)
 {
-  const sframe_header *ehp = sframe_encoder_get_header (encoder);
+  const sframe_header *ehp = sframe_encoder_get_header (ectx);
   return ehp->sfh_preamble.sfp_version;
 }
 
-/* Get the section flags from the SFrame encoder context ENCODER.  */
+/* Get the SFrame flags from the encoder context ECTX.  */
 
 uint8_t
-sframe_encoder_get_flags (sframe_encoder_ctx *encoder)
+sframe_encoder_get_flags (sframe_encoder_ctx *ectx)
 {
-  const sframe_header *ehp = sframe_encoder_get_header (encoder);
+  const sframe_header *ehp = sframe_encoder_get_header (ectx);
   return ehp->sfh_preamble.sfp_flags;
 }
 
-/* Return the number of function descriptor entries in the SFrame encoder
-   ENCODER.  */
+/* Return the number of SFrame function descriptor entries in the encoder
+   context ECTX.  */
 
 uint32_t
-sframe_encoder_get_num_fidx (sframe_encoder_ctx *encoder)
+sframe_encoder_get_num_fidx (sframe_encoder_ctx *ectx)
 {
   uint32_t num_fdes = 0;
-  const sframe_header *ehp = sframe_encoder_get_header (encoder);
+  const sframe_header *ehp = sframe_encoder_get_header (ectx);
   if (ehp)
     num_fdes = ehp->sfh_num_fdes;
   return num_fdes;
@@ -1642,7 +1642,7 @@ sframe_encoder_get_num_fidx (sframe_encoder_ctx *encoder)
 
 /* Get the offset of the sfde_func_start_address field (from the start of the
    on-disk layout of the SFrame section) of the FDE at FUNC_IDX in the encoder
-   context ENCODER.
+   context ECTX.
 
    If FUNC_IDX is more than the number of SFrame FDEs in the section, sets
    error code in ERRP, but returns the (hypothetical) offset.  This is useful
@@ -1650,24 +1650,24 @@ sframe_encoder_get_num_fidx (sframe_encoder_ctx *encoder)
    emitted.  */
 
 uint32_t
-sframe_encoder_get_offsetof_fde_start_addr (sframe_encoder_ctx *encoder,
+sframe_encoder_get_offsetof_fde_start_addr (sframe_encoder_ctx *ectx,
 					    uint32_t func_idx, int *errp)
 {
-  if (func_idx >= sframe_encoder_get_num_fidx (encoder))
+  if (func_idx >= sframe_encoder_get_num_fidx (ectx))
     sframe_ret_set_errno (errp, SFRAME_ERR_FDE_INVAL);
   else if (errp)
     *errp = 0;
 
-  return (sframe_encoder_get_hdr_size (encoder)
+  return (sframe_encoder_get_hdr_size (ectx)
 	  + func_idx * sizeof (sframe_func_desc_entry)
 	  + offsetof (sframe_func_desc_entry, sfde_func_start_address));
 }
 
-/* Add an FRE to function at FUNC_IDX'th function descriptor entry in
-   the encoder context.  */
+/* Add an SFrame FRE to function at FUNC_IDX'th function descriptor entry in
+   the encoder context ECTX.  */
 
 int
-sframe_encoder_add_fre (sframe_encoder_ctx *encoder,
+sframe_encoder_add_fre (sframe_encoder_ctx *ectx,
 			unsigned int func_idx,
 			sframe_frame_row_entry *frep)
 {
@@ -1679,19 +1679,19 @@ sframe_encoder_add_fre (sframe_encoder_ctx *encoder,
   size_t fre_tbl_sz;
   int err = 0;
 
-  if (encoder == NULL || frep == NULL)
+  if (ectx == NULL || frep == NULL)
     return sframe_set_errno (&err, SFRAME_ERR_INVAL);
   if (!sframe_fre_sanity_check_p (frep))
     return sframe_set_errno (&err, SFRAME_ERR_FRE_INVAL);
 
   /* Use func_idx to gather the function descriptor entry.  */
-  fdep = sframe_encoder_get_funcdesc_at_index (encoder, func_idx);
+  fdep = sframe_encoder_get_funcdesc_at_index (ectx, func_idx);
 
   if (fdep == NULL)
     return sframe_set_errno (&err, SFRAME_ERR_FDE_NOTFOUND);
 
   fre_type = sframe_get_fre_type (fdep);
-  sf_fre_tbl *fre_tbl = encoder->sfe_fres;
+  sf_fre_tbl *fre_tbl = ectx->sfe_fres;
 
   if (fre_tbl == NULL)
     {
@@ -1743,10 +1743,10 @@ sframe_encoder_add_fre (sframe_encoder_ctx *encoder,
   esz = sframe_fre_entry_size (frep, fre_type);
   fre_tbl->count++;
 
-  encoder->sfe_fres = fre_tbl;
-  encoder->sfe_fre_nbytes += esz;
+  ectx->sfe_fres = fre_tbl;
+  ectx->sfe_fre_nbytes += esz;
 
-  ehp = sframe_encoder_get_header (encoder);
+  ehp = sframe_encoder_get_header (ectx);
   ehp->sfh_num_fres = fre_tbl->count;
 
   /* Update the value of the number of FREs for the function.  */
@@ -1757,16 +1757,16 @@ sframe_encoder_add_fre (sframe_encoder_ctx *encoder,
 bad:
   if (fre_tbl != NULL)
     free (fre_tbl);
-  encoder->sfe_fres = NULL;
-  encoder->sfe_fre_nbytes = 0;
+  ectx->sfe_fres = NULL;
+  ectx->sfe_fre_nbytes = 0;
   return -1;
 }
 
-/* Add a new function descriptor entry with START_ADDR, FUNC_SIZE and NUM_FRES
-   to the encoder.  */
+/* Add a new SFrame function descriptor entry with START_ADDR, FUNC_SIZE and
+   FUNC_INFO to the encoder context ECTX.  */
 
 int
-sframe_encoder_add_funcdesc (sframe_encoder_ctx *encoder,
+sframe_encoder_add_funcdesc (sframe_encoder_ctx *ectx,
 			     int32_t start_addr,
 			     uint32_t func_size,
 			     unsigned char func_info,
@@ -1778,11 +1778,11 @@ sframe_encoder_add_funcdesc (sframe_encoder_ctx *encoder,
   int err = 0;
 
   /* FIXME book-keep num_fres for error checking.  */
-  if (encoder == NULL)
+  if (ectx == NULL)
     return sframe_set_errno (&err, SFRAME_ERR_INVAL);
 
-  fd_info = encoder->sfe_funcdesc;
-  ehp = sframe_encoder_get_header (encoder);
+  fd_info = ectx->sfe_funcdesc;
+  ehp = sframe_encoder_get_header (ectx);
 
   if (fd_info == NULL)
     {
@@ -1819,7 +1819,7 @@ sframe_encoder_add_funcdesc (sframe_encoder_ctx *encoder,
      sframe_encoder_add_fre.  */
   fd_info->entry[fd_info->count].sfde_func_size = func_size;
   fd_info->entry[fd_info->count].sfde_func_start_fre_off
-    = encoder->sfe_fre_nbytes;
+    = ectx->sfe_fre_nbytes;
 #if 0
   // Linker optimization test code cleanup later ibhagat TODO FIXME
   uint32_t fre_type = sframe_calc_fre_type (func_size);
@@ -1829,25 +1829,24 @@ sframe_encoder_add_funcdesc (sframe_encoder_ctx *encoder,
 #endif
   fd_info->entry[fd_info->count].sfde_func_info = func_info;
   fd_info->count++;
-  encoder->sfe_funcdesc = fd_info;
+  ectx->sfe_funcdesc = fd_info;
   ehp->sfh_num_fdes++;
   return 0;
 
 bad:
   if (fd_info != NULL)
     free (fd_info);
-  encoder->sfe_funcdesc = NULL;
+  ectx->sfe_funcdesc = NULL;
   ehp->sfh_num_fdes = 0;
   return -1;
 }
 
-/* Add a new function descriptor entry with START_ADDR, FUNC_SIZE, FUNC_INFO
-   and REP_BLOCK_SIZE to the encoder.
-
-   This API is valid only for SFrame format version 2.  */
+/* Add a new SFrame function descriptor entry with START_ADDR, FUNC_SIZE,
+   FUNC_INFO and REP_BLOCK_SIZE to the encoder context ECTX.  This API is valid
+   only for SFrame format version 2.  */
 
 int
-sframe_encoder_add_funcdesc_v2 (sframe_encoder_ctx *encoder,
+sframe_encoder_add_funcdesc_v2 (sframe_encoder_ctx *ectx,
 				int32_t start_addr,
 				uint32_t func_size,
 				unsigned char func_info,
@@ -1857,28 +1856,27 @@ sframe_encoder_add_funcdesc_v2 (sframe_encoder_ctx *encoder,
   sf_fde_tbl *fd_info;
   int err;
 
-  if (encoder == NULL
-      || sframe_encoder_get_version (encoder) == SFRAME_VERSION_1)
+  if (ectx == NULL || sframe_encoder_get_version (ectx) == SFRAME_VERSION_1)
     return sframe_set_errno (&err, SFRAME_ERR_INVAL);
 
-  err = sframe_encoder_add_funcdesc (encoder, start_addr, func_size, func_info,
+  err = sframe_encoder_add_funcdesc (ectx, start_addr, func_size, func_info,
 				     num_fres);
   if (err)
     return SFRAME_ERR;
 
-  fd_info = encoder->sfe_funcdesc;
+  fd_info = ectx->sfe_funcdesc;
   fd_info->entry[fd_info->count-1].sfde_func_rep_size = rep_block_size;
 
   return 0;
 }
 
 static int
-sframe_sort_funcdesc (sframe_encoder_ctx *encoder)
+sframe_sort_funcdesc (sframe_encoder_ctx *ectx)
 {
-  sframe_header *ehp = sframe_encoder_get_header (encoder);
+  sframe_header *ehp = sframe_encoder_get_header (ectx);
 
   /* Sort and write out the FDE table.  */
-  sf_fde_tbl *fd_info = encoder->sfe_funcdesc;
+  sf_fde_tbl *fd_info = ectx->sfe_funcdesc;
   if (fd_info)
     {
       /* The new encoding of sfde_func_start_address means the distances are
@@ -1888,14 +1886,14 @@ sframe_sort_funcdesc (sframe_encoder_ctx *encoder)
 
       for (unsigned int i = 0; i < fd_info->count; i++)
 	fd_info->entry[i].sfde_func_start_address
-	  += sframe_encoder_get_offsetof_fde_start_addr (encoder, i, NULL);
+	  += sframe_encoder_get_offsetof_fde_start_addr (ectx, i, NULL);
 
       qsort (fd_info->entry, fd_info->count,
 	     sizeof (sframe_func_desc_entry), fde_func);
 
       for (unsigned int i = 0; i < fd_info->count; i++)
 	fd_info->entry[i].sfde_func_start_address
-	  -= sframe_encoder_get_offsetof_fde_start_addr (encoder, i, NULL);
+	  -= sframe_encoder_get_offsetof_fde_start_addr (ectx, i, NULL);
 
       /* Update preamble's flags.  */
       ehp->sfh_preamble.sfp_flags |= SFRAME_F_FDE_SORTED;
@@ -1985,10 +1983,11 @@ sframe_encoder_write_fre (char *contents, sframe_frame_row_entry *frep,
 }
 
 /* Serialize the core contents of the SFrame section and write out to the
-   output buffer held in the ENCODER.  Return SFRAME_ERR if failure.  */
+   output buffer held in the encoder context ECTX.  Return SFRAME_ERR if
+   failure.  */
 
 static int
-sframe_encoder_write_sframe (sframe_encoder_ctx *encoder)
+sframe_encoder_write_sframe (sframe_encoder_ctx *ectx)
 {
   char *contents;
   size_t buf_size;
@@ -2007,15 +2006,15 @@ sframe_encoder_write_sframe (sframe_encoder_ctx *encoder)
   uint32_t fre_type;
   int err = 0;
 
-  contents = encoder->sfe_data;
-  buf_size = encoder->sfe_data_size;
-  num_fdes = sframe_encoder_get_num_fidx (encoder);
+  contents = ectx->sfe_data;
+  buf_size = ectx->sfe_data_size;
+  num_fdes = sframe_encoder_get_num_fidx (ectx);
   all_fdes_size = num_fdes * sizeof (sframe_func_desc_entry);
-  ehp = sframe_encoder_get_header (encoder);
+  ehp = sframe_encoder_get_header (ectx);
   hdr_size = sframe_get_hdr_size (ehp);
 
-  fd_info = encoder->sfe_funcdesc;
-  fr_info = encoder->sfe_fres;
+  fd_info = ectx->sfe_funcdesc;
+  fr_info = ectx->sfe_fres;
 
   /* Sanity checks:
      - buffers must be malloc'd by the caller.  */
@@ -2065,19 +2064,19 @@ sframe_encoder_write_sframe (sframe_encoder_ctx *encoder)
 
   sframe_assert (fre_size == ehp->sfh_fre_len);
   sframe_assert (global == ehp->sfh_num_fres);
-  sframe_assert ((size_t)(contents - encoder->sfe_data) == buf_size);
+  sframe_assert ((size_t)(contents - ectx->sfe_data) == buf_size);
 
   /* Sort the FDE table */
-  sframe_sort_funcdesc (encoder);
+  sframe_sort_funcdesc (ectx);
 
   /* Sanity checks:
      - the FDE section must have been sorted by now on the start address
      of each function.  */
-  if (!(sframe_encoder_get_flags (encoder) & SFRAME_F_FDE_SORTED)
+  if (!(sframe_encoder_get_flags (ectx) & SFRAME_F_FDE_SORTED)
       || (fd_info == NULL))
     return sframe_set_errno (&err, SFRAME_ERR_FDE_INVAL);
 
-  contents = encoder->sfe_data;
+  contents = ectx->sfe_data;
   /* Write out the SFrame header.  The SFrame header in the encoder
      object has already been updated with correct offsets by the caller.  */
   memcpy (contents, ehp, hdr_size);
@@ -2090,11 +2089,12 @@ sframe_encoder_write_sframe (sframe_encoder_ctx *encoder)
   return 0;
 }
 
-/* Serialize the contents of the encoder and return the buffer.  ENCODED_SIZE
-   is updated to the size of the buffer.  */
+/* Serialize the contents of the encoder context ECTX and return the buffer.
+   ENCODED_SIZE is updated to the size of the buffer.
+   Sets ERRP if failure.  */
 
 char *
-sframe_encoder_write (sframe_encoder_ctx *encoder,
+sframe_encoder_write (sframe_encoder_ctx *ectx,
 		      size_t *encoded_size, int *errp)
 {
   sframe_header *ehp;
@@ -2103,29 +2103,28 @@ sframe_encoder_write (sframe_encoder_ctx *encoder,
 
   /* Initialize the encoded_size to zero.  This makes it simpler to just
      return from the function in case of failure.  Free'ing up of
-     encoder->sfe_data is the responsibility of the caller.  */
+     ectx->sfe_data is the responsibility of the caller.  */
   *encoded_size = 0;
 
-  if (encoder == NULL || encoded_size == NULL || errp == NULL)
+  if (ectx == NULL || encoded_size == NULL || errp == NULL)
     return sframe_ret_set_errno (errp, SFRAME_ERR_INVAL);
 
-  ehp = sframe_encoder_get_header (encoder);
+  ehp = sframe_encoder_get_header (ectx);
   hdrsize = sframe_get_hdr_size (ehp);
-  fsz = sframe_encoder_get_num_fidx (encoder)
-    * sizeof (sframe_func_desc_entry);
-  fresz = encoder->sfe_fre_nbytes;
+  fsz = sframe_encoder_get_num_fidx (ectx) * sizeof (sframe_func_desc_entry);
+  fresz = ectx->sfe_fre_nbytes;
 
   /* Encoder writes out data in the latest SFrame format version.  */
-  if (sframe_encoder_get_version (encoder) != SFRAME_VERSION)
+  if (sframe_encoder_get_version (ectx) != SFRAME_VERSION)
     return sframe_ret_set_errno (errp, SFRAME_ERR_VERSION_INVAL);
 
   /* The total size of buffer is the sum of header, SFrame Function Descriptor
      Entries section and the FRE section.  */
   bufsize = hdrsize + fsz + fresz;
-  encoder->sfe_data = (char *) malloc (bufsize);
-  if (encoder->sfe_data == NULL)
+  ectx->sfe_data = (char *) malloc (bufsize);
+  if (ectx->sfe_data == NULL)
     return sframe_ret_set_errno (errp, SFRAME_ERR_NOMEM);
-  encoder->sfe_data_size = bufsize;
+  ectx->sfe_data_size = bufsize;
 
   /* Update the information in the SFrame header.  */
   /* SFrame FDE section follows immediately after the header.  */
@@ -2137,18 +2136,18 @@ sframe_encoder_write (sframe_encoder_ctx *encoder,
   foreign_endian = need_swapping (ehp->sfh_abi_arch);
 
   /* Write out the FDE Index and the FRE table in the sfe_data. */
-  if (sframe_encoder_write_sframe (encoder))
+  if (sframe_encoder_write_sframe (ectx))
     return sframe_ret_set_errno (errp, SFRAME_ERR_BUF_INVAL);
 
   /* Endian flip the contents if necessary.  */
   if (foreign_endian)
     {
-      if (flip_sframe (encoder->sfe_data, bufsize, 1))
+      if (flip_sframe (ectx->sfe_data, bufsize, 1))
 	return sframe_ret_set_errno (errp, SFRAME_ERR_BUF_INVAL);
-      if (flip_header (encoder->sfe_data, SFRAME_VERSION))
+      if (flip_header (ectx->sfe_data, SFRAME_VERSION))
 	return sframe_ret_set_errno (errp, SFRAME_ERR_BUF_INVAL);
     }
 
   *encoded_size = bufsize;
-  return encoder->sfe_data;
+  return ectx->sfe_data;
 }