static void AddExtraFile(nodebuildinfo_t *info, const char *str)
{
int count = 0;
int space;
if (! info->extra_files)
{
info->extra_files = (const char **)
UtilCalloc(EXTRA_BLOCK * sizeof(const char *));
info->extra_files[0] = str;
info->extra_files[1] = NULL;
return;
}
while (info->extra_files[count])
count++;
space = EXTRA_BLOCK - 1 - (count % EXTRA_BLOCK);
if (space == 0)
{
info->extra_files = (const char **) UtilRealloc((void *)info->extra_files,
(count + 1 + EXTRA_BLOCK) * sizeof(const char *));
}
info->extra_files[count] = str;
info->extra_files[count+1] = NULL;
}
void DetectDuplicateSidedefs(void)
{
int i;
uint16_g *array = UtilCalloc(num_sidedefs * sizeof(uint16_g));
DisplayTicker();
// sort array of indices
for (i=0; i < num_sidedefs; i++)
array[i] = i;
qsort(array, num_sidedefs, sizeof(uint16_g), SidedefCompare);
// now mark them off
for (i=0; i < num_sidedefs - 1; i++)
{
// duplicate ?
if (SidedefCompare(array + i, array + i+1) == 0)
{
sidedef_t *A = lev_sidedefs[array[i]];
sidedef_t *B = lev_sidedefs[array[i+1]];
// found a duplicate !
B->equiv = A->equiv ? A->equiv : A;
}
}
UtilFree(array);
}
//
// ReadLumpData
//
static void ReadLumpData(lump_t *lump)
{
size_t len;
cur_comms->file_pos++;
DisplaySetBar(1, cur_comms->file_pos);
DisplayTicker();
# if DEBUG_LUMP
PrintDebug("Reading... %s (%d)\n", lump->name, lump->length);
# endif
if (lump->length == 0)
return;
lump->data = UtilCalloc(lump->length);
fseek(in_file, lump->start, SEEK_SET);
len = fread(lump->data, lump->length, 1, in_file);
if (len != 1)
{
if (wad.current_level)
PrintWarn("Trouble reading lump '%s' in %s\n",
lump->name, wad.current_level->name);
else
PrintWarn("Trouble reading lump '%s'\n", lump->name);
}
lump->flags &= ~LUMP_READ_ME;
}
//
// NewLevel
//
// Create new level information
//
static level_t *NewLevel(int flags)
{
level_t *cur;
cur = UtilCalloc(sizeof(level_t));
cur->flags = flags;
return cur;
}
//
// WriteLumpData
//
static void WriteLumpData(lump_t *lump)
{
size_t len;
int align_size;
cur_comms->file_pos++;
DisplaySetBar(1, cur_comms->file_pos);
DisplayTicker();
# if DEBUG_LUMP
if (lump->flags & LUMP_COPY_ME)
PrintDebug("Copying... %s (%d)\n", lump->name, lump->length);
else
PrintDebug("Writing... %s (%d)\n", lump->name, lump->length);
# endif
if (ftell(out_file) != lump->new_start)
PrintWarn("Consistency failure writing %s (%08lX, %08X\n",
lump->name, ftell(out_file), lump->new_start);
if (lump->length == 0)
return;
if (lump->flags & LUMP_COPY_ME)
{
lump->data = UtilCalloc(lump->length);
fseek(in_file, lump->start, SEEK_SET);
len = fread(lump->data, lump->length, 1, in_file);
if (len != 1)
PrintWarn("Trouble reading lump %s to copy\n", lump->name);
}
len = fwrite(lump->data, lump->length, 1, out_file);
if (len != 1)
PrintWarn("Trouble writing lump %s\n", lump->name);
align_size = ALIGN_LEN(lump->length) - lump->length;
if (align_size > 0)
fwrite(align_filler, align_size, 1, out_file);
UtilFree(lump->data);
lump->data = NULL;
}
void DetectOverlappingLines(void)
{
// Algorithm:
// Sort all lines by left-most vertex.
// Overlapping lines will then be near each other in this set.
// Note: does not detect partially overlapping lines.
int i;
int *array = UtilCalloc(num_linedefs * sizeof(int));
int count = 0;
DisplayTicker();
// sort array of indices
for (i=0; i < num_linedefs; i++)
array[i] = i;
qsort(array, num_linedefs, sizeof(int), LineStartCompare);
for (i=0; i < num_linedefs - 1; i++)
{
int j;
for (j = i+1; j < num_linedefs; j++)
{
if (LineStartCompare(array + i, array + j) != 0)
break;
if (LineEndCompare(array + i, array + j) == 0)
{
linedef_t *A = lev_linedefs[array[i]];
linedef_t *B = lev_linedefs[array[j]];
// found an overlap !
B->overlap = A->overlap ? A->overlap : A;
count++;
}
}
}
if (count > 0)
{
PrintVerbose("Detected %d overlapped linedefs\n", count);
}
UtilFree(array);
}
//
// NewIntersection
//
static intersection_t *NewIntersection(void)
{
intersection_t *cut;
if (quick_alloc_cuts)
{
cut = quick_alloc_cuts;
quick_alloc_cuts = cut->next;
}
else
{
cut = UtilCalloc(sizeof(intersection_t));
}
return cut;
}
//
// NewLump
//
// Create new lump. 'name' must be allocated storage.
//
static lump_t *NewLump(char *name)
{
lump_t *cur;
cur = UtilCalloc(sizeof(lump_t));
cur->name = name;
cur->start = cur->new_start = -1;
cur->flags = LUMP_NEW;
cur->length = 0;
cur->space = 0;
cur->data = NULL;
cur->lev_info = NULL;
return cur;
}
//
// AppendLevelLump
//
void AppendLevelLump(lump_t *lump, const void *data, int length)
{
if (length == 0)
return;
if (lump->length == 0)
{
lump->space = MAX(length, APPEND_BLKSIZE);
lump->data = UtilCalloc(lump->space);
}
else if (lump->space < length)
{
lump->space = MAX(length, APPEND_BLKSIZE);
lump->data = UtilRealloc(lump->data, lump->length + lump->space);
}
memcpy(((char *)lump->data) + lump->length, data, length);
lump->length += length;
lump->space -= length;
}
