void help_init(void)
{
gint n;
gchar *filename, *line, *topic;
gpointer scan;
GString *buffer;
/* hash table with topic label as the key */
sysenv.manual = g_hash_table_new(g_str_hash, g_str_equal);
/* open the manual file for scanning */
filename = g_build_filename(sysenv.gdis_path, MANUAL_FILE, NULL);
printf("scanning: %s\n", filename);
scan = scan_new(filename);
g_free(filename);
if (!scan)
{
help_topic_new(NULL, NULL);
return;
}
/* process the manual file */
topic=NULL;
buffer = g_string_new(NULL);
line = scan_get_line(scan);
while (!scan_complete(scan))
{
if (g_ascii_strncasecmp(line, "%topic ", 7) == 0)
{
/* add any old data */
if (topic && buffer->len)
{
help_topic_new(topic, buffer->str);
buffer = g_string_set_size(buffer, 0);
g_free(topic);
}
/* remove trailing <cr> */
n = strlen(&line[7]);
topic = g_strndup(&line[7], n-1);
}
else
{
/* append everything that's not a topic to the current buffer */
if (topic)
g_string_append(buffer, line);
}
line = scan_get_line(scan);
}
/* done - add the last topic found */
if (topic)
help_topic_new(topic, buffer->str);
g_string_free(buffer, TRUE);
g_free(topic);
scan_free(scan);
}
static void
Scan_dealloc(Scan* self)
{
scan_free(&self->scan);
free(self->lidar_mm);
Py_TYPE(self)->tp_free((PyObject*)self);
}
/**
* shrink_dpa_allocation - for each dimm in region free n bytes for label_id
* @nd_region: the set of dimms to reclaim @n bytes from
* @label_id: unique identifier for the namespace consuming this dpa range
* @n: number of bytes per-dimm to release
*
* Assumes resources are ordered. Starting from the end try to
* adjust_resource() the allocation to @n, but if @n is larger than the
* allocation delete it and find the 'new' last allocation in the label
* set.
*/
static int shrink_dpa_allocation(struct nd_region *nd_region,
struct nd_label_id *label_id, resource_size_t n)
{
int i;
for (i = 0; i < nd_region->ndr_mappings; i++) {
struct nd_mapping *nd_mapping = &nd_region->mapping[i];
int rc;
rc = scan_free(nd_region, nd_mapping, label_id, n);
if (rc)
return rc;
}
return 0;
}
int main(int argc, char **argv) {
struct scan_ctx *scan;
struct scan_chunk_data chunk_data[2];
struct analyze_ctx *analyze;
int fd, result;
analyze = analyze_open(argv[2], argv[1]);
if (!analyze) {
perror("analyze_init");
return EXIT_FAILURE;
}
scan = scan_init();
if (!scan) {
perror("scan_init");
return EXIT_FAILURE;
}
fd = open(argv[1], O_RDWR);
if (fd < 0) {
perror("open");
return EXIT_FAILURE;
}
scan_set_fd(scan, fd);
scan_set_aio(scan);
if (!scan_begin(scan))
return EXIT_FAILURE;
do {
result = scan_read_chunk(scan, chunk_data);
if (result & SCAN_CHUNK_FOUND)
store_chunk(analyze, chunk_data);
else {
fputs("Scan error\n", stderr);
return EXIT_FAILURE;
}
} while (!(result & SCAN_CHUNK_LAST));
analyze_close(analyze);
scan_free(scan);
return EXIT_SUCCESS;
}
gint read_aims(gchar *filename, struct model_pak *model)
{
gint i, num_tokens;
gchar **buff;
gpointer scan;
struct core_pak *core;
g_assert(model != NULL);
scan = scan_new(filename);
if (!scan) return(1);
while (!scan_complete(scan)) {
buff = scan_get_tokens(scan, &num_tokens);
/*
for debugging purposes
produces a compiler warning about an
implicit declaration of function 'g_printf'
though this is a valid glib function since 2.2
http://library.gnome.org/devel/glib/2.18/glib-String-Utility-Functions.html#g-printf
*/
/*
for (i=0; i<num_tokens; i++) {
g_printf(" %s ", buff[i]);
}
printf("\n");
*/
if (!buff) break;
/* read cell vectors */
if ( g_strrstr(*buff, "lattice_vector") != NULL ) {
for (i=0 ; i<3 ; i++) {
if (num_tokens >= 3) {
model->latmat[i] = str_to_float(*(buff+1));
model->latmat[i+3] = str_to_float(*(buff+2));
model->latmat[i+6] = str_to_float(*(buff+3));
}
else {
gui_text_show(ERROR, "error reading AIMS lattice vectors \n");
return(2);
}
g_strfreev(buff);
buff = scan_get_tokens(scan, &num_tokens);
}
model->periodic = 3;
model->construct_pbc = TRUE;
}
/* read coordinates */
if ( g_strrstr(*buff, "atom") != NULL ) {
if ( ( num_tokens >= 4 ) && ( elem_symbol_test(*(buff+4)) ) ) {
core = new_core(*(buff+4), model);
core->x[0] = str_to_float(*(buff+1));
core->x[1] = str_to_float(*(buff+2));
core->x[2] = str_to_float(*(buff+3));
model->cores = g_slist_prepend(model->cores, core);
}
else {
gui_text_show(ERROR, "error reading AIMS lattice vectors \n");
return(2);
}
}
g_strfreev(buff);
}
/* done reading */
scan_free(scan);
/* model setup */
g_free(model->filename);
model->filename = g_strdup(filename);
g_free(model->basename);
model->basename = g_path_get_basename(filename);
model->fractional = FALSE;
model_prep(model);
return(0);
}
// no coords - just control data for the run
// coords - .pdb file
// topology - .frx file
gint reaxmd_input_import(gpointer import)
{
gint *symbols, num_symbols, unknown;
gchar *line, *fullname_model;
gchar *filename, *filepath;
gpointer scan, config;
GString *unparsed;
struct reaxmd_pak *reaxmd;
struct model_pak *model;
FILE *fp;
scan = scan_new(import_fullpath(import));
if (!scan)
return(1);
/* populate symbol table */
reaxmd_symbols_init(scan);
config = config_new(REAXMD, NULL);
reaxmd = config_data(config);
unparsed = g_string_new(NULL);
while (!scan_complete(scan))
{
symbols = scan_get_symbols(scan, &num_symbols);
if (num_symbols)
{
unknown = FALSE;
/* process first recognized symbol */
switch (symbols[0])
{
case REAXMD_NSTEPS:
reaxmd->total_steps = parse_nth_token_dup(1, scan_cur_line(scan));
break;
case REAXMD_TIMESTEP:
case REAXMD_TEMPERATURE:
case REAXMD_THERMOSTAT:
case REAXMD_BAROSTAT:
case REAXMD_CUTOFF:
case REAXMD_UPDATE:
case REAXMD_NWRITE:
case REAXMD_GRID:
break;
case REAXMD_PLUMED_FILE:
filename = parse_nth_token_dup(1, scan_cur_line(scan));
filepath = g_build_filename(import_path(import), filename, NULL);
//printf("Looking for: %s\n", filepath);
if (g_file_test(filepath, G_FILE_TEST_EXISTS))
project_job_file_append(NULL, filepath, sysenv.workspace);
else
gui_text_show(ERROR, "REAXMD plumed file was not found!\n");
g_free(filename);
g_free(filepath);
break;
default:
unknown = TRUE;
}
g_free(symbols);
}
else
unknown=TRUE;
if (unknown)
{
line = scan_cur_line(scan);
if (line)
g_string_append(unparsed, line);
}
}
config_unparsed_set(g_string_free(unparsed, FALSE), config);
/* CURRENT - free this, until we add a GUI */
//import_object_add(IMPORT_CONFIG, config, import);
config_free(config);
/* done irx parse */
scan_free(scan);
/* NEW - attempt to load reference coordinates */
fullname_model = parse_extension_set(import_fullpath(import), "pdb");
fp = fopen(fullname_model, "rt");
if (fp)
{
model = model_new();
read_pdb_block(fp, model);
fclose(fp);
import_object_add(IMPORT_MODEL, model, import);
}
else
{
gui_text_show(WARNING, "Failed to open reference PDB model for ReaxMD.\n");
}
g_free(fullname_model);
/* init */
import_init(import);
return(0);
}
gint nwchem_input_import(gpointer import)
{
gint *symbols, num_symbols, num_tokens, value;
gchar *line, **buff;
gpointer scan, config;
GString *unparsed;
struct model_pak *model=NULL; // CURRENT - will break if more than one in a file
struct nwchem_pak *nwchem;
scan = scan_new(import_fullpath(import));
if (!scan)
return(1);
/* populate symbol table */
nwchem_scan_symbols_init(scan);
config = config_new(NWCHEM, NULL);
nwchem = config_data(config);
unparsed = g_string_new(NULL);
while (!scan_complete(scan))
{
symbols = scan_get_symbols(scan, &num_symbols);
if (num_symbols)
{
/* process first recognized symbol */
value = symbols[0];
switch (value)
{
case NWCHEM_START:
/* TODO - could this serve as title? */
nwchem->start = parse_strip(scan_cur_line(scan));
break;
case NWCHEM_BASIS:
// TODO - don't want to use this for predefined basis sets
read_nwchem_basis_library(scan, config);
break;
case NWCHEM_CHARGE:
line = scan_cur_line(scan);
buff = tokenize(line, &num_tokens);
if (num_tokens > 1)
nwchem->charge = g_strdup(buff[1]);
g_strfreev(buff);
break;
case NWCHEM_GEOMETRY:
if (!model)
{
model = model_new();
import_object_add(IMPORT_MODEL, model, import);
}
read_nwchem_geometry(scan, model);
break;
case NWCHEM_SYSTEM:
if (!model)
{
model = model_new();
import_object_add(IMPORT_MODEL, model, import);
}
read_nwchem_system(scan, model);
break;
case NWCHEM_TASK:
read_nwchem_task(scan, config, symbols, num_symbols);
break;
default:
/* add lines that have recognized symbols (but no special trigger) to unparsed */
/* this'll happen for symbols that occur in multiple locations (eg dft) */
line = scan_cur_line(scan);
if (line)
g_string_append(unparsed, line);
}
g_free(symbols);
}
else
{
/* add non-NULL lines to unparsed list */
line = scan_cur_line(scan);
if (line)
g_string_append(unparsed, line);
}
}
config_unparsed_set(g_string_free(unparsed, FALSE), config);
import_object_add(IMPORT_CONFIG, config, import);
scan_free(scan);
import_init(import);
return(0);
}
/* Scan file FILENAME for tokens. Upon success, return zero and set TOKEN
* to point to a NULL-terminated array of scan_tokens, i.e. the token id
* of the last token is 0. Return non-zero otherwise. */
int
scan_file(const char* filename, struct scan_token** token)
{
struct misc_file_buffer file;
struct scan_token* array;
struct scan_token* buffer;
int pos;
int size;
int current;
int rc;
int line;
rc = misc_get_file_buffer(filename, &file);
if (rc)
return rc;
size = INITIAL_ARRAY_LENGTH;
pos = 0;
array = (struct scan_token*) misc_malloc(size *
sizeof(struct scan_token));
if (array == NULL) {
misc_free_file_buffer(&file);
return -1;
}
memset(array, 0, size * sizeof(struct scan_token));
line = 1;
while ((size_t) file.pos < file.length) {
skip_blanks(&file);
current = misc_get_char(&file, 0);
switch (current) {
case '[':
file.pos++;
rc = scan_section_heading(&file, &array[pos++], line);
break;
case ':':
file.pos++;
rc = scan_menu_heading(&file, &array[pos++], line);
break;
case '#':
file.pos++;
skip_line(&file);
rc = 0;
break;
case '\n':
file.pos++;
rc = 0;
break;
case EOF:
rc = 0;
break;
default:
if (search_line_for(&file, '=')) {
if (isdigit(current))
rc = scan_number_assignment(
&file, &array[pos++], line);
else
rc = scan_keyword_assignment(
&file, &array[pos++], line);
} else {
rc = scan_keyword_only_statement(&file,
&array[pos++], line);
}
}
if (rc)
break;
line++;
/* Enlarge array if there is only one position left */
if (pos + 1 >= size) {
size *= 2;
buffer = (struct scan_token *)
misc_malloc(size *
sizeof(struct scan_token));
if (buffer == NULL) {
rc = -1;
break;
}
memset(buffer, 0, size * sizeof(struct scan_token));
memcpy(buffer, array, pos*sizeof(struct scan_token));
free(array);
array = buffer;
}
}
misc_free_file_buffer(&file);
if (rc)
scan_free(array);
else
*token = array;
return rc;
}
struct scan_token *
scan_build_automenu(struct scan_token* scan)
{
char* entry[BOOT_MENU_ENTRIES];
int num_entries;
int default_entry;
char* db_keyword[SCAN_KEYWORD_NUM];
int db_line[SCAN_KEYWORD_NUM];
char* sec_keyword[SCAN_KEYWORD_NUM];
int sec_line[SCAN_KEYWORD_NUM];
int num_targets;
int num_sections;
size_t size;
struct scan_token* new_scan;
int i;
int i_new;
char* name;
char* default_name;
int pos;
/* Find defaultboot */
i = scan_find_section(scan, DEFAULTBOOT_SECTION,
scan_id_section_heading, 0);
/* Get defaultboot data */
if (scan_get_section_keywords(scan, &i, DEFAULTBOOT_SECTION, db_keyword,
db_line, NULL, NULL))
return NULL;
default_name = db_keyword[(int) scan_keyword_default];
num_targets = scan_count_target_keywords(db_keyword);
/* Get size of scan array and number of sections */
num_sections = 0;
for (i = 0; scan[i].id != scan_id_empty; i++) {
if (scan[i].id == scan_id_section_heading)
num_sections++;
}
size = /* old scan array + delimiter */ i + 1 +
/* defaultboot heading */ 1 +
/* defaultmenu */ 1 +
/* menu heading */ 1 +
/* keyword default,prompt,timeout */ 3 +
/* target keywords*/ num_targets +
/* missing target definitions */ num_sections * num_targets +
/* number assigment */ num_sections;
size *= sizeof(struct scan_token);
new_scan = misc_malloc(size);
if (!new_scan)
return NULL;
memset(new_scan, 0, size);
/* Fill new array */
i = 0;
i_new = 0;
num_entries = 0;
default_entry = -1;
memset(entry, 0, sizeof(entry));
while (scan[i].id != scan_id_empty) {
switch (scan[i].id) {
case scan_id_menu_heading:
name = scan[i].content.menu.name;
/* Abort if automenu name is already in use */
if (strcmp(name, SCAN_AUTOMENU_NAME) == 0) {
error_reason("Cannot build automenu: menu name "
"'%s' already used",
SCAN_AUTOMENU_NAME);
goto err;
}
/* Menu sections are copied without changes */
if (scan_copy_section(scan, new_scan, &i, &i_new))
goto err;
break;
case scan_id_section_heading:
name = scan[i].content.section.name;
/* Do not copy old defaultboot section */
if (strcmp(name, DEFAULTBOOT_SECTION) == 0) {
scan_skip_section(scan, &i);
break;
}
/* Get section data but do not advance index */
pos = i;
if (scan_get_section_keywords(scan, &pos, name,
sec_keyword, sec_line,
NULL, NULL))
goto err;
/* Copy section contents and advance index */
if (scan_copy_section(scan, new_scan, &i, &i_new))
goto err;
/* Stop here for non-IPL sections. */
if (scan_get_section_type(sec_keyword) != section_ipl)
break;
/* Is there enough room for another section? */
if (num_entries == BOOT_MENU_ENTRIES) {
error_reason("Cannot build automenu: too many "
"IPL sections defined (max %d)",
BOOT_MENU_ENTRIES);
goto err;
}
/* Determine if this is the default entry */
if (default_name && strcmp(default_name, name) == 0)
default_entry = num_entries;
entry[num_entries++] = name;
/* Add missing target parameters if necessary */
if (scan_count_target_keywords(sec_keyword) > 0)
break;
if (scan_append_target_keywords(new_scan, &i_new,
db_keyword))
goto err;
break;
default:
/* Rule 1 */
error_reason("Line %d: %s not allowed outside of "
"section", scan[i].line,
scan_id_name(scan[i].id));
goto err;
}
}
if (num_entries == 0) {
error_reason("Cannot build automenu: no IPL entries available");
goto err;
}
/* Append new defaultboot and automenu sections */
/* [defaultboot] */
if (scan_append_section_heading(new_scan, &i_new, DEFAULTBOOT_SECTION))
goto err;
/* defaultmenu=zipl-automatic-menu */
if (scan_append_keyword_assignment(new_scan, &i_new,
scan_keyword_defaultmenu, SCAN_AUTOMENU_NAME))
goto err;
/* :zipl-automatic-menu */
if (scan_append_menu_heading(new_scan, &i_new, SCAN_AUTOMENU_NAME))
goto err;
/* default= */
if (default_entry >= 0) {
char str[20];
snprintf(str, sizeof(str), "%d", default_entry + 1);
if (scan_append_keyword_assignment(new_scan, &i_new,
scan_keyword_default, str))
goto err;
}
/* prompt= */
i = (int) scan_keyword_prompt;
if (db_keyword[i]) {
if (scan_append_keyword_assignment(new_scan, &i_new,
scan_keyword_prompt,
db_keyword[i]))
goto err;
}
/* timeout= */
i = (int) scan_keyword_timeout;
if (db_keyword[i]) {
if (scan_append_keyword_assignment(new_scan, &i_new,
scan_keyword_timeout,
db_keyword[i]))
goto err;
}
/* target= */
/* targetbase= */
/* targetgeometry= */
/* targetblocksize= */
/* targetoffset= */
if (scan_append_target_keywords(new_scan, &i_new, db_keyword))
goto err;
/* <num>=<section name>*/
for (i = 0; i < num_entries; i++) {
if (scan_append_number_assignment(new_scan, &i_new, i + 1,
entry[i]))
goto err;
}
return new_scan;
err:
scan_free(new_scan);
return NULL;
}
gint read_rietica(gchar *filename, struct model_pak *model)
{
gint i, phases=0, skip, num_tokens;
gchar **buff, *line;
float x, y, z;
gpointer scan;
GSList *list;
struct core_pak *core;
/* checks */
g_assert(model != NULL);
scan = scan_new(filename);
if (!scan)
return(1);
/* FIXME - stop the previous file routines setting this */
model->id = -1;
while (!scan_complete(scan))
{
buff = scan_get_tokens(scan, &num_tokens);
/* search for structure start */
if (num_tokens)
{
if (g_ascii_strncasecmp(*buff, "***", 3) == 0)
{
if (phases)
model = model_new();
phases++;
/* structure name - omit the 1st and last tokens (ie "***") */
if (num_tokens > 1)
{
g_free(*(buff+num_tokens-1));
*(buff+num_tokens-1) = NULL;
g_free(model->basename);
model->basename = g_strjoinv(" ", buff+1);
}
/* parse spacegroup */
line = scan_get_line(scan);
line = scan_get_line(scan);
model->sginfo.spacename = g_strstrip(g_strdup(line));
model->sginfo.spacenum = -1;
/* parse a structure */
skip = 0;
while (!scan_complete(scan))
{
g_strfreev(buff);
buff = scan_get_tokens(scan, &num_tokens);
if (num_tokens)
{
if (elem_symbol_test(*buff))
{
/* new core */
/*
if (num_tokens > 6)
*/
{
core = new_core(*buff, model);
model->cores = g_slist_prepend(model->cores, core);
/* formatted output can result in -ve signs "joining" tokens */
line = scan_cur_line(scan);
/* no doubt some fortran programmer thought this was a clever format */
sscanf(line, "%*16c%8f%8f%8f", &x, &y, &z);
VEC3SET(core->x, x, y, z);
/*
printf("> %s", line);
P3VEC(" - ", core->x);
core->x[0] = str_to_float(*(buff+2));
core->x[1] = str_to_float(*(buff+3));
core->x[2] = str_to_float(*(buff+4));
core->sof = str_to_float(*(buff+6));
*/
skip = 0;
}
}
else
skip++;
}
/* 4 lines after the last core - parse cell info and terminate structure */
if (skip == 4)
{
if (num_tokens > 5)
{
for (i=6 ; i-- ; )
model->pbc[i] = str_to_float(*(buff+i));
model->pbc[3] *= D2R;
model->pbc[4] *= D2R;
model->pbc[5] *= D2R;
}
break;
}
}
}
}
g_strfreev(buff);
}
/* setup all new structures */
for (list=sysenv.mal ; list ; list=g_slist_next(list))
{
model = list->data;
if (model->id == -1)
{
model->id = RIETICA;
model->periodic = 3;
model->fractional = TRUE;
strcpy(model->filename, filename);
model->cores = g_slist_reverse(model->cores);
model_prep(model);
}
}
scan_free(scan);
return(0);
}
