/*@
* @deftypefun int jit_writeelf_write_section (jit_writeelf_t @var{writeelf}, const char *@var{name}, jit_int @var{type}, const void *@var{buf}, unsigned int @var{len}, int @var{discardable})
* Write auxillary data to a section called @var{name}. If @var{type}
* is not zero, then it indicates an ELF section type. This is used
* by virtual machines to store auxillary data that can be retrieved
* later using @code{jit_readelf_get_section}. If the section already
* contains data, then this will append the new data. If @var{discardable}
* is non-zero, then it is OK for this section to be discarded when the
* ELF binary is stripped. Returns zero if out of memory or the
* parameters are invalid.
* @end deftypefun
@*/
int jit_writeelf_write_section
(jit_writeelf_t writeelf, const char *name, jit_int type,
const void *buf, unsigned int len, int discardable)
{
jit_section_t section;
if(!writeelf || !name)
{
return 0;
}
if(!type)
{
/* Application-specific section type, for storing unspecified data */
type = (jit_int)(SHT_LOUSER + 0x1234);
}
if(discardable)
{
section = get_section(writeelf, name, type, 0, 1, 1);
}
else
{
section = get_section(writeelf, name, type, SHF_ALLOC, 1, 1);
}
if(!section)
{
return 0;
}
if(len > 0)
{
return add_to_section(section, buf, len);;
}
else
{
return 1;
}
}
void parse_header(void *buf, char *name, int size)
{
int i;
char *limit;
Elf32_Ehdr *elf;
Elf32_Shdr *section;
Elf32_Shdr *section_name;
elf = buf;
if (check_type_elf(elf, name) == -1)
return ;
limit = (char *) ((unsigned int) buf + size);
if (check_limit_elfheader(elf, limit) == -1)
return ;
i = 0;
if ((section_name = get_section(elf->e_shstrndx, elf, buf, limit)) == NULL)
return ;
while (i < elf->e_shstrndx)
{
section = get_section(i, elf, buf, limit);
if ((section->sh_size > 0) && (section->sh_type == SHT_PROGBITS))
afsct(section, buf, (char *)elf->e_entry, section_name);
i++;
}
}
/** Convert to a string representation. If this RVA is unbound, then the string representation is the numeric RVA value (in
* hexadecimal and decimal). Otherwise the string representation contains information about the bound section. */
std::string
rose_rva_t::to_string() const
{
char s[1024];
sprintf(s, "0x%08"PRIx64" (%"PRIu64")", get_rva(), get_rva());
std::string ss = s;
if (get_section()) {
sprintf(s, " + 0x%08"PRIx64" (%"PRIu64")", get_rel(), get_rel());
ss += " <" + get_section()->get_name()->get_string(true) + s + ">";
}
return ss;
}
/* ARGSUSED */
int
fru_get_sections(container_hdl_t container, section_t *section, int maxsec,
door_cred_t *cred)
{
int count;
int num_sec = 0;
hash_obj_t *cont_object;
hash_obj_t *sec_hash;
cont_object = lookup_handle_object(container, CONTAINER_TYPE);
if (cont_object == NULL) {
return (-1);
}
if (cont_object->u.cont_obj->num_of_section > maxsec) {
return (-1);
}
sec_hash = cont_object->u.cont_obj->sec_obj_list;
if (sec_hash == NULL) {
return (-1);
}
for (count = 0; count < cont_object->u.cont_obj->num_of_section;
count++) {
section->version = -1;
/* populate section_t */
if (get_section(g_raw, sec_hash, section) == 0) {
section++;
num_sec++;
}
sec_hash = sec_hash->u.sec_obj->next;
}
return (num_sec);
}
static void read_triggers(void)
{
File f = cfg_file;
String line;
uint32_t pos = 0;
Serial.println("reading trigger list");
if (!f)
return;
__log("DBG: %s: f.available=%d\n", __func__, f.available());
while (f.available()) {
__log("DBG: read_triggers: position %u\n", pos);
//Serial.printf("- pos %u\n", pos);
if (!f.seek(pos, SeekSet)) {
Serial.println("read_triggers: failed seek\n");
break;
}
line = f.readStringUntil('\n');
if (!line)
break;
// is line null if this fails?
if (line.startsWith("[logic") ||
line.startsWith("[input") ||
line.startsWith("[output")) {
String section = get_section(line);
read_trigger(section.c_str());
}
pos += line.length() + 1;
}
}
static int config_parser(const char* section, const char* key, const char* value, void* config_v) {
UTOX_SAVE *config = (UTOX_SAVE*) config_v;
switch(get_section(section)) {
case GENERAL_SECTION: {
parse_general_section(config, key, value);
break;
}
case INTERFACE_SECTION: {
parse_interface_section(config, key, value);
break;
}
case AV_SECTION: {
parse_av_section(config, key, value);
break;
}
case NOTIFICATIONS_SECTION: {
parse_notifications_section(config, key, value);
break;
}
case ADVANCED_SECTION: {
parse_advanced_section(config, key, value);
break;
}
case UNKNOWN_SECTION: {
LOG_NOTE("Settings", "Unknown section in config file: %s", section);
break;
}
}
return 1;
}
char const *
__kmp_i18n_catgets(
kmp_i18n_id_t id
) {
int section = get_section( id );
int number = get_number( id );
char const * message = NULL;
if ( 1 <= section && section <= __kmp_i18n_default_table.size ) {
if ( 1 <= number && number <= __kmp_i18n_default_table.sect[ section ].size ) {
if ( status == KMP_I18N_CLOSED ) {
__kmp_i18n_catopen();
}; // if
if ( status == KMP_I18N_OPENED ) {
message =
catgets(
cat,
section, number,
__kmp_i18n_default_table.sect[ section ].str[ number ]
);
}; // if
if ( message == NULL ) {
message = __kmp_i18n_default_table.sect[ section ].str[ number ];
}; // if
}; // if
}; // if
if ( message == NULL ) {
message = no_message_available;
}; // if
return message;
} // func __kmp_i18n_catgets
int
bits_clear (
BITS *bits,
long bit)
{
int
index, /* Number of index block */
section; /* Number of section in index */
dbyte
bit_nbr; /* Number of bit in section */
int
feedback = 0;
ASSERT (bits);
if (bit >= 0 && bit < BIT_MAXBITS)
{
locate_bit (bits, bit, &index, §ion, &bit_nbr);
get_section (bits, index, section, section_data, TRUE);
section_data [bit_nbr / 8] &= 255 - (1 << (bit_nbr % 8));
put_section (bits, index, section, section_data);
}
else
feedback = -1;
return (feedback);
}
static void read_depends(void)
{
File f = cfg_file;
String line;
uint32_t pos = 0;
Serial.println("reading dependency info");
if (!f)
return;
while (true) {
if (!f.seek(pos, SeekSet)) {
Serial.println("read_triggers: failed seek\n");
break;
}
if (f.available() <= 0)
break;
line = f.readStringUntil('\n');
if (!line)
break;
if (line.startsWith("[dependency")) {
String section = get_section(line);
__log("DBG: found depdency section '%s'\n", section.c_str());
read_dependency(section.c_str());
}
pos += line.length() + 1;
}
}
void regini_file::write_string(string section, string key, string value)
{
section_type *sec = get_section(section);
entry_type newentry;
newentry.key = key;
newentry.value = value;
if (sec == nullptr)
{
section_type newsection;
newsection.name = section;
newsection.entry.push_back(newentry);
this->section.push_back(newsection);
}
else
{
entry_type *entry = get_entry(section, key);
if (entry == nullptr)
{
sec->entry.push_back(newentry);
}
else
{
entry->value = newentry.value;
}
}
}
void get_section_value(const frontend::stache_model &model,
const std::string &key,
section_range_sink &sink)
{
auto isubmodel = model.find(key);
if (isubmodel != model.end()) {
detail::section_getter_visitor get_section(sink);
boost::apply_visitor(get_section, isubmodel->second);
}
}
void add_entry(char *section_name, char *key, char *value)
{
section_t *s = get_section(section_name);
if (s == NULL) {
s = new_section(section_name);
}
s->entry_count++;
int len = s->entry_count;
s->entries = realloc(s->entries, sizeof(entry_t) * len);
s->entries[s->entry_count - 1].key = g_strdup(key);
s->entries[s->entry_count - 1].value = clean_value(value);
}
char *get_value(char *section, char *key)
{
section_t *s = get_section(section);
if (!s) {
return NULL;
}
for (int i = 0; i < s->entry_count; i++) {
if (strcmp(s->entries[i].key, key) == 0) {
return s->entries[i].value;
}
}
return NULL;
}
void
go_write_export_data (const char *bytes, unsigned int size)
{
static section* sec;
if (sec == NULL)
{
gcc_assert (targetm_common.have_named_sections);
sec = get_section (GO_EXPORT_SECTION_NAME, SECTION_DEBUG, NULL);
}
switch_to_section (sec);
assemble_string (bytes, size);
}
char const *
__kmp_i18n_catgets(
kmp_i18n_id_t id
) {
int section = get_section( id );
int number = get_number( id );
char const * message = NULL;
if ( 1 <= section && section <= __kmp_i18n_default_table.size ) {
if ( 1 <= number && number <= __kmp_i18n_default_table.sect[ section ].size ) {
if ( status == KMP_I18N_CLOSED ) {
__kmp_i18n_catopen();
}; // if
if ( cat != KMP_I18N_NULLCAT ) {
if ( table.size == 0 ) {
table.sect = (kmp_i18n_section_t *)
KMP_INTERNAL_CALLOC(
( __kmp_i18n_default_table.size + 2 ),
sizeof( kmp_i18n_section_t )
);
table.size = __kmp_i18n_default_table.size;
}; // if
if ( table.sect[ section ].size == 0 ) {
table.sect[ section ].str = (const char **)
KMP_INTERNAL_CALLOC(
__kmp_i18n_default_table.sect[ section ].size + 2,
sizeof( char const * )
);
table.sect[ section ].size = __kmp_i18n_default_table.sect[ section ].size;
}; // if
if ( table.sect[ section ].str[ number ] == NULL ) {
table.sect[ section ].str[ number ] = ___catgets( id );
}; // if
message = table.sect[ section ].str[ number ];
}; // if
if ( message == NULL ) {
// Catalog is not opened or message is not found, return default message.
message = __kmp_i18n_default_table.sect[ section ].str[ number ];
}; // if
}; // if
}; // if
if ( message == NULL ) {
message = no_message_available;
}; // if
return message;
} // func __kmp_i18n_catgets
static int fixup_reloc(void *image, struct nt_header *nt_hdr)
{
struct section_header *sect_hdr;
int base = nt_hdr->opt_hdr.opt_nt_hdr.image_base;
int size;
struct coffpe_relocs *fixup_block;
sect_hdr = get_section(nt_hdr, ".reloc");
if (sect_hdr == NULL)
return -EINVAL;
fixup_block = (struct coffpe_relocs *)(image + sect_hdr->rawdata_addr);
do
{
int i;
uint16_t fixup, offset;
size = (fixup_block->block_size - (2 * sizeof(uint32_t))) /
sizeof(uint16_t);
for (i = 0; i < size; i++)
{
uint32_t *loc;
uint32_t addr;
fixup = fixup_block->fixup[i];
offset = fixup & 0xfff;
loc = RVA2VA(image, fixup_block->page_rva + offset,
uint32_t *);
switch ((fixup >> 12) & 0x0f)
{
case COFF_FIXUP_ABSOLUTE:
break;
case COFF_FIXUP_HIGHLOW:
addr = RVA2VA(image, (*loc - base), uint32_t);
*loc = addr;
break;
default:
ERROR("unknown fixup: %08X", fixup);
return -EOPNOTSUPP;
break;
}
}
fixup_block = (struct coffpe_relocs *)
((size_t)fixup_block + fixup_block->block_size);
} while (fixup_block->block_size);
return 0;
}
void
symtab_node::set_section_for_node (const char *section)
{
const char *current = get_section ();
void **slot;
if (current == section
|| (current && section
&& !strcmp (current, section)))
return;
if (current)
{
x_section->ref_count--;
if (!x_section->ref_count)
{
slot = htab_find_slot_with_hash (symtab->section_hash, x_section->name,
htab_hash_string (x_section->name),
INSERT);
ggc_free (x_section);
htab_clear_slot (symtab->section_hash, slot);
}
x_section = NULL;
}
if (!section)
{
implicit_section = false;
return;
}
if (!symtab->section_hash)
symtab->section_hash = htab_create_ggc (10, hash_section_hash_entry,
eq_sections, NULL);
slot = htab_find_slot_with_hash (symtab->section_hash, section,
htab_hash_string (section),
INSERT);
if (*slot)
x_section = (section_hash_entry *)*slot;
else
{
int len = strlen (section);
*slot = x_section = ggc_cleared_alloc<section_hash_entry> ();
x_section->name = ggc_vec_alloc<char> (len + 1);
memcpy (x_section->name, section, len + 1);
}
x_section->ref_count++;
}
static int parse(struct ini_config *ini, char *buff, unsigned long size)
{
int curr_section;
char *curr_pos;
char *tmp;
char line[128];
int section_nr;
int key_nr;
int key_cnt;
int val_cnt;
int cnt;
curr_section = 0;
curr_pos = buff;
while (size) {
cnt = get_section_key_nr(curr_pos, size, §ion_nr, &key_nr);
if (cnt == -1)
return 0;
tmp = curr_pos;
ini->section_tbl[curr_section].key_nr = key_nr;
ini->section_tbl[curr_section].key_tbl = (struct key *)malloc(sizeof(struct key));
if (!ini->section_tbl[curr_section].key_tbl)
return 0;
ini->section_tbl[curr_section].name = (char *)malloc(section_nr);
tmp = get_line(tmp, line, 128);
get_section(line, 128, ini->section_tbl[curr_section].name);
for (int i = 0; i < key_nr; i++) {
tmp = get_line(tmp, line, 128);
get_key_val_nr(line, 128, &key_cnt, &val_cnt);
ini->section_tbl[curr_section].key_tbl[i].key_name = (char *)malloc(key_cnt);
ini->section_tbl[curr_section].key_tbl[i].key_val = (char *)malloc(val_cnt);
get_key_val(line, 128,
ini->section_tbl[curr_section].key_tbl[i].key_name,
ini->section_tbl[curr_section].key_tbl[i].key_val);
printf("section:%s,key_name:%s, key_val%s\n", ini->section_tbl[curr_section].name,
ini->section_tbl[curr_section].key_tbl[i].key_name,
ini->section_tbl[curr_section].key_tbl[i].key_val);
}
curr_section++;
curr_pos += cnt;
size -= cnt;
}
return 1;
}
void
pp::INI::File::write (std::wstring fname)
{
FILE* fOut;
errno_t ret;
// Strip Read-Only
/////////AD_SetNormalFileAttribs (fname);
TRY_FILE_IO (_wfopen_s (&fOut, fname.c_str (), L"w,ccs=UTF-16LE"), fname.c_str (), ret);
if (ret != 0 || fOut == 0) {
//AD_MessageBox (L"ERROR: Cannot open INI file for writing. Is it read-only?", fname.c_str (), MB_OK | MB_ICONSTOP);
return;
}
std::vector <std::wstring>::iterator it = ordered_sections.begin ();
std::vector <std::wstring>::iterator end = ordered_sections.end ();
while (it != end) {
Section& section = get_section (*it);
fwprintf (fOut, L"[%s]\n", section.name.c_str ());
std::vector <std::wstring>::iterator key_it = section.ordered_keys.begin ();
std::vector <std::wstring>::iterator key_end = section.ordered_keys.end ();
while (key_it != key_end) {
std::wstring val = section.get_value (*key_it);
fwprintf (fOut, L"%s=%s\n", key_it->c_str (), val.c_str ());
++key_it;
}
// Append a newline for everything except the last line...
if (++it != end)
fwprintf (fOut, L"\n");
}
fflush (fOut);
fclose (fOut);
// Make Read-Only
////SetFileAttributes (fname.c_str (), FILE_ATTRIBUTE_READONLY);
}
void
nwld_named_section_asm_out_destructor (rtx symbol, int priority)
{
#if !SUPPORTS_INIT_PRIORITY
const char section[] = ".dtors"TARGET_SUB_SECTION_SEPARATOR;
#else
char section[20];
sprintf (section, ".dtors"TARGET_SUB_SECTION_SEPARATOR"%.5u",
/* Invert the numbering so the linker puts us in the proper
order; destructors are run from left to right, and the
linker sorts in increasing order. */
MAX_INIT_PRIORITY - priority);
#endif
switch_to_section (get_section (section, 0, NULL));
assemble_align (POINTER_SIZE);
assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
}
entry_type* regini_file::get_entry(string section_name, string key_name)
{
section_type* sec = get_section(section_name);
if (sec != nullptr)
{
key_name = string_tolower(key_name);
for (size_t i = 0; i < sec->entry.size(); i++)
{
string ekeyname = string_tolower(sec->entry[i].key);
if (ekeyname.compare(key_name) == 0)
return &sec->entry[i];
}
}
return nullptr;
}
int
bits_test (
const BITS *bits,
long bit)
{
int
index, /* Number of index block */
section; /* Number of section in index */
dbyte
bit_nbr; /* Number of bit in section */
ASSERT (bits);
locate_bit (bits, bit, &index, §ion, &bit_nbr);
get_section ((BITS *) bits, index, section, section_data, FALSE);
if ((section_data [bit_nbr / 8]) & (1 << (bit_nbr % 8)))
return (1);
else
return (0);
}
void load_section(Elf64_Ehdr *header, char *file, char *section_name, t_section *section_ptr)
{
Elf64_Half nb_entry;
Elf64_Shdr *section;
char *name;
nb_entry = header->e_shnum;
for (int i = 0; i < nb_entry; i++)
{
section = get_section(header, file, i);
name = get_string(section->sh_name, header, file);
if (!strcmp(name, section_name))
{
section_ptr->data = map_section(file, section);
section_ptr->size = section->sh_size;
break;
}
}
}
int
bits_clear (
BITS *bits,
long bit)
{
int
index, /* Number of index block */
section; /* Number of section in index */
dbyte
bit_nbr; /* Number of bit in section */
ASSERT (bits);
locate_bit (bits, bit, &index, §ion, &bit_nbr);
get_section (bits, index, section, section_data, TRUE);
section_data [bit_nbr / 8] &= 255 - (1 << (bit_nbr % 8));
put_section (bits, index, section, section_data);
return 0;
}
/*@
* @deftypefun int jit_writeelf_add_needed (jit_writeelf_t @var{writeelf}, const char *@var{library_name})
* Add @var{library_name} to the list of dependent libraries that are needed
* when the ELF binary is reloaded. If @var{library_name} is already on
* the list, then this request will be silently ignored. Returns
* zero if out of memory or the parameters are invalid.
* @end deftypefun
@*/
int jit_writeelf_add_needed(jit_writeelf_t writeelf, const char *library_name)
{
jit_section_t section;
Elf_Dyn *dyn;
unsigned int num_dyn;
Elf_Word name_index;
if(!writeelf || !library_name)
{
return 0;
}
section = get_section(writeelf, ".dynamic", SHT_DYNAMIC,
SHF_WRITE | SHF_ALLOC,
sizeof(Elf_Dyn), sizeof(Elf_Dyn));
if(!section)
{
return 0;
}
dyn = (Elf_Dyn *)(section->data);
num_dyn = section->data_len / sizeof(Elf_Dyn);
while(num_dyn > 0)
{
if(dyn->d_tag == DT_NEEDED &&
!jit_strcmp(get_dyn_string(writeelf, (Elf_Word)(dyn->d_un.d_ptr)),
library_name))
{
return 1;
}
++dyn;
--num_dyn;
}
name_index = add_dyn_string(writeelf, library_name);
if(!name_index)
{
return 0;
}
if(!add_dyn_info(writeelf, DT_NEEDED, (Elf_Addr)name_index, 0))
{
return 0;
}
return 1;
}
static int read_exports(void *image, struct nt_header *nt_hdr, char *dll)
{
struct section_header *export_section;
struct export_dir_table *export_dir_table;
cu32 *export_addr_table;
int i;
unsigned int *name_table;
export_section = get_section(nt_hdr, ".edata");
if (export_section)
DBGTRACE1("%s", "found exports section");
else
return 0;
export_dir_table = (struct export_dir_table *)
(image + export_section->rawdata_addr);
name_table = (unsigned int *)(image + export_dir_table->name_addr_rva);
export_addr_table = (cu32 *)
(image + export_dir_table->export_table_rva);
for (i = 0; i < export_dir_table->num_name_addr; i++)
{
if (nt_hdr->opt_hdr.export_tbl.rva <= *export_addr_table ||
*export_addr_table >= (nt_hdr->opt_hdr.export_tbl.rva +
nt_hdr->opt_hdr.export_tbl.size))
DBGTRACE1("%s", "forwarder rva");
DBGTRACE1("export symbol: %s, at %08X",
(char *)(image + *name_table),
(unsigned int)(image + *export_addr_table));
exports[num_exports].dll = dll;
exports[num_exports].name = (char *)(image + *name_table);
exports[num_exports].addr = (cu32)(image + *export_addr_table);
num_exports++;
name_table++;
export_addr_table++;
}
return 0;
}
/** \brief
*
* \param ctx
* \param fp
*
* \return Number of options set
*/
int iniread_file(configctx_t *ctx, FILE *fp)
{
char buffer[LIBINI_LINE_MAX];
char *start,*ptr;
int ret = 0;
while (fgets(buffer,sizeof(buffer),fp) != NULL ) {
start = skpws(buffer);
if ( *start == ';' || *start =='#' || *start ==0)
continue;
if ( *start == '[' ) {
get_section(ctx, start);
} else { /* Must be an option! */
ptr = start;
while ( isoptionchar(*ptr) )
ptr++;
if ( *ptr == '=' ) {
*ptr++ = 0;
} else {
*ptr++ = 0;
/* Search for the '=' now */
if ( (ptr = strchr(ptr,'=') ) == NULL ) {
continue;
}
ptr++;
}
ptr = skpws(ptr); /* Skip over any white space */
if ( *ptr == ';' || *ptr =='#' || *ptr ==0 ) {
continue;
}
if ( strlen(start) ) {
if ( option_set(ctx, start,ptr) >= 0 ) {
ret++;
}
}
}
}
return ret;
}
/*
* Add an entry to the dynamic linking information section.
*/
static int add_dyn_info
(jit_writeelf_t writeelf, int type, Elf_Addr value, int modify_existing)
{
jit_section_t section;
Elf_Dyn dyn;
/* Get or create the ".dynamic" section */
section = get_section(writeelf, ".dynamic", SHT_DYNAMIC,
SHF_WRITE | SHF_ALLOC,
sizeof(Elf_Dyn), sizeof(Elf_Dyn));
if(!section)
{
return 0;
}
/* See if we already have this entry, and modify it as appropriate */
if(modify_existing)
{
Elf_Dyn *existing = (Elf_Dyn *)(section->data);
unsigned int num = section->data_len / sizeof(Elf_Dyn);
while(num > 0)
{
if(existing->d_tag == type)
{
existing->d_un.d_ptr = value;
return 1;
}
++existing;
--num;
}
}
/* Format the dynamic entry */
jit_memzero(&dyn, sizeof(dyn));
dyn.d_tag = type;
dyn.d_un.d_ptr = value;
/* Add the entry to the section's contents */
return add_to_section(section, &dyn, sizeof(dyn));
}
char get_section_symbol_32(char *ptr, uint32_t n)
{
uint32_t i;
struct load_command *l_cmd;
i = 0;
l_cmd = (struct load_command *)(ptr + sizeof(struct mach_header));
while (i++ < ((struct mach_header *)ptr)->ncmds)
{
if (l_cmd->cmd == LC_SEGMENT)
{
if (n > ((struct segment_command *)l_cmd)->nsects)
n -= ((struct segment_command *)l_cmd)->nsects;
else
return (get_section((struct section *)
((char *)l_cmd + sizeof(struct segment_command)), n,
sizeof(struct section)));
}
l_cmd = (struct load_command *)((char *)l_cmd + l_cmd->cmdsize);
}
return ('1');
}
/******************************************************************************
* *
******************************************************************************/
int open_namelist(const char *fname)
{
int nml = -1;
FILE *f = fopen(fname, "r");
NML *fl = NULL;
if ( f == NULL ) {
fprintf(stderr, "Could not open \"%s\"\n", fname);
return -1;
}
nml = list_count++;
file_list = realloc(file_list, sizeof(NML)*list_count);
fl = &file_list[nml];
fl->count = 0; fl->section = NULL;
lineno = 0;
while ( readline(f, buf) ) {
if (buf[0] != '&') {
fprintf(stderr, "Error in file \"%s\"\n", fname);
fprintf(stderr, "\"%s\"\n",buf);
list_count--;
file_list = realloc(file_list, sizeof(NML)*list_count);
nml = -1;
break;
}
fl->count++;
fl->section = realloc(fl->section, sizeof(NML_Section)*fl->count);
get_section(f, &fl->section[fl->count-1], &buf[1]);
}
fclose(f);
#if DEBUG_NML
show_namelist(nml);
exit(0);
#endif
return nml;
}
