Compare commits

...

1 Commits

Author SHA1 Message Date
The ReactOS Team
6caaf63c2c This commit was manufactured by cvs2svn to create tag 'krnl0015'.
svn path=/tags/krnl0015/; revision=940
2000-01-19 07:05:04 +00:00
96 changed files with 0 additions and 19103 deletions

View File

@@ -1,115 +0,0 @@
/*
* fcntl.h
*
* Access constants for _open. Note that the permissions constants are
* in sys/stat.h (ick).
*
* This code is part of the Mingw32 package.
*
* Contributors:
* Created by Colin Peters <colin@bird.fu.is.saga-u.ac.jp>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* $Revision: 1.4 $
* $Author: ariadne $
* $Date: 1999/03/22 20:48:08 $
*
*/
/* Appropriated for Reactos Crtdll by Ariadne */
/* added _O_RANDOM_O_SEQUENTIAL _O_SHORT_LIVED*/
/* changed fmode_dll */
#ifndef _FCNTL_H_
#define _FCNTL_H_
/*
* It appears that fcntl.h should include io.h for compatibility...
*/
#include <io.h>
/*
* This variable determines the default file mode.
* TODO: Which flags work?
*/
#if __MSVCRT__
extern unsigned int* __imp__fmode;
#define _fmode (*__imp__fmode)
#else
/* CRTDLL */
extern unsigned int* _fmode_dll;
#define _fmode (*_fmode_dll)
#endif
/* Specifiy one of these flags to define the access mode. */
#define _O_RDONLY 0
#define _O_WRONLY 1
#define _O_RDWR 2
/* Mask for access mode bits in the _open flags. */
#define _O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR)
#define _O_APPEND 0x0008 /* Writes will add to the end of the file. */
#define _O_CREAT 0x0100 /* Create the file if it does not exist. */
#define _O_TRUNC 0x0200 /* Truncate the file if it does exist. */
#define _O_EXCL 0x0400 /* Open only if the file does not exist. */
/* NOTE: Text is the default even if the given _O_TEXT bit is not on. */
#define _O_TEXT 0x4000 /* CR-LF in file becomes LF in memory. */
#define _O_BINARY 0x8000 /* Input and output is not translated. */
#define _O_RAW _O_BINARY
#define _O_TEMPORARY 0x0040 /* Make the file dissappear after closing.
* WARNING: Even if not created by _open! */
#define _O_RANDOM 0x0010
#define _O_SEQUENTIAL _O_RANDOM
#define _O_SHORT_LIVED 0x1000
#ifndef __STRICT_ANSI__
#ifndef _NO_OLDNAMES
/* POSIX/Non-ANSI names for increased portability */
#define O_RDONLY _O_RDONLY
#define O_WRONLY _O_WRONLY
#define O_RDWR _O_RDWR
#define O_ACCMODE _O_ACCMODE
#define O_APPEND _O_APPEND
#define O_CREAT _O_CREAT
#define O_TRUNC _O_TRUNC
#define O_EXCL _O_EXCL
#define O_TEXT _O_TEXT
#define O_BINARY _O_BINARY
#define O_TEMPORARY _O_TEMPORARY
#define O_RANDOM _O_RANDOM
#define O_SEQUENTIAL _O_RANDOM
#define O_SHORT_LIVED _O_SHORT_LIVED
#endif /* Not _NO_OLDNAMES */
#ifdef __cplusplus
extern "C" {
#endif
int _setmode (int nHandle, int nAccessMode);
#ifndef _NO_OLDNAMES
int setmode (int nHandle, int nAccessMode);
#endif /* Not _NO_OLDNAMES */
#ifdef __cplusplus
}
#endif
#endif /* Not __STRICT_ANSI__ */
#endif /* Not _FCNTL_H_ */

View File

@@ -1,193 +0,0 @@
/*
* stdlib.h
*
* Definitions for common types, variables, and functions.
*
* This file is part of the Mingw32 package.
*
* Contributors:
* Created by Colin Peters <colin@bird.fu.is.saga-u.ac.jp>
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
* This source code is offered for use in the public domain. You may
* use, modify or distribute it freely.
*
* This code is distributed in the hope that it will be useful but
* WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
* DISCLAMED. This includes but is not limited to warranties of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* $Revision: 1.5 $
* $Author: ariadne $
* $Date: 1999/03/22 20:48:08 $
*
*/
/* Appropriated for Reactos Crtdll by Ariadne */
/* added splitpath */
/* changed definition of environ and argc */
#ifndef _STDLIB_H_
#define _STDLIB_H_
#ifdef __cplusplus
extern "C" {
#endif
/*
* This seems like a convenient place to declare these variables, which
* give programs using WinMain (or main for that matter) access to main-ish
* argc and argv. environ is a pointer to a table of environment variables.
* NOTE: Strings in _argv and environ are ANSI strings.
*/
extern int* __argc_dll;
extern char*** __argv_dll;
extern char*** _environ_dll;
#define __argc (*__argc_dll)
#define __argv (*__argv_dll)
#define _environ (*_environ_dll)
#define __need_size_t
#define __need_wchar_t
#define __need_NULL
#include <stddef.h>
#ifdef __GNUC__
#define _ATTRIB_NORETURN __attribute__ ((noreturn))
#else /* Not __GNUC__ */
#define _ATTRIB_NORETURN
#endif /* __GNUC__ */
double atof (const char* szNumber);
int atoi (const char* szNumber);
long atol (const char* szNumber);
double strtod (const char* szNumber, char** pszAfterNumber);
double wcstod (const wchar_t* wsNumber, wchar_t** pwsAfterNumber);
long strtol (const char* szNumber, char** pszAfterNumber, int nBase);
long wcstol (const wchar_t* wsNumber, wchar_t** pwsAfterNumber, int nBase);
unsigned long strtoul (const char* szNumber, char** pszAfterNumber,
int nBase);
unsigned long wcstoul (const wchar_t* wsNumber, wchar_t** pwsAfterNumber,
int nBase);
size_t wcstombs (char* mbsDest, const wchar_t* wsConvert, size_t size);
int wctomb (char* mbDest, wchar_t wc);
int mblen (const char* mbs, size_t sizeString);
size_t mbstowcs (wchar_t* wcaDest, const char* mbsConvert,
size_t size);
int mbtowc (wchar_t* wcDest, const char* mbConvert, size_t size);
/*
* RAND_MAX is the maximum value that may be returned by rand.
* The minimum is zero.
*/
#define RAND_MAX 0x7FFF
int rand (void);
void srand (unsigned int nSeed);
void* calloc (size_t sizeObjCnt, size_t sizeObject);
void* malloc (size_t sizeObject);
void* realloc (void* pObject, size_t sizeNew);
void free (void* pObject);
/* These values may be used as exit status codes. */
#define EXIT_SUCCESS 0
#define EXIT_FAILURE -1
void abort (void) _ATTRIB_NORETURN;
void exit (int nStatus) _ATTRIB_NORETURN;
int atexit (void (*pfuncExitProcessing)(void));
int system (const char* szCommand); // impl in process
char* getenv (const char* szVarName); // impl in stdio
typedef int (*_pfunccmp_t)(const void*, const void*);
void* bsearch (const void* pKey, const void* pBase, size_t cntObjects,
size_t sizeObject, _pfunccmp_t pfuncCmp);
void qsort (const void* pBase, size_t cntObjects, size_t sizeObject,
_pfunccmp_t pfuncCmp);
int abs (int n);
long labs (long n);
/*
* div_t and ldiv_t are structures used to return the results of div and
* ldiv.
*
* NOTE: div and ldiv appear not to work correctly unless
* -fno-pcc-struct-return is specified. This is included in the
* mingw32 specs file.
*/
typedef struct { int quot, rem; } div_t;
typedef struct { long quot, rem; } ldiv_t;
typedef struct { long long quot, rem; } lldiv_t;
div_t div (int nNumerator, int nDenominator);
ldiv_t ldiv (long lNumerator, long lDenominator);
lldiv_t lldiv (long long lNumerator, long long lDenominator);
#ifndef __STRICT_ANSI__
/*
* NOTE: Officially the three following functions are obsolete. The Win32 API
* functions SetErrorMode, Beep and Sleep are their replacements.
*/
void _beep (unsigned int, unsigned int);
void _seterrormode (int nMode);
void _sleep (unsigned long ulTime);
void _exit (int nStatus) _ATTRIB_NORETURN;
int _putenv (const char* szNameEqValue);
void _searchenv (const char* szFileName, const char* szVar,
char* szFullPathBuf);
void _splitpath( const char *path, char *drive, char *dir,
char *fname, char *ext );
char* _itoa (int nValue, char* sz, int nRadix);
char* _ltoa (long lnValue, char* sz, int nRadix);
char* _ecvt (double dValue, int nDig, int* pnDec, int* pnSign);
char* _fcvt (double dValue, int nDig, int* pnDec, int* pnSign);
char* _gcvt (double dValue, int nDec, char* caBuf);
char* _fullpath (char* caBuf, const char* szPath, size_t sizeMax);
#ifndef _NO_OLDNAMES
#define beep _beep
#define seterrormode _seterrormode
#define sleep _sleep
#define putenv _putenv
#define searchenv _searchenv
#define splitpath _splitpath
#define itoa _itoa
#define ltoa _ltoa
#define ecvt _ecvt
#define fcvt _fcvt
#define gcvt _gcvt
#endif /* Not _NO_OLDNAMES */
#endif /* Not __STRICT_ANSI__ */
/*
* Undefine the no return attribute used in some function definitions
*/
#undef _ATTRIB_NORETURN
#ifdef __cplusplus
}
#endif
#endif /* _STDLIB_H_ */

View File

@@ -1,45 +0,0 @@
ifneq ($(HOST),mingw32-windows)
ifneq ($(HOST),mingw32-linux)
DLLTARGET=ntdll.a
DLLMAIN=
else
DLLTARGET=ntdll.dll
DLLMAIN=main/dllmain.o
endif
else
DLLTARGET=ntdll.dll
DLLMAIN=main/dllmain.o
endif
all: $(DLLTARGET)
OBJECTS = napi.o ldr/startup.o rtl/largeint.o rtl/namespc.o rtl/unicode.o \
stdio/vsprintf.o string/ctype.o string/memcpy.o string/memset.o \
string/strcat.o string/strcmp.o string/strcpy.o string/stricmp.o \
string/strlen.o string/strncmp.o string/strncpy.o string/strnlen.o \
string/strrchr.o string/wstring.o stubs/stubs.o rtl/heap.o \
rtl/critical.o rtl/mem.o
ntdll.a: $(OBJECTS)
$(AR) csr ntdll.a $(OBJECTS)
ntdll.dll: $(DLLMAIN) $(OBJECTS) def/ntdll.def
$(LD) -r $(DLLMAIN) $(OBJECTS) -o ntdll.o
$(DLLTOOL) --dllname ntdll.dll --def def/ntdll.def \
--output-lib ntdll.a
$(CC) -specs=ntdll_specs -mdll -o junk.tmp \
-Wl,--base-file,base.tmp ntdll.o
- $(RM) junk.tmp
$(DLLTOOL) --dllname ntdll.dll --base-file base.tmp \
--output-exp temp.exp --def def/ntdll.def
- $(RM) base.tmp
$(CC) -specs=ntdll_specs -mdll -o ntdll.dll ntdll.o \
-Wl,--entry=_LdrStartup \
-Wl,--image-base,0x80000000 \
-Wl,--file-alignment,0x1000 \
-Wl,--section-alignment,0x1000 \
-Wl,temp.exp
- $(RM) temp.exp
$(NM) --numeric-sort ntdll.dll > ntdll.sym
include ../../rules.mak

View File

@@ -1,142 +0,0 @@
#
# Global makefile
#
#
# Select your host
#
#HOST = mingw32-linux
#HOST = djgpp-msdos
HOST = mingw32-windows
include rules.mak
#
# Required to run the system
#
COMPONENTS = iface_native ntoskrnl
#DLLS = ntdll kernel32 crtdll user32 fmifs gdi32
DLLS = ntdll kernel32 crtdll fmifs gdi32
#DLLS = crtdll mingw32
SUBSYS = win32k
#
# Select the server(s) you want to build
#
SERVERS = win32
# SERVERS = posix linux os2
#
# Select the loader(s) you want to build
#
LOADERS = dos
# LOADERS = boot
#
# Select the device drivers and filesystems you want
#
DEVICE_DRIVERS = blue ide keyboard mouse null parallel serial vidport
# DEVICE_DRIVERS = beep event floppy ide_test sound test test1
FS_DRIVERS = vfat
# FS_DRIVERS = minix ext2 template
KERNEL_SERVICES = $(DEVICE_DRIVERS) $(FS_DRIVERS)
APPS = args hello shell test cat bench
# APPS = cmd
all: $(COMPONENTS) $(DLLS) $(SUBSYS) $(LOADERS) $(KERNEL_SERVICES) $(APPS)
.PHONY: all
clean: $(COMPONENTS:%=%_clean) $(DLLS:%=%_clean) $(LOADERS:%=%_clean) \
$(KERNEL_SERVICES:%=%_clean) $(APPS:%=%_clean)
.PHONY: clean
#
# Applications
#
$(APPS): %:
make -C apps/$*
$(APPS:%=%_clean): %_clean:
make -C apps/$* clean
.PHONY: $(APPS) $(APPS:%=%_clean)
#
# Interfaces
#
iface_native:
make -C iface/native
iface_native_clean:
make -C iface/native clean
.PHONY: iface_native iface_native_clean
#
# Device driver rules
#
$(DEVICE_DRIVERS): %:
make -C services/dd/$*
$(DEVICE_DRIVERS:%=%_clean): %_clean:
make -C services/dd/$* clean
.PHONY: $(DEVICE_DRIVERS) $(DEVICE_DRIVERS:%=%_clean)
$(FS_DRIVERS): %:
make -C services/fs/$*
$(FS_DRIVERS:%=%_clean): %_clean:
make -C services/fs/$* clean
.PHONY: $(FS_DRIVERS) $(FS_DRIVERS:%=%_clean)
#
# Kernel loaders
#
$(LOADERS): %:
make -C loaders/$*
$(LOADERS:%=%_clean): %_clean:
make -C loaders/$* clean
.PHONY: $(LOADERS) $(LOADERS:%=%_clean)
#
# Required system components
#
ntoskrnl:
make -C ntoskrnl
ntoskrnl_clean:
make -C ntoskrnl clean
.PHONY: ntoskrnl ntoskrnl_clean
#
# Required DLLs
#
$(DLLS): %:
make -C lib/$*
$(DLLS:%=%_clean): %_clean:
make -C lib/$* clean
.PHONY: $(DLLS) $(DLLS:%=%_clean)
#
# Kernel Subsystems
#
$(SUBSYS): %:
make -C subsys/$*
$(SUBSYS:%=%_clean): %_clean:
make -C lib/$* clean
.PHONY: $(SUBSYS) $(SUBSYS:%=%_clean)

View File

@@ -1,87 +0,0 @@
#
# Global makefile for the ROSAPPS package
#
#
# Select your host
#
#HOST = djgpp-msdos
HOST = mingw32-windows
include rules.mak
#
# Available applications
#
APPS = cmd cmdutils notevil sysutils
all: $(APPS)
.PHONY: all
clean: $(APPS:%=%_clean)
.PHONY: clean
floppy: make_floppy_dirs $(APPS:%=%_floppy)
dist: clean_dist_dir make_dist_dirs $(APPS:%=%_dist)
.PHONY: dist
#
# Applications
#
$(APPS): %:
make -C $*
$(APPS:%=%_clean): %_clean:
make -C $* clean
$(APPS:%=%_floppy): %_floppy:
make -C $* floppy
$(APPS:%=%_dist): %_dist:
make -C $* dist
.PHONY: $(APPS) $(APPS:%=%_clean) $(APPS:%=%_floppy) $(APPS:%=%_dist)
#
# Make an install floppy
#
install: all
./install.sh /mnt/hda1
make_floppy_dirs:
ifeq ($(DOSCLI),yes)
mkdir $(FLOPPY_DIR)\apps
else
mkdir $(FLOPPY_DIR)/apps
endif
.PHONY: make_floppy_dirs
#
# Make a distribution saveset
#
clean_dist_dir:
ifeq ($(DOSCLI),yes)
# $(RM) $(DIST_DIR)\apps\*.*
# $(RMDIR) $(DIST_DIR)\apps
# $(RMDIR) $(DIST_DIR)
else
$(RM) -r $(DIST_DIR)
endif
make_dist_dirs:
ifeq ($(DOSCLI),yes)
mkdir $(DIST_DIR)
mkdir $(DIST_DIR)\apps
else
mkdir $(DIST_DIR)
mkdir $(DIST_DIR)/apps
endif
.PHONY: clean_dist_dir make_dist_dirs
# EOF

View File

@@ -1,356 +0,0 @@
/*
* ALIAS.C - alias administration module.
*
*
* History:
*
* 02/02/1996 (Oliver Mueller)
* started.
*
* 02/03/1996 (Oliver Mueller)
* Added sorting algorithm and case sensitive substitution by using
* partstrupr().
*
* 27 Jul 1998 John P. Price
* added config.h include
* added ifdef's to disable aliases
*
* 09-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed crash when removing an alias in DeleteAlias().
* Added help text ("/?").
*
* 14-Jan-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Clean up and Unicode safe!
*
* 24-Jan-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Redirection safe!
*/
#include "config.h"
#ifdef FEATURE_ALIASES
#include <windows.h>
#include <tchar.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
typedef struct tagALIAS
{
struct tagALIAS *next;
LPTSTR lpName;
LPTSTR lpSubst;
DWORD dwUsed;
} ALIAS, *LPALIAS;
static LPALIAS lpFirst = NULL;
static LPALIAS lpLast = NULL;
static DWORD dwUsed = 0;
/* module internal functions */
/* strlwr only for first word in string */
static VOID
partstrlwr (LPTSTR str)
{
LPTSTR c = str;
while (*c && !_istspace (*c) && *c != _T('='))
{
*c = _totlower (*c);
c++;
}
}
static VOID
PrintAlias (VOID)
{
LPALIAS ptr = lpFirst;
while (ptr)
{
ConOutPrintf (_T("%s=%s\n"), ptr->lpName, ptr->lpSubst);
ptr = ptr->next;
}
}
static VOID
DeleteAlias (LPTSTR pszName)
{
LPALIAS ptr = lpFirst;
LPALIAS prev = NULL;
while (ptr)
{
if (!_tcsicmp (ptr->lpName, pszName))
{
if (prev)
prev->next = ptr->next;
else
lpFirst = ptr->next;
free (ptr->lpName);
free (ptr->lpSubst);
free (ptr);
return;
}
prev = ptr;
ptr = ptr->next;
}
}
static VOID
AddAlias (LPTSTR name, LPTSTR subst)
{
LPALIAS ptr = lpFirst;
LPALIAS prev, entry;
LPTSTR s;
while (ptr)
{
if (!_tcsicmp (ptr->lpName, name))
{
s = (LPTSTR)malloc ((_tcslen (subst) + 1)*sizeof(TCHAR));
if (!s)
{
error_out_of_memory ();
return;
}
free (ptr->lpSubst);
ptr->lpSubst = s;
_tcscpy (ptr->lpSubst, subst);
return;
}
ptr = ptr->next;
}
ptr = (LPALIAS)malloc (sizeof (ALIAS));
if (!ptr)
return;
ptr->next = 0;
ptr->lpName = (LPTSTR)malloc ((_tcslen (name) + 1)*sizeof(TCHAR));
if (!ptr->lpName)
{
error_out_of_memory ();
free (ptr);
return;
}
_tcscpy (ptr->lpName, name);
ptr->lpSubst = (LPTSTR)malloc ((_tcslen (subst) + 1)*sizeof(TCHAR));
if (!ptr->lpSubst)
{
error_out_of_memory ();
free (ptr->lpName);
free (ptr);
return;
}
_tcscpy (ptr->lpSubst, subst);
/* it's necessary for recursive substitution */
partstrlwr (ptr->lpSubst);
ptr->dwUsed = 0;
/* Alias table must be sorted!
* Here a little example:
* command line = "ls -c"
* If the entries are
* ls=dir
* ls -c=ls /w
* command line will be expanded to "dir -c" which is not correct.
* If the entries are sortet as
* ls -c=ls /w
* ls=dir
* it will be expanded to "dir /w" which is a valid DOS command.
*/
entry = lpFirst;
prev = 0;
while (entry)
{
if (_tcsicmp (ptr->lpName, entry->lpName) > 0)
{
if (prev)
{
prev->next = ptr;
ptr->next = entry;
}
else
{
ptr->next = entry;
lpFirst = ptr;
}
return;
}
prev = entry;
entry = entry->next;
}
/* The new entry is the smallest (or the first) and must be
* added to the end of the list.
*/
if (!lpFirst)
lpFirst = ptr;
else
lpLast->next = ptr;
lpLast = ptr;
return;
}
VOID InitializeAlias (VOID)
{
lpFirst = NULL;
lpLast = NULL;
dwUsed = 0;
}
VOID DestroyAlias (VOID)
{
if (lpFirst == NULL)
return;
while (lpFirst->next != NULL)
{
lpLast = lpFirst;
lpFirst = lpLast->next;
free (lpLast->lpName);
free (lpLast->lpSubst);
free (lpLast);
}
free (lpFirst->lpName);
free (lpFirst->lpSubst);
free (lpFirst);
lpFirst = NULL;
lpLast = NULL;
dwUsed = 0;
}
/* specified routines */
VOID ExpandAlias (LPTSTR cmd, INT maxlen)
{
unsigned n = 0,
m,
i,
len;
short d = 1;
LPALIAS ptr = lpFirst;
dwUsed++;
if (dwUsed == 0)
{
while (ptr)
ptr->dwUsed = 0;
ptr = lpFirst;
dwUsed = 1;
}
/* skipping white spaces */
while (_istspace (cmd[n]))
n++;
partstrlwr (&cmd[n]);
if (!_tcsncmp (&cmd[n], _T("NOALIAS"), 7) &&
(_istspace (cmd[n + 7]) || cmd[n + 7] == _T('\0')))
{
memmove (cmd, &cmd[n + 7], (_tcslen (&cmd[n + 7]) + 1) * sizeof (TCHAR));
return;
}
/* substitution loop */
while (d)
{
d = 0;
while (ptr)
{
len = _tcslen (ptr->lpName);
if (!_tcsncmp (&cmd[n], ptr->lpName, len) &&
(_istspace (cmd[n + len]) || cmd[n + len] == _T('\0')) &&
ptr->dwUsed != dwUsed)
{
m = _tcslen (ptr->lpSubst);
if ((int)(_tcslen (cmd) - len + m - n) > maxlen)
{
ConErrPrintf (_T("Command line too long after alias expansion!\n"));
/* the parser won't cause any problems with an empty line */
cmd[0] = _T('\0');
}
else
{
memmove (&cmd[m], &cmd[n + len], (_tcslen(&cmd[n + len]) + 1) * sizeof (TCHAR));
for (i = 0; i < m; i++)
cmd[i] = ptr->lpSubst[i];
ptr->dwUsed = dwUsed;
/* whitespaces are removed! */
n = 0;
d = 1;
}
}
ptr = ptr->next;
}
}
}
INT CommandAlias (LPTSTR cmd, LPTSTR param)
{
LPTSTR ptr;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Sets, removes or shows aliases.\n"
"\n"
"ALIAS [alias=[command]]\n"
"\n"
" alias Name for an alias.\n"
" command Text to be substituted for an alias.\n"
"\n"
// "For example:\n"
"To list all aliases:\n"
" ALIAS\n\n"
"To set a new or replace an existing alias:\n"
" ALIAS da=dir a:\n\n"
"To remove an alias from the alias list:\n"
" ALIAS da="
// "Type ALIAS without a parameter to display the alias list.\n"
));
return 0;
}
if (param[0] == _T('\0'))
{
PrintAlias ();
return 0;
}
/* error if no '=' found */
if ((ptr = _tcschr (param, _T('='))) == 0)
return 1;
/* Split rest into name and substitute */
*ptr++ = _T('\0');
partstrlwr (param);
if (ptr[0] == _T('\0'))
DeleteAlias (param);
else
AddAlias (param, ptr);
return 0;
}
#endif

View File

@@ -1,356 +0,0 @@
/*
* ATTRIB.C - attrib internal command.
*
*
* History:
*
* 04-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* started
*
* 09-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* implementation works, except recursion ("attrib /s").
*
* 05-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* major rewrite.
* fixed recursion ("attrib /s").
* started directory support ("attrib /s /d").
* updated help text.
*
* 14-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode ready!
*
* 19-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Redirection ready!
*
* 21-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added check for invalid filenames.
*
* 23-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added handling of multiple filenames.
*/
#include "config.h"
#ifdef INCLUDE_CMD_ATTRIB
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
static VOID
PrintAttribute (LPTSTR pszPath, LPTSTR pszFile, BOOL bRecurse)
{
WIN32_FIND_DATA findData;
HANDLE hFind;
TCHAR szFullName[MAX_PATH];
LPTSTR pszFileName;
/* prepare full file name buffer */
_tcscpy (szFullName, pszPath);
pszFileName = szFullName + _tcslen (szFullName);
/* display all subdirectories */
if (bRecurse)
{
/* append file name */
_tcscpy (pszFileName, pszFile);
hFind = FindFirstFile (szFullName, &findData);
if (hFind == INVALID_HANDLE_VALUE)
{
ErrorMessage (GetLastError (), pszFile);
return;
}
do
{
if (!(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
continue;
if (!_tcscmp (findData.cFileName, _T(".")) ||
!_tcscmp (findData.cFileName, _T("..")))
continue;
_tcscpy (pszFileName, findData.cFileName);
_tcscat (pszFileName, _T("\\"));
PrintAttribute (szFullName, pszFile, bRecurse);
}
while (FindNextFile (hFind, &findData));
FindClose (hFind);
}
/* append file name */
_tcscpy (pszFileName, pszFile);
/* display current directory */
hFind = FindFirstFile (szFullName, &findData);
if (hFind == INVALID_HANDLE_VALUE)
{
ErrorMessage (GetLastError (), pszFile);
return;
}
do
{
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
continue;
_tcscpy (pszFileName, findData.cFileName);
ConOutPrintf (_T("%c %c%c%c %s\n"),
(findData.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) ? _T('A') : _T(' '),
(findData.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) ? _T('S') : _T(' '),
(findData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) ? _T('H') : _T(' '),
(findData.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? _T('R') : _T(' '),
szFullName);
}
while (FindNextFile (hFind, &findData));
FindClose (hFind);
}
static VOID
ChangeAttribute (LPTSTR pszPath, LPTSTR pszFile, DWORD dwMask,
DWORD dwAttrib, BOOL bRecurse, BOOL bDirectories)
{
WIN32_FIND_DATA findData;
HANDLE hFind;
DWORD dwAttribute;
TCHAR szFullName[MAX_PATH];
LPTSTR pszFileName;
/* prepare full file name buffer */
_tcscpy (szFullName, pszPath);
pszFileName = szFullName + _tcslen (szFullName);
/* change all subdirectories */
if (bRecurse)
{
/* append file name */
_tcscpy (pszFileName, _T("*.*"));
hFind = FindFirstFile (szFullName, &findData);
if (hFind == INVALID_HANDLE_VALUE)
{
ErrorMessage (GetLastError (), pszFile);
return;
}
do
{
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (!_tcscmp (findData.cFileName, _T(".")) ||
!_tcscmp (findData.cFileName, _T("..")))
continue;
_tcscpy (pszFileName, findData.cFileName);
_tcscat (pszFileName, _T("\\"));
ChangeAttribute (szFullName, pszFile, dwMask,
dwAttrib, bRecurse, bDirectories);
}
}
while (FindNextFile (hFind, &findData));
FindClose (hFind);
}
/* append file name */
_tcscpy (pszFileName, pszFile);
hFind = FindFirstFile (szFullName, &findData);
if (hFind == INVALID_HANDLE_VALUE)
{
ErrorMessage (GetLastError (), pszFile);
return;
}
do
{
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
continue;
_tcscpy (pszFileName, findData.cFileName);
dwAttribute = GetFileAttributes (szFullName);
if (dwAttribute != 0xFFFFFFFF)
{
dwAttribute = (dwAttribute & ~dwMask) | dwAttrib;
SetFileAttributes (szFullName, dwAttribute);
}
}
while (FindNextFile (hFind, &findData));
FindClose (hFind);
}
INT CommandAttrib (LPTSTR cmd, LPTSTR param)
{
LPTSTR *arg;
INT argc, i;
TCHAR szPath[MAX_PATH];
TCHAR szFileName [MAX_PATH];
BOOL bRecurse = FALSE;
BOOL bDirectories = FALSE;
DWORD dwAttrib = 0;
DWORD dwMask = 0;
/* initialize strings */
szPath[0] = _T('\0');
szFileName[0] = _T('\0');
/* print help */
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays or changes file attributes.\n\n"
"ATTRIB [+R | -R] [+A | -A] [+S | -S] [+H | -H] file ...\n"
" [/S [/D]]\n\n"
" + Sets an attribute\n"
" - Clears an attribute\n"
" R Read-only file attribute\n"
" A Archive file attribute\n"
" S System file attribute\n"
" H Hidden file attribute\n"
" /S Processes matching files in the current directory\n"
" and all subdirectories\n"
" /D Processes direcories as well\n\n"
"Type ATTRIB without a parameter to display the attributes of all files."));
return 0;
}
/* build parameter array */
arg = split (param, &argc);
/* check for options */
for (i = 0; i < argc; i++)
{
if (_tcsicmp (arg[i], _T("/s")) == 0)
bRecurse = TRUE;
else if (_tcsicmp (arg[i], _T("/d")) == 0)
bDirectories = TRUE;
}
/* create attributes and mask */
for (i = 0; i < argc; i++)
{
if (*arg[i] == _T('+'))
{
if (_tcslen (arg[i]) != 2)
{
error_invalid_parameter_format (arg[i]);
freep (arg);
return -1;
}
switch ((TCHAR)_totupper (arg[i][1]))
{
case _T('A'):
dwMask |= FILE_ATTRIBUTE_ARCHIVE;
dwAttrib |= FILE_ATTRIBUTE_ARCHIVE;
break;
case _T('H'):
dwMask |= FILE_ATTRIBUTE_HIDDEN;
dwAttrib |= FILE_ATTRIBUTE_HIDDEN;
break;
case _T('R'):
dwMask |= FILE_ATTRIBUTE_READONLY;
dwAttrib |= FILE_ATTRIBUTE_READONLY;
break;
case _T('S'):
dwMask |= FILE_ATTRIBUTE_SYSTEM;
dwAttrib |= FILE_ATTRIBUTE_SYSTEM;
break;
default:
error_invalid_parameter_format (arg[i]);
freep (arg);
return -1;
}
}
else if (*arg[i] == _T('-'))
{
if (_tcslen (arg[i]) != 2)
{
error_invalid_parameter_format (arg[i]);
freep (arg);
return -1;
}
switch ((TCHAR)_totupper (arg[i][1]))
{
case _T('A'):
dwMask |= FILE_ATTRIBUTE_ARCHIVE;
dwAttrib &= ~FILE_ATTRIBUTE_ARCHIVE;
break;
case _T('H'):
dwMask |= FILE_ATTRIBUTE_HIDDEN;
dwAttrib &= ~FILE_ATTRIBUTE_HIDDEN;
break;
case _T('R'):
dwMask |= FILE_ATTRIBUTE_READONLY;
dwAttrib &= ~FILE_ATTRIBUTE_READONLY;
break;
case _T('S'):
dwMask |= FILE_ATTRIBUTE_SYSTEM;
dwAttrib &= ~FILE_ATTRIBUTE_SYSTEM;
break;
default:
error_invalid_parameter_format (arg[i]);
freep (arg);
return -1;
}
}
}
if (argc == 0)
{
DWORD len;
len = GetCurrentDirectory (MAX_PATH, szPath);
if (szPath[len-1] != _T('\\'))
{
szPath[len] = _T('\\');
szPath[len + 1] = 0;
}
_tcscpy (szFileName, _T("*.*"));
PrintAttribute (szPath, szFileName, bRecurse);
freep (arg);
return 0;
}
/* get full file name */
for (i = 0; i < argc; i++)
{
if ((*arg[i] != _T('+')) && (*arg[i] != _T('-')) && (*arg[i] != _T('/')))
{
LPTSTR p;
GetFullPathName (arg[i], MAX_PATH, szPath, NULL);
p = _tcsrchr (szPath, _T('\\')) + 1;
_tcscpy (szFileName, p);
*p = _T('\0');
if (dwMask == 0)
PrintAttribute (szPath, szFileName, bRecurse);
else
ChangeAttribute (szPath, szFileName, dwMask,
dwAttrib, bRecurse, bDirectories);
}
}
freep (arg);
return 0;
}
#endif /* INCLUDE_CMD_ATTRIB */

View File

@@ -1,446 +0,0 @@
/* $Id: batch.c,v 1.3 1999/10/03 22:20:32 ekohl Exp $
*
* BATCH.C - batch file processor for CMD.EXE.
*
*
* History:
*
* ??/??/?? (Evan Jeffrey)
* started.
*
* 15 Jul 1995 (Tim Norman)
* modes and bugfixes.
*
* 08 Aug 1995 (Matt Rains)
* i have cleaned up the source code. changes now bring this
* source into guidelines for recommended programming practice.
*
* i have added some constants to help making changes easier.
*
* 29 Jan 1996 (Steffan Kaiser)
* made a few cosmetic changes
*
* 05 Feb 1996 (Tim Norman)
* changed to comply with new first/rest calling scheme
*
* 14 Jun 1997 (Steffen Kaiser)
* bug fixes. added error level expansion %?. ctrl-break handling
*
* 16 Jul 1998 (Hans B Pufal)
* Totally reorganised in conjunction with COMMAND.C (cf) to
* implement proper BATCH file nesting and other improvements.
*
* 16 Jul 1998 (John P Price <linux-guru@gcfl.net>)
* Seperated commands into individual files.
*
* 19 Jul 1998 (Hans B Pufal) [HBP_001]
* Preserve state of echo flag across batch calls.
*
* 19 Jul 1998 (Hans B Pufal) [HBP_002]
* Implementation of FOR command
*
* 20-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added error checking after malloc calls
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 02-Aug-1998 (Hans B Pufal) [HBP_003]
* Fixed bug in ECHO flag restoration at exit from batch file
*
* 26-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Replaced CRT io functions by Win32 io functions.
* Unicode safe!
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "cmd.h"
#include "batch.h"
/* The stack of current batch contexts.
* NULL when no batch is active
*/
LPBATCH_CONTEXT bc = NULL;
BOOL bEcho = TRUE; /* The echo flag */
/* Buffer for reading Batch file lines */
TCHAR textline[BATCH_BUFFSIZE];
/*
* Returns a pointer to the n'th parameter of the current batch file.
* If no such parameter exists returns pointer to empty string.
* If no batch file is current, returns NULL
*
*/
LPTSTR FindArg (INT n)
{
LPTSTR pp;
#ifdef _DEBUG
DebugPrintf ("FindArg: (%d)\n", n);
#endif
if (bc == NULL)
return NULL;
n += bc->shiftlevel;
pp = bc->params;
/* Step up the strings till we reach the end */
/* or the one we want */
while (*pp && n--)
pp += _tcslen (pp) + 1;
return pp;
}
/*
* Batch_params builds a parameter list in newlay allocated memory.
* The parameters consist of null terminated strings with a final
* NULL character signalling the end of the parameters.
*
*/
LPTSTR BatchParams (LPTSTR s1, LPTSTR s2)
{
LPTSTR dp = (LPTSTR)malloc ((_tcslen(s1) + _tcslen(s2) + 3) * sizeof (TCHAR));
/* JPP 20-Jul-1998 added error checking */
if (dp == NULL)
{
error_out_of_memory();
return NULL;
}
if (s1 && *s1)
{
s1 = stpcpy (dp, s1);
*s1++ = _T('\0');
}
else
s1 = dp;
while (*s2)
{
if (_istspace (*s2) || _tcschr (_T(",;"), *s2))
{
*s1++ = _T('\0');
s2++;
while (*s2 && _tcschr (_T(" ,;"), *s2))
s2++;
continue;
}
if ((*s2 == _T('"')) || (*s2 == _T('\'')))
{
TCHAR st = *s2;
do
*s1++ = *s2++;
while (*s2 && (*s2 != st));
}
*s1++ = *s2++;
}
*s1++ = _T('\0');
*s1 = _T('\0');
return dp;
}
/*
* If a batch file is current, exits it, freeing the context block and
* chaining back to the previous one.
*
* If no new batch context is found, sets ECHO back ON.
*
* If the parameter is non-null or not empty, it is printed as an exit
* message
*/
VOID ExitBatch (LPTSTR msg)
{
#ifdef _DEBUG
DebugPrintf ("ExitBatch: (\'%s\')\n", msg);
#endif
if (bc != NULL)
{
LPBATCH_CONTEXT t = bc;
if (bc->hBatchFile)
{
CloseHandle (bc->hBatchFile);
bc->hBatchFile = INVALID_HANDLE_VALUE;
}
if (bc->params)
free(bc->params);
if (bc->forproto)
free(bc->forproto);
if (bc->ffind)
free(bc->ffind);
/* Preserve echo state across batch calls */
bEcho = bc->bEcho;
bc = bc->prev;
free(t);
}
if (msg && *msg)
ConOutPrintf ("%s\n", msg);
}
/*
* Start batch file execution
*
* The firstword parameter is the full filename of the batch file.
*
*/
BOOL Batch (LPTSTR fullname, LPTSTR firstword, LPTSTR param)
{
HANDLE hFile;
hFile = CreateFile (fullname, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL |
FILE_FLAG_SEQUENTIAL_SCAN, NULL);
#ifdef _DEBUG
DebugPrintf ("Batch: (\'%s\', \'%s\', \'%s\') hFile = %x\n",
fullname, firstword, param, hFile);
#endif
if (hFile == INVALID_HANDLE_VALUE)
{
ConErrPrintf (_T("Error opening batch file\n"));
return FALSE;
}
/* Kill any and all FOR contexts */
while (bc && bc->forvar)
ExitBatch (NULL);
if (bc == NULL)
{
/* No curent batch file, create a new context */
LPBATCH_CONTEXT n = (LPBATCH_CONTEXT)malloc (sizeof(BATCH_CONTEXT));
if (n == NULL)
{
error_out_of_memory ();
return FALSE;
}
n->prev = bc;
bc = n;
}
else if (bc->hBatchFile != INVALID_HANDLE_VALUE)
{
/* Then we are transferring to another batch */
CloseHandle (bc->hBatchFile);
bc->hBatchFile = INVALID_HANDLE_VALUE;
free (bc->params);
}
bc->hBatchFile = hFile;
bc->bEcho = bEcho; /* Preserve echo across batch calls */
bc->shiftlevel = 0;
bc->ffind = NULL;
bc->forvar = _T('\0');
bc->forproto = NULL;
bc->params = BatchParams (firstword, param);
#ifdef _DEBUG
DebugPrintf ("Batch: returns TRUE\n");
#endif
return TRUE;
}
/*
* Read and return the next executable line form the current batch file
*
* If no batch file is current or no further executable lines are found
* return NULL.
*
* Here we also look out for FOR bcontext structures which trigger the
* FOR expansion code.
*
* Set eflag to 0 if line is not to be echoed else 1
*/
LPTSTR ReadBatchLine (LPBOOL bLocalEcho)
{
HANDLE hFind = INVALID_HANDLE_VALUE;
LPTSTR first;
LPTSTR ip;
/* No batch */
if (bc == NULL)
return NULL;
#ifdef _DEBUG
DebugPrintf ("ReadBatchLine ()\n");
#endif
while (1)
{
/* User halt */
if (CheckCtrlBreak (BREAK_BATCHFILE))
{
while (bc)
ExitBatch (NULL);
return NULL;
}
/* No batch */
if (bc == NULL)
return NULL;
/* If its a FOR context... */
if (bc->forvar)
{
LPTSTR sp = bc->forproto; /* pointer to prototype command */
LPTSTR dp = textline; /* Place to expand protoype */
LPTSTR fv = FindArg (0); /* Next list element */
/* End of list so... */
if ((fv == NULL) || (*fv == _T('\0')))
{
/* just exit this context */
ExitBatch (NULL);
continue;
}
if (_tcscspn (fv, _T("?*")) == _tcslen (fv))
{
/* element is wild file */
bc->shiftlevel++; /* No use it and shift list */
}
else
{
/* Wild file spec, find first (or next) file name */
if (bc->ffind)
{
/* First already done so do next */
fv = FindNextFile (hFind, bc->ffind) ? bc->ffind->cFileName : NULL;
}
else
{
/* For first find, allocate a find first block */
if ((bc->ffind = (LPWIN32_FIND_DATA)malloc (sizeof (WIN32_FIND_DATA))) == NULL)
{
error_out_of_memory();
return NULL;
}
hFind = FindFirstFile (fv, bc->ffind);
fv = !(hFind==INVALID_HANDLE_VALUE) ? bc->ffind->cFileName : NULL;
}
if (fv == NULL)
{
/* Null indicates no more files.. */
free (bc->ffind); /* free the buffer */
bc->ffind = NULL;
bc->shiftlevel++; /* On to next list element */
continue;
}
}
/* At this point, fv points to parameter string */
while (*sp)
{
if ((*sp == _T('%')) && (*(sp + 1) == bc->forvar))
{
/* replace % var */
dp = stpcpy (dp, fv);
sp += 2;
}
else
{
/* Else just copy */
*dp++ = *sp++;
}
}
*dp = _T('\0');
*bLocalEcho = bEcho;
return textline;
}
if (!FileGetString (bc->hBatchFile, textline, sizeof (textline)))
{
#ifdef _DEBUG
DebugPrintf (_T("ReadBatchLine(): Reached EOF!\n"));
#endif
/* End of file.... */
ExitBatch (NULL);
if (bc == NULL)
return NULL;
continue;
}
#ifdef _DEBUG
DebugPrintf (_T("ReadBatchLine(): textline: \'%s\'\n"), textline);
#endif
/* Strip leading spaces and trailing space/control chars */
for (first = textline; _istspace (*first); first++)
;
for (ip = first + _tcslen (first) - 1; _istspace (*ip) || _istcntrl (*ip); ip--)
;
*++ip = _T('\0');
/* ignore labels and empty lines */
if (*first == _T(':') || *first == 0)
continue;
if (*first == _T('@'))
{
/* don't echo this line */
do
first++;
while (_istspace (*first));
*bLocalEcho = 0;
}
else
*bLocalEcho = bEcho;
break;
}
return first;
}
/* EOF */

View File

@@ -1,44 +0,0 @@
/*
* BATCH.H - A structure to preserve the context of a batch file
*
*
*/
#ifndef _BATCH_H_INCLUDED_
#define _BATCH_H_INCLUDED_
typedef struct tagBATCHCONTEXT
{
struct tagBATCHCONTEXT *prev;
LPWIN32_FIND_DATA ffind;
HANDLE hBatchFile;
LPTSTR forproto;
LPTSTR params;
INT shiftlevel;
BOOL bEcho; /* Preserve echo flag across batch calls [HBP_001] */
TCHAR forvar;
} BATCH_CONTEXT, *LPBATCH_CONTEXT;
/* HBP_002 } */
/* The stack of current batch contexts.
* NULL when no batch is active
*/
extern LPBATCH_CONTEXT bc;
extern BOOL bEcho; /* The echo flag */
#define BATCH_BUFFSIZE 2048
extern TCHAR textline[BATCH_BUFFSIZE]; /* Buffer for reading Batch file lines */
LPTSTR FindArg (INT);
LPTSTR BatchParams (LPTSTR, LPTSTR);
VOID ExitBatch (LPTSTR);
BOOL Batch (LPTSTR, LPTSTR, LPTSTR);
LPTSTR ReadBatchLine (LPBOOL);
#endif /* _BATCH_H_INCLUDED_ */

View File

@@ -1,57 +0,0 @@
/*
* BEEP.C - beep internal command.
*
*
* History:
*
* 16 Jul 1998 (Hans B Pufal)
* started.
*
* 16 Jul 1998 (John P Price)
* Separated commands into individual files.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 14-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("beep /?").
* Unicode ready!
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Redirection ready!
*/
#include "config.h"
#ifdef INCLUDE_CMD_BEEP
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
#include "batch.h"
INT cmd_beep (LPTSTR cmd, LPTSTR param)
{
if (_tcsncmp (param, _T("/?"), 2) == 0)
{
ConOutPuts (_T("Beep the speaker.\n\nBEEP"));
return 0;
}
#if 0
/* check if run in batch mode */
if (bc == NULL)
return 1;
#endif
#ifdef __REACTOS__
Beep (440, 50);
#else
MessageBeep (-1);
#endif
return 0;
}
#endif

View File

@@ -1,15 +0,0 @@
**** Please report bugs to ekohl@abo.rhein-zeitung.de! ****
Known bugs in CMD version 0.0.4
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
o let set work with or without the '=' sign. People like it that way.
(I don't know, if I should really fix this?)
o command.com ignores control-c and control-break, which makes it difficult
to quit typing a long file, among other things
o "alias v = dir" doesn't work because of the spaces.
**** Please report bugs to ekohl@abo.rhein-zeitung.de! ****

View File

@@ -1,95 +0,0 @@
/* $Id: call.c,v 1.3 1999/10/03 22:20:33 ekohl Exp $
*
* CALL.C - call internal batch command.
*
*
* History:
*
* 16 Jul 1998 (Hans B Pufal)
* started.
*
* 16 Jul 1998 (John P Price)
* Seperated commands into individual files.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 04-Aug-1998 (Hans B Pufal)
* added lines to initialize for pointers (HBP004) This fixed the
* lock-up that happened sometimes when calling a batch file from
* another batch file.
*
* 07-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("call /?") and cleaned up.
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection safe!
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cmd.h"
#include "batch.h"
/*
* Perform CALL command.
*
* Allocate a new batch context and add it to the current chain.
* Call parsecommandline passing in our param string
* If No batch file was opened then remove our newly allocted
* context block.
*/
INT cmd_call (LPTSTR cmd, LPTSTR param)
{
LPBATCH_CONTEXT n = NULL;
#ifdef _DEBUG
DebugPrintf ("cmd_call: (\'%s\',\'%s\')\n", cmd, param);
#endif
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Calls one batch program from another.\n\n"
"CALL [drive:][path]filename [batch-parameter]\n\n"
" batch-parameter Specifies any command-line information required by the\n"
" batch program."));
return 0;
}
n = (LPBATCH_CONTEXT)malloc (sizeof (BATCH_CONTEXT));
if (n == NULL)
{
error_out_of_memory ();
return 1;
}
n->prev = bc;
bc = n;
bc->hBatchFile = INVALID_HANDLE_VALUE;
bc->params = NULL;
bc->shiftlevel = 0;
bc->forvar = 0; /* HBP004 */
bc->forproto = NULL; /* HBP004 */
ParseCommandLine (param);
/* Wasn't a batch file so remove conext */
if (bc->hBatchFile == INVALID_HANDLE_VALUE)
{
bc = bc->prev;
free (n);
}
return 0;
}
/* EOF */

View File

@@ -1,85 +0,0 @@
/*
* CHCP.C - chcp internal command.
*
*
* History:
*
* 23-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Started.
*
*/
#include "config.h"
#ifdef INCLUDE_CMD_CHCP
#include <windows.h>
#include <tchar.h>
#include <stdlib.h>
#include <string.h>
#include "cmd.h"
INT CommandChcp (LPTSTR cmd, LPTSTR param)
{
LPTSTR *arg;
INT args;
UINT uOldCodePage;
UINT uNewCodePage;
/* print help */
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays or sets the active code page number.\n\n"
"CHCP [nnn]\n\n"
" nnn Specifies the active code page number.\n\n"
"Type CHCP without a parameter to display the active code page number."));
return 0;
}
if (args == 0)
{
/* display active code page number */
ConOutPrintf ("Active code page: %u\n", GetConsoleCP ());
return 0;
}
if (args >= 2)
{
/* too many parameters */
ConErrPrintf ("Invalid parameter format - %s\n", param);
return 1;
}
/* get parameters */
arg = split (param, &args);
/* save old code page */
uOldCodePage = GetConsoleCP ();
uNewCodePage = (UINT)_ttoi (arg[0]);
if (uNewCodePage == 0)
{
ConErrPrintf ("Parameter format incorrect - %s\n", arg[0]);
freep (arg);
return 1;
}
if (!SetConsoleCP (uNewCodePage))
{
ConErrPrintf ("Invalid code page\n");
}
else
{
SetConsoleOutputCP (uNewCodePage);
InitLocale ();
}
freep (arg);
return 0;
}
#endif /* INCLUDE_CMD_CHCP */

View File

@@ -1,331 +0,0 @@
/*
* CHOICE.C - internal command.
*
*
* History:
*
* 12 Aug 1999 (Eric Kohl)
* started.
*
* 01 Sep 1999 (Eric Kohl)
* Fixed help text.
*
* 26 Sep 1999 (Paolo Pantaleo)
* Fixed timeout.
*/
#include "config.h"
#ifdef INCLUDE_CMD_CHOICE
#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <tchar.h>
#include "cmd.h"
#include "batch.h"
#define GC_TIMEOUT -1
#define GC_NOKEY 0 //an event occurred but it wasn't a key pressed
#define GC_KEYREAD 1 //a key has been read
static INT
GetCharacterTimeout (LPTCH ch, DWORD dwMilliseconds)
{
//--------------------------------------------
// Get a character from standard input but with a timeout.
// The function will wait a limited amount
// of time, then the function returns GC_TIMEOUT.
//
// dwMilliseconds is the timeout value, that can
// be set to INFINITE, so the function works like
// stdio.h's getchar()
HANDLE hInput;
DWORD dwRead;
INPUT_RECORD lpBuffer;
hInput = GetStdHandle (STD_INPUT_HANDLE);
//if the timeout experied return GC_TIMEOUT
if (WaitForSingleObject (hInput, dwMilliseconds) == WAIT_TIMEOUT)
return GC_TIMEOUT;
//otherwise get the event
ReadConsoleInput (hInput, &lpBuffer, 1, &dwRead);
//if the event is a key pressed
if ((lpBuffer.EventType == KEY_EVENT) &&
(lpBuffer.Event.KeyEvent.bKeyDown == TRUE))
{
//read the key
#ifdef _UNICODE
*ch = lpBuffer.Event.KeyEvent.uChar.UnicodeChar;
#else
*ch = lpBuffer.Event.KeyEvent.uChar.AsciiChar;
#endif
return GC_KEYREAD;
}
//else return no key
return GC_NOKEY;
}
static INT
IsKeyInString (LPTSTR lpString, TCHAR cKey, BOOL bCaseSensitive)
{
LPTCH p = lpString;
INT val = 0;
while (*p)
{
if (bCaseSensitive)
{
if (*p == cKey)
return val;
}
else
{
if (_totlower (*p) == _totlower (cKey))
return val;
}
val++;
p++;
}
return -1;
}
INT
CommandChoice (LPTSTR cmd, LPTSTR param)
{
LPTSTR lpOptions = "YN";
LPTSTR lpText = NULL;
BOOL bNoPrompt = FALSE;
BOOL bCaseSensitive = FALSE;
BOOL bTimeout = FALSE;
INT nTimeout = 0;
TCHAR cDefault = _T('\0');
INPUT_RECORD ir;
LPTSTR p, np;
LPTSTR *arg;
INT argc;
INT i;
INT val;
INT GCret;
TCHAR Ch;
DWORD amount,clk;
if (_tcsncmp (param, _T("/?"), 2) == 0)
{
ConOutPuts (_T("Waits for the user to choose one of a set of choices.\n"
"\n"
"CHOICE [/C[:]choices][/N][/S][/T[:]c,nn][text]\n"
"\n"
" /C[:]choices Specifies allowable keys. Default is YN.\n"
" /N Do not display choices and ? at the end of the prompt string.\n"
" /S Treat choice keys as case sensitive.\n"
" /T[:]c,nn Default choice to c after nn seconds.\n"
" text Prompt string to display.\n"
"\n"
"ERRORLEVEL is set to offset of key user presses in choices."));
return 0;
}
/* retrieve text */
p = param;
while (TRUE)
{
if (*p == _T('\0'))
break;
if (*p != _T('/'))
{
lpText = p;
break;
}
np = _tcschr (p, _T(' '));
if (!np)
break;
p = np + 1;
}
/* build parameter array */
arg = split (param, &argc);
/* evaluate arguments */
if (argc > 0)
{
for (i = 0; i < argc; i++)
{
if (_tcsnicmp (arg[i], _T("/c"), 2) == 0)
{
if (arg[i][2] == _T(':'))
lpOptions = &arg[i][3];
else
lpOptions = &arg[i][2];
if (_tcslen (lpOptions) == 0)
{
ConErrPuts (_T("Invalid option. Expected format: /C[:]options"));
freep (arg);
return 1;
}
}
else if (_tcsnicmp (arg[i], _T("/n"), 2) == 0)
{
bNoPrompt = TRUE;
}
else if (_tcsnicmp (arg[i], _T("/s"), 2) == 0)
{
bCaseSensitive = TRUE;
}
else if (_tcsnicmp (arg[i], _T("/t"), 2) == 0)
{
LPTSTR s;
if (arg[i][2] == _T(':'))
{
cDefault = arg[i][3];
s = &arg[i][4];
}
else
{
cDefault = arg[i][2];
s = &arg[i][3];
}
if (*s != _T(','))
{
ConErrPuts (_T("Invalid option. Expected format: /T[:]c,nn"));
freep (arg);
return 1;
}
s++;
nTimeout = _ttoi(s);
bTimeout = TRUE;
}
else if (arg[i][0] == _T('/'))
{
ConErrPrintf (_T("Illegal Option: %s"), arg[i]);
freep (arg);
return 1;
}
}
}
/* print text */
if (lpText)
ConOutPrintf (_T("%s"), lpText);
/* print options */
if (bNoPrompt == FALSE)
{
ConOutPrintf (_T("[%c"), lpOptions[0]);
for (i = 1; (unsigned)i < _tcslen (lpOptions); i++)
ConOutPrintf (_T(",%c"), lpOptions[i]);
ConOutPrintf (_T("]?"));
}
ConInFlush ();
if(!bTimeout)
{
while (TRUE)
{
ConInKey (&ir);
val = IsKeyInString (lpOptions,
#ifdef _UNICODE
ir.Event.KeyEvent.uChar.UnicodeChar,
#else
ir.Event.KeyEvent.uChar.AsciiChar,
#endif /* _UNICODE */
bCaseSensitive);
if (val >= 0)
{
ConOutPrintf (_T("%c\n"), lpOptions[val]);
nErrorLevel = val + 1;
break;
}
Beep (440, 50);
}
freep (arg);
return 0;
}
clk = GetTickCount ();
amount = nTimeout*1000;
loop:
GCret = GetCharacterTimeout (&Ch, amount - (GetTickCount () - clk));
switch (GCret)
{
case GC_TIMEOUT:
#ifdef _DEBUG
DebugPrintf (_T("GC_TIMEOUT\n"));
DebugPrintf (_T("elapsed %d msecs\n"), GetTickCount () - clk);
#endif /* _DEBUG */
break;
case GC_NOKEY:
#ifdef _DEBUG
DebugPrintf(_T("GC_NOKEY\n"));
DebugPrintf(_T("elapsed %d msecs\n"), GetTickCount () - clk);
#endif /* _DEBUG */
goto loop;
case GC_KEYREAD:
#ifdef _DEBUG
DebugPrintf(_T("GC_KEYREAD\n"));
DebugPrintf(_T("elapsed %d msecs\n"), GetTickCount () - clk);
DebugPrintf(_T("read %c"), Ch);
#endif /* _DEBUG */
if ((val=IsKeyInString(lpOptions,Ch,bCaseSensitive))==-1)
{
Beep (440, 50);
goto loop;
}
cDefault=Ch;
break;
}
#ifdef _DEBUG
DebugPrintf(_T("exiting wait loop after %d msecs\n"),
GetTickCount () - clk);
#endif /* _DEBUG */
val = IsKeyInString (lpOptions, cDefault, bCaseSensitive);
ConOutPrintf (_T("%c\n"), lpOptions[val]);
nErrorLevel = val + 1;
freep (arg);
#ifdef _DEBUG
DebugPrintf (_T("ErrorLevel: %d\n"), nErrorLevel);
#endif /* _DEBUG */
return 0;
}
#endif /* INCLUDE_CMD_CHOICE */
/* EOF */

View File

@@ -1,65 +0,0 @@
/*
* CLS.C - clear screen internal command.
*
*
* History:
*
* 07/27/1998 (John P. Price)
* started.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 04-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Changed to Win32 console app.
*
* 08-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("/?").
*
* 14-Jan-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode ready!
*
* 20-Jan-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Redirection ready!
*/
#include "config.h"
#ifdef INCLUDE_CMD_CLS
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
INT cmd_cls (LPTSTR cmd, LPTSTR param)
{
DWORD dwWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD coPos;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Clears the screen.\n\nCLS"));
return 0;
}
GetConsoleScreenBufferInfo (hOut, &csbi);
coPos.X = 0;
coPos.Y = 0;
FillConsoleOutputAttribute (hOut, wColor,
(csbi.dwSize.X)*(csbi.dwSize.Y),
coPos, &dwWritten);
FillConsoleOutputCharacter (hOut, _T(' '),
(csbi.dwSize.X)*(csbi.dwSize.Y),
coPos, &dwWritten);
SetConsoleCursorPosition (hOut, coPos);
bIgnoreEcho = TRUE;
return 0;
}
#endif

File diff suppressed because it is too large Load Diff

View File

@@ -1,404 +0,0 @@
/* $Id: cmd.h,v 1.18 1999/12/28 23:06:35 ekohl Exp $
*
* CMD.H - header file for the modules in CMD.EXE
*
*
* History:
*
* 7-15-95 Tim Norman
* started
*
* 06/29/98 (Rob Lake)
* Moved error messages in here
*
* 07/12/98 (Rob Lake)
* Moved more error messages here.
*
* 30-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* Added compile date to version.
*
* 26-Feb-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Introduced a new version string.
* Thanks to Emanuele Aliberti!
*/
#ifndef _CMD_H_INCLUDED_
#define _CMD_H_INCLUDED_
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include "cmdver.h"
#ifdef _MSC_VER
#define SHELLVER "Version " CMD_VER " [" __DATE__ ", msc]"
#else
#ifdef __LCC__
#define SHELLVER "Version " CMD_VER " [" __DATE__ ", lcc-win32]"
#else
#define SHELLVER "Version " CMD_VER " [" __DATE__ "]"
#endif
#endif
#define BREAK_BATCHFILE 1
#define BREAK_OUTOFBATCH 2
#define BREAK_INPUT 3
#define BREAK_IGNORE 4
/* define some error messages */
#define NOENVERR "ERROR: no environment"
#define INVALIDDRIVE "ERROR: invalid drive"
#define INVALIDFUNCTION "ERROR: invalid function"
#define ACCESSDENIED "ERROR: access denied"
#define BADENVIROMENT "ERROR: bad enviroment"
#define BADFORMAT "ERROR: bad format"
#define ERROR_E2BIG "ERROR: Argument list too long"
#define ERROR_EINVAL "ERROR: Invalid argument"
#define SHELLINFO "ReactOS Command Line Interpreter"
#define D_ON "on"
#define D_OFF "off"
/* global variables */
extern HANDLE hOut;
extern HANDLE hIn;
extern WORD wColor;
extern WORD wDefColor;
extern BOOL bCtrlBreak;
extern BOOL bIgnoreEcho;
extern BOOL bExit;
extern INT nErrorLevel;
extern SHORT maxx;
extern SHORT maxy;
extern OSVERSIONINFO osvi;
/* Prototypes for ALIAS.C */
VOID InitializeAlias (VOID);
VOID DestroyAlias (VOID);
VOID ExpandAlias (LPTSTR, INT);
INT CommandAlias (LPTSTR, LPTSTR);
/* Prototypes for ATTRIB.C */
INT CommandAttrib (LPTSTR, LPTSTR);
/* Prototypes for BEEP.C */
INT cmd_beep (LPTSTR, LPTSTR);
/* Prototypes for CALL.C */
INT cmd_call (LPTSTR, LPTSTR);
/* Prototypes for CHCP.C */
INT CommandChcp (LPTSTR, LPTSTR);
/* Prototypes for CHOICE.C */
INT CommandChoice (LPTSTR, LPTSTR);
/* Prototypes for CLS.C */
INT cmd_cls (LPTSTR, LPTSTR);
/* Prototypes for CMD.C */
VOID ParseCommandLine (LPTSTR);
VOID AddBreakHandler (VOID);
VOID RemoveBreakHandler (VOID);
/* Prototypes for CMDINPUT.C */
VOID ReadCommand (LPTSTR, INT);
/* Prototypes for CMDTABLE.C */
#define CMD_SPECIAL 1
#define CMD_BATCHONLY 2
typedef struct tagCOMMAND
{
LPTSTR name;
INT flags;
INT (*func) (LPTSTR, LPTSTR);
} COMMAND, *LPCOMMAND;
extern COMMAND cmds[]; /* The internal command table */
/* Prototypes for COLOR.C */
VOID SetScreenColor(WORD wArgColor, BOOL bFill);
INT CommandColor (LPTSTR, LPTSTR);
/* Prototypes for CONSOLE.C */
#ifdef _DEBUG
VOID DebugPrintf (LPTSTR, ...);
#endif /* _DEBUG */
VOID ConInDummy (VOID);
VOID ConInDisable (VOID);
VOID ConInEnable (VOID);
VOID ConInFlush (VOID);
VOID ConInKey (PINPUT_RECORD);
VOID ConInString (LPTSTR, DWORD);
VOID ConOutChar (TCHAR);
VOID ConOutPuts (LPTSTR);
VOID ConOutPrintf (LPTSTR, ...);
VOID ConErrChar (TCHAR);
VOID ConErrPuts (LPTSTR);
VOID ConErrPrintf (LPTSTR, ...);
SHORT GetCursorX (VOID);
SHORT GetCursorY (VOID);
VOID GetCursorXY (PSHORT, PSHORT);
VOID SetCursorXY (SHORT, SHORT);
VOID GetScreenSize (PSHORT, PSHORT);
VOID SetCursorType (BOOL, BOOL);
/* Prototypes for COPY.C */
INT cmd_copy (LPTSTR, LPTSTR);
/* Prototypes for DATE.C */
INT cmd_date (LPTSTR, LPTSTR);
/* Prototypes for DEL.C */
INT CommandDelete (LPTSTR, LPTSTR);
/* Prototypes for DELAY.C */
INT CommandDelay (LPTSTR, LPTSTR);
/* Prototypes for DIR.C */
INT CommandDir (LPTSTR, LPTSTR);
/* Prototypes for DIRSTACK.C */
VOID InitDirectoryStack (VOID);
VOID DestroyDirectoryStack (VOID);
INT GetDirectoryStackDepth (VOID);
INT CommandPushd (LPTSTR, LPTSTR);
INT CommandPopd (LPTSTR, LPTSTR);
INT CommandDirs (LPTSTR, LPTSTR);
/* Prototypes for ECHO.C */
INT CommandEcho (LPTSTR, LPTSTR);
INT CommandEchos (LPTSTR, LPTSTR);
INT CommandEchoerr (LPTSTR, LPTSTR);
INT CommandEchoserr (LPTSTR, LPTSTR);
/* Prototypes for ERROR.C */
VOID ErrorMessage (DWORD, LPTSTR, ...);
VOID error_no_pipe (VOID);
VOID error_bad_command (VOID);
VOID error_invalid_drive (VOID);
VOID error_req_param_missing (VOID);
VOID error_sfile_not_found (LPTSTR);
VOID error_file_not_found (VOID);
VOID error_path_not_found (VOID);
VOID error_too_many_parameters (LPTSTR);
VOID error_invalid_switch (TCHAR);
VOID error_invalid_parameter_format (LPTSTR);
VOID error_out_of_memory (VOID);
VOID error_syntax (LPTSTR);
VOID msg_pause (VOID);
/* Prototypes for FILECOMP.C */
#ifdef FEATURE_UNIX_FILENAME_COMPLETION
VOID CompleteFilename (LPTSTR, INT);
INT ShowCompletionMatches (LPTSTR, INT);
#endif
#ifdef FEATURE_4NT_FILENAME_COMPLETION
#endif
/* Prototypes for FOR.C */
INT cmd_for (LPTSTR, LPTSTR);
/* Prototypes for FREE.C */
INT CommandFree (LPTSTR, LPTSTR);
/* Prototypes for GOTO.C */
INT cmd_goto (LPTSTR, LPTSTR);
/* Prototypes for HISTORY.C */
#ifdef FEATURE_HISTORY
VOID History (INT, LPTSTR);/*add entries browse history*/
VOID History_move_to_bottom(VOID);/*F3*/
VOID InitHistory(VOID);
VOID CleanHistory(VOID);
VOID History_del_current_entry(LPTSTR str);/*CTRL-D*/
#endif
/* Prototypes for INTERNAL.C */
VOID InitLastPath (VOID);
VOID FreeLastPath (VOID);
INT cmd_chdir (LPTSTR, LPTSTR);
INT cmd_mkdir (LPTSTR, LPTSTR);
INT cmd_rmdir (LPTSTR, LPTSTR);
INT CommandExit (LPTSTR, LPTSTR);
INT CommandRem (LPTSTR, LPTSTR);
INT CommandShowCommands (LPTSTR, LPTSTR);
/* Prototypes for LABEL.C */
INT cmd_label (LPTSTR, LPTSTR);
/* Prototypes for LOCALE.C */
extern TCHAR cDateSeparator;
extern INT nDateFormat;
extern TCHAR cTimeSeparator;
extern INT nTimeFormat;
extern TCHAR aszDayNames[7][8];
extern TCHAR cThousandSeparator;
extern TCHAR cDecimalSeparator;
extern INT nNumberGroups;
VOID InitLocale (VOID);
VOID PrintDate (VOID);
VOID PrintTime (VOID);
/* Prototypes for MEMORY.C */
INT CommandMemory (LPTSTR, LPTSTR);
/* Prototypes for MISC.C */
TCHAR cgetchar (VOID);
BOOL CheckCtrlBreak (INT);
LPTSTR *split (LPTSTR, LPINT);
VOID freep (LPTSTR *);
LPTSTR stpcpy (LPTSTR, LPTSTR);
BOOL IsValidPathName (LPCTSTR);
BOOL IsValidFileName (LPCTSTR);
BOOL IsValidDirectory (LPCTSTR);
BOOL FileGetString (HANDLE, LPTSTR, INT);
#ifndef __REACTOS__
HWND GetConsoleWindow(VOID);
#endif
#define PROMPT_NO 0
#define PROMPT_YES 1
#define PROMPT_ALL 2
#define PROMPT_BREAK 3
INT PagePrompt (VOID);
INT FilePromptYN (LPTSTR, ...);
INT FilePromptYNA (LPTSTR, ...);
/* Prototypes for MOVE.C */
INT cmd_move (LPTSTR, LPTSTR);
/* Prototypes for MSGBOX.C */
INT CommandMsgbox (LPTSTR, LPTSTR);
/* Prototypes from PATH.C */
INT cmd_path (LPTSTR, LPTSTR);
/* Prototypes from PROMPT.C */
VOID PrintPrompt (VOID);
INT cmd_prompt (LPTSTR, LPTSTR);
/* Prototypes for REDIR.C */
#define INPUT_REDIRECTION 1
#define OUTPUT_REDIRECTION 2
#define OUTPUT_APPEND 4
#define ERROR_REDIRECTION 8
#define ERROR_APPEND 16
INT GetRedirection (LPTSTR, LPTSTR, LPTSTR, LPTSTR, LPINT);
/* Prototypes for REN.C */
INT cmd_rename (LPTSTR, LPTSTR);
/* Prototypes for SCREEN.C */
INT CommandScreen (LPTSTR, LPTSTR);
/* Prototypes for SET.C */
INT cmd_set (LPTSTR, LPTSTR);
/* Prototypes for START.C */
INT cmd_start (LPTSTR, LPTSTR);
/* Prototypes for STRTOCLR.C */
BOOL StringToColor (LPWORD, LPTSTR *);
/* Prototypes for TIME.C */
INT cmd_time (LPTSTR, LPTSTR);
/* Prototypes for TIMER.C */
INT CommandTimer (LPTSTR cmd, LPTSTR param);
/* Prototypes for TITLE.C */
INT cmd_title (LPTSTR, LPTSTR);
/* Prototypes for TYPE.C */
INT cmd_type (LPTSTR, LPTSTR);
/* Prototypes for VER.C */
VOID ShortVersion (VOID);
INT cmd_ver (LPTSTR, LPTSTR);
/* Prototypes for VERIFY.C */
INT cmd_verify (LPTSTR, LPTSTR);
/* Prototypes for VOL.C */
INT cmd_vol (LPTSTR, LPTSTR);
/* Prototypes for WHERE.C */
BOOL SearchForExecutable (LPCTSTR, LPTSTR);
/* Prototypes for WINDOW.C */
INT CommandActivate (LPTSTR, LPTSTR);
INT CommandWindow (LPTSTR, LPTSTR);
/* The MSDOS Batch Commands [MS-DOS 5.0 User's Guide and Reference p359] */
int cmd_if(char *, char *);
int cmd_pause(char *, char *);
int cmd_shift(char *, char *);
#endif /* _CMD_H_INCLUDED_ */

View File

@@ -1,40 +0,0 @@
#include "../../reactos/include/defines.h"
#include "../../reactos/include/reactos/resource.h"
#include "cmdver.h"
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
VS_VERSION_INFO VERSIONINFO
FILEVERSION RES_UINT_FV_MAJOR,RES_UINT_FV_MINOR,RES_UINT_FV_REVISION,RES_UINT_FV_BUILD
PRODUCTVERSION RES_UINT_PV_MAJOR,RES_UINT_PV_MINOR,RES_UINT_PV_REVISION,RES_UINT_PV_BUILD
FILEFLAGSMASK 0x3fL
#ifdef _DEBUG
FILEFLAGS 0x1L
#else
FILEFLAGS 0x0L
#endif
FILEOS 0x40004L
FILETYPE 0x2L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904b0"
BEGIN
VALUE "CompanyName", RES_STR_COMPANY_NAME
VALUE "FileDescription", "ReactOS Command Processor\0"
VALUE "FileVersion", CMD_VER_RC
VALUE "InternalName", "cmd\0"
VALUE "OriginalCopyright", "Copyright (C) 1994-1998 Tim Norman and others\0"
VALUE "LegalCopyright", "Copyright (C) 1998,1999 Eric Kohl\0"
VALUE "OriginalFilename", "cmd.exe\0"
VALUE "ProductName", RES_STR_PRODUCT_NAME
VALUE "ProductVersion", RES_STR_PRODUCT_VERSION
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x409, 1200
END
END

View File

@@ -1,457 +0,0 @@
/*
* CMDINPUT.C - handles command input (tab completion, history, etc.).
*
*
* History:
*
* 01/14/95 (Tim Norman)
* started.
*
* 08/08/95 (Matt Rains)
* i have cleaned up the source code. changes now bring this source
* into guidelines for recommended programming practice.
* i have added some constants to help making changes easier.
*
* 12/12/95 (Tim Norman)
* added findxy() function to get max x/y coordinates to display
* correctly on larger screens
*
* 12/14/95 (Tim Norman)
* fixed the Tab completion code that Matt Rains broke by moving local
* variables to a more global scope and forgetting to initialize them
* when needed
*
* 8/1/96 (Tim Norman)
* fixed a bug in tab completion that caused filenames at the beginning
* of the command-line to have their first letter truncated
*
* 9/1/96 (Tim Norman)
* fixed a silly bug using printf instead of fputs, where typing "%i"
* confused printf :)
*
* 6/14/97 (Steffan Kaiser)
* ctrl-break checking
*
* 6/7/97 (Marc Desrochers)
* recoded everything! now properly adjusts when text font is changed.
* removed findxy(), reposition(), and reprint(), as these functions
* were inefficient. added goxy() function as gotoxy() was buggy when
* the screen font was changed. the printf() problem with %i on the
* command line was fixed by doing printf("%s",str) instead of
* printf(str). Don't ask how I find em just be glad I do :)
*
* 7/12/97 (Tim Norman)
* Note: above changes pre-empted Steffan's ctrl-break checking.
*
* 7/7/97 (Marc Desrochers)
* rewrote a new findxy() because the new dir() used it. This
* findxy() simply returns the values of *maxx *maxy. In the
* future, please use the pointers, they will always be correct
* since they point to BIOS values.
*
* 7/8/97 (Marc Desrochers)
* once again removed findxy(), moved the *maxx, *maxy pointers
* global and included them as externs in command.h. Also added
* insert/overstrike capability
*
* 7/13/97 (Tim Norman)
* added different cursor appearance for insert/overstrike mode
*
* 7/13/97 (Tim Norman)
* changed my code to use _setcursortype until I can figure out why
* my code is crashing on some machines. It doesn't crash on mine :)
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 28-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* put ifdef's around filename completion code.
*
* 30-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* moved filename completion code to filecomp.c
* made second TAB display list of filename matches
*
* 31-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* Fixed bug where if you typed something, then hit HOME, then tried
* to type something else in insert mode, it crashed.
*
* 07-Aug-1998 (John P Price <linux-guru@gcfl.net>)
* Fixed carrage return output to better match MSDOS with echo
* on or off.(marked with "JPP 19980708")
*
* 13-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added insert/overwrite cursor.
*
* 25-Jan-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Replaced CRT io functions by Win32 console io functions.
* This can handle <Shift>-<Tab> for 4NT filename completion.
* Unicode and redirection safe!
*
* 04-Feb-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed input bug. A "line feed" character remained in the keyboard
* input queue when you pressed <RETURN>. This sometimes caused
* some very strange effects.
* Fixed some command line editing annoyances.
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
#include "batch.h"
SHORT maxx;
SHORT maxy;
/*
* global command line insert/overwrite flag
*/
static BOOL bInsert = TRUE;
static VOID
ClearCommandLine (LPTSTR str, INT maxlen, SHORT orgx, SHORT orgy)
{
INT count;
SetCursorXY (orgx, orgy);
for (count = 0; count < (INT)_tcslen (str); count++)
ConOutChar (_T(' '));
_tcsnset (str, _T('\0'), maxlen);
SetCursorXY (orgx, orgy);
}
/* read in a command line */
VOID ReadCommand (LPTSTR str, INT maxlen)
{
SHORT orgx; /* origin x/y */
SHORT orgy;
SHORT curx; /*current x/y cursor position*/
SHORT cury;
INT count; /*used in some for loops*/
INT current = 0; /*the position of the cursor in the string (str)*/
INT charcount = 0;/*chars in the string (str)*/
INPUT_RECORD ir;
WORD wLastKey = 0;
TCHAR ch;
/* get screen size */
GetScreenSize (&maxx, &maxy);
/* JPP 19980807 - if echo off, don't print prompt */
if (bEcho)
PrintPrompt();
GetCursorXY (&orgx, &orgy);
memset (str, 0, maxlen * sizeof (TCHAR));
SetCursorType (bInsert, TRUE);
do
{
ConInKey (&ir);
switch (ir.Event.KeyEvent.wVirtualKeyCode)
{
case VK_BACK:
/* <BACKSPACE> - delete character to left of cursor */
if (current > 0 && charcount > 0)
{
if (current == charcount)
{
/* if at end of line */
str[current - 1] = _T('\0');
if (GetCursorX () != 0)
{
ConOutPrintf ("\b \b");
}
else
{
SetCursorXY ((SHORT)(maxx - 1), (SHORT)(GetCursorY () - 1));
ConOutChar (_T(' '));
SetCursorXY ((SHORT)(maxx - 1), (SHORT)(GetCursorY () - 1));
}
}
else
{
for (count = current - 1; count < charcount; count++)
str[count] = str[count + 1];
if (GetCursorX () != 0)
SetCursorXY ((SHORT)(GetCursorX () - 1), GetCursorY ());
else
SetCursorXY ((SHORT)(maxx - 1), (SHORT)(GetCursorY () - 1));
GetCursorXY (&curx, &cury);
ConOutPrintf (_T("%s "), &str[current - 1]);
SetCursorXY (curx, cury);
}
charcount--;
current--;
}
break;
case VK_INSERT:
/* toggle insert/overstrike mode */
bInsert ^= TRUE;
SetCursorType (bInsert, TRUE);
break;
case VK_DELETE:
/* delete character under cursor */
if (current != charcount && charcount > 0)
{
for (count = current; count < charcount; count++)
str[count] = str[count + 1];
charcount--;
GetCursorXY (&curx, &cury);
ConOutPrintf (_T("%s "), &str[current]);
SetCursorXY (curx, cury);
}
break;
case VK_HOME:
/* goto beginning of string */
if (current != 0)
{
SetCursorXY (orgx, orgy);
current = 0;
}
break;
case VK_END:
/* goto end of string */
if (current != charcount)
{
SetCursorXY (orgx, orgy);
ConOutPrintf (_T("%s"), str);
current = charcount;
}
break;
case VK_TAB:
#ifdef FEATURE_UNIX_FILENAME_COMPLETION
/* expand current file name */
if (current == charcount) /* only works at end of line*/
{
if (wLastKey != VK_TAB)
{
/* if first TAB, complete filename*/
CompleteFilename (str, charcount);
charcount = _tcslen (str);
current = charcount;
SetCursorXY (orgx, orgy);
ConOutPrintf (_T("%s"), str);
if ((_tcslen (str) > (USHORT)(maxx - orgx)) && (orgy == maxy + 1))
orgy--;
}
else
{
/*if second TAB, list matches*/
if (ShowCompletionMatches (str, charcount))
{
PrintPrompt ();
GetCursorXY (&orgx, &orgy);
ConOutPrintf (_T("%s"), str);
}
}
}
else
{
#ifdef __REACTOS__
Beep (440, 50);
#else
MessageBeep (-1);
#endif
}
#endif
#ifdef FEATURE_4NT_FILENAME_COMPLETION
/* this is not implemented yet */
if (ir.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED)
{
/* get previous match */
}
else
{
/* get next match */
}
#endif
break;
case VK_RETURN:
/* end input, return to main */
#ifdef FEATURE_HISTORY
/* add to the history */
if (str[0])
History (0, str);
#endif
ConInDummy ();
ConOutChar (_T('\n'));
break;
case VK_ESCAPE:
/* clear str Make this callable! */
ClearCommandLine (str, maxlen, orgx, orgy);
current = charcount = 0;
break;
case VK_F3:
#ifdef FEATURE_HISTORY
History_move_to_bottom();
#endif
case VK_UP:
#ifdef FEATURE_HISTORY
/* get previous command from buffer */
ClearCommandLine (str, maxlen, orgx, orgy);
History (-1, str);
current = charcount = _tcslen (str);
ConOutPrintf (_T("%s"), str);
#endif
break;
case VK_DOWN:
#ifdef FEATURE_HISTORY
/* get next command from buffer */
ClearCommandLine (str, maxlen, orgx, orgy);
History (1, str);
current = charcount = _tcslen (str);
ConOutPrintf (_T("%s"), str);
#endif
break;
case VK_LEFT:
/* move cursor left */
if (current > 0)
{
current--;
if (GetCursorX () == 0)
SetCursorXY ((SHORT)(maxx - 1), (SHORT)(GetCursorY () - 1));
else
SetCursorXY ((SHORT)(GetCursorX () - 1), GetCursorY ());
}
else
{
#ifdef __REACTOS__
Beep (440, 50);
#else
MessageBeep (-1);
#endif
}
break;
case VK_RIGHT:
/* move cursor right */
if (current != charcount)
{
current++;
if (GetCursorX () == maxx - 1)
SetCursorXY (0, (SHORT)(GetCursorY () + 1));
else
SetCursorXY ((SHORT)(GetCursorX () + 1), GetCursorY ());
}
break;
#ifdef FEATURE_HISTORY
/*!!!WARNING!!!*/
/*this will only work as long as the two if statement
evaluates the same expression and a break is included
in each if statement.
This can be used for any combination using CTRL.
For other combinations is needed another system*/
//case VK_K:
case 'K':
/*add the current command line to the history*/
if (ir.Event.KeyEvent.dwControlKeyState &
(LEFT_CTRL_PRESSED|RIGHT_CTRL_PRESSED))
{
if (str[0])
History(0,str);
ClearCommandLine (str, maxlen, orgx, orgy);
current = charcount = 0;
break;
}
case 'D':
if (ir.Event.KeyEvent.dwControlKeyState &
(LEFT_CTRL_PRESSED|RIGHT_CTRL_PRESSED))
{
ClearCommandLine (str, maxlen, orgx, orgy);
History_del_current_entry(str);
current = charcount = _tcslen (str);
ConOutPrintf (_T("%s"), str);
break;
}
#endif
default:
#ifdef _UNICODE
ch = ir.Event.KeyEvent.uChar.UnicodeChar;
if ((ch >= 32 && ch <= 255) && (charcount != (maxlen - 2)))
#else
ch = ir.Event.KeyEvent.uChar.AsciiChar;
if (ch >= 32 && (charcount != (maxlen - 2)))
#endif /* _UNICODE */
{
/* insert character into string... */
if (bInsert && current != charcount)
{
for (count = charcount; count > current; count--)
str[count] = str[count - 1];
str[current++] = ch;
if (GetCursorX () == maxx - 1)
{
curx = 0;
cury = GetCursorY () + 1;
}
else
{
GetCursorXY (&curx, &cury);
curx++;
}
ConOutPrintf (_T("%s"), &str[current - 1]);
if ((_tcslen (str) > (USHORT)(maxx - orgx)) && (orgy == maxy + 1))
cury--;
SetCursorXY (curx, cury);
charcount++;
}
else
{
if (current == charcount)
charcount++;
str[current++] = ch;
ConOutChar (ch);
}
if ((_tcslen (str) > (USHORT)(maxx - orgx)) && (orgy == maxy + 1))
orgy--;
}
#if 0
else
{
#ifdef __REACTOS__
Beep (440, 100);
#else
MessageBeep (-1);
#endif
}
#endif
break;
}
wLastKey = ir.Event.KeyEvent.wVirtualKeyCode;
}
while (ir.Event.KeyEvent.wVirtualKeyCode != VK_RETURN);
SetCursorType (bInsert, TRUE);
}

View File

@@ -1,227 +0,0 @@
/*
* CMDTABLE.C - table of internal commands.
*
*
* History:
*
* 16 Jul 1998 (Hans B Pufal)
* started.
* New file to keep the internal command table. I plan on
* getting rid of the table real soon now and replacing it
* with a dynamic mechnism.
*
* 27 Jul 1998 John P. Price
* added config.h include
*
* 21-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode ready!
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include "cmd.h"
/* a list of all the internal commands, associating their command names */
/* to the functions to process them */
COMMAND cmds[] =
{
{_T("?"), 0, CommandShowCommands},
#ifdef INCLUDE_CMD_ACTIVATE
{_T("activate"), 0, CommandActivate},
#endif
#ifdef FEATURE_ALIASES
{_T("alias"), 0, CommandAlias},
#endif
#ifdef INCLUDE_CMD_ATTRIB
{_T("attrib"), 0, CommandAttrib},
#endif
#ifdef INCLUDE_CMD_BEEP
{_T("beep"), 0, cmd_beep},
#endif
{_T("call"), CMD_BATCHONLY, cmd_call},
#ifdef INCLUDE_CMD_CHDIR
{_T("cd"), CMD_SPECIAL, cmd_chdir},
{_T("chdir"), CMD_SPECIAL, cmd_chdir},
#endif
#ifdef INCLUDE_CMD_CHCP
{_T("chcp"), 0, CommandChcp},
#endif
#ifdef INCLUDE_CMD_CHOICE
{_T("choice"), 0, CommandChoice},
#endif
#ifdef INCLUDE_CMD_CLS
{_T("cls"), 0, cmd_cls},
#endif
#ifdef INCLUDE_CMD_COLOR
{_T("color"), 0, CommandColor},
#endif
#ifdef INCLUDE_CMD_COPY
{_T("copy"), 0, cmd_copy},
#endif
#ifdef INCLUDE_CMD_DATE
{_T("date"), 0, cmd_date},
#endif
#ifdef INCLUDE_CMD_DEL
{_T("del"), 0, CommandDelete},
{_T("delete"), 0, CommandDelete},
#endif
#ifdef INCLUDE_CMD_DELAY
{_T("delay"), 0, CommandDelay},
#endif
#ifdef INCLUDE_CMD_DIR
{_T("dir"), CMD_SPECIAL, CommandDir},
#endif
#ifdef FEATURE_DIRECTORY_STACK
{_T("dirs"), 0, CommandDirs},
#endif
{_T("echo"), 0, CommandEcho},
{_T("echos"), 0, CommandEchos},
{_T("echoerr"), 0, CommandEchoerr},
{_T("echoserr"), 0, CommandEchoserr},
#ifdef INCLUDE_CMD_DEL
{_T("erase"), 0, CommandDelete},
#endif
{_T("exit"), 0, CommandExit},
{_T("for"), 0, cmd_for},
#ifdef INCLUDE_CMD_FREE
{_T("free"), 0, CommandFree},
#endif
{_T("goto"), CMD_BATCHONLY, cmd_goto},
{_T("if"), 0, cmd_if},
#ifdef INCLUDE_CMD_LABEL
{_T("label"), 0, cmd_label},
#endif
#ifdef INCLUDE_CMD_MEMORY
{_T("memory"), 0, CommandMemory},
#endif
#ifdef INCLUDE_CMD_MKDIR
{_T("md"), CMD_SPECIAL, cmd_mkdir},
{_T("mkdir"), CMD_SPECIAL, cmd_mkdir},
#endif
#ifdef INCLUDE_CMD_MOVE
{_T("move"), 0, cmd_move},
#endif
#ifdef INCLUDE_CMD_MSGBOX
{_T("msgbox"), 0, CommandMsgbox},
#endif
#ifdef INCLUDE_CMD_PATH
{_T("path"), 0, cmd_path},
#endif
#ifdef INCLUDE_CMD_PAUSE
{_T("pause"), 0, cmd_pause},
#endif
#ifdef FEATURE_DIRECTORY_STACK
{_T("popd"), 0, CommandPopd},
#endif
#ifdef INCLUDE_CMD_PROMPT
{_T("prompt"), 0, cmd_prompt},
#endif
#ifdef FEATURE_DIRECTORY_STACK
{_T("pushd"), 0, CommandPushd},
#endif
#ifdef INCLUDE_CMD_RMDIR
{_T("rd"), CMD_SPECIAL, cmd_rmdir},
#endif
#ifdef INCLUDE_CMD_REM
{_T("rem"), 0, CommandRem},
#endif
#ifdef INCLUDE_CMD_RENAME
{_T("ren"), 0, cmd_rename},
{_T("rename"), 0, cmd_rename},
#endif
#ifdef INCLUDE_CMD_RMDIR
{_T("rmdir"), CMD_SPECIAL, cmd_rmdir},
#endif
#ifdef INCLUDE_CMD_SCREEN
{_T("screen"), 0, CommandScreen},
#endif
#ifdef INCLUDE_CMD_SET
{_T("set"), 0, cmd_set},
#endif
{_T("shift"), CMD_BATCHONLY, cmd_shift},
#ifdef INCLUDE_CMD_START
{_T("start"), 0, cmd_start},
#endif
#ifdef INCLUDE_CMD_TIME
{_T("time"), 0, cmd_time},
#endif
#ifdef INCLUDE_CMD_TIMER
{_T("timer"), 0, CommandTimer},
#endif
#ifdef INCLUDE_CMD_TITLE
{_T("title"), 0, cmd_title},
#endif
#ifdef INCLUDE_CMD_TYPE
{_T("type"), 0, cmd_type},
#endif
#ifdef INCLUDE_CMD_VER
{_T("ver"), 0, cmd_ver},
#endif
#ifdef INCLUDE_CMD_VERIFY
{_T("verify"), 0, cmd_verify},
#endif
#ifdef INCLUDE_CMD_VOL
{_T("vol"), 0, cmd_vol},
#endif
#ifdef INCLUDE_CMD_WINDOW
{_T("window"), 0, CommandWindow},
#endif
{NULL, 0, NULL}
};
/* EOF */

View File

@@ -1,2 +0,0 @@
#define CMD_VER "0.1"
#define CMD_VER_RC CMD_VER"\0"

View File

@@ -1,131 +0,0 @@
/* $Id: color.c,v 1.4 1999/12/04 14:54:50 ekohl Exp $
*
* COLOR.C - color internal command.
*
*
* History:
*
* 13-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Started.
*
* 19-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode ready!
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Redirection ready!
*
* 14-Oct-1999 (Paolo Pantaleo <paolopan@freemail.it>)
* 4nt's syntax implemented
*/
#include "config.h"
#ifdef INCLUDE_CMD_COLOR
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include "cmd.h"
static VOID ColorHelp (VOID)
{
ConOutPuts (_T(
"Sets the default foreground and background colors.\n"
"\n"
"COLOR [attr [/F]] \n\n"
" attr Specifies color attribute of console output\n"
" /F fill the console with color attribute\n"
"\n"
"There are three ways to specify the colors:"
));
ConOutPuts (_T(
"\n"
"1) [bright] name on [bright] name (only the first three letters are required)\n"
"2) decimal on decimal\n"
"3) two hex digits\n"
"\n"
"Colors are:"
));
ConOutPuts (_T(
"dec hex name dec hex name\n"
"0 0 Black 8 8 Gray(Bright black)\n"
"1 1 Blue 9 9 Bright Blue\n"
"2 2 Green 10 A Bright Green\n"
"3 3 Cyan 11 B Bright Cyan\n"
"4 4 Red 12 C Bright Red\n"
"5 5 Magenta 13 D Bright Magenta\n"
"6 6 Yellow 14 E Bright Yellow\n"
"7 7 White 15 F Bright White"));
}
VOID SetScreenColor (WORD wColor, BOOL bFill)
{
DWORD dwWritten;
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD coPos;
if (bFill == TRUE)
{
GetConsoleScreenBufferInfo (hOut, &csbi);
coPos.X = 0;
coPos.Y = 0;
FillConsoleOutputAttribute (hOut,
(WORD)(wColor & 0x00FF),
(csbi.dwSize.X)*(csbi.dwSize.Y),
coPos,
&dwWritten);
}
SetConsoleTextAttribute (hOut, (WORD)(wColor & 0x00FF));
}
/*
* color
*
* internal dir command
*/
INT CommandColor (LPTSTR first, LPTSTR rest)
{
if (_tcsncmp (rest, _T("/?"), 2) == 0)
{
ColorHelp ();
return 0;
}
if (rest[0] == _T('\0'))
{
/* set default color */
wColor = wDefColor;
SetScreenColor (wColor, TRUE);
return 0;
}
if (StringToColor (&wColor, &rest) == FALSE)
{
ConErrPuts("error in color specification");
return 1;
}
ConErrPrintf ("Color %x\n", wColor);
if ((wColor & 0xF) == (wColor &0xF0) >> 4)
{
ConErrPuts (_T("same colors error!"));
return 1;
}
/* set color */
SetScreenColor (wColor,
(_tcsstr (rest,"/F") || _tcsstr (rest,"/f")));
return 0;
}
#endif /* INCLUDE_CMD_COLOR */
/* EOF */

View File

@@ -1,106 +0,0 @@
/*
* CONFIG.H - Used to configure what will be compiled into the shell.
*
*
* History:
*
* 27 Jul 1998 - John P. Price
* started.
*
*/
/* Define only if used under ReactOS */
#define __REACTOS__
#ifndef _CONFIG_H_INCLUDED_
#define _CONFIG_H_INCLUDED_
#ifndef __REACTOS__
#define WIN32_LEAN_AND_MEAN
#endif /* __REACTOS__ */
/* Define to enable debugging code */
/* #define _DEBUG */
/* Define to enable the alias command, and aliases.*/
#define FEATURE_ALIASES
/* Define to enable history */
#define FEATURE_HISTORY
/*Define to enable history wrap (4nt's style)*/
#define WRAP_HISTORY
/* Define one of these to enable filename completion */
#define FEATURE_UNIX_FILENAME_COMPLETION
/* #define FEATURE_4NT_FILENAME_COMPLETION */
/* Define to enable the directory stack */
#define FEATURE_DIRECTORY_STACK
/* Define to activate redirections and piping */
#define FEATURE_REDIRECTION
/* Define one of these to select the used locale. */
/* (date and time formats etc.) used in DATE, TIME, */
/* DIR, PROMPT etc. */
#ifdef __REACTOS__
#define LOCALE_DEFAULT
#else
#define LOCALE_WINDOWS /* System locale */
/* #define LOCALE_GERMAN */ /* German locale */
/* #define LOCALE_DEFAULT */ /* United States locale */
#endif
#ifndef __REACTOS__
#define INCLUDE_CMD_ACTIVATE
#endif
#define INCLUDE_CMD_ATTRIB
#define INCLUDE_CMD_CHCP
#define INCLUDE_CMD_CHDIR
#define INCLUDE_CMD_CHOICE
#define INCLUDE_CMD_CLS
#define INCLUDE_CMD_COLOR
#define INCLUDE_CMD_COPY
#define INCLUDE_CMD_DATE
#define INCLUDE_CMD_DEL
#define INCLUDE_CMD_DELAY
#define INCLUDE_CMD_DIR
#define INCLUDE_CMD_FREE
#define INCLUDE_CMD_LABEL
#define INCLUDE_CMD_MEMORY
#define INCLUDE_CMD_MKDIR
#define INCLUDE_CMD_MOVE
#ifndef __REACTOS__
#define INCLUDE_CMD_MSGBOX
#endif
#define INCLUDE_CMD_PATH
#define INCLUDE_CMD_PROMPT
#define INCLUDE_CMD_RMDIR
#define INCLUDE_CMD_RENAME
#define INCLUDE_CMD_SCREEN
#define INCLUDE_CMD_SET
#define INCLUDE_CMD_START
#define INCLUDE_CMD_TIME
#define INCLUDE_CMD_TIMER
#define INCLUDE_CMD_TITLE
#define INCLUDE_CMD_TYPE
#define INCLUDE_CMD_VER
#define INCLUDE_CMD_REM
#define INCLUDE_CMD_PAUSE
#define INCLUDE_CMD_BEEP
#define INCLUDE_CMD_VERIFY
#define INCLUDE_CMD_VOL
#ifndef __REACTOS__
#define INCLUDE_CMD_WINDOW
#endif
#endif /* _CONFIG_H_INCLUDED_ */

View File

@@ -1,302 +0,0 @@
/* $Id: console.c,v 1.13 1999/12/15 00:50:41 ekohl Exp $
*
* CONSOLE.C - console input/output functions.
*
*
* History:
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* started
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include "cmd.h"
#define OUTPUT_BUFFER_SIZE 4096
#ifdef _DEBUG
VOID DebugPrintf (LPTSTR szFormat, ...)
{
TCHAR szOut[OUTPUT_BUFFER_SIZE];
va_list arg_ptr;
DWORD dwWritten;
va_start (arg_ptr, szFormat);
_vstprintf (szOut, szFormat, arg_ptr);
va_end (arg_ptr);
WriteFile (GetStdHandle (STD_ERROR_HANDLE),
szOut,
_tcslen(szOut) * sizeof(TCHAR),
&dwWritten,
NULL);
#if 0
OutputDebugString (szOut);
#endif
}
#endif /* _DEBUG */
VOID ConInDisable (VOID)
{
HANDLE hInput = GetStdHandle (STD_INPUT_HANDLE);
DWORD dwMode;
GetConsoleMode (hInput, &dwMode);
dwMode &= ~ENABLE_PROCESSED_INPUT;
SetConsoleMode (hInput, dwMode);
}
VOID ConInEnable (VOID)
{
HANDLE hInput = GetStdHandle (STD_INPUT_HANDLE);
DWORD dwMode;
GetConsoleMode (hInput, &dwMode);
dwMode |= ENABLE_PROCESSED_INPUT;
SetConsoleMode (hInput, dwMode);
}
VOID ConInDummy (VOID)
{
HANDLE hInput = GetStdHandle (STD_INPUT_HANDLE);
INPUT_RECORD dummy;
DWORD dwRead;
#ifdef _DEBUG
if (hInput == INVALID_HANDLE_VALUE)
DebugPrintf ("Invalid input handle!!!\n");
#endif /* _DEBUG */
ReadConsoleInput (hInput, &dummy, 1, &dwRead);
}
VOID ConInFlush (VOID)
{
FlushConsoleInputBuffer (GetStdHandle (STD_INPUT_HANDLE));
}
VOID ConInKey (PINPUT_RECORD lpBuffer)
{
HANDLE hInput = GetStdHandle (STD_INPUT_HANDLE);
DWORD dwRead;
#ifdef _DEBUG
if (hInput == INVALID_HANDLE_VALUE)
DebugPrintf ("Invalid input handle!!!\n");
#endif /* _DEBUG */
do
{
ReadConsoleInput (hInput, lpBuffer, 1, &dwRead);
if ((lpBuffer->EventType == KEY_EVENT) &&
(lpBuffer->Event.KeyEvent.bKeyDown == TRUE))
break;
}
while (TRUE);
}
VOID ConInString (LPTSTR lpInput, DWORD dwLength)
{
DWORD dwOldMode;
DWORD dwRead;
HANDLE hFile;
LPTSTR p;
DWORD i;
ZeroMemory (lpInput, dwLength * sizeof(TCHAR));
hFile = GetStdHandle (STD_INPUT_HANDLE);
GetConsoleMode (hFile, &dwOldMode);
SetConsoleMode (hFile, ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT);
ReadFile (hFile, lpInput, dwLength, &dwRead, NULL);
p = lpInput;
for (i = 0; i < dwRead; i++, p++)
{
if (*p == _T('\x0d'))
{
*p = _T('\0');
break;
}
}
SetConsoleMode (hFile, dwOldMode);
}
VOID ConOutChar (TCHAR c)
{
DWORD dwWritten;
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE),
&c,
sizeof(TCHAR),
&dwWritten,
NULL);
}
VOID ConOutPuts (LPTSTR szText)
{
DWORD dwWritten;
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE),
szText,
_tcslen(szText) * sizeof(TCHAR),
&dwWritten,
NULL);
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE),
_T("\n"),
sizeof(TCHAR),
&dwWritten,
NULL);
}
VOID ConOutPrintf (LPTSTR szFormat, ...)
{
TCHAR szOut[OUTPUT_BUFFER_SIZE];
DWORD dwWritten;
va_list arg_ptr;
va_start (arg_ptr, szFormat);
_vstprintf (szOut, szFormat, arg_ptr);
va_end (arg_ptr);
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE),
szOut,
_tcslen(szOut) * sizeof(TCHAR),
&dwWritten,
NULL);
}
VOID ConErrChar (TCHAR c)
{
DWORD dwWritten;
WriteFile (GetStdHandle (STD_ERROR_HANDLE),
&c,
sizeof(TCHAR),
&dwWritten,
NULL);
}
VOID ConErrPuts (LPTSTR szText)
{
DWORD dwWritten;
WriteFile (GetStdHandle (STD_ERROR_HANDLE),
szText,
_tcslen(szText) * sizeof(TCHAR),
&dwWritten,
NULL);
WriteFile (GetStdHandle (STD_ERROR_HANDLE),
_T ("\n"),
sizeof(TCHAR),
&dwWritten,
NULL);
}
VOID ConErrPrintf (LPTSTR szFormat, ...)
{
TCHAR szOut[OUTPUT_BUFFER_SIZE];
DWORD dwWritten;
va_list arg_ptr;
va_start (arg_ptr, szFormat);
_vstprintf (szOut, szFormat, arg_ptr);
va_end (arg_ptr);
WriteFile (GetStdHandle (STD_ERROR_HANDLE),
szOut,
_tcslen(szOut) * sizeof(TCHAR),
&dwWritten,
NULL);
}
VOID SetCursorXY (SHORT x, SHORT y)
{
COORD coPos;
coPos.X = x;
coPos.Y = y;
SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), coPos);
}
VOID GetCursorXY (PSHORT x, PSHORT y)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &csbi);
*x = csbi.dwCursorPosition.X;
*y = csbi.dwCursorPosition.Y;
}
SHORT GetCursorX (VOID)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &csbi);
return csbi.dwCursorPosition.X;
}
SHORT GetCursorY (VOID)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &csbi);
return csbi.dwCursorPosition.Y;
}
VOID GetScreenSize (PSHORT maxx, PSHORT maxy)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &csbi);
if (maxx)
*maxx = csbi.dwSize.X;
if (maxy)
*maxy = csbi.dwSize.Y;
}
VOID SetCursorType (BOOL bInsert, BOOL bVisible)
{
CONSOLE_CURSOR_INFO cci;
cci.dwSize = bInsert ? 10 : 99;
cci.bVisible = bVisible;
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE), &cci);
}
/* EOF */

View File

@@ -1,751 +0,0 @@
/* $Id: copy.c,v 1.6 1999/12/24 17:20:54 ekohl Exp $
*
* COPY.C -- copy internal command.
*
*
* History:
*
* 01-Aug-98 (Rob Lake z63rrl@morgan.ucs.mun.ca)
* started
*
* 13-Aug-1998 (John P. Price)
* fixed memory leak problem in copy function.
* fixed copy function so it would work with wildcards in the source
*
* 13-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added COPY command to CMD.
*
* 26-Jan-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Replaced CRT io functions by Win32 io functions.
*
* 27-Oct-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Disabled prompting when used in batch mode.
*/
#include "config.h"
#ifdef INCLUDE_CMD_COPY
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "cmd.h"
#include "batch.h"
#define VERIFY 1 /* VERIFY Switch */
#define BINARY 2 /* File is to be copied as BINARY */
#define ASCII 4 /* File is to be copied as ASCII */
#define PROMPT 8 /* Prompt before overwriting files */
#define NPROMPT 16 /* Do not prompt before overwriting files */
#define HELP 32 /* Help was asked for */
#define SOURCE 128 /* File is a source */
typedef struct tagFILES
{
struct tagFILES *next;
TCHAR szFile[MAX_PATH];
DWORD dwFlag; /* BINARY -xor- ASCII */
} FILES, *LPFILES;
static BOOL DoSwitches (LPTSTR, LPDWORD);
static BOOL AddFile (LPFILES, char *, int *, int *, LPDWORD);
static BOOL AddFiles (LPFILES, char *, int *, int *, int *, LPDWORD);
static BOOL GetDestination (LPFILES, LPFILES);
static INT ParseCommand (LPFILES, int, char **, LPDWORD);
static VOID DeleteFileList (LPFILES);
static INT Overwrite (LPTSTR);
static BOOL
IsDirectory (LPTSTR fn)
{
if (!IsValidFileName (fn))
return FALSE;
return (GetFileAttributes (fn) & FILE_ATTRIBUTE_DIRECTORY);
}
static BOOL
DoSwitches (LPTSTR arg, LPDWORD lpdwFlags)
{
if (!_tcsicmp (arg, _T("/-Y")))
{
*lpdwFlags |= PROMPT;
*lpdwFlags &= ~NPROMPT;
return TRUE;
}
else if (_tcslen (arg) > 2)
{
error_too_many_parameters ("");
return FALSE;
}
switch (_totupper (arg[1]))
{
case _T('V'):
*lpdwFlags |= VERIFY;
break;
case _T('A'):
*lpdwFlags |= ASCII;
*lpdwFlags &= ~BINARY;
break;
case _T('B'):
*lpdwFlags |= BINARY;
*lpdwFlags &= ~ASCII;
break;
case _T('Y'):
*lpdwFlags &= ~PROMPT;
*lpdwFlags |= NPROMPT;
break;
default:
error_invalid_switch (arg[1]);
return FALSE;
}
return TRUE;
}
static BOOL
AddFile (LPFILES f, char *arg, int *source, int *dest, LPDWORD flags)
{
if (*dest)
{
error_too_many_parameters ("");
return FALSE;
}
if (*source)
{
*dest = 1;
f->dwFlag = 0;
}
else
{
*source = 1;
f->dwFlag = SOURCE;
}
_tcscpy(f->szFile, arg);
f->dwFlag |= *flags & ASCII ? ASCII : BINARY;
if ((f->next = (LPFILES)malloc (sizeof (FILES))) == NULL)
{
error_out_of_memory ();
return FALSE;
}
f = f->next;
f->dwFlag = 0;
f->next = NULL;
return TRUE;
}
static BOOL
AddFiles (LPFILES f, char *arg, int *source, int *dest,
int *count, LPDWORD flags)
{
char t[128];
int j;
int k;
if (*dest)
{
error_too_many_parameters ("");
return FALSE;
}
j = 0;
k = 0;
while (arg[j] == _T('+'))
j++;
while (arg[j] != _T('\0'))
{
t[k] = arg[j++];
if (t[k] == '+' || arg[j] == _T('\0'))
{
if (!k)
continue;
if (arg[j] == _T('\0') && t[k] != _T('+'))
k++;
t[k] = _T('\0');
*count += 1;
_tcscpy (f->szFile, t);
*source = 1;
if (*flags & ASCII)
f->dwFlag |= *flags | SOURCE | ASCII;
else
f->dwFlag |= *flags | BINARY | SOURCE;
if ((f->next = (LPFILES)malloc (sizeof (FILES))) == NULL)
{
error_out_of_memory ();
return FALSE;
}
f = f->next;
f->next = NULL;
k = 0;
f->dwFlag = 0;
continue;
}
k++;
}
if (arg[--j] == _T('+'))
*source = 0;
return 1;
}
static BOOL
GetDestination (LPFILES f, LPFILES dest)
{
LPFILES p = NULL;
LPFILES start = f;
while (f->next != NULL)
{
p = f;
f = f->next;
}
f = p;
if ((f->dwFlag & SOURCE) == 0)
{
free (p->next);
p->next = NULL;
_tcscpy (dest->szFile, f->szFile);
dest->dwFlag = f->dwFlag;
dest->next = NULL;
f = start;
return TRUE;
}
return FALSE;
}
static INT
ParseCommand (LPFILES f, int argc, char **arg, LPDWORD lpdwFlags)
{
INT i;
INT dest;
INT source;
INT count;
dest = 0;
source = 0;
count = 0;
for (i = 0; i < argc; i++)
{
if (arg[i][0] == _T('/'))
{
if (!DoSwitches (arg[i], lpdwFlags))
return -1;
}
else
{
if (!_tcscmp(arg[i], _T("+")))
source = 0;
else if (!_tcschr(arg[i], _T('+')) && source)
{
if (!AddFile(f, arg[i], &source, &dest, lpdwFlags))
return -1;
f = f->next;
count++;
}
else
{
if (!AddFiles(f, arg[i], &source, &dest, &count, lpdwFlags))
return -1;
while (f->next != NULL)
f = f->next;
}
}
}
#ifdef _DEBUG
DebugPrintf ("ParseCommand: flags has %s\n",
*lpdwFlags & ASCII ? "ASCII" : "BINARY");
#endif
return count;
}
static VOID
DeleteFileList (LPFILES f)
{
LPFILES temp;
while (f != NULL)
{
temp = f;
f = f->next;
free (temp);
}
}
static INT
Overwrite (LPTSTR fn)
{
TCHAR inp[10];
LPTSTR p;
ConOutPrintf (_T("Overwrite %s (Yes/No/All)? "), fn);
ConInString (inp, 10);
ConOutPuts (_T(""));
_tcsupr (inp);
for (p = inp; _istspace (*p); p++)
;
if (*p != _T('Y') && *p != _T('A'))
return 0;
if (*p == _T('A'))
return 2;
return 1;
}
#define BUFF_SIZE 16384 /* 16k = max buffer size */
int copy (LPTSTR source, LPTSTR dest, int append, LPDWORD lpdwFlags)
{
FILETIME srctime;
HANDLE hFileSrc;
HANDLE hFileDest;
LPBYTE buffer;
DWORD dwAttrib;
DWORD dwRead;
DWORD dwWritten;
DWORD i;
BOOL bEof = FALSE;
#ifdef _DEBUG
DebugPrintf ("checking mode\n");
#endif
dwAttrib = GetFileAttributes (source);
hFileSrc = CreateFile (source, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, 0, NULL);
if (hFileSrc == INVALID_HANDLE_VALUE)
{
ConErrPrintf (_T("Error: Cannot open source - %s!\n"), source);
return 0;
}
#ifdef _DEBUG
DebugPrintf (_T("getting time\n"));
#endif
GetFileTime (hFileSrc, &srctime, NULL, NULL);
#ifdef _DEBUG
DebugPrintf (_T("copy: flags has %s\n"),
*lpdwFlags & ASCII ? "ASCII" : "BINARY");
#endif
if (!IsValidFileName (dest))
{
#ifdef _DEBUG
DebugPrintf (_T("opening/creating\n"));
#endif
hFileDest =
CreateFile (dest, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
}
else if (!append)
{
if (!_tcscmp (dest, source))
{
ConErrPrintf (_T("Error: Can't copy onto itself!\n"));
CloseHandle (hFileSrc);
return 0;
}
#ifdef _DEBUG
DebugPrintf (_T("SetFileAttributes (%s, FILE_ATTRIBUTE_NORMAL);\n"), dest);
#endif
SetFileAttributes (dest, FILE_ATTRIBUTE_NORMAL);
#ifdef _DEBUG
DebugPrintf (_T("DeleteFile (%s);\n"), dest);
#endif
DeleteFile (dest);
hFileDest =
CreateFile (dest, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
}
else
{
LONG lFilePosHigh = 0;
if (!_tcscmp (dest, source))
{
CloseHandle (hFileSrc);
return 0;
}
#ifdef _DEBUG
DebugPrintf (_T("opening/appending\n"));
#endif
hFileDest =
CreateFile (dest, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
SetFilePointer (hFileDest, 0, &lFilePosHigh,FILE_END);
}
if (hFileDest == INVALID_HANDLE_VALUE)
{
CloseHandle (hFileSrc);
error_path_not_found ();
return 0;
}
buffer = (LPBYTE)malloc (BUFF_SIZE);
if (buffer == NULL)
{
CloseHandle (hFileDest);
CloseHandle (hFileSrc);
error_out_of_memory ();
return 0;
}
do
{
ReadFile (hFileSrc, buffer, BUFF_SIZE, &dwRead, NULL);
if (*lpdwFlags & ASCII)
{
for (i = 0; i < dwRead; i++)
{
if (((LPTSTR)buffer)[i] == 0x1A)
{
bEof = TRUE;
break;
}
}
dwRead = i;
}
if (dwRead == 0)
break;
WriteFile (hFileDest, buffer, dwRead, &dwWritten, NULL);
if (dwWritten != dwRead)
{
ConErrPrintf (_T("Error writing destination!\n"));
free (buffer);
CloseHandle (hFileDest);
CloseHandle (hFileSrc);
return 0;
}
}
while (dwRead && !bEof);
#ifdef _DEBUG
DebugPrintf (_T("setting time\n"));
#endif
SetFileTime (hFileDest, &srctime, NULL, NULL);
if (*lpdwFlags & ASCII)
{
((LPTSTR)buffer)[0] = 0x1A;
((LPTSTR)buffer)[1] = _T('\0');
#ifdef _DEBUG
DebugPrintf (_T("appending ^Z\n"));
#endif
WriteFile (hFileDest, buffer, sizeof(TCHAR), &dwWritten, NULL);
}
free (buffer);
CloseHandle (hFileDest);
CloseHandle (hFileSrc);
#ifdef _DEBUG
DebugPrintf (_T("setting mode\n"));
#endif
SetFileAttributes (dest, dwAttrib);
return 1;
}
int setup_copy (LPFILES sources, char **p, BOOL bMultiple,
char *drive_d, char *dir_d, char *file_d,
char *ext_d, int *append, LPDWORD lpdwFlags)
{
WIN32_FIND_DATA find;
char drive_s[_MAX_DRIVE];
CHAR dir_s[_MAX_DIR];
char file_s[_MAX_FNAME];
char ext_s[_MAX_EXT];
char from_merge[_MAX_PATH];
LPTSTR real_source;
LPTSTR real_dest;
INT nCopied = 0;
BOOL bAll = FALSE;
BOOL bDone;
HANDLE hFind;
real_source = (LPTSTR)malloc (MAX_PATH);
real_dest = (LPTSTR)malloc (MAX_PATH);
if (!real_source || !real_dest)
{
error_out_of_memory ();
DeleteFileList (sources);
free (real_source);
free (real_dest);
freep (p);
return 0;
}
while (sources->next != NULL)
{
_splitpath (sources->szFile, drive_s, dir_s, file_s, ext_s);
hFind = FindFirstFile (sources->szFile, &find);
if (hFind == INVALID_HANDLE_VALUE)
{
error_file_not_found();
DeleteFileList (sources);
freep(p);
free(real_source);
free(real_dest);
return 0;
}
do
{
if (find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
goto next;
_makepath(from_merge, drive_d, dir_d, file_d, ext_d);
if (from_merge[_tcslen(from_merge) - 1] == _T('\\'))
from_merge[_tcslen(from_merge) - 1] = 0;
if (IsDirectory (from_merge))
{
bMultiple = FALSE;
_tcscat (from_merge, _T("\\"));
_tcscat (from_merge, find.cFileName);
}
else
bMultiple = TRUE;
_tcscpy (real_dest, from_merge);
_makepath (real_source, drive_s, dir_s, find.cFileName, NULL);
#ifdef _DEBUG
DebugPrintf (_T("copying %s -> %s (%sappending%s)\n"),
real_source, real_dest,
*append ? "" : "not ",
sources->dwFlag & ASCII ? ", ASCII" : ", BINARY");
#endif
if (IsValidFileName (real_dest) && !bAll)
{
/* Don't prompt in a batch file */
if (bc != NULL)
{
bAll = TRUE;
}
else
{
int over;
over = Overwrite (real_dest);
if (over == 2)
bAll = TRUE;
else if (over == 0)
goto next;
else if (bMultiple)
bAll = TRUE;
}
}
if (copy (real_source, real_dest, *append, lpdwFlags))
nCopied++;
next:
bDone = FindNextFile (hFind, &find);
if (bMultiple)
*append = 1;
}
while (bDone);
FindClose (hFind);
sources = sources->next;
}
free (real_source);
free (real_dest);
return nCopied;
}
INT cmd_copy (LPTSTR first, LPTSTR rest)
{
char **p;
char drive_d[_MAX_DRIVE];
char dir_d[_MAX_DIR];
char file_d[_MAX_FNAME];
char ext_d[_MAX_EXT];
int argc;
int append;
int files;
int copied;
LPFILES sources = NULL;
LPFILES start = NULL;
FILES dest;
BOOL bMultiple;
BOOL bWildcards;
BOOL bDestFound;
DWORD dwFlags = 0;
if (!_tcsncmp (rest, _T("/?"), 2))
{
ConOutPuts (_T("Copies one or more files to another location.\n"
"\n"
"COPY [/V][/Y|/-Y][/A|/B] source [/A|/B]\n"
" [+ source [/A|/B] [+ ...]] [destination [/A|/B]]\n"
"\n"
" source Specifies the file or files to be copied.\n"
" /A Indicates an ASCII text file.\n"
" /B Indicates a binary file.\n"
" destination Specifies the directory and/or filename for the new file(s).\n"
" /V Verifies that new files are written correctly.\n"
" /Y Suppresses prompting to confirm you want to overwrite an\n"
" existing destination file.\n"
" /-Y Causes prompting to confirm you want to overwrite an\n"
" existing destination file.\n"
"\n"
"The switch /Y may be present in the COPYCMD environment variable.\n"
"..."));
return 1;
}
p = split (rest, &argc);
if (argc == 0)
{
error_req_param_missing ();
return 0;
}
sources = (LPFILES)malloc (sizeof (FILES));
if (!sources)
{
error_out_of_memory ();
return 0;
}
sources->next = NULL;
sources->dwFlag = 0;
if ((files = ParseCommand (sources, argc, p, &dwFlags)) == -1)
{
DeleteFileList (sources);
freep (p);
return 0;
}
else if (files == 0)
{
error_req_param_missing();
DeleteFileList (sources);
freep (p);
return 0;
}
start = sources;
bDestFound = GetDestination (sources, &dest);
if (bDestFound)
{
_splitpath (dest.szFile, drive_d, dir_d, file_d, ext_d);
if (IsDirectory (dest.szFile))
{
_tcscat (dir_d, file_d);
_tcscat (dir_d, ext_d);
file_d[0] = _T('\0');
ext_d[0] = _T('\0');
}
}
if (_tcschr (dest.szFile, _T('*')) || _tcschr (dest.szFile, _T('?')))
bWildcards = TRUE;
else
bWildcards = FALSE;
if (strchr(rest, '+'))
bMultiple = TRUE;
else
bMultiple = FALSE;
append = 0;
copied = 0;
if (bDestFound && !bWildcards)
{
copied = setup_copy (sources, p, bMultiple, drive_d, dir_d, file_d, ext_d, &append, &dwFlags);
}
else if (bDestFound && bWildcards)
{
ConErrPrintf (_T("Error: Not implemented yet!\n"));
DeleteFileList (sources);
freep (p);
return 0;
}
else if (!bDestFound && !bMultiple)
{
_splitpath (sources->szFile, drive_d, dir_d, file_d, ext_d);
if (IsDirectory (sources->szFile))
{
_tcscat (dir_d, file_d);
_tcscat (dir_d, ext_d);
file_d[0] = _T('\0');
ext_d[0] = _T('\0');
}
copied = setup_copy (sources, p, FALSE, "", "", file_d, ext_d, &append, &dwFlags);
}
else
{
_splitpath(sources->szFile, drive_d, dir_d, file_d, ext_d);
if (IsDirectory (sources->szFile))
{
_tcscat (dir_d, file_d);
_tcscat (dir_d, ext_d);
file_d[0] = _T('\0');
ext_d[0] = _T('\0');
}
ConOutPuts (sources->szFile);
append = 1;
copied = setup_copy (sources->next, p, bMultiple, drive_d, dir_d, file_d, ext_d, &append, &dwFlags) + 1;
}
DeleteFileList (sources);
freep (p);
ConOutPrintf (_T(" %d file(s) copied\n"), copied);
return 1;
}
#endif /* INCLUDE_CMD_COPY */
/* EOF */

View File

@@ -1,261 +0,0 @@
/*
* DATE.C - date internal command.
*
*
* History:
*
* 08 Jul 1998 (John P. Price)
* started.
*
* 20 Jul 1998 (John P. Price)
* corrected number of days for December from 30 to 31.
* (Thanx to Steffen Kaiser for bug report)
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 29-Jul-1998 (Rob Lake)
* fixed stand-alone mode.
* Added Pacific C compatible dos_getdate functions
*
* 09-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added locale support
*
* 23-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection safe!
*
* 04-Feb-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed date input bug.
*/
#include "config.h"
#ifdef INCLUDE_CMD_DATE
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
static WORD awMonths[2][13] =
{
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
static VOID
PrintDateString (VOID)
{
switch (nDateFormat)
{
case 0: /* mmddyy */
default:
ConOutPrintf (_T("\nEnter new date (mm%cdd%cyyyy): "),
cDateSeparator, cDateSeparator);
break;
case 1: /* ddmmyy */
ConOutPrintf (_T("\nEnter new date (dd%cmm%cyyyy): "),
cDateSeparator, cDateSeparator);
break;
case 2: /* yymmdd */
ConOutPrintf (_T("\nEnter new date (yyyy%cmm%cdd): "),
cDateSeparator, cDateSeparator);
break;
}
}
static BOOL
ReadNumber (LPTSTR *s, LPWORD lpwValue)
{
if (_istdigit (**s))
{
while (_istdigit (**s))
{
*lpwValue = *lpwValue * 10 + **s - _T('0');
(*s)++;
}
return TRUE;
}
return FALSE;
}
static BOOL
ReadSeparator (LPTSTR *s)
{
if (**s == _T('/') || **s == _T('-') || **s == cDateSeparator)
{
(*s)++;
return TRUE;
}
return FALSE;
}
static BOOL
ParseDate (LPTSTR s)
{
SYSTEMTIME d;
unsigned char leap;
LPTSTR p = s;
if (!*s)
return TRUE;
GetLocalTime (&d);
d.wYear = 0;
d.wDay = 0;
d.wMonth = 0;
switch (nDateFormat)
{
case 0: /* mmddyy */
default:
if (!ReadNumber (&p, &d.wMonth))
return FALSE;
if (!ReadSeparator (&p))
return FALSE;
if (!ReadNumber (&p, &d.wDay))
return FALSE;
if (!ReadSeparator (&p))
return FALSE;
if (!ReadNumber (&p, &d.wYear))
return FALSE;
break;
case 1: /* ddmmyy */
if (!ReadNumber (&p, &d.wDay))
return FALSE;
if (!ReadSeparator (&p))
return FALSE;
if (!ReadNumber (&p, &d.wMonth))
return FALSE;
if (!ReadSeparator (&p))
return FALSE;
if (!ReadNumber (&p, &d.wYear))
return FALSE;
break;
case 2: /* yymmdd */
if (!ReadNumber (&p, &d.wYear))
return FALSE;
if (!ReadSeparator (&p))
return FALSE;
if (!ReadNumber (&p, &d.wMonth))
return FALSE;
if (!ReadSeparator (&p))
return FALSE;
if (!ReadNumber (&p, &d.wDay))
return FALSE;
break;
}
/* if only entered two digits: */
/* assume 2000's if value less than 80 */
/* assume 1900's if value greater or equal 80 */
if (d.wYear <= 99)
{
if (d.wYear >= 80)
d.wYear = 1900 + d.wYear;
else
d.wYear = 2000 + d.wYear;
}
leap = (!(d.wYear % 4) && (d.wYear % 100)) || !(d.wYear % 400);
if ((d.wMonth >= 1 && d.wMonth <= 12) &&
(d.wDay >= 1 && d.wDay <= awMonths[leap][d.wMonth]) &&
(d.wYear >= 1980 && d.wYear <= 2099))
{
SetLocalTime (&d);
return TRUE;
}
return FALSE;
}
INT cmd_date (LPTSTR cmd, LPTSTR param)
{
LPTSTR *arg;
INT argc;
INT i;
BOOL bPrompt = TRUE;
INT nDateString = -1;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays or sets the date.\n\n"
"DATE [/T][date]\n\n"
" /T display only\n\n"
"Type DATE without parameters to display the current date setting and\n"
"a prompt for a new one. Press ENTER to keep the same date."));
return 0;
}
/* build parameter array */
arg = split (param, &argc);
/* check for options */
for (i = 0; i < argc; i++)
{
if (_tcsicmp (arg[i], _T("/t")) == 0)
bPrompt = FALSE;
if ((*arg[i] != _T('/')) && (nDateString == -1))
nDateString = i;
}
if (nDateString == -1)
PrintDate ();
if (!bPrompt)
{
freep (arg);
return 0;
}
if (nDateString == -1)
{
while (TRUE) /* forever loop */
{
TCHAR s[40];
PrintDateString ();
ConInString (s, 40);
#ifdef _DEBUG
DebugPrintf ("\'%s\'\n", s);
#endif
while (*s && s[_tcslen (s) - 1] < ' ')
s[_tcslen (s) - 1] = '\0';
if (ParseDate (s))
{
freep (arg);
return 0;
}
ConErrPuts ("Invalid date.");
}
}
else
{
if (ParseDate (arg[nDateString]))
{
freep (arg);
return 0;
}
ConErrPuts ("Invalid date.");
}
freep (arg);
return 0;
}
#endif

View File

@@ -1,348 +0,0 @@
/*
* DEL.C - del internal command.
*
*
* History:
*
* 06/29/98 (Rob Lake rlake@cs.mun.ca)
* rewrote del to support wildcards
* added my name to the contributors
*
* 07/13/98 (Rob Lake)
* fixed bug that caused del not to delete file with out
* attribute. moved set, del, ren, and ver to there own files
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 09-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeiung.de>)
* Fixed command line parsing bugs.
*
* 21-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeiung.de>)
* Started major rewrite using a new structure.
*
* 03-Feb-1999 (Eric Kohl <ekohl@abo.rhein-zeiung.de>)
* First working version.
*
* 30-Mar-1999 (Eric Kohl <ekohl@abo.rhein-zeiung.de>)
* Added quiet ("/Q"), wipe ("/W") and zap ("/Z") option.
*
* 06-Nov-1999 (Eric Kohl <ekohl@abo.rhein-zeiung.de>)
* Little fix to keep DEL quiet inside batch files.
*/
#include "config.h"
#ifdef INCLUDE_CMD_DEL
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "cmd.h"
#include "batch.h"
enum
{
DEL_ATTRIBUTES = 0x001, /* /A : not implemented */
DEL_ERROR = 0x002, /* /E : not implemented */
DEL_NOTHING = 0x004, /* /N */
DEL_PROMPT = 0x008, /* /P : not implemented */
DEL_QUIET = 0x010, /* /Q */
DEL_SUBDIR = 0x020, /* /S : not implemented */
DEL_TOTAL = 0x040, /* /T */
DEL_WIPE = 0x080, /* /W */
DEL_EMPTYDIR = 0x100, /* /X : not implemented */
DEL_YES = 0x200, /* /Y : not implemented */
DEL_ZAP = 0x400 /* /Z */
};
static BOOL
RemoveFile (LPTSTR lpFileName, DWORD dwFlags)
{
if (dwFlags & DEL_WIPE)
{
/* FIXME: Wipe the given file */
}
return DeleteFile (lpFileName);
}
INT CommandDelete (LPTSTR cmd, LPTSTR param)
{
TCHAR szFullPath[MAX_PATH];
LPTSTR pFilePart;
LPTSTR *arg = NULL;
INT args;
INT i;
INT nEvalArgs = 0; /* nunber of evaluated arguments */
DWORD dwFlags = 0;
DWORD dwFiles = 0;
HANDLE hFile;
WIN32_FIND_DATA f;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Deletes one or more files.\n"
"\n"
"DEL [/N /P /T /Q /W /Z] file ...\n"
"DELETE [/N /P /T /Q /W /Z] file ...\n"
"ERASE [/N /P /T /Q /W /Z] file ...\n"
"\n"
" file Specifies the file(s) to delete.\n"
"\n"
" /N Nothing.\n"
" /P Prompts for confirmation before deleting each file.\n"
" (Not implemented yet!)\n"
" /T Display total number of deleted files and freed disk space.\n"
" /Q Quiet.\n"
" /W Wipe. Overwrite the file with zeros before deleting it.\n"
" /Z Zap (delete hidden, read-only and system files).\n"));
return 0;
}
arg = split (param, &args);
if (args > 0)
{
/* check for options anywhere in command line */
for (i = 0; i < args; i++)
{
if (*arg[i] == _T('/'))
{
if (_tcslen (arg[i]) >= 2)
{
switch (_totupper (arg[i][1]))
{
case _T('N'):
dwFlags |= DEL_NOTHING;
break;
case _T('P'):
dwFlags |= DEL_PROMPT;
break;
case _T('Q'):
dwFlags |= DEL_QUIET;
break;
case _T('S'):
dwFlags |= DEL_SUBDIR;
break;
case _T('T'):
dwFlags |= DEL_TOTAL;
break;
case _T('W'):
dwFlags |= DEL_WIPE;
break;
case _T('Z'):
dwFlags |= DEL_ZAP;
break;
}
}
nEvalArgs++;
}
}
/* there are only options on the command line --> error!!! */
if (args == nEvalArgs)
{
error_req_param_missing ();
freep (arg);
return 1;
}
/* keep quiet within batch files */
if (bc != NULL)
dwFlags |= DEL_QUIET;
/* check for filenames anywhere in command line */
for (i = 0; i < args; i++)
{
if (!_tcscmp (arg[i], _T("*")) ||
!_tcscmp (arg[i], _T("*.*")))
{
INT res;
res = FilePromptYN (_T("All files in directory will be deleted!\n"
"Are you sure (Y/N)?"));
if ((res == PROMPT_NO) ||
(res == PROMPT_BREAK))
break;
}
if (*arg[i] != _T('/'))
{
#ifdef _DEBUG
ConErrPrintf (_T("File: %s\n"), arg[i]);
#endif
if (_tcschr (arg[i], _T('*')) || _tcschr (arg[i], _T('?')))
{
/* wildcards in filespec */
#ifdef _DEBUG
ConErrPrintf (_T("Wildcards!\n\n"));
#endif
GetFullPathName (arg[i],
MAX_PATH,
szFullPath,
&pFilePart);
#ifdef _DEBUG
ConErrPrintf (_T("Full path: %s\n"), szFullPath);
ConErrPrintf (_T("File part: %s\n"), pFilePart);
#endif
hFile = FindFirstFile (szFullPath, &f);
if (hFile == INVALID_HANDLE_VALUE)
{
error_file_not_found ();
freep (arg);
return 0;
}
do
{
/* ignore "." and ".." */
if (!_tcscmp (f.cFileName, _T(".")) ||
!_tcscmp (f.cFileName, _T("..")))
continue;
_tcscpy (pFilePart, f.cFileName);
#ifdef _DEBUG
ConErrPrintf (_T("Full filename: %s\n"), szFullPath);
#endif
if (!(dwFlags & DEL_QUIET) && !(dwFlags & DEL_TOTAL))
ConErrPrintf (_T("Deleting: %s\n"), szFullPath);
/* delete the file */
if (!(dwFlags & DEL_NOTHING))
{
if (RemoveFile (szFullPath, dwFlags))
{
dwFiles++;
}
else
{
if (dwFlags & DEL_ZAP)
{
if (SetFileAttributes (szFullPath, 0))
{
if (RemoveFile (szFullPath, dwFlags))
{
dwFiles++;
}
else
{
ErrorMessage (GetLastError(), _T(""));
}
}
else
{
ErrorMessage (GetLastError(), _T(""));
}
}
else
{
ErrorMessage (GetLastError(), _T(""));
}
}
}
}
while (FindNextFile (hFile, &f));
FindClose (hFile);
}
else
{
/* no wildcards in filespec */
#ifdef _DEBUG
ConErrPrintf (_T("No Wildcards!\n"));
#endif
GetFullPathName (arg[i],
MAX_PATH,
szFullPath,
&pFilePart);
#ifdef _DEBUG
ConErrPrintf (_T("Full path: %s\n"), szFullPath);
#endif
if (!(dwFlags & DEL_QUIET) && !(dwFlags & DEL_TOTAL))
ConOutPrintf (_T("Deleting %s\n"), szFullPath);
if (!(dwFlags & DEL_NOTHING))
{
if (RemoveFile (szFullPath, dwFlags))
{
dwFiles++;
}
else
{
if (dwFlags & DEL_ZAP)
{
if (SetFileAttributes (szFullPath, 0))
{
if (RemoveFile (szFullPath, dwFlags))
{
dwFiles++;
}
else
{
ErrorMessage (GetLastError(), _T(""));
}
}
else
{
ErrorMessage (GetLastError(), _T(""));
}
}
else
{
ErrorMessage (GetLastError(), _T(""));
}
}
}
}
}
}
}
else
{
/* only command given */
error_req_param_missing ();
freep (arg);
return 1;
}
freep (arg);
if (!(dwFlags & DEL_QUIET))
{
if (dwFiles == 0)
ConOutPrintf (_T(" 0 files deleted\n"));
else
ConOutPrintf (_T(" %lu file%s deleted\n"),
dwFiles,
(dwFiles == 1) ? "" : "s");
}
return 0;
}
#endif

View File

@@ -1,58 +0,0 @@
/*
* DELAY.C - internal command.
*
* clone from 4nt delay command
*
* 30 Aug 1999
* started - Paolo Pantaleo <paolopan@freemail.it>
*
*
*/
#include "config.h"
#ifdef INCLUDE_CMD_DELAY
#include <tchar.h>
#include <windows.h>
#include <stdlib.h>
#include "cmd.h"
INT CommandDelay (LPTSTR cmd, LPTSTR param)
{
DWORD val;
DWORD mul=1000;
if (_tcsncmp (param, _T("/?"), 2) == 0)
{
ConOutPuts(_T(
"pause for n seconds or milliseconds"
"\n"
"DELAY [/m]n\n"
"\n"
" /m specifiy than n are milliseconds\n"
" otherwise n are seconds"));
return 0;
}
if (*param==0)
{
error_req_param_missing ();
return 1;
}
if (_tcsnicmp(param,"/m",2) == 0)
{
mul = 1;
param += 2;
}
val = atoi(param);
Sleep(val*mul);
return 0;
}
#endif /* INCLUDE_CMD_DELAY */

File diff suppressed because it is too large Load Diff

View File

@@ -1,237 +0,0 @@
/*
* DIRSTACK.C - pushd / pop (directory stack) internal commands.
*
*
* History:
*
* 14-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Implemented PUSHD and POPD command.
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection safe!
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added DIRS command.
*/
#include "config.h"
#ifdef FEATURE_DIRECTORY_STACK
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include "cmd.h"
typedef struct tagDIRENTRY
{
struct tagDIRENTRY *prev;
struct tagDIRENTRY *next;
LPTSTR pszPath;
} DIRENTRY, *LPDIRENTRY;
static INT nStackDepth;
static LPDIRENTRY lpStackTop;
static LPDIRENTRY lpStackBottom;
static INT
PushDirectory (LPTSTR pszPath)
{
LPDIRENTRY lpDir;
lpDir = (LPDIRENTRY)malloc (sizeof (DIRENTRY));
if (!lpDir)
{
error_out_of_memory ();
return -1;
}
lpDir->prev = NULL;
if (lpStackTop == NULL)
{
lpDir->next = NULL;
lpStackBottom = lpDir;
}
else
{
lpDir->next = lpStackTop;
lpStackTop->prev = lpDir;
}
lpStackTop = lpDir;
lpDir->pszPath = (LPTSTR)malloc ((_tcslen(pszPath)+1)*sizeof(TCHAR));
if (!lpDir->pszPath)
{
free (lpDir);
error_out_of_memory ();
return -1;
}
_tcscpy (lpDir->pszPath, pszPath);
nStackDepth++;
return 0;
}
static VOID
PopDirectory (VOID)
{
LPDIRENTRY lpDir;
if (nStackDepth == 0)
return;
lpDir = lpStackTop;
lpStackTop = lpDir->next;
if (lpStackTop != NULL)
lpStackTop->prev = NULL;
else
lpStackBottom = NULL;
free (lpDir->pszPath);
free (lpDir);
nStackDepth--;
}
static VOID
GetDirectoryStackTop (LPTSTR pszPath)
{
if (lpStackTop)
_tcsncpy (pszPath, lpStackTop->pszPath, MAX_PATH);
else
*pszPath = _T('\0');
}
/*
* initialize directory stack
*/
VOID InitDirectoryStack (VOID)
{
nStackDepth = 0;
lpStackTop = NULL;
lpStackBottom = NULL;
}
/*
* destroy directory stack
*/
VOID DestroyDirectoryStack (VOID)
{
while (nStackDepth)
PopDirectory ();
}
INT GetDirectoryStackDepth (VOID)
{
return nStackDepth;
}
/*
* pushd command
*/
INT CommandPushd (LPTSTR first, LPTSTR rest)
{
TCHAR curPath[MAX_PATH];
TCHAR newPath[MAX_PATH];
BOOL bChangePath = FALSE;
if (!_tcsncmp (rest, _T("/?"), 2))
{
ConOutPuts (_T("Stores the current directory for use by the POPD command, then\n"
"changes to the specified directory.\n\n"
"PUSHD [path | ..]\n\n"
" path Specifies the directory to make the current directory"));
return 0;
}
if (rest[0] != _T('\0'))
{
GetFullPathName (rest, MAX_PATH, newPath, NULL);
bChangePath = IsValidPathName (newPath);
}
GetCurrentDirectory (MAX_PATH, curPath);
if (PushDirectory (curPath))
return 0;
if (bChangePath)
SetCurrentDirectory (newPath);
return 0;
}
/*
* popd command
*/
INT CommandPopd (LPTSTR first, LPTSTR rest)
{
TCHAR szPath[MAX_PATH];
if (!_tcsncmp(rest, _T("/?"), 2))
{
ConOutPuts (_T("Changes to the directory stored by the PUSHD command.\n\n"
"POPD"));
return 0;
}
if (GetDirectoryStackDepth () == 0)
return 0;
GetDirectoryStackTop (szPath);
PopDirectory ();
SetCurrentDirectory (szPath);
return 0;
}
/*
* dirs command
*/
INT CommandDirs (LPTSTR first, LPTSTR rest)
{
LPDIRENTRY lpDir;
if (!_tcsncmp(rest, _T("/?"), 2))
{
ConOutPuts (_T("Prints the contents of the directory stack.\n"
"\n"
"DIRS"));
return 0;
}
lpDir = lpStackBottom;
if (lpDir == NULL)
{
ConOutPuts (_T("Directory stack empty"));
return 0;
}
while (lpDir != NULL)
{
ConOutPuts (lpDir->pszPath);
lpDir = lpDir->prev;
}
return 0;
}
#endif /* FEATURE_DIRECTORY_STACK */

View File

@@ -1,121 +0,0 @@
/* $Id: echo.c,v 1.3 1999/10/03 22:15:33 ekohl Exp $
*
* ECHO.C - internal echo commands.
*
*
* History:
*
* 16 Jul 1998 (Hans B Pufal)
* Started.
*
* 16 Jul 1998 (John P Price)
* Separated commands into individual files.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* Added config.h include
*
* 08-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("/?").
*
* 19-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection ready!
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
#include "batch.h"
INT CommandEcho (LPTSTR cmd, LPTSTR param)
{
#ifdef _DEBUG
DebugPrintf ("CommandEcho '%s' : '%s'\n", cmd, param);
#endif
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts ("Displays a message or switches command echoing on or off.\n\n"
"ECHO [ON | OFF]\nECHO [message]\n\n"
"Type ECHO without a parameter to display the current ECHO setting.");
return 0;
}
if (_tcsicmp (param, D_OFF) == 0)
bEcho = FALSE;
else if (_tcsicmp (param, D_ON) == 0)
bEcho = TRUE;
else if (*param)
ConOutPuts (param);
else
ConOutPrintf (_T("ECHO is %s\n"), bEcho ? D_ON : D_OFF);
return 0;
}
INT CommandEchos (LPTSTR cmd, LPTSTR param)
{
#ifdef _DEBUG
DebugPrintf ("CommandEchos '%s' : '%s'\n", cmd, param);
#endif
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts ("Display a messages without trailing carridge return and line feed.\n"
"\n"
"ECHOS message\n");
return 0;
}
if (*param)
ConOutPrintf ("%s", param);
return 0;
}
INT CommandEchoerr (LPTSTR cmd, LPTSTR param)
{
#ifdef _DEBUG
DebugPrintf ("CommandEchoerr '%s' : '%s'\n", cmd, param);
#endif
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts ("Displays a message to the standard error.\n"
"\n"
"ECHOERR message");
return 0;
}
if (*param)
ConErrPuts (param);
return 0;
}
INT CommandEchoserr (LPTSTR cmd, LPTSTR param)
{
#ifdef _DEBUG
DebugPrintf ("CommandEchoserr '%s' : '%s'\n", cmd, param);
#endif
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts ("Prints a messages to standard error output without trailing carridge return and line feed.\n"
"\n"
"ECHOSERR message\n");
return 0;
}
if (*param)
ConOutPrintf ("%s", param);
return 0;
}
/* EOF */

View File

@@ -1,175 +0,0 @@
/*
* ERROR.C - error reporting functions.
*
*
* History:
*
* 07/12/98 (Rob Lake)
* started
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 24-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Redirection safe!
*
* 02-Feb-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Use FormatMessage() for error reports.
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <stdarg.h>
#include "cmd.h"
#define INVALID_SWITCH _T("Invalid switch - /%c\n")
#define TOO_MANY_PARAMETERS _T("Too many parameters - %s\n")
#define PATH_NOT_FOUND _T("Path not found\n")
#define FILE_NOT_FOUND _T("File not found\n")
#define REQ_PARAM_MISSING _T("Required parameter missing\n")
#define INVALID_DRIVE _T("Invalid drive specification\n")
#define INVALID_PARAM_FORMAT _T("Invalid parameter format - %s\n")
#define BADCOMMAND _T("Bad command or filename\n")
#define OUT_OF_MEMORY _T("Out of memory error.\n")
#define CANNOTPIPE _T("Error! Cannot pipe! Cannot open temporary file!\n")
#define D_PAUSEMSG _T("Press any key to continue . . .")
VOID ErrorMessage (DWORD dwErrorCode, LPTSTR szFormat, ...)
{
TCHAR szMessage[1024];
LPTSTR szError;
va_list arg_ptr;
if (dwErrorCode == ERROR_SUCCESS)
return;
va_start (arg_ptr, szFormat);
_vstprintf (szMessage, szFormat, arg_ptr);
va_end (arg_ptr);
#ifndef __REACTOS__
if (FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
NULL, dwErrorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&szError, 0, NULL))
{
ConErrPrintf (_T("%s %s\n"), szError, szMessage);
LocalFree (szError);
return;
}
else
{
ConErrPrintf (_T("Unknown error! Error code: 0x%lx\n"), dwErrorCode);
return;
}
#else
switch (dwErrorCode)
{
case ERROR_FILE_NOT_FOUND:
szError = _T("File not found --");
break;
case ERROR_PATH_NOT_FOUND:
szError = _T("Path not found --");
break;
default:
ConErrPrintf (_T("Unknown error! Error code: 0x%lx\n"), dwErrorCode);
return;
}
ConErrPrintf (_T("%s %s\n"), szError, szMessage);
#endif
}
VOID error_invalid_switch (TCHAR ch)
{
ConErrPrintf (INVALID_SWITCH, ch);
}
VOID error_too_many_parameters (LPTSTR s)
{
ConErrPrintf (TOO_MANY_PARAMETERS, s);
}
VOID error_path_not_found (VOID)
{
ConErrPrintf (PATH_NOT_FOUND);
}
VOID error_file_not_found (VOID)
{
ConErrPrintf (FILE_NOT_FOUND);
}
VOID error_sfile_not_found (LPTSTR f)
{
ConErrPrintf (FILE_NOT_FOUND _T(" - %s\n"), f);
}
VOID error_req_param_missing (VOID)
{
ConErrPrintf (REQ_PARAM_MISSING);
}
VOID error_invalid_drive (VOID)
{
ConErrPrintf (INVALID_DRIVE);
}
VOID error_bad_command (VOID)
{
ConErrPrintf (BADCOMMAND);
}
VOID error_no_pipe (VOID)
{
ConErrPrintf (CANNOTPIPE);
}
VOID error_out_of_memory (VOID)
{
ConErrPrintf (OUT_OF_MEMORY);
}
VOID error_invalid_parameter_format (LPTSTR s)
{
ConErrPrintf (INVALID_PARAM_FORMAT, s);
}
VOID error_syntax (LPTSTR s)
{
if (s)
ConErrPrintf (_T("Syntax error - %s\n"), s);
else
ConErrPrintf (_T("Syntax error.\n"));
}
VOID msg_pause (VOID)
{
ConOutPuts (D_PAUSEMSG);
}

View File

@@ -1,285 +0,0 @@
/*
* FILECOMP.C - handles filename completion.
*
*
* Comments:
*
* 30-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* moved from command.c file
* made second TAB display list of filename matches
* made filename be lower case if last character typed is lower case
*
* 25-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Cleanup. Unicode safe!
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdio.h>
#include "cmd.h"
#ifdef FEATURE_UNIX_FILENAME_COMPLETION
VOID CompleteFilename (LPTSTR str, INT charcount)
{
WIN32_FIND_DATA file;
HANDLE hFile;
INT curplace = 0;
INT start;
INT count;
BOOL found_dot = FALSE;
BOOL perfectmatch = TRUE;
TCHAR path[MAX_PATH];
TCHAR fname[MAX_PATH];
TCHAR maxmatch[MAX_PATH] = _T("");
TCHAR directory[MAX_PATH];
LPCOMMAND cmds_ptr;
/* expand current file name */
count = charcount - 1;
if (count < 0)
count = 0;
/* find front of word */
while (count > 0 && str[count] != _T(' '))
count--;
/* if not at beginning, go forward 1 */
if (str[count] == _T(' '))
count++;
start = count;
/* extract directory from word */
_tcscpy (directory, &str[start]);
curplace = _tcslen (directory) - 1;
while (curplace >= 0 && directory[curplace] != _T('\\') &&
directory[curplace] != _T(':'))
{
directory[curplace] = 0;
curplace--;
}
_tcscpy (path, &str[start]);
/* look for a '.' in the filename */
for (count = _tcslen (directory); path[count] != _T('\0'); count++)
{
if (path[count] == _T('.'))
{
found_dot = TRUE;
break;
}
}
if (found_dot)
_tcscat (path, _T("*"));
else
_tcscat (path, _T("*.*"));
/* current fname */
curplace = 0;
hFile = FindFirstFile (path, &file);
if (hFile != INVALID_HANDLE_VALUE)
{
/* find anything */
do
{
/* ignore "." and ".." */
if (!_tcscmp (file.cFileName, _T(".")) ||
!_tcscmp (file.cFileName, _T("..")))
continue;
_tcscpy (fname, file.cFileName);
if (file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
_tcscat (fname, _T("\\"));
else
_tcscat (fname, _T(" "));
if (!maxmatch[0] && perfectmatch)
{
_tcscpy(maxmatch, fname);
}
else
{
for (count = 0; maxmatch[count] && fname[count]; count++)
{
if (tolower(maxmatch[count]) != tolower(fname[count]))
{
perfectmatch = FALSE;
maxmatch[count] = 0;
break;
}
}
}
}
while (FindNextFile (hFile, &file));
FindClose (hFile);
if( perfectmatch )
{
str[start] = '\"';
_tcscpy (&str[start+1], directory);
_tcscat (&str[start], maxmatch);
_tcscat (&str[start], "\"" );
}
else
#ifdef __REACTOS__
Beep (440, 50);
#else
MessageBeep (-1);
#endif
}
else
{
/* no match found - search for internal command */
for (cmds_ptr = cmds; cmds_ptr->name; cmds_ptr++)
{
if (!_tcsnicmp (&str[start], cmds_ptr->name,
_tcslen (&str[start])))
{
/* return the mach only if it is unique */
if (_tcsnicmp (&str[start], (cmds_ptr+1)->name, _tcslen (&str[start])))
_tcscpy (&str[start], cmds_ptr->name);
break;
}
}
#ifdef __REACTOS__
Beep (440, 50);
#else
MessageBeep (-1);
#endif
}
}
/*
* returns 1 if at least one match, else returns 0
*/
BOOL ShowCompletionMatches (LPTSTR str, INT charcount)
{
WIN32_FIND_DATA file;
HANDLE hFile;
BOOL found_dot = FALSE;
INT curplace = 0;
INT start;
INT count;
TCHAR path[MAX_PATH];
TCHAR fname[MAX_PATH];
TCHAR directory[MAX_PATH];
/* expand current file name */
count = charcount - 1;
if (count < 0)
count = 0;
/* find front of word */
while (count > 0 && str[count] != _T(' '))
count--;
/* if not at beginning, go forward 1 */
if (str[count] == _T(' '))
count++;
start = count;
/* extract directory from word */
_tcscpy (directory, &str[start]);
curplace = _tcslen (directory) - 1;
while (curplace >= 0 &&
directory[curplace] != _T('\\') &&
directory[curplace] != _T(':'))
{
directory[curplace] = 0;
curplace--;
}
_tcscpy (path, &str[start]);
/* look for a . in the filename */
for (count = _tcslen (directory); path[count] != _T('\0'); count++)
{
if (path[count] == _T('.'))
{
found_dot = TRUE;
break;
}
}
if (found_dot)
_tcscat (path, _T("*"));
else
_tcscat (path, _T("*.*"));
/* current fname */
curplace = 0;
hFile = FindFirstFile (path, &file);
if (hFile != INVALID_HANDLE_VALUE)
{
/* find anything */
ConOutChar (_T('\n'));
count = 0;
do
{
/* ignore . and .. */
if (!_tcscmp (file.cFileName, _T(".")) ||
!_tcscmp (file.cFileName, _T("..")))
continue;
if (file.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
_stprintf (fname, _T("[%s]"), file.cFileName);
else
_tcscpy (fname, file.cFileName);
ConOutPrintf (_T("%-14s"), fname);
if (++count == 5)
{
ConOutChar (_T('\n'));
count = 0;
}
}
while (FindNextFile (hFile, &file));
FindClose (hFile);
if (count)
ConOutChar (_T('\n'));
}
else
{
/* no match found */
#ifdef __REACTOS__
Beep (440, 50);
#else
MessageBeep (-1);
#endif
return FALSE;
}
return TRUE;
}
#endif
#ifdef FEATURE_4NT_FILENAME_COMPLETION
//static VOID BuildFilenameMatchList (...)
// VOID CompleteFilenameNext (LPTSTR, INT)
// VOID CompleteFilenamePrev (LPTSTR, INT)
// VOID RemoveFilenameMatchList (VOID)
#endif

View File

@@ -1,61 +0,0 @@
Archive Contents
~~~~~~~~~~~~~~~~
bugs.txt Bug List
files.txt This file list
history.txt History of the shell development
license.txt GNU license - applies to all files named here
readme.txt General shell info
todo.txt What I have to do
wishlist.txt Wish List
makefile experimental makefile
makefile.lcc makefile for lcc-win
alias.c Alias code
alias.h Alias header file
attrib.c Implements attrib command
batch.c Batch file interpreter
beep.c Implements beep command
call.c Implements call command
chcp.c Implements chcp command
choice.c Implements choice command
cls.c Implements cls command
cmdinput.c Command-line input functions
cmdtable.c Table of available internal commands
cmd.c Main code for command-line interpreter
cmd.h Command header file
color.c Implements color command
console.c Windows console handling code
copy.c Implements copy command
date.c Implements date command
del.c Implements del command
dir.c Directory listing code
dirstack.c Directory stack code (PUSHD and POPD)
echo.c Implements echo command
error.c Error Message Routines
filecomp.c Filename completion functions
for.c Implements for command
free.c Implements free command
goto.c Implements goto command
history.c Command-line history handling
if.c Implements if command
internal.c Internal commands (DIR, RD, etc)
label.c Implements label command
locale.c Locale handling code
memory.c Implements memory command
misc.c Misc. Functions
msgbox.c Implements msgbox command
move.c Implements move command
path.c Implements path command
pause.c Implements pause command
prompt.c Prompt handling functions
redir.c Redirection and piping parsing functions
ren.c Implements rename command
set.c Implements set command
shift.c Implements shift command
time.c Implements time command
timer.c Implements timer command
type.c Implements type command
ver.c Implements ver command
where.c Code to search path for executables
verify.c Implements verify command

View File

@@ -1,149 +0,0 @@
/*
* FOR.C - for internal batch command.
*
*
* History:
*
* 16-Jul-1998 (Hans B Pufal)
* Started.
*
* 16-Jul-1998 (John P Price)
* Seperated commands into individual files.
*
* 19-Jul-1998 (Hans B Pufal)
* Implementation of FOR.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* Added config.h include.
*
* 20-Jan-1999 (Eric Kohl)
* Unicode and redirection safe!
*
* 01-Sep-1999 (Eric Kohl)
* Added help text.
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "cmd.h"
#include "batch.h"
/*
* Perform FOR command.
*
* First check syntax is correct : FOR %v IN ( <list> ) DO <command>
* v must be alphabetic, <command> must not be empty.
*
* If all is correct build a new bcontext structure which preserves
* the necessary information so that readbatchline can expand
* each the command prototype for each list element.
*
* You might look on a FOR as being a called batch file with one line
* per list element.
*/
INT cmd_for (LPTSTR cmd, LPTSTR param)
{
LPBATCH_CONTEXT lpNew;
LPTSTR pp;
TCHAR var;
#ifdef _DEBUG
DebugPrintf ("cmd_for (\'%s\', \'%s\'\n", cmd, param);
#endif
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Runs a specified command for each file in a set of files\n"
"\n"
"FOR %variable IN (set) DO command [parameters]\n"
"\n"
" %variable Specifies a replaceable parameter.\n"
" (set) Specifies a set of one or more files. Wildcards may be used.\n"
" command Specifies the command to carry out for each file.\n"
" parameters Specifies parameters or switches for the specified command.\n"
"\n"
"To user the FOR comamnd in a batch program, specify %%variable instead of\n"
"%variable."));
return 0;
}
/* Check that first element is % then an alpha char followed by space */
if ((*param != _T('%')) || !_istalpha (*(param + 1)) || !_istspace (*(param + 2)))
{
error_syntax (_T("bad variable specification."));
return 1;
}
param++;
var = *param++; /* Save FOR var name */
while (_istspace (*param))
param++;
/* Check next element is 'IN' */
if ((_tcsnicmp (param, _T("in"), 2) != 0) || !_istspace (*(param + 2)))
{
error_syntax (_T("'in' missing in for statement."));
return 1;
}
param += 2;
while (_istspace (*param))
param++;
/* Folowed by a '(', find also matching ')' */
if ((*param != _T('(')) || (NULL == (pp = _tcsrchr (param, _T(')')))))
{
error_syntax (_T("no brackets found."));
return 1;
}
*pp++ = _T('\0');
param++; /* param now points at null terminated list */
while (_istspace (*pp))
pp++;
/* Check DO follows */
if ((_tcsnicmp (pp, _T("do"), 2) != 0) || !_istspace (*(pp + 2)))
{
error_syntax (_T("'do' missing."));
return 1;
}
pp += 2;
while (_istspace (*pp))
pp++;
/* Check that command tail is not empty */
if (*pp == _T('\0'))
{
error_syntax (_T("no command after 'do'."));
return 1;
}
/* OK all is correct, build a bcontext.... */
lpNew = (LPBATCH_CONTEXT)malloc (sizeof (BATCH_CONTEXT));
lpNew->prev = bc;
bc = lpNew;
bc->hBatchFile = INVALID_HANDLE_VALUE;
bc->ffind = NULL;
bc->params = BatchParams (_T(""), param); /* Split out list */
bc->shiftlevel = 0;
bc->forvar = var;
bc->forproto = _tcsdup (pp);
return 0;
}
/* EOF */

View File

@@ -1,165 +0,0 @@
/*
* FREE.C - internal command.
*
*
* History:
*
* 01-Sep-1999 (Eric Kohl)
* Started.
*/
#include "config.h"
#ifdef INCLUDE_CMD_FREE
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "cmd.h"
/*
* convert
*
* insert commas into a number
*/
static INT
ConvertULargeInteger (ULARGE_INTEGER num, LPTSTR des, INT len)
{
TCHAR temp[32];
INT c = 0;
INT n = 0;
if (num.QuadPart == 0)
{
des[0] = _T('0');
des[1] = _T('\0');
n = 1;
}
else
{
temp[31] = 0;
while (num.QuadPart > 0)
{
if (((c + 1) % (nNumberGroups + 1)) == 0)
temp[30 - c++] = cThousandSeparator;
temp[30 - c++] = (TCHAR)(num.QuadPart % 10) + _T('0');
num.QuadPart /= 10;
}
for (n = 0; n <= c; n++)
des[n] = temp[31 - c + n];
}
return n;
}
static VOID
PrintDiskInfo (LPTSTR szDisk)
{
TCHAR szRootPath[4] = "A:\\";
TCHAR szDrive[2] = "A";
TCHAR szVolume[64];
TCHAR szSerial[10];
TCHAR szTotal[40];
TCHAR szUsed[40];
TCHAR szFree[40];
DWORD dwSerial;
ULARGE_INTEGER uliSize;
DWORD dwSecPerCl;
DWORD dwBytPerSec;
DWORD dwFreeCl;
DWORD dwTotCl;
if (_tcslen (szDisk) < 2 || szDisk[1] != _T(':'))
{
ConErrPrintf (_T("Invalid drive %s\n"), szDisk);
return;
}
szRootPath[0] = szDisk[0];
szDrive[0] = _totupper (szRootPath[0]);
if (!GetVolumeInformation (szRootPath, szVolume, 64, &dwSerial,
NULL, NULL, NULL, 0))
{
ConErrPrintf (_T("Invalid drive %s:\n"), szDrive);
return;
}
if (szVolume[0] == _T('\0'))
_tcscpy (szVolume, _T("unlabeled"));
_stprintf (szSerial,
_T("%04X-%04X"),
HIWORD(dwSerial),
LOWORD(dwSerial));
if (!GetDiskFreeSpace (szRootPath, &dwSecPerCl,
&dwBytPerSec, &dwFreeCl, &dwTotCl))
{
ConErrPrintf (_T("Invalid drive %s:\n"), szDrive);
return;
}
uliSize.QuadPart = dwSecPerCl * dwBytPerSec * dwTotCl;
ConvertULargeInteger (uliSize, szTotal, 40);
uliSize.QuadPart = dwSecPerCl * dwBytPerSec * (dwTotCl - dwFreeCl);
ConvertULargeInteger (uliSize, szUsed, 40);
uliSize.QuadPart = dwSecPerCl * dwBytPerSec * dwFreeCl;
ConvertULargeInteger (uliSize, szFree, 40);
ConOutPrintf (_T("\n"
" Volume in drive %s is %-11s Serial number is %s\n"
" %16s bytes total disk space\n"
" %16s bytes used\n"
" %16s bytes free\n"),
szDrive, szVolume, szSerial,
szTotal, szUsed, szFree);
}
INT CommandFree (LPTSTR cmd, LPTSTR param)
{
LPTSTR szParam;
TCHAR szDefPath[MAX_PATH];
INT argc, i;
LPTSTR *arg;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays drive information.\n"
"\n"
"FREE [drive: ...]"));
return 0;
}
if (!param || *param == _T('\0'))
{
GetCurrentDirectory (MAX_PATH, szDefPath);
szDefPath[2] = _T('\0');
szParam = szDefPath;
}
else
szParam = param;
arg = split (szParam, &argc);
for (i = 0; i < argc; i++)
PrintDiskInfo (arg[i]);
freep (arg);
return 0;
}
#endif /* INCLUDE_CMD_FREE */
/* EOF */

View File

@@ -1,109 +0,0 @@
/*
* GOTO.C - goto internal batch command.
*
* History:
*
* 16 Jul 1998 (Hans B Pufal)
* started.
*
* 16 Jul 1998 (John P Price)
* Seperated commands into individual files.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 28 Jul 1998 (Hans B Pufal) [HBP_003]
* Terminate label on first space character, use only first 8 chars of
* label string
*
* 24-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection safe!
*
* 27-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("/?").
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
#include "batch.h"
/*
* Perform GOTO command.
*
* Only valid if batch file current.
*
*/
INT cmd_goto (LPTSTR cmd, LPTSTR param)
{
LPTSTR tmp;
LONG lNewPosHigh;
#ifdef _DEBUG
DebugPrintf ("cmd_goto (\'%s\', \'%s\'\n", cmd, param);
#endif
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Directs CMD to a labeled line in a batch script.\n"
"\n"
"GOTO label\n"
"\n"
" label Specifies a text string used in a batch script as a label.\n"
"\n"
"You type a label on a line by itself, beginning with a colon."));
return 0;
}
/* if not in batch -- error!! */
if (bc == NULL)
{
return 1;
}
if (*param == _T('\0'))
{
ExitBatch (_T("No label specified for GOTO\n"));
return 1;
}
/* terminate label at first space char */
tmp = param;
while (*tmp && !_istspace (*tmp))
tmp++;
*tmp = _T('\0');
/* set file pointer to the beginning of the batch file */
lNewPosHigh = 0;
SetFilePointer (bc->hBatchFile, 0, &lNewPosHigh, FILE_BEGIN);
while (FileGetString (bc->hBatchFile, textline, sizeof(textline)))
{
/* Strip out any trailing spaces or control chars */
tmp = textline + _tcslen (textline) - 1;
while (_istcntrl (*tmp) || _istspace (*tmp))
tmp--;
*(tmp + 1) = _T('\0');
/* Then leading spaces... */
tmp = textline;
while (_istspace (*tmp))
tmp++;
/* use only 1st 8 chars of label */
if ((*tmp == _T(':')) && (_tcsncmp (++tmp, param, 8) == 0))
return 0;
}
ConErrPrintf (_T("Label '%s' not found\n"), param);
ExitBatch (NULL);
return 1;
}

View File

@@ -1,233 +0,0 @@
/* $Id: history.c,v 1.8 1999/12/24 17:19:20 ekohl Exp $
*
* HISTORY.C - command line history.
*
*
* History:
*
* 14/01/95 (Tim Norman)
* started.
*
* 08/08/95 (Matt Rains)
* i have cleaned up the source code. changes now bring this source
* into guidelines for recommended programming practice.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 25-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Cleanup!
* Unicode and redirection safe!
*
* 25-Jan-1999 (Paolo Pantaleo <paolopan@freemail.it>)
* Added lots of comments (beginning studying the source)
* Added command.com's F3 support (see cmdinput.c)
*
*/
/*
* HISTORY.C - command line history. Second version
*
*
* History:
*
* 06/12/99 (Paolo Pantaleo <paolopan@freemail.it>)
* started.
*
*/
#include "config.h"
#ifdef FEATURE_HISTORY
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include "cmd.h"
typedef struct tagHISTORY
{
struct tagHISTORY *prev;
struct tagHISTORY *next;
LPTSTR string;
} HIST_ENTRY, * LPHIST_ENTRY;
static INT size;
static INT max_size=10; /* for now not configurable */
static LPHIST_ENTRY Top;
static LPHIST_ENTRY Bottom;
static LPHIST_ENTRY curr_ptr=0;
/* service functions */
static VOID del (LPHIST_ENTRY item);
static VOID add_at_bottom (LPTSTR string);
VOID InitHistory (VOID)
{
size=0;
Top = malloc(sizeof(HIST_ENTRY));
Bottom = malloc(sizeof(HIST_ENTRY));
Top->prev = Bottom;
Top->next = NULL;
Top->string = NULL;
Bottom->prev = NULL;
Bottom->next = Top;
Bottom->string = NULL;
curr_ptr=Bottom;
}
VOID CleanHistory (VOID)
{
while (Bottom->next!=Top)
del (Bottom->next);
free (Top);
free (Bottom);
}
VOID History_del_current_entry(LPTSTR str)
{
LPHIST_ENTRY tmp;
if (size==0)
return;
if(curr_ptr==Bottom)
curr_ptr=Bottom->next;
if(curr_ptr==Top)
curr_ptr=Top->prev;
tmp=curr_ptr;
curr_ptr=curr_ptr->prev;
del(tmp);
History(-1,str);
}
static
VOID del(LPHIST_ENTRY item)
{
if( item==NULL || item==Top || item==Bottom )
{
#ifdef _DEBUG
DebugPrintf("del in " __FILE__ ": retrning\n"
"item is 0x%08x (Bottom is0x%08x)\n",
item, Bottom);
#endif
return;
}
/*free string's mem*/
if (item->string)
free(item->string);
/*set links in prev and next item*/
item->next->prev=item->prev;
item->prev->next=item->next;
free(item);
size--;
}
static
VOID add_at_bottom(LPTSTR string)
{
LPHIST_ENTRY tmp;
/*delete first entry if maximum number of entries is reached*/
if(size==max_size)
del(Top->prev);
/*fill bottom with string*/
Bottom->string=malloc(_tcslen(string)+1);
_tcscpy(Bottom->string,string);
/*save Bottom value*/
tmp=Bottom;
/*create new void Bottom*/
Bottom=malloc(sizeof(HIST_ENTRY));
Bottom->next=tmp;
Bottom->prev=NULL;
Bottom->string=NULL;
tmp->prev=Bottom;
/*set new size*/
size++;
}
VOID History_move_to_bottom(VOID)
{
curr_ptr=Bottom;
}
VOID History (INT dir, LPTSTR commandline)
{
if(dir==0)
{
add_at_bottom(commandline);
curr_ptr=Bottom;
return;
}
if (size==0)
{
commandline[0]=_T('\0');
return;
}
if(dir<0)/*key up*/
{
if (curr_ptr->next==Top || curr_ptr==Top)
{
#ifdef WRAP_HISTORY
curr_ptr=Bottom;
#else
curr_ptr=Top;
commandline[0]=_T('\0');
return;
#endif
}
curr_ptr = curr_ptr->next;
if(curr_ptr->string)
_tcscpy(commandline,curr_ptr->string);
}
if(dir>0)
{
if (curr_ptr->prev==Bottom || curr_ptr==Bottom)
{
#ifdef WRAP_HISTORY
curr_ptr=Top;
#else
curr_ptr=Bottom;
commandline[0]=_T('\0');
return;
#endif
}
curr_ptr=curr_ptr->prev;
if(curr_ptr->string)
_tcscpy(commandline,curr_ptr->string);
}
}
#endif /* FEATURE_HISTORY */
/* EOF */

View File

@@ -1,359 +0,0 @@
FreeDOS Command Line Interface Development History
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11/11/94 version 0.01
~~~~~~~~~~~~~~~~~~~~~
o initial release.
01/01/95 version 0.10
~~~~~~~~~~~~~~~~~~~~~
o removed some scaffolding.
o modified CD.
o added tab file completion.
o added command line history.
01/15/95 version 0.20
~~~~~~~~~~~~~~~~~~~~~
o formatted all existing source modules.
o added prompt support.
o added drive selection.
o added dir command.
o started this development log.
08/06/95 prerelease of version 0.30
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
o reorganized code into separate source modules.
o added batch processing support (thanks to Evan Jeffrey).
o added exec code (thanks to Steffan Kaiser).
o removed environment handling (thanks again to Steffan Kaiser)
[ 08/08/95 -- Matt Rains ]
o formatted this development log.
o formatted all existing source modules so that they comply with recommended
programming practice.
o added MD command.
o added RD command.
o added VER command.
o replaced CD command.
o modified DIR command.
o DIR now called regardless of other DIR.??? files. this is done because of
exec() problems.
12/10/95 version 0.30
~~~~~~~~~~~~~~~~~~~~~
o used Borland's spawnve to fix exec problem
o fixed CD again so you don't need a space after it
o couple of spelling fixes
12/14/95 version 0.31
~~~~~~~~~~~~~~~~~~~~~
o modified cmdinput.c to work with non-standard screen sizes (see 28.com)
o fixed a bug in history.c that made it not work when you hit the up arrow
on the first line
o fixed DIR to work a little more like MS-DOS's DIR (see internal.c)
o fixed some code in where.c to make things a bit more efficient and nicer
01/06/96 version 0.40 (never released)
~~~~~~~~~~~~~~~~~~~~~
o added redirection and piping support!!! (see redir.c and command.c)
o fixed a stupid pointer problem in where.c that was causing LOTS of
problems in the strangest places...
o added day of the week support to prompt.c (oops, that was already supposed
to be there! :)
o fixed and reorganized the EXEC code!!! Thanks to Svante Frey!
o reorganized command.c and internal.c to handle parsing internal commands
more efficiently and consistently.
o changed the behavior of MD, CD, RD to work without spaces (e.g. CD\DOS)
o small changes here and there to make it work with redirection/piping
(e.g. DIR only pauses if you're not doing redirection)
01/17/96 version 0.50
~~~~~~~~~~~~~~~~~~~~~
Version 0.40 was never released because I was home on Christmas vacation,
and I couldn't upload it. By the time I got back to school, I had the
LOADHIGH patch from Svante Frey, so I decided to jump up to 0.50 without any
release of 0.40... - Tim Norman
o LOADHIGH/LOADFIX/LH support added!!!! Many thanks go to Svante Frey!
o bug fixed in command parsing that didn't handle / switches correctly...
o removed debugging output from history.c
07/26/96 version 0.60
~~~~~~~~~~~~~~~~~~~~~
Lots of internal changes here... Not much added to the interface.
o Changed internals to use first,rest parameters instead of arrays of params
o Fixed some bugs
o Some other things I don't remember :)
07/26/96 version 0.61
~~~~~~~~~~~~~~~~~~~~~
Bugfixes
o Added hook to the PATH command
o Fixed CD.. bug
08/27/96 version 0.70
~~~~~~~~~~~~~~~~~~~~~
Finally added Oliver Mueller's ALIAS command! Also numerous bug fixes.
o Added ALIAS command
o Removed support for - as a switch in LOADHIGH.C
o Bugfixes in BATCH.C. %0 was returning garbage
o Removed lots of unused variables, reducing # of warnings when compiling
o Other miscellaneous code clean-ups
o Changed WHERE.C to use a little less memory
06/14/97 version 0.71
~~~~~~~~~~~~~~~~~~~~~
Lots of bug fixes, plus some additional features.
o New DIR command. Now more like MS-DOS's DIR. /p supported, /s coming soon
o bug fix in internal.c - parse_firstarg
o Rewrote parser in batch.c (Steffan Kaiser)
o Ctrl-Break checking in various places (Steffan Kaiser)
o Error level setting/checking (%? in batch files) (Steffan Kaiser)
o bug fix in cmdinput.c ("%i" on command-line caused weird behavior)
o bug fix in where.c (first item in path wasn't searched)
07/12/97 version 0.72
~~~~~~~~~~~~~~~~~~~~~
More bug fixes and code cleanup
o Rewrote cmdinput.c to be more efficient (Marc Desrochers)
o Added insert/overstrike modes (Marc Desrochers)
o Replaced findxy() with pointers into BIOS (maxx, maxy) (Marc Desrochers)
o Fixed bug that disallowed listing of root directories
o Fixed bug that didn't search the first path (again!)
07/13/97 version 0.72b
~~~~~~~~~~~~~~~~~~~~~~
Disabled a feature that caused a crash on some machines.
o Replaced setcursor calls in cmdinput.c with _setcursortype
o Added dir.c to the distribution (was left out in 0.72)
07/01/98 version 0.73 (Rob Lake)
~~~~~~~~~~~~~~~~~~~~~~
o New DIR commands supported: /S, /B, /L, /A and /W.
(/R changed to /S). Also /? added.
o Supports DIRCMD in environment.
o Supports turning off commands with hyphen (ex. /-S
turns off recursive listing)
o Changed error messages for DIR and DEL to more MS-DOS'ish
o Moved error messages from DIR.C and DEL.C to COMMAND.H
(more may go there soon)
o Fixed bug that caused dir *.ext/X not to work (no spaces
between filespec and slash)
o Added wildcard support for DEL command
o Added prompt and help switch for DEL command, /P and /?
respectively.
o Added support for /C when envoking the shell
o Added /P support when Kernel loads shell. This means
the shell now is permanent and runs the autoexec.bat
(/E is not implemented)
o Added my name (Rob Lake) to the developer listing
o Changed version routine to print out copyright notice
with no args, and with appropriate switches, warranty
and redistribution notices and developer listing
07/08/1998 version 0.74 (John P. Price (linux-guru@gcfl.net))
~~~~~~~~~~~~~~~~~~~~~~~~
COMMAND.C/COMMAND.H:
o Now sets COMSPEC environment variable
o misc clean up and optimization
o added date, time and type commands
o changed to using spawnl instead of exec. exec does not copy the
environment to the child process!
DIR.C
o removed extra returns; closer to MSDOS
o fixed wide display so that an extra return is not displayed when
there is five filenames in the last line.
ENVIRON.C
o commented out show_environment function. Not used anymore.
INTERAL.C
o removed call to show_environment in set command.
o moved test for syntax before allocating memory in set command.
o misc clean up and optimization.
o created DATE.C
o created TIME.C
o created TYPE.C
07/08/1998 version 0.74b (John P. Price (linux-guru@gcfl.net))
~~~~~~~~~~~~~~~~~~~~~~~~
COMMAND.C
o fixed call to spawnl so that it would pass command line arguments
correctly.
07/12/98 version 0.74c (Rob Lake rlake@cs.mun.ca)
~~~~~~~~~~~~~~~~~~~~~~
Various Files:
o removed redundant use of error message defines and moved
error printing calls to ERROR.C to reduced program size.
o created MISC.C
o created ERR_HAND.C/H
o created ERROR.C
07/13/98 version 0.74d (Rob Lake rlake@cs.mun.ca)
~~~~~~~~~~~~~~~~~~~~~~
INTERNAL.C
o removed most of the commands and placed them in there own file
-- del, ren, set and ver
o created DEL.C, REN.C SET.C and VER.C
o fixed bug that caused del not to delete files with no attributes
o the critical error handler count number of times called, autofails
at 5 calls
16 Jul 1998 (Hans B Pufal <hansp@digiweb.com>)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
batch.c
A new version, implements CALL, ECHO, GOT, IF, PAUSE, SHIFT and
BEEP. There is a stub for FOR but that's all.
cmdtable.c
New file to keep the internal command table. I plan on getting rid
of the table real soon now and replacing it with a dynamic
mechanism.
command.c
A new (improved ;) version. Conforms closely to MS-DOS specs.
Cleaned up (and fixed) the redirection handler.
command.h
Version D with changes. Look for the HBP tag.
redir.c
Modified file, now supports append redirects.
16 Jul 1998 (Rob Lake rlake@cs.mun.ca)
~~~~~~~~~~~~~~~~~~~~~~
Added TRUENAME command.
19 Jul 1998 (Hans B Pufal) <hansp@digiweb.com>)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
o Preserve state of echo flag across batch calls.
o Implementation of FOR command
20 Jul 1998 (John P Price <linux-guru@gcfl.net>)
~~~~~~~~~~~~~~~~~~~~~~
o Fixed bug in DATE.C.
o Fixed bug in LH.ASM.
o Separated commands into individual files.
28 Jul 1998 (John P Price <linux-guru@gcfl.net>)
~~~~~~~~~~~~~~~~~~~~~~
o Added CLS command.
o Put ifdef's around all commands and added include file config.h
Now you can define exact what commands you want to include in
command.com.
o Also added ifdefs for optional features: aliases, command history
and filename completion.
o Added display of available internal commands and options at startup.
29 Jul 1998 (Rob Lake rlake@cs.mun.ca)
~~~~~~~~~~~~~~~~~~~~~~
o changed date.c and time.c, and wrote datefunc.c and timefunc.c to
impliment _dos_getdate, _dos_setdate, _dos_gettime and _dos_settime.
This is the first of many steps to make the shell compatible under
Pacific C.
30-Jul-1998 (John P Price <linux-guru@gcfl.net>)
~~~~~~~~~~~~~~~~~~~~~~
o Changed filename completion so that a second TAB displays a list of
matching filenames!
o made filename be lower case if last character typed is lower case.
o Moved filename completion code to filecomp.c.
o Change ver command to display email address to report bugs, and the
web page address for updates.
o fixed so that it find_which returns NULL if filename is not
executable (does not have .bat, .com, or .exe extension). Before
command would to execute any file with any extension. (opps!)
30-Jul-1998 (John P Price <linux-guru@gcfl.net>)
~~~~~~~~~~~~~~~~~~~~~~
o Fixed bug where if you typed something, then hit HOME, then tried to
type something else in insert mode, it locked up.
o Changed default insert mode to on. There should be a way to change
this. Maybe options to doskey command.
o Added VERIFY command
02-Aug-1998 (Hans B Pufal) <hansp@digiweb.com>)
~~~~~~~~~~~~~~~~~~~~~~
o batch.c: Fixed bug in ECHO flag restoration at exit from batch file
o command.c: Fixed return value when called with /C option
o Terminate label on first space character, use only first 8 chars of
label string
04-Aug-1998 (Hans B Pufal) <hansp@digiweb.com>)
~~~~~~~~~~~~~~~~~~~~~~
o call.c: added lines to initialize for pointers. This fixed the
lock-up that happened sometimes when calling a batch file from
another batch file.
07-Aug-1998 (John P Price <linux-guru@gcfl.net>)
~~~~~~~~~~~~~~~~~~~~~~
o Fixed carrage return output to better match MSDOS with echo on or off.
07-Dec-1998 ReactOS CMD version 0.0.1 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
o First test release.
o Added internal ATTRIB command.
11-Dec-1998 ReactOS CMD version 0.0.2 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
o Fixed bug in ALIAS. CMD crashed when you tried to remove an alias.
o Fixed bug in split(). Added freep(). This fixed the DEL command.
o Improved ATTRIB command.
o Added most help texts.
o Fixed recursive DIR ("dir /s").
o Fixed DATE and TIME command. Now they accept values when used
without parameter.
o Implemented LABEL command.
05-Jan-1999 ReactOS CMD version 0.0.3 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
o Added COLOR command and "/t" option.
o Cursor shows insert/overwrite mode.
o COMSPEC environment variable is set upon startup.
o Started COPY command.
o Started MOVE command.
o Added directory stack (PUSHD and POPD commands).
o Added support for file names or paths that contain spaces
(quoted paths / file names).
o Added recursion to ATTRIB command.
o Added locale support for DIR, DATE, TIME and PROMPT.
o Fixed VERIFY.
10-Feb-1999 ReactOS CMD version 0.0.4 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
o "?" lists all available commands.
o Most commands are unicode and redirection aware now.
o Input-, Output- and Error-Redirections works with most commands.
o ATTRIB and DEL can handle multiple filenames now.
o Fixed handling of environment variables.
o Added CHCP command.
o Fixed keyboard input bug.
o Rewrote DEL and MOVE commands.
28-Dec-1999 ReactOS CMD version 0.1 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
o Cleaned up DIR command.
o Searching for executables in the right order.
o Fixed some little but nasty bugs.
o Added TITLE command. Thanks to Emanuele Aliberti!
o Added "/Q", "/W" and "/Z" options to DEL command.
o Added CHOICE, TIMER, FREE and MEMORY commands.
o Added MSGBOX command (not available under ReactOS).
o Added and fixed missing help texts.
o Fixed bugs in MD and RD that crashed cmd when no directory was specified.
o Improved history support.
o Improved COLOR command.

View File

@@ -1,172 +0,0 @@
/*
* IF.C - if internal batch command.
*
*
* History:
*
* 16 Jul 1998 (Hans B Pufal)
* started.
*
* 16 Jul 1998 (John P Price)
* Seperated commands into individual files.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 07-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("if /?") and cleaned up.
*
* 21-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection ready!
*
* 01-Sep-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed help text.
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
#include "batch.h"
#define X_EXEC 1
#define X_EMPTY 0x80
INT cmd_if (LPTSTR cmd, LPTSTR param)
{
INT x_flag = 0; /* when set cause 'then' clause to be executed */
LPTSTR pp;
#ifdef _DEBUG
DebugPrintf ("cmd_if: (\'%s\', \'%s\'\n", cmd, param);
#endif
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Performs conditional processing in batch programs.\n"
"\n"
" IF [NOT] ERRORLEVEL number command\n"
" IF [NOT] string1==string2 command\n"
" IF [NOT] EXIST filename command\n"
"\n"
"NOT Specifies that CMD should carry out the command only if\n"
" the condition is false\n"
"ERRORLEVEL number Specifies a true condition if the last program run returned\n"
" an exit code equal or greater than the number specified.\n"
"command Specifies the command to carry out if the condition is met.\n"
"string1==string2 Specifies a true condition if the specified text strings\n"
" match.\n"
"EXIST filename Specifies a true condition if the specified filename exists."));
return 0;
}
/* First check if param string begins with word 'not' */
if (!_tcsnicmp (param, _T("not"), 3) && _istspace (*(param + 3)))
{
x_flag = X_EXEC; /* Remember 'NOT' */
param += 3; /* Step over 'NOT' */
while (_istspace (*param)) /* And subsequent spaces */
param++;
}
/* Check for 'exist' form */
if (!_tcsnicmp (param, _T("exist"), 5) && _istspace (*(param + 5)))
{
param += 5;
while (_istspace (*param))
param++;
pp = param;
while (*pp && !_istspace (*pp))
pp++;
if (*pp)
{
WIN32_FIND_DATA f;
HANDLE hFind;
*pp++ = _T('\0');
hFind = FindFirstFile (param, &f);
x_flag ^= (hFind != INVALID_HANDLE_VALUE) ? 0 : X_EXEC;
if (hFind != INVALID_HANDLE_VALUE)
FindClose (hFind);
}
else
return 0;
}
/* Check for 'errorlevel' form */
else if (!_tcsnicmp (param, _T("errorlevel"), 10) && _istspace (*(param + 10)))
{
INT n = 0;
pp = param + 10;
while (_istspace (*pp))
pp++;
while (_istdigit (*pp))
n = n * 10 + (*pp++ - _T('0'));
x_flag ^= (nErrorLevel < n) ? 0 : X_EXEC;
x_flag |= X_EMPTY; /* Syntax error if comd empty */
}
/* Check that '==' is present, syntax error if not */
else if (NULL == (pp = _tcsstr (param, _T("=="))))
{
error_syntax (NULL);
return 1;
}
else
{
/* Change first '='to space to terminate comparison loop */
*pp = _T(' '); /* Need a space to terminate comparison loop */
pp += 2; /* over '==' */
while (_istspace (*pp)) /* Skip subsequent spaces */
pp++;
_tcscat (pp, _T(" ")); /* Add one space to ensure comparison ends */
while (*param == *pp) /* Comparison loop */
{
if (_istspace (*param)) /* Terminates on space */
break;
param++, pp++;
}
if (x_flag ^= (*param != *pp) ? 0 : X_EXEC)
{
while (*pp && !_istspace (*pp)) /* Find first space, */
pp++;
x_flag |= X_EMPTY;
}
}
if (x_flag & X_EMPTY)
{
while (_istspace (*pp)) /* Then skip spaces */
pp++;
if (*pp == _T('\0')) /* If nothing left then syntax err */
{
error_syntax (NULL);
return 1;
}
}
if (x_flag & X_EXEC)
ParseCommandLine (pp);
return 0;
}

View File

@@ -1,500 +0,0 @@
/*
* INTERNAL.C - command.com internal commands.
*
*
* History:
*
* 17/08/94 (Tim Norman)
* started.
*
* 08/08/95 (Matt Rains)
* i have cleaned up the source code. changes now bring this source into
* guidelines for recommended programming practice.
*
* cd()
* started.
*
* dir()
* i have added support for file attributes to the DIR() function. the
* routine adds "d" (directory) and "r" (read only) output. files with the
* system attribute have the filename converted to lowercase. files with
* the hidden attribute are not displayed.
*
* i have added support for directorys. now if the directory attribute is
* detected the file size if replaced with the string "<dir>".
*
* ver()
* started.
*
* md()
* started.
*
* rd()
* started.
*
* del()
* started.
*
* does not support wildcard selection.
*
* todo: add delete directory support.
* add recursive directory delete support.
*
* ren()
* started.
*
* does not support wildcard selection.
*
* todo: add rename directory support.
*
* a general structure has been used for the cd, rd and md commands. this
* will be better in the long run. it is too hard to maintain such diverse
* functions when you are involved in a group project like this.
*
* 12/14/95 (Tim Norman)
* fixed DIR so that it will stick \*.* if a directory is specified and
* that it will stick on .* if a file with no extension is specified or
* *.* if it ends in a \
*
* 1/6/96 (Tim Norman)
* added an isatty call to DIR so it won't prompt for keypresses unless
* stdin and stdout are the console.
*
* changed parameters to be mutually consistent to make calling the
* functions easier
*
* rem()
* started.
*
* doskey()
* started.
*
* 01/22/96 (Oliver Mueller)
* error messages are now handled by perror.
*
* 02/05/96 (Tim Norman)
* converted all functions to accept first/rest parameters
*
* 07/26/96 (Tim Norman)
* changed return values to int instead of void
*
* path() started.
*
* 12/23/96 (Aaron Kaufman)
* rewrote dir() to mimic MS-DOS's dir
*
* 01/28/97 (Tim Norman)
* cleaned up Aaron's DIR code
*
* 06/13/97 (Tim Norman)
* moved DIR code to dir.c
* re-implemented Aaron's DIR code
*
* 06/14/97 (Steffan Kaiser)
* ctrl-break handling
* bug fixes
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 03-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Replaced DOS calls by Win32 calls.
*
* 08-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help texts ("/?").
*
* 18-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added support for quoted arguments (cd "program files").
*
* 07-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Clean up.
*
* 26-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Replaced remaining CRT io functions by Win32 io functions.
* Unicode safe!
*
* 30-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added "cd -" feature. Changes to the previous directory.
*
* 15-Mar-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed bug in "cd -" feature. If the previous directory was a root
* directory, it was ignored.
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "cmd.h"
extern COMMAND cmds[]; /* The internal command table, used in '?' */
#ifdef INCLUDE_CMD_CHDIR
static LPTSTR lpLastPath;
VOID InitLastPath (VOID)
{
lpLastPath = NULL;
}
VOID FreeLastPath (VOID)
{
if (lpLastPath)
free (lpLastPath);
}
/*
* CD / CHDIR
*
*/
INT cmd_chdir (LPTSTR cmd, LPTSTR param)
{
LPTSTR dir; /* pointer to the directory to change to */
LPTSTR place; /* used to search for the \ when no space is used */
LPTSTR lpOldPath;
LPTSTR *arg = NULL;
INT argc;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Changes the current directory or displays it's name\n\n"
"CHDIR [drive:][path]\n"
"CHDIR[..|-]\n"
"CD [drive:][path]\n"
"CD[..|-]\n\n"
" .. parent directory\n"
" - previous directory\n\n"
"Type CD drive: to display the current directory on the specified drive.\n"
"Type CD without a parameter to display the current drive and directory."));
return 0;
}
/* check if there is no space between the command and the path */
if (param[0] == _T('\0'))
{
/* search for the '\', '.' or '-' so that both short & long names will work */
for (place = cmd; *place; place++)
if (*place == _T('.') || *place == _T('\\') || *place == _T('-'))
break;
if (*place)
dir = place;
else
/* signal that there are no parameters */
dir = NULL;
}
else
{
arg = split (param, &argc);
if (argc > 1)
{
/*JPP 20-Jul-1998 use standard error message */
error_too_many_parameters (param);
freep (arg);
return 1;
}
else
dir = arg[0];
}
/* if doing a CD and no parameters given, print out current directory */
if (!dir || !dir[0])
{
TCHAR szPath[MAX_PATH];
GetCurrentDirectory (MAX_PATH, szPath);
ConOutPuts (szPath);
freep (arg);
return 0;
}
if (dir && _tcslen (dir) == 1 && *dir == _T('-'))
{
if (lpLastPath)
dir = lpLastPath;
else
{
freep (arg);
return 0;
}
}
else if (dir && _tcslen (dir) > 1 && dir[1] == _T(':'))
{
TCHAR szRoot[3] = _T("A:");
TCHAR szPath[MAX_PATH];
szRoot[0] = _totupper (dir[0]);
GetFullPathName (szRoot, MAX_PATH, szPath, NULL);
/* PathRemoveBackslash */
if (_tcslen (szPath) > 3)
{
LPTSTR p = _tcsrchr (szPath, _T('\\'));
*p = _T('\0');
}
ConOutPuts (szPath);
freep (arg);
return 0;
}
/* remove trailing \ if any, but ONLY if dir is not the root dir */
if (_tcslen (dir) > 3 && dir[_tcslen (dir) - 1] == _T('\\'))
dir[_tcslen(dir) - 1] = _T('\0');
/* store current directory */
lpOldPath = (LPTSTR)malloc (MAX_PATH * sizeof(TCHAR));
GetCurrentDirectory (MAX_PATH, lpOldPath);
if (!SetCurrentDirectory (dir))
{
ErrorMessage (GetLastError(), _T("CD"));
/* throw away current directory */
free (lpOldPath);
lpOldPath = NULL;
freep (arg);
return 1;
}
else
{
if (lpLastPath)
free (lpLastPath);
lpLastPath = lpOldPath;
}
freep (arg);
return 0;
}
#endif
#ifdef INCLUDE_CMD_MKDIR
/*
* MD / MKDIR
*
*/
INT cmd_mkdir (LPTSTR cmd, LPTSTR param)
{
LPTSTR dir; /* pointer to the directory to change to */
LPTSTR place; /* used to search for the \ when no space is used */
LPTSTR *p = NULL;
INT argc;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Creates a directory.\n\n"
"MKDIR [drive:]path\nMD [drive:]path"));
return 0;
}
/* check if there is no space between the command and the path */
if (param[0] == _T('\0'))
{
/* search for the \ or . so that both short & long names will work */
for (place = cmd; *place; place++)
if (*place == _T('.') || *place == _T('\\'))
break;
if (*place)
dir = place;
else
/* signal that there are no parameters */
dir = NULL;
}
else
{
p = split (param, &argc);
if (argc > 1)
{
/*JPP 20-Jul-1998 use standard error message */
error_too_many_parameters (param);
freep (p);
return 1;
}
else
dir = p[0];
}
if (!dir)
{
ConErrPrintf (_T("Required parameter missing\n"));
return 1;
}
/* remove trailing \ if any, but ONLY if dir is not the root dir */
if (_tcslen (dir) >= 2 && dir[_tcslen (dir) - 1] == _T('\\'))
dir[_tcslen(dir) - 1] = _T('\0');
if (!CreateDirectory (dir, NULL))
{
ErrorMessage (GetLastError(), _T("MD"));
freep (p);
return 1;
}
freep (p);
return 0;
}
#endif
#ifdef INCLUDE_CMD_RMDIR
/*
* RD / RMDIR
*
*/
INT cmd_rmdir (LPTSTR cmd, LPTSTR param)
{
LPTSTR dir; /* pointer to the directory to change to */
LPTSTR place; /* used to search for the \ when no space is used */
LPTSTR *p = NULL;
INT argc;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Removes a directory.\n\n"
"RMDIR [drive:]path\nRD [drive:]path"));
return 0;
}
/* check if there is no space between the command and the path */
if (param[0] == _T('\0'))
{
/* search for the \ or . so that both short & long names will work */
for (place = cmd; *place; place++)
if (*place == _T('.') || *place == _T('\\'))
break;
if (*place)
dir = place;
else
/* signal that there are no parameters */
dir = NULL;
}
else
{
p = split (param, &argc);
if (argc > 1)
{
/*JPP 20-Jul-1998 use standard error message */
error_too_many_parameters (param);
freep (p);
return 1;
}
else
dir = p[0];
}
if (!dir)
{
ConErrPrintf (_T("Required parameter missing\n"));
return 1;
}
/* remove trailing \ if any, but ONLY if dir is not the root dir */
if (_tcslen (dir) >= 2 && dir[_tcslen (dir) - 1] == _T('\\'))
dir[_tcslen(dir) - 1] = _T('\0');
if (!RemoveDirectory (dir))
{
ErrorMessage (GetLastError(), _T("RD"));
freep (p);
return 1;
}
freep (p);
return 0;
}
#endif
/*
* set the exitflag to true
*
*/
INT CommandExit (LPTSTR cmd, LPTSTR param)
{
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Exits the command line interpreter.\n\nEXIT"));
return 0;
}
bExit = TRUE;
return 0;
}
#ifdef INCLUDE_CMD_REM
/*
* does nothing
*
*/
INT CommandRem (LPTSTR cmd, LPTSTR param)
{
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Starts a comment line in a batch file.\n\n"
"REM [Comment]"));
}
return 0;
}
#endif /* INCLUDE_CMD_REM */
INT CommandShowCommands (LPTSTR cmd, LPTSTR param)
{
LPCOMMAND cmdptr;
INT y;
y = 0;
cmdptr = cmds;
while (cmdptr->name)
{
if (++y == 8)
{
ConOutPuts (cmdptr->name);
y = 0;
}
else
ConOutPrintf (_T("%-10s"), cmdptr->name);
cmdptr++;
}
if (y != 0)
ConOutChar (_T('\n'));
return 0;
}
/* EOF */

View File

@@ -1,120 +0,0 @@
/*
* LABEL.C - label internal command.
*
*
* History:
*
* 10-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Started.
*
* 11-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Finished.
*
* 19-Jan-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode ready!
*/
#include "config.h"
#ifdef INCLUDE_CMD_LABEL
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
INT cmd_label (LPTSTR cmd, LPTSTR param)
{
TCHAR szRootPath[] = _T("A:\\");
TCHAR szLabel[80];
TCHAR szOldLabel[80];
DWORD dwSerialNr;
LPTSTR *arg;
INT args;
/* set empty label string */
szLabel[0] = _T('\0');
/* print help */
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays or changes drive label.\n\n"
"LABEL [drive:][label]"));
return 0;
}
/* get parameters */
arg = split (param, &args);
if (args > 2)
{
/* too many parameters */
error_too_many_parameters (arg[args - 1]);
freep (arg);
return 1;
}
if (args == 0)
{
/* get label of current drive */
TCHAR szCurPath[MAX_PATH];
GetCurrentDirectory (MAX_PATH, szCurPath);
szRootPath[0] = szCurPath[0];
}
else
{
if ((_tcslen (arg[0]) >= 2) && (arg[0][1] == _T(':')))
{
szRootPath[0] = toupper (*arg[0]);
if (args == 2)
_tcsncpy (szLabel, arg[1], 12);
}
else
{
TCHAR szCurPath[MAX_PATH];
GetCurrentDirectory (MAX_PATH, szCurPath);
szRootPath[0] = szCurPath[0];
_tcsncpy (szLabel, arg[0], 12);
}
}
/* check root path */
if (!IsValidPathName (szRootPath))
{
error_invalid_drive ();
freep (arg);
return 1;
}
GetVolumeInformation (szRootPath, szOldLabel, 80, &dwSerialNr,
NULL, NULL, NULL, 0);
/* print drive info */
ConOutPrintf (_T("Volume in drive %c:"), _totupper (szRootPath[0]));
if (szOldLabel[0] != _T('\0'))
ConOutPrintf (_T(" is %s\n"), szOldLabel);
else
ConOutPrintf (_T(" has no label\n"));
/* print the volume serial number */
ConOutPrintf (_T("Volume Serial Number is %04X-%04X\n"),
HIWORD(dwSerialNr), LOWORD(dwSerialNr));
if (szLabel[0] == _T('\0'))
{
ConOutPrintf (_T("Drive label (11 Characters, ENTER if none)? "));
ConInString (szLabel, 80);
}
SetVolumeLabel (szRootPath, szLabel);
freep (arg);
return 0;
}
#endif /* INCLUDE_CMD_LABEL */

View File

@@ -1,342 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) 19yy <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

View File

@@ -1,184 +0,0 @@
/*
* LOCALE.C - locale handling.
*
*
* History:
*
* 09-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Started.
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode safe!
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include "cmd.h"
TCHAR cDateSeparator;
TCHAR cTimeSeparator;
TCHAR cThousandSeparator;
TCHAR cDecimalSeparator;
INT nDateFormat;
INT nTimeFormat;
TCHAR aszDayNames[7][8];
INT nNumberGroups;
VOID InitLocale (VOID)
{
#ifdef LOCALE_WINDOWS
TCHAR szBuffer[256];
INT i;
/* date settings */
GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_SDATE, szBuffer, 256);
CharToOem (szBuffer, szBuffer);
cDateSeparator = szBuffer[0];
GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_IDATE, szBuffer, 256);
nDateFormat = _ttoi (szBuffer);
/* time settings */
GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_STIME, szBuffer, 256);
CharToOem (szBuffer, szBuffer);
cTimeSeparator = szBuffer[0];
GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_ITIME, szBuffer, 256);
nTimeFormat = _ttoi (szBuffer);
/* number settings */
GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, szBuffer, 256);
CharToOem (szBuffer, szBuffer);
cThousandSeparator = szBuffer[0];
GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, szBuffer, 256);
CharToOem (szBuffer, szBuffer);
cDecimalSeparator = szBuffer[0];
GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_SGROUPING, szBuffer, 256);
nNumberGroups = _ttoi (szBuffer);
/* days of week */
for (i = 0; i < 7; i++)
{
GetLocaleInfo (LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1 + i, szBuffer, 256);
CharToOem (szBuffer, szBuffer);
_tcscpy (aszDayNames[(i+1)%7], szBuffer); /* little hack */
}
#endif
#ifdef LOCALE_GERMAN
LPTSTR names [7] = {_T("So"), _T("Mo"), _T("Di"), _T("Mi"), _T("Do"), _T("Fr"), _T("Sa")};
INT i;
/* date settings */
cDateSeparator = '.';
nDateFormat = 1; /* ddmmyy */
/* time settings */
cTimeSeparator = ':';
nTimeFormat = 1; /* 24 hour */
/* number settings */
cThousandSeparator = '.';
cDecimalSeparator = ',';
nNumberGroups = 3;
/* days of week */
for (i = 0; i < 7; i++)
_tcscpy (aszDayNames[i], names[i]);
#endif
#ifdef LOCALE_DEFAULT
LPTSTR names [7] = {_T("Sun"), _T("Mon"), _T("Tue"), _T("Wed"), _T("Thu"), _T("Fri"), _T("Sat")};
INT i;
/* date settings */
cDateSeparator = '-';
nDateFormat = 0; /* mmddyy */
/* time settings */
cTimeSeparator = ':';
nTimeFormat = 0; /* 12 hour */
/* number settings */
cThousandSeparator = ',';
cDecimalSeparator = '.';
nNumberGroups = 3;
/* days of week */
for (i = 0; i < 7; i++)
_tcscpy (aszDayNames[i], names[i]);
#endif
}
VOID PrintDate (VOID)
{
#ifdef __REACTOS__
SYSTEMTIME st;
GetLocalTime (&st);
switch (nDateFormat)
{
case 0: /* mmddyy */
default:
ConOutPrintf (_T("%s %02d%c%02d%c%04d"),
aszDayNames[st.wDayOfWeek], st.wMonth, cDateSeparator, st.wDay, cDateSeparator, st.wYear);
break;
case 1: /* ddmmyy */
ConOutPrintf (_T("%s %02d%c%02d%c%04d"),
aszDayNames[st.wDayOfWeek], st.wDay, cDateSeparator, st.wMonth, cDateSeparator, st.wYear);
break;
case 2: /* yymmdd */
ConOutPrintf (_T("%s %04d%c%02d%c%02d"),
aszDayNames[st.wDayOfWeek], st.wYear, cDateSeparator, st.wMonth, cDateSeparator, st.wDay);
break;
}
#else
TCHAR szDate[32];
GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL,
szDate, sizeof (szDate));
ConOutPrintf (_T("%s"), szDate);
#endif
}
VOID PrintTime (VOID)
{
#ifdef __REACTOS__
SYSTEMTIME st;
GetLocalTime (&st);
switch (nTimeFormat)
{
case 0: /* 12 hour format */
default:
ConOutPrintf (_T("Current time is %2d%c%02d%c%02d%c%02d%c\n"),
(st.wHour == 0 ? 12 : (st.wHour <= 12 ? st.wHour : st.wHour - 12)),
cTimeSeparator, st.wMinute, cTimeSeparator, st.wSecond, cDecimalSeparator,
st.wMilliseconds / 10, (st.wHour <= 11 ? 'a' : 'p'));
break;
case 1: /* 24 hour format */
ConOutPrintf (_T("Current time is %2d%c%02d%c%02d%c%02d\n"),
st.wHour, cTimeSeparator, st.wMinute, cTimeSeparator,
st.wSecond, cDecimalSeparator, st.wMilliseconds / 10);
break;
}
#else
TCHAR szTime[32];
GetTimeFormat (LOCALE_USER_DEFAULT, 0, NULL, NULL,
szTime, sizeof (szTime));
ConOutPrintf (_T("Current time is: %s\n"), szTime);
#endif
}

View File

@@ -1,54 +0,0 @@
#
# ReactOS makefile for CMD
#
TARGET=cmd.exe
all: $(TARGET)
OBJECTS = cmd.o attrib.o alias.o batch.o beep.o call.o chcp.o choice.o \
cls.o cmdinput.o cmdtable.o color.o console.o copy.o date.o del.o \
delay.o dir.o dirstack.o echo.o error.o filecomp.o for.o free.o \
goto.o history.o if.o internal.o label.o locale.o memory.o misc.o \
move.o msgbox.o path.o pause.o prompt.o redir.o ren.o screen.o \
set.o shift.o start.o strtoclr.o time.o timer.o title.o type.o \
ver.o verify.o vol.o where.o window.o cmd.coff
CLEAN_FILES = *.o cmd.exe cmd.sym cmd.coff
cmd.exe: $(OBJECTS)
$(CC) $(OBJECTS) -lkernel32 -lcrtdll -luser32 -o cmd.exe
$(NM) --numeric-sort cmd.exe > cmd.sym
clean: $(CLEAN_FILES:%=%_clean)
$(CLEAN_FILES:%=%_clean): %_clean:
- $(RM) $*
.phony: clean $(CLEAN_FILES:%=%_clean)
floppy: $(TARGET:%=$(FLOPPY_DIR)/apps/%)
$(TARGET:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* $(FLOPPY_DIR)\apps\$*
else
$(CP) $* $(FLOPPY_DIR)/apps/$*
endif
dist: $(TARGET:%=../$(DIST_DIR)/apps/%)
$(TARGET:%=../$(DIST_DIR)/apps/%): ../$(DIST_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* ..\$(DIST_DIR)\apps\$*
else
$(CP) $* ../$(DIST_DIR)/apps\$*
endif
include ../rules.mak
# EOF

View File

@@ -1,76 +0,0 @@
# ReactOS cmd.exe makefile for lcc-win32
# 19990119 Emanuele Aliberti <ea@iol.it>
# 19990127 EA
# 19990128 Eric Kohl <ekohl@abo.rhein-zeitung.de>
# Modified for cmd 0.0.4pre3.
#
# ReactOS : http://www.reactos.com
# Lcc-Win32: http://www.cs.virginia.edu/*lcc-win32
#
TARGET=cmd
CC=lcc.exe
CFLAGS=-c -O
LD=lcclnk.exe
LFLAGS=-subsystem console -s -o $(TARGET).exe
OBJS=alias.obj \
attrib.obj \
batch.obj \
beep.obj \
call.obj \
chcp.obj \
choice.obj \
cls.obj \
cmd.obj \
cmdinput.obj \
cmdtable.obj \
color.obj \
console.obj \
copy.obj \
date.obj \
del.obj \
delay.obj \
dir.obj \
dirstack.obj \
echo.obj \
error.obj \
filecomp.obj \
for.obj \
free.obj \
goto.obj \
history.obj \
if.obj \
internal.obj \
label.obj \
locale.obj \
memory.obj \
misc.obj \
move.obj \
msgbox.obj \
path.obj \
pause.obj \
prompt.obj \
redir.obj \
ren.obj \
screen.obj \
set.obj \
shift.obj \
start.obj \
time.obj \
timer.obj \
title.obj \
type.obj \
ver.obj \
verify.obj \
vol.obj \
where.obj
# MAIN
.c.obj:
$(CC) $(CFLAGS) $<
$(TARGET).exe: $(OBJS)
$(LD) $(LFLAGS) $(OBJS)
#EOF

View File

@@ -1,110 +0,0 @@
/*
* MEMORY.C - internal command.
*
*
* History:
*
* 01-Sep-1999 (Eric Kohl)
* Started.
*/
#include "config.h"
#ifdef INCLUDE_CMD_MEMORY
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
/*
* convert
*
* insert commas into a number
*/
static INT
ConvertDWord (DWORD num, LPTSTR des, INT len, BOOL bSeparator)
{
TCHAR temp[32];
INT c = 0;
INT n = 0;
if (num == 0)
{
des[0] = _T('0');
des[1] = _T('\0');
n = 1;
}
else
{
temp[31] = 0;
while (num > 0)
{
if (bSeparator && (((c + 1) % (nNumberGroups + 1)) == 0))
temp[30 - c++] = cThousandSeparator;
temp[30 - c++] = (TCHAR)(num % 10) + _T('0');
num /= 10;
}
for (n = 0; n <= c; n++)
des[n] = temp[31 - c + n];
}
return n;
}
INT CommandMemory (LPTSTR cmd, LPTSTR param)
{
MEMORYSTATUS ms;
TCHAR szMemoryLoad[20];
TCHAR szTotalPhys[20];
TCHAR szAvailPhys[20];
TCHAR szTotalPageFile[20];
TCHAR szAvailPageFile[20];
TCHAR szTotalVirtual[20];
TCHAR szAvailVirtual[20];
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays the amount of system memory.\n"
"\n"
"MEMORY"));
return 0;
}
ms.dwLength = sizeof(MEMORYSTATUS);
GlobalMemoryStatus (&ms);
ConvertDWord (ms.dwMemoryLoad, szMemoryLoad, 20, FALSE);
ConvertDWord (ms.dwTotalPhys, szTotalPhys, 20, TRUE);
ConvertDWord (ms.dwAvailPhys, szAvailPhys, 20, TRUE);
ConvertDWord (ms.dwTotalPageFile, szTotalPageFile, 20, TRUE);
ConvertDWord (ms.dwAvailPageFile, szAvailPageFile, 20, TRUE);
ConvertDWord (ms.dwTotalVirtual, szTotalVirtual, 20, TRUE);
ConvertDWord (ms.dwAvailVirtual, szAvailVirtual, 20, TRUE);
ConOutPrintf (_T("\n"
" %12s%% memory load.\n"
"\n"
" %13s bytes total physical RAM.\n"
" %13s bytes available physical RAM.\n"
"\n"
" %13s bytes total page file.\n"
" %13s bytes available page file.\n"
"\n"
" %13s bytes total virtual memory.\n"
" %13s bytes available virtual memory.\n"),
szMemoryLoad, szTotalPhys, szAvailPhys, szTotalPageFile,
szAvailPageFile, szTotalVirtual, szAvailVirtual);
return 0;
}
#endif /* INCLUDE_CMD_MEMORY */
/* EOF */

View File

@@ -1,502 +0,0 @@
/*
* MISC.C - misc. functions.
*
*
* History:
*
* 07/12/98 (Rob Lake)
* started
*
* 07/13/98 (Rob Lake)
* moved functions in here
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 18-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Changed split() to accept quoted arguments.
* Removed parse_firstarg().
*
* 23-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed an ugly bug in split(). In rare cases (last character
* of the string is a space) it ignored the NULL character and
* tried to add the following to the argument list.
*
* 28-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* FileGetString() seems to be working now.
*
* 06-Nov-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added PagePrompt() and FilePrompt().
*/
#include "config.h"
#include <windows.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
//#include <stdarg.h>
#include <stdio.h>
#include <tchar.h>
#include "cmd.h"
/*
* get a character out-of-band and honor Ctrl-Break characters
*/
TCHAR cgetchar (VOID)
{
HANDLE hInput = GetStdHandle (STD_INPUT_HANDLE);
INPUT_RECORD irBuffer;
DWORD dwRead;
do
{
ReadConsoleInput (hInput, &irBuffer, 1, &dwRead);
if ((irBuffer.EventType == KEY_EVENT) &&
(irBuffer.Event.KeyEvent.bKeyDown == TRUE))
{
if ((irBuffer.Event.KeyEvent.dwControlKeyState &
(LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) &
(irBuffer.Event.KeyEvent.wVirtualKeyCode == 'C'))
bCtrlBreak = TRUE;
break;
}
}
while (TRUE);
#ifndef _UNICODE
return irBuffer.Event.KeyEvent.uChar.AsciiChar;
#else
return irBuffer.Event.KeyEvent.uChar.UnicodeChar;
#endif /* _UNICODE */
}
/*
* Check if Ctrl-Break was pressed during the last calls
*/
BOOL CheckCtrlBreak (INT mode)
{
static BOOL bLeaveAll = FALSE; /* leave all batch files */
TCHAR c;
switch (mode)
{
case BREAK_OUTOFBATCH:
bLeaveAll = 0;
return FALSE;
case BREAK_BATCHFILE:
if (bLeaveAll)
return TRUE;
if (!bCtrlBreak)
return FALSE;
/* we need to be sure the string arrives on the screen! */
do
ConOutPuts (_T("\r\nCtrl-Break pressed. Cancel batch file? (Yes/No/All) "));
while (!_tcschr ("YNA\3", c = _totupper (cgetchar())) || !c);
ConOutPuts (_T("\r\n"));
if (c == _T('N'))
return bCtrlBreak = FALSE; /* ignore */
/* leave all batch files */
bLeaveAll = ((c == _T('A')) || (c == _T('\3')));
break;
case BREAK_INPUT:
if (!bCtrlBreak)
return FALSE;
break;
}
/* state processed */
bCtrlBreak = FALSE;
return TRUE;
}
/*
* split - splits a line up into separate arguments, deliminators
* are spaces and slashes ('/').
*/
LPTSTR *split (LPTSTR s, LPINT args)
{
LPTSTR *arg;
LPTSTR *p;
LPTSTR start;
LPTSTR q;
INT ac;
INT len;
BOOL bQuoted = FALSE;
arg = malloc (sizeof (LPTSTR));
if (!arg)
return NULL;
*arg = NULL;
ac = 0;
while (*s)
{
/* skip leading spaces */
while (*s && (_istspace (*s) || _istcntrl (*s)))
++s;
/* if quote (") then set bQuoted */
if (*s == _T('\"'))
{
++s;
bQuoted = TRUE;
}
start = s;
/* the first character can be '/' */
if (*s == _T('/'))
++s;
/* skip to next word delimiter or start of next option */
if (bQuoted)
{
while (_istprint (*s) && (*s != _T('\"')) && (*s != _T('/')))
++s;
}
else
{
while (_istprint (*s) && !_istspace (*s) && (*s != _T('/')))
++s;
}
/* a word was found */
if (s != start)
{
/* add new entry for new argument */
arg = realloc (p = arg, (ac + 2) * sizeof (LPTSTR));
if (!arg)
{
freep (p);
return NULL;
}
/* create new entry */
q = arg[ac] = malloc (((len = s - start) + 1) * sizeof (TCHAR));
arg[++ac] = NULL;
if (!q)
{
freep (arg);
return NULL;
}
memcpy (q, start, len * sizeof (TCHAR));
q[len] = _T('\0');
}
/* adjust string pointer if quoted (") */
if (bQuoted)
{
++s;
bQuoted = FALSE;
}
}
*args = ac;
return arg;
}
/*
* freep -- frees memory used for a call to split
*
*/
VOID freep (LPTSTR *p)
{
LPTSTR *q;
if (!p)
return;
q = p;
while (*q)
free(*q++);
free(p);
}
LPTSTR stpcpy (LPTSTR dest, LPTSTR src)
{
_tcscpy (dest, src);
return (dest + _tcslen (src));
}
/*
* Checks if a path is valid (accessible)
*/
BOOL IsValidPathName (LPCTSTR pszPath)
{
TCHAR szOldPath[MAX_PATH];
BOOL bResult;
GetCurrentDirectory (MAX_PATH, szOldPath);
bResult = SetCurrentDirectory (pszPath);
SetCurrentDirectory (szOldPath);
return bResult;
}
/*
* Checks if a file exists (accessible)
*/
BOOL IsValidFileName (LPCTSTR pszPath)
{
return (GetFileAttributes (pszPath) != 0xFFFFFFFF);
}
BOOL IsValidDirectory (LPCTSTR pszPath)
{
return (GetFileAttributes (pszPath) & FILE_ATTRIBUTE_DIRECTORY);
}
BOOL FileGetString (HANDLE hFile, LPTSTR lpBuffer, INT nBufferLength)
{
LPTSTR lpString;
TCHAR ch;
DWORD dwRead;
lpString = lpBuffer;
while ((--nBufferLength > 0) &&
ReadFile(hFile, &ch, 1, &dwRead, NULL) && dwRead)
{
if (ch == _T('\r'))
{
/* overread '\n' */
ReadFile (hFile, &ch, 1, &dwRead, NULL);
break;
}
*lpString++ = ch;
}
if (!dwRead && lpString == lpBuffer)
return FALSE;
*lpString++ = _T('\0');
return TRUE;
}
#ifndef __REACTOS__
/*
* GetConsoleWindow - returns the handle to the current console window
*/
HWND GetConsoleWindow (VOID)
{
TCHAR original[256];
TCHAR temp[256];
HWND h=0;
if(h)
return h;
GetConsoleTitle (original, sizeof(original));
_tcscpy (temp, original);
_tcscat (temp, _T("-xxx "));
if (FindWindow (0, temp) == NULL )
{
SetConsoleTitle (temp);
Sleep (0);
while(!(h = FindWindow (0, temp)))
;
SetConsoleTitle (original);
}
return h;
}
#endif
INT PagePrompt (VOID)
{
INPUT_RECORD ir;
ConOutPrintf ("Press a key to continue...\n");
RemoveBreakHandler ();
ConInDisable ();
do
{
ConInKey (&ir);
}
while ((ir.Event.KeyEvent.wVirtualKeyCode == VK_SHIFT) ||
(ir.Event.KeyEvent.wVirtualKeyCode == VK_MENU) ||
(ir.Event.KeyEvent.wVirtualKeyCode == VK_CONTROL));
AddBreakHandler ();
ConInEnable ();
if ((ir.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE) ||
((ir.Event.KeyEvent.wVirtualKeyCode == 'C') &&
(ir.Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))))
return PROMPT_BREAK;
return PROMPT_YES;
}
INT FilePromptYN (LPTSTR szFormat, ...)
{
TCHAR szOut[512];
va_list arg_ptr;
// TCHAR cKey = 0;
// LPTSTR szKeys = _T("yna");
TCHAR szIn[10];
LPTSTR p;
va_start (arg_ptr, szFormat);
_vstprintf (szOut, szFormat, arg_ptr);
va_end (arg_ptr);
ConOutPrintf (szFormat);
/* preliminary fix */
ConInString (szIn, 10);
ConOutPrintf (_T("\n"));
_tcsupr (szIn);
for (p = szIn; _istspace (*p); p++)
;
if (*p == _T('Y'))
return PROMPT_YES;
else if (*p == _T('N'))
return PROMPT_NO;
#if 0
else if (*p == _T('\03'))
return PROMPT_BREAK;
#endif
return PROMPT_NO;
/* unfinished sollution */
#if 0
RemoveBreakHandler ();
ConInDisable ();
do
{
ConInKey (&ir);
cKey = _totlower (ir.Event.KeyEvent.uChar.AsciiChar);
if (_tcschr (szKeys, cKey[0]) == NULL)
cKey = 0;
}
while ((ir.Event.KeyEvent.wVirtualKeyCode == VK_SHIFT) ||
(ir.Event.KeyEvent.wVirtualKeyCode == VK_MENU) ||
(ir.Event.KeyEvent.wVirtualKeyCode == VK_CONTROL));
AddBreakHandler ();
ConInEnable ();
if ((ir.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE) ||
((ir.Event.KeyEvent.wVirtualKeyCode == 'C') &&
(ir.Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))))
return PROMPT_BREAK;
return PROMPT_YES;
#endif
}
INT FilePromptYNA (LPTSTR szFormat, ...)
{
TCHAR szOut[512];
va_list arg_ptr;
// TCHAR cKey = 0;
// LPTSTR szKeys = _T("yna");
TCHAR szIn[10];
LPTSTR p;
va_start (arg_ptr, szFormat);
_vstprintf (szOut, szFormat, arg_ptr);
va_end (arg_ptr);
ConOutPrintf (szFormat);
/* preliminary fix */
ConInString (szIn, 10);
ConOutPrintf (_T("\n"));
_tcsupr (szIn);
for (p = szIn; _istspace (*p); p++)
;
if (*p == _T('Y'))
return PROMPT_YES;
else if (*p == _T('N'))
return PROMPT_NO;
if (*p == _T('A'))
return PROMPT_ALL;
#if 0
else if (*p == _T('\03'))
return PROMPT_BREAK;
#endif
return PROMPT_NO;
/* unfinished sollution */
#if 0
RemoveBreakHandler ();
ConInDisable ();
do
{
ConInKey (&ir);
cKey = _totlower (ir.Event.KeyEvent.uChar.AsciiChar);
if (_tcschr (szKeys, cKey[0]) == NULL)
cKey = 0;
}
while ((ir.Event.KeyEvent.wVirtualKeyCode == VK_SHIFT) ||
(ir.Event.KeyEvent.wVirtualKeyCode == VK_MENU) ||
(ir.Event.KeyEvent.wVirtualKeyCode == VK_CONTROL));
AddBreakHandler ();
ConInEnable ();
if ((ir.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE) ||
((ir.Event.KeyEvent.wVirtualKeyCode == 'C') &&
(ir.Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))))
return PROMPT_BREAK;
return PROMPT_YES;
#endif
}
/* EOF */

View File

@@ -1,265 +0,0 @@
/*
* MOVE.C - move internal command.
*
*
* History:
*
* 14-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Started.
*
* 18-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode safe!
* Preliminary version!!!
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Redirection safe!
*
* 27-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("/?").
* Added more error checks.
*
* 03-Feb-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added "/N" option.
*/
#include "config.h"
#ifdef INCLUDE_CMD_MOVE
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
#define OVERWRITE_NO 0
#define OVERWRITE_YES 1
#define OVERWRITE_ALL 2
#define OVERWRITE_CANCEL 3
static INT Overwrite (LPTSTR fn)
{
TCHAR inp[10];
LPTSTR p;
ConOutPrintf (_T("Overwrite %s (Yes/No/All)? "), fn);
ConInString (inp, 10);
_tcsupr (inp);
for (p=inp; _istspace (*p); p++)
;
if (*p != _T('Y') && *p != _T('A'))
return OVERWRITE_NO;
if (*p == _T('A'))
return OVERWRITE_ALL;
return OVERWRITE_YES;
}
INT cmd_move (LPTSTR cmd, LPTSTR param)
{
LPTSTR *arg;
INT argc, i, nFiles;
TCHAR szDestPath[MAX_PATH];
TCHAR szSrcPath[MAX_PATH];
BOOL bPrompt = TRUE;
LPTSTR p;
WIN32_FIND_DATA findBuffer;
HANDLE hFile;
LPTSTR pszFile;
BOOL bNothing = FALSE;
if (!_tcsncmp (param, _T("/?"), 2))
{
#if 0
ConOutPuts (_T("Moves files and renames files and directories.\n\n"
"To move one or more files:\n"
"MOVE [/N][/Y|/-Y][drive:][path]filename1[,...] destination\n"
"\n"
"To rename a directory:\n"
"MOVE [/N][/Y|/-Y][drive:][path]dirname1 dirname2\n"
"\n"
" [drive:][path]filename1 Specifies the location and name of the file\n"
" or files you want to move.\n"
" /N Nothing. Don everthing but move files or direcories.\n"
" /Y\n"
" /-Y\n"
"..."));
#else
ConOutPuts (_T("Moves files and renames files and directories.\n\n"
"To move one or more files:\n"
"MOVE [/N][drive:][path]filename1[,...] destination\n"
"\n"
"To rename a directory:\n"
"MOVE [/N][drive:][path]dirname1 dirname2\n"
"\n"
" [drive:][path]filename1 Specifies the location and name of the file\n"
" or files you want to move.\n"
" /N Nothing. Don everthing but move files or direcories.\n"
"\n"
"Current limitations:\n"
" - You can't move a file or directory from one drive to another.\n"
));
#endif
return 0;
}
arg = split (param, &argc);
nFiles = argc;
/* read options */
for (i = 0; i < argc; i++)
{
p = arg[i];
if (*p == _T('/'))
{
p++;
if (*p == _T('-'))
{
p++;
if (_totupper (*p) == _T('Y'))
bPrompt = TRUE;
}
else
{
if (_totupper (*p) == _T('Y'))
bPrompt = FALSE;
else if (_totupper (*p) == _T('N'))
bNothing = TRUE;
}
nFiles--;
}
}
if (nFiles < 2)
{
/* there must be at least two pathspecs */
error_req_param_missing ();
return 1;
}
/* get destination */
GetFullPathName (arg[argc - 1], MAX_PATH, szDestPath, NULL);
#ifdef _DEBUG
DebugPrintf (_T("Destination: %s\n"), szDestPath);
#endif
/* move it*/
for (i = 0; i < argc - 1; i++)
{
if (*arg[i] == _T('/'))
continue;
hFile = FindFirstFile (arg[i], &findBuffer);
if (hFile == INVALID_HANDLE_VALUE)
{
ErrorMessage (GetLastError (), arg[i]);
freep (arg);
return 1;
}
do
{
GetFullPathName (findBuffer.cFileName, MAX_PATH, szSrcPath, &pszFile);
if (GetFileAttributes (szSrcPath) & FILE_ATTRIBUTE_DIRECTORY)
{
/* source is directory */
#ifdef _DEBUG
DebugPrintf (_T("Move directory \'%s\' to \'%s\'\n"),
szSrcPath, szDestPath);
#endif
if (!bNothing)
{
MoveFile (szSrcPath, szDestPath);
}
}
else
{
/* source is file */
if (IsValidFileName (szDestPath))
{
/* destination exists */
if (GetFileAttributes (szDestPath) & FILE_ATTRIBUTE_DIRECTORY)
{
/* destination is existing directory */
TCHAR szFullDestPath[MAX_PATH];
_tcscpy (szFullDestPath, szDestPath);
_tcscat (szFullDestPath, _T("\\"));
_tcscat (szFullDestPath, pszFile);
ConOutPrintf (_T("%s => %s"), szSrcPath, szFullDestPath);
if (!bNothing)
{
if (MoveFile (szSrcPath, szFullDestPath))
ConOutPrintf (_T("[OK]\n"));
else
ConOutPrintf (_T("[Error]\n"));
}
}
else
{
/* destination is existing file */
INT nOverwrite;
/* must get the overwrite code */
if ((nOverwrite = Overwrite (szDestPath)))
{
#if 0
if (nOverwrite == OVERWRITE_ALL)
*lpFlags |= FLAG_OVERWRITE_ALL;
#endif
ConOutPrintf (_T("%s => %s"), szSrcPath, szDestPath);
if (!bNothing)
{
if (MoveFile (szSrcPath, szDestPath))
ConOutPrintf (_T("[OK]\n"));
else
ConOutPrintf (_T("[Error]\n"));
}
}
}
}
else
{
/* destination does not exist */
TCHAR szFullDestPath[MAX_PATH];
GetFullPathName (szDestPath, MAX_PATH, szFullDestPath, NULL);
ConOutPrintf (_T("%s => %s"), szSrcPath, szFullDestPath);
if (!bNothing)
{
if (MoveFile (szSrcPath, szFullDestPath))
ConOutPrintf (_T("[OK]\n"));
else
ConOutPrintf (_T("[Error]\n"));
}
}
}
}
while (FindNextFile (hFile, &findBuffer));
FindClose (hFile);
}
freep (arg);
return 0;
}
#endif /* INCLUDE_CMD_MOVE */

View File

@@ -1,174 +0,0 @@
/*
* MSGBOX.C - msgbox internal command.
*
* clone from 4nt msgbox command
*
* 25 Aug 1999
* started - Paolo Pantaleo <paolopan@freemail.it>
*/
#include "config.h"
#ifdef INCLUDE_CMD_MSGBOX
#include <windows.h>
#include <ctype.h>
#include <string.h>
#include <tchar.h>
#include "cmd.h"
//#include <assert.h>
//#include <malloc.h>
#define U_TYPE_INIT 0
//undefine it to allow to omit arguments
//that will be replaced by default ones
#define _SYNTAX_CHECK
INT CommandMsgbox (LPTSTR cmd, LPTSTR param)
{
//used to parse command line
LPTSTR tmp;
//used to find window title (used as messagebox title)
//and to find window handle to pass to MessageBox
HWND hWnd;
TCHAR buff[128];
//these are MessabeBox() parameters
LPTSTR title, prompt="";
UINT uType=U_TYPE_INIT;
//set default title to window title
GetConsoleTitle(buff,128);
title = buff;
if (_tcsncmp (param, _T("/?"), 2) == 0)
{
ConOutPuts(_T(
"display a message box and return user responce\n"
"\n"
"MSGBOX type [\"title\"] prompt\n"
"\n"
"type button displayed\n"
" possible values are: OK, OKCANCEL,\n"
" YESNO, YESNOCANCEL\n"
"title title of message box\n"
"prompt text displayed by the message box\n"
"\n"
"\n"
"ERRORLEVEL is set according the button pressed:\n"
"\n"
"YES : 10 | NO : 11\n"
"OK : 10 | CANCEL : 12\n"));
return 0;
}
//yes here things are quite massed up :)
//skip spaces
while(_istspace(*param))
param++;
//search for type of messagebox (ok, okcancel, ...)
if (_tcsnicmp(param, _T("ok "),3 ) == 0)
{
uType |= MB_ICONEXCLAMATION | MB_OK;
param+=3;
}
else if (_tcsnicmp(param, _T("okcancel "),9 ) == 0)
{
uType |= MB_ICONQUESTION | MB_OKCANCEL;
param+=9;
}
else if (_tcsnicmp(param, _T("yesno "),6 ) == 0)
{
uType |= MB_ICONQUESTION | MB_YESNO;
param+=6;
}
else if (_tcsnicmp(param, _T("yesnocancel "), 12 ) == 0)
{
uType |= MB_ICONQUESTION | MB_YESNOCANCEL;
param+=12;
}
else{
#ifdef _SYNTAX_CHECK
error_req_param_missing ();
return 1;
#else
uType |= MB_ICONEXCLAMATION | MB_OK;
#endif
}
//skip spaces
while(_istspace(*param))
param++;
#ifdef _SYNTAX_CHECK
//if reached end of string
//it is an error becuase we do not yet have prompt
if ( *param == 0)
{
error_req_param_missing ();
return 1;
}
#endif
//search for "title"
tmp = param;
if(*param == '"')
{
tmp = _tcschr(param+1,'"');
if (tmp)
{
*tmp = 0;
title = param+1;
tmp++;
param = tmp;
}
}
//skip spaces
while(_istspace(*param))
param++;
#ifdef _SYNTAX_CHECK
//get prompt
if ( *param == 0)
{
error_req_param_missing ();
return 1;
}
#endif
prompt = param;
hWnd=GetConsoleWindow ();
// DebugPrintf("FindWindow hWnd = %d\n",hWnd);
ConErrPrintf("FindWindow hWnd = %d\n",hWnd);
switch (
MessageBox(hWnd,prompt,title,uType)
)
{
case IDYES:
case IDOK:
nErrorLevel = 10;
break;
case IDNO:
nErrorLevel = 11;
break;
case IDCANCEL:
nErrorLevel = 12;
break;
}
return 0;
}
#endif /* INCLUDE_CMD_MSGBOX */

View File

@@ -1,90 +0,0 @@
/*
* PATH.C - path internal command.
*
*
* History:
*
* 17 Jul 1998 (John P Price)
* Separated commands into individual files.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 09-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("/?").
*
* 18-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode ready!
*
* 18-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Redirection safe!
*
* 24-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed Win32 environment handling.
*/
#include "config.h"
#ifdef INCLUDE_CMD_PATH
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include "cmd.h"
/* size of environment variable buffer */
#define ENV_BUFFER_SIZE 1024
INT cmd_path (LPTSTR cmd, LPTSTR param)
{
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays or sets a search path for executable files.\n\n"
"PATH [[drive:]path[;...]]\nPATH ;\n\n"
"Type PATH ; to clear all search-path settings and direct the command shell\n"
"to search only in the current directory.\n"
"Type PATH without parameters to display the current path.\n"));
return 0;
}
/* if param is empty, display the PATH environment variable */
if (!param || !*param)
{
DWORD dwBuffer;
LPTSTR pszBuffer;
pszBuffer = (LPTSTR)malloc (ENV_BUFFER_SIZE * sizeof(TCHAR));
dwBuffer = GetEnvironmentVariable (_T("PATH"), pszBuffer, ENV_BUFFER_SIZE);
if (dwBuffer == 0)
{
ConErrPrintf ("CMD: Not in environment \"PATH\"\n");
return 0;
}
else if (dwBuffer > ENV_BUFFER_SIZE)
{
pszBuffer = (LPTSTR)realloc (pszBuffer, dwBuffer * sizeof (TCHAR));
GetEnvironmentVariable (_T("PATH"), pszBuffer, ENV_BUFFER_SIZE);
}
ConOutPrintf (_T("PATH=%s\n"), pszBuffer);
free (pszBuffer);
return 0;
}
/* skip leading '=' */
if (*param == _T('='))
param++;
/* set PATH environment variable */
if (!SetEnvironmentVariable (_T("PATH"), param))
return 1;
return 0;
}
#endif

View File

@@ -1,66 +0,0 @@
/*
* PAUSE.C - pause internal command.
*
*
* History:
*
* 16 Jul 1998 (Hans B Pufal)
* started.
*
* 16 Jul 1998 (John P Price)
* Seperated commands into individual files.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 18-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode ready!
*/
#include "config.h"
#ifdef INCLUDE_CMD_PAUSE
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
#include "batch.h"
/*
* Perform PAUSE command.
*
* FREEDOS extension : If parameter is specified use that as the pause
* message.
*
* ?? Extend to include functionality of CHOICE if switch chars
* specified.
*/
INT cmd_pause (LPTSTR cmd, LPTSTR param)
{
#ifdef _DEBUG
DebugPrintf ("cmd_pause: \'%s\' : \'%s\'\n", cmd, param);
#endif
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Stops the execution of a batch file and shows the following message:\n"
"\"Press any key to continue...\" or a user defined message.\n\n"
"PAUSE [message]"));
return 0;
}
if (*param)
ConOutPrintf (param);
else
msg_pause ();
cgetchar ();
return 0;
}
#endif

View File

@@ -1,225 +0,0 @@
/*
* PROMPT.C - prompt handling.
*
*
* History:
*
* 14/01/95 (Tim Normal)
* started.
*
* 08/08/95 (Matt Rains)
* i have cleaned up the source code. changes now bring this source
* into guidelines for recommended programming practice.
*
* 01/06/96 (Tim Norman)
* added day of the week printing (oops, forgot about that!)
*
* 08/07/96 (Steffan Kaiser)
* small changes for speed
*
* 20-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* removed redundant day strings. Use ones defined in date.c.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 28-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* moved cmd_prompt from internal.c to here
*
* 09-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("/?").
*
* 14-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added "$+" option.
*
* 09-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added "$A", "$C" and "$F" option.
* Added locale support.
* Fixed "$V" option.
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection safe!
*
* 24-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed Win32 environment handling.
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
/*
* print the command-line prompt
*
*/
VOID PrintPrompt(VOID)
{
static TCHAR default_pr[] = _T("$P$G");
TCHAR szPrompt[256];
LPTSTR pr;
if (GetEnvironmentVariable (_T("PROMPT"), szPrompt, 256))
pr = szPrompt;
else
pr = default_pr;
while (*pr)
{
if (*pr != _T('$'))
{
ConOutChar (*pr);
}
else
{
pr++;
switch (_totupper (*pr))
{
case _T('A'):
ConOutChar (_T('&'));
break;
case _T('B'):
ConOutChar (_T('|'));
break;
case _T('C'):
ConOutChar (_T('('));
break;
case _T('D'):
PrintDate ();
break;
case _T('E'):
ConOutChar (_T('\x1B'));
break;
case _T('F'):
ConOutChar (_T(')'));
break;
case _T('G'):
ConOutChar (_T('>'));
break;
case _T('H'):
ConOutChar (_T('\x08'));
break;
case _T('L'):
ConOutChar (_T('<'));
break;
case _T('N'):
{
TCHAR szPath[MAX_PATH];
GetCurrentDirectory (MAX_PATH, szPath);
ConOutChar (szPath[0]);
}
break;
case _T('P'):
{
TCHAR szPath[MAX_PATH];
GetCurrentDirectory (MAX_PATH, szPath);
ConOutPrintf (_T("%s"), szPath);
}
break;
case _T('Q'):
ConOutChar (_T('='));
break;
case _T('T'):
PrintTime ();
break;
case _T('V'):
switch (osvi.dwPlatformId)
{
case VER_PLATFORM_WIN32_WINDOWS:
if (osvi.dwMajorVersion == 4 &&
osvi.dwMinorVersion == 1)
ConOutPrintf (_T("Windows 98"));
else
ConOutPrintf (_T("Windows 95"));
break;
case VER_PLATFORM_WIN32_NT:
ConOutPrintf (_T("Windows NT Version %lu.%lu"),
osvi.dwMajorVersion, osvi.dwMinorVersion);
break;
}
break;
case _T('_'):
ConOutChar (_T('\n'));
break;
case '$':
ConOutChar (_T('$'));
break;
#ifdef FEATURE_DIRECTORY_STACK
case '+':
{
INT i;
for (i = 0; i < GetDirectoryStackDepth (); i++)
ConOutChar (_T('+'));
}
break;
#endif
}
}
pr++;
}
}
#ifdef INCLUDE_CMD_PROMPT
INT cmd_prompt (LPTSTR cmd, LPTSTR param)
{
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Changes the command prompt.\n\n"
"PROMPT [text]\n\n"
" text Specifies a new command prompt.\n\n"
"Prompt can be made up of normal characters and the following special codes:\n\n"
" $A & (Ampersand)\n"
" $B | (pipe)\n"
" $C ( (Left parenthesis)\n"
" $D Current date\n"
" $E Escape code (ASCII code 27)\n"
" $F ) (Right parenthesis)\n"
" $G > (greater-than sign)\n"
" $H Backspace (erases previous character)\n"
" $L < (less-than sign)\n"
" $N Current drive\n"
" $P Current drive and path\n"
" $Q = (equal sign)\n"
" $T Current time\n"
" $V OS version number\n"
" $_ Carriage return and linefeed\n"
" $$ $ (dollar sign)"));
#ifdef FEATURE_DIRECTORY_STACK
ConOutPuts (_T(" $+ Displays the current depth of the directory stack"));
#endif
ConOutPuts (_T("\nType PROMPT without parameters to reset the prompt to the default setting."));
return 0;
}
/* set PROMPT environment variable */
if (!SetEnvironmentVariable (_T("PROMPT"), param))
return 1;
return 0;
}
#endif

View File

@@ -1,68 +0,0 @@
ReactOS command line interpreter CMD version 0.1
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The ReactOS command line interpreter CMD is derived from FreeCOM, the
FreeDOS command line interpreter.
We are going for 4NT compatibility but try to stay compatible with
WinNT's CMD.EXE too.
Compiling
~~~~~~~~~
Cmd can be built in two different versions. A full version for use under
Windows 9x or Windows NT and a reduced version for use under ReactOS.
Note: The full version won't runder ReactOS and the reduced version is not
usable under Win 9x/NT.
To build the full version, make sure the symbol '__REACTOS__' is NOT defined
in 'rosapps/cmd/config.h' line 13.
To build the reduced version, make sure the symbol '__REACTOS__' is defined
in 'rosapps/cmd/config.h' line 13.
Current Features
~~~~~~~~~~~~~~~~
- environment handling with prompt and path support.
- directory utilities.
- command-line history with doskey-like features.
- batch file processing.
- input/output redirection and piping.
- alias support.
- filename completion (use TAB)
Credits
~~~~~~~
FreeDOS developers:
normat@rpi.edu (Tim Norman)
mrains@apanix.apana.org.au (Matt Rains)
ejeffrey@iastate.edu (Evan Jeffrey)
Steffen.Kaiser@Informatik.TU-Chemnitz.DE (Steffen Kaiser)
Svante Frey (sfrey@kuai.se)
Oliver Mueller (ogmueller@t-online.de)
Aaron Kaufman (morgan@remarque.berkeley.edu)
Marc Desrochers (bitzero@hotmail.com)
Rob Lake (rlake@cs.mun.ca)
John P. Price <linux-guru@gcfl.net>
Hans B Pufal <hansp@digiweb.com>
ReactOS developers:
Eric Kohl <ekohl@abo.rhein-zeitung.de>
Emanuele Aliberti <ea@iol.it>
Paolo Pantaleo <paolopan@freemail.it>
Bugs
~~~~
Please report bugs to Eric Kohl <ekohl@abo.rhein-zeitung.de>.
Good luck
Eric Kohl

View File

@@ -1,216 +0,0 @@
/*
* REDIR.C - redirection handling.
*
*
* History:
*
* 12/15/95 (Tim Norman)
* started.
*
* 12 Jul 98 (Hans B Pufal)
* Rewrote to make more efficient and to conform to new command.c
* and batch.c processing.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* Added config.h include
*
* 22-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode safe!
* Added new error redirection "2>" and "2>>".
*
* 26-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added new error AND output redirection "&>" and "&>>".
*/
#include "config.h"
#ifdef FEATURE_REDIRECTION
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
static BOOL
IsRedirection (TCHAR c)
{
return (c == _T('<')) || (c == _T('>')) || (c == _T('|'));
}
/*
* Gets the redirection info from the command line and copies the
* file names into ifn, ofn and efn removing them from the command
* line.
*
* Converts remaining command line into a series of null terminated
* strings defined by the pipe char '|'. Each string corresponds
* to a single executable command. A double null terminates the
* command strings.
*
* Return number of command strings found.
*
*/
INT GetRedirection (LPTSTR s, LPTSTR ifn, LPTSTR ofn, LPTSTR efn, LPINT lpnFlags)
{
INT num = 1;
LPTSTR dp = s;
LPTSTR sp = s;
/* find and remove all the redirections first */
while (*sp)
{
if ((*sp == _T('"')) || (*sp == _T('\'')))
{
/* No redirects inside quotes */
TCHAR qc = *sp;
do
*dp++ = *sp++;
while (*sp && *sp != qc);
*dp++ = *sp++;
}
else if ((*sp == _T('<')) || (*sp == _T('>')) ||
(*sp == _T('2')) || (*sp == _T('&')))
{
/* MS-DOS ignores multiple redirection symbols and uses the last */
/* redirection, so we'll emulate that and not check */
if (*sp == _T('<'))
{
/* input redirection */
*lpnFlags |= INPUT_REDIRECTION;
while (_istspace (*sp))
sp++;
/* copy file name */
while (*sp && !IsRedirection (*sp) && !_istspace (*sp))
*ifn++ = *sp++;
*ifn = _T('\0');
}
else if (*sp == _T('>'))
{
/* output redirection */
*lpnFlags |= OUTPUT_REDIRECTION;
sp++;
/* append request ? */
if (*sp == _T('>'))
{
*lpnFlags |= OUTPUT_APPEND;
sp++;
}
while (_istspace (*sp))
sp++;
/* copy file name */
while (*sp && !IsRedirection (*sp) && !_istspace (*sp))
*ofn++ = *sp++;
*ofn = _T('\0');
}
else if (*sp == _T('2'))
{
/* error redirection */
sp++;
if (*sp == _T('>'))
{
*lpnFlags |= ERROR_REDIRECTION;
sp++;
/* append request ? */
if (*sp == _T('>'))
{
*lpnFlags |= ERROR_APPEND;
sp++;
}
}
else
{
/* no redirection!! copy the '2' character! */
sp--;
*dp++ = *sp++;
continue;
}
while (_istspace (*sp))
sp++;
/* copy file name */
while (*sp && !IsRedirection (*sp) && !_istspace (*sp))
*efn++ = *sp++;
*efn = _T('\0');
}
else if (*sp == _T('&'))
{
/* output AND error redirection */
sp++;
if (*sp == _T('>'))
{
*lpnFlags |= (ERROR_REDIRECTION | OUTPUT_REDIRECTION);
sp++;
/* append request ? */
if (*sp == _T('>'))
{
*lpnFlags |= (ERROR_APPEND | OUTPUT_APPEND);
sp++;
}
}
else
{
/* no redirection!! copy the '&' character! */
sp--;
*dp++ = *sp++;
continue;
}
while (_istspace (*sp))
sp++;
/* copy file name */
while (*sp && !IsRedirection (*sp) && !_istspace (*sp))
*ofn++ = *efn++ = *sp++;
*ofn = *efn = _T('\0');
}
}
else
*dp++ = *sp++;
}
*dp++ = _T('\0');
*dp = _T('\0');
/* now go for the pipes */
sp = s;
while (*sp)
{
if ((*sp == _T('"')) || (*sp == _T('\'')))
{
TCHAR qc = *sp;
do
sp++;
while (*sp && *sp != qc);
sp++;
}
else if (*sp == _T('|'))
{
*sp++ = _T('\0');
num++;
}
else
sp++;
}
return num;
}
#endif /* FEATURE_REDIRECTION */

View File

@@ -1,70 +0,0 @@
/*
* REN.C - rename internal command.
*
*
* History:
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 18-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>
* Added support for quoted long file names with spaces.
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>
* Unicode and redirection safe!
*/
#include "config.h"
#ifdef INCLUDE_CMD_RENAME
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
/*
* simple file rename internal command.
*
*/
INT cmd_rename (LPTSTR cmd, LPTSTR param)
{
LPTSTR *arg;
INT argc;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Renames a file/directory or files/directories.\n"
"\n"
"RENAME [drive:][path][directoryname1 | filename1] [directoryname2 | filename2]\n"
"REN [drive:][path][directoryname1 | filename1] [directoryname2 | filename2]\n"
"\n"
"Note that you cannot specify a new drive or path for your destination. Use\n"
"the MOVE command for that purpose."));
return 0;
}
/* split the argument list */
arg = split (param, &argc);
if (argc != 2)
{
freep (arg);
error_too_many_parameters (param);
return 1;
}
if (!MoveFile (arg[0], arg[1]))
{
ConErrPuts (_T("rename"));
freep (arg);
return 1;
}
freep (arg);
return 0;
}
#endif

View File

@@ -1,111 +0,0 @@
/*
* SCREEN.C - screen internal command.
*
* clone from 4nt msgbox command
*
* 30 Aug 1999
* started - Paolo Pantaleo <paolopan@freemail.it>
*
*
*/
#include "config.h"
#ifdef INCLUDE_CMD_SCREEN
#include <tchar.h>
#include <windows.h>
#include <stdlib.h>
#include <ctype.h>
#include "cmd.h"
INT CommandScreen (LPTSTR cmd, LPTSTR param)
{
SHORT x,y;
BOOL bSkipText = FALSE;
if (_tcsncmp (param, _T("/?"), 2) == 0)
{
ConOutPuts(_T(
"move cursor and optionally print text\n"
"\n"
"SCREEN row col [text]\n"
"\n"
" row row to wich move the cursor\n"
" col column to wich move the cursor"));
return 0;
}
//get row
while(_istspace(*param))
param++;
if(!(*param))
{
error_req_param_missing ();
return 1;
}
y = atoi(param);
if (y<0 || y>(maxy-1))
{
ConOutPrintf("invalid value for row");
return 1;
}
//get col
if(!(param = _tcschr(param,_T(' '))))
{
error_req_param_missing ();
return 1;
}
while(_istspace(*param))
param++;
if(!(*param))
{
error_req_param_missing ();
return 1;
}
x = atoi(param);
if (x<0 || x>(maxx-1))
{
ConErrPuts(_T("invalid value for col"));
return 1;
}
//get text
if(!(param = _tcschr(param,_T(' '))))
{
bSkipText = TRUE;
}
else
{
while(_istspace(*param))
param++;
if(!(*param))
{
bSkipText = TRUE;
}
}
bIgnoreEcho = TRUE;
if(bSkipText)
x=0;
SetCursorXY(x,y);
if(!(bSkipText))
ConOutPuts(param);
return 0;
}
#endif /* INCLUDE_CMD_SCREEN */

View File

@@ -1,128 +0,0 @@
/*
* SET.C - set internal command.
*
*
* History:
*
* 06/14/97 (Tim Norman)
* changed static var in set() to a malloc'd space to pass to putenv.
* need to find a better way to do this, since it seems it is wasting
* memory when variables are redefined.
*
* 07/08/1998 (John P. Price)
* removed call to show_environment in set command.
* moved test for syntax before allocating memory in set command.
* misc clean up and optimization.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 28-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added set_env function to set env. variable without needing set command
*
* 09-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("/?").
*
* 24-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed Win32 environment handling.
* Unicode and redirection safe!
*
* 25-Feb-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed little bug.
*/
#include "config.h"
#ifdef INCLUDE_CMD_SET
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include "cmd.h"
/* initial size of environment variable buffer */
#define ENV_BUFFER_SIZE 1024
INT cmd_set (LPTSTR cmd, LPTSTR param)
{
LPTSTR p;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays, sets, or removes environment variables.\n\n"
"SET [variable[=][string]]\n\n"
" variable Specifies the environment-variable name.\n"
" string Specifies a series of characters to assign to the variable.\n\n"
"Type SET without parameters to display the current environment variables.\n"));
return 0;
}
/* if no parameters, show the environment */
if (param[0] == _T('\0'))
{
LPTSTR lpEnv;
LPTSTR lpOutput;
INT len;
lpEnv = (LPTSTR)GetEnvironmentStrings ();
if (lpEnv)
{
lpOutput = lpEnv;
while (*lpOutput)
{
len = _tcslen(lpOutput);
if (len)
{
if (*lpOutput != _T('='))
ConOutPuts (lpOutput);
lpOutput += (len + 1);
}
}
FreeEnvironmentStrings (lpEnv);
}
return 0;
}
p = _tcschr (param, _T('='));
if (p)
{
/* set or remove environment variable */
*p = _T('\0');
p++;
SetEnvironmentVariable (param, p);
}
else
{
/* display environment variable */
LPTSTR pszBuffer;
DWORD dwBuffer;
pszBuffer = (LPTSTR)malloc (ENV_BUFFER_SIZE * sizeof(TCHAR));
dwBuffer = GetEnvironmentVariable (param, pszBuffer, ENV_BUFFER_SIZE);
if (dwBuffer == 0)
{
ConErrPrintf ("CMD: Not in environment \"%s\"\n", param);
return 0;
}
else if (dwBuffer > ENV_BUFFER_SIZE)
{
pszBuffer = (LPTSTR)realloc (pszBuffer, dwBuffer * sizeof (TCHAR));
GetEnvironmentVariable (param, pszBuffer, dwBuffer * sizeof (TCHAR));
}
ConOutPrintf ("%s\n", pszBuffer);
free (pszBuffer);
return 0;
}
return 0;
}
#endif

View File

@@ -1,70 +0,0 @@
/*
* SHIFT.C - shift internal batch command
*
*
* History:
*
* 16 Jul 1998 (Hans B Pufal)
* started.
*
* 16 Jul 1998 (John P Price)
* Separated commands into individual files.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 07-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("shift /?") and cleaned up.
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection safe!
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
#include "batch.h"
/*
* Perform the SHIFT command.
*
* Only valid inside batch files.
*
* FREEDOS extension : optional parameter DOWN to allow shifting
* parameters backwards.
*/
INT cmd_shift (LPTSTR cmd, LPTSTR param)
{
#ifdef _DEBUG
DebugPrintf ("cmd_shift: (\'%s\', \'%s\'\n", cmd, param);
#endif
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Changes the position of replaceable parameters in a batch file.\n\n"
"SHIFT [DOWN]"));
return 0;
}
if (bc == NULL)
{
/* not in batch - error!! */
return 1;
}
if (!_tcsicmp (param, _T("down")))
{
if (bc->shiftlevel)
bc->shiftlevel--;
}
else /* shift up */
bc->shiftlevel++;
return 0;
}

View File

@@ -1,116 +0,0 @@
/*
* START.C - start internal command.
*
*
* History:
*
* 24-Jul-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Started.
*/
#include "config.h"
#ifdef INCLUDE_CMD_START
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "cmd.h"
INT cmd_start (LPTSTR first, LPTSTR rest)
{
TCHAR szFullName[MAX_PATH];
BOOL bWait = FALSE;
if (_tcsncmp (rest, _T("/?"), 2) == 0)
{
ConOutPuts (_T("Starts a command.\n\n"
"START command \n\n"
" command Specifies the command to run.\n\n"
"At the moment all commands are started asynchronously.\n"));
return 0;
}
/* check for a drive change */
if (!_tcscmp (first + 1, _T(":")) && _istalpha (*first))
{
TCHAR szPath[MAX_PATH];
_tcscpy (szPath, _T("A:"));
szPath[0] = _totupper (*first);
SetCurrentDirectory (szPath);
GetCurrentDirectory (MAX_PATH, szPath);
if (szPath[0] != (TCHAR)_totupper (*first))
ConErrPuts (INVALIDDRIVE);
return 0;
}
/* get the PATH environment variable and parse it */
/* search the PATH environment variable for the binary */
if (!SearchForExecutable (first, szFullName))
{
error_bad_command ();
return 1;
}
/* check if this is a .BAT or .CMD file */
if (!_tcsicmp (_tcsrchr (szFullName, _T('.')), _T(".bat")) ||
!_tcsicmp (_tcsrchr (szFullName, _T('.')), _T(".cmd")))
{
#ifdef _DEBUG
DebugPrintf ("[BATCH: %s %s]\n", szFullName, rest);
#endif
ConErrPuts (_T("No batch support at the moment!"));
}
else
{
/* exec the program */
TCHAR szFullCmdLine [1024];
PROCESS_INFORMATION prci;
STARTUPINFO stui;
#ifdef _DEBUG
DebugPrintf ("[EXEC: %s %s]\n", szFullName, rest);
#endif
/* build command line for CreateProcess() */
_tcscpy (szFullCmdLine, szFullName);
_tcscat (szFullCmdLine, _T(" "));
_tcscat (szFullCmdLine, rest);
/* fill startup info */
memset (&stui, 0, sizeof (STARTUPINFO));
stui.cb = sizeof (STARTUPINFO);
stui.dwFlags = STARTF_USESHOWWINDOW;
stui.wShowWindow = SW_SHOWDEFAULT;
if (CreateProcess (NULL, szFullCmdLine, NULL, NULL, FALSE,
0, NULL, NULL, &stui, &prci))
{
if (bWait)
{
DWORD dwExitCode;
WaitForSingleObject (prci.hProcess, INFINITE);
GetExitCodeProcess (prci.hProcess, &dwExitCode);
nErrorLevel = (INT)dwExitCode;
CloseHandle (prci.hThread);
CloseHandle (prci.hProcess);
}
}
else
{
ErrorMessage (GetLastError (),
"Error executing CreateProcess()!!\n");
}
}
return 0;
}
#endif
/* EOF */

View File

@@ -1,287 +0,0 @@
/*
* STRTOCLR.C - read color (for color command and other)
*
*
* History:
*
* 07-Oct-1999 (Paolo Pantaleo)
* Started.
*
*
*/
/*only
BOOL StringToColor(LPWORD lpColor, LPTSTR*str)
is to be called
other are internal service functions*/
#include "cmd.h"
#include <ctype.h>
#include <tchar.h>
#define _B FOREGROUND_BLUE
#define _G FOREGROUND_GREEN
#define _R FOREGROUND_RED
#define _I FOREGROUND_INTENSITY
/*return values for chop_blank*/
#define CP_OK 0
#define CP_BLANK_NOT_FOUND 1
#define CP_END_OF_STRING 2
#define SC_HEX 0x0100
#define SC_TXT 0x0200
typedef struct _CLRTABLE
{
LPTSTR name;
WORD val;
} CLRTABLE;
CLRTABLE clrtable[] =
{
{"bla" ,0 },
{"blu" ,_B },
{"gre" ,_G },
{"cya" ,_B|_G },
{"red" ,_R },
{"mag" ,_B|_R },
{"yel" ,_R|_G },
{"whi" ,_R|_G|_B },
{"gra" ,_I },
{"0" ,0 },
{"2" ,_G },
{"3" ,_B|_G },
{"4" ,_R },
{"5" ,_B|_R },
{"6" ,_R|_G },
{"7" ,_R|_G|_B },
{"8" ,_I },
{"9" ,_I|_B },
{"10" ,_I|_G },
{"11" ,_I|_B|_G },
{"12" ,_I|_R },
{"13" ,_I|_B|_R },
{"14" ,_I|_R|_G },
{"15" ,_I|_R|_G|_B},
/* note that 1 is at the end of list
to avoid to confuse it with 10-15*/
{"1" ,_B },
/*cyan synonimous*/
{"aqu" ,_B|_G },
/*magenta synonimous*/
{"pur" ,_B|_R },
{"" ,0},
};
/*
move string pointer to next word (skip all spaces)
on erro retunr nonzero value
*/
static
INT chop_blank(LPTSTR *arg_str)
{
LPTSTR str;
str = _tcschr(*arg_str,_T(' '));
if(!str)
{
str = _tcschr (*arg_str, _T('\0'));
if(str != NULL)
*arg_str=str;
return CP_BLANK_NOT_FOUND;
}
while(_istspace(*str))
str++;
if (*str == _T('\0'))
{
*arg_str=str;
return CP_END_OF_STRING;
}
*arg_str = str;
return CP_OK;
}
/*
read a color value in hex (like win nt's cmd syntax)
if an error occurs return -1
*/
static
WORD hex_clr(LPTSTR str)
{
WORD ret= (WORD)-1;
TCHAR ch;
ch = str[1];
if(_istdigit(ch))
ret = ch-_T('0');
else
{
ch=_totupper(ch);
if( ch >= _T('A') && ch <= _T('F') )
ret = ch-_T('A')+10;
else
return (WORD)-1;
}
ch = str[0];
if(_istdigit(ch))
ret |= (ch-_T('0')) << 4;
else
{
ch=_totupper(ch);
if( ch >= _T('A') && ch <= _T('F') )
ret |= (ch-_T('A')+10) <<4;
else
return (WORD)-1;
}
return ret;
}
/*
read a color value from a string (like 4nt's syntax)
if an error occurs return -1
*/
static
WORD txt_clr(LPTSTR str)
{
INT i;
for(i=0;*(clrtable[i].name);i++)
if( _tcsnicmp(str,clrtable[i].name,_tcslen(clrtable[i].name)) == 0)
return clrtable[i].val;
return (WORD)-1;
}
/*search for x on y*/
static
WORD str_to_color(LPTSTR* arg_str)
{
LPTSTR str;
BOOL bBri=FALSE;
WORD tmp_clr,ret_clr;
str = *arg_str;
if(!(*str))
return (WORD)-1;
/*foreground*/
if(_tcsnicmp(str,"bri",3) == 0 )
{
bBri = TRUE;
if(chop_blank(&str))
return (WORD)-1;
}
if( (tmp_clr = txt_clr(str)) == (WORD)-1 )
{
return (WORD)-1;
}
/*skip spaces and "on"*/
if ( chop_blank(&str) || chop_blank(&str) )
return (WORD)-1;
ret_clr = tmp_clr | (bBri << 3);
/*background*/
if(_tcsnicmp(str,"bri",3) == 0 )
{
bBri = TRUE;
if(chop_blank(&str))
return (WORD)-1;
}
if( (tmp_clr = txt_clr(str)) == (WORD)-1 )
return (WORD)-1;
chop_blank(&str);
*arg_str = str;
return SC_HEX | ret_clr | tmp_clr << 4 | bBri << 7;
}
/****main function****/
/*
the only parameter is arg_str, a pointer to a string.
the string is modified so it will begin to first word after
color specification
(only the char* is moved, no chars in the string are modfied)
it returns the color in the l.o. byte, plus two flags in the
h.o. byte, they are:
SC_HEX win nt's cmd syntax (for exampl a0)
SC_TXT 4nt's syntax ( "bri gre on bla" or "10 on 0")
if succedes also move the LPTSTR to end of
string that specify color
*/
BOOL StringToColor(LPWORD lpColor, LPTSTR*str)
{
WORD wRet;
wRet = str_to_color (str);
if (wRet == (WORD)-1)
{
wRet=hex_clr (*str);
chop_blank (str);
if (wRet == (WORD)-1)
return FALSE;
}
*lpColor = wRet;
return TRUE;
}
/* EOF */

View File

@@ -1,221 +0,0 @@
/*
* TIME.C - time internal command.
*
*
* History:
*
* 07/08/1998 (John P. Price)
* started.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 09-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added locale support.
*
* 19-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection safe!
* Added "/t" option.
*
* 04-Feb-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Fixed time input bug.
*/
#include "config.h"
#ifdef INCLUDE_CMD_TIME
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
static BOOL ParseTime (LPTSTR s)
{
SYSTEMTIME t;
LPTSTR p = s;
if (!*s)
return TRUE;
GetLocalTime (&t);
t.wHour = 0;
t.wMinute = 0;
t.wSecond = 0;
t.wMilliseconds = 0;
// first get hour
if (_istdigit(*p))
{
while (_istdigit(*p))
{
t.wHour = t.wHour * 10 + *p - _T('0');
p++;
}
}
else
return FALSE;
// get time separator
if (*p != cTimeSeparator)
return FALSE;
p++;
// now get minutes
if (_istdigit(*p))
{
while (_istdigit(*p))
{
t.wMinute = t.wMinute * 10 + *p - _T('0');
p++;
}
}
else
return FALSE;
// get time separator
if (*p != cTimeSeparator)
return FALSE;
p++;
// now get seconds
if (_istdigit(*p))
{
while (_istdigit(*p))
{
t.wSecond = t.wSecond * 10 + *p - _T('0');
p++;
}
}
else
return FALSE;
// get decimal separator
if (*p == cDecimalSeparator)
{
p++;
// now get hundreths
if (_istdigit(*p))
{
while (_istdigit(*p))
{
// t.wMilliseconds = t.wMilliseconds * 10 + *p - _T('0');
p++;
}
// t.wMilliseconds *= 10;
}
}
/* special case: 12 hour format */
if (nTimeFormat == 0)
{
if (_totupper(*s) == _T('P'))
{
t.wHour += 12;
}
if ((_totupper(*s) == _T('A')) && (t.wHour == 12))
{
t.wHour = 0;
}
}
if (t.wHour > 23 || t.wMinute > 60 || t.wSecond > 60 || t.wMilliseconds > 999)
return FALSE;
SetLocalTime (&t);
return TRUE;
}
INT cmd_time (LPTSTR cmd, LPTSTR param)
{
LPTSTR *arg;
INT argc;
INT i;
BOOL bPrompt = TRUE;
INT nTimeString = -1;
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays or sets the system time.\n"
"\n"
"TIME [/T][time]\n"
"\n"
" /T display only\n"
"\n"
"Type TIME with no parameters to display the current time setting and a prompt\n"
"for a new one. Press ENTER to keep the same time."));
return 0;
}
/* build parameter array */
arg = split (param, &argc);
/* check for options */
for (i = 0; i < argc; i++)
{
if (_tcsicmp (arg[i], _T("/t")) == 0)
bPrompt = FALSE;
if ((*arg[i] != _T('/')) && (nTimeString == -1))
nTimeString = i;
}
if (nTimeString == -1)
PrintTime ();
if (!bPrompt)
{
freep (arg);
return 0;
}
while (1)
{
if (nTimeString == -1)
{
TCHAR s[40];
ConOutPrintf (_T("Enter new time: "));
ConInString (s, 40);
#ifdef _DEBUG
DebugPrintf ("\'%s\'\n", s);
#endif
while (*s && s[_tcslen (s) - 1] < _T(' '))
s[_tcslen(s) - 1] = _T('\0');
if (ParseTime (s))
{
freep (arg);
return 0;
}
}
else
{
if (ParseTime (arg[nTimeString]))
{
freep (arg);
return 0;
}
/* force input the next time around. */
nTimeString = -1;
}
ConErrPuts (_T("Invalid time."));
}
freep (arg);
return 0;
}
#endif

View File

@@ -1,246 +0,0 @@
/*
* TIMER.C - timer internal command.
*
* clone from 4nt timer command
*
* 20 Aug 1999
* started - Paolo Pantaleo <paolopan@freemail.it>
*/
#include "config.h"
#ifdef INCLUDE_CMD_TIMER
#include "cmd.h"
#include <ctype.h>
#include <string.h>
#include <tchar.h>
#include <windows.h>
#define NCS_NOT_SPECIFIED -1
#define NCS_ON 1
#define NCS_OFF 0
//print timer status
#define PS ConOutPrintf("Timer %d is %s: ",clk_n,cS?"ON":"OFF"); \
PrintTime()
//print timer value
#define PT(format) PrintElapsedTime(GetTickCount()-cT,format)
//current timer Time (at wich started to count)
#define cT clksT[clk_n]
//current timer status
#define cS clksS[clk_n]
static VOID
PrintElapsedTime (DWORD time,INT format)
{
DWORD h,m,s,ms;
#ifdef _DEBUG
DebugPrintf("PrintTime(%d,%d)",time,format);
#endif
switch (format)
{
case 0:
ConOutPrintf("Elapsed %d msecs\n",time);
break;
case 1:
ms = time % 1000;
time /= 1000;
s = time % 60;
time /=60;
m = time % 60;
h = time / 60;
ConOutPrintf("Elapsed %02d%c%02d%c%02d%c%02d\n",
h,cTimeSeparator,
m,cTimeSeparator,
s,cDecimalSeparator,ms/10);
break;
}
}
INT CommandTimer (LPTSTR cmd, LPTSTR param)
{
// all timers are kept
static DWORD clksT[10];
// timers status
// set all the clocks off by default
static BOOL clksS[10]={FALSE,FALSE,FALSE,FALSE,
FALSE,FALSE,FALSE,FALSE,FALSE,FALSE};
// TRUE if /S in command line
BOOL bS = FALSE;
// avoid to set clk_n more than once
BOOL bCanNSet = TRUE;
INT NewClkStatus = NCS_NOT_SPECIFIED;
// the clock number specified on the command line
// 1 by default
INT clk_n=1;
// output format
INT iFormat=1;
// command line parsing variables
INT argc;
LPTSTR *p;
INT i;
if (_tcsncmp (param, _T("/?"), 2) == 0)
{
ConOutPrintf(_T(
"allow the use of ten stopwaches.\n"
"\n"
"TIMER [ON|OFF] [/S] [/n] [/Fn]\n"
"\n"
" ON set stopwach ON\n"
" OFF set stopwach OFF\n"
" /S Split time. Return stopwach split\n"
" time without changing its value\n"
" /n Specifiy the stopwach number.\n"
" Stopwaches avaliable are 0 to 10\n"
" If it is not specified default is 1\n"
" /Fn Format for output\n"
" n can be:\n"
" 0 milliseconds\n"
" 1 hh%cmm%css%cdd\n"
"\n"),
cTimeSeparator,cTimeSeparator,cDecimalSeparator);
ConOutPrintf(_T(
"if none of ON, OFF or /S is specified the command\n"
"will toggle stopwach state\n"
"\n"));
return 0;
}
p = split (param,&argc);
//read options
for (i = 0; i < argc; i++)
{
//set timer on
if (!(_tcsicmp(&p[i][0],"on")) && NewClkStatus == NCS_NOT_SPECIFIED)
{
NewClkStatus = NCS_ON;
continue;
}
//set timer off
if (!(_tcsicmp(&p[i][0],"off")) && NewClkStatus == NCS_NOT_SPECIFIED)
{
NewClkStatus = NCS_OFF;
continue;
}
// other options
if (p[i][0] == _T('/'))
{
// set timer number
if (_istdigit(p[i][1]) && bCanNSet)
{
clk_n = p[i][1] - _T('0');
bCanNSet = FALSE;
continue;
}
// set s(plit) option
if (_totupper(p[i][1]) == _T('S'))
{
bS = TRUE;
continue;
}
// specify format
if(_totupper(p[i][1]) == _T('F'))
{
iFormat = p[i][2] - _T('0');
continue;
}
}
}
// do stuff (start/stop/read timer)
if(NewClkStatus == NCS_ON)
{
cT=GetTickCount();
cS=TRUE;
PS;
freep(p);
return 0;
}
if(bS)
{
if(cS)
{
PS;
PrintElapsedTime(GetTickCount()-cT, iFormat);
freep(p);
return 0;
}
cT=GetTickCount();
cS=TRUE;
PS;
freep(p);
return 0;
}
if(NewClkStatus == NCS_NOT_SPECIFIED)
{
if(cS){
cS=FALSE;
PS;
PrintElapsedTime(GetTickCount()-cT, iFormat);
freep(p);
return 0;
}
cT=GetTickCount();
cS=TRUE;
PS;
freep(p);
return 0;
}
if(NewClkStatus == NCS_OFF)
{
if(cS)
{
cS=FALSE;
PS;
PrintElapsedTime(GetTickCount()-cT, iFormat);
freep(p);
return 0;
}
PS;
freep(p);
return 0;
}
freep(p);
return 0;
}
#endif /* INCLUDE_CMD_TIMER */

View File

@@ -1,42 +0,0 @@
/*
* title.c - title internal command.
*
*
* History:
* 1999-02-11 Emanuele Aliberti
*/
#include "config.h"
#ifdef INCLUDE_CMD_TITLE
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
INT cmd_title (LPTSTR cmd, LPTSTR param)
{
/* Do nothing if no args */
if (*param == _T('\0'))
return 0;
/* Asking help? */
if (!_tcsncmp(param, _T("/?"), 2))
{
ConOutPuts (_T("Sets the window title for the command prompt window.\n"
"\n"
"TITLE [string]\n"
"\n"
" string Specifies the title for the command prompt window."));
return 0;
}
return SetConsoleTitle (param);
}
#endif /* def INCLUDE_CMD_TITLE */
/* EOF */

View File

@@ -1,16 +0,0 @@
Things to do
~~~~~~~~~~~~
Fix bugs :)
Optimize the code! For size and speed. There are numerous places
where the code is hardly optimal for either.
Sorting in DIR command ("dir /o...").
^S and ^Q to pause/resume displays.
Improve DEL, COPY and MOVE commands.
Add wildcard support to REN.
And many, many more...

View File

@@ -1,145 +0,0 @@
/*
* TYPE.C - type internal command.
*
* History:
*
* 07/08/1998 (John P. Price)
* started.
*
* 07/12/98 (Rob Lake)
* Changed error messages
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 07-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added support for quoted arguments (type "test file.dat").
* Cleaned up.
*
* 19-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection ready!
*
* 19-Jan-1999 (Paolo Pantaleo <paolopan@freemail.it>)
* Added multiple file support (copied from y.c)
*/
#include "config.h"
#ifdef INCLUDE_CMD_TYPE
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
INT cmd_type (LPTSTR cmd, LPTSTR param)
{
TCHAR buff[256];
HANDLE hFile, hConsoleOut, hFind;
DWORD dwRead;
DWORD dwWritten;
BOOL bRet;
INT argc,i;
LPTSTR *argv;
WIN32_FIND_DATA FindData;
hConsoleOut=GetStdHandle (STD_OUTPUT_HANDLE);
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays the contents of text files.\n\n"
"TYPE [drive:][path]filename"));
return 0;
}
if (!*param)
{
error_req_param_missing ();
return 1;
}
argv = split (param, &argc);
for (i = 0; i < argc; i++)
{
hFind=FindFirstFile(argv[i],&FindData);
if (hFind==INVALID_HANDLE_VALUE)
{
ConErrPrintf("File not found - %s\n",argv[i]);
continue;
}
do
{
hFile = CreateFile(FindData.cFileName,
GENERIC_READ,
FILE_SHARE_READ,NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,NULL);
if(hFile == INVALID_HANDLE_VALUE)
{
ConErrPrintf("File not found - %s\n",FindData.cFileName);
continue;
}
do
{
bRet = ReadFile(hFile,buff,sizeof(buff),&dwRead,NULL);
if (dwRead>0 && bRet)
WriteFile(hConsoleOut,buff,dwRead,&dwWritten,NULL);
} while(dwRead>0 && bRet);
CloseHandle(hFile);
}
while(FindNextFile(hFind,&FindData));
FindClose(hFile);
}
/*
if (args > 1)
{
error_too_many_parameters (_T("\b \b"));
freep (arg);
return 1;
}
hFile = CreateFile (arg[0], GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN,
NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
error_sfile_not_found (param);
freep (arg);
return 1;
}
do
{
bResult = ReadFile (hFile, szBuffer, sizeof(szBuffer),
&dwBytesRead, NULL);
if (dwBytesRead)
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE), szBuffer, dwBytesRead,
&dwBytesWritten, NULL);
}
while (bResult && dwBytesRead > 0);
CloseHandle (hFile);
*/
freep (argv);
return 0;
}
#endif

View File

@@ -1,149 +0,0 @@
/*
* VER.C - ver internal command.
*
*
* History:
*
* 06/30/98 (Rob Lake)
* rewrote ver command to accept switches, now ver alone prints
* copyright notice only.
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 30-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added text about where to send bug reports and get updates.
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection safe!
*
* 26-Feb-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* New version info and some output changes.
*/
#include "config.h"
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include <ctype.h>
#include "cmd.h"
VOID ShortVersion (VOID)
{
ConOutPuts (_T("\n"
SHELLINFO "\n"
SHELLVER "\n"));
}
#ifdef INCLUDE_CMD_VER
/*
* display shell version info internal command.
*
*
*/
INT cmd_ver (LPTSTR cmd, LPTSTR param)
{
INT i;
if (_tcsstr (param, _T("/?")) != NULL)
{
ConOutPuts (_T("Displays shell version information\n"
"\n"
"VER [/C][/R][/W]\n"
"\n"
" /C Displays credits.\n"
" /R Displays redistribution information.\n"
" /W Displays warranty information."));
return 0;
}
ConOutPuts (_T("\n"
SHELLINFO "\n"
SHELLVER "\n"
"\n"
"Copyright (C) 1994-1998 Tim Norman and others."));
ConOutPuts (_T("Copyright (C) 1998,1999 Eric Kohl and others."));
/* Basic copyright notice */
if (param[0] == _T('\0'))
{
ConOutPuts (_T("\n"SHELLINFO
" comes with ABSOLUTELY NO WARRANTY; for details\n"
"type: `ver /w'. This is free software, and you are welcome to redistribute\n"
"it under certain conditions; type `ver /r' for details. Type `ver /c' for a\n"
"listing of credits."));
}
else
{
for (i = 0; param[i]; i++)
{
/* skip spaces */
if (param[i] == _T(' '))
continue;
if (param[i] == _T('/'))
{
/* is this a lone '/' ? */
if (param[i + 1] == 0)
{
error_invalid_switch (_T(' '));
return 1;
}
continue;
}
if (_totupper (param[i]) == _T('W'))
{
/* Warranty notice */
ConOutPuts (_T("\n This program is distributed in the hope that it will be useful,\n"
" but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
" GNU General Public License for more details."));
}
else if (_totupper (param[i]) == _T('R'))
{
/* Redistribution notice */
ConOutPuts (_T("\n This program is free software; you can redistribute it and/or modify\n"
" it under the terms of the GNU General Public License as published by\n"
" the Free Software Foundation; either version 2 of the License, or\n"
" (at your option) any later version."));
}
else if (_totupper (param[i]) == _T('C'))
{
/* Developer listing */
ConOutPuts (_T("\n"
"FreeDOS version written by:\n"
" Tim Norman Matt Rains\n"
" Evan Jeffrey Steffen Kaiser\n"
" Svante Frey Oliver Mueller\n"
" Aaron Kaufman Marc Desrochers\n"
" Rob Lake John P Price\n"
" Hans B Pufal\n"
"\n"
"ReactOS version written by:\n"
" Eric Kohl Emanuele Aliberti\n"
" Paolo Pantaleo\n"));
}
else
{
error_invalid_switch ((TCHAR)_totupper (param[i]));
return 1;
}
}
}
ConOutPuts (_T("\nSend bug reports to <ekohl@abo.rhein-zeitung.de>."
/*
"\nUpdates are available at http://www.reactos.com"
*/
));
return 0;
}
#endif

View File

@@ -1,57 +0,0 @@
/*
* VERIFY.C - verify internal command.
*
*
* History:
*
* 31 Jul 1998 (John P Price)
* started.
*
* 18-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* VERIFY is just a dummy under Win32; it only exists
* for compatibility!!!
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode and redirection ready!
*/
#include "config.h"
#ifdef INCLUDE_CMD_VERIFY
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
/* global verify flag */
static BOOL bVerify = FALSE;
INT cmd_verify (LPTSTR cmd, LPTSTR param)
{
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("This command is just a dummy!!\n"
"Sets whether to verify that your files are written correctly to a\n"
"disk.\n\n"
"VERIFY [ON | OFF]\n\n"
"Type VERIFY without a parameter to display the current VERIFY setting."));
return 0;
}
if (!*param)
ConOutPrintf (_T("VERIFY is %s.\n"), bVerify ? D_ON : D_OFF);
else if (_tcsicmp (param, D_OFF) == 0)
bVerify = FALSE;
else if (_tcsicmp (param, D_ON) == 0)
bVerify = TRUE;
else
ConOutPuts (_T("Must specify ON or OFF."));
return 0;
}
#endif

View File

@@ -1,105 +0,0 @@
/*
* VOL.C - vol internal command.
*
*
* History:
*
* 03-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Replaced DOS calls by Win32 calls.
*
* 08-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added help text ("/?").
*
* 07-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Cleanup.
*
* 18-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Unicode ready!
*
* 20-Jan-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Redirection ready!
*/
#include "config.h"
#ifdef INCLUDE_CMD_VOL
#include <windows.h>
#include <tchar.h>
#include <string.h>
#include "cmd.h"
static INT
PrintVolumeHeader (LPTSTR pszRootPath)
{
TCHAR szVolName[80];
DWORD dwSerialNr;
/* get the volume information of the drive */
if(!GetVolumeInformation (pszRootPath, szVolName, 80, &dwSerialNr,
NULL, NULL, NULL, 0))
{
ErrorMessage (GetLastError (), _T(""));
return 1;
}
/* print drive info */
ConOutPrintf (_T(" Volume in drive %c:"), pszRootPath[0]);
if (szVolName[0] != '\0')
ConOutPrintf (_T(" is %s\n"), szVolName);
else
ConOutPrintf (_T(" has no label\n"));
/* print the volume serial number */
ConOutPrintf (_T(" Volume Serial Number is %04X-%04X\n"),
HIWORD(dwSerialNr), LOWORD(dwSerialNr));
return 0;
}
INT cmd_vol (LPTSTR cmd, LPTSTR param)
{
TCHAR szRootPath[] = _T("A:\\");
TCHAR szPath[MAX_PATH];
if (!_tcsncmp (param, _T("/?"), 2))
{
ConOutPuts (_T("Displays the disk volume label and serial number, if they exist.\n\n"
"VOL [drive:]"));
return 0;
}
if (param[0] == _T('\0'))
{
GetCurrentDirectory (MAX_PATH, szPath);
szRootPath[0] = szPath[0];
}
else
{
_tcsupr (param);
if (param[1] == _T(':'))
szRootPath[0] = param[0];
else
{
error_invalid_drive ();
return 1;
}
}
if (!IsValidPathName (szRootPath))
{
error_invalid_drive ();
return 1;
}
/* print the header */
if (!PrintVolumeHeader (szRootPath))
return 1;
return 0;
}
#endif

View File

@@ -1,338 +0,0 @@
/*
* WHERE.C - file search functions.
*
*
* History:
*
* 07/15/95 (Tim Norman)
* started.
*
* 08/08/95 (Matt Rains)
* i have cleaned up the source code. changes now bring this source
* into guidelines for recommended programming practice.
*
* 12/12/95 (Steffan Kaiser & Tim Norman)
* added some patches to fix some things and make more efficient
*
* 1/6/96 (Tim Norman)
* fixed a stupid pointer mistake...
* Thanks to everyone who noticed it!
*
* 8/1/96 (Tim Norman)
* fixed a bug when getenv returns NULL
*
* 8/7/96 (Steffan Kaiser and Tim Norman)
* speed improvements and bug fixes
*
* 8/27/96 (Tim Norman)
* changed code to use pointers directly into PATH environment
* variable rather than making our own copy. This saves some memory,
* but requires we write our own function to copy pathnames out of
* the variable.
*
* 12/23/96 (Aaron Kaufman)
* Fixed a bug in get_paths() that did not point to the first PATH
* in the environment variable.
*
* 7/12/97 (Tim Norman)
* Apparently, Aaron's bugfix got lost, so I fixed it again.
*
* 16 July 1998 (John P. Price)
* Added stand alone code.
*
* 17 July 1998 (John P. Price)
* Rewrote find_which to use searchpath function
*
* 24-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* fixed bug where didn't check all extensions when path was specified
*
* 27-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* added config.h include
*
* 30-Jul-1998 (John P Price <linux-guru@gcfl.net>)
* fixed so that it find_which returns NULL if filename is not
* executable (does not have .bat, .com, or .exe extention).
* Before command would to execute any file with any extension (opps!)
*
* 03-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Changed find_which().
*
* 07-Dec-1998 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Added ".CMD" extension.
* Replaced numeric constant by _NR_OF_EXTENSIONS.
*
* 26-Feb-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Replaced find_which() by SearchForExecutable().
* Now files are searched using the right extension order.
*
* 20-Apr-1999 (Eric Kohl <ekohl@abo.rhein-zeitung.de>)
* Some minor changes and improvements.
*/
#include "config.h"
#include <windows.h>
#include <string.h>
#include <stdlib.h>
#include "cmd.h"
/* initial size of environment variable buffer */
#define ENV_BUFFER_SIZE 1024
static LPTSTR ext[] = {".bat", ".cmd", ".com", ".exe"};
static INT nExtCount = sizeof(ext) / sizeof(LPTSTR);
/* searches for file using path info. */
BOOL
SearchForExecutable (LPCTSTR pFileName, LPTSTR pFullName)
{
TCHAR szPathBuffer[MAX_PATH];
LPTSTR pszBuffer = NULL;
DWORD dwBuffer, len;
INT n;
LPTSTR p,s,f;
/* initialize full name buffer */
*pFullName = _T('\0');
#ifdef _DEBUG
DebugPrintf (_T("SearchForExecutable: \'%s\'\n"), pFileName);
#endif
if (_tcschr (pFileName, _T('\\')) != NULL)
{
LPTSTR pFilePart;
#ifdef _DEBUG
DebugPrintf (_T("Absolute or relative path is given.\n"));
#endif
if (GetFullPathName (pFileName,
MAX_PATH,
szPathBuffer,
&pFilePart) ==0)
return FALSE;
if(pFilePart == 0)
return FALSE;
if (_tcschr (pFilePart, _T('.')) != NULL)
{
#ifdef _DEBUG
DebugPrintf (_T("Filename extension!\n"));
#endif
_tcscpy (pFullName, szPathBuffer);
return TRUE;
}
else
{
#ifdef _DEBUG
DebugPrintf (_T("No filename extension!\n"));
#endif
p = szPathBuffer + _tcslen (szPathBuffer);
for (n = 0; n < nExtCount; n++)
{
_tcscpy (p, ext[n]);
#ifdef _DEBUG
DebugPrintf (_T("Testing: \'%s\'\n"), szPathBuffer);
#endif
if (IsValidFileName (szPathBuffer))
{
#ifdef _DEBUG
DebugPrintf (_T("Found: \'%s\'\n"), szPathBuffer);
#endif
_tcscpy (pFullName, szPathBuffer);
return TRUE;
}
}
return FALSE;
}
}
/* load environment varable PATH into buffer */
pszBuffer = (LPTSTR)malloc (ENV_BUFFER_SIZE * sizeof(TCHAR));
dwBuffer = GetEnvironmentVariable (_T("PATH"), pszBuffer, ENV_BUFFER_SIZE);
if (dwBuffer > ENV_BUFFER_SIZE)
{
pszBuffer = (LPTSTR)realloc (pszBuffer, dwBuffer * sizeof (TCHAR));
GetEnvironmentVariable (_T("PATH"), pszBuffer, dwBuffer * sizeof (TCHAR));
}
if (!(p = _tcsrchr (pFileName, _T('.'))) ||
_tcschr (p + 1, _T('\\')))
{
/* There is no extension ==> test all the extensions. */
#ifdef _DEBUG
DebugPrintf (_T("No filename extension!\n"));
#endif
/* search in current directory */
len = GetCurrentDirectory (MAX_PATH, szPathBuffer);
if (szPathBuffer[len - 1] != _T('\\'))
{
szPathBuffer[len] = _T('\\');
szPathBuffer[len + 1] = _T('\0');
}
_tcscat (szPathBuffer, pFileName);
p = szPathBuffer + _tcslen (szPathBuffer);
for (n = 0; n < nExtCount; n++)
{
_tcscpy (p, ext[n]);
#ifdef _DEBUG
DebugPrintf (_T("Testing: \'%s\'\n"), szPathBuffer);
#endif
if (IsValidFileName (szPathBuffer))
{
#ifdef _DEBUG
DebugPrintf (_T("Found: \'%s\'\n"), szPathBuffer);
#endif
free (pszBuffer);
_tcscpy (pFullName, szPathBuffer);
return TRUE;
}
}
/* search in PATH */
s = pszBuffer;
while (s && *s)
{
f = _tcschr (s, _T(';'));
if (f)
{
_tcsncpy (szPathBuffer, s, (size_t)(f-s));
szPathBuffer[f-s] = _T('\0');
s = f + 1;
}
else
{
_tcscpy (szPathBuffer, s);
s = NULL;
}
len = _tcslen(szPathBuffer);
if (szPathBuffer[len - 1] != _T('\\'))
{
szPathBuffer[len] = _T('\\');
szPathBuffer[len + 1] = _T('\0');
}
_tcscat (szPathBuffer, pFileName);
p = szPathBuffer + _tcslen (szPathBuffer);
for (n = 0; n < nExtCount; n++)
{
_tcscpy (p, ext[n]);
#ifdef _DEBUG
DebugPrintf (_T("Testing: \'%s\'\n"), szPathBuffer);
#endif
if (IsValidFileName (szPathBuffer))
{
#ifdef _DEBUG
DebugPrintf (_T("Found: \'%s\'\n"), szPathBuffer);
#endif
free (pszBuffer);
_tcscpy (pFullName, szPathBuffer);
return TRUE;
}
}
}
}
else
{
/* There is an extension and it is in the last path component, */
/* so don't test all the extensions. */
#ifdef _DEBUG
DebugPrintf (_T("Filename extension!\n"));
#endif
/* search in current directory */
len = GetCurrentDirectory (MAX_PATH, szPathBuffer);
if (szPathBuffer[len - 1] != _T('\\'))
{
szPathBuffer[len] = _T('\\');
szPathBuffer[len + 1] = _T('\0');
}
_tcscat (szPathBuffer, pFileName);
#ifdef _DEBUG
DebugPrintf (_T("Testing: \'%s\'\n"), szPathBuffer);
#endif
if (IsValidFileName (szPathBuffer))
{
#ifdef _DEBUG
DebugPrintf (_T("Found: \'%s\'\n"), szPathBuffer);
#endif
free (pszBuffer);
_tcscpy (pFullName, szPathBuffer);
return TRUE;
}
/* search in PATH */
s = pszBuffer;
while (s && *s)
{
f = _tcschr (s, _T(';'));
if (f)
{
_tcsncpy (szPathBuffer, s, (size_t)(f-s));
szPathBuffer[f-s] = _T('\0');
s = f + 1;
}
else
{
_tcscpy (szPathBuffer, s);
s = NULL;
}
len = _tcslen(szPathBuffer);
if (szPathBuffer[len - 1] != _T('\\'))
{
szPathBuffer[len] = _T('\\');
szPathBuffer[len + 1] = _T('\0');
}
_tcscat (szPathBuffer, pFileName);
#ifdef _DEBUG
DebugPrintf (_T("Testing: \'%s\'\n"), szPathBuffer);
#endif
if (IsValidFileName (szPathBuffer))
{
#ifdef _DEBUG
DebugPrintf (_T("Found: \'%s\'\n"), szPathBuffer);
#endif
free (pszBuffer);
_tcscpy (pFullName, szPathBuffer);
return TRUE;
}
}
}
free (pszBuffer);
return FALSE;
}

View File

@@ -1,247 +0,0 @@
/* $Id: window.c,v 1.3 1999/10/03 22:16:14 ekohl Exp $
*
* WINDOW.C - activate & window internal commands.
*
* clone from 4nt activate command
*
* 10 Sep 1999 (Paolo Pantaleo)
* started (window command in WINDOW.c)
*
* 29 Sep 1999 (Paolo Pantaleo)
* activate and window in a single file using mainly the same code
* (nice size optimization :)
*/
#include "config.h"
#if ( defined(INCLUDE_CMD_WINDOW) || defined(INCLUDE_CMD_ACTIVATE) )
#include "cmd.h"
#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <tchar.h>
#define A_MIN 0x01
#define A_MAX 0x02
#define A_RESTORE 0x04
#define A_POS 0x08
#define A_SIZE 0x10
#define A_CLOSE 0x20
/*service funciton to perform actions on windows
param is a string to parse for options/actions
hWnd is the handle of window on wich perform actions
*/
static
INT ServiceActivate (LPTSTR param, HWND hWnd)
{
LPTSTR *p=0,p_tmp;
INT argc=0,i;
INT iAction=0;
LPTSTR title=0;
WINDOWPLACEMENT wp;
RECT pos;
LPTSTR tmp;
if(*param)
p=split(param,&argc);
for(i = 0; i < argc; i++)
{
p_tmp=p[i];
if (*p_tmp == _T('/'))
p_tmp++;
if (_tcsicmp(p_tmp,_T("min"))==0)
{
iAction |= A_MIN;
continue;
}
if (_tcsicmp(p_tmp,_T("max"))==0)
{
iAction |= A_MAX;
continue;
}
if (_tcsicmp(p_tmp,_T("restore"))==0)
{
iAction |= A_RESTORE;
continue;
}
if (_tcsicmp(p_tmp,_T("close"))==0)
{
iAction |= A_CLOSE;
continue;
}
if (_tcsnicmp(p_tmp,_T("pos"),3)==0)
{
iAction |= A_POS;
tmp = p_tmp+3;
if (*tmp == _T('='))
tmp++;
pos.left= _ttoi(tmp);
if(!(tmp=_tcschr(tmp,_T(','))))
{
error_invalid_parameter_format(p[i]);
freep(p);
return 1;
}
pos.top = _ttoi (++tmp);
if(!(tmp=_tcschr(tmp,_T(','))))
{
error_invalid_parameter_format(p[i]);
freep(p);
return 1;
}
pos.right = _ttoi(++tmp)+pos.left;
if(!(tmp=_tcschr(tmp,_T(','))))
{
error_invalid_parameter_format(p[i]);
freep(p);
return 1;
}
pos.bottom = _ttoi(++tmp) + pos.top;
continue;
}
if (_tcsnicmp(p_tmp,_T("size"),4)==0)
{
iAction |=A_SIZE;
continue;
}
/*none of them=window title*/
if (title)
{
error_invalid_parameter_format(p[i]);
freep(p);
return 1;
}
if (p_tmp[0] == _T('"'))
{
title = (p_tmp+1);
*_tcschr(p_tmp+1,_T('"'))=0;
continue;
}
title = p_tmp;
}
if(title)
SetWindowText(hWnd,title);
wp.length=sizeof(WINDOWPLACEMENT);
GetWindowPlacement(hWnd,&wp);
if(iAction & A_POS)
wp.rcNormalPosition = pos;
if(iAction & A_MIN)
wp.showCmd=SW_MINIMIZE;
if(iAction & A_MAX)
wp.showCmd=SW_SHOWMAXIMIZED;
/*if no actions are specified default is SW_RESTORE*/
if( (iAction & A_RESTORE) || (!iAction) )
wp.showCmd=SW_RESTORE;
if(iAction & A_CLOSE)
ConErrPrintf(_T("!!!FIXME: CLOSE Not implemented!!!\n"));
wp.length=sizeof(WINDOWPLACEMENT);
SetWindowPlacement(hWnd,&wp);
if(p)
freep(p);
return 0;
}
INT CommandWindow (LPTSTR cmd, LPTSTR param)
{
HWND h;
if (_tcsncmp (param, _T("/?"), 2) == 0)
{
ConOutPuts(_T("change console window aspect\n"
"\n"
"WINDOW [/POS[=]left,top,width,heigth]\n"
" [MIN|MAX|RESTORE] [\"title\"]\n"
"\n"
"/POS specify window placement and dimensions\n"
"MIN minimize the window\n"
"MAX maximize the window\n"
"RESTORE restore the window"));
return 0;
}
h = GetConsoleWindow();
Sleep(0);
return ServiceActivate(param,h);
}
INT CommandActivate (LPTSTR cmd, LPTSTR param)
{
LPTSTR str;
HWND h;
if (_tcsncmp (param, _T("/?"), 2) == 0)
{
ConOutPuts(_T("change console window aspect\n"
"\n"
"ACTIAVTE \"window\" [/POS[=]left,top,width,heigth]\n"
" [MIN|MAX|RESTORE] [\"title\"]\n"
"\n"
"window tile of window on wich perform actions\n"
"/POS specify window placement and dimensions\n"
"MIN minimize the window\n"
"MAX maximize the window\n"
"RESTORE restore the window\n"
"title new title"));
return 0;
}
if(!(*param))
return 1;
str=_tcschr(param,_T(' '));
if (str)
{
*str=_T('\0');
str++;
}
else
str = "";
h=FindWindow(NULL, param);
if (!h)
{
ConErrPuts("window not found");
return 1;
}
return ServiceActivate(str,h);
}
#endif /* ( defined(INCLUDE_CMD_WINDOW) || defined(INCLUDE_CMD_ACTIVATE) ) */

View File

@@ -1,15 +0,0 @@
Wishlist for ReactOS CMD
~~~~~~~~~~~~~~~~~~~~~~~~
- Exclusion wildcards: "del /r *.bak -abcd.bak"
Deletes ALL *.bak files EXCEPT abcd.bak.
- Progress indikator on long file operations (copy/move).
Percentage at the right side of the filename.
- [cd test directory] should change to the subdirectoy "test directory".
More ideas?
Eric Kohl <ekohl@abo.rhein-zeitung.de>

View File

@@ -1,51 +0,0 @@
#
# ReactOS cmdutils makefile
#
TARGET=more.exe tee.exe y.exe
all: $(TARGET)
CLEAN_FILES = *.o *.exe *.sym *.coff
more.exe: more.o
$(CC) more.o -lkernel32 -lcrtdll -o more.exe
$(NM) --numeric-sort more.exe > more.sym
tee.exe: tee.o
$(CC) tee.o -lkernel32 -lcrtdll -o tee.exe
$(NM) --numeric-sort tee.exe > tee.sym
y.exe: y.o
$(CC) y.o -lkernel32 -lcrtdll -o y.exe
$(NM) --numeric-sort y.exe > y.sym
clean: $(CLEAN_FILES:%=%_clean)
$(CLEAN_FILES:%=%_clean): %_clean:
- $(RM) $*
.phony: clean $(CLEAN_FILES:%=%_clean)
floppy: $(TARGET:%=$(FLOPPY_DIR)/apps/%)
$(TARGET:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* $(FLOPPY_DIR)\apps\$*
else
$(CP) $* $(FLOPPY_DIR)/apps/$*
endif
dist: $(TARGET:%=../$(DIST_DIR)/apps/%)
$(TARGET:%=../$(DIST_DIR)/apps/%): ../$(DIST_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* ..\$(DIST_DIR)\apps\$*
else
$(CP) $* ../$(DIST_DIR)/apps/$*
endif
include ../rules.mak

View File

@@ -1,149 +0,0 @@
/*
* MORE.C - external command.
*
* clone from 4nt more command
*
* 26 Sep 1999 - Paolo Pantaleo <paolopan@freemail.it>
* started
*/
#include <windows.h>
#include <malloc.h>
#include <tchar.h>
DWORD len;
LPTSTR msg = "--- continue ---";
/*handle for file and console*/
HANDLE hStdIn;
HANDLE hStdOut;
HANDLE hStdErr;
HANDLE hKeyboard;
static VOID
GetScreenSize (PSHORT maxx, PSHORT maxy)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo (hStdOut, &csbi);
if (maxx)
*maxx = csbi.dwSize.X;
if (maxy)
*maxy = csbi.dwSize.Y;
}
static
VOID ConOutPuts (LPTSTR szText)
{
DWORD dwWritten;
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE), szText, _tcslen(szText), &dwWritten, NULL);
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE), "\n", 1, &dwWritten, NULL);
}
static VOID
ConInKey (VOID)
{
INPUT_RECORD ir;
DWORD dwRead;
do
{
ReadConsoleInput (hKeyboard, &ir, 1, &dwRead);
if ((ir.EventType == KEY_EVENT) &&
(ir.Event.KeyEvent.bKeyDown == TRUE))
return;
}
while (TRUE);
}
static VOID
WaitForKey (VOID)
{
DWORD dwWritten;
WriteFile (hStdErr,msg , len, &dwWritten, NULL);
ConInKey();
WriteFile (hStdErr, _T("\n"), 1, &dwWritten, NULL);
// FlushConsoleInputBuffer (hConsoleIn);
}
//INT CommandMore (LPTSTR cmd, LPTSTR param)
int main (int argc, char **argv)
{
SHORT maxx,maxy;
SHORT line_count=0,ch_count=0;
INT i;
/*reading/writing buffer*/
TCHAR *buff;
/*bytes written by WriteFile and ReadFile*/
DWORD dwRead,dwWritten;
/*ReadFile() return value*/
BOOL bRet;
len = _tcslen (msg);
hStdIn = GetStdHandle(STD_INPUT_HANDLE);
hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
hStdErr = GetStdHandle(STD_ERROR_HANDLE);
if (_tcsncmp (argv[1], _T("/?"), 2) == 0)
{
ConOutPuts(_T("Help text still missing!!"));
return 0;
}
hKeyboard = CreateFile ("CONIN$", GENERIC_READ,
0,NULL,OPEN_ALWAYS,0,0);
GetScreenSize(&maxx,&maxy);
buff=malloc(maxx);
FlushConsoleInputBuffer (hKeyboard);
do
{
bRet = ReadFile(hStdIn,buff,1,&dwRead,NULL);
if (dwRead>0 && bRet)
WriteFile(hStdOut,buff,dwRead,&dwWritten,NULL);
for(i=0;i<dwRead;i++)
{
ch_count++;
if(buff[i] == _T('\x0a') || ch_count == maxx)
{
ch_count=0;
line_count++;
if (line_count == maxy-1)
{
line_count = 0;
FlushFileBuffers (hStdOut);
WaitForKey ();
}
}
}
}
while(dwRead>0 && bRet);
free (buff);
CloseHandle (hKeyboard);
return 0;
}
/* EOF */

View File

@@ -1,220 +0,0 @@
/*
* TEE.C - external command.
*
* clone from 4nt tee command
*
* 01 Sep 1999 - Paolo Pantaleo <paolopan@freemail.it>
* started
*
*
*/
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <malloc.h>
#define TEE_BUFFER_SIZE 8192
/*these are function that emulate the ones used in cmd*/
/*many of them are just copied in this file from their
original location*/
VOID ConOutPuts (LPTSTR szText)
{
DWORD dwWritten;
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE), szText, _tcslen(szText), &dwWritten, NULL);
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE), _T("\n"), 1, &dwWritten, NULL);
}
VOID ConErrPrintf (LPTSTR szFormat, ...)
{
DWORD dwWritten;
TCHAR szOut[4096];
va_list arg_ptr;
va_start (arg_ptr, szFormat);
_vstprintf (szOut, szFormat, arg_ptr);
va_end (arg_ptr);
WriteFile (GetStdHandle (STD_ERROR_HANDLE), szOut, _tcslen(szOut), &dwWritten, NULL);
}
VOID error_sfile_not_found (LPTSTR f)
{
ConErrPrintf (_T("Error opening file") _T(" - %s\n"), f);
}
VOID ConErrPuts (LPTSTR szText)
{
ConErrPrintf(_T("%s\n"),szText );
}
INT main (int argc,char **p)
{
/*reading/writing buffer*/
TCHAR buff[TEE_BUFFER_SIZE];
/*handle for file and console*/
HANDLE hConsoleIn,hConsoleOut;
/*bytes written by WriteFile and ReadFile*/
DWORD dwRead,dwWritten;
BOOL bRet,bAppend=FALSE;
/*command line parsing stuff*/
LPTSTR tmp;
INT i;
BOOL bQuote;
/*file list implementation*/
LPTSTR *files;
INT iFileCounter=0;
HANDLE *hFile;
/*used to remove '"' (if any)*/
INT add;
DWORD dw;
if (argc < 2)
return 1;
if (_tcsncmp (p[1], _T("/?"), 2) == 0)
{
ConOutPuts (_T("Copy standard input to both standard output and a file.\n"
"\n"
"TEE [/A] file...\n"
"\n"
" file One or more files that will receive output.\n"
" /A Append output to files.\n"));
return 0;
}
files = malloc(sizeof(LPTSTR)*argc);
hFile = malloc(sizeof(HANDLE)*argc);
hConsoleIn=GetStdHandle(STD_INPUT_HANDLE);
hConsoleOut=GetStdHandle(STD_OUTPUT_HANDLE);
/*parse command line for /a and file name(s)*/
for(i=1;i <argc;i++)
{
bQuote=FALSE;
add=0;
if(_tcsnicmp(p[i],_T("/a"),2) == 0)
{
bAppend = TRUE;
continue;
}
/*remove quote if any*/
if (p[i][0] == _T('"'))
{
tmp = _tcschr (p[i]+1, _T('"'));
if (tmp != 0)
{
add = 1;
*tmp= _T('\0');
}
}
/*add filename to array of filename*/
/*
if( iFileCounter >= sizeof(files) / sizeof(*files) )
{
ConErrPrintf("too many files, maximum is %d\n",sizeof(files) / sizeof(*files));
return 1;
}
*/
files[iFileCounter++]= p[i]+add;
}
/*open file(s)*/
for(i=0;i<iFileCounter;i++)
{
//l=0;
hFile[i] = CreateFile(files[i],GENERIC_WRITE,
0,NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,NULL);
if (hFile[i] == INVALID_HANDLE_VALUE)
{
error_sfile_not_found (files[i]);
for(i=0;i<iFileCounter;i++)
CloseHandle (hFile[i]);
free (files);
free (hFile);
return 1;
}
/*set append mode*/
if (bAppend)
{
if (GetFileType (hFile[i]) == FILE_TYPE_DISK)
{
dw = SetFilePointer (hFile[i],0,NULL,FILE_END);
if (dw == 0xFFFFFFFF)
{
ConErrPrintf(_T("error moving to end of file %s"),files[i]);
for(i=0;i<iFileCounter;i++)
CloseHandle (hFile[i]);
free (files);
free (hFile);
return 1;
}
ConErrPrintf(_T("SetFilePointer() = %d\n"),dw);
}
}
}
/*read and write*/
do
{
bRet = ReadFile(hConsoleIn,buff,sizeof(buff),&dwRead,NULL);
if (dwRead>0 && bRet)
{
for(i=0;i<iFileCounter;i++)
WriteFile(hFile[i],buff,dwRead,&dwWritten,NULL);
WriteFile(hConsoleOut,buff,dwRead,&dwWritten,NULL);
}
} while(dwRead>0 && bRet);
for(i=0;i<iFileCounter;i++)
CloseHandle (hFile[i]);
free (files);
free (hFile);
return 0;
}
/* EOF */

View File

@@ -1,122 +0,0 @@
/*
* Y.C - Y external command.
*
* clone from 4nt y command
*
* 02 Oct 1999 (Paolo Pantaleo)
* started
*
*
*/
#define BUFF_SIZE 4096
#include <windows.h>
#include <stdio.h>
#include <tchar.h>
static
VOID ConErrPrintf (LPTSTR szFormat, ...)
{
DWORD dwWritten;
TCHAR szOut[BUFF_SIZE];
va_list arg_ptr;
va_start (arg_ptr, szFormat);
_vstprintf (szOut, szFormat, arg_ptr);
va_end (arg_ptr);
WriteFile (GetStdHandle (STD_ERROR_HANDLE), szOut, _tcslen(szOut), &dwWritten, NULL);
}
static
VOID ConOutPuts (LPTSTR szText)
{
DWORD dwWritten;
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE), szText, _tcslen(szText), &dwWritten, NULL);
WriteFile (GetStdHandle (STD_OUTPUT_HANDLE), "\n", 1, &dwWritten, NULL);
}
int main (int argc, char **argv)
{
INT i;
HANDLE hFind;
HANDLE hConsoleIn, hConsoleOut, hFile;
char buff[BUFF_SIZE];
DWORD dwRead,dwWritten;
BOOL bRet;
WIN32_FIND_DATA FindData;
hConsoleIn = GetStdHandle(STD_INPUT_HANDLE);
hConsoleOut = GetStdHandle(STD_OUTPUT_HANDLE);
if (_tcsncmp (argv[1], _T("/?"), 2) == 0)
{
ConOutPuts(_T("copy stdin to stdout and then files to stdout\n"
"\n"
"Y [files]\n"
"\n"
"files files to copy to stdout"));
return 0;
}
/*stdin to stdout*/
do
{
bRet = ReadFile(hConsoleIn,buff,sizeof(buff),&dwRead,NULL);
if (dwRead>0 && bRet)
WriteFile(hConsoleOut,buff,dwRead,&dwWritten,NULL);
} while(dwRead>0 && bRet);
/*files to stdout*/
Sleep(0);
for (i = 1; i < argc; i++)
{
hFind=FindFirstFile(argv[i],&FindData);
if (hFind==INVALID_HANDLE_VALUE)
{
ConErrPrintf("File not found - %s\n",argv[i]);
continue;
}
do
{
hFile = CreateFile(FindData.cFileName,
GENERIC_READ,
FILE_SHARE_READ,NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,NULL);
if(hFile == INVALID_HANDLE_VALUE)
{
ConErrPrintf("File not found - %s\n",FindData.cFileName);
continue;
}
do
{
bRet = ReadFile(hFile,buff,sizeof(buff),&dwRead,NULL);
if (dwRead>0 && bRet)
WriteFile(hConsoleOut,buff,dwRead,&dwWritten,NULL);
} while(dwRead>0 && bRet);
CloseHandle(hFile);
}
while(FindNextFile(hFind,&FindData));
FindClose(hFile);
}
return 0;
}

View File

@@ -1,340 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) 19yy <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

View File

@@ -1,54 +0,0 @@
# $Id: makefile,v 1.2 1999/10/03 22:10:15 ekohl Exp $
#
# ReactOS makefile for notevil
# Compiler: egcs 1.1.2
#
TARGET=notevil
all: $(TARGET).exe
OBJECTS = $(TARGET).o $(TARGET).coff
CLEAN_FILES = *.o $(TARGET).exe $(TARGET).sym $(TARGET).coff
clean: $(CLEAN_FILES:%=%_clean)
$(CLEAN_FILES:%=%_clean): %_clean:
- $(RM) $*
.phony: clean $(CLEAN_FILES:%=%_clean)
$(TARGET).exe: $(OBJECTS)
$(CC) $(OBJECTS) \
-o $(TARGET).exe \
-lkernel32 \
-luser32 \
-lcrtdll
$(NM) --numeric-sort $(TARGET).exe > $(TARGET).sym
$(TARGET).coff: $(TARGET).rc
$(RC) $(RFLAGS) $(TARGET).rc $(TARGET).coff
floppy: $(TARGET:%=$(FLOPPY_DIR)/apps/%)
$(TARGET:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* $(FLOPPY_DIR)\apps\$*
else
$(CP) $* $(FLOPPY_DIR)/apps/$*
endif
dist: $(TARGET:%=../$(DIST_DIR)/apps/%)
$(TARGET:%=../$(DIST_DIR)/apps/%): ../$(DIST_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* ..\$(DIST_DIR)\apps\$*
else
$(CP) $* ../$(DIST_DIR)/apps/$*
endif
include ../rules.mak
# EOF

View File

@@ -1,21 +0,0 @@
# $Id: makefile.lcc,v 1.1 1999/05/15 07:23:34 ea Exp $
# Makefile for lcc-win32
#
CC=lcc.exe
CFLAGS=-c -O
LD=lcclnk.exe
LFLAGS=-s
RC=lrc.exe
OBJECTS=notevil.obj notevil.res
notevil.exe: $(OBJECTS)
$(LD) $(LFLAGS) $(OBJECTS)
notevil.obj: notevil.c resource.h
$(CC) $(CFLAGS) notevil.c
notevil.res: notevil.rc
$(RC) notevil.rc
# EOF

View File

@@ -1,247 +0,0 @@
/* $Id: notevil.c,v 1.2 1999/10/03 22:10:15 ekohl Exp $
*
* notevil.c
*
* --------------------------------------------------------------------
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This software 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this software; see the file COPYING.LIB. If
* not, write to the Free Software Foundation, Inc., 675 Mass Ave,
* Cambridge, MA 02139, USA.
*
* --------------------------------------------------------------------
* ReactOS Coders Console Parade
*
* 19990411 EA
* 19990515 EA
*/
//#define UNICODE
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
#include "resource.h"
LPCTSTR app_name = _TEXT("notevil");
HANDLE myself;
HANDLE ScreenBuffer;
CONSOLE_SCREEN_BUFFER_INFO ScreenBufferInfo;
void
WriteStringAt(
LPTSTR lpString,
COORD xy,
WORD wColor
)
{
DWORD cWritten = 0;
WORD wLen = lstrlen(lpString);
if (0 == wLen)
return;
WriteConsoleOutputCharacter(
ScreenBuffer,
lpString,
wLen,
xy,
& cWritten
);
FillConsoleOutputAttribute(
ScreenBuffer,
wColor,
wLen,
xy,
& cWritten
);
}
#ifdef DISPLAY_COORD
void
WriteCoord(COORD c)
{
COORD xy = {0,0};
TCHAR buf [40];
wsprintf(
buf,
_TEXT("x=%02d y=%02d"),
c.X,
c.Y
);
WriteStringAt(
buf,
xy,
(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)
);
}
#endif /* def DISPLAY_COORD */
INT
GetNextString(
LPTSTR Buffer,
INT BufferSize,
DWORD *Index
)
{
if (RES_LAST_INDEX == *Index)
{
*Index = RES_FIRST_INDEX;
}
else
{
++*Index;
}
LoadString(
myself,
*Index,
Buffer,
BufferSize
);
return 0;
}
VOID
DisplayTitle(VOID)
{
LPTSTR szTitle = _TEXT("ReactOS Coders Console Parade");
COORD xy;
xy.X = (ScreenBufferInfo.dwSize.X - lstrlen(szTitle)) / 2;
xy.Y = ScreenBufferInfo.dwSize.Y / 2;
WriteStringAt(
szTitle,
xy,
(FOREGROUND_GREEN | FOREGROUND_INTENSITY)
);
}
#define RES_DELAY_CHANGE 12
#define RES_BUFFER_SIZE 1024
void
MainLoop(void)
{
TCHAR NameString [RES_BUFFER_SIZE];
DWORD NameIndex = 1;
INT NameLength = 0;
COORD xy;
INT n = RES_DELAY_CHANGE;
INT dir_y = 1;
INT dir_x = 1;
WORD wColor = 1;
xy.X = ScreenBufferInfo.dwSize.X / 2;
xy.Y = ScreenBufferInfo.dwSize.Y / 2;
for ( ; 1; ++n )
{
if (n == RES_DELAY_CHANGE)
{
n = GetNextString(
NameString,
RES_BUFFER_SIZE,
& NameIndex
);
NameLength = lstrlen(NameString);
wColor++;
if ((wColor & 0x000F) == 0)
wColor = 1;
}
if (xy.X == 0)
{
if (dir_x == -1)
dir_x = 1;
}
else if (xy.X >= ScreenBufferInfo.dwSize.X - NameLength - 1)
{
if (dir_x == 1)
dir_x = -1;
}
xy.X += dir_x;
if (xy.Y == 0)
{
if (dir_y == -1)
dir_y = 1;
}
else if (xy.Y >= ScreenBufferInfo.dwSize.Y - 1)
{
if (dir_y == 1)
dir_y = -1;
}
xy.Y += dir_y;
#ifdef DISPLAY_COORD
WriteCoord(xy);
#endif /* def DISPLAY_COORD */
DisplayTitle();
WriteStringAt(
NameString,
xy,
wColor
);
Sleep(100);
WriteStringAt(
NameString,
xy,
0
);
}
}
int
main(
int argc,
char *argv []
)
{
myself = GetModuleHandle(NULL);
#if 1
GetConsoleScreenBufferInfo (GetStdHandle(STD_OUTPUT_HANDLE),
&ScreenBufferInfo);
#else
ScreenBufferInfo.dwSize.X = 80;
ScreenBufferInfo.dwSize.Y = 25;
#endif
ScreenBuffer = CreateConsoleScreenBuffer(
GENERIC_WRITE,
0,
NULL,
CONSOLE_TEXTMODE_BUFFER,
NULL
);
if (INVALID_HANDLE_VALUE == ScreenBuffer)
{
_ftprintf(
stderr,
_TEXT("%s: could not create a new screen buffer\n"),
app_name
);
return EXIT_FAILURE;
}
SetConsoleActiveScreenBuffer(ScreenBuffer);
MainLoop();
CloseHandle(ScreenBuffer);
return EXIT_SUCCESS;
}
/* EOF */

View File

@@ -1,69 +0,0 @@
/* $Id: notevil.rc,v 1.2 1999/10/03 22:10:15 ekohl Exp $ */
#include "../../reactos/include/defines.h"
#include "../../reactos/include/reactos/resource.h"
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
/* Version information. */
VS_VERSION_INFO VERSIONINFO
FILEVERSION RES_UINT_FV_MAJOR,RES_UINT_FV_MINOR,RES_UINT_FV_REVISION,RES_UINT_FV_BUILD
PRODUCTVERSION RES_UINT_PV_MAJOR,RES_UINT_PV_MINOR,RES_UINT_PV_REVISION,RES_UINT_PV_BUILD
FILEFLAGSMASK 0x3fL
#ifdef _DEBUG
FILEFLAGS 0x1L
#else
FILEFLAGS 0x0L
#endif
FILEOS 0x40004L
FILETYPE 0x2L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904b0"
BEGIN
VALUE "CompanyName", RES_STR_COMPANY_NAME
VALUE "FileDescription", "ReactOS Coders Console Parade\0"
VALUE "FileVersion", "1.0.0\0"
VALUE "InternalName", "notevil\0"
VALUE "LegalCopyright", RES_STR_LEGAL_COPYRIGHT
VALUE "OriginalFilename", "notevil.exe\0"
VALUE "ProductName", RES_STR_PRODUCT_NAME
VALUE "ProductVersion", RES_STR_PRODUCT_VERSION
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x409, 1200
END
END
/*
* String table
*
* Order is the same as in the status report published weekly in
* the "ros-kernel" mailing list by Rex Jolliff.
*
*/
STRINGTABLE MOVEABLE
BEGIN
1, "Boudewijn Dekker (Ariadne)"
2, "Robert Bergkvist (FragDance Galore)"
3, "Arindam Das"
4, "Boudewijn Dekker"
5, "Jason Eager"
6, "Jason Filby"
7, "Rex Jolliff"
8, "Eric Kohl"
9, "Hans Kremer"
10, "Frederik Leemans"
11, "Jean Michault"
12, "Jim Noeth"
13, "Brian Palmer"
14, "Matt Pyne"
15, "Jason Weiler"
16, "David Welch"
END
/* EOF */

View File

@@ -1,21 +0,0 @@
$Id: readme.txt,v 1.1 1999/05/15 07:23:34 ea Exp $
ReactOS Coders Console Parade
-----------------------------
The name "notevil" is from the well known Easter egg
of the "3D Text (OpenGL)" screen saver, which
displays the NT programmers' names if one writes
"not evil" in the text box.
To add a new name, add a new string in the
resource script notevil.rc (string index numbers must be
unique) and edit resource.h to update minimum and
maximum indices.
Eventually run make.
Written to test Win32 console functions implementation.
___________
19990411 EA

View File

@@ -1,2 +0,0 @@
#define RES_FIRST_INDEX 1
#define RES_LAST_INDEX 16

View File

@@ -1,12 +0,0 @@
This directory contains core applications that support the
ReactOS kernel.
Before you start to compile applications check the HOST
variable in 'rules.mak'.
The following is a short decription of each. Check the
readme.txt under each application for more details.
CMD: This is Eric Kohl's port of COMMAND for ReactOS.

View File

@@ -1,84 +0,0 @@
#
# Select your host
#
#HOST = mingw32-linux
HOST = mingw32-windows
#
# Important
#
.EXPORT_ALL_VARIABLES:
ifeq ($(HOST),mingw32-linux)
TOPDIR := $(shell if [ "$$PWD" != "" ]; then echo $$PWD; else pwd; fi)
endif
#
# Choose various options
#
ifeq ($(HOST),mingw32-linux)
PREFIX = i586-mingw32-
EXE_POSTFIX =
CP = cp
DLLTOOL = $(PREFIX)dlltool --as=$(PREFIX)as
FLOPPY_DIR = A/
# DIST_DIR should be relative from the top of the tree
DIST_DIR = dist
endif
ifeq ($(HOST),mingw32-windows)
PREFIX =
EXE_POSTFIX = .exe
CP = copy
DLLTOOL = $(PREFIX)dlltool --as=$(PREFIX)as
RM = del
DOSCLI = yes
FLOPPY_DIR = A:
# DIST_DIR should be relative from the top of the tree
DIST_DIR = dist
endif
#
# Create variables for all the compiler tools
#
ifeq ($(WITH_DEBUGGING),yes)
DEBUGGING_CFLAGS = -g
else
DEBUGGING_CFLAGS =
endif
ifeq ($(WARNINGS_ARE_ERRORS),yes)
EXTRA_CFLAGS = -Werror
endif
DEFINES = -DDBG
ifeq ($(WIN32_LEAN_AND_MEAN),yes)
LEAN_AND_MEAN_DEFINE = -DWIN32_LEAN_AND_MEAN
else
LEAN_AND_MEAN_DEFINE =
endif
CC = $(PREFIX)gcc
NATIVE_CC = gcc
CFLAGS = -O2 -Wall -Wstrict-prototypes -fno-builtin \
$(LEAN_AND_MEAN_DEFINE) $(DEFINES) $(DEBUGGING_CFLAGS) \
$(EXTRA_CFLAGS)
CXXFLAGS = $(CFLAGS)
LD = $(PREFIX)ld
NM = $(PREFIX)nm
OBJCOPY = $(PREFIX)objcopy
STRIP = $(PREFIX)strip
AS = $(PREFIX)gcc -c -x assembler-with-cpp
CPP = $(PREFIX)cpp
AR = $(PREFIX)ar
RC = $(PREFIX)windres
%.o: %.c
$(CC) $(CFLAGS) -c $< -o $@
%.coff: %.rc
$(RC) $< $@
RULES_MAK_INCLUDED = 1

View File

@@ -1,423 +0,0 @@
//======================================================================
//
// $Id: chkdsk.c,v 1.1 1999/05/16 07:27:35 ea Exp $
//
// Chkdskx
//
// Copyright (c) 1998 Mark Russinovich
// Systems Internals
// http://www.sysinternals.com/
//
// --------------------------------------------------------------------
//
// This software is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This software 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
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this software; see the file COPYING.LIB. If
// not, write to the Free Software Foundation, Inc., 675 Mass Ave,
// Cambridge, MA 02139, USA.
//
// --------------------------------------------------------------------
//
// Chkdsk clone that demonstrates the use of the FMIFS file system
// utility library.
//
// 1999 February (Emanuele Aliberti)
// Adapted for ReactOS and lcc-win32.
//
// 1999 April (Emanuele Aliberti)
// Adapted for ReactOS and egcs.
//
//======================================================================
#define UNICODE
#include <windows.h>
#include <stdio.h>
#include "fmifs.h"
#define _UNICODE 1
#include <tchar.h>
#include "config.h"
#include "win32err.h"
//
// Globals
//
BOOL Error = FALSE;
// switches
BOOL FixErrors = FALSE;
BOOL SkipClean = FALSE;
BOOL ScanSectors = FALSE;
BOOL Verbose = FALSE;
PWCHAR Drive = NULL;
WCHAR CurrentDirectory[1024];
#ifndef FMIFS_IMPORT_DLL
//
// FMIFS function
//
PCHKDSK Chkdsk;
#endif /* ndef FMIFS_IMPORT_DLL */
//--------------------------------------------------------------------
//
// CtrlCIntercept
//
// Intercepts Ctrl-C's so that the program can't be quit with the
// disk in an inconsistent state.
//
//--------------------------------------------------------------------
BOOL
WINAPI
CtrlCIntercept( DWORD dwCtrlType )
{
//
// Handle the event so that the default handler doesn't
//
return TRUE;
}
//----------------------------------------------------------------------
//
// Usage
//
// Tell the user how to use the program
//
// 19990216 EA Missing printf %s argument
//----------------------------------------------------------------------
VOID
Usage( PWCHAR ProgramName )
{
_tprintf(
L"\
Usage: %s [drive:] [-F] [-V] [-R] [-C]\n\n\
[drive:] Specifies the drive to check.\n\
-F Fixes errors on the disk.\n\
-V Displays the full path of every file on the disk.\n\
-R Locates bad sectors and recovers readable information.\n\
-C Checks the drive only if it is dirty.\n\n",
ProgramName
);
}
//----------------------------------------------------------------------
//
// ParseCommandLine
//
// Get the switches.
//
//----------------------------------------------------------------------
int
ParseCommandLine(
int argc,
WCHAR *argv []
)
{
int i;
BOOLEAN gotFix = FALSE;
BOOLEAN gotVerbose = FALSE;
BOOLEAN gotClean = FALSE;
BOOLEAN gotScan = FALSE;
for ( i = 1;
(i < argc);
i++
) {
switch( argv[i][0] )
{
case L'-':
case L'/':
switch( argv[i][1] )
{
case L'F':
case L'f':
if( gotFix ) return i;
FixErrors = TRUE;
gotFix = TRUE;
break;
case L'V':
case L'v':
if( gotVerbose) return i;
Verbose = TRUE;
gotVerbose = TRUE;
break;
case L'R':
case L'r':
if( gotFix ) return i;
ScanSectors = TRUE;
gotFix = TRUE;
break;
case L'C':
case L'c':
if( gotClean ) return i;
SkipClean = TRUE;
gotClean = TRUE;
break;
default:
return i;
}
break;
default:
if( Drive ) return i;
if( argv[i][1] != L':' ) return i;
Drive = argv[i];
break;
}
}
return 0;
}
//----------------------------------------------------------------------
//
// ChkdskCallback
//
// The file system library will call us back with commands that we
// can interpret. If we wanted to halt the chkdsk we could return FALSE.
//
//----------------------------------------------------------------------
BOOLEAN
__stdcall
ChkdskCallback(
CALLBACKCOMMAND Command,
DWORD Modifier,
PVOID Argument
)
{
PDWORD percent;
PBOOLEAN status;
PTEXTOUTPUT output;
//
// We get other types of commands,
// but we don't have to pay attention to them
//
switch( Command )
{
case PROGRESS:
percent = (PDWORD) Argument;
_tprintf(L"%d percent completed.\r", *percent);
break;
case OUTPUT:
output = (PTEXTOUTPUT) Argument;
fprintf(stdout, "%s", output->Output);
break;
case DONE:
status = (PBOOLEAN) Argument;
if( *status == TRUE ) {
_tprintf(L"Chkdsk was unable to complete successfully.\n\n");
Error = TRUE;
}
break;
}
return TRUE;
}
#ifndef FMIFS_IMPORT_DLL
//----------------------------------------------------------------------
//
// LoadFMIFSEntryPoints
//
// Loads FMIFS.DLL and locates the entry point(s) we are going to use
//
// 19990216 EA User wide functions
//
//----------------------------------------------------------------------
BOOLEAN
LoadFMIFSEntryPoints(VOID)
{
LoadLibraryW( L"fmifs.dll" );
if( !(Chkdsk =
(void *) GetProcAddress(
GetModuleHandleW(L"fmifs.dll"),
"Chkdsk" ))
)
{
return FALSE;
}
return TRUE;
}
#endif /* ndef FMIFS_IMPORT_DLL */
//----------------------------------------------------------------------
//
// WMain
//
// Engine. Just get command line switches and fire off a chkdsk. This
// could also be done in a GUI like Explorer does when you select a
// drive and run a check on it.
//
// We do this in UNICODE because the chkdsk command expects PWCHAR
// arguments.
//
//----------------------------------------------------------------------
int
wmain( int argc, WCHAR *argv[] )
{
int badArg;
HANDLE volumeHandle;
WCHAR fileSystem [1024];
WCHAR volumeName [1024];
DWORD serialNumber;
DWORD flags,
maxComponent;
wprintf(
L"\n\
Chkdskx v1.0 by Mark Russinovich\n\
Systems Internals - http://www.sysinternals.com/\n\
ReactOS adaptation 1999 by Emanuele Aliberti\n\n"
);
#ifndef FMIFS_IMPORT_DLL
//
// Get function pointers
//
if( !LoadFMIFSEntryPoints())
{
wprintf(L"Could not located FMIFS entry points.\n\n");
return -1;
}
#endif /* ndef FMIFS_IMPORT_DLL */
//
// Parse command line
//
if( (badArg = ParseCommandLine( argc, argv )))
{
wprintf(L"Unknown argument: %s\n", argv[badArg] );
Usage(argv[0]);
return -1;
}
//
// Get the drive's format
//
if( !Drive )
{
if( !GetCurrentDirectoryW(
sizeof(CurrentDirectory),
CurrentDirectory
)
) {
PrintWin32Error(
L"Could not get current directory",
GetLastError()
);
return -1;
}
} else {
wcscpy( CurrentDirectory, Drive );
}
CurrentDirectory[2] = L'\\';
CurrentDirectory[3] = L'\0';
Drive = CurrentDirectory;
//
// Determine the drive's file system format, which we need to
// tell chkdsk
//
if( !GetVolumeInformationW(
Drive,
volumeName,
sizeof volumeName,
& serialNumber,
& maxComponent,
& flags,
fileSystem,
sizeof fileSystem
)
) {
PrintWin32Error(
L"Could not query volume",
GetLastError()
);
return -1;
}
//
// If they want to fix, we need to have access to the drive
//
if ( FixErrors )
{
swprintf(
volumeName,
L"\\\\.\\%C:",
Drive[0]
);
volumeHandle = CreateFileW(
volumeName,
GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
0,
0
);
if( volumeHandle == INVALID_HANDLE_VALUE )
{
wprintf("Chdskx cannot run because the volume is in use by another process.\n\n");
return -1;
}
CloseHandle( volumeHandle );
//
// Can't let the user break out of a chkdsk that can modify the drive
//
SetConsoleCtrlHandler( CtrlCIntercept, TRUE );
}
//
// Just do it
//
wprintf(
"The type of file system is %s.\n",
fileSystem
);
Chkdsk(
Drive,
fileSystem,
FixErrors,
Verbose,
SkipClean,
ScanSectors,
NULL,
NULL,
ChkdskCallback
);
if ( Error ) return -1;
return 0;
}
/* EOF */

View File

@@ -1,185 +0,0 @@
/* $Id: chklib.c,v 1.1 1999/05/16 07:27:35 ea Exp $
*
* chklib.c
*
* Copyright (C) 1998, 1999 Emanuele Aliberti.
*
* --------------------------------------------------------------------
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This software 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this software; see the file COPYING.LIB. If
* not, write to the Free Software Foundation, Inc., 675 Mass Ave,
* Cambridge, MA 02139, USA.
*
* --------------------------------------------------------------------
* Check a PE DLL for loading and get an exported symbol's address
* (relocated).
*
*/
//#define UNICODE
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "win32err.h"
#ifdef DISPLAY_VERSION
static
void
DisplayVersion(
HANDLE dll,
PCHAR ModuleName
)
{
DWORD Zero;
DWORD Size;
PVOID vi = NULL;
assert(ModuleName);
Size = GetFileVersionInfoSize(
ModuleName,
& Zero
);
if (Size == 0)
{
PrintWin32Error(
L"GetFileVersionInfoSize",
GetLastError()
);
return;
}
vi = (PVOID) LocalAlloc(LMEM_ZEROINIT,Size);
if (!vi) return;
assert(dll != INVALID_HANDLE_VALUE);
if (0 == GetFileVersionInfo(
ModuleName,
(DWORD) dll,
Size,
vi
)
) {
PrintWin32Error(
L"GetFileVersionInfo",
GetLastError()
);
return;
}
/*
VerQueryValue(
vi,
L"\\StringFileInfo\\040904E4\\FileDescription",
& lpBuffer,
& dwBytes
);
*/
LocalFree(vi);
}
#endif /* def DISPLAY_VERSION */
static
void
DisplayEntryPoint(
const HANDLE dll,
LPCSTR SymbolName
)
{
FARPROC EntryPoint;
printf(
"[%s]\n",
SymbolName
);
EntryPoint = GetProcAddress(
dll,
SymbolName
);
if (!EntryPoint)
{
PrintWin32Error(
L"GetProcAddress",
GetLastError()
);
return;
}
printf(
"%08X %s\n",
EntryPoint,
SymbolName
);
}
/* --- MAIN --- */
int
main(
int argc,
char * argv []
)
{
HINSTANCE dll;
TCHAR ModuleName [_MAX_PATH];
if (argc != 2 && argc != 3)
{
fprintf(
stderr,
"\
ReactOS System Tools\n\
Check a Dynamic Link Library (DLL) for loading\n\
Copyright (c) 1998, 1999 Emanuele Aliberti\n\n\
usage: %s module [symbol]\n",
argv[0]
);
exit(EXIT_FAILURE);
}
dll = LoadLibraryA(argv[1]);
if (!dll)
{
UINT LastError;
LastError = GetLastError();
PrintWin32Error(L"LoadLibrary",LastError);
fprintf(
stderr,
"%s: loading %s failed (%d).\n",
argv[0],
argv[1],
LastError
);
exit(EXIT_FAILURE);
}
GetModuleFileName(
(HANDLE) dll,
ModuleName,
sizeof ModuleName
);
printf(
"%s loaded.\n",
ModuleName
);
#ifdef DISPLAY_VERSION
DisplayVersion(dll,ModuleName);
#endif
if (argc == 3) DisplayEntryPoint( dll, argv[2] );
FreeLibrary(dll);
printf(
"%s unloaded.\n",
ModuleName
);
return EXIT_SUCCESS;
}
/* EOF */

View File

@@ -1,6 +0,0 @@
#ifndef _INC_CONFIG_H
#define _INC_CONFIG_H
/* $Id: config.h,v 1.1 1999/05/16 07:27:35 ea Exp $ */
#define FMIFS_IMPORT_DLL
#define REACTOS_NO_SECURITY_SS
#endif /* ndef _INC_CONFIG_H */

View File

@@ -1,129 +0,0 @@
#ifndef _FMIFS_H
#define _FMIFS_H
/* $Id: fmifs.h,v 1.1 1999/05/16 07:27:35 ea Exp $
*
* fmifs.h
*
* Copyright (c) 1998 Mark Russinovich
* Systems Internals
* http://www.sysinternals.com
*
* Typedefs and definitions for using chkdsk and formatex
* functions exported by the fmifs.dll library.
*
* ---
*
* 1999-02-18 (Emanuele Aliberti)
* Normalized function names.
*
*/
#ifndef _INC_WINDOWS_
#include <windows.h>
#endif
/* Output command */
typedef
struct
{
DWORD Lines;
PCHAR Output;
} TEXTOUTPUT, *PTEXTOUTPUT;
/* Callback command types */
typedef
enum
{
PROGRESS,
DONEWITHSTRUCTURE,
UNKNOWN2,
UNKNOWN3,
UNKNOWN4,
UNKNOWN5,
INSUFFICIENTRIGHTS,
UNKNOWN7,
UNKNOWN8,
UNKNOWN9,
UNKNOWNA,
DONE,
UNKNOWNC,
UNKNOWND,
OUTPUT,
STRUCTUREPROGRESS
} CALLBACKCOMMAND;
/* FMIFS callback definition */
typedef
BOOL
(STDCALL * PFMIFSCALLBACK) (
CALLBACKCOMMAND Command,
DWORD SubAction,
PVOID ActionInfo
);
/* Chkdsk command in FMIFS */
VOID
STDCALL
ChkDsk(
PWCHAR DriveRoot,
PWCHAR Format,
BOOL CorrectErrors,
BOOL Verbose,
BOOL CheckOnlyIfDirty,
BOOL ScanDrive,
PVOID Unused2,
PVOID Unused3,
PFMIFSCALLBACK Callback
);
/* ChkdskEx command in FMIFS (not in the original) */
VOID
STDCALL
ChkDskEx(
PWCHAR DriveRoot,
PWCHAR Format,
BOOL CorrectErrors,
BOOL Verbose,
BOOL CheckOnlyIfDirty,
BOOL ScanDrive,
PVOID Unused2,
PVOID Unused3,
PFMIFSCALLBACK Callback
);
/* DiskCopy command in FMIFS */
VOID
STDCALL
DiskCopy(VOID);
/* Enable/Disable volume compression */
BOOL
STDCALL
EnableVolumeCompression(
PWCHAR DriveRoot,
BOOL Enable
);
/* Format command in FMIFS */
/* media flags */
#define FMIFS_HARDDISK 0xC
#define FMIFS_FLOPPY 0x8
VOID
STDCALL
FormatEx(
PWCHAR DriveRoot,
DWORD MediaFlag,
PWCHAR Format,
PWCHAR Label,
BOOL QuickFormat,
DWORD ClusterSize,
PFMIFSCALLBACK Callback
);
#endif /* ndef _FMIFS_H */

View File

@@ -1,646 +0,0 @@
//======================================================================
//
// $Id: format.c,v 1.1 1999/05/16 07:27:35 ea Exp $
//
// Formatx
//
// Copyright (c) 1998 Mark Russinovich
// Systems Internals
// http://www.sysinternals.com/
//
// This software is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This software 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
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this software; see the file COPYING.LIB. If
// not, write to the Free Software Foundation, Inc., 675 Mass Ave,
// Cambridge, MA 02139, USA.
//
// ---------------------------------------------------------------------
// Format clone that demonstrates the use of the FMIFS file system
// utility library.
//
// 1999 February (Emanuele Aliberti)
// Adapted for ReactOS and lcc-win32.
//
// 1999 April (Emanuele Aliberti)
// Adapted for ReactOS and egcs.
//
//======================================================================
#define UNICODE 1
#define _UNICODE 1
#include <windows.h>
#include <stdio.h>
#include "fmifs.h"
//#include <tchar.h>
#include "win32err.h"
#include "config.h"
#define WBUFSIZE(b) (sizeof(b) / sizeof (wchar_t))
//
// Globals
//
BOOL Error = FALSE;
// switches
BOOL QuickFormat = FALSE;
DWORD ClusterSize = 0;
BOOL CompressDrive = FALSE;
BOOL GotALabel = FALSE;
PWCHAR Label = L"";
PWCHAR Drive = NULL;
PWCHAR Format = L"FAT";
WCHAR RootDirectory [MAX_PATH];
WCHAR LabelString [12];
#ifndef FMIFS_IMPORT_DLL
//
// Functions in FMIFS.DLL
//
PFORMATEX FormatEx;
PENABLEVOLUMECOMPRESSION EnableVolumeCompression;
#endif /* ndef FMIFS_IMPORT_DLL */
//
// Size array
//
typedef
struct
{
WCHAR SizeString [16];
DWORD ClusterSize;
} SIZEDEFINITION, *PSIZEDEFINITION;
SIZEDEFINITION
LegalSizes [] =
{
{ L"512", 512 },
{ L"1024", 1024 },
{ L"2048", 2048 },
{ L"4096", 4096 },
{ L"8192", 8192 },
{ L"16K", 16384 },
{ L"32K", 32768 },
{ L"64K", 65536 },
{ L"128K", 65536 * 2 },
{ L"256K", 65536 * 4 },
{ L"", 0 },
};
//----------------------------------------------------------------------
//
// Usage
//
// Tell the user how to use the program
//
// 1990218 EA ProgramName missing in wprintf arg list
//
//----------------------------------------------------------------------
VOID
Usage( PWCHAR ProgramName )
{
wprintf(
L"\
Usage: %s drive: [-FS:file-system] [-V:label] [-Q] [-A:size] [-C]\n\n\
[drive:] Specifies the drive to format.\n\
-FS:file-system Specifies the type of file system (e.g. FAT).\n\
-V:label Specifies volume label.\n\
-Q Performs a quick format.\n\
-A:size Overrides the default allocation unit size. Default settings\n\
are strongly recommended for general use\n\
NTFS supports 512, 1024, 2048, 4096, 8192, 16K, 32K, 64K.\n\
FAT supports 8192, 16K, 32K, 64K, 128K, 256K.\n\
NTFS compression is not supported for allocation unit sizes\n\
above 4096.\n\
-C Files created on the new volume will be compressed by\n\
default.\n\n",
ProgramName
);
}
//----------------------------------------------------------------------
//
// ParseCommandLine
//
// Get the switches.
//
// 19990218 EA switch characters '-' and '/' are wide
//
//----------------------------------------------------------------------
int
ParseCommandLine(
int argc,
WCHAR *argv []
)
{
int i,
j;
BOOLEAN gotFormat = FALSE;
BOOLEAN gotQuick = FALSE;
BOOLEAN gotSize = FALSE;
BOOLEAN gotLabel = FALSE;
BOOLEAN gotCompressed = FALSE;
for (
i = 1;
(i < argc);
i++
) {
switch ( argv[i][0] )
{
case L'-':
case L'/':
if( !wcsnicmp( & argv[i][1], L"FS:", 3 ))
{
if( gotFormat) return -1;
Format = & argv[i][4];
gotFormat = TRUE;
}
else if( !wcsnicmp( & argv[i][1], L"A:", 2 ))
{
if ( gotSize ) return -1;
j = 0;
while ( LegalSizes[j].ClusterSize &&
wcsicmp(
LegalSizes[j].SizeString,
& argv[i][3]
)
) {
j++;
}
if( !LegalSizes[j].ClusterSize ) return i;
ClusterSize = LegalSizes[j].ClusterSize;
gotSize = TRUE;
}
else if( !wcsnicmp( & argv[i][1], L"V:", 2 ))
{
if( gotLabel ) return -1;
Label = & argv[i][3];
gotLabel = TRUE;
GotALabel = TRUE;
}
else if ( !wcsicmp( & argv[i][1], L"Q" ))
{
if( gotQuick ) return -1;
QuickFormat = TRUE;
gotQuick = TRUE;
}
else if ( !wcsicmp( & argv[i][1], L"C" ))
{
if( gotCompressed ) return -1;
CompressDrive = TRUE;
gotCompressed = TRUE;
}
else
{
return i;
}
break;
default:
if ( Drive ) return i;
if ( argv[i][1] != L':' ) return i;
Drive = argv[i];
break;
}
}
return 0;
}
//----------------------------------------------------------------------
//
// FormatExCallback
//
// The file system library will call us back with commands that we
// can interpret. If we wanted to halt the chkdsk we could return FALSE.
//
//----------------------------------------------------------------------
BOOLEAN
__stdcall
FormatExCallback(
CALLBACKCOMMAND Command,
DWORD Modifier,
PVOID Argument
)
{
PDWORD percent;
PTEXTOUTPUT output;
PBOOLEAN status;
//static createStructures = FALSE;
//
// We get other types of commands, but we don't have to pay attention to them
//
switch ( Command )
{
case PROGRESS:
percent = (PDWORD) Argument;
wprintf(L"%d percent completed.\r", *percent);
break;
case OUTPUT:
output = (PTEXTOUTPUT) Argument;
fprintf(stdout, "%s", output->Output);
break;
case DONE:
status = (PBOOLEAN) Argument;
if ( *status == FALSE )
{
wprintf(L"FormatEx was unable to complete successfully.\n\n");
Error = TRUE;
}
break;
}
return TRUE;
}
#ifndef FMIFS_IMPORT_DLL
//----------------------------------------------------------------------
//
// LoadFMIFSEntryPoints
//
// Loads FMIFS.DLL and locates the entry point(s) we are going to use
//
// 19990216 EA ANSI strings in LoadFMIFSEntryPoints should be
// wide strings
//
//----------------------------------------------------------------------
BOOLEAN
LoadFMIFSEntryPoints(VOID)
{
LoadLibraryW( L"fmifs.dll" );
if ( !(FormatEx =
(void *) GetProcAddress(
GetModuleHandleW( L"fmifs.dll"),
"FormatEx"
)
)
) {
return FALSE;
}
if ( !(EnableVolumeCompression =
(void *) GetProcAddress(
GetModuleHandleW( L"fmifs.dll"),
"EnableVolumeCompression"
)
)
) {
return FALSE;
}
return TRUE;
}
#endif /* ndef FMIFS_IMPORT_DLL */
//----------------------------------------------------------------------
//
// WMain
//
// Engine. Just get command line switches and fire off a format. This
// could also be done in a GUI like Explorer does when you select a
// drive and run a check on it.
//
// We do this in UNICODE because the chkdsk command expects PWCHAR
// arguments.
//
//----------------------------------------------------------------------
int
wmain( int argc, WCHAR *argv[] )
{
int badArg;
DWORD media;
DWORD driveType;
WCHAR fileSystem [1024];
WCHAR volumeName [1024];
WCHAR input [1024];
DWORD serialNumber;
DWORD flags,
maxComponent;
ULARGE_INTEGER freeBytesAvailableToCaller,
totalNumberOfBytes,
totalNumberOfFreeBytes;
wprintf( L"\
\nFormatx v1.0 by Mark Russinovich\n\
Systems Internals - http://www.sysinternals.com\n\
ReactOs adaptation 1999 by Emanuele Aliberti\n\n"
);
#ifndef FMIFS_IMPORT_DLL
//
// Get function pointers
//
if( !LoadFMIFSEntryPoints())
{
wprintf(L"Could not located FMIFS entry points.\n\n");
return -1;
}
#endif /* ndef FMIFS_IMPORT_DLL */
//
// Parse command line
//
if( (badArg = ParseCommandLine( argc, argv )))
{
wprintf(
L"Unknown argument: %s\n",
argv[badArg]
);
Usage(argv[0]);
return -1;
}
//
// Get the drive's format
//
if( !Drive )
{
wprintf(L"Required drive parameter is missing.\n\n");
Usage( argv[0] );
return -1;
}
else
{
wcscpy( RootDirectory, Drive );
}
RootDirectory[2] = L'\\';
RootDirectory[3] = L'\0';
//
// See if the drive is removable or not
//
driveType = GetDriveTypeW( RootDirectory );
if ( driveType != DRIVE_FIXED )
{
wprintf(
L"Insert a new floppy in drive %C:\nand press Enter when ready...",
RootDirectory[0]
);
fgetws(
input,
WBUFSIZE(input),
stdin
);
media = FMIFS_FLOPPY;
}
//
// Determine the drive's file system format
//
if ( !GetVolumeInformationW(
RootDirectory,
volumeName,
WBUFSIZE(volumeName),
& serialNumber,
& maxComponent,
& flags,
fileSystem,
WBUFSIZE(fileSystem) )
) {
PrintWin32Error(
L"Could not query volume",
GetLastError()
);
return -1;
}
if( !GetDiskFreeSpaceExW(
RootDirectory,
& freeBytesAvailableToCaller,
& totalNumberOfBytes,
& totalNumberOfFreeBytes )
)
{
PrintWin32Error(
L"Could not query volume size",
GetLastError()
);
return -1;
}
wprintf(
L"The type of the file system is %s.\n",
fileSystem
);
//
// Make sure they want to do this
//
if ( driveType == DRIVE_FIXED )
{
if ( volumeName[0] )
{
while (1)
{
wprintf(
L"Enter current volume label for drive %C: ",
RootDirectory[0]
);
fgetws(
input,
WBUFSIZE(input),
stdin
);
input[ wcslen( input ) - 1 ] = 0;
if ( !wcsicmp( input, volumeName ))
{
break;
}
wprintf(L"An incorrect volume label was entered for this drive.\n");
}
}
while ( 1 )
{
wprintf(L"\nWARNING, ALL DATA ON NON_REMOVABLE DISK\n");
wprintf(L"DRIVE %C: WILL BE LOST!\n", RootDirectory[0] );
wprintf(L"Proceed with Format (Y/N)? " );
fgetws(
input,
WBUFSIZE(input),
stdin
);
if ( (input[0] == L'Y') || (input[0] == L'y') ) break;
if ( (input[0] == L'N') || (input[0] == L'n') )
{
wprintf(L"\n");
return 0;
}
}
media = FMIFS_HARDDISK;
}
//
// Tell the user we're doing a long format if appropriate
//
if ( !QuickFormat )
{
if ( totalNumberOfBytes.QuadPart > 1024*1024*10 )
{
wprintf(
L"Verifying %dM\n",
(DWORD) (totalNumberOfBytes.QuadPart/(1024*1024))
);
}
else
{
wprintf(
L"Verifying %.1fM\n",
((float)(LONGLONG)totalNumberOfBytes.QuadPart)/(float)(1024.0*1024.0)
);
}
}
else
{
if ( totalNumberOfBytes.QuadPart > 1024*1024*10 )
{
wprintf(
L"QuickFormatting %dM\n",
(DWORD) (totalNumberOfBytes.QuadPart / (1024 * 1024))
);
}
else
{
wprintf(
L"QuickFormatting %.2fM\n",
((float)(LONGLONG)totalNumberOfBytes.QuadPart) / (float)(1024.0*1024.0)
);
}
wprintf(L"Creating file system structures.\n");
}
//
// Format away!
//
FormatEx(
RootDirectory,
media,
Format,
Label,
QuickFormat,
ClusterSize,
FormatExCallback
);
if ( Error ) return -1;
wprintf(L"Format complete.\n");
//
// Enable compression if desired
//
if ( CompressDrive )
{
if( !EnableVolumeCompression( RootDirectory, TRUE ))
{
wprintf(L"Volume does not support compression.\n");
}
}
//
// Get the label if we don't have it
//
if( !GotALabel )
{
wprintf(L"Volume Label (11 characters, Enter for none)? " );
fgetws(
input,
WBUFSIZE(LabelString),
stdin
);
input[ wcslen(input) - 1 ] = 0;
if( !SetVolumeLabelW( RootDirectory, input ))
{
PrintWin32Error(
L"Could not label volume",
GetLastError()
);
return -1;
}
}
if ( !GetVolumeInformationW(
RootDirectory,
volumeName,
WBUFSIZE(volumeName),
& serialNumber,
& maxComponent,
& flags,
fileSystem,
WBUFSIZE(fileSystem) )
) {
PrintWin32Error(
L"Could not query volume",
GetLastError()
);
return -1;
}
//
// Print out some stuff including the formatted size
//
if ( !GetDiskFreeSpaceExW(
RootDirectory,
& freeBytesAvailableToCaller,
& totalNumberOfBytes,
& totalNumberOfFreeBytes )
) {
PrintWin32Error(
L"Could not query volume size",
GetLastError()
);
return -1;
}
wprintf(
L"\n%I64d bytes total disk space.\n",
totalNumberOfBytes.QuadPart
);
wprintf(
L"%I64d bytes available on disk.\n",
totalNumberOfFreeBytes.QuadPart
);
//
// Get the drive's serial number
//
if ( !GetVolumeInformationW(
RootDirectory,
volumeName,
WBUFSIZE(volumeName),
& serialNumber,
& maxComponent,
& flags,
fileSystem,
WBUFSIZE(fileSystem) )
) {
PrintWin32Error(
L"Could not query volume",
GetLastError()
);
return -1;
}
wprintf(
L"\nVolume Serial Number is %04X-%04X\n",
serialNumber >> 16,
serialNumber & 0xFFFF
);
return 0;
}
/* EOF */

View File

@@ -1,108 +0,0 @@
# $Id: makefile,v 1.2 1999/10/03 22:12:07 ekohl Exp $
#
# ReactOS System Utilities
#
# 1999-02-16 (Emanuele Aliberti)
# Added chkdskx.c and formatx.c by by Mark Russinovich
# (mark@sysinternals.com) and shutdown.c
#
# 1999-03-03 (Emanuele Aliberti)
# Added login.c and chklib.c
#
# 1999-03-16 (Emanuele Aliberti)
# Added regnav.c
#
ROSINC=../../reactos/include
TARGET=regnav.exe
# chkdsk.exe format.exe \
# chklib.exe shutdown.exe regnav.exe
# login.exe chklib.exe shutdown.exe regnav.exe
all: $(TARGET)
# By Mark Russinovich
chkdsk.exe: chkdsk.o win32err.o wmain.o
$(CC) chkdsk.o win32err.o wmain.o \
-o chkdsk.exe \
-lkernel32 \
-lcrtdll \
-lfmifs
$(NM) --numeric-sort chkdsk.exe > chkdsk.sym
format.exe: format.o win32err.o wmain.o
$(CC) format.o win32err.o wmain.o \
-o format.exe \
-lkernel32 \
-lcrtdll \
-lfmifs
$(NM) --numeric-sort format.exe > format.sym
#---
#login.exe: login.o
# $(CC) login.o \
# -o login.exe \
# -lntdll \
# -Wl,--subsystem native:4.0
# $(NM) --numeric-sort login.exe > login.sym
chklib.exe: chklib.o win32err.o
$(CC) chklib.o win32err.o \
-o chklib.exe \
-lkernel32 \
-lcrtdll
$(NM) --numeric-sort chklib.exe > chklib.sym
regnav.exe: regnav.o win32err.o
$(CC) regnav.o win32err.o \
-o regnav.exe \
-lkernel32 \
-lcrtdll
$(NM) --numeric-sort regnav.exe > regnav.sym
shutdown.exe: shutdown.o win32err.o
$(CC) shutdown.o win32err.o \
-o shutdown.exe \
-lkernel32 \
-luser32 \
-lcrtdll
$(NM) --numeric-sort shutdown.exe > shutdown.sym
#---
CLEAN_FILES = *.o *.exe *.sym
clean: $(CLEAN_FILES:%=%_clean)
$(CLEAN_FILES:%=%_clean): %_clean:
- $(RM) $*
.phony: clean $(CLEAN_FILES:%=%_clean)
floppy: $(TARGET:%=$(FLOPPY_DIR)/apps/%)
$(TARGET:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* $(FLOPPY_DIR)\apps\$*
else
$(CP) $* $(FLOPPY_DIR)/apps/$*
endif
dist: $(TARGET:%=../$(DIST_DIR)/apps/%)
$(TARGET:%=../$(DIST_DIR)/apps/%): ../$(DIST_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* ..\$(DIST_DIR)\apps\$*
else
$(CP) $* ../$(DIST_DIR)/apps/$*
endif
include ../rules.mak
# EOF

View File

@@ -1,634 +0,0 @@
/* $Id: regnav.c,v 1.2 1999/05/28 19:49:46 ea Exp $
*
* regnav.c
*
* Copyright (c) 1998, 1999 Emanuele Aliberti
*
* --------------------------------------------------------------------
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This software 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this software; see the file COPYING.LIB. If
* not, write to the Free Software Foundation, Inc., 675 Mass Ave,
* Cambridge, MA 02139, USA.
*
* --------------------------------------------------------------------
* ReactOS system registry console navigation tool.
*/
//#define UNICODE
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
#include <assert.h>
#include "win32err.h"
#define INPUT_BUFFER_SIZE 512
#define COMMAND_NOT_FOUND NULL
#define CURRENT_PATH_SIZE 1024
LPCTSTR STR_HKEY_CLASSES_ROOT = _TEXT("HKEY_CLASSES_ROOT");
LPCTSTR STR_HKEY_CURRENT_USER = _TEXT("HKEY_CURRENT_USER");
LPCTSTR STR_HKEY_LOCAL_MACHINE = _TEXT("HKEY_LOCAL_MACHINE");
LPCTSTR STR_HKEY_USERS = _TEXT("HKEY_USERS");
LPCTSTR STR_HKEY_CURRENT_CONFIG = _TEXT("HKEY_CURRENT_CONFIG");
LPCTSTR STR_HKEY_PERFORMANCE_DATA = _TEXT("HKEY_PERFORMANCE_DATA");
LPTSTR app_name = _TEXT("regnav");
LPCTSTR app_ver = _TEXT("1.0.4");
HANDLE CurrentWorkingKey = INVALID_HANDLE_VALUE; /* \ */
TCHAR CurrentPath [CURRENT_PATH_SIZE] = _TEXT("\\");
BOOL Done = FALSE;
INT LastExitCode = 0;
/* === COMMANDS === */
#define CMDPROTOIF (int argc,LPTSTR argv[])
typedef int (*CommandFunction) CMDPROTOIF;
#define CMDPROTO(n) int n CMDPROTOIF
typedef
struct _COMMAND_DESCRIPTOR
{
LPCTSTR Name;
LPCTSTR ShortDescription;
LPCTSTR Usage;
CommandFunction Command;
int MinArgc;
int MaxArgc;
} COMMAND_DESCRIPTOR, * PCOMMAND_DESCRIPTOR;
CMDPROTO(cmd_ck);
CMDPROTO(cmd_exit);
CMDPROTO(cmd_help);
CMDPROTO(cmd_ls);
CMDPROTO(cmd_pwk);
CMDPROTO(cmd_ver);
COMMAND_DESCRIPTOR
CommandsTable [] =
{
{
_TEXT("ck"),
_TEXT("Change the working key."),
_TEXT("CK key\n\nChange the working key."),
cmd_ck,
1,
2
},
{
_TEXT("exit"),
_TEXT("Terminate the application."),
_TEXT("EXIT\n\nTerminate the application."),
cmd_exit,
1,
1
},
{
_TEXT("help"),
_TEXT("Print this commands summary, or a command's synopsis."),
_TEXT("HELP [command]\n\nPrint commands summary, or a command's synopsis."),
cmd_help,
1,
2
},
{
_TEXT("ls"),
_TEXT("List a key's values and subkeys."),
_TEXT("LS [key]\n\nList a key's values and subkeys."),
cmd_ls,
1,
2
},
{
_TEXT("pwk"),
_TEXT("Print the current working key."),
_TEXT("PWK\n\nPrint the current working key."),
cmd_pwk,
1,
1
},
{
_TEXT("ver"),
_TEXT("Print version information."),
_TEXT("VER\n\nPrint version information."),
cmd_ver,
1,
1
},
/* End of array marker */
{ NULL }
};
/* === CMD MANAGER === */
PCOMMAND_DESCRIPTOR
DecodeVerb( LPCTSTR Name )
{
register int i;
for ( i = 0;
CommandsTable[i].Name;
++i
)
{
if (0 == lstrcmpi(CommandsTable[i].Name,Name))
{
return & CommandsTable[i];
}
}
return COMMAND_NOT_FOUND;
}
/* === Visual key name manager */
typedef
struct _SPLIT_KEY_NAME
{
TCHAR Host [32];
HANDLE Hive;
TCHAR SubKey [_MAX_PATH];
} SPLIT_KEY_NAME, * PSPLIT_KEY_NAME;
PSPLIT_KEY_NAME
ParseKeyName(
LPTSTR KeyName,
PSPLIT_KEY_NAME k
)
{
TCHAR *r = KeyName;
TCHAR *w = NULL;
TCHAR SystemKey [64];
assert(r && k);
ZeroMemory( k, sizeof (SPLIT_KEY_NAME) );
k->Hive = INVALID_HANDLE_VALUE;
/* HOST */
if (r[0] == _TEXT('\\') && r[1] == _TEXT('\\'))
{
for ( r += 2, w = k->Host;
(*r && (*r != _TEXT('\\')));
++r
) {
*w++ = *r;
}
if (w) *w = _TEXT('\0');
}
/* SYSTEM KEY */
if (*r == _TEXT('\\')) ++r;
for ( w = SystemKey;
(*r && (*r != _TEXT('\\')));
++r
) {
*w++ = *r;
}
if (w) *w = _TEXT('\0');
if (0 == lstrcmpi(STR_HKEY_CLASSES_ROOT, SystemKey))
{
k->Hive = HKEY_CLASSES_ROOT;
}
else if (0 == lstrcmpi(STR_HKEY_CURRENT_USER, SystemKey))
{
k->Hive = HKEY_CURRENT_USER;
}
else if (0 == lstrcmpi(STR_HKEY_LOCAL_MACHINE, SystemKey))
{
k->Hive = HKEY_LOCAL_MACHINE;
}
else if (0 == lstrcmpi(STR_HKEY_USERS, SystemKey))
{
k->Hive = HKEY_USERS;
}
else if (0 == lstrcmpi(STR_HKEY_CURRENT_CONFIG, SystemKey))
{
k->Hive = HKEY_CURRENT_CONFIG;
}
else if (0 == lstrcmpi(STR_HKEY_PERFORMANCE_DATA, SystemKey))
{
k->Hive = HKEY_PERFORMANCE_DATA;
}
/* SUBKEY */
if (*r == _TEXT('\\')) ++r;
for ( w = k->SubKey;
(*r);
++r
) {
*w++ = *r;
}
if (w) *w = _TEXT('\0');
/* OK */
return k;
}
/* === COMMANDS === */
/**********************************************************************
* ck
*
* DESCRIPTION
* Change the current working key.
*/
CMDPROTO(cmd_ck)
{
LONG rv;
SPLIT_KEY_NAME k;
if (0 == lstrcmp(argv[1], _TEXT("..")))
{
_tprintf( _TEXT("Change to parent not implemented yet.\n") );
return EXIT_FAILURE;
}
if (INVALID_HANDLE_VALUE != CurrentWorkingKey)
{
RegCloseKey(CurrentWorkingKey);
CurrentWorkingKey = INVALID_HANDLE_VALUE;
}
if (NULL == ParseKeyName(argv[1], &k))
{
return EXIT_FAILURE;
}
rv = RegOpenKeyEx(
k.Hive, /* handle of open key */
k.SubKey, /* address of name of subkey to open */
0, /* reserved */
(REGSAM) KEY_ENUMERATE_SUB_KEYS,/* security access mask */
& CurrentWorkingKey /* address of handle of open key */
);
if (ERROR_SUCCESS != rv)
{
PrintWin32Error(L"RegOpenKeyEx",GetLastError());
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/**********************************************************************
* exit
*
* DESCRIPTION
* Terminate.
*/
CMDPROTO(cmd_exit)
{
Done = TRUE;
_tprintf( _TEXT("Quitting...\n") );
return EXIT_SUCCESS;
}
/**********************************************************************
* help
*
* DESCRIPTION
* Print help.
*/
CMDPROTO(cmd_help)
{
PCOMMAND_DESCRIPTOR cd = NULL;
if (1 == argc)
{
int CommandIndex;
for ( CommandIndex = 0;
(CommandsTable[CommandIndex].Name);
CommandIndex++
)
{
_tprintf(
_TEXT("%s\t%s\n"),
CommandsTable[CommandIndex].Name,
CommandsTable[CommandIndex].ShortDescription
);
}
return EXIT_SUCCESS;
}
if ((cd = DecodeVerb(argv[1])))
{
_tprintf(
_TEXT("%s\n"),
cd->Usage
);
return EXIT_SUCCESS;
}
_tprintf(
_TEXT("Unknown help item \"%s\".\n"),
argv[1]
);
return EXIT_FAILURE;
}
/**********************************************************************
* ls
*
* DESCRIPTION
* List a key.
*/
CMDPROTO(cmd_ls)
{
LONG rv;
DWORD dwIndexK = 0;
DWORD dwIndexV = 0;
UCHAR Name [256];
DWORD cbName;
UCHAR Class [256];
DWORD cbClass;
UCHAR Data [1024];
DWORD cbData;
DWORD Type;
FILETIME ft;
SYSTEMTIME st;
/* _self is always present */
_tprintf( _TEXT(".\\\n") );
/* _root directory? */
if (INVALID_HANDLE_VALUE == CurrentWorkingKey)
{
_tprintf(
_TEXT("%s\\\n"),
STR_HKEY_CLASSES_ROOT
);
_tprintf(
_TEXT("%s\\\n"),
STR_HKEY_CURRENT_USER
);
_tprintf(
_TEXT("%s\\\n"),
STR_HKEY_LOCAL_MACHINE
);
_tprintf(
_TEXT("%s\\\n"),
STR_HKEY_USERS
);
_tprintf(
_TEXT("%s\\\n"),
STR_HKEY_CURRENT_CONFIG
);
_tprintf(
_TEXT("%s\\\n"),
STR_HKEY_PERFORMANCE_DATA
);
return EXIT_SUCCESS;
}
/* _parent is present only if _self != _root
* (FIXME: change it when RegConnect... available)
*/
_tprintf( _TEXT("..\\\n") );
/* Enumerate subkeys of the current key. */
do {
cbName = sizeof(Name);
cbClass = sizeof(Class);
rv = RegEnumKeyEx(
CurrentWorkingKey, /* handle of key to enumerate */
dwIndexK, /* index of subkey to enumerate */
Name, /* address of buffer for subkey name */
& cbName, /* address for size of subkey buffer */
NULL, /* reserved */
Class, /* address of buffer for class string */
& cbClass, /* address for size of class buffer */
& ft /* address for time key last written to */
);
if (ERROR_SUCCESS == rv)
{
FileTimeToSystemTime( & ft, & st );
if (cbClass)
_tprintf(
_TEXT("%-32s\\ %4d-%02d-%02d %02d:%02d [%s]\n"),
Name,
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute,
Class
);
else
_tprintf(
_TEXT("%-32s\\ %4d-%02d-%02d %02d:%02d\n"),
Name,
st.wYear, st.wMonth, st.wDay,
st.wHour, st.wMinute
);
++dwIndexK;
}
} while (ERROR_SUCCESS == rv);
/* Enumerate key's values */
do {
cbName = sizeof(Name);
cbData = sizeof(Data);
rv = RegEnumValue(
CurrentWorkingKey, /* handle of key to query */
dwIndexV, /* index of value to query */
Name, /* address of buffer for value string */
& cbName, /* address for size of value buffer */
NULL, /* reserved */
& Type, /* address of buffer for type code */
Data, /* address of buffer for value data */
& cbData /* address for size of data buffer */
);
if (ERROR_SUCCESS == rv)
{
switch (Type)
{
case REG_DWORD:
_tprintf(
_TEXT("%s = *REG_DWORD*\n"),
Name
);
break;
case REG_EXPAND_SZ:
/* expand env vars */
break;
case REG_LINK:
/* reparse! */
break;
case REG_SZ:
_tprintf(
_TEXT("%s = \"%s\"\n"),
Name,
Data
);
break;
}
++dwIndexV;
}
} while (ERROR_SUCCESS == rv);
return (UINT) dwIndexK + (UINT) dwIndexV;
}
/**********************************************************************
* pwk
*
* DESCRIPTION
* Print the current working key.
*/
CMDPROTO(cmd_pwk)
{
if (INVALID_HANDLE_VALUE == CurrentWorkingKey)
{
_tprintf( _TEXT("[\\]\n") );
return EXIT_SUCCESS;
}
_tprintf(
_TEXT("[%s]\n"),
CurrentPath
);
return EXIT_SUCCESS;
}
/**********************************************************************
* ver
*
* DESCRIPTION
* Print version information.
*/
CMDPROTO(cmd_ver)
{
_tprintf(
_TEXT("\
%s version %s (compiled on %s, at %s)\n\
ReactOS Console Registry Navigator\n\
Copyright (c) 1998, 1999 Emanuele Aliberti\n\n"),
app_name,
app_ver,
_TEXT(__DATE__),
_TEXT(__TIME__)
);
return EXIT_SUCCESS;
}
/* === UTILITIES === */
#define ARGV_SIZE 32
INT
ParseCommandLine(
LPTSTR InputBuffer,
LPTSTR argv[]
)
{
register INT n = 0;
register TCHAR *c = InputBuffer;
assert(InputBuffer);
do
{
for ( ;
( *c
&& ( (*c == _TEXT(' '))
|| (*c == _TEXT('\t'))
|| (*c == _TEXT('\n'))
)
);
++c
);
argv[n++] = c;
if (*c)
{
for ( ;
( *c
&& (*c != _TEXT(' '))
&& (*c != _TEXT('\t'))
&& (*c != _TEXT('\n'))
);
++c
);
*c++ = _TEXT('\0');
}
} while ( *c );
return n;
}
VOID
DisplayPrompt(VOID)
{
_tprintf(
_TEXT("[%s] "),
CurrentPath
);
}
/* === MAIN === */
int
main(
int argc,
char * argv []
)
{
TCHAR InputBuffer [INPUT_BUFFER_SIZE];
PCOMMAND_DESCRIPTOR cd;
INT LocalArgc;
LPTSTR LocalArgv [ARGV_SIZE];
while (!Done)
{
DisplayPrompt();
_fgetts(
InputBuffer,
(sizeof InputBuffer / sizeof (TCHAR)),
stdin
);
if (0 == lstrlen(InputBuffer)) continue;
LocalArgc = ParseCommandLine(InputBuffer, LocalArgv);
if (LocalArgc && (cd = DecodeVerb(LocalArgv[0])))
{
if (LocalArgc < cd->MinArgc)
{
_tprintf(
_TEXT("Too few arguments. Type \"HELP %s\".\n"),
LocalArgv[0]
);
continue;
}
if (LocalArgc > cd->MaxArgc)
{
_tprintf(
_TEXT("Too many arguments. Type \"HELP %s\".\n"),
LocalArgv[0]
);
continue;
}
LastExitCode = cd->Command(
LocalArgc,
LocalArgv
);
continue;
}
_tprintf(
_TEXT("Unknown command (\"%s\").\n"),
LocalArgv[0]
);
}
return EXIT_SUCCESS;
}
/* EOF */

View File

@@ -1,181 +0,0 @@
/* $Id: shutdown.c,v 1.1 1999/05/16 07:27:35 ea Exp $
*
* EAU shutdown.c 1.4.1
*
* Copyright (C) 1997,1998,1999 Emanuele Aliberti
*
* --------------------------------------------------------------------
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This software 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this software; see the file COPYING.LIB. If
* not, write to the Free Software Foundation, Inc., 675 Mass Ave,
* Cambridge, MA 02139, USA.
*
* --------------------------------------------------------------------
* 1999-05-14 (Emanuele Aliberti)
* Released version 1.4.1 under GNU GPL for the ReactOS project.
* --------------------------------------------------------------------
*/
#define UNICODE
#define _UNICODE
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
#include "win32err.h"
struct _EWX
{
CHAR mode;
UINT id;
};
static
struct _EWX modes[] =
{
{ 'f', EWX_FORCE },
{ 'l', EWX_LOGOFF },
{ 'p', EWX_POWEROFF },
{ 'r', EWX_REBOOT },
{ 's', EWX_SHUTDOWN },
{ 0, 0 }
};
static
UINT
DecodeArg( CHAR * modestr )
{
register int i;
if (modestr[0] != '-' && modestr[0] != '/')
{
return (UINT) -1;
}
for ( i = 0; modes[i].mode; ++i)
{
if (modestr[1] == modes[i].mode)
{
return modes[i].id;
}
}
return (UINT) -1;
}
static
const
char * usage = "\
Shutdown ver. 1.4.1 (compiled on %s, at %s)\n\
Copyright (C) 1997-1999 Emanuele Aliberti\n\n\
usage: %s [-f] [-l] [-p] [-r] [-s]\n\
f (FORCE) processes are unconditionally terminated\n\
l (LOGOFF) logs the current user off\n\
p (POWEROFF) turns off the power, if possibile\n\
r (REBOOT) reboots the system\n\
s (SHUTDOWN) shuts down the system to a point at which\n\
it is safe to turn off the power\n\n\
Any other letter will print this help message.\n";
int
main(
int argc,
char * argv []
)
{
UINT mode;
HANDLE h;
TOKEN_PRIVILEGES tp;
mode = (argc == 2)
? DecodeArg(argv[1])
: DecodeArg("-?");
if (mode == (UINT) -1)
{
fprintf(
stderr,
usage,
__DATE__,
__TIME__,
argv[0]
);
return EXIT_SUCCESS;
}
/*
* Get the current process token handle
* so we can get shutdown privilege.
*/
if (FALSE == OpenProcessToken(
GetCurrentProcess(),
(TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY),
& h
)
) {
PrintWin32Error(
L"while opening the process",
GetLastError()
);
return EXIT_FAILURE;
}
/*
* Get the LUID for shutdown privilege.
*/
if (FALSE == LookupPrivilegeValue(
NULL,
SE_SHUTDOWN_NAME,
& tp.Privileges[0].Luid
)
) {
PrintWin32Error(
L"while looking up privileges",
GetLastError()
);
return EXIT_FAILURE;
}
tp.PrivilegeCount = 1; /* One privilege to seat */
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
/*
* Get shutdown privilege for this process.
*/
if (FALSE == AdjustTokenPrivileges(
h,
FALSE,
& tp,
0,
(PTOKEN_PRIVILEGES) NULL,
0
)
) {
PrintWin32Error(
L"while adjusting shutdown privilege",
GetLastError()
);
return EXIT_FAILURE;
}
/* Now really exit! */
if (FALSE == ExitWindowsEx(mode, 0))
{
PrintWin32Error(
L"ExitWindowsEx",
GetLastError()
);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/* EOF */

View File

@@ -1,70 +0,0 @@
/* $Id: win32err.c,v 1.1 1999/05/16 07:27:35 ea Exp $
*
* win32err.c
*
* Copyright (c) 1998 Mark Russinovich
* Systems Internals
* http://www.sysinternals.com/
*
* --------------------------------------------------------------------
*
* This software is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This software 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this software; see the file COPYING.LIB. If
* not, write to the Free Software Foundation, Inc., 675 Mass Ave,
* Cambridge, MA 02139, USA.
*
* --------------------------------------------------------------------
*
* Print a Win32 error.
*
* 1999 February (Emanuele Aliberti)
* Taken from chkdskx.c and formatx.c by Mark Russinovich
* to be used in all sysutils.
*/
#include <windows.h>
#include <stdio.h>
//----------------------------------------------------------------------
//
// PrintWin32Error
//
// Takes the win32 error code and prints the text version.
//
//----------------------------------------------------------------------
void
PrintWin32Error(
PWCHAR Message,
DWORD ErrorCode
)
{
LPVOID lpMsgBuf;
FormatMessageW(
(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM),
NULL,
ErrorCode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(PWCHAR) & lpMsgBuf,
0,
NULL
);
wprintf(
L"%s: %s\n",
Message,
lpMsgBuf
);
LocalFree( lpMsgBuf );
}
/* EOF */

View File

@@ -1,12 +0,0 @@
#ifndef _INC_WIN32ERR_H
#define _INC_WIN32ERR_H
/* $Id: win32err.h,v 1.1 1999/05/16 07:27:35 ea Exp $ */
#ifndef _GNU_H_WINDOWS_H
#include <windows.h>
#endif /* ndef _GNU_H_WINDOWS_H */
VOID
PrintWin32Error(
PWCHAR Message,
DWORD ErrorCode
);
#endif /* ndef _INC_WIN32ERR_H */

View File

@@ -1,52 +0,0 @@
/* $Id: wmain.c,v 1.1 1999/05/16 07:27:35 ea Exp $
*
* Entry point for programs that use wmain()
*/
#include <windows.h>
#include <stdio.h>
int wmain(int argc,wchar_t *argv[]);
wchar_t *
a2w( char * a, wchar_t * w )
{
wchar_t * ww = w;
while (*a) *w++ = (wchar_t) *a++;
*w = 0;
return ww;
}
wchar_t *
fgetws(wchar_t *buf, int bufsize, FILE *file)
{
char * abuf = GlobalAlloc(bufsize,0);
if (!buf)return NULL;
fgets(abuf,bufsize,file);
a2w(abuf,buf);
GlobalFree(abuf);
return buf;
}
int main(int argc, char *argv[])
{
wchar_t ** wargv;
int i;
int ec;
wargv = (wchar_t **) GlobalAlloc(
sizeof(void*) * argc,
0
);
for(i=0;i<argc;++i)
{
wargv[i] = (wchar_t*) GlobalAlloc(
sizeof(wchar_t) * (1+lstrlenA(argv[i])),
0
);
a2w(argv[i],wargv[i]);
}
wargv[i] = NULL;
ec = wmain(argc,wargv);
for (i=0;wargv[i];++i) GlobalFree(wargv[i]);
return ec;
}