workbench/c/shellcommands/Shell.c

   1 /*
   2     Copyright (C) 1995-2009, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     The shell program.
   6 */
   7
   8 /******************************************************************************
   9
  10     NAME
  11
  12         Shell
  13
  14     SYNOPSIS
  15
  16         COMMAND/K/F,FROM
  17
  18     LOCATION
  19
  20         C:
  21
  22     FUNCTION
  23
  24         Start a shell (interactive or background).
  25
  26     INPUTS
  27
  28         COMMAND  --  command line to execute
  29
  30         FROM     --  script to invoke before user interaction
  31
  32
  33     RESULT
  34
  35     NOTES
  36
  37     The script file is not a script in execute sense (as you may not use any
  38     .key, .bra or .ket and similar things).
  39
  40     Feb 2008 - initial support for .key/bra/ket/dot/dollar/default.
  41
  42     EXAMPLE
  43
  44         Shell FROM S:Startup-Sequence
  45
  46         Starts a shell and executes the startup script.
  47
  48     BUGS
  49
  50     SEE ALSO
  51
  52     Execute, NewShell
  53
  54     INTERNALS
  55
  56     The prompt   support is not using SetCurrentDirName() as this function
  57     has improper limitations. More or less the same goes for GetProgramName().
  58
  59 ******************************************************************************/
  60
  61 /* TODO:
  62
  63   *  Alias [] support
  64   *  Break support (and +(0L) before execution) -- CreateNewProc()?
  65   *  Script file execution capabilities (if script bit set)
  66   *  $ must be taken care of differently than it is now so that things
  67      like cd SYS:Olle/$pelle works
  68
  69  */
  70
  71 #define  DEBUG  0
  72 #define  DEBUG1 1
  73 #include <aros/debug.h>
  74
  75 #include <exec/memory.h>
  76 #include <exec/libraries.h>
  77 #include <proto/exec.h>
  78 #include <dos/dos.h>
  79 #include <dos/dosextens.h>
  80 #include <dos/var.h>
  81 #include <dos/filesystem.h>
  82 #include <dos/bptr.h>
  83 #include <dos/stdio.h>
  84 #include <proto/dos.h>
  85 #include <proto/alib.h>
  86 #include <proto/utility.h>
  87 #include <utility/tagitem.h>
  88 #include <ctype.h>
  89 #include <stdio.h>
  90 #include <string.h>
  91 #include <aros/asmcall.h>
  92 #include <unistd.h>
  93 #include <stdarg.h>
  94
  95 #include <aros/debug.h>
  96
  97 #define SH_GLOBAL_SYSBASE 1
  98 #define SH_GLOBAL_DOSBASE 1
  99 #include <aros/shcommands.h>
 100
 101 #define SET_HOMEDIR 1
 102
 103 #define  min(a,b)  ((a) < (b)) ? (a) : (b)
 104
 105 #define  COMMANDSTR_LEN  (256 + 2)  /* Maximum length of a 'command' */
 106 #define  FILENAME_LEN    256        /* Maximum length of a redirection filename */
 107
 108 struct Redirection
 109 {
 110     BPTR  newIn;
 111     BPTR  newOut;
 112     BPTR  oldIn;
 113     BPTR  oldOut;
 114
 115     BOOL  haveCommand;
 116     BOOL  haveOutRD;
 117     BOOL  haveInRD;
 118     BOOL  haveAppRD;
 119
 120     STRPTR  commandStr;         /* The command to execute */
 121     STRPTR  outFileName;        /* Redirection file for > or >> */
 122     STRPTR  inFileName;         /* Redirection file for < */
 123 };
 124
 125
 126 struct CommandLine
 127 {
 128     STRPTR  line;
 129     LONG    position;
 130     LONG    size;
 131 };
 132
 133
 134 struct ShellState
 135 {
 136 #if SET_HOMEDIR
 137     BPTR  oldHomeDir;           /* shared lock on program file's parent directory */
 138     BOOL  homeDirChanged;
 139 #endif
 140     BOOL  residentCommand;      /* The last command executed was resident */
 141     BOOL  script;               /* This command has the script bit set */
 142     BPTR  scriptLock;
 143 };
 144
 145 struct CommandLineInterface *cli;
 146
 147 #define MAXARGS    32
 148 #define MAXARGLEN  32
 149
 150 /* Template options (copied *and mofified* from Dos_ReadArgs) */
 151 #define REQUIRED 0x80           /* /A */
 152 #define KEYWORD  0x40           /* /K */
 153 #define MULTIPLE 0x20           /* /M */
 154 #define NORMAL   0x00           /* No option */
 155 #define SWITCH   0x01           /* /S, implies /K */
 156 #define TOGGLE   0x02           /* /T, implies /K */
 157 #define NUMERIC  0x04           /* /N */
 158 #define REST     0x08           /* /F */
 159
 160 struct InterpreterState
 161 {
 162     BOOL   isBootShell;
 163     LONG   cliNumber;
 164     LONG   argcount;
 165     TEXT   argname[MAXARGS][MAXARGLEN];
 166     LONG   argnamelen[MAXARGS];
 167     IPTR   arg[MAXARGS];
 168     LONG   arglen[MAXARGS];
 169     IPTR   argdef[MAXARGS];
 170     LONG   argdeflen[MAXARGS];
 171     UBYTE  argtype[MAXARGS];
 172
 173     TEXT   bra, ket, dollar, dot;
 174
 175     struct RDArgs *rdargs;
 176
 177     struct InterpreterState *stack;
 178 };
 179
 180
 181
 182 /* Prototypes */
 183
 184 /* Function: convertLine
 185  *
 186  * Action:   Parses a command line and returns a filtered version (removing
 187  *           redirections, incorporating embedded commands, taking care of
 188  *           variable references and aliases.
 189  *
 190  * Input:    struct CSource          *filtered   --  output command string
 191  *           struct CSource          *cs         --  input string
 192  *           struct Redirection      *rd         --  state
 193  *           struct InterpreterState *is    --  interpreter state
 194  *
 195  * Output:   LONG  --  error code or 0 if everything went OK
 196  */
 197 LONG convertLine(struct CSource *filtered, struct CSource *cs,
 198                  struct Redirection *rd, struct InterpreterState *is);
 199
 200
 201 /* Function: getCommand
 202  *
 203  * Action:
 204  *
 205  * Input:    struct CSource          *filtered  --  output buffer
 206  *           struct CSource          *cs        --  input string
 207  *           struct Redirection      *rd        --  state
 208  *           struct InterpreterState *is    --  interpreter state
 209  *
 210  * Output:   BOOL --  FALSE if there was some error, TRUE otherwise
 211  */
 212 BOOL getCommand(struct CSource *filtered, struct CSource *cs,
 213                 struct Redirection *rd, struct InterpreterState *is);
 214
 215
 216
 217 /* Function: executeLine
 218  *
 219  * Action:   Execute one line of commands
 220  *
 221  * Input:    STRPTR                  command      --  command
 222  *           STRPTR                  commandArgs  --  arguments of the 'command'
 223  *           struct Redirection      *rd          --  state
 224  *           struct InterpreterState *is          --  interpreter state
 225  *
 226  * Output:   LONG  --  error code or 0 if everything went OK
 227  */
 228 LONG executeLine(STRPTR command, STRPTR commandArgs, struct Redirection *rd,
 229                  struct InterpreterState *is);
 230
 231
 232 /* Function: readLine
 233  *
 234  * Action:   Read one line of a stream into a buffer.
 235  *
 236  * Input:    struct CommandLine *cl           --  the result will be stored
 237  *                                                here
 238  *           BPTR                inputStream  --  stream to read the line from
 239  *
 240  * Note:     This routine deals with buffering internally so "infinite" command
 241  *           lines are supported. You may specify NULL as the cl->line. The
 242  *           cl->line buffer may be disposed of by calling FreeVec().
 243  *
 244  * Output:   BOOL  --  FALSE if error, TRUE if everything went OK
 245  */
 246 BOOL readLine(struct CommandLine *cl, BPTR inputStream);
 247
 248
 249 /* Function: checkLine
 250  *
 251  * Action:   Parse a command line and do consistency checks
 252  *
 253  * Input:    struct Redirection      *rd  --  state
 254  *           struct CommandLine      *cl  --  the command line
 255  *           struct InterpreterState *is  --  interpreter state
 256  *
 257  * Output:   LONG --  DOS error code
 258  */
 259 LONG checkLine(struct Redirection *rd, struct CommandLine *cl,
 260                struct InterpreterState *is);
 261
 262
 263 /* Function: releaseFiles
 264  *
 265  * Action:   Deallocate file resources used for redirecion and reinstall
 266  *           standard input and output streams.
 267  *
 268  * Input:    struct Redirection *rd  --  state
 269  *
 270  * Output:   --
 271  */
 272 void releaseFiles(struct Redirection *rd);
 273
 274
 275 /* Function: appendString
 276  *
 277  * Action:   Add a string to the filtered command line
 278  *
 279  * Input:    struct CSource *cs    --  output stream (command line)
 280  *           STRPTR          from  --  string to append
 281  *           LONG            size  --  number of chars to copy
 282  *
 283  * Output:   BOOL  --  success/failure indicator
 284  */
 285 BOOL appendString(struct CSource *cs, CONST_STRPTR from, LONG size);
 286
 287
 288 /* Function: printFlush
 289  *
 290  * Action:   Do a formatted print that will instantly be displayed.
 291  *
 292  * Input:    STRPTR   fmt   --  format string
 293  *           ...    ...     --  varagrs
 294  *
 295  * Output:   BOOL  --  success/failure indicator
 296  */
 297 #define printFlush(format...) do {Printf(format); Flush(Output());} while (0)
 298
 299 /* Function: interact
 300  *
 301  * Action:   Execute a commandfile and then perform standard shell user
 302  *           interaction.
 303  *
 304  * Input:    struct InterpreterState *is  --  interpreter state
 305  *
 306  * Output:   LONG  --  error code
 307  */
 308 LONG interact(struct InterpreterState *is);
 309
 310
 311 /* Function: loadCommand
 312  *
 313  * Action:   Load a command, searching the paths, C: and the resident lists.
 314  *
 315  * Input:    STRPTR             commandName  --  the command to load
 316  *           struct ShellState *ss           --  state
 317  *
 318  * Output:   BPTR  --  segment of the loaded command or NULL if there was an
 319  *                     error
 320  */
 321 BPTR loadCommand(STRPTR commandName, struct ShellState *ss);
 322
 323
 324 /* Function: unloadCommand
 325  *
 326  * Action:   Free the resources held by a (loaded) command.
 327  *
 328  * Input:    BPTR               commandSeg  --  segment of the program to
 329  *                                              unload
 330  *           struct ShellState *ss          --  state
 331  *
 332  * Output:   --
 333  */
 334 void unloadCommand(BPTR commandSeg, struct ShellState *ss);
 335
 336
 337 /* Function: Redirection_release
 338  *
 339  * Action:   Release resources allocated in the state
 340  *
 341  * Input:    struct Redirection *rd  --  state
 342  *
 343  * Output:   --
 344  */
 345 void Redirection_release(struct Redirection *rd);
 346
 347
 348 /* Function: Redirection_init
 349  *
 350  * Action:   Initialize a state structure
 351  *
 352  * Input:    struct Redirection *rd  --  state
 353  *
 354  * Output:   BOOL  --  success/failure indicator
 355  */
 356 BOOL Redirection_init(struct Redirection *rd);
 357
 358
 359 /* Function: setPath
 360  *
 361  * Action:   Set the current command (standard) path.
 362  *
 363  * Input:    BPTR lock  --  a lock on the directory
 364  *
 365  * Notes:    This will set the current directory name via
 366  *           SetCurrentDirName() eventhough this is not used later.
 367  *
 368  * Output:   --
 369  */
 370 static void setPath(BPTR lock);
 371
 372
 373 /* Function: printPath
 374  *
 375  * Action:   Print the current command path to Output().
 376  *
 377  * Input:    --
 378  *
 379  * Notes:    Used for Prompt purposes.
 380  *
 381  * Output:   --
 382  */
 383 static void printPath(void);
 384
 385
 386 /* Function: printPrompt
 387  *
 388  * Action:   Print the prompt to indicate that user input is viable.
 389  *
 390  * Input:    struct InterpreterState *is  --  interpreter state
 391  *
 392  * Output:   --
 393  */
 394 static void printPrompt(struct InterpreterState *is);
 395
 396
 397 /*****************************************************************************/
 398 void setupResidentCommands(void);
 399
 400 static void initDefaultInterpreterState(struct InterpreterState *is)
 401 {
 402     int i;
 403
 404     is->argcount = 0;
 405
 406     for (i =  0; i < MAXARGS; ++i)
 407     {
 408         is->argnamelen[i] = 0;
 409         is->argname[i][0] = '\0';
 410         is->arg[i]        = (IPTR)NULL;
 411         is->arglen[i]     = 0;
 412         is->argdef[i]     = (IPTR)NULL;
 413         is->argdeflen[i]  = 0;
 414         is->argtype[i]    = NORMAL;
 415     }
 416
 417     is->bra    = '<';
 418     is->ket    = '>';
 419     is->dollar = '$';
 420     is->dot    = '.';
 421
 422     is->rdargs = NULL;
 423     is->stack  = NULL;
 424 }
 425
 426 static LONG pushInterpreterState(struct InterpreterState *is)
 427 {
 428     struct InterpreterState *tmp_is;
 429
 430     tmp_is = (struct InterpreterState *)AllocMem(sizeof(*is), MEMF_LOCAL);
 431
 432     if (!tmp_is)
 433         return ERROR_NO_FREE_STORE;
 434
 435     *tmp_is = *is;
 436     initDefaultInterpreterState(is);
 437     is->stack = tmp_is;
 438     return 0;
 439 }
 440
 441 static void popInterpreterState(struct InterpreterState *is)
 442 {
 443     struct InterpreterState *tmp_is = is->stack;
 444     LONG i;
 445
 446     for (i = 0; i < is->argcount; ++i)
 447         if (is->argdef[i])
 448             FreeMem((APTR)is->argdef[i], is->argdeflen[i] + 1);
 449
 450     if (is->rdargs)
 451     {
 452         FreeDosObject(DOS_RDARGS, is->rdargs);
 453         is->rdargs = NULL;
 454     }
 455
 456     if (tmp_is)
 457     {
 458         *is = *tmp_is;
 459         FreeMem(tmp_is, sizeof(*is));
 460     }
 461     else
 462         initDefaultInterpreterState(is);
 463 }
 464
 465 static LONG getArgumentIdx(struct InterpreterState *is,
 466                            CONST_STRPTR name, LONG len)
 467 {
 468     LONG i;
 469
 470     for (i = 0; i < is->argcount; ++i)
 471     {
 472         if (strncmp(is->argname[i], name, len) == 0)
 473            return i;
 474     }
 475
 476     if (is->argcount >= MAXARGS)
 477         return -1;
 478
 479     i = is->argcount++;
 480     CopyMem(name, is->argname[i], len);
 481     is->argname[i][len] = '\0';
 482     is->argnamelen[i] = len;
 483     return i;
 484 }
 485
 486 AROS_SH1(Shell, 41.1,
 487 AROS_SHA(STRPTR, ,COMMAND,/F,NULL))
 488 {
 489     AROS_SHCOMMAND_INIT
 490
 491     struct Process *me = (struct Process *)FindTask(NULL);
 492     struct InterpreterState is;
 493     LONG error = RETURN_OK;
 494
 495     D(bug("Executing shell\n"));
 496
 497     UtilityBase = (struct UtilityBase *)OpenLibrary("utility.library", 39);
 498     if (!UtilityBase) return RETURN_FAIL;
 499
 500     setupResidentCommands();
 501
 502     cli = Cli();
 503     setPath(NULL);
 504
 505     is.cliNumber = me->pr_TaskNum;
 506
 507     if (strcmp(me->pr_Task.tc_Node.ln_Name, "Boot Shell") == 0)
 508         is.isBootShell = TRUE;
 509     else
 510         is.isBootShell = FALSE;
 511
 512     initDefaultInterpreterState(&is);
 513
 514     if (is.isBootShell)
 515         SetPrompt("%N> ");
 516
 517     if(SHArg(COMMAND) && SHArg(COMMAND)[0])
 518     {
 519         struct Redirection rd;
 520         struct CommandLine cl = {SHArgLine(),
 521                                  0,
 522                                  strlen(SHArg(COMMAND))};
 523
 524         if(Redirection_init(&rd))
 525         {
 526             D(bug("Running command %s\n", SHArg(COMMAND)));
 527             error = checkLine(&rd, &cl, &is);
 528             Redirection_release(&rd);
 529         }
 530
 531         D(bug("Command done\n"));
 532     }
 533     else
 534     {
 535         error = interact(&is);
 536     }
 537
 538     D(bug("Exiting shell\n"));
 539
 540     return error;
 541
 542     AROS_SHCOMMAND_EXIT
 543 }
 544
 545 struct UtilityBase *UtilityBase;
 546
 547 void setupResidentCommands(void)
 548 {
 549
 550
 551 }
 552
 553
 554 /* First we execute the script, then we interact with the user */
 555 LONG interact(struct InterpreterState *is)
 556 {
 557     LONG  error = 0;
 558     BOOL  moreLeft = FALSE;
 559
 560     if (!cli->cli_Background)
 561     {
 562         SetVBuf(Output(), NULL, BUF_FULL, -1);
 563         if (is->isBootShell)
 564         {
 565             PutStr
 566             (
 567                 "AROS - The AROS Research Operating System\n"
 568                 "Copyright © 1995-2009, The AROS Development Team. All rights reserved.\n"
 569                 "AROS is licensed under the terms of the AROS Public License (APL),\n"
 570                 "a copy of which you should have received with this distribution.\n"
 571                 "Visit http://www.aros.org/ for more information.\n"
 572             );
 573         }
 574         else
 575         {
 576             IPTR data[] = {(IPTR)is->cliNumber};
 577
 578             VPrintf("New Shell process %ld\n", data);
 579         }
 580         SetVBuf(Output(), NULL, BUF_LINE, -1);
 581     }
 582
 583     do
 584     {
 585         struct CommandLine cl = { NULL, 0, 0 };
 586         struct Redirection rd;
 587
 588         if(Redirection_init(&rd))
 589         {
 590             if (cli->cli_Interactive)
 591                 printPrompt(is);
 592
 593             moreLeft = readLine(&cl, cli->cli_CurrentInput);
 594             error = checkLine(&rd, &cl, is);
 595
 596             Redirection_release(&rd);
 597             FreeVec(cl.line);
 598         }
 599
 600         if (!moreLeft)
 601         {
 602             popInterpreterState(is);
 603
 604             if (!cli->cli_Interactive)
 605             {
 606                 Close(cli->cli_CurrentInput);
 607
 608                 if (AROS_BSTR_strlen(cli->cli_CommandFile))
 609                 {
 610                     DeleteFile(AROS_BSTR_ADDR(cli->cli_CommandFile));
 611                     AROS_BSTR_setstrlen(cli->cli_CommandFile, 0);
 612                 }
 613
 614                 if (!cli->cli_Background)
 615                 {
 616                     cli->cli_CurrentInput = cli->cli_StandardInput;
 617                     cli->cli_Interactive = TRUE;
 618                     moreLeft = TRUE;
 619                     Flush(Output());
 620                     Flush(Error());
 621                 }
 622             }
 623         }
 624     } while(moreLeft);
 625
 626     if (cli->cli_Interactive)
 627         printFlush("Process %ld ending\n", is->cliNumber);
 628
 629     return error;
 630 }
 631
 632
 633 /* Close redirection files and install regular input and output streams */
 634 void releaseFiles(struct Redirection *rd)
 635 {
 636    if (rd->newIn) Close(rd->newIn);
 637    rd->newIn = NULL;
 638
 639    if (rd->newOut) Close(rd->newOut);
 640    rd->newOut = NULL;
 641 }
 642
 643 char avBuffer[256];
 644 char varBuffer[256];
 645 char argBuffer[256];
 646
 647
 648 /* Take care of one command line */
 649 LONG checkLine(struct Redirection *rd, struct CommandLine *cl,
 650                struct InterpreterState *is)
 651 {
 652     /* The allocation is taken care of by appendString */
 653     struct CSource filtered = { NULL, 0, 0 };
 654     struct CSource cs       = { cl->line, strlen(cl->line), 0 };
 655     struct LocalVar *lv;
 656     LONG result = ERROR_UNKNOWN;
 657
 658     lv = FindVar("echo", LV_VAR);
 659     if (lv != NULL)
 660     {
 661         /* AmigaDOS's shell is content also with echo being set to anything
 662            that begins with "on" in order to trigger commands echoing on,
 663            it doesn't really have to be set to just "on".  */
 664         if (lv->lv_Len >= 2)
 665             if (strncasecmp(lv->lv_Value, "on", 2) == 0)
 666             {
 667                 /* Ok, commands echoing is on.  */
 668                 PutStr(cl->line);
 669             }
 670     }
 671
 672     D(bug("Calling convertLine(), line = %s\n", cl->line));
 673
 674     if ((result = convertLine(&filtered, &cs, rd, is)) == 0)
 675     {
 676         D(bug("Position %i\n", filtered.CS_CurChr));
 677
 678         /* End string */
 679         appendString(&filtered, "\n\0", 2);
 680
 681         /* Consistency checks */
 682         if(rd->haveOutRD && rd->haveAppRD)
 683         {
 684             PutStr("Cannot combine > with >>\n");
 685             result = ERROR_TOO_MANY_LEVELS;
 686             goto exit;
 687         }
 688
 689         /* Only a comment? */
 690         if(!rd->haveCommand)
 691         {
 692             result = 0;
 693             goto exit;
 694         }
 695
 696         /* stegerg: Set redirection to default in/out handles */
 697
 698         if(rd->haveOutRD)
 699         {
 700             D(bug("Redirecting output to file %s\n", rd->outFileName));
 701
 702             rd->newOut = Open(rd->outFileName, MODE_NEWFILE);
 703
 704             if(BADDR(rd->newOut) == NULL)
 705             {
 706                 result = IoErr();
 707                 PrintFault(IoErr(), rd->outFileName);
 708                 goto exit;
 709             }
 710
 711             D(bug("Output stream opened\n"));
 712             SelectOutput(rd->newOut);
 713         }
 714
 715         if(rd->haveAppRD)
 716         {
 717             rd->newOut = Open(rd->outFileName, MODE_READWRITE);
 718
 719             if(BADDR(rd->newOut) == NULL)
 720             {
 721                 result = IoErr();
 722                 PrintFault(IoErr(), rd->outFileName);
 723                 goto exit;
 724             }
 725
 726             Seek(rd->newOut, 0, OFFSET_END);
 727             D(bug("Output stream opened (append)\n"));
 728             SelectOutput(rd->newOut);
 729         }
 730
 731         if(rd->haveInRD)
 732         {
 733             rd->newIn = Open(rd->inFileName, MODE_OLDFILE/*FMF_READ*/);
 734
 735             if(BADDR(rd->newIn) == NULL)
 736             {
 737                 result = IoErr();
 738                 PrintFault(IoErr(), rd->inFileName);
 739                 goto exit;
 740             }
 741
 742             D(bug("Input stream opened\n"));
 743             SelectInput(rd->newIn);
 744         }
 745
 746         D(bug("Calling executeLine()\n"));
 747
 748         /* OK, we've got a command. Let's execute it! */
 749         result = executeLine(rd->commandStr, filtered.CS_Buffer, rd, is);
 750
 751         SelectInput(cli->cli_StandardInput);
 752         SelectOutput(cli->cli_StandardOutput);
 753     }
 754     else
 755     {
 756         /* PutStr("Erroneous command line.\n"); */
 757         PrintFault(result, filtered.CS_Buffer);
 758     }
 759
 760 exit:
 761     FreeVec(filtered.CS_Buffer);
 762
 763     if (cli->cli_Interactive)
 764     {
 765         Flush(Output());
 766         Flush(Error());
 767     }
 768
 769     return result;
 770 }
 771
 772 static void substArgs(struct CSource *filtered, CONST_STRPTR s, LONG size,
 773                       struct InterpreterState *is)
 774 {
 775     CONST_STRPTR send = s + size;
 776     LONG i, len;
 777
 778     while (s < send)
 779     {
 780         if (s[0] == is->bra)
 781         {
 782             char buf[32];
 783
 784             ++s;
 785             if (s[0] == is->dollar && s[1] == is->dollar && s[2] == is->ket)
 786             {
 787                 /* <$$> CLI number substitution */
 788                 s += 3;
 789                 len = sprintf(buf, "%d", is->cliNumber);
 790                 appendString(filtered, buf, len);
 791             }
 792             else for (i = 0; i < is->argcount; ++i)
 793             {
 794                 len = is->argnamelen[i];
 795                 if (strncmp(s, is->argname[i], len) == 0)
 796                 {
 797                     CONST_STRPTR pos = strchr(s + len, is->ket);
 798
 799                     if (s[len] == is->dollar && !is->arg[i] && pos)
 800                     {
 801                         /* default argument */
 802                         s += len + 1;
 803                         appendString(filtered, s, pos - s);
 804                         s = pos + 1;
 805                         break;
 806                     }
 807                     else if (s[len] == is->ket || s[len] == is->dollar && pos)
 808                     {
 809                         /* argument substitution */
 810                         STRPTR arg = NULL;
 811                         UBYTE t = is->argtype[i];
 812
 813                         s = pos + 1;
 814                         if (t & KEYWORD)
 815                         {
 816                             arg = is->argname[i];
 817                             len = is->argnamelen[i];
 818                         }
 819                         else if (t & (SWITCH | TOGGLE))
 820                         {
 821                             arg = is->arg[i] ? "1" : "0";
 822                             len = 1;
 823                         }
 824                         else if (t & NUMERIC)
 825                         {
 826                             if (is->arg[i])
 827                             {
 828                                 LONG value;
 829
 830                                 if (t & MULTIPLE)
 831                                 {
 832                                     LONG **m = (LONG**)is->arg[i];
 833
 834                                     bug("[Shell] substArgs: %s -> ",
 835                                         is->argname[i]);
 836
 837                                     arg = (STRPTR)1;
 838                                     while (*m)
 839                                     {
 840                                         if (arg == (STRPTR)1)
 841                                             arg = 0;
 842                                         else
 843                                             appendString(filtered, " ", 1);
 844
 845                                         value = **m;
 846                                         bug("%d ", value);
 847                                         len = sprintf(buf, "%d", value);
 848                                         appendString(filtered, buf, len);
 849                                         ++m;
 850                                     }
 851
 852                                     bug("\n");
 853                                     break;
 854                                 }
 855                                 else
 856                                 {
 857                                     value = *(LONG*)is->arg[i];
 858                                     len = sprintf(buf, "%d", value);
 859                                     arg = buf;
 860                                 }
 861                             }
 862                             else
 863                             {
 864                                 arg = (STRPTR)is->argdef[i];
 865                                 len = is->argdeflen[i];
 866                             }
 867                         }
 868                         else if (t & MULTIPLE)
 869                         {
 870                             CONST_STRPTR *m = (CONST_STRPTR*)is->arg[i];
 871
 872                             bug("[Shell] substArgs: %s -> ", is->argname[i]);
 873                             if (!m || !*m)
 874                             {
 875                                 arg = (STRPTR)is->argdef[i];
 876                                 len = is->argdeflen[i];
 877
 878                                 bug("%s\n", arg);
 879
 880                                 if (arg > 0)
 881                                     appendString(filtered, arg, len);
 882                                 break;
 883                             }
 884
 885                             arg = (STRPTR)1;
 886                             while (*m)
 887                             {
 888                                 if (arg == (STRPTR)1)
 889                                     arg = 0;
 890                                 else
 891                                     appendString(filtered, " ", 1);
 892
 893                                 bug("%s ", *m);
 894                                 len = strlen(*m);
 895                                 appendString(filtered, *m, len);
 896
 897                                 ++m;
 898                             }
 899                             bug("\n");
 900
 901                             break;
 902                         }
 903                         else
 904                         {
 905                             arg = (STRPTR)is->arg[i];
 906                             if (!arg)
 907                             {
 908                                 arg = (STRPTR)is->argdef[i];
 909                                 len = is->argdeflen[i];
 910                             }
 911                             else
 912                                 len = is->arglen[i];
 913                         }
 914
 915                         bug("[Shell] substArgs: %s -> %s\n",
 916                             is->argname[i], arg);
 917
 918                         if (arg > 0)
 919                             appendString(filtered, arg, len);
 920                         break;
 921                     }
 922                 }
 923             }
 924
 925             if (is->argcount == i)
 926                 appendString(filtered, s - 1, 1);
 927         }
 928         else
 929             appendString(filtered, s++, 1);
 930     }
 931 }
 932
 933 static BOOL doCommand(struct CSource *cs, struct CSource *filtered,
 934                       CONST_STRPTR cmd1, LONG l1,
 935                       CONST_STRPTR cmd2, LONG l2,
 936                       TEXT *res, LONG *error,
 937                       struct InterpreterState *is)
 938 {
 939     CONST_STRPTR s = cs->CS_Buffer + cs->CS_CurChr + 1;
 940     CONST_STRPTR start = s;
 941     LONG len = l1;
 942     BOOL match = FALSE;
 943
 944     if (strncasecmp(s, cmd1, l1) == 0)
 945         match = TRUE;
 946     else if (cmd2 && strncasecmp(s, cmd2, l2) == 0)
 947     {
 948         match = TRUE;
 949         len = l2;
 950     }
 951
 952     if (match)
 953     {
 954         s += len;
 955         while (s[0] == ' ' || s[0] == '\t')
 956             ++s;
 957
 958         if (s[0] == '\n' || s[0] == '\0')
 959         {
 960             appendString(filtered, &is->dot, 1);
 961             appendString(filtered, start, len);
 962             *error = ERROR_REQUIRED_ARG_MISSING;
 963             return TRUE;
 964         }
 965         else
 966         {
 967             *res = s[0];
 968             cs->CS_CurChr += s - start + 2;
 969         }
 970
 971         return TRUE;
 972     }
 973
 974     return FALSE;
 975 }
 976
 977
 978 /* The shell has the following semantics when it comes to command lines:
 979    Redirection (<,>,>>) may be written anywhere (except before the command
 980    itself); the following item (as defined by ReadItem() is the redirection
 981    file. The first item of the command line is the command to be executed.
 982    This may be an alias, that is there is a Local LV_ALIAS variable that
 983    should be substituted for the command text. Aliasing only applies to
 984    commands and not to options, for instance. Variables (set by SetEnv or Set)
 985    may be referenced by prepending a '$' to the variable name. */
 986
 987 LONG convertLine(struct CSource *filtered, struct CSource *cs,
 988                  struct Redirection *rd, struct InterpreterState *is)
 989 {
 990
 991 #define item       cs->CS_Buffer[cs->CS_CurChr]
 992 #define from       cs->CS_Buffer
 993 #define advance(x) cs->CS_CurChr += x;
 994
 995     LONG result;
 996
 997     while(TRUE)
 998     {
 999         D(bug("Str: %s\n", cs->CS_Buffer+cs->CS_CurChr));
1000
1001         while(item == ' ' || item == '\t')
1002         {
1003             STRPTR temp = " ";
1004
1005             temp[0] = item;
1006
1007             appendString(filtered, temp, 1);
1008             advance(1);
1009         }
1010
1011         /* Are we done yet? */
1012         if(item == '\n' || item == ';' || item == '\0')
1013             break;
1014
1015         if(item == '|')
1016         {
1017             BPTR pipefhs[2] = {0, 0};
1018             int i;
1019             struct TagItem tags[] =
1020             {
1021                 { SYS_Input   , (IPTR) NULL                                     },
1022                 { SYS_Output  , SYS_DupStream                                   },
1023                 { SYS_Error   , SYS_DupStream                                   },
1024                 { SYS_Asynch  , TRUE                                            },
1025                 { NP_StackSize, cli->cli_DefaultStack * CLI_DEFAULTSTACK_UNIT },
1026                 { TAG_DONE    , 0                                               }
1027             };
1028
1029             /* Prevent command lines like "Prompt> | Olle echo Oepir" */
1030             if(!rd->haveCommand)
1031                 return ERROR_ACTION_NOT_KNOWN;
1032
1033             item = 0;
1034
1035             /* There must be something after a pipe... */
1036             for
1037             (
1038                 i = cs->CS_CurChr + 1;
1039                 cs->CS_Buffer[i] == ' ' || cs->CS_Buffer[i] == '\t';
1040                 i++
1041             );
1042
1043             if(cs->CS_Buffer[i] == '\n' || cs->CS_Buffer[i] == ';' || cs->CS_Buffer[i] == '\0')
1044             {
1045                 SetIoErr(ERROR_LINE_TOO_LONG); /* what kind of error must we report? */
1046                 return ERROR_LINE_TOO_LONG;
1047             }
1048
1049             D(bug("commannd = %S\n", &item+1));
1050
1051             if(rd->haveOutRD)
1052             {
1053                 if (SystemTagList(&item+1, tags) == -1)
1054                     return IoErr();
1055             }
1056             else
1057             {
1058                 if (Pipe("PIPEFS:", &pipefhs[0], &pipefhs[1]) != DOSTRUE)
1059                     return IoErr();
1060
1061                 tags[0].ti_Data = (IPTR)pipefhs[0];
1062
1063                 if (SystemTagList(&item+1, tags) == -1)
1064                 {
1065                     LONG error = IoErr();
1066
1067                     Close(pipefhs[0]);
1068                     Close(pipefhs[1]);
1069
1070                     return error;
1071                 }
1072
1073                 rd->oldOut = SelectOutput(pipefhs[1]);
1074                 rd->newOut = pipefhs[1];
1075             }
1076         }
1077         else
1078         if(item == '<')
1079         {
1080             /* Prevent command lines like "Prompt> <Olle type" */
1081             if(!rd->haveCommand)
1082                 return ERROR_ACTION_NOT_KNOWN;
1083
1084             /* Multiple redirections not allowed */
1085             if(rd->haveInRD)
1086                 return ERROR_TOO_MANY_LEVELS;
1087
1088             advance(1);
1089             result = ReadItem(rd->inFileName, FILENAME_LEN, cs);
1090
1091             D(bug("Found input redirection\n"));
1092
1093             if(result == ITEM_ERROR || result == ITEM_NOTHING)
1094                 return ERROR_OBJECT_NOT_FOUND;
1095
1096             rd->haveInRD = TRUE;
1097         }
1098         else if(item == '>')
1099         {
1100             /* Prevent command lines like "Prompt> >>Olle echo Oepir" */
1101             if(!rd->haveCommand)
1102                 return ERROR_ACTION_NOT_KNOWN;
1103
1104             advance(1);
1105
1106             if(item == '>')
1107             {
1108                 /* Multiple redirections not allowed */
1109                 if(rd->haveAppRD)
1110                     return ERROR_TOO_MANY_LEVELS;
1111
1112                 advance(1);
1113                 result = ReadItem(rd->outFileName, FILENAME_LEN, cs);
1114
1115                 D(bug("Found append redirection\n"));
1116
1117                 if(result == ITEM_ERROR || result == ITEM_NOTHING)
1118                     return ERROR_OBJECT_NOT_FOUND;
1119
1120                 rd->haveAppRD = TRUE;
1121             }
1122             else
1123             {
1124                 /* Multiple redirections not allowed */
1125                 if(rd->haveOutRD)
1126                     return ERROR_TOO_MANY_LEVELS;
1127
1128                 result = ReadItem(rd->outFileName, FILENAME_LEN, cs);
1129
1130                 D(bug("Found output redirection\n"));
1131
1132                 if(result == ITEM_ERROR || result == ITEM_NOTHING)
1133                     return ERROR_OBJECT_NOT_FOUND;
1134
1135                 rd->haveOutRD = TRUE;
1136             }
1137         }
1138         else if (item == is->dollar) /* Possible environment variable usage */
1139         {
1140             LONG size = cs->CS_CurChr;
1141
1142             advance(1);
1143             result = ReadItem(avBuffer, sizeof(avBuffer), cs);
1144
1145             D(bug("Found variable\n"));
1146
1147             if(result == ITEM_ERROR || ITEM_NOTHING)
1148                 return ERROR_REQUIRED_ARG_MISSING;
1149
1150             if
1151             (
1152                 (GetVar(avBuffer, varBuffer, sizeof(varBuffer),
1153                        GVF_GLOBAL_ONLY | LV_VAR) != -1) &&
1154                 !(varBuffer[0] == '$' && !strcmp(varBuffer+1, avBuffer))
1155             )
1156             {
1157                 LONG result;
1158                 struct CSource varCs = { varBuffer, sizeof(varBuffer), 0 };
1159
1160                 D(bug("Real variable! Value = %s\n", varBuffer));
1161
1162                 if ((result = convertLine(filtered, &varCs, rd, is)) != 0)
1163                     return result;
1164             }
1165             else
1166                 /* If this "variable" wasn't defined, we use the '$' as a
1167                    regular character */
1168             {
1169                 D(bug("No real variable\n"));
1170
1171                 if(!rd->haveCommand)
1172                 {
1173                     cs->CS_CurChr = size;
1174                     getCommand(filtered, cs, rd, is);
1175                 }
1176                 else
1177                     appendString(filtered, cs->CS_Buffer + size,
1178                                  cs->CS_CurChr - size);
1179             }
1180         }
1181         else
1182         {
1183             STRPTR s = &item;
1184
1185             if (strncmp(s, ".popis\n", 7) == 0)
1186             {
1187                 popInterpreterState(is);
1188                 return 0;
1189             }
1190             else if (strncmp(s, ".pushis\n", 8) == 0)
1191             {
1192                 pushInterpreterState(is);
1193                 return 0;
1194             }
1195             else if (item == is->dot)
1196             {
1197                 LONG error = 0, i, j, len;
1198
1199                 ++s;
1200
1201                 if (s[0] == ' ') /* dot comment */
1202                     return 0;
1203                 else if (doCommand(cs, filtered, "bra ", 4, NULL, 0,
1204                                    &is->bra, &error, is))
1205                 {
1206                     return error;
1207                 }
1208                 else if (doCommand(cs, filtered, "ket ", 4, NULL, 0,
1209                                    &is->ket, &error, is))
1210                 {
1211                     return error;
1212                 }
1213                 else if (doCommand(cs, filtered, "dollar ", 7, "dol ", 4,
1214                                    &is->dollar, &error, is))
1215                 {
1216                     return error;
1217                 }
1218                 else if (doCommand(cs, filtered, "dot ", 4, NULL, 0,
1219                                    &is->ket, &error, is))
1220                 {
1221                     return error;
1222                 }
1223                 else if (strncasecmp(s, "key ", 4) == 0 ||
1224                          strncasecmp(s, "k ", 2) == 0)
1225                 {
1226                     /* .key must be the first line of the script */
1227                     struct RDArgs *rd;
1228
1229                     len = s[1] == ' ' ? 2 : 4;
1230                     appendString(filtered, &is->dot, 1);
1231                     appendString(filtered, s, len);
1232                     advance(++len);
1233
1234                     if (is->rdargs)
1235                     {
1236                         appendString(filtered, "duplicate", 10);
1237                         FreeDosObject(DOS_RDARGS, is->rdargs);
1238                         is->rdargs = NULL;
1239                         return ERROR_ACTION_NOT_KNOWN;
1240                     }
1241
1242                     is->rdargs = AllocDosObject(DOS_RDARGS, NULL);
1243                     if (is->rdargs)
1244                     {
1245                         result = ReadItem(argBuffer, sizeof(argBuffer), cs);
1246
1247                         if (result == ITEM_ERROR)
1248                             return ERROR_UNKNOWN;
1249
1250                         if (result == ITEM_NOTHING)
1251                             return ERROR_KEY_NEEDS_ARG;
1252
1253                         len = strlen(argBuffer);
1254                         appendString(filtered, argBuffer, len + 1);
1255
1256                         s = AROS_BSTR_ADDR(cli->cli_CommandName);
1257                         len = AROS_BSTR_strlen(cli->cli_CommandName);
1258                         is->rdargs->RDA_Source.CS_Buffer = s;
1259                         is->rdargs->RDA_Source.CS_Length = len;
1260                         is->rdargs->RDA_Source.CS_CurChr = 0;
1261
1262                         rd = ReadArgs(argBuffer, is->arg, is->rdargs);
1263                         if (rd)
1264                         {
1265                             UBYTE t;
1266
1267                             s = argBuffer;
1268                             is->argcount = 0;
1269
1270                             for (i = 0; i < MAXARGS; ++i)
1271                             {
1272                                 len = 0;
1273
1274                                 while (s[0] == ' ' || s[0] == '\t')
1275                                     ++s;
1276
1277                                 while (s[0] != '/' && s[0] != '\0')
1278                                 {
1279                                     ++len;
1280                                     ++s;
1281                                 }
1282
1283                                 j = getArgumentIdx(is, s - len, len);
1284                                 if (j < 0)
1285                                     return ERROR_UNKNOWN;
1286
1287                                 t = NORMAL;
1288                                 while (s[0] == '/')
1289                                 {
1290                                     switch (*++s)
1291                                     {
1292                                     case 'A': t |= REQUIRED; break;
1293                                     case 'K': t |= KEYWORD;  break;
1294                                     case 'M': t |= MULTIPLE; break;
1295                                     case 'S': t |= SWITCH;   break;
1296                                     case 'T': t |= TOGGLE;   break;
1297                                     case 'N': t |= NUMERIC;  break;
1298                                     case 'F': t |= REST;     break;
1299                                     default: return ERROR_UNKNOWN;
1300                                     }
1301                                     ++s;
1302                                 }
1303
1304                                 is->argtype[j] = t;
1305
1306                                 while (s[0] != ',' && s[0] != '\0')
1307                                     ++s;
1308
1309                                 if (!(t & (NUMERIC | SWITCH | TOGGLE)))
1310                                     if (is->arg[j])
1311                                         is->arglen[j] =
1312                                             strlen((STRPTR)is->arg[j]);
1313
1314                                 if (s[0] == '\0')
1315                                     break;
1316                                 ++s;
1317                             }
1318
1319 #if DEBUG1
1320                             kprintf("[Shell] argcount=%d\n", is->argcount);
1321                             for (i = 0; i < is->argcount; ++i)
1322                             {
1323                                 t = is->argtype[i];
1324                                 if (t & (SWITCH | TOGGLE | NUMERIC))
1325                                 {
1326                                     kprintf("[Shell] .key[%s]/%02x = %d\n",
1327                                         is->argname[i], (int)is->argtype[i],
1328                                         is->arg[i]);
1329                                 }
1330                                 else if (t & MULTIPLE)
1331                                 {
1332                                     CONST_STRPTR *m = (CONST_STRPTR*)is->arg[i];
1333
1334                                     kprintf("[Shell] .key[%s]/%02x = ",
1335                                         is->argname[i], (int)is->argtype[i]);
1336                                     while (*m)
1337                                     {
1338                                         kprintf("%s ", *m);
1339                                         ++m;
1340                                     }
1341                                     kprintf("\n");
1342                                 }
1343                                 else
1344                                 {
1345                                     kprintf("[Shell] .key[%s]/%02x = %s\n",
1346                                         is->argname[i], (int)is->argtype[i],
1347                                         is->arg[i]);
1348                                 }
1349                             }
1350 #endif
1351                         }
1352                         else
1353                         {
1354                             error = IoErr();
1355                             D(bug("[Shell] bad args for: %s\n", argBuffer));
1356                             FreeDosObject(DOS_RDARGS, is->rdargs);
1357                             is->rdargs = NULL;
1358                             return error;
1359                         }
1360
1361                         return 0;
1362                     }
1363                     else
1364                     {
1365                         D(bug("[Shell] memory exhausted\n"));
1366                         return ERROR_NO_FREE_STORE;
1367                     }
1368                 }
1369                 else if (strncasecmp(s, "default ", 8) == 0 ||
1370                          strncasecmp(s, "def ", 4) == 0)
1371                 {
1372                     len = s[3] == ' ' ? 5 : 9;
1373                     advance(len);
1374
1375                     i = cs->CS_CurChr;
1376                     result = ReadItem(argBuffer, sizeof(argBuffer), cs);
1377
1378                     if (result == ITEM_UNQUOTED)
1379                     {
1380                         len = cs->CS_CurChr - i;
1381
1382                         i = getArgumentIdx(is, argBuffer, len);
1383                         if (i < 0)
1384                             return ERROR_UNKNOWN;
1385
1386                         advance(1);
1387                         len = cs->CS_CurChr;
1388                         result = ReadItem(argBuffer, sizeof(argBuffer), cs);
1389                         len = cs->CS_CurChr - len;
1390                         switch (result)
1391                         {
1392                         case ITEM_ERROR:
1393                             return ERROR_UNKNOWN;
1394                         case ITEM_NOTHING:
1395                             return ERROR_REQUIRED_ARG_MISSING;
1396                         default:
1397                             if (is->argdef[i])
1398                                 FreeMem((APTR)is->argdef[i], is->argdeflen[i] + 1);
1399
1400                             is->argdef[i] = (IPTR)AllocMem(len + 1, MEMF_LOCAL);
1401                             CopyMem(argBuffer, (APTR)is->argdef[i], len);
1402                             ((STRPTR)is->argdef[i])[len] = '\0';
1403                             is->argdeflen[i] = len;
1404                             advance(len);
1405                             return 0;
1406                         }
1407                     }
1408                 }
1409             }
1410
1411             /* This is a regular character -- that is, we have a command */
1412             if(!rd->haveCommand)
1413             {
1414                 D(bug("Found possible command\n"));
1415
1416                 getCommand(filtered, cs, rd, is);
1417             }
1418             else
1419             {
1420                 /* Copy argument */
1421                 LONG size = cs->CS_CurChr;
1422
1423                 result = ReadItem(argBuffer, sizeof(argBuffer), cs);
1424
1425                 /*??AGR who coded this shit ? */
1426                 if(result == ITEM_ERROR || ITEM_NOTHING)
1427                     return ERROR_UNKNOWN;
1428
1429                 D(bug("\nFound argument %s\n", argBuffer));
1430                 substArgs(filtered, from + size, cs->CS_CurChr - size, is);
1431             }
1432         }
1433     }
1434
1435     D(bug("Exiting convertLine()\n"));
1436
1437     return 0;
1438 }
1439
1440
1441
1442
1443 BOOL getCommand(struct CSource *filtered, struct CSource *cs,
1444                 struct Redirection *rd, struct InterpreterState *is)
1445 {
1446     LONG  result;
1447
1448     rd->haveCommand = TRUE;
1449
1450     D(bug("Command found!\n"));
1451
1452     result = ReadItem(rd->commandStr, COMMANDSTR_LEN, cs);
1453
1454     if(result == ITEM_ERROR || result == ITEM_NOTHING)
1455         return FALSE;
1456
1457     /* Is this command an alias? */
1458     if(GetVar(rd->commandStr, avBuffer, sizeof(avBuffer),
1459               GVF_LOCAL_ONLY | LV_ALIAS) != -1)
1460     {
1461         struct CSource aliasCs = { avBuffer, sizeof(avBuffer), 0 };
1462
1463         result = ReadItem(rd->commandStr, COMMANDSTR_LEN, &aliasCs);
1464
1465         D(bug("Found alias! value = %s\n", avBuffer));
1466
1467         if(result == ITEM_ERROR || result == ITEM_NOTHING)
1468             return FALSE;
1469
1470         /* We don't check if the alias was an alias as that might
1471            lead to infinite loops (alias Copy Copy) */
1472
1473         /* Make a recursive call to take care of the rest of the
1474            alias string */
1475         return convertLine(filtered, &aliasCs, rd, is);
1476     }
1477
1478     D(bug("Command = %s\n", rd->commandStr));
1479
1480     return TRUE;
1481 }
1482
1483 #undef item
1484 #undef from
1485 #undef advance
1486
1487 #define __extendSize  512       /* How much to increase buffer if it's full */
1488
1489
1490 BOOL readLine(struct CommandLine *cl, BPTR inputStream)
1491 {
1492     LONG letter;
1493
1494     while(TRUE)
1495     {
1496         letter = inputStream ? FGetC(inputStream) : EOF;
1497
1498         D(bug("Read character %c (%d)\n", letter, letter));
1499
1500         /* -2 to skip test for boundary for terminating '\n\0' */
1501         if(cl->position > (cl->size - 2))
1502         {
1503             STRPTR newString = AllocVec(cl->size + __extendSize, MEMF_ANY);
1504
1505             D(bug("Allocated new buffer %p\n", newString));
1506
1507             if(cl->line  != NULL)
1508                 CopyMem(cl->line, newString, cl->size);
1509
1510             cl->size += __extendSize;
1511             FreeVec(cl->line);
1512             cl->line = newString;
1513         }
1514
1515         if(letter == '\n' || letter == EOF)
1516         {
1517             D(bug("Found end of line\n"));
1518             break;
1519         }
1520
1521         cl->line[cl->position++] = letter;
1522     }
1523
1524     /* Terminate the line with a newline and a NULL terminator */
1525     cl->line[cl->position++] = '\n';
1526     cl->line[cl->position++] = '\0';
1527
1528     D(bug("commandline: %s\n", cl->line));
1529
1530     if(letter == EOF)
1531         return FALSE;
1532
1533     return TRUE;
1534 }
1535
1536
1537 /* Currently, there is no error checking involved */
1538 BOOL appendString(struct CSource *cs, CONST_STRPTR fromStr, LONG size)
1539 {
1540     /* +2 for additional null bytes, '\n', \0' */
1541     while(cs->CS_CurChr + size + 2 > (cs->CS_Length - cs->CS_CurChr))
1542     {
1543         STRPTR newString = AllocVec(cs->CS_Length + __extendSize, MEMF_ANY);
1544
1545         CopyMem(cs->CS_Buffer, newString, cs->CS_Length);
1546         cs->CS_Length += __extendSize;
1547         FreeVec(cs->CS_Buffer);
1548         cs->CS_Buffer = newString;
1549     }
1550
1551     while(size > 0)
1552     {
1553         cs->CS_Buffer[cs->CS_CurChr++] = *fromStr++;
1554         size--;
1555     }
1556
1557     return TRUE;
1558 }
1559
1560 void unloadCommand(BPTR commandSeg, struct ShellState *ss)
1561 {
1562     if (!cli->cli_Module) return;
1563
1564     if(ss->residentCommand)
1565     {
1566         struct Segment *residentSeg = (struct Segment *)BADDR(commandSeg);
1567
1568         Forbid();
1569
1570         /* Decrease usecount */
1571         if(residentSeg->seg_UC > 0)
1572             residentSeg->seg_UC--;
1573
1574         Permit();
1575
1576         ss->residentCommand = FALSE;
1577     }
1578     else
1579         UnLoadSeg(commandSeg);
1580
1581 #if SET_HOMEDIR
1582     if (ss->homeDirChanged)
1583     {
1584         UnLock(SetProgramDir(ss->oldHomeDir));
1585         ss->homeDirChanged = FALSE;
1586     }
1587 #endif
1588 }
1589
1590
1591 BPTR loadCommand(STRPTR commandName, struct ShellState *ss)
1592 {
1593     BPTR   oldCurDir;
1594     BPTR   commandSeg = NULL;
1595     BPTR  *paths;
1596     struct Segment *residentSeg;
1597     BOOL   absolutePath = strpbrk(commandName, "/:") != NULL;
1598     BPTR   file;
1599
1600     /* We check the resident lists only if we do not have an absolute path */
1601     if(!absolutePath)
1602     {
1603         Forbid();
1604
1605         /* Check regular list first... */
1606         residentSeg = FindSegment(commandName, NULL, FALSE);
1607
1608         if(residentSeg == NULL)
1609         {
1610             /* ... then the system list */
1611             residentSeg = FindSegment(commandName, NULL, TRUE);
1612         }
1613
1614         if(residentSeg != NULL)
1615         {
1616             /* Can we use this command? */
1617             if(residentSeg->seg_UC == CMD_INTERNAL || residentSeg->seg_UC >= 0)
1618             {
1619                 if(residentSeg->seg_UC >= 0)
1620                     residentSeg->seg_UC++;
1621
1622                 ss->residentCommand = TRUE;
1623                 Permit();
1624                 return MKBADDR(residentSeg);
1625             }
1626         }
1627
1628         Permit();
1629     }
1630
1631     ss->residentCommand = FALSE;
1632
1633     D(bug("Trying to load command1: %s\n", commandName));
1634
1635     oldCurDir = CurrentDir(NULL);
1636     CurrentDir(oldCurDir);
1637
1638     file = Open(commandName, MODE_OLDFILE);
1639
1640     if (!file)
1641     {
1642         if
1643         (
1644             absolutePath ||                 /* If this was an absolute path, we don't check the paths set by
1645                                                'path' or the C: multiassign */
1646             IoErr() == ERROR_OBJECT_IN_USE  /* The object might be exclusively locked */
1647         )
1648         return NULL;
1649
1650         /* Search the command in the path */
1651
1652         for
1653         (
1654             paths = (BPTR *)BADDR(cli->cli_CommandDir);
1655             file == NULL && paths != NULL;
1656             paths = (BPTR *)BADDR(paths[0])    /* Go on with the next path */
1657         )
1658         {
1659             CurrentDir(paths[1]);
1660             file = Open(commandName, MODE_OLDFILE);
1661         }
1662
1663         /* The last resort -- the C: multiassign */
1664         if (!file)
1665         {
1666             commandName-=2;
1667             file = Open(commandName, MODE_OLDFILE);
1668         }
1669     }
1670
1671     if (file)
1672     {
1673         commandSeg = LoadSeg(commandName);
1674
1675         #if SET_HOMEDIR
1676         if (commandSeg)
1677         {
1678             BPTR lock = ParentOfFH(file);
1679
1680             if (lock)
1681             {
1682                 ss->oldHomeDir = SetProgramDir(lock);
1683                 ss->homeDirChanged = TRUE;
1684             }
1685         }
1686         else
1687         #endif
1688         {
1689             struct FileInfoBlock fib;
1690             if (Examine(file, &fib) && fib.fib_Protection & FIBF_SCRIPT)
1691             {
1692                 commandSeg = LoadSeg("C:Execute");
1693                 if (commandSeg)
1694                 {
1695                     ss->script = TRUE;
1696                     ss->scriptLock = Lock(commandName, SHARED_LOCK);
1697                 }
1698             }
1699             else
1700                 SetIoErr(ERROR_FILE_NOT_OBJECT);
1701         }
1702
1703         Close(file);
1704     }
1705
1706     CurrentDir(oldCurDir);
1707
1708     return commandSeg;
1709 }
1710
1711
1712 /* Execute one command */
1713 LONG executeLine(STRPTR command, STRPTR commandArgs, struct Redirection *rd,
1714                  struct InterpreterState *is)
1715 {
1716     BPTR              module;
1717     LONG              error = 0;
1718     struct ShellState ss = {FALSE};
1719     TEXT cmd[4096];
1720
1721     ss.script = FALSE;
1722
1723 /*
1724   if ss->residentCommand isn't initialized as FALSE, it's value is rather
1725   random ( loadCommand doesn't change it ) so unloadCommand almost always
1726   thinks that last Command was resident, and doesn't do an UnloadSeg...
1727 */
1728
1729     D(bug("Trying to load command: %s\nArguments: %s\n", command,
1730              commandArgs));
1731
1732     module = loadCommand(command, &ss);
1733
1734     /* Set command name even if we couldn't load the command to be able to
1735        report errors correctly */
1736     SetProgramName(command);
1737
1738     if(module != NULL)
1739     {
1740         struct Task *me = FindTask(NULL);
1741         STRPTR oldtaskname = me->tc_Node.ln_Name;
1742         BOOL  __debug_mem;
1743         LONG mem_before;
1744
1745         BPTR seglist = ss.residentCommand ? ((struct Segment *)BADDR(module))->seg_Seg:module;
1746
1747         STRPTR dst = cmd, src;
1748         LONG len = 0;
1749
1750         if (ss.script)
1751         {
1752             *dst++ = '"';
1753             NameFromLock(ss.scriptLock, dst, sizeof(cmd));
1754             while (*dst != '\0')
1755             {
1756                 ++dst;
1757                 ++len;
1758             }
1759             *dst++ = '"';
1760             *dst++ = ' ';
1761             UnLock(ss.scriptLock);
1762             len += 2;
1763
1764 #if 0
1765             error = pushInterpreterState(is);
1766             if (error)
1767             {
1768                 D(bug("Returned from command %s\n", command));
1769                 unloadCommand(module, &ss);
1770                 cli->cli_Result2 = error;
1771                 return RETURN_FAIL;
1772             }
1773 #endif
1774         }
1775
1776         src = commandArgs;
1777         if (src[0] == ' ')
1778             ++src;
1779
1780         for (; *src != '\0'; ++dst, ++src, ++len)
1781             *dst = *src;
1782         *dst = '\0';
1783
1784         D(bug("Command loaded: len=%d, args=%s\n", len, cmd));
1785
1786         SetIoErr(0);                     /* Clear error before we execute this command */
1787         SetSignal(0, SIGBREAKF_CTRL_C);
1788
1789         cli->cli_Module = seglist;
1790
1791         me->tc_Node.ln_Name = command;
1792
1793         __debug_mem = FindVar("__debug_mem", LV_VAR) != NULL;
1794
1795         if (__debug_mem)
1796         {
1797             FreeVec(AllocVec(~0ul/2, MEMF_ANY)); /* Flush memory */
1798
1799             mem_before = AvailMem(MEMF_ANY);
1800             Printf("Available total memory before command execution: %10ld\n", mem_before);
1801         }
1802
1803         cli->cli_ReturnCode = RunCommand(seglist, cli->cli_DefaultStack * CLI_DEFAULTSTACK_UNIT,
1804                                          cmd, len);
1805         if (__debug_mem)
1806         {
1807             LONG mem_after;
1808             FreeVec(AllocVec(~0ul/2, MEMF_ANY)); /* Flush memory */
1809
1810             mem_after = AvailMem(MEMF_ANY);
1811             Printf("Available total memory after command execution:  %10ld\n", mem_after);
1812             Printf("Memory difference (before - after):              %10ld\n", mem_before - mem_after);
1813         }
1814
1815         me->tc_Node.ln_Name = oldtaskname;
1816
1817         D(bug("Returned from command %s\n", command));
1818         unloadCommand(module, &ss);
1819
1820         cli->cli_Result2 = IoErr();
1821     }
1822     else
1823     {
1824         /* Implicit cd? */
1825         /* SFS returns ERROR_INVALID_COMPONENT_NAME if you try to open "" */
1826         if(!(rd->haveInRD || rd->haveOutRD || rd->haveAppRD) &&
1827            (IoErr() == ERROR_OBJECT_WRONG_TYPE || IoErr() == ERROR_OBJECT_NOT_FOUND || IoErr() == ERROR_INVALID_COMPONENT_NAME))
1828         {
1829             BPTR lock = Lock(command, SHARED_LOCK);
1830
1831             if(lock != NULL)
1832             {
1833                 struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
1834
1835                 if(fib != NULL)
1836                 {
1837                     if(Examine(lock, fib))
1838                     {
1839                         if(fib->fib_DirEntryType > 0)
1840                         {
1841                             setPath(lock);
1842                             lock = CurrentDir(lock);
1843                         }
1844                         else
1845                             SetIoErr(ERROR_OBJECT_WRONG_TYPE);
1846                     }
1847
1848                     FreeDosObject(DOS_FIB, fib);
1849                 }
1850
1851                 /* UnLock the old currentdir */
1852                 UnLock(lock);
1853             }
1854         }
1855
1856         if(IoErr())
1857         {
1858             cli->cli_Result2 = IoErr();
1859             PrintFault(IoErr(), command);
1860         }
1861     }
1862
1863     D(bug("Done with the command...\n"));
1864
1865     return error;
1866 }
1867
1868
1869 BOOL Redirection_init(struct Redirection *rd)
1870 {
1871     bzero(rd, sizeof(struct Redirection));
1872
1873     rd->commandStr  = AllocVec(COMMANDSTR_LEN, MEMF_CLEAR);
1874
1875     rd->outFileName = AllocVec(FILENAME_LEN, MEMF_CLEAR);
1876     rd->inFileName  = AllocVec(FILENAME_LEN, MEMF_CLEAR);
1877
1878     if(rd->commandStr == NULL || rd->outFileName == NULL ||
1879        rd->inFileName == NULL)
1880     {
1881         Redirection_release(rd);
1882         return FALSE;
1883     }
1884
1885     /* Preset the first bytes to "C:" to handle C: multiassigns */
1886     *rd->commandStr++ = 'C';
1887     *rd->commandStr++ = ':';
1888
1889     return TRUE;
1890 }
1891
1892
1893 void Redirection_release(struct Redirection *rd)
1894 {
1895     /* -2 as we set pointer 2 bytes ahead to be able to use C: as a multi-
1896        assign in a smooth way */
1897     FreeVec(rd->commandStr - 2);
1898     FreeVec(rd->outFileName);
1899     FreeVec(rd->inFileName);
1900
1901     releaseFiles(rd);
1902 }
1903
1904 static void printPath(void)
1905 {
1906     STRPTR  buf;
1907     ULONG   i;
1908
1909     for(i = 256; ; i += 256)
1910     {
1911         buf = AllocVec(i, MEMF_ANY);
1912
1913         if(buf == NULL)
1914             break;
1915
1916         if(GetCurrentDirName(buf, i) == DOSTRUE)
1917         {
1918             FPuts(Output(), buf);
1919             FreeVec(buf);
1920             break;
1921         }
1922
1923         FreeVec(buf);
1924
1925         if(IoErr() != ERROR_OBJECT_TOO_LARGE)
1926             break;
1927     }
1928 }
1929
1930
1931 static void setPath(BPTR lock)
1932 {
1933     BPTR    dir;
1934     STRPTR  buf;
1935     ULONG   i;
1936
1937     if(lock == NULL)
1938         dir = CurrentDir(NULL);
1939     else
1940         dir = lock;
1941
1942     for(i = 256; ; i += 256)
1943     {
1944         buf = AllocVec(i, MEMF_ANY);
1945
1946         if(buf == NULL)
1947             break;
1948
1949         if(NameFromLock(dir, buf, i))
1950         {
1951             SetCurrentDirName(buf);
1952             FreeVec(buf);
1953             break;
1954         }
1955
1956         FreeVec(buf);
1957     }
1958
1959     if(lock == NULL)
1960         CurrentDir(dir);
1961 }
1962
1963 static void printPrompt(struct InterpreterState *is)
1964 {
1965     BSTR prompt = cli->cli_Prompt;
1966     LONG length = AROS_BSTR_strlen(prompt);
1967     ULONG i;
1968
1969     for(i = 0; i < length; i++)
1970     {
1971         if(AROS_BSTR_getchar(prompt, i) == '%')
1972         {
1973             i++;
1974
1975             if(i == length)
1976                 break;
1977
1978             switch(AROS_BSTR_getchar(prompt, i))
1979             {
1980             case 'N':
1981             case 'n':
1982                 Printf("%ld", is->cliNumber);
1983                 break;
1984             case 'R':
1985             case 'r':
1986                 Printf("%ld", cli->cli_ReturnCode);
1987                 break;
1988             case 'S':
1989             case 's':
1990                 printPath();
1991                 break;
1992             default:
1993                 FPutC(Output(), '%');
1994                 FPutC(Output(), AROS_BSTR_getchar(prompt, i));
1995                 break;
1996             }
1997         }
1998         else
1999             FPutC(Output(), AROS_BSTR_getchar(prompt, i));
2000     }
2001
2002     Flush(Output());
2003 }
2004