With my initial success using the CMOC compiler to build a CoCo program, I wanted to automate my steps (build and copy to disk image).

Back in my OS-9 days, I used an OS-9 shell script called “doit” that would manually do the steps to build whatever project it was designed for. This would do the compile, optimize, link, etc. steps for me.

I wanted to make a shell that let me specify the C file then build and copy it to some emulator disk image. I thought it might be like:

doit hello.c

I couldn’t remember how to pass parameters in to a shell script, so instead of doing a websearch, I just asked ChatGPT:

“how can you pass a parameter to a unix shell script?

To pass a parameter to a Unix shell script, you can use the $1, $2, $3, etc. variables, which correspond to the first, second, third, etc. arguments passed to the script. For example, if you want to pass a filename as a parameter to your script, you could use the following syntax:

Copy code./myscript.sh myfile.txt

Then, in the script, you can access the parameter using the $1 variable, like this:

#!/bin/bash

# Print the filename passed as a parameter
echo "The filename is: $1"

Alternatively, you can use the shift command to access all of the arguments passed to the script, like this:

#!/bin/bash

# Print all of the arguments passed to the script
echo "The arguments are: $@"

# Shift the arguments to the left, so that $1 now refers to the second argument, $2 now refers to the third argument, etc.
shift

# Print all of the arguments again, after shifting
echo "The arguments are now: $@"

In this example, the shift command is used to move all of the arguments to the left by one position, so that the second argument is now accessible using the $1 variable, the third argument is accessible using the $2 variable, and so on. This can be useful if you want to access all of the arguments passed to the script, but you don’t know in advance how many arguments will be passed.

– chat.openai.com

That was quicker than a Google search! I decided to just tell it what I wanted to do:

Write a shell script that takes one parameter (a name) and then runs “cmoc name” and then “decb copy name.bin C.DSK,NAME.BIN -2r”

Here is an example of a Unix shell script that takes one parameter (a name) and then runs the cmoc and decb commands using that parameter:

#!/bin/bash

# Get the name parameter
name=$1

# Run the cmoc command using the name parameter
cmoc $name

# Run the decb command using the name parameter
decb copy $name.bin C.DSK,$name.BIN -2r

In this script, the first line specifies the shell interpreter to use (in this case, /bin/bash), and the second line uses the $1 variable to retrieve the first argument passed to the script (i.e., the name parameter). The third and fourth lines use the cmoc and decb commands, respectively, to perform the specified operations using the name parameter.

To run this script, you would use the following command:

Copy code./myscript.sh myname

Replace myscript.sh with the name of your script file, and myname with the name you want to use as the parameter. The script will then run the cmoc and decb commands using the specified name.

– chat.openai.com

Well, if it can do that, maybe it an make it even better…

update that script so the parameter’s extension is removed and replaced with .bin for the copy

To update the script so that the extension of the parameter is removed and replaced with .bin for the decb copy command, you can use the basename and dirname commands to extract the base name and directory path of the parameter, respectively, and then use the sed command to remove the extension from the base name. Here is an example of how you could do this:

Copy code#!/bin/bash

# Get the name parameter name=$1

# Use the basename and dirname commands to extract the base name and directory path of the parameter
dir=$(dirname $name) base=$(basename $name)

# Use the sed command to remove the extension from the base
namename_without_ext=$(echo $base | sed -e "s/\.[^.]*$//")

# Run the cmoc command using the name parameter
cmoc $name

# Run the decb copy command using the modified name
decb copy $name_without_ext.bin $dir/C.DSK,$name_without_ext.BIN -2r

In this updated script, the basename and dirname commands are used to extract the base name and directory path of the parameter. The sed command is then used to remove the extension from the base name, and the modified name is used as the argument to the decb copy command.

To run this script, you would use the same command as before:

Copy code./myscript.sh myname

This time, however, the decb copy command will use the modified name (i.e., the name with the extension removed and replaced with .bin) instead of the original name. For example, if you pass myfile.txt as the parameter, the decb copy command will use myfile.bin as the destination filename.

– chat.openai.com

And maybe even more better than that!

can you uppercase the second $name_without_ext in the decb line?

To uppercase the second instance of $name_without_ext in the decb line, you can use the tr command to convert the string to uppercase. Here is an example of how you could do this:

#!/bin/bash 

# Get the name parameter
name=$1

# Use the basename and dirname commands to extract the base name and directory path of the parameter
dir=$(dirname $name)
base=$(basename $name) 

# Use the sed command to remove the extension from the base namename_without_ext=$(echo $base | sed -e "s/\.[^.]*$//") 

# Use the tr command to convert the name to uppercase name_upper=$(echo $name_without_ext | tr "[:lower:]" "[:upper:]")

# Run the cmoc command using the name parameter
cmoc $name

# Run the decb copy command using the modified name decb copy $name_without_ext.bin $dir/C.DSK,$name_upper.BIN -2r

In this updated script, the tr command is used to convert the $name_without_ext variable to uppercase, and the resulting string is stored in the $name_upper variable. The $name_upper variable is then used as the second argument to the decb copy command, so the second instance of the name will be uppercase.

To run this script, you would use the same command as before:

Copy code./myscript.sh myname

This time, the decb copy command will use the uppercase version of the name as the second argument. For example, if you pass myfile.txt as the parameter, the decb copy command will be run as follows:

Copy codedecb copy myfile.bin mydir/C.DSK,MYFILE.BIN -2r

Notice that the second instance of the name (i.e., MYFILE.BIN) is now in uppercase.

– chat.openai.com

It worked great! But it didn’t tell me what it was doing, so…

Make it print what is happening at the cmoc and decb steps

To make the script print what is happening at the cmoc and decb steps, you can simply add some echo statements to the script. Here is an example of how you could do this:

#!/bin/bash

# Get the name parameter
name=$1 

# Use the basename and dirname commands to extract the base name and directory path of the parameter
dir=$(dirname $name) base=$(basename $name) 

# Use the sed command to remove the extension from the base
namename_without_ext=$(echo $base | sed -e "s/\.[^.]*$//") 

# Use the tr command to convert the name to uppercase name_upper=$(echo $name_without_ext | tr "[:lower:]" "[:upper:]") 

# Print a message before running the cmoc command
echo "Running cmoc on $name..." 

# Run the cmoc command using the name parameter
cmoc $name 

# Print a message before running the decb copy command
echo "Running decb copy on $name_without_ext.bin..." 

# Run the decb copy command using the modified name
decb copy $name_without_ext.bin $dir/C.DSK,$name_upper.BIN -2r

In this updated script, two echo statements have been added to print a message before running the cmoc and decb copy commands, respectively. These messages will be printed to the console and will indicate what is happening at each step of the script.

To run this script, you would use the same command as before:

Copy code./myscript.sh myname

When you run the script, you should see the following output:

Copy codeRunning cmoc on myname... (output from cmoc command) Running decb copy on myfile.bin... (output from decb copy command)

The output from the cmoc and decb copy commands will be shown after the messages indicating what is happening at each step.

– chat.openai.com

And that’s how I got this…

I will never write a shell script again…

Recently on LinkedIn, I saw a post by Rogelio Perea about his Tandy Model 102 portable computer. Although I never owned one, I remember this machine well. I always wanted one. Having a “portable” computer really wasn’t a thing back in those days, and this one even had a modem built in!

I recalled how, when I worked for Radio Shack, I wrote a program on our display Model 102 that we used to track our customer repairs. We had to have everything on paper in those days, but would type things in to the computer so we could find them quicker when a customer inquired about their repair status. I wish I had a copy, but I think the only place it ever existed was the memory of that specific computer.

I do, however, have the program it was based on. It started out as a PEN-PAL program for the Radio Shack Color Computer:

This program, in turn, was based on work I had done for my *ALL RAM* cassette-based BBS program.

*ALLRAM* used BASIC arrays to store the userlog and message base in memory, and would load/save them to tape. My Pen-Pal program did the same thing, but was updated to load from either Tape or Disk.

That Pen-Pal program was also the basis for a custom program I wrote for a lady who ran a large newspaper route where I lived at the time. Her name was Laverne Ricks, and I remember this because I put it on the title screen of the program I wrote for her:

According to comments in the source code, I wrote this on 7/8/1987. This was the summer after I graduated high school, and I had just moved to Lufkin, Texas. Since this was before I got a job at Radio Shack, I am not sure how she and I got connected (possibly through the Lufkin Area CoCo Club or someone at Radio Shack).

The initial version of the program has a menu very similar to the Pen-Pal program:

You can see I had made it look a bit nicer by using graphical black block characters instead of rows of equal signs ;-)

I also found a second version, where I added built-in help:

THIS must be why I wrote the BASIC windowing routine I have written about before. It offered several screens of help:

Neat!

The program has ways to Add a new record:

Ah, the days before spell checkers. You should see the misspellings in my furniture store inventory program I did a year or so later… But I digress.

And you could use arrow keys to flip through them:

You could Delete entries, Edit them, and Insert new ones (at the location you were currently viewing, which was important since a Paper Route was organized by delivery location rather than alphabetical or whatever). There was a way to Jump to a specific entry as well.

And, of course, you could Search by field:

Looking at it 35 years later, I’m pretty impressed with the features it offered. I have no idea what I based all of this on since I’d only owned a VIC-20 and a CoCo at that point and certainly had never worked with any kind of database software that I can recall.

Side note: A short while later, I would do something like this again for someone who ran a garbage collection route, though I think it was for a Tandy 1000 and was using a Deskmate Database.

This is what let me to search out Laverne Ricks and see where she was these days. Sadly, she passed away in 2011.

https://www.legacy.com/obituaries/lufkindailynews/obituary.aspx?n=juanita-laverne-ricks&pid=149650362&fhid=11038

Rest in peace, Laverne Ricks. A tiny bit of your legacy will be remembered here, always.

Until next time…