--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ccd/t30_ident.c	Thu Jun 09 00:02:41 2016 +0000
@@ -0,0 +1,429 @@
+/* 
++----------------------------------------------------------------------------- 
+|  Project :  
+|  Modul   : t30_ident.c
++----------------------------------------------------------------------------- 
+|  Copyright 2002 Texas Instruments Berlin, AG 
+|                 All rights reserved. 
+| 
+|                 This file is confidential and a trade secret of Texas 
+|                 Instruments Berlin, AG 
+|                 The receipt of or possession of this file does not convey 
+|                 any rights to reproduce or disclose its contents or to 
+|                 manufacture, use, or sell anything it may describe, in 
+|                 whole, or in part, without the specific written consent of 
+|                 Texas Instruments Berlin, AG. 
++----------------------------------------------------------------------------- 
+|  Purpose :  Definition of encoding and decoding functions for T30_IDENT elements 
++----------------------------------------------------------------------------- 
+*/ 
+
+
+/*
+ * standard definitions like GLOBAL, UCHAR, ERROR etc.
+ */
+#include "typedefs.h"
+#include "header.h"
+
+/*
+ * Prototypes of ccd (USE_DRIVER EQ undef) for prototypes only
+ * look at ccdapi.h
+ */
+#undef USE_DRIVER
+#include "ccdapi.h"
+
+/*
+ * Types and functions for bit access and manipulation
+ */
+#include "ccd_globs.h"
+#include "bitfun.h"
+
+/*
+ * Prototypes of ccd internal functions
+ */
+#include "ccd.h"
+
+/*
+ * Declaration of coder/decoder tables
+ */
+#include "ccdtable.h"
+#include "ccddata.h"
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : CCD (6144)                MODULE  : CCD                  |
+| STATE   : code                      ROUTINE : cdc_t30_ident_decode |
++--------------------------------------------------------------------+
+
+  PURPOSE :
+
+*/
+
+SHORT cdc_t30_ident_decode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs)
+{
+  ULONG               max_rep;
+  BOOL                is_variable;
+  UBYTE               digBuffer[30], bit, digT30, digASCII;
+  UBYTE               *addr_c_xxx;
+  int                 i, repeat;
+  ULONG               cix_ref, num_prolog_steps, prolog_step_ref;
+  register UBYTE      *ident;
+
+#ifdef DEBUG_CCD
+  #ifndef CCD_SYMBOLS
+  TRACE_CCD (globs, "cdc_t30_ident_decode()");
+  #else
+  TRACE_CCD (globs, "cdc_t30_ident_decode() %s", ccddata_get_alias((USHORT) e_ref, 1));
+  #endif
+#endif
+
+  cix_ref = melem[e_ref].calcIdxRef;
+  num_prolog_steps = calcidx[cix_ref].numPrologSteps;
+  prolog_step_ref  = calcidx[cix_ref].prologStepRef;
+
+  /*
+   * if this element is conditional, check the condition
+   */
+  if (calcidx[cix_ref].numCondCalcs NEQ 0
+  AND ! ccd_conditionOK (e_ref, globs))
+    return 1;
+
+  /*
+   * if this element have a defined Prolog
+   * we have to process it before decoding the bitstream
+   */
+  if (num_prolog_steps)
+  {
+    ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
+  }
+  
+  /*
+   * if this element is repeatable, and the number of
+   * repeats depends on another element, calculate the repeater
+   */
+
+  if (melem[e_ref].repType NEQ ' ')
+  {
+    ULONG rep; 
+    is_variable = ccd_calculateRep (e_ref, &rep, &max_rep, globs);
+    repeat = rep;
+  }
+  else
+  {
+    repeat = 1;
+    is_variable = FALSE;
+  }
+  
+  /*
+   * setup the offset into the C-structure for this element
+   */
+  globs->pstructOffs = melem[e_ref].structOffs;
+
+  if (melem[e_ref].optional)
+  {
+    /*
+     * for optional elements set the valid-flag
+     */
+    globs->pstruct[globs->pstructOffs++] = (UBYTE) TRUE;
+  }
+
+
+  if (is_variable)
+  {
+    /*
+     * for variable sized elements store the min-value
+     * as counter into the C-Structure (c_xxx).
+     */
+    addr_c_xxx = (UBYTE *) (globs->pstruct + globs->pstructOffs++);
+    if (max_rep > 255)
+      globs->pstructOffs++;
+  }
+  else
+    addr_c_xxx = NULL;
+
+  /*
+   * calculate the address of the Most Significant Digit 
+   * of the T30_IDENT element in the C-struct
+   */
+  ident = (UBYTE *) (globs->pstruct + globs->pstructOffs);
+
+  
+  /*
+   * now read 'repeat' T30_IDENT digits and convert them
+   * into ASCII.
+   */
+  i=0;
+
+  while (!bf_endOfBitstream(globs) AND i<repeat)
+  {
+    digT30 = bf_decodeByteNumber (8, globs);
+#ifdef DEBUG_CCD
+    TRACE_CCD (globs, "T30 digit (%X) read", digT30);
+#endif
+    /*
+     * conversion T30->ASCII
+     * reverse the bitorder of each byte
+     */
+    digASCII = 0;
+
+    for (bit = 0; bit < 8; bit++)
+    {
+      digASCII <<= 1;
+      digASCII |= (digT30 & 0x01);
+      digT30   >>= 1;
+    }
+
+    digBuffer[i] = digASCII;
+#ifdef DEBUG_CCD
+    TRACE_CCD (globs, "  converted to %X = %c", digBuffer[i], digBuffer[i]);
+#endif
+    i++;
+  }
+
+  /*
+   * eleminate leading spaces
+   */
+  while (i > 0 AND digBuffer[i-1] EQ ' ')
+  {
+#ifdef DEBUG_CCD
+    TRACE_CCD (globs, "eliminating leading space");
+#endif
+    i--;
+  }
+
+  repeat = i;
+
+
+  if (addr_c_xxx NEQ NULL)
+  {
+    /*
+     * store the number of digits into the 
+     * c_xxx variable if there is one.
+     */
+    if (max_rep > 65535)
+    {
+      ULONG *addr_c_xxx_u32;
+      addr_c_xxx_u32 = (ULONG *)addr_c_xxx;
+      *addr_c_xxx_u32 = (ULONG) repeat;
+#ifdef DEBUG_CCD
+      TRACE_CCD (globs, "storing %d into counter var at (%lx)",
+               repeat, addr_c_xxx_u32);
+#endif
+    }
+    else if (max_rep > 255)
+    {
+      USHORT *addr_c_xxx_u16;
+      addr_c_xxx_u16 = (USHORT *)addr_c_xxx;
+      *addr_c_xxx_u16 = (USHORT) repeat;
+#ifdef DEBUG_CCD
+      TRACE_CCD (globs, "storing %d into counter var at (%lx)",
+               repeat, addr_c_xxx_u16);
+#endif
+    }
+    else
+    {
+      *addr_c_xxx = (UBYTE) repeat;
+#ifdef DEBUG_CCD
+      TRACE_CCD (globs, "storing %d into counter var at (%lx)",
+               repeat,
+               addr_c_xxx);
+#endif
+    }
+  }
+
+  /*
+   * store the digits in reverse order
+   * into the C-Structure variable
+   */
+#ifdef DEBUG_CCD
+  TRACE_CCD (globs, "storing %d digits into cstruct at (%lx)",
+             repeat,
+             ident);
+#endif
+
+  for (i=0; i<repeat; i++)
+    ident[i] = digBuffer[(repeat-1)-i];
+
+  return 1;
+}
+#endif /* !RUN_INT_RAM */
+
+#ifndef RUN_INT_RAM
+/*
++--------------------------------------------------------------------+
+| PROJECT : CCD (6144)                MODULE  : CCD                  |
+| STATE   : code                      ROUTINE : cdc_t30_ident_encode |
++--------------------------------------------------------------------+
+
+  PURPOSE : 
+
+*/
+
+
+SHORT cdc_t30_ident_encode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs)
+{
+  ULONG               repeat, max_rep;
+  UBYTE               digBuffer[30], bit, digT30, digASCII;
+  ULONG               i;
+  ULONG               cix_ref, num_prolog_steps, prolog_step_ref;
+  register UBYTE     *ident;
+
+#ifdef DEBUG_CCD
+  #ifndef CCD_SYMBOLS
+  TRACE_CCD (globs, "cdc_t30_ident_encode()");
+  #else
+  TRACE_CCD (globs, "cdc_t30_ident_encode() %s", ccddata_get_alias((USHORT) e_ref, 1));
+  #endif
+#endif
+
+  cix_ref = melem[e_ref].calcIdxRef;
+  num_prolog_steps = calcidx[cix_ref].numPrologSteps;
+  prolog_step_ref  = calcidx[cix_ref].prologStepRef;
+
+  /*
+   * if this element is conditional, check the condition
+   */
+  if (calcidx[cix_ref].numCondCalcs NEQ 0
+  AND ! ccd_conditionOK (e_ref, globs))
+    return 1;
+
+  /*
+   * if this element have a defined Prolog
+   * we have to process it before encoding
+   */
+  if (num_prolog_steps)
+  {
+    ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
+  }
+  
+  /*
+   * setup the offset into the C-structure for this element
+   */
+  globs->pstructOffs = melem[e_ref].structOffs;
+
+  if (melem[e_ref].optional)
+  {
+    /*
+     * for optional elements check the valid-flag
+     */
+    if (globs->pstruct[globs->pstructOffs++] == FALSE)
+    {
+      return 1;
+    }
+#ifdef DEBUG_CCD
+    else if (globs->pstruct [melem[e_ref].structOffs] != TRUE)
+    {
+      TRACE_CCD (globs, "Ambiguous value for valid flag!\n...assumed 1 for ccdID=%d",
+                 e_ref);
+    }
+#endif
+  }
+
+  /* 
+   * if this element is repeatable, and the number of
+   * repeats depends on another element, calculate the repeater
+   */
+  if (melem[e_ref].repType EQ 'v' OR melem[e_ref].repType EQ 'i')
+  {
+    /*
+     * for variable sized elements read the amount
+     * of repeats out of the C-Structure (c_xxx).
+     * If the number of repeats given by the C-Structure 
+     * exceeds the allowed value (maxRepeat) CCD gives a warning!
+     */
+    if (melem[e_ref].maxRepeat > 255)
+    {
+      ULONG count = (ULONG) (* (USHORT *)(globs->pstruct + globs->pstructOffs++));
+      repeat = MINIMUM (count, (ULONG) melem[e_ref].maxRepeat);
+      if (repeat < count) 
+        ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
+                         (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+    }
+    else
+    {
+      repeat = (ULONG) MINIMUM (globs->pstruct[globs->pstructOffs], 
+                                melem[e_ref].maxRepeat);
+      if ( repeat < (ULONG) (globs->pstruct[globs->pstructOffs]) )
+        ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, 
+                         (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
+    }
+    globs->pstructOffs++;
+    max_rep = (ULONG) melem[e_ref].maxRepeat;
+  }
+  else
+    if (melem[e_ref].repType EQ 'c')
+    {
+      repeat = (ULONG) melem[e_ref].maxRepeat;
+      max_rep = (ULONG) melem[e_ref].maxRepeat;
+    }
+    else
+    {
+      repeat = 1; 
+      max_rep = 1;
+    }
+
+  /* 
+   * setup the read pointer to the byte array that contain
+   * the ident number.
+   */
+  ident = (UBYTE *) (globs->pstruct + globs->pstructOffs);
+
+  /*
+   * read the digits in reverse order out of the C-Structure variable.
+   * (filled up with blanks to the maxRepeat)
+   */
+
+  i=0;
+
+  while (i < max_rep)
+  {
+    if (i < repeat)
+      digBuffer[i] = ident[(repeat-1)-i];
+    else
+    {
+#ifdef DEBUG_CCD
+      TRACE_CCD (globs, "appending space char");
+#endif
+      digBuffer[i] = ' ';
+    }
+    i++;
+  }
+
+  /*
+   * now read 'repeat' T30_IDENT digits and convert them
+   * into ASCII.
+   */
+  i=0;
+
+  while (i < max_rep)
+  {
+    digASCII = digBuffer[i];
+
+#ifdef DEBUG_CCD
+    TRACE_CCD (globs, "ASCII digit (%X) = %c ", (USHORT) digASCII, digASCII);
+#endif
+    /*
+     * conversion ASCII->T30
+     * reverse the bitorder of each byte
+     */
+    digT30 = 0;
+
+    for (bit = 0; bit < 8; bit++)
+    {
+      digT30   <<= 1;
+      digT30   |= (digASCII & 0x01);
+      digASCII >>= 1;
+    }
+
+#ifdef DEBUG_CCD
+    TRACE_CCD (globs, "  converted to %X", (USHORT) digT30);
+#endif
+    bf_codeByteNumber (8, digT30, globs);
+
+    i++;
+  }
+  
+  return 1;
+}
+#endif /* !RUN_INT_RAM */