github.com/Interlisp.medley
1
0
Fork 0
mirror of synced 2026-01-26 04:12:03 +00:00
Code Issues Projects Releases Wiki Activity

Overhaul of loadup scripts (#1699)

Browse Source 
* Make medley.sh and its associated scripts POSIX compliant - i.e., debashify them

* Added config file for medley script, medley now reads from config file and prepends arguemnts from file to the copmmand line arguments

* WIP. Updates to medley.sh scripts.

* WIP.  More on medley.sh and friends update.

* WIP. Medley redo

* WIP.  Debugging new medley scripts

* Renamed medley.sh/medley.command to be medley_main.sh.  Added code to compile single medley.sh/medley.command script by inlining all of the source'd medley_*.sh files.

* Add temp fix for cygwin Issue #1685

* Minor fixup to medley_utils.sh; take debug code out out of run_medley

* Add README to medley directory to explain how to compile medley.sh (medley.command).

* Ooops. This time really adding the README file to the medley directory explaining how to compile medley.sh (medley.command)

* Update loadup- scripts to use updated medley scripts rather than run-medley

* Fix default setting of $config_file in medley_configfile.sh

* Redo medley compile to pick up last commikt

* Fixing how maiko exe is found and sysout argument error processing - both issues discovered testing on MAcOS

* In medley_configfile, replace echo with printf %s because echo - does not work in zsh

* Supress config file on loadups calls to Medley

* Add oldschool support (use original run-medley) to loadup scripts; improve FAILURE detection so loadup-all won't proceed once one of the components fails

* Add in medley_args.sh add -prog as synonym to --maikoprog to aid in loadup scripts; in medley_run.sh script try to get a good exit code for call to maiko, especially useful for loadup scripts

* Run loadup scripts thru shellcheck and update as necessary to make Posix compliant

* Get rid of -nt comparisons in loadup-setup.sh because they are not posix-complaint.  They were not really needed anyway.

* Removing (for now) use of lde exit codes to decide FAILURE case in loadup-setup.sh since exit codes from lde apperar to be inverted on MacOS.

* Update medley man page.  Add - functionality to more args is medley_args.sh

* Compile medley.sh with changes from last commit

* Ooops.  Left medley_args.sh changes out of last commit.  Rectifying here.

* Added support for LDEKEYBOARDTYPE to medley_run to match run-medley

* Add to medley.sh: auto numbered id's and titles with id's inserted

* Cleanup some shellcheck issues in medley_main.sh

* fix maiko args -nh-xxx.  were -nethub-xxxx. In medley_run.sh

* Overhaul handling of pass-on args to manage the quoting issues prevelant in the previous implementation

* Cleanup minor shellcheck issues in medley_*.sh scripts

* Add underscore as character allowed in ids - makes things clearer when id used with +

* Add a self-numbering id to medley calls in loadup scripts

* Put workaround in medley_run.sh for Issue #1702 - issues with sysout arg processing in Maiko

* Oops.  messed up LDESRCSYSOUT in last commit.  should be LDESOURCESYSOUT

* compile medley.sh
This commit is contained in:
Frank Halasz
2024-05-09 21:31:27 -07:00
committed by GitHub
parent 4272a6e5ed
commit 415a698df5
29 changed files with 3728 additions and 769 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
scripts/loadup-all.sh
View File

@@ -1,27 +1,43 @@
#!/bin/sh
# shellcheck disable=SC2181
if [ ! -x run-medley ] ; then
echo run from MEDLEYDIR
if [ ! -h ./medley ] || [ ! -d ./lispusers ]
then
echo "*** ERROR ***"
echo "You must run $(basename "$0") while the cwd is a Medley top-level directory."
echo "The cwd ($(pwd)) is not a Medley top-level directory."
echo "Exiting."
exit 1
fi
# shellcheck source=./loadup-setup.sh
. scripts/loadup-setup.sh
if [ "$1" = "-apps" ]; then
# look thru args looking to see if -apps, --apps, or -a was specified in args
apps=true
j=1
jmax=$#
while [ "$j" -le "$jmax" ]
do
if [ "$(eval "printf %s \${${j}}")" = "-a" ] || \
[ "$(eval "printf %s \${${j}}")" = "-apps" ] || \
[ "$(eval "printf %s \${${j}}")" = "--apps" ]
then
apps="./scripts/loadup-apps-from-full.sh"
else
apps="true"
fi
break
fi
done
# Do loadup components
./scripts/loadup-init.sh && \
./scripts/loadup-mid-from-init.sh && \
./scripts/loadup-lisp-from-mid.sh && \
./scripts/loadup-full-from-lisp.sh && \
${apps} && \
./scripts/loadup-aux.sh && \
./scripts/copy-all.sh $1
./scripts/copy-all.sh "$1"
if [ $? -eq 0 ];
if [ $? -eq 0 ]
then
echo "+++++ loadup-all.sh: SUCCESS +++++"
else

35
scripts/loadup-apps-from-full.sh
View File

@@ -1,29 +1,38 @@
#!/bin/sh
if [ ! -x run-medley ] ; then
echo must run from MEDLEYDIR ;
exit 1 ;
if [ ! -h ./medley ] || [ ! -d ./lispusers ]
then
echo "*** ERROR ***"
echo "You must run $(basename "$0") while the cwd is a Medley top-level directory."
echo "The cwd ($(pwd)) is not a Medley top-level directory."
echo "Exiting."
exit 1
fi
# shellcheck source=./loadup-setup.sh
. scripts/loadup-setup.sh
loadup_start
export ROOMSDIR=${MEDLEYDIR}/rooms
export CLOSDIR=${MEDLEYDIR}/clos
export ROOMSDIR="${MEDLEYDIR}/rooms"
export CLOSDIR="${MEDLEYDIR}/clos"
export NOTECARDSDIR=${MEDLEYDIR}/notecards
if [ ! -e ${NOTECARDSDIR} ]; then
NOTECARDSDIR=$(cd ${MEDLEYDIR}/../ && pwd)/notecards
if [ ! -e ${NOTECARDSDIR} ]; then
NOTECARDSDIR=$(cd ${MEDLEYDIR}/../../ && pwd)/notecards
if [ ! -e ${NOTECARDSDIR} ]; then
export NOTECARDSDIR="${MEDLEYDIR}/notecards"
if [ ! -e "${NOTECARDSDIR}" ]
then
NOTECARDSDIR=$(cd "${MEDLEYDIR}/../" && pwd)/notecards
if [ ! -e "${NOTECARDSDIR}" ]
then
NOTECARDSDIR=$(cd "${MEDLEYDIR}/../../" && pwd)/notecards
if [ ! -e "${NOTECARDSDIR}" ]
then
NOTECARDSDIR=""
fi
fi
fi
if [ -z "${NOTECARDSDIR}" ]; then
if [ -z "${NOTECARDSDIR}" ]
then
echo "Error: Cannot find the Notecards directory"
echo "It should be located at ${MEDLEYDIR}/../notecards or"
echo "${MEDLEYDIR}/../../notecards. But its not."
@@ -62,6 +71,6 @@ SHH
"
EOF
./run-medley ${scr} -loadup "${cmfile}" "${LOADUP_WORKDIR}/full.sysout"
run_medley "${LOADUP_WORKDIR}/full.sysout"
loadup_finish "apps.sysout" "apps.*"

11
scripts/loadup-aux.sh
View File

@@ -1,10 +1,15 @@
#!/bin/sh
if [ ! -f run-medley ] ; then
echo run from MEDLEYDIR
if [ ! -h ./medley ] || [ ! -d ./lispusers ]
then
echo "*** ERROR ***"
echo "You must run $(basename "$0") while the cwd is a Medley top-level directory."
echo "The cwd ($(pwd)) is not a Medley top-level directory."
echo "Exiting."
exit 1
fi
# shellcheck source=./loadup-setup.sh
. scripts/loadup-setup.sh
loadup_start
@@ -26,6 +31,6 @@ cat >"${cmfile}" <<"EOF"
"
EOF
./run-medley ${scr} -loadup "${cmfile}" "${LOADUP_WORKDIR}"/full.sysout
run_medley "${LOADUP_WORKDIR}/full.sysout"
loadup_finish "whereis.hash" "whereis.hash" "exports.all"

11
scripts/loadup-db-from-full.sh
View File

@@ -1,10 +1,15 @@
#!/bin/sh
if [ ! -x run-medley ] ; then
echo run from MEDLEYDIR
if [ ! -h ./medley ] || [ ! -d ./lispusers ]
then
echo "*** ERROR ***"
echo "You must run $(basename "$0") while the cwd is a Medley top-level directory."
echo "The cwd ($(pwd)) is not a Medley top-level directory."
echo "Exiting."
exit 1
fi
# shellcheck source=./loadup-setup.sh
. scripts/loadup-setup.sh
loadup_start
@@ -35,7 +40,7 @@ cat >"${cmfile}" <<"EOF"
"
EOF
./run-medley ${scr} -loadup "${cmfile}" "${SYSOUT}"
run_medley "${SYSOUT}"
loadup_finish "fuller.database" "fuller*"

10
scripts/loadup-db.sh
View File

@@ -1,10 +1,16 @@
#!/bin/sh
# shellcheck disable=SC2181
if [ ! -x run-medley ] ; then
echo run from MEDLEYDIR
if [ ! -h ./medley ] || [ ! -d ./lispusers ]
then
echo "*** ERROR ***"
echo "You must run $(basename "$0") while the cwd is a Medley top-level directory."
echo "The cwd ($(pwd)) is not a Medley top-level directory."
echo "Exiting."
exit 1
fi
# shellcheck source=./loadup-setup.sh
. scripts/loadup-setup.sh
./scripts/loadup-db-from-full.sh && ./scripts/copy-db.sh

13
scripts/loadup-full-from-lisp.sh
View File

@@ -1,10 +1,15 @@
#!/bin/sh
if [ ! -x run-medley ] ; then
echo must run from MEDLEYDIR ;
exit 1 ;
if [ ! -h ./medley ] || [ ! -d ./lispusers ]
then
echo "*** ERROR ***"
echo "You must run $(basename "$0") while the cwd is a Medley top-level directory."
echo "The cwd ($(pwd)) is not a Medley top-level directory."
echo "Exiting."
exit 1
fi
# shellcheck source=./loadup-setup.sh
. scripts/loadup-setup.sh
loadup_start
@@ -27,7 +32,7 @@ SHH
"
EOF
./run-medley ${scr} -loadup "${cmfile}" "${LOADUP_WORKDIR}/lisp.sysout"
run_medley "${LOADUP_WORKDIR}/lisp.sysout"
loadup_finish "full.sysout" "full.*"

12
scripts/loadup-full.sh
View File

@@ -1,10 +1,16 @@
#!/bin/sh
# shellcheck disable=SC2181
if [ ! -x run-medley ] ; then
echo must run from MEDLEYDIR ;
exit 1 ;
if [ ! -h ./medley ] || [ ! -d ./lispusers ]
then
echo "*** ERROR ***"
echo "You must run $(basename "$0") while the cwd is a Medley top-level directory."
echo "The cwd ($(pwd)) is not a Medley top-level directory."
echo "Exiting."
exit 1
fi
# shellcheck source=./loadup-setup.sh
. ./scripts/loadup-setup.sh
./scripts/loadup-init.sh && \

11
scripts/loadup-init.sh
View File

@@ -1,10 +1,15 @@
#!/bin/sh
if [ ! -f run-medley ] ; then
echo run from MEDLEYDIR
if [ ! -h ./medley ] || [ ! -d ./lispusers ]
then
echo "*** ERROR ***"
echo "You must run $(basename "$0") while the cwd is a Medley top-level directory."
echo "The cwd ($(pwd)) is not a Medley top-level directory."
echo "Exiting."
exit 1
fi
# shellcheck source=./loadup-setup.sh
. scripts/loadup-setup.sh
loadup_start
@@ -40,6 +45,6 @@ cat >"${cmfile}" <<"EOF"
STOP
EOF
./run-medley $scr -loadup "${cmfile}" "${LOADUP_SOURCEDIR}"/starter.sysout
run_medley "${LOADUP_SOURCEDIR}/starter.sysout"
loadup_finish "init.dlinit" "init.*" "RDSYS*" "I-NEW*"

11
scripts/loadup-lisp-from-mid.sh
View File

@@ -1,10 +1,15 @@
#!/bin/sh
if [ ! -f run-medley ] ; then
echo run from MEDLEYDIR
if [ ! -h ./medley ] || [ ! -d ./lispusers ]
then
echo "*** ERROR ***"
echo "You must run $(basename "$0") while the cwd is a Medley top-level directory."
echo "The cwd ($(pwd)) is not a Medley top-level directory."
echo "Exiting."
exit 1
fi
# shellcheck source=./loadup-setup.sh
. scripts/loadup-setup.sh
loadup_start
@@ -29,6 +34,6 @@ SHH
"
EOF
./run-medley ${scr} -loadup "${cmfile}" "${LOADUP_WORKDIR}/init-mid.sysout"
run_medley "${LOADUP_WORKDIR}/init-mid.sysout"
loadup_finish "lisp.sysout" "lisp.*"

16
scripts/loadup-mid-from-init.sh
View File

@@ -1,10 +1,15 @@
#!/bin/sh
if [ ! -x run-medley ] ; then
echo run from MEDLEYDIR
if [ ! -h ./medley ] || [ ! -d ./lispusers ]
then
echo "*** ERROR ***"
echo "You must run $(basename "$0") while the cwd is a Medley top-level directory."
echo "The cwd ($(pwd)) is not a Medley top-level directory."
echo "Exiting."
exit 1
fi
# shellcheck source=./loadup-setup.sh
. scripts/loadup-setup.sh
loadup_start
@@ -18,9 +23,8 @@ cat >"${cmfile}" <<"EOF"
"
EOF
./run-medley -prog "ldeinit" \
-NF \
-loadup "${cmfile}" ${scr} -vmem "${LOADUP_WORKDIR}/init-mid.sysout" \
"${LOADUP_WORKDIR}/init.dlinit"
run_medley "${LOADUP_WORKDIR}/init.dlinit" -NF -prog ldeinit --vmem "${LOADUP_WORKDIR}/init-mid.sysout"
echo " "
loadup_finish "init-mid.sysout" "init-mid.sysout"

89
scripts/loadup-setup.sh
View File

@@ -1,19 +1,31 @@
#!sh
# shellcheck shell=sh
export MEDLEYDIR=`pwd`
MEDLEYDIR="$(pwd)"
export MEDLEYDIR
if [ -z "${LOADUP_WORKDIR}" ];
if [ -z "${LOADUP_WORKDIR}" ]
then
export LOADUP_WORKDIR=/tmp/loadups-$$
LOADUP_WORKDIR=/tmp/loadups-$$
export LOADUP_WORKDIR
fi
if [ -z "${LOADUP_SOURCEDIR}" ];
if [ -z "${LOADUP_SOURCEDIR}" ]
then
export LOADUP_SOURCEDIR="${MEDLEYDIR}"/internal/loadups
LOADUP_SOURCEDIR="${MEDLEYDIR}/internal/loadups"
export LOADUP_SOURCEDIR
fi
if [ -z "${LOADUP_OUTDIR}" ];
if [ -z "${LOADUP_OUTDIR}" ]
then
export LOADUP_OUTDIR="${MEDLEYDIR}"/loadups
LOADUP_OUTDIR="${MEDLEYDIR}/loadups"
export LOADUP_OUTDIR
fi
if [ -z "${LOADUP_LOGINDIR}" ]
then
LOADUP_LOGINDIR="${LOADUP_WORKDIR}/logindir"
export LOADUP_LOGINDIR
fi
if [ ! -d "${LOADUP_OUTDIR}" ];
@@ -22,7 +34,8 @@ then
then
mkdir -p "${LOADUP_OUTDIR}"
else
"Error: ${LOADUP_OUTDIR} exists but is not a directory. Exiting."
echo "Error: ${LOADUP_OUTDIR} exists but is not a directory. Exiting."
exit 1
fi
fi
@@ -32,18 +45,37 @@ then
then
mkdir -p "${LOADUP_WORKDIR}"
else
"Error: ${LOADUP_WORKDIR} exists but is not a directory. Exiting."
echo "Error: ${LOADUP_WORKDIR} exists but is not a directory. Exiting."
exit 1
fi
fi
scr="-sc 1024x768 -g 1042x790"
geometry=1024x768
touch "${LOADUP_WORKDIR}"/loadup.timestamp
script_name=$(basename "$0" ".sh")
cmfile="${LOADUP_WORKDIR}/${script_name}.cm"
# look thru args looking to see if oldschool was specified in args
j=1
jmax=$#
while [ "$j" -le "$jmax" ]
do
if [ "$(eval "printf %s \${${j}}")" = "-os" ] || [ "$(eval "printf %s \${${j}}")" = "--oldschool" ]
then
LOADUP_OLDSCHOOL=true
export LOADUP_OLDSCHOOL
break
else
j=$(( j + 1 ))
fi
done
######################################################################
@@ -65,9 +97,12 @@ loadup_start () {
}
loadup_finish () {
local exit_code
rm -f "${cmfile}"
if [ "${LOADUP_WORKDIR}"/loadup.timestamp -nt "${LOADUP_WORKDIR}/${1}" ];
# 2024-05-05 FGH
# Can't use exit code for now since on MacOS exit codes appear to be inverted
# Will restore once MacOS exit code are figured out
# if [ "${exit_code}" -ne 0 ] || [ ! -f "${LOADUP_WORKDIR}/$1" ]
if [ ! -f "${LOADUP_WORKDIR}/$1" ]
then
echo "----- FAILURE -----"
exit_code=1
@@ -76,17 +111,19 @@ loadup_finish () {
exit_code=0
fi
echo "..... files created ....."
if [ -f "${LOADUP_WORKDIR}/$1" ]
then
shift;
for f in ${*};
for f in "$@"
do
# shellcheck disable=SC2045,SC2086
for ff in $(ls -1 "${LOADUP_WORKDIR}"/$f);
do
if [ "${ff}" -nt "${LOADUP_WORKDIR}"/loadup.timestamp ];
then
ls -l ${ff} 2>/dev/null | grep -v "^.*~[0-9]\+~$"
fi
# shellcheck disable=SC2010
ls -l "${ff}" 2>/dev/null | grep -v "^.*~[0-9]\+~$"
done
done
fi
if [ "${TMP_PRE_EXISTS}" = "false" ];
then
rm -rf "${MEDLEYDIR}/tmp"
@@ -101,6 +138,26 @@ loadup_finish () {
exit ${exit_code}
}
run_medley () {
if [ ! "${LOADUP_OLDSCHOOL}" = true ]
then
./medley --config - \
--id loadup_+ \
--geometry "${geometry}" \
--noscroll \
--logindir "${LOADUP_LOGINDIR}" \
--greet "${cmfile}" \
--sysout "$1" \
"$2" "$3" "$4" "$5" "$6" "$7" ;
exit_code=$?
else
# shellcheck disable=SC2086
./run-medley ${scr} $2 $3 $4 $5 $6 $7 -loadup "${cmfile}" "$1"
exit_code=$?
fi
}
######################################################################

6
scripts/medley/README Normal file
View File

@@ -0,0 +1,6 @@
Note that medley.sh is just a symbolic link to medley.command (to accomodate MacOS).
medley.command should not be edited directly. It is compiled from all the of the
medley_*.sh components. The script compile.sh does this compile (with help from
the inline.sh script).

5
scripts/medley/compile.sh Executable file
View File

@@ -0,0 +1,5 @@
#!/bin/sh
mv medley.command medley.command~
./inline.sh --in-file medley_main.sh --out-file medley.command
chmod +x medley.command

460
scripts/medley/inline.sh Executable file
View File

@@ -0,0 +1,460 @@
#!/usr/bin/env sh
# MIT License
#
# Copyright (c) 2022-2022 Carlo Corradini
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# Inspired by https://gist.github.com/joehillen/30f08738c1c3c0ca3e4c754ad33ad2ff
# Fail on error
set -o errexit
# Disable wildcard character expansion
set -o noglob
# PID shell
SELF_PID=$$
# ================
# LOGGER
# ================
# Fatal log level. Cause exit failure
LOG_LEVEL_FATAL=100
# Warning log level
LOG_LEVEL_WARN=200
# Informational log level
LOG_LEVEL_INFO=300
# Debug log level
LOG_LEVEL_DEBUG=400
# Silent log level
LOG_LEVEL_SILENT=500
# Log level
LOG_LEVEL=$LOG_LEVEL_INFO
# Log color flag
LOG_COLOR_ENABLE=true
# Convert log level to equivalent name
# @param $1 Log level
to_log_level_name() {
_log_level=${1:-LOG_LEVEL}
_log_level_name=
case $_log_level in
"$LOG_LEVEL_FATAL") _log_level_name=fatal ;;
"$LOG_LEVEL_WARN") _log_level_name=warn ;;
"$LOG_LEVEL_INFO") _log_level_name=info ;;
"$LOG_LEVEL_DEBUG") _log_level_name=debug ;;
"$LOG_LEVEL_SILENT") _log_level_name=silent ;;
*) FATAL "Unknown log level '$_log_level'" ;;
esac
printf "%s\n" "$_log_level_name"
}
# Print log message
# @param $1 Log level
# @param $2 Message
_log_print_message() {
_log_level=${1:-LOG_LEVEL_FATAL}
shift
_log_level_name=
_log_message=${*:-}
_log_prefix=
_log_suffix="\033[0m"
# Check log level
if [ "$LOG_LEVEL" -eq "$LOG_LEVEL_SILENT" ] || [ "$_log_level" -gt "$LOG_LEVEL" ]; then
return 0
fi
case $_log_level in
"$LOG_LEVEL_FATAL")
_log_level_name=FATAL
_log_prefix="\033[41;37m"
;;
"$LOG_LEVEL_WARN")
_log_level_name=WARN
_log_prefix="\033[1;33m"
;;
"$LOG_LEVEL_INFO")
_log_level_name=INFO
_log_prefix="\033[37m"
;;
"$LOG_LEVEL_DEBUG")
_log_level_name=DEBUG
_log_prefix="\033[1;34m"
;;
esac
# Check color flag
if [ "$LOG_COLOR_ENABLE" = false ]; then
_log_prefix=
_log_suffix=
fi
# Log
printf '%b[%-5s] %b%b\n' "$_log_prefix" "$_log_level_name" "$_log_message" "$_log_suffix"
}
# Fatal log message
# @param $1 Message
FATAL() {
_log_print_message "$LOG_LEVEL_FATAL" "$1" >&2
exit 1
}
# Warning log message
# @param $1 Message
WARN() { _log_print_message "$LOG_LEVEL_WARN" "$1" >&2; }
# Informational log message
# @param $1 Message
INFO() { _log_print_message "$LOG_LEVEL_INFO" "$1" >&2; }
# Debug log message
# @param $1 Message
DEBUG() { _log_print_message "$LOG_LEVEL_DEBUG" "$1" >&2; }
# ================
# FUNCTIONS
# ================
# Show help message
show_help() {
cat << EOF
Usage: $(basename "$0") --in-file <FILE> [--disable-color] [--help] [--log-level <LEVEL>] [--out-file <FILE>] [--overwrite]
reCluster bundle script.
Options:
--disable-color Disable color
--help Show this help message and exit
--in-file <FILE> Input file
Values:
Any valid file
--log-level <LEVEL> Logger level
Default: $(to_log_level_name "$LOG_LEVEL")
Values:
fatal Fatal level
warn Warning level
info Informational level
debug Debug level
silent Silent level
--out-file <FILE> Output file
Default: [IN_FILE_NAME].inlined[IN_FILE_EXTENSION]
Values:
Any valid file
--overwrite Overwrite input file
EOF
}
# Assert command is installed
# @param $1 Command name
assert_cmd() {
command -v "$1" > /dev/null 2>&1 || FATAL "Command '$1' not found"
DEBUG "Command '$1' found at '$(command -v "$1")'"
}
# ================
# CACHE
# ================
# Cache
CACHE=
# Add file path to cache
# @param $1 File path
cache_add() {
if [ -z "$CACHE" ]; then
CACHE=$(printf '%s\n' "$1")
else
CACHE=$(printf '%s\n%s\n' "$CACHE" "$1")
fi
}
# Check cache has file path
# @param $1 File path
cache_has() {
while read -r _entry; do
if [ "$_entry" = "$1" ]; then
return 0
fi
done << EOF
$CACHE
EOF
return 1
}
# Inline sources ('source' or '.') of given script file
# @param $1 Script file path
inline_sources() {
_file=$1
_file_dir=$(dirname "$_file")
_regex='^([[:space:]]*)(source|\.)[[:space:]]+(.+)'
_regex_inline_skip='^[[:space:]]*#[[:space:]]*inline[[:space:]]+skip.*'
_regex_shellcheck='^[[:space:]]*#[[:space:]]*shellcheck[[:space:]]+source=(.+)'
_inline_skip=false
_source_file_shellcheck=
[ -f "$_file" ] || FATAL "File '$_file' does not exists"
INFO "Reading file '$_file'"
# Add to cache
cache_add "$_file"
# Read
while IFS='' read -r _line; do
DEBUG "Analyzing line '$_line'"
if printf "%s\n" "$_line" | grep -q -E "$_regex_inline_skip"; then
# # inline skip
_inline_skip=true
DEBUG "Inline skip '$_line'"
# Print line
printf '%s\n' "$_line"
elif printf "%s\n" "$_line" | grep -q -E "$_regex_shellcheck"; then
# # shellcheck source=...
DEBUG "ShellCheck source '$_line'"
# Source
_source_file_shellcheck=$(printf "%s\n" "$_line" | sed -n -r "s/$_regex_shellcheck/\1/p")
# Print line
printf '%s\n' "$_line"
elif printf "%s\n" "$_line" | grep -q -E "$_regex"; then
# source ...
# . ...
DEBUG "Source '$_line'"
# Source
_source_file=$(printf "%s\n" "$_line" | sed -n -r "s/$_regex/\3/p" | sed -e 's/^"//' -e 's/"$//')
# Check skip
[ "$_inline_skip" = false ] || {
# Skip
WARN "Skipping source '$_line'"
# Reset inline skip
_inline_skip=false
# Reset shellcheck
_source_file_shellcheck=
# Print line
printf '%s\n' "$_line"
continue
}
# Resolve source path
_path=
if printf "%s\n" "$_source_file" | grep -q -E -v '.*\/.*'; then
# Search $PATH
DEBUG "Searching '\$PATH'"
_path=$(command -v "$_source_file" || :)
fi
if [ -z "$_path" ]; then
# Resolve links, relative paths, ~, quotes, and escapes
DEBUG "Path is undefined, continue searching"
_path=$_source_file
if printf "%s\n" "$_path" | grep -q -E -v '^\/|^\$'; then
# Path does not start with '/' or '$' symbol, preprend directory
_path="$_file_dir/$_path"
fi
# Canonicalize
_path=$(eval readlink -f "$_path" || :)
DEBUG "Path candidate '$_path'"
if [ ! -f "$_path" ] && [ -n "$_source_file_shellcheck" ]; then
# File does not exists, try shellcheck
DEBUG "Path '$_path' is invalid, searching ShellCheck"
_path=$_source_file_shellcheck
if printf "%s\n" "$_path" | grep -q -E -v '^\/'; then
# Path does not start with '/' symbol, preprend directory
_path="$_file_dir/$_path"
fi
# Canonicalize
_path=$(readlink -f "$_path" || :)
DEBUG "Path candidate '$_path'"
# Reset shellcheck
_source_file_shellcheck=
fi
fi
# Check path
[ -f "$_path" ] || FATAL "Unable to resolve source file path '$_source_file'"
DEBUG "Source '$_source_file' resolved to '$_path'"
# Comment source
printf '# %s\n' "$_line"
# Check if already sourced
! cache_has "$_path" || {
WARN "Recursion detected, source '$_source_file' of '$_file'"
kill $SELF_PID
wait $SELF_PID
}
# Inline source and remove shebang
inline_sources "$_path" | sed '/^#!.*/d'
else
# Reset inline skip
_inline_skip=false
# Reset shellcheck
_source_file_shellcheck=
# Print line
printf '%s\n' "$_line"
fi
done < "$_file"
}
################################################################################################################################
# Parse command line arguments
# @param $@ Arguments
parse_args() {
# Assert argument has a value
# @param $1 Argument name
# @param $2 Argument value
parse_args_assert_value() {
[ -n "$2" ] || FATAL "Argument '$1' requires a non-empty value"
}
while [ $# -gt 0 ]; do
case $1 in
--disable-color)
# Disable color
LOG_COLOR_ENABLE=false
shift
;;
--help)
# Display help message and exit
show_help
exit 0
;;
--in-file)
# Input file
parse_args_assert_value "$@"
IN_FILE=$2
shift
shift
;;
--log-level)
# Log level
parse_args_assert_value "$@"
case $2 in
fatal) LOG_LEVEL=$LOG_LEVEL_FATAL ;;
warn) LOG_LEVEL=$LOG_LEVEL_WARN ;;
info) LOG_LEVEL=$LOG_LEVEL_INFO ;;
debug) LOG_LEVEL=$LOG_LEVEL_DEBUG ;;
silent) LOG_LEVEL=$LOG_LEVEL_SILENT ;;
*) FATAL "Value '$2' of argument '$1' is invalid" ;;
esac
shift
shift
;;
--out-file)
# Output file
parse_args_assert_value "$@"
OUT_FILE=$2
shift
shift
;;
--overwrite)
# Overwrite
OVERWRITE=true
shift
;;
-*)
# Unknown argument
WARN "Unknown argument '$1' is ignored"
shift
;;
*)
# No argument
WARN "Skipping argument '$1'"
shift
;;
esac
done
# Determine output file
if [ "$OVERWRITE" = true ]; then
# Input file
OUT_FILE=$IN_FILE
elif [ -n "$IN_FILE" ] && [ -z "$OUT_FILE" ]; then
# Input file 'inlined'
_in_file_basename=$(basename -- "$IN_FILE")
_in_file_name="${_in_file_basename%.*}"
_in_file_extension=
case $_in_file_basename in
*.*) _in_file_extension=".${_in_file_basename##*.}" ;;
esac
OUT_FILE="$_in_file_name.inlined$_in_file_extension"
fi
}
# Verify system
verify_system() {
assert_cmd grep
assert_cmd sed
[ -n "$IN_FILE" ] || FATAL "Input file required"
[ -f "$IN_FILE" ] || FATAL "Input file '$IN_FILE' does not exists"
if [ "$OVERWRITE" = false ] && [ -f "$OUT_FILE" ]; then FATAL "Output file '$OUT_FILE' already exists"; fi
}
# Inline input file
inline() {
INFO "Inlining file '$IN_FILE'"
_inlined=$(inline_sources "$(readlink -f "$IN_FILE")") || FATAL "Error inlining file '$IN_FILE'"
INFO "Saving file '$OUT_FILE'"
printf '%s\n' "$_inlined" > "$OUT_FILE"
}
# ================
# CONFIGURATION
# ================
# Input file
IN_FILE=
# Log level
LOG_LEVEL=$LOG_LEVEL_INFO
# Log color flag
LOG_COLOR_ENABLE=true
# Output file
OUT_FILE=
# Overwrite flag
OVERWRITE=false
# ================
# MAIN
# ================
{
parse_args "$@"
verify_system
inline
}

1657
scripts/medley/medley.command
View File

File diff suppressed because it is too large Load Diff

330
scripts/medley/medley_args.sh
View File

@@ -1,3 +1,6 @@
#!only-to-be-sourced
# shellcheck shell=sh
# shellcheck disable=SC2034,SC2154,SC2164
###############################################################################
#
# medley_args.sh - script for processing the args to medley.sh script.
@@ -12,115 +15,232 @@
###############################################################################
# load usage function
source ${SCRIPTDIR}/medley_usage.sh
# shellcheck source=./medley_usage.sh
. "${SCRIPTDIR}/medley_usage.sh"
args_stage="config file"
# Defaults
apps_flag=false
err_msg=""
full_flag=false
geometry=""
greet_specified=false
lisp_flag=false
noscroll=false
pass_args=false
run_args=()
run_id="default"
screensize=""
sysout_flag=false
sysout_arg=""
title="Medley Interlisp"
sysout_stage=""
title="Medley Interlisp %i"
use_vnc=false
windows=false
maikodir_arg=""
maikodir_stage=""
maikoprog_arg=""
greet_arg=""
noscroll=false
display_arg=""
vmem_arg=""
mem_arg=""
maiko_args=""
logindir_arg=""
nh_host_arg=""
nh_port_arg=""
nh_mac_arg=""
nh_debug_arg=""
pixelscale_arg=""
borderwidth_arg=""
# Add marker at end of args so we can accumulate pass-on args in args array
set -- "$@" "--start_of_pass_args"
# Loop thru args and process
while [ "$#" -ne 0 ];
do
if [ ${pass_args} = false ];
if [ "${pass_args}" = false ];
then
case "$1" in
-a | --apps)
sysout_arg="apps"
apps_flag=true
sysout_stage="${args_stage}"
;;
-c | --config)
# already handled so just skip both flag and value
shift;
;;
-d | --display)
check_for_dash_or_end "$1" "$2"
run_args+=(-d $2)
if [ "$2" = "-" ]
then
display=""
else
check_for_dash_or_end "$1" "$2"
display_arg="$2"
fi
shift
;;
-e | --interlisp)
export MEDLEY_EXEC="inter"
case "$2" in
-)
MEDLEY_EXEC=""
shift
;;
+)
export MEDLEY_EXEC="inter"
shift
;;
*)
export MEDLEY_EXEC="inter"
;;
esac
;;
-f | --full)
sysout_arg="-full"
full_flag=true
sysout_arg="full"
sysout_stage="${args_stage}"
;;
-g | --geometry)
check_for_dash_or_end "$1" "$2"
geometry="$2"
if [ "$2" = "-" ]
then
geometry=""
else
check_for_dash_or_end "$1" "$2"
geometry="$2"
fi
shift
;;
-h | --help)
usage
;;
-i | --id)
if [ "$2" = "-" ];
if [ "$2" = "-" ]
then
run_id=$( basename ${MEDLEYDIR} )
elif [ "$2" = "--" ];
run_id="default"
elif [ "$2" = "--" ]
then
run_id=$(cd ${MEDLEYDIR}; cd ..; basename $(pwd))
run_id="$( basename "${MEDLEYDIR}" )"
elif [ "$2" = "---" ]
then
run_id="$(cd "${MEDLEYDIR}/.."; basename "$(pwd)")"
else
check_for_dash_or_end "$1" "$2"
run_id=$(echo "$2" | sed s/[^A-Za-z0-9]//g)
run_id=$(echo "$2" | sed -e "s/++*\(.\)/\\1/g" -e "s/[^A-Za-z0-9+_]//g")
fi
shift
;;
-k | --vmem)
check_for_dash_or_end "$1" "$2"
check_file_writeable_or_creatable "$1" "$2"
export LDEDESTSYSOUT="$2"
if [ "$2" = "-" ]
then
vmem_arg=""
else
check_for_dash_or_end "$1" "$2"
check_file_writeable_or_creatable "$1" "$2"
vmem_arg="$2"
fi
shift
;;
-l | --lisp)
sysout_arg="-lisp"
lisp_flag=true
sysout_arg="lisp"
sysout_stage="${args_stage}"
;;
-m | --mem)
check_for_dash_or_end "$1" "$2"
run_args+=(-m $2)
if [ "$2" = "-" ]
then
mem_arg=""
else
check_for_dash_or_end "$1" "$2"
mem_arg="$2"
fi
shift
;;
-n | --noscroll)
noscroll=true
run_args+=("-noscroll")
case "$2" in
-)
noscroll=false
shift
;;
+)
noscroll=true
shift
;;
*)
noscroll=true
;;
esac
;;
-nh | --nethub)
case "$2" in
-:* | - )
true
;;
*)
check_for_dash_or_end "$1" "$2"
;;
esac
parse_nethub_data "$2"
if [ "${nh_host}" = "-" ]; then nh_host_arg=""; else nh_host_arg="${nh_host}"; fi
if [ "${nh_port}" = "-" ]; then nh_port_arg=""; else nh_port_arg="${nh_port}"; fi
if [ "${nh_mac}" = "-" ]; then nh_mac_arg=""; else nh_mac_arg="${nh_mac}"; fi
if [ "${nh_debug}" = "-" ]; then nh_debug_arg=""; else nh_debug_arg="${nh_debug}"; fi
shift
;;
-ps | --pixelscale)
if [ "$2" = "-" ]
then
pixelscale_arg=""
else
check_for_dash_or_end "$1" "$2"
pixelscale_arg="$2"
fi
shift
;;
-r | --greet)
if [[ "$2" = "-" || "$2" = "--" ]];
if [ "$2" = "-" ] || [ "$2" = "--" ]
then
run_args+=("--nogreet")
greet_arg="--nogreet--"
else
check_for_dash_or_end "$1" "$2"
check_file_readable "$1" "$2"
run_args+=("-greet" "$2")
greet_arg="$2"
fi
greet_specified='true'
shift
;;
-s | --screensize)
check_for_dash_or_end "$1" "$2"
screensize="$2"
if [ "$2" = "-" ]
then
screensize=""
else
check_for_dash_or_end "$1" "$2"
screensize="$2"
fi
shift
;;
-t | --title)
check_for_dash_or_end "$1" "$2"
if [ -n "$2" ]; then title="$2"; fi
if [ "$2" = "-" ]
then
title=""
else
check_for_dash_or_end "$1" "$2"
if [ -n "$2" ]; then title="$2"; fi
fi
shift
;;
-u | --continue)
sysout_arg=""
sysout_stage="${args_stage}"
;;
-v | --vnc)
if [[ ${wsl} = true && $(uname -m) = x86_64 ]];
case "$2" in
-)
use_vnc=false
shift
;;
+)
use_vnc=true
shift
;;
*)
use_vnc=true
;;
esac
if [ "${use_vnc}" = true ] && { [ ! "${wsl}" = true ] || [ ! "$(uname -m)" = x86_64 ] ; }
then
use_vnc=true
else
echo "Warning: The -v or --vnc flag was set."
echo "But the vnc option is only available when running on "
echo "Windows System for Linux (wsl) on x86_64 machines."
@@ -129,19 +249,33 @@ do
fi
;;
-x | --logindir)
if [[ "$2" = "-" || "$2" = "--" ]];
if [ "$2" = "-" ]
then
logindir_arg=""
elif [ "$2" = "--" ]
then
check_dir_writeable_or_creatable "$1" "${MEDLEYDIR}/logindir"
LOGINDIR="${MEDLEYDIR}/logindir"
logindir_arg="${MEDLEYDIR}/logindir"
else
check_for_dash_or_end "$1" "$2"
check_dir_writeable_or_creatable "$1" "$2"
LOGINDIR="$2"
logindir_arg="$2"
fi
shift
;;
-y | --sysout)
if [ "$2" = "-" ]
then
sysout_arg=""
else
check_for_dash_or_end "$1" "$2"
sysout_arg="$2"
fi
sysout_stage="${args_stage}"
shift
;;
-z | --man)
if [ ${darwin} = true ];
if [ "${darwin}" = true ]
then
/usr/bin/man "${MEDLEYDIR}/docs/man-page/medley.1.gz"
else
@@ -149,79 +283,89 @@ do
fi
exit 0
;;
-nf | -NF | --nofork)
# for use in loadups
case $2 in
-)
nofork_arg=""
;;
+)
nofork_arg="-NF"
;;
*)
nofork_arg="-NF"
;;
esac
;;
--maikodir)
# for use in loadups
check_for_dash_or_end "$1" "$2"
check_dir_exists "$1" "2"
maikodir_arg="$2"
maikodir_stage="${args_stage}"
shift;
;;
-prog | --maikoprog)
# for use in loadups
check_for_dash_or_end "$1" "$2"
maikoprog_arg="$2"
shift
;;
--windows)
# internal: called from Windows medley.ps1 (via docker)
windows=true
;;
--start_cl_args)
# internal: used to separate config file args from command line args
args_stage="command line arguments"
pass_args=false
;;
--start_of_pass_args)
# internal: used to mark end of args and start of accumulated pass-on args
shift
break
;;
--)
pass_args=true
;;
-*)
err_msg=("ERROR: Unknown flag: $1" )
usage "${err_msg[@]}"
usage "ERROR: Unknown flag: $1"
;;
*)
# if matched the empty string, just ignore
if [ -n "$1" ];
then
if [[ $# -eq 1 || "$2" = "--" ]];
if [ $# -eq 1 ] || [ "$2" = "--" ]
then
sysout_flag=true
sysout_arg="$1"
sysout_stage="${args_stage}"
else
err_msg=(
"ERROR: sysout argument must be last argument"
"or last argument before the \"--\" flag"
)
usage "${err_msg[@]}"
err_msg="ERROR: unexpected argument \"$1\""
usage "${err_msg}"
fi
fi
;;
esac
else
run_args+=("$1")
if [ "$1" = "--start_cl_args" ]
then
args_stage="command line arguments"
pass_args=false
elif [ "$1" = "--start_of_pass_args" ]
then
shift
break
else
# add pass-on args to end of args array
set -- "$@" "$1"
# maiko_args="${maiko_args} \"$1\""
fi
fi
shift
done
# Figure out screensize and geometry based on arguments
source ${SCRIPTDIR}/medley_geometry.sh
# Figure out the sysout situation
ctr=0
for x in ${lisp_flag} ${full_flag} ${apps_flag} ${sysout_flag};
do
if [ "${x}" = "true" ];
then
(( ctr++ ))
fi
done
if [ ${ctr} -gt 1 ];
then
err_msg=(
"Error: only one sysout can be specified. Two or more sysouts were specified"
"via the -l (--lisp), -f (--full), -a (--apps) flags and/or a sysout filename"
)
usage "${err_msg[@]}"
fi
if [ "${sysout_arg}" = "apps" ];
then
export LDESRCESYSOUT="${MEDLEYDIR}/loadups/apps.sysout"
if [ "${greet_specified}" = "false" ];
then
export LDEINIT="${MEDLEYDIR}/greetfiles/APPS-INIT.LCOM"
fi
else
# pass on to run-medley
unset LDESRCESYSOUT
if [ -n "${sysout_arg}" ];
then
run_args+=("${sysout_arg}")
fi
fi
# if running on WSL1, force use_vnc
if [[ ${wsl} = true && ${wsl_ver} -eq 1 ]];
if [ "${wsl}" = true ] && [ "${wsl_ver}" -eq 1 ]
then
use_vnc=true
fi

78
scripts/medley/medley_configfile.sh Normal file
View File

@@ -0,0 +1,78 @@
#!only-to-be-sourced
# shellcheck shell=sh
###############################################################################
#
# medley_configfile.sh - script for processing the config file for the
# medley.sh script.
#
# !!!! This script is meant to be SOURCEd from the scripts/medley.sh script.
# !!!! It should not be run as a standlone script.
#
# 2024-04-20 Frank Halasz
#
# Copyright 2024 Interlisp.org
#
###############################################################################
config_file=""
# look thru args looking to see if a config file was specified
j=1
jmax=$#
while [ "$j" -le "$jmax" ]
do
if [ "$(eval "printf %s \${${j}}")" = "-c" ] || [ "$(eval "printf %s \${${j}}")" = "--config" ]
then
k=$(( j + 1 ))
config_file="$(eval "printf %s \${${k}}")"
if [ ! "${config_file}" = "-" ] && [ ! -f "${config_file}" ]
then
echo "Error: specified config file \"${config_file}\" not found."
echo "Exiting."
exit 52
fi
j=$(( j + 1 ))
fi
j=$(( j + 1 ))
done
# if no config file specified, use the defaults (if they exist)
if [ -z "${config_file}" ]
then
for f in "${HOME}/.medley_config" "${MEDLEYDIR}/.medley_config"
do
if [ -f "$f" ]
then
config_file="$f"
fi
done
fi
# add marker to separate config file args from command line args
set -- "--start_cl_args" "--start_cl_args" "$@"
# if there is a config file and its not been suppressed with "-",
# read the config file (in reverse order) and add the first two items on each line
# to the arguments array
if [ -n "${config_file}" ] && [ ! "${config_file}" = "-" ]
then
rev_config_file="${TMPDIR:-/tmp}"/.medley_config_$$
# reverse order of lines in medley config file
sed '1!x;H;1h;$!d;g' < "${config_file}" >"${rev_config_file}"
while read -r arg1 arg2
do
if [ -n "${arg2}" ]
then
arg2="$(echo "${arg2}" | sed s/\"//g)"
set -- "${arg2}" "$@"
fi
if [ -n "${arg1}" ]
then
set -- "${arg1}" "$@"
fi
done < "${rev_config_file}"
rm -f "${rev_config_file}"
fi

71
scripts/medley/medley_geometry.sh
View File

@@ -1,3 +1,6 @@
#!only-to-be-sourced
# shellcheck shell=sh
# shellcheck disable=SC2154,SC2269
###############################################################################
#
# medley_geometry.sh - script for computing the geometry and screensize
@@ -12,68 +15,66 @@
#
###############################################################################
if [ ${noscroll} = false ];
if [ "${noscroll}" = false ];
then
scroll=22
else
scroll=0
fi
if [[ -n ${geometry} && -n ${screensize} ]];
if [ -n "${geometry}" ] && [ -n "${screensize}" ]
then
gw=$(expr "${geometry}" : "\([0-9]*\)x[0-9]*$")
gh=$(expr "${geometry}" : "[0-9]*x\([0-9]*\)$")
if [[ -z "${gw}" || -z "${gh}" ]];
if [ -z "${gw}" ] || [ -z "${gh}" ]
then
echo "Error: Improperly formed -geometry or -dimension argument: ${geometry}"
echo "Exiting"
exit 7
err_msg="Error: Improperly formed -geometry or -dimension argument: ${geometry}"
usage "${err_msg}"
fi
geometry="-g ${geometry}"
geometry="${geometry}"
#
sw=$(expr "${screensize}" : "\([0-9]*\)x[0-9]*$")
sh=$(expr "${screensize}" : "[0-9]*x\([0-9]*\)$")
if [[ -z "${sw}" || -z "${sh}" ]];
if [ -z "${sw}" ] || [ -z "${sh}" ]
then
echo "Error: Improperly formed -screensize argument: ${screensize}"
echo "Exiting"
exit 7
err_msg="Error: Improperly formed -screensize argument: ${screensize}"
usage "${err_msg}"
fi
screensize="-sc ${screensize}"
elif [[ -n ${geometry} ]];
screensize="${screensize}"
elif [ -n "${geometry}" ]
then
gw=$(expr "${geometry}" : "\([0-9]*\)x[0-9]*$")
gh=$(expr "${geometry}" : "[0-9]*x\([0-9]*\)$")
if [ -n "${gw}" -a -n "${gh}" ] ; then
sw=$(( ((31+${gw})/32*32) - ${scroll} ))
sh=$(( ${gh} - ${scroll} ))
geometry="-g ${gw}x${gh}"
screensize="-sc ${sw}x${sh}"
if [ -n "${gw}" ] && [ -n "${gh}" ]
then
sw=$(( (((31+gw)/32)*32)-scroll ))
sh=$(( gh - scroll ))
geometry="${gw}x${gh}"
screensize="${sw}x${sh}"
else
echo "Error: Improperly formed -geometry or -dimension argument: ${geometry}"
echo "Exiting"
exit 7
err_msg="Error: Improperly formed -geometry or -dimension argument: ${geometry}"
usage "${err_msg}"
fi
elif [[ -n ${screensize} ]];
elif [ -n "${screensize}" ]
then
sw=$(expr "${screensize}" : "\([0-9]*\)x[0-9]*$")
sh=$(expr "${screensize}" : "[0-9]*x\([0-9]*\)$")
if [ -n "${sw}" -a -n "${sh}" ] ; then
sw=$(( (31+$sw)/32*32 ))
gw=$(( ${scroll}+${sw} ))
gh=$(( ${scroll}+${sh} ))
geometry="-g ${gw}x${gh}"
screensize="-sc ${sw}x${sh}"
if [ -n "${sw}" ] && [ -n "${sh}" ]
then
sw=$(( (31+sw)/32*32 ))
gw=$(( scroll+sw ))
gh=$(( scroll+sh ))
geometry="${gw}x${gh}"
screensize="${sw}x${sh}"
else
echo "Error: Improperly formed -screensize argument: ${screensize}"
echo "Exiting"
exit 7
err_msg="Error: Improperly formed -screensize argument: ${screensize}"
usage "${err_msg}"
fi
else
screensize="-sc 1440x900"
if [ ${noscroll} = false ];
screensize="1440x900"
if [ "${noscroll}" = false ];
then
geometry="-g 1462x922"
geometry="1462x922"
else
geometry="-g 1440x900"
geometry="1440x900"
fi
fi

28
scripts/medley/medley_header.sh Normal file
View File

@@ -0,0 +1,28 @@
#!only-to-be-sourced
# shellcheck shell=sh
###############################################################################
#
# medley.sh - script for running Medley Interlisp on
# Linux/WSL/Cygwin/MacOS. On all platforms it just sets
# up directories and environment variables and then calls
# maiko with the right arguments. On WSL, there is an option to
# run without or around X Windows by using the XVnc and a VNC viewer
# on the Windows side. This script will start this VNC viewer
# on the Windows side.
#
# NOTE: This script is "compiled" using compile.sh (and inline.sh) from the
# component scripts (medley_*.sh). The top-level component is
# medley_main.sh. The other components are sourced (directly or
# indirectly) from medley_main.sh.
#
# Do not edit this script directly. Edit the component scripts and
# then recompile to get this "combined" script. You can also run
# the scripts by exec-ing the medley_main.sh script. This will allow
# testing of component modifications without having to compile.
#
# 2023-01-12 Frank Halasz
# 2024-04-29 Frank Halasz: Major overhaul
#
# Copyright 2023-2024 Interlisp.org
#
###############################################################################

207
scripts/medley/medley_main.sh Executable file
View File

@@ -0,0 +1,207 @@
#!/bin/sh
# shellcheck disable=SC2164,SC2181,SC2009,SC2034,SC2154
. ./medley_header.sh
###############################################################################
#
# medley_main.sh - "main" script for running Medley Interlisp on
# Linux/WSL/Cygwin/MacOS. On all platforms it just sets
# up directories and environment variables and then calls
# maiko with the right arguments. On WSL, there is an option to
# run without or around X Windows by using the XVnc and a VNC viewer
# on the Windows side. This script will start this VNC viewer
# on the Windows side.
#
# 2023-01-12 Frank Halasz
# 2024-04-29 Frank Halasz: Major overhaul
#
# Copyright 2023-2024 Interlisp.org
#
###############################################################################
#set -x
#
#
# Start off with some functions to determine what directory this script is being executed from
#
#
get_abs_filename() {
# $1 : relative filename
echo "$(cd "$(dirname "$1")" && pwd)/$(basename "$1")"
}
# This function taken from
# https://stackoverflow.com/questions/29832037/how-to-get-script-directory-in-posix-sh
rreadlink() (
# Execute this function in a *subshell* to localize variables and the effect of `cd`.
target=$1
fname=
targetDir=
CDPATH=
# Try to make the execution environment as predictable as possible:
# All commands below are invoked via `command`, so we must make sure that `command`
# itself is not redefined as an alias or shell function.
# (Note that command is too inconsistent across shells, so we don't use it.)
# `command` is a *builtin* in bash, dash, ksh, zsh, and some platforms do not even have
# an external utility version of it (e.g, Ubuntu).
# `command` bypasses aliases and shell functions and also finds builtins
# in bash, dash, and ksh. In zsh, option POSIX_BUILTINS must be turned on for that
# to happen.
{ \unalias command; \unset -f command; } >/dev/null 2>&1
[ -n "$ZSH_VERSION" ] && options[POSIX_BUILTINS]=on # make zsh find *builtins* with `command` too.
while :; do # Resolve potential symlinks until the ultimate target is found.
[ -L "$target" ] || [ -e "$target" ] || { command printf '%s\n' "ERROR: '$target' does not exist." >&2; return 1; }
command cd "$(command dirname -- "$target")" # Change to target dir; necessary for correct resolution of target path.
fname=$(command basename -- "$target") # Extract filename.
[ "$fname" = '/' ] && fname='' # !! curiously, `basename /` returns '/'
if [ -L "$fname" ]; then
# Extract [next] target path, which may be defined
# *relative* to the symlink's own directory.
# Note: We parse `ls -l` output to find the symlink target
# which is the only POSIX-compliant, albeit somewhat fragile, way.
target=$(command ls -l "$fname")
target=${target#* -> }
continue # Resolve [next] symlink target.
fi
break # Ultimate target reached.
done
targetDir=$(command pwd -P) # Get canonical dir. path
# Output the ultimate target's canonical path.
# Note that we manually resolve paths ending in /. and /.. to make sure we have a normalized path.
if [ "$fname" = '.' ]; then
command printf '%s\n' "${targetDir%/}"
elif [ "$fname" = '..' ]; then
# Caveat: something like /var/.. will resolve to /private (assuming /var@ -> /private/var), i.e. the '..' is applied
# AFTER canonicalization.
command printf '%s\n' "$(command dirname -- "${targetDir}")"
else
command printf '%s\n' "${targetDir%/}/$fname"
fi
)
get_script_dir() {
# call this with $0 (from main script) as its (only) parameter
# if you need to preserve cwd, run this is a subshell since
# it can change cwd
# set -x
local_SCRIPT_PATH="$( get_abs_filename "$1" )";
while [ -h "$local_SCRIPT_PATH" ];
do
cd "$( dirname -- "$local_SCRIPT_PATH"; )";
local_SCRIPT_PATH="$( rreadlink "$local_SCRIPT_PATH" )";
done
cd "$( dirname -- "$local_SCRIPT_PATH"; )" > '/dev/null';
local_SCRIPT_PATH="$( pwd; )";
# set +x
echo "${local_SCRIPT_PATH}"
}
# end of script directory functions
###############################################################################
# figure out the script dir
SCRIPTDIR="$(get_script_dir "$0")"
# Define some generally useful functions
# shellcheck source=./medley_utils.sh
. "${SCRIPTDIR}/medley_utils.sh"
MEDLEYDIR="$(cd "${SCRIPTDIR}/../.."; pwd)"
export MEDLEYDIR
IL_DIR="$(cd "${MEDLEYDIR}/.."; pwd)"
# Are we running under WSL or Darwin or Cygwin?
#
wsl=false
darwin=false
cygwin=false
if [ "$(uname)" = "Darwin" ]
then
darwin=true
elif [ "$(uname -s | head --bytes 6)" = "CYGWIN" ]
then
cygwin=true
elif [ -e "/proc/version" ] && grep --ignore-case --quiet Microsoft /proc/version
then
wsl=true
wsl_ver=0
# WSL2
grep --ignore-case --quiet wsl /proc/sys/kernel/osrelease
if [ $? -eq 0 ];
then
wsl_ver=2
else
# WSL1
grep --ignore-case --quiet microsoft /proc/sys/kernel/osrelease
if [ $? -eq 0 ]
then
if [ "$(uname -m)" = "x86_64" ]
then
wsl_ver=1
else
err_msg="ERROR: Running Medley on WSL1 requires an x86_64-based PC.
This is not an x86_64-based PC.
Exiting"
output_error_msg "${err_msg}"
exit 23
fi
fi
fi
fi
# process config file and args
# shellcheck source=./medley_configfile.sh
. "${SCRIPTDIR}/medley_configfile.sh"
# shellcheck source=./medley_args.sh
. "${SCRIPTDIR}/medley_args.sh"
# Process run_id
# if it doesn't end in #, make sure that there is not another instance currently running with this same id
# If it does end in #, find the right number to fill in for the #
run_id_base="${run_id%+}"
run_id_has_plus="${run_id#"${run_id_base}"}"
if [ -z "${run_id_has_plus}" ]
then
matching=$(ps ax | sed -e "/sed/d" -e "/ldex.*-id ${run_id_base}/p" -e "/ldesdl.*-id ${run_id_base}/p" -e d)
if [ -n "${matching}" ]
then
err_msg="Another instance of Medley Interlisp is already running with the id \"${run_id}\".
Only a single instance with a given id can be run at the same time.
Please retry using the \"--id <name>\" argument to give this new instance a different id.
Exiting"
output_error_msg "${err_msg}"
exit 3
fi
else
matching=$( \
ps ax | \
sed -e "/ldex.*-id ${run_id_base}[0-9]/s/^.*-id ${run_id_base}\([0-9]*\).*$/\\1/p" \
-e "/ldesdl.*-id ${run_id_base}[0-9]/s/^.*-id ${run_id_base}\([0-9]*\).*$/\\1/p" \
-e d \
)
max=0
for n in $matching
do
if [ "$n" -gt "$max" ]; then max=$n; fi
done
max=$(( max + 1 ))
run_id="${run_id_base}${max}"
fi
# Run medley
# shellcheck source=./medley_run.sh
. "${SCRIPTDIR}/medley_run.sh"

320
scripts/medley/medley_run.sh Normal file
View File

@@ -0,0 +1,320 @@
#!only-to-be-sourced
# shellcheck shell=sh
# shellcheck disable=SC2154,SC2164,SC2086
###############################################################################
#
# medley_run.sh - script for processing actually running maiko/medley
# for the medley.sh script.
#
# !!!! This script is meant to be SOURCEd from the scripts/medley.sh script.
# !!!! It should not be run as a standlone script.
#
# 2024-04-21 Frank Halasz
#
# Copyright 2024 Interlisp.org
#
###############################################################################
# Figure out LOGINDIR situation
if [ -z "${logindir_arg}" ]
then
LOGINDIR="${HOME}/il"
else
LOGINDIR="${logindir_arg}"
fi
export LOGINDIR
if [ ! -e "${LOGINDIR}" ];
then
mkdir -p "${LOGINDIR}"
elif [ ! -d "${LOGINDIR}" ];
then
echo "ERROR: Medley requires a directory named ${LOGINDIR}."
echo "But ${LOGINDIR} exists but appears not be a directory."
echo "Exiting"
exit 2
fi
mkdir -p "${LOGINDIR}"/vmem
# Set LDEDESTSYSOUT env variable based on id
# if LDEDESRTSYSOUT has not already been set
# during arg processing
if [ -z "${vmem_arg}" ]
then
if [ "${run_id}" = "default" ]
then
LDEDESTSYSOUT="${LOGINDIR}/vmem/lisp.virtualmem"
else
LDEDESTSYSOUT="${LOGINDIR}/vmem/lisp_${run_id}.virtualmem"
fi
else
LDEDESTSYSOUT="${vmem_arg}"
fi
export LDEDESTSYSOUT
# Figure out the sysout situation
loadups_dir="${MEDLEYDIR}/loadups"
if [ -z "${sysout_arg}" ]
then
if [ -f "${LDEDESTSYSOUT}" ]
then
src_sysout="${LDEDESTSYSOUT}"
else
src_sysout="${loadups_dir}/full.sysout"
fi
else
case "${sysout_arg}" in
lisp | full | apps)
if [ ! -d "${loadups_dir}" ]
then
err_msg="Error: The sysout argument --${sysout_arg} was specified in ${sysout_stage},
but the directory \"${loadups_dir}\" where ${sysout_arg}.sysout is supposed to be located
cannot be found.
Exiting."
output_error_msg "${err_msg}"
exit 62
fi
src_sysout="${loadups_dir}/${sysout_arg}.sysout"
;;
*)
src_sysout="${sysout_arg}"
;;
esac
fi
if [ ! -f "${src_sysout}" ]
then
err_msg="Error: Cannot find the specified sysout file \"${src_sysout}\".
Exiting."
output_error_msg "${err_msg}"
fi
# Figure out screensize and geometry based on arguments
# shellcheck source=./medley_geometry.sh
. "${SCRIPTDIR}/medley_geometry.sh"
# Figure out border width situation
borderwidth_flag=""
borderwidth_value=""
if [ -n "${borderwidth_arg}" ]
then
borderwidth_flag="-bw"
borderwidth_value="${borderwidth_arg}"
fi
# Figure out pixelscale situation
pixelscale_flag=""
pixelscale_value=""
if [ -n "${pixelscale_arg}" ]
then
pixelscale_flag="-pixelscale"
pixelscale_value="${pixelscale_arg}"
fi
# figure out greet files situation
if [ -z "${greet_arg}" ]
then
if [ "${sysout_arg}" = "apps" ]
then
LDEINIT="${MEDLEYDIR}/greetfiles/APPS-INIT.LCOM"
else
LDEINIT="${MEDLEYDIR}/greetfiles/MEDLEYDIR-INIT.LCOM"
fi
else
if [ "${greet_arg}" = "--nogreet--" ]
then
LDEINIT="${MEDLEYDIR}/greetfiles/NOGREET"
else
LDEINIT="${greet_arg}"
fi
fi
export LDEINIT
# figure out noscroll situation
noscroll_arg=""
if [ "${noscroll}" = true ]
then
noscroll_arg="-noscroll"
fi
# figure out -m situatiom
mem_flag=""
mem_value=""
if [ -n "${mem_arg}" ]
then
mem_flag="-m"
mem_value="${mem_arg}"
fi
# figure out the nethub situation
nh_host_flag=""
nh_host_value=""
nh_port_flag=""
nh_port_value=""
nh_mac_flag=""
nh_mac_value=""
nh_debug_flag=""
nh_debug_value=""
if [ -n "${nh_host_arg}" ]
then
nh_host_flag="-nh-host"
nh_host_value="${nh_host_arg}"
if [ -n "${nh_port_arg}" ]
then
nh_port_flag="-nh-port"
nh_port_value="${nh_port_arg}"
fi
if [ -n "${nh_mac_arg}" ]
then
nh_mac_flag="-nh-mac"
nh_mac_value="${nh_mac_arg}"
fi
if [ -n "${nh_debug_arg}" ]
then
nh_debug_flag="-nh-loglevel"
nh_debug_value="${nh_debug_arg}"
fi
fi
# figure out the keyboard type
if [ -z "${LDEKBDTYPE}" ]; then
export LDEKBDTYPE="X"
fi
# figure out title situation
if [ ! "${run_id}" = default ]
then
title="$(printf %s "${title}" | sed -e "s/%i/:: ${run_id}/")"
else
title="$(printf %s "${title}" | sed -e "s/%i//")"
fi
# Figure out the maiko executable name
# used for loadups (ldeinit)
if [ -z "${maikoprog_arg}" ]
then
maikoprog_arg="lde"
fi
# Figure out the maiko directory maiko
check_if_maiko_dir () {
if [ -d "$1/bin" ]
then
cd "$1/bin"
else
return 1
fi
if [ -x ./osversion ] && [ -x ./machinetype ]
then
maiko_exe="$1/$(./osversion).$(./machinetype)/${maikoprog_arg}"
if [ -x "${maiko_exe}" ]
then
cd ${OLDPWD}
return 0
fi
fi
maiko_exe=""
cd ${OLDPWD}
return 1
}
if [ -z "${maikodir_arg}" ]
then
if [ -d "${MEDLEYDIR}/maiko" ] && check_if_maiko_dir "${MEDLEYDIR}/maiko"
then
maikodir_arg="${MEDLEYDIR}/maiko"
elif [ -d "${MEDLEYDIR}/../maiko" ] && check_if_maiko_dir "${MEDLEYDIR}/../maiko"
then
maikodir_arg="$(cd "${MEDLEYDIR}/../maiko"; pwd)"
else
err_msg="ERROR: Cannot find the directory containing the Maiko emulator in either
\"${MEDLEYDIR}/maiko\" or \"${MEDLEYDIR}/../maiko\".
Please use the --maikodir argument to specify the correct Maiko directory.
Exiting."
output_error_msg "${err_msg}"
exit 53
fi
elif ! check_if_maiko_dir "${maikodir_arg}"
then
err_msg="In ${maikodir_stage}:
ERROR: The value of the --maikodir argument is not in fact a directory containing
the Maiko emulator. Exiting."
output_error_msg "${err_msg}"
exit 53
fi
maiko="${maiko_exe}"
# Define function to start up maiko given all arguments
# Arg to this function should be "$@", the main args
# array that at this point should just include the pass-on args
start_maiko() {
echo \
\"${maiko}\" \"${src_sysout}\" \
-id \"${run_id}\" \
-title \"${title}\" \
-g ${geometry} \
-sc ${screensize} \
${borderwidth_flag} ${borderwidth_value} \
${pixelscale_flag} ${pixelscale_value} \
${noscroll_arg} \
${mem_flag} ${mem_value} \
${nh_host_flag} ${nh_host_value} \
${nh_port_flag} ${nh_port_value} \
${nh_mac_flag} ${nh_mac_value} \
${nh_debug_flag} ${nh_debug_value} \
${nofork_arg} \
"$@" ;
echo "MEDLEYDIR: \"${MEDLEYDIR}\""
echo "LOGINDIR: \"${LOGINDIR}\""
echo "GREET FILE: \"${LDEINIT}\""
echo "VMEM FILE: \"${LDEDESTSYSOUT}\""
#
# Temp workaround for issues in Maiko sysout arg
# processing. See Issue #1702. FGH 2024-05-09
#
LDESOURCESYSOUT="${src_sysout}"
export LDESOURCESYSOUT
#
# End work around
#
"${maiko}" "${src_sysout}" \
-id "${run_id}" \
-title "${title}" \
-g "${geometry}" \
-sc "${screensize}" \
${borderwidth_flag} ${borderwidth_value} \
${pixelscale_flag} ${pixelscale_value} \
${noscroll_arg} \
${mem_flag} ${mem_value} \
${nh_host_flag} ${nh_host_value} \
${nh_port_flag} ${nh_port_value} \
${nh_mac_flag} ${nh_mac_value} \
${nh_debug_flag} ${nh_debug_value} \
${nofork_arg} \
"$@" ;
exit_code=$?
}
# temp fix for cygwin to workaround issue #1685
# 2024-04-29
if [ "${cygwin}" = true ]
then
MEDLEYDIR="${MEDLEYDIR}/"
fi
# Run maiko either directly or with vnc
if [ "${wsl}" = true ] && [ "${use_vnc}" = true ]
then
# do the vnc thing on wsl (if called for)
# shellcheck source=./medley_vnc.sh
. "${SCRIPTDIR}/medley_vnc.sh"
else
# If not using vnc, just exec maiko directly
# handing over the pass-on args which are all thats left in the main args array
start_maiko "$@"
fi
exit ${exit_code}

64
scripts/medley/medley_usage.sh
View File

@@ -1,3 +1,6 @@
#!only-to-be-sourced
# shellcheck shell=sh
# shellcheck disable=SC2154
###############################################################################
#
# medley_useage.sh - script defining the "usage" for medley.sh script.
@@ -11,14 +14,13 @@
#
###############################################################################
PAGER=$( if [ -n $(which more) ]; then echo "more"; else echo "cat"; fi)
PAGER=$( if [ -n "$(which more)" ]; then echo "more"; else echo "cat"; fi)
usage() {
local err_msg
local msg_path=/tmp/msg-$$
local lines=("$@")
usage_msg_path=/tmp/msg-$$
if [ ${wsl} = true ];
if [ "${wsl}" = true ];
then
wsl_incl="+w"
wsl_excl="-w"
@@ -27,7 +29,7 @@ usage() {
wsl_excl="+w"
fi
if [ ${docker} = true ];
if [ "${docker}" = true ];
then
docker_incl="+d"
docker_excl="-d"
@@ -36,7 +38,7 @@ usage() {
docker_excl="+d"
fi
if [ ${windows} = true ];
if [ "${windows}" = true ];
then
windows_incl="+W"
windows_excl="-W"
@@ -47,15 +49,14 @@ usage() {
if [ $# -ne 0 ];
then
echo > ${msg_path}
echo "$(output_error_msg "${lines[@]}")" >> ${msg_path}
echo >> ${msg_path}
echo >> ${msg_path}
full_msg="In ${args_stage}:
$1"
{ echo; output_error_msg "${full_msg}"; echo; } >> "${usage_msg_path}"
else
touch ${msg_path}
touch "${usage_msg_path}"
fi
cat ${msg_path} - <<EOF \
cat "${usage_msg_path}" - <<EOF \
| sed -e "/^${docker_excl}/d" -e "s/^${docker_incl}/ /" \
| sed -e "/^${wsl_excl}/d" -e "s/^${wsl_incl}/ /" \
| sed -e "/^${windows_excl}/d" -e "s/^${windows_incl}/ /" \
@@ -72,11 +73,17 @@ flags:
-z | --man : show the man page for medley
-c FILE | --config FILE : use FILE as the config file (default: ~/.medley_config)
-f | --full : start Medley from the "full" sysout
-l | --lisp : start Medley from the "lisp" sysout
-a | --apps : start Medley from the "apps" sysout
-a | --apps : start Medley from the "apps" sysout
-u | --continue : start Medley from the vmem file from previous Medley run
-y FILE | --sysout FILE : start Medley using FILE as sysout
-e | --interlisp : (for apps.sysout only) Start in the Interlisp exec
@@ -86,6 +93,8 @@ flags:
-s WxH | --screensize WxH : set the Medley screen size to be Width x Height
-ps N | --pixelscale N : use N as the pixel scale factor - for SDL display only
-t STRING | --title STRING : use STRING as title of window
-d :N | --display :N : use X display :N
@@ -94,42 +103,25 @@ flags:
-i STRING | --id STRING : use STRING as the id for this run of Medley (default: default)
-i - | --id - : for id use the basename of MEDLEYDIR
-i -- | --id -- : for id use the basename of the parent directory of MEDLEYDIR
-m N | --mem N : set Medley memory size to N
-k FILE | --vmem FILE : use FILE as the Medley virtual memory store.
+d FILE must be a file in the Medley file system under LOGINDIR (/home/medley/il).
-r FILE | --greet FILE : use FILE as the Medley greetfile.
+d FILE must be a file in the Medley file system under LOGINDIR (/home/medley/il).
-r - | --greet - : do not use a greetfile
-d
-d -x DIR | --logindir DIR : use DIR as LOGINDIR in Medley
-d
-d -x - | --logindir - : use MEDLEYDIR/logindir as LOGINDIR in Medley
+d
+d -x DIR | --logindir DIR : use DIR (on the host) to map to LOGINDIR (/home/medley/il) in Medley
+d
+d -p N | --port N : use N as the port for connecting to the Xvnc server inside the Docker container
+d
+d -u | --update : first do a pull to get the latest medley Docker image
+W
+W -w DISTRO | --wsl DISTRO : run in WSL (on the named DISTRO) instead of in a Docker container
+W
+W -b | --background : run as background process
-x DIR | --logindir DIR : use DIR as LOGINDIR in Medley
-x - | --logindir - : use MEDLEYDIR/logindir as LOGINDIR in Medley
sysout:
The pathname of the file to use as a sysout for Medley to start from.
+d The pathname must be in the Medley file system under LOGINDIR (/home/medley/il).
If sysout is not provided and none of the flags [-a, -f & -l] is used, then Medley will start from
the saved virtual memory file for the previous run with the sane id as this run.
pass_args:
All arguments after the "--" flag, are passed unaltered to lde via run-medley.
All arguments after the "--" flag, are passed unaltered to the Maiko emulator.
EOF

185
scripts/medley/medley_utils.sh
View File

@@ -1,3 +1,5 @@
#!only-to-be-sourced
# shellcheck shell=sh
###############################################################################
#
# medley_utils.sh - script containing various useful functions for medley.sh script.
@@ -11,123 +13,152 @@
#
###############################################################################
is_tput=$(which tput)
is_tput="$(which tput)"
output_error_msg() {
local lines=("$@")
for line in "${lines[@]}"
local_oem_file="${TMPDIR:-/tmp}"/oem_$$
echo "$1" >"${local_oem_file}"
while read -r line
do
if [ -n "${is_tput}" ];
then
echo "$(${is_tput} setab 1)$(${is_tput} setaf 7)${line}$(${is_tput} sgr0)"
else
echo "${line}"
echo "$1"
fi
done
done <"${local_oem_file}"
rm -f "${local_oem_file}"
}
check_for_dash_or_end() {
local err_msg;
if [[ -z "$2" || "$2" = "--" ]];
local_err_msg="";
if [ -z "$2" ] || [ "$2" = "--" ]
then
err_msg=(
"Error: the flag \"$1\" requires a value."
"Value is missing."
)
usage "${err_msg[@]}"
elif [ "${2:0:1}" = "-" ];
then
err_msg=(
"Error: either the value for flag \"${1}\" is missing OR"
"the value begins with a \"-\", which is not allowed."
)
usage "${err_msg[@]}"
local_err_msg="Error: the flag \"$1\" requires a value.
Value is missing."
usage "${local_err_msg}"
else
case "$2" in
-*)
local_err_msg="Error: either the value for flag \"${1}\" is missing OR
the value begins with a \"-\", which is not allowed."
usage "${local_err_msg}"
;;
esac
fi
}
check_file_writeable_or_creatable() {
local msg_core="\"$2\" given as the value of the \"$1\" flag"
local err_msg;
if [[ -e "$%2" ]];
local_msg_core="\"$2\" given as the value of the \"$1\" flag"
local_err_msg=""
if [ -e "$%2" ]
then
if [[ ! -f "$2" ]];
if [ ! -f "$2" ]
then
err_msg=(
"Error: File ${msg_core} is not a regular file."
"It is either a directory or a device file of some sort."
"Exiting"
)
output_error_msg "${err_msg[@]}"
local_err_msg="Error: File ${local_msg_core} is not a regular file.
It is either a directory or a device file of some sort.
Exiting"
output_error_msg "${local_err_msg}"
exit 1
elif [[ ! -w "$2" ]];
elif [ ! -w "$2" ]
then
err_msg=(
"Error: File ${msg_core} exists but is not writeable"
"Exiting"
)
output_error_msg "${err_msg[@]}"
local_err_msg="Error: File ${local_msg_core} exists but is not writeable
Exiting"
output_error_msg "${local_err_msg}"
exit 1
fi
else
if [[ ! -w "$(dirname -- $2)" ]];
if [ ! -w "$(dirname -- "$2")" ]
then
err_msg=(
"Error: File ${msg_core} cannot be created because"
"its directory either doen't exist or is not writeable."
"Exiting"
)
output_error_msg "${err_msg[@]}"
local_err_msg="Error: File ${local_msg_core} cannot be created because
its directory either doen't exist or is not writeable.
Exiting"
output_error_msg "${local_err_msg}"
exit 1
fi
fi
}
check_file_readable() {
local msg_core="\"$2\" given as the value of the \"$1\" flag"
if [[ ! -r "$2" ]];
then
err_msg=(
"Error: File ${msg_core}"
"either doesn't exist or is not readable."
"Exiting"
)
output_error_msg "${err_msg[@]}"
exit 1
fi
}
check_dir_writeable_or_creatable() {
local msg_core="\"$2\" given as the value of the \"$1\" flag"
if [[ -e "$2" ]];
local_msg_core="\"$2\" given as the value of the \"$1\" flag"
local_err_msg=""
if [ -e "$%2" ]
then
if [[ ! -d "$2" ]];
if [ ! -d "$2" ]
then
err_msg=(
"Error: Pathname ${msg_core} exists but is not a directory."
"Exiting"
)
output_error_msg "${err_msg[@]}"
local_err_msg="Error: ${local_msg_core} exists but is not a directory.
Exiting"
output_error_msg "${local_err_msg}"
exit 1
elif [[ ! -w "$2" ]];
elif [ ! -w "$2" ]
then
err_msg=(
"Error: Directory ${msg_core} exists but is not writeable."
"Exiting"
)
output_error_msg "${err_msg[@]}"
local_err_msg="Error: Directory ${local_msg_core} exists but is not writeable
Exiting"
output_error_msg "${local_err_msg}"
exit 1
fi
else
if [[ ! -w "$(dirname -- $2)" ]];
if [ ! -w "$(dirname -- "$2")" ]
then
err_msg=(
"Error: Directory ${msg_core} cannot be created because"
"its parent directory either doesn't exist or is not writeable."
"Exiting"
)
output_error_msg "${err_msg[@]}"
local_err_msg="Error: Directory ${local_msg_core} cannot be created because
its directory either doesn't exist or is not writeable.
Exiting"
output_error_msg "${local_err_msg}"
exit 1
fi
fi
}
check_file_readable() {
local_msg_core="\"$2\" given as the value of the \"$1\" flag"
if [ ! -r "$2" ]
then
local_err_msg="Error: File ${local_msg_core}
either doesn't exist or is not readable.
Exiting"
output_error_msg "${local_err_msg}"
exit 1
fi
}
check_dir_exists() {
local_msg_core="\"$2\" given as the value of the \"$1\" flag"
if [ -e "$2" ]
then
if [ ! -d "$2" ]
then
local_err_msg="Error: Pathname ${local_msg_core} exists but is not a directory.
Exiting"
output_error_msg "${local_err_msg}"
exit 1
elif [ ! -r "$2" ]
then
local_err_msg="Error: Directory ${local_msg_core} exists but is not readable.
Exiting"
output_error_msg "${local_err_msg}"
exit 1
fi
fi
}
parse_nethub_data() {
nh_host=""
nh_port=""
nh_mac=""
nh_debug=""
#
x="${1%:}:"
nh_host="${x%%:*}"
x="${x#"${nh_host}":*}"
nh_port="${x%%:*}"
if [ "${nh_port}" = "${x}" ]; then nh_port=""; return 0; fi
x="${x#"${nh_port}":*}"
nh_mac="${x%%:*}"
if [ "${nh_mac}" = "${x}" ]; then nh_mac=""; return 0; fi
nh_debug="${x#"${nh_mac}":*}"
if [ "${nh_debug}" = "${x}" ]; then nh_debug=""; return 0; fi
nh_debug="${nh_debug%:}"
return 0
}

273
scripts/medley/medley_vnc.sh
View File

@@ -1,3 +1,6 @@
#!only-to-be-sourced
# shellcheck shell=sh
# shellcheck disable=SC2154,SC2162
###############################################################################
#
# medley_vnc.sh - script for running Medley Interlisp on WSL using Xvnc
@@ -19,50 +22,41 @@
}
find_open_display() {
local ctr=1
local result=-1
local locked_pid=0
while [ ${ctr} -lt 64 ];
local_ctr=1
local_result=-1
while [ ${local_ctr} -lt 64 ];
do
if [ ! -e /tmp/.X${ctr}-lock ];
if [ ! -e /tmp/.X${local_ctr}-lock ];
then
result=${ctr}
local_result=${local_ctr}
break
else
locked_pid=$(cat /tmp/.X${ctr}-lock)
ps lax | awk '{print $3}' | grep --quiet ${locked_pid} >/dev/null
if [ $? -eq 1 ];
then
result=${ctr}
break
else
(( ctr++ ))
fi
local_ctr=$(( local_ctr+1 ))
fi
done
echo ${result}
echo ${local_result}
}
find_open_port() {
local ctr=5900
local result=-1
while [ ${ctr} -lt 6000 ];
local_ctr=5900
local_result=-1
while [ ${local_ctr} -lt 6000 ];
do
if [[ ${wsl} = true && ${wsl_ver} -eq 1 ]];
if [ "${wsl}" = true ] && [ "${wsl_ver}" -eq 1 ]
then
netstat.exe -a -n | awk '{ print $2 }' | grep -q ":${ctr}\$"
netstat.exe -a -n | awk '{ print $2 }' | grep -q ":${local_ctr}\$"
else
ss -a | grep -q "LISTEN.*:${ctr}[^0-9]"
ss -a | grep -q "LISTEN.*:${local_ctr}[^0-9]"
fi
if [ $? -eq 1 ];
then
result=${ctr}
local_result=${local_ctr}
break
else
(( ctr++ ))
local_ctr=$(( local_ctr+1 ))
fi
done
echo ${result}
echo ${local_result}
}
#
@@ -71,9 +65,9 @@
if [ "${use_vnc}" = "true" ];
then
win_userprofile="$(cmd.exe /c "<nul set /p=%UserProfile%" 2>/dev/null)"
vnc_dir="$(wslpath ${win_userprofile})/AppData/Local/Interlisp"
vnc_dir="$(wslpath "${win_userprofile}")/AppData/Local/Interlisp"
vnc_exe="vncviewer64-1.12.0.exe"
if [[ $(which Xvnc) = "" || $(Xvnc -version |& grep -iq tigervnc; echo $?) -eq 1 ]];
if [ "$(which Xvnc)" = "" ] || [ "$(Xvnc -version 2>&1 | grep -iq tigervnc; echo $?)" -eq 1 ]
then
echo "Error: The -v or --vnc flag was set."
echo "But it appears that that TigerVNC \(Xvnc\) has not been installed."
@@ -86,165 +80,134 @@
then
# make sure TigerVNC viewer is in a Windows (not Linux) directory. If its in a Linux directory
# there will be a long delay when it starts up
mkdir -p ${vnc_dir}
mkdir -p "${vnc_dir}"
cp -p "${IL_DIR}/wsl/${vnc_exe}" "${vnc_dir}/${vnc_exe}"
else
echo "TigerVnc viewer is required by the -vnc option but is not installed."
echo -n "Ok to download from SourceForge? [y, Y, n or N, default n] "
read resp
if [ -z ${resp} ]; then resp=n; else resp=${resp:0:1}; fi
if [[ ${resp} = 'n' || ${resp} = 'N' ]];
then
echo "Ok. You can download the Tiger VNC viewer \(v1.12.0\) .exe yourself and "
echo "place it in ${vnc_dir}/${vnc_exe}. Then retry."
echo "Exiting."
exit 5
else
pushd "${vnc_dir}" >/dev/null
wget https://sourceforge.net/projects/tigervnc/files/stable/1.12.0/vncviewer64-1.12.0.exe
popd >/dev/null
fi
loop_done=false
while [ "${loop_done}" = "false" ]
do
echo "TigerVnc viewer is required by the -vnc option but is not installed."
echo "Ok to download from SourceForge? [y, Y, n or N, default n] "
read resp
if [ -z "${resp}" ]; then resp=n; fi
case "${resp}" in
n* | N* )
echo "Ok. You can download the Tiger VNC viewer \(v1.12.0\) .exe yourself and "
echo "place it in ${vnc_dir}/${vnc_exe}. Then retry."
echo "Exiting."
exit 5
;;
y* | Y* )
wget -P "${vnc_dir}" https://sourceforge.net/projects/tigervnc/files/stable/1.12.0/vncviewer64-1.12.0.exe
loop_done=true
;;
* )
echo "Answer not one of Y, y, N, or n. Retry."
;;
esac
done
fi
fi
fi
#
# Start the log file so we can trace any issues with vnc, etc
#
LOG=${LOGINDIR}/logs/medley_${run_id}.log
mkdir -p $(dirname -- ${LOG})
echo "START" >${LOG}
LOG="${LOGINDIR}/logs/medley_${run_id}.log"
mkdir -p "$(dirname -- "${LOG}")"
echo "START" >"${LOG}"
#
# If we're running under docker:
# set the VNC_PORT to the value of the --port flag (or its default value)
# set DISPLAY to :0
#
#set -x
if [ "${docker}" = "true" ];
# are we running in background - used for pretty-fying the echos
case $(ps -o stat= -p $$) in
*+*) bg=false ;;
*) bg=true ;;
esac
#
# find an unused display and an available port
#
#set -x
OPEN_DISPLAY="$(find_open_display)"
if [ "${OPEN_DISPLAY}" -eq -1 ];
then
export VNC_PORT=5900
export DISPLAY=:0
echo "Error: cannot find an unused DISPLAY between 1 and 63"
echo "Exiting"
exit 33
else
# are we running in background - used for pretty-fying the echos
case $(ps -o stat= -p $$) in
*+*) bg=false ;;
*) bg=true ;;
esac
# For not docker (i.e., for wsl/vnc)
# find an unused display and an available port
#
#set -x
OPEN_DISPLAY=`find_open_display`
if [ ${OPEN_DISPLAY} -eq -1 ];
then
echo "Error: cannot find an unused DISPLAY between 1 and 63"
echo "Exiting"
exit 33
else
if [ ${bg} = true ]; then echo; fi
echo "Using DISPLAY=:${OPEN_DISPLAY}"
fi
export DISPLAY=":${OPEN_DISPLAY}"
export VNC_PORT=`find_open_port`
if [ ${VNC_PORT} -eq -1 ];
then
echo "Error: cannot find an unused port between 5900 and 5999"
echo "Exiting"
exit 33
else
echo "Using VNC_PORT=${VNC_PORT}"
fi
if [ "${bg}" = true ]; then echo; fi
echo "Using DISPLAY=:${OPEN_DISPLAY}"
fi
DISPLAY=":${OPEN_DISPLAY}"
export DISPLAY
VNC_PORT="$(find_open_port)"
export VNC_PORT
if [ "${VNC_PORT}" -eq -1 ];
then
echo "Error: cannot find an unused port between 5900 and 5999"
echo "Exiting"
exit 33
else
echo "Using VNC_PORT=${VNC_PORT}"
fi
#
# Start the Xvnc server
#
mkdir -p ${LOGINDIR}/logs
mkdir -p "${LOGINDIR}"/logs
/usr/bin/Xvnc "${DISPLAY}" \
-rfbport ${VNC_PORT} \
-geometry "${geometry#-g }" \
-rfbport "${VNC_PORT}" \
-geometry "${geometry}" \
-SecurityTypes None \
-NeverShared \
-DisconnectClients=0 \
-desktop "${title}" \
--MaxDisconnectionTime=10 \
>> ${LOG} 2>&1 &
>> "${LOG}" 2>&1 &
# Leaving pid wait for all but docker,
# which seems to need it. For all others
# it seems like its not needed but we'll have
# to see how it runs on slower/faster machines
# FGH 2023-02-16
if [ ${docker} = true ];
then
xvnc_pid=""
end_time=$(expr $(date +%s) + 10)
while [ -z "${xvnc_pid}" ];
do
if [ $(date +%s) -gt $end_time ];
then
echo "Xvnc server failed to start."
echo "See log file at ${LOG}"
echo "Exiting"
exit 3
fi
sleep .125
xvnc_pid=$(pgrep -f "Xvnc ${DISPLAY}")
done
# echo "XVNC_PID is ${xvnc_pid}"
fi
sleep .5
#
# Run Medley in foreground if docker, else in background
# Run Maiko in background, handing over the pass-on args which are all thats left in the main args array
#
tmp_dir=$(if [[ -d /run/shm && ! -h /run/shm ]]; then echo "/run/shm"; else echo "/tmp"; fi)
medley_run=$(mktemp --tmpdir=${tmp_dir} medley-XXXXX)
cat > ${medley_run} <<..EOF
#!/bin/bash
${MEDLEYDIR}/run-medley -id '${run_id}' ${geometry} ${screensize} ${run_args[@]} \
2>&1 | tee -a ${LOG} | grep -v "broken (explicit kill"
if [ -n "\$(pgrep -f "${vnc_exe}.*:${VNC_PORT}")" ]; then vncconfig -disconnect; fi
..EOF
#cat ${medley_run}
chmod +x ${medley_run}
if [ "${docker}" = "true" ];
{
start_maiko "$@"
if [ -n "$(pgrep -f "${vnc_exe}.*:${VNC_PORT}")" ]; then vncconfig -disconnect; fi
} &
#
# Start the vncviewer on the windows side
#
# First give medley time to startup
# sleep .25
# SLeep appears not to be needed, but faster/slower machines ????
# FGH 2023-02-08
# Then start vnc viewer on Windows side
vncv_loc=$(( OPEN_DISPLAY * 50 ))
start_time=$(date +%s)
"${vnc_dir}"/${vnc_exe} \
-geometry "+${vncv_loc}+${vncv_loc}" \
-ReconnectOnError=off \
−AlertOnFatalError=off \
"$(ip_addr)":"${VNC_PORT}" \
>>"${LOG}" 2>&1 &
wait $!
if [ $(( $(date +%s) - start_time )) -lt 5 ]
then
${medley_run}; rm ${medley_run}
else
(${medley_run}; rm ${medley_run}) &
#
# If not docker (i.e., if wsl/vnc), start the vncviewer on the windows side
#
# First give medley time to startup
# sleep .25
# SLeep appears not to be needed, but faster/slower machines ????
# FGH 2023-02-08
# Then start vnc viewer on Windows side
start_time=$(date +%s)
${vnc_dir}/${vnc_exe} \
-geometry "+50+50" \
-ReconnectOnError=off \
−AlertOnFatalError=off \
$(ip_addr):${VNC_PORT} \
>>${LOG} 2>&1 &
wait $!
if [ $( expr $(date +%s) - ${start_time} ) -lt 5 ];
if [ -z "$(pgrep -f "Xvnc ${DISPLAY}")" ]
then
if [ -z "$(pgrep -f "Xvnc ${DISPLAY}")" ];
then
echo "Xvnc server failed to start."
echo "See log file at ${LOG}"
echo "Exiting"
exit 3
else
echo "VNC viewer failed to start.";
echo "See log file at ${LOG}";
echo "Exiting" ;
exit 4;
fi
echo "Xvnc server failed to start."
echo "See log file at ${LOG}"
echo "Exiting"
exit 3
else
echo "VNC viewer failed to start.";
echo "See log file at ${LOG}";
echo "Exiting" ;
exit 4;
fi
fi
#
# Done, "Go back" to medley.sh
# Done, "Go back" to medley_run.sh
#
true