Node* Namespace::ForwardDeclareAlongPath(const tNodePath& path)
{
if (path.empty())
return nullptr;
if (path[0]->GetNodeType() != NodeType::Namespace || path[0]->GetName() != GetName())
return nullptr;
Namespace *parent = this;
for (size_t i = 1, S = path.size(); i < S; ++i)
{
auto p = path[i];
if (p->GetNodeType() == NodeType::Namespace)
parent = GetOrCreateNamespace(p->GetName());
else if (p->GetNodeType() == NodeType::Class)
parent = GetOrCreateClass(p->GetName());
else if (p->GetNodeType() == NodeType::Type)
{
if (i == S - 1)
return GetOrCreateType((static_cast<const Type *>(p))->GetPrimitive(), p->GetName());
else
return nullptr;
}
}
return parent;
}
bool SP_Node_CH::DataRespondHandler_SN(SP_Msg& inMsg)
{
//DATA MESSAGE, FROM SENSOR NODES
if(!(
this->state == SP_CommState::CONNECTED &&
inMsg.type == SP_MsgType::DATA &&
inMsg.fromNodeType == SP_NodeType::SN))
return false;
#ifdef SMARTPARK_SERIAL_DEBUG
Serial.print(F("[INFO]: Parked="));
Serial.println(static_cast<uint8_t>(inMsg.data[0]) == 1);
#endif
//Take data and add to table
bool parked = static_cast<uint8_t>(inMsg.data[0]) == 1;
AddOrModifyEventData(inMsg.from, parked);
//Respond with an ACK
SP_Msg* existingMsg = GetFirstOutMsgOfType(SP_MsgType::ACK);
if(existingMsg == 0)
{
//ACKnowledge their message
SP_Msg* outMsg = new SP_Msg();
outMsg->reliable = false;
outMsg->to = inMsg.from;
outMsg->from = this->addr;
outMsg->fromNodeType = GetNodeType();
outMsg->type = SP_MsgType::ACK;
outMsg->dataLen = 0;
outMsg->data = 0;
this->PendMsg(outMsg);
}
return true;
}
STDMETHODIMP CMaxMaterialCollection::IsSelectionValid(VARIANT_BOOL* vResult)
{
Interface* ip = GetCOREInterface();
*vResult = VARIANT_FALSE;
/*
if(ip->GetSelNodeCount())
*vResult = VARIANT_TRUE;
*/
int n = 0;
int count = ip->GetSelNodeCount();
INode *pNode;
for (int i=0; i<count; i++) {
pNode = ip->GetSelNode(i);
if(pNode == NULL)
continue;
SClass_ID id = GetNodeType(pNode);
if (id==SHAPE_CLASS_ID) n++;
else if (id==GEOMOBJECT_CLASS_ID) {
if (!pNode->IsTarget()) n++;
}
}
if(n>0)
*vResult = VARIANT_TRUE;
return S_OK;
}
bool SP_Node_CH::DataRespondHandler_CH(SP_Msg& inMsg)
{
//DATA MESSAGE, FROM CLUSTER HEAD NODES
if(!(
this->state == SP_CommState::CONNECTED &&
inMsg.type == SP_MsgType::DATA &&
inMsg.fromNodeType == SP_NodeType::CH))
return false;
//Get the data from the message
uint8_t len = getSP_EventDataArrLenFromStr(inMsg.data);
SP_EventData** datas = new SP_EventData*[len];
len = parseSP_EventDataArrStr(inMsg.data, datas, len); //Returns actual len
//Take data and add to table
for(int i=0; i<len; ++i)
AddOrModifyEventData(datas[i]->from, datas[i]->parked);
//Respond with an ACK
SP_Msg* existingMsg = GetFirstOutMsgOfType(SP_MsgType::ACK);
if(existingMsg == 0)
{
//ACKnowledge their message
SP_Msg* outMsg = new SP_Msg();
outMsg->reliable = false;
outMsg->to = inMsg.from;
outMsg->from = this->addr;
outMsg->fromNodeType = GetNodeType();
outMsg->type = SP_MsgType::ACK;
outMsg->dataLen = 0;
outMsg->data = 0;
this->PendMsg(outMsg);
}
return true;
}
int bytnodtyp(void) {
int going=TRUE,nr,x;
struct NodeType *nt=NULL;
puttekn("\n\n\rVilken nodtyp vill du ha som förinställd?\n\n\r",-1);
puttekn(" 0: Ingen, jag vill bli tillfrågad vid inloggning.\n\r",-1);
for(x=0; x<MAXNODETYPES; x++) {
if(Servermem->nodetypes[x].nummer==0) break;
sprintf(outbuffer,"%2d: %s\n\r",Servermem->nodetypes[x].nummer,Servermem->nodetypes[x].desc);
putstring(outbuffer,-1,0);
}
while(going) {
putstring("\n\rVal: ",-1,0);
if(getstring(EKO,2,NULL)) return(1);
nr = atoi(inmat);
if(nr<0) putstring("\n\rDu måste ange ett positivt heltal.\n\r",-1,0);
else if(nr==0) going=FALSE;
else if(!(nt=GetNodeType(atoi(inmat)))) putstring("\n\rFinns ingen sådan nodtyp.\n\r",-1,0);
else going=FALSE;
}
if(!nt) {
Servermem->inne[nodnr].shell=0;
puttekn("\n\n\rDu har nu ingen förinställd nodtyp.\n\r",-1);
} else {
Servermem->inne[nodnr].shell = nt->nummer;
puttekn("\n\n\rDin förinställda nodtyp är nu:\n\r",-1);
puttekn(nt->desc,-1);
puttekn("\n\n\r",-1);
}
return(0);
}
bool ProjectFileParser::ReadItemGroup(rapidxml::xml_node<>* node)
{
std::string label = GetAttributeValue(node,"Label");
if (label == "ProjectConfigurations")
return ReadProjectConfigurations(node);
rapidxml::xml_node<>* child = node->first_node();
while (child)
{
switch (GetNodeType(child))
{
case eClCompile:
AddSourceFile(child);
break;
case eClInclude:
AddIncludeFile(child);
break;
case eResourceCompile:
AddResourceFile(child);
break;
case eCustomBuild:
AddCustomBuildFile(child);
break;
case eNone:
break;
case eProjectReference:
AddProjectReference(child);
break;
default:
break;
}
child = child->next_sibling();
}
return true;
}
string CJsonNode::Repr(TReprFlags flags) const
{
CNcbiOstrstream oss;
switch (GetNodeType()) {
case CJsonNode::eObject:
if (flags & fOmitOutermostBrackets)
s_Repr_Object(oss, *this);
else {
oss << '{';
s_Repr_Object(oss, *this);
oss << '}';
}
break;
case CJsonNode::eArray:
if (flags & fOmitOutermostBrackets)
s_Repr_Array(oss, *this);
else {
oss << '[';
s_Repr_Array(oss, *this);
oss << ']';
}
break;
case CJsonNode::eString:
if (flags & fVerbatimIfString)
return (static_cast<const SJsonStringNodeImpl*>(
m_Impl.GetPointerOrNull())->m_String);
/* FALL THROUGH */
default:
s_Repr_Value(oss, *this);
}
return CNcbiOstrstreamToString(oss);
}
MovieTexture::MovieTexture() : X3DTexture2DNode(GetNodeType()),
m_url(new MFString(this)),
m_repeatS(new SFBool(this, true)),
m_repeatT(new SFBool(this, true))
{
// m_texName = 0;
m_status = 0;
}
Transform::Transform() : X3DGroupingNode(GetNodeType()),
m_center(new SFVec3f(get_centerFieldDef(), this)),
m_rotation(new SFRotation(get_rotationFieldDef(), this)),
m_scale(new SFVec3f(get_scaleFieldDef(), this)),
m_scaleOrientation(new SFRotation(get_scaleOrientationFieldDef(), this)),
m_translation(new SFVec3f(get_translationFieldDef(), this))
{
}
Material::Material() : X3DMaterialNode(GetNodeType()),
m_ambientIntensity(new SFFloat(get_ambientIntensityFieldDef(), this)),
m_diffuseColor(new SFColor(get_diffuseColorFieldDef(), this)),
m_emissiveColor(new SFColor(get_emissiveColorFieldDef(), this)),
m_shininess(new SFFloat(get_shininessFieldDef(), this)),
m_specularColor(new SFColor(get_specularColorFieldDef(), this)),
m_transparency(new SFFloat(get_transparencyFieldDef(), this))
{
}
bool
ConfigManager::ReadTag(std::istream& in, std::string &tagName, NodeTypeEnum &tagType,
int &tagLength, bool &tagIsReturnTag)
{
// Read strings.
stringVector sv = ReadStringVector(in, '>');
std::string tagTypeStr("");
tagName = "";
tagType = INTERNAL_NODE;
tagLength = 0;
for(size_t i = 0; i < sv.size(); ++i)
{
std::string::size_type pos = sv[i].find('=') + 1;
std::string token(sv[i].substr(0, pos));
std::string tokenValue;
if(pos != std::string::npos && token.size() > 0)
tokenValue = sv[i].substr(pos + 1, sv[i].size() - pos - 2);
if(sv[i][0] == '/')
{
tagIsReturnTag = true;
return true;
}
else if(token == "type=")
{
tagTypeStr = tokenValue;
}
else if(token == "name=")
{
tagName = tokenValue;
}
else if(token == "length=")
{
int len;
if(sscanf(tokenValue.c_str(), "%d", &len) == 1)
{
tagLength = (len > 0) ? len : tagLength;
}
}
else if(token == "childObjects=")
{
// Skip this tag, it is obsolete.
}
else
tagTypeStr = sv[i];
}
// Get the NodeTypeEnum from the tag's type name.
tagType = GetNodeType(tagTypeStr.c_str());
return sv.size() > 0;
}
Sound::Sound() : X3DSoundNode(GetNodeType()),
m_direction(new SFVec3f(get_directionFieldDef(), this, Vec3f(0.0f, 0.0f, 1.0f))),
m_intensity(new SFFloat(get_intensityFieldDef(), this, 1.0f)),
m_maxBack(new SFFloat(get_maxBackFieldDef(), this, 10)),
m_maxFront(new SFFloat(get_maxFrontFieldDef(), this, 10)),
m_minBack(new SFFloat(get_minBackFieldDef(), this, 1)),
m_minFront(new SFFloat(get_minFrontFieldDef(), this, 1)),
m_bPlaying(false)
{
}
static rc_t CC NodeDataInit(NodeData* data, const KXMLNode* node,
const char* parentName, uint32_t idx)
{
rc_t rc = 0;
assert(node && parentName && data);
memset(data, 0, sizeof *data);
rc = KXMLNodeGetName(node, &data->nodeName);
/* if (rc != 0) {
PLOGERR(klogErr, (klogErr, rc,
"while calling KXMLNodeGetName($(parent)[$(i)]",
"parent=%s,i=%d", parentName, idx));
}*/
if (rc == 0
&& data->nodeName && !strcmp(data->nodeName, "symlink"))
{
rc = KXMLNodeReadCStr(node, &data->nodeValue, NULL);
/* if (rc != 0) {
PLOGERR(klogErr, (klogErr, rc,
"while calling KXMLNodeReadCStr($(name))",
"name=%s", data->nodeName));
}*/
}
if (rc == 0) {
rc = NodeDataReadAttribs(data, node, parentName, idx);
}
if (rc == 0) {
data->nodeType = GetNodeType(data->nodeName);
if (data->md5) {
if (strlen(data->md5) != 32) {
rc = RC(rcFS, rcXmlDoc, rcReading, rcFormat, rcInvalid);
/* PLOGERR(klogErr, (klogErr, rc,
"md5sum '$(md5)'", "md5=%s", data->md5));*/
}
else {
rc = MD5SumExtract(data->md5, data->digest);
}
}
}
if (rc == 0) {
rc = StrToKTime(data->mtime, &data->tMtime);
}
return rc;
}
Box::Box() : X3DGeometryNode(GetNodeType()), m_size(new SFVec3f(get_sizeFieldDef(), this, Vec3f(2,2,2)))
{
// m_vertexBuffer = NULL;
// m_size = NULL;
// Cache pointers to relevant fields
// m_size = static_cast<SFVec3f*>(getField(WSTR("size")));
ASSERT(m_size);
// Set defaults
// m_size->m_value[0] = m_size->m_value[1] = m_size->m_value[2] = 2;
}
std::auto_ptr<Project> ProjectFileParser::Parse(std::string file)
{
std::auto_ptr<Project> ret;
try
{
rapidxml::file<> xmlFile(file.c_str());
rapidxml::xml_document<> doc;
doc.parse<0>(xmlFile.data());
rapidxml::xml_node<>* projNode = doc.first_node();
if (projNode == NULL) return ret;
if (std::string(projNode->name()) != "Project") return ret;
ret.reset(new Project());
m_project = ret.get();
rapidxml::xml_node<>* node = projNode->first_node();
while (node)
{
switch (GetNodeType(node))
{
case eItemGroup:
ReadItemGroup(node);
break;
case ePropertyGroup:
ReadPropertyGroup(node);
break;
case eImportGroup:
ReadImportGroup(node);
break;
case eImport:
ReadImport(node);
break;
case eItemDefinitionGroup:
ReadItemDefinitionGroup(node);
break;
case eUnknown:
break;
default:
// any node at this level should be handled
break;
}
node = node->next_sibling();
}
}
catch (...)
{
ret.reset();
}
m_project = NULL;
return ret;
}
bool SP_Node_CH::ConnectedHandler(SP_Msg& inMsg)
{
//Only respond to ADD messages directly to us
if(!(
inMsg.type == SP_MsgType::ADD))
return false;
bool shouldRespond = false;
//Respond if we have an existing NEW out message and no neighbors
SP_Msg* existingMsg = GetOutMsg(0);
if(existingMsg != 0 && existingMsg->type == SP_MsgType::NEW && neighborCount == 0)
{
//Remove message
RemoveFirstOutMsg();
shouldRespond = true;
//Add neighbor
SP_Node::SP_Node_Info* newNeighbor = new SP_Node::SP_Node_Info();
newNeighbor->addr = inMsg.from;
newNeighbor->type = inMsg.fromNodeType;
AddNeighbor(newNeighbor);
state = SP_CommState::CONNECTED;
}
//Or if responding to node that's our upstream neighbor
else if(neighbors[0] != 0 && neighbors[0]->addr == inMsg.from)
{
shouldRespond = true;
}
if(!shouldRespond) //Don't continue if no response
return false;
//Respond with ACK
existingMsg = GetFirstOutMsgOfType(SP_MsgType::ACK);
if(existingMsg == 0)
{
//Add new ACK if none exists
SP_Msg* outMsg = new SP_Msg();
outMsg->reliable = false;
outMsg->to = inMsg.from;
outMsg->from = this->addr;
outMsg->fromNodeType = GetNodeType();
outMsg->type = SP_MsgType::ACK;
outMsg->dataLen = 0;
outMsg->data = 0;
//Set this message as pending
this->PendMsg(outMsg);
}
return true;
}
void XmlReader::Advance()
{
do
{
int succ = xmlTextReaderRead(mImpl);
if(succ == -1)
{
throw Exception("Couldn't read xml file ");
}
else if(succ == 0)
{
break;
}
}
while(!IsSignificant(GetNodeType()));
}
spIMetadata APICALL DOMParserImpl::Parse( const char * buffer, sizet bufferLength ) {
auto node = ParseAsNode( buffer, bufferLength );
if ( node ) {
switch ( node->GetNodeType() ) {
case INode::kNTSimple:
case INode::kNTArray:
{
spIMetadata meta = IMetadata::CreateMetadata();
meta->AppendNode( node );
return meta;
}
break;
case INode::kNTStructure:
{
pIMetadata meta( NULL );
try {
meta = node->GetInterfacePointer< IMetadata >();
} catch ( spcIError err ) {
meta = NULL;
}
if ( meta ) {
return MakeUncheckedSharedPointer( meta, __FILE__, __LINE__ );
} else {
spIMetadata meta = IMetadata::CreateMetadata();
meta->AppendNode( node );
return meta;
}
}
break;
default:
NOTIFY_ERROR( IError::kEDGeneral, kGECInternalFailure, "Unhandled situation occured", IError::kESOperationFatal, false, false );
}
}
return spIMetadata();
}
void SP_Node_CH::HeldDataAction()
{
if(!(
dataHasChanged &&
state == SP_CommState::CONNECTED))
return;
//Get a the string representing all the data
uint8_t heldDataStrLen = getSP_EventDataArrStrLen(dataCount);
char* heldDataStr = new char[heldDataStrLen];
getSP_EventDataArrStr(data, dataCount, heldDataStr, heldDataStrLen);
//Pend a message with all data
SP_Msg* existingMsg = GetFirstOutMsgOfType(SP_MsgType::DATA);
if(existingMsg == 0)
{
//Pend new message
SP_Msg* outMsg = new SP_Msg();
outMsg->reliable = true;
outMsg->to = neighbors[0]->addr;
outMsg->from = this->addr;
outMsg->fromNodeType = GetNodeType();
outMsg->type = SP_MsgType::DATA;
outMsg->dataLen = heldDataStrLen;
outMsg->data = heldDataStr;
this->PendMsg(outMsg);
}
else
{
//Reuse existing message
delete[] existingMsg->data; //Delete old buffer
existingMsg->dataLen = heldDataStrLen; //Use new buffer
existingMsg->data = heldDataStr;
}
dataHasChanged = false;
}
bool SP_Node_CH::ConnectRespondHandler(SP_Msg& inMsg)
{
if(!(
this->state == SP_CommState::CONNECTED &&
inMsg.type == SP_MsgType::NEW))
return false;
SP_Msg* existingMsg = GetFirstOutMsgOfType(SP_MsgType::ADD);
if(existingMsg == 0)
{
//Add new ADD if none exists
SP_Msg* outMsg = new SP_Msg();
outMsg->reliable = true;
outMsg->to = inMsg.from;
outMsg->from = this->addr;
outMsg->fromNodeType = GetNodeType();
outMsg->type = SP_MsgType::ADD;
outMsg->dataLen = 0;
outMsg->data = 0;
//Set this message as pending
this->PendMsg(outMsg);
}
return true;
}
Anchor::Anchor() : X3DGroupingNode(GetNodeType())
{
}
/*
* ======== DSPNode_Delete ========
* Purpose:
* Delete all DSP-side and GPP-side resources for the node.
*/
DBAPI DSPNode_Delete(DSP_HNODE hNode)
{
DSP_STATUS status = DSP_SOK;
Trapped_Args tempStruct;
BYTE *pVirtBase = NULL;
struct DSP_BUFFERATTR bufAttr;
struct CMM_OBJECT *hCmm; /* shared memory mngr handle */
struct CMM_INFO pInfo; /* Used for virtual space allocation */
DSP_NODETYPE nodeType;
struct DSP_NODEATTR nodeAttr;
#ifdef DEBUG_BRIDGE_PERF
struct timeval tv_beg;
struct timeval tv_end;
struct timezone tz;
int timeRetVal = 0;
timeRetVal = getTimeStamp(&tv_beg);
#endif
DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("NODE: DSPNode_Delete:\r\n")));
if (!hNode) {
/* Invalid pointer */
status = DSP_EHANDLE;
DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("NODE: DSPNode_Delete: "
"hNode is Invalid Handle\r\n")));
return status;
}
/* Get segment size.
>0 is SM segment. Get default SM Mgr*/
tempStruct.ARGS_CMM_GETHANDLE.hProcessor = NULL;
tempStruct.ARGS_CMM_GETHANDLE.phCmmMgr = &hCmm;
status = DSPTRAP_Trap(&tempStruct, CMD_CMM_GETHANDLE_OFFSET);
if (DSP_SUCCEEDED(status)) {
/* Get SM segment info from CMM */
tempStruct.ARGS_CMM_GETINFO.hCmmMgr = hCmm;
tempStruct.ARGS_CMM_GETINFO.pCmmInfo = &pInfo;
status = DSPTRAP_Trap(&tempStruct, CMD_CMM_GETINFO_OFFSET);
if (DSP_FAILED(status)) {
status = DSP_EFAIL;
DEBUGMSG(DSPAPI_ZONE_ERROR,
(TEXT("NODE: DSPNode_Delete:"
" Failed to get SM segment\r\n")));
} else
status = DSP_SOK;
} else {
status = DSP_EFAIL;
DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("NODE: DSPNode_Delete: "
"Failed to CMM handle\r\n")));
}
if (!DSP_SUCCEEDED(status)) {
status = DSP_EBADSEGID; /* no SM segments*/
return status;
}
status = DSPNode_GetAttr(hNode, &nodeAttr, sizeof(nodeAttr));
GetNodeType(hNode, &nodeType);
if (nodeType != NODE_DEVICE) {
/*segInfo index starts at 0.These checks may not be required*/
if ((pInfo.segInfo[0].dwSegBasePa != 0) &&
(pInfo.segInfo[0].ulTotalSegSize) > 0) {
/* get node translator's virtual address range
so we can free it */
bufAttr.uAlignment = 0;
bufAttr.uSegment = 1 | MEMRY_GETVIRTUALSEGID;
DSPNode_AllocMsgBuf(hNode, 1, &bufAttr, &pVirtBase);
/* Free virtual space */
if (!pVirtBase)
goto loop_end;
if (munmap(pVirtBase,
pInfo.segInfo[0].ulTotalSegSize)) {
status = DSP_EFAIL;
}
}
}
loop_end:
if (DSP_SUCCEEDED(status)) {
/* Set up the structure Call DSP Trap */
tempStruct.ARGS_NODE_DELETE.hNode = hNode;
status = DSPTRAP_Trap(&tempStruct, CMD_NODE_DELETE_OFFSET);
/* Free any node heap memory */
if (nodeAttr.inNodeAttrIn.pGPPVirtAddr) {
DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("DSPNodeDelete:"
"Freeing Node heap addr \n")));
free(nodeAttr.inNodeAttrIn.pGPPVirtAddr);
}
}
#ifdef DEBUG_BRIDGE_PERF
timeRetVal = getTimeStamp(&tv_end);
PrintStatistics(&tv_beg, &tv_end, "DSPNode_Delete", 0);
#endif
return status;
}
/*
* ======== DSPNode_Allocate ========
* Purpose:
* Allocate data structures for controlling and communicating
* with a node on a specific DSP processor..
*/
DBAPI DSPNode_Allocate(DSP_HPROCESSOR hProcessor,
IN CONST struct DSP_UUID *pNodeID,
IN CONST OPTIONAL struct DSP_CBDATA *pArgs,
IN OPTIONAL struct DSP_NODEATTRIN *pAttrIn,
OUT DSP_HNODE *phNode)
{
DSP_STATUS status = DSP_SOK;
Trapped_Args tempStruct;
struct CMM_OBJECT *hCmm; /* shared memory mngr handle */
struct CMM_INFO pInfo; /* Used for virtual space allocation */
PVOID pVirtBase;
struct DSP_BUFFERATTR bufAttr;
DSP_NODETYPE nodeType;
struct DSP_NDBPROPS nodeProps;
UINT heapSize = 0;
PVOID pGPPVirtAddr = NULL;
UINT uProfileID;
DEBUGMSG(DSPAPI_ZONE_FUNCTION, (TEXT("NODE: DSPNode_Allocate:\r\n")));
if (!hProcessor) {
status = DSP_EHANDLE;
DEBUGMSG(DSPAPI_ZONE_ERROR,
(TEXT("NODE: DSPNode_Allocate: "
"hProcessor is Invalid \r\n")));
goto func_cont;
}
if (!(pNodeID) || !(phNode)) {
status = DSP_EPOINTER;
DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("NODE: DSPNode_Allocate: "
"Invalid pointer in the Input\r\n")));
goto func_cont;
}
/* First get the NODE properties, allocate, reserve
memory for Node heap */
if (pAttrIn) {
status = DSPNode_GetUUIDProps(hProcessor, pNodeID, &nodeProps);
pAttrIn->pGPPVirtAddr = NULL;
if (DSP_SUCCEEDED(status)) {
uProfileID = pAttrIn->uProfileID;
DEBUGMSG(DSPAPI_ZONE_FUNCTION,
("DSPNodeAllocate: User requested"
"node heap profile \n"));
if (uProfileID < nodeProps.uCountProfiles)
heapSize =
nodeProps.aProfiles[uProfileID].ulHeapSize;
if (heapSize) {
/* allocate heap memory */
/* Make heap size multiple of page size * */
heapSize = PG_ALIGN_HIGH(heapSize, PG_SIZE_4K);
/* align memory on cache line boundary * */
pGPPVirtAddr = memalign(GEM_CACHE_LINE_SIZE,
heapSize);
DEBUGMSG(DSPAPI_ZONE_FUNCTION,
("DSPNodeAllocate: Node heap memory"
"addr, size \n"));
if ((pGPPVirtAddr == NULL))
status = DSP_EMEMORY;
pAttrIn->uHeapSize = heapSize;
pAttrIn->pGPPVirtAddr = pGPPVirtAddr;
}
} else {
DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT(
"NODE:DSPNode_Allocate: Failed to get Node "
"UUID properties \r\n")));
}
}
if (DSP_SUCCEEDED(status)) {
/* Set up the structure Call DSP Trap */
tempStruct.ARGS_NODE_ALLOCATE.hProcessor = hProcessor;
tempStruct.ARGS_NODE_ALLOCATE.pNodeID =
(struct DSP_UUID *)pNodeID;
tempStruct.ARGS_NODE_ALLOCATE.pArgs =
(struct DSP_CBDATA *)pArgs;
tempStruct.ARGS_NODE_ALLOCATE.pAttrIn =
(struct DSP_NODEATTRIN *)pAttrIn;
tempStruct.ARGS_NODE_ALLOCATE.phNode = phNode;
status = DSPTRAP_Trap(&tempStruct, CMD_NODE_ALLOCATE_OFFSET);
}
func_cont:
/* If 1st SM segment is configured then allocate and map it to
this process.*/
if (!DSP_SUCCEEDED(status)) {
if (pGPPVirtAddr)
free(pGPPVirtAddr);
return status;
}
tempStruct.ARGS_CMM_GETHANDLE.hProcessor = hProcessor;
tempStruct.ARGS_CMM_GETHANDLE.phCmmMgr = &hCmm;
status = DSPTRAP_Trap(&tempStruct, CMD_CMM_GETHANDLE_OFFSET);
if (DSP_SUCCEEDED(status)) {
/* Get SM segment info from CMM */
tempStruct.ARGS_CMM_GETINFO.hCmmMgr = hCmm;
tempStruct.ARGS_CMM_GETINFO.pCmmInfo = &pInfo;
status = DSPTRAP_Trap(&tempStruct, CMD_CMM_GETINFO_OFFSET);
if (DSP_FAILED(status)) {
status = DSP_EFAIL;
DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT(
"NODE: DSPNode_Allocate: "
"Failed to get SM segment\r\n")));
} else
status = DSP_SOK;
} else {
status = DSP_EFAIL;
DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT(
"NODE: DSPNode_Allocate:Failed to CMM handle\r\n")));
}
if (!DSP_SUCCEEDED(status)) {
free(pGPPVirtAddr);
return status;
}
GetNodeType(*phNode, &nodeType);
if ((nodeType != NODE_DEVICE) && (pInfo.ulNumGPPSMSegs > 0)) {
/* Messaging uses 1st segment */
if ((pInfo.segInfo[0].dwSegBasePa != 0) &&
(pInfo.segInfo[0].ulTotalSegSize) > 0) {
pVirtBase = mmap(NULL, pInfo.segInfo[0].ulTotalSegSize,
PROT_READ | PROT_WRITE, MAP_SHARED |
MAP_LOCKED, hMediaFile,
pInfo.segInfo[0].dwSegBasePa);
if (!pVirtBase) {
DEBUGMSG(DSPAPI_ZONE_ERROR, (TEXT("NODE: "
"DSPNode_Allocate:Virt alloc failed\r\n")));
status = DSP_EMEMORY;
/* Clean up */
tempStruct.ARGS_NODE_DELETE.hNode = *phNode;
DSPTRAP_Trap(&tempStruct,
CMD_NODE_DELETE_OFFSET);
return status;
}
/* set node translator's virt addr range for seg */
bufAttr.uAlignment = 0;
bufAttr.uSegment = 1 | MEMRY_SETVIRTUALSEGID;
bufAttr.cbStruct = 0;
status = DSPNode_AllocMsgBuf(*phNode,
pInfo.segInfo[0].ulTotalSegSize,
&bufAttr, (BYTE **)&pVirtBase);
if (DSP_FAILED(status)) {
/* If failed to set segment, unmap */
munmap(pVirtBase,
pInfo.segInfo[0].ulTotalSegSize);
/* Clean up */
tempStruct.ARGS_NODE_DELETE.hNode = *phNode;
DSPTRAP_Trap(&tempStruct,
CMD_NODE_DELETE_OFFSET);
}
}
}
return status;
}
XnStatus XnFileDevice::HandleNewStream(const XnChar *strType, const XnChar *strName, const XnActualPropertiesHash *pInitialValues)
{
XnStatus nRetVal = XN_STATUS_OK;
// check if we need to ignore that (stream was not removed upon Rewind).
XnNodeInfoMap::Iterator it = m_ignoreNewNodes.End();
if (m_ignoreNewNodes.Find(strName, it) == XN_STATUS_OK)
{
// ignore
return (XN_STATUS_OK);
}
XnProductionNodeType type = GetNodeType(strType);
if (type == -1)
{
XN_LOG_WARNING_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_FILE, "Invalid node type: %s", strType);
}
// find compression type
XnActualIntProperty* pComp = NULL;
nRetVal = pInitialValues->Get(XN_STREAM_PROPERTY_COMPRESSION, (XnProperty*&)pComp);
XN_IS_STATUS_OK(nRetVal);
XnCodecID codecID = XnCodec::GetCodecIDFromCompressionFormat((XnCompressionFormats)pComp->GetValue());
if (codecID == XN_CODEC_NULL)
{
XN_LOG_WARNING_RETURN(XN_STATUS_CORRUPT_FILE, XN_MASK_FILE, "Invalid compression type: %llu", pComp->GetValue());
}
// notify we have a new node
nRetVal = m_pNotifications->OnNodeAdded(m_pNotificationsCookie, strName, type, codecID);
XN_IS_STATUS_OK(nRetVal);
// we support the mirror capability
nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strName, XN_CAPABILITY_MIRROR, 1);
XN_IS_STATUS_OK(nRetVal);
// we support the extended serialization capability
nRetVal = m_pNotifications->OnNodeIntPropChanged(m_pNotificationsCookie, strName, XN_CAPABILITY_EXTENDED_SERIALIZATION, 1);
XN_IS_STATUS_OK(nRetVal);
// now write state
for (XnActualPropertiesHash::ConstIterator it = pInitialValues->Begin(); it != pInitialValues->End(); ++it)
{
XnProperty* pProp = it->Value();
switch (pProp->GetType())
{
case XN_PROPERTY_TYPE_INTEGER:
{
XnActualIntProperty* pIntProp = (XnActualIntProperty*)pProp;
nRetVal = HandleIntProperty(strName, pProp->GetName(), pIntProp->GetValue());
}
break;
case XN_PROPERTY_TYPE_REAL:
{
XnActualRealProperty* pRealProp = (XnActualRealProperty*)pProp;
nRetVal = HandleRealProperty(strName, pProp->GetName(), pRealProp->GetValue());
}
break;
case XN_PROPERTY_TYPE_STRING:
{
XnActualStringProperty* pStrProp = (XnActualStringProperty*)pProp;
nRetVal = HandleStringProperty(strName, pProp->GetName(), pStrProp->GetValue());
}
break;
case XN_PROPERTY_TYPE_GENERAL:
{
XnActualGeneralProperty* pGenProp = (XnActualGeneralProperty*)pProp;
nRetVal = HandleGeneralProperty(strName, pProp->GetName(), pGenProp->GetValue());
}
break;
default:
XN_LOG_WARNING_RETURN(XN_STATUS_ERROR, XN_MASK_FILE, "Unknown property type: %d", pProp->GetType());
}
XN_IS_STATUS_OK(nRetVal);
}
// at this stage, a node should exist with this name
xn::ProductionNode node;
nRetVal = m_context.GetProductionNodeByName(strName, node);
XN_IS_STATUS_OK(nRetVal);
// S2D & RW
if (type == XN_NODE_TYPE_DEPTH)
{
nRetVal = UpdateS2DTables(xn::DepthGenerator(node));
XN_IS_STATUS_OK(nRetVal);
nRetVal = UpdateRWData(xn::DepthGenerator(node));
XN_IS_STATUS_OK(nRetVal);
}
// notify end-of-state
nRetVal = m_pNotifications->OnNodeStateReady(m_pNotificationsCookie, strName);
XN_IS_STATUS_OK(nRetVal);
// add it to the map
XnNodeInfo nodeInfo = {0};
nRetVal = m_nodeInfoMap.Set(strName, nodeInfo);
XN_IS_STATUS_OK(nRetVal);
// create codec
nRetVal = CreateCodec(node);
XN_IS_STATUS_OK(nRetVal);
// check IR compatibility
nRetVal = CheckIRCompatibility(node);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
FloatVertexAttribute::FloatVertexAttribute() : X3DVertexAttributeNode(GetNodeType()),
m_numComponents(new SFInt32(NULL, this, 4))
{
}
Sound2D::Sound2D() : X3DSoundNode(GetNodeType())
{
}
Script::Script() : X3DScriptNode(GetNodeType())
{
}
struct NodeType *selectNodeType(void) {
struct NodeType *nt;
int going, i;
if(Servermem->nodetypes[0].nummer == 0) {
LogEvent(SYSTEM_LOG, ERROR, "Can't login user, no valid node types found.");
putstring("\n\n\r*** System error ***\n\n\r", -1, 0);
return NULL;
}
if(Servermem->nodetypes[1].nummer == 0) {
if((nt = GetNodeType(Servermem->nodetypes[0].nummer)) == NULL) {
LogEvent(SYSTEM_LOG, ERROR,
"Can't login user, the only configured node type (%d) can not be found.",
Servermem->nodetypes[0].nummer);
putstring("\n\n\r*** System error ***\n\n\r", -1, 0);
}
return nt;
}
if(Servermem->inne[nodnr].shell) {
nt = GetNodeType(Servermem->inne[nodnr].shell);
if(nt == NULL) {
Servermem->inne[nodnr].shell=0;
}
}
if(Servermem->inne[nodnr].shell == 0) {
putstring("\n\n\rDu har ingen förinställd nodtyp.\n\n\rVälj mellan:\n\n\r",-1,0);
for(i = 0; i < MAXNODETYPES; i++) {
if(Servermem->nodetypes[i].nummer == 0) {
break;
}
sprintf(outbuffer, "%2d: %s\n\r",
Servermem->nodetypes[i].nummer, Servermem->nodetypes[i].desc);
putstring(outbuffer, -1, 0);
}
going = TRUE;
while(going) {
putstring("\n\rVal: ",-1,0);
if(getstring(EKO, 2, NULL)) {
return NULL;
}
if(atoi(inmat) < 1) {
putstring("\n\rDu måste ange ett positivt heltal.\n\r",-1,0);
}
else if(!(nt = GetNodeType(atoi(inmat)))) {
putstring("\n\rFinns ingen sådan nodtyp.\n\r",-1,0);
}
else {
going=FALSE;
}
}
putstring("\n\n\rVill du använda denna nodtyp varje gång du loggar in?",-1,0);
if(jaellernej('j','n', 1)) {
putstring("Ja\n\r", -1, 0);
Servermem->inne[nodnr].shell = nt->nummer;
} else {
putstring("Nej\n\r",-1,0);
}
}
return nt;
}
IndexedLineSet2D::IndexedLineSet2D() : X3DGeometryNode(GetNodeType())
{
}
bool XmlCallbackReader::Parse(IContentHandler * pContentHandler)
{
bool bShouldContinue = true;
if (pContentHandler)
mpContentHandler = pContentHandler;
if (mpContentHandler)
mpContentHandler->StartDocument();
while (bShouldContinue && Read() ) {
if (mpContentHandler) {
const XmlReader::NodeType nodeType = GetNodeType();
switch (nodeType) {
case Element:
bShouldContinue = mpContentHandler->StartElement( mpTokenName, mAttributeArray.data(), mAttributeArray.size() / 2 );
if (bShouldContinue && IsEmptyElement())
bShouldContinue = mpContentHandler->EndElement( mpTokenName );
break;
case EndElement:
bShouldContinue = mpContentHandler->EndElement( mpTokenName );
break;
case CharacterData:
bShouldContinue = mpContentHandler->Characters( mpTokenValue, (size_t)mValueLength );
break;
case Comment:
bShouldContinue = mpContentHandler->Comment( mpTokenValue, (size_t)mValueLength );
break;
case ProcessingInstruction:
// As it stands now, the attribute list of the processing instruction is passed as a single unparsed string (mpTokenValue);
bShouldContinue = mpContentHandler->ProcessingInstruction( mpTokenName, mpTokenValue );
break;
case EntityRef:
bShouldContinue = mpContentHandler->SkippedEntity( mpTokenName );
break;
case None:
case Document:
case Prologue:
case DocTypeDecl:
case EntityDecl:
case ElementDecl:
case AttListDecl:
case NotationDecl:
// To do: We should do something about these types so the user can at least see them.
break;
}
}
}
if (mResultCode == kSuccess) {
if (mpContentHandler)
mpContentHandler->EndDocument();
return true;
}
return false;
}
