static void handle_delayed_updates(char *local_name)
{
char *fname, *partialptr;
int ndx;
for (ndx = -1; (ndx = bitbag_next_bit(delayed_bits, ndx)) >= 0; ) {
struct file_struct *file = cur_flist->files[ndx];
fname = local_name ? local_name : f_name(file, NULL);
if ((partialptr = partial_dir_fname(fname)) != NULL) {
if (make_backups > 0 && !make_backup(fname))
continue;
if (verbose > 2) {
rprintf(FINFO, "renaming %s to %s\n",
partialptr, fname);
}
/* We don't use robust_rename() here because the
* partial-dir must be on the same drive. */
if (do_rename(partialptr, fname) < 0) {
rsyserr(FERROR_XFER, errno,
"rename failed for %s (from %s)",
full_fname(fname), partialptr);
} else {
if (remove_source_files
|| (preserve_hard_links && F_IS_HLINKED(file)))
send_msg_int(MSG_SUCCESS, ndx);
handle_partial_dir(partialptr, PDIR_DELETE);
}
}
}
}
/* finish off a file transfer, renaming the file and setting the permissions
and ownership */
void finish_transfer(char *fname, char *fnametmp, struct file_struct *file)
{
if (make_backups && !make_backup(fname))
return;
/* move tmp file over real file */
if (robust_rename(fnametmp,fname) != 0) {
if (errno == EXDEV) {
/* rename failed on cross-filesystem link.
Copy the file instead. */
if (copy_file(fnametmp,fname, file->mode & INITACCESSPERMS)) {
rprintf(FERROR,"copy %s -> %s : %s\n",
fnametmp,fname,strerror(errno));
} else {
set_perms(fname,file,NULL,0);
}
} else {
rprintf(FERROR,"rename %s -> %s : %s\n",
fnametmp,fname,strerror(errno));
}
do_unlink(fnametmp);
} else {
set_perms(fname,file,NULL,0);
}
}
void BACKUP_call_very_often(void){
static bool has_inited = false;
if (has_inited==false){
RT_BACKUP_reset_timer();
has_inited=true;
}
static bool is_playing = false;
Player_State player_state = ATOMIC_GET(pc->player_state);
if (!is_playing && player_state==PLAYER_STATE_PLAYING){
is_playing = true;
g_curr_playing_start_time = TIME_get_ms();
}
if (is_playing && player_state==PLAYER_STATE_STOPPED){
is_playing = false;
double added_playing_duration = TIME_get_ms() - g_curr_playing_start_time;
g_curr_playing_duration += added_playing_duration;
}
if (is_playing)
return;
//printf("duration: %f\n",get_unbackuped_duration() / 1000.0);
if (get_unbackuped_duration() > get_backup_interval_ms()){
make_backup();
RT_BACKUP_reset_timer();
}
}
static void handle_delayed_updates(struct file_list *flist, char *local_name)
{
char *fname, *partialptr, numbuf[4];
int i;
for (i = -1; (i = next_delayed_bit(i)) >= 0; ) {
struct file_struct *file = flist->files[i];
fname = local_name ? local_name : f_name(file);
if ((partialptr = partial_dir_fname(fname)) != NULL) {
if (make_backups && !make_backup(fname))
continue;
if (verbose > 2) {
rprintf(FINFO, "renaming %s to %s\n",
safe_fname(partialptr),
safe_fname(fname));
}
if (do_rename(partialptr, fname) < 0) {
rsyserr(FERROR, errno,
"rename failed for %s (from %s)",
full_fname(fname),
safe_fname(partialptr));
} else {
if (remove_sent_files
|| (preserve_hard_links
&& file->link_u.links)) {
SIVAL(numbuf, 0, i);
send_msg(MSG_SUCCESS,numbuf,4);
}
handle_partial_dir(partialptr,
PDIR_DELETE);
}
}
}
}
FILE *ffopen(const char *file,const char *mode)
{
#ifdef SKIP_FFOPS
return fopen(file,mode);
#else
FILE *ff=NULL;
char buf[256],*bf,*bufsize=0,*ptr;
gmx_bool bRead;
int bs;
if (mode[0]=='w') {
make_backup(file);
}
where();
bRead= (mode[0]=='r'&&mode[1]!='+');
strcpy(buf,file);
if (gmx_fexist(buf) || !bRead) {
if ((ff=fopen(buf,mode))==NULL)
gmx_file(buf);
where();
/* Check whether we should be using buffering (default) or not
* (for debugging)
*/
if (bUnbuffered || ((bufsize=getenv("LOG_BUFS")) != NULL)) {
/* Check whether to use completely unbuffered */
if (bUnbuffered)
bs = 0;
else
bs=strtol(bufsize, NULL, 10);
if (bs <= 0)
setbuf(ff,NULL);
else {
snew(ptr,bs+8);
if (setvbuf(ff,ptr,_IOFBF,bs) != 0)
gmx_file("Buffering File");
}
}
where();
}
else {
sprintf(buf,"%s.Z",file);
if (gmx_fexist(buf)) {
ff=uncompress(buf,mode);
}
else {
sprintf(buf,"%s.gz",file);
if (gmx_fexist(buf)) {
ff=gunzip(buf,mode);
}
else
gmx_file(file);
}
}
return ff;
#endif
}
int colvarproxy_gromacs::backup_file (char const *filename)
{
if (std::string(filename).rfind(std::string(".colvars.state"))
!= std::string::npos) {
return my_backup_file(filename, ".old");
} else {
// GROMACS has its own way to avoid overwriting files.
//if (make_backup(filename)) return COLVARS_OK;
//else return FILE_ERROR;
make_backup(filename);
}
return COLVARS_OK;
}
void BACKUP_call_very_often(void){
if (MIXER_is_saving())
return;
if (g_radium_runs_custom_exec)
return;
static bool has_inited = false;
if (has_inited==false){
RT_BACKUP_reset_timer();
has_inited=true;
}
if (!editor_has_keyboard_focus()) // If showing popup menu, editing text widgets, etc. we don't want to disturb the user.
return;
if (QApplication::mouseButtons() != Qt::NoButton) // Wait until user doesn't use the mouse.
return;
static bool is_playing = false;
Player_State player_state = ATOMIC_GET(pc->player_state);
if (!is_playing && player_state==PLAYER_STATE_PLAYING){
is_playing = true;
g_curr_playing_start_time = TIME_get_ms();
}
if (is_playing && player_state==PLAYER_STATE_STOPPED){
is_playing = false;
double added_playing_duration = TIME_get_ms() - g_curr_playing_start_time;
g_curr_playing_duration += added_playing_duration;
}
if (!doSaveBackupWhilePlaying())
if (is_playing)
return;
//printf("duration: %f\n",get_unbackuped_duration() / 1000.0);
if (SampleRecorder_Get_Num_Instances() > 0)
return;
if (get_unbackuped_duration() > get_backup_interval_ms()){
make_backup();
RT_BACKUP_reset_timer();
}
}
static exit_values_ty indent_multiple_files(void)
{
exit_values_ty exit_status = total_success;
int i;
/* When multiple input files are specified, make a backup copy
* and then output the indented code into the same filename. */
for (i = 0; input_files; i++, input_files--)
{
exit_values_ty status;
struct stat file_stats;
in_name = in_file_names[i];
out_name = in_file_names[i];
current_input = read_file(in_file_names[i], &file_stats);
open_output(out_name, "r+");
make_backup(current_input, &file_stats); /* Aborts on failure. */
/* We have safely made a backup so the open file can be truncated. */
reopen_output_trunc(out_name);
reset_parser();
status = indent (current_input);
if (status > exit_status)
{
exit_status = status;
}
if (settings.preserve_mtime)
{
close_output(&file_stats, out_name);
}
else
{
close_output(NULL, out_name);
}
}
return exit_status;
}
static void update_topol(const char *topinout, int p_num, int n_num,
const char *p_name, const char *n_name, char *grpname)
{
FILE *fpin, *fpout;
char buf[STRLEN], buf2[STRLEN], *temp, **mol_line = NULL;
int line, i, nmol_line, sol_line, nsol_last;
gmx_bool bMolecules;
char temporary_filename[STRLEN];
printf("\nProcessing topology\n");
fpin = gmx_ffopen(topinout, "r");
std::strncpy(temporary_filename, "temp.topXXXXXX", STRLEN);
fpout = gmx_fopen_temporary(temporary_filename);
line = 0;
bMolecules = FALSE;
nmol_line = 0;
sol_line = -1;
nsol_last = -1;
while (fgets(buf, STRLEN, fpin))
{
line++;
std::strcpy(buf2, buf);
if ((temp = std::strchr(buf2, '\n')) != NULL)
{
temp[0] = '\0';
}
ltrim(buf2);
if (buf2[0] == '[')
{
buf2[0] = ' ';
if ((temp = std::strchr(buf2, '\n')) != NULL)
{
temp[0] = '\0';
}
rtrim(buf2);
if (buf2[std::strlen(buf2)-1] == ']')
{
buf2[std::strlen(buf2)-1] = '\0';
ltrim(buf2);
rtrim(buf2);
bMolecules = (gmx_strcasecmp(buf2, "molecules") == 0);
}
fprintf(fpout, "%s", buf);
}
else if (!bMolecules)
{
fprintf(fpout, "%s", buf);
}
else
{
/* Check if this is a line with solvent molecules */
sscanf(buf, "%s", buf2);
if (gmx_strcasecmp(buf2, grpname) == 0)
{
sol_line = nmol_line;
sscanf(buf, "%*s %d", &nsol_last);
}
/* Store this molecules section line */
srenew(mol_line, nmol_line+1);
mol_line[nmol_line] = gmx_strdup(buf);
nmol_line++;
}
}
gmx_ffclose(fpin);
if (sol_line == -1)
{
gmx_ffclose(fpout);
gmx_fatal(FARGS, "No line with moleculetype '%s' found the [ molecules ] section of file '%s'", grpname, topinout);
}
if (nsol_last < p_num+n_num)
{
gmx_ffclose(fpout);
gmx_fatal(FARGS, "The last entry for moleculetype '%s' in the [ molecules ] section of file '%s' has less solvent molecules (%d) than were replaced (%d)", grpname, topinout, nsol_last, p_num+n_num);
}
/* Print all the molecule entries */
for (i = 0; i < nmol_line; i++)
{
if (i != sol_line)
{
fprintf(fpout, "%s", mol_line[i]);
}
else
{
printf("Replacing %d solute molecules in topology file (%s) "
" by %d %s and %d %s ions.\n",
p_num+n_num, topinout, p_num, p_name, n_num, n_name);
nsol_last -= p_num + n_num;
if (nsol_last > 0)
{
fprintf(fpout, "%-10s %d\n", grpname, nsol_last);
}
if (p_num > 0)
{
fprintf(fpout, "%-15s %d\n", p_name, p_num);
}
if (n_num > 0)
{
fprintf(fpout, "%-15s %d\n", n_name, n_num);
}
}
}
gmx_ffclose(fpout);
make_backup(topinout);
gmx_file_rename(temporary_filename, topinout);
}
/*****************************************************************
*
* EXPORTED SECTION
*
*****************************************************************/
t_fileio *gmx_fio_open(const char *fn, const char *mode)
{
t_fileio *fio = NULL;
int i;
char newmode[5];
gmx_bool bRead, bReadWrite;
int xdrid;
if (fn2ftp(fn) == efTPA)
{
strcpy(newmode, mode);
}
else
{
/* sanitize the mode string */
if (strncmp(mode, "r+", 2) == 0)
{
strcpy(newmode, "r+");
}
else if (mode[0] == 'r')
{
strcpy(newmode, "r");
}
else if (strncmp(mode, "w+", 2) == 0)
{
strcpy(newmode, "w+");
}
else if (mode[0] == 'w')
{
strcpy(newmode, "w");
}
else if (strncmp(mode, "a+", 2) == 0)
{
strcpy(newmode, "a+");
}
else if (mode[0] == 'a')
{
strcpy(newmode, "a");
}
else
{
gmx_fatal(FARGS, "DEATH HORROR in gmx_fio_open, mode is '%s'", mode);
}
}
/* Check if it should be opened as a binary file */
if (strncmp(ftp2ftype(fn2ftp(fn)), "ASCII", 5))
{
/* Not ascii, add b to file mode */
if ((strchr(newmode, 'b') == NULL) && (strchr(newmode, 'B') == NULL))
{
strcat(newmode, "b");
}
}
snew(fio, 1);
#ifdef GMX_THREAD_MPI
tMPI_Lock_init(&(fio->mtx));
#endif
bRead = (newmode[0] == 'r' && newmode[1] != '+');
bReadWrite = (newmode[1] == '+');
fio->fp = NULL;
fio->xdr = NULL;
if (fn)
{
fio->iFTP = fn2ftp(fn);
fio->fn = strdup(fn);
fio->bStdio = FALSE;
/* If this file type is in the list of XDR files, open it like that */
if (in_ftpset(fio->iFTP, asize(ftpXDR), ftpXDR))
{
/* First check whether we have to make a backup,
* only for writing, not for read or append.
*/
if (newmode[0] == 'w')
{
#ifndef GMX_FAHCORE
/* only make backups for normal gromacs */
make_backup(fn);
#endif
}
else
{
/* Check whether file exists */
if (!gmx_fexist(fn))
{
gmx_open(fn);
}
}
/* Open the file */
fio->fp = ffopen(fn, newmode);
/* determine the XDR direction */
if (newmode[0] == 'w' || newmode[0] == 'a')
{
fio->xdrmode = XDR_ENCODE;
}
else
{
fio->xdrmode = XDR_DECODE;
}
snew(fio->xdr, 1);
xdrstdio_create(fio->xdr, fio->fp, fio->xdrmode);
}
else
{
/* If it is not, open it as a regular file */
fio->fp = ffopen(fn, newmode);
}
/* for appending seek to end of file to make sure ftell gives correct position
* important for checkpointing */
if (newmode[0] == 'a')
{
gmx_fseek(fio->fp, 0, SEEK_END);
}
}
else
{
/* Use stdin/stdout for I/O */
fio->iFTP = efTPA;
fio->fp = bRead ? stdin : stdout;
fio->fn = strdup("STDIO");
fio->bStdio = TRUE;
}
fio->bRead = bRead;
fio->bReadWrite = bReadWrite;
fio->bDouble = (sizeof(real) == sizeof(double));
fio->bDebug = FALSE;
fio->bOpen = TRUE;
fio->bLargerThan_off_t = FALSE;
/* set the reader/writer functions */
gmx_fio_set_iotype(fio);
/* and now insert this file into the list of open files. */
gmx_fio_insert(fio);
return fio;
}
void gmx_tng_open(const char *filename,
char mode,
tng_trajectory_t *tng)
{
#ifdef GMX_USE_TNG
/* First check whether we have to make a backup,
* only for writing, not for read or append.
*/
if (mode == 'w')
{
#ifndef GMX_FAHCORE
/* only make backups for normal gromacs */
make_backup(filename);
#endif
}
/* tng must not be pointing at already allocated memory.
* Memory will be allocated by tng_util_trajectory_open() and must
* later on be freed by tng_util_trajectory_close(). */
if (TNG_SUCCESS != tng_util_trajectory_open(filename, mode, tng))
{
/* TNG does return more than one degree of error, but there is
no use case for GROMACS handling the non-fatal errors
gracefully. */
gmx_fatal(FARGS,
"%s while opening %s for %s",
gmx_strerror("file"),
filename,
modeToVerb(mode));
}
if (mode == 'w' || mode == 'a')
{
/* FIXME in TNG: When adding data to the header, subsequent blocks might get
* overwritten. This could be solved by moving the first trajectory
* frame set(s) to the end of the file. Could that cause other problems,
* e.g. when continuing a simulation? */
char hostname[256];
gmx_gethostname(hostname, 256);
if (mode == 'w')
{
tng_first_computer_name_set(*tng, hostname);
}
/* TODO: This should be implemented when the above fixme is done (adding data to
* the header). */
// else
// {
// tng_last_computer_name_set(*tng, hostname);
// }
char programInfo[256];
const char *precisionString = "";
#ifdef GMX_DOUBLE
precisionString = " (double precision)";
#endif
sprintf(programInfo, "%.100s, %.128s%.24s",
gmx::getProgramContext().displayName(),
GromacsVersion(), precisionString);
if (mode == 'w')
{
tng_first_program_name_set(*tng, programInfo);
}
/* TODO: This should be implemented when the above fixme is done (adding data to
* the header). */
// else
// {
// tng_last_program_name_set(*tng, programInfo);
// }
#ifdef HAVE_UNISTD_H
char username[256];
getlogin_r(username, 256);
if (mode == 'w')
{
tng_first_user_name_set(*tng, username);
}
/* TODO: This should be implemented when the above fixme is done (adding data to
* the header). */
// else
// {
// tng_last_user_name_set(*tng, username);
// }
#endif
}
#else
gmx_file("GROMACS was compiled without TNG support, cannot handle this file type");
GMX_UNUSED_VALUE(filename);
GMX_UNUSED_VALUE(mode);
GMX_UNUSED_VALUE(tng);
#endif
}
/* Delete a file or directory. If DEL_RECURSE is set in the flags, this will
* delete recursively.
*
* Note that fbuf must point to a MAXPATHLEN buffer if the mode indicates it's
* a directory! (The buffer is used for recursion, but returned unchanged.)
*/
enum delret delete_item(char *fbuf, uint16 mode, uint16 flags)
{
enum delret ret;
char *what;
int ok;
if (DEBUG_GTE(DEL, 2)) {
rprintf(FINFO, "delete_item(%s) mode=%o flags=%d\n",
fbuf, (int)mode, (int)flags);
}
if (flags & DEL_NO_UID_WRITE)
do_chmod(fbuf, mode | S_IWUSR);
if (S_ISDIR(mode) && !(flags & DEL_DIR_IS_EMPTY)) {
/* This only happens on the first call to delete_item() since
* delete_dir_contents() always calls us w/DEL_DIR_IS_EMPTY. */
ignore_perishable = 1;
/* If DEL_RECURSE is not set, this just reports emptiness. */
ret = delete_dir_contents(fbuf, flags);
ignore_perishable = 0;
if (ret == DR_NOT_EMPTY || ret == DR_AT_LIMIT)
goto check_ret;
/* OK: try to delete the directory. */
}
if (!(flags & DEL_MAKE_ROOM) && max_delete >= 0 && stats.deleted_files >= max_delete) {
skipped_deletes++;
return DR_AT_LIMIT;
}
if (S_ISDIR(mode)) {
what = "rmdir";
ok = do_rmdir(fbuf) == 0;
} else {
if (make_backups > 0 && !(flags & DEL_FOR_BACKUP) && (backup_dir || !is_backup_file(fbuf))) {
what = "make_backup";
ok = make_backup(fbuf, True);
if (ok == 2) {
what = "unlink";
ok = robust_unlink(fbuf) == 0;
}
} else {
what = "unlink";
ok = robust_unlink(fbuf) == 0;
}
}
if (ok) {
if (!(flags & DEL_MAKE_ROOM)) {
log_delete(fbuf, mode);
stats.deleted_files++;
if (S_ISREG(mode)) {
/* Nothing more to count */
} else if (S_ISDIR(mode))
stats.deleted_dirs++;
#ifdef SUPPORT_LINKS
else if (S_ISLNK(mode))
stats.deleted_symlinks++;
#endif
else if (IS_DEVICE(mode))
stats.deleted_symlinks++;
else
stats.deleted_specials++;
}
ret = DR_SUCCESS;
} else {
if (S_ISDIR(mode) && errno == ENOTEMPTY) {
rprintf(FINFO, "cannot delete non-empty directory: %s\n",
fbuf);
ret = DR_NOT_EMPTY;
} else if (errno != ENOENT) {
rsyserr(FERROR, errno, "delete_file: %s(%s) failed",
what, fbuf);
ret = DR_FAILURE;
} else
ret = DR_SUCCESS;
}
check_ret:
if (ret != DR_SUCCESS && flags & DEL_MAKE_ROOM) {
const char *desc;
switch (flags & DEL_MAKE_ROOM) {
case DEL_FOR_FILE: desc = "regular file"; break;
case DEL_FOR_DIR: desc = "directory"; break;
case DEL_FOR_SYMLINK: desc = "symlink"; break;
case DEL_FOR_DEVICE: desc = "device file"; break;
case DEL_FOR_SPECIAL: desc = "special file"; break;
default: exit_cleanup(RERR_UNSUPPORTED); /* IMPOSSIBLE */
}
rprintf(FERROR_XFER, "could not make way for %s %s: %s\n",
flags & DEL_FOR_BACKUP ? "backup" : "new",
desc, fbuf);
}
return ret;
}
static exit_values_ty indent_single_file(BOOLEAN using_stdin)
{
int is_stdin = false;
exit_values_ty exit_status = total_success;
struct stat file_stats;
if ((input_files == 0) || using_stdin)
{
input_files = 1;
in_file_names[0] = "Standard input";
in_name = in_file_names[0];
current_input = read_stdin ();
is_stdin = true;
}
else
{
/* 1 input file */
in_name = in_file_names[0];
current_input = read_file(in_file_names[0], &file_stats);
if (!out_name && !settings.use_stdout)
{
out_name = in_file_names[0];
make_backup(current_input, &file_stats);
}
}
/* Use stdout if it was specified ("-st"), or neither input
* nor output file was specified. */
if (settings.use_stdout || !out_name)
{
open_output(NULL, NULL);
}
else
{
open_output(out_name, "w");
}
reset_parser ();
exit_status = indent (current_input);
if (input_files > 0 && !using_stdin && settings.preserve_mtime)
{
close_output(&file_stats, out_name);
}
else
{
close_output(NULL, out_name);
}
if (current_input) {
if (!is_stdin && current_input->name)
xfree(current_input->name);
xfree(current_input->data);
}
return exit_status;
}
// motion_notify_event: When the mouse pointer is moved over the map area
// ------------------------------------------------------------------- >>
static gboolean motion_notify_event(GtkWidget *widget, GdkEventMotion *event)
{
int x, y;
bool redraw_map = false;
bool update_map = false;
GdkModifierType state;
if (event->is_hint)
{
gdk_window_get_pointer(event->window, &x, &y, &state);
}
else
{
x = event->x;
y = event->y;
state = (GdkModifierType)(event->state);
}
mouse.set(x, y);
// Selection box
if (sel_box.x1() != -1)
{
sel_box.br.set(x, y);
if (line_draw)
line_drawbox();
redraw_map = true;
}
else
{
if (binds.pressed("edit_selectbox"))
{
sel_box.tl.set(down_pos);
sel_box.br.set(down_pos);
//binds.clear("edit_selectbox");
}
}
// Moving items
if (items_moving)
{
move_items();
redraw_map = update_map = true;
}
else
{
if (binds.pressed("edit_moveitems") && (selection() || hilight_item != -1))
{
items_moving = true;
add_move_items();
//binds.clear("edit_moveitems");
redraw_map = update_map = true;
}
}
// Quick thing angle
if (thing_quickangle)
{
thing_setquickangle();
redraw_map = update_map = true;
}
else
{
if (binds.pressed("thing_quickangle"))
{
make_backup(false, false, false, false, true);
thing_quickangle = true;
thing_setquickangle();
redraw_map = update_map = true;
//binds.clear("thing_quickangle");
}
}
/*
if (state & GDK_BUTTON3_MASK)
{
if (items_moving)
{
move_items();
redraw_map = true;
update_map = true;
}
else
{
add_move_items();
items_moving = true;
redraw_map = update_map = true;
}
}
if (state & GDK_BUTTON2_MASK)
{
// Quick thing angle
thing_quickangle = true;
thing_setquickangle();
redraw_map = true;
update_map = true;
}
if (sel_box.x1() != -1)
{
sel_box.br.set(x, y);
if (line_draw)
line_drawbox();
redraw_map = true;
}
else
{
if (line_draw || paste_mode)
redraw_map = true;
if (!thing_quickangle && !paste_mode)
{
int old_hilight = hilight_item;
get_hilight_item(x, y);
if (hilight_item != old_hilight)
redraw_map = true;
}
}
*/
if (line_draw || paste_mode)
redraw_map = true;
if (!thing_quickangle && !paste_mode && !line_draw && sel_box.x1() == -1)
{
int old_hilight = hilight_item;
get_hilight_item(x, y);
if (hilight_item != old_hilight)
redraw_map = true;
}
//if (redraw_map)
force_map_redraw(update_map);
update_status_bar();
return TRUE;
}
