{
struct io *io;
- io = (struct io *)malloc(sizeof(*io));
+ io = malloc(sizeof(*io));
io->nbytes = cc;
io->offset = 0;
io->data = buf;
struct qelem *qp;
int i;
- table = (struct qelem *)malloc(sizeof(*table) * nelem);
+ table = malloc(sizeof(*table) * nelem);
for (i = 0, qp = table; i < nelem; i++, qp++)
initque(qp);
return table;
while (p < buf + n && q < out + 4000) {
if (*p == '\n') {
if (tagging) {
- tag = (struct tagstruct *)malloc(sizeof(struct tagstruct));
- tag->item = (char *)malloc((1 + p - s) * sizeof(char));
+ tag = malloc(sizeof(struct tagstruct));
+ tag->item = malloc((1 + p - s) * sizeof(char));
tag->next = taglist;
taglist = tag;
t = tag->item;
}
} else {
/* We must make a new one of these */
- from = (struct as_frompath *)malloc(sizeof(struct as_frompath));
+ from = malloc(sizeof(struct as_frompath));
if (from == NULL)
return;
/* And set some stuff */
}
if (!to) {
/* We must make a new one */
- to = (struct as_topath *)malloc(sizeof(struct as_topath));
+ to = malloc(sizeof(struct as_topath));
/* We can't, sorry */
if (to == NULL)
return;
/* Free this path */
as_free_path(to->path);
/* Free this node */
- free((s_char *)to);
+ free(to);
}
}
/* Now, free the list of lists */
- free((s_char *)from->tolist);
+ free(from->tolist);
/* Save the next pointer */
from2 = from->next;
/* now, free this from node */
- free((s_char *)from);
+ free(from);
}
}
/* Note we don't free the fromhead here, we just zero it. That way,
struct as_queue *qp, *qp2;
for (qp = queue; qp; qp = qp2) {
- free((s_char *)qp->np);
+ free(qp->np);
qp2 = qp->next;
- free((s_char *)qp);
+ free(qp);
}
}
for (; pp; pp = pp2) {
pp2 = pp->next;
- free((s_char *)pp);
+ free(pp);
}
}
as_delete(struct as_data *adp)
{
as_reset(adp);
- free((s_char *)adp->neighbor_coords);
- free((s_char *)adp->neighbor_nodes);
- free((s_char *)adp->hashtab);
- free((s_char *)adp);
+ free(adp->neighbor_coords);
+ free(adp->neighbor_nodes);
+ free(adp->hashtab);
+ free(adp);
}
for (i = 0; i < adp->hashsize; i++) {
for (hp = adp->hashtab[i]; hp; hp = hp2) {
hp2 = hp->next;
- free((char *)hp);
+ free(hp);
}
adp->hashtab[i] = NULL;
}
struct as_node *np;
for (np = adp->head->np; np; np = np->back) {
- pp = (struct as_path *)malloc(sizeof(struct as_path));
+ pp = malloc(sizeof(struct as_path));
pp->c = np->c;
pp->next = adp->path;
adp->path = pp;
if (p == 0)
return RET_OK;
snxtitem_all(&ni, EF_LAND);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == coun) {
makelost(EF_LAND, land.lnd_own, land.lnd_uid, land.lnd_x,
land.lnd_y);
nuketype = i;
nukenum = -1;
snxtitem_all(&ni, EF_NUKE);
- while (nxtitem(&ni, (s_char *)&nuke)) {
+ while (nxtitem(&ni, &nuke)) {
if (nuke.nuk_own != player->cnum)
continue;
if (nuke.nuk_x != pl.pln_x || nuke.nuk_y != pl.pln_y)
/* Look for land units with mobility */
snxtitem_xy(&ni, EF_LAND, off->x, off->y);
foundland = 0;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own != player->cnum)
continue;
if (land.lnd_ship >= 0)
*planes = *pbuild = *npbuild = *pmaint = 0;
np = getnatp(player->cnum);
- bp = (int *)calloc(WORLD_X * WORLD_Y * 8, sizeof(int));
+ bp = calloc(WORLD_X * WORLD_Y * 8, sizeof(int));
for (n = 0; NULL != (sp = getsectid(n)); n++) {
fill_update_array(bp, sp);
if (sp->sct_own == player->cnum) {
player->dolcost += cost;
cash -= cost;
snxtitem_all(&nstr, EF_SHIP);
- while (nxtitem(&nstr, (s_char *)&ship)) {
+ while (nxtitem(&nstr, &ship)) {
if (ship.shp_own == 0) {
freeship++;
break;
player->dolcost += cost;
cash -= cost;
snxtitem_all(&nstr, EF_LAND);
- while (nxtitem(&nstr, (s_char *)&land)) {
+ while (nxtitem(&nstr, &land)) {
if (land.lnd_own == 0) {
freeland++;
break;
cash -= cost;
snxtitem_all(&nstr, EF_PLANE);
freeplane = 0;
- while (nxtitem(&nstr, (s_char *)&plane)) {
+ while (nxtitem(&nstr, &plane)) {
if (plane.pln_own == 0) {
freeplane++;
break;
if (!snxtitem(&ni, EF_SHIP, player->argp[1]))
return RET_SYN;
nships = 0;
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (ship.shp_own == 0)
continue;
if ((player->cnum != ship.shp_own) && !player->god)
if (!snxtitem(&ni, EF_LAND, player->argp[1]))
return RET_SYN;
nunits = 0;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!land.lnd_own)
continue;
if ((player->cnum != land.lnd_own) && !player->god)
bad = 0;
}
snxtitem_all(&ni, EF_SHIP);
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if ((ship.shp_own == to) &&
((ship.shp_x == sect.sct_x) && (ship.shp_y == sect.sct_y)))
bad = 0;
int nships = 0;
int bad = 0;
- while (nxtitem(ni, (s_char *)&ship)) {
+ while (nxtitem(ni, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
bad = 1;
snxtitem_xy(&tni, EF_SHIP, ship.shp_x, ship.shp_y);
- while (nxtitem(&tni, (s_char *)&tship) && bad)
+ while (nxtitem(&tni, &tship) && bad)
if (tship.shp_own == to)
bad = 0;
return RET_SYN;
for (i = 0; i < TSIZE; i++)
list[i] = 0;
- cp = (struct coast *)malloc(sizeof(*cp));
+ cp = malloc(sizeof(*cp));
snxtitem_all(&ni, EF_SHIP);
- while (nxtitem(&ni, (s_char *)&cp->c_shp)) {
+ while (nxtitem(&ni, &cp->c_shp)) {
if (cp->c_shp.shp_own == 0 || cp->c_shp.shp_own == player->cnum)
continue;
/*
cp->c_number = i;
cp->c_next = list[n];
list[n] = cp;
- cp = (struct coast *)malloc(sizeof(*cp));
+ cp = malloc(sizeof(*cp));
nship++;
}
/* get that last one! */
- free((s_char *)cp);
+ free(cp);
pr("- = [ Coastwatch report for %s ] = -\n", cname(player->cnum));
pr(" Country Ship Location\n");
tech = tfact(player->cnum, 1.0);
for (i = 0; i < TSIZE; i++) {
while (NULL != (cp = list[i])) {
list[i] = cp->c_next;
- free((s_char *)cp);
+ free(cp);
}
}
return RET_OK;
do {
/* we delete it, we free it. */
if (todelete) {
- free((s_char *)todelete);
+ free(todelete);
todelete = 0;
}
if (cp->c_shp.shp_x != x || cp->c_shp.shp_y != y) {
} while (NULL != (cp = cp->c_next));
/* check that last one! */
if (todelete)
- free((s_char *)todelete);
+ free(todelete);
return (nship);
}
}
/* check to see if a loan already exists */
snxtitem_all(&nstr, EF_LOAN);
- while (nxtitem(&nstr, (s_char *)&loan)) {
+ while (nxtitem(&nstr, &loan)) {
if (loan.l_status == LS_SIGNED && loan.l_lonee == lp->l_loner
&& (loan.l_loner == lp->l_lonee)) {
pr("He already owes you money - make him repay his loan!\n");
(void)time(&lp->l_lastpay);
lp->l_duedate = lp->l_ldur * 86400 + lp->l_lastpay;
lp->l_status = LS_SIGNED;
- if (!putloan(ltcp->num, (s_char *)lp)) {
+ if (!putloan(ltcp->num, lp)) {
pr("Problem writing lp->to disk; get help!\n");
return RET_FAIL;
}
* count.
*/
snxtitem_xy(&ni, EF_LAND, sect.sct_x, sect.sct_y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
mil += lnd_getmil(&land);
/* mil += (lnd_getmil(&land) *
((double)land.lnd_effic/100.0));*/
if (!snxtitem(&ni, EF_NATION, player->argp[1]))
return RET_SYN;
first = 1;
- while (nxtitem(&ni, (s_char *)&nat)) {
+ while (nxtitem(&ni, &nat)) {
if ((nat.nat_stat & STAT_INUSE) == 0)
continue;
if (((nat.nat_stat & GOD) != GOD) && !player->god)
}
natp = getnatp(who);
- while (nxtitem(&ni, (s_char *)&nat)) {
+ while (nxtitem(&ni, &nat)) {
if (!(nat.nat_stat & STAT_INUSE))
continue;
if (player->cnum == (natid)ni.cur)
&& ip->i_vtype == I_SHELL)
pln_mine(&bomb_list, &target);
else
- pln_dropoff(&bomb_list, ip, tx, ty, (s_char *)&target, EF_SECTOR);
+ pln_dropoff(&bomb_list, ip, tx, ty, &target, EF_SECTOR);
}
pln_put(&bomb_list);
pln_put(&esc_list);
}
x = ship.shp_x;
y = ship.shp_y;
- while (nxtitem(&nstr, (s_char *)&ship)) {
+ while (nxtitem(&nstr, &ship)) {
if (!player->owner)
continue;
if (ship.shp_x != x || ship.shp_y != y) {
if (fort_amt > land_mob_max)
fort_amt = land_mob_max;
nunits = 0;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!player->owner || land.lnd_own == 0)
continue;
if (land.lnd_type < 0 || land.lnd_type > lnd_maxno) {
return RET_FAIL;
}
- while (nxtitem(&ni, (s_char *)&item)) {
+ while (nxtitem(&ni, &item)) {
fueled = 0;
if (type == EF_SHIP) {
if (item.ship.shp_own != player->cnum) {
if (!check_ship_ok(&item.ship))
continue;
- if (!nxtitem(&tender, (s_char *)&item2))
+ if (!nxtitem(&tender, &item2))
continue;
if (!(mchr[(int)item2.ship.shp_type].m_flags & M_OILER)) {
if (!check_land_ok(&item.land))
continue;
- if (!nxtitem(<ender, (s_char *)&item2))
+ if (!nxtitem(<ender, &item2))
continue;
if (!(lchr[(int)item2.land.lnd_type].l_flags & L_SUPPLY)) {
return RET_SYN;
natp = getnatp(player->cnum);
cash = natp->nat_money;
- while (nxtitem(&ni, (s_char *)&pln)) {
+ while (nxtitem(&ni, &pln)) {
if (!player->owner)
continue;
pcp = &plchr[(int)pln.pln_type];
memset(hist, 0, sizeof(hist));
snxtitem_all(&nstr, EF_NEWS);
maxcnum = 0;
- while (nxtitem(&nstr, (s_char *)&news)) {
+ while (nxtitem(&nstr, &news)) {
news_age = now - news.nws_when;
if (news_age > news_per)
continue;
return RET_SYS;
}
- fbuf = (s_char *)malloc(256);
- lbuf = (s_char *)malloc(256);
- lbp = (s_char *)malloc(256);
+ fbuf = malloc(256);
+ lbuf = malloc(256);
+ lbp = malloc(256);
/*
* lower case search string into lbp
return RET_SYS;
}
- fbuf = (s_char *)malloc(256);
- lbuf = (s_char *)malloc(256);
- lbp = (s_char *)malloc(256);
+ fbuf = malloc(256);
+ lbuf = malloc(256);
+ lbp = malloc(256);
/*
* lower case search string into lbp
return RET_SYN;
nunits = 0;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
if (!player->owner && !player->god)
if (!snxtitem(&nstr, EF_PLANE, player->argp[1]))
return RET_SYN;
- while (nxtitem(&nstr, (s_char *)&plane)) {
+ while (nxtitem(&nstr, &plane)) {
if (plane.pln_own != player->cnum)
continue;
pcp = &plchr[(int)plane.pln_type];
pr("\n");
np = getnatp(player->cnum);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
if (!player->owner && !player->god)
return RET_SYN;
pr("\n... %s Ledger ...\n", cname(player->cnum));
nloan = 0;
- while (nxtitem(&nstr, (s_char *)&loan)) {
+ while (nxtitem(&nstr, &loan)) {
if (disloan(nstr.cur, &loan) > 0)
nloan++;
}
load_unload = **player->argp == 'l' ? LOAD : UNLOAD;
nships = 0;
- while (nxtitem(&nbst, (s_char *)&ship)) {
+ while (nxtitem(&nbst, &ship)) {
if (!ship.shp_own)
continue;
if (!player->owner && (load_unload == UNLOAD)) {
load_unload = *(*player->argp + 1) == 'l' ? LOAD : UNLOAD;
nunits = 0;
- while (nxtitem(&nbst, (s_char *)&land)) {
+ while (nxtitem(&nbst, &land)) {
if (land.lnd_own == 0)
continue;
if (p && *p)
noisy &= isdigit(*p);
- while (nxtitem(&ni, (s_char *)&pln)) {
+ while (nxtitem(&ni, &pln)) {
if (pln.pln_own != player->cnum)
continue;
if (!(plchr[(int)pln.pln_type].pl_flags & P_L)
if (p && *p)
noisy &= isdigit(*p);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own != player->cnum)
continue;
pr("WARNING: %s is out of supply!\n", prland(&land));
putship(sp->shp_uid, sp);
snxtitem_xy(&pni, EF_PLANE, land.lnd_x, land.lnd_y);
- while (nxtitem(&pni, (s_char *)&plane)) {
+ while (nxtitem(&pni, &plane)) {
if (plane.pln_flags & PLN_LAUNCHED)
continue;
if (plane.pln_land != land.lnd_uid)
they are quietly unloaded too. */
if (!(lchr[(int)land.lnd_type].l_flags & L_SPY)) {
snxtitem_xy(&pni, EF_PLANE, land.lnd_x, land.lnd_y);
- while (nxtitem(&pni, (s_char *)&plane)) {
+ while (nxtitem(&pni, &plane)) {
if (plane.pln_flags & PLN_LAUNCHED)
continue;
if (plane.pln_land != land.lnd_uid)
return 0;
}
- while (nxtitem(&ni, (s_char *)&pln)) {
+ while (nxtitem(&ni, &pln)) {
if (pln.pln_own != player->cnum)
continue;
if (p && *p)
noisy &= isdigit(*p);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own != player->cnum)
continue;
pr("WARNING: %s is out of supply!\n", prland(&land));
putland(lp->lnd_uid, lp);
snxtitem_xy(&pni, EF_PLANE, land.lnd_x, land.lnd_y);
- while (nxtitem(&pni, (s_char *)&plane)) {
+ while (nxtitem(&pni, &plane)) {
if (plane.pln_flags & PLN_LAUNCHED)
continue;
if (plane.pln_land != land.lnd_uid)
putland(land.lnd_uid, &land);
putland(lp->lnd_uid, lp);
snxtitem_xy(&pni, EF_PLANE, land.lnd_x, land.lnd_y);
- while (nxtitem(&pni, (s_char *)&plane)) {
+ while (nxtitem(&pni, &plane)) {
if (plane.pln_flags & PLN_LAUNCHED)
continue;
if (plane.pln_land != land.lnd_uid)
if (!snxtitem(&ni, EF_SHIP, player->argp[1]))
return RET_SYN;
- if ((bitmap = (u_char *)malloc((WORLD_X * WORLD_Y) / 8)) == 0) {
+ if ((bitmap = malloc((WORLD_X * WORLD_Y) / 8)) == 0) {
logerror("malloc failed in look\n");
pr("Memory error. Tell the deity.\n");
return RET_FAIL;
}
memset(bitmap, 0, (WORLD_X * WORLD_Y) / 8);
- while (nxtitem(&ni, (s_char *)&myship)) {
+ while (nxtitem(&ni, &myship)) {
if (!player->owner)
continue;
look_ship(&myship);
}
if (changed)
writemap(player->cnum);
- free((s_char *)bitmap);
+ free(bitmap);
return RET_OK;
}
if (!snxtitem(&ni, EF_LAND, player->argp[1]))
return RET_SYN;
- if ((bitmap = (u_char *)malloc((WORLD_X * WORLD_Y) / 8)) == 0) {
+ if ((bitmap = malloc((WORLD_X * WORLD_Y) / 8)) == 0) {
logerror("malloc failed in llook\n");
pr("Memory error. Tell the deity.\n");
return RET_FAIL;
}
memset(bitmap, 0, (WORLD_X * WORLD_Y) / 8);
- while (nxtitem(&ni, (s_char *)&myland)) {
+ while (nxtitem(&ni, &myland)) {
if (!player->owner)
continue;
if (myland.lnd_ship >= 0)
}
if (changed)
writemap(player->cnum);
- free((s_char *)bitmap);
+ free(bitmap);
return RET_OK;
}
if (player->god)
pr("owner ");
pr("type id x y timestamp\n");
- while (nxtitem(&ni, (s_char *)&lost)) {
+ while (nxtitem(&ni, &lost)) {
if (lost.lost_owner == 0)
continue;
if (lost.lost_owner != player->cnum && !player->god)
return RET_SYN;
nunits = 0;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!player->owner || land.lnd_own == 0)
continue;
if (land.lnd_type < 0 || land.lnd_type > lnd_maxno) {
if (!snxtitem(&tenders, EF_SHIP,
getstarg(player->argp[2], "Tender(s)? ", buf)))
return RET_SYN;
- while (nxtitem(&tenders, (s_char *)&tender)) {
+ while (nxtitem(&tenders, &tender)) {
if (!player->owner)
continue;
if ((p =
if (!check_ship_ok(&tender))
return RET_FAIL;
total = 0;
- while (nxtitem(&targets, (s_char *)&target)) {
+ while (nxtitem(&targets, &target)) {
if (!player->owner)
continue;
pr("Fire aborted.\n");
return RET_OK;
}
- while (nxtitem(&nbst, (s_char *)&item)) {
+ while (nxtitem(&nbst, &item)) {
attacker = orig_attacker;
if (attacker == targ_unit) {
if (!getland(item.land.lnd_uid, &fland))
(dam = quiet_bigdef(attacker, dl, vict, aown, fx, fy, &nfiring))) {
if (nfiring > *nd)
*nd = nfiring;
- fp = (struct flist *)malloc(sizeof(struct flist));
+ fp = malloc(sizeof(struct flist));
memset(fp, 0, sizeof(struct flist));
fp->defdam = dam;
fp->victim = vict;
xyas(fp->x, fp->y, vict), dam);
}
emp_remque(&fp->queue);
- free((s_char *)fp);
+ free(fp);
}
}
continue;
(*nfiring)++;
- fp = (struct flist *)malloc(sizeof(struct flist));
+ fp = malloc(sizeof(struct flist));
memset(fp, 0, sizeof(struct flist));
fp->type = targ_ship;
fp->uid = ship.shp_uid;
if (nshot == 0)
continue;
(*nfiring)++;
- fp = (struct flist *)malloc(sizeof(struct flist));
+ fp = malloc(sizeof(struct flist));
memset(fp, 0, sizeof(struct flist));
fp->type = targ_ship;
fp->uid = ship.shp_uid;
land.lnd_ammo, shell);
(*nfiring)++;
- fp = (struct flist *)malloc(sizeof(struct flist));
+ fp = malloc(sizeof(struct flist));
memset(fp, 0, sizeof(struct flist));
fp->type = targ_unit;
fp->uid = land.lnd_uid;
if (gun == 0 || firing.sct_item[I_MILIT] < 5 || shell == 0)
continue;
(*nfiring)++;
- fp = (struct flist *)malloc(sizeof(struct flist));
+ fp = malloc(sizeof(struct flist));
memset(fp, 0, sizeof(struct flist));
fp->x = firing.sct_x;
fp->y = firing.sct_y;
putland(land.lnd_uid, &land);
emp_remque(&fp->queue);
- free((s_char *)fp);
+ free(fp);
}
}
"Drop how many mines from each ship? ");
if (mines <= 0)
return RET_SYN;
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (!player->owner)
continue;
mp = &mchr[(int)ship.shp_type];
if (!snxtitem(&ni, EF_LAND, player->argp[1]))
return RET_SYN;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!player->owner)
continue;
lp = &lchr[(int)land.lnd_type];
size = max(sizeof(struct lndstr), sizeof(struct plnstr));
size = max(size, sizeof(struct shpstr));
- block = (s_char *)malloc(size);
+ block = malloc(size);
switch (type) {
case EF_SHIP:
mobmax = ship_mob_max;
pr("warning: %d less than optimal\n", mobquota);
}
}
- while (nxtitem(&nstr, (s_char *)&ship)) {
+ while (nxtitem(&nstr, &ship)) {
if (!player->owner)
continue;
if (!oldmq)
if (!snxtitem(&np, EF_LAND, player->argp[1]))
return RET_SYN;
- while (!player->aborted && nxtitem(&np, (s_char *)&land)) {
+ while (!player->aborted && nxtitem(&np, &land)) {
if (!player->owner || land.lnd_own == 0)
continue;
natp = getnatp(land.lnd_own);
}
if (!snxtitem(&nb, EF_SHIP, player->argp[1]))
return RET_SYN;
- while (nxtitem(&nb, (s_char *)&ship)) {
+ while (nxtitem(&nb, &ship)) {
if (!player->owner)
continue;
p = getstarg(player->argp[2], "Name? ", buf);
if (!snxtsct(&ns, what))
return RET_FAIL;
if (!wmapbuf)
- wmapbuf =
- (s_char *)malloc((WORLD_Y * MAPWIDTH(1)) * sizeof(s_char));
+ wmapbuf = malloc((WORLD_Y * MAPWIDTH(1)) * sizeof(s_char));
if (!wmap) {
- wmap = (s_char **)malloc(WORLD_Y * sizeof(s_char *));
+ wmap = malloc(WORLD_Y * sizeof(s_char *));
if (wmap && wmapbuf) {
for (i = 0; i < WORLD_Y; i++)
wmap[i] = &wmapbuf[MAPWIDTH(1) * i];
} else if (wmap) {
- free((s_char *)wmap);
+ free(wmap);
wmap = (s_char **)0;
}
}
if (!bitmap)
- bitmap = (u_char *)malloc((WORLD_X * WORLD_Y) / 8);
+ bitmap = malloc((WORLD_X * WORLD_Y) / 8);
if (!wmapbuf || !wmap || !bitmap) {
pr("Memory error, tell the deity.\n");
logerror("malloc failed in navi\n");
pr("own ");
pr("id x y num type\n");
nnukes = 0;
- while (nxtitem(&nstr, (s_char *)&nuk)) {
+ while (nxtitem(&nstr, &nuk)) {
if (!player->god && !player->owner)
continue;
if (nuk.nuk_own == 0)
nmin = ngold = noil = nur = 0;
navail = nfree = nowned = 0;
- if ((map = (s_char *)malloc((WORLD_X * WORLD_Y) / 2)) == 0) {
+ if ((map = malloc((WORLD_X * WORLD_Y) / 2)) == 0) {
logerror("malloc failed in isok\n");
pr("Memory error. Tell the deity.\n");
return 0;
}
memset(map, 0, (WORLD_X * WORLD_Y) / 2);
ok(map, x, y);
- free((s_char *)map);
+ free(map);
if (nfree < 5)
return 0;
pr("Cap at %s; owned sectors: %d, free sectors: %d, avail: %d\n",
id = sctoff(x, y);
if (map[id])
return;
- if (!ef_read(EF_SECTOR, id, (s_char *)§))
+ if (!ef_read(EF_SECTOR, id, §))
return;
if (sect.sct_type == SCT_WATER || sect.sct_type == SCT_BSPAN)
return;
natp = getnatp(own);
snxtitem_all(&nstr, EF_LAND);
- while (nxtitem(&nstr, (s_char *)&land)) {
+ while (nxtitem(&nstr, &land)) {
if (land.lnd_own == 0) {
extend = 0;
break;
then = now - days(3);
*/
pr("\nThe details of Empire news since %s", ctime(&then));
- while (nxtitem(&nstr, (s_char *)&nws)) {
+ while (nxtitem(&nstr, &nws)) {
if (nws.nws_when < then)
continue;
if (opt_HIDDEN) {
continue;
pr("\n\t === %s ===\n", page_headings[page]);
snxtitem_rewind(&nstr);
- while (nxtitem(&nstr, (s_char *)&nws)) {
+ while (nxtitem(&nstr, &nws)) {
if (rpt[(int)nws.nws_vrb].r_newspage != page)
continue;
if (nws.nws_when < then)
if (!snxtitem(&nstr, EF_NUKE, player->argp[1]))
return RET_SYN;
- while (nxtitem(&nstr, (s_char *)&nuk)) {
+ while (nxtitem(&nstr, &nuk)) {
if (!player->god && !player->owner)
continue;
if (nuk.nuk_own == 0)
}
(void)time(&now);
snxtitem_all(&nstr, EF_TREATY);
- while (nxtitem(&nstr, (s_char *)&trty)) {
+ while (nxtitem(&nstr, &trty)) {
if (trty.trt_status == TS_FREE) {
break;
}
if (irate < 5)
return RET_FAIL;
snxtitem_all(&nstr, EF_LOAN);
- while (nxtitem(&nstr, (s_char *)&loan)) {
+ while (nxtitem(&nstr, &loan)) {
if ((loan.l_status == LS_SIGNED) && (loan.l_lonee == player->cnum)
&& (loan.l_loner == recipient)) {
pr("You already owe HIM money - how about repaying your loan?\n");
}
}
snxtitem_all(&nstr, EF_LOAN);
- while (nxtitem(&nstr, (s_char *)&loan)) {
+ while (nxtitem(&nstr, &loan)) {
if (loan.l_status == LS_FREE)
break;
}
if (!snxtitem(&nb, EF_SHIP, player->argp[1]))
return RET_SYN;
- while (!player->aborted && nxtitem(&nb, (s_char *)(&ship))) {
+ while (!player->aborted && nxtitem(&nb, (&ship))) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
if (!snxtitem(&nb, EF_SHIP, player->argp[1]))
return RET_SYN;
- while (nxtitem(&nb, (s_char *)(&ship))) {
+ while (nxtitem(&nb, (&ship))) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
if (!snxtitem(&nb, EF_SHIP, player->argp[1]))
return RET_SYN;
- while (nxtitem(&nb, (s_char *)(&ship))) {
+ while (nxtitem(&nb, (&ship))) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
return RET_FAIL;
}
if (!mapbuf)
- mapbuf =
- (s_char *)malloc((WORLD_Y * MAPWIDTH(3)) * sizeof(s_char));
+ mapbuf = malloc((WORLD_Y * MAPWIDTH(3)) * sizeof(s_char));
if (!map) {
- map = (s_char **)malloc(WORLD_Y * sizeof(s_char *));
+ map = malloc(WORLD_Y * sizeof(s_char *));
if (map && mapbuf) {
for (i = 0; i < WORLD_Y; i++)
map[i] = &mapbuf[MAPWIDTH(3) * i];
} else if (map) {
- free((s_char *)map);
+ free(map);
map = (s_char **)0;
}
}
return RET_SYN;
nships = 0;
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
if (!snxtitem(&np, EF_PLANE, player->argp[1]))
return RET_SYN;
- while (nxtitem(&np, (s_char *)&plane)) {
+ while (nxtitem(&np, &plane)) {
getsect(plane.pln_x, plane.pln_y, §);
if (sect.sct_own != player->cnum)
continue;
nplanes = 0;
natp = getnatp(player->cnum);
- while (nxtitem(&np, (s_char *)&plane)) {
+ while (nxtitem(&np, &plane)) {
if (!player->owner || plane.pln_own == 0)
continue;
nplanes++;
if (!snxtitem(&np, EF_PLANE, player->argp[1]))
return RET_SYN;
nplanes = 0;
- while (nxtitem(&np, (s_char *)&plane)) {
+ while (nxtitem(&np, &plane)) {
if (!player->owner || plane.pln_own == 0)
continue;
if (nplanes++ == 0) {
if (!power_generated) {
snxtitem_all(&ni, EF_POWER);
- if (!nxtitem(&ni, (s_char *)&pow)) {
+ if (!nxtitem(&ni, &pow)) {
pr("Power for this game has not been built yet. Type 'power new' to build it.\n");
return RET_FAIL;
}
pr(" as of %s\n sects eff civ", ctime(&pow_time));
pr(" mil shell gun pet iron dust oil pln ship unit money\n");
snxtitem_all(&ni, EF_POWER);
- while ((nxtitem(&ni, (s_char *)&pow)) && num > 0) {
+ while ((nxtitem(&ni, &pow)) && num > 0) {
if (pow.p_nation == 0 || pow.p_power <= 0.0)
continue;
if (opt_HIDDEN) {
addtopow(sect.sct_item, pow);
}
snxtitem_all(&ni, EF_LAND);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
pow = &powbuf[land.lnd_own];
pow->p_units += 1.0;
}
snxtitem_all(&ni, EF_SHIP);
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (ship.shp_own == 0)
continue;
pow = &powbuf[ship.shp_own];
pow->p_ships += 1.0;
}
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_own == 0)
continue;
pow = &powbuf[plane.pln_own];
if (!snxtitem(&np, EF_PLANE, player->argp[1]))
return RET_SYN;
nplanes = 0;
- while (nxtitem(&np, (s_char *)&plane)) {
+ while (nxtitem(&np, &plane)) {
if (!player->owner || plane.pln_own == 0)
continue;
if (plane.pln_type < 0 || plane.pln_type > pln_maxno) {
pr("Specify at least one ship\n");
return RET_SYN;
}
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (!player->owner)
continue;
if (mchr[(int)ship.shp_type].m_flags & M_SONAR)
pr("Specify at least one unit\n");
return RET_SYN;
}
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!player->owner)
continue;
if (!(lchr[(int)land.lnd_type].l_flags & L_RADAR)) {
if (!snxtitem(&np, EF_PLANE, player->argp[1]))
return RET_SYN;
- while (nxtitem(&np, (s_char *)&plane)) {
+ while (nxtitem(&np, &plane)) {
if (!player->owner || plane.pln_own == 0)
continue;
p = getstarg(player->argp[2], "New range? ", buf);
if (!snxtitem(&np, EF_LAND, player->argp[1]))
return RET_SYN;
- while (nxtitem(&np, (s_char *)&land)) {
+ while (nxtitem(&np, &land)) {
if (!player->owner || land.lnd_own == 0)
continue;
lcp = &lchr[(int)land.lnd_type];
lastdate = 0;
lastcnum = -1;
lasttype = -1;
- while (fread((s_char *)&tgm, sizeof(tgm), 1, telfp) == 1) {
+ while (fread(&tgm, sizeof(tgm), 1, telfp) == 1) {
readit = 1;
if (tgm.tel_length < 0) {
logerror("bad telegram file header in %s", mbox);
}
if (!snxtitem(&ni, EF_NATION, player->argp[3]))
return RET_SYN;
- while (nxtitem(&ni, (s_char *)&nat)) {
+ while (nxtitem(&ni, &nat)) {
#if 0
if ((nat.nat_stat & STAT_NORM) == 0) {
pr("You may not reject/accept stuff from %s\nbecause they are not a normal country.\n", nat.nat_cnam);
} else {
first = 1;
}
- while (nxtitem(&ni, (s_char *)&nat)) {
+ while (nxtitem(&ni, &nat)) {
if (!(nat.nat_stat & STAT_INUSE))
continue;
if (opt_HIDDEN) {
if (zero)
rflags = 0;
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
if (zero)
rflags = 0;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!player->owner || land.lnd_own == 0)
continue;
if (land.lnd_type < 0 || land.lnd_type > lnd_maxno) {
} else if (!snxtsct(&ns, str))
return RET_FAIL;
if (!mapbuf)
- mapbuf =
- (s_char *)malloc((WORLD_Y * MAPWIDTH(3)) * sizeof(s_char));
+ mapbuf = malloc((WORLD_Y * MAPWIDTH(3)) * sizeof(s_char));
if (!map) {
- map = (s_char **)malloc(WORLD_Y * sizeof(s_char *));
+ map = malloc(WORLD_Y * sizeof(s_char *));
if (map && mapbuf) {
for (i = 0; i < WORLD_Y; i++)
map[i] = &mapbuf[MAPWIDTH(3) * i];
} else if (map) {
- free((s_char *)map);
+ free(map);
map = (s_char **)0;
}
}
if (!buf)
- buf = (s_char *)malloc((MAPWIDTH(3) + 12) * sizeof(s_char));
+ buf = malloc((MAPWIDTH(3) + 12) * sizeof(s_char));
if (!mapbuf || !map || !buf) {
pr("Memory error, tell the deity.\n");
logerror("malloc failed in rout\n");
if (!snxtitem(&ni, EF_LAND, player->argp[1]))
return RET_SYN;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!player->owner)
continue;
if (!(lchr[(int)land.lnd_type].l_flags & L_SPY)) {
int count = 0;
struct shpstr ship;
- while (nxtitem(nstr, (s_char *)&ship)) {
+ while (nxtitem(nstr, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
struct shpstr ship;
int count = 0;
- while (nxtitem(nstr, (s_char *)&ship)) {
+ while (nxtitem(nstr, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
struct shpstr ship;
char navpath[MAX_PATH_LEN];
- while (!player->aborted && nxtitem(nstr, (s_char *)&ship)) {
+ while (!player->aborted && nxtitem(nstr, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
if (!confirm(y_or_n))
return RET_FAIL;
}
- while (nxtitem(&ni, (s_char *)&item)) {
+ while (nxtitem(&ni, &item)) {
if (!player->owner)
continue;
sect.sct_item[I_HCM] += mp->m_hcm * 2 / 3 * eff;
getsect(item.ship.shp_x, item.ship.shp_y, §2);
snxtitem_all(&ni2, EF_PLANE);
- while (nxtitem(&ni2, (s_char *)&plane)) {
+ while (nxtitem(&ni2, &plane)) {
if (plane.pln_own == 0)
continue;
if (plane.pln_ship == item.ship.shp_uid) {
plane.pln_own = sect2.sct_own;
makenotlost(EF_PLANE, plane.pln_own, plane.pln_uid,
plane.pln_x, plane.pln_y);
- putplane(plane.pln_uid, (s_char *)&plane);
+ putplane(plane.pln_uid, &plane);
}
}
snxtitem_all(&ni2, EF_LAND);
- while (nxtitem(&ni2, (s_char *)&land)) {
+ while (nxtitem(&ni2, &land)) {
if (land.lnd_own == 0)
continue;
if (land.lnd_ship == item.ship.shp_uid) {
land.lnd_own = sect2.sct_own;
makenotlost(EF_LAND, land.lnd_own, land.lnd_uid,
land.lnd_x, land.lnd_y);
- putland(land.lnd_uid, (s_char *)&land);
+ putland(land.lnd_uid, &land);
}
}
makelost(EF_SHIP, item.ship.shp_own, item.ship.shp_uid,
item.ship.shp_x, item.ship.shp_y);
item.ship.shp_own = 0;
- putship(item.ship.shp_uid, (s_char *)&item.ship);
+ putship(item.ship.shp_uid, &item.ship);
} else if (type == EF_LAND) {
eff = ((float)item.land.lnd_effic / 100.0);
lp = &lchr[(int)item.land.lnd_type];
getsect(item.land.lnd_x, item.land.lnd_y, §2);
snxtitem_all(&ni2, EF_LAND);
- while (nxtitem(&ni2, (s_char *)&land)) {
+ while (nxtitem(&ni2, &land)) {
if (land.lnd_own == 0)
continue;
if (land.lnd_land == item.land.lnd_uid) {
land.lnd_own = sect2.sct_own;
makenotlost(EF_LAND, land.lnd_own, land.lnd_uid,
land.lnd_x, land.lnd_y);
- putland(land.lnd_uid, (s_char *)&land);
+ putland(land.lnd_uid, &land);
}
}
snxtitem_all(&ni2, EF_PLANE);
- while (nxtitem(&ni2, (s_char *)&plane)) {
+ while (nxtitem(&ni2, &plane)) {
if (plane.pln_own == 0)
continue;
if (plane.pln_land == item.land.lnd_uid) {
plane.pln_own = sect2.sct_own;
makenotlost(EF_PLANE, plane.pln_own, plane.pln_uid,
plane.pln_x, plane.pln_y);
- putplane(plane.pln_uid, (s_char *)&plane);
+ putplane(plane.pln_uid, &plane);
}
}
makelost(EF_LAND, item.land.lnd_own, item.land.lnd_uid,
item.land.lnd_x, item.land.lnd_y);
item.land.lnd_own = 0;
- putland(item.land.lnd_uid, (s_char *)&item.land);
+ putland(item.land.lnd_uid, &item.land);
} else {
eff = ((float)item.land.lnd_effic / 100.0);
pp = &plchr[(int)item.plane.pln_type];
makelost(EF_PLANE, item.plane.pln_own, item.plane.pln_uid,
item.plane.pln_x, item.plane.pln_y);
item.plane.pln_own = 0;
- putplane(item.plane.pln_uid, (s_char *)&item.plane);
+ putplane(item.plane.pln_uid, &item.plane);
}
pr(" scrapped in %s\n",
xyas(sect.sct_x, sect.sct_y, player->cnum));
if (!confirm(y_or_n))
return RET_FAIL;
}
- while (nxtitem(&ni, (s_char *)&item)) {
+ while (nxtitem(&ni, &item)) {
if (!player->owner)
continue;
if (opt_MARKET) {
makelost(EF_PLANE, item.plane.pln_own, item.plane.pln_uid,
item.plane.pln_x, item.plane.pln_y);
item.plane.pln_own = 0;
- putplane(item.plane.pln_uid, (s_char *)&item.plane);
+ putplane(item.plane.pln_uid, &item.plane);
}
pr(" scuttled in %s\n",
xyas(item.ship.shp_x, item.ship.shp_y, player->cnum));
getsect(sp->shp_x, sp->shp_y, §);
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_own == 0)
continue;
if (plane.pln_ship == sp->shp_uid) {
plane.pln_uid, sp->shp_uid,
xyas(plane.pln_x, plane.pln_y, plane.pln_own));
}
- putplane(plane.pln_uid, (s_char *)&plane);
+ putplane(plane.pln_uid, &plane);
}
}
snxtitem_all(&ni, EF_LAND);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
if (land.lnd_ship == sp->shp_uid) {
"Land unit %d transferred off ship %d to %s\n",
land.lnd_uid, sp->shp_uid,
xyas(land.lnd_x, land.lnd_y, land.lnd_own));
- putland(land.lnd_uid, (s_char *)&land);
+ putland(land.lnd_uid, &land);
} else
scuttle_land(&land);
}
getsect(lp->lnd_x, lp->lnd_y, §);
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_own == 0)
continue;
if (plane.pln_land == lp->lnd_uid) {
plane.pln_uid, lp->lnd_uid,
xyas(plane.pln_x, plane.pln_y, plane.pln_own));
}
- putplane(plane.pln_uid, (s_char *)&plane);
+ putplane(plane.pln_uid, &plane);
}
}
snxtitem_all(&ni, EF_LAND);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
if (land.lnd_land == lp->lnd_uid) {
"Land unit %d transferred off unit %d to %s\n",
land.lnd_uid, lp->lnd_uid,
xyas(land.lnd_x, land.lnd_y, land.lnd_own));
- putland(land.lnd_uid, (s_char *)&land);
+ putland(land.lnd_uid, &land);
} else
scuttle_land(&land);
}
nships = 0;
np = getnatp(player->cnum);
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
} else if (!snxtsct(&ns, str))
return RET_SYN;
if (!mapbuf)
- mapbuf =
- (s_char *)malloc((WORLD_Y * MAPWIDTH(1)) * sizeof(s_char));
+ mapbuf = malloc((WORLD_Y * MAPWIDTH(1)) * sizeof(s_char));
if (!map) {
- map = (s_char **)malloc(WORLD_Y * sizeof(s_char *));
+ map = malloc(WORLD_Y * sizeof(s_char *));
if (map && mapbuf) {
for (i = 0; i < WORLD_Y; i++)
map[i] = &mapbuf[MAPWIDTH(1) * i];
} else if (map) {
- free((s_char *)map);
+ free(map);
map = (s_char **)0;
}
}
type = EF_LAND;
if (!snxtitem(&ni, type, player->argp[2]))
return RET_SYN;
- while (nxtitem(&ni, (char *)&item)) {
+ while (nxtitem(&ni, &item)) {
if (!player->owner && !player->god)
continue;
getsect(item.gen.trg_x, item.gen.trg_y, §);
foundslot = -1;
freeslot = -1;
snxtitem_all(&ni_trade, EF_TRADE);
- while (nxtitem(&ni_trade, (char *)&trade)) {
+ while (nxtitem(&ni_trade, &trade)) {
if (trade.trd_owner == 0)
freeslot = ni_trade.cur;
if (trade.trd_unitid == ni.cur && trade.trd_type == type) {
return RET_SYN;
nships = 0;
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
mil = sect.sct_item[I_MILIT];
nsec = 0;
snxtitem_xy(&ni, EF_LAND, sect.sct_x, sect.sct_y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
mil += total_mil(&land);
if (lchr[(int)land.lnd_type].l_flags & L_SECURITY) {
return RET_SYN;
for (i = 0; i < TSIZE; i++)
list[i] = 0;
- skyp = (struct sky *)malloc(sizeof(*skyp));
+ skyp = malloc(sizeof(*skyp));
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&skyp->s_sat)) {
+ while (nxtitem(&ni, &skyp->s_sat)) {
if (!skyp->s_sat.pln_own)
continue;
if (!(skyp->s_sat.pln_flags & PLN_LAUNCHED))
skyp->s_spotted = 0;
skyp->s_next = list[n];
list[n] = skyp;
- skyp = (struct sky *)malloc(sizeof(*skyp));
+ skyp = malloc(sizeof(*skyp));
nsat++;
}
/* get that last one! */
- free((s_char *)skyp);
+ free(skyp);
pr("- = [ Skywatch report for %s ] = -\n", cname(player->cnum));
pr(" %18s%20s %s\n", "Country", "Satellite", "Location");
tech = tfact(player->cnum, 1.0);
for (i = 0; i < TSIZE; i++) {
while (NULL != (skyp = list[i])) {
list[i] = skyp->s_next;
- free((s_char *)skyp);
+ free(skyp);
}
}
return RET_OK;
do {
/* we delete it, we free it. */
if (todelete) {
- free((s_char *)todelete);
+ free(todelete);
todelete = 0;
}
if (skyp->s_sat.pln_x != x || skyp->s_sat.pln_y != y) {
} while (NULL != (skyp = skyp->s_next));
/* check that last one! */
if (todelete)
- free((s_char *)todelete);
+ free(todelete);
return (nsat);
}
if (!snxtitem(&ni, EF_SHIP, player->argp[1]))
return RET_SYN;
if (!radbuf)
- radbuf =
- (s_char *)malloc((WORLD_Y * (WORLD_X + 1)) * sizeof(s_char));
+ radbuf = malloc((WORLD_Y * (WORLD_X + 1)) * sizeof(s_char));
if (!visbuf)
- visbuf =
- (s_char *)malloc((WORLD_Y * (WORLD_X + 1)) * sizeof(s_char));
+ visbuf = malloc((WORLD_Y * (WORLD_X + 1)) * sizeof(s_char));
if (!rad) {
- rad = (s_char **)malloc(WORLD_Y * sizeof(s_char *));
+ rad = malloc(WORLD_Y * sizeof(s_char *));
if (rad && radbuf) {
for (x = 0; x < WORLD_Y; x++) {
rad[x] = &radbuf[(WORLD_X + 1) * x];
}
} else if (rad) {
- free((s_char *)rad);
+ free(rad);
rad = (s_char **)0;
}
}
if (!vis) {
- vis = (s_char **)malloc(WORLD_Y * sizeof(s_char *));
+ vis = malloc(WORLD_Y * sizeof(s_char *));
if (vis && visbuf) {
for (x = 0; x < WORLD_Y; x++) {
vis[x] = &visbuf[(WORLD_X + 1) * x];
}
} else if (vis) {
- free((s_char *)vis);
+ free(vis);
vis = (s_char **)0;
}
}
logerror("malloc failed in sona\n");
return RET_FAIL;
}
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (!player->owner)
continue;
mcp = &mchr[(int)ship.shp_type];
* set up all the goodies we need later
* 6 = neighbors, 2 = x,y
*/
- table = (coord *)malloc((nsects + 1) * 6 * 2 * sizeof(coord));
+ table = malloc((nsects + 1) * 6 * 2 * sizeof(coord));
memset(table, 0, (nsects + 1) * 6 * 2 * sizeof(coord));
pr("SPY report\n");
prdate();
nrecon = 0;
nunits = 0;
snxtitem_xy(&ni, EF_LAND, from.sct_x, from.sct_y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
nunits++;
if (lchr[(int)land.lnd_type].l_flags & L_RECON)
nrecon++;
if (changed)
writemap(player->cnum);
player->btused += btucost;
- free((s_char *)table);
+ free(table);
return RET_OK;
}
int n = 0;
snxtitem_xy(&ni, EF_LAND, x, y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if ((land.lnd_own == player->cnum) || (land.lnd_own == 0))
continue;
if (land.lnd_ship >= 0 || land.lnd_land >= 0)
s_char report[128];
snxtitem_xy(&ni, EF_LAND, x, y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == player->cnum || land.lnd_own == 0)
continue;
if (land.lnd_ship >= 0 || land.lnd_land >= 0)
s_char report[128];
snxtitem_xy(&ni, EF_PLANE, x, y);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_own == player->cnum || plane.pln_own == 0)
continue;
if (plane.pln_ship >= 0 || plane.pln_land >= 0)
return RET_SYN;
nships = 0;
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (!player->owner || ship.shp_own == 0)
continue;
if (ship.shp_type < 0 || ship.shp_type > shp_maxno) {
struct lndstr land;
snxtitem_xy(&ni, EF_LAND, def->x, def->y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
if (land.lnd_own != def->own)
if (!snxtitem(&ni, EF_SHIP, range))
return;
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (!player->owner || !ship.shp_own)
continue;
if (!snxtitem(&ni, EF_LAND, range))
return;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!player->owner || !land.lnd_own)
continue;
return RET_SYN;
nunits = 0;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!player->owner || land.lnd_own == 0)
continue;
nunits++;
for (i = 0; i < WORLD_Y; i++)
map[i] = &mapbuf[MAPWIDTH(1) * i];
} else if (map) {
- free((s_char *)map);
+ free(map);
map = (s_char **)0;
}
}
getstarg(player->argp[2], "Tender(s)? ", buf)))
return RET_SYN;
- while (nxtitem(&tenders, (s_char *)&tender)) {
+ while (nxtitem(&tenders, &tender)) {
if (!player->owner)
continue;
if (type == EF_LAND) {
if (!snxtitem(&lni, EF_LAND, units))
return RET_SYN;
- while (nxtitem(&lni, (s_char *)&land)) {
+ while (nxtitem(&lni, &land)) {
if (!player->owner)
continue;
if (land.lnd_ship != tenderp->shp_uid) {
count_units(tenderp);
putship(tenderp->shp_uid, tenderp);
snxtitem_xy(&pni, EF_PLANE, land.lnd_x, land.lnd_y);
- while (nxtitem(&pni, (s_char *)&plane)) {
+ while (nxtitem(&pni, &plane)) {
if (plane.pln_flags & PLN_LAUNCHED)
continue;
if (plane.pln_land != land.lnd_uid)
return RET_SYN;
if (!snxtitem(&nbst, EF_SHIP, sav))
return RET_SYN;
- while (nxtitem(&nbst, (s_char *)&sub)) {
+ while (nxtitem(&nbst, &sub)) {
if (sub.shp_own != player->cnum)
continue;
if ((mchr[(int)sub.shp_type].m_flags & M_TORP) == 0)
}
pr("%d ships are eligible to torp\n", ntorping);
snxtitem(&nbst, EF_SHIP, sav);
- while (nxtitem(&nbst, (s_char *)&sub)) {
+ while (nxtitem(&nbst, &sub)) {
if (!sub.shp_own)
continue;
if (sub.shp_own != player->cnum) {
pr(" --- -------- -- --------- ----- -------------------------\n");
snxtitem_all(&ni, EF_TRADE);
- while (nxtitem(&ni, (char *)&trade)) {
+ while (nxtitem(&ni, &trade)) {
if (trade.trd_owner == 0)
continue;
if (!trade_getitem(&trade, &tg)) {
tg.lnd.lnd_mission = 0;
/* Drop any land units this unit was carrying */
snxtitem_xy(&ni, EF_LAND, tg.lnd.lnd_x, tg.lnd.lnd_y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_land != tg.lnd.lnd_uid)
continue;
land.lnd_land = -1;
}
/* Drop any planes this unit was carrying */
snxtitem_xy(&ni, EF_PLANE, tg.lnd.lnd_x, tg.lnd.lnd_y);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_flags & PLN_LAUNCHED)
continue;
if (plane.pln_land != land.lnd_uid)
logerror("Bad trade type %d in trade\n", trade.trd_type);
break;
}
- if (!ef_write(trade.trd_type, saveid, (char *)&tg)) {
+ if (!ef_write(trade.trd_type, saveid, &tg)) {
logerror("Couldn't write unit to disk; seek help.\n");
continue;
}
* No one could seriously want to move planes in parallel from
* several sectors!
*/
- while (nxtitem(&nstr, (s_char *)&plane)) {
+ while (nxtitem(&nstr, &plane)) {
if (!player->owner)
continue;
type = plane.pln_type;
dstx = endsect.sct_x;
dsty = endsect.sct_y;
snxtitem_rewind(&nstr);
- while (nxtitem(&nstr, (s_char *)&plane)) {
+ while (nxtitem(&nstr, &plane)) {
if (!player->owner)
continue;
if (dam)
return RET_SYN;
pr("\t... %s Treaty Report ...\n", cname(player->cnum));
ntreaty = 0;
- while (nxtitem(&nstr, (s_char *)&treaty)) {
+ while (nxtitem(&nstr, &treaty)) {
if (distrea(nstr.cur, &treaty) > 0)
ntreaty++;
}
cash = natp->nat_money;
tlev = (int)natp->nat_level[NAT_TLEV];
n = 0;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
getsect(land.lnd_x, land.lnd_y, §);
cash = natp->nat_money;
tlev = (int)natp->nat_level[NAT_TLEV];
n = 0;
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (ship.shp_own == 0)
continue;
getsect(ship.shp_x, ship.shp_y, §);
cash = natp->nat_money;
tlev = (int)natp->nat_level[NAT_TLEV];
n = 0;
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_own == 0)
continue;
getsect(plane.pln_x, plane.pln_y, §);
return RET_FAIL;
}
nunits = 0;
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!player->owner || land.lnd_own == 0)
continue;
if (land.lnd_type < 0 || land.lnd_type > lnd_maxno) {
unsigned int routelen;
if (!mapbuf)
- mapbuf = (unsigned int *)malloc((WORLD_X * WORLD_Y) *
+ mapbuf = malloc((WORLD_X * WORLD_Y) *
sizeof(unsigned int));
if (!mapbuf)
return ((s_char *)0);
if (!mapindex) {
- mapindex =
- (unsigned int **)malloc(WORLD_X * sizeof(unsigned int *));
+ mapindex = malloc(WORLD_X * sizeof(unsigned int *));
if (mapindex) {
/* Setup the map pointers */
for (i = 0; i < WORLD_X; i++)
if (x == ex && y == ey) {
bpath[0] = 'h';
bpath[1] = 0;
- return ((s_char *)bpath);
+ return bpath;
}
if (!valid(x, y) || !valid(ex, ey))
if (++routelen == MAXROUTE) {
bpath[0] = '?';
bpath[1] = 0;
- return ((s_char *)bpath);
+ return bpath;
}
markedsectors = 0;
for (scanx = minx; scanx <= maxx; scanx++) {
tx = XNORM(tx);
ty = YNORM(ty);
}
- return ((s_char *)bpath);
+ return bpath;
}
}
}
/* Sink all the units */
snxtitem_xy(&ni, EF_LAND, sp->sct_x, sp->sct_y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
if (land.lnd_x != sp->sct_x || land.lnd_y != sp->sct_y)
}
/* Sink all the planes */
snxtitem_xy(&ni, EF_PLANE, sp->sct_x, sp->sct_y);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_own == 0)
continue;
if (plane.pln_x != sp->sct_x || plane.pln_y != sp->sct_y)
int n;
struct lndstr land;
- for (n = 0; ef_read(EF_LAND, n, (s_char *)&land); n++) {
+ for (n = 0; ef_read(EF_LAND, n, &land); n++) {
if (land.lnd_x != x || land.lnd_y != y)
continue;
if (lp) {
struct lndstr land;
snxtitem_xy(&ni, EF_LAND, x, y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own != cn)
continue;
if (land.lnd_mobil > 0)
struct lndstr land;
snxtitem_xy(&ni, EF_LAND, x, y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own != cn && getrel(getnatp(land.lnd_own), cn) != ALLIED)
continue;
if (lchr[(int)land.lnd_type].l_flags & L_ENGINEER)
static s_char **wmap = (s_char **)0;
if (!wmapbuf)
- wmapbuf =
- (s_char *)malloc((WORLD_Y * MAPWIDTH(1)) * sizeof(s_char));
+ wmapbuf = malloc((WORLD_Y * MAPWIDTH(1)) * sizeof(s_char));
if (!wmap) {
- wmap = (s_char **)malloc(WORLD_Y * sizeof(s_char *));
+ wmap = malloc(WORLD_Y * sizeof(s_char *));
if (wmap && wmapbuf) {
for (i = 0; i < WORLD_Y; i++)
wmap[i] = &wmapbuf[MAPWIDTH(1) * i];
} else if (wmap) {
- free((s_char *)wmap);
+ free(wmap);
wmap = (s_char **)0;
}
}
if (!bitmap)
- bitmap = (u_char *)malloc((WORLD_X * WORLD_Y) / 8);
+ bitmap = malloc((WORLD_X * WORLD_Y) / 8);
if (!wmapbuf || !wmap || !bitmap) {
pr("Memory error, tell the deity.\n");
logerror("malloc failed in draw_map\n");
ep = &empfile[EF_SECTOR];
- bp = (struct bestp *)malloc(sizeof(*bp));
+ bp = malloc(sizeof(*bp));
memset(bp, 0, sizeof(*bp));
bp->adp = as_init(BP_NEIGHBORS, BP_ASHASHSIZE, bp_coord_hash,
bp_neighbors, bp_lbcost, bp_realcost,
return NULL;
if (neighsects == (struct sctstr **)0)
- neighsects = (struct sctstr **)calloc(1, (sizeof(struct sctstr *) *
- ((WORLD_X * WORLD_Y) /
- 2) * 6));
+ neighsects = calloc(((WORLD_X * WORLD_Y) / 2) * 6,
+ sizeof(struct sctstr *));
return (s_char *)bp;
}
return eff;
snxtitem_xy(&ni, EF_LAND, sp->sct_x, sp->sct_y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!land.lnd_own)
continue;
landdamage(&land, dam);
if (dam <= 0)
return eff;
snxtitem_xy(&ni, EF_PLANE, sp->sct_x, sp->sct_y);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (!plane.pln_own)
continue;
if (plane.pln_flags & PLN_LAUNCHED)
SetConsoleCtrlHandler((PHANDLER_ROUTINE)loc_Exit_Handler, TRUE);
/* Create the global Thread context. */
- pThread = (loc_Thread_t *)malloc(sizeof(*pThread));
+ pThread = malloc(sizeof(*pThread));
if (!pThread) {
logerror("not enough memory to create main thread.");
return 0;
loc_debug("creating new thread %s:%s", name, desc);
- pThread = (loc_Thread_t *)malloc(sizeof(*pThread));
+ pThread = malloc(sizeof(*pThread));
if (!pThread) {
logerror("not enough memory to create thread: %s (%s)", name,
desc);
{
loc_Sem_t *pSem;
- pSem = (loc_Sem_t *)malloc(sizeof(*pSem));
+ pSem = malloc(sizeof(*pSem));
if (!pSem) {
logerror("out of memory at %s:%d", __FILE__, __LINE__);
return NULL;
sigaction(SIGALRM, &act, NULL);
udata = ctx_ptr;
- ctx = (empth_t *)malloc(sizeof(empth_t));
+ ctx = malloc(sizeof(empth_t));
if (!ctx) {
logerror("pthread init failed: not enough memory");
exit(1);
empth_status("creating new thread %s:%s", name, desc);
- ctx = (empth_t *)malloc(sizeof(empth_t));
+ ctx = malloc(sizeof(empth_t));
if (!ctx) {
logerror("not enough memoty to create thread: %s (%s)", name,
desc);
#else
ctx_ptr = (empth_t *)pthread_getspecific(ctx_key);
#endif
- *udata = (char *)ctx_ptr->ud;
+ *udata = ctx_ptr->ud;
if (ctx_ptr->state == EMPTH_KILLED) {
empth_status("i am dead");
empth_exit();
{
empth_sem_t *sm;
- sm = (empth_sem_t *)malloc(sizeof(empth_sem_t));
+ sm = malloc(sizeof(empth_sem_t));
if (!sm) {
logerror("out of memory at %s:%d", __FILE__, __LINE__);
return NULL;
flags = flags & (IO_READ | IO_WRITE | IO_NBLOCK | IO_NEWSOCK);
if ((flags & (IO_READ | IO_WRITE)) == 0)
return NULL;
- iop = (struct iop *)malloc(sizeof(struct iop));
+ iop = malloc(sizeof(struct iop));
if (!iop)
return NULL;
iop->fd = fd;
#else
closesocket(iop->fd);
#endif
- free((s_char *)iop);
+ free(iop);
}
int
{
struct ioqueue *ioq;
- ioq = (struct ioqueue *)malloc(sizeof(struct ioqueue));
+ ioq = malloc(sizeof(struct ioqueue));
emp_initque(&ioq->list.queue);
ioq->list.nbytes = 0;
ioq->list.offset = 0;
/* ioq_drain doesn't work under aix or NeXT... dunno why --ts */
ioq_drain(ioq);
#endif /* aix */
- free((s_char *)ioq);
+ free(ioq);
}
void
len = cc > ioq->bufsize ? cc : ioq->bufsize;
ptr = malloc(len);
memcpy(ptr, buf, cc);
- io = (struct io *)malloc(sizeof(struct io));
+ io = malloc(sizeof(struct io));
io->nbytes = cc;
io->size = len;
io->offset = 0;
{
char *y;
- y = (char *)malloc((sizeof(char) * strlen(x)) + 1);
+ y = malloc((sizeof(char) * strlen(x)) + 1);
strcpy(y, x);
return y;
}
int endpoint;
if (initcontext == NULL) {
- initcontext = (struct lwpProc *)malloc(sizeof(struct lwpProc));
+ initcontext = malloc(sizeof(struct lwpProc));
tempcontext = &holder;
if (!setjmp(tempcontext->context))
startcontext();
#endif /* UCONTEXT */
unsigned long stackp;
- if (!(newp = (struct lwpProc *)malloc(sizeof(struct lwpProc))))
+ if (!(newp = malloc(sizeof(struct lwpProc))))
return (0);
if (flags & LWP_STACKCHECK) {
/* Add a 1K buffer on each side of the stack */
}
size += LWP_EXTRASTACK;
size += sizeof(stkalign_t);
- if (!(s = (int *)malloc(size)))
+ if (!(s = malloc(size)))
return (0);
newp->flags = flags;
newp->name = strdup(name);
proc->entry = 0;
proc->ud = 0;
proc->argv = 0;
- free((char *)proc->sbtm);
+ free(proc->sbtm);
free(proc->name);
free(proc->desc);
proc->name = 0;
proc->sbtm = 0;
proc->lowmark = 0;
proc->himark = 0;
- free((char *)proc);
+ free(proc);
}
/*
/* *LwpContextPtr = 0; */
if (!(LwpCurrent = calloc(1, sizeof(struct lwpProc))))
return (0);
- if (!(stack = (int *)malloc(64)))
+ if (!(stack = malloc(64)))
return (0);
if (LWP_MAX_PRIO <= pri)
pri = LWP_MAX_PRIO - 1;
#endif
FD_ZERO(&LwpSelect.readmask);
FD_ZERO(&LwpSelect.writemask);
- LwpSelect.wait = (struct lwpProc **)
- calloc(LwpSelect.nfile, sizeof(char *));
+ LwpSelect.wait = calloc(LwpSelect.nfile, sizeof(char *));
LwpSelect.delayq.head = 0;
LwpSelect.delayq.tail = 0;
LwpSelect.proc = proc;
{
struct lwpSem *new;
- if (!(new = (struct lwpSem *)malloc(sizeof(struct lwpSem))))
+ if (!(new = malloc(sizeof(struct lwpSem))))
return (0);
new->name = strdup(name);
new->count = count;
}
val = 1;
#if !(defined(__linux__) && defined(__alpha__))
- if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&val, sizeof(val))
- < 0) {
+ if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0) {
logerror("inet socket setsockopt SO_REUSEADDR (%d)", errno);
exit(1);
}
struct hostent *hostp;
#endif
- lp = (struct player *)malloc(sizeof(struct player));
+ lp = malloc(sizeof(struct player));
if (!lp)
return NULL;
memset(lp, 0, sizeof(struct player));
strcpy(lp->hostaddr, inet_ntoa(sin->sin_addr));
#ifdef RESOLVE_IPADDRESS
if (NULL !=
- (hostp =
- gethostbyaddr((char *)&sin->sin_addr, sizeof(sin->sin_addr),
- AF_INET)))
+ (hostp = gethostbyaddr(&sin->sin_addr, sizeof(sin->sin_addr),
+ AF_INET)))
strcpy(lp->hostname, hostp->h_name);
#endif /* RESOLVE_IPADDRESS */
lp->cnum = 255;
io_close(lp->iop);
lp->iop = 0;
}
- free((s_char *)lp);
+ free(lp);
/* XXX may need to free bigmap here */
return back;
}
logerror("new socket accept");
continue;
}
- (void)setsockopt(ns, SOL_SOCKET, SO_KEEPALIVE,
- (char *)&set, sizeof(set));
+ (void)setsockopt(ns, SOL_SOCKET, SO_KEEPALIVE, &set, sizeof(set));
np = player_new(ns, &sin);
if (!np) {
logerror("can't create player for fd %d", ns);
}
snxtitem_all(&ni, EF_NATION);
- while (nxtitem(&ni, (s_char *)&nat)) {
+ while (nxtitem(&ni, &nat)) {
if (nat.nat_stat != (STAT_INUSE | STAT_SANCT))
continue;
if (first) {
/* Go figure out if there are ships in this sector, and who's they are */
memset(nats, 0, sizeof(nats));
snxtitem_xy(&ni, EF_SHIP, x, y);
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (mchr[(int)ship.shp_type].m_flags & M_SUB)
continue;
nats[ship.shp_own]++;
/* Go figure out if there are units in this sector, and who's they are */
memset(lnats, 0, sizeof(lnats));
snxtitem_xy(&ni, EF_LAND, x, y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_ship >= 0 || land.lnd_land >= 0)
continue;
lnats[land.lnd_own]++;
if (dplp->plane.pln_range <
mapdist(x, y, dplp->plane.pln_x, dplp->plane.pln_y)) {
emp_remque(dqp);
- free((s_char *)dqp);
+ free(dqp);
continue;
}
if (mission_pln_equip(dplp, 0, P_F, 0) < 0) {
emp_remque(dqp);
- free((s_char *)dqp);
+ free(dqp);
continue;
}
if (first) {
if (!(dplp->pcp->pl_flags & P_M))
continue;
emp_remque(dqp);
- free((s_char *)dqp);
+ free(dqp);
continue;
}
}
continue;
if (mission_pln_equip(plp, 0, P_F, 0) < 0) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
/* got one; delete from def_list, add to int_list */
pp->pln_own = 0;
putplane(pp->pln_uid, pp);
emp_remque(&plp->queue);
- free((s_char *)plp);
+ free(plp);
} else if (disp == 2) {
putplane(pp->pln_uid, pp);
emp_remque(&plp->queue);
- free((s_char *)plp);
+ free(plp);
} else
putplane(pp->pln_uid, pp);
strcpy(mesg, dmess);
memset(nats, 0, sizeof(nats));
guns = 0;
snxtitem_xy(&ni, EF_SHIP, x, y);
- while (!QEMPTY(list) && nxtitem(&ni, (s_char *)&ship)) {
+ while (!QEMPTY(list) && nxtitem(&ni, &ship)) {
if (ship.shp_own == 0 || ship.shp_own == plane_owner)
continue;
if (guns >= 14)
memset(nats, 0, sizeof(nats));
guns = 0;
snxtitem_xy(&ni, EF_LAND, x, y);
- while (!QEMPTY(list) && nxtitem(&ni, (s_char *)&land)) {
+ while (!QEMPTY(list) && nxtitem(&ni, &land)) {
if (land.lnd_own == 0 || land.lnd_own == plane_owner)
continue;
if (guns >= 14)
emp_initque(list);
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_own != own)
continue;
pcp = &plchr[(int)plane.pln_type];
if (ac_isflying(&plane, d))
continue;
/* got one! */
- ip = (struct plist *)malloc(sizeof(*ip));
+ ip = malloc(sizeof(*ip));
ip->state = P_OK;
ip->bombs = 0;
ip->misc = 0;
maxland = def->shp_mcp->m_nland;
snxtitem_xy(&ni, EF_LAND, off->x, off->y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own != player->cnum)
continue;
if (land.lnd_effic < LAND_MINEFF)
land_answer[(int)land.lnd_army] != 'Y')
continue;
}
- if (!(llp = (struct llist *)malloc(sizeof(struct llist)))) {
+ if (!(llp = malloc(sizeof(struct llist)))) {
logerror("Malloc failed in attack!\n");
abort_attack();
return;
lists. Spies try to hide, trains get trapped and can be boarded. */
snxtitem_xy(&ni, EF_LAND, def->x, def->y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!land.lnd_own)
continue;
if (land.lnd_own != def->own)
"Scouts report defending unit:");
continue;
}
- if (!(llp = (struct llist *)malloc(sizeof(struct llist)))) {
+ if (!(llp = malloc(sizeof(struct llist)))) {
logerror("Malloc failed in attack!\n");
abort_attack();
return 0;
putland(llp->land.lnd_uid, &llp->land);
if (llp->land.lnd_own != player->cnum) {
emp_remque((struct emp_qelem *)llp);
- free((s_char *)llp);
+ free(llp);
} else
get_land(A_ATTACK, 0, llp->land.lnd_uid, llp, 0);
}
else
dtotal = 0;
snxtitem_all(&ni, EF_LAND);
- while (nxtitem(&ni, (s_char *)&land) &&
+ while (nxtitem(&ni, &land) &&
(dtotal + new_land * eff < (int)(1.2 * (float)ototal))) {
if (!land.lnd_own)
continue;
if (sp->sct_oldown != sp->sct_own) {
snxtitem_xy(&ni, EF_LAND, sp->sct_x, sp->sct_y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == sp->sct_own)
tot_mil += total_mil(&land);
}
first = 1;
ships = 0;
snxtitem_xy(&ni, EF_SHIP, x, y);
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (player->owner)
continue;
if (ship.shp_effic < SHIP_MINEFF || ship.shp_own == 0)
first = 1;
ships = 0;
snxtitem_xy(&ni, EF_SHIP, x, y);
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (ship.shp_effic < SHIP_MINEFF || ship.shp_own == 0)
continue;
if (ship.shp_own != own
first = 1;
units = 0;
snxtitem_xy(&ni, EF_LAND, x, y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_effic < LAND_MINEFF || land.lnd_own == 0)
continue;
/* Can't bomb units on ships or other units */
planes = 0;
first = 1;
snxtitem_xy(&ni, EF_PLANE, x, y);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_effic < PLANE_MINEFF || plane.pln_own == 0)
continue;
if (plane.pln_flags & PLN_LAUNCHED)
first = 1;
ships = 0;
snxtitem_xy(&ni, EF_SHIP, x, y);
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (player->owner)
continue;
if (ship.shp_effic < SHIP_MINEFF || ship.shp_own == 0)
ships = 0;
snxtitem_xy(&ni, EF_SHIP, x, y);
- while (nxtitem(&ni, (s_char *)&ship)) {
+ while (nxtitem(&ni, &ship)) {
if (ship.shp_effic < SHIP_MINEFF || ship.shp_own == 0)
continue;
mp = &mchr[(int)ship.shp_type];
lnd_print(llp, s);
putland(llp->land.lnd_uid, &llp->land);
emp_remque((struct emp_qelem *)llp);
- free((s_char *)llp);
+ free(llp);
}
int
if (llp->land.lnd_effic < LAND_MINEFF) {
sprintf(buf, "dies %s %s!",
- combat_mode ? att_mode[combat_mode] : (s_char *)
- "defending", xyas(llp->land.lnd_x, llp->land.lnd_y,
- llp->land.lnd_own));
+ combat_mode ? att_mode[combat_mode] : "defending",
+ xyas(llp->land.lnd_x, llp->land.lnd_y, llp->land.lnd_own));
lnd_delete(llp, buf);
/* Since we killed the unit, we killed all the mil on it */
return taken;
struct lndstr land;
snxtitem_all(&ni, EF_LAND);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (!land.lnd_own)
continue;
if (land.lnd_x != sp->sct_x || land.lnd_y != sp->sct_y)
return;
snxtitem_xy(&ni, EF_LAND, sp->shp_x, sp->shp_y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
if (land.lnd_ship == sp->shp_uid)
return;
snxtitem_xy(&ni, EF_LAND, lp->lnd_x, lp->lnd_y);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_own == 0)
continue;
if (land.lnd_land == lp->lnd_uid)
struct llist *llp;
emp_initque(list);
- while (nxtitem(ni, (s_char *)&land)) {
+ while (nxtitem(ni, &land)) {
if (!player->owner)
continue;
if (opt_MARKET) {
land.lnd_harden = 0;
memset(land.lnd_rpath, 0, sizeof(land.lnd_rpath));
putland(land.lnd_uid, &land);
- llp = (struct llist *)malloc(sizeof(struct llist));
+ llp = malloc(sizeof(struct llist));
llp->lcp = lcp;
llp->land = land;
llp->mobil = (double)land.lnd_mobil;
mpr(actor, "%s was disbanded at %s\n",
prland(&land), xyas(land.lnd_x, land.lnd_y, land.lnd_own));
emp_remque((struct emp_qelem *)llp);
- free((s_char *)llp);
+ free(llp);
continue;
}
if (land.lnd_ship >= 0) {
putland(llp->land.lnd_uid, &llp->land);
newqp = qp->q_back;
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
qp = newqp;
}
}
lnd_hit_mine(&llp->land, llp->lcp);
sect.sct_mines--;
putsect(§);
- putland(llp->land.lnd_uid, (s_char *)&llp->land);
+ putland(llp->land.lnd_uid, &llp->land);
if (!llp->land.lnd_own) {
stopping = 1;
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
}
}
}
llp->land.lnd_mobil = llp->mobil;
putland(llp->land.lnd_uid, &llp->land);
emp_remque((struct emp_qelem *)llp);
- free((s_char *)llp);
+ free(llp);
}
static int
putland(llp->land.lnd_uid, &llp->land);
if (!llp->land.lnd_own) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
}
}
return dam;
double range, range2;
snxtitem_all(&ni, EF_LAND);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_frg == 0)
continue;
if ((land.lnd_x == x) && (land.lnd_y == y))
}
getsect(lp->lnd_x, lp->lnd_y, §);
if (lchr[(int)lp->lnd_type].l_flags & L_TRAIN)
- cp = (s_char *)BestLandPath(buf, §, &d_sect, &dummy, MOB_RAIL);
+ cp = BestLandPath(buf, §, &d_sect, &dummy, MOB_RAIL);
else
- cp = (s_char *)BestLandPath(buf, §, &d_sect, &dummy, MOB_ROAD);
+ cp = BestLandPath(buf, §, &d_sect, &dummy, MOB_ROAD);
if (!cp) {
pr("No owned path from %s to %s!\n",
xyas(lp->lnd_x, lp->lnd_y, player->cnum),
/*
size = max(sizeof(struct shpstr),sizeof(struct lndstr));
size = max(size,sizeof(struct plnstr));
- block = (s_char *)malloc(size);
+ block = malloc(size);
*/
size = sizeof(u_block);
block = (s_char *)&u_block;
if (opt_SLOW_WAR) {
if (mission != MI_AIR_DEFENSE) {
- getsect(x, y, (s_char *)§);
+ getsect(x, y, §);
if (getrel(getnatp(gp->own), sect.sct_own) > AT_WAR) {
/*
}
}
- glp = (struct genlist *)malloc(sizeof(struct genlist));
+ glp = malloc(sizeof(struct genlist));
memset(glp, 0, sizeof(struct genlist));
glp->x = gp->x;
glp->y = gp->y;
glp->cp = (s_char *)&plchr[(int)gp->type];
break;
}
- glp->thing = (s_char *)malloc(size);
+ glp->thing = malloc(size);
memcpy(glp->thing, block, size);
emp_insque(&glp->queue, &mi[gp->own].queue);
}
int dist;
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_own != cn)
continue;
if (dist > ((int)((float)plane.pln_range / 2.0)))
continue;
- plp = (struct plist *)malloc(sizeof(struct plist));
+ plp = malloc(sizeof(struct plist));
memset(plp, 0, sizeof(struct plist));
plp->pcp = &plchr[(int)plane.pln_type];
plp->plane = plane;
continue;
/* save planes for later */
- plp = (struct plist *)malloc(sizeof(struct plist));
+ plp = malloc(sizeof(struct plist));
memset(plp, 0, sizeof(struct plist));
plp->pcp = pcp;
qp = qp->q_forw;
free(glp->thing);
- free((s_char *)glp);
+ free(glp);
}
return dam;
}
qp = qp->q_forw;
free(glp->thing);
- free((s_char *)glp);
+ free(glp);
}
qp = escorts.q_forw;
while (qp != (&escorts)) {
newqp = qp->q_forw;
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
qp = newqp;
}
while (qp != (&bombers)) {
newqp = qp->q_forw;
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
qp = newqp;
}
size = max(sizeof(struct lndstr), sizeof(struct plnstr));
size = max(size, sizeof(struct shpstr));
- block = (s_char *)malloc(size);
+ block = malloc(size);
while (nxtitem(np, block)) {
gp = (struct genitem *)block;
if (pp->pln_effic < 40) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
if (pp->pln_mobil < 1) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
if (opt_MARKET) {
if (ontradingblock(EF_PLANE, (int *)pp)) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
}
}
if (bad) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
if (bad1 == 2) {
}
if (bad1) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
}
}
if (bad) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
}
pp->pln_effic = 0;
putplane(pp->pln_uid, pp);
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
if (!can_be_on_ship(pp->pln_uid, ship.shp_uid)) {
((ship.shp_own != pp->pln_own) &&
(getrel(getnatp(ship.shp_own), pp->pln_own) != ALLIED))) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
}
pp->pln_effic = 0;
putplane(pp->pln_uid, pp);
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
if (!(pcp->pl_flags & P_E))
((land.lnd_own != pp->pln_own) &&
(getrel(getnatp(land.lnd_own), pp->pln_own) != ALLIED))) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
/* Can't fly off units in ships or other units */
if ((land.lnd_ship >= 0) || (land.lnd_land >= 0)) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
}
/* If we can't get the sector, we can't check it, and can't fly */
if (!getsect(pp->pln_x, pp->pln_y, §)) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
/* First, check allied status */
if ((sect.sct_own != pp->pln_own) &&
(getrel(getnatp(sect.sct_own), pp->pln_own) != ALLIED)) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
/* non-vtol plane */
if ((pcp->pl_flags & P_V) == 0) {
if ((sect.sct_type != SCT_AIRPT) || (sect.sct_effic < 40)) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
}
if (pcp->pl_flags & P_A) {
if (roll(100) > pln_identchance(pp, hardtarget, EF_SHIP)) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
}
if (mission_pln_equip(plp, ip, flags, mission) < 0) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
if (flags & (P_S | P_I)) {
struct airport *a;
struct sctstr sect;
- a = (struct airport *)malloc(sizeof(struct airport));
+ a = malloc(sizeof(struct airport));
a->x = x;
a->y = y;
dist = mapdist(x, y, gp->x, gp->y);
- plp = (struct plist *)malloc(sizeof(struct plist));
+ plp = malloc(sizeof(struct plist));
memset(plp, 0, sizeof(struct plist));
plp->pcp = (struct plchrstr *)glp->cp;
memcpy(&plp->plane, glp->thing, sizeof(struct plnstr));
/* Free it up and continue */
emp_remque(qp);
glp = (struct genlist *)qp;
- free((s_char *)glp);
+ free(glp);
}
}
next = qp->q_forw;
glp = (struct genlist *)qp;
free(glp->thing);
- free((s_char *)glp);
+ free(glp);
}
}
emp_initque(list);
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (!plane.pln_own)
continue;
if (plane.pln_effic < 100)
continue;
/* got a valid interceptor */
- irv = (struct plist *)malloc(sizeof(*irv));
+ irv = malloc(sizeof(*irv));
irv->state = P_OK;
irv->bombs = 0;
irv->misc = 0;
pcp = ip->pcp;
if (mission_pln_equip(ip, 0, 0, 'i') < 0) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
/* got one interceptor, delete from irv_list and
pcp = ip->pcp;
if (mission_pln_equip(ip, 0, 0, 'i') < 0) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
/* got one interceptor, delete from irv_list and
while (!QEMPTY(irvlist)) {
qp = irvlist->q_forw;
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
}
if (icount == 0) {
if (sect.sct_own != 0)
pp->pln_own = 0;
putplane(pp->pln_uid, pp);
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
if (destroyed)
break;
}
while (!QEMPTY(intlist)) {
qp = intlist->q_forw;
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
}
if (destroyed)
return (destroyed);
unsigned int x;
emp_initque(list);
- while (nxtitem(ni, (s_char *)&plane)) {
+ while (nxtitem(ni, &plane)) {
if (!player->owner)
continue;
if (plane.pln_mobil <= 0)
pr("%s standing by\n", prplane(&plane));
plane.pln_mission = 0;
putplane(plane.pln_uid, &plane);
- plp = (struct plist *)malloc(sizeof(struct plist));
+ plp = malloc(sizeof(struct plist));
plp->state = P_OK;
plp->misc = 0;
plp->bombs = 0;
plp = (struct plist *)qp;
if (pln_equip(plp, ip, flags, mission) < 0) {
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
continue;
}
if (flags & (P_S | P_I)) {
putplane(pp->pln_uid, pp);
newqp = qp->q_forw;
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
qp = newqp;
}
}
escp = (struct plist *)esc;
if (escp->plane.pln_uid == bombp->plane.pln_uid) {
emp_remque(esc);
- free((s_char *)esc);
+ free(esc);
esc = esc_list;
} else
esc = esc->q_forw;
mcp = &mchr[(int)sp->shp_type];
snxtitem_xy(&ni, EF_PLANE, sp->shp_x, sp->shp_y);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_own == 0)
continue;
if (plane.pln_ship == sp->shp_uid) {
return;
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_own == 0)
continue;
if (plane.pln_land == lp->lnd_uid)
struct plnstr plane;
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (!plane.pln_own)
continue;
if (plane.pln_flags & PLN_LAUNCHED)
register s_char c;
s_char *p;
- p = (s_char *)malloc(strlen(buf) + 1);
+ p = malloc(strlen(buf) + 1);
strcpy(p, buf);
for (bp = p; 0 != (c = *bp); bp++)
if (isprint(c))
int changed = 0;
if (!radbuf)
- radbuf = (s_char *)malloc((WORLD_Y * (WORLD_X + 1)) *
+ radbuf = malloc((WORLD_Y * (WORLD_X + 1)) *
sizeof(s_char));
if (!visbuf)
- visbuf = (s_char *)malloc((WORLD_Y * (WORLD_X + 1)) *
+ visbuf = malloc((WORLD_Y * (WORLD_X + 1)) *
sizeof(s_char));
if (!rad) {
- rad = (s_char **)malloc(WORLD_Y * sizeof(s_char *));
+ rad = malloc(WORLD_Y * sizeof(s_char *));
if (rad && radbuf) {
for (x = 0; x < WORLD_Y; x++)
rad[x] = &radbuf[(WORLD_X + 1) * x];
}
}
if (!vis) {
- vis = (s_char **)malloc(WORLD_Y * sizeof(s_char *));
+ vis = malloc(WORLD_Y * sizeof(s_char *));
if (vis && visbuf) {
for (x = 0; x < WORLD_Y; x++)
vis[x] = &visbuf[(WORLD_X + 1) * x];
buf[0] = sp->shp_fleet;
buf[1] = 0;
snxtitem(&ni, EF_SHIP, buf);
- while (nxtitem(&ni, (s_char *)&ship))
+ while (nxtitem(&ni, &ship))
if ((ship.shp_fleet == buf[0]) &&
(ship.shp_own == sp->shp_own)) {
if (ship.shp_uid == sp->shp_uid) {
buf[0] = lp->lnd_army;
buf[1] = 0;
snxtitem(&ni, EF_SHIP, buf);
- while (nxtitem(&ni, (s_char *)&land))
+ while (nxtitem(&ni, &land))
if ((land.lnd_army == buf[0]) && (land.lnd_own == lp->lnd_own)) {
if (land.lnd_uid == lp->lnd_uid) {
retreat_land1(lp, code, 1);
return;
if (!radbuf)
- radbuf = (s_char *)malloc((WORLD_Y * (WORLD_X + 1)) *
+ radbuf = malloc((WORLD_Y * (WORLD_X + 1)) *
sizeof(s_char));
if (!rad) {
- rad = (s_char **)malloc(WORLD_Y * sizeof(s_char *));
+ rad = malloc(WORLD_Y * sizeof(s_char *));
if (rad && radbuf) {
for (rx = 0; rx < WORLD_Y; rx++)
rad[rx] = &radbuf[(WORLD_X + 1) * rx];
struct mlist *mlp;
emp_initque(list);
- while (nxtitem(ni, (s_char *)&ship)) {
+ while (nxtitem(ni, &ship)) {
if (!player->owner)
continue;
mcp = &mchr[(int)ship.shp_type];
ship.shp_rflags = 0;
memset(ship.shp_rpath, 0, sizeof(ship.shp_rpath));
putship(ship.shp_uid, &ship);
- mlp = (struct mlist *)malloc(sizeof(struct mlist));
+ mlp = malloc(sizeof(struct mlist));
mlp->mcp = mcp;
mlp->ship = ship;
mlp->mobil = (double)ship.shp_mobil;
mpr(actor, "%s was sunk at %s\n",
prship(&ship), xyas(ship.shp_x, ship.shp_y, actor));
emp_remque((struct emp_qelem *)mlp);
- free((s_char *)mlp);
+ free(mlp);
continue;
}
if (opt_SAIL) {
putship(mlp->ship.shp_uid, &mlp->ship);
newqp = qp->q_back;
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
qp = newqp;
}
}
if (shp_check_one_mines(mlp)) {
stopping = 1;
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
}
putship(mlp->ship.shp_uid, &mlp->ship);
putsect(§);
if (changed)
writemap(actor);
putsect(§);
- putship(mlp->ship.shp_uid, (s_char *)&mlp->ship);
+ putship(mlp->ship.shp_uid, &mlp->ship);
if (!mlp->ship.shp_own)
return 1;
}
if (shp_check_one_mines(mlp)) {
stopping = 1;
emp_remque(qp);
- free((s_char *)qp);
+ free(qp);
}
}
return stopping;
mlp->ship.shp_mobil = (int)mlp->mobil;
putship(mlp->ship.shp_uid, &mlp->ship);
emp_remque((struct emp_qelem *)mlp);
- free((s_char *)mlp);
+ free(mlp);
}
static int
putship(mlp->ship.shp_uid, &mlp->ship);
if (!mlp->ship.shp_own) {
emp_remque((struct emp_qelem *)mlp);
- free((s_char *)mlp);
+ free(mlp);
}
}
return 0;
}
- cp = (s_char *)BestShipPath(buf, shp->shp_x, shp->shp_y,
- d_sect.sct_x, d_sect.sct_y, player->cnum);
+ cp = BestShipPath(buf, shp->shp_x, shp->shp_y,
+ d_sect.sct_x, d_sect.sct_y, player->cnum);
if (!cp || shp->shp_mobil <= 0) {
mpr(shp->shp_own, "Can't get to '%s' right now.\n",
xyas(d_sect.sct_x, d_sect.sct_y, player->cnum));
emp_initque(&list);
- mlp = (struct mlist *)malloc(sizeof(struct mlist));
+ mlp = malloc(sizeof(struct mlist));
mlp->mcp = &mchr[(int)sp->shp_type];
mlp->ship = *sp;
mlp->mobil = (double)sp->shp_mobil;
/* look for an owned ship in a harbor */
snxtitem_dist(&ni, EF_SHIP, x, y, lookrange);
- while (nxtitem(&ni, (s_char *)&ship) && wanted) {
+ while (nxtitem(&ni, &ship) && wanted) {
if (ship.shp_own != own)
continue;
/* look for an owned supply unit */
snxtitem_dist(&ni, EF_LAND, x, y, lookrange);
- while (nxtitem(&ni, (s_char *)&land) && wanted) {
+ while (nxtitem(&ni, &land) && wanted) {
int min;
if (land.lnd_own != own)
pr("] #%d", tp->trd_unitid);
if (opt_SHOWPLANE) {
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_ship == sp->shp_uid && plane.pln_own != 0) {
pr("\n\t\t\t\t tech %3d %3d%% %s #%d",
plane.pln_tech,
}
}
snxtitem_all(&ni, EF_LAND);
- while (nxtitem(&ni, (s_char *)&land)) {
+ while (nxtitem(&ni, &land)) {
if (land.lnd_ship == sp->shp_uid && land.lnd_own != 0) {
pr("\n\t\t\t\t tech %3d %3d%% %s #%d",
land.lnd_tech,
lchr[(int)land.lnd_type].l_name, land.lnd_uid);
if (land.lnd_nxlight) {
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_land == land.lnd_uid) {
pr("\n\t\t\t\t tech %3d %3d%% %s #%d",
plane.pln_tech,
pr("] #%d", tp->trd_unitid);
if (opt_SHOWPLANE) {
snxtitem_all(&ni, EF_PLANE);
- while (nxtitem(&ni, (s_char *)&plane)) {
+ while (nxtitem(&ni, &plane)) {
if (plane.pln_land == lp->lnd_uid && plane.pln_own != 0) {
pr("\n\t\t\t\t tech %3d %3d%% %s #%d",
plane.pln_tech,
int
trade_getitem(struct trdstr *tp, union trdgenstr *tgp)
{
- if (!ef_read(tp->trd_type, tp->trd_unitid, (s_char *)tgp))
+ if (!ef_read(tp->trd_type, tp->trd_unitid, tgp))
return 0;
return 1;
}
for (cn = 0; cn < MAXNOC; cn++)
involved[cn] = 0;
snxtitem_all(&nstr, EF_TREATY);
- while (nxtitem(&nstr, (s_char *)&treaty)) {
+ while (nxtitem(&nstr, &treaty)) {
if (treaty.trt_status == TS_FREE)
continue;
if (treaty.trt_exp < now)
if (sp->sct_type == SCT_WATER || sp->sct_own == 0) {
#ifdef SAVE_FINISH_PATHS
if (infptr->path)
- free((s_char *)infptr->path);
+ free(infptr->path);
#endif /* SAVE_FINISH_PATHS */
continue;
}
if (np->nat_money < 0) {
#ifdef SAVE_FINISH_PATHS
if (infptr->path)
- free((s_char *)infptr->path);
+ free(infptr->path);
#endif /* SAVE_FINISH_PATHS */
continue;
}
infptr->path, infptr->imcost, infptr->excost);
#ifdef SAVE_FINISH_PATHS
if (infptr->path)
- free((s_char *)infptr->path);
+ free(infptr->path);
#endif /* SAVE_FINISH_PATHS */
}
logerror("done importing\n");
int len;
/* Here we malloc a buffer and save it */
len = strlen(path);
- infptr->path = (s_char *)malloc(len);
+ infptr->path = malloc(len);
if (infptr->path == (s_char *)0) {
logerror("malloc failed in assemble_dist_path!\n");
return;
memset(air_money, 0, sizeof(air_money));
memset(sea_money, 0, sizeof(sea_money));
memset(lnd_money, 0, sizeof(lnd_money));
- bp = (int *)calloc(WORLD_X * WORLD_Y * 7, sizeof(int));
+ bp = calloc(WORLD_X * WORLD_Y * 7, sizeof(int));
for (n = 0; n < MAXNOC; n++) {
money[n] = 0;
if ((np = getnatp(n)) == (struct natstr *)0)
/* Make a list of one ships so we can use the navi.c code */
emp_initque(&ship_list);
- mlp = (struct mlist *)malloc(sizeof(struct mlist));
+ mlp = malloc(sizeof(struct mlist));
mlp->mcp = mchr + sp->shp_type;
mlp->ship = *sp;
mlp->mobil = (double)sp->shp_mobil;
fltp = fltp->next) ;
if (!fltp) {
- fltp = (struct fltheadstr *)malloc(sizeof(*fltp));
+ fltp = malloc(sizeof(*fltp));
memset(fltp, 0, sizeof(*fltp));
/* Fix the links. */
return (0);
}
- this = (struct fltelemstr *)malloc(sizeof(*this));
+ this = malloc(sizeof(*this));
memset(this, 0, sizeof(*this));
this->num = sp->shp_uid;
this->own = sp->shp_own;
emp_initque(list);
for (fe = fltp->head; fe; fe = fe->next) {
- mlp = (struct mlist *)malloc(sizeof(struct mlist));
+ mlp = malloc(sizeof(struct mlist));
sp = getshipp(fe->num);
mlp->mcp = mchr + sp->shp_type;
mlp->ship = *sp;
return -1;
}
free(fname);
- sectsbuf =
- (struct sctstr *)calloc((YSIZE * XSIZE), sizeof(struct sctstr));
- sects = (struct sctstr **)calloc(YSIZE, sizeof(struct sctstr *));
+ sectsbuf = calloc((YSIZE * XSIZE), sizeof(struct sctstr));
+ sects = calloc(YSIZE, sizeof(struct sctstr *));
for (i = 0; i < YSIZE; i++)
sects[i] = §sbuf[XSIZE * i];
- capx = (int *)calloc(nc, sizeof(int));
- capy = (int *)calloc(nc, sizeof(int));
- vector = (int *)calloc(WORLD_X + WORLD_Y, sizeof(int));
- mc = (int *)calloc(STABLE_CYCLE, sizeof(int));
- own = (int **)calloc(WORLD_X, sizeof(int *));
- elev = (int **)calloc(WORLD_X, sizeof(int *));
+ capx = calloc(nc, sizeof(int));
+ capy = calloc(nc, sizeof(int));
+ vector = calloc(WORLD_X + WORLD_Y, sizeof(int));
+ mc = calloc(STABLE_CYCLE, sizeof(int));
+ own = calloc(WORLD_X, sizeof(int *));
+ elev = calloc(WORLD_X, sizeof(int *));
for (i = 0; i < WORLD_X; ++i) {
- own[i] = (int *)calloc(WORLD_Y, sizeof(int));
- elev[i] = (int *)calloc(WORLD_Y, sizeof(int));
+ own[i] = calloc(WORLD_Y, sizeof(int));
+ elev[i] = calloc(WORLD_Y, sizeof(int));
}
- sectx = (int **)calloc(nc + ni, sizeof(int *));
- secty = (int **)calloc(nc + ni, sizeof(int *));
- sectc = (int **)calloc(nc + ni, sizeof(int *));
- isecs = (int *)calloc(nc + ni, sizeof(int));
- weight = (int *)calloc(max(sc, is * 2), sizeof(int));
- dsea = (int *)calloc(max(sc, is * 2), sizeof(int));
- dmoun = (int *)calloc(max(sc, is * 2), sizeof(int));
+ sectx = calloc(nc + ni, sizeof(int *));
+ secty = calloc(nc + ni, sizeof(int *));
+ sectc = calloc(nc + ni, sizeof(int *));
+ isecs = calloc(nc + ni, sizeof(int));
+ weight = calloc(max(sc, is * 2), sizeof(int));
+ dsea = calloc(max(sc, is * 2), sizeof(int));
+ dmoun = calloc(max(sc, is * 2), sizeof(int));
for (i = 0; i < nc; ++i) {
- sectx[i] = (int *)calloc(sc, sizeof(int));
- secty[i] = (int *)calloc(sc, sizeof(int));
- sectc[i] = (int *)calloc(sc, sizeof(int));
+ sectx[i] = calloc(sc, sizeof(int));
+ secty[i] = calloc(sc, sizeof(int));
+ sectc[i] = calloc(sc, sizeof(int));
}
for (i = nc; i < nc + ni; ++i) {
- sectx[i] = (int *)calloc(is * 2, sizeof(int));
- secty[i] = (int *)calloc(is * 2, sizeof(int));
- sectc[i] = (int *)calloc(is * 2, sizeof(int));
+ sectx[i] = calloc(is * 2, sizeof(int));
+ secty[i] = calloc(is * 2, sizeof(int));
+ sectc[i] = calloc(is * 2, sizeof(int));
}
return 0;
int i, j, n = 0, k, gotit, c;
int *trans, *trans_cont, *oldcapx, *oldcapy;
- trans = (int *)calloc(nc, sizeof(int));
- trans_cont = (int *)calloc(nc, sizeof(int));
- oldcapx = (int *)calloc(nc, sizeof(int));
- oldcapy = (int *)calloc(nc, sizeof(int));
+ trans = calloc(nc, sizeof(int));
+ trans_cont = calloc(nc, sizeof(int));
+ oldcapx = calloc(nc, sizeof(int));
+ oldcapy = calloc(nc, sizeof(int));
for (i = 0; i < WORLD_Y; ++i) {
for (j = i % 2; j < WORLD_X; j += 2) {
putsect(&sct);
}
}
- map = (s_char *)calloc(WORLD_X * WORLD_Y / 2, sizeof(*map));
+ map = calloc(WORLD_X * WORLD_Y / 2, sizeof(*map));
for (i = 0; i < MAXNOC; i++) {
ef_write(EF_MAP, i, map);
}
- map = (s_char *)calloc(WORLD_X * WORLD_Y / 2, sizeof(*map));
+ map = calloc(WORLD_X * WORLD_Y / 2, sizeof(*map));
for (i = 0; i < MAXNOC; i++) {
ef_write(EF_BMAP, i, map);
}
projects / empserver / commitdiff