INT8U CTask::Create(bool bRunNow)
{
INT32U nStackSize = StackSize();
m_nId = s_nNextId ++;
OSSchedLock();
INT8U errno = OSTaskCreateExt(_callbackFunc, (void*)this,
&m_pTaskStack[nStackSize-1],
m_nPrio,
m_nId,
m_pTaskStack,
nStackSize,
(void*)NULL,
OS_TASK_OPT_STK_CHK|OS_TASK_OPT_STK_CLR);
if (!errno){
OSTaskNameSet(m_nPrio, (INT8U*)m_aTaskName, &errno);
}
if (!bRunNow){
OSTaskSuspend(m_nPrio);
}
OSSchedUnlock();
return errno;
}
void KomLoop(void) {
int defaultCmd;
g_unreadRepliesStack = CreateStack();
for(;;) {
if(StackSize(g_unreadRepliesStack) > 0) {
defaultCmd = CMD_NEXTREPLY;
} else if(hasUnreadInConf(mote2)) {
defaultCmd = CMD_NEXTTEXT;
} else if(HasUnreadMail()) {
defaultCmd = CMD_GOMAIL;
} else if(FindNextUnreadConf(mote2) >= 0) {
defaultCmd = CMD_NEXTCONF;
} else {
defaultCmd = CMD_SEETIME;
}
displayPrompt(defaultCmd);
if(shouldLogout()) {
break;
}
}
DeleteStack(g_unreadRepliesStack);
}
int main() {
int arr[] = {
1, 2, 3, 4, 5, 6, 7
};
int i = 0, *top = 0;
Stack stack;
StackInit(&stack, sizeof(int));
while (i < sizeof(arr) / sizeof(int)) {
StackPush(&stack, &arr[i]);
++i;
}
top = StackTop(&stack);
printf("The top of the stack element is %d\n", *top);
top = StackPop(&stack);
printf("Pop element %d\n", *top);
top = StackTop(&stack);
printf("The top of the stack element is %d\n", *top);
printf("The stack size is %d\n", StackSize(&stack));
StackClear(&stack);
if (StackEmpty(&stack)) {
printf("Stack is empty.\n");
} else {
printf("Stack is not empty.\n");
}
StackDestory(&stack);
return 0;
}
D_MOBILE *load_player(char *player)
{
D_MOBILE *dMob = NULL;
char sql[MAX_BUFFER];
char pName[MAX_BUFFER];
sqlite3_stmt *rSet = NULL;
int i, size;
memset(sql, '\0', MAX_BUFFER);
pName[0] = toupper(player[0]);
size = strlen(player);
for (i = 1; i < size && i < MAX_BUFFER - 1; i++)
pName[i] = tolower(player[i]);
pName[i] = '\0';
/* prepare sql to query player table */
snprintf(sql, MAX_BUFFER, "select * from players where name = ?");
sqlite3_prepare_v2(db, sql, sizeof(sql), &rSet, NULL);
sqlite3_bind_text(rSet, 1, pName, strlen(pName), 0);
/* execute query and return NULL if player isn't found*/
if (sqlite3_step(rSet) != SQLITE_ROW)
{
sqlite3_reset(rSet);
sqlite3_finalize(rSet);
return NULL;
}
/* create new mobile data */
if (StackSize(dmobile_free) <= 0)
{
if ((dMob = malloc(sizeof(*dMob))) == NULL)
{
bug("Load_player: Cannot allocate memory.");
abort();
}
}
else
{
dMob = (D_MOBILE *) PopStack(dmobile_free);
}
clear_mobile(dMob);
/* load data */
dMob->name = strdup((const char *)sqlite3_column_text(rSet,3));
dMob->password = strdup((const char *)sqlite3_column_text(rSet,4));
dMob->level = sqlite3_column_int(rSet,2);
dMob->room = find_room(sqlite3_column_int(rSet,0));
/* clear result set */
sqlite3_reset(rSet);
sqlite3_finalize(rSet);
if (dMob->room == NULL)
dMob->room = find_room(START_ROOM);
return dMob;
}
CTask::CTask(int nPriority, const char* pTaskName)
:m_nPrio(nPriority)
{
INT32U nStackSize = StackSize();
m_pTaskStack = new OS_STK[ nStackSize ];
strncpy(m_aTaskName, pTaskName, TASK_NAME_MAXSIZE);
}
static void Compose2D(MatrixStack2D *ms) {
if (StackSize(ms) >= 2) {
Matrix2D *d = (Matrix2D *)StackPushNew(ms);
Matrix2D *a = (Matrix2D *)StackPeek(ms, 2);
Matrix2D *b = (Matrix2D *)StackPeek(ms, 1);
Multiply2D(d, a, b);
}
}
bool DwarfOp<AddressType>::op_pick() {
AddressType index = OperandAt(0);
if (index > StackSize()) {
last_error_.code = DWARF_ERROR_STACK_INDEX_NOT_VALID;
return false;
}
stack_.push_front(StackAt(index));
return true;
}
void SNetThreadingSpawn(snet_entity_t ent, int loc, const char *name,
snet_taskfun_t func, void *arg)
{
int res;
pthread_t p;
pthread_attr_t attr;
/* create snet_thread_t */
snet_thread_t *thr = SNetMemAlloc(sizeof(snet_thread_t));
thr->fun = func;
pthread_mutex_init( &thr->lock, NULL );
pthread_cond_init( &thr->pollcond, NULL );
thr->wakeup_sd = NULL;
thr->inarg = arg;
thr->name = (char*) name;
/* increment entity counter */
pthread_mutex_lock( &entity_lock );
entity_count += 1;
pthread_mutex_unlock( &entity_lock );
/* create pthread: */
(void) pthread_attr_init( &attr);
size_t stacksize = StackSize(ent);
if (stacksize > 0) {
res = pthread_attr_setstacksize(&attr, stacksize);
if (res != 0) perror("Cannot set stack size!");
}
/* all threads are detached */
res = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (res != 0) perror("Cannot set detached!");
/* spawn off thread */
res = pthread_create( &p, &attr, &TaskWrapper, thr);
if (res != 0) perror("Cannot create pthread!");
pthread_attr_destroy( &attr);
/* core affinity */
#ifdef USE_CORE_AFFINITY
if (ent == ENTITY_other) {
SetThreadAffinity( &p, STRICTLYFIRST);
} else {
SetThreadAffinity( &p, DEFAULT);
}
#endif /* USE_CORE_AFFINITY */
}
void StopAllProc(pstack_t **head, struct SyncMethod *type) {
HANDLE hEvent;
int size;
hEvent = OpenEvent(EVENT_ALL_ACCESS, FALSE, "Event");
if (hEvent == NULL) {
exit(EXIT_FAILURE);
}
WaitForSingleObject(hEvent, INFINITE);
while ((size = StackSize(head)) != 0) {
TerminateProcess((*head)->process.procInfo.hProcess, 0);
CloseHandle((*head)->process.procInfo.hThread);
CloseHandle((*head)->process.procInfo.hProcess);
type->process_count--;
StackPop(head);
}
CloseHandle(hEvent);
return;
}
int main(void)
{
Stack s;
if(StackAlloc(&s, 100) == -1){
puts("すたっくの確保に失敗しました。");
return (1);
}
while(1){
int m, x;
printf("現在のでーた数：%d/%d\n", StackNo(&s), StackSize(&s));
printf("（１）ぷっしゅ （２）ぽっぷ （０）終了 ：");
scanf("%d", &m);
if(m == 0){
break;
}
switch (m){
case 1:
printf("でーた：");
scanf("%d", &x);
if(StackPush(&s, x) == -1){
puts("すたっくへのぷっしゅに失敗しました。");
}
break;
case 2:
if(StackPop(&s, &x) == -1){
puts("ぽっぷできません。");
}else{
printf("ぽっぷしたでーたは%dです。\n", x);
}
break;
}
}
StackFree(&s);
return (0);
}
/* function :: alloc_event()
* arguments :: none
* ======================================================
* This function allocates memory for an event, and
* makes sure it's values are set to default.
*/
EVENT_DATA *alloc_event()
{
EVENT_DATA *event;
if (StackSize(event_free) <= 0)
event = malloc(sizeof(*event));
else
event = (EVENT_DATA *) PopStack(event_free);
/* clear the event */
event->fun = NULL;
event->argument = NULL;
event->owner.dMob = NULL; /* only need to NULL one of the union members */
event->passes = 0;
event->bucket = 0;
event->ownertype = EVENT_UNOWNED;
event->type = EVENT_NONE;
/* return the allocated and cleared event */
return event;
}
int main(void) {
Stack s;
StackEntry e;
CreateStack(&s); //for intializing the stack
if (!StackFull(&s))
Push (e, &s);
if (!StackEmpty(&s))
Pop (&e, &s);
if (!StackEmpty(&s))
StackTop (&e, &s);
x = StackSize (&s);
ClearStack (&s);
return 0;
}
int main(int argc, char* argv[], char** envp)
{
int i = 0;
int count = 20;
char *s1 = "abcdefg";
char *s2 = "g";
size_t len1 = 0;
size_t n = 3;
char dest[20];
node_t *node1 = NULL;
node_t *node2 = NULL;
node_t *node3 = NULL;
node_t *node4 = NULL;
node_t *node5 = NULL;
char *t = NULL;
stack_t *stack = NULL;
size_t n1 = 1;
size_t n2 = 2;
size_t n3 = 3;
size_t n4 = 4;
size_t n5 = 5;
/*__________ RecFibonacci __________*/
printf("\n[%s %s %d]RecFibonacci\n", __FILE__, __func__, __LINE__);
for (i = 0; i < count; ++i)
{
printf("RecFibonacci(%i):%i\n", i , RecFibonacci(i));
}
/*__________ RecStrlen __________*/
printf("\n[%s %s %d]RecStrlen\n", __FILE__, __func__, __LINE__);
len1 = RecStrlen(s1);
printf("len1:%lu\n", len1);
/*__________ RecStrcmp __________*/
printf("\n[%s %s %d]RecStrcmp\n", __FILE__, __func__, __LINE__);
printf("RecStrcmp(s1, s2): %i\n", RecStrcmp(s1, s2));
/*__________ RecStrncmp __________*/
printf("\n[%s %s %d]RecStrncmp\n", __FILE__, __func__, __LINE__);
printf("RecStrncmp(s1, s2, n): %i\n", RecStrncmp(s1, s2, n));
/*__________ RecStrstr __________*/
printf("\n[%s %s %d]RecStrstr\n", __FILE__, __func__, __LINE__);
printf("RecStrstr(s1, s2):%s\n", RecStrstr(s1, s2));
/*__________ RecStrcpy __________*/
printf("\n[%s %s %d]RecStrcpy\n", __FILE__, __func__, __LINE__);
t = RecStrcpy(dest, s1);
printf("RecStrcpy(dest, s1):%s expected result:%s\n", t, dest);
/*__________ RecStrcat __________*/
printf("\n[%s %s %d]RecStrcat\n", __FILE__, __func__, __LINE__);
printf("RecStrcat(dest, s1):%s expected result:%s\n",
RecStrcat(dest, s1), "abcgefgabcdefg");
/*__________ RecSlistFlip __________*/
printf("\n[%s %s %d]RecSListFlip\n", __FILE__, __func__, __LINE__);
node5 = SListCreateNode((void*)5, NULL);
node4 = SListCreateNode((void*)4, node5);
node3 = SListCreateNode((void*)3, node4);
node2 = SListCreateNode((void*)2, node3);
node1 = SListCreateNode((void*)1, node2);
printf("SListCount(node1):%lu\n", SListCount(node1));
RecSListFlip(node1);
printf("SListCount(node1):%lu\n", SListCount(node5));
SListFreeAll(node5);
/*__________ Compere __________*/
printf("\n[%s %s %d]Compere\n", __FILE__, __func__, __LINE__);
printf("Compere(&n1, &n2):%i expected result:1\n", Compere(&n1, &n2));
printf("Compere(&n1, &n1):%i expected result:1\n", Compere(&n1, &n2));
printf("Compere(&n2, &n1):%i expected result:0\n", Compere(&n2, &n1));
/*_________________________ END Compere _______________________*/
/*________________________________________________________________*/
printf("\n[%s %s %d]RecStackSort\n", __FILE__, __func__, __LINE__);
/*_________________________ RecStackSort _______________________*/
stack = StackCreate(sizeof(size_t), 5);
assert(stack);
StackPush(stack, &n3);
StackPush(stack, &n2);
StackPush(stack, &n5);
StackPush(stack, &n4);
StackPush(stack, &n1);
RecStackSort(stack, &Compere, sizeof(size_t));
for( ; StackSize(stack); StackPop(stack))
{
printf("StackPeek(stack):%lu\n", *(size_t*)StackPeek(stack));
}
StackDestroy(stack);
return(0);
}
D_MOBILE *load_player(char *player)
{
FILE *fp;
D_MOBILE *dMob = NULL;
char pfile[MAX_BUFFER];
char pName[MAX_BUFFER];
char *word;
bool done = FALSE, found;
int i, size;
pName[0] = toupper(player[0]);
size = strlen(player);
for (i = 1; i < size && i < MAX_BUFFER - 1; i++)
pName[i] = tolower(player[i]);
pName[i] = '\0';
/* open the pfile so we can write to it */
snprintf(pfile, MAX_BUFFER, "players/%s.pfile", pName);
if ((fp = fopen(pfile, "r")) == NULL)
return NULL;
/* create new mobile data */
if (StackSize(dmobile_free) <= 0)
{
if ((dMob = malloc(sizeof(*dMob))) == NULL)
{
bug("Load_player: Cannot allocate memory.");
abort();
}
}
else
{
dMob = (D_MOBILE *) PopStack(dmobile_free);
}
clear_mobile(dMob);
/* load data */
word = fread_word(fp);
while (!done)
{
found = FALSE;
switch (word[0])
{
case 'E':
if (!strcasecmp(word, "EOF")) {done = TRUE; found = TRUE; break;}
break;
case 'L':
IREAD( "Level", dMob->level );
break;
case 'N':
SREAD( "Name", dMob->name );
break;
case 'P':
SREAD( "Password", dMob->password );
break;
}
if (!found)
{
bug("Load_player: unexpected '%s' in %s's pfile.", word, player);
free_mobile(dMob);
return NULL;
}
/* read one more */
if (!done) word = fread_word(fp);
}
fclose(fp);
return dMob;
}
D_MOBILE *load_player(char *player)
{
FILE *fp;
D_MOBILE *dMob = NULL;
char pfile[256];
char pName[20];
char *word;
bool done = FALSE, found;
int i, size;
pName[0] = toupper(player[0]);
size = strlen(player);
for (i = 1; i < size; i++)
pName[i] = tolower(player[i]);
pName[i] = '\0';
/* open the pfile so we can write to it */
sprintf(pfile, "../players/%s.pfile", pName);
if ((fp = fopen(pfile, "r")) == NULL)
return NULL;
/* create new mobile data */
if (StackSize(dmobile_free) <= 0)
{
if ((dMob = malloc(sizeof(*dMob))) == NULL)
{
bug("Load_player: Cannot allocate memory.");
abort();
}
}
else
{
dMob = (D_MOBILE *) PopStack(dmobile_free);
}
clear_mobile(dMob);
#ifdef IMC
imc_initchar( dMob );
#endif
/* load data */
word = fread_word(fp);
while (!done)
{
found = FALSE;
switch (word[0])
{
case 'C':
if (compares(word, "Coordx")) { IREAD( "Coordx", dMob->coordx ); }
if (compares(word, "Coordy")) { IREAD( "Coordy", dMob->coordy ); }
if (compares(word, "Coordz")) { IREAD( "Coordz", dMob->coordz ); }
break;
case 'E':
if (!strcasecmp(word, "EOF")) {done = TRUE; found = TRUE; break;}
break;
case 'I':
#ifdef IMC
if( ( found = imc_loadchar( dMob, fp, word ) ) )
break;
#endif
break;
case 'L':
IREAD( "Level", dMob->level );
break;
case 'N':
SREAD( "Name", dMob->name );
break;
case 'P':
SREAD( "Password", dMob->password );
break;
case 'T':
SREAD( "Title", dMob->title );
break;
}
if (!found)
{
bug("Load_player: unexpected '%s' in %s's pfile.", word, player);
free_mobile(dMob);
return NULL;
}
/* read one more */
if (!done) word = fread_word(fp);
}
fclose(fp);
return dMob;
}
