52         assert(ind <= (
int)
m_Names.size());
   144         short type = oldStrc[0];
   151                         int eleLen = curStruct[1];
   154                         for (
int j=0; j<eleLen; j++, curStruct+=2)
   156                                 if (curStruct[0] == type)
   160                                         if (
m_Names[curStruct[1]].m_isPointer)
   179         assert(!(
m_Names.size() == 0));
   199 #ifdef SLOW_FORWARD_COMPATIBLE   200                 char* typeName = 
mTypes[oldLookup];
   207                 short *curStruct = memDNA->
mStructs[newLookup];
   213                         short *curStruct = memDNA->
mStructs[oldLookup];
   221 #ifndef TEST_BACKWARD_FORWARD_COMPATIBILITY   223                         if (curStruct[1] == oldStruct[1])
   226                                 if (
mTlens[oldStruct[0]] == memDNA->
mTlens[curStruct[0]])
   229                                         int elementLength = oldStruct[1];
   236                                         for (
int j=0; j<elementLength; j++, curStruct+=2, oldStruct+=2)
   241                                                 if (strcmp(
mTypes[oldStruct[0]], memDNA->
mTypes[curStruct[0]])!=0)
   248                                                 if (strcmp(
m_Names[oldStruct[1]].m_name, memDNA->
m_Names[curStruct[1]].m_name)!=0)
   279         int len = strlen(name);
   294         bp = strchr(name, 
'[');
   299         while (++bp < name+len-1) {
   304                 if (c <= '9' && c >= 
'0') {
   308                         printf(
"array parse error.\n");
   317         bp = strchr(bp, 
'[');
   322         while (++bp < name+len-1) {
   327                 if (c <= '9' && c >= 
'0') {
   331                         printf(
"array2 parse error.\n");
   351         int *intPtr=0;
short *shtPtr=0;
   352         char *cp = 0;
int dataLen =0;
long nr=0;
   363         if (strncmp(data, 
"SDNA", 4)==0)
   381         for ( i=0; i<dataLen; i++)
   412         assert(strncmp(cp, 
"TYPE", 4)==0); intPtr++;
   422         for ( i=0; i<dataLen; i++)
   448         assert(strncmp(cp, 
"TLEN", 4)==0); intPtr++;
   452         shtPtr = (
short*)intPtr;
   453         for ( i=0; i<dataLen; i++, shtPtr++)
   460         if (dataLen & 1) shtPtr++;
   473         intPtr = (
int*)shtPtr;
   475         assert(strncmp(cp, 
"STRC", 4)==0); intPtr++;
   485         shtPtr = (
short*)intPtr;
   486         for ( i=0; i<dataLen; i++)
   497                         for (
int a=0; a<len; a++, shtPtr+=2)
   504                         shtPtr+= (2*shtPtr[1])+2;
   527         int len = strlen(
string);
   531         for (
int i=0; i<len; i++)
   553         for (i=0;i<numTypes;i++)
   570                 short* newStruct = 
mStructs[oldLookup];
   571                 char* typeName = 
mTypes[newStruct[0]];
   572                 printf(
"%3d: %s ",i,typeName);
   575                 int len = oldStruct[1];
   576                 printf(
" (%d fields) ",len);
   581                 for (j=0; j<len; ++j,oldStruct+=2) {
   582                         const char* name = 
m_Names[oldStruct[1]].m_name;
   583                         printf(
"%s %s", 
mTypes[oldStruct[0]],name);
   587                         if (
m_Names[oldStruct[1]].m_isPointer)
   594                         printf(
" /* %d bytes */",elemNumBytes*arrayDimensions);
   601                         totalBytes+=elemNumBytes*arrayDimensions;
   603                 printf(
"\ntotalBytes=%d\n\n",totalBytes);
   611         for (i=0; i<bf->types_count; ++i) {
   614                         printf(
"%3d: sizeof(%s%s)=%d",
   616                                 bf->types[i].is_struct ? 
"struct " : 
"atomic ",
   617                                 bf->types[i].name, bf->types[i].size);
   618                         if (bf->types[i].is_struct) {
   620                                 printf(
", %d fields: { ", bf->types[i].fieldtypes_count);
   621                                 for (j=0; j<bf->types[i].fieldtypes_count; ++j) {
   623                                                 bf->types[bf->types[i].fieldtypes[j]].name,
   624                                                 bf->names[bf->types[i].fieldnames[j]]);
   625                                         if (j == bf->types[i].fieldtypes_count-1) {
 
void push_back(const T &_Val)
btAlignedObjectArray< int > mCMPFlags
int getArraySizeNew(short name)
btAlignedObjectArray< short * > mStructs
bool lessThan(bDNA *other)
const T & at(int n) const 
void dumpTypeDefinitions()
void initCmpFlags(bDNA *memDNA)
btAlignedObjectArray< short > mTlens
btAlignedObjectArray< bNameInfo > m_Names
static int swapInt(int inte)
int size() const 
return the number of elements in the array 
btHashMap< btHashInt, int > mStructReverse
static int name_is_array(char *name, int *dim1, int *dim2)
void insert(const Key &key, const Value &value)
int getArraySize(char *str)
const Value * find(const Key &key) const 
bool flagNotEqual(int dna_nr)
very basic hashable string implementation, compatible with btHashMap 
void resize(int newsize, const T &fillData=T())
short * getStruct(int ind)
void init(char *data, int len, bool swap=false)
bool flagEqual(int dna_nr)
static short swapShort(short sht)
void initRecurseCmpFlags(int i)
btAlignedObjectArray< char * > mTypes
btHashMap< btHashString, int > mTypeLookup
int getReverseType(short type)
bool flagNone(int dna_nr)