/*
* Return a relative path variation of path
*/
static char *relativePath(char *path)
{
char cwd[MAXPATH], **strSegments, **cwdSegments, *cp, *result;
size_t len;
int cwdCount, strCount, i, commonLevels, upLevels;
if (path == NULL || *path == '\0') {
return ".";
}
strSegments = getSegments(canonPath(absolutePath(path)), &strCount);
cwd[sizeof(cwd) - 1] = '\0';
if (getcwd(cwd, sizeof(cwd) - 1) == 0) {
fprintf(stderr, "Can't get working directory");
exit(255);
}
cwdSegments = getSegments(cwd, &cwdCount);
len = min(cwdCount, strCount);
for (i = 0; i < len; i++) {
if (strcmp(strSegments[i], cwdSegments[i]) != 0) {
break;
}
}
commonLevels = i;
upLevels = cwdCount - commonLevels;
len = (upLevels * 3);
for (; i < strCount; i++) {
len += strlen(strSegments[i]) + 1;
}
cp = result = malloc(len + 1);
for (i = 0; i < upLevels; i++) {
strcpy(cp, "../");
cp += 3;
}
for (i = commonLevels; i < strCount; i++) {
strcpy(cp, strSegments[i]);
cp += strlen(strSegments[i]);
if ((i + 1) < strCount) {
*cp++ = '/';
}
}
*cp = '\0';
return result;
}
void display2digHex(unsigned int number)
{
unsigned char tempNumber;
if(number > 0xFF)
{
number = 0xFF; //truncate to 0xFF
}
tempNumber = number / 0x10;
digits[1] = getSegments(tempNumber);
number = number - tempNumber * 0x10;
digits[0] = getSegments(number);
}
std::string Circle::getShapesArrayType() const
{
std::stringstream ss;
ss << "Circle( ";
ss << getCenter() << ", ";
ss << getRadius() << ", ";
ss << getSegments() << " )";
return ss.str();
}
void QLCDNumberPrivate::drawDigit(const QPoint &pos, QPainter &p, int segLen,
char newCh, char oldCh)
{
// Draws and/or erases segments to change display of a single digit
// from oldCh to newCh
char updates[18][2]; // can hold 2 times number of segments, only
// first 9 used if segment table is correct
int nErases;
int nUpdates;
const char *segs;
int i,j;
const char erase = 0;
const char draw = 1;
const char leaveAlone = 2;
segs = getSegments(oldCh);
for (nErases=0; segs[nErases] != 99; nErases++) {
updates[nErases][0] = erase; // get segments to erase to
updates[nErases][1] = segs[nErases]; // remove old char
}
nUpdates = nErases;
segs = getSegments(newCh);
for(i = 0 ; segs[i] != 99 ; i++) {
for (j=0; j<nErases; j++)
if (segs[i] == updates[j][1]) { // same segment ?
updates[j][0] = leaveAlone; // yes, already on screen
break;
}
if (j == nErases) { // if not already on screen
updates[nUpdates][0] = draw;
updates[nUpdates][1] = segs[i];
nUpdates++;
}
}
for (i=0; i<nUpdates; i++) {
if (updates[i][0] == draw)
drawSegment(pos, updates[i][1], p, segLen);
if (updates[i][0] == erase)
drawSegment(pos, updates[i][1], p, segLen, true);
}
}
TEST(WireFormat, StructRoundTrip_OneSegmentPerAllocation_NoTag) {
Session ctx;
ctx.capn.create = &CreateSmallSegment;
g_AddTag = 0;
setupStruct(&ctx.capn);
g_AddTag = 1;
struct capn_segment *segments[31];
getSegments(&ctx.capn, segments, 31);
// Check that each segment has the expected size. Note that we have plenty
// of 16 byte double far ptrs.
EXPECT_EQ( 8, segments[ 0]->len); // root ref
EXPECT_EQ(64, segments[ 1]->len); // root struct
EXPECT_EQ(16, segments[ 2]->len); // root struct ptr
EXPECT_EQ( 8, segments[ 3]->len); // sub-struct
EXPECT_EQ(16, segments[ 4]->len); // sub-struct ptr
EXPECT_EQ(16, segments[ 5]->len); // 3-element int32 list
EXPECT_EQ(16, segments[ 6]->len); // 3-element int32 list ptr
EXPECT_EQ(72, segments[ 7]->len); // struct list
EXPECT_EQ(16, segments[ 8]->len); // struct list ptr
EXPECT_EQ( 8, segments[ 9]->len); // struct list substruct 1
EXPECT_EQ(16, segments[10]->len); // struct list substruct 1 ptr
EXPECT_EQ( 8, segments[11]->len); // struct list substruct 2
EXPECT_EQ(16, segments[12]->len); // struct list substruct 2 ptr
EXPECT_EQ( 8, segments[13]->len); // struct list substruct 3
EXPECT_EQ(16, segments[14]->len); // struct list substruct 3 ptr
EXPECT_EQ( 8, segments[15]->len); // struct list substruct 4
EXPECT_EQ(16, segments[16]->len); // struct list substruct 4 ptr
EXPECT_EQ(40, segments[17]->len); // list list
EXPECT_EQ(16, segments[18]->len); // list list ptr
EXPECT_EQ( 8, segments[19]->len); // list list sublist 1
EXPECT_EQ(16, segments[20]->len); // list list sublist 1 ptr
EXPECT_EQ( 8, segments[21]->len); // list list sublist 2
EXPECT_EQ(16, segments[22]->len); // list list sublist 2 ptr
EXPECT_EQ( 8, segments[23]->len); // list list sublist 3
EXPECT_EQ(16, segments[24]->len); // list list sublist 3 ptr
EXPECT_EQ( 8, segments[25]->len); // list list sublist 4
EXPECT_EQ(16, segments[26]->len); // list list sublist 4 ptr
EXPECT_EQ(16, segments[27]->len); // list list sublist 5
EXPECT_EQ(16, segments[28]->len); // list list sublist 5 ptr
EXPECT_EQ(16, segments[29]->len); // recurse struct
EXPECT_EQ(16, segments[30]->len); // recurse struct ptr
checkStruct(&ctx.capn);
struct capn ctx2;
memset(&ctx2, 0, sizeof(ctx2));
for (int i = 0; i < sizeof(segments)/sizeof(segments[0]); i++) {
capn_append_segment(&ctx2, segments[i]);
}
checkStruct(&ctx2);
}
map<DotNode*, set<DotNode*> > SpatialNeighbors(DotGraph& g)
{
if (g.nodes.empty())
return map<DotNode*, set<DotNode*> >();
//////////////////////////
map<Point, DotNode*> posToNode;
vector<Point> points;
Rectangle bbRect(g.nodes[0]->getPos());
for (auto node : g.nodes)
{
Rectangle bb = node->getBoundingRectangle();
vector<Point> pp;
pp.push_back(node->getPos());
pp.push_back(Point(bb.xl, bb.yl));
pp.push_back(Point(bb.xr, bb.yl));
pp.push_back(Point(bb.xl, bb.yr));
pp.push_back(Point(bb.xr, bb.yr));
for (auto point : pp)
{
points.push_back(point);
posToNode[point] = node;
bbRect.Add(point);
}
}
//boundary
double sz = min(bbRect.getWidth(), bbRect.getHeight()) * 0.1;
bbRect.Add(bbRect.minPoint() - Point(sz, sz));
bbRect.Add(bbRect.maxPoint() + Point(sz, sz));
points.push_back(Point(bbRect.xl, bbRect.yl));
points.push_back(Point(bbRect.xl, bbRect.yr));
points.push_back(Point(bbRect.xr, bbRect.yl));
points.push_back(Point(bbRect.xr, bbRect.yr));
auto dt = geometry::DelaunayTriangulation::Create(points);
map<DotNode*, set<DotNode*> > neighbors;
for (auto seg : dt->getSegments())
{
if (!posToNode.count(seg.first)) continue;
if (!posToNode.count(seg.second)) continue;
DotNode* an = posToNode[seg.first];
DotNode* bn = posToNode[seg.second];
if (an == bn) continue;
neighbors[an].insert(bn);
neighbors[bn].insert(an);
}
return neighbors;
}
Segment* Canvas::getSegment(const SegmentPath& path)
{
const Segments& segments = getSegments();
LBASSERTINFO(segments.size() > path.segmentIndex,
segments.size() << " <= " << path.segmentIndex);
if (segments.size() <= path.segmentIndex)
return 0;
return segments[path.segmentIndex];
}
void eval1(int* output, int* label, int length) {
getSegments(output, length, outputSegments_);
getSegments(label, length, labelSegments_);
size_t i = 0, j = 0;
while (i < outputSegments_.size() && j < labelSegments_.size()) {
if (outputSegments_[i] == labelSegments_[j]) {
++numCorrect_;
}
if (outputSegments_[i].end < labelSegments_[j].end) {
++i;
} else if (outputSegments_[i].end > labelSegments_[j].end) {
++j;
} else {
++i;
++j;
}
}
numLabelSegments_ += labelSegments_.size();
numOutputSegments_ += outputSegments_.size();
}
void displayDigDec(unsigned long number)
{
unsigned long divisor;
unsigned char tempNumber, iTemp, index;
//if(digits > 14) return;
//no need to truncate, a maxed out 32 bit number in decimal is 4,294,967,295 (ten digits)
divisor = 1000000000;
//divisor = pow(10, NUM_DIGITS);
for(iTemp = 0; iTemp<(NUM_DIGITS-1); iTemp++) //for all but the last digit
{
index = iTemp;
tempNumber = number/divisor;
digits[index] = getSegments(tempNumber);
number = number % (tempNumber * divisor);
divisor /= 10;
}
digits[(NUM_DIGITS-1)] = getSegments(number); //for the last digit
}
void GlassLayer::updateSegments(void)
{
//Calculate a Cubic Hermite spline
_Segments.clear();
Vec2f Pos;
Real32 t,
t_sqr,
t_cub;
for(UInt32 i(1) ; i<getSegments() ; ++i)
{
t = static_cast<Real32>(i)/static_cast<Real32>(getSegments());
t_sqr = t*t;
t_cub = t_sqr*t;
Pos = ( 2.0f * t_cub - 3.0f*t_sqr + 1.0f) * getStartPosition().subZero() +
( t_cub - 2.0f*t_sqr + t) * getStartDirection() +
(-2.0f * t_cub + 3.0f*t_sqr ) * getEndPosition().subZero() +
( t_cub - t_sqr ) * getEndDirection();
_Segments.push_back(Pos);
}
}
void BW_LED_Number::display(char s ){
QPainter p;
p.begin( this );
old_symbol = current_symbol;
old_segments = current_segments;
current_symbol = s;
current_segments = getSegments(s);
drawSymbol(&p,s,FALSE);
p.end();
}
uintptr_t MachOObject::getTotalMappingSize()
{
uintptr_t minAddr = std::numeric_limits<uintptr_t>::max();
uintptr_t maxAddr = 0;
for (Segment* seg : getSegments(*m_file))
{
if (strcmp(seg->segname, SEG_PAGEZERO) == 0)
continue;
if (seg->vmaddr < minAddr)
minAddr = seg->vmaddr;
if (seg->vmaddr+seg->vmsize > maxAddr)
maxAddr = seg->vmaddr+seg->vmsize;
}
if (!maxAddr)
return 0;
else
return maxAddr-minAddr;
}
IOReturn IOFWSimpleContiguousPhysicalAddressSpace::cachePhysicalAddress( void )
{
IOReturn status = kIOReturnSuccess;
UInt32 segment_count = 0;
FWSegment segments[ 2 ];
if( status == kIOReturnSuccess )
{
UInt64 offset_64 = 0;
segment_count = 2;
status = getSegments( &offset_64, segments, &segment_count );
}
// sanity checks for contiguous allocation
if( status == kIOReturnSuccess )
{
if( segment_count > 2 || segment_count == 0 )
{
status = kIOReturnNoResources;
}
}
if( status == kIOReturnSuccess )
{
if( segments[0].length < getLength() )
{
status = kIOReturnNoResources;
}
}
if( status == kIOReturnSuccess )
{
_members->fFWPhysicalAddress = segments[0].address;
}
// IOLog( "IOFWSimpleContiguousPhysicalAddressSpace::cachePhysicalAddress - 0x%04x %08lx\n",
// _members->fFWPhysicalAddress.addressHi, _members->fFWPhysicalAddress.addressLo );
return status;
}
TEST(WireFormat, StructRoundTrip_OneSegmentPerAllocation) {
Session ctx;
ctx.capn.create = &CreateSmallSegment;
setupStruct(&ctx.capn);
struct capn_segment *segments[16];
getSegments(&ctx.capn, segments, 16);
// Check that each segment has the expected size. Recall that the first word of each segment will
// actually be a reference to the first thing allocated within that segment.
EXPECT_EQ( 8, segments[ 0]->len); // root ref
EXPECT_EQ(72, segments[ 1]->len); // root struct
EXPECT_EQ(16, segments[ 2]->len); // sub-struct
EXPECT_EQ(24, segments[ 3]->len); // 3-element int32 list
EXPECT_EQ(80, segments[ 4]->len); // struct list
EXPECT_EQ(16, segments[ 5]->len); // struct list substruct 1
EXPECT_EQ(16, segments[ 6]->len); // struct list substruct 2
EXPECT_EQ(16, segments[ 7]->len); // struct list substruct 3
EXPECT_EQ(16, segments[ 8]->len); // struct list substruct 4
EXPECT_EQ(48, segments[ 9]->len); // list list
EXPECT_EQ(16, segments[10]->len); // list list sublist 1
EXPECT_EQ(16, segments[11]->len); // list list sublist 2
EXPECT_EQ(16, segments[12]->len); // list list sublist 3
EXPECT_EQ(16, segments[13]->len); // list list sublist 4
EXPECT_EQ(24, segments[14]->len); // list list sublist 5
EXPECT_EQ(24, segments[15]->len); // recurse struct
checkStruct(&ctx.capn);
struct capn ctx2;
memset(&ctx2, 0, sizeof(ctx2));
for (int i = 0; i < sizeof(segments)/sizeof(segments[0]); i++) {
capn_append_segment(&ctx2, segments[i]);
}
checkStruct(&ctx2);
}
void MachOObject::loadSegments()
{
for (Segment* seg : getSegments(*m_file))
{
uintptr_t mappingSize;
int initprot, maxprot;
void* mappingAddr;
void* rv;
int flags = MAP_PRIVATE;
if (strcmp(seg->segname, SEG_PAGEZERO) == 0 || seg->vmsize == 0)
continue;
assert(seg->vmsize >= seg->filesize);
if (!m_base)
{
mappingAddr = (void*) seg->vmaddr;
if (mappingAddr < MachOMgr::instance()->maxAddress())
mappingAddr = MachOMgr::instance()->maxAddress();
}
else
mappingAddr = (void*) (seg->vmaddr + m_slide);
mappingSize = pageAlign(seg->filesize);
maxprot = machoProtectionFlagsToMmap(seg->maxprot);
initprot = machoProtectionFlagsToMmap(seg->initprot);
if (MachOMgr::instance()->printSegments())
std::cerr << "dyld: Mapping segment " << seg->segname << " from " << m_file->filename() << " to " << mappingAddr << ", slide is 0x" << std::hex << m_slide << std::dec << std::endl;
#ifndef __arm__ // All executables on iOS are PIE
// The first segment can be moved by mmap, but not the following ones
auto filetype = m_file->header().filetype;
if (m_base || (!(m_file->header().flags & MH_PIE) && filetype != MH_DYLIB && filetype != MH_BUNDLE))
flags |= MAP_FIXED;
else
#endif
{
// When letting the system decide where to place the mapping, we need to make sure that the spot chosen
// is big enough for all segments
uintptr_t size = getTotalMappingSize();
rv = ::mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
if (rv == MAP_FAILED)
{
std::stringstream ss;
ss << "Failed to mmap temporary anonymous range: " << strerror(errno);
throw std::runtime_error(ss.str());
}
flags |= MAP_FIXED;
mappingAddr = rv;
}
rv = ::mmap(mappingAddr, mappingSize, maxprot, flags, m_file->fd(), m_file->offset() + seg->fileoff);
if (rv == MAP_FAILED)
{
std::stringstream ss;
if (errno == EPERM && uintptr_t(mappingAddr) < getMinMappingAddr())
{
ss << "This executable is not position independent and your vm.mmap_min_addr is too low to load it. ";
ss << "As low as " << uintptr_t(mappingAddr) << " is needed.";
}
else
ss << "Failed to mmap '" << m_file->filename() << "': " << strerror(errno);
throw std::runtime_error(ss.str());
}
if (!m_base)
{
m_slide = (intptr_t(rv) - intptr_t(seg->vmaddr));
m_base = rv;
mappingAddr = rv;
}
m_mappings.push_back(Mapping { mappingAddr, pageAlign(seg->vmsize), initprot, maxprot });
if (seg->vmsize > mappingSize)
{
// Map empty pages to cover the vmsize range
mappingAddr = (void*) (seg->vmaddr + m_slide + mappingSize);
mappingSize = seg->vmsize - mappingSize;
rv = ::mmap(mappingAddr, mappingSize, maxprot, MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
//int err = ::mprotect(mappingAddr, mappingSize, maxprot);
if (rv == MAP_FAILED)
{
std::stringstream ss;
ss << "Failed to mmap anonymous pages for '" << m_file->filename() << "': " << strerror(errno);
throw std::runtime_error(ss.str());
}
}
}
}
void R3DLuminance::calculateLuminance(std::list<double> *luminance)
{
std::list<R3DLight>::iterator light_it;
int N = m_triangles->size();
int Nsegm = m_Ntheta * m_Nphi + 2;
std::list<int> *segments = new std::list<int>[ Nsegm ];
bool *isVisible = new bool[N];
//LineSegment *rayList = new LineSegment[N];
R3DPoint *midPoint = new R3DPoint[N];
// initialize with zeros
int i;
luminance->clear();
for(i=0;i<N;i++)
luminance->push_back( 0 );
// calculate luminance: light by light
for(light_it = m_lights->begin();
light_it != m_lights->end();
light_it ++)
{
R3DPoint L = (*light_it).position;
double power = (*light_it).power;
for(i=0;i<Nsegm;i++) segments[i].clear();
for(i=0;i<N;i++) isVisible[i] = true;
std::set<int> S; //segment of triangles
std::set<int>::iterator set_it;
std::list<R3DTriangle>::iterator tri_it;
int tri_idx;
// add triangles to appropriate segments
for(tri_it = m_triangles->begin(), tri_idx = 0;
tri_it != m_triangles->end();
tri_it++, tri_idx ++ )
{
S.clear();
getSegments( *tri_it, //R3DTriangle &T,
L ,// R3DPoint &L, //light position
&S //std::set<int> *segment_set
);
if(DEBUG) std::cout<<"Triangle "<<*tri_it<<" SEGMENTS:"<<std::endl;
for( set_it = S.begin(); set_it!=S.end(); set_it ++ )
{
if(DEBUG)
{
std::cout<<*set_it;
}
segments[ *set_it ].push_back( tri_idx );
}
}// tri_it
if(DEBUG)
{
for(i=0;i<Nsegm;i++)
{
std::list<int>::iterator idx_it;
printf("SEGMENT %d:\n",i);
for( idx_it = segments[i].begin(); idx_it!=segments[i].end(); idx_it++)
{
std::cout<<"Triangle "<<*idx_it<<" : "<< *m_triIndex[ *idx_it ]<<std::endl;
}
}
}
// intersect triangles inside the segments
int segm_id;
for(segm_id = 0; segm_id < Nsegm; segm_id++)
{
// go through all the triangles in the segment
std::list<int>::iterator idx_it1,idx_it2;
for( idx_it1 = segments[ segm_id].begin();
idx_it1 != segments[ segm_id].end();
idx_it1++)
{
R3DTriangle T1 = *m_triIndex[ *idx_it1 ];
R3DPoint M = (T1.A + T1.B + T1.C)/3;
R3DLineSegment ML(M,L);
midPoint[ *idx_it1 ] = M;
// check if ML croses one of triangles in this segment
for(idx_it2 = segments[segm_id].begin();
idx_it2 != segments[segm_id].end();
idx_it2 ++ )
{
if ( *idx_it1 == *idx_it2) continue; //triangle coinside
R3DPoint X; //cross of the plane with
R3DPlane P2 = *m_planeIndex[ *idx_it2 ];
if(! intersect( ML, P2, &X)) continue; // ML does not intersect wuth the plane of second triangle
R3DTriangle T2 = *m_triIndex[ *idx_it2 ];
if( T2.isInside(X)) //croos point (X) is inside T2
{
isVisible[ *idx_it1 ] = false; // T2 covers T1
break;
}
}//idx_it2
}// idx_it1
} //segm_id
// std::list<double>::iterator lum_it;
std::list<double>::iterator lum_it;
for( i=0, lum_it = luminance->begin();
i<N;
i++, lum_it++)
{
if(!isVisible[i]) continue;
R3DPlane P = *m_planeIndex[i];
R3DLineSegment ML( midPoint[i], L);
double normML = ML.m_direction.norm();
double cos_phi = fabs( P.getNormal() * ML.m_direction )/normML;
if(DEBUG)
std::cout<<"M:"<<midPoint[i]<<" cos_phi="<<cos_phi<<" normML="<<normML<<std::endl;
// K = L.power / (normML * normML) * cos_phi;
*lum_it += power / (normML * normML) * cos_phi;
}
}// for light
delete [] segments;
delete [] isVisible;
delete [] midPoint;
}
/*
* Canonicalize a path. This removes "." and ".." segments and also redundant "/".
*/
static char *canonPath(char *path)
{
char *str, *cp, *result, **segments;
size_t len;
int count, i, from, to;
if (path == NULL) {
return NULL;
}
if (*path == '\0') {
return "";
}
/*
* Duplicate as we modify in-place and trim trailing "/"
*/
str = trim(mapDelim(strdup(path)));
while (*str == '/') {
str++;
}
/*
* Allocate space for the result (conservative)
*/
result = malloc(strlen(str) + 1);
segments = getSegments(str, &count);
/*
* Remove "." and ".." segments
*/
for (from = to = 0; from < count && segments[from]; from++) {
if (strcmp(segments[from], ".") == 0) {
continue;
} else if (strcmp(segments[from], "..") == 0) {
if (to > 0 && strcmp(segments[to - 1], "..") != 0) {
to--;
} else {
to++;
}
} else {
segments[to] = segments[from];
to++;
}
}
/*
* Catenate the result
*/
cp = result;
if (*path == '/') {
*cp++ = '/';
}
for (i = 0; i < to; i++) {
len = strlen(segments[i]);
strcpy(cp, segments[i]);
cp += len;
if ((i + 1) < to) {
*cp++ = '/';
}
}
*cp = '\0';
return result;
}
void MachOLoader::loadSegments(const MachO& mach, intptr* slide, intptr* base, ELFBlock* elf)
{
*base = 0;
--*base;
if (m_pTrampolineMgr)
m_pTrampolineMgr->invalidateMemoryMap();
const std::vector<Segment*>& segments = getSegments(mach);
for (Segment* seg : segments)
{
const char* name = seg->segname;
if (!strcmp(name, SEG_PAGEZERO))
continue;
LOG << seg->segname << ": "
<< "fileoff=" << seg->fileoff
<< ", vmaddr=" << seg->vmaddr <<std::endl;
int prot = 0, maxprot = 0;
if (seg->initprot & VM_PROT_READ)
prot |= PROT_READ;
if (seg->initprot & VM_PROT_WRITE)
prot |= PROT_WRITE;
if (seg->initprot & VM_PROT_EXECUTE)
prot |= PROT_EXEC;
if (seg->maxprot & VM_PROT_READ)
maxprot |= PROT_READ;
if (seg->maxprot & VM_PROT_WRITE)
maxprot |= PROT_WRITE;
if (seg->maxprot & VM_PROT_EXECUTE)
maxprot |= PROT_EXEC;
intptr filesize = alignMem(seg->filesize, 0x1000);
intptr vmaddr = seg->vmaddr + *slide;
if (vmaddr < m_last_addr)
{
LOG << "will rebase: filename=" << mach.filename()
<< ", vmaddr=" << (void*)vmaddr
<< ", last_addr=" << (void*)m_last_addr <<std::endl;
assert(seg == segments[0]);
vmaddr = m_last_addr;
*slide = vmaddr - seg->vmaddr;
}
*base = std::min(*base, vmaddr);
intptr vmsize = alignMem(seg->vmsize, 0x1000);
LOG << "mmap(file) " << mach.filename() << ' ' << name
<< ": " << (void*)vmaddr << "-" << (void*)(vmaddr + filesize)
<< " offset=" << mach.offset() + seg->fileoff <<std::endl;
if (filesize == 0)
continue;
checkMmapMinAddr(vmaddr);
void* mapped = ::mmap((void*)vmaddr, filesize, maxprot, MAP_PRIVATE | MAP_FIXED, mach.fd(), mach.offset() + seg->fileoff);
m_mprotects.push_back(MProtect{(void*) vmaddr, filesize, prot});
if (mapped == MAP_FAILED)
{
std::stringstream ss;
ss << "Failed to mmap '" << mach.filename() << "': " << strerror(errno);
throw std::runtime_error(ss.str());
}
assert(vmsize >= filesize);
if (vmsize > filesize)
{
LOG << "mmap(anon) " << mach.filename() << ' ' << name
<< ": " << (void*)(vmaddr + filesize) << "-"
<< (void*)(vmaddr + vmsize)
<<std::endl;
void* mapped = ::mmap(reinterpret_cast<char*>(vmaddr) + filesize, vmsize - filesize, prot, MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, 0, 0);
if (mapped == MAP_FAILED)
{
std::stringstream ss;
ss << "mmap(anon) failed on '" << mach.filename() << "': " << strerror(errno);
throw std::runtime_error(ss.str());
}
}
m_last_addr = std::max(m_last_addr, (intptr)vmaddr + vmsize);
if (elf)
elf->addSection(name, (void*)vmaddr, vmsize, 0);
}
}
void CX3DOpenHRPHumanoidNode::print(int indent)
{
FILE *fp = CX3DParser::getDebugLogFp();
int nMax = CX3DParser::getMaxPrintElemsForMFField();
bool bPartialPrint = false;
char *nodeName = getNodeName();
if (nodeName)
{
float x, y, z, rot;
MFNode *nodes;
int i, n;
CX3DParser::printIndent(indent);
fprintf(fp, "%s (%s)\n", nodeName, CX3DNode::getNodeTypeString(getNodeType()));
CX3DParser::printIndent(indent+1);
getCenter()->getValue(x, y, z);
fprintf(fp, "center : (%f %f %f)\n", x, y, z);
CX3DParser::printIndent(indent+1);
getRotation()->getValue(x, y, z, rot);
fprintf(fp, "rotation : (%f %f %f)(%f)\n", x, y, z, rot);
CX3DParser::printIndent(indent+1);
getScale()->getValue(x, y, z);
fprintf(fp, "scale : (%f %f %f)\n", x, y, z);
CX3DParser::printIndent(indent+1);
getScaleOrientation()->getValue(x, y, z, rot);
fprintf(fp, "scaleOrientation : (%f %f %f)(%f)\n", x, y, z, rot);
CX3DParser::printIndent(indent+1);
getTranslation()->getValue(x, y, z);
fprintf(fp, "translation : (%f %f %f)\n", x, y, z);
CX3DParser::printIndent(indent+1);
fprintf(fp, "name (%s)\n", m_name.getValue());
CX3DParser::printIndent(indent+1);
n = m_info.count();
fprintf(fp, "info [%d]\n", n);
if ((nMax > 0) && (n > nMax)) { n = nMax; bPartialPrint = true; }
else { bPartialPrint = false; }
for (i=0; i<n; i++)
{
CX3DParser::printIndent(indent+2);
fprintf(fp, "%s\n", m_info.getValue(i));
}
if (bPartialPrint)
{
CX3DParser::printIndent(indent+2);
fprintf(fp, "...\n");
}
CX3DParser::printIndent(indent+1);
nodes = getJoints();
n = nodes->count();
fprintf(fp, "joints [%d]\n", n);
for (i=0; i<n; i++)
{
CX3DNode *child = nodes->getNode(i);
if (child)
{
child->print(indent+2);
}
}
CX3DParser::printIndent(indent+1);
nodes = getSegments();
n = nodes->count();
fprintf(fp, "segments [%d]\n", n);
for (i=0; i<n; i++)
{
CX3DNode *child = nodes->getNode(i);
if (child)
{
child->print(indent+2);
}
}
CX3DParser::printIndent(indent+1);
nodes = getSites();
n = nodes->count();
fprintf(fp, "sites [%d]\n", n);
for (i=0; i<n; i++)
{
CX3DNode *child = nodes->getNode(i);
if (child)
{
child->print(indent+2);
}
}
CX3DParser::printIndent(indent+1);
nodes = getHumanoidBody();
n = nodes->count();
fprintf(fp, "humanoidBody [%d]\n", n);
for (i=0; i<n; i++)
{
CX3DNode *child = nodes->getNode(i);
if (child)
{
child->print(indent+2);
}
}
CX3DParser::printIndent(indent+1);
fprintf(fp, "version (%s)\n", m_version.getValue());
CX3DParser::printIndent(indent+1);
nodes = getViewpoints();
n = nodes->count();
fprintf(fp, "viewpoints [%d]\n", n);
for (i=0; i<n; i++)
{
CX3DNode *child = nodes->getNode(i);
if (child)
{
child->print(indent+2);
}
}
}
}
