queue<T>::queue(const queue& src) : head(NULL), tail(NULL)
{
if (NULL != src.head)
{
head = src.head->cascadeCopy();
findTail(head);
}
}
int main(int argc, char **argv) {
int c;
char *file_name = NULL;
int number_of_words = 0;
FILE *input_file;
while ( (c = getopt(argc, argv, "i:n:")) != -1) {
switch (c) {
case 'i':
file_name = optarg;
break;
case 'n':
number_of_words = atoi(optarg);
break;
}
}
if (file_name == NULL || number_of_words == 0) {
usage(argv[0]);
exit(EXIT_FAILURE);
}
input_file = fopen(file_name, "r");
if (input_file == NULL) {
fprintf(stderr, "Cannot open file %s\n", file_name);
exit(EXIT_FAILURE);
}
while(!feof(input_file)) {
char word[64];
fscanf(input_file, "%s\n", word);
toLower(word);
printf("%s\n", word);
struct Entry *existing = search(word);
if (existing != NULL) {
++existing->count;
} else {
struct Entry *tail = findTail();
struct Entry *entry = malloc(sizeof(struct Entry));
strcpy(entry->word, word);
entry->count = 1;
tail->next = entry;
}
}
int entry_count = count();
printf("Number of element is the list is %d\n", entry_count);
//showAll();
struct Entry asArray[entry_count];
makeArray(asArray);
qsort(asArray, entry_count, sizeof(struct Entry), cmpfunc);
for(int i=0 ; i < entry_count ; i++) {
struct Entry e = asArray[i];
printf("Word: %s Count: %d\n", e.word, e.count);
}
return EXIT_SUCCESS;
}
queue<T>& queue<T>::operator = (const queue<T>& src)
{
// prevent self assignment
if (&src != this)
{
if (NULL != head)
{
head->cascadeDelete();
}
if (NULL != src.head)
{
head = src.head->cascadeCopy();
findTail(head);
}
}
return *this;
}
/******************************************************************************
* @fn HalUARTPollDMA
*
* @brief Poll a USART module implemented by DMA.
*
* @param none
*
* @return none
*****************************************************************************/
static void HalUARTPollDMA(void)
{
uint16 cnt = 0;
uint8 evt = 0;
if (HAL_UART_DMA_NEW_RX_BYTE(dmaCfg.rxHead))
{
rxIdx_t tail = findTail();
// If the DMA has transferred in more Rx bytes, reset the Rx idle timer.
if (dmaCfg.rxTail != tail)
{
dmaCfg.rxTail = tail;
// Re-sync the shadow on any 1st byte(s) received.
if (dmaCfg.rxTick == 0)
{
dmaCfg.rxShdw = ST0;
}
dmaCfg.rxTick = HAL_UART_DMA_IDLE;
}
else if (dmaCfg.rxTick)
{
// Use the LSB of the sleep timer (ST0 must be read first anyway).
uint8 decr = ST0 - dmaCfg.rxShdw;
if (dmaCfg.rxTick > decr)
{
dmaCfg.rxTick -= decr;
dmaCfg.rxShdw = ST0;
}
else
{
dmaCfg.rxTick = 0;
}
}
cnt = HalUARTRxAvailDMA();
}
else
{
dmaCfg.rxTick = 0;
}
if (cnt >= HAL_UART_DMA_FULL)
{
evt = HAL_UART_RX_FULL;
}
else if (cnt >= HAL_UART_DMA_HIGH)
{
evt = HAL_UART_RX_ABOUT_FULL;
PxOUT |= HAL_UART_Px_RTS; // Disable Rx flow.
}
else if (cnt && !dmaCfg.rxTick)
{
evt = HAL_UART_RX_TIMEOUT;
}
if (dmaCfg.txMT)
{
dmaCfg.txMT = FALSE;
evt |= HAL_UART_TX_EMPTY;
}
if (dmaCfg.txShdwValid)
{
uint8 decr = ST0;
decr -= dmaCfg.txShdw;
if (decr > dmaCfg.txTick)
{
// No protection for txShdwValid is required
// because while the shadow was valid, DMA ISR cannot be triggered
// to cause concurrent access to this variable.
dmaCfg.txShdwValid = FALSE;
}
}
if (dmaCfg.txDMAPending && !dmaCfg.txShdwValid)
{
// UART TX DMA is expected to be fired and enough time has lapsed since last DMA ISR
// to know that DBUF can be overwritten
halDMADesc_t *ch = HAL_DMA_GET_DESC1234(HAL_DMA_CH_TX);
halIntState_t intState;
// Clear the DMA pending flag
dmaCfg.txDMAPending = FALSE;
HAL_DMA_SET_SOURCE(ch, dmaCfg.txBuf[dmaCfg.txSel]);
HAL_DMA_SET_LEN(ch, dmaCfg.txIdx[dmaCfg.txSel]);
dmaCfg.txSel ^= 1;
HAL_ENTER_CRITICAL_SECTION(intState);
HAL_DMA_ARM_CH(HAL_DMA_CH_TX);
do
{
asm("NOP");
} while (!HAL_DMA_CH_ARMED(HAL_DMA_CH_TX));
HAL_DMA_CLEAR_IRQ(HAL_DMA_CH_TX);
HAL_DMA_MAN_TRIGGER(HAL_DMA_CH_TX);
HAL_EXIT_CRITICAL_SECTION(intState);
}
else
{
halIntState_t his;
HAL_ENTER_CRITICAL_SECTION(his);
if ((dmaCfg.txIdx[dmaCfg.txSel] != 0) && !HAL_DMA_CH_ARMED(HAL_DMA_CH_TX)
&& !HAL_DMA_CHECK_IRQ(HAL_DMA_CH_TX))
{
HAL_EXIT_CRITICAL_SECTION(his);
HalUARTIsrDMA();
}
else
{
HAL_EXIT_CRITICAL_SECTION(his);
}
}
if (evt && (dmaCfg.uartCB != NULL))
{
dmaCfg.uartCB(HAL_UART_DMA-1, evt);
}
}
