/*
* lftp - file transfer program
*
* Copyright (c) 1996-2012 by Alexander V. Lukyanov (lav@yars.free.net)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* All indexes in this function start at 0; -1 is used contextually to
* indicate the last job or moving to the end of the list. */
#include <config.h>
#include <unistd.h>
#include <assert.h>
#include <fnmatch.h>
#include <stddef.h>
#include "QueueFeeder.h"
#include "plural.h"
#include "misc.h"
const char *QueueFeeder::NextCmd(CmdExec *exec, const char *)
{
if(jobs == NULL) return NULL;
/* denext the first job */
QueueJob *job = grab_job(0);
buffer.truncate(0);
if(xstrcmp(cur_pwd, job->pwd)) {
buffer.append("cd ").append_quoted(job->pwd).append("; ");
cur_pwd.set(job->pwd);
}
if(xstrcmp(cur_lpwd, job->lpwd)) {
buffer.append("lcd ").append_quoted(job->lpwd).append("; ");
cur_lpwd.set(job->lpwd);
}
buffer.append(job->cmd.get()).append('\n');
delete job;
return buffer;
}
void QueueFeeder::QueueCmd(const char *cmd, const char *pwd, const char *lpwd, int pos, int v)
{
QueueJob *job = new QueueJob;
job->cmd.set(cmd);
job->pwd.set(pwd);
job->lpwd.set(lpwd);
/* we never want a newline at the end: */
if(last_char(job->cmd) == '\n')
job->cmd.truncate(strlen(job->cmd)-1);
insert_jobs(job, jobs, lastjob, pos != -1? get_job(pos): NULL);
PrintJobs(job, v, _("Added job$|s$"));
}
int QueueFeeder::JobCount(const QueueJob *j)
{
int job_count=0;
for(; j; j=j->next)
job_count++;
return job_count;
}
/* verbose:
* 0, quiet
* 1, interactive
* 2, verbose (print changes of pwd and lpwd)
* PrintRequeue, output to requeue
*/
xstring& QueueFeeder::FormatJobs(xstring& s,const QueueJob *job, int v, const char *plur) const
{
if(v < 1)
return s;
const char *pwd = 0, *lpwd = 0;
if(v == PrintRequeue)
{
for(const QueueJob *j = job; j; j=j->next)
{
if(xstrcmp(pwd, job->pwd))
{
s.append("cd ").append_quoted(job->pwd).append(" &\n");
pwd = job->pwd;
}
if(xstrcmp(lpwd, job->lpwd))
{
s.append("lcd ").append_quoted(job->lpwd).append(" &\n");
lpwd = job->lpwd;
}
s.append("queue ").append_quoted(job->cmd).append('\n');
}
return s;
}
int job_count=JobCount(job);
if(job_count>1)
s.appendf("%s:\n", plural(plur,job_count));
pwd = cur_pwd;
lpwd = cur_lpwd;
int n = 1;
for(const QueueJob *j = job; j; j=j->next)
{
/* Print pwd/lpwd changes when v >= 2. (This only happens when there's
* more than one.) */
if(xstrcmp(pwd, job->pwd))
{
if(v > 2) {
s.append("\tcd ").append_quoted(job->pwd).append('\n');
}
pwd = job->pwd;
}
if(xstrcmp(lpwd, job->lpwd))
{
if(v > 2) {
s.append("\tlcd ").append_quoted(job->lpwd).append('\n');
}
lpwd = job->lpwd;
}
if(job_count==1)
s.appendf("%s: ", plural(plur,job_count));
else
s.appendf("\t%2d. ",n++);
s.append(j->cmd.get()).append('\n');
}
return s;
}
void QueueFeeder::PrintJobs(const QueueJob *job, int v, const char *plur) const
{
xstring buf("");
FormatJobs(buf,job,v,plur);
printf("%s",buf.get());
}
bool QueueFeeder::DelJob(int from, int v)
{
QueueJob *job = grab_job(from);
if(!job)
{
if(v > 0)
{
if(from == -1 || !jobs)
printf(_("No queued jobs.\n"));
else
printf(_("No queued job #%i.\n"), from+1);
}
return false;
}
PrintJobs(job, v, _("Deleted job$|s$"));
FreeList(job);
return true;
}
bool QueueFeeder::DelJob(const char *cmd, int v)
{
QueueJob *job = grab_job(cmd);
if(!job)
{
if(v > 0)
{
if(!jobs)
printf(_("No queued jobs.\n"));
else
printf(_("No queued jobs match \"%s\".\n"), cmd);
}
return false;
}
PrintJobs(job, v, _("Deleted job$|s$"));
FreeList(job);
return true;
}
/* When moving, grab the insertion pointer *before* pulling out things to
* move, since doing so will change offsets. (Note that "to == -1" means
* "move to the end", not "before the last entry".)
*/
bool QueueFeeder::MoveJob(int from, int to, int v)
{
/* Safety: make sure we don't try to move an item before itself. */
if(from == to) return false;
QueueJob *before = to != -1? get_job(to): NULL;
QueueJob *job = grab_job(from);
if(job == NULL) return false;
PrintJobs(job, v, _("Moved job$|s$"));
assert(job != before);
insert_jobs(job, jobs, lastjob, before);
return true;
}
bool QueueFeeder::MoveJob(const char *cmd, int to, int v)
{
QueueJob *before = to != -1? get_job(to): NULL;
/* Mild hack: we need to make sure the "before" job isn't one that's
* going to be moved, so move it upward until it isn't. */
while(before && !fnmatch(cmd, before->cmd,FNM_CASEFOLD)) before=before->next;
QueueJob *job = grab_job(cmd);
if(job == NULL) return false;
PrintJobs(job, v, _("Moved job$|s$"));
insert_jobs(job, jobs, lastjob, before);
return true;
}
/* remove the given job from the list */
void QueueFeeder::unlink_job(QueueJob *job)
{
/* update head/tail */
if(!job->prev) jobs = jobs->next;
if(!job->next) lastjob = lastjob->prev;
/* linked list stuff */
if(job->prev) job->prev->next = job->next;
if(job->next) job->next->prev = job->prev;
job->prev = job->next = 0;
}
QueueFeeder::QueueJob *QueueFeeder::get_job(int n)
{
QueueJob *j;
if(n == -1) {
j = lastjob;
} else {
j = jobs;
while(j && n--) j=j->next;
}
return j;
}
/* get the n'th job, removed from the list; returns NULL (an empty list)
* if there aren't that many jobs: */
QueueFeeder::QueueJob *QueueFeeder::grab_job(int n)
{
QueueJob *j = get_job(n);
if(j)
unlink_job(j);
return j;
}
QueueFeeder::QueueJob *QueueFeeder::grab_job(const char *cmd)
{
QueueJob *j = jobs, *head = NULL, *tail = NULL;
while(j) {
QueueJob *match = get_next_match(cmd, j);
if(!match) break;
j = match->next;
/* matches */
unlink_job(match);
insert_jobs(match, head, tail, NULL);
}
return head;
}
QueueFeeder::QueueJob *QueueFeeder::get_next_match(const char *cmd, QueueJob *j)
{
while(j) {
if(!fnmatch(cmd, j->cmd,FNM_CASEFOLD))
return j;
j = j->next;
}
return 0;
}
/* insert a list of jobs before "before", or at the end if before is NULL.
* If before is not NULL, it must be contained between lst_head and lst_tail. */
void QueueFeeder::insert_jobs(QueueJob *job,
QueueJob *&lst_head,
QueueJob *&lst_tail,
QueueJob *before)
{
assert(!job->prev); /* this should be an independant, clean list head */
/* Find the last entry in the new list. (This is a bit inefficient, as
* we usually know this somewhere else, but passing around both head
* and tail pointers of the new job list is too klugy.) */
QueueJob *tail = job;
while(tail->next) tail=tail->next;
if(!before) {
/* end */
job->prev = lst_tail;
tail->next = 0; /* superfluous; here for clarity */
} else {
tail->next = before;
job->prev = before->prev;
}
if(job->prev) job->prev->next = job;
if(tail->next) tail->next->prev = tail;
if(!tail->next) lst_tail = tail;
if(!job->prev) lst_head = job;
}
/* Free a list of jobs (forward only; j should be a head pointer.) */
void QueueFeeder::FreeList(QueueJob *j)
{
while(j) {
QueueJob *job = j;
j = j->next;
delete job;
}
}
QueueFeeder::~QueueFeeder()
{
FreeList(jobs);
}
xstring& QueueFeeder::FormatStatus(xstring& s,int v,const char *prefix) const
{
if(jobs == NULL)
return s;
if(v == PrintRequeue)
return FormatJobs(s, jobs, v, "");
s.append(prefix).append(_("Commands queued:")).append('\n');
int n = 1;
const char *pwd = cur_pwd, *lpwd = cur_lpwd;
for(const QueueJob *job = jobs; job; job = job->next) {
if(v<2 && n>4 && job->next)
{
s.appendf("%s%2d. ...\n",prefix,n);
break;
}
/* Print pwd/lpwd changes when v >= 2. */
if(v >= 2 && (xstrcmp(pwd, job->pwd)))
s.appendf("%s cd %s\n",prefix,job->pwd.get());
if(v >= 2 && (xstrcmp(lpwd, job->lpwd)))
s.appendf("%s lcd %s\n",prefix,job->lpwd.get());
pwd = job->pwd;
lpwd = job->lpwd;
s.appendf("%s%2d. %s\n",prefix,n++,job->cmd.get());
}
return s;
}