PROGRAM FileAttributes;

{$G128,P128,D-} 							{010,001}

CONST

    ProgramVersion = '1.0';

(***********************************************************************

     This software has been placed into the public domain by Digital
			 Equipment Corporation.


DISCLAIMER:

The information herein is subject to change without  notice  and  should
not be construed as a commitment by Digital Equipment Corporation.

Digital Equipment Corporation assumes no responsibility for the  use  or
reliability  of  this  software.   This  software  is  provided "as is,"
without any warranty of any kind, express or implied.  Digital Equipment
Corporation  will  not	be liable in any event for any damages including
any loss of data, profit, or savings, claims against  the  user  by  any
other  party,  or  any other incidental or consequential damages arising
out of the use of, or inability to use, this software, even  if  Digital
Equipment Corporation is advised of the possibility of such damage.

DEFECT REPORTING AND SUGGESTIONS:

Please send reports of defects or suggestions for  improvement	directly
to the author:

	Brian Hetrick
	Digital Equipment Corporation
	110 Spit Brook Road  ZKO1-3/J10
	Nashua NH  03062-2698

Do NOT file a Software Performance Report on  this  software,  call  the
Telephone  Support  Center regarding this software, contact your Digital
Field Office  regarding  this  software,  or  use  any	other  mechanism
provided for Digital's supported and warranted software.


FACILITY:

    MS-DOS user utilities

ABSTRACT:

    Manipulates attributes of files

ENVIRONMENT:

    MS-DOS V2.0 or later compiled  with  Borland  International's  TURBO
    Pascal V3.0 or later

AUTHOR: Brian Hetrick, CREATION DATE: 24 November 1986.

MODIFIED BY:

	Brian Hetrick, 24-Nov-86: Version Y1.0-0
  000 - Original creation of module.
	Released to selected Easynet sites for beta test on 24	November
	1986.

	Brian Hetrick, 02-Dec-86: Version Y1.0-8
  001 - Add Gn, Pn compiler directives for compilation on IBM PC clones.
  002 - Modify IsPrefix routine to PrefixLength for  command  qualifiers
	starting with same letter.
  003 - Parse command qualifiers before and after parsing file spec,  as
	bad  command  qualifier  with no file spec prompts for file spec
	before detecting bad command qualifer.
  004 - Add /CLEAR and /REMOVE synonyms for /RESET.
  005 - Add help message if no command line given.
  006 - Allow multiple wild card specs.
  007 - Make path specifications absolute before reporting.
  008 - List file names on left side of display.
	Released to selected Easynet sites for beta test on  2	December
	1986.

	Brian Hetrick, 16-Dec-86: Version Y1.0-14
  009 - Use CtlCTrap package to trap CTRL/C, as  TURBO	Pascal's  CTRL/C
	is  not  as desired.  The undesired behavior (waiting for a Read
	or ReadLn to abort the program) appears to occur only on  MS-DOS
	or  PC-DOS  V2.x.  The PC-DOS specific TURBO Pascal had this un-
	desired behavior all along, but MS-DOS generic TURBO Pascals be-
	fore version 3.02A did not have this  behavior	on  the  Rainbow
	(due to a bug in how the TURBO CTRL/C handler was set up), where
	most testing occurred.	The undesired behavior was noticed by  a
	beta  test  site using ATTRIB Y1.0-8, the first release compiled
	with TURBO Pascal 3.02A, when it was impossible to CTRL/C out of
	listings  that were hit with the performance bug handled in edit
	011.
  010 - Construct print lines as a whole and omit trailing spaces.   Add
	the D- compiler directive and Flush (Output) to speed things up.
	This also makes all program-generated text finally go to the MS-
	-DOS standard output:  even with Pn, TURBO will use IBM  PC  ROM
	BIOS calls if the standard output is the console.
  011 - Retain attribute  from	wild  card  lookup.   This  considerably
	improves performance in highly fragmented directories.
  012 - CTRL/C entered in response to the ReadLn in CLA.PAS  does  *NOT*
	abort  the  program  at  least	under PC-DOS V2.10.  Apparently,
	using the Gn,Pn,D- set of compiler directives  entirely  defeats
	^C detection.  So use the ^C package even for command line pars-
	ing.
  013 - Detect CTRL/Z entered in response to ReadLn in CLA.PAS.
  014 - Reorder attributes in listing to put Arc and Dir, the most  pop-
	ular attributes, first.
	Released to selected Easynet sites for beta test on 17	December
	1986.

	Brian Hetrick, 30-Jan-87: Version Y1.0-16
  015 - Introduce /HELP switch to give long help message;  if no command
	line given, give short message and assume *.*.	Remove prompting
	for command parameters as there is now a 'reasonable' default.
  016 - Make help text less dense, as it is now explicitly requested and
	the user is presumably ready to deal with it.

	Brian Hetrick, 30-Jan-87: Version 1.0
  017 - Delete internal use only notice, copyright notice, etc., and set
	version  number to have no prefix or edit suffix, as will be re-
	leased to DECUS Program Library.
	Released to Easynet sites and DECUS Program Library  30  January
	1987.

***********************************************************************)
{.PA}
(*
 *  INCLUDE FILES:
 *)

{$I CtlCTrap.Pas}							{009}
{$I CLA.PAS}
{$I WildExpa.Pas}
{$I MakeAbs.Pas}							{007}
{$I BaseName.Pas}							{008}

(*
 *  LABEL DECLARATIONS:
 *)

(*
 *  CONSTANT DECLARATIONS:
 *)

CONST

    AttrMaskReadOnly	 = 1;
    AttrMaskHidden	 = 2;
    AttrMaskSystem	 = 4;
    AttrMaskSubDirectory = 16;
    AttrMaskArchive	 = 32;

(*
 *  TYPE DECLARATIONS:
 *)

TYPE

    PathSpec = WildExpandPathSpec;					{011}

(*
 *  OWN STORAGE:
 *)

VAR

    Logging	    : BOOLEAN;
    HelpDesired     : BOOLEAN;						{015}
    OptionSpecified : BOOLEAN;						{005}
    ResetMask	    : INTEGER;
    SetMask	    : INTEGER;

(*
 *  TABLE OF CONTENTS:
 *)
{.PA}
PROCEDURE PrintHelp;							{005}

(***********************************************************************{005}

FUNCTIONAL DESCRIPTION: 						{005}

    Writes a description of the program on the standard output. 	{005}

FORMAL PARAMETERS:							{005}

    None.								{005}

RETURN VALUE:								{005}

    None.								{005}

IMPLICIT INPUTS:							{005}

    None.								{005}

IMPLICIT OUTPUTS:							{005}

    None.								{005}

SIDE EFFECTS:								{005}

    None.								{005}

***********************************************************************){005}

    BEGIN								{005}

    WriteLn;										 {016}
    WriteLn ('Command line:   ATTRIB filespec [qualifier]...'); 			 {005}
    WriteLn;										 {016}
    WriteLn ('''filespec'' is a path specification possibly with wild card characters'); {005}
    WriteLn ('   in the last component');						 {005}
    WriteLn;										 {016}
    WriteLn ('''qualifier'' is one of /[NO]HELP, /[NO]LOG, /SET:value, /RESET:value,');  {005}
    WriteLn ('   /CLEAR:value, /REMOVE:value'); 					 {005}
    WriteLn;										 {016}
    WriteLn ('   /SET grants attributes');						 {016}
    WriteLn ('   /RESET, /CLEAR, and /REMOVE remove attributes');			 {016}
    WriteLn;										 {016}
    WriteLn ('''value'' is either name or (name[,name]...)');				 {005}
    WriteLn;										 {016}
    WriteLn ('''name'' is one of ARCHIVE, HIDDEN, SYSTEM, READ_ONLY');			 {005}
    WriteLn;										 {016}
    WriteLn ('All keywords may be uniquely abbreviated')				 {005}

    END;								{005}
{.PA}
FUNCTION PrefixLength							{002}
   (	Str1 : PathSpec;
	Str2 : PathSpec) : INTEGER;					{002}

(***********************************************************************

FUNCTIONAL DESCRIPTION:

    Determines whether one string is a prefix of another,  ignoring  the
    case of letters.

FORMAL PARAMETERS:

    TestString.rt.v - The string which may be a prefix of TargetString.
    TargetString.rt.v - The string of which TestString may be a prefix.

RETURN VALUE:

    Zero: TestString is not a prefix of TargetString.			{002}
    n>0:  TestString is a prefix of TargetString and has n characters.	{002}

IMPLICIT INPUTS:

    None.

IMPLICIT OUTPUTS:

    None.

SIDE EFFECTS:

    None.

***********************************************************************)

    VAR
	Chr1  : CHAR;
	Chr2  : CHAR;
	Index : INTEGER;

    BEGIN

    IF Length (Str1) <= Length (Str2)
    THEN
	BEGIN

	(*
	 *  Test string is no longer than target string, so check char-
	 *  acters
	 *)

	PrefixLength := Length (Str1);					{002}

	FOR Index := 1 TO Length (Str1)
	DO
	    BEGIN

	    Chr1 := UpCase (Str1 [Index]);
	    Chr2 := UpCase (Str2 [Index]);
	    IF Chr1 <> Chr2
	    THEN
		BEGIN							{002}

		(*
		 *  A mismatch was found, test string is not a prefix of
		 *  target string
		 *)

		PrefixLength := 0;					{002}
		Exit							{002}

		END							{002}
	    END

	END

    ELSE

	(*
	 *  Test string is longer than target string and so cannot be a
	 *  prefix
	 *)

	PrefixLength := 0						{002}

    END;
{.PA}
PROCEDURE Pad								{010,008}
   (VAR StringText : PathSpec;						{010,008}
	PadLength  : INTEGER);						{010,008}

(***********************************************************************{008}

FUNCTIONAL DESCRIPTION: 						{008}

    Adjusts a string by truncating the rightmost characters  or  padding{008}
    on the right with spaces to be a specified length.			{008}

FORMAL PARAMETERS:							{008}

    StringToPad.rt.v - The string to be adjusted.			{008}
    DesiredLength.rg.v - The length of the result string.		{008}

RETURN VALUE:								{008}

    None.								{010}

IMPLICIT INPUTS:							{008}

    None.								{008}

IMPLICIT OUTPUTS:							{008}

    None.								{008}

SIDE EFFECTS:								{008}

    None.								{008}

***********************************************************************){008}

    VAR 								{008}

	StuffIndex : INTEGER;						{008}

    BEGIN								{008}

    (*									{008}
     *	Pad on the right with blanks					{008}
     *) 								{008}

    FOR StuffIndex := Length (StringText) + 1 TO PadLength		{008}
    DO									{008}
	StringText [StuffIndex] := ' '; 				{010,008}

    (*									{008}
     *	Adjust the length						{008}
     *) 								{008}

    StringText [0] := Chr (PadLength)					{010,008}

    END;								{008}
{.PA}
PROCEDURE AppendString							{010}
   (	InsertString : PathSpec;					{010}
    VAR TargetString : PathSpec);					{010}

(***********************************************************************{010}

FUNCTIONAL DESCRIPTION: 						{010}

    Appends one string to another.					{010}

FORMAL PARAMETERS:							{010}

    StringToAdd.rt.v - The string to be appended to TargetString.	{010}
    TargetString.mt.r - The string to which StringToAdd is to be ap-	{010}
	pended. 							{010}

RETURN VALUE:								{010}

    None.								{010}

IMPLICIT INPUTS:							{010}

    None.								{010}

IMPLICIT OUTPUTS:							{010}

    None.								{010}

SIDE EFFECTS:								{010}

    None.								{010}

***********************************************************************){010}

    BEGIN								{010}

    Insert (InsertString, TargetString, Length (TargetString) + 1)	{010}

    END;								{010}
{.PA}
PROCEDURE SetKeywordBit
   (	KeywordText : PathSpec;
    VAR OptionMask  : INTEGER);

(***********************************************************************

FUNCTIONAL DESCRIPTION:

    Sets the bit in an attribute mask designated by a keyword.	The key-
    word is any of ARCHIVE, HIDDEN, READ_ONLY, or SYSTEM, or any leading
    abbreviation of one of these keywords.

FORMAL PARAMETERS:

    Keyword.rt.v - The keyword designating an attribute.
    AttributeMask.mg.r - The attribute mask in which the bit correspond-
	ing to the keyword is to be set.

RETURN VALUE:

    None.

IMPLICIT INPUTS:

    None.

IMPLICIT OUTPUTS:

    None.

SIDE EFFECTS:

    If Keyword is not an abbreviation of one of the valid  keywords,  an
    error  mesage  is  written to the standard output and the program is
    terminated.

***********************************************************************)

    BEGIN

    (*
     *	Check against list and set appropriate bit
     *)

    IF PrefixLength (KeywordText, 'HIDDEN') > 0 			{002}
    THEN

	OptionMask := OptionMask OR AttrMaskHidden

    ELSE IF PrefixLength (KeywordText, 'SYSTEM') > 0			{002}
    THEN

	OptionMask := OptionMask OR AttrMaskSystem

    ELSE IF PrefixLength (KeywordText, 'READ_ONLY') > 0 		{002}
    THEN

	OptionMask := OptionMask OR AttrMaskReadOnly

    ELSE IF PrefixLength (KeywordText, 'ARCHIVE') > 0			{002}
    THEN

	OptionMask := OptionMask OR AttrMaskArchive

    ELSE
	BEGIN

	WriteLn ('Invalid argument value: "', KeywordText, '"');
	Halt

	END

    END;
{.PA}
PROCEDURE DoSetArgument
   (	ArgumentText : PathSpec;
    VAR OptionMask   : INTEGER);

(***********************************************************************

FUNCTIONAL DESCRIPTION:

    Parses the value to the /SET or /RESET option.  The syntax of  these
    values is:

	keyword
	(keyword[,keyword]...])

    where 'keyword' is one of ARCHIVE, HIDDEN, READ_ONLY, or SYSTEM,  or
    a unique leading abbreviation of one of these.

FORMAL PARAMETERS:

    ValueText.rt.v - The text of the value to be parsed.
    AttributeMask.mg.r - The attribute	mask  in  which  the  bits  cor-
	responding to the keywords are to be set.

RETURN VALUE:

    None.

IMPLICIT INPUTS:

    None.

IMPLICIT OUTPUTS:

    None.

SIDE EFFECTS:

    May write a message to the standard output and halt program  execut-
    ion under the following circumstances:

     -	ValueText consists only of '(';
     -	ValueText starts with '(' but does not end with ')';
     -	ValueText has ')' before the end of the string;
     -	ValueText has two adjacent commas.

***********************************************************************)

    VAR

	KeyWord     : PathSpec;
	SearchIndex : INTEGER;

    BEGIN

    (*
     *	See whether single keyword or bundle
     *)

    IF ArgumentText [1] = '('
    THEN
	BEGIN

	(*
	 *  Is a bundle.  Do each word individually
	 *)

	Delete (ArgumentText, 1, 1);

	WHILE Length (ArgumentText) > 0
	DO
	    BEGIN

	    (*
	     *	Isolate the keyword
	     *)

	    SearchIndex := 1;

	    WHILE (SearchIndex <= Length (ArgumentText)) AND
		  (ArgumentText [SearchIndex] <> ',') AND
		  (ArgumentText [SearchIndex] <> ')')
	    DO
		SearchIndex := SearchIndex + 1;

	    IF SearchIndex > Length (ArgumentText)
	    THEN
		BEGIN

		WriteLn ('Invalid unterminated argument value');
		Halt

		END;

	    IF SearchIndex = 1
	    THEN
		BEGIN

		WriteLn ('Invalid null argument value');
		Halt

		END;

	    Keyword := Copy (ArgumentText, 1, SearchIndex - 1);

	    (*
	     *	Set the appropriate bit
	     *)

	    SetKeywordBit (Keyword, OptionMask);

	    (*
	     *	Ensure proper separator format
	     *)

	    IF SearchIndex = Length (ArgumentText)
	    THEN
		BEGIN

		IF ArgumentText [SearchIndex] <> ')'
		THEN
		    BEGIN

		    WriteLn ('Invalid unterminated argument value');
		    Halt

		    END

		END
	    ELSE
		BEGIN

		IF ArgumentText [SearchIndex] <> ','
		THEN
		    BEGIN

		    WriteLn ('Invalid argument value after termination');
		    Halt

		    END

		END;

	    Delete (ArgumentText, 1, SearchIndex)

	    END
	END
    ELSE

	(*
	 *  Argument value is single keyword
	 *)

	SetKeywordBit (ArgumentText, OptionMask)

    END;
{.PA}
PROCEDURE ParseCommandQualifiers;					{003}

(***********************************************************************

FUNCTIONAL DESCRIPTION:

    Parses the command line for the ATTRIB program.

    The command line has the format:

    ATTRIB wildspec [option]...

    The ATTRIB token is typed by the user but is not part of the command
    line tail retained by MS-DOS, and so does not  participate	in  this
    parse.

    Wildspec is a single path specification which may contain wild  card
    characters	in  the  last  component.  Any single token not starting
    with the option character is accepted in this position.  This is not{003}
    parsed by this routine.						{003}

    Option is one of:

	/SET:value
	/RESET:value or /CLEAR:value or /REMOVE:value			{004}
	/[NO]LOG

    where 'value' is as accepted by  the  DoSetArgument  routine  above.
    The  keywords  SET, CLEAR, REMOVE, and LOG may be abbreviated to any{004}
    unique leading substring;  the keywords RESET and REMOVE may be  ab-{004}
    breviated  all the way to R, permitted in this case as they are syn-{004}
    onyms.								{004}

    An equal sign (=) may be used in place of the colon.

FORMAL PARAMETERS:

    None.

RETURN VALUE:

    None.

IMPLICIT INPUTS:

    The command line tail at CS:0080.  [Actually, this	is  an	implicit
	input of the CLA package which this routine uses.]
    ResetMask - The mask of attribute bits to be reset.
    SetMask - The mask of attribute bits to be set.

IMPLICIT OUTPUTS:

    OptionSpecifed - The  flag	determining  whether  any  options  were
	specified on the command line.
    ResetMask - The mask of attribute bits to be reset.
    SetMask - The mask of attribute bits to be set.

SIDE EFFECTS:

    May write a message to the standard  output  and  terminate  program
    execution under the following circumstances:

     -	A null option (slash with no other characters) is present in the
	command
     -	An unrecognized option (slash followed by something other than a
	unique abbreviation of [NO]LOG, RESET, or SET) is present in the
	command
     -	A value is specified with [NO]LOG
     -	No value is specified with RESET or SET
     -	The attributes specified with /SET and /RESET are not disjoint.

***********************************************************************)

    VAR

	DummyArg    : PathSpec;
	Keyword     : PathSpec;
	SearchIndex : INTEGER;
	TargetMask  : ^ INTEGER;
	ValueType   : INTEGER;

    BEGIN

    (*
     *	Get all switches						{003}
     *)

    DummyArg := CommandLineArgument ('', '', TRUE);

    WHILE Length (DummyArg) > 0
    DO
	BEGIN

	(*
	 *  Delete the leading slash
	 *)

	Delete (DummyArg, 1, 1);
	IF Length (DummyArg) = 0
	THEN
	    BEGIN

	    WriteLn ('Invalid null option');
	    Halt

	    END;

	(*
	 *  Extract the keyword
	 *)

	SearchIndex := 1;
	WHILE (SearchIndex <= Length (DummyArg)) AND
	      (DummyArg [SearchIndex] <> ':') AND
	      (DummyArg [SearchIndex] <> '=')
	DO
	    SearchIndex := SearchIndex + 1;

	Keyword := Copy (DummyArg, 1, SearchIndex - 1);

	(*
	 *  Delete all but the keyword value
	 *)

	IF SearchIndex > Length (DummyArg)
	THEN
	    SearchIndex := Length (DummyArg);
	Delete (DummyArg, 1, SearchIndex);

	(*
	 *  Try to match the keyword to a possible keyword
	 *)

	IF PrefixLength (Keyword, 'LOG') > 0				{002}
	THEN
	    BEGIN

	    Logging := TRUE;
	    ValueType := 0

	    END
	ELSE IF PrefixLength (Keyword, 'NOLOG') > 2			{002}
	THEN
	    BEGIN

	    Logging := FALSE;
	    ValueType := 0

	    END
	ELSE IF PrefixLength (Keyword, 'SET') > 0			{002}
	THEN
	    BEGIN

	    TargetMask := Addr (SetMask);
	    ValueType  := 1

	    END
	ELSE IF (PrefixLength (Keyword, 'RESET')  > 0) OR		{004,002}
		(PrefixLength (Keyword, 'CLEAR')  > 0) OR		{004}
		(PrefixLength (Keyword, 'REMOVE') > 0)			{004}
	THEN
	    BEGIN

	    TargetMask := Addr (ResetMask);
	    ValueType  := 1

	    END
	ELSE IF PrefixLength (Keyword, 'HELP') > 0			{015}
	THEN								{015}
	    BEGIN							{015}

	    HelpDesired := TRUE;					{015}
	    ValueType := 0						{015}

	    END 							{015}
	ELSE IF PrefixLength (Keyword, 'NOHELP') > 2			{015}
	THEN								{015}
	    BEGIN							{015}

	    HelpDesired := FALSE;					{015}
	    ValueType := 0						{015}

	    END 							{015}
	ELSE
	    BEGIN

	    WriteLn ('Invalid switch: "', Keyword, '"');
	    Halt

	    END;

	(*
	 *  Parse the switch value
	 *)

	IF ValueType = 0
	THEN
	    BEGIN

	    IF Length (DummyArg) > 0
	    THEN
		BEGIN

		WriteLn ('/LOG switch does not take value');
		Halt

		END
	    END
	ELSE
	    BEGIN

	    IF Length (DummyArg) = 0
	    THEN
		BEGIN

		WriteLn ('/SET and /RESET require value');
		Halt

		END;

	    DoSetArgument (DummyArg, TargetMask ^)

	    END;

	(*								{005}
	 *  Note option parsed						{005}
	 *)								{005}

	OptionSpecified := TRUE;					{005}

	(*
	 *  Get next switch
	 *)

	DummyArg := CommandLineArgument ('', '', TRUE)

	END;

    (*
     *	Check for non-interference of set and reset masks
     *)

    IF (SetMask AND ResetMask) <> 0
    THEN
	BEGIN

	WriteLn ('Same attribute specified for both /SET and /RESET');
	Halt

	END

    END;
{.PA}
(***********************************************************************

FUNCTIONAL DESCRIPTION:

    Manipulates attributes of files.

FORMAL PARAMETERS:

    None.

RETURN VALUE:

    None.

IMPLICIT INPUTS:

    Logging - The flag showing whether	attribute  messages  are  to  be
	written to the standard output.
    ResetMask - The mask of attribute bits to be reset in the files sel-
	ected by WildSpec.
    SetMask - The mask of attribute bits to be set in the files  select-
	ed by WildSpec.

IMPLICIT OUTPUTS:

    None.

SIDE EFFECTS:

    May write messages to the standard output.
    May modify attributes of files.

***********************************************************************)

TYPE

    RegPack = RECORD
	CASE INTEGER OF
	 0: (AX, BX, CX, DX, DP, SI, DI, DS, ES, Flags : INTEGER);
	 1: (AL, AH, BL, BH, CL, CH, DL, DH	       : BYTE)
	END;

VAR

    FileSpec  : PathSpec;
    NewAttr   : INTEGER;
    OldAttr   : INTEGER;
    OutLine   : PathSpec;						{010}
    Registers : RegPack;
    WildSpec  : PathSpec;						{003}

BEGIN

(*									{012}
 *  Set up Control/C trapping for program				{012}
 *)									{012}

CtrlCSetup;								{012,009}

(*
 *  Print banner
 *)

WriteLn ('ATTRIB version ', ProgramVersion);
Flush (Output); 							{012}

(*
 *  Parse the command line
 *)

Logging 	:= TRUE;						{003}
OptionSpecified := FALSE;						{005}
HelpDesired	:= FALSE;						{015}
ResetMask	:= 0;							{003}
SetMask 	:= 0;							{003}

ParseCommandQualifiers; 						{003}

WildSpec := CommandLineArgument ('', '', FALSE);			{005}

IF (Length (WildSpec) = 0) AND NOT OptionSpecified			{005}
THEN									{005}
    BEGIN								{005}

    (*									{015}
     *	A totally blank command line.  Assume *.* and  give  short  mes-{015}
     *	sage.								{015}
     *) 								{015}

    WildSpec := '*.*';							{015}
    WriteLn;								{015}
    WriteLn ('Use /HELP qualifier for help')				{015}

    END;								{005}

(*									{015}
 *  If help requested, give it						{015}
 *)									{015}

IF HelpDesired								{015}
THEN									{015}

    PrintHelp;								{015}

(*									{006}
 *  Scan with each wild card specification				{006}
 *)									{006}

WHILE (NOT CtrlCOccurred) AND (Length (WildSpec) > 0)			{009,006}
DO									{006}
    BEGIN								{006}

    (*									{007}
     *	Append *.* if path ends in : or \				{007}
     *) 								{007}

    IF WildSpec [Length (WildSpec)] IN [':', '/', '\']			{007}
    THEN								{007}

	Insert ('*.*', WildSpec, Length (WildSpec) + 1);		{007}

    (*									{007}
     *	Make the wild card path absolute				{007}
     *) 								{007}

    MakePathAbsolute (WildSpec);					{007}

    (*									{008}
     *	Log the specification						{008}
     *) 								{008}

    IF Logging								{008}
    THEN								{008}
	BEGIN								{008}

	WriteLn;							{008}
	WriteLn (WildSpec, ':') 					{008}

	END;								{008}

    (*
     *	Initialize the wild card scan
     *)

    IF NOT WildExpandInitialize (WildSpec, $17)
    THEN
	BEGIN

	IF Logging							{008}
	THEN								{008}

	    WriteLn ('  No files found')				{008}

	ELSE								{008}

	    WriteLn ('No files found for ', WildSpec)			{008}

	END								{008}
    ELSE								{006}
	BEGIN								{006}

	WildExpandContinue (FileSpec, OldAttr); 			{011}

	WHILE (NOT CtrlCOccurred) AND (Length (FileSpec) > 0)		{009}
	DO
	    BEGIN

	    (*
	     *	Append NUL for MS-DOS
	     *)

	    FileSpec [Length (FileSpec) + 1] := #$00;

	    (*
	     *	Obtain changed attributes
	     *)

	    NewAttr := (OldAttr OR SetMask) AND NOT ResetMask;

	    (*
	     *	Modify attributes
	     *)

	    IF NewAttr <> OldAttr
	    THEN
		BEGIN

		Registers . AH := $43;
		Registers . AL := $01;
		Registers . CX := NewAttr AND NOT AttrMaskSubDirectory;
		Registers . DS := Seg (FileSpec [1]);
		Registers . DX := Ofs (FileSpec [1]);
		MsDos (Registers)

		END
	    ELSE							{010}

		Registers . Flags := 0; 				{010}

	    IF (Registers . Flags AND 1) <> 0
	    THEN

		WriteLn ('Cannot change attributes for ', FileSpec)	{008}

	    ELSE
		BEGIN

		(*
		 *  List new attributes and file name
		 *)

		IF Logging
		THEN
		    BEGIN

		    OutLine := '  ';					{010}
		    AppendString (BaseName (FileSpec), OutLine);	{010}

		    IF (NewAttr AND AttrMaskArchive) <> 0
		    THEN
			BEGIN						{010}
			Pad (OutLine, 16);				{014,010}
			AppendString ('Arc', OutLine)			{010}
			END;						{010}

		    IF (NewAttr AND AttrMaskSubDirectory) <> 0
		    THEN
			BEGIN						{010}
			Pad (OutLine, 20);				{014,010}
			AppendString ('Dir', OutLine)			{010}
			END;						{010}

		    IF (NewAttr AND AttrMaskReadOnly) <> 0
		    THEN
			BEGIN						{010}
			Pad (OutLine, 24);				{014,010}
			AppendString ('R/O', OutLine)			{010}
			END;						{010}

		    IF (NewAttr AND AttrMaskHidden) <> 0
		    THEN
			BEGIN						{010}
			Pad (OutLine, 28);				{014,010}
			AppendString ('Hid', OutLine)			{010}
			END;						{010}

		    IF (NewAttr AND AttrMaskSystem) <> 0
		    THEN
			BEGIN						{010}
			Pad (OutLine, 32);				{014,010}
			AppendString ('Sys', OutLine)			{010}
			END;						{010}

		    WriteLn (OutLine);					{010,008}
		    Flush (Output)					{009}

		    END
		END;

	    WildExpandContinue (FileSpec, OldAttr)			{011}

	    END 							{006}
	END;

    WildSpec := CommandLineArgument ('', '', FALSE)			{006}

    END 								{006}
END.