IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ticket #906: psMetadataConfig_endian.patch

File psMetadataConfig_endian.patch, 13.2 KB (added by jester@…, 19 years ago)

Paul's patch to address the byte-order issue

  • src/types/psMetadataConfig.c 

    ? psMetadataConfig_endian.patch
RCS file: /data/panstarrs/cvsroot/psLib/src/types/psMetadataConfig.c,v
retrieving revision 1.137
diff -u -p -r1.137 psMetadataConfig.c
    bool parseMetadataItem(char* keyName,  
    677677    char*                strComment    = NULL;
    678678    psS32                status        = 0;
    679679    psMetadata*          md            = NULL;
    680     psF64                tempDbl       = 0.0;
    681     bool               tempBool      = false;
    682     psS64                tempInt       = 0;
    683     psU64                tempUint      = 0;
    684     psVector*            tempVec       = NULL;
    685     char*                tempStr       = NULL;
    686680    psArray*             nonUniqueKeys = NULL;
    687681    psMetadata*          tempMeta      = NULL;
    688682    p_psParseLevelInfo*  nextLevelInfo = NULL;
    689     psTime *mTime;
    690     psTimeType timeType = PS_TIME_TAI;
    691683
    692684    long level = psArrayLength(levelArray) - 1;
    693685
    … … bool parseMetadataItem(char* keyName,  
    844836        }
    845837    }
    846838
     839#define PARSE_ADD_CASE(NAME, TYPE, PARSEFUNC) \
     840  case PS_DATA_##NAME: { \
     841      ps##TYPE value = PARSEFUNC(strValue, &status); \
     842      if (!status) { \
     843          addStatus = psMetadataAdd##TYPE(md, PS_LIST_TAIL, keyName, flags, strComment, value); \
     844      } else { \
     845          psError(PS_ERR_IO, true, \
     846                  _("Failed to parse the value '%s' of metadata item %s, type %s."), \
     847                  strValue, keyName, strType); \
     848          returnValue = false; \
     849      } \
     850      break; \
     851  }
     852
    847853    // Need to add item to metadata so get pointer to metadata
    848854    status = 0;
    849855    md = ((p_psParseLevelInfo*)(levelArray->data[level]))->metadata;
    850856    nonUniqueKeys = ((p_psParseLevelInfo*)(levelArray->data[level]))->nonUniqueKeyArray;
    851857    switch(mdType) {
    852     case PS_DATA_STRING:
    853         addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
    854                                   mdType | flags,
    855                                   strComment, strValue);
    856         break;
    857     case PS_DATA_BOOL:
    858         tempBool = parseBool(strValue, &status);
    859         if(!status) {
    860             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
    861                                       mdType | flags,
    862                                       strComment, tempBool);
    863         } else {
    864             psError(PS_ERR_IO, true,
    865                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
     858        PARSE_ADD_CASE(BOOL,   Bool,   parseBool);
     859        PARSE_ADD_CASE(F32,    F32,    parseDouble);
     860        PARSE_ADD_CASE(F64,    F64,    parseDouble);
     861        PARSE_ADD_CASE(S8,     S8,     parseSignedInt);
     862        PARSE_ADD_CASE(S16,    S16,    parseSignedInt);
     863        PARSE_ADD_CASE(S32,    S32,    parseSignedInt);
     864        PARSE_ADD_CASE(S64,    S64,    parseSignedInt);
     865        PARSE_ADD_CASE(U8,     U8,     parseUnsignedInt);
     866        PARSE_ADD_CASE(U16,    U16,    parseUnsignedInt);
     867        PARSE_ADD_CASE(U32,    U32,    parseUnsignedInt);
     868        PARSE_ADD_CASE(U64,    U64,    parseUnsignedInt);
     869      case PS_DATA_STRING:
     870        addStatus = psMetadataAddStr(md, PS_LIST_TAIL, keyName, flags, strComment, strValue);
     871        break;
     872      case PS_DATA_TIME: {
     873          psTimeType timeType = PS_TIME_TAI;
     874          if(!strncmp(strType, "UTC", 3)) {
     875              timeType = PS_TIME_UTC;
     876          } else if(!strncmp(strType, "TAI", 3)) {
     877              timeType = PS_TIME_TAI;
     878          } else if(!strncmp(strType, "UT1", 3)) {
     879              timeType = PS_TIME_UT1;
     880          } else if(!strncmp(strType, "TT", 3)) {
     881              timeType = PS_TIME_TT;
     882          }
     883
     884          psTime *mTime = parseTime(strValue, timeType, &status);
     885          if(!status) {
     886              addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
     887                                        mdType | flags,
     888                                        strComment, mTime);
     889          } else {
     890              psError(PS_ERR_IO, true,
     891                      _("Failed to parse the value '%s' of metadata item %s, type %s."),
    866892                      strValue, keyName, strType);
    867             returnValue = false;
    868         }
    869         break;
    870     case PS_DATA_F32:
    871     case PS_DATA_F64:
    872         tempDbl = parseDouble(strValue, &status);
    873         if(!status) {
    874             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
    875                                       mdType | flags,
    876                                       strComment, tempDbl);
    877         } else {
    878             psError(PS_ERR_IO, true,
    879                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
     893              returnValue = false;
     894          }
     895          psFree(mTime);
     896          break;
     897      }
     898      case PS_DATA_VECTOR: {
     899          psVector *tempVec = parseVector(strValue, vectorType, &status);
     900          if(!status) {
     901              addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName+1,
     902                                        mdType | flags,
     903                                        strComment, tempVec);
     904          } else {
     905              psError(PS_ERR_IO, true,
     906                      _("Failed to parse the value '%s' of metadata item %s, type %s."),
    880907                      strValue, keyName, strType);
    881             returnValue = false;
    882         }
    883         break;
    884     case PS_DATA_S8:
    885         tempInt = (psS8) parseSignedInt(strValue, &status);
    886         if(!status) {
    887             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    888                                       strComment, tempInt);
    889         } else {
    890             psError(PS_ERR_IO, true,
    891                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    892                     strValue, keyName, strType);
    893             returnValue = false;
    894         }
    895         break;
    896     case PS_DATA_S16:
    897         tempInt = (psS16) parseSignedInt(strValue, &status);
    898         if(!status) {
    899             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    900                                       strComment, tempInt);
    901         } else {
    902             psError(PS_ERR_IO, true,
    903                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    904                     strValue, keyName, strType);
    905             returnValue = false;
    906         }
    907         break;
    908     case PS_DATA_S32:
    909         tempInt = (psS32) parseSignedInt(strValue, &status);
    910         if(!status) {
    911             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    912                                       strComment, tempInt);
    913         } else {
    914             psError(PS_ERR_IO, true,
    915                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    916                     strValue, keyName, strType);
    917             returnValue = false;
    918         }
    919         break;
    920     case PS_DATA_S64:
    921         tempInt = (psS64) parseSignedInt(strValue, &status);
    922         if(!status) {
    923             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    924                                       strComment, tempInt);
    925         } else {
    926             psError(PS_ERR_IO, true,
    927                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    928                     strValue, keyName, strType);
    929             returnValue = false;
    930         }
    931         break;
    932     case PS_DATA_U8:
    933         tempUint = (psU8)parseUnsignedInt(strValue, &status);
    934         if(!status) {
    935             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    936                                       strComment, tempUint);
    937         } else {
    938             psError(PS_ERR_IO, true,
    939                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    940                     strValue, keyName, strType);
    941             returnValue = false;
    942         }
    943         break;
    944     case PS_DATA_U16:
    945         tempUint = (psU16)parseUnsignedInt(strValue, &status);
    946         if(!status) {
    947             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    948                                       strComment, tempUint);
    949         } else {
    950             psError(PS_ERR_IO, true,
    951                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    952                     strValue, keyName, strType);
    953             returnValue = false;
    954         }
    955         break;
    956     case PS_DATA_U32:
    957         tempUint = (psU32)parseUnsignedInt(strValue, &status);
    958         if(!status) {
    959             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    960                                       strComment, tempUint);
    961         } else {
    962             psError(PS_ERR_IO, true,
    963                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    964                     strValue, keyName, strType);
    965             returnValue = false;
    966         }
    967         break;
    968     case PS_DATA_U64:
    969         tempUint = (psU64)parseUnsignedInt(strValue, &status);
    970         if(!status) {
    971             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    972                                       strComment, tempUint);
    973         } else {
    974             psError(PS_ERR_IO, true,
    975                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    976                     strValue, keyName, strType);
    977             returnValue = false;
    978         }
    979         break;
    980     case PS_DATA_TIME:
    981         if(!strncmp(strType, "UTC", 3)) {
    982             timeType = PS_TIME_UTC;
    983         } else if(!strncmp(strType, "TAI", 3)) {
    984             timeType = PS_TIME_TAI;
    985         } else if(!strncmp(strType, "UT1", 3)) {
    986             timeType = PS_TIME_UT1;
    987         } else if(!strncmp(strType, "TT", 3)) {
    988             timeType = PS_TIME_TT;
    989         }
    990 
    991         mTime = parseTime(strValue, timeType, &status);
    992         if(!status) {
    993             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
    994                                       mdType | flags,
    995                                       strComment, mTime);
    996         } else {
    997             psError(PS_ERR_IO, true,
    998                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    999                     strValue, keyName, strType);
    1000             returnValue = false;
    1001         }
    1002         psFree(mTime);
    1003         break;
    1004     case PS_DATA_VECTOR:
    1005         tempVec = parseVector(strValue, vectorType, &status);
    1006         if(!status) {
    1007             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName+1,
    1008                                       mdType | flags,
    1009                                       strComment, tempVec);
    1010         } else {
    1011             psError(PS_ERR_IO, true,
    1012                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    1013                     strValue, keyName, strType);
    1014             returnValue = false;
    1015         }
    1016         psFree(tempVec);
    1017         break;
     908              returnValue = false;
     909          }
     910          psFree(tempVec);
     911          break;
     912      }
    1018913    case PS_DATA_METADATA_MULTI:
    1019914        // Add key to non-unique array of keys
    1020915        // Check for duplicate MULTI lines
    … … bool parseMetadataItem(char* keyName,  
    1026921                return false;
    1027922            }
    1028923        }
    1029         tempStr = psStringCopy(keyName);
     924        psString tempStr = psStringCopy(keyName);
    1030925        nonUniqueKeys = psArrayAdd(nonUniqueKeys,0,tempStr);
    1031926        addStatus = true;
    1032927        psFree(tempStr);
    … … static psString formatMetadataItem(psMet  
    15461441        FORMAT_PRIMITIVE_METADATAITEM(F64, ".15g");
    15471442        break;
    15481443      case PS_DATA_STRING: {
    1549           bool valid = false;
    1550           if (item->data.str && strlen(item->data.str) > 0) {
    1551               char *p = item->data.str;
    1552               while (*p && isblank(*p)) p++;
    1553               if (*p) valid = true;
    1554           }
    1555           if (valid) {
    1556               psStringAppend(&content, "%-15s  %-8s  %-15s",
    1557                              item->name, "STR", item->data.str);
    1558           } else {
    1559               psStringAppend(&content, "%-15s  %-8s  %-15s",
    1560                              item->name, "STR", "NULL");
    1561           }
    1562           if (item->comment && strncmp(item->comment,"",2)) {
    1563               psStringAppend(&content, "  # %s", item->comment);
    1564           }
    1565           psStringAppend(&content, " \n");
    1566           break;
     1444          bool valid = false;
     1445          if (item->data.str && strlen(item->data.str) > 0) {
     1446              char *p = item->data.str;
     1447              while (*p && isblank(*p)) p++;
     1448              if (*p) valid = true;
     1449          }
     1450          if (valid) {
     1451              psStringAppend(&content, "%-15s  %-8s  %-15s",
     1452                             item->name, "STR", item->data.str);
     1453          } else {
     1454              psStringAppend(&content, "%-15s  %-8s  %-15s",
     1455                             item->name, "STR", "NULL");
     1456          }
     1457          if (item->comment && strncmp(item->comment,"",2)) {
     1458              psStringAppend(&content, "  # %s", item->comment);
     1459          }
     1460          psStringAppend(&content, " \n");
     1461          break;
    15671462      }
    15681463    case PS_DATA_METADATA: {
    15691464            if (item->comment && strncmp(item->comment,"",2)) {