The Project | About Us | Contribute | Donations | License

HOME

In this section, we will explore how to create useful utilities using REXX. Utilities are small programs designed to perform specific tasks, often to automate repetitive processes or to provide handy tools for users. By the end of this section, you will be able to create your own REXX utilities to enhance productivity and streamline workflows.

Key Concepts

Understanding Utilities: What are utilities and why are they useful?
Designing a Utility: Steps to design a utility.
Implementing a Utility: Writing the REXX code for a utility.
Testing and Debugging: Ensuring your utility works correctly.
Deploying Utilities: Making your utility available for use.

Understanding Utilities

Utilities are small, focused programs that perform specific tasks. Examples include:

File renaming tools
Log file analyzers
Data format converters
Automated backup scripts

Benefits of Utilities

Efficiency: Automate repetitive tasks.
Consistency: Ensure tasks are performed the same way every time.
Productivity: Free up time for more complex tasks.

Designing a Utility

Before writing any code, it's important to plan your utility. Consider the following steps:

Define the Purpose: Clearly state what the utility will do.
Identify Inputs and Outputs: Determine what data the utility will need and what it will produce.
Outline the Process: Break down the steps the utility will take to achieve its goal.
Consider Edge Cases: Think about unusual or unexpected inputs and how the utility should handle them.

Example: File Renaming Utility

Purpose: Rename files in a directory based on a specific pattern.
Inputs: Directory path, file pattern, new naming convention.
Outputs: Renamed files.
Process:
1. Read the directory contents.
2. Filter files based on the pattern.
3. Rename each file according to the new naming convention.
4. Handle errors (e.g., file not found, permission issues).

Implementing a Utility

Let's implement the file renaming utility in REXX.

Code Example

/* File Renaming Utility */
parse arg directory pattern newname

if directory = '' | pattern = '' | newname = '' then do
    say 'Usage: rexx rename.rexx <directory> <pattern> <newname>'
    exit 1
end

/* Read the directory contents */
call rxfuncadd 'SysFileTree', 'RexxUtil', 'SysFileTree'
call SysFileTree directory || '\' || pattern, 'fileList.'

if fileList.0 = 0 then do
    say 'No files found matching the pattern.'
    exit 1
end

/* Rename each file */
do i = 1 to fileList.0
    oldname = fileList.i
    newname = directory || '\' || newname || i
    call SysFileRename oldname, newname
    if rc = 0 then
        say 'Renamed' oldname 'to' newname
    else
        say 'Error renaming' oldname
end

exit 0

Explanation

Argument Parsing: The script expects three arguments: directory, pattern, and newname.
Usage Check: If any argument is missing, it displays usage instructions and exits.
Directory Reading: Uses SysFileTree to read the directory contents matching the pattern.
File Renaming: Iterates over the files and renames them using SysFileRename.

Testing and Debugging

Testing

Normal Cases: Test with valid inputs to ensure the utility works as expected.
Edge Cases: Test with invalid inputs, empty directories, and permission issues.

Debugging

Print Statements: Use say statements to print variable values and track the script's progress.
Error Codes: Check return codes (rc) from functions to identify errors.

Deploying Utilities

Making Your Utility Available

Script Location: Place the script in a directory included in the system's PATH.
Permissions: Ensure the script has execute permissions.
Documentation: Provide usage instructions and examples.

Example Deployment

Save the script as rename.rexx.
Place it in /usr/local/bin (or another directory in PATH).
Run chmod +x /usr/local/bin/rename.rexx to make it executable.
Document usage in a README file.

Conclusion

Creating utilities in REXX can significantly enhance productivity by automating repetitive tasks. By following the steps outlined in this section, you can design, implement, test, and deploy your own REXX utilities. Practice by creating different utilities to solve real-world problems and streamline your workflows.

Creating REXX Utilities