← Back to branch summary

~ubuntu-branches/ubuntu/trusty/sblim-sfcb/trusty-proposed

« back to all changes in this revision

Viewing changes to objectImpl.c

  • Committer: Bazaar Package Importer
  • Author(s): Thierry Carrez
  • Date: 2009-06-08 12:04:49 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090608120449-byfplk09rqz8rtg6
Tags: 1.3.3-0ubuntu1
* New upstream release.
* debian/rules: Removed rpath hacks, SFCB default build handles that now.
* Removed 1934753-remove-assignment.diff, now upstream.
* Refreshed patch cim-schema-location.diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
objectImpl.c
177
177
}
178
178
 
179
179
 
180
 
static long addClString(ClObjectHdr * hdr, const char *str)
 
180
long addClString(ClObjectHdr * hdr, const char *str)
181
181
{
182
182
   _SFCB_ENTER(TRACE_OBJECTIMPL, "addClString");
183
183
 
264
264
        return(retCode);
265
265
}
266
266
 
 
267
 
 
268
/* TODO: search for duplicate code between here and addObjectPropertyH() */
267
269
static long addClArray(ClObjectHdr * hdr, CMPIData d)
268
270
{
269
271
   _SFCB_ENTER(TRACE_OBJECTIMPL, "addClArray");
609
611
   case CMPI_chars:
610
612
   case CMPI_string:
611
613
      return "string";
 
614
   case CMPI_real64:
 
615
      return "real64";
 
616
   case CMPI_real32:
 
617
      return "real32";
612
618
   case CMPI_sint64:
613
619
      return "sint64";
614
620
   case CMPI_uint64:
627
633
      return "sint8";
628
634
   case CMPI_boolean:
629
635
      return "boolean";
 
636
   case CMPI_char16:
 
637
      return "char16";
630
638
   case CMPI_ref:
631
 
      return "reference";
 
639
      return "ref";
 
640
   case CMPI_instance:
 
641
      return "instance";
632
642
   case CMPI_dateTime:
633
643
      return "dateTime";
 
644
   default:
 
645
      return "unknownType";
634
646
   }
635
 
   return "*??*";
636
647
}
637
648
 
638
649
static char *dataValueToString(ClObjectHdr * hdr, CMPIData * d)
639
650
{
640
651
   static char *True = "true", *False = "false";
 
652
   // Allocate for the biggest numeric type we'll get, if 
 
653
   // we get a char type, it's reallocated below.
 
654
   char *retval=malloc(sizeof(d->value.real64));
641
655
   switch (d->type) {
642
 
   case CMPI_chars:
643
 
      return (char *) ClObjectGetClString(hdr, (ClString *) & d->value.chars);
644
 
   case CMPI_sint32:
645
 
      return "sint32";
646
 
   case CMPI_boolean:
647
 
      return d->value.boolean ? True : False;
 
656
       case CMPI_chars:
 
657
          {
 
658
             char *ret = (char *) ClObjectGetClString(hdr, (ClString *) & d->value.chars);
 
659
             if (ret) {
 
660
                 retval=realloc(retval,sizeof(ret));
 
661
                 strcpy(retval, ret); }
 
662
             else
 
663
                 return "\"\"";
 
664
          }
 
665
          break;
 
666
       case CMPI_char16:
 
667
          {
 
668
             char *ret = (char *) ClObjectGetClString(hdr, (ClString *) & d->value.char16);
 
669
             if (ret) {
 
670
                 retval=realloc(retval,sizeof(ret));
 
671
                 strcpy (retval, ret); }
 
672
             else
 
673
                 return "\"\"";
 
674
          }
 
675
          break;
 
676
       case CMPI_real64:
 
677
          sprintf(retval, "%lf", d->value.real64);
 
678
          break;
 
679
       case CMPI_real32:
 
680
          sprintf(retval, "%f", d->value.real32);
 
681
          break;
 
682
       case CMPI_sint64:
 
683
          sprintf(retval, "%lld", d->value.sint64);
 
684
          break;
 
685
       case CMPI_sint32:
 
686
          sprintf(retval, "%d", d->value.sint32);
 
687
          break;
 
688
       case CMPI_sint16:
 
689
          sprintf(retval, "%d", d->value.sint16);
 
690
          break;
 
691
       case CMPI_sint8:
 
692
          sprintf(retval, "%d", d->value.sint8);
 
693
          break;
 
694
       case CMPI_uint64:
 
695
          sprintf(retval, "%llu", d->value.uint64);
 
696
          break;
 
697
       case CMPI_uint32:
 
698
          sprintf(retval, "%u", d->value.uint32);
 
699
          break;
 
700
       case CMPI_uint16:
 
701
          sprintf(retval, "%u", d->value.uint16);
 
702
          break;
 
703
       case CMPI_uint8:
 
704
          sprintf(retval, "%u", d->value.uint8);
 
705
          break;
 
706
       case CMPI_boolean:
 
707
          strcpy(retval, d->value.boolean ? True : False);
 
708
          break;
 
709
       default:
 
710
          strcpy(retval, "***??***");
648
711
   }
649
 
   return "*??*";
 
712
   return retval;
650
713
}
651
714
 
652
715
 
782
845
   cat2string(sc, ClObjectGetClString(hdr, &q->id));
783
846
   if (q->data.state != CMPI_nullValue) {
784
847
      cat2string(sc, "(");
785
 
      cat2string(sc, dataValueToString(hdr, &q->data));
 
848
      char * val=dataValueToString(hdr, &q->data);
 
849
      cat2string(sc, val);
786
850
      cat2string(sc, ")");
 
851
      free(val);
787
852
   }
788
853
   if (sb & 1) cat2string(sc, "]");
789
854
   return sc->str + o;
1117
1182
   ClProperty *p;
1118
1183
 
1119
1184
   p=(ClProperty*)getSectionPtr(hdr,prps); 
1120
 
 
1121
1185
   for (i = 0; i < prps->used; i++) {
1122
1186
      if (strcasecmp(id, ClObjectGetClString(hdr, &(p + i)->id)) == 0)
1123
1187
         return i + 1;
1148
1212
   ClQualifier *q;
1149
1213
   char *array = NULL;
1150
1214
 
 
1215
   if (p->data.state && CMPI_nullValue)
 
1216
       return NULL;
 
1217
 
1151
1218
   q = (ClQualifier *) ClObjectGetClSection(hdr, &p->qualifiers);
1152
1219
   if ((l = p->qualifiers.used)) {
1153
1220
      for (i = 0; i < l; sb = 0, i++) {
1158
1225
      cat2string(sc, "\n");
1159
1226
   }
1160
1227
 
 
1228
 
1161
1229
   cat2string(sc, " ");
1162
1230
   cat2string(sc, datatypeToString(&p->data, &array));
1163
1231
   cat2string(sc, " ");
1164
1232
   cat2string(sc, ClObjectGetClString(hdr, &p->id));
1165
1233
   if (array) cat2string(sc, array);
1166
1234
   cat2string(sc, " = ");
1167
 
   cat2string(sc, dataValueToString(hdr,&p->data));     
 
1235
 
 
1236
   char *val = dataValueToString(hdr,&p->data);
 
1237
   if (val == NULL || *val == 0)
 
1238
       cat2string(sc, "\"\"");
 
1239
   else
 
1240
       cat2string(sc, val);
 
1241
 
1168
1242
   cat2string(sc, ";\n");
 
1243
   free(val);
1169
1244
   return sc->str + o;
1170
1245
}
1171
1246
 
1232
1307
   CMPIStatus st;
1233
1308
 
1234
1309
   _SFCB_ENTER(TRACE_OBJECTIMPL, "addObjectPropertyH");
1235
 
 
 
1310
   /* if id is not in the section (prps), add it, increment number of props */
1236
1311
   if ((i = ClObjectLocateProperty(hdr, prps, id)) == 0) {
1237
1312
      p = (ClProperty *) ensureClSpace(hdr, prps, sizeof(*p), 8);
1238
1313
      p = p + (prps->used++);
1298
1373
            _SFCB_RETURN(-CMPI_RC_ERR_TYPE_MISMATCH);
1299
1374
            
1300
1375
         if (d.type != CMPI_chars) {
 
1376
            if (d.type != CMPI_string) {
 
1377
               _SFCB_RETURN(-CMPI_RC_ERR_TYPE_MISMATCH);
 
1378
            }
1301
1379
            replaceClString(hdr, (long)od.value.chars, "");
1302
1380
            (p + i - 1)->data = d;
1303
1381
         }
1315
1393
      
1316
1394
      else if (od.type == CMPI_dateTime && (d.state & CMPI_nullValue) == 0) {
1317
1395
         char chars[26];
 
1396
         if (d.type != CMPI_dateTime) {
 
1397
           _SFCB_RETURN(-CMPI_RC_ERR_TYPE_MISMATCH);
 
1398
         }
1318
1399
         dateTime2chars(d.value.dateTime, NULL, chars);
1319
1400
         if (od.value.chars) {
1320
1401
           (p + i - 1)->data = d;
1329
1410
 
1330
1411
      else if (od.type == CMPI_ref && (d.state & CMPI_nullValue) == 0) {
1331
1412
         char chars[4096] = { 0 };
 
1413
         if (d.type != CMPI_ref) {
 
1414
           _SFCB_RETURN(-CMPI_RC_ERR_TYPE_MISMATCH);
 
1415
         }
1332
1416
         sfcb_pathToChars(d.value.ref, &st, chars);
1333
1417
         if (od.value.chars) {   
1334
1418
           (p + i - 1)->data = d;
1342
1426
      }
1343
1427
      
1344
1428
      else if ((od.type & CMPI_ARRAY) && (d.state & CMPI_nullValue) == 0) {
 
1429
        if (!(d.type & CMPI_ARRAY)) {
 
1430
           _SFCB_RETURN(-CMPI_RC_ERR_TYPE_MISMATCH);
 
1431
        }
1345
1432
        if (od.value.array) {
1346
1433
          (p + i - 1)->data = d;
1347
1434
          replaceClArray(hdr, (long)od.value.array, d);
1757
1844
   return newInstanceH(ns, cn);
1758
1845
}
1759
1846
 
 
1847
ClInstance *ClInstanceNewFromMof(const char *ns, const char *cn)
 
1848
{
 
1849
   ClInstance *inst = newInstanceH(ns, cn);
 
1850
   if (inst)
 
1851
       inst->hdr.flags |= HDR_FromMof;
 
1852
   return inst;
 
1853
}
 
1854
 
1760
1855
static long sizeInstanceH(ClObjectHdr * hdr, ClInstance * inst)
1761
1856
{
1762
1857
   long sz = sizeof(*inst);
1842
1937
 
1843
1938
   p = (ClProperty *) ClObjectGetClSection(&inst->hdr, &inst->properties);
1844
1939
   for (i = 0, l = inst->properties.used; i < l; i++) {
1845
 
      addPropertyToString(&sc, &inst->hdr, p + i);
 
1940
      addPropertyToString(&sc, &inst->hdr, (p+i));
1846
1941
   }
1847
1942
 
1848
1943
   cat2string(&sc, "};\n");