void asyncOperationsProcess()
{
for(int i = 0; i < length; i++)
{
auto item = asyncBuffer[i];
auto res = item.handler(item.payload);
switch(res)
{
case ASYNC_OPERATION_COMPLETE:
asyncBuffer[i--] = asyncBuffer[--length];
item.dtor(item.payload);
RLOGI("Async operation %s completed", item.operationID);
break;
case ASYNC_OPERATION_RUNNING:
//Do nothing
break;
case ASYNC_OPERATION_FAILURE:
RLOGE("Async operation %s failed", item.operationID);
asyncBuffer[i--] = asyncBuffer[--length];
item.dtor(item.payload);
break;
default:
RLOGE("Async operation %s returned invalid result %d", item.operationID, res);
asyncBuffer[i--] = asyncBuffer[--length];
item.dtor(item.payload);
break;
}
}
}
double RobotMove::fixAngle(double angle){
while(angle > dtor(180)){
angle -= dtor(360);
}
while(angle < dtor(-180)){
angle += dtor(360);
}
return angle;
}
/* Function: destroy
* Destroys the pointer <MatrixCSR::a>, <MatrixCSR::ia>, and <MatrixCSR::ja> using a custom deallocator if <MatrixCSR::free> is true. */
void destroy(void (*dtor)(void*)) {
if(_free) {
dtor(_a);
dtor(_ia);
dtor(_ja);
_a = nullptr;
_ia = _ja = nullptr;
}
}
//car update handlers------------------
void car::onUpdate(float timeElapsed) {
if (speed != 0) {
if (speed > 0) {
facingRot -= turnRate * timeElapsed;
wheelRot--;
} else {
facingRot += turnRate * timeElapsed;
wheelRot++;
}
centerX += sin(dtor(facingRot)) * speed * timeElapsed;
centerY += cos(dtor(facingRot)) * speed * timeElapsed;
}
}
/*
* potm --
* return phase of the moon
*/
static double
potm(double days)
{
double N, Msol, Ec, LambdaSol, l, Mm, Ev, Ac, A3, Mmprime;
double A4, lprime, V, ldprime, D, Nm;
N = 360 * days / 365.2422; /* sec 42 #3 */
adj360(&N);
Msol = N + EPSILONg - RHOg; /* sec 42 #4 */
adj360(&Msol);
Ec = 360 / PI * ECCEN * sin(dtor(Msol)); /* sec 42 #5 */
LambdaSol = N + Ec + EPSILONg; /* sec 42 #6 */
adj360(&LambdaSol);
l = 13.1763966 * days + lzero; /* sec 61 #4 */
adj360(&l);
Mm = l - (0.1114041 * days) - Pzero; /* sec 61 #5 */
adj360(&Mm);
Nm = Nzero - (0.0529539 * days); /* sec 61 #6 */
adj360(&Nm);
Ev = 1.2739 * sin(dtor(2*(l - LambdaSol) - Mm)); /* sec 61 #7 */
Ac = 0.1858 * sin(dtor(Msol)); /* sec 61 #8 */
A3 = 0.37 * sin(dtor(Msol));
Mmprime = Mm + Ev - Ac - A3; /* sec 61 #9 */
Ec = 6.2886 * sin(dtor(Mmprime)); /* sec 61 #10 */
A4 = 0.214 * sin(dtor(2 * Mmprime)); /* sec 61 #11 */
lprime = l + Ev + Ec - Ac + A4; /* sec 61 #12 */
V = 0.6583 * sin(dtor(2 * (lprime - LambdaSol))); /* sec 61 #13 */
ldprime = lprime + V; /* sec 61 #14 */
D = ldprime - LambdaSol; /* sec 63 #2 */
return(50 * (1 - cos(dtor(D)))); /* sec 63 #3 */
}
void chgOrient(PlayerClient *robotc, LaserProxy &lp, Position2dProxy &pp, robot_pos *point, robot_pos *robot){
unsigned char orientn, directn;
double newspeed, newturnrate;
int iters=0;
if ((robot->yaw >= 0) && (robot->yaw <= dtor(90))) orientn=1;
else if ((robot->yaw > dtor(90)) && (robot->yaw <= dtor(180))) orientn=2;
else if ((robot->yaw < 0) && (robot->yaw >= -dtor(90))) orientn=3;
else orientn=4;
if ((robot->x >= point->x) && (robot->y >= point->y)) directn=1;
else if ((robot->x <= point->x) && (robot->y >= point->y)) directn=2;
else if ((robot->x >= point->x) && (robot->y <= point->y)) directn=3;
else directn=4;
newspeed = 0;
iters = MOVE_ITER;
if((directn==1) && (orientn==1)) newturnrate = dtor((180)/TURNFACTOR);
else if ((directn==2) && (orientn==2)) newturnrate = dtor((180)/TURNFACTOR);
else if ((directn==3) && (orientn==3)) newturnrate = dtor((180)/TURNFACTOR);
else if ((directn==4) && (orientn==4)) newturnrate = dtor((180)/TURNFACTOR);
else iters = 0;
for(int i=0; i<iters; i++){
robotc->Read();
moveRobot(lp, pp, &newspeed, &newturnrate);
}
}
void RobotMove::DriveToVector(Vector &whereToGo, Position2dProxy * position){
startingAngle = whereToGo.getAngle();
startingAngle = fixAngle(dtor(startingAngle));
distanceToGo = whereToGo.getDistance();
speed = whereToGo.getDistance();
angularDistence = fixAngle(startingAngle - (*position).GetYaw());
speed = abs(speed - abs(angularDistence / dtor(90)));
if(speed > maxSpeed) speed = maxSpeed;
(*position).SetSpeed(speed, angularDistence / angleDampener);
}
//Calculate bearing from lat1/lon1 to lat2/lon2
//Note lat1/lon1/lat2/lon2 must be in radians
//Returns bearing in degrees
int CalcBearing(double lat1, double lon1, double lat2, double lon2)
{
lat1 = dtor(lat1);
lon1 = dtor(lon1);
lat2 = dtor(lat2);
lon2 = dtor(lon2);
//determine angle
double bearing = atan2(sin(lon2-lon1)*cos(lat2), (cos(lat1)*sin(lat2))-(sin(lat1)*cos(lat2)*cos(lon2-lon1)));
//convert to degrees
bearing = rtod(bearing);
//use mod to turn -90 = 270
//bearing = fmod((bearing + 360.0), 360);
//return (int) bearing + 0.5;
return ((int) bearing + 360) % 360;
}
static void call_tls_dtors()
{
again:
bool had_valid_tls = false;
// for each registered dtor: (call order unspecified by SUSv3)
for(size_t i = 0; i < MAX_DTORS; i++)
{
// is slot #i in use?
void (*dtor)(void*) = dtors[i].dtor;
if(!dtor)
continue;
// clear slot and call dtor with its previous value.
const pthread_key_t key = dtors[i].key;
void* tls = pthread_getspecific(key);
if(tls)
{
WARN_IF_ERR(pthread_setspecific(key, 0));
dtor(tls);
had_valid_tls = true;
}
}
// rationale: SUSv3 says we're allowed to loop infinitely. we do so to
// expose any dtor bugs - this shouldn't normally happen.
if(had_valid_tls)
goto again;
}
Script :: Script(const std::string& fn):
IConfigurable(fn)
{
nullify();
scoped_dtor<Script> dtor(this);
// attempt to get script filename from ini file
if(Filesystem::hasExtension(fn,"ini"))
{
properties().getStringValue("default", "script", m_Filename);
if(!m_Filename.empty())
{
Log::get().error("Could not locate script property in file \"" + fn + "\"");
throw Failure();
}
}
else
m_Filename = fn; // use passed in filename as script filename
//m_Script.open(script_fn);
//if(m_Script.bad())
//{
// Log::get().error((std::string)"Unable to open script \"" + script_fn + "\"");
// throw Failure();
//}
setupBindings();
m_TickFrames = 60;
//m_TickTime.speed(1000.0f);
dtor.resolve();
}
void BulletCommand::createSimpleBullet(double direction, double speed)
{
HitBox *box = 0;
double vx, vy;
double dir = dtor(direction);
Bullet *bullet;
if (_shape == BulletCommand::Circle)
box = new CircleHitBox(this->getX(), this->getY(),
static_cast<double>(_width));
else if (_shape == BulletCommand::Rectangle)
box = new RectHitBox(this->getX(), this->getY(),
static_cast<double>(_width),
static_cast<double>(_height));
vx = speed * cos(dir);
vy = speed * sin(dir);
if (box)
{
bullet = new Bullet(_state, this->_simpleSprite, *box, vx, vy, this->_simpleXHitbox, this->_simpleYHitbox);
bullet->setScrollY(this->_scrollY);
bullet->setLife(this->_simpleLife);
bullet->setDamage(this->_simpleDamage);
this->_state.addGameObject(bullet, this->_simpleGroup, false);
//this->insertChild(*bullet);
}
}
/*
* Trim down the number of pages in the quicklist
*/
void quicklist_trim(int nr, void (*dtor)(void *),
unsigned long min_pages, unsigned long max_free)
{
long pages_to_free;
struct quicklist *q;
q = &get_cpu_var(quicklist)[nr];
if (q->nr_pages > min_pages) {
pages_to_free = min_pages_to_free(q, min_pages, max_free);
while (pages_to_free > 0) {
/*
* We pass a gfp_t of 0 to quicklist_alloc here
* because we will never call into the page allocator.
*/
void *p = quicklist_alloc(nr, 0, NULL);
if (dtor)
dtor(p);
free_page((unsigned long)p);
pages_to_free--;
}
}
put_cpu_var(quicklist);
}
Position Robot::getStagePosition(Position position) const {
Position stagePosition(
getStageLocation(position.getLocation()),
dtor(position.getYaw())
);
return stagePosition;
}
void RobotCenter::setup(){
for(int i=0;i<3;i++){
enc[i]->setup();
enc[i]->cpr(1000);
}
enc[LEFT]->rev(true);
enc[RIGHT]->rev(true);
enc[BACK]->rev(true);
enc[LEFT]->mlt(50.8);
enc[RIGHT]->mlt(50.8);
enc[BACK]->mlt(50.8);
encMountAngle[LEFT]=dtor(150);
encMountAngle[RIGHT]=dtor(30);
encMountAngle[BACK]=dtor(-90);
encRadius=100.0;
}
void
heim_w32_service_thread_detach(void *unused)
{
tls_keys *key_defs;
void (*dtor)(void*);
size_t i;
HEIMDAL_MUTEX_lock(&tls_key_defs_lock);
key_defs = tls_key_defs;
HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
if (key_defs == NULL)
return;
for (i = 0; i < values.values_num; i++) {
assert(i >= key_defs->keys_start_idx);
if (i >= key_defs->keys_start_idx + key_defs->keys_num) {
HEIMDAL_MUTEX_lock(&tls_key_defs_lock);
key_defs = key_defs->keys_next;
HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
assert(key_defs != NULL);
assert(i >= key_defs->keys_start_idx);
assert(i < key_defs->keys_start_idx + key_defs->keys_num);
}
dtor = key_defs->keys_dtors[i - key_defs->keys_start_idx];
if (values.values[i] != NULL && dtor != NULL && dtor != DEAD_KEY)
dtor(values.values[i]);
values.values[i] = NULL;
}
}
int ListClear(linked_list* list, int (*dtor)(void*)) {
while( list->count != 0) {
dtor(list->head->data);
ListPopFront(list);
}
return LNKL_SUCCESS;
}
static void getVectorFromAngle(float ori_angle[3], float ori_vec[3])
{
float azim,elev,roll,cos_azim,sin_azim,sin_elev,cos_roll,sin_roll;
azim = dtor(ori_angle[1]);
elev = dtor(ori_angle[0]);
roll = dtor(ori_angle[2]);
cos_azim = cosf(azim);
sin_azim = sinf(azim);
sin_elev = sinf(elev);
cos_roll = cosf(roll);
sin_roll = sinf(roll);
//float vec[3];
ori_vec[0] = -cos_azim * cos_roll - sin_azim * sin_elev * sin_roll;
ori_vec[1] = -cosf(elev) * sin_roll;
ori_vec[2] = sin_azim * cos_roll - cos_azim * sin_elev * sin_roll;
}
void WiFi_forward_to_xcsoar()
{
int bearing = CalcBearing(fo.latitude, fo.longtitude, LATITUDE, LONGTITUDE);
int alt_diff = fo.altitude - ALTITUDE;
char *csum_ptr;
unsigned char cs = 0; //clear any old checksum
Udp.beginPacket(ARGUS_HOSTNAME, XCSOAR_PORT);
snprintf(UDPpacketBuffer, sizeof(UDPpacketBuffer), "$PFLAU,0,1,1,1,%d,2,%d,%u,%X*", \
bearing, alt_diff, (int) fo.distance, fo.addr );
//calculate the checksum
for (unsigned int n = 1; n < strlen(UDPpacketBuffer) - 1; n++) {
cs ^= UDPpacketBuffer[n]; //calculates the checksum
}
csum_ptr = UDPpacketBuffer + strlen(UDPpacketBuffer);
snprintf(csum_ptr, sizeof(UDPpacketBuffer) - strlen(UDPpacketBuffer), "%02X\n", cs);
#ifdef SERIAL_VERBOSE
Serial.println(UDPpacketBuffer);
#endif
Udp.write(UDPpacketBuffer, strlen(UDPpacketBuffer));
Udp.endPacket();
Udp.beginPacket(XCSOAR_HOSTNAME, XCSOAR_PORT);
snprintf(UDPpacketBuffer, sizeof(UDPpacketBuffer), "$PFLAA,2,%d,%d,%d,2,%X,,,,,1*", \
(int) (fo.distance * cos(dtor(bearing))), (int) (fo.distance * sin(dtor(bearing))), \
alt_diff, fo.addr );
cs = 0; //clear any old checksum
for (unsigned int n = 1; n < strlen(UDPpacketBuffer) - 1; n++) {
cs ^= UDPpacketBuffer[n]; //calculates the checksum
}
csum_ptr = UDPpacketBuffer + strlen(UDPpacketBuffer);
snprintf(csum_ptr, sizeof(UDPpacketBuffer) - strlen(UDPpacketBuffer), "%02X\n", cs);
#ifdef SERIAL_VERBOSE
Serial.println(UDPpacketBuffer);
#endif
Udp.write(UDPpacketBuffer, strlen(UDPpacketBuffer));
Udp.endPacket();
}
void asyncOperationsCancel()
{
for (int i = 0; i < length; i++)
{
auto item = asyncBuffer[i];
item.dtor(item.payload);
}
length = 0;
}
void __stdcall MSVCRTEX_eh_vector_destructor_iterator(void *pMem, size_t sizeOfItem, int nItems, void (__thiscall *dtor)(void *))
{
char *pEnd = static_cast<char *>(pMem) + nItems * sizeOfItem;
for (char *pItem = pEnd - sizeOfItem;
pItem >= pMem;
pItem -= sizeOfItem)
{
try
{
dtor(pItem);
}
catch (...)
{
for (pItem -= sizeOfItem; pItem >= pMem; pItem -= sizeOfItem)
dtor(pItem);
throw;
}
}
}
void BulletCommand::doChangeDirection(double direction)
{
if (!this->_isCommanded)
return ;
this->_direction = dtor(direction);
this->_vx = this->_speed * cos(this->_direction);
this->_vy = this->_speed * sin(this->_direction);
if (this->_sprite)
this->_sprite->setRotation(-direction + 90);
}
//!-----------------------------------------
void destroyTree(treeElem_t *root)
{
assert(root);
if (root->left)
destroyTree(root->left);
if (root->right)
destroyTree(root->right);
dtor(root);
}
void reset() {
// If I am empty return
if (!*this) return;
if (!--*k) { /* --*k == 0 */
dtor(ptr); // clean up memory
delete k;
k=0;
ptr=0;
}
assert_invariant();
}
static void pt_sb_free_decoder(struct pt_sb_decoder *decoder)
{
void (*dtor)(void *);
if (!decoder)
return;
dtor = decoder->dtor;
if (dtor)
dtor(decoder->priv);
free(decoder);
}
LinearAllocator::~LinearAllocator(void) {
while (mDtorList) {
auto node = mDtorList;
mDtorList = node->next;
node->dtor(node->addr);
}
Page* p = mPages;
while (p) {
Page* next = p->next();
p->~Page();
free(p);
RM_ALLOCATION();
p = next;
}
}
ClassMetatable()
{
FunctorType dtor(&class_userdata::destructor<ObjectWrapperBase>);
function_map_["__gc"].push_back(dtor);
KAGUYA_STATIC_ASSERT(is_registerable<class_type>::value || !traits::is_std_vector<class_type>::value, "std::vector is binding to lua-table by default.If you wants register for std::vector yourself,"
"please define KAGUYA_NO_STD_VECTOR_TO_TABLE");
KAGUYA_STATIC_ASSERT(is_registerable<class_type>::value || !traits::is_std_map<class_type>::value, "std::map is binding to lua-table by default.If you wants register for std::map yourself,"
"please define KAGUYA_NO_STD_MAP_TO_TABLE");
//can not register push specialized class
KAGUYA_STATIC_ASSERT(is_registerable<class_type>::value,
"Can not register specialized of type conversion class. e.g. std::tuple");
}
static void spl_ptr_llist_destroy(spl_ptr_llist *llist) /* {{{ */
{
spl_ptr_llist_element *current = llist->head, *next;
spl_ptr_llist_dtor_func dtor = llist->dtor;
while (current) {
next = current->next;
if (dtor) {
dtor(current);
}
SPL_LLIST_DELREF(current);
current = next;
}
efree(llist);
}
//!-----------------------------------
void removeList(header_t *Head)
{
assert_ok(Head != NULL);
listElem_t * work = Head->theFirst;
for (int i = 2; i < Head->ListLen; i++)
{
assert(2 <= i && i <= Head->ListLen);
dtor(work->prev, Head);
work = work->next;
}
work = NULL;
free(Head);
dumpList(Head);
}
void LinearAllocator::runDestructorFor(void* addr) {
auto node = mDtorList;
DestructorNode* previous = nullptr;
while (node) {
if (node->addr == addr) {
if (previous) {
previous->next = node->next;
} else {
mDtorList = node->next;
}
node->dtor(node->addr);
rewindIfLastAlloc(node, sizeof(DestructorNode));
break;
}
previous = node;
node = node->next;
}
}
/* Function: al_emit_user_event
*/
bool al_emit_user_event(ALLEGRO_EVENT_SOURCE *src,
ALLEGRO_EVENT *event, void (*dtor)(ALLEGRO_USER_EVENT *))
{
size_t num_queues;
bool rc;
ASSERT(src);
ASSERT(event);
ASSERT(ALLEGRO_EVENT_TYPE_IS_USER(event->any.type));
if (dtor) {
ALLEGRO_USER_EVENT_DESCRIPTOR *descr = al_malloc(sizeof(*descr));
descr->refcount = 0;
descr->dtor = dtor;
event->user.__internal__descr = descr;
}
else {
event->user.__internal__descr = NULL;
}
_al_event_source_lock(src);
{
ALLEGRO_EVENT_SOURCE_REAL *rsrc = (ALLEGRO_EVENT_SOURCE_REAL *)src;
num_queues = _al_vector_size(&rsrc->queues);
if (num_queues > 0) {
event->user.timestamp = al_get_time();
_al_event_source_emit_event(src, event);
rc = true;
}
else {
rc = false;
}
}
_al_event_source_unlock(src);
if (dtor && !rc) {
dtor(&event->user);
al_free(event->user.__internal__descr);
}
return rc;
}
