1/*  Part of SWI-Prolog
   2
   3    Author:        Jan Wielemaker
   4    E-mail:        J.Wielemaker@vu.nl
   5    WWW:           http://www.swi-prolog.org
   6    Copyright (c)  1985-2014, University of Amsterdam
   7                              VU University Amsterdam
   8    All rights reserved.
   9
  10    Redistribution and use in source and binary forms, with or without
  11    modification, are permitted provided that the following conditions
  12    are met:
  13
  14    1. Redistributions of source code must retain the above copyright
  15       notice, this list of conditions and the following disclaimer.
  16
  17    2. Redistributions in binary form must reproduce the above copyright
  18       notice, this list of conditions and the following disclaimer in
  19       the documentation and/or other materials provided with the
  20       distribution.
  21
  22    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  26    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  30    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  32    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33    POSSIBILITY OF SUCH DAMAGE.
  34*/
  35
  36:- module(shell,
  37          [ shell/0,
  38            ls/0,
  39            ls/1,                               % +Pattern
  40            cd/0,
  41            cd/1,                               % +Dir
  42            pushd/0,
  43            pushd/1,                            % +Dir
  44            dirs/0,
  45            pwd/0,
  46            popd/0,
  47            mv/2,                               % +File1, +File2
  48            rm/1                                % +File1
  49          ]).
  50:- use_module(library(lists), [nth1/3]).
  51:- use_module(library(error)).
  52:- use_module(library(apply)).
  53:- set_prolog_flag(generate_debug_info, false).
  54
  55/** <module>  Elementary shell commands
  56
  57This library provides some basic  shell   commands  from Prolog, such as
  58=pwd=, =ls= for situations where there  is   no  shell  available or the
  59shell output cannot be captured.
  60
  61It is developed on the ST-MINIX version.   MINIX  did not have a vfork()
  62call, and thus only allows shell/[0,1,2] if   Prolog uses less than half
  63the amount of available memory.
  64*/
  65
  66%!  shell
  67%
  68%   Execute an interactive shell. The executed   shell is defined by
  69%   the environment =SHELL= or =comspec=   (Windows).  If neither is
  70%   defined, =|/bin/sh|= is used.
  71
  72shell :-
  73    getenv('SHELL', Shell),        % Unix, also Cygwin
  74    !,
  75    shell(Shell).
  76shell :-
  77    getenv(comspec, ComSpec),      % Windows
  78    !,
  79    shell(ComSpec).
  80shell :-
  81    shell('/bin/sh').
  82
  83%!  cd.
  84%!  cd(Dir).
  85%
  86%   Change working directory
  87
  88cd :-
  89    cd(~).
  90
  91cd(Dir) :-
  92    name_to_file(Dir, Name),
  93    working_directory(_, Name).
  94
  95%!  pushd.
  96%!  pushd(+Dir).
  97%!  popd.
  98%!  dirs.
  99%
 100%   Manage the _directory stack_:
 101%
 102%     - pushd/1 is as cd/1, pushing th old directory on a stack
 103%     - pushd/0 swaps the current directory with the top of the
 104%       stack
 105%     - popd/0 pops to the top of the stack
 106%     - dirs/0 lists the current directory and the stack.
 107
 108:- dynamic
 109    stack/1.
 110
 111pushd :-
 112    pushd(+1).
 113
 114pushd(N) :-
 115    integer(N),
 116    !,
 117    findall(D, stack(D), Ds),
 118    (   nth1(N, Ds, Go),
 119        retract(stack(Go))
 120    ->  pushd(Go),
 121        print_message(information, shell(directory(Go)))
 122    ;   warning('Directory stack not that deep', []),
 123        fail
 124    ).
 125pushd(Dir) :-
 126    name_to_file(Dir, Name),
 127    working_directory(Old, Name),
 128    asserta(stack(Old)).
 129
 130popd :-
 131    retract(stack(Dir)),
 132    !,
 133    working_directory(_, Dir),
 134    print_message(information, shell(directory(Dir))).
 135popd :-
 136    warning('Directory stack empty', []),
 137    fail.
 138
 139dirs :-
 140    working_directory(WD, WD),
 141    findall(D, stack(D), Dirs),
 142    maplist(dir_name, [WD|Dirs], Results),
 143    print_message(information, shell(file_set(Results))).
 144
 145%!  pwd
 146%
 147%   Print current working directory
 148
 149pwd :-
 150    working_directory(WD, WD),
 151    print_message(information, format('~w', [WD])).
 152
 153dir_name('/', '/') :- !.
 154dir_name(Path, Name) :-
 155    atom_concat(P, /, Path),
 156    !,
 157    dir_name(P, Name).
 158dir_name(Path, Name) :-
 159    current_prolog_flag(unix, true),
 160    expand_file_name('~', [Home0]),
 161    (   atom_concat(Home, /, Home0)
 162    ->  true
 163    ;   Home = Home0
 164    ),
 165    atom_concat(Home, FromHome, Path),
 166    !,
 167    atom_concat('~', FromHome, Name).
 168dir_name(Path, Path).
 169
 170%!  ls.
 171%!  ls(+Pattern).
 172%
 173%   Listing similar to Unix =ls -F=, flagging directories with =/=.
 174
 175ls :-
 176    ls('.').
 177
 178ls(Spec) :-
 179    name_to_files(Spec, Matches),
 180    ls_(Matches).
 181
 182ls_([]) :-
 183    !,
 184    warning('No Match', []).
 185ls_([Dir]) :-
 186    exists_directory(Dir),
 187    !,
 188    atom_concat(Dir, '/*', Pattern),
 189    expand_file_name(Pattern, Files),
 190    maplist(tagged_file_in_dir, Files, Results),
 191    print_message(information, shell(file_set(Results))).
 192ls_(Files) :-
 193    maplist(tag_file, Files, Results),
 194    print_message(information, shell(file_set(Results))).
 195
 196tagged_file_in_dir(File, Result) :-
 197    file_base_name(File, Base),
 198    (   exists_directory(File)
 199    ->  atom_concat(Base, /, Result)
 200    ;   Result = Base
 201    ).
 202
 203tag_file(File, Dir) :-
 204    exists_directory(File),
 205    !,
 206    atom_concat(File, /, Dir).
 207tag_file(File, File).
 208
 209%!  mv(+From, +To) is det.
 210%
 211%   Move (Rename) a file. If To is   a directory, From is moved into
 212%   the directory.
 213
 214mv(From, To) :-
 215    name_to_files(From, Src),
 216    name_to_file(To, Dest),
 217    mv_(Src, Dest).
 218
 219mv_([One], Dest) :-
 220    \+ exists_directory(Dest),
 221    !,
 222    rename_file(One, Dest).
 223mv_(Multi, Dest) :-
 224    (   exists_directory(Dest)
 225    ->  maplist(mv_to_dir(Dest), Multi)
 226    ;   print_message(warning, format('Not a directory: ~w', [Dest])),
 227        fail
 228    ).
 229
 230mv_to_dir(Dest, Src) :-
 231    file_base_name(Src, Name),
 232    atomic_list_concat([Dest, Name], /, Target),
 233    rename_file(Src, Target).
 234
 235%!  rm(+File) is det.
 236%
 237%   Remove (unlink) a file
 238
 239rm(File) :-
 240    name_to_file(File, A),
 241    delete_file(A).
 242
 243
 244%!  name_to_file(+Name, -File)
 245%
 246%   Convert Name into a single file.
 247
 248name_to_file(Spec, File) :-
 249    name_to_files(Spec, Files),
 250    (   Files = [File]
 251    ->  true
 252    ;   print_message(warning, format('Ambiguous: ~w', [Spec])),
 253        fail
 254    ).
 255
 256name_to_files(Spec, Files) :-
 257    name_to_files_(Spec, Files),
 258    (   Files == []
 259    ->  print_message(warning, format('No match: ~w', [Spec])),
 260        fail
 261    ;   true
 262    ).
 263
 264name_to_files_(Spec, Files) :-
 265    compound(Spec),
 266    compound_name_arity(Spec, _Alias, 1),
 267    !,
 268    findall(File,
 269            (   absolute_file_name(Spec, File,
 270                                   [ access(exist),
 271                                     file_type(directory),
 272                                     file_errors(fail),
 273                                     solutions(all)
 274                                   ])
 275            ;   absolute_file_name(Spec, File,
 276                                   [ access(exist),
 277                                     file_errors(fail),
 278                                     solutions(all)
 279                                   ])
 280            ),
 281            Files).
 282name_to_files_(Spec, Files) :-
 283    (   atomic(Spec)
 284    ->  S1 = Spec
 285    ;   phrase(segments(Spec), L),
 286        atomic_list_concat(L, /, S1)
 287    ),
 288    expand_file_name(S1, Files0),
 289    (   Files0 == [S1],
 290        \+ access_file(S1, exist)
 291    ->  warning('"~w" does not exist', [S1]),
 292        fail
 293    ;   Files = Files0
 294    ).
 295
 296segments(Var) -->
 297    { var(Var),
 298      !,
 299      instantiation_error(Var)
 300    }.
 301segments(A/B) -->
 302    !,
 303    segments(A),
 304    segments(B).
 305segments(A) -->
 306    { must_be(atomic, A) },
 307    [ A ].
 308
 309%!  warning(+Fmt, +Args:list) is det.
 310
 311warning(Fmt, Args) :-
 312    print_message(warning, format(Fmt, Args)).
 313
 314:- multifile prolog:message//1.
 315
 316prolog:message(shell(file_set(Files))) -->
 317    { catch(tty_size(_, Width), _, Width = 80)
 318    },
 319    table(Files, Width).
 320prolog:message(shell(directory(Path))) -->
 321    { dir_name(Path, Name) },
 322    [ '~w'-[Name] ].
 323
 324%!  table(+List, +Width)//
 325%
 326%   Produce a tabular layout to list all   elements of List on lines
 327%   with a maximum width of Width. Elements are placed as =ls= does:
 328%
 329%      ==
 330%      1  4  7
 331%      2  5  8
 332%      3  6
 333%      ==
 334
 335table(List, Width) -->
 336    { table_layout(List, Width, Layout),
 337      compound_name_arguments(Array, a, List)
 338    },
 339    table(0, Array, Layout).
 340
 341table(I, Array, Layout) -->
 342    { Cols = Layout.cols,
 343      Index is I // Cols + (I mod Cols) * Layout.rows + 1,
 344      (   (I+1) mod Cols =:= 0
 345      ->  NL = true
 346      ;   NL = false
 347      )
 348    },
 349    (   { arg(Index, Array, Atom) }
 350    ->  (   { NL == false }
 351        ->  [ '~|~w~t~*+'-[Atom, Layout.col_width] ]
 352        ;   [ '~w'-[Atom] ]
 353        )
 354    ;   []
 355    ),
 356    (   { I2 is I+1,
 357          I2 < Cols*Layout.rows
 358        }
 359    ->  (   { NL == true }
 360        ->  [ nl ]
 361        ;   []
 362        ),
 363        table(I2, Array, Layout)
 364    ;   []
 365    ).
 366
 367table_layout(Atoms, Width, _{cols:Cols, rows:Rows, col_width:ColWidth}) :-
 368    length(Atoms, L),
 369    longest(Atoms, Longest),
 370    Cols is max(1, Width // (Longest + 3)),
 371    Rows is integer(L / Cols + 0.49999),    % should be ceil/1
 372    ColWidth is Width // Cols.
 373
 374longest(List, Longest) :-
 375    longest(List, 0, Longest).
 376
 377longest([], M, M) :- !.
 378longest([H|T], Sofar, M) :-
 379    atom_length(H, L),
 380    L >= Sofar,
 381    !,
 382    longest(T, L, M).
 383longest([_|T], S, M) :-
 384    longest(T, S, M).