ByteArray * getStringForVersionChecksumBytes(VersionChecksumBytes * self){
if (self->cachedString) {
incrementReferenceCount(self->cachedString);
return self->cachedString;
} else {
reverseBytes(getByteArray(self));
BigInt bytes;
BigIntAlloc(&bytes, getByteArray(self)->length);
bytes.length = getByteArray(self)->length;
memcpy(bytes.data, getByteArrayData(getByteArray(self)), bytes.length);
char * string = encodeBase58(bytes.data,bytes.length);
if (! string){
return NULL;
}
ByteArray * str = createNewByteArrayFromString(string, TRUE, getByteArray(self)->onErrorReceived);
if (! str) {
free(string);
return NULL;
}
reverseBytes(getByteArray(self));
if (self->cacheString) {
self->cachedString = str;
incrementReferenceCount(str);
}
return str;
}
}
void showTargetRange(struct xaAli *xa, int tOff, int tLen, char strand, boolean showSym)
/* Display a range of xa, indexed by target. */
{
char *hSym = xa->hSym, *qSym = xa->qSym, *tSym = xa->tSym;
int symCount = xa->symCount;
int tPos = 0;
int i = 0;
int j;
int maxLineLen = 50;
int lineLen;
int startIx;
int fullLen;
int endIx;
/* Figure out starting and ending positions taking inserts in target
* into account. */
startIx = lenWithDashes(tSym, tOff);
fullLen = lenWithDashes(tSym+startIx, tLen);
endIx = startIx + fullLen;
if (strand == '-')
{
reverseComplement(qSym+startIx, fullLen);
reverseComplement(tSym+startIx, fullLen);
reverseBytes(hSym+startIx, fullLen);
}
for (i=startIx; i<endIx; i += lineLen)
{
lineLen = endIx-i;
if (lineLen > maxLineLen)
lineLen = maxLineLen;
mustWrite(stdout, qSym+i, lineLen);
fputc('\n', stdout);
for (j=0; j<lineLen; ++j)
{
char c = (toupper(qSym[i+j]) == toupper(tSym[i+j]) ? '|' : ' ');
fputc(c, stdout);
}
fputc('\n', stdout);
mustWrite(stdout, tSym+i, lineLen);
fputc('\n', stdout);
//if (showSym)
{
mustWrite(stdout, hSym+i, lineLen);
fputc('\n', stdout);
}
fputc('\n', stdout);
}
if (strand == '-')
{
reverseComplement(qSym+startIx, fullLen);
reverseComplement(tSym+startIx, fullLen);
reverseBytes(hSym+startIx, fullLen);
}
}
void reTraceFixMaf(char *mafFileName, char *qaFileName, char *newMafFileName)
/* reTraceFixMaf - Add quality line and recompute chrom line in maf. */
{
struct mafFile *mFile = mafReadAll(mafFileName);
struct qaSeq *qaList = qaRead(qaFileName);
struct hash *qaHash = makeQaHash(qaList);
struct mafAli *ali;
for (ali = mFile->alignments; ali != NULL; ali = ali->next)
{
if (!ali->components || !ali->components->next)
errAbort("Something's up with the maf.");
else
{
struct mafComp *secondSrc = ali->components->next;
struct qaSeq *qas = hashMustFindVal(qaHash, secondSrc->src);
int i, offset;
int length = strlen(secondSrc->text);
if (secondSrc->strand == '-')
reverseBytes(qas->qa, qas->size);
offset = secondSrc->start;
AllocArray(secondSrc->quality, length+1);
for (i = 0; i < length; i++)
{
if (secondSrc->text[i] == '-')
secondSrc->quality[i] = '-';
else
{
int q = (int)qas->qa[offset++];
char c = 'F';
if ((q >= 0) && (q < 45))
{
q = q / 5;
c = '0' + q;
}
else if ((q >= 45) && (q < 98))
c = '9';
else if (q == 99)
c = '0';
else
c = 'F';
secondSrc->quality[i] = c;
}
}
secondSrc->quality[length] = '\0';
if (secondSrc->strand == '-')
reverseBytes(qas->qa, qas->size);
}
}
mafWriteAll(mFile, newMafFileName);
hashFree(&qaHash);
qaSeqFreeList(&qaList);
mafFileFree(&mFile);
}
void populate_Obj_Floats_socket (OTA_Object* p, int socketfd, int flags)
{
BYTE elementsize = 0;
UInt16 datasize = 0;
UInt32 d32 = 0;
ULong d64 = 0;
BYTE* buff ;
int i=0;
// reading byte size
int n = recv(socketfd, &datasize, 2, flags);
reverseBytes((BYTE*)&datasize, 2);
p->payload.obj_floats.data_size = datasize;
n = recv(socketfd, &elementsize, 1, flags);
p->payload.obj_floats.element_size = elementsize;
if(datasize == 0 || elementsize == 0)
{
p->payload.obj_floats.obj_data = NULL;
return;
}
// total size
buff = malloc(datasize);
for(i=0; i< datasize/elementsize; i++)
{
switch (elementsize)
{
case 4:
n = recv(socketfd, &d32, 4, flags);
reverseBytes((BYTE*)&d32, 4);
memcpy(&(buff[i*elementsize]), &d32, 4);
break;
case 8:
n = recv(socketfd, &d64, 8, flags);
reverseBytes((BYTE*)&d64, 8);
memcpy(&(buff[i*elementsize]), &d64, 8);
break;
}
}
p->payload.obj_floats.obj_data = buff;
return;
}
BYTEARRAY* Floats_to_BYTES (OTA_Object* p)
{
int size = p->size(p);
BYTEARRAY* array = new_BYTEARRAY(size);
int offset = 0;
UInt16 d16 = 0;
UInt32 d32 = 0;
ULong d64 = 0;
UInt16 datasize;
BYTE elementsize;
int i=0;
array->data[offset++] = p->objectid;
array->data[offset++] = p->objtype;
datasize = p->payload.obj_floats.data_size;
elementsize = p->payload.obj_floats.element_size;
if(datasize ==0 || elementsize == 0)
return array;
reverseBytes((BYTE*)&datasize, 2);
memcpy(&(array->data[offset]), &datasize, 2);
offset += 2;
array->data[offset++] = elementsize;
for(i=0; i<p->payload.obj_floats.data_size/elementsize; i++)
{
switch (elementsize)
{
case 4:
memcpy(&d32, &(p->payload.obj_floats.obj_data[i*elementsize]), 4);
reverseBytes((BYTE*) &d32, 4);
memcpy(&(array->data[i*elementsize + offset]), &d32, 4);
break;
case 8:
memcpy(&d64, &(p->payload.obj_floats.obj_data[i*elementsize]), 8);
reverseBytes((BYTE*) &d64, 8);
memcpy(&(array->data[i*elementsize + offset]), &d64, 8);
break;
}
}
return array;
}
uint32_t reverseBits(uint32_t n) {
int n1 = n >> 24;
int n2 = (n << 8) >> 24;
int n3 = (n << 16) >> 24;
int n4 = (n << 24) >> 24;
int res = 0;
n1 = reverseBytes(n1);
n2 = reverseBytes(n2);
n3 = reverseBytes(n3);
n4 = reverseBytes(n4);
res = n1 + (n2 << 8) + (n3 << 16) + (n4 << 24);
return res;
}
void tallyHits(struct pcm *pcm, bool *hits, bool *covers, int hitSize,
boolean isRev)
/* Put samples from hits into pcm. */
{
int pixels = pcm->pixels;
int *match = pcm->match;
int *count = pcm->count;
int *cover = pcm->cover;
int *coverNondash = pcm->coverNondash;
int i, x;
double scale = (double)hitSize/(double)pixels;
bool c;
if (hitSize <= 0)
return;
pcm->totalSize += hitSize;
pcm->totalFeatures += 1;
if (isRev)
{
reverseBytes(hits, hitSize);
reverseBytes(covers, hitSize);
}
for (i=0; i<pixels; ++i)
{
x = floor(i * scale);
if (x >= hitSize)
{
assert(x < pixels);
}
count[i] += 1;
if (hits[x])
match[i] += 1;
c = covers[x];
if (c)
{
cover[i] += 1;
if (c == 2)
coverNondash[i] += 1;
}
if (hits[x] && !covers[x])
errAbort("%s: i=%d, x=%d, hits[x] = %d, covers[x] = %d", pcm->name, i, x, hits[x], covers[i]);
}
if (isRev)
{
reverseBytes(hits, hitSize);
reverseBytes(covers, hitSize);
}
}
uint8_t initializeVersionChecksumBytesFromString(VersionChecksumBytes * self,ByteArray * string,uint8_t cacheString,void (*onErrorReceived)(Error error,char *,...))
{
/* Cache string if needed */
if (cacheString) {
self->cachedString = string;
incrementReferenceCount(string);
} else {
self->cachedString = NULL;
}
self->cacheString = cacheString;
/* Get bytes from string conversion*/
BigInt bytes;
BigIntAlloc(&bytes, 25); /*25 is the number of bytes for bitcoin addresses.*/
bytes=decodeBase58Checked((char *)getByteArrayData(string), onErrorReceived);
if (&bytes==NULL){
return FALSE;
}
/* Take over the bytes with the ByteArray*/
if (! initializeNewByteArrayFromData(getByteArray(self), bytes.data, bytes.length, onErrorReceived)){
return FALSE;
}
reverseBytes(getByteArray(self)); /* BigInt is in little-endian. Conversion needed to make bitcoin address the right way.*/
return TRUE;
}
void Squeak_Image_Reader::read_image() {
/*
readImageFromFile: f HeapSize: desiredHeapSize StartingAt: imageOffset
"Read an image from the given file stream, allocating the given amount of
memory to its object heap. Fail if the image has an unknown format or
requires more than the given amount of memory."
"Details: This method detects when the image was stored on a machine with
the opposite byte ordering from this machine and swaps the bytes
automatically. Furthermore, it allows the header information to start 512
bytes into the file, since some file transfer programs for the Macintosh
apparently prepend a Mac-specific header of this size. Note that this same
512 bytes of prefix area could also be used to store an exec command on
Unix systems, allowing one to launch Smalltalk by invoking the image name
as a command."
"This code is based on C code by Ian Piumarta and Smalltalk code by Tim
Rowledge. Many thanks to both of you!!"
*/
Object::verify_constants();
read_header();
fprintf(stdout, "allocating memory for snapshot\n");
// "allocate a contiguous block of memory for the Squeak heap"
memory = (char*)Memory_Semantics::shared_malloc(dataSize);
assert_always(memory != NULL);
/*
memStart := self startOfMemory.
memoryLimit := (memStart + heapSize) - 24. "decrease memoryLimit a tad for safety"
endOfMemory := memStart + dataSize.
*/
// "position file after the header"
fprintf(stdout, "reading objects in snapshot\n");
if ( fseek(image_file, headerStart + headerSize, SEEK_SET))
perror("seek"), fatal();
// "read in the image in bulk, then swap the bytes if necessary"
xfread(memory, 1, dataSize, image_file);
// "First, byte-swap every word in the image. This fixes objects headers."
if (swap_bytes) reverseBytes((int32*)&memory[0], (int32*)&memory[dataSize]);
// "Second, return the bytes of bytes-type objects to their orginal order."
if (swap_bytes) byteSwapByteObjects();
Safepoint_Ability sa(false); // for distributing objects and putting image name
distribute_objects();
imageNamePut_on_all_cores(file_name, strlen(file_name));
// we need to reoder floats if the image was a Cog image
if (is_cog_image_with_reodered_floats()) {
normalize_float_ordering_in_image();
}
}
int main()
{
unsigned char c = 0x23;
printf("%x %x\n", c, reverseBytes(c));
unsigned int val = 0xdeadbeef;
printf("%x %x\n", val, reverseBits(val));
val = 1;
printf("%x %x\n", val, reverseBits(val));
}
// optimize: big/little endian
uint32_t reverseBits(uint32_t n) {
uint32_t ret = 0;
int i;
for (i = 0; i != 4; i++) {
ret = (ret << 8) | reverseBytes(n % 256);
n /= 256;
}
return ret;
}
void populate_Obj_Time(OTA_Object* p, BYTE* data)
{
// size 2 byte,
int offset = 0;
ULong d64 = 0;
memcpy(&d64, &(data[offset]), sizeof(d64));
reverseBytes((BYTE*)&d64, 8);
p->payload.obj_timestamp.set(p, d64);
}
void populate_Obj_Floats (OTA_Object* p, BYTE* data)
{
int offset = 0;
int i;
UInt32 d32 = 0;
ULong d64 = 0;
UInt16 datasize;
BYTE elementsize;
memcpy(&datasize, data, 2);
offset += 2;
reverseBytes((BYTE*)&datasize, 2);
p->payload.obj_floats.data_size = datasize;
p->payload.obj_floats.element_size = data[offset++];
elementsize = p->payload.obj_floats.element_size;
if(datasize == 0 || elementsize == 0)
{
p->payload.obj_floats.obj_data = NULL;
return;
}
p->payload.obj_floats.obj_data = malloc (datasize);
for (i=0;i < p->payload.obj_floats.data_size/p->payload.obj_floats.element_size;i++)
{
switch (elementsize)
{
case 4:
memcpy(&d32, &(data[i*elementsize + offset]), 4);
reverseBytes((BYTE*)&d32, 4);
memcpy(&(p->payload.obj_floats.obj_data[i*elementsize]), &d32, 4);
break;
case 8:
memcpy(&d64, &(data[i*elementsize + offset]), 8);
reverseBytes((BYTE*)&d64, 8);
memcpy(&(p->payload.obj_floats.obj_data[i*elementsize]), &d64, 8);
break;
}
}
return;
}
void populate_Obj_Timestamp_socket (OTA_Object*p, int socketfd, int flags)
{
ULong d64 = 0;
int n = recv(socketfd, &d64, 8, flags);
reverseBytes((BYTE*)&d64, 8);
p->payload.obj_timestamp.time = d64;
}
BYTEARRAY* Header_getBytes(Msg_Header* h)
{
BYTEARRAY* p = new_BYTEARRAY(HEADER_SIZE);
UInt16 seqid;
int offset = 0;
ULong timestamp;
p->data[offset++] = h->type;
p->data[offset++] = h->version;
p->data[offset++] = h->event_code;
seqid = h->seq_id;
reverseBytes((BYTE*)&seqid, sizeof(UInt16));
memcpy(&(p->data[offset]), &seqid, sizeof(UInt16));
offset += sizeof(UInt16);
timestamp = h->timestamp;
reverseBytes((BYTE*)×tamp, sizeof(ULong));
memcpy(&(p->data[offset]), ×tamp, sizeof(ULong));
return p;
}
void reverseFold(char *s)
/* Reverse the order of the parenthesis defining an RNA secondary structure annotation. */
{
reverseBytes(s, strlen(s));
for (;*s;s++)
{
if (*s == '(')
*s = ')';
else if (*s == ')')
*s = '(';
}
}
void BStream_writeNumber_size_(BStream *self, unsigned char *v, size_t length)
{
memcpy(self->typeBuf, v, length);
if (self->flipEndian)
{
reverseBytes(self->typeBuf, length);
}
UArray_appendBytes_size_(self->ba, (unsigned char *)self->typeBuf, length);
self->index += length;
}
BYTEARRAY* Timestamp_to_BYTES(OTA_Object* p)
{
int size = p->size(p);
BYTEARRAY* array = new_BYTEARRAY(size);
ULong d64 = p->payload.obj_timestamp.time;
int offset = 0;
array->data[offset++] = p->objectid;
array->data[offset++] = p->objtype;
reverseBytes((BYTE*)&d64, 8);
memcpy(&(array->data[offset]), &d64, 8);
return array;
}
Msg_Header* createHeaderFromBytes( Msg_Header* header, BYTE* bytes)
{
int offset = 0;
BYTE type;
BYTE version;
BYTE event_code;
UInt16 seqid = 0;
ULong time = 0;
if(bytes == NULL)
return NULL;
type = bytes[offset++];
version = bytes[offset++];
event_code = bytes[offset++];
memcpy(&seqid, &(bytes[offset]), 2);
offset += 2;
reverseBytes((BYTE*)&seqid, 2);
if(header == NULL)
header = new_OTA_MSG_Header(NULL, type, event_code, seqid);
else
{
header->type = type;
header->event_code = event_code;
header->seq_id = seqid;
}
memcpy(&time, &(bytes[offset]), sizeof(ULong));
reverseBytes((BYTE*)&time, sizeof(time));
header->setTime(header, time);
return header;
}
void BStream_readNumber_size_(BStream *self, unsigned char *v, int size)
{
if (self->index + size <= UArray_size(self->ba))
{
const uint8_t *b = UArray_bytes(self->ba);
memcpy(v, b + self->index, size);
if (self->flipEndian)
{
reverseBytes(v, size);
}
self->index += size;
return;
}
while (size--)
{
*v = 0;
v ++;
}
}
bool
DataWriter<T>::write( T* value )
{
if ( m_format == DataWriter<T>::Ascii )
{
T val = *value;
m_outputStream << val << " ";
}
else
{
m_nextValue = reinterpret_cast< char* >( value );
if ( m_native != m_endian )
{
reverseBytes( m_nextValue, m_nextValueCopy );
m_outputStream.write( m_nextValueCopy, m_sizeOfT );
}
else
{
m_outputStream.write( m_nextValue, m_sizeOfT );
}
}
return true;
}
void mafFlipStrand(struct mafAli *maf)
/* Reverse complement maf. */
{
struct mafComp *mc;
for (mc = maf->components; mc != NULL; mc = mc->next)
{
int e = mc->start + mc->size;
reverseIntRange(&mc->start, &e, mc->srcSize);
if (mc->text != NULL)
reverseComplement(mc->text, maf->textSize);
if (mc->quality != NULL)
reverseBytes(mc->quality, maf->textSize);
if (mc->strand == '-')
mc->strand = '+';
else
mc->strand = '-';
char holdStatus = mc->leftStatus;
mc->leftStatus = mc->rightStatus;
mc->rightStatus = holdStatus;
int holdLen = mc->leftLen;
mc->leftLen = mc->rightLen;
mc->rightLen = holdLen;
}
}
void NetUtil::host2Net(const void *source, void *result, size_t length)
{
if(isLittleEndian()) //只有小字节序才需要转换，大字节序和网络字节序是一致的
reverseBytes(source, result, length);
}
/* Reverse complement DNA. */
void reverseComplement(DNA *dna, long length)
{
reverseBytes(dna, length);
complement(dna, length);
}
void DataInput::read(T& val)
{
readBytes(reinterpret_cast<uint8_t*>(&val), sizeof(T));
reverseBytes(reinterpret_cast<uint8_t*>(&val), sizeof(T));
}
inline int16_t reverseBytes(int16_t v)
{
return (int16_t)reverseBytes((char16_t)v);
}
inline int32_t reverseBytes(int32_t v)
{
return (int32_t)reverseBytes((char32_t)v);
}
static void swap(T& value)
{
value = reverseBytes(value);
}
void writeGap(struct gapInfo *gap, struct xaAli *xa,
int symStart, int symEnd, char geneStrand, FILE *f)
/* Write out info on one gap to file. */
{
char qStart[totSize+1], qEnd[totSize+1];
char tStart[totSize+1], tEnd[totSize+1];
char hStart[totSize+1], hEnd[totSize+1];
int s, e, size;
int midSize;
int i;
char *threePrime, *fivePrime;
boolean isQgap;
fprintf(f, "%s %s %s hom %s:%d-%d %c %s:%d-%d %c slide %d\n",
gapTypeStrings[gap->type],
(gap->hasIntronEnds ? " intron" : "!intron"),
(gap->hasStrongHomology ? "heavy" : "light"),
gap->query, gap->qStart, gap->qEnd, xa->qStrand,
gap->target, gap->tStart, gap->tEnd, geneStrand, gap->slideCount);
s = symStart-exSize;
e = symStart + inSize;
if (s < 0)
s = 0;
size = e-s;
uglyf("s %d size %d e %d totSize %d\n", s, size, e, totSize);
strncpy(qStart, xa->qSym+s, size);
strncpy(tStart, xa->tSym+s, size);
strncpy(hStart, xa->hSym+s, size);
qStart[size] = tStart[size] = hStart[size] = 0;
// uglyf - crashes by here
s = symEnd-inSize;
midSize = s - e;
e = symEnd+exSize;
if (e > xa->symCount)
e = xa->symCount;
size = e-s;
strncpy(qEnd, xa->qSym+s, size);
strncpy(tEnd, xa->tSym+s, size);
strncpy(hEnd, xa->hSym+s, size);
qEnd[size] = tEnd[size] = hEnd[size] = 0;
if (gap->isRc)
{
swapBytes(qStart, qEnd, totSize);
swapBytes(tStart, tEnd, totSize);
swapBytes(hStart, hEnd, totSize);
reverseComplement(qStart, totSize);
reverseComplement(qEnd, totSize);
reverseComplement(tStart, totSize);
reverseComplement(tEnd, totSize);
reverseBytes(hStart, totSize);
reverseBytes(hEnd, totSize);
}
/* Write out ends of gap to file. */
fprintf(f, "%s ...%d... %s\n", qStart, midSize, qEnd);
fprintf(f, "%s ...%d... %s\n", tStart, midSize, tEnd);
fprintf(f, "%s ...%d... %s\n\n", hStart, midSize, hEnd);
/* Add intron ends to consensus sequence histogram. */
if (gap->hasIntronEnds && gap->type == cCodingGap)
{
isQgap = (qStart[exSize] == '-');
if (isQgap)
{
fivePrime = tStart;
threePrime = tEnd;
}
else
{
fivePrime = qStart;
threePrime = qEnd;
}
if (noInserts(threePrime, totSize) && noInserts(fivePrime, totSize) )
{
int *homoCount;
for (i=0; i<totSize; ++i)
{
hist5[i][histIx(fivePrime[i])] += 1;
hist3[i][histIx(threePrime[i])] += 1;
}
++histCount;
if (isQgap)
{
++ceOnlyCount;
homoCount = ceOnlyHomoCount;
}
else
{
++cbOnlyCount;
homoCount = cbOnlyHomoCount;
}
++bothCount;
for (i=0; i<totSize; ++i)
{
if (fivePrime[i] == threePrime[i])
{
homoCount[i] += 1;
bothHomoCount[i] += 1;
}
}
/* Add introns to list. */
{
char idBuf[2*intronEndsSize+1];
struct intronList *il;
struct hashEl *hel;
memcpy(idBuf, fivePrime+exSize, intronEndsSize);
memcpy(idBuf+intronEndsSize, threePrime, intronEndsSize);
idBuf[ sizeof(idBuf)-1 ] = 0;
if ((hel = hashLookup(intronHash, idBuf)) != NULL)
{
il = hel->val;
il->count += 1;
fprintf(f, ">>>%d of set<<<\n", il->count);
if (il->isQgap != isQgap)
{
il->onBoth = TRUE;
}
}
else
{
AllocVar(il);
strcpy(il->ends, idBuf);
il->count = 1;
il->isQgap = isQgap;
slAddHead(&intronList, il);
hashAdd(intronHash, idBuf, il);
}
}
}
else
{
static insertCount = 0;
warn("Skipping intron with flanking inserts %d", ++insertCount);
}
}
}
//-----------------------------------------------------------------------------
// this function, if called from the non-reference endian platform,
// will reverse the order of bytes in each variable/value of the data
// to correct endian differences & make a uniform data chunk
void VstChunk::correctEndian(void *data, bool isReversed, bool isPreset)
{
#if MAC
// Mac OS (big endian) is the reference platform, so no byte-swapping is necessary
#else
unsigned long storedHeaderSize;
long numStoredParameters, numStoredPrograms;
// start by looking at the header info
ChunkInfo *dataHeader = (ChunkInfo*)data;
// we need to know how big the header is before dealing with it
storedHeaderSize = dataHeader->storedHeaderSize;
// correct the value's endian byte order order if the chunk was received byte-swapped
if (isReversed)
reverseBytes(&storedHeaderSize, sizeof(unsigned long));
// since the data is not yet reversed, collect this info now before we reverse it
if (!isReversed)
{
numStoredParameters = dataHeader->numStoredParameters;
numStoredPrograms = (isPreset ? 1 : dataHeader->numStoredPrograms);
}
// reverse the order of bytes of the header values
reverseBytes(dataHeader, sizeof(long), (signed)storedHeaderSize/(signed)sizeof(long));
// if the data started off reversed, collect this info now that we've un-reversed the data
if (isReversed)
{
numStoredParameters = dataHeader->numStoredParameters;
numStoredPrograms = (isPreset ? 1 : dataHeader->numStoredPrograms);
}
// reverse the byte order for each of the parameter IDs
long *dataParameterIDs = (long*) ((char*)data + storedHeaderSize);
reverseBytes(dataParameterIDs, sizeof(long), numStoredParameters);
// reverse the order of bytes for each parameter value,
// but no need to mess with the program names since they are char strings
Program *dataPrograms = (Program*) ((char*)dataParameterIDs + (sizeof(long)*numStoredParameters));
unsigned long sizeofStoredProgram = sizeof(Program) + (sizeof(float) * (numStoredParameters-2));
for (long i=0; i < numStoredPrograms; i++)
{
reverseBytes(dataPrograms->params, sizeof(float), numStoredParameters);
// point to the next program in the data array
dataPrograms = (Program*) ((char*)dataPrograms + sizeofStoredProgram);
}
// & reverse the byte order of each event assignment, if we're processing a bank
if (!isPreset)
{
ParameterAssignment *dataParameterAssignments = (ParameterAssignment*) dataPrograms;
for (long i=0; i < numStoredParameters; i++)
{
reverseBytes( &(dataParameterAssignments->eventType), sizeof(long) );
reverseBytes( &(dataParameterAssignments->eventChannel), sizeof(long) );
reverseBytes( &(dataParameterAssignments->eventNum), sizeof(long) );
reverseBytes( &(dataParameterAssignments->eventNum2), sizeof(long) );
reverseBytes( &(dataParameterAssignments->eventBehaviourFlags), sizeof(long) );
reverseBytes( &(dataParameterAssignments->data1), sizeof(long) );
reverseBytes( &(dataParameterAssignments->data2), sizeof(long) );
reverseBytes( &(dataParameterAssignments->fdata1), sizeof(float) );
reverseBytes( &(dataParameterAssignments->fdata2), sizeof(float) );
}
}
#endif
}
