btBroadphaseProxy* btDbvtBroadphase::createProxy(const btVector3& aabbMin,
const btVector3& aabbMax,
int /*shapeType*/,
void* userPtr,
int collisionFilterGroup,
int collisionFilterMask,
btDispatcher* /*dispatcher*/)
{
btDbvtProxy* proxy = new (btAlignedAlloc(sizeof(btDbvtProxy), 16)) btDbvtProxy(aabbMin, aabbMax, userPtr,
collisionFilterGroup,
collisionFilterMask);
btDbvtAabbMm aabb = btDbvtVolume::FromMM(aabbMin, aabbMax);
//bproxy->aabb = btDbvtVolume::FromMM(aabbMin,aabbMax);
proxy->stage = m_stageCurrent;
proxy->m_uniqueId = ++m_gid;
proxy->leaf = m_sets[0].insert(aabb, proxy);
listappend(proxy, m_stageRoots[m_stageCurrent]);
if (!m_deferedcollide)
{
btDbvtTreeCollider collider(this);
collider.proxy = proxy;
m_sets[0].collideTV(m_sets[0].m_root, aabb, collider);
m_sets[1].collideTV(m_sets[1].m_root, aabb, collider);
}
return (proxy);
}
static void
lister(void *data, const char *line)
{
Var *r = (Var *) data;
Var v;
v.type = TYPE_STR;
v.v.str = str_dup(line);
*r = listappend(*r, v);
}
static void
xml_streamCharacterDataHandler(void *userData, const XML_Char *s, int len)
{
XMLdata **data = (XMLdata**)userData;
XMLdata *node = *data;
Var element = node->element;
Var v;
v.type = TYPE_STR;
v.v.str = str_dup(raw_bytes_to_binary(s, len));
element.v.list[4] = listappend(element.v.list[4], v);
}
static void
finish_node(XMLdata *data)
{
XMLdata *parent = data->parent;
Var element = data->element;
Var body;
Stream *s = data->body;
body.type = TYPE_STR;
if(s == NULL) {
body.v.str = str_dup("");
} else {
body.v.str = str_dup(reset_stream(s));
}
element.v.list[3] = body;
if(parent != NULL) {
Var pelement = parent->element;
pelement.v.list[4] = listappend(pelement.v.list[4], var_ref(element));
}
}
static void
xml_startElement(void *userData, const char *name, const char **atts)
{
XMLdata **data = (XMLdata**)userData;
XMLdata *parent = *data;
XMLdata *node = new_node(parent, name);
const char **patts = atts;
while(*patts != NULL) {
Var pair = new_list(2);
pair.v.list[1].type = TYPE_STR;
pair.v.list[1].v.str = str_dup(patts[0]);
pair.v.list[2].type = TYPE_STR;
pair.v.list[2].v.str = str_dup(patts[1]);
patts += 2;
node->element.v.list[2] = listappend(node->element.v.list[2], pair);
}
*data = node;
}
void btDbvtBroadphase::setAabbForceUpdate(btBroadphaseProxy* absproxy,
const btVector3& aabbMin,
const btVector3& aabbMax,
btDispatcher* /*dispatcher*/)
{
btDbvtProxy* proxy = (btDbvtProxy*)absproxy;
ATTRIBUTE_ALIGNED16(btDbvtVolume)
aabb = btDbvtVolume::FromMM(aabbMin, aabbMax);
bool docollide = false;
if (proxy->stage == STAGECOUNT)
{ /* fixed -> dynamic set */
m_sets[1].remove(proxy->leaf);
proxy->leaf = m_sets[0].insert(aabb, proxy);
docollide = true;
}
else
{ /* dynamic set */
++m_updates_call;
/* Teleporting */
m_sets[0].update(proxy->leaf, aabb);
++m_updates_done;
docollide = true;
}
listremove(proxy, m_stageRoots[proxy->stage]);
proxy->m_aabbMin = aabbMin;
proxy->m_aabbMax = aabbMax;
proxy->stage = m_stageCurrent;
listappend(proxy, m_stageRoots[m_stageCurrent]);
if (docollide)
{
m_needcleanup = true;
if (!m_deferedcollide)
{
btDbvtTreeCollider collider(this);
m_sets[1].collideTTpersistentStack(m_sets[1].m_root, proxy->leaf, collider);
m_sets[0].collideTTpersistentStack(m_sets[0].m_root, proxy->leaf, collider);
}
}
}
void btDbvtBroadphase::collide(btDispatcher* dispatcher)
{
/*printf("---------------------------------------------------------\n");
printf("m_sets[0].m_leaves=%d\n",m_sets[0].m_leaves);
printf("m_sets[1].m_leaves=%d\n",m_sets[1].m_leaves);
printf("numPairs = %d\n",getOverlappingPairCache()->getNumOverlappingPairs());
{
int i;
for (i=0;i<getOverlappingPairCache()->getNumOverlappingPairs();i++)
{
printf("pair[%d]=(%d,%d),",i,getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy0->getUid(),
getOverlappingPairCache()->getOverlappingPairArray()[i].m_pProxy1->getUid());
}
printf("\n");
}
*/
SPC(m_profiling.m_total);
/* optimize */
m_sets[0].optimizeIncremental(1 + (m_sets[0].m_leaves * m_dupdates) / 100);
if (m_fixedleft)
{
const int count = 1 + (m_sets[1].m_leaves * m_fupdates) / 100;
m_sets[1].optimizeIncremental(1 + (m_sets[1].m_leaves * m_fupdates) / 100);
m_fixedleft = btMax<int>(0, m_fixedleft - count);
}
/* dynamic -> fixed set */
m_stageCurrent = (m_stageCurrent + 1) % STAGECOUNT;
btDbvtProxy* current = m_stageRoots[m_stageCurrent];
if (current)
{
#if DBVT_BP_ACCURATESLEEPING
btDbvtTreeCollider collider(this);
#endif
do
{
btDbvtProxy* next = current->links[1];
listremove(current, m_stageRoots[current->stage]);
listappend(current, m_stageRoots[STAGECOUNT]);
#if DBVT_BP_ACCURATESLEEPING
m_paircache->removeOverlappingPairsContainingProxy(current, dispatcher);
collider.proxy = current;
btDbvt::collideTV(m_sets[0].m_root, current->aabb, collider);
btDbvt::collideTV(m_sets[1].m_root, current->aabb, collider);
#endif
m_sets[0].remove(current->leaf);
ATTRIBUTE_ALIGNED16(btDbvtVolume)
curAabb = btDbvtVolume::FromMM(current->m_aabbMin, current->m_aabbMax);
current->leaf = m_sets[1].insert(curAabb, current);
current->stage = STAGECOUNT;
current = next;
} while (current);
m_fixedleft = m_sets[1].m_leaves;
m_needcleanup = true;
}
/* collide dynamics */
{
btDbvtTreeCollider collider(this);
if (m_deferedcollide)
{
SPC(m_profiling.m_fdcollide);
m_sets[0].collideTTpersistentStack(m_sets[0].m_root, m_sets[1].m_root, collider);
}
if (m_deferedcollide)
{
SPC(m_profiling.m_ddcollide);
m_sets[0].collideTTpersistentStack(m_sets[0].m_root, m_sets[0].m_root, collider);
}
}
/* clean up */
if (m_needcleanup)
{
SPC(m_profiling.m_cleanup);
btBroadphasePairArray& pairs = m_paircache->getOverlappingPairArray();
if (pairs.size() > 0)
{
int ni = btMin(pairs.size(), btMax<int>(m_newpairs, (pairs.size() * m_cupdates) / 100));
for (int i = 0; i < ni; ++i)
{
btBroadphasePair& p = pairs[(m_cid + i) % pairs.size()];
btDbvtProxy* pa = (btDbvtProxy*)p.m_pProxy0;
btDbvtProxy* pb = (btDbvtProxy*)p.m_pProxy1;
if (!Intersect(pa->leaf->volume, pb->leaf->volume))
{
#if DBVT_BP_SORTPAIRS
if (pa->m_uniqueId > pb->m_uniqueId)
btSwap(pa, pb);
#endif
m_paircache->removeOverlappingPair(pa, pb, dispatcher);
--ni;
--i;
}
}
if (pairs.size() > 0)
m_cid = (m_cid + ni) % pairs.size();
else
m_cid = 0;
}
}
++m_pid;
m_newpairs = 1;
m_needcleanup = false;
if (m_updates_call > 0)
{
m_updates_ratio = m_updates_done / (btScalar)m_updates_call;
}
else
{
m_updates_ratio = 0;
}
m_updates_done /= 2;
m_updates_call /= 2;
}
void btDbvtBroadphase::setAabb(btBroadphaseProxy* absproxy,
const btVector3& aabbMin,
const btVector3& aabbMax,
btDispatcher* /*dispatcher*/)
{
btDbvtProxy* proxy = (btDbvtProxy*)absproxy;
ATTRIBUTE_ALIGNED16(btDbvtVolume)
aabb = btDbvtVolume::FromMM(aabbMin, aabbMax);
#if DBVT_BP_PREVENTFALSEUPDATE
if (NotEqual(aabb, proxy->leaf->volume))
#endif
{
bool docollide = false;
if (proxy->stage == STAGECOUNT)
{ /* fixed -> dynamic set */
m_sets[1].remove(proxy->leaf);
proxy->leaf = m_sets[0].insert(aabb, proxy);
docollide = true;
}
else
{ /* dynamic set */
++m_updates_call;
if (Intersect(proxy->leaf->volume, aabb))
{ /* Moving */
const btVector3 delta = aabbMin - proxy->m_aabbMin;
btVector3 velocity(((proxy->m_aabbMax - proxy->m_aabbMin) / 2) * m_prediction);
if (delta[0] < 0) velocity[0] = -velocity[0];
if (delta[1] < 0) velocity[1] = -velocity[1];
if (delta[2] < 0) velocity[2] = -velocity[2];
if (
m_sets[0].update(proxy->leaf, aabb, velocity, gDbvtMargin)
)
{
++m_updates_done;
docollide = true;
}
}
else
{ /* Teleporting */
m_sets[0].update(proxy->leaf, aabb);
++m_updates_done;
docollide = true;
}
}
listremove(proxy, m_stageRoots[proxy->stage]);
proxy->m_aabbMin = aabbMin;
proxy->m_aabbMax = aabbMax;
proxy->stage = m_stageCurrent;
listappend(proxy, m_stageRoots[m_stageCurrent]);
if (docollide)
{
m_needcleanup = true;
if (!m_deferedcollide)
{
btDbvtTreeCollider collider(this);
m_sets[1].collideTTpersistentStack(m_sets[1].m_root, proxy->leaf, collider);
m_sets[0].collideTTpersistentStack(m_sets[0].m_root, proxy->leaf, collider);
}
}
}
}
static package bf_http_request( Var arglist, Byte next, void *vdata, Objid progr)
{
CURL *curl_handle;
CURLcode ok;
package result;
if (!is_wizard(progr))
{
free_var(arglist);
return make_error_pack(E_PERM);
}
int nargs = arglist.v.list[0].v.num;
const char *address = arglist.v.list[1].v.str;
const char *agent="",*postfields="",*cookies="";
int headers = 0;
switch(nargs)
{
case 5:
cookies = arglist.v.list[5].v.str;
case 4:
postfields = arglist.v.list[4].v.str;
case 3:
agent = arglist.v.list[3].v.str;
case 2:
headers = arglist.v.list[2].v.num;
}
if(!strlen(agent))
agent = "MOO-http/1.0";
const char delimiters[] = "\n";
free_var(arglist);
struct MemoryStruct chunk;
chunk.memory = malloc(1);
chunk.size = 0;
curl_global_init(CURL_GLOBAL_ALL);
curl_handle = curl_easy_init();
curl_easy_setopt(curl_handle, CURLOPT_URL, address);
curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);
curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, agent);
curl_easy_setopt(curl_handle, CURLOPT_TIMEOUT, 5);
curl_easy_setopt(curl_handle, CURLOPT_CONNECTTIMEOUT, 3);
curl_easy_setopt(curl_handle, CURLOPT_FTP_RESPONSE_TIMEOUT, 3);
curl_easy_setopt(curl_handle, CURLOPT_MAXREDIRS, 5);
curl_easy_setopt(curl_handle, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl_handle, CURLOPT_MAXFILESIZE, 1048576);
if(strlen(postfields))
curl_easy_setopt(curl_handle, CURLOPT_POSTFIELDS, postfields);
if(strlen(cookies))
curl_easy_setopt(curl_handle, CURLOPT_COOKIE, cookies);
if(headers)
curl_easy_setopt(curl_handle, CURLOPT_HEADER, 1);
ok = curl_easy_perform(curl_handle);
curl_easy_cleanup(curl_handle);
if(ok == CURLE_OK && strlen(chunk.memory) != chunk.size)
ok = CURLE_BAD_CONTENT_ENCODING; // binary !!!
if(ok == CURLE_OK)
{
char *token,*p=chunk.memory;
Var r;
r.type = TYPE_LIST;
r = new_list(0);
token = strsep(&p, delimiters);
while( token != NULL )
{
Var line;
line.type = TYPE_STR;
if(token[strlen(token)-1] == '\r')
token[strlen(token)-1] = '\0';
//run it through utf8_substr to get rid of invalid utf8
line.v.str = (char *)utf8_substr(token,1,utf8_strlen(token));
r = listappend(r, var_dup(line));
token = strsep(&p, delimiters);
free_var(line);
}
result = make_var_pack(r);
}
else
{
Var r;
r.type = TYPE_INT;
r.v.num = ok;
result = make_raise_pack(E_INVARG,
curl_easy_strerror(ok),
r);
}
if(chunk.memory)
free(chunk.memory);
curl_global_cleanup();
return result;
}
static package bf_mysql_query( Var arglist, Byte next, void *vdata, Objid progr)
{
Var r;
char error_string[MOOSQL_ERROR_LEN];
MYSQL_CONN *wrapper;
MYSQL_RES *res_set;
#ifdef MOOSQL_MULTIPLE_STATEMENTS
Var tmp;
Var end;
int len = 0;
int continu = 1;
#endif
if (!is_wizard(progr))
{
free_var(arglist);
return make_error_pack(E_PERM);
}
Objid oid = arglist.v.list[1].v.obj;
wrapper = resolve_mysql_connection(oid);
if (wrapper == NULL || wrapper->conn == NULL || wrapper->active == 0)
{
free_var(arglist);
return make_error_pack(E_INVARG);
}
const char *query = arglist.v.list[2].v.str;
free_var(arglist);
/* we do the query now. */
if (mysql_query (wrapper->conn, query) != 0) /* failed */
{
/* there is an error, so we will return that string. similar to below which
* returns a string for a successful query with no result set which is handled in
* process_mysql_query */
snprintf(error_string,MOOSQL_ERROR_LEN,"ERR: %s",mysql_error(wrapper->conn));
r.type = TYPE_STR;
r.v.str = str_dup(error_string);
return make_var_pack(r);
}
wrapper->last_query_time = time(0);
#ifdef MOOSQL_MULTIPLE_STATEMENTS
r = new_list(1);
r.v.list[1].type = TYPE_INT;
r.v.list[1].v.num = 0;
end = new_list(0);
while (continu)
{
len++;
res_set = process_mysql_query(wrapper,error_string);
if (res_set == NULL) /* there was no result on this query */
{
tmp.type = TYPE_STR;
tmp.v.str = str_dup(error_string);
end = listappend(end,var_dup(tmp));
}
else
{
tmp = process_result_set(wrapper,res_set);
end = listappend(end,var_dup(tmp));
}
if (mysql_more_results(wrapper->conn))
{
mysql_next_result(wrapper->conn);
continu = 1;
}
else
continu = 0;
}
if (len <= 1) /* if there is only one result return it like in previous versions, a list of rows */
return make_var_pack(end.v.list[1]);
r.v.list[1].v.num = len;
/* if there are more return it in this format {X, Y} where X is the number of results and Y is a list of results */
r = listappend(r,end);
return make_var_pack(r);
#else
res_set = process_mysql_query(wrapper,error_string);
if (res_set == NULL) /* there was either an error / no result on this query */
{
r.type = TYPE_STR;
r.v.str = str_dup(error_string);
return make_var_pack(r);
}
r = process_result_set(wrapper,res_set);
return make_var_pack(r);
#endif
}
int main (int argc, char * argv [])
{
LIST files;
char filename [FILENAME_MAX];
char const * paths [_LISTSIZE] =
{
getenv ("PWD"),
(char const *) (0)
};
size_t path = 1;
#if CTAR_SEARCH
/*
* search argv for additional -Ipath and -I path argments, similar to
* gcc compiler options; since we are not using getoptv() to parse the
* command line, we scan argv[] and strip out these extra arguments;
*/
int argn;
int argx;
for (argn = 1; argn < argc; argn++)
{
char const * sp = argv [argn];
if (* sp++ != GETOPTV_C_OPTION)
{
continue;
}
if (* sp++ != 'I')
{
continue;
}
if (* sp == (char) (0))
{
for (argx = argn; argx < argc; argx++)
{
argv [argx] = argv [argx + 1];
}
sp = argv [argn];
argc--;
}
paths [path++] = sp;
for (argx = argn; argx < argc; argx++)
{
argv [argx] = argv [argx + 1];
}
argn--;
argc--;
}
paths [path] = (char const *) (0);
argv [argc] = (char *) (0);
#endif
if (argc < 4)
{
printf ("%s [tar-options] archive program [-I path] [-I path] [...]\n", * argv);
exit (1);
}
makepath (filename, getenv ("PWD"), argv [-- argc]);
listcreate (& files, _LISTSIZE);
listappend (& files, filename);
if (ccollect (& files, paths))
{
error (1, 0, "%s: missing %d file(s)", files.table [0], files.error);
}
if ((args = (char **) (malloc ((argc + files.count + 1) * sizeof (char *)))))
{
error (1, 0, "%s: out of memory", basename ((char *) (* argv)));
}
args [0] = PATH_TAR;
for (argc = 1; argv [argc]; argc++)
{
args [argc] = argv [argc];
}
for (files.lower = files.start; files.lower < files.count; files.lower++)
{
args [argc++] = (char *) (files.table [files.lower]);
}
args [argc] = (char *) (0);
execv (* args, args);
error (1, errno, "can't execute %s", * args);
exit (0);
}
