NodeQueue* ServeQueue(Queue* ApQ) {
NodeQueue *aux = ApQ->head;
if(EmptyQueue(ApQ) == FALSE) {
ApQ->head = ApQ->head->next;
if(EmptyQueue(ApQ) == TRUE)
ApQ->tail = NULL;
}
return aux;
}
void DbgGdb::DoCleanup()
{
#ifdef __WXMSW__
if(GetIsRemoteDebugging()) {
SetConsoleCtrlHandler((PHANDLER_ROUTINE)SigHandler, FALSE);
FreeConsole(); // Disconnect any existing console window.
}
#endif
wxDELETE(m_gdbProcess);
SetIsRecording(false);
m_reverseDebugging = false;
m_goingDown = false;
m_attachedMode = false;
SetIsRemoteDebugging(false);
SetIsRemoteExtended(false);
EmptyQueue();
m_gdbOutputArr.Clear();
m_bpList.clear();
m_debuggeeProjectName.Clear();
// Clear any bufferd output
m_gdbOutputIncompleteLine.Clear();
// Free allocated console for this session
m_consoleFinder.FreeConsole();
}
void *nReceive(nTask *ptask, int timeout)
{
void *msg;
nTask send_task;
START_CRITICAL();
pending_receives++;
{ nTask this_task= current_task;
if (EmptyQueue(this_task->send_queue) && timeout!=0)
{
if (timeout>0)
{
this_task->status= WAIT_SEND_TIMEOUT;
ProgramTask(timeout);
/* La tarea se despertara automaticamente despues de timeout */
}
else this_task->status= WAIT_SEND; /* La tarea espera indefinidamente */
ResumeNextReadyTask(); /* Se suspende indefinidamente hasta un nSend */
}
send_task= GetTask(this_task->send_queue);
if (ptask!=NULL) *ptask= send_task;
msg= send_task==NULL ? NULL : send_task->send.msg;
}
pending_receives--;
END_CRITICAL();
return msg;
}
int BFSTraverse(MGraph G,int(*Visit)(char v))
{
LinkQueue Q;
int v,w,u;
for(v=0;v<G.vexnum;v++)
visited[v]=0;
InitQueue(Q);
for(v=0;v<G.vexnum;v++)
{
if(!visited[v])
{
visited[v]=1;
Visit(G.dingdian[v]);
EnQueue(Q,v);
while(!EmptyQueue(Q))
{
DeQueue(Q,u);
w=FirstAdjVex(G,G.dingdian[u]);
for(;w>=0;w=NextAdjVex(G,G.dingdian[u],G.dingdian[w]))
if(!visited[w])
{
visited[w]=1;
Visit(G.dingdian[w]);
EnQueue(Q,w);
}
}
}
}
return OK;
}
BOOL Piezo_Driver::Tone( UINT32 Frequency_Hertz, UINT32 Duration_Milliseconds )
{
// Not sure why this is neccessary. Calling the Piezo::Tone function from with-in an ISR
// should be a valid scenario. Lorenzo and I (Zach) can not determine
// why this assert is needed; therefore, it is being commented out (for now).
//ASSERT(!SystemState_Query( SYSTEM_STATE_ISR ));
GLOBAL_LOCK(irq);
// special to clear queue
if(Frequency_Hertz == TONE_CLEAR_BUFFER)
{
// let active note to finish on it's own
EmptyQueue();
}
else
{
// 0 length tone isn't wrong persay, but if a NULL op, so drop it gracefully, as a success
if(Duration_Milliseconds > 0)
{
PIEZO_TONE* Tone = g_Piezo_Driver.m_ToneToRelease.ExtractFirstNode();
if(Tone == NULL)
{
//
// Re-enable interrupts when allocating memory.
//
irq.Release();
Tone = (PIEZO_TONE*)private_malloc( sizeof(PIEZO_TONE) );
Tone->Initialize();
irq.Acquire();
}
if(Tone == NULL)
{
// No memory, just drop this tone and fail the call
ASSERT(0);
return FALSE;
}
Tone->Frequency_Hertz = Frequency_Hertz;
Tone->Duration_Milliseconds = Duration_Milliseconds;
DEBUG_TRACE3(0, "Tone(%4d,%4d)=%d\r\n", Frequency_Hertz, Duration_Milliseconds, g_Piezo_Driver.m_ToneToPlay.NumOfNodes() );
g_Piezo_Driver.m_ToneToPlay.LinkAtBack( Tone );
if(g_Piezo_Driver.m_TonePlaying == NULL)
{
StartNext();
}
}
}
return TRUE;
}
TTSQueue::~TTSQueue()
{
CloseHandle(mutex);
CloseHandle(empty);
CloseHandle(full);
EmptyQueue();
}
ScheduledTickQueue::~ScheduledTickQueue()
{
if( 0 != m_Queue.size() )
{
ASSERT_DEBUG(false);
EmptyQueue();
}
}
BOOL PolyphonicPiezo_Driver::Tone( const PIEZO_POLY_TONE& ToneRef )
{
ASSERT(!SystemState_Query(SYSTEM_STATE_ISR));
GLOBAL_LOCK(irq);
// special to clear queue
if(ToneRef.Period[0] == TONE_CLEAR_BUFFER)
{
// let active note to finish on it's own
EmptyQueue();
}
else
{
// 0 length tone isn't wrong persay, but if a NULL op, so drop it gracefully, as a success
if(ToneRef.Duration_MicroSeconds > 0)
{
PIEZO_POLY_TONE* Tone = g_PolyphonicPiezo_Driver.m_ToneToRelease.ExtractFirstNode();
if(Tone == NULL)
{
//
// Re-enable interrupts when allocating memory.
//
irq.Release();
Tone = (PIEZO_POLY_TONE*)private_malloc( sizeof(PIEZO_POLY_TONE) );
irq.Acquire();
}
if(Tone == NULL)
{
// No memory, just drop this tone and fail the call
ASSERT(0);
return FALSE;
}
*Tone = ToneRef;
Tone->Initialize();
DEBUG_TRACE2( 0, "Tone(%4d)=%d\r\n", ToneRef.Duration_MicroSeconds, g_PolyphonicPiezo_Driver.m_ToneToPlay.NumOfNodes() );
g_PolyphonicPiezo_Driver.m_ToneToPlay.LinkAtBack( Tone );
if(g_PolyphonicPiezo_Driver.m_TonePlaying == NULL)
{
StartNext();
}
}
}
return TRUE;
}
void AppendQueue(Queue* ApQ, NodeQueue* new_node) {
if(EmptyQueue(ApQ) == TRUE) {
ApQ->head = new_node;
ApQ->tail = new_node;
}
else {
ApQ->tail->next = new_node;
ApQ->tail = new_node;
}
new_node->next = NULL;
}
/**
* The run method, this loops, executing actions, until we're told to
* terminate.
*/
void *ConsumerThread::Run() {
m_mutex->Lock();
while (true) {
EmptyQueue();
// Mutex is held here
if (*m_shutdown) {
m_mutex->Unlock();
break;
}
m_condition_var->Wait(m_mutex);
}
return NULL;
}
NS_IMETHODIMP
nsPrefetchService::Observe(nsISupports *aSubject,
const char *aTopic,
const PRUnichar *aData)
{
LOG(("nsPrefetchService::Observe [topic=%s]\n", aTopic));
if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
StopPrefetching();
EmptyQueue();
mDisabled = PR_TRUE;
}
else if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
nsCOMPtr<nsIPrefBranch> prefs(do_QueryInterface(aSubject));
PRBool enabled;
nsresult rv = prefs->GetBoolPref(PREFETCH_PREF, &enabled);
if (NS_SUCCEEDED(rv) && enabled) {
if (mDisabled) {
LOG(("enabling prefetching\n"));
mDisabled = PR_FALSE;
AddProgressListener();
}
}
else {
if (!mDisabled) {
LOG(("disabling prefetching\n"));
StopPrefetching();
EmptyQueue();
mDisabled = PR_TRUE;
RemoveProgressListener();
}
}
}
return NS_OK;
}
void
nsPrefetchService::StopPrefetching()
{
mStopCount++;
LOG(("StopPrefetching [stopcount=%d]\n", mStopCount));
// only kill the prefetch queue if we've actually started prefetching.
if (!mCurrentNode)
return;
mCurrentNode->CancelChannel(NS_BINDING_ABORTED);
mCurrentNode = nsnull;
EmptyQueue();
}
bool DbgGdb::Stop()
{
if (m_gdbProcess) {
delete m_gdbProcess;
m_gdbProcess = NULL;
}
//free allocated console for this session
m_consoleFinder.FreeConsole();
//return control to the program
m_observer->UpdateGotControl(DBG_DBGR_KILLED);
EmptyQueue();
m_gdbOutputArr.Clear();
m_bpList.clear();
return true;
}
void ICACHE_FLASH_ATTR user_uart_task(void *pvParameters)
{
CusUartIntrPtr uartptrData;
u32 sys_time_value = system_get_time();
while (1)
{
if (EmptyQueue() == false && (system_get_time() - sys_time_value) >= 100) {
ESP_DBG(("***heap_size %d\n", system_get_free_heap_size()));
frame_t frame;
if (Dequeue(&frame)) {
uart0_tx_buffer((uint8_t *)&frame, frame.len);
}
sys_time_value = system_get_time();
}
if (xQueueReceive(xQueueCusUart, (void *)&uartptrData, (portTickType)20/*portMAX_DELAY*/)) // wait about 20msec
{
ESP_DBG(("data uart recv.."));
debug_print_hex_data(uartptrData.rx_buf, uartptrData.rx_len);
if (uartptrData.rx_len>0x00) {
cus_uart_data_handle(uartptrData.rx_buf, uartptrData.rx_len, NULL);
}
}
/*
if ((system_get_time() - sys_time_value) >= (60 * 1000 * 1000)) //about 1min, send data to uart0, demo beat data
{
ESP_DBG(("uart beat data***heap_size %d\n", system_get_free_heap_size()));
//uart0_write_data(uart_beat_data, sizeof(uart_beat_data));//heatbeat sent to MCU
sys_time_value = system_get_time();
}
*/
}
vTaskDelete(NULL);
}
void QueueType<ItemType>::Dequeue(ItemType &i)
{
if(IsEmpty())
{
throw EmptyQueue();
}
else
{
NodeType<ItemType> *temp;
temp = front;
i = front->info;
front = front->next;
if(front == NULL)
rear == NULL;
delete temp;
}
}
void QueType::Dequeue(ItemType& item)
// Removes front item from the queue and returns it in item.
// Pre: Queue has been initialized and is not empty.
// Post: If (queue is not empty) the front of the queue has been
// removed and a copy returned in item;
// othersiwe a EmptyQueue exception has been thrown.
{
if (IsEmpty())
throw EmptyQueue();
else
{
NodeType* tempPtr;
tempPtr = front;
item = front->info;
front = front->next;
if (front == NULL)
rear = NULL;
delete tempPtr;
}
}
void PolyphonicPiezo_Driver::Uninitialize()
{
{
GLOBAL_LOCK(irq);
EmptyQueue();
//
// This purges the currently playing tone.
//
StartNext();
}
bool fEnabled = INTERRUPTS_ENABLED_STATE();
if(!fEnabled) ENABLE_INTERRUPTS();
ToneRelease( NULL );
if(!fEnabled) DISABLE_INTERRUPTS();
}
void DbgGdb::DoCleanup()
{
if ( m_gdbProcess ) {
delete m_gdbProcess;
m_gdbProcess = NULL;
}
m_goingDown = false;
m_attachedMode = false;
SetIsRemoteDebugging( false );
SetIsRemoteExtended( false );
EmptyQueue();
m_gdbOutputArr.Clear();
m_bpList.clear();
m_debuggeeProjectName.Clear();
// Clear any bufferd output
m_gdbOutputIncompleteLine.Clear();
// Free allocated console for this session
m_consoleFinder.FreeConsole();
}
void Piezo_Driver::Uninitialize()
{
g_Piezo_Driver.m_ToneDone .Abort();
g_Piezo_Driver.m_ToneRelease.Abort();
{
GLOBAL_LOCK(irq);
EmptyQueue();
//
// This purges the currently playing tone.
//
StartNext();
}
bool fEnabled = INTERRUPTS_ENABLED_STATE();
if(!fEnabled) ENABLE_INTERRUPTS();
ToneRelease( NULL );
if(!fEnabled) DISABLE_INTERRUPTS();
// restore the hardware to proper default state
for(int i = 0; i < 2; i++)
{
PWM_CONFIG* PWM_Config = &g_pPIEZO_Config->PWM_Config[i];
if(PWM_Config->PWM_Output.Pin != GPIO_PIN_NONE)
{
CPU_GPIO_EnableInputPin( PWM_Config->PWM_Output.Pin, FALSE, NULL, GPIO_INT_NONE, RESISTOR_PULLDOWN );
}
}
}
ppw(pword *pw) /* print prolog words */
{
int arity = 1;
pword *queue_head = (pword *) 0;
pword *queue_tail = (pword *) 0;
for (;;)
{
char region;
int t = TagType(pw->tag);
if (t < TFORWARD || t > TBUFFER)
t = TUNKNOWN;
if (TG_ORIG <= pw && pw < TG) region = 'g';
else if (SP <= pw && pw < SP_ORIG) region = 'l';
else if (B_ORIG <= pw && pw < B.args) region = 'c';
else if (TT <= (pword **) pw && (pword **) pw < TT_ORIG) region = 't';
else if (address_in_heap(&global_heap, (generic_ptr) pw)) region = 'h';
else region = '?';
p_fprintf(current_output_, "%c 0x%08x: 0x%08x 0x%08x %s ", region,
pw, pw->val.all, pw->tag.all, tag_string[t-TUNKNOWN]);
switch (t)
{
case TFORWARD:
case TMETA:
case TNAME:
if (pw != pw->val.ptr)
{
ec_outfs(current_output_, "--->");
EnQueue_(pw->val.ptr, 1);
}
else
{
ec_outfs(current_output_, IsNamed(pw->tag.kernel) ?
DidName(TagDid(pw->tag.kernel)) : "_");
}
break;
case TVAR_TAG:
if (pw != pw->val.ptr)
{
ec_outfs(current_output_, "--->");
EnQueue_(pw->val.ptr, 1);
}
else
ec_outfs(current_output_, "_");
break;
case TLIST:
EnQueue_(pw->val.ptr, 2);
break;
case TCOMP:
if (pw->val.ptr)
EnQueue_(pw->val.ptr, DidArity(pw->val.ptr->val.did)+1);
break;
case TSTRG:
ec_outfs(current_output_, StringStart(pw->val));
break;
case TSUSP:
break;
case TDE:
break;
case THANDLE:
break;
case TNIL:
break;
case TINT:
p_fprintf(current_output_, "%d", pw->val.nint);
break;
case TDICT:
ec_outfs(current_output_, DidName(pw->val.did));
if (DidArity(pw->val.did))
p_fprintf(current_output_, "/%d", DidArity(pw->val.did));
break;
case TPTR:
break;
case TPROC:
case TEND:
case TVARNUM:
case TGRS:
case TGRL:
case TEXTERN:
case TBUFFER:
break;
case TDBL:
p_fprintf(current_output_, "%f", Dbl(pw->val));
break;
case TBIG:
case TRAT:
default:
if (t >= 0 && t <= NTYPES)
{
(void) tag_desc[t].write(QUOTED, current_output_,
pw->val, pw->tag);
}
break;
}
ec_newline(current_output_);
if (--arity > 0)
{
pw++;
continue;
}
ec_newline(current_output_);
if (EmptyQueue())
break;
DeQueue_(pw, arity);
}
Succeed_;
}
void ClearQueue(Queue* ApQ) {
while(EmptyQueue(ApQ) == FALSE) {
free(ServeQueue(ApQ));
}
}
avtDatasetOnDemandFilter::~avtDatasetOnDemandFilter()
{
EmptyQueue();
}
nsPrefetchService::~nsPrefetchService()
{
// cannot reach destructor if prefetch in progress (listener owns reference
// to this service)
EmptyQueue();
}
pword *
term_to_dbformat(pword *parg, dident mod)
{
pword **save_tt = TT;
register word arity = 1, len;
register word curr_offset = 0, top_offset = 2; /* in 'word's */
register pword *queue_tail = (pword *) 0;
pword *queue_head = (pword *) 0;
register pword *pw;
register char *dest, *stop;
pword *header;
temp_area meta_attr;
int flag = 0;
Temp_Create(meta_attr, 4 * ATTR_IO_TERM_SIZE * sizeof(pword));
header = TG;
dest = (char *) (header + 1) + 4; /* space for the TBUFFER pword and for
* the external format header */
for(;;) /* handle <arity> consecutive pwords, starting at <parg> */
{
do /* handle the pword pointed to by parg */
{
pw = parg;
/* I need here a slightly modified version of Dereference_(pw)
* that stops also at MARKed words. Not very nice, I know.
*/
while (IsRef(pw->tag) && !(pw->tag.kernel & MARK) && !IsSelfRef(pw))
pw = pw->val.ptr;
Reserve_Space(6);
if (pw->tag.kernel & MARK)
{
if (SameTypeC(pw->tag,TDE)) /* a suspension */
{
Store_Byte(Tag(pw->tag.kernel));
Store_Int32((pw[SUSP_FLAGS].tag.kernel & ~MARK));
if (SuspDead(pw)) {
curr_offset += Words(SUSP_HEADER_SIZE-1);
parg += SUSP_HEADER_SIZE-1;
arity -= SUSP_HEADER_SIZE-1;
} else {
Store_Byte(SuspPrio(pw) + (SuspRunPrio(pw) << 4));
curr_offset += Words(SUSP_GOAL-1);
parg += SUSP_GOAL-1;
arity -= SUSP_GOAL-1;
}
}
else if (pw->val.nint == curr_offset) /* a nonstd variable */
{
Store_Byte(Tag(pw->tag.kernel));
Store_Int(pw->val.nint);
if (!IsNamed(pw->tag.kernel))
{
Store_Byte(0);
}
else /* store its name */
{
dident vdid = TagDid(pw->tag.kernel);
len = DidLength(vdid);
Store_Int(len);
Reserve_Space(len);
Store_String(len, DidName(vdid));
}
}
else /* just a reference to an already encountered variable */
{
Store_Byte(Tag(TVAR_TAG));
Store_Int(pw->val.nint);
}
}
else switch (TagType(pw->tag))
{
case TINT:
#if SIZEOF_CHAR_P > 4
if (pw->val.nint < WSUF(-2147483648) || WSUF(2147483648) <= pw->val.nint)
{
/* store as a bignum (to be readable on 32bit machines) */
len = tag_desc[pw->tag.kernel].string_size(pw->val, pw->tag, 1);
Store_Byte(TBIG);
Store_Int(len);
Reserve_Space(len+1);
stop = dest+len;
dest += tag_desc[pw->tag.kernel].to_string(pw->val, pw->tag,
dest, 1);
while (dest <= stop) /* pad and terminate */
*dest++ = 0;
break;
}
#endif
Store_Byte(TINT);
#ifdef OLD_FORMAT
Store_Int32(pw->val.nint);
#else
Store_Int(pw->val.nint);
#endif
break;
case TNIL:
Store_Byte(Tag(pw->tag.kernel));
break;
case TDICT:
len = DidLength(pw->val.did);
Store_Byte(TDICT);
Store_Int(DidArity(pw->val.did));
Store_Int(len);
Reserve_Space(len);
Store_String(len, DidName(pw->val.did));
break;
case TDBL:
{
ieee_double d;
d.as_dbl = Dbl(pw->val);
Store_Byte(TDBL);
Store_Byte(sizeof(double)-1); /* backward compat */
Reserve_Space(sizeof(double));
Store_Int32(d.as_struct.mant1);
Store_Int32(d.as_struct.mant0);
break;
}
case TIVL:
{
ieee_double dlwb, dupb;
dlwb.as_dbl = IvlLwb(pw->val.ptr);
dupb.as_dbl = IvlUpb(pw->val.ptr);
Store_Byte(TIVL);
Reserve_Space(2*sizeof(double));
Store_Int32(dlwb.as_struct.mant1);
Store_Int32(dlwb.as_struct.mant0);
Store_Int32(dupb.as_struct.mant1);
Store_Int32(dupb.as_struct.mant0);
break;
}
case TSTRG:
len = StringLength(pw->val);
Store_Byte(TSTRG);
Store_Int(len);
Reserve_Space(len);
Store_String(len, StringStart(pw->val));
break;
case TVAR_TAG: /* standard variable */
Store_Byte(Tag(TVAR_TAG));
Store_Int(curr_offset);
Trail_(pw);
pw->val.nint = curr_offset;
pw->tag.kernel |= MARK;
break;
case TNAME:
case TUNIV:
Store_Byte(Tag(TVAR_TAG));
Store_Int(top_offset);
Trail_Tag(pw);
pw->val.nint = top_offset;
pw->tag.kernel |= MARK;
top_offset += 2;
EnQueue_(pw, 1, 0);
break;
case TMETA:
Store_Byte(Tag(TVAR_TAG));
Store_Int(top_offset);
Trail_Tag(pw);
pw->val.nint = top_offset;
pw->tag.kernel |= MARK;
top_offset += 4;
EnQueue_(pw, 2, QUEUE_MASK_META);
break;
case TSUSP:
Store_Byte(Tag(TSUSP));
pw = pw->val.ptr;
if (pw->tag.kernel & MARK) /* not the first encounter */
{
Store_Int(pw->val.nint);
}
else
{
Store_Int(top_offset);
Trail_Pword(pw);
pw->tag.kernel |= MARK;
pw->val.nint = top_offset;
if (SuspDead(pw))
{
top_offset += Words(SUSP_HEADER_SIZE); /* for TDE */
EnQueue_(pw, SUSP_HEADER_SIZE, 0);
}
else
{
top_offset += Words(SUSP_SIZE); /* for TDE */
EnQueue_(pw, SUSP_SIZE, 0);
}
}
break;
case TLIST:
Store_Byte(Tag(TLIST));
Store_Int(top_offset);
top_offset += 4;
EnQueue_(pw->val.ptr, 2, 0);
break;
case TCOMP:
Store_Byte(Tag(TCOMP));
Store_Int(top_offset);
if (flag) {
pword pw_out;
(void) transf_meta_out(pw->val, pw->tag,
(pword *) TempAlloc(meta_attr, ATTR_IO_TERM_SIZE * sizeof(pword)),
D_UNKNOWN, &pw_out);
pw = pw_out.val.ptr;
len = 1 + DidArity(pw->val.did);
EnQueue_(pw, len, 0);
} else {
len = 1 + DidArity(pw->val.ptr->val.did);
EnQueue_(pw->val.ptr, len, 0);
}
top_offset += 2*len;
break;
default:
if (TagType(pw->tag) >= 0 && TagType(pw->tag) <= NTYPES)
{
len = tag_desc[TagType(pw->tag)].string_size(pw->val, pw->tag, 1);
Store_Byte(Tag(pw->tag.kernel));
Store_Int(len);
Reserve_Space(len+1);
stop = dest+len;
dest += tag_desc[TagType(pw->tag)].to_string(pw->val, pw->tag,
dest, 1);
while (dest <= stop) /* pad and terminate */
*dest++ = 0;
}
else
{
p_fprintf(current_err_,
"bad type in term_to_dbformat: 0x%x\n",
pw->tag.kernel);
}
break;
}
curr_offset += Words(1);
++parg;
} while (--arity);
if (EmptyQueue())
break;
DeQueue_(parg, arity, flag);
}
/* # bytes of external representation */
Store_Byte(0); /* add a terminating 0 */
Set_Buffer_Size(header, dest - (char*) header - sizeof(pword));
header->tag.kernel = TBUFFER;
Align(); /* align the global stack pointer */
TG = (pword *) dest;
dest = (char *) (header + 1); /* fill in the external format header */
Store_Int32(top_offset); /* (size of term after restoring) */
Untrail_Variables(save_tt);
Temp_Destroy(meta_attr);
return header;
}
