/*============================================
* cgn_callback -- callback for name traversal
* for checking for ghost names
* Created: 2001/01/01, Perry Rapp
*==========================================*/
static BOOLEAN
cgn_callback (TRAV_NAMES_FUNC_ARGS(key, name, newset, param))
{
/* a name record which points at indi=key */
RECORD indi0 = NULL;
NODE indi = NULL;
param=param; /* unused */
/* bail out immediately if not INDI */
if (key[0] != 'I') {
report_error(ERR_NONINDINAME
, _("Non-indi name, key=%s, name=%s")
, key, name);
return 1; /* continue traversal */
}
indi0 = qkey_to_irecord(key);
indi = nztop(indi0);
if (newset) {
finish_and_delete_nameset();
soundexseq = create_indiseq_sval();
}
append_indiseq_sval(soundexseq, strsave(key), (STRING)name, strsave(name)
, TRUE, TRUE); /* sure, alloc */
if (!indi) {
report_error(ERR_ORPHANNAME, _("Orphaned name: %s"), name);
if (todo.fix_ghosts)
enqueue_list(tofix, (VPTR)alloc_namerefn(name, key, ERR_ORPHANNAME));
} else {
NODE node;
BOOLEAN found=FALSE;
NODE nam, refn, sex, body, famc, fams;
split_indi_old(indi, &nam, &refn, &sex, &body, &famc, &fams);
for (node = nam; node; node = nsibling(node)) {
if (!strcmp(nval(node), name))
found=TRUE;
}
join_indi(indi, nam, refn, sex, body, famc, fams);
if (!found) {
report_error(ERR_GHOSTNAME, _("Ghost name: %s -> %s"), name, key);
if (todo.fix_ghosts)
enqueue_list(tofix, (VPTR)alloc_namerefn(name, key, ERR_GHOSTNAME));
}
}
if (noisy)
report_progress("Name: %s", name);
return 1; /* continue traversal */
}
/*=================================================
* append_to_text_list - add onto fixed width string list
* newline: flag to not append to last element of list
* we build each line in current, and add it to list as done
* ptr points to the undone part of text
* curptr points to the end (insertion point) of current
* NB: We also build list from last to first, so client can use
* FORLIST traversal (which is backwards)
* TO DO: Break at whitespace
*=================================================*/
static void
append_to_text_list (LIST list, STRING text, INT width, BOOLEAN newline)
{
STRING ptr = text;
STRING temp, current, curptr;
INT len, curlen;
if (!text || !text[0])
return;
/* pull off last line into temp, to append to */
if (newline) {
temp = NULL;
} else {
temp = pop_list(list);
if (temp && (INT)strlen(temp) >= width) {
enqueue_list(list, temp);
temp = NULL;
}
}
current=stdalloc((width+1)*sizeof(char));
current[0] = 0;
curptr = current;
curlen = width;
if (temp) {
llstrcatn(&curptr, temp, &curlen);
}
while (1) {
len = strlen(ptr);
if (!len) {
/* done */
if (current[0]) {
enqueue_list(list, strsave(current));
}
stdfree(current);
return;
}
if (len > curlen)
len = curlen;
temp = curptr;
llstrcatn(&curptr, ptr, &curlen);
ptr += (curptr - temp);
if (!curlen) {
/* filled up an item */
enqueue_list(list, strsave(current));
current[0] = 0;
curptr = current;
curlen = width;
}
}
}
//matching making, dequeue first two elements of playerlist
int matchmaking(struct queue_list *playerlist, struct queue_list *battlelist)
{
struct battle *b;
struct node *p1 = playerlist->front;
struct player *c1 = p1->content;
struct node *temp = playerlist->front->next;
struct player *c2 = temp->content;
if (!p1 || !temp)
{
printf("Not enough player!\n");
return -1;
}
while ((c1->prev_id == c2->prev_id) && temp)
{
temp = temp->next;
c2 = temp->content;
}
if (!temp)
{
printf("Cannot find match\n");
return -1;
}
b = createcombat(c1, c2);
enqueue_list(battlelist, b);
dequeue_list(playerlist, p1);
remove_ele(playerlist, temp)
return 1;
}
//deal with client linked list
void addclient(int clientfd,struct in_addr addr, struct queue_list *clientlist)
{
struct client *c = malloc(sizeof(struct client));
c->fd = clientfd;
c->ipaddr = addr;
enqueue_list(clientlist, c);
}
/*============================================
* cgr_callback -- callback for refn traversal
* for checking for ghost refns
* Created: 2001/01/13, Perry Rapp
*==========================================*/
static BOOLEAN
cgr_callback (TRAV_REFNS_FUNC_ARGS(key, refn, newset, param))
{
/* a refn record which points at record=key */
RECORD rec = key_to_record(key);
NODE node = nztop(rec);
param = param; /* unused */
if (newset) {
finish_and_delete_refnset();
soundexseq = create_indiseq_sval();
}
append_indiseq_sval(soundexseq, strsave(key), NULL, strsave(refn)
, TRUE, TRUE); /* sure, alloc */
if (!node) {
report_error(ERR_ORPHANNAME, _("Orphaned refn: %s"), refn);
if (todo.fix_ghosts)
enqueue_list(tofix, (VPTR)alloc_namerefn(refn, key, ERR_ORPHANNAME));
} else {
}
if (noisy)
report_progress("Refn: %s", refn);
return 1; /* continue traversal */
}
/*===================================================
* add_dir_files_to_proplist -- Add all files in dir to list of property tables
* Created: 2002/10/19, Perry Rapp
*=================================================*/
INT
add_dir_files_to_proplist (CNSTRING dir, SELECT_FNC selectfnc, LIST list)
{
struct dirent **programs;
INT n = scandir(dir, &programs, selectfnc, alphasort);
INT i;
for (i=0; i<n; ++i) {
TABLE table = create_table_str();
set_prop_dnum(table, 1, "filename", programs[i]->d_name);
set_prop_dnum(table, 2, "dir", dir);
stdfree(programs[i]);
programs[i] = NULL;
enqueue_list(list, table);
}
if (n>0)
stdfree(programs);
return i;
}
/*=================================================================
* advedit_expand_traverse -- Traverse routine called when expanding record
*===============================================================*/
static BOOLEAN
advedit_expand_traverse (NODE node, VPTR param)
{
LIST subs = (LIST)param;
STRING key = value_to_xref(nval(node));
if (!key) return TRUE;
key = strsave(key);
#ifdef DEBUG
llwprintf("expand_traverse: %s %s\n", ntag(node), nval(node));
#endif /* DEBUG */
FORLIST(subs, el)
#ifdef DEBUG
llwprintf("expand_traverse: %s %s\n", key, rmvat(nval((NODE) el)));
#endif /* DEBUG */
if (eqstr(key, rmvat(nval((NODE) el)))) {
STOPLIST
stdfree(key);
return TRUE;
}
ENDLIST
enqueue_list(subs, node);
stdfree(key);
return TRUE;
}
int battle_end(struct battle *b, struct queue_list *playerlist, int force_exit)
{
struct player *p = b->player_1;
struct player *p_1 = b->player_2;
char buf1[256];
char buf2[256];
int n, n1, err = 1, err1 = 1, bid;
if (!b)
{
return -1;
}
if ((p->stat->hp > 0) && (p_1->stat->hp > 0) && (force_exit != 1))
{
return 0; // battle doesn't end
}
else
{
bid = b->battle_id;
if ((p->stat->hp <= 0) && (p_1->stat->hp > 0))
{
n = sprintf(buf1, "You win! You have defeated %s!\nAwaiting for next battle\r\n", p->name);
n1 = sprintf(buf2, "You are defeated by %s!\nAwaiting for next battle\r\n", p_1->name);
err = write(p_1->client->fd, buf1, n);
err1 = write(p->client->fd, buf2, n1);
}
else if ((p->stat->hp > 0) && (p_1->stat->hp <=0))
{
n = sprintf(buf1, "You win! You have defeated %s!\nAwaiting for next battle\r\n", p_1->name);
n1 = sprintf(buf2, "You are defeated by %s!\nAwaiting for next battle\r\n", p->name);
err = write(p->client->fd, buf1, n);
err1 = write(p_1->client->fd, buf2, n1);
}
else
{
if (force_exit != 1)
{
return -1;
}
}
if (err < 0 || err1 < 0)
{
perror("write battle_end()");
}
p->status = 0;
p_1->status = 0;
p->cur_bat = NULL;
p_1->cur_bat = NULL;
enqueue_list(playerlist, p_1);
enqueue_list(playerlist, p_2);
return bid;
}
return -1;
}
/*=====================================
* process_fam -- process indi record
* checking in pass 1, fixing in pass 2
*===================================*/
static void
process_fam (RECORD rec)
{
NODE fam0, fam1;
NODE fref1, husb1, wife1, chil1, rest1;
NODE node1;
INT members = 0;
BOOLEAN altered=FALSE;
BOOLEAN needfix=FALSE;
CNSTRING key = nzkey(rec);
fam0 = nztop(rec);
if (todo.pass==1) {
fam1 = fam0;
} else {
fam1 = copy_node_subtree(fam0);
}
split_fam(fam1, &fref1, &husb1, &wife1, &chil1, &rest1);
/* check refns */
for (node1 = fref1; node1; node1 = nsibling(node1)) {
/* STRING refn=nval(node1); */
/* TO DO: verify that refn is in db */
}
/* check husbs */
for (node1 = husb1; node1; node1 = nsibling(node1)) {
STRING husbkey=rmvat(nval(node1));
NODE husb = qkey_to_indi(husbkey);
members++;
if (!husb) {
if (todo.pass == 1) {
report_error(ERR_BADHUSBREF
, _("Bad HUSB reference (%s) in family %s")
, husbkey, key);
needfix=TRUE;
} else {
if (fix_bad_pointer(key, rec, node1)) {
report_fix(ERR_BADHUSBREF
, _("Fixed Bad HUSB reference (%s) in family %s")
, husbkey, key);
altered=TRUE;
}
}
} else {
/* look for family (key) in husb */
if (!find_xref(key, husb, "FAMS", NULL)) {
report_error(ERR_EXTRAHUSB
, _("Improper HUSB (%s) in family (%s)")
, husbkey, key);
}
}
}
/* check wives */
for (node1 = wife1; node1; node1 = nsibling(node1)) {
STRING wifekey=rmvat(nval(node1));
NODE wife = qkey_to_indi(wifekey);
members++;
if (!wife) {
if (todo.pass == 1) {
report_error(ERR_BADWIFEREF
, _("Bad wife reference (%s) in family %s")
, wifekey, key);
needfix=TRUE;
} else {
if (fix_bad_pointer(key, rec, node1)) {
report_fix(ERR_BADWIFEREF
, _("Fixed Bad wife reference (%s) in family %s")
, printkey(wifekey), key);
altered=TRUE;
}
}
} else {
/* look for family (key) in wife */
if (!find_xref(key, wife, "FAMS", NULL)) {
report_error(ERR_EXTRAWIFE
, _("Improper wife (%s) in family (%s)")
, printkey(wifekey), key);
}
}
}
/* check children */
for (node1 = chil1; node1; node1 = nsibling(node1)) {
STRING chilkey=rmvat(nval(node1));
NODE child = qkey_to_indi(chilkey);
members++;
if (!child) {
if (todo.pass == 1) {
report_error(ERR_BADCHILDREF
, _("Bad child reference (%s) in family %s")
, printkey(chilkey), key);
needfix=TRUE;
} else {
if (fix_bad_pointer(key, rec, node1)) {
report_fix(ERR_BADCHILDREF
, _("Fixed bad child reference (%s) in family %s")
, printkey(chilkey), key);
altered=TRUE;
}
}
} else {
/* look for family (key) in child */
if (!find_xref(key, child, "FAMC", NULL)) {
report_error(ERR_EXTRACHILD
, _("Improper child: Child (%s) without FAMC reference to family (%s)")
, printkey(chilkey), key);
}
}
}
join_fam(fam1, fref1, husb1, wife1, chil1, rest1);
/* check for undersized family */
if (!members) {
report_error(ERR_EMPTYFAM, _("Empty family (%s)"), key);
} else if (members == 1) {
report_error(ERR_SOLOFAM, _("Single person family (%s)"), key);
}
if (altered) {
/* must normalize, as some lineage references may have been
altered to non-lineage tags to fix broken pointers */
normalize_fam(fam1);
/* write to database */
replace_fam(fam0, fam1);
} else if (needfix) {
enqueue_list(tofix, strsave(key));
}
}
/*=====================================
* process_indi -- process indi record
* checking in pass 1, fixing in pass 2
*===================================*/
static void
process_indi (RECORD rec)
{
NODE indi0, indi1;
NODE name1, refn1, sex1, body1, famc1, fams1;
NODE node1;
BOOLEAN altered=FALSE;
BOOLEAN needfix=FALSE;
CNSTRING key = nzkey(rec);
indi0 = nztop(rec);
if (todo.pass==1) {
indi1 = indi0;
} else {
indi1 = copy_node_subtree(indi0);
}
split_indi_old(indi1, &name1, &refn1, &sex1, &body1, &famc1, &fams1);
if (todo.pass == 1) {
/* check names */
for (node1 = name1; node1; node1 = nsibling(node1)) {
STRING name=nval(node1);
if (!valid_name(name)) {
report_error(ERR_BADNAME, _("Bad name for individual %s: %s"), key, name);
} else {
/* TO DO: verify that name is in db */
}
}
/* check refns */
for (node1 = refn1; node1; node1 = nsibling(node1)) {
/* STRING refn=nval(node1); */
/* TO DO: verify that refn is in db */
}
}
/* check parents */
for (node1 = famc1; node1; node1 = nsibling(node1)) {
STRING famkey=rmvat(nval(node1));
NODE fam2 = qkey_to_fam(famkey);
if (!fam2) {
if (todo.pass == 1) {
report_error(ERR_BADFAMREF, _("Bad family reference (%s) individual %s"), famkey, key);
}
} else {
/* look for indi1 (key) in fam2's children */
if (!find_xref(key, fam2, "CHIL", NULL)) {
if (todo.pass == 1) {
report_error(ERR_MISSINGCHILD, _("Missing child (%s) in family (%s)"), key, famkey);
needfix=TRUE;
} else {
if (fix_bad_pointer(key, rec, node1)) {
report_fix(ERR_MISSINGCHILD, _("Fixed missing child (%s) in family (%s)"), key, famkey);
altered=TRUE;
}
}
}
}
}
/* check spouses */
for (node1 = fams1; node1; node1 = nsibling(node1)) {
STRING famkey=rmvat(nval(node1));
NODE fam2 = qkey_to_fam(famkey);
if (!fam2) {
if (todo.pass == 1) {
report_error(ERR_BADFAMREF, _("Bad family reference (%s) individual %s"), famkey, key);
}
} else {
/* look for indi1 (key) in fam2's spouses */
if (!find_xref(key, fam2, "HUSB", "WIFE")) {
if (todo.pass == 1) {
report_error(ERR_MISSINGSPOUSE, _("Missing spouse (%s) in family (%s)"), key, famkey);
needfix=TRUE;
} else {
if (fix_bad_pointer(key, rec, node1)) {
report_fix(ERR_MISSINGSPOUSE, _("Fixed missing spouse (%s) in family (%s)"), key, famkey);
altered=TRUE;
}
}
}
}
}
join_indi(indi1, name1, refn1, sex1, body1, famc1, fams1);
if (altered) {
/* must normalize, as some lineage references may have been
altered to non-lineage tags to fix broken pointers */
normalize_indi(indi1);
/* write to database */
replace_indi(indi0, indi1);
} else if (needfix) {
enqueue_list(tofix, strsave(key));
}
}
int read_File(FILE * fp,sch * list) {
char string[BUFF_SIZE];
int temp = 0, temp2 = 0, temp3 = 0;
int thread_id = 0;
int proc_id = 0;
int num_thread = 0;
int num_CPU = 0;
int counter = 0;
int thread_counter = 0;
int CPU_counter = 0;
int flag = 0;
if(fp!=NULL){
while(!feof(fp)){
if( fgets(string,BUFF_SIZE,fp) != NULL){
if(counter == 0){
sscanf(string,"%d%d%d",&temp,&temp2,&temp3);
list->number_proc = temp;
list->thread_switch = temp2;
list->proc_switch = temp3;
//creat procs
}else if(thread_counter == num_thread && flag == 0){
sscanf(string,"%d%d",&temp,&temp2);
num_thread = temp2;
proc_id = temp;
thread_counter = 0;
if(enqueue_list(list,NULL,NULL, creat_proc(temp,temp2),0,0) == 1){
printf("error: proc\n");
exit(1);
}
//creat threads
}else if(CPU_counter == num_CPU){
sscanf(string,"%d%d%d",&temp,&temp2,&temp3);
num_CPU = temp3;
thread_id = temp;
thread_counter++;
CPU_counter = 0;
if(thread_counter == num_thread){
flag = 1;
}
if(enqueue_list(list,NULL,creat_thread(temp,temp2,temp3),NULL,proc_id,0) == 1){
printf("error: thread\n");
exit(1);
}
}else{
//creat burst
sscanf(string,"%d%d%d",&temp,&temp2,&temp3);
CPU_counter++;
if(flag == 1 && CPU_counter == num_CPU){
flag = 0;
}
if(enqueue_list(list,creat_CPU(temp,temp3,temp2),NULL,NULL,thread_id,proc_id) == 1){
printf("error: CPU\n");
exit(1);
}
}
temp = 0;
temp2 = 0;
temp3 = 0;
counter++;
}
}
fclose(fp);
}else{
return -1;
}
return 0;
}
