int VerifyMemberInside(const void *parent, uint64_t parent_size,
const void *member, uint64_t member_size,
uint64_t member_data_offset,
uint64_t member_data_size)
{
uint64_t end = OffsetOf(parent, member);
if (end > parent_size)
return 1;
if (UINT64_MAX - end < member_size)
return 1; /* Detect wraparound in integer math */
if (end + member_size > parent_size)
return 1;
if (UINT64_MAX - end < member_data_offset)
return 1;
end += member_data_offset;
if (end > parent_size)
return 1;
if (UINT64_MAX - end < member_data_size)
return 1;
if (end + member_data_size > parent_size)
return 1;
return 0;
}
void PublicKeyInit(VbPublicKey *key, uint8_t *key_data, uint64_t key_size)
{
key->key_offset = OffsetOf(key, key_data);
key->key_size = key_size;
key->algorithm = kNumAlgorithms; /* Key not present yet */
key->key_version = 0;
}
void Render(Position p, Size s)
{
Position mapPos;
Position screenPos;
for (mapPos.x = p.x, screenPos.x = 0; mapPos.x < p.x + s.w; mapPos.x++, screenPos.x++)
{
for (mapPos.y = p.y, screenPos.y = 0; mapPos.y < p.y + s.h; mapPos.y++, screenPos.y++)
{
CellRenderInfo ri;
auto appearance = m_appearance.find(m_map[mapPos].type);
if (appearance != m_appearance.end())
{
ri = appearance->second;
}
Color color(ri.col);
auto offset = OffsetOf(mapPos, m_map.GetSize());
auto vmap = m_varianceMap[offset];
vmap = std::max(vmap, ri.minVariance);
vmap = std::min(vmap, ri.maxVariance);
color.r = (color.r * vmap) / 4;
color.g = (color.g * vmap) / 4;
color.b = (color.b * vmap) / 4;
m_textRenderer.PrintCharacter(ri.c, screenPos, color);
}
}
}
void DominancyClassifier::updateMeshVBO()
{
#pragma pack(push,1)
struct VBOData
{
GLfloat vertex[3];
GLfloat normal[3];
GLint id;
};
#pragma pack(pop)
// Gathers vertex position and normal data from the mesh, and store them on GPU into a VBO.
VBOData *vboData = new VBOData [ m_Mesh.vn ];
for( int v=0; v<m_Mesh.vn; ++v )
{
for( int i=0; i<3; ++i )
{
vboData[v].vertex[i] = m_Mesh.vert[v].P()[i];
vboData[v].normal[i] = m_Mesh.vert[v].N()[i];
}
vboData[v].id = v;
}
m_MeshVBO.Create( GL_STATIC_DRAW, vboData, m_Mesh.vn );
m_MeshVBO.Vertex.SetPointer( sizeof(VBOData), OffsetOf(VBOData,vertex) );
m_MeshVBO.Normal.SetPointer( sizeof(VBOData), OffsetOf(VBOData,normal) );
m_MeshVBO.TexCoord.SetPointer( sizeof(VBOData), OffsetOf(VBOData,id) );
delete [] vboData;
// Gathers mesh face indices and store them into the VBO.
unsigned int *vboIndices = new unsigned int [ 3*m_Mesh.fn ];
for( int f=0, n=0; f<m_Mesh.fn; ++f )
for( int i=0; i<3; ++i, ++n )
vboIndices[n] = m_Mesh.face[f].V(i) - &m_Mesh.vert[0];
m_MeshVBO.LoadIndices( GL_STATIC_DRAW, vboIndices, 3*m_Mesh.fn );
delete [] vboIndices;
}
int main(int argc, char** argv, char** envp) {
// this is how you would use such a union...
LARGE_INTEGER li;
li.LowPart=15;
li.HighPart=16;
printf("li.LowPart is %u\n", li.LowPart);
printf("li.HighPart is %u\n", li.HighPart);
printf("li.QuadPart is %lli\n", li.QuadPart);
// trampling the quad part tramples both low and high parts
li.QuadPart=17;
printf("li.LowPart is %u\n", li.LowPart);
printf("li.HighPart is %u\n", li.HighPart);
printf("li.QuadPart is %lli\n", li.QuadPart);
// this is the offsets of it's relevant parts...
printf("offset of LowPart is %zd\n", OffsetOf(LARGE_INTEGER, LowPart));
printf("offset of HighPart is %zd\n", OffsetOf(LARGE_INTEGER, HighPart));
printf("offset of QuadPart is %zd\n", OffsetOf(LARGE_INTEGER, QuadPart));
// or we could use the built in...
printf("offset of LowPart is %zd\n", __builtin_offsetof(LARGE_INTEGER, LowPart));
printf("offset of HighPart is %zd\n", __builtin_offsetof(LARGE_INTEGER, HighPart));
printf("offset of QuadPart is %zd\n", __builtin_offsetof(LARGE_INTEGER, QuadPart));
return EXIT_SUCCESS;
}
int
vars_main(int argc, char **argv)
{
char *line=0;
char *name,*v;
unsigned long value,f;
CexpSym val;
int ch;
cexpVarInitOnce();
{
CexpVar vv;
val=cexpVarLookup("hallo",1);
vv = (CexpVar)((unsigned long)val - OffsetOf(CexpVar,sym));
printf("CexpVar size: %i, & 0x%08lx, &name: %08lx\n",
sizeof(*vv), (unsigned long)vv, (unsigned long)&vv->sym.name);
}
while (free(line),line=readline("Vars Tst>")) {
for (name=line+1; *name && isspace(*name); name++);
for (v=name; *v && !isspace(*v); v++);
if (*v) {
*v=0;
for (v++;*v && isspace(*v); v++);
if (*v) sscanf(v,"%li",&value);
}
f=0;
switch ((ch=toupper(line[0]))) {
default: fprintf(stderr,"unknown command\n");
continue; /* dont add bad commands to history */
case 'F': cexpVarsFlush();
break;
case 'P': varPrintList();
break;
case 'T': strPrintList();
break;
case 'A': f=1;/* find and add */
case 'S': /* find and set (dont add) */
if (!*name || !*v) {
fprintf(stderr,"missing name and/or value\n");
break;
}
val=cexpVarLookup(name,f);
if (val) {
val->value.type=TULong;
val->value.ptv->l=value;
}
printf("\n%s %s\n",
f?"adding":"setting",
val?"success":"failure");
break;
case 'L':
case 'D':
if (!*name) {
fprintf(stderr,"missing name\n");
break;
}
if ('D'==ch) {
printf("Deleting %s\n",
cexpVarDelete(name) ? "success" : "failure");
} else {
val=cexpVarLookup(name,0);
printf("Var %sfound: 0x%lx\n",
val ? "" : "not ", val->value.ptv->l);
}
break;
}
add_history(line);
}
return 0;
}
#include <ctype.h>
#include <X11/StringDefs.h>
#include <Xm/XmP.h>
#include <Xm/Label.h>
#include "Macros.h"
#include "CaptionP.h"
#ifndef tolower
#define tolower(c) ((c) - 'A' + 'a')
#endif
#define OffsetOf(field) XtOffsetOf(XbaeCaptionRec, field)
static XtResource resources[] = {
{ XmNfontList, XmCFontList, XmRFontList, sizeof(XmFontList),
OffsetOf(caption.font_list), XmRImmediate, (XtPointer) NULL },
{ XmNlabelAlignment, XmCLabelAlignment, XmRLabelAlignment,
sizeof(XbaeLabelAlignment), OffsetOf(caption.label_alignment),
XmRImmediate, (XtPointer) XbaeAlignmentCenter },
{ XmNlabelOffset, XmCLabelOffset, XmRInt, sizeof(int),
OffsetOf(caption.label_offset), XmRImmediate, (XtPointer) 0 },
{ XmNlabelPixmap, XmCLabelPixmap, XmRManForegroundPixmap, sizeof(Pixmap),
OffsetOf(caption.label_pixmap),
XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP },
{ XmNlabelPosition, XmCLabelPosition, XmRLabelPosition,
sizeof(XbaeLabelPosition), OffsetOf(caption.label_position),
XmRImmediate, (XtPointer) XbaePositionLeft },
{ XmNlabelString, XmCXmString, XmRXmString, sizeof(XmString),
OffsetOf(caption.label_string), XmRImmediate, (XtPointer) NULL },
{ XmNlabelTextAlignment, XmCAlignment, XmRAlignment, sizeof(unsigned char),
OffsetOf(caption.label_text_alignment),
C_dict::C_dict()
{
MetaClass* meta1 = new MetaClass("Event", "Event header");
meta1->addField("event", "long", "Event Number", OffsetOf(Event,m_event));
meta1->addField("run", "long", "Run Number", OffsetOf(Event,m_run));
meta1->addField("time", "Time", "Event creation Time", OffsetOf(Event,m_time));
meta1->addMethod("getRun", "Get run number", "long", Event_run );
std::vector<std::string> argnames1;
argnames1.push_back("long");
meta1->addMethod("setRun", "Set run number", argnames1, Event_setRun );
MetaClass* meta2 = new MetaClass("Time", "Absolute time (64-bit) in ns");
meta2->addField("time", "longlong", "Time",OffsetOf(Gaudi::Time,m_time));
MetaClass* meta3 = new MetaClass("MyTrack", "Track test object");
meta3->addField("px", "float", "Momentum in x direction", OffsetOf(MyTrack,m_px));
meta3->addField("py", "float", "Momentum in y direction", OffsetOf(MyTrack,m_py));
meta3->addField("pz", "float", "Momentum in z direction", OffsetOf(MyTrack,m_pz));
meta3->addField("event", "SmartRef<Event>", "Link to event root",OffsetOf(MyTrack,m_event));
meta3->addField("decay", "SmartRef<MyVertex>", "Link to decay Vertex", OffsetOf(MyTrack,m_decay));
meta3->addMethod("getEvent", "Get Event pointer", "Event*", MyTrack_event );
std::vector<std::string> argnames3;
argnames3.push_back("Event*");
meta3->addMethod("setEvent", "Set Event", argnames3, MyTrack_setEvent );
MetaClass* meta4 = new MetaClass("MyVertex", "Vertex test object");
meta4->addField("x", "double", "Position in x", OffsetOf(MyVertex,m_x));
meta4->addField("y", "double", "Position in y", OffsetOf(MyVertex,m_y));
meta4->addField("z", "double", "Position in z", OffsetOf(MyVertex,m_z));
meta4->addField("mother", "SmartRef<MyTrack>", "Link to mother Track", OffsetOf(MyVertex,m_mother));
meta4->addField("daughters", "SmartRefVector<MyTrack>", "Link to daughter Tracks", OffsetOf(MyVertex,m_daughters));
}
return false;
if(er.signature==0x06054b50)
break;
}
if(i==100)
return false;
//found, read the end record
er.Read(ck);
//fail, if multi-volume zip
if(er.thisDisk != 0 || er.dirStartDisk != 0 || er.numEntriesOnDisk != er.numEntriesTotal)
return false;
}
ck.Seek(er.dirStartOffset);
//compute the size of data needed for storing all file info
dword alloc_size = er.numEntriesTotal * (OffsetOf(S_file_entry, name) + sizeof(wchar)*2 + 3);
//space for names (deduct from used file space)
alloc_size += er.dirSize*2;
//add terminating zero dword + align
alloc_size += 4;
//alloc structures
file_info = new(true) byte[alloc_size];
num_files = 0;
S_file_entry *file_entry = (S_file_entry*)file_info;
for(int i=0; i<er.numEntriesTotal; i++){
struct C_DirFileHeader{
dword signature; // 0x02014b50
word versionUsed; //
{"alldirection", FlagTESTFLAG, ALLDIRECTIONFLAG},
{"swapstartdir", FlagTESTFLAG, SWAPSTARTDIRFLAG},
{"uniquename", FlagTESTFLAG, UNIQUENAMEFLAG},
{"clearnew", FlagTESTFLAG, CLEARNEWFLAG},
{"snappin", FlagTESTFLAG, SNAPPINFLAG},
{"showmask", FlagTESTFLAG, SHOWMASKFLAG},
{"thindraw", FlagTESTFLAG, THINDRAWFLAG},
{"orthomove", FlagTESTFLAG, ORTHOMOVEFLAG},
{"liveroute", FlagTESTFLAG, LIVEROUTEFLAG},
{"thindrawpoly", FlagTESTFLAG, THINDRAWPOLYFLAG},
{"locknames", FlagTESTFLAG, LOCKNAMESFLAG},
{"onlynames", FlagTESTFLAG, ONLYNAMESFLAG},
{"newfullpoly", FlagTESTFLAG, NEWFULLPOLYFLAG},
{"hidenames", FlagTESTFLAG, HIDENAMESFLAG},
{"fullpoly", FlagSETTINGS, OffsetOf (SettingType, FullPoly)},
{"grid_units_mm", FlagSETTINGS, OffsetOf (SettingType, grid_units_mm)},
{"clearline", FlagSETTINGS, OffsetOf (SettingType, ClearLine)},
{"uniquenames", FlagSETTINGS, OffsetOf (SettingType, UniqueNames)},
{"showsolderside", FlagSETTINGS, OffsetOf (SettingType, ShowSolderSide)},
{"savelastcommand", FlagSETTINGS, OffsetOf (SettingType, SaveLastCommand)},
{"saveintmp", FlagSETTINGS, OffsetOf (SettingType, SaveInTMP)},
{"drawgrid", FlagSETTINGS, OffsetOf (SettingType, DrawGrid)},
{"ratwarn", FlagSETTINGS, OffsetOf (SettingType, RatWarn)},
{"stipplepolygons", FlagSETTINGS, OffsetOf (SettingType, StipplePolygons)},
{"alldirectionlines", FlagSETTINGS,
OffsetOf (SettingType, AllDirectionLines)},
{"rubberbandmode", FlagSETTINGS, OffsetOf (SettingType, RubberBandMode)},
{"swapstartdirection", FlagSETTINGS,
OffsetOf (SettingType, SwapStartDirection)},
{"showdrcmode", FlagSETTINGS, OffsetOf (SettingType, ShowDRC)},
