QueueFeeder.cc

Go to the documentation of this file.

/*
 * 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;
}