co_cdh.c

Go to the documentation of this file.

 
/* co_cdh.c -- class definition handler
   This module contains the API-routines to the
   Class Definition Handler, CDH.  */
 
#include <ctype.h>
#include <errno.h>
#include <math.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
 
#include "co_cdh_msg.h"
#include "co_cdh.h"
#include "co_string.h"
#include "co_time.h"
 
 
 
int cdh_ObjidCompare(pwr_tObjid Objid_1, pwr_tObjid Objid_2)
{
  if (Objid_1.vid == Objid_2.vid) {
    if (Objid_1.oix == Objid_2.oix)
      return 0;
    else if (Objid_1.oix < Objid_2.oix)
      return -1;
    else
      return 1;
  } else if (Objid_1.vid < Objid_2.vid)
    return -1;
  else
    return 1;
}
 
 
int cdh_ObjidIsEqual(pwr_tObjid Objid_1, pwr_tObjid Objid_2)
{
  return (Objid_1.vid == Objid_2.vid) && (Objid_1.oix == Objid_2.oix);
}
 
 
int cdh_ObjidIsNotEqual(pwr_tObjid Objid_1, pwr_tObjid Objid_2)
{
  return (Objid_1.vid != Objid_2.vid) || (Objid_1.oix != Objid_2.oix);
}
 
 
int cdh_ObjidIsNull(pwr_tObjid Objid)
{
  return (Objid.vid == pwr_cNObjid.vid) && (Objid.oix == pwr_cNObjid.oix);
}
 
 
int cdh_ObjidIsNotNull(pwr_tObjid Objid)
{
  return (Objid.vid != pwr_cNObjid.vid) || (Objid.oix != pwr_cNObjid.oix);
}
 
int cdh_RefIdCompare(pwr_tRefId Reference_1, pwr_tRefId Reference_2)
{
  return cdh_ObjidCompare(
      *(pwr_tObjid*)&Reference_1, *(pwr_tObjid*)&Reference_2);
}
 
int cdh_RefIdIsEqual(pwr_tRefId Reference_1, pwr_tRefId Reference_2)
{
  return cdh_ObjidIsEqual(
      *(pwr_tObjid*)&Reference_1, *(pwr_tObjid*)&Reference_2);
}
 
int cdh_RefIdIsNotEqual(pwr_tRefId Reference_1, pwr_tRefId Reference_2)
{
  return cdh_ObjidIsNotEqual(
      *(pwr_tObjid*)&Reference_1, *(pwr_tObjid*)&Reference_2);
}
 
int cdh_RefIdIsNull(pwr_tRefId Reference)
{
  return cdh_ObjidIsNull(*(pwr_tObjid*)&Reference);
}
 
int cdh_RefIdIsNotNull(pwr_tRefId Reference)
{
  return cdh_ObjidIsNotNull(*(pwr_tObjid*)&Reference);
}
 
int cdh_SubidCompare(pwr_tSubid Subscription_1, pwr_tSubid Subscription_2)
{
  return cdh_ObjidCompare(
      *(pwr_tObjid*)&Subscription_1, *(pwr_tObjid*)&Subscription_2);
}
 
int cdh_SubidIsEqual(pwr_tSubid Subscription_1, pwr_tSubid Subscription_2)
{
  return cdh_ObjidIsEqual(
      *(pwr_tObjid*)&Subscription_1, *(pwr_tObjid*)&Subscription_2);
}
 
int cdh_SubidIsNotEqual(pwr_tSubid Subscription_1, pwr_tSubid Subscription_2)
{
  return cdh_ObjidIsNotEqual(
      *(pwr_tObjid*)&Subscription_1, *(pwr_tObjid*)&Subscription_2);
}
 
int cdh_SubidIsNull(pwr_tSubid Subscription)
{
  return cdh_ObjidIsNull(*(pwr_tObjid*)&Subscription);
}
 
int cdh_SubidIsNotNull(pwr_tSubid Subscription)
{
  return cdh_ObjidIsNotNull(*(pwr_tObjid*)&Subscription);
}
 
int cdh_DlidCompare(pwr_tDlid DirectLink_1, pwr_tDlid DirectLink_2)
{
  return cdh_ObjidCompare(
      *(pwr_tObjid*)&DirectLink_1, *(pwr_tObjid*)&DirectLink_2);
}
 
int cdh_DlidIsEqual(pwr_tDlid DirectLink_1, pwr_tDlid DirectLink_2)
{
  return cdh_ObjidIsEqual(
      *(pwr_tObjid*)&DirectLink_1, *(pwr_tObjid*)&DirectLink_2);
}
 
int cdh_DlidIsNotEqual(pwr_tDlid DirectLink_1, pwr_tDlid DirectLink_2)
{
  return cdh_ObjidIsNotEqual(
      *(pwr_tObjid*)&DirectLink_1, *(pwr_tObjid*)&DirectLink_2);
}
 
int cdh_DlidIsNull(pwr_tDlid DirectLink)
{
  return cdh_ObjidIsNull(*(pwr_tObjid*)&DirectLink);
}
 
int cdh_DlidIsNotNull(pwr_tDlid DirectLink)
{
  return cdh_ObjidIsNotNull(*(pwr_tObjid*)&DirectLink);
}
 
int cdh_ArefIsEqual(pwr_sAttrRef* arp1, pwr_sAttrRef* arp2)
{
  if (arp1->Flags.b.Object && arp2->Flags.b.Object)
    return (arp1->Objid.vid == arp2->Objid.vid
        && arp1->Objid.oix == arp2->Objid.oix);
  else
    return (arp1->Objid.vid == arp2->Objid.vid
        && arp1->Objid.oix == arp2->Objid.oix && arp1->Offset == arp2->Offset
        && (arp1->Size == 0 || arp2->Size == 0 || arp1->Size == arp2->Size));
}
 
 
pwr_tClassId cdh_ClassObjidToId(pwr_tObjid Objid)
{
  cdh_uTypeId cid;
  cdh_uObjid oid;
 
  oid.pwr = Objid;
 
  cid.c.bix = 0;
  cid.c.cix = oid.c.cix;
  cid.c.must_be_zero = 0;
  cid.c.vid_0 = oid.c.vid_0;
  cid.c.vid_1 = oid.c.vid_1;
 
  return (pwr_tClassId)cid.pwr;
}
 
 
pwr_tObjid cdh_ClassIdToObjid(pwr_tClassId Class)
{
  cdh_uObjid oid;
  cdh_uTypeId cid;
 
  cid.pwr = Class;
 
  oid.c.aix = 0;
  oid.c.reserved = 0;
  oid.c.bix = 0;
  oid.c.cix = cid.c.cix;
  oid.c.must_be_two = 2;
  oid.c.vid_0 = cid.c.vid_0;
  oid.c.vid_1 = cid.c.vid_1;
  oid.c.vid_2 = 0;
  oid.c.vid_3 = 0;
 
  return oid.pwr;
}
 
 
pwr_tTypeId cdh_TypeObjidToId(pwr_tObjid Objid)
{
  cdh_uObjid oid;
  cdh_uTypeId tid;
 
  oid.pwr = Objid;
 
  if (oid.t.must_be_three == 2) {
    /* We have a class body.  */
    tid.c.bix = oid.c.bix;
    tid.c.cix = oid.c.cix;
    tid.c.must_be_zero = 0;
    tid.c.vid_0 = oid.c.vid_0;
    tid.c.vid_1 = oid.c.vid_1;
  } else if (oid.t.must_be_three == 3) {
    /* We have a type.  */
    tid.t.tix = oid.t.tix;
    tid.t.tyg = oid.t.tyg;
    tid.t.must_be_one = 1;
    tid.t.vid_0 = oid.t.vid_0;
    tid.t.vid_1 = oid.t.vid_1;
  } else {
    // TODO: We have an error.
    tid.t.tix = oid.t.tix;
    tid.t.tyg = oid.t.tyg;
    tid.t.must_be_one = 1;
    tid.t.vid_0 = oid.t.vid_0;
    tid.t.vid_1 = oid.t.vid_1;
  }
 
  return tid.pwr;
}
 
 
int cdh_TypeIdToIndex(pwr_tTypeId Type)
{
  cdh_uTypeId tid;
 
  tid.pwr = Type;
 
  return tid.t.tix;
}
 
 
pwr_tObjid cdh_TypeIdToObjid(pwr_tTypeId Type)
{
  cdh_uObjid oid;
  cdh_uTypeId tid;
 
  tid.pwr = Type;
 
  if (tid.t.must_be_one == 1) {
    oid.t.aix = 0;
    oid.t.reserved = 0;
    oid.t.tix = tid.t.tix;
    oid.t.tyg = tid.t.tyg;
    oid.t.must_be_three = 3;
    oid.t.vid_0 = tid.t.vid_0;
    oid.t.vid_1 = tid.t.vid_1;
    oid.t.vid_2 = 0;
    oid.t.vid_3 = 0;
  } else {
    oid.c.aix = 0;
    oid.c.reserved = 0;
    oid.c.bix = tid.c.bix;
    oid.c.cix = tid.c.cix;
    oid.c.must_be_two = 2;
    oid.c.vid_0 = tid.c.vid_0;
    oid.c.vid_1 = tid.c.vid_1;
    oid.c.vid_2 = 0;
    oid.c.vid_3 = 0;
  }
 
  return oid.pwr;
}
 
pwr_sAttrRef cdh_ObjidToAref(pwr_tObjid Objid)
{
  pwr_sAttrRef a = pwr_cNAttrRef;
  a.Objid = Objid;
  a.Flags.b.Object = 1;
 
  return a;
}
 
 
pwr_tStatus cdh_AttrValueToString(
    pwr_eType Type, void* Value, char* String, int MaxSize)
{
  pwr_tStatus sts = CDH__SUCCESS;
  char timbuf[24];
 
  switch (Type) {
  case pwr_eType_Boolean:
    if (*(pwr_tBoolean*)Value)
      strcpy(String, "1");
    else
      strcpy(String, "0");
    break;
  case pwr_eType_Float32: {
    pwr_tFloat32 f;
    memcpy(&f, Value, sizeof(f));
    snprintf(String, MaxSize, "%.7g", f);
    break;
  }
  case pwr_eType_Float64: {
    pwr_tFloat64 f;
    memcpy(&f, Value, sizeof(f));
    snprintf(String, MaxSize, "%.17g", f);
    break;
  }
  case pwr_eType_Char:
    if (*(pwr_tChar*)Value == 0)
      *String = '\0';
    else
      sprintf(String, "%c", *(pwr_tChar*)Value);
    break;
  case pwr_eType_Int8:
    snprintf(String, MaxSize, "%d", *(pwr_tInt8*)Value);
    break;
  case pwr_eType_Int16:
    snprintf(String, MaxSize, "%hd", *(pwr_tInt16*)Value);
    break;
  case pwr_eType_Int32:
  case pwr_eType_Status:
  case pwr_eType_NetStatus:
  case pwr_eType_Enum:
    snprintf(String, MaxSize, "%d", *(pwr_tInt32*)Value);
    break;
  case pwr_eType_Int64:
    snprintf(String, MaxSize, pwr_dFormatInt64, *(pwr_tInt64*)Value);
    break;
  case pwr_eType_UInt8:
    snprintf(String, MaxSize, "%u", *(pwr_tUInt8*)Value);
    break;
  case pwr_eType_UInt16:
    snprintf(String, MaxSize, "%hu", *(pwr_tUInt16*)Value);
    break;
  case pwr_eType_UInt32:
  case pwr_eType_Mask:
    snprintf(String, MaxSize, "%u", *(pwr_tUInt32*)Value);
    break;
  case pwr_eType_UInt64:
    snprintf(String, MaxSize, pwr_dFormatUInt64, *(pwr_tUInt64*)Value);
    break;
  case pwr_eType_Time:
    if (ODD(time_AtoAscii(
            Value, time_eFormat_DateAndTime, timbuf, sizeof(timbuf)))) {
      strncpy(String, timbuf, MaxSize);
    } else {
      strncpy(String, "*** Bad time value ***", MaxSize);
      sts = CDH__INVTIME;
    }
    break;
  case pwr_eType_DeltaTime:
    if (ODD(time_DtoAscii(Value, 1, timbuf, sizeof(timbuf)))) {
      strncpy(String, timbuf, MaxSize);
    } else {
      strncpy(String, "*** Bad delta time value ***", MaxSize);
      sts = CDH__INVDELTATIME;
    }
    break;
  case pwr_eType_String:
  case pwr_eType_Text:
    snprintf(String, MaxSize, "%s", (char*)Value);
    break;
  case pwr_eType_ProString: {
    int len = MIN(strlen((char*)Value), MaxSize-1);
    int i;
    strcpy(String, "");
    for (i = 0; i < len; i++)
      strcat(String, "*");
    break;
  }
  default:
    sts = CDH__INVTYPE;
    break;
  }
 
  String[MaxSize - 1] = 0;
  return sts;
}
 
 
pwr_tStatus cdh_StringToAttrValue(
    pwr_eType Type, const char* String, void* Value)
{
  pwr_tStatus sts = CDH__SUCCESS;
  pwr_tBoolean bval = 0;
  pwr_tInt8 i8val = 0;
  pwr_tInt16 i16val = 0;
  pwr_tInt32 i32val = 0;
  pwr_tInt64 i64val = 0;
  pwr_tUInt8 ui8val = 0;
  pwr_tUInt16 ui16val = 0;
  pwr_tUInt32 ui32val = 0;
  pwr_tUInt64 ui64val = 0;
  pwr_tFloat32 f32val = 0.0;
  pwr_tFloat64 f64val = 0.0;
  pwr_tClassId cidval = pwr_cNClassId;
  pwr_tTypeId tidval = pwr_cNTypeId;
  pwr_tObjectIx oixval = pwr_cNObjectIx;
  pwr_tVolumeId vidval = pwr_cNVolumeId;
  pwr_tTime timeval;
  pwr_tDeltaTime dtimeval;
  char timbuf[24];
  unsigned int timlen;
  char* endp;
 
  errno = 0;
 
  pwr_Assert(String != NULL);
  pwr_Assert(Value != NULL);
 
  switch (Type) {
  case pwr_eType_Boolean:
    if (*String != '\0') {
      i32val = strtoul(String, &endp, 0);
      if (errno == ERANGE || *endp != '\0' || (i32val != 0 && i32val != 1)) {
        sts = CDH__INVBOOL;
        break;
      }
    }
    bval = i32val;
    memcpy(Value, &bval, sizeof(bval));
    break;
 
  case pwr_eType_Float32:
    if (*String != '\0') {
      f64val = strtod(String, &endp);
      if (errno == ERANGE || *endp != '\0' || fabs(f64val) > FLT_MAX) {
        sts = CDH__INVFLOAT32;
        break;
      }
    }
    f32val = f64val;
    memcpy(Value, &f32val, sizeof(f32val));
    break;
 
  case pwr_eType_Float64:
    if (*String != '\0') {
      f64val = strtod(String, &endp);
      if (errno == ERANGE || *endp != '\0' || fabs(f64val) > DBL_MAX) {
        sts = CDH__INVFLOAT64;
        break;
      }
    }
    memcpy(Value, &f64val, sizeof(f64val));
    break;
 
  case pwr_eType_Char:
    *((char*)Value) = *String;
    break;
 
  case pwr_eType_Int8:
    if (*String != '\0') {
      i32val = strtol(String, &endp, 0);
      if (errno == ERANGE || *endp != '\0' || i32val > SCHAR_MAX
          || i32val < SCHAR_MIN) {
        sts = CDH__INVINT8;
        break;
      }
    }
    i8val = i32val;
    memcpy(Value, &i8val, sizeof(i8val));
    break;
 
  case pwr_eType_Int16:
    if (*String != '\0') {
      i32val = strtol(String, &endp, 0);
      if (errno == ERANGE || *endp != '\0' || i32val > SHRT_MAX
          || i32val < SHRT_MIN) {
        sts = CDH__INVINT16;
        break;
      }
    }
    i16val = i32val;
    memcpy(Value, &i16val, sizeof(i16val));
    break;
 
  case pwr_eType_Int32:
  case pwr_eType_Status:
  case pwr_eType_NetStatus:
  case pwr_eType_Enum:
    if (*String != '\0') {
      i32val = strtol(String, &endp, 0);
      if (errno == ERANGE || *endp != '\0' || i32val > INT_MAX
          || i32val < INT_MIN) {
        sts = CDH__INVINT32;
        break;
      }
    }
    memcpy(Value, &i32val, sizeof(i32val));
    break;
 
  case pwr_eType_Int64:
    if (*String != '\0') {
      if (sscanf(String, pwr_dFormatInt64, &i64val) != 1) {
        sts = CDH__INVINT32;
        break;
      }
    }
    memcpy(Value, &i64val, sizeof(i64val));
    break;
 
  case pwr_eType_UInt8:
    while (*String && isspace(*String))
      String++;
    if (*String != '\0') {
      ui32val = strtoul(String, &endp, 0);
      if (errno == ERANGE || *endp != '\0' || ui32val > UCHAR_MAX
          || *String == '-') {
        sts = CDH__INVUINT8;
        break;
      }
    }
    ui8val = ui32val;
    memcpy(Value, &ui8val, sizeof(ui8val));
    break;
 
  case pwr_eType_UInt16:
    while (*String && isspace(*String))
      String++;
    if (*String != '\0') {
      ui32val = strtoul(String, &endp, 0);
      if (errno == ERANGE || *endp != '\0' || ui32val > USHRT_MAX
          || *String == '-') {
        sts = CDH__INVUINT16;
        break;
      }
    }
    ui16val = ui32val;
    memcpy(Value, &ui16val, sizeof(ui16val));
    break;
 
  case pwr_eType_UInt32:
  case pwr_eType_Mask:
    while (*String && isspace(*String))
      String++;
    if (*String != '\0') {
      ui32val = strtoul(String, &endp, 0);
      if (errno == ERANGE || *endp != '\0' || ui32val > UINT_MAX
          || *String == '-') {
        sts = CDH__INVUINT32;
        break;
      }
    }
    memcpy(Value, &ui32val, sizeof(ui32val));
    break;
 
  case pwr_eType_UInt64:
    if (*String != '\0') {
      if (sscanf(String, pwr_dFormatUInt64, &ui64val) != 1) {
        sts = CDH__INVUINT32;
        break;
      }
    }
    memcpy(Value, &ui64val, sizeof(ui64val));
    break;
 
  case pwr_eType_String:
  case pwr_eType_Text:
  case pwr_eType_ProString:
    strcpy(Value, String);
    break;
 
  case pwr_eType_Time:
    timlen = strlen(String);
    if (timlen > 23) {
      sts = CDH__INVTIME;
      break;
    }
    memcpy(timbuf, String, MIN(sizeof(timbuf), timlen));
    timbuf[MIN(sizeof(timbuf), timlen)] = '\0';
    sts = time_AsciiToA(timbuf, &timeval);
    if (EVEN(sts)) {
      sts = CDH__INVTIME;
      break;
    }
    memcpy(Value, &timeval, sizeof(timeval));
    break;
 
  case pwr_eType_DeltaTime:
    timlen = strlen(String);
    if (timlen > 23) {
      sts = CDH__INVDELTATIME;
      break;
    }
    memcpy(timbuf, String, MIN(sizeof(timbuf), timlen));
    timbuf[MIN(sizeof(timbuf), timlen)] = '\0';
    sts = time_AsciiToD(timbuf, &dtimeval);
    if (EVEN(sts)) {
      sts = CDH__INVDELTATIME;
      break;
    }
    memcpy(Value, &dtimeval, sizeof(dtimeval));
    break;
 
  case pwr_eType_ClassId:
    while (*String && isspace(*String))
      String++;
    if (*String != '\0') {
      sts = cdh_StringToClassId(String, &cidval);
      if (EVEN(sts))
        break;
    }
    memcpy(Value, &cidval, sizeof(cidval));
    break;
 
  case pwr_eType_VolumeId:
    while (*String && isspace(*String))
      String++;
    if (*String != '\0') {
      sts = cdh_StringToVolumeId(String, &vidval);
      if (EVEN(sts))
        break;
    }
    memcpy(Value, &vidval, sizeof(vidval));
    break;
 
  case pwr_eType_TypeId:
    while (*String && isspace(*String))
      String++;
    if (*String != '\0') {
      sts = cdh_StringToTypeId(String, &tidval);
      if (EVEN(sts))
        break;
    }
    memcpy(Value, &tidval, sizeof(tidval));
    break;
 
  case pwr_eType_ObjectIx:
    while (*String && isspace(*String))
      String++;
    if (*String != '\0') {
      sts = cdh_StringToObjectIx(String, &oixval);
      if (EVEN(sts))
        break;
    }
    memcpy(Value, &oixval, sizeof(oixval));
    break;
 
  default:
    sts = CDH__INVTYPE;
    break;
  }
 
  return sts;
}
 
 
void cdh_MaskToBinaryString(unsigned int mask, int noofbits, char* str)
{
  unsigned int m;
  int i;
 
  m = 1 << (noofbits - 1);
  strcpy(str, "");
  for (i = 0; i < noofbits; i++) {
    if (m & mask)
      strcat(str, "1");
    else
      strcat(str, "0");
    m >>= 1;
  }
}
 
 
pwr_tStatus cdh_StringToClassId(const char* s, pwr_tClassId* cid)
{
  unsigned int vid_0;
  unsigned int vid_1;
  unsigned int cix;
  cdh_uTypeId lcid;
 
  pwr_Assert(cid != NULL);
 
  lcid.pwr = pwr_cNClassId;
 
  if (*s == '_')
    s++;
  if (*s == 'C' || *s == 'c')
    s++;
 
  if (sscanf(s, "%d.%d:%d%*s", &vid_1, &vid_0, &cix) != 3)
    return CDH__INVCID;
 
  if (vid_1 > cdh_cMaxVidGroup || vid_0 > cdh_cMaxVidGroup || cix > cdh_cMaxCix)
    return CDH__INVCID;
 
  lcid.c.vid_1 = vid_1;
  lcid.c.vid_0 = vid_0;
  lcid.c.cix = cix;
 
  *cid = lcid.pwr;
 
  return CDH__SUCCESS;
}
 
 
pwr_tStatus cdh_StringToObjid(const char* s, pwr_tObjid* oid)
{
  unsigned int vid_0;
  unsigned int vid_1;
  unsigned int vid_2;
  unsigned int vid_3;
  unsigned int oix;
  cdh_uObjid loid;
 
  pwr_Assert(oid != NULL);
 
  loid.pwr = pwr_cNObjid;
 
  if (*s == '_')
    s++;
  if (*s == 'O' || *s == 'o')
    s++;
  if (*s == 'A' || *s == 'a')
    s++;
 
  if (sscanf(s, "%d.%d.%d.%d:%u%*s", &vid_3, &vid_2, &vid_1, &vid_0, &oix) != 5)
    return CDH__INVOID;
 
  if (vid_3 > cdh_cMaxVidGroup || vid_2 > cdh_cMaxVidGroup
      || vid_1 > cdh_cMaxVidGroup || vid_0 > cdh_cMaxVidGroup) {
    return CDH__INVOID;
  }
 
  loid.o.vid_3 = vid_3;
  loid.o.vid_2 = vid_2;
  loid.o.vid_1 = vid_1;
  loid.o.vid_0 = vid_0;
  loid.o.oix = oix;
 
  *oid = loid.pwr;
 
  return CDH__SUCCESS;
}
 
 
pwr_tStatus cdh_StringToAref(const char* s, pwr_tAttrRef* aref)
{
  char oid_str[40];
  char body_str[40];
  char offset_str[40];
  char size_str[40];
  pwr_tAttrRef a;
  pwr_tStatus sts;
  unsigned int idx;
  unsigned int state;
  const char* t;
 
  pwr_Assert(aref != NULL);
 
  idx = 0;
  state = 0;
  for (t = s; *t; t++) {
    if (state == 0 && *t == '(') {
      oid_str[idx] = 0;
      idx = 0;
      state++;
    } else if (state == 1 && *t == ')') {
      body_str[idx] = 0;
      idx = 0;
      state++;
      t++;
      if (*t != '[')
        return CDH__INVCID;
    } else if (state == 2 && *t == '.') {
      offset_str[idx] = 0;
      idx = 0;
      state++;
    } else if (state == 3 && *t == ']') {
      size_str[idx] = 0;
      state++;
    } else {
      if (state == 0)
        oid_str[idx++] = *t;
      else if (state == 1)
        body_str[idx++] = *t;
      else if (state == 2)
        offset_str[idx++] = *t;
      else if (state == 3)
        size_str[idx++] = *t;
      else
        return CDH__INVCID;
    }
  }
 
  memset(&a, 0, sizeof(a));
 
  sts = cdh_StringToObjid(oid_str, &a.Objid);
  if (EVEN(sts))
    return sts;
 
  if (state < 1)
    a.Flags.b.Object = 1;
  else {
    sts = cdh_StringToTypeId(body_str, &a.Body);
    if (EVEN(sts))
      return sts;
 
    if (state < 2)
      a.Flags.b.Object = 1;
    else {
      if (sscanf(offset_str, "%u", &a.Offset) != 1)
        return CDH__INVCID;
      if (sscanf(size_str, "%u", &a.Size) != 1)
        return CDH__INVCID;
 
      a.Flags.m = 0;
    }
  }
 
  *aref = a;
 
  return CDH__SUCCESS;
}
 
 
pwr_tStatus cdh_StringToTypeId(const char* s, pwr_tTypeId* tid)
{
  unsigned int vid_0;
  unsigned int vid_1;
  unsigned int bit;
  unsigned int tyg;
  unsigned int tix;
  cdh_uTypeId ltid;
 
  pwr_Assert(tid != NULL);
 
  ltid.pwr = pwr_cNTypeId;
 
  if (*s == '_')
    s++;
  if (*s == 'T' || *s == 't')
    s++;
 
  if (sscanf(s, "%d.%d:%d.%d.%d%*s", &vid_1, &vid_0, &bit, &tyg, &tix) != 5)
    return CDH__INVTID;
 
  if (vid_0 > cdh_cMaxVidGroup || vid_1 > cdh_cMaxVidGroup || bit > 1)
    return CDH__INVTID;
 
  if (bit == 0) { /*  Class Type.  */
    if (tyg > cdh_cMaxCix || tix > cdh_cMaxBix)
      return CDH__INVTID;
 
    ltid.c.vid_1 = vid_1;
    ltid.c.vid_0 = vid_0;
    ltid.c.must_be_zero = 0;
    ltid.c.cix = tyg;
    ltid.c.bix = tix;
 
  } else { /*  Type.  */
    if (tyg > cdh_cMaxTyg || tix > cdh_cMaxTix)
      return CDH__INVTID;
 
    ltid.t.vid_1 = vid_1;
    ltid.t.vid_0 = vid_0;
    ltid.t.must_be_one = 1;
    ltid.t.tyg = tyg;
    ltid.t.tix = tix;
  }
 
  *tid = ltid.pwr;
  return CDH__SUCCESS;
}
 
 
pwr_tStatus cdh_StringToVolumeId(const char* s, pwr_tVolumeId* vid)
{
  unsigned int vid_0;
  unsigned int vid_1;
  unsigned int vid_2;
  unsigned int vid_3;
  cdh_uVolumeId lvid;
 
  pwr_Assert(vid != NULL);
 
  lvid.pwr = pwr_cNVolumeId;
 
  if (*s == '_')
    s++;
  if (*s == 'V' || *s == 'v')
    s++;
  if (*s == 'O' || *s == 'o')
    s++;
  if (*s == 'A' || *s == 'a')
    s++;
 
  if (sscanf(s, "%d.%d.%d.%d%*s", &vid_3, &vid_2, &vid_1, &vid_0) != 4)
    return CDH__INVVID;
 
  if (vid_3 > cdh_cMaxVidGroup || vid_2 > cdh_cMaxVidGroup
      || vid_1 > cdh_cMaxVidGroup || vid_0 > cdh_cMaxVidGroup)
    return CDH__INVVID;
 
  lvid.v.vid_3 = vid_3;
  lvid.v.vid_2 = vid_2;
  lvid.v.vid_1 = vid_1;
  lvid.v.vid_0 = vid_0;
 
  *vid = lvid.pwr;
 
  return CDH__SUCCESS;
}
 
 
pwr_tStatus cdh_StringToObjectIx(const char* s, pwr_tObjectIx* oix)
{
  pwr_tObjectIx loix = pwr_cNObjectIx;
 
  pwr_Assert(oix != NULL);
  errno = 0;
 
  if (*s == '_')
    s++;
  if (*s == 'X' || *s == 'x')
    s++;
 
  loix = strtoul(s, NULL, 0);
  if (errno == ERANGE || loix > cdh_cMaxOix)
    return CDH__INVOIX;
 
  *oix = loix;
 
  return CDH__SUCCESS;
}
 
pwr_tStatus cdh_StringToSubid(const char* s, pwr_tSubid* sid)
{
  unsigned int vid_0;
  unsigned int vid_1;
  unsigned int vid_2;
  unsigned int vid_3;
  unsigned int six;
  cdh_uRefId lrid;
 
  pwr_Assert(sid != NULL);
 
  lrid.pwr = pwr_cNSubid;
 
  if (*s == '_')
    s++;
  if (*s == 'S' || *s == 's')
    s++;
 
  if (sscanf(s, "%d.%d.%d.%d:%u%*s", &vid_3, &vid_2, &vid_1, &vid_0, &six) != 5)
    return CDH__INVSID;
 
  if (vid_3 != cdh_eVid3_subid || vid_2 > cdh_cMaxVidGroup
      || vid_1 > cdh_cMaxVidGroup || vid_0 > cdh_cMaxVidGroup) {
    return CDH__INVSID;
  }
 
  lrid.r.vid_3 = vid_3;
  lrid.r.vid_2 = vid_2;
  lrid.r.vid_1 = vid_1;
  lrid.r.vid_0 = vid_0;
  lrid.r.rix = six;
 
  *sid = lrid.pwr;
 
  return CDH__SUCCESS;
}
 
pwr_tStatus cdh_StringToDlid(const char* s, pwr_tDlid* did)
{
  unsigned int vid_0;
  unsigned int vid_1;
  unsigned int vid_2;
  unsigned int vid_3;
  unsigned int dix;
  cdh_uRefId lrid;
 
  pwr_Assert(did != NULL);
 
  lrid.pwr = pwr_cNDlid;
 
  if (*s == '_')
    s++;
  if (*s == 'D' || *s == 'd')
    s++;
 
  if (sscanf(s, "%d.%d.%d.%d:%u%*s", &vid_3, &vid_2, &vid_1, &vid_0, &dix) != 5)
    return CDH__INVDID;
 
  if (vid_3 != cdh_eVid3_dlid || vid_2 > cdh_cMaxVidGroup
      || vid_1 > cdh_cMaxVidGroup || vid_0 > cdh_cMaxVidGroup) {
    return CDH__INVDID;
  }
 
  lrid.r.vid_3 = vid_3;
  lrid.r.vid_2 = vid_2;
  lrid.r.vid_1 = vid_1;
  lrid.r.vid_0 = vid_0;
  lrid.r.rix = dix;
 
  *did = lrid.pwr;
 
  return CDH__SUCCESS;
}
 
 
void cdh_ClassIdToString(char* s, int size, pwr_tClassId cid, int prefix)
{
  cdh_uTypeId lcid;
 
  lcid.pwr = cid;
 
  if (/*  Check validity of class identifier. */
      lcid.c.bix != 0 || lcid.c.must_be_zero != 0) {
    snprintf(s, size, "%s%u.%u:?%u?", (prefix ? "_C" : ""), lcid.c.vid_1,
        lcid.c.vid_0, lcid.c.cix);
  } else {
    snprintf(s, size, "%s%u.%u:%u", (prefix ? "_C" : ""), lcid.c.vid_1,
        lcid.c.vid_0, lcid.c.cix);
  }
}
 
 
void cdh_TypeIdToString(char* s, int size, pwr_tTypeId tid, int prefix)
{
  cdh_uTypeId ltid;
 
  ltid.pwr = tid;
 
  if (ltid.t.must_be_one == 0) { /*  This is a class TypeId.  */
    snprintf(s, size, "%s%u.%u:0.%u.%u", (prefix ? "_T" : ""), ltid.c.vid_1,
        ltid.c.vid_0, ltid.c.cix, ltid.c.bix);
  } else { /*   This i s a type TypeId.  */
    snprintf(s, size, "%s%u.%u:1.%u.%u", (prefix ? "_T" : ""), ltid.t.vid_1,
        ltid.t.vid_0, ltid.t.tyg, ltid.t.tix);
  }
}
 
 
void cdh_ObjectIxToString(char* s, int size, pwr_tObjectIx oix, int prefix)
{
  snprintf(s, size, "%s%u", (prefix ? "_X" : ""), oix);
}
 
 
void cdh_ArefToString(char* s, int size, pwr_sAttrRef* aref, int prefix)
{
  char ls[200];
  char tmp[40];
 
  cdh_OidToString(ls, sizeof(ls), aref->Objid, 0);
 
  if (aref->Body != pwr_cNTypeId) {
    strcat(ls, "(");
    cdh_TypeIdToString(&ls[strlen(ls)], sizeof(ls), aref->Body, 1);
    strcat(ls, ")");
    if (aref->Offset > 0 || aref->Size > 0) {
      sprintf(tmp, "[%d.%d]", aref->Offset, aref->Size);
      strcat(ls, tmp);
    }
  }
 
  sprintf(s, "%s", (prefix ? "_A" : ""));
  strncat(s, ls, size - strlen(s));
}
 
 
char* cdh_AttrRefToString(pwr_sAttrRef* aref, int prefix)
{
  static char ls[200];
 
  cdh_ArefToString(ls, sizeof(ls), aref, prefix);
  return ls;
}
 
 
char* cdh_NodeIdToString(char* s, pwr_tNodeId nid, int prefix, int suffix)
{
  cdh_uVolumeId lvid;
  static char ls[sizeof("_N255.255.255.255:")];
 
  lvid.pwr = (pwr_tVolumeId)nid;
 
  sprintf(ls, "%s%u.%u.%u.%u%s", (prefix ? "_N" : ""), lvid.v.vid_3,
      lvid.v.vid_2, lvid.v.vid_1, lvid.v.vid_0, (suffix ? ":" : ""));
 
  if (s != NULL)
    return strcat(s, ls);
  else
    return ls;
}
 
 
void cdh_OidToString(char* s, int size, pwr_tObjid oid, int prefix)
{
  cdh_uObjid loid;
 
  loid.pwr = oid;
 
  snprintf(s, size, "%s%u.%u.%u.%u:%u", (prefix ? "_O" : ""), loid.o.vid_3,
      loid.o.vid_2, loid.o.vid_1, loid.o.vid_0, loid.o.oix);
}
 
 
char* cdh_ObjidToString(pwr_tObjid oid, int prefix)
{
  cdh_uObjid loid;
  static char ls[sizeof("_O255.255.255.255:4294967295")];
 
  loid.pwr = oid;
 
  sprintf(ls, "%s%u.%u.%u.%u:%u", (prefix ? "_O" : ""), loid.o.vid_3,
      loid.o.vid_2, loid.o.vid_1, loid.o.vid_0, loid.o.oix);
  return ls;
}
 
 
char* cdh_ObjidToFnString(char* s, pwr_tOid oid)
{
  cdh_uObjid loid;
  static char str[40];
 
  loid.pwr = oid;
 
  sprintf(str, "%3.3u_%3.3u_%3.3u_%3.3u_%8.8x", loid.o.vid_3, loid.o.vid_2,
      loid.o.vid_1, loid.o.vid_0, loid.o.oix);
 
  if (s != NULL)
    return strcat(s, str);
  else
    return str;
}
 
 
char* cdh_VolumeIdToString(
    char* s, int size, pwr_tVolumeId vid, int prefix, int suffix)
{
  cdh_uVolumeId lvid;
  static char ls[sizeof("_V255.255.255.255:")];
 
  lvid.pwr = vid;
 
  if (s) {
    snprintf(s, size, "%s%u.%u.%u.%u%s", (prefix ? "_V" : ""), lvid.v.vid_3,
        lvid.v.vid_2, lvid.v.vid_1, lvid.v.vid_0, (suffix ? ":" : ""));
    return s;
  } else
    sprintf(ls, "%s%u.%u.%u.%u%s", (prefix ? "_V" : ""), lvid.v.vid_3,
        lvid.v.vid_2, lvid.v.vid_1, lvid.v.vid_0, (suffix ? ":" : ""));
  return ls;
}
 
 
char* cdh_VolumeIdToFnString(char* s, int size, pwr_tVolumeId vid)
{
  cdh_uVolumeId lvid;
 
  lvid.pwr = vid;
 
  snprintf(s, size, "%3.3u_%3.3u_%3.3u_%3.3u", lvid.v.vid_3, lvid.v.vid_2,
      lvid.v.vid_1, lvid.v.vid_0);
 
  return s;
}
 
 
void cdh_SubidToString(char* s, int size, pwr_tSubid sid, int prefix)
{
  cdh_uRefId lrid;
 
  lrid.pwr = sid;
 
  snprintf(s, size, "%s%u.%u.%u.%u:%u", (prefix ? "_S" : ""), lrid.r.vid_3,
      lrid.r.vid_2, lrid.r.vid_1, lrid.r.vid_0, lrid.r.rix);
}
 
 
void cdh_DlidToString(char* s, int size, pwr_tDlid did, int prefix)
{
  cdh_uRefId lrid;
 
  lrid.pwr = did;
 
  snprintf(s, size, "%s%u.%u.%u.%u:%u", (prefix ? "_D" : ""), lrid.r.vid_3,
      lrid.r.vid_2, lrid.r.vid_1, lrid.r.vid_0, lrid.r.rix);
}
 
cdh_sFamily* cdh_Family(cdh_sFamily* f, const char* name, pwr_tObjid poid)
{
  cdh_ObjName(&f->name, name);
  f->poid = poid;
 
  return f;
}
 
cdh_sObjName* cdh_ObjName(cdh_sObjName* on, const char* name)
{
  strncpy(on->orig, name, sizeof(pwr_tObjName));
  on->orig[sizeof(pwr_tObjName) - 1] = '\0';
  str_ToUpper(on->norm, on->orig);
  on->pack.key = cdh_PackName(on->norm);
 
  return on;
}
 
cdh_sParseName* cdh_ParseName(pwr_tStatus* sts, cdh_sParseName* pn,
    pwr_tObjid poid, const char* name, pwr_tUInt32 flags)
{
  pwr_tStatus lsts = 1;
  const char* inp;
  char* outp;
  char* outcp;
  pwr_tUInt32 len;
  pwr_tUInt32 seglen = 0;
  pwr_tUInt32 number = 0;
  unsigned char c;
  unsigned char cc;
  char* segp;
  char* segcp;
  pwr_tInt32 state;
  cdh_sParseName ParseName;
  char origName[256];
  char normName[256];
 
  /* Conversion table.
     ! : illegal character
     * : terminates state
     ^ : lowercase, subtract 32 if cdh_mParseName_UpperCase
     + : eat
     - : new segment
     . : new segment
     ~ : end of string
     */
 
  static const char* cvttab[] = { /* 0: init */
    "\
~+++++++++++++++++++++++++++++++\
+*******************************\
********************************\
********************************\
++++++++++++++++++++++++++++++++\
********************************\
********************************\
********************************\
",
    /* 1: id() before '(' */
    "\
~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!*!!!!-.!0123456789:!!!!!\
!A!CD!!!!!!!!!!O!!!ST!V!X!!!!!!_\
!^!^^!!!!!!!!!!^!!!^^!^!^!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    /* 2: id(bname)attribute[index],  (bvol:Class-b-b-b) before ':' */
    "\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!$!!!!!!!!!!!0123456789*!!!!!\
!ABCDEFGHIJKLMNOPQRSTUVWXYZ!!!!_\
!^^^^^^^^^^^^^^^^^^^^^^^^^^!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    /* 3: id(bname)attribute[index],  (bvol:Class-b-b-b) before ')'  */
    "\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!$!!!!*!!!-!!0123456789!!!!!!\
!ABCDEFGHIJKLMNOPQRSTUVWXYZ!!!!_\
!^^^^^^^^^^^^^^^^^^^^^^^^^^!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    /* 4: id(bname)attribute[index],  attribute before '['  */
    "\
~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!$!!!!!!!!!!!0123456789!!!!!!\
!ABCDEFGHIJKLMNOPQRSTUVWXYZ*!!!_\
!^^^^^^^^^^^^^^^^^^^^^^^^^^!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏ!ÑÒÓÔÕÖ×ØÙÚÛÜÝ!!\
^^^^^^^^^^^^^^^^!^^^^^^^^^^^^^!!\
",
    /* 5: id(bname)attribute[index], index before ']'  */
    "\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!0123456789!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    /* 6: id(bname)attribute[index], after  ']'  */
    "\
~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    /* 7: id(bid)[offset.size], bid before ')'  */
    "\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!*!!!!.!0123456789:!!!!!\
!!!!!!!!!!!!!!!!!!!!T!!!!!!!!!!_\
!!!!!!!!!!!!!!!!!!!!^!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    /* 8: id(bid)[offset.size], offset before '.'  */
    "\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!*!0123456789!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    /* 9: id(bid)[offset.size], size before ']'  */
    "\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!0123456789!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    /* 10: id(bid)[offset.size], after  ']'  */
    "\
~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    /* 11: name.attribute[index], name before ':'  */
    "\
~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!$!!!!!!!!**!0123456789*!!!!!\
!ABCDEFGHIJKLMNOPQRSTUVWXYZ!!!!_\
!^^^^^^^^^^^^^^^^^^^^^^^^^^!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏ!ÑÒÓÔÕÖ×ØÙÚÛÜÝ!!\
^^^^^^^^^^^^^^^^!^^^^^^^^^^^^^!!\
",
    /* 12: name.attribute[index], name before '.'  */
    "\
~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!$!!!!!!!!-*!0123456789!!!!!!\
!ABCDEFGHIJKLMNOPQRSTUVWXYZ!!!!_\
!^^^^^^^^^^^^^^^^^^^^^^^^^^!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏ!ÑÒÓÔÕÖ×ØÙÚÛÜÝ!!\
^^^^^^^^^^^^^^^^!^^^^^^^^^^^^^!!\
",
    /* 13: name.attribute[index], attribute before '[' or '.' */
    "\
~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!$!!!!!!!!!.!0123456789!!!!!!\
!ABCDEFGHIJKLMNOPQRSTUVWXYZ*!!!_\
!^^^^^^^^^^^^^^^^^^^^^^^^^^!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏ!ÑÒÓÔÕÖ×ØÙÚÛÜÝ!!\
^^^^^^^^^^^^^^^^!^^^^^^^^^^^^^!!\
",
    /* 14: name.attribute[index], index before ']'  */
    "\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!0123456789!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    /* 15: name.attribute[index], after  ']'  */
    "\
~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!*!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
",
    "\
~!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!$!!!!!!!!-.!0123456789:!!!!!\
!ABCDEFGHIJKLMNOPQRSTUVWXYZ[!]!_\
!^^^^^^^^^^^^^^^^^^^^^^^^^^!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏ!ÑÒÓÔÕÖ×ØÙÚÛÜÝ!!\
^^^^^^^^^^^^^^^^!^^^^^^^^^^^^^!!"
  };
 
  /* Conversion table.
     ! : do not convert
     any other copy as is.  */
 
  static const char ascii7tab[] = { "\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
AAAAAAACEEEEIIII!NOOOOOOOUUUUY!!\
aaaaaaaceeeeiiii!nooooooouuuuy!!\
" };
 
  len = strlen(name);
  if (len >= sizeof(origName)) {
    *sts = CDH__NAMELEN;
    return NULL;
  }
 
  if (pn == NULL)
    pn = &ParseName;
 
  memset(pn, 0, sizeof(*pn));
 
  if (cdh_ObjidIsNotNull(poid)) {
    pn->poid = poid;
    pn->flags.b.parent = 1;
  }
  pn->parseFlags.m = flags;
 
  inp = name;
  outp = normName;
  outcp = origName;
  *outp = '\0';
  *outcp = '\0';
  segp = outp;
  segcp = outcp;
  seglen = 0;
 
  state = 0;
 
  while (inp <= name + len) {
    cc = c = *inp;
    if (cvttab[state][c] == '!') {
      printf("State: %d, %c\n", state, c);
      lsts = CDH__INVCHAR;
      goto error;
    } else if (cvttab[state][c] == '^')
      c -= 32;
    else
      c = cvttab[state][c];
 
    if (pn->parseFlags.b.ascii_7 && ascii7tab[c] != '!') {
      c = ascii7tab[c];
      cc = ascii7tab[cc];
    }
 
    switch (state) {
    case 0: /* 0: init */
      if (c == '*') {
        if (*inp == '_') {
          state++;
        } else if (*inp == '.') {
          ++inp;
          state = 13;
        } else if (pn->flags.b.parent) {
          state = 12;
        } else {
          state = 11;
        }
      } else if (c == '~') {
        lsts = CDH__NONAME;
        goto error;
      } else if (c == '+') {
        ++inp;
      }
      break;
    case 1: /* 1: id before '(' */
      if (c == '~') {
        if (outp == segp) {
          lsts = CDH__INVID;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.idString = 1;
        switch (segp[1]) {
        case 'O':
          lsts = cdh_StringToObjid(segp, &pn->uId.oid);
          pn->eId = cdh_eId_objid;
          break;
        case 'C':
          lsts = cdh_StringToClassId(segp, &pn->uId.cid);
          pn->eId = cdh_eId_classId;
          break;
        case 'V':
          lsts = cdh_StringToVolumeId(segp, &pn->uId.vid);
          pn->eId = cdh_eId_volumeId;
          break;
        case 'T':
          lsts = cdh_StringToTypeId(segp, &pn->uId.tid);
          pn->eId = cdh_eId_typeId;
          break;
        case 'A':
          lsts = cdh_StringToObjid(segp, &pn->uId.aref.Objid);
          pn->eId = cdh_eId_aref;
          break;
        case 'S':
          lsts = cdh_StringToSubid(segp, &pn->uId.sid);
          pn->eId = cdh_eId_subid;
          break;
        case 'D':
          lsts = cdh_StringToDlid(segp, &pn->uId.did);
          pn->eId = cdh_eId_dlid;
          break;
        case 'X':
          lsts = cdh_StringToObjectIx(segp, &pn->uId.oix);
          pn->eId = cdh_eId_objectIx;
          break;
        default:
          lsts = CDH__INVIDCHAR;
          goto error;
        }
        if (EVEN(lsts))
          goto error;
        segp = outp;
        segcp = outcp;
        seglen = 0;
      } else if (c == '*') {
        if (outp == segp) {
          lsts = CDH__INVSYNTAX;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.idString = 1;
        switch (segp[1]) {
        case 'A':
          lsts = cdh_StringToObjid(segp, &pn->uId.aref.Objid);
          pn->eId = cdh_eId_aref;
          if (*(inp + 1) == '_')
            state = 7;
          else
            state = 2;
          break;
        default:
          lsts = CDH__INVIDCHAR;
          goto error;
        }
        if (EVEN(lsts)) {
          goto error;
        }
        segp = outp;
        segcp = outcp;
        seglen = 0;
      } else if (c == '-') {
        if (outp == segp) {
          lsts = CDH__INVSYNTAX;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.parent = 1;
        switch (segp[1]) {
        case 'A':
        case 'O':
          lsts = cdh_StringToObjid(segp, &pn->poid);
          state = 12;
          break;
        default:
          lsts = CDH__INVIDCHAR;
          goto error;
        }
        if (EVEN(lsts))
          goto error;
        segp = outp;
        segcp = outcp;
        seglen = 0;
      } else {
        *outp++ = c;
        *outcp++ = cc;
        seglen++;
      }
      inp++;
      break;
    case 2: /* 2: id(bname)attribute[index],  (bvol:Class-b-b-b) before ':' */
      if (c == '*') {
        if (outp == segp) {
          lsts = CDH__INVTYPENAME;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        if (seglen >= sizeof(pwr_tObjName)) {
          lsts = CDH__SEGLEN;
          goto error;
        }
        strcpy(pn->body[pn->nBody].name.orig, segcp);
        strcpy(pn->body[pn->nBody].name.norm, segp);
        pn->body[pn->nBody].name.pack.key = cdh_PackName(segp);
        pn->nBody++;
        segp = outp;
        segcp = outcp;
        seglen = 0;
        state++;
      } else {
        *outp++ = c;
        *outcp++ = cc;
        seglen++;
      }
      inp++;
      break;
    case 3: /* 3: id(bname)attribute[index],  (bvol:Class-b-b-b) before ')'  */
      if (c == '*') {
        if (outp == segp) {
          lsts = CDH__INVTYPENAME;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.bodyName = 1;
        if (seglen >= sizeof(pwr_tObjName)) {
          lsts = CDH__SEGLEN;
          goto error;
        }
        strcpy(pn->body[pn->nBody].name.orig, segcp);
        strcpy(pn->body[pn->nBody].name.norm, segp);
        pn->body[pn->nBody].name.pack.key = cdh_PackName(segp);
        pn->nBody++;
        segp = outp;
        segcp = outcp;
        seglen = 0;
        state++;
      } else if (c == '-') {
        if (outp == segp) {
          lsts = CDH__INVTYPENAME;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        if (seglen >= sizeof(pwr_tObjName)) {
          lsts = CDH__SEGLEN;
          goto error;
        }
        strcpy(pn->body[pn->nBody].name.orig, segcp);
        strcpy(pn->body[pn->nBody].name.norm, segp);
        pn->body[pn->nBody].name.pack.key = cdh_PackName(segp);
        pn->nBody++;
        segp = outp;
        segcp = outcp;
        seglen = 0;
      } else {
        *outp++ = c;
        *outcp++ = cc;
        seglen++;
      }
      inp++;
      break;
    case 4: /* 4: id(bname)attribute[index],  attribute before '['  */
      if (c == '~') {
        if (outp != segp) {
          *outp++ = '\0';
          *outcp++ = '\0';
          pn->flags.b.attribute = 1;
          if (seglen >= sizeof(pwr_tObjName)) {
            lsts = CDH__SEGLEN;
            goto error;
          }
          strcpy(pn->attribute[0].name.orig, segcp);
          strcpy(pn->attribute[0].name.norm, segp);
          pn->attribute[0].name.pack.key = cdh_PackName(segp);
          segp = outp;
          segcp = outcp;
          seglen = 0;
        }
      } else if (c == '*') {
        if (outp == segp) {
          lsts = CDH__INVATTRNAME;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.attribute = 1;
        if (seglen >= sizeof(pwr_tObjName)) {
          lsts = CDH__SEGLEN;
          goto error;
        }
        strcpy(pn->attribute[0].name.orig, segcp);
        strcpy(pn->attribute[0].name.norm, segp);
        pn->attribute[0].name.pack.key = cdh_PackName(segp);
        segp = outp;
        segcp = outcp;
        seglen = 0;
        state++;
      } else {
        *outp++ = c;
        *outcp++ = cc;
        seglen++;
      }
      inp++;
      break;
    case 7: /* 7: id(bid)[offset.size], bid before ')'  */
      if (c == '*') {
        if (outp == segp) {
          lsts = CDH__INVBID;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        lsts = cdh_StringToTypeId(segp, &pn->bid);
        if (EVEN(lsts))
          goto error;
        pn->uId.aref.Body = pn->bid;
        pn->flags.b.bodyId = 1;
        segp = outp;
        segcp = outcp;
        seglen = 0;
        if (*(inp + 1) == '[') {
          inp++;
          state = 8;
        } else {
          state = 10;
        }
      } else {
        *outp++ = c;
        *outcp++ = cc;
        seglen++;
      }
      inp++;
      break;
    case 11: /* 11: name.attribute[index], name before ':'  */
      if (c == '~') {
        if (outp == segp) {
          lsts = CDH__INVCHAR;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.object = 1;
        if (seglen >= sizeof(pwr_tObjName)) {
          lsts = CDH__SEGLEN;
          goto error;
        }
        strcpy(pn->object[pn->nObject].name.orig, segcp);
        strcpy(pn->object[pn->nObject].name.norm, segp);
        pn->object[pn->nObject].name.pack.key = cdh_PackName(segp);
        pn->nObject++;
        segp = outp;
        segcp = outcp;
        seglen = 0;
      } else if (c == '*') {
        if (outp == segp) {
          lsts = CDH__INVCHAR;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        if (*inp == ':') {
          if (seglen >= sizeof(pwr_tObjName)) {
            lsts = CDH__SEGLEN;
            goto error;
          }
          strcpy(pn->volume.name.orig, segcp);
          strcpy(pn->volume.name.norm, segp);
          pn->volume.name.pack.key = cdh_PackName(segp);
          pn->flags.b.volume = 1;
          state = 12;
        } else if (*inp == '-') {
          pn->flags.b.object = 1;
          if (seglen >= sizeof(pwr_tObjName)) {
            lsts = CDH__SEGLEN;
            goto error;
          }
          strcpy(pn->object[pn->nObject].name.orig, segcp);
          strcpy(pn->object[pn->nObject].name.norm, segp);
          pn->object[pn->nObject].name.pack.key = cdh_PackName(segp);
          pn->nObject++;
          state = 12;
        } else if (*inp == '.') {
          pn->flags.b.object = 1;
          if (seglen >= sizeof(pwr_tObjName)) {
            lsts = CDH__SEGLEN;
            goto error;
          }
          strcpy(pn->object[pn->nObject].name.orig, segcp);
          strcpy(pn->object[pn->nObject].name.norm, segp);
          pn->object[pn->nObject].name.pack.key = cdh_PackName(segp);
          pn->nObject++;
          state = 13;
        }
        segp = outp;
        segcp = outcp;
        seglen = 0;
      } else {
        *outp++ = c;
        *outcp++ = cc;
        seglen++;
      }
      inp++;
      break;
    case 12: /* 12: name.attribute[index], name before '.'  */
      if (c == '~') {
        if (outp != segp) {
          *outp++ = '\0';
          *outcp++ = '\0';
          pn->flags.b.object = 1;
          if (seglen >= sizeof(pwr_tObjName)) {
            lsts = CDH__SEGLEN;
            goto error;
          }
          strcpy(pn->object[pn->nObject].name.orig, segcp);
          strcpy(pn->object[pn->nObject].name.norm, segp);
          pn->object[pn->nObject].name.pack.key = cdh_PackName(segp);
          pn->nObject++;
          segp = outp;
          segcp = outcp;
          seglen = 0;
        }
      } else if (c == '*') {
        if (outp == segp) {
          lsts = CDH__INVCHAR;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.object = 1;
        if (seglen >= sizeof(pwr_tObjName)) {
          lsts = CDH__SEGLEN;
          goto error;
        }
        strcpy(pn->object[pn->nObject].name.orig, segcp);
        strcpy(pn->object[pn->nObject].name.norm, segp);
        pn->object[pn->nObject].name.pack.key = cdh_PackName(segp);
        pn->nObject++;
        segp = outp;
        segcp = outcp;
        seglen = 0;
        state = 13;
      } else if (c == '-') {
        if (outp == segp) {
          lsts = CDH__INVCHAR;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.object = 1;
        if (seglen >= sizeof(pwr_tObjName)) {
          lsts = CDH__SEGLEN;
          goto error;
        }
        strcpy(pn->object[pn->nObject].name.orig, segcp);
        strcpy(pn->object[pn->nObject].name.norm, segp);
        pn->object[pn->nObject].name.pack.key = cdh_PackName(segp);
        pn->nObject++;
        segp = outp;
        segcp = outcp;
        seglen = 0;
      } else {
        *outp++ = c;
        *outcp++ = cc;
        seglen++;
      }
      inp++;
      break;
    case 13: /* 13: name.attribute[index], attribute before '['  */
      if (c == '~') {
        if (outp == segp) {
          lsts = CDH__INVATTRNAME;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.attribute = 1;
        if (seglen >= sizeof(pwr_tObjName)) {
          lsts = CDH__SEGLEN;
          goto error;
        }
        strcpy(pn->attribute[pn->nAttribute].name.orig, segcp);
        strcpy(pn->attribute[pn->nAttribute].name.norm, segp);
        pn->attribute[pn->nAttribute].name.pack.key = cdh_PackName(segp);
        pn->nAttribute++;
        segp = outp;
        segcp = outcp;
        seglen = 0;
      } else if (c == '*') {
        if (outp == segp) {
          lsts = CDH__INVATTRNAME;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.attribute = 1;
        if (seglen >= sizeof(pwr_tObjName)) {
          lsts = CDH__SEGLEN;
          goto error;
        }
        strcpy(pn->attribute[pn->nAttribute].name.orig, segcp);
        strcpy(pn->attribute[pn->nAttribute].name.norm, segp);
        pn->attribute[pn->nAttribute].name.pack.key = cdh_PackName(segp);
        pn->nAttribute++;
        segp = outp;
        segcp = outcp;
        seglen = 0;
        state++;
      } else if (c == '.') {
        if (outp == segp) {
          lsts = CDH__INVATTRNAME;
          goto error;
        }
        *outp++ = '\0';
        *outcp++ = '\0';
        pn->flags.b.attribute = 1;
        if (seglen >= sizeof(pwr_tObjName)) {
          lsts = CDH__SEGLEN;
          goto error;
        }
        strcpy(pn->attribute[pn->nAttribute].name.orig, segcp);
        strcpy(pn->attribute[pn->nAttribute].name.norm, segp);
        pn->attribute[pn->nAttribute].name.pack.key = cdh_PackName(segp);
        pn->nAttribute++;
        segp = outp;
        segcp = outcp;
        seglen = 0;
      } else {
        *outp++ = c;
        *outcp++ = cc;
        seglen++;
      }
      inp++;
      break;
    case 5: /* 5: id(bname)attribute[index], index before ']'  */
    case 8: /* 8: id(bid)[offset.size], offset before '.'  */
    case 9: /* 9: id(bid)[offset.size], size before ']'  */
    case 14: /* 14: name.attribute[index], index before ']'  */
      if (c == '*') {
        switch (state) {
        case 5:
        case 14:
          pn->index[pn->nAttribute - 1] = number;
          pn->hasIndex[pn->nAttribute - 1] = 1;
          pn->flags.b.index = 1;
          break;
        case 8:
          pn->offset = number;
          pn->uId.aref.Offset = pn->offset;
          break;
        case 9:
          pn->size = number;
          pn->uId.aref.Size = pn->size;
          pn->flags.b.index = 1;
          break;
        }
        number = 0;
        state++;
      } else {
        number = number * 10 + (c - '0');
        if (number > 65535) {
          lsts = CDH__INVATTRINDEX;
          goto error;
        }
      }
      inp++;
      break;
    case 6: /* 6:  id(bname)attribute[index], after  ']'  */
    case 10: /* 10: id(bid)[offset.size], after  ']'  */
    case 15: /* 15: name.attribute[index], after  ']'  */
      if (c == '*') {
        state = 13;
      } else {
        state = -1;
      }
      inp++;
      break;
    }
  }
 
  if (pn->nObject > 1)
    pn->flags.b.path = 1;
  *sts = lsts;
  return pn;
 
error:
  *sts = lsts;
  return NULL;
}
 
pwr_tUInt32 cdh_PackName(const char* name)
{
  cdh_uPackName pack;
  unsigned int len = strlen(name);
  const char* s = name;
  unsigned char hash = 0;
 
  while (*s)
    hash = (hash * 3) ^ *s++;
 
  pack.c.len = len;
  pack.c.hash = hash;
  pack.c.first = name[0];
  pack.c.last = name[len - 1];
 
  return pack.key;
}
 
 
char* cdh_Low(const char* s)
{
  static char buf[500];
 
  return str_ToLower(buf, s);
}
 
 
char* cdh_OpSysToStr(pwr_mOpSys opsys)
{
  static char str[32];
 
  switch (opsys) {
  case pwr_mOpSys_PPC_LINUX:
    strcpy(str, "ppc_linux");
    break;
  case pwr_mOpSys_X86_LINUX:
    strcpy(str, "x86_linux");
    break;
  case pwr_mOpSys_X86_64_LINUX:
    strcpy(str, "x86_64_linux");
    break;
  case pwr_mOpSys_X86_64_MACOS:
    strcpy(str, "x86_64_macos");
    break;
  case pwr_mOpSys_ARM_LINUX:
    strcpy(str, "arm_linux");
    break;
  case pwr_mOpSys_ARM64_LINUX:
    strcpy(str, "arm64_linux");
    break;
  case pwr_mOpSys_X86_64_FREEBSD:
    strcpy(str, "x86_64_freebsd");
    break;
  case pwr_mOpSys_X86_64_OPENBSD:
    strcpy(str, "x86_64_openbsd");
    break;
  case pwr_mOpSys_X86_CYGWIN:
    strcpy(str, "x86_cygwin");
    break;
  default:
    strcpy(str, "");
  }
  return str;
}
 
 
char* cdh_OpSysToDirStr(pwr_mOpSys opsys)
{
  static char str[80];
 
  switch (opsys) {
  case pwr_mOpSys_PPC_LINUX:
    strcpy(str, "os_linux/hw_ppc");
    break;
  case pwr_mOpSys_X86_LINUX:
    strcpy(str, "os_linux/hw_x86");
    break;
  case pwr_mOpSys_X86_64_LINUX:
    strcpy(str, "os_linux/hw_x86_64");
    break;
  case pwr_mOpSys_X86_64_MACOS:
    strcpy(str, "os_macos/hw_x86_64");
    break;
  case pwr_mOpSys_ARM_LINUX:
    strcpy(str, "os_linux/hw_arm");
    break;
  case pwr_mOpSys_ARM64_LINUX:
    strcpy(str, "os_linux/hw_arm64");
    break;
  case pwr_mOpSys_X86_64_FREEBSD:
    strcpy(str, "os_freebsd/hw_x86_64");
    break;
  case pwr_mOpSys_X86_64_OPENBSD:
    strcpy(str, "os_openbsd/hw_x86_64");
    break;
  case pwr_mOpSys_X86_CYGWIN:
    strcpy(str, "os_cygwin/hw_x86");
    break;
  default:
    strcpy(str, "");
  }
  return str;
}
 
int cdh_IsClassVolume(pwr_tVid vid)
{
  return ((cdh_cSystemClassVolMin <= vid && vid <= cdh_cSystemClassVolMax)
      || (cdh_cManufactClassVolMin <= vid && vid <= cdh_cManufactClassVolMax)
      || (cdh_cUserClassVolMin <= vid && vid <= cdh_cUserClassVolMax));
}
 
pwr_sAttrRef cdh_ArefToCastAref(pwr_sAttrRef* arp)
{
  pwr_sAttrRef cast_aref;
 
  cast_aref = *arp;
  if (arp->Flags.b.DisableAttr)
    cast_aref.Offset -= pwr_cAlignLW;
  cast_aref.Offset -= pwr_cAlignLW;
  cast_aref.Size = sizeof(pwr_tCastId);
  cast_aref.Flags.b.ObjectAttr = 0;
  cast_aref.Flags.b.CastAttr = 0;
  cast_aref.Flags.b.DisableAttr = 0;
  cast_aref.Flags.b.Indirect = 0;
  return cast_aref;
}
 
pwr_sAttrRef cdh_ArefToDisableAref(pwr_sAttrRef* arp)
{
  pwr_sAttrRef dis_aref;
 
  dis_aref = *arp;
  dis_aref.Offset -= pwr_cAlignLW;
  dis_aref.Size = sizeof(pwr_tDisableAttr);
  dis_aref.Flags.b.ObjectAttr = 0;
  dis_aref.Flags.b.CastAttr = 0;
  dis_aref.Flags.b.DisableAttr = 0;
  return dis_aref;
}
 
pwr_sAttrRef cdh_ArefAdd(pwr_sAttrRef* arp1, pwr_sAttrRef* arp2)
{
  pwr_sAttrRef aref = *arp1;
  aref.Offset += arp2->Offset;
  aref.Size = arp2->Size;
  aref.Flags = arp2->Flags;
  return aref;
}
 
void cdh_SuppressSuper(char* out, char* in)
{
  char* s = in;
  while (str_StartsWith(s, "Super."))
    s += 6;
  strcpy(out, s);
}
 
void cdh_SuppressSuperAll(char* out, char* in)
{
  char *s, *t;
 
  for (s = in, t = out; *s;) {
    if (str_StartsWith(s, "Super."))
      s += 6;
    else {
      *t = *s;
      s++;
      t++;
    }
  }
  *t = 0;
}
 
int cdh_TypeToMaxStrSize(pwr_eType type, int attr_size, int attr_elements)
{
  int size;
 
  switch (type) {
  case pwr_eType_Boolean:
    size = 1;
    break;
  case pwr_eType_Int64:
    size = 20;
    break;
  case pwr_eType_UInt64:
    size = 20;
    break;
  case pwr_eType_Enum:
  case pwr_eType_Mask:
  case pwr_eType_Status:
  case pwr_eType_NetStatus:
  case pwr_eType_Int32:
    size = 11;
    break;
  case pwr_eType_UInt32:
    size = 10;
    break;
  case pwr_eType_Int16:
    size = 6;
    break;
  case pwr_eType_UInt16:
    size = 5;
    break;
  case pwr_eType_Int8:
    size = 4;
    break;
  case pwr_eType_UInt8:
    size = 3;
    break;
  case pwr_eType_Char:
    size = 1;
    break;
  case pwr_eType_Float32:
    size = 40;
    break;
  case pwr_eType_Float64:
    size = 40;
    break;
  case pwr_eType_Time:
    size = 23;
    break;
  case pwr_eType_DeltaTime:
    size = 40;
    break;
  case pwr_eType_AttrRef:
    size = sizeof(pwr_tAName) - 1;
    break;
  case pwr_eType_TypeId:
  case pwr_eType_ClassId:
  case pwr_eType_Objid:
    size = sizeof(pwr_tOName) - 1;
    break;
  case pwr_eType_VolumeId:
    size = sizeof(pwr_tObjName) - 1;
    break;
  case pwr_eType_String:
  case pwr_eType_Text:
    size = attr_size / attr_elements - 1;
    break;
  default:
    size = 80;
  }
  return size;
}
 
int cdh_TypeToSize(pwr_eType type)
{
  int size;
 
  switch (type) {
  case pwr_eType_Boolean:
    size = sizeof(pwr_tBoolean);
    break;
  case pwr_eType_Enum:
    size = sizeof(pwr_tEnum);
    break;
  case pwr_eType_Mask:
    size = sizeof(pwr_tMask);
    break;
  case pwr_eType_Status:
  case pwr_eType_NetStatus:
    size = sizeof(pwr_tStatus);
    break;
  case pwr_eType_Int64:
  case pwr_eType_UInt64:
    size = sizeof(pwr_tInt64);
    break;
  case pwr_eType_Int32:
  case pwr_eType_UInt32:
    size = sizeof(pwr_tInt32);
    break;
  case pwr_eType_Int16:
  case pwr_eType_UInt16:
    size = sizeof(pwr_tInt16);
    break;
  case pwr_eType_Int8:
  case pwr_eType_UInt8:
    size = sizeof(pwr_tInt8);
    break;
  case pwr_eType_Char:
    size = sizeof(pwr_tChar);
    break;
  case pwr_eType_Float32:
    size = sizeof(pwr_tFloat32);
    break;
  case pwr_eType_Float64:
    size = sizeof(pwr_tFloat64);
    break;
  case pwr_eType_Time:
    size = sizeof(pwr_tTime);
    break;
  case pwr_eType_DeltaTime:
    size = sizeof(pwr_tDeltaTime);
    break;
  case pwr_eType_AttrRef:
    size = sizeof(pwr_tAttrRef);
    break;
  case pwr_eType_TypeId:
    size = sizeof(pwr_tTypeId);
    break;
  case pwr_eType_ClassId:
    size = sizeof(pwr_tClassId);
    break;
  case pwr_eType_ObjectIx:
    size = sizeof(pwr_tObjectIx);
    break;
  case pwr_eType_RefId:
    size = sizeof(pwr_tRefId);
    break;
  case pwr_eType_CastId:
    size = sizeof(pwr_tCastId);
    break;
  case pwr_eType_DisableAttr:
    size = sizeof(pwr_tDisableAttr);
    break;
  case pwr_eType_Objid:
    size = sizeof(pwr_tObjid);
    break;
  case pwr_eType_VolumeId:
    size = sizeof(pwr_tVolumeId);
    break;
  default:
    size = 0;
  }
  return size;
}
 
 
char* cdh_StringToObjectName(char* t, const char* s)
{
  static const char valtab[] = "\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!$!!!!!!!!!!!0123456789!!!!!!\
!ABCDEFGHIJKLMNOPQRSTUVWXYZ!!!!_\
!^^^^^^^^^^^^^^^^^^^^^^^^^^!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\
ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏ!ÑÒÓÔÕÖ×ØÙÚÛÜÝ!!\
^^^^^^^^^^^^^^^^!^^^^^^^^^^^^^!!";
  char* rs = t;
  const char* s1 = s;
 
  if (t == NULL)
    return NULL;
  if (s == NULL)
    s = t;
 
  while (*s1)
    if (valtab[(unsigned char)*s1] == '!') {
      if (s1 == s)
        *t++ = 'O';
      else
        *t++ = '_';
      s1++;
    } else
      *t++ = *s1++;
 
  *t = *s1; /* Copy the null byte.  */
 
  return rs;
}
 
 
pwr_tStatus cdh_NextObjectName(char* t, const char* s)
{
  int i;
  int num;
  int len = strlen(s);
  char name[80];
 
  for (i = len - 1; i >= 0; i--) {
    if (isdigit(s[i]) == 0)
      break;
  }
  if (i == len - 1)
    return CDH__NONAME;
 
  strncpy(name, s, i + 1);
  sscanf(&s[i + 1], "%d", &num);
  num++;
  if (s[i + 1] == '0')
    sprintf(&name[i + 1], "%0*d", len - i - 1, num);
  else
    sprintf(&name[i + 1], "%d", num);
 
  if (strlen(name) > sizeof(pwr_tObjName) - 1)
    return CDH__NAMELEN;
 
  strcpy(t, name);
  return CDH__SUCCESS;
}
 
 
void cdh_CutNameSegments(char* outname, char* name, int segments)
{
  char* s[20];
  int i, j, last_i = 0;
 
  if (segments == 0) {
    strcpy(outname, "");
    return;
  }
 
  for (i = 0; i < segments; i++) {
    s[i] = strrchr(name, '-');
    if (s[i] == 0) {
      last_i = i;
      break;
    }
    *s[i] = '+';
    last_i = i;
  }
  for (j = 0; j <= last_i; j++) {
    if (s[j] != 0)
      *s[j] = '-';
  }
  if (s[last_i] == 0)
    strcpy(outname, name);
  else
    strcpy(outname, s[last_i] + 1);
}
 
 
pwr_tUInt32 cdh_AttrSize(pwr_sParInfo* info)
{
  if (info->Flags & PWR_MASK_POINTER && !(info->Flags & PWR_MASK_PRIVATE))
    /* Return pointer size, info size contains size of pointed entity */
    return sizeof(pwr_tUInt64) * info->Elements;
 
  return info->Size;
}
 
 
pwr_tUInt32 cdh_AttrElemSize(pwr_sParInfo* info)
{
  return cdh_AttrSize(info) / info->Elements;
}