//show entry index sequences -- for debug purposes.
void XmlSync::check1()
{
QDomElement codeNode_in, codeNode_out;
QDomElement entryNode_in, entryNode_out;
quint32 i, index;
GET_NODE(root_in, "code", codeNode_in);
GET_NODE(root_out, "code", codeNode_out);
GET_FIRST_CHILD_NODE(codeNode_in, entryNode_in);
GET_FIRST_CHILD_NODE(codeNode_out, entryNode_out);
for (i = 0; i < 30; i++)
{
ATTRIBUTE_TO_UINT(entryNode_in, "index", index, quint32);
printf("%d ", index);
entryNode_in = entryNode_in.nextSiblingElement();
}
printf("\n\n");
for (i = 0; i < 30; i++)
{
ATTRIBUTE_TO_UINT(entryNode_out, "index", index, quint32);
printf("%i ", index);
entryNode_out=entryNode_out.nextSiblingElement();
}
printf("\n\n");
}
bool ehgraph_transfer_edge(ehgraph_t* dest, enode_t n1, ehgraph_t* src, enode_t n2, size_t link) {
bool bRet = false;
do {
CheckNotNULL(dest);
CheckNotNULL(src);
CheckLessThan(n1, dest->size);
CheckLessThan(n2, src->size);
CheckEqual(src->nLinks, dest->nLinks);
CheckLessThan(link, src->nLinks);
size_t nL = src->nLinks;
enode_info_t* nDst = &GET_NODE(dest, n1);
enode_info_t* nSrc = &GET_NODE(src, n2);
if (link == 0)
nDst->outDoubleLink = nSrc->outDoubleLink;
if (1 == link)
nDst->inDoubleLink = nSrc->inDoubleLink;
nDst->links[link] = nSrc->links[link];
nDst->superEdge[link] = nSrc->superEdge[link];
for (size_t ld = 0; ld < nL; ++ld) {
nDst->isPredicate[link][ld] = nSrc->isPredicate[link][ld];
nDst->predicateTarget[link][ld] = nSrc->predicateTarget[link][ld];
}
bRet = true;
} while(0);
return bRet;
}
int reset_pnodes(int curr, int pnode)
{
struct msm_bus_inode_info *info;
struct msm_bus_fabric_device *fabdev;
int index, next_pnode;
fabdev = msm_bus_get_fabric_device(GET_FABID(curr));
if (!fabdev) {
MSM_BUS_ERR("Fabric not found for: %d\n",
(GET_FABID(curr)));
return -ENXIO;
}
index = GET_INDEX(pnode);
info = fabdev->algo->find_node(fabdev, curr);
if (!info) {
MSM_BUS_ERR("Cannot find node info!\n");
return -ENXIO;
}
MSM_BUS_DBG("Starting the loop--remove\n");
do {
struct msm_bus_inode_info *hop;
fabdev = msm_bus_get_fabric_device(GET_FABID(curr));
if (!fabdev) {
MSM_BUS_ERR("Fabric not found\n");
return -ENXIO;
}
next_pnode = info->pnode[index].next;
info->pnode[index].next = -2;
curr = GET_NODE(next_pnode);
index = GET_INDEX(next_pnode);
if (IS_NODE(curr))
hop = fabdev->algo->find_node(fabdev, curr);
else
hop = fabdev->algo->find_gw_node(fabdev, curr);
if (!hop) {
MSM_BUS_ERR("Null Info found for hop\n");
return -ENXIO;
}
MSM_BUS_DBG("%d[%d] = %d\n", info->node_info->priv_id, index,
info->pnode[index].next);
MSM_BUS_DBG("num_pnodes: %d: %d\n", info->node_info->priv_id,
info->num_pnodes);
info = hop;
} while (GET_NODE(info->pnode[index].next) != info->node_info->priv_id);
info->pnode[index].next = -2;
MSM_BUS_DBG("%d[%d] = %d\n", info->node_info->priv_id, index,
info->pnode[index].next);
MSM_BUS_DBG("num_pnodes: %d: %d\n", info->node_info->priv_id,
info->num_pnodes);
return 0;
}
bool ehgraph_set_pred(ehgraph_t* graph, enode_t node, size_t edge, size_t link, size_t target) {
if (NULL == graph) {
DB_ERROR("null argument");
return false;
}
GET_NODE(graph, node).superEdge[edge] = true;
GET_NODE(graph, node).isPredicate[edge][link] = true;
GET_NODE(graph, node).predicateTarget[edge][link] = target;
return true;
}
void AnimationTreePlayer::oneshot_node_set_fadeout_time(const StringName& p_node,float p_time) {
GET_NODE( NODE_ONESHOT, OneShotNode );
n->fade_out=p_time;
}
void AnimationTreePlayer::timeseek_node_seek(const StringName& p_node,float p_pos) {
GET_NODE( NODE_TIMESEEK, TimeSeekNode );
n->seek_pos=p_pos;
}
void AnimationTreePlayer::timescale_node_set_scale(const StringName& p_node,float p_scale) {
GET_NODE( NODE_TIMESCALE, TimeScaleNode );
n->scale=p_scale;
}
void AnimationTreePlayer::oneshot_node_start(const StringName& p_node) {
GET_NODE( NODE_ONESHOT, OneShotNode );
n->active=true;
n->start=true;
}
void XmlSync::processEntryType05(QDomElement &parentNode, QByteArray *data)
{
QDomElement entryNode = parentNode.firstChildElement();
QTextCodec *codec = QTextCodec::codecForName("Shift-JIS");
while(!entryNode.isNull())
{
if(entryNode.tagName() == QString("text"))
{
QDomElement originalNode;
QString originalText;
GET_NODE(entryNode, "original", originalNode);
GET_NODE_TEXT(originalNode, originalText);
data->append(codec->fromUnicode(originalText));
}
else if (entryNode.tagName() == QString("ctrl"))
{
QString ctrlString;
ATTRIBUTE_TO_STRING_NOT_EMPTY(entryNode, "value", ctrlString);
data->append(ctrlString);
}
else
{
fatalExit("Unknown tag (not 'text' or 'ctrl')");
}
entryNode = entryNode.nextSiblingElement();
}
}
/**
* build mtree from serialized mtree data
*
* @params[in] pointer to serialized data
* @returns handle to new mtree
*
*/
H _m_unserialize(void *s) {
M *m = malloc(sizeof(M));
m->magic = ((M *)s)->magic;
m->levels = ((M *)s)->levels;
m->lP = malloc(sizeof(L)*m->levels);
H h = {m,{0,0}};
void *blob = ((S *)s)->blob_offset + (void *)s;
uint32_t s_size = SERIALIZED_HEADER_SIZE(m->levels);
for(h.a.l=0; h.a.l<m->levels; h.a.l++) {
L *sl = (L *) (((void *)s) + s_size + ((S *)s)->level_offsets[h.a.l]);
L *l = GET_LEVEL(h);
l->nodes = sl->nodes;
l->nP = malloc(sizeof(N)*l->nodes);
N *sn = sizeof(Mindex)+(void *)sl;
for(h.a.i=0;h.a.i < l->nodes;h.a.i++) {
N *n = GET_NODE(h,l);
*n = *sn;
void *surface = blob+*(size_t *)&sn->surface;
if (n->flags & TFLAG_ALLOCATED) {
n->surface = malloc(sn->size);
memcpy(n->surface,surface,sn->size);
}
else {
*((int *)&n->surface) = *((int *)&sn->surface);
}
sn = (N *) (SERIALIZED_NODE_SIZE + ((void*)sn));
}
}
h.a.i = h.a.l = 0;
return h;
}
void AnimationTreePlayer::transition_node_set_input_auto_advance(const StringName& p_node, int p_input,bool p_auto_advance) {
GET_NODE( NODE_TRANSITION, TransitionNode );
ERR_FAIL_INDEX(p_input,n->input_data.size());
n->input_data[p_input].auto_advance=p_auto_advance;
}
ehgraph_t* permute_graph(ehgraph_t* graph, int* perm) {
ehgraph_t* ret = NULL, *b = NULL;
do {
CheckNotNULL(graph);
CheckNotNULL(perm);
if (0 != perm[0]) {
DB_ERROR("the null element should remain unchanged in the permutation");
break;
}
b = ehgraph_alloc(NULL, graph->size, graph->ptrdim, graph->nLinks);
if (!b) {
DB_ERROR("allocation failed");
break;
}
b->closed = graph->closed;
for (enode_t i = 0; i < graph->ptrdim; ++i)
VAR2NODE(b, i) = perm[ VAR2NODE(graph, i) ];
for (enode_t i = 0; i < graph->size; ++i) {
GET_NODE(b, perm[i]).inDoubleLink = GET_NODE(graph, i).inDoubleLink;
GET_NODE(b, perm[i]).outDoubleLink = GET_NODE(graph, i).outDoubleLink;
for (size_t l = 0; l < graph->nLinks; ++l) {
GET_LINK(b, perm[i], l) = perm[ GET_LINK(graph, i, l) ];
GET_NODE(b, perm[i]).superEdge[l] = GET_NODE(graph, i).superEdge[l];
for (size_t lp = 0; lp < graph->nLinks; ++lp) {
GET_NODE(b, perm[i]).isPredicate[l][lp] = GET_NODE(graph, i).isPredicate[l][lp];
GET_NODE(b, perm[i]).predicateTarget[l][lp] = perm[ GET_NODE(graph, i).predicateTarget[l][lp] ];
}
}
}
ret = b;
} while(0);
if (!ret)
SafeFree(b);
return ret;
}
void AnimationTreePlayer::animation_node_set_animation(const StringName& p_node,const Ref<Animation>& p_animation) {
GET_NODE( NODE_ANIMATION, AnimationNode );
n->animation=p_animation;
dirty_caches=true;
}
/**
* add_path_node: Adds the path information to the current node
* @info: Internal node info structure
* @next: Combination of the id and index of the next node
* Function returns: Number of pnodes (path_nodes) on success,
* error on failure.
*
* Every node maintains the list of path nodes. A path node is
* reached by finding the node-id and index stored at the current
* node. This makes updating the paths with requested bw and clock
* values efficient, as it avoids lookup for each update-path request.
*/
static int add_path_node(struct msm_bus_inode_info *info, int next)
{
struct path_node *pnode;
int i;
if (ZERO_OR_NULL_PTR(info)) {
MSM_BUS_ERR("Cannot find node info!: id :%d\n",
info->node_info->priv_id);
return -ENXIO;
}
for (i = 0; i <= info->num_pnodes; i++) {
if (info->pnode[i].next == -2) {
MSM_BUS_DBG("Reusing pnode for info: %d at index: %d\n",
info->node_info->priv_id, i);
info->pnode[i].clk[DUAL_CTX] = 0;
info->pnode[i].clk[ACTIVE_CTX] = 0;
info->pnode[i].bw[DUAL_CTX] = 0;
info->pnode[i].bw[ACTIVE_CTX] = 0;
info->pnode[i].next = next;
MSM_BUS_DBG("%d[%d] : (%d, %d)\n",
info->node_info->priv_id, i, GET_NODE(next),
GET_INDEX(next));
return i;
}
}
info->num_pnodes++;
pnode = krealloc(info->pnode,
((info->num_pnodes + 1) * sizeof(struct path_node))
, GFP_KERNEL);
if (ZERO_OR_NULL_PTR(pnode)) {
MSM_BUS_ERR("Error creating path node!\n");
info->num_pnodes--;
return -ENOMEM;
}
info->pnode = pnode;
info->pnode[info->num_pnodes].clk[DUAL_CTX] = 0;
info->pnode[info->num_pnodes].clk[ACTIVE_CTX] = 0;
info->pnode[info->num_pnodes].bw[DUAL_CTX] = 0;
info->pnode[info->num_pnodes].bw[ACTIVE_CTX] = 0;
info->pnode[info->num_pnodes].next = next;
MSM_BUS_DBG("%d[%d] : (%d, %d)\n", info->node_info->priv_id,
info->num_pnodes, GET_NODE(next), GET_INDEX(next));
return info->num_pnodes;
}
sl_iter_t *sl_iter_begin (skiplist_t *sl, map_key_t key) {
sl_iter_t *iter = (sl_iter_t *)nbd_malloc(sizeof(sl_iter_t));
if (key != DOES_NOT_EXIST) {
find_preds(NULL, &iter->next, 1, sl, key, DONT_UNLINK);
} else {
iter->next = GET_NODE(sl->head->next[0]);
}
return iter;
}
bool ehgraph_del_pred(ehgraph_t* graph, enode_t node, size_t edge, size_t link) {
if (NULL == graph) {
DB_ERROR("null argument");
return false;
}
GET_NODE(graph, node).isPredicate[edge][link] = false;
return true;
}
map_key_t sl_min_key (skiplist_t *sl) {
node_t *item = GET_NODE(sl->head->next[0]);
while (item != NULL) {
markable_t next = item->next[0];
if (!HAS_MARK(next))
return item->key;
item = STRIP_MARK(next);
}
return DOES_NOT_EXIST;
}
void AnimationTreePlayer::oneshot_node_set_filter_path(const StringName& p_node,const NodePath& p_filter,bool p_enable) {
GET_NODE( NODE_ONESHOT, OneShotNode );
if (p_enable)
n->filter[p_filter]=true;
else
n->filter.erase(p_filter);
}
void AnimationTreePlayer::blend2_node_set_filter_path(const StringName& p_node,const NodePath& p_filter,bool p_enable) {
GET_NODE( NODE_BLEND2, Blend2Node );
if (p_enable)
n->filter[p_filter]=true;
else
n->filter.erase(p_filter);
}
void AnimationTreePlayer::animation_node_set_master_animation(const StringName& p_node,const String& p_master_animation) {
GET_NODE( NODE_ANIMATION, AnimationNode );
n->from=p_master_animation;
dirty_caches=true;
if (master!=NodePath())
_update_sources();
}
void sl_free (skiplist_t *sl) {
node_t *item = GET_NODE(sl->head->next[0]);
while (item) {
node_t *next = STRIP_MARK(item->next[0]);
if (sl->key_type != NULL) {
nbd_free((void *)item->key);
}
nbd_free(item);
item = next;
}
}
size_t sl_count (skiplist_t *sl) {
size_t count = 0;
node_t *item = GET_NODE(sl->head->next[0]);
while (item) {
if (!HAS_MARK(item->next[0])) {
count++;
}
item = STRIP_MARK(item->next[0]);
}
return count;
}
void AnimationTreePlayer::transition_node_set_input_count(const StringName& p_node, int p_inputs) {
GET_NODE( NODE_TRANSITION, TransitionNode );
ERR_FAIL_COND(p_inputs<1);
n->inputs.resize(p_inputs);
n->input_data.resize(p_inputs);
last_error=_cycle_test(out_name);
}
void XmlSync::replaceEntries(quint32 in_index, quint32 out_index)
{
QDomElement codeNode_in, codeNode_out;
QDomElement entryNode_in, entryNode_out;
QDomNode res;
quint32 i;
//Get to the nodes
GET_NODE(root_in, "code", codeNode_in);
GET_NODE(root_out, "code", codeNode_out);
GET_FIRST_CHILD_NODE(codeNode_in, entryNode_in);
GET_FIRST_CHILD_NODE(codeNode_out, entryNode_out);
//maybe include warning about non-equal indexes?
for (i = 0; i < in_index; i++)
{
entryNode_in=entryNode_in.nextSiblingElement();
}
for (i = 0; i < out_index; i++)
{
entryNode_out=entryNode_out.nextSiblingElement();
}
if (out_index != in_index)
{
//index consistency fix -- easy, hopefully safe.
QDomAttr index_attr = entryNode_in.attributeNode("index");
index_attr.setNodeValue(QString().sprintf("%d", out_index));
}
res = codeNode_out.replaceChild(entryNode_in.cloneNode(), entryNode_out);
if (res.isNull())
{
//fatalExit("failed to replace entry node");
printf("WARNING: Failed to replace entry node\n");
}
}
DesignFlowStep_Status HDLFunctionDeclFix::Exec()
{
bool changed_tree = false;
const tree_managerRef TM = AppM->get_tree_manager();
const auto hdl_writer_type = static_cast<HDLWriter_Language>(parameters->getOption<unsigned int>(OPT_writer_language));
const auto hdl_writer = language_writer::create_writer(hdl_writer_type, GetPointer<HLS_manager>(AppM)->get_HLS_target()->get_technology_manager(), parameters);
const auto hdl_reserved_names = hdl_writer->GetHDLReservedNames();
std::remove_const<decltype(hdl_reserved_names)>::type found_names;
if(hdl_writer_type == HDLWriter_Language::VHDL)
{
for(const auto hdl_reserved_name : hdl_reserved_names)
{
found_names.insert(boost::to_upper_copy<std::string>(hdl_reserved_name));
}
}
else
{
found_names = hdl_reserved_names;
}
for(const auto function : TM->GetAllFunctions())
{
auto fd = GetPointer<function_decl>(TM->get_tree_node_const(function));
if(not fd->name)
continue;
auto in = GetPointer<identifier_node>(GET_NODE(fd->name));
const auto identifier = hdl_writer_type == HDLWriter_Language::VHDL ? boost::to_upper_copy<std::string>(in->strg) : in->strg;
if(found_names.find(identifier) != found_names.end())
{
std::map<TreeVocabularyTokenTypes_TokenEnum, std::string> IR_schema;
unsigned int var_decl_name_nid_test;
unsigned var_decl_unique_id=0;
do
{
IR_schema[TOK(TOK_STRG)] = in->strg + STR(var_decl_unique_id++);
var_decl_name_nid_test = TM->find(identifier_node_K, IR_schema);
} while(var_decl_name_nid_test);
found_names.insert(in->strg + STR(var_decl_unique_id - 1));
unsigned int var_decl_name_nid = TM->new_tree_node_id();
TM->create_tree_node(var_decl_name_nid, identifier_node_K, IR_schema);
IR_schema.clear();
tree_nodeRef tr_new_id = TM->GetTreeReindex(var_decl_name_nid);
fd->name = tr_new_id;
}
else
{
found_names.insert(identifier);
}
}
return changed_tree ? DesignFlowStep_Status::SUCCESS : DesignFlowStep_Status::UNCHANGED;
}
void AnimationTreePlayer::transition_node_delete_input(const StringName& p_node, int p_input) {
GET_NODE(NODE_TRANSITION, TransitionNode);
ERR_FAIL_INDEX(p_input,n->inputs.size());
if (n->inputs.size()<=1)
return;
n->inputs.remove(p_input);
n->input_data.remove(p_input);
last_error=_cycle_test(out_name);
}
void
lwan_trie_add(struct lwan_trie *trie, const char *key, void *data)
{
if (UNLIKELY(!trie || !key || !data))
return;
struct lwan_trie_node **knode, *node;
const char *orig_key = key;
/* Traverse the trie, allocating nodes if necessary */
for (knode = &trie->root; *key; knode = &node->next[(int)(*key++ & 7)])
GET_NODE();
/* Get the leaf node (allocate it if necessary) */
GET_NODE();
struct lwan_trie_leaf *leaf = find_leaf_with_key(node, orig_key, (size_t)(key - orig_key));
bool had_key = leaf;
if (!leaf) {
leaf = malloc(sizeof(*leaf));
if (!leaf)
lwan_status_critical_perror("malloc");
} else if (trie->free_node) {
trie->free_node(leaf->data);
}
leaf->data = data;
if (!had_key) {
leaf->key = strdup(orig_key);
leaf->next = node->leaf;
node->leaf = leaf;
}
return;
oom:
lwan_status_critical_perror("calloc");
}
void AnimationTreePlayer::transition_node_set_current(const StringName& p_node, int p_current) {
GET_NODE( NODE_TRANSITION, TransitionNode );
ERR_FAIL_INDEX(p_current,n->inputs.size());
if (n->current==p_current)
return;
n->prev=n->current;
n->prev_xfading=n->xfade;
n->prev_time=n->time;
n->time=0;
n->current=p_current;
}
void msm_bus_scale_client_reset_pnodes(uint32_t cl)
{
int i, src, pnode, index;
struct msm_bus_client *client = (struct msm_bus_client *)(cl);
if (IS_ERR(client)) {
MSM_BUS_ERR("msm_bus_scale_reset_pnodes error\n");
return;
}
index = 0;
for (i = 0; i < client->pdata->usecase->num_paths; i++) {
src = msm_bus_board_get_iid(
client->pdata->usecase[index].vectors[i].src);
pnode = client->src_pnode[i];
MSM_BUS_DBG("(%d, %d)\n", GET_NODE(pnode), GET_INDEX(pnode));
reset_pnodes(src, pnode);
}
}
static int
lru_ass_sub(LRU *self, PyObject *key, PyObject *value)
{
int res = 0;
Node *node = GET_NODE(self->dict, key);
PyErr_Clear(); /* GET_NODE sets an exception on miss. Shut it up. */
if (value) {
if (node) {
Py_INCREF(value);
Py_DECREF(node->value);
node->value = value;
lru_remove_node(self, node);
lru_add_node_at_head(self, node);
res = 0;
} else {
node = PyObject_NEW(Node, &NodeType);
node->key = key;
node->value = value;
node->next = node->prev = NULL;
Py_INCREF(key);
Py_INCREF(value);
res = PUT_NODE(self->dict, key, node);
if (res == 0) {
if (lru_length(self) > self->size) {
lru_delete_last(self);
}
lru_add_node_at_head(self, node);
}
}
} else {
res = PUT_NODE(self->dict, key, NULL);
if (res == 0) {
assert(node && PyObject_TypeCheck(node, &NodeType));
lru_remove_node(self, node);
}
}
Py_XDECREF(node);
return res;
}
