G:/ScriptBasic/source/commands/file.c

Go to the documentation of this file.

/*file.c

--GNU LGPL
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library 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
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#if (!defined(_WIN32) && !defined(__MACOS__))
#include <sys/file.h>
#endif

#include "../command.h"
#include "../filesys.h"
#include "../match.h"
#include "../matchc.h"

#define THISFILEP  pFCO->Descriptor[FileNumber].fp
#define THISSOCKET pFCO->Descriptor[FileNumber].sp
/*
File functions and commands

This file contains the code for the commands and functions that deal with files.
*/
#if (!defined(_WIN32) && !defined(__MACOS__))
int stricmp(char *,char*);
#endif

#define MAXFILES 512
typedef struct _FileCommandObject {
  union {
    FILE *fp;  /* the file pointer to the opened file */
    SOCKET sp;
    }Descriptor[MAXFILES];
  long RecordSize[MAXFILES]; /* the length of a record */
  char mode[MAXFILES]; /* the mode the file was opened 'i', 'o', 'a', 'r' or 'b' */
                       /* 's' for client sockets */
                       /* '\0' for not opened file or socket */
  int SocketState[MAXFILES]; /*0 normal, -1 kind of EOF */
  } FileCommandObject, *pFileCommandObject;

static void close_all_files(pExecuteObject pEo){
  pFileCommandObject pFCO;
  long FileNumber;

  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);
  for( FileNumber = 0 ; FileNumber < MAXFILES ; FileNumber++ ){
    if( pFCO->mode[FileNumber] ){
      if( pFCO->mode[FileNumber] == 's' )
        HOOK_TCPCLOSE(THISSOCKET);
      else
        HOOK_FCLOSE(THISFILEP);
      }
    THISFILEP = NULL;
    }
  }

static int init(pExecuteObject pEo){
#define INITIALIZE init(pEo)
  pFileCommandObject pFCO;
  int i;

  /* initialize only once */
  if( PARAMPTR(CMD_OPEN) )return 0;
  PARAMPTR(CMD_OPEN) = ALLOC(sizeof(FileCommandObject));
  if( PARAMPTR(CMD_OPEN) == NULL )return COMMAND_ERROR_MEMORY_LOW;

  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);
  for( i=0 ; i < MAXFILES ; i++ )
    pFCO->mode[i] = (char)0;
  FINALPTR(CMD_OPEN) = close_all_files;
  return 0;
  }

/* Create the directory for a file in case it does not exists. */
static void prepare_directory(pExecuteObject pEo,char *pszFileName){
  int i;
  char *s;

  s = pszFileName + (i=strlen(pszFileName)) -1;
  while( i ){
#ifdef __MACOS__
    if( *s == ':' ){
#else
    if( *s == '/' || *s == '\\' ){
#endif
      i = *s;
      *s = (char)0;
      HOOK_MAKEDIRECTORY(pszFileName);
      *s = (char)i;
      return;
      }
    i--;
    s--;
    }
  }

/* check that a file name is secure */
static int FileIsSecure(pExecuteObject pEo,VARIABLE vFileName){
  unsigned long i;

  for( i=0 ; i < STRLEN(vFileName) ; i++ ){
    if( STRINGVALUE(vFileName)[i] == 0 )return 0;
    }
  return 1;
  }

#define SECUREFILE(x) if( ! FileIsSecure(pEo,x) )ERROR(COMMAND_ERROR_FILE_CANNOT_BE_OPENED);

COMMAND(OPEN)
#if NOTIMP_OPEN
NOTIMPLEMENTED;
#else


  long FileNumber,RecLen;
  char *FileName;
  char *ModeString;
  pFileCommandObject pFCO;
  VARIABLE Op1,FN,vLEN;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  Op1 = CONVERT2STRING(_EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  NEXTPARAMETER;
  ModeString = pEo->StringTable+pEo->CommandArray[_ActualNode-1].Parameter.CommandArgument.Argument.szStringValue;
  NEXTPARAMETER;
  FN = _EVALUATEEXPRESSION(PARAMETERNODE);
  ASSERTOKE;
  NEXTPARAMETER;
  vLEN = CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;

  if( memory_IsUndef(vLEN) )ERROR(COMMAND_ERROR_BAD_RECORD_LENGTH);
  RecLen = LONGVALUE(vLEN); /* the default record length is 1 */
  if( RecLen < 1 )ERROR(COMMAND_ERROR_BAD_RECORD_LENGTH);

  if( memory_IsUndef(FN) )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  if( TYPE(FN) == VTYPE_LONG && LONGVALUE(FN) == 0 ){/* we have to automatically allocate the file number */

    for( FileNumber = 1 ; FileNumber < MAXFILES ; FileNumber++ )
      if( ! pFCO->mode[FileNumber] )break;
    if( FileNumber >= MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
    LONGVALUE(FN) = FileNumber;
    }
  FileNumber = LONGVALUE(CONVERT2LONG(FN));

  if( FileNumber < 1 || FileNumber > MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  FileNumber --;
  if( pFCO->mode[FileNumber] )ERROR(COMMAND_ERROR_FILE_NUMBER_IS_USED);

  FileName = ALLOC(STRLEN(Op1)+1);
  if( FileName == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  memcpy(FileName,STRINGVALUE(Op1),STRLEN(Op1));
  FileName[STRLEN(Op1)] = (char)0;

  if( !stricmp(ModeString,"socket") || !stricmp(ModeString,"socket_binary")){
    if( HOOK_TCPCONNECT(&(THISSOCKET),FileName) ){
      FREE(FileName);
      pFCO->mode[FileNumber] = (char)0;
      ERROR(COMMAND_ERROR_FILE_CANNOT_BE_OPENED);
      }
    pFCO->mode[FileNumber] = 's';
    FREE(FileName);
    pFCO->RecordSize[FileNumber] = RecLen;
    pFCO->SocketState[FileNumber] = 0;
    RETURN;
    }else
  if( !stricmp(ModeString,"input") ){
    pFCO->mode[FileNumber] = 'i';
    if( HOOK_ISDIR(FileName) )
      THISFILEP = NULL;
    else
      THISFILEP = HOOK_FOPEN(FileName,"r");
    }else
  if( !stricmp(ModeString,"input_binary") ){
    pFCO->mode[FileNumber] = 'i';
    if( HOOK_ISDIR(FileName) )
      THISFILEP = NULL;
    else
      THISFILEP = HOOK_FOPEN(FileName,"rb");
    }else
  if( !stricmp(ModeString,"output") ){
    pFCO->mode[FileNumber] = 'o';
    if( HOOK_ISDIR(FileName) )
      THISFILEP = NULL;
    else{
      prepare_directory(pEo,FileName);
      THISFILEP = HOOK_FOPEN(FileName,"w");
      }
    }else
  if( !stricmp(ModeString,"output_binary") ){
    pFCO->mode[FileNumber] = 'o';
    if( HOOK_ISDIR(FileName) )
      THISFILEP = NULL;
    else{
      prepare_directory(pEo,FileName);
      THISFILEP = HOOK_FOPEN(FileName,"wb");
      }
    }else
  if( !stricmp(ModeString,"append") ){
    pFCO->mode[FileNumber] = 'a';
    if( HOOK_ISDIR(FileName) )
      THISFILEP = NULL;
    else{
      prepare_directory(pEo,FileName);
      THISFILEP = HOOK_FOPEN(FileName,"a");
      }
    }else
  if( !stricmp(ModeString,"append_binary") ){
    pFCO->mode[FileNumber] = 'a';
    if( HOOK_ISDIR(FileName) )
      THISFILEP = NULL;
    else{
      prepare_directory(pEo,FileName);
      THISFILEP = HOOK_FOPEN(FileName,"ab");
      }
    }else
  if( !stricmp(ModeString,"random") ){
    pFCO->mode[FileNumber] = 'r';
    if( HOOK_ISDIR(FileName) )
      THISFILEP = NULL;
    else{
      prepare_directory(pEo,FileName);
      THISFILEP = HOOK_FOPEN(FileName,"r+");
      if( THISFILEP == NULL )
        THISFILEP = HOOK_FOPEN(FileName,"w+");
      }
    }else
  if( !stricmp(ModeString,"binary") || !stricmp(ModeString,"random_binary") ){
    pFCO->mode[FileNumber] = 'b';
    if( HOOK_ISDIR(FileName) )
      THISFILEP = NULL;
    else{
      prepare_directory(pEo,FileName);
      THISFILEP = HOOK_FOPEN(FileName,"rb+");
      if( THISFILEP == NULL )
        THISFILEP = HOOK_FOPEN(FileName,"wb+");
      }
    }
  FREE(FileName);
  if( THISFILEP == NULL ){
    pFCO->mode[FileNumber] = (char)0;
    ERROR(COMMAND_ERROR_FILE_CANNOT_BE_OPENED);
    }
  pFCO->RecordSize[FileNumber] = RecLen;
#endif
END

static char *ReadFileLine(pExecuteObject pEo,
                          FILE *fp,
                          unsigned long *plCharactersRead,
                          int (*pfExtIn)(void *)){
  char *s,*r;
  unsigned long lBufferSize;
  int ch;
#define BUFFER_INCREASE 256

  s = ALLOC(BUFFER_INCREASE);
  if( s == NULL )return NULL;
  lBufferSize = BUFFER_INCREASE;
  *plCharactersRead = 0L;
  while( 1 ){
    if( (ch= (pfExtIn == NULL ? HOOK_FGETC(fp) : pfExtIn(pEo->pEmbedder) )) == EOF )break;
    if( lBufferSize <= *plCharactersRead ){
      r = ALLOC(lBufferSize+BUFFER_INCREASE);
      if( r == NULL ){
        FREE(s);
        return NULL;
        }
      memcpy(r,s,lBufferSize);
      lBufferSize += BUFFER_INCREASE;
      FREE(s);
      s = r;
      }
    s[(*plCharactersRead)++] = ch;
    if( ch == '\n' )break;
    }
  return s;
  }

static char *ReadSocketLine(pExecuteObject pEo,
                            SOCKET sp,
                            unsigned long *plCharactersRead){
  char *s,*r;
  unsigned long lBufferSize;
  char ch;
#define BUFFER_INCREASE 256

  s = ALLOC(BUFFER_INCREASE);
  if( s == NULL )return NULL;
  lBufferSize = BUFFER_INCREASE;
  *plCharactersRead = 0L;
  while( 1 ){
    if( HOOK_TCPRECV(sp,&ch,1,0) == 0 ){
      break;
      }
    if( lBufferSize <= *plCharactersRead ){
      r = ALLOC(lBufferSize+BUFFER_INCREASE);
      if( r == NULL ){
        FREE(s);
        return NULL;
        }
      memcpy(r,s,lBufferSize);
      lBufferSize += BUFFER_INCREASE;
      FREE(s);
      s = r;
      }
    s[(*plCharactersRead)++] = ch;
    if( ch == '\n' )break;
    }
  return s;
  }



COMMAND(LINPUTF)
#if NOTIMP_LINPUTF
NOTIMPLEMENTED;
#else

  long FileNumber;
  pFileCommandObject pFCO;
  VARIABLE Result;
  LEFTVALUE LetThisVariable;
  unsigned long lCharactersRead;
  char *s;
  long refcount;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;
  NEXTPARAMETER;
  /* we get the pointer to the variable that points to the value */
  LetThisVariable = EVALUATELEFTVALUE(PARAMETERNODE);
  ASSERTOKE;
  DEREFERENCE(LetThisVariable)

  if( FileNumber < 1 || FileNumber > MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )ERROR(COMMAND_ERROR_FILE_IS_NOT_OPENED);

  if( pFCO->mode[FileNumber] == 's' ){
    s = ReadSocketLine(pEo,THISSOCKET,&lCharactersRead);
    if( lCharactersRead == 0 )pFCO->SocketState[FileNumber] = -1;
    }
  else
    s = ReadFileLine(pEo,THISFILEP,&lCharactersRead,NULL);
  if( s == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  Result = NEWSTRING(lCharactersRead);
  memcpy(STRINGVALUE(Result),s,lCharactersRead);
  FREE(s);

  /* if this variable had value assigned to it then release that value */
  if( *LetThisVariable )memory_ReleaseVariable(pEo->pMo,*LetThisVariable);

  /* and finally assign the code to the variable */
  *LetThisVariable = Result;

#endif
END

COMMAND(LINPUT)
#if NOTIMP_LINPUT
NOTIMPLEMENTED;
#else

  VARIABLE Result;
  LEFTVALUE LetThisVariable;
  unsigned long lCharactersRead;
  char *s;
  long refcount;

  INITIALIZE;

  /* we get the pointer to the variable that points to the value */
  LetThisVariable = EVALUATELEFTVALUE(PARAMETERNODE);
  ASSERTOKE;
  DEREFERENCE(LetThisVariable)


  s = ReadFileLine(pEo,stdin,&lCharactersRead,(int (*)(void *))pEo->fpStdinFunction);
  if( s == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  Result = NEWSTRING(lCharactersRead);
  memcpy(STRINGVALUE(Result),s,lCharactersRead);
  FREE(s);

  /* if this variable had value assigned to it then release that value */
  if( *LetThisVariable )memory_ReleaseVariable(pEo->pMo,*LetThisVariable);

  /* and finally assign the code to the variable */
  *LetThisVariable = Result;
#endif
END

COMMAND(EOFFUN)
#if NOTIMP_EOFFUN
NOTIMPLEMENTED;
#else

  long FileNumber;
  pFileCommandObject pFCO;
  NODE nItem;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  USE_CALLER_MORTALS;

  nItem = PARAMETERLIST;
  FileNumber = LONGVALUE(CONVERT2LONG(_EVALUATEEXPRESSION(CAR(nItem))));
  ASSERTOKE;

  if( FileNumber < 1 || FileNumber > MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )ERROR(COMMAND_ERROR_FILE_IS_NOT_OPENED);

  if( pFCO->mode[FileNumber] == 's' ){
    RESULT = NEWMORTALLONG;
    ASSERTNULL(RESULT)
    LONGVALUE(RESULT) = (long)pFCO->SocketState[FileNumber];
    }else{
    RESULT = NEWMORTALLONG;
    ASSERTNULL(RESULT)
    if( HOOK_FEOF(THISFILEP) )
      LONGVALUE(RESULT) = -1L;
    else
      LONGVALUE(RESULT) =  0L;
    }
#endif
END

COMMAND(INPUTFUN)
#if NOTIMP_INPUTFUN
NOTIMPLEMENTED;
#else


  long FileNumber,BytesToRead,CharsRead;
  pFileCommandObject pFCO;
  NODE nItem;
  FILE *fp;
  VARIABLE fpN,vBTR;
  char *s;
  int ch;
  int (*pfExtIn)(void *); /* function to return a single character from the embedder standard input*/

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  USE_CALLER_MORTALS;

  nItem = PARAMETERLIST;
  vBTR = EVALUATEEXPRESSION(CAR(nItem));
  ASSERTOKE;
  if( memory_IsUndef(vBTR) ){
    /* we won't read anything because the number of characters is undefined, and therefore the
       result is undef, but we still evaluate the second argument if any */
    nItem = CDR(nItem);
    if( nItem ){
      _EVALUATEEXPRESSION(CAR(nItem));
      ASSERTOKE;

      }
    RESULT = NULL;
    RETURN;
    }
  BytesToRead = GETLONGVALUE(vBTR);
  nItem = CDR(nItem);
  if( nItem ){
    fpN = _EVALUATEEXPRESSION(CAR(nItem));
    ASSERTOKE;

    if( ! memory_IsUndef(fpN) ){
      FileNumber = GETLONGVALUE(fpN);

      if( FileNumber < 1 || FileNumber > MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
      FileNumber --;
      if( ! pFCO->mode[FileNumber] )ERROR(COMMAND_ERROR_FILE_IS_NOT_OPENED);
      BytesToRead *= pFCO->RecordSize[FileNumber];
      fp = THISFILEP;
      }else fp = stdin;

    }else{
    if( pEo->fpStdinFunction != NULL ){
      pfExtIn = pEo->fpStdinFunction;
      RESULT = NEWMORTALSTRING(BytesToRead);
      ASSERTNULL(RESULT)
      s = STRINGVALUE(RESULT);
      CharsRead = 0;
      while( BytesToRead && ( ch = pfExtIn(pEo->pEmbedder) ) != EOF ){
        *s++ = ch;
        BytesToRead --;
        CharsRead ++;
        }
      STRLEN(RESULT) = CharsRead;
      RETURN;
      }
    fp = stdin;
    }
  RESULT = NEWMORTALSTRING(BytesToRead);
  ASSERTNULL(RESULT)
  if( pFCO->mode[FileNumber] == 's' ){
    STRLEN(RESULT) = HOOK_TCPRECV(THISSOCKET,STRINGVALUE(RESULT),BytesToRead,0);
    if( STRLEN(RESULT) == 0 )
      pFCO->SocketState[FileNumber] = -1;
    }else{
      s = STRINGVALUE(RESULT);
      CharsRead = 0;
      while( BytesToRead && ( ch = HOOK_FGETC(fp) ) != EOF ){
        *s++ = ch;
        BytesToRead --;
        CharsRead ++;
        }
      STRLEN(RESULT) = CharsRead;
    }

#endif
END

COMMAND(CLOSE)
#if NOTIMP_CLOSE
NOTIMPLEMENTED;
#else

  long FileNumber;
  pFileCommandObject pFCO;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);
  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;

  if( FileNumber < 1 || FileNumber > MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )ERROR(COMMAND_ERROR_FILE_IS_NOT_OPENED);
  if( pFCO->mode[FileNumber] == 's' )
    HOOK_TCPCLOSE(THISSOCKET);
  else
    HOOK_FCLOSE(THISFILEP);
  pFCO->mode[FileNumber] = (char)0;
  THISFILEP = NULL;
#endif
END

COMMAND(RESET)
#if NOTIMP_RESET
NOTIMPLEMENTED;
#else

  long FileNumber;
  pFileCommandObject pFCO;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);
  for( FileNumber = 0 ; FileNumber < MAXFILES ; FileNumber++ ){
    if( pFCO->mode[FileNumber] )
      if( pFCO->mode[FileNumber] == 's' )
        HOOK_TCPCLOSE(THISSOCKET);
      else
        HOOK_FCLOSE(THISFILEP);
    pFCO->mode[FileNumber] = (char)0;
    THISFILEP = NULL;
    }
#endif
END

COMMAND(SEEK)
#if NOTIMP_SEEK
NOTIMPLEMENTED;
#else


  long FileNumber,Position;
  pFileCommandObject pFCO;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);
  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;
  if( FileNumber < 1 || FileNumber > MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )ERROR(COMMAND_ERROR_FILE_IS_NOT_OPENED);
  if( pFCO->mode[FileNumber] == 's' )ERROR(COMMAND_ERROR_SOCKET_FILE);
  NEXTPARAMETER;
  Position = pFCO->RecordSize[FileNumber] * LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;

  fflush(THISFILEP);
  fseek(THISFILEP,Position,SEEK_SET);

#endif
END

COMMAND(TRUNCATEF)
#if NOTIMP_TRUNCATEF
NOTIMPLEMENTED;
#else


  long FileNumber,Position;
  pFileCommandObject pFCO;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);
  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;
  if( FileNumber < 1 || FileNumber > MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )ERROR(COMMAND_ERROR_FILE_IS_NOT_OPENED);
  if( pFCO->mode[FileNumber] == 's' )ERROR(COMMAND_ERROR_SOCKET_FILE);
  NEXTPARAMETER;
  Position = pFCO->RecordSize[FileNumber] * LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;

  fflush(THISFILEP);
  HOOK_TRUNCATE(THISFILEP,Position);

#endif
END
COMMAND(REWIND)
#if NOTIMP_REWIND
NOTIMPLEMENTED;
#else


  long FileNumber;
  pFileCommandObject pFCO;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);
  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;
  if( FileNumber < 1 || FileNumber > MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )ERROR(COMMAND_ERROR_FILE_IS_NOT_OPENED);
  if( pFCO->mode[FileNumber] == 's' )ERROR(COMMAND_ERROR_SOCKET_FILE);

  fflush(THISFILEP);
  fseek(THISFILEP,0L,SEEK_SET);

#endif
END

COMMAND(LOC)
#if NOTIMP_LOC
NOTIMPLEMENTED;
#else


  VARIABLE Op1;
  long FileNumber;
  pFileCommandObject pFCO;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  Op1 = EVALUATEEXPRESSION(CAR(PARAMETERLIST));
  ASSERTOKE;

  if( memory_IsUndef(Op1) ){
    RESULT = NULL;
    RETURN;
    }

  FileNumber = LONGVALUE(CONVERT2LONG(Op1));
  RESULT = NULL;
  if( FileNumber < 1 || FileNumber > MAXFILES )RETURN;
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )RETURN;
  if( pFCO->mode[FileNumber] == 's' )RESULT;

  RESULT = NEWMORTALLONG;
  ASSERTNULL(RESULT)
  LONGVALUE(RESULT) = (long)(ftell(THISFILEP) / pFCO->RecordSize[FileNumber]);

#endif
END

COMMAND(LOF)
#if NOTIMP_LOF
NOTIMPLEMENTED;
#else


  VARIABLE Op1;
  long FileNumber,SavePosition;
  pFileCommandObject pFCO;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  Op1 = EVALUATEEXPRESSION(CAR(PARAMETERLIST));
  ASSERTOKE;

  if( memory_IsUndef(Op1) ){
    RESULT = NULL;
    RETURN;
    }

  FileNumber = LONGVALUE(CONVERT2LONG(Op1));
  RESULT = NULL;
  if( FileNumber < 1 || FileNumber > MAXFILES )RETURN;
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )RETURN;
  if( pFCO->mode[FileNumber] == 's' )RETURN;

  RESULT = NEWMORTALLONG;
  ASSERTNULL(RESULT)
  SavePosition = ftell(THISFILEP);
  fseek(THISFILEP,0,SEEK_END);
  LONGVALUE(RESULT) = (long)(ftell(THISFILEP) / pFCO->RecordSize[FileNumber]);
  fseek(THISFILEP,SavePosition,SEEK_SET);

#endif
END

COMMAND(FREEFILE)
#if NOTIMP_FREEFILE
NOTIMPLEMENTED;
#else


  VARIABLE Op1;
  long FileNumber,Range;
  pFileCommandObject pFCO;
  NODE nItem;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  /* evaluate the parameter */
  if( nItem = PARAMETERLIST ){
    Op1 = EVALUATEEXPRESSION(CAR(PARAMETERLIST));
    ASSERTOKE;
    if( memory_IsUndef(Op1) )
      Range = -1;
    else
      Range = LONGVALUE(CONVERT2LONG(Op1));
    }else Range = -1;

  if( Range == -1 ){
    for( FileNumber = 1 ; FileNumber < MAXFILES ; FileNumber++ )
      if( ! pFCO->mode[FileNumber] ){
        Range = -2;
        break;
        }
    }else
  if( Range == 0 ){
    for( FileNumber = 1 ; FileNumber < 255 ; FileNumber++ )
      if( ! pFCO->mode[FileNumber]  ){
        Range = -2;
        break;
        }
    }else{

    for( FileNumber = 255 ; FileNumber < MAXFILES ; FileNumber++ )
      if( ! pFCO->mode[FileNumber]  ){
        Range = -2;
        break;
        }
    }
  if( Range != -2 ){
    RESULT = NULL;
    RETURN;
    }

  RESULT = NEWMORTALLONG;
  ASSERTNULL(RESULT)
  LONGVALUE(RESULT) = FileNumber+1;

#endif
END

COMMAND(FPRINT)
#if NOTIMP_FPRINT
NOTIMPLEMENTED;
#else

  char buffer[80]; /* should be enough to print a long or a double */
  NODE nItem;
  VARIABLE ItemResult;

  long FileNumber;
  pFileCommandObject pFCO;
  char *s;
  unsigned long slen;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  nItem = PARAMETERNODE;
  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(nItem)));
  ASSERTOKE;
  if( FileNumber < 1 || FileNumber > MAXFILES )RETURN;
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )RETURN;


  NEXTPARAMETER;
  nItem = PARAMETERNODE;

  while( nItem ){
    ItemResult = EVALUATEEXPRESSION(CAR(nItem));
    ASSERTOKE;


    if( memory_IsUndef(ItemResult) ){
      s = "undef";
      slen = 5;
      }
    else
    switch( TYPE(ItemResult) ){
      case VTYPE_LONG:
        sprintf(buffer,"%ld",LONGVALUE(ItemResult));
        s = buffer;
        slen = strlen(buffer);
        break;
      case VTYPE_DOUBLE:
        sprintf(buffer,"%lf",DOUBLEVALUE(ItemResult));
        s = buffer;
        slen = strlen(buffer);
        break;
      case VTYPE_STRING:
        s = STRINGVALUE(ItemResult);
        slen = STRLEN(ItemResult);
        break;
      case VTYPE_ARRAY:
        sprintf(buffer,"ARRAY@#%08X",LONGVALUE(ItemResult));
        s = buffer;
        slen = strlen(buffer);
        break;
      }

    if( pFCO->mode[FileNumber] == 's' )
      HOOK_TCPSEND(THISSOCKET,s,slen,0);
    else
      while( slen -- )HOOK_PUTC(((int)*s++),THISFILEP);

    nItem = CDR(nItem);
    }

  if( pFCO->mode[FileNumber] != 's' &&
      fflush(THISFILEP) == EOF )ERROR(COMMAND_ERROR_PRINT_FAIL);

#endif
END

COMMAND(FPRINTNL)
#if NOTIMP_FPRINTNL
NOTIMPLEMENTED;
#else


  NODE nItem;
  long FileNumber;
  pFileCommandObject pFCO;


  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  nItem = PARAMETERNODE;
  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(nItem)));
  ASSERTOKE;
  if( FileNumber < 1 || FileNumber > MAXFILES )RETURN;
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )RETURN;


  if( pFCO->mode[FileNumber] == 's' )
    HOOK_TCPSEND(THISSOCKET,"\n",1,0);
  else{
    HOOK_PUTC('\n',THISFILEP);
    if( fflush(THISFILEP) == EOF )ERROR(COMMAND_ERROR_PRINT_FAIL);
    }

#endif
END
#define NOCOMMAND(XXX) \
COMMAND(XXX)\
NOTIMPLEMENTED;\
END

#define FILE_FUN(XXX,yyy) \
COMMAND(XXX)\
\
  char *FileName;\
  VARIABLE Op;\
  long lRes;\
\
  USE_CALLER_MORTALS;\
\
  Op = _EVALUATEEXPRESSION(CAR(PARAMETERLIST));\
  ASSERTOKE;\
  if( memory_IsUndef(Op) ){\
    RESULT = NULL;\
    RETURN;\
    }\
\
  Op = CONVERT2STRING(Op);\
\
  FileName = ALLOC(STRLEN(Op)+1);\
  if( FileName == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);\
  memcpy(FileName,STRINGVALUE(Op),STRLEN(Op));\
  FileName[STRLEN(Op)] = (char)0;\
  lRes = yyy(FileName);\
  if( lRes == -1 ){\
    RESULT = NULL;\
    RETURN;\
    }\
\
  RESULT = NEWMORTALLONG;\
  ASSERTNULL(RESULT)\
  LONGVALUE(RESULT) = lRes;\
  FREE(FileName);\
\
END

#define FILE_BFUN(XXX,yyy) \
COMMAND(XXX)\
\
  char *FileName;\
  VARIABLE Op;\
  long lRes;\
\
  USE_CALLER_MORTALS;\
\
  Op = _EVALUATEEXPRESSION(CAR(PARAMETERLIST));\
  ASSERTOKE;\
  if( memory_IsUndef(Op) ){\
    RESULT = NULL;\
    RETURN;\
    }\
\
  Op = CONVERT2STRING(Op);\
\
  FileName = ALLOC(STRLEN(Op)+1);\
  if( FileName == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);\
  memcpy(FileName,STRINGVALUE(Op),STRLEN(Op));\
  FileName[STRLEN(Op)] = (char)0;\
  lRes = yyy(FileName);\
  RESULT = NEWMORTALLONG;\
  ASSERTNULL(RESULT)\
  LONGVALUE(RESULT) = lRes;\
  FREE(FileName);\
\
END

#if NOTIMP_FILELEN
NOCOMMAND(FILELEN)
#else
FILE_FUN(FILELEN,HOOK_SIZE)
#endif

#if NOTIMP_FTACCESS
NOCOMMAND(FTACCESS)
#else
FILE_FUN(FTACCESS,HOOK_TIME_ACCESSED)
#endif

#if NOTIMP_FTMODIFY
NOCOMMAND(FTMODIFY)
#else
FILE_FUN(FTMODIFY,HOOK_TIME_MODIFIED)
#endif

#if NOTIMP_FTCREATED
NOCOMMAND(FTCREATED)
#else
FILE_FUN(FTCREATED,HOOK_TIME_CREATED)
#endif

#if NOTIMP_ISDIR
NOCOMMAND(ISDIR)
#else
FILE_BFUN(ISDIR,HOOK_ISDIR)
#endif

#if NOTIMP_ISREG
NOCOMMAND(ISREG)
#else
FILE_BFUN(ISREG,HOOK_ISREG)
#endif

#if NOTIMP_FILEXISTS
NOCOMMAND(FILEXISTS)
#else
FILE_BFUN(FILEXISTS,HOOK_EXISTS)
#endif

COMMAND(FLOCK)
#if NOTIMP_FLOCK
NOTIMPLEMENTED;
#else


  long FileNumber;
  char *ModeString;
  pFileCommandObject pFCO;


  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;
  if( FileNumber < 1 || FileNumber > MAXFILES )RETURN;
  FileNumber --;
  if( ! pFCO->mode[FileNumber] || pFCO->mode[FileNumber] == 's' )RETURN;

  NEXTPARAMETER;
  ModeString = pEo->StringTable+pEo->CommandArray[_ActualNode-1].Parameter.CommandArgument.Argument.szStringValue;

  if( !stricmp(ModeString,"read") ){
    HOOK_FLOCK(THISFILEP,LOCK_SH);
    }else
  if( !stricmp(ModeString,"write") ){
    HOOK_FLOCK(THISFILEP,LOCK_EX);
    }else
  if( !stricmp(ModeString,"release") ){
    HOOK_FLOCK(THISFILEP,LOCK_UN);
    }else ERROR(COMMAND_ERROR_INVALID_LOCK);

#endif
END

COMMAND(RLOCK)
#if NOTIMP_RLOCK
NOTIMPLEMENTED;
#else


  long FileNumber,lFrom,lTo,lSwap;
  char *ModeString;
  pFileCommandObject pFCO;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;
  if( FileNumber < 1 || FileNumber > MAXFILES )RETURN;
  FileNumber --;
  if( ! pFCO->mode[FileNumber] || pFCO->mode[FileNumber] == 's' )RETURN;

  NEXTPARAMETER;
  lFrom = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;
  if( lFrom < 0 )RETURN;
  NEXTPARAMETER;
  lTo   = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;
  if( lTo < 0 )RETURN;
  if( lFrom > lTo ){
    lSwap = lTo;
    lTo = lFrom;
    lFrom = lSwap;
    }

  NEXTPARAMETER;
  ModeString = pEo->StringTable+pEo->CommandArray[_ActualNode-1].Parameter.CommandArgument.Argument.szStringValue;

  if( !stricmp(ModeString,"read") ){
    HOOK_LOCK(THISFILEP,LOCK_SH,lFrom,(lTo-lFrom+1)*pFCO->RecordSize[FileNumber]);
    }else
  if( !stricmp(ModeString,"write") ){
    HOOK_LOCK(THISFILEP,LOCK_EX,lFrom,(lTo-lFrom+1)*pFCO->RecordSize[FileNumber]);
    }else
  if( !stricmp(ModeString,"release") ){
    HOOK_LOCK(THISFILEP,LOCK_UN,lFrom,(lTo-lFrom+1)*pFCO->RecordSize[FileNumber]);
    }else ERROR(COMMAND_ERROR_INVALID_LOCK);

#endif
END
COMMAND(MKDIR)
#if NOTIMP_MKDIR
NOTIMPLEMENTED;
#else

  VARIABLE Op;
  char *s;

  Op = CONVERT2STRING(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  s = ALLOC(STRLEN(Op)+1);
  if( s == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  memcpy(s,STRINGVALUE(Op),STRLEN(Op));
  s[STRLEN(Op)] = (char)0;
  if( HOOK_MAKEDIRECTORY(s) == -1 ){
    FREE(s);
    ERROR(COMMAND_ERROR_MKDIR_FAIL);
    }
  FREE(s);
#endif
END

COMMAND(DELETE)
#if NOTIMP_DELETE
NOTIMPLEMENTED;
#else

  VARIABLE Op;
  char *s;
  int iResult;

  Op = CONVERT2STRING(EVALUATEEXPRESSION(PARAMETERNODE));
  s = ALLOC(STRLEN(Op)+1);
  ASSERTOKE;
  if( s == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  memcpy(s,STRINGVALUE(Op),STRLEN(Op));
  s[STRLEN(Op)] = (char)0;
  if( ! HOOK_EXISTS(s) ){
    FREE(s);
    RETURN;
    }
  if( HOOK_ISDIR(s) ){
    iResult = HOOK_RMDIR(s);
    FREE(s);
    if( iResult == -1 )ERROR(COMMAND_ERROR_DELETE_FAIL);
    RETURN;
    }
  iResult = HOOK_REMOVE(s);
  FREE(s);
  if( iResult == -1 )ERROR(COMMAND_ERROR_DELETE_FAIL);
  RETURN;

#endif
END

COMMAND(FCOPY)
#if NOTIMP_FCOPY
NOTIMPLEMENTED;
#else

  VARIABLE Op1,Op2;
  char *sfile,*dfile;
  FILE *fs,*fd;
  int ch;
  long i,LastDSPos;

  Op1 = CONVERT2STRING(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  CONVERT2ZCHAR(Op1,sfile);
  /* the file that we copy should exist */
  if( ! HOOK_EXISTS(sfile) ){
    FREE(sfile);
    RETURN;
    }
  NEXTPARAMETER;
  Op2 = CONVERT2STRING(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  CONVERT2ZCHAR(Op2,dfile);
  fs = HOOK_FOPEN(sfile,"rb");
  if( fs == NULL ){
    FREE(sfile);
    FREE(dfile);
    ERROR(COMMAND_ERROR_FILE_READ);
    }

  /* if the file is going into a directory that does not exist yet then try to create the directory */
  LastDSPos = 0;
  for( i=0 ; dfile[i] ; i++ )
#ifdef __MACOS__
    if( dfile[i] == ':' )LastDSPos = i;
#else
    if( dfile[i] == '/' || dfile[i] == '\\' )LastDSPos = i;
#endif
  if( LastDSPos ){
    i = dfile[LastDSPos];
    dfile[LastDSPos] = (char)0;
    HOOK_MAKEDIRECTORY(dfile);
    dfile[LastDSPos] = (char)i;
    }

  fd = HOOK_FOPEN(dfile,"wb");
  if( fd == NULL ){
    HOOK_FCLOSE(fs);
    FREE(sfile);
    FREE(dfile);
    ERROR(COMMAND_ERROR_FILE_WRITE);
    }
  while( (ch=HOOK_FGETC(fs)) != EOF ){
    HOOK_PUTC(ch,fd);
    }
  HOOK_FCLOSE(fs);
  HOOK_FCLOSE(fd);
  FREE(sfile);
  FREE(dfile);
  RETURN;
#endif
END

COMMAND(NAME)
#if NOTIMP_NAME
NOTIMPLEMENTED;
#else

  VARIABLE Op1,Op2;
  char *sfile,*dfile;

  Op1 = CONVERT2STRING(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  CONVERT2ZCHAR(Op1,sfile);
  /* the file that we copy should exist */
  if( ! HOOK_EXISTS(sfile) ){
    FREE(sfile);
    RETURN;
    }
  NEXTPARAMETER;
  Op2 = CONVERT2STRING(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  CONVERT2ZCHAR(Op2,dfile);

  rename(sfile,dfile);

  FREE(sfile);
  FREE(dfile);
  RETURN;
#endif
END

COMMAND(DELETEF)
#if NOTIMP_DELETEF
NOTIMPLEMENTED;
#else

  VARIABLE Op;
  char *s;
  int iResult;

  Op = CONVERT2STRING(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  s = ALLOC(STRLEN(Op)+1);
  if( s == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  memcpy(s,STRINGVALUE(Op),STRLEN(Op));
  s[STRLEN(Op)] = (char)0;
  if( ! HOOK_EXISTS(s) ){
    FREE(s);
    RETURN;
    }
  if( ! HOOK_ISDIR(s) ){
    iResult = HOOK_REMOVE(s);
    FREE(s);
    if( iResult == -1 )ERROR(COMMAND_ERROR_DELETE_FAIL);
    RETURN;
    }

  /* Delete the files recursively inside the directory. */
  iResult = HOOK_DELTREE(s);
  FREE(s);
  if( iResult == -1 )ERROR(COMMAND_ERROR_DELETE_FAIL);
  RETURN;

#endif
END

#define MAXDIRS 512

/* A DirList contains the file names.

   The field cbFileName points to an array.
   Each element of the array contains the length of a file name.

   SortValue is an array that stores file size, creation date or
   other parameter according to the sort condition.

   ppszFileName points to an array of char * each pointing to a
   file name. This array is altered during sort.

   cFileNames is the number of file names in the list.

   FileIndex is the index to the cbFileName array for the
   current file name during file iterations.

*/
typedef struct _DirList {
  unsigned long *cbFileName; /* file name length */
  unsigned long *SortValue;  /* sort value or string offset */
  char **ppszFileName;       /* file name */
  unsigned long cFileNames;  /* number of file names */
  unsigned long FileIndex;   /* current file index */
  } DirList, *pDirList;

#define FILES_INCREMENT 10
static int store_file_name(pExecuteObject pEo,
                           pDirList p,
                           char *buffer,
                           unsigned long ThisSortValue

  ){
  unsigned long ulNewSize;
  unsigned long *plNewCbFileName,*NewSortValue;
  char **ppszNewppszFileName;
  unsigned long i;

  /* first of all check that there is enough space to store the file name on the current index location. */
  if( p->FileIndex >= (ulNewSize = p->cFileNames) ){
    while( p->FileIndex >= ulNewSize )/* this while is redundant unless there is a programming error somwhere else */
      ulNewSize += FILES_INCREMENT;
    plNewCbFileName = ALLOC( ulNewSize * sizeof(long) );
    if( plNewCbFileName == NULL )return 1;
    NewSortValue = ALLOC( ulNewSize * sizeof(long));
    if( NewSortValue == NULL )return 1;
    ppszNewppszFileName = ALLOC( ulNewSize * sizeof(char *));
    if( ppszNewppszFileName == NULL )return 1;
    for( i=0 ; i < p->cFileNames ; i++ ){
       plNewCbFileName[i] = p->cbFileName[i];
       NewSortValue[i] = p->SortValue[i];
       ppszNewppszFileName[i] = p->ppszFileName[i];
       }
    if( p->cbFileName )FREE(p->cbFileName);
    if( p->SortValue )FREE(p->SortValue);
    if( p->ppszFileName )FREE(p->ppszFileName);
    p->cbFileName = plNewCbFileName;
    p->SortValue = NewSortValue;
    p->ppszFileName = ppszNewppszFileName;
    p->cFileNames = ulNewSize;
    }

  if( (p->ppszFileName[p->FileIndex] = ALLOC( (p->cbFileName[p->FileIndex] = strlen(buffer)) )) == NULL )
    return 1;
  memcpy(p->ppszFileName[p->FileIndex],buffer,p->cbFileName[p->FileIndex]);
  p->SortValue[p->FileIndex] = ThisSortValue;
  p->FileIndex++;
  return 0;
  }

typedef struct _DirCommandObject {
  pDirList dp[MAXDIRS];
  } DirCommandObject, *pDirCommandObject;

static void close_directory_list(pExecuteObject pEo,
                                 unsigned long i
  ){
  pDirCommandObject pDCO;
  unsigned long j;

  pDCO = (pDirCommandObject)PARAMPTR(CMD_OPENDIR);
  if( pDCO == NULL )return;

  for( j=0 ; j<pDCO->dp[i]->cFileNames ; j++ )
     FREE(pDCO->dp[i]->ppszFileName[j]);
  /* the following two pointers may be null if the directory list contained no file name*/
  if( pDCO->dp[i]->cbFileName )FREE( pDCO->dp[i]->cbFileName);
  if( pDCO->dp[i]->ppszFileName )FREE( pDCO->dp[i]->ppszFileName);
  /* this should never be null when we get here */
  if( pDCO->dp[i] )FREE( pDCO->dp[i]);
  pDCO->dp[i] = NULL;
  return;
  }

static void close_all_dirs(pExecuteObject pEo){
  pDirCommandObject pDCO;
  long i;

  pDCO = (pDirCommandObject)PARAMPTR(CMD_OPENDIR);
  if( pDCO == NULL )return;
  for( i = 0 ; i < MAXDIRS ; i++ )
    if( pDCO->dp[i] )
      close_directory_list(pEo,i);
  }

static int initdir(pExecuteObject pEo){
#define INITDIR initdir(pEo)
  pDirCommandObject pDCO;
  int i;

  /* initialize only once */
  if( PARAMPTR(CMD_OPENDIR) )return 0;

  PARAMPTR(CMD_OPENDIR) = ALLOC(sizeof(DirCommandObject));
  if( PARAMPTR(CMD_OPENDIR) == NULL )return COMMAND_ERROR_MEMORY_LOW;

  pDCO = (pDirCommandObject)PARAMPTR(CMD_OPENDIR);
  for( i=0 ; i < MAXDIRS ; i++ )
    pDCO->dp[i] = NULL;

  FINALPTR(CMD_OPENDIR) = close_all_dirs;
  return 0;
  }


#define COLLECT_DIRS   0x0001 /* collect directories as well */
#define COLLECT_DOTS   0x0002 /* collect the dot directories */
#define COLLECT_RECU   0x0004 /* collect recursively */
#define SORTBY_SIZE    0x0008 /* sort by file size */
#define SORTBY_CRETI   0x0010 /* sort by creation time */
#define SORTBY_ACCTI   0x0020 /* sort by access time */
#define SORTBY_MODTI   0x0040 /* sort by modification time */
#define SORTBY_NAME    0x0080 /* sort by name (no directory part is compared) */
#define SORTBY_FNAME   0x0100 /* sort by full name */
#define COLLECT_FULLP  0x0200 /* collect and return "full" path names including the original directory name in
                                 each file name retuned (can directly be used in file handling statements */
#define SORTBY_DESCEN  0x0400 /* sort descending order */

#define MAX_FNLEN 1024

/* This function recursively collects
*/
static int collect_dirs_r(pExecuteObject pEo,
                          char * buffer,
                          unsigned long fAction,
                          pDirList pThisDirList,
                          char *pattern,
                          unsigned long StartCharIndex
  ){
  tDIR DL;
  DIR *pDL;
  struct dirent *pD;
  int dirlen;

  unsigned long sL,pL,i;
  unsigned long cArraySize;
  pPatternParam pLastResult;
  int iError;
  unsigned long ulSortValue;

  pLastResult = (pPatternParam)PARAMPTR(CMD_LIKEOP);

  dirlen=strlen(buffer);
#ifdef __MACOS__
  if( buffer[dirlen-1] != ':' ){
    dirlen++;
    if( dirlen >= MAX_FNLEN )return -1;
    strcpy(buffer+dirlen-1,":");
    }
#else
  if( buffer[dirlen-1] != '/' ){
    dirlen++;
    if( dirlen >= MAX_FNLEN )return -1;
    strcpy(buffer+dirlen-1,"/");
    }
#endif
  pDL = HOOK_OPENDIR(buffer,&DL);
  if( pDL == NULL )return -1;
  while( pD = HOOK_READDIR(pDL) ){
    /* skip . and .. directories */
    if( pD->d_name[0] == '.' && 
       ( pD->d_name[1] == (char)0 ||
         ( pD->d_name[1] == '.' && pD->d_name[2] == (char)0 ) ) ){
      if( fAction&COLLECT_DOTS ){
        if( dirlen+strlen(pD->d_name) >= MAX_FNLEN )return -1;
        strcpy(buffer+dirlen,pD->d_name);
        if( fAction & SORTBY_SIZE )ulSortValue = HOOK_SIZE(buffer); else
        if( fAction & SORTBY_CRETI )ulSortValue = HOOK_TIME_CREATED(buffer); else
        if( fAction & SORTBY_MODTI )ulSortValue = HOOK_TIME_MODIFIED(buffer); else
        if( fAction & SORTBY_ACCTI )ulSortValue = HOOK_TIME_ACCESSED(buffer); else
        if( fAction & SORTBY_NAME  )ulSortValue = dirlen - StartCharIndex; else
        ulSortValue = 0; /* SORTBY_FNAME */
        if( store_file_name(pEo,pThisDirList,buffer+StartCharIndex,ulSortValue) )return -1;
        }
      continue;
      }
    if( dirlen+(sL=strlen(pD->d_name)) >= MAX_FNLEN )return -1;
    strcpy(buffer+dirlen,pD->d_name);
    if( *pattern ){
      pL = strlen(pattern);
      cArraySize = match_count(pattern,pL);
      if( cArraySize > pLastResult->cArraySize ){
        if( pLastResult->pcbParameterArray )FREE(pLastResult->pcbParameterArray);
        if( pLastResult->ParameterArray)FREE(pLastResult->ParameterArray);
        pLastResult->cArraySize = 0;
        pLastResult->pcbParameterArray = ALLOC(cArraySize*sizeof(unsigned long));
        if( pLastResult->pcbParameterArray == NULL )return -1;
        pLastResult->ParameterArray    = ALLOC(cArraySize*sizeof(char *));
        if( pLastResult->ParameterArray == NULL ){
          FREE(pLastResult->pcbParameterArray);
          pLastResult->pcbParameterArray = NULL;
          return -1;
          }
        pLastResult->cArraySize = cArraySize;
        }else{
        /* If the array is long enough then delete the previous result otherwise
           fake data may remain in it and it may cause trouble. */
        for( i=0 ; i < pLastResult->cArraySize ; i++ ){
          pLastResult->pcbParameterArray[i] = 0;
          pLastResult->ParameterArray[i] = NULL;
          }
        }
      pLastResult->cAArraySize = cArraySize;

      if( pLastResult->cbBufferSize < sL ){
        pLastResult->cbBufferSize = 0;
        if( pLastResult->pszBuffer )FREE(pLastResult->pszBuffer);
        pLastResult->pszBuffer = ALLOC(sL*sizeof(char));
        if( pLastResult->pszBuffer == NULL )return -1;
        pLastResult->cbBufferSize = sL;
        }

      iError = match_match(pattern,
                           pL,
                           buffer+dirlen,
                           sL,
                           pLastResult->ParameterArray,
                           pLastResult->pcbParameterArray,
                           pLastResult->pszBuffer,
                           pLastResult->cArraySize,
                           pLastResult->cbBufferSize,
#ifdef WIN32
                           0,
#else
                           !(OPTION("compare")&1),
#endif
                           pLastResult->pThisMatchSets,
                           &(pLastResult->iMatches));
      }
    if( (!*pattern) || pLastResult->iMatches ){
      if( fAction & SORTBY_SIZE )ulSortValue = HOOK_SIZE(buffer); else
      if( fAction & SORTBY_CRETI )ulSortValue = HOOK_TIME_CREATED(buffer); else
      if( fAction & SORTBY_MODTI )ulSortValue = HOOK_TIME_MODIFIED(buffer); else
      if( fAction & SORTBY_ACCTI )ulSortValue = HOOK_TIME_ACCESSED(buffer); else
      if( fAction & SORTBY_NAME  )ulSortValue = dirlen - StartCharIndex; else
      ulSortValue = 0;
      if( (fAction & COLLECT_DIRS) || (!HOOK_ISDIR(buffer)) )
        store_file_name(pEo,pThisDirList,buffer+StartCharIndex,ulSortValue);
      }
    pLastResult->iMatches = 0; /* no joker() after file pattern match */
    if( HOOK_ISDIR(buffer) && (fAction & COLLECT_RECU) )
      collect_dirs_r(pEo,buffer,fAction,pThisDirList,pattern,StartCharIndex);
    }
  HOOK_CLOSEDIR(pDL);
  dirlen--;
  buffer[dirlen] = (char)0;
  return 0;
  }

static int collect_dirs(pExecuteObject pEo,
                        unsigned long fAction,
                        pDirList pThisDirList,
                        char *Directory,
                        unsigned long cDirectory,
                        char *pattern,
                        unsigned long c_pattern
  ){
  char buffer[MAX_FNLEN];
  char puffer[MAX_FNLEN];
  unsigned long StartCharIndex;

  if( initialize_like(pEo) )return -1;
  memcpy(buffer,Directory,cDirectory);
  buffer[cDirectory] = (char)0;
#ifdef __MACOS__
  if( buffer[cDirectory-1] != ':' ){
    cDirectory++;
    if( cDirectory >= MAX_FNLEN )return -1;
    strcpy(buffer+cDirectory-1,":");
    }
#else
  if( buffer[cDirectory-1] != '/' ){
    cDirectory++;
    if( cDirectory >= MAX_FNLEN )return -1;
    strcpy(buffer+cDirectory-1,"/");
    }
#endif
  if( pattern )
    memcpy(puffer,pattern,c_pattern);
  puffer[c_pattern] = (char)0;

  StartCharIndex = strlen(buffer);
  if( fAction & COLLECT_FULLP )StartCharIndex = 0;
  if( collect_dirs_r(pEo,buffer,fAction,pThisDirList,puffer,StartCharIndex) == -1 )return -1;
  pThisDirList->cFileNames = pThisDirList->FileIndex;
  pThisDirList->FileIndex = 0;
  return 0;
  }

static int sort_dirs(pExecuteObject pEo,
                        unsigned long fAction,
                        pDirList p
  ){
  unsigned long i,j;
  unsigned long lSwap;
  char *pszSwap;
  unsigned long CompareLength,Leni,Lenj;
  int CompareSult;

#define SWAP do{\
                lSwap = p->cbFileName[i];\
                p->cbFileName[i] = p->cbFileName[j];\
                p->cbFileName[j] = lSwap;\
                lSwap = p->SortValue[i];\
                p->SortValue[i] = p->SortValue[j];\
                p->SortValue[j] = lSwap;\
                pszSwap = p->ppszFileName[i];\
                p->ppszFileName[i] = p->ppszFileName[j];\
                p->ppszFileName[j] = pszSwap;\
                }while(0)

  /* if there is nothing to sort by */
  if( !(fAction & ( SORTBY_SIZE | SORTBY_CRETI | SORTBY_ACCTI | SORTBY_MODTI | SORTBY_NAME | SORTBY_FNAME)) )
    return 0;

  if( fAction & (SORTBY_NAME | SORTBY_FNAME) ){
    /* string type of comparision */
    for( i=1 ; i < p->cFileNames ; i++ )
     for( j=0 ; j < i ; j++ ){
       CompareLength = Leni = p->cbFileName[i] - p->SortValue[i];
       if( CompareLength > (Lenj=p->cbFileName[j] - p->SortValue[j]) )
         CompareLength = Lenj;
       CompareSult = memcmp(p->ppszFileName[i]+p->SortValue[i],p->ppszFileName[j]+p->SortValue[j],CompareLength);
       CompareSult = CompareSult > 0 || (CompareSult == 0 && Leni > Lenj);
       if( fAction & SORTBY_DESCEN )CompareSult = !CompareSult;
       if( CompareSult )
         SWAP;
       }
    }else{
    /* numeric comparision based on collected value */
    for( i=1 ; i < p->cFileNames ; i++ )
     for( j=0 ; j < i ; j++ )
       if( (fAction & SORTBY_DESCEN) ? p->SortValue[i] < p->SortValue[j] : p->SortValue[i] > p->SortValue[j] )
         SWAP;
    }
  return 0;
  }

COMMAND(OPENDIR)
#if NOTIMP_OPENDIR
NOTIMPLEMENTED;
#else

  long DirNumber;
  char *DirName;
  unsigned long i;
  pDirCommandObject pDCO;
  VARIABLE vDirName,vPattern,vDirNumber,vOption;
  unsigned long fAction;

  INITDIR;
  pDCO = (pDirCommandObject)PARAMPTR(CMD_OPENDIR);

  /* get the directory name */
  vDirName = CONVERT2STRING(_EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  NEXTPARAMETER;
  vPattern = CONVERT2STRING(_EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  NEXTPARAMETER;
  vOption = CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  NEXTPARAMETER;
  vDirNumber = _EVALUATEEXPRESSION(PARAMETERNODE);
  ASSERTOKE;
  if( memory_IsUndef(vDirNumber) )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  if( TYPE(vDirNumber) == VTYPE_LONG && LONGVALUE(vDirNumber) == 0 ){/* we have to automatically allocate the file number */
    for( i = 1 ; i < MAXFILES ; i++ )
      if( pDCO->dp[i] == NULL )break;
    if( i >= MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
    LONGVALUE(vDirNumber) = i;
    }
  DirNumber = LONGVALUE(CONVERT2LONG(vDirNumber));

  if( DirNumber <1 || DirNumber >= MAXDIRS )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  if( pDCO->dp[DirNumber] )ERROR(COMMAND_ERROR_FILE_NUMBER_IS_USED);

  /* copy the dir name to DirName zchar terminated. */
  if( memory_IsUndef(vDirName) )ERROR(COMMAND_ERROR_INV_DNAME);
  SECUREFILE(vDirName)
  CONVERT2ZCHAR(vDirName,DirName);

  pDCO->dp[DirNumber] = ALLOC( sizeof(DirList) );
  if( pDCO->dp[DirNumber] == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  pDCO->dp[DirNumber]->cFileNames = 0;
  pDCO->dp[DirNumber]->FileIndex  = 0;
  pDCO->dp[DirNumber]->cbFileName = NULL;
  pDCO->dp[DirNumber]->SortValue = NULL;
  pDCO->dp[DirNumber]->ppszFileName = NULL;

  if( memory_IsUndef(vOption) )ERROR(COMMAND_ERROR_INV_DO_OPTION);
  fAction = ~ (GETLONGVALUE(vOption));

#define SORTBY_SIZE    0x0008 /* sort by file size */
#define SORTBY_CRETI   0x0010 /* sort by creation time */
#define SORTBY_ACCTI   0x0020 /* sort by access time */
#define SORTBY_MODTI   0x0040 /* sort by modification time */
#define SORTBY_NAME    0x0080 /* sort by name (no directory part is compared) */
#define SORTBY_FNAME   0x0100 /* sort by full name */

  /* If the user specifies more than one sorting criuteria, we have to correct it,
     because the underlying layers assume that only one bit is set. Former version
     crashed when open directory option was sloppyly set to 0. */
  if( fAction & SORTBY_SIZE  )
    fAction &= ~(    0      |SORTBY_CRETI|SORTBY_ACCTI|SORTBY_MODTI|SORTBY_NAME|SORTBY_FNAME); else
  if( fAction & SORTBY_CRETI )
    fAction &= ~(SORTBY_SIZE|       0    |SORTBY_ACCTI|SORTBY_MODTI|SORTBY_NAME|SORTBY_FNAME); else
  if( fAction & SORTBY_ACCTI )
    fAction &= ~(SORTBY_SIZE|SORTBY_CRETI|      0     |SORTBY_MODTI|SORTBY_NAME|SORTBY_FNAME); else
  if( fAction & SORTBY_MODTI )
    fAction &= ~(SORTBY_SIZE|SORTBY_CRETI|SORTBY_ACCTI|      0     |SORTBY_NAME|SORTBY_FNAME); else
  if( fAction & SORTBY_NAME  )
    fAction &= ~(SORTBY_SIZE|SORTBY_CRETI|SORTBY_ACCTI|SORTBY_MODTI|      0    |SORTBY_FNAME); else
  if( fAction & SORTBY_FNAME )
    fAction &= ~(SORTBY_SIZE|SORTBY_CRETI|SORTBY_ACCTI|SORTBY_MODTI|SORTBY_NAME|      0     );

  if( collect_dirs(pEo,
                   fAction,
                   pDCO->dp[DirNumber],
                   STRINGVALUE(vDirName),
                   STRLEN(vDirName),
                   vPattern ? STRINGVALUE(vPattern) : NULL ,
                   vPattern ? STRLEN(vPattern) : 0 ) == -1 ){
    close_directory_list(pEo,DirNumber);
    ERROR(COMMAND_ERROR_DIR_NO_OPEN); 
    }
  sort_dirs(pEo,
            fAction,
            pDCO->dp[DirNumber]);
#endif
END

COMMAND(NEXTFILE)
#if NOTIMP_NEXTFILE
NOTIMPLEMENTED;
#else

  VARIABLE Op1;
  pDirCommandObject pDCO;
  unsigned long DirNumber;

  INITDIR;
  pDCO = (pDirCommandObject)PARAMPTR(CMD_OPENDIR);

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  Op1 = CONVERT2LONG(EVALUATEEXPRESSION(CAR(PARAMETERLIST)));
  ASSERTOKE;
  if( memory_IsUndef(Op1) ){
    RESULT = NULL;
    RETURN;
    }
  DirNumber = LONGVALUE(Op1);
  if( DirNumber <1 || DirNumber >= MAXDIRS )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);

  if( pDCO->dp[DirNumber]->FileIndex >= pDCO->dp[DirNumber]->cFileNames ){
    RESULT = NULL;
    RETURN;
    }

  RESULT = NEWMORTALSTRING(pDCO->dp[DirNumber]->cbFileName[pDCO->dp[DirNumber]->FileIndex]);
  ASSERTNULL(RESULT)
  memcpy(STRINGVALUE(RESULT),pDCO->dp[DirNumber]->ppszFileName[pDCO->dp[DirNumber]->FileIndex],
         (STRLEN(RESULT)=pDCO->dp[DirNumber]->cbFileName[pDCO->dp[DirNumber]->FileIndex]));
  pDCO->dp[DirNumber]->FileIndex++;
#endif
END

COMMAND(EODFUN)
#if NOTIMP_EODFUN
NOTIMPLEMENTED;
#else

  VARIABLE Op1;
  pDirCommandObject pDCO;
  unsigned long DirNumber;

  INITDIR;
  pDCO = (pDirCommandObject)PARAMPTR(CMD_OPENDIR);

  /* this is an operator and not a command, therefore we do not have our own mortal list */
  USE_CALLER_MORTALS;

  Op1 = CONVERT2LONG(EVALUATEEXPRESSION(CAR(PARAMETERLIST)));
  ASSERTOKE;
  if( memory_IsUndef(Op1) ){
    RESULT = NULL;
    RETURN;
    }
  DirNumber = LONGVALUE(Op1);
  if( DirNumber <1 || DirNumber >= MAXDIRS )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  if( pDCO->dp[DirNumber]->FileIndex >= pDCO->dp[DirNumber]->cFileNames ){
    RESULT = NEWMORTALLONG;
    ASSERTNULL(RESULT)
    LONGVALUE(RESULT) = -1;
    RETURN;
    }
  RESULT = NEWMORTALLONG;
  ASSERTNULL(RESULT)
  LONGVALUE(RESULT) = 0;
#endif
END

COMMAND(RESETDIR)
#if NOTIMP_RESETDIR
NOTIMPLEMENTED;
#else

  VARIABLE Op1;
  pDirCommandObject pDCO;
  unsigned long DirNumber;

  INITDIR;
  pDCO = (pDirCommandObject)PARAMPTR(CMD_OPENDIR);

  Op1 = CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  if( memory_IsUndef(Op1) ){
    RESULT = NULL;
    RETURN;
    }
  DirNumber = LONGVALUE(Op1);
  if( DirNumber <1 || DirNumber >= MAXDIRS )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  pDCO->dp[DirNumber]->FileIndex = 0;
#endif
END

COMMAND(CLOSEDIR)
#if NOTIMP_CLOSEDIR
NOTIMPLEMENTED;
#else

  VARIABLE Op1;
  pDirCommandObject pDCO;
  unsigned long DirNumber;

  INITDIR;
  pDCO = (pDirCommandObject)PARAMPTR(CMD_OPENDIR);

  Op1 = CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  if( memory_IsUndef(Op1) ){
    RESULT = NULL;
    RETURN;
    }
  DirNumber = LONGVALUE(Op1);
  if( DirNumber <1 || DirNumber >= MAXDIRS )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  close_directory_list(pEo,DirNumber);
#endif
END

COMMAND(SLEEP)
#if NOTIMP_SLEEP
NOTIMPLEMENTED;
#else

  VARIABLE Op1;

  Op1 = CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  if( ! memory_IsUndef(Op1) )
    sys_sleep(LONGVALUE(Op1));

#endif
END

COMMAND(PAUSE)
#if NOTIMP_PAUSE
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

COMMAND(HOSTNAME)
#if NOTIMP_HOSTNAME
NOTIMPLEMENTED;
#else

  char *pszBuffer;
  long cbBuffer;
  int err;

  cbBuffer = 256;
  pszBuffer = ALLOC(cbBuffer);
  err = HOOK_GETHOSTNAME(pszBuffer,cbBuffer);
  if( err == 0 ){
    cbBuffer = strlen(pszBuffer);
    RESULT = NEWMORTALSTRING(cbBuffer);
    ASSERTNULL(RESULT)
    memcpy(STRINGVALUE(RESULT),pszBuffer,cbBuffer);
    }else RESULT = NULL;
#endif
END

COMMAND(CURDIR)
#if NOTIMP_CURDIR
NOTIMPLEMENTED;
#else

 char *Buffer;
 long cBuffer;

  USE_CALLER_MORTALS;

  cBuffer = 256;
  Buffer = ALLOC(cBuffer);
  while( HOOK_CURDIR(Buffer,cBuffer) == -1 ){
    FREE(Buffer);
    cBuffer += 256;
    if( cBuffer > 1024 )ERROR(COMMAND_ERROR_CURDIR);
    Buffer = ALLOC(cBuffer);
    }
  cBuffer = strlen(Buffer);
  RESULT = NEWMORTALSTRING(cBuffer);
  ASSERTNULL(RESULT)

  memcpy(STRINGVALUE(RESULT),Buffer,cBuffer);
#endif
END

COMMAND(CHDIR)
#if NOTIMP_CHDIR
NOTIMPLEMENTED;
#else

  VARIABLE Op;
  char *Buffer;
  int i;

  Op = CONVERT2STRING(_EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  if( memory_IsUndef(Op) )ERROR(COMMAND_ERROR_UNDEF_DIR);

  SECUREFILE(Op)
  CONVERT2ZCHAR(Op,Buffer);

  i = HOOK_CHDIR(Buffer);
  FREE(Buffer);
  if( i )ERROR(COMMAND_ERROR_CHDIR);
  
#endif
END

COMMAND(SETFILE)
#if NOTIMP_SETFILE
NOTIMPLEMENTED;
#else

  VARIABLE vAttribute,vFile;
  long iErrorC;
  char *pszAttribute,*pszFile,*pszAttributeSymbol;

  vFile = CONVERT2STRING(_EVALUATEEXPRESSION(PARAMETERNODE));
  ASSERTOKE;
  NEXTPARAMETER;
  pszAttributeSymbol = pEo->StringTable+pEo->CommandArray[_ActualNode-1].Parameter.CommandArgument.Argument.szStringValue;
  NEXTPARAMETER;
  vAttribute = EVALUATEEXPRESSION(PARAMETERNODE);
  ASSERTOKE;

  if( memory_IsUndef(vAttribute) )ERROR(COMMAND_ERROR_SETFILE_INVALID_ATTRIBUTE);
  if( memory_IsUndef(vFile) )ERROR(COMMAND_ERROR_INVALID_FILE_NAME);


  SECUREFILE(vFile)
  CONVERT2ZCHAR(  vFile  , pszFile  );
  if( !stricmp(pszAttributeSymbol,"owner") ){
    vAttribute = CONVERT2STRING(vAttribute);
    CONVERT2ZCHAR(  vAttribute , pszAttribute );
    iErrorC = HOOK_CHOWN(pszFile,pszAttribute);
    FREE(pszAttribute);
    }
  else if( !stricmp(pszAttributeSymbol,"createtime") ){
    CONVERT2LONG(vAttribute);
    iErrorC = HOOK_SETCREATETIME(pszFile,LONGVALUE(vAttribute));
    }
  else if( !stricmp(pszAttributeSymbol,"modifytime") ){
    CONVERT2LONG(vAttribute);
    iErrorC = HOOK_SETMODIFYTIME(pszFile,LONGVALUE(vAttribute));
    }
  else if( !stricmp(pszAttributeSymbol,"accesstime") ){
    CONVERT2LONG(vAttribute);
    iErrorC = HOOK_SETACCESSTIME(pszFile,LONGVALUE(vAttribute));
    }

  else{
    FREE(pszFile);
    ERROR(COMMAND_ERROR_SETFILE_INVALID_ATTRIBUTE);
    }
  FREE(pszFile);
  if( iErrorC )ERROR(iErrorC);
#endif
END

COMMAND(KILL)
#if NOTIMP_KILL
NOTIMPLEMENTED;
#else

  long pid;
  NODE nItem;

  USE_CALLER_MORTALS;

  nItem = PARAMETERLIST;
  pid = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(CAR(nItem))));
  ASSERTOKE;

  RESULT = NEWMORTALLONG;
  ASSERTNULL(RESULT)
  if( HOOK_KILLPROC(pid) )
    LONGVALUE(RESULT) = 0L;
  else
    LONGVALUE(RESULT) = -1L;

#endif
END

#define MAXOWNERLEN 512
COMMAND(FOWNER)
#if NOTIMP_FOWNER
NOTIMPLEMENTED;
#else

  char *pszOwnerBuffer,*pszFileName;

  long cbOwnerBuffer;
  VARIABLE vFileName;

  USE_CALLER_MORTALS;

  vFileName = CONVERT2STRING(_EVALUATEEXPRESSION(CAR(PARAMETERLIST)));
  ASSERTOKE;
  SECUREFILE(vFileName)
  CONVERT2ZCHAR(vFileName,pszFileName);
  pszOwnerBuffer = ALLOC( MAXOWNERLEN );
  if( pszOwnerBuffer == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  cbOwnerBuffer = MAXOWNERLEN;
  if( HOOK_GETOWNER(pszFileName,pszOwnerBuffer,cbOwnerBuffer) ){
    RESULT = NULL;
    RETURN;
    }
  FREE(pszFileName);
  RESULT = NEWMORTALSTRING(cbOwnerBuffer=strlen(pszOwnerBuffer));
  ASSERTNULL(RESULT)
  memcpy(STRINGVALUE(RESULT),pszOwnerBuffer,cbOwnerBuffer);

#endif
END

COMMAND(FCRYPT)
#if NOTIMP_FCRYPT
NOTIMPLEMENTED;
#else

  char *pszString,*pszSalt;
  char szResult[13];
  VARIABLE vString,vSalt;
  NODE nItem;

  USE_CALLER_MORTALS;

  nItem = PARAMETERLIST;

  vString = CONVERT2STRING(_EVALUATEEXPRESSION(CAR(nItem)));
  ASSERTOKE;
  nItem = CDR(nItem);
  vSalt = CONVERT2STRING(_EVALUATEEXPRESSION(CAR(nItem)));
  ASSERTOKE;

  if( memory_IsUndef(vString) || memory_IsUndef(vSalt) ){
    RESULT = NULL;
    RETURN;
    }

  CONVERT2ZCHAR(vString,pszString);
  CONVERT2ZCHAR(vSalt,pszSalt);

  HOOK_FCRYPT(pszString,pszSalt,szResult);

  FREE(pszString);
  FREE(pszSalt);

  RESULT = NEWMORTALSTRING(12);
  ASSERTNULL(RESULT)
  memcpy(STRINGVALUE(RESULT),szResult,12);

#endif
END

COMMAND(FORK)
#if NOTIMP_FORK
NOTIMPLEMENTED;
#else
NOTIMPLEMENTED;
#endif
END

COMMAND(CREATEPROCESS)
#if NOTIMP_CREATEPROCESS
NOTIMPLEMENTED;
#else

  char *pszCommandLine;
  VARIABLE vCommandLine;
  long lPid;

  USE_CALLER_MORTALS;

  vCommandLine = CONVERT2STRING(_EVALUATEEXPRESSION(CAR(PARAMETERLIST)));
  ASSERTOKE;
  if( memory_IsUndef(vCommandLine) ){
    RESULT = NULL;
    RETURN;
    }

  SECUREFILE(vCommandLine)
  CONVERT2ZCHAR(vCommandLine,pszCommandLine);

  lPid = HOOK_CREATEPROCESS(pszCommandLine);

  FREE(pszCommandLine);

  RESULT = NEWMORTALLONG;
  ASSERTNULL(RESULT)
  LONGVALUE(RESULT) = lPid;

#endif
END

COMMAND(CREATEPROCESSEX)
#if NOTIMP_CREATEPROCESSEX
NOTIMPLEMENTED;
#else

  char *pszCommandLine;
  VARIABLE vCommandLine,vTimeOut;
  unsigned long lPid,lExitCode;
  NODE nItem;
  LEFTVALUE LetThisVariable;
  long refcount;
  int iError;

  nItem = PARAMETERLIST;

  USE_CALLER_MORTALS;

  vCommandLine = CONVERT2STRING(_EVALUATEEXPRESSION(CAR(nItem)));
  ASSERTOKE;
  if( memory_IsUndef(vCommandLine) ){
    RESULT = NULL;
    RETURN;
    }

  /* check that the command string does not contain zero character */
  SECUREFILE(vCommandLine)
  CONVERT2ZCHAR(vCommandLine,pszCommandLine);

  nItem = CDR(nItem);
  vTimeOut = CONVERT2LONG(_EVALUATEEXPRESSION(CAR(nItem)));
  ASSERTOKE;

  nItem = CDR(nItem);
  LetThisVariable = EVALUATELEFTVALUE(CAR(nItem));
  ASSERTOKE;
  DEREFERENCE(LetThisVariable);

  iError = HOOK_CREATEPROCESSEX(pszCommandLine,LONGVALUE(vTimeOut),&lPid,&lExitCode);

  FREE(pszCommandLine);
  if( iError == FILESYSE_TIMEOUT ){
    /* if this variable had value assigned to it then release that value */
    if( *LetThisVariable )memory_ReleaseVariable(pEo->pMo,*LetThisVariable);
    *LetThisVariable = NEWLONG;
    if( *LetThisVariable == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
    LONGVALUE(*LetThisVariable) = lPid;
    ERROR(COMMAND_ERROR_TIMEOUT);
    }

  if( iError == FILESYSE_SUCCESS ){
    RESULT = NEWMORTALLONG;
    ASSERTNULL(RESULT)
    LONGVALUE(RESULT) = lExitCode;
    }
  ERROR(iError);
#endif
END

COMMAND(WAITPID)
#if NOTIMP_WAITPID
NOTIMPLEMENTED;
#else

  VARIABLE vPid;
  NODE nItem;
  LEFTVALUE LetThisVariable;
  long refcount;
  long Result;
  long lExitCode;

  nItem = PARAMETERLIST;

  USE_CALLER_MORTALS;

  vPid = CONVERT2LONG(_EVALUATEEXPRESSION(CAR(PARAMETERLIST)));
  ASSERTOKE;
  if( memory_IsUndef(vPid) ){
    RESULT = NULL;
    RETURN;
    }

  nItem = CDR(nItem);
  LetThisVariable = EVALUATELEFTVALUE(CAR(nItem));
  ASSERTOKE;
  DEREFERENCE(LetThisVariable);

  Result = HOOK_WAITPID(LONGVALUE(vPid),&lExitCode);

  /* if this variable had value assigned to it then release that value */
  if( *LetThisVariable )memory_ReleaseVariable(pEo->pMo,*LetThisVariable);
  *LetThisVariable = NEWLONG;
  if( *LetThisVariable == NULL )ERROR(COMMAND_ERROR_MEMORY_LOW);
  if( Result == 0) lExitCode = 0;
  LONGVALUE(*LetThisVariable) = lExitCode;

  RESULT = NEWMORTALLONG;
  ASSERTNULL(RESULT)
  LONGVALUE(RESULT) = Result;

#endif
END

COMMAND(BINMF)
#if NOTIMP_BINMF
NOTIMPLEMENTED;
#else

  long FileNumber;
  pFileCommandObject pFCO;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);
  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;

  if( FileNumber < 1 || FileNumber > MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )ERROR(COMMAND_ERROR_FILE_IS_NOT_OPENED);
  if( pFCO->mode[FileNumber] != 's' )/* sockets are binary and binary only */
    HOOK_BINMODE(THISFILEP);
#endif
END

COMMAND(TXTMF)
#if NOTIMP_TEXTMF
NOTIMPLEMENTED;
#else

  long FileNumber;
  pFileCommandObject pFCO;

  INITIALIZE;
  pFCO = (pFileCommandObject)PARAMPTR(CMD_OPEN);

  FileNumber = LONGVALUE(CONVERT2LONG(EVALUATEEXPRESSION(PARAMETERNODE)));
  ASSERTOKE;

  if( FileNumber < 1 || FileNumber > MAXFILES )ERROR(COMMAND_ERROR_BAD_FILE_NUMBER);
  FileNumber --;
  if( ! pFCO->mode[FileNumber] )ERROR(COMMAND_ERROR_FILE_IS_NOT_OPENED);
  if( pFCO->mode[FileNumber] != 's' )/* sockets are binary and binary only */
    HOOK_TEXTMODE(THISFILEP);
#endif
END

COMMAND(BINMO)
#if NOTIMP_BINMO
NOTIMPLEMENTED;
#else
  HOOK_BINMODE(stdout);
#endif
END

COMMAND(BINMI)
#if NOTIMP_BINMI
NOTIMPLEMENTED;
#else
  HOOK_BINMODE(stdin);
#endif
END

COMMAND(TXTMO)
#if NOTIMP_TEXTMO
NOTIMPLEMENTED;
#else
  HOOK_TEXTMODE(stdout);
#endif
END

COMMAND(TXTMI)
#if NOTIMP_TEXTMI
NOTIMPLEMENTED;
#else
  HOOK_TEXTMODE(stdin);
#endif
END

---