PiDP-8/I Software

# 
# The rest have no special treatment.
OS8RUN_INFILES = \
	@srcdir@/lib/pidp8i/__init__.py.in \
	@srcdir@/lib/pidp8i/ips.py.in \
	@srcdir@/media/os8/init.tx.in \
	@srcdir@/media/os8/3finit.tx.in \
	@srcdir@/media/os8/uni-init.tx.in \
	@srcdir@/src/pidp8i/main.c.in \
	$(PIDP8I_DIN)
PRECIOUS_INFILES = \
	@srcdir@/Makefile.in \
    @srcdir@/examples/Makefile.in \
    @srcdir@/src/Makefile.in \
    @srcdir@/src/cc8/Makefile.in \
    @srcdir@/src/SIMH/Makefile.in \
    @srcdir@/src/SIMH/PDP8/Makefile.in
INFILES = \
	@srcdir@/bin/os8-cp.in \
	@srcdir@/tools/os8-cmp.in \
	@srcdir@/bin/os8-run.in \
	@srcdir@/bin/teco-pi-demo.in \

	@srcdir@/bin/pidp8i.in \
	@srcdir@/boot/0.script.in \
	@srcdir@/boot/2.script.in \
	@srcdir@/boot/3.script.in \
	@srcdir@/boot/4.script.in \
	@srcdir@/boot/6.script.in \
	@srcdir@/boot/7.script.in \
	@srcdir@/boot/run.script.in \
	@srcdir@/boot/run-v3f.script.in \
	@srcdir@/boot/tss8.script.in \
	@srcdir@/etc/pidp8i.service.in \
	@srcdir@/etc/sudoers.in \
	@srcdir@/etc/usb-mount@.service.in \
	@srcdir@/lib/os8script.py.in \
	@srcdir@/lib/simh.py.in \
	@srcdir@/src/pidp8i/gpio-common.c.in \
	@srcdir@/tools/simh-update.in \

	$(OS8RUN_INFILES)
OS8RUN_OUTFILES := $(subst @srcdir@/,,$(OS8RUN_INFILES))
OS8RUN_OUTFILES := $(subst .in,,$(OS8RUN_OUTFILES))
PRECIOUS_OUTFILES := $(subst @srcdir@/,,$(PRECIOUS_INFILES))
PRECIOUS_OUTFILES := $(subst .in,,$(PRECIOUS_OUTFILES))
OUTFILES := $(subst @srcdir@/,,$(INFILES))
OUTFILES := $(subst .in,,$(OUTFILES))

OS8_DIST_RK05 = bin/v3d-dist.rk05
OS8_SRC_RK05 = @OS8_SRC_RK05@
OS8_BOOT_DISK = bin/@OS8_BOOT_DISK@
OS8_RK05S = $(OS8_DIST_RK05) $(OS8_BOOT_DISK) $(OS8_SRC_RK05) $(OS8_UNI_DIST_RK05) $(OS8_UNI_RK05)



OS8_SCRIPTS_DIR = @srcdir@/media/os8/scripts

V3D_DIST_SCRIPT = $(OS8_SCRIPTS_DIR)/v3d-dist-rk05.os8
V3D_SRC_SCRIPT = $(OS8_SCRIPTS_DIR)/v3d-src-rk05.os8
V3D_RK05_SCRIPT = $(OS8_SCRIPTS_DIR)/v3d-rk05.os8

V3F_SRCDIR = @srcdir@/src/os8/v3f
V3F_BUILD_RK05 = obj/v3f-build.rk05
V3F_MANIFEST = actions.txt

V3F_MADE_RK05 = bin/v3f-made.rk05

V3F_MAKER = $(OS8_SCRIPTS_DIR)/v3f-control.os8

# OS/8 Combined Kit. Build from Source.
# We build each object rk05 image in one large script
# Because otherwise mmake would have terrible race conditions.
# We cut the tree up into chunks to fit them on rk05 images:
# SYS: The System Head and device Handlers and key system CUSPS.
# CUSPS: The remaining Commonly Used System Programs (CUSPS)
# BF2: BASIC and FORTRAN II
# FIV: FORTRAN IV

OS8_UNI_SRCDIR = @srcdir@/src/os8/uni

OS8_UNI_SYS_SRC_RK05 = obj/uni-sys-src.rk05
OS8_UNI_SYS_OBJ_RK05 = bin/uni-sys-obj.rk05
OS8_UNI_SYS_MAKER = $(OS8_SCRIPTS_DIR)/uni-sys-build.os8

OS8_UNI_CUSPS_SRC_RK05 = obj/uni-cusps-src.rk05
OS8_UNI_CUSPS_OBJ_RK05 = bin/uni-cusps-obj.rk05
OS8_UNI_CUSPS_MAKER = $(OS8_SCRIPTS_DIR)/uni-cusps-build.os8

OS8_UNI_BF2_SRC_RK05 = obj/uni-bf2-src.rk05
OS8_UNI_BF2_OBJ_RK05 = bin/uni-bf2-obj.rk05
OS8_UNI_BF2_MAKER = $(OS8_SCRIPTS_DIR)/uni-bf2-build.os8

OS8_UNI_FIV_SRC_RK05 = obj/uni-fiv-src.rk05
OS8_UNI_FIV_OBJ_RK05 = bin/uni-fiv-obj.rk05
OS8_UNI_FIV_MAKER = $(OS8_SCRIPTS_DIR)/uni-fiv-build.os8

OS8_UNI_DIST_RK05 = bin/uni-dist.rk05
OS8_UNI_DIST_MAKER = $(OS8_SCRIPTS_DIR)/uni-dist-rk05.os8
OS8_UNI_RK05_MAKER = $(OS8_SCRIPTS_DIR)/uni-rk05.os8
OS8_UNI_RK05 = bin/uni.rk05

ALL_TU56_SCRIPT = $(OS8_SCRIPTS_DIR)/all-tu56.os8

CUSP_COPYIN_SCRIPT = $(OS8_SCRIPTS_DIR)/cusp-copyin.os8

OS8_BOOT_TAPE = bin/@OS8_BOOT_TAPE@
V3D_TC08_TU56 = bin/v3d-tc08.tu56

	$(V3D_TD12K_TU56) $(V3F_TC08_TU56) $(V3F_TD12K_TU56)

clean:
	@rm -f $(BINS) $(BOOTSCRIPTS) $(ASM_PTS) $(PAL_EX_PTS) $(LISTINGS) \
		$(OUTFILES) $(ADF) \
		$(OS8_RK05S) $(V3F_MADE_RK05) $(V3F_BUILD_RK05) $(V3D_TC08_TU56) \
		$(V3D_TD12K_TU56) $(V3F_TC08_TU56) $(V3F_TD12K_TU56) \
		$(OS8_UNI_SYS_SRC_RK05) $(OS8_UNI_SYS_OBJ_RK05) \
		$(OS8_UNI_CUSPS_SRC_RK05) $(OS8_UNI_CUSPS_OBJ_RK05) \
		$(OS8_UNI_BF2_SRC_RK05) $(OS8_UNI_BF2_OBJ_RK05) \
		$(OS8_UNI_FIV_SRC_RK05) $(OS8_UNI_FIV_OBJ_RK05) \
		$(OS8_UNI_DIST_RK05) \
		config.log cscope.out tags \
		bin/*.pt bin/*.save bin/*.tu56 bin/txt2ptp \
		lib/*.pyc lib/*/*.pyc lib/pidp8i/dirs.py lib/pidp8i/ips.py \
		obj/*.log obj/*.pt obj/os8.opts \
		src/config.h \
		@srcdir@/examples/*.err
	@find obj \( -name \*.o -o -name \*.d \) -delete

	@echo "Installing os8-run..."
	@@INSTALL@ -m 775 -g @INSTGRP@ $(OS8RUN) @prefix@/bin
	@( for src in $(OS8RUN_PY_ALL) ; do \
		test -e $$src || src=@srcdir@/$$src ; \
		dest=@prefix@/$$(echo $$src | sed -e 's_^@srcdir@/__') ; \
		echo "Installing $$src to $$dest..." ; \
	    @INSTALL@ -m 644 -g @INSTGRP@ -D $${src}  $${dest}  ; \


	  done \
	)
	@sed -e 's#^build =.*#build = "@ABSPREFIX@"#' \
	     -e 's#^media =.*#media = os.path.join (build, "share/media/")#' \
	     -e 's#^os8mo =.*#os8mo = os8mi#' \
		 < $(PIDP8I_DIRS) > @prefix@/$(PIDP8I_DIRS)
	@chgrp @INSTGRP@ @prefix@/$(PIDP8I_DIRS)

# Dependency on the contents of the v3f source directory.
V3F_SOURCES := \
	@srcdir@/src/os8/v3f/*.PA \
	@srcdir@/src/os8/v3f/*.MA \
	@srcdir@/src/os8/v3f/*.BI

# Dependency on the contents of the uni source directory.
OS8_UNI_SYS_SOURCES := \
	@srcdir@/src/os8/uni/SYSTEM/*.PA \
	@srcdir@/src/os8/uni/SYSTEM/*.MA \
	@srcdir@/src/os8/uni/SYSTEM/*.BI \
	@srcdir@/src/os8/uni/HANDLERS/*.PA \
	@srcdir@/src/os8/uni/CUSPS/*.MA \
	@srcdir@/src/os8/uni/CUSPS/*.BI \
	@srcdir@/src/os8/uni/CUSPS/*.HL

OS8_UNI_CUSPS_SOURCES :=\
	@srcdir@/src/os8/uni/CUSPS/*.PA

OS8_UNI_BF2_SOURCES := \
	@srcdir@/src/os8/uni/LANGUAGE/BASIC/*.PA \
	@srcdir@/src/os8/uni/LANGUAGE/FORTRAN2/*.PA \
	@srcdir@/src/os8/uni/LANGUAGE/FORTRAN2/*.CO \
	@srcdir@/src/os8/uni/LANGUAGE/FORTRAN2/LIBRARY/*.SB

OS8_UNI_FIV_SOURCES := \
	@srcdir@/src/os8/uni/LANGUAGE/FORTRAN4/*.PA \
	@srcdir@/src/os8/uni/LANGUAGE/FORTRAN4/*.BI \
	@srcdir@/src/os8/uni/LANGUAGE/FORTRAN4/LIBRARY/*.RA

# We could make FIV conditional here.
OS8_UNI_DIST_SRCS := \
	$(OS8RUN) $(PIDP8I_DIN) \
	lib/pidp8i/dirs.py \
	$(OS8_UNI_DIST_MAKER) \
	@srcdir@/media/os8/al-*-ba-*.tu56 \
	@srcdir@/media/os8/subsys/*.tu56 \
	$(OS8_UNI_SYS_OBJ_RK05) $(OS8_UNI_CUSPS_OBJ_RK05) \
	$(OS8_UNI_BF2_OBJ_RK05) $(OS8_UNI_FIV_OBJ_RK05)

UNI_PATCHES := \
	# @srcdir@/media/os8/patches/uni/*.patch8

$(OS8_DIST_RK05): $(V3D_DIST_SRCS) | $(PIDP8I_SIM) $(OS8RUN_OUTFILES)
	$(OS8RUN)@OS8_OPTS@ $(V3D_DIST_SCRIPT)

$(OS8_BOOT_DISK): $(V3D_RK05_SCRIPT) $(OS8_DIST_RK05) $(V3D_PATCHES) @CC8_TU56@ | $(PIDP8I_SIM) $(OS8RUN_OUTFILES)
	$(OS8RUN)@OS8_OPTS@ $(V3D_RK05_SCRIPT)


$(OS8_UNI_RK05): $(OS8_UNI_RK05_MAKER) $(OS8_UNI_DIST_RK05) $(UNI_PATCHES) @CC8_TU56@ | $(PIDP8I_SIM) $(OS8RUN_OUTFILES)
	$(OS8RUN)@OS8_OPTS@ $(OS8_UNI_RK05_MAKER)


# Also build an OS/8 source disk, as a convenience to avoid the 
# need to mount up the 7 source tapes in succession.
#
# Using an order-only dependency for the simulator and the bin disk: we
# only need *a* version of each, they don't have to be recent!
OS8_SRC_SRCS = \

$(V3F_BUILD_RK05): $(V3F_SRCDIR)/$(V3F_MANIFEST) $(V3F_SOURCES) | $(OS8_BOOT_DISK)
	rm -f $(V3F_BUILD_RK05)
	cd $(V3F_SRCDIR); @builddir@/bin/os8-cp -v --action-file $(V3F_MANIFEST)

# Make a disk with binaries assembled from the V3F source disk
$(V3F_MADE_RK05): $(V3F_BUILD_RK05) $(V3F_MAKER)
	$(OS8RUN) $(V3F_MAKER)

# Build the source disk for OS/8 UNI SYS Component.
$(OS8_UNI_SYS_SRC_RK05): $(OS8_UNI_SYS_SOURCES) | $(OS8_BOOT_DISK)
	@builddir@/bin/os8-cp -v -rk1 $(OS8_UNI_SYS_SRC_RK05) -z -a $(OS8_UNI_SYS_SOURCES) RKA1:

# Make a disk with binaries assembled from the OS8_UNI SYS source disk
$(OS8_UNI_SYS_OBJ_RK05): $(OS8_UNI_SYS_SRC_RK05) $(OS8_UNI_SYS_MAKER)
	$(OS8RUN) $(OS8_UNI_SYS_MAKER)

# Build the source disk for OS/8 UNI CUSPS Component.
$(OS8_UNI_CUSPS_SRC_RK05): $(OS8_UNI_CUSPS_SOURCES) | $(OS8_BOOT_DISK)
	@builddir@/bin/os8-cp -v -rk1 $(OS8_UNI_CUSPS_SRC_RK05) -z -a $(OS8_UNI_CUSPS_SOURCES) RKA1:

# Make a disk with binaries assembled from the OS8_UNI SYS source disk
$(OS8_UNI_CUSPS_OBJ_RK05): $(OS8_UNI_CUSPS_SRC_RK05) $(OS8_UNI_CUSPS_MAKER)
	$(OS8RUN) $(OS8_UNI_CUSPS_MAKER)

# Build the source disk for OS/8 UNI BASIC and FORTRAN II Component.
$(OS8_UNI_BF2_SRC_RK05): $(OS8_UNI_BF2_SOURCES) | $(OS8_BOOT_DISK)
	@builddir@/bin/os8-cp -v -rk1 $(OS8_UNI_BF2_SRC_RK05) -z -a $(OS8_UNI_BF2_SOURCES) RKA1:

# Make a disk with binaries assembled from the OS8_UNI FIRTRAN II source disk
$(OS8_UNI_BF2_OBJ_RK05): $(OS8_UNI_BF2_SRC_RK05) $(OS8_UNI_BF2_MAKER)
	$(OS8RUN) $(OS8_UNI_BF2_MAKER)

# Build the source disk for OS/8 UNI FORTRAN IV Component.
$(OS8_UNI_FIV_SRC_RK05): $(OS8_UNI_FIV_SOURCES) | $(OS8_BOOT_DISK)
	@builddir@/bin/os8-cp -v -rk1 $(OS8_UNI_FIV_SRC_RK05) -z -a $(OS8_UNI_FIV_SOURCES) RKA1:

# Make a disk with binaries assembled from the OS8_UNI FORTRAN IV source disk
$(OS8_UNI_FIV_OBJ_RK05): $(OS8_UNI_FIV_SRC_RK05) $(OS8_UNI_FIV_MAKER)
	$(OS8RUN) $(OS8_UNI_FIV_MAKER)

$(OS8_UNI_DIST_RK05): $(OS8_UNI_DIST_SRCS) | $(PIDP8I_SIM) $(OS8RUN_OUTFILES)
	$(OS8RUN)@OS8_OPTS@ $(OS8_UNI_DIST_MAKER)

# Make a bootable OS/8 v3f TCO8 DECtape image
$(V3F_TC08_TU56): $(V3F_MADE_RK05) $(ALL_TU56_SCRIPT) $(CUSP_COPYIN_SCRIPT)
	$(OS8RUN)@OS8_OPTS@ $(ALL_TU56_SCRIPT) --enable v3f

# Make a bootable OS/8 v3f TD8E 12K DECtape image
$(V3F_TD12K_TU56): $(V3F_MADE_RK05) $(ALL_TU56_SCRIPT) $(CUSP_COPYIN_SCRIPT)

# @include the output version.
make-config-header src/config.h \
    -auto {ENABLE_* HAVE_* PACKAGE_* SIZEOF_*} \
    -bare {ILS_MODE PCB_*}
make-template bin/pidp8i.in
make-template bin/os8-cp.in
make-template bin/os8-run.in
make-template tools/os8-cmp.in
make-template bin/teco-pi-demo.in
make-template boot/common.script.in
make-template boot/0.script.in
make-template boot/2.script.in
make-template boot/3.script.in
make-template boot/4.script.in
make-template boot/6.script.in
make-template boot/7.script.in

make-template lib/os8script.py.in
make-template lib/pidp8i/__init__.py.in
make-template lib/pidp8i/dirs.py.in
make-template lib/pidp8i/ips.py.in
make-template lib/simh.py.in
make-template media/os8/init.tx.in
make-template media/os8/3finit.tx.in
make-template media/os8/uni-init.tx.in
make-template src/Makefile.in
make-template src/cc8/Makefile.in
make-template src/cc8/os8/Makefile.in
make-template src/pidp8i/gpio-common.c.in
make-template src/pidp8i/main.c.in
make-template src/SIMH/Makefile.in
make-template src/SIMH/PDP8/Makefile.in
make-template tools/simh-update.in

make-template Makefile.in
foreach f [concat [glob "$builddir/bin/*"] [glob "$builddir/tools/*"]] {
    exec chmod +x $f
}

  if att_spec == None: att_spec = _default_att_spec
  simh_boot_dev = att_spec[0] + att_spec[1]     # Compose simh dev from name and unit.
  imagename = att_spec[2]
  if not os.path.exists (imagename):
    abort_prog ("Requested boot image file: " + imagename + " not found.")
  if VERBOSE or DEBUG:
    print("Attaching " + simh_boot_dev + " to " + imagename)
  s.simh_cmd ("att " + simh_boot_dev + " " + imagename, debug=DEBUG)

  images_to_zero = []
  
  # Attach other mounts
  for att_spec in action_plan["mount"]:
    simh_dev = att_spec[0] + att_spec[1]     # Compose simh dev from name and unit.
    imagename = att_spec[2]
    if os.path.exists (imagename):
      if VERBOSE or DEBUG:
        print("Modifying existing " + simh_dev + " image " + imagename)
    else:
      if VERBOSE or DEBUG:
        print("Will create a new image file named: " + imagename)
      # Save this att_spec so we can zero it later.
      images_to_zero.append (att_spec)
    if VERBOSE or DEBUG:
      print("Attaching " + simh_dev + " to " + imagename)
    s.simh_cmd ("att " + simh_dev + " " + imagename, debug=DEBUG)

  if VERBOSE or DEBUG: print("Booting " + simh_boot_dev + "...")
  # Confirm successful boot into OS/8. Note we call simh_cmd with _os8_replies!
  reply = s.simh_cmd ("boot " + simh_boot_dev, s._os8_replies_rex, debug=DEBUG)
  s.os8_test_result (reply, "Monitor Prompt", "os8-cp")

  for att_spec in images_to_zero:
    os8dev = _os8_from_simh_dev[att_spec[0]]
    if os8dev in _os8_partitions:
      for partition in _os8_partitions[os8dev]:
        os8name = os8dev + partition + att_spec[1] + ":"
        if VERBOSE or DEBUG:
          print("Initializing directory of " + os8name + " in " + \
              imagename)
        s.os8_cmd ("ZERO " + os8name, debug=DEBUG)
    else:
      os8name = os8dev + att_spec[1] + ":"
      if VERBOSE or DEBUG:
        print("Initializing directory of " + os8name + " in " + \
            imagename)
      s.os8_cmd ("ZERO " + os8name, debug=DEBUG)

  # Perform copy operations
  for do_copy in action_plan["copy"]:
    mode_opt = do_copy[0]
    source = do_copy[1]
    destination = do_copy[2]
    copy_type = do_copy[3]

    # "into" -- Attach source to simh ptr
    # If we are operating "from" and source has wild cards,
    # Use DIRECT to create list of files.
    # "from" -- Attach destination to ptp. We've already done POSIX globing.
    # "within" -- Use COPY.
    
    if copy_type == "into":
      s.os8_pip_to(source, destination, pip_option, debug=DEBUG)
    elif copy_type == "from":
      if has_os8_wildcards(source):
        # Split off device from source:
        os8dev = source[0:source.index(":")+1]
        if DEBUG: print("Wild card dev: " + os8dev)
        # Use OS/8 Direct to enumerate our input files.
        if DEBUG:
          print("Calling OS/8 DIRECT on wild card filespec: " + source)
        s.os8_cmd ("DIR " + source + "/F=1", "\d+\s+FREE BLOCKS", debug=DEBUG)
        # Now harvest direct output.  One file per line.  Ignore blank lines.
        # Maybe parse the FREE BLOCKS Output.
        # Done when we see a dot.
        # s._child.expect("\d+\s+FREE BLOCKS")
        files = file_list_from_expect(s._child.before.decode())
	# Confirm return to monitor after call to DIR command.
        s.os8_cfm_monitor ("os8_cp")  
        for filename in files:
          if VERBOSE or DEBUG:
            print("Wildcard call os8_pip_from: copy from: " + \
                "{" + os8dev + "}{" + filename + "}" + \
                " to: " + destination + ", mode: " + pip_option)
          s.os8_pip_from(os8dev + filename, destination, pip_option, debug=DEBUG)
      else:
        if VERBOSE or DEBUG:
          print("Call os8_pip_from: copy from: " + source + " to " + \
              destination + ", mode: " + pip_option)
        s.os8_pip_from(source, destination, pip_option, debug=DEBUG)
    elif copy_type == "within":
      if VERBOSE or DEBUG:
        print("Call COPY of: " + source + " to " + destination)
      s.os8_cmd ("COPY " + destination + "< " + source)
    else:
      abort_prog ("Unrecognized copy type: " + copy_type)  # Should never happen.
      
  # Detach all mounts and then sys.
  s.esc_to_simh()
  for att_spec in action_plan["mount"]:
    simh_dev = att_spec[0] + att_spec[1]     # Compose simh dev from name and unit.
    if VERBOSE or DEBUG:
      print("Detaching " + simh_dev)
    s.simh_cmd ("det " + simh_dev, debug=DEBUG)
  if VERBOSE or DEBUG:
    print("Detaching " + simh_boot_dev)
  s.simh_cmd ("det " + simh_boot_dev, debug=DEBUG)

  # And shut down the simulator.
  if VERBOSE or DEBUG:
    print("Quitting simh.")
  s._child.sendline("quit")

if __name__ == "__main__": main()

  # After all scripts are done, we remove any scratch files,
  # detach any mounted devices, and shut down simh gracefully.

  for filename in os8.scratch_list:
    if os8.verbose: print("Deleting scratch_copy: " + filename)
    os.remove(filename)
    
  s.simh_cmd ("detach all")

  s._child.sendline("quit")
  if VERBOSE: print("Done!")

  
if __name__ == "__main__":
    main()

from simh   import *


#### main ##############################################################

def main ():
  # Check for command line flags
  benchmark = False
  throttle = True
  if len (sys.argv) > 1:
    if sys.argv[1] == '-b': benchmark = True
    elif sys.argv[1] == '-f': throttle = False


  # Create the SIMH child instance and tell it where to send log output
  try:
    s = simh (dirs.build)
  except (RuntimeError) as e:
    print("Could not start simulator: " + e.message + '!')
    exit (1)
  s.set_logfile (os.fdopen (sys.stdout.fileno (), 'wb', 0))

  # Find and boot the built OS/8 bin disk
  rk = os.path.join (dirs.os8mo, 'v3d.rk05')
  if not os.path.isfile (rk):
    print("Could not find " + rk + "; OS/8 media not yet built?")
    exit (1)
  print("Booting " + rk + "...")
  reply = s.simh_cmd ("att rk0 " + rk)
  s.simh_test_result (reply, "Prompt", "main 1")
  reply = s.simh_cmd ("boot rk0", s._os8_replies_rex)
  s.os8_test_result (reply, "Monitor Prompt", "main 2")

  # Start TECO8 in the simulator under OS/8
  # Confirm it is running when you receive the Command Decoder Prompt.
  reply = s.os8_cmd ("R TECO")
  s.os8_test_result (reply, "Command Decoder Prompt", "main 2")

  # The macro comes from http://www.iwriteiam.nl/HaPi_TECO_macro.html
  # and it was created by Stanley Rabinowitz.
  #
  # The 248 preceding "UN" in the first line of the macro is the number
  # of digits of pi to calculate.  That value was reached by experiment
  # as the largest value that runs without crashing TECO with a

  ]

  # First and last lines are handled specially, so slice them off.
  first = macro.pop (0)
  last  = macro.pop ()

  # Send the first line of the macro; implicitly awaits 1st TECO prompt
  s.os8_send_line (first)

  # Blindly send core lines of the macro; TECO gives no prompts for 'em.
  for line in macro: 
    s.os8_send_line (line)

  # Send last line of macro sans CR, followed by two Esc characters to
  # start it running.
  s.os8_send_str (last)     # not os8_send_line!
  s.os8_send_ctrl ('[')
  s.os8_send_ctrl ('[')

  if benchmark:
    # Run demo long enough to get a good sense of the simulator's
    # execution rate while unthrottled on this host hardware.  If
    # you don't run it long enough, the IPS value is untrustworthy.
    try:
      s.spin (10)
    except pexpect.TIMEOUT:






      # Ask the simulator what IPS rate we ran that benchmark at.
      # It knows how to shift context appropriately.
      s.simh_send_line ('show clocks')
      line = s.read_tail ('Execution Rate:').decode()
      curr_ips = int (line.strip().replace(',', '').split(' ')[0])
      pf = open ('lib/pidp8i/ips.py', 'a')
      pf.write ('current = ' + str (curr_ips) + '    # ' + \
            str (datetime.today ()) + '\n')
      pf.close ()
      s.quit()
      pdp_ratio = float (curr_ips) / ips.pdp8i
      rpi_ratio = float (curr_ips) / ips.raspberry_pi_b_plus
      print("\nYour system is " + format (rpi_ratio, '.1f') + \
          " times faster than a Raspberry Pi Model B+")
      print("or " + format (pdp_ratio, '.1f') + \
          " times faster than a PDP-8/I.\n")
  elif throttle:
    # Normal mode.  Tell SIMH and throttle down to a rate suitable for a
    # blinkenlights demo.  1/17 means SIMH runs one instruction then
    # waits for 17ms, yielding ~59 IPS.


    s.simh_cmd ('set throttle 1/17')

    # You can't hit Ctrl-E while running this script in the foreground
    # since pexpect takes over stdio.  Therefore, if you want to be able
    # to send commands to the simulator while the demo is running,
    # uncomment the line below, which will let you send commands to the
    # simulator via telnet.  From another terminal or SSH session:
    #

    # obviously-unsafe commands like ! on the remote console, but it is
    # possible some mischief may be possible via this path anyway.  It
    # could be used to exfiltrate a sensitive file via ATTACH, for one
    # thing.  For another, it's a potential DoS vector.
    #s.send_cmd ('set remote telnet=3141')

    # Let it run.  Never exits.
    s.send_line ('cont')
    s.spin ()
  else:
    s.spin ()


if __name__ == "__main__":
    main()

When someone on the mailing list asked for a way to automatically
drive a demo script he'd found online, it was natural to generalize
the core functionality of `mkos8` as a reusable Python class, then
write a script to make use of it. The result is `class simh`, currently
used by six different scripts in the PiDP-8/I software distribution
including `os8-run` and the `teco-pi-demo` demo script.

The basis for this work is `pexpect` the Python Expect library.

This document describes how `teco-pi-demo` works, and through it, how
`class simh` works, with an eye toward teaching you how to reuse this
functionality for your own ends.

[ori]: https://tangentsoft.com/pidp8i/doc/trunk/doc/os8-run.md
[py]:  https://www.python.org/

Note that this more complicated scheme appends to the log file instead
of overwriting it because there are cases where `os8-run` gets run
more than once with different script inputs, so we want to preserve
the prior script outputs, not keep only the latest.


## Driving SIMH and OS/8

The basic control flow is:

1. Send to SIMH text to act upon.
2. Harvest results.
3. Check results.
4. Goto 1 or quit.

## Checking results

There are a number of helper methods and data structures to help
in checking results.

Although `pexpect` can search replies for a regular expression string,
or a list of such strings, the helper methods use an array of compiled
regular expressions.

The simh class contains two arrays, `_simh_replies` and `_os8_replies`
with corresponding arrays of compiled regular expressions, `_simh_replies_rex`,
and `_os8_replies_rex`.

You can use the simh Class replies or define some for yourself. Example:

```
my_replies = [
  ["Sample Reply", "Sample Reply\s+.*\n$", "False"],
  ["Fatal Error", "Fatal error was\s+.*\n$", "True"]
]

my_replies_rex = []
for item in my_replies:
   my_replies_rex.append(re.compile(item[1].encode()))

```

Often you want your replies in addition to the errors you might
want from OS/8.  In that case you'd do something like:

```
my_replies.extend(s._os8_replies)
```
Of course the extend would appear before the computation of
`my_replies_rex`.

## Running SIMH or OS/8 commands

High level calls to run commands in SIMH can be made from

`simh_cmd` for SIMH commands and
`os8_cmd` for OS/8 commands.

These two methods default to searching results for replies in the relevant arrays.
They return an index into the array that says which reply was received.

The `test_result` method takes a reply number, an expected reply name, an array
replies and a string for helping identify the caller of the test.  (There's also an
optional debug flag. These scripts can be difficult to debug.)

To see if the reply from running a command that would reply with
`my_replies` the code would be:

```
s.test_result(reply, "Fatal Error", my_replies, "myfunc")
```

The reply item at the index given by `reply` is examined. And the desired reply
is matched against the first element of that item.  If it matches, `True` is returned,
otherwise `False` is returned.  If the caller string is present, (in this case,
`"myfunc"`, a message is printed if the reply doesn't match the expected reply.
If the caller string is the empty string, no message is printed.  This makes it
easy to add error diagnostics without a lot of extra work.

Sometimes you want to try a couple different expected values, and don't want
to print anything if there isn't a match.  That's why we special case an empty
caller string.

For SIMH and OS/8 command testing, there are convenience wrappers, `simh_test_result`
and `os8_test_result` that use the relevant array so you don't have to keep typing it.
So the following two are equivalent:

```
s.test_result(reply, "Prompt", s._simh_replies, "myfunc", debug=True)

s.simh_test_result(reply, "Prompt", "myfunc", debug=True)
```

Armed with an understanding of how we make calls into SIMH and OS/8, and
how we test results, we're ready to continue our exploration.

## Finding and Booting the OS/8 Media

If your program will use our OS/8 boot disk, you can find it
programmatically by using the `dirs.os8mo` constant, which means "OS/8
media output directory", where "output" refers to the worldview of
`os8-run`.  Contrast `dirs.os8mi`, which points to the directory holding
the input media for `os8-run`.

This snippet shows how to use it:

    rk = os.path.join (dirs.os8mo, 'v3d.rk05')
    if not os.path.isfile (rk):
        print "Could not find " + rk + "; OS/8 media not yet built?"
        exit (1)

Now we attach the RK05 disk image to the PiDP-8/I simulator found by the
`simh` object and boot from it:

    print "Booting " + rk + "..."
    s.simh_cmd ("att rk0 " + rk)
    s.simh_test_result (reply, "Prompt", "main 1")
    reply = s.simh_cmd ("boot rk0", s._os8_replies_rex)
    s.os8_test_result (reply, "Monitor Prompt", "main 2")




A couple subtle points:  We issued a command to SIMH to attach the rk0
device. If we didn't get the SIMH prompt back, `simh_test_result` would
have said,





    main 1: Expecting Prompt. Instead got: Fatal Error






Then we issued the SIMH command to boot that device. We used the `os8_test_result`
method instead of the `simh_test_result` method because we expected

the panoply of replies would more likely be from the OS/8 list.

After the simulator starts up, and we've confirmed we've got our
OS/8 monitor prompt as a result, we send the first OS/8 command to start our demo.

    s.os8_cmd ("R TECO")
    s.os8_test_result (reply, "Command Decoder Prompt", "main 2")



The bulk of `teco-pi-demo` consists of more calls to `simh.os8_cmd`
and `simh.cmd`. Read the script if you want more examples.



**IMPORTANT:** When you specify the [regular expression][re] strings

for result matching, and want literal matches for characters that
are special to regular expressions such as dot `.`, asterisk `*`,






etc., you need to be preface the characterpair of backslashes.


Example:  To match a literal dollar sign you would say `\\$`.


[re]: https://en.wikipedia.org/wiki/Regular_expression


## Contexts

The operation of OS/8 under SIMH requires awareness of who
is getting the commands: SIMH, the OS/8 Keyboard Monitor,
the OS/8 Command Decoder, or some read/eval/print loop in
a program being run.

Your use of the simh class needs to be mindful of this.
Throughout this document every attempt has been made to be clear
on which methods keep track of context switches for you and
which do not.


### Context Within a program under OS/8

If you've forgotten to exit a sub-program, that program
will still be getting your subsequent commands instead of
OS/8.

You may have a program that keeps running and asking for more input,
for example OS/8 `PIP` returns to the command decoder after each
action.

There is a subtle issue with program interrupts:  You **need**
to check for the string that gets echoed when you do an interrupt.
Otherwise pexpect can get confused.

Two methods that abstract this for you are provided: `os8_ctrl_c`
and `os8_escape` which send those interrupt characters, ask
pexpect to listen for their echo back (`$` comes back from
escape), and confirms a return to the OS/8 monitor.

Here is the implementation of `os8_ctrl_c` as an example if you
need to run a sub-program with a different interrupt character:


```
  #### os8_ctrl_c ##################################################
  # Return to OS/8 monitor using the ^C given escape character.
  # We need to listen for the ^C echo or else cfm_monitor gets confused.
  # Confirm we got our monitor prompt.
  # Optional caller argument enables a message if escape failed.
  # Note: OS/8 will respond to this escape IMMEDIATELY,
  # even if it has pending output.
  # You will need to make sure all pending output is in
  # a known state and the running program is quiescent
  # before calling this method. Otherwise pexpect may get lost.

  def os8_ctrl_c (self, caller = "", debug=False):
    self.os8_send_ctrl ("c")
    self._child.expect("\\^C")
    return self.os8_cfm_monitor (caller)

```

### Sending Control Characters

Several OS/8 programs expect an <kbd>Escape</kbd> (a.k.a. `ALTMODE`)
keystroke to do things. Examples are `TECO` and `FRTS`. 

(Yes, <kbd>Escape</kbd> is <kbd>Ctrl-\[</kbd>. Now you can be the life of
the party with that bit of trivia up your sleeve. Or maybe you go to
better parties than I do.)

The `os8_send_ctrl` method enables you to send arbitrary control
characters but it does not keep track of whether you're in the OS/8 or
SIMH context.  Note also that the `e` control character escapes to SIMH.
So avoid writing programs that need that control character as input.


### Context Between SIMH and OS/8

It is important to make sure that commands intended for SIMH
go there, and not to OS/8 or any programs running under SIMH.  The
`os8_cmd` amd `simh_cmd` methods keep track of context. If
you call the `simh_cmd` method but aren't actually escaped out to
SIMH, an escape will be made for you, and the context change will be
recorded.

If you issue `os8_cmd` when OS/8 is not running, it will complain
and refuse to send the command.

The cleanest way to explicitly escape from OS/8 to SIMH
is to call `esc_to_simh`. It manages the context switch, and tests
to see that you got the SIMH prompt.  Example:

    esc_to_simh()

Subtle points:  Calling  `simh_cmd` will leave you in SIMH. You will
need to resume OS/8 explicitly.  There are a variety of ways
to do this.


## Getting Back to OS/8 from SIMH

There are several ways to get back to the simulated OS/8 environment
from SIMH context, each with different tradeoffs.

*FIXME*  We used to have a lot of trouble with continue commands.
We think they're all fixed now, so we can fully flesh out this section.


### Rebooting

You saw the first one above: send a `boot rk0` command to SIMH. This
restarts OS/8 entirely. This is good if you need a clean environment.
If you need to save state between one run of OS/8 and the next, save it
to the RK05 disk pack or other SIMH media, then re-load it when OS/8
reboots.

It's important to check that you got your OS/8 prompt so the recommended
code looks like this:

```
    reply = s.simh_cmd ("boot rk0", my_replies_rex)
    s.os8_test_result (reply, "Monitor Prompt", "myprog")
```

### Continuing

The way `teco-pi-demo` does it is to send a `cont` command to SIMH:







```
    s.send_line ('cont')
```


A previous version of the simh class would sometime hang the
simulator unless a small delay were inserted before escaping to

the SIMH context.  We believe this is no longer necessary.


However the problems with `cont` made implementors gun shy

using it.  Most code you will see does a restart with an explicit
confirmation we are at the OS/8 command level.


### Re-starting OS/8

If your use of OS/8 is such that all required state is saved to disk
before re-entering OS/8, you can call the `simh_restart_os8` method to
avoid the need for a delay *or* a reboot.

It sends the simh command `go 7600` which is the traditional "restart
at the OS/8 entrypoint" commonly used from the PDP-8 front panel.
It then uses `os8_test_result` to confirm that it got a monitor prompt.
`simh_restart_os8` has an optional `caller` argument to make it
quick and easy to print an error if returning to the monitor failed.

    s.simh_restart_os8 (caller = "myprog")

`os8-run` uses this option extensively.


## Sending without testing results.

At some point you always need to test your results and make sure
you are where you think you are.  Otherwise some corner case will
trip up your use of the simh class, and the error message you will
get is a 60 second pause, and a big backtrace.

But often you need to send and receive data in a much less structured
way than that used by `os8_cmd` and `simh_cmd`.  Here is what you need:

| Method           | Description                                                   |
|----------------  |----------------------------------------------------------------
| `send_line`      | Send the given line blind without before or after checks.
| `simh_send_line` | Like `send_line` above, but mindful of context. Will escape to SIMH if necessary.|
| `os8_kbd_delay`  | Wait an amount of time proportional to what OS/8 should be able to handle on the hosting platform without overflowing the input buffer and dying. |
| `os8_send_ctrl`  | Send a control character to OS/8.  Use `os8_kbd_delay` to prevent overflowin the input buffer and killing OS/8.|
| `os8_send_str`   | Send a string of characters to OS/8, and wait for os8_kbd_delay afterwards. |
| `os8_send_line`  | Add a carriage return to the given string and calk os8_send_str` to send it to OS/8.|


## Other Operations

### Quitting the simulator

It is recommended that you use the `quit` method to exit the simulator.
It will make sure it selects the simh context before trying to quit.

Indeed it's further recommended that you send a command to simh to
detach all devices to make sure any buffered output is flushed.
You need to test for the SIMH prompt to make sure you've succeeded.


```
  s.simh_cmd ("detach all")
  s.simh_test_result(reply, "Prompt", my_replies_rex, "myprog")
  s._child.sendline("quit")

```


### Zero Core

SIMH's PDP-8 simulator doesn't start with core zeroed, on purpose,
because the actual hardware did not do that.  SIMH does not attempt to
simulate the persistence of core memory by saving it to disk between
runs, but the SIMH developers are right to refuse to do this by
default: you cannot trust the prior state of a PDP-8's core memory
before initializing it yourself.


### Zero OS/8 Core

Sometimes we want to zero out core, but leave OS/8 in tact.
The `os8_zero_core` method zeros  all of core excepting:

 * 0. page zero - many apps put temporary data here
 * 1. the top pages of fields 1 & 2 - OS/8 is resident here
 *  2. the top page of field 2 - OS/8's TD8E driver (if any) lives here

We then restart OS/8, which means we absolutely need to do #1 and
may need to do #2.  We could probably get away with zeroing page 0.


## But There's More!

The above introduced you to most of the functionality of `class simh`
used by `teco-pi-demo`. It is a useful exercise to read through [the


simh class's source code][ssc]. There are many useful and interesting
methods in the simh class that are documented there not here. Although
it started off as a simple class amenable to quick study, some heavy
duty drivers for configuration of OS/8 devices under SIMH were added.
The source file is organized places the lower level methods first and
proceeds through progressively higher level ones, first for simh
direct interaction and the OS/8 interaction.

The `os8-run` script has a whole [higher level library][os8script]
built on top of the simh class that includes state machines for
executing complex commands like BUILD and applying patches with
ODT and FUTIL.

Another useful module is [`pidp8i.dirs`][dsc] which contains paths to
many directories in the PiDP-8/I system, which you can reuse to avoid
having to hard-code their locations.  This not only makes your script
independent of the installation location, which is configurable at build
time via `./configure --prefix=/some/path`, but also allows it to run
correctly from the PiDP-8/I software's build directory, which has a
somewhat different directory structure from the installation tree.

[ssc]: https://tangentsoft.com/pidp8i/file/lib/simh.py.in
[dsc]: https://tangentsoft.com/pidp8i/file/lib/pidp8i/dirs.py.in
[os8script]: https://tangentsoft.com/pidp8i/file/lib/os8script.py.in


## <a id="license" name="credits"></a>Credits and License

Written by and copyright © 2017-2020 by Warren Young and William Cattey.
Licensed under the terms of [the SIMH license][sl].

[sl]: https://tangentsoft.com/pidp8i/doc/trunk/SIMH-LICENSE.md

* copy files from the running OS/8 environment into the POSIX environment
running SIMH.
* copy files to the running OS/8 from the POSIX environment running SIMH.
* run any OS/8 command as long as it returns immediately to the OS/8 Keyboard
Monitor. This includes BATCH scripts.
* run `ABSLDR` and `FOTP`, cycling an arbitrary number of times through the OS/8
Command Decoder.
* run `PAL8` and report any errors encountered.

* run `BUILD` with arbitrarily complex configuration scripts, including
the `BUILD` of a system head that inputs `OS8.BN` and `CD.BN`.
* configure the `tti`, `rx`, `td`, and `dt` devices at run time to allow
shifting between otherwise incompatible configurations of SIMH and OS/8
device drivers.
* run included script files so that common code blocks can be written once
in an external included script.

hangs for a while and then gives a timeout backtrace.


### <a id="resume-comm"></a>`resume` — Resume OS/8 at Keyboard Monitor command level.

`resume`

The least disruptive way to resume operations under SIMH is to issue
the `continue` command. Although it took a while, we finally got this
command working reliably.  There were timing and workflow issues
that had to be resolved.



The `resume` command checks to see if OS/8 has been booted and refuses
to act if it has not.






### <a id="restart-comm"></a>`restart` — Restart OS/8.

`restart`

Equivalent to the SIMH command line of \"`go 7600`\", but which confirms
we got our Monitor prompt.

Before `resume` was developed, the next less disruptive way to get an
OS/8 Keyboard Monitor prompt was to restart SIMH at address 07600.
This is considered a soft-restart of OS/8.  It is less disruptive than
a `boot` command, because the `boot` command loads OS/8 into main
memory from the boot device, whereas restarting at location 07600 is
just a resart without a reload.

The `restart` command checks to see if OS/8 has been booted and refuses
to act if it has not.


### <a id="copy-comm"></a>`copy` — Make a copy of a POSIX file.

`copy` _source-path_ _destination-path_

The most common activity for `os8-run` is to modify a system image.

the command will return to the monitor command level and the command
prompt, "`.`" will be produced.

This command should be used ONLY for OS/8 commands that return
immediately to command level.  `BATCH` scripts do this, and they can
be run from here.

The `os8` command is aware of a special enablement keyword: `transcript`.
(See the [`enable` \ `disable`](#en-dis-comm) section below.)
If `transcript` is enabled, the output from running the OS/8
command line is printed.  

For example, if you wanted to display the contents of a DECtape image
you are constructing but no other command lines fed to the `os8`
command you would do this:

```
enable transcript
os8 DIR DTA0:
disable transcript
```

This transcript capability provides a fine grained debugging aid.


### <a id="pal8-comm"></a>`pal8` — Run OS/8 `PAL8` assembler.




Actually, the `PAL8` assembler can be called just fine
by using the `os8` command, for example:

    os8 PAL8 RKB1:RL0.BN<RKA1:RL0.PA
   
However, an separate pal8 command was created to enable richer display




of errors.























Examples:

Create a binary `OS8.BN` on partition B of rk05 drive 1 from `OS8.PA`
source file found on partition A of rk05 drive 1.

    pal8 RKB1:OS8.BN<RKA1:OS8.PA

default, switch to TD8e to run `BUILD` and create .tu55 tape images
suitable for deployment on commonly found hardware out in the real
world. 


## TODOs


* Add sanity check parse of sub-commands to confirm command. **OR** Change the 
begin command to treat _argument_ not as a full command, but merely
a device from which to fetch the command.  Maybe make _argument_ optional.


## Notes

# authorization from those authors.
########################################################################

# Bring in just the basics so we can bring in our local modules
import os
import sys
import tempfile
import time
sys.path.insert (0, os.path.dirname (__file__) + '/../lib')
sys.path.insert (0, os.getcwd () + '/lib')

# Python core modules we use
import re
from string import Template
import shutil

# Optional device spec, i.e. DTA0:
# File spec with a specific extension or no extension.

_os8_fspec = Template ("((\S+:)?([A-Z0-9]{1,6}|[A-Z0-9]{1,6}\.$ext))")
_os8_BN_fspec = _os8_fspec.substitute(ext="BN")
_os8_PA_fspec = _os8_fspec.substitute(ext="PA")
_os8_LS_fspec = _os8_fspec.substitute(ext="LS")












# Regex to parse a valid OS/8 option string either with slash or parens.











_opt_str =  "((/[A-Z0-9])+|\([A-Z0-9]+\))?"



# Regular expression for syntax checking inside ABSLDR
# FIXME: Use (and test) _opt_str for full OS/8 Option spec compatibility
# One or more OS/8 binary files and optional args beginning with a slash.

_absldr_re = re.compile ("^" + _os8_BN_fspec + "(," + _os8_BN_fspec + ")*(/\S)*$")

# Regular expressions for syntax checking for cpto and cpfrom.
# May be <source> where destination and default option /A is implied.
# Or <source> <option> where destination is implied and option is set.

                    "SYSTEM": re.compile("^\S+$"),
                    "DSK"   : re.compile("^(\S+:)?\S+$"),
                    "BUILD" : re.compile("^(\S+(.BN)?)\s+(\S+(.BN)?)$"),
                    "PRINT" : None,
                    "BOOT"  : None,
                    "end"   : None}













# Parse two whitspace separated arguments into group(1) and group(2)
_two_args_re = re.compile("^(\S+)\s+(\S+)$")

_rx_settings = ["rx01", "rx02", "RX8E", "RX28"]
_tape_settings = ["td", "dt"]
_tti_settings = ["KSR", "7b"]

  return vers_array


class os8script:
  # Contains a simh object, other global state and methods
  # for running OS/8 scripts under simh.
  #### globals and constants ###########################################

  # Replies that pal8 adds.
  _pal8_rep_adds = [
    # Prompts come from the existing _os8_replies
    # Status:
    ["ERRORS DETECTED", "ERRORS DETECTED: ", False],
    ["LINKS GENERATED", "LINKS GENERATED: ", False],
    # Errors:
    ["Buffer Exceeded", "BE\s+\S+.*\r", True],
    ["Cref not Found", "CF\s+\S+.*\r", False],
    ["Device Error", "DE\s+\S+.*\r", True],
    ["Device Full", "DF\r", True],
    ["Illegal Character", "IC\s+\S+.*\r", False],
    ["Illegal re-Definition", "ID\s+\S+.*\r", False],
    ["Illegal Equals", "IE\s+\S+.*\r", False],
    ["Illegal Indirect", "II\s+\S+.*\r", False],
    ["Illegal PseudoOp", "IP\s+\S+.*\r", False],
    ["Illegal page Zero reference", "IZ\s+\S+.*\r", False],
    ["Loader not founD", "LD\s+\S+.*\r", False],
    ["Link Generated", "LG\s+\S+.*\r", False],
    ["current Page Exceeded", "PE\s+\S+.*\r", False],
    ["PHase Error", "PH\s+\S+.*\r", False],
    ["Re Definition", "RD\s+\S+.*\r", False],
    ["Symbol table Exceeded", "SE\s+\S+.*\r", False],
    ["Undefined Origin", "UO\s+\S+.*\r", False],
    ["Undefined Symbol", "US\s+\S.*\r", False],
    ["page Zero Exceeded", "ZE\s+\S+.*\r", False],
    ["NOT FOUND", "\S+ NOT FOUND", False],
  ]
  
  _build_rep_adds = [
    # Prompts:
    # Add the BUILD prompt
    # Subtle point:  Dollar sign appears in all kinds of output
    # so we try to minimize where we look for it so as to avoid
    # confusing pexpect.
    ["BUILD Prompt", "\n\\$$", True],
    # Status:
    ["SYS BUILT", "SYS BUILT", False],
    ["WRITE ZERO DIRECT?", "WRITE ZERO DIRECT\\?", False],
    ["LOAD OS8", "LOAD OS/8: ", False],
    ["LOAD CD", "LOAD CD: ", False],
    # Errors:
    ["BAD ARG", "\\?BAD ARG", False],
    ["BAD INPUT", "\\?BAD INPUT", False],
    ["BAD LOAD", "\\?BAD LOAD", False],
    ["BAD ORIGIN", "\\?BAD ORIGIN", False],
    ["CORE", "\\?CORE", False],
    ["DSK", "\\?DSK", False],
    ["HANDLERS", "\\?HANDLERS", False],
    ["I/O ERR", "I/O ERR", False],
    ["NAME", "\\?NAME", False],
    ["NO ROOM", "NO ROOM", False],
    ["SYS NOT FOUND", "SYS NOT FOUND", False],
    ["PLAT", "\\?PLAT", False],
    ["SYNTAX", "\\?SYNTAX", False],
    ["SYS", "\\?SYS", False],
    ["SYS ERR", "SYS ERR", False],
    ["File NOT FOUND", "\S+ NOT FOUND", False]
  ]


  def __init__ (self, simh, enabled_options, disabled_options, verbose=False, debug=True):
    self.lang_version = LANG_VERSION
    self.verbose = verbose
    self.debug = debug
    self.simh = simh
    self.options_enabled = enabled_options
    self.options_disabled = disabled_options
    # Do we need separate stacks for enabled/disabled options?
    self.options_stack = []
    # List of scratch files to delete when we are done with all script runs.
    self.scratch_list = []
    self.booted = False
    self.line_ct_stack = []

    # _pal8_replies is the union of _pal8_rep_adds and _os8_replies
    self._pal8_replies = self._pal8_rep_adds
    self._pal8_replies.extend(self.simh._os8_replies)
    # Pre-compile our pal8_replies regexps.
    self._pal8_replies_rex = []
    for item in self._pal8_replies:
      self._pal8_replies_rex.append(re.compile(item[1].encode()))

    # _build_replies is the union of _build_rep_adds and _os8_replies
    self._build_replies = self._build_rep_adds
    self._build_replies.extend(self.simh._os8_replies)
    # Pre-compile our build_replies regexps.
    self._build_replies_rex = []
    for item in self._build_replies:
      self._build_replies_rex.append(re.compile(item[1].encode()))




  #### path_expand #######################################################
  # Simple minded variable substitution in a path.
  # A path beginning with a dollar sign parses the characters between
  # the dollar sign and the first slash seen becomes a name to
  # expand with a couple local names: $home and the anchor directories

      rest = m.group(1)
      if rest == None: rest = ""
      
      if rest == end_str: return
  
  
  #### include_command #################################################
  # Call run_script_file recursively on the file path provided.
  
  def include_command (self, line, script_file):
    path = self.path_expand(line)
    if path == None:
      print("Ignoring: \n\tinclude " + line)
      return "fail"

    return "success"


  #### resume_command #############################################
  # Call the os8_resume in simh to resume OS/8.

  def resume_command (self, line, script_file):
    if not self.booted:
      print("Cannot run resume command at line " + \
        str(self.line_ct_stack[0]) + ". OS/8 has not been booted.")
      return "die"

    if self.verbose:
      print("Resuming OS/8 at line " + str(self.line_ct_stack[0]) + ".")

    self.simh.simh_resume_os8()
    return "success"


  #### restart_command #############################################
  # Call the os8_restart in simh to resume OS/8.

  def restart_command (self, line, script_file):
    if not self.booted:
      print("Cannot run restart command at line " + \
        str(self.line_ct_stack[0]) + ". OS/8 has not been booted.")
      return "die"

    if self.verbose:
      print("Restarting OS/8 at line " + str(self.line_ct_stack[0]) + ".")

    self.simh.simh_restart_os8()
    return "success"


  #### patch_command ##############################################
  # Read the named patch file and perform its actions.

  def patch_command (self, line, script_file):

      else: rest = m.group(3)
      retval = commands[m.group(1)](rest, script_file)
      if retval == "die":
        print("\nFatal error encountered in " + script_path + \
          " at line " +  str(self.line_ct_stack[0]) + ":")
        print("\t" + line)
        sys.exit(-1)
      elif retval == "fail":
        print("Non-fatal error encountered in " + script_path + \
          " at line " +  str(self.line_ct_stack[0]) + ":")
        print("\t" + line + "\n")

    # Done.  Pop the line count off our line_ct_stack
    self.line_ct_stack.pop(0)
    if self.debug:
      print("popped line_ct_stack: " + str(self.line_ct_stack))
    
    return "success"


  #### end_command #####################################################
  
  def end_command (self, line, script_file):
    print("Unexpectedly encountered end command at line " + \
      str(self.line_ct_stack[0]) + ": " + line)
    return "fail"

  
  #### parse_odt #######################################################
  
  def parse_odt (self, line):
    if self.debug: print(line)
    
    if line == "\\c": return "break"
    match = _odt_parse.match(line)
    if match == None:
      print("Aborting because of bad ODT line: " + line)
      self.simh.os8_ctrl_c (caller="parse_odt")
      return "err"
    loc = match.group(1)
    old_val = match.group(2)
    new_val = match.group(3)
    expect_val_str = "\s*[0-7]{4} "
    
    if self.debug:
      print("Loc: " + loc + ", old_val: " + old_val + ", new_val: " + \
          new_val)
    self.simh.os8_send_str (loc + "/")
    self.simh._child.expect(expect_val_str)
  
    if old_val.isdigit():          # We need to check old value
      found_val = self.simh._child.after.decode().strip()
      if found_val != old_val:
        print("\tOld value: " + found_val + " does not match " +
            old_val + ". Aborting patch.")
        # Abort out of ODT back to the OS/8 Monitor
        self.simh.os8_ctrl_c ("parse_odt 2")
        return "err"
  
    self.simh.os8_send_line (new_val)
    return "cont"


  #### futil_exit ########################################################
  
  def futil_exit (self, line):
    self.simh.os8_send_line(line)
    return "break"


  #### futil_file ########################################################
  
  def futil_file (self, line):
    # Redundant re-parse of line but nobody else wants args right now.
    match = _com_split_parse.match(line)
    if match == None:
      print("Aborting because of mal-formed FUTIL FILE command: " + line)
      self.simh.os8_ctrl_c (caller="futil_file")
      return "err"
    fname = match.group(2)
    expect_futil_file_str = "\n" + fname + "\s+(.*)$"
    self.simh.os8_send_line (line)
    self.simh._child.expect(expect_futil_file_str)
    result = self.simh._child.after.decode().strip()
    match = _com_split_parse.match(result)
    if match == None:
      print("Aborting because unexpected return status: " + result + \
          " from: " + line)
      self.simh.os8_ctrl_c (caller="futil_file 2")
      return "err"
    if match.group(2).strip() == "LOOKUP FAILED":
      print("Aborting because of FUTIL lookup failure on: " + fname)
      self.simh.os8_ctrl_c (caller="futil_file 3")
      return "err"
    else:
      return "cont"
  
  
  #### parse_futil #####################################################
  #
  # Very simple minded:
  # If first char on line is an alpha, run the command.
  # If the first char on line is number, do the substitute command.
  #
  # Substitute command acts like ODT.
  # Future version should support the IF construct.
  #
  # When we encounter the EXIT command, we return success.
  
  def parse_futil (self, line):
    futil_specials = {
      "EXIT": self.futil_exit,
      "FILE": self.futil_file
    }
  
    if line[0].isdigit():
      # Treat the line as ODT
      return self.parse_odt(line)
    else:
      match = _com_split_parse.match(line)
      if match == None:
        print("Ignoring failed FUTIL command parse of: " + line)
        return "cont"
      fcom = match.group(1)
      rest = match.group(2)
  
      if fcom not in futil_specials:
        # Blind faith and no error checking.
        self.simh.os8_send_line(line)
        return "cont"
      else:
        return futil_specials[fcom](line)


  #### run_patch_file ##################################################
  
  def run_patch_file (self, pathname):
    sys.stdout.write ("Applying patch " + os.path.basename (pathname) + "...")
    sys.stdout.flush ()

    try:
      patch_file = open(pathname, "r")
    except IOError:
      print(pathname + " not found. Skipping.")
      return "fail"
    
    # Supported parsers.
    # Note tht FUTIL has not been tested since we flipped the expect order.
    parsers = {
      "ODT": self.parse_odt,

      "FUTIL": self.parse_futil
    }

    # What prompt do we want when we run an allowed command?
    # If there is none, we don't wait.  But if we want one,
    # We BETTER wait for it.  A race condition has been observed
    # where, if we don't wait for SAVE, it might not happen.
    allowed_commands = ["ODT", "R", "GET", "GE",  "SAVE", "SA"]
    
    inside_a_command = False
    the_command = ""
    the_command_parser = None
    
    # Any os8-run command may be called after a simh command that left us
    # in simh context. Check to see if we need to restart OS/8.
    # We resume OS/8. It should be non-disruptive and work well.
    if self.simh._context == "simh":
      self.resume_command(line, script_file)

    for line in patch_file:
      line = line.rstrip()
      if line == "": continue
      elif line[0] == '#': continue     # Ignore Comments
      elif inside_a_command:
        retval = the_command_parser (line)
        if retval == "break":
          inside_a_command = False
          self.simh.os8_ctrl_c (caller="run_patch_file")
        elif retval == "err":
          patch_file.close()
          return "fail"
      elif line[0] == '.':        # New OS/8 Command
        match = _com_os8_parse.match(line)
        if match == None:
          print("Aborting patch on failed OS/8 command parse of: " + line)
          return "fail"
        com = match.group(1)
        rest = match.group(2)
  
        if com not in allowed_commands:
          print ("Command " + com + " not allowed in patch. Ignoring.")
          continue
        # Fall through to start up our command.
        # Maybe command is ".ODT", maybe it's "R FUTIL"
        if com == "R":

          # Check to see if we can run this.
          if rest not in parsers:
            print ("Not allowed to run " + rest + " in a patch file.  Aborting.")
            return "fail"
          com = rest     # Now fall through an set the_command
        the_command = com

        


        # Noisy debug output. Our line.
        if self.verbose and self.debug: print(line)


        # Are we going to be inside a command after we do the run?
        if com in parsers:
          the_command_parser = parsers[com]
          inside_a_command = True
          # Run the line blind, skipping over the dot at the beginning.
          # We won't get a prompt.
          self.simh.os8_send_line (line[1:])
        # It's an OS/8 command
        else:
          # We must test for monitor prompt to signify success.
          # Otherwise a race condition has been shown to prevent save of
          # patched binary because our exit of SIMH happens too quickly!
          reply = self.simh.os8_cmd (line[1:])  # Skip over Prompt in line.
          # We need to confirm we succeeded.
          # If we fail, we just complain and keep going.
          self.simh.os8_test_result (reply, "Monitor Prompt", "run_patch_file command " \
                                      + line[1:])
    # Done with all patch file lines.
    patch_file.close()
  
    print("Success.")
    return "success"


  #### skip_patch ######################################################
  # Returns true if the given filename matches one of the regex string
  # keys of the given skips dict and the flag value for that key is set.
  # See skips definition in make_patch, which calls this.
  
  def skip_patch (fn, skips):
      for p in skips:
          if re.search (p, fn) and skips[p]: return True
      return False
  





































  #### simh_command ####################################################
  # I tried to avoid including this command but sometimes you just
  # have to reconfigure subtle bits of device drivers.
  # We assume we can call a simh command at any time, but
  # doing so puts us in the simh context that persists until we
  # issue a boot or go command.
  
  def simh_command (self, line, script_file):
    print("simh command is disabled. Line " + \
      str(self.line_ct_stack[0]) + " ignored.")
    return "fail"
    if self.verbose: print(line)
    reply = self.simh.simh_cmd(line)
    self.simh.simh_test_result(reply, "Prompt", "simh_command")
    return "success"


  #### umount_command ##################################################
  def umount_command (self, line, script_file):
    detach_comm = "det " + line
    if self.verbose: print("line: " + \
        str(self.line_ct_stack[0]) + ": " + detach_comm)
    reply = self.simh.simh_cmd(detach_comm)
    self.simh.simh_test_result(reply, "Prompt", "umount_command")
    return "success"


  #### make_scratch ####################################################
  # Create a copy of the contents of image file using the python
  # method to create a secure, named temp filename.
  # The caller has split the image file name into a base path,

    os8dev = _os8_from_simh_dev[simh_dev]
  
    attach_comm = "att " + ro_arg + simh_dev + unit + " " + imagename
  
    if self.verbose:
      print("Line " + str(self.line_ct_stack[0]) + ": mount: " + \
          attach_comm)
    reply = self.simh.simh_cmd(attach_comm)
    self.simh.simh_test_result(reply, "Prompt", "mount_command")
    return "success"


  #### boot_command ####################################################
  #
  # Check to see if the device to be booted has something attached.
  # If not die.
  # If so, boot it, and set our booted state to True.
  
  def boot_command (self, line, script_file):
    # First confirm something is attached to boot from.
    ucname = line.upper()
    boot_replies = [ucname + "\s+(.+)\r", "Non-existent device"]
    self.simh.simh_send_line("show " + line)
    retval = self.simh._child.expect(boot_replies)
    if retval == 1:
      print("Attempt to boot non-existent device: " + line)
      return "die"
    reply_str = self.simh._child.after.decode()
    m = re.match("^(\S+)\s(\S+),\s+(attached to |not attached)(\S+)?,\s+(.+)\r",
        reply_str)
    if m == None:
      print("Could not determine if device " + line + " is attached; " +
          "got '" + reply_str + "'")
      return "die"

    # Caution match group we want ends with a space.
    if m.group(3) != "attached to ":
      print("Attempt to boot on non-attached device: " + line)
      return "die"
    
    boot_comm = "boot " + line
    if self.verbose:
      print("Line " + str(self.line_ct_stack[0]) + ": " + boot_comm)
    reply = self.simh.simh_cmd(boot_comm, self.simh._os8_replies_rex)
    # We're in OS/8 now use that tester.
    self.simh.os8_test_result (reply, "Monitor Prompt", "boot_command")
    self.booted = True
    return "success"


  #### os8_command #####################################################
  
  def os8_command (self, line, script_file):
    if not self.booted:
      print("Cannot run os8 command at line " + \
        str(self.line_ct_stack[0]) + ". OS/8 has not been booted.")
      return "die"

    os8_comm = line
    retval = "success"
    if self.verbose: print("Line: " + \
       str(self.line_ct_stack[0]) + ": os8_command: " + os8_comm)

    # Any os8-run command may be called after a simh command that left us
    # in simh context. Check to see if we need to restart OS/8.
    # We could resume, but restart is safer.
    if self.simh._context == "simh":
      self.restart_command(line, script_file)

    reply = self.simh.os8_cmd (os8_comm, debug=self.debug)
    if "transcript" in self.options_enabled:
      print (self.simh._child.before.decode().strip())

    mon = self.simh.os8_test_result (reply, "Monitor Prompt", "os8_command moncheck 1")
    cd  = self.simh.os8_test_result (reply, "Command Decoder Prompt", "")
    while not mon:
      retval = "fail"
      if cd: continue
      # If this was not a fatal error, we need to ^C to get back to Monitor.
      # But sometimes OS/8 is not yet ready for ^C, so we wait half a second.
      if self.simh._os8_replies[reply][2] == False:
        time.sleep (.5)
        self.simh.os8_send_ctrl ('c')
      reply = self.simh._child.expect (self.simh._os8_replies_rex)
      mon = self.simh.os8_test_result (reply, "Monitor Prompt", "os8_command moncheck 2")
      cd  = self.simh.os8_test_result (reply, "Command Decoder Prompt", "")
    return retval


  #### pal8_command ####################################################
  # The "pal8" script command comes in two forms:
  # The two argument form where the PAL8 status is printed on the fly
  # and the 3 argument form where all status goes into the listing file.
  # We do the 3 argument form with a simple "os8" script command.
  
  def pal8_command (self, line, script_file):
    if not self.booted:
      print("Cannot run pal8 command at line " + \
        str(self.line_ct_stack[0]) + ". OS/8 has not been booted.")
      return "die"

    if self.verbose: print("Running PAL8 on: " + line)
    reply = self.simh.os8_cmd ("R PAL8")
    # Did the command successfully run and enter the command decoder?
    if self.simh.os8_test_result (reply, "Command Decoder Prompt", "call_pal8") == False:
      print("PAL8 failed to start at line " + str(self.line_ct_stack[0]))
      return "fail"

    com_line = line
    retval = "success"
    if self.verbose: print("Line: " + \
       str(self.line_ct_stack[0]) + ": pal8_command: " + com_line)

    # Any os8-run command may be called after a simh command that left us
    # in simh context. Check to see if we need to restart OS/8.
    # We could resume, but restart is safer.
    if self.simh._context == "simh":
      self.restart_command(line, script_file)

    # Send our command and harvest results.
    reply = self.simh.os8_cmd (com_line, self._pal8_replies_rex)
    err_count = 0
    executed_line = self.simh._child.before.decode().strip()
    reply_match_str = self.simh._child.after.decode().strip()
    ed  = self.simh.test_result(reply, "ERRORS DETECTED", self._pal8_replies, "")
    mon = self.simh.test_result(reply, "Monitor Prompt", self._pal8_replies, "")
    cd  = self.simh.test_result(reply, "Command Decpder Prompt", self._pal8_replies, "")
    lg  = self.simh.test_result(reply, "LINKS GENERATED", self._pal8_replies, "")


    err_string = ""

    ret_val = "success"
    # We're going to print all the errors we see
    # and keep looking till we get either a monitor or command decoder prompt.
    while not mon:
      if ed:   # Got Errors Detected. Count them.
        self.simh._child.expect("\d+")
        err_count = int(self.simh._child.after.decode().strip())
      elif lg: 


        self.simh._child.expect("\d+")
        link_count = int(self.simh._child.after.decode().strip())
      elif cd: # Got Command Decoder. Exit with failure.
        if self.debug: print ("call_pal8: Non-fatal error: Sending ^C")
        # Exit pal8. We'll confirm we got back to OS/8 monitor below.
        self.simh.os8_send_ctrl ('c')      
      else:
        err_string += ("\t" + self.simh._child.after.decode().strip() + "\n")
      reply = self.simh._child.expect(self._pal8_replies_rex)
      ed = self.simh.test_result(reply, "ERRORS DETECTED", self._pal8_replies, "")
      mon = self.simh.test_result(reply, "Monitor Prompt", self._pal8_replies, "")
      cd = self.simh.test_result(reply, "Command Decoder Prompt", self._pal8_replies, "")
      lg = self.simh.test_result(reply, "LINKS GENERATED", self._pal8_replies, "")
    if err_count > 0 or err_string != "":
      print ("PAL8 Error: \n\t" + executed_line)
      print (err_string)

      return "fail"
    return "success"


  #### begin_command ###################################################
  
  def begin_command (self, line, script_file):
    if not self.booted:

    if m.group(1) not in sub_commands:
      print("Ignoring unrecognized sub-command at line " + \
        str(self.line_ct_stack[0]) + ": " + m.group(1))
      print("Ignoring everything to next end.")
      self.ignore_to_subcomm_end(line, script_file, "")
      return "fail"
    else:
      # Any os8-run command may be called after a simh command that left us
      # in simh context. Check to see if we need to restart OS/8.
      # We could resume, but restart is safer.
      if self.simh._context == "simh":
        self.restart_command(line, script_file)

      return sub_commands[m.group(1)](m.group(3), script_file)
  
  






  #### build_subcomm ###################################################

  # Run system BUILD command.



  # Use RU not R because we will save it.
  # Allow specifying WHICH version of build on the command line.

  
  def build_subcomm (self, old_line, script_file):




    os8_comm = "RU " + old_line
    if self.verbose:
      print("Line " + str(self.line_ct_stack[0]) + ": " + os8_comm)

    # Run BUILD and confirm it has started successfully.
    reply = self.simh.os8_cmd (os8_comm, self._build_replies_rex, debug=self.debug)
    if self.simh.test_result (reply, "BUILD Prompt", self._build_replies, \
                              "build_subcomm startup " + os8_comm, debug=self.debug) == False:
      print ("Line " + str(self.line_ct_stack[0]) + ": " + os8_comm + " failed.")
      print ("Ignoring the rest of this block.")
      self.ignore_to_subcomm_end(os8_comm, script_file, "build")
      # Confirm we're back to monitor command level.
      self.simh.os8_cfm_monitor ("build_subcomm 1")
      return "fail"

    # Submit the lines from script file to BUILD sub-command.
    for line in script_file:


      line = self.basic_line_parse(line, script_file)
      if line == None: continue
  
      m = re.match(_comm_re, line)
      if m == None:
        print("Ignoring mal-formed build sub-command at line " + \
          str(self.line_ct_stack[0]) + ": " + line)
        continue
  
      build_sub = m.group(1)
      rest = m.group(3)
      if rest == None: rest = ""
      
      if self.debug: print ("build_sub: " + build_sub)
      if build_sub not in _build_comm_regs:
        print("Unrecognized BUILD command at line " + \
            str(self.line_ct_stack[0]) + ": " + build_sub)
        continue

      # Handle the exit from BUILD when we hit an "end" statement.
      if build_sub == "end":
        if rest == "":
          print("Warning! end statement encountered inside build with no argument at line " + \
              str(self.line_ct_stack[0]) + ".\nExiting build.")
          # Exit BUILD. Note! Unlike many commands build does NOT echo "^C!"
          self.simh.os8_send_ctrl ('c')
          self.simh.os8_cfm_monitor ("build_subcomm end with no argument")
          return "fail"
        elif rest != "build": 
          print("Warning! Mismatched begin/end blocks in BUILD at line " + \
              str(self.line_ct_stack[0]) + ".\nEncountered end: {" + \
              rest + "}. Exiting BUILD.")
          # Exit BUILD. Note! Unlike many commands build does NOT echo "^C!"
          self.simh.os8_send_ctrl ('c')
          self.simh.os8_cfm_monitor ("build_subcomm mismatched begin/end")
          return "fail"
        
        # We're done.  Print any desired verbose or debug status
        # then ^C to exit and confirm we're at monitor level.
        if self.verbose:
          print("Line " + str(self.line_ct_stack[0]) + ": end BUILD")
        if self.debug:
          print("before: " + self.simh._child.before.decode().strip())
          print("after: " + self.simh._child.after.decode().strip())
        # Return to monitor.
        # Note! Unlike many commands build does NOT echo "^C!"
        self.simh.os8_send_ctrl ('c')
        self.simh.os8_cfm_monitor ("build_subcomm end with no argument.")
        return "success"
        
      # Now perform sub-commands within BUILD. They have a discernable format.
      build_re = _build_comm_regs[build_sub]
  
      if build_re != None:
        m2 = re.match(build_re, rest)
        if m2 == None:
          print("Ignoring mal-formed BUILD at line " + \
              str(self.line_ct_stack[0]) + ": " + build_sub + \

                str(self.line_ct_stack[0]) + ".")
            continue
          else: cd_arg = m2.group(3)
          
          if self.verbose:
            print("Line " + str(self.line_ct_stack[0]) + \
                 ": BUILD KBM: " + kbm_arg + ", CD: " + cd_arg)






          # Confirm prompted for OS8 binary.


          reply = self.simh.os8_cmd ("BUILD", self._build_replies_rex, debug=self.debug)
          if self.simh.test_result(reply, "LOAD OS8", self._build_replies, "build_subcomm 5") == False:




            print("No prompt for LOAD OS/8 in BUILD command within BUILD at line " + \
              str(self.line_ct_stack[0]) + ".")

            print("Fatal error. Aborting script.")
            return "die"






          # Send it and confirm prompted for CD binary.


          reply = self.simh.os8_cmd (kbm_arg, self._build_replies_rex, debug=self.debug)
          if self.simh.test_result(reply, "LOAD CD", self._build_replies, "build_subcomm 6") == False:




            print("No prompt for LOAD CD in BUILD command within BUILD at line " + \
              str(self.line_ct_stack[0]) + ".")

            print("Fatal error. Aborting script.")
            return "die"


          # Send it and confirm we're back in BUILD command mode.
          reply = self.simh.os8_cmd (cd_arg, self._build_replies_rex, debug=self.debug)
          if self.simh.test_result(reply, "BUILD Prompt", self._build_replies, "build_subcomm 7") == False:
            print ("BUILD command within build failed.  Aborting script.")
            return "die"



          if self.debug:
            print("Resume BUILD.SV command loop.")
          continue

      # Normal case: commands within BUILD.
      comm = build_sub + " " + rest
      if self.verbose:
        print("Line " + str(self.line_ct_stack[0]) + ": BUILD-> " + comm)
      reply = self.simh.os8_cmd (comm, self._build_replies_rex, debug=self.debug)

      # Special case "BOOT" sub-command: May ask, "WRITE ZERO DIRECT?"
      # Will give a monitor prompt when done.
      if build_sub == "BOOT":
        if self.simh.test_result(reply, "WRITE ZERO DIRECT?", self._build_replies, \
                                 "", debug=self.debug):


          if self.debug:
            print("Got, \"WRITE ZERO DIRECT?\". Sending \"Y\".")
          reply = self.simh.os8_cmd("Y", self._build_replies_rex, debug=self.debug)

        if self.simh.test_result(reply, "SYS BUILT", self._build_replies, "", debug=self.debug):
          # Successful boot.  We're now at monitor level.
          # Simplest to ignore anything else in the script up to "end build"
          # Return success or failure based on finding that monitor prompt.
          self.ignore_to_subcomm_end(os8_comm, script_file, "build")
          if self.simh.os8_cfm_monitor ("build_subcomm 8"):
            return "success"
          else:
            return "fail"

      # At this point we either have a BUILD prompt or an error message.
      # If it's not the BUILD prompt, we print an error.
      # If the error is fatal, ignore rest of build block,
      # exit back to OS/8 if necessary and return fail.
      # If it's not fatal, continue running BUILD.
      if self.simh.test_result(reply, "BUILD Prompt", self._build_replies, \

                               "build_subcomm 9", debug=self.debug) == False:
        print("BUILD error at line " + str(self.line_ct_stack[0]) + \
          " with command " + self.simh._child.before.decode().strip())





        if self._build_replies[reply][2] == True:

          print ("Fatal error.  Ignoring rest of this block.")

          self.ignore_to_subcomm_end(os8_comm, script_file, "build")
          # Confirm we're back at the monitor as expected.
          self.simh.os8_cfm_monitor ("build_subcomm 10")





          return "fail"
        # To continue, we need to ask pexpect to get that BUILD prompt before






        # resuming after an error. Ignore everything until we get it.
        self.simh._child.expect("\n\\$$")
        



    print("Warning end of file encountered with no end of BUILD command block at line " + \
      str(self.line_ct_stack[0]) + ".")
    return "fail"


  #### cdprog_subcomm ##################################################
  # Cycle through OS/8 command decoder with the command specified
  # in the argument.
  
  def cdprog_subcomm (self, old_line, script_file):
    os8_comm = "RU " + old_line
    end_str = "cdprog " + old_line
    if self.verbose:
      print("Line: " + str(self.line_ct_stack[0]) + ": " + os8_comm)

    reply = self.simh.os8_cmd (os8_comm, debug=self.debug)
    if self.simh.os8_test_result (reply, "Command Decoder Prompt", "cdprog: " + \
                                  os8_comm, debug=self.debug) == False:
      print (" failed at Line " + str(self.line_ct_stack[0]))
      print ("Ignoring the rest of this block.")
      self.ignore_to_subcomm_end(os8_comm, script_file, end_str)
      # Confirm we're back to monitor command level.
      self.simh.os8_cfm_monitor ("cdprog OS/8 restart after failed RU command")
      return "fail"

    # Submit the lines from script file to the running command.
    # Track whether we return to the Comnand Decoder for more or exit.
    # Track whether we need to exit and ignore the rest of the block.
    for line in script_file:
      line = self.basic_line_parse(line, script_file)
      if line == None: continue
  
      # Test for special case, "end" and act on it if present.
      m = re.match(_comm_re, line)
      if m != None and m.group(1) != None and m.group(1) != "" and m.group(1)  == "end":

        else:
          retval = "success"
          if self.verbose:
            print("Line " + str(self.line_ct_stack[0]) + ": end " + end_str)
        if retval == "fail":
          print("Exiting cdprog, possibly earlier than expected at line " + \
            str(self.line_ct_stack[0]) + ".")
        # Return to Monitor
        reply = self.simh.os8_escape (caller="Sending escape failed. Trying ^c")
        self.simh.os8_send_ctrl ('c')
        self.simh.os8_cfm_monitor ("cdprog: ^c failed. State machine will be confused.")
        return retval
  
      # We could do some basic OS/8 command decoder synax checking here.

      if self.verbose:
        print("Line: " + str(self.line_ct_stack[0]) + ": * " + line)
        print("Sending...")
      reply = self.simh.os8_cmd (line)
      if self.debug:
        print ("cdprog sent line. Got reply: " + str(reply) + " -> " + \
               self.simh._os8_replies [reply][0])

      # Transcribe our output if desired.
      if "transcript" in self.options_enabled:
        print (self.simh._child.before.decode().strip())

      mon = self.simh.os8_test_result(reply, "Monitor Prompt", "")
      cd  = self.simh.os8_test_result(reply, "Command Decoder Prompt", "")
      if mon:
        # Case of command running to completion and returning to OS/8
        # Clean up the parse to the end of the block and return success.
        self.ignore_to_subcomm_end(os8_comm, script_file, end_str)
        return "success"
      elif not cd:
        # We didn't return to command decoder.  That means we have an error.
        # Test the fatal bit in the error structure.
        # IF True: we returned to OS/8. Say we're ignoring the block and return failure.
        # Otherwise we should continue.
        if self.simh._os8_replies[reply][2] == True:
          print ("Fatal error. Ignoring rest of this block.")
          self.ignore_to_subcomm_end(os8_comm, script_file, end_str)
          # Print error message.
          self.simh.os8_test_result(reply, "Command Decoder Prompt", "cdprog failure")
          # Confirm we're back at Monitor
          self.simh.os8_cfm_monitor ("cdprog error handler return to monitor fail")
          return "fail"
        else:
          print ("Non-fatal error encountered with: " + line)
          print ("\t" + self.simh._os8_replies[reply][0])
          # To continue, we need to ask pexpect to get that Command Decoder
          # prompt before resuming after an error. Ignore everything until we get it.
          self.simh._child.expect("\n\\*$")
    print("Warning end of file encountered at line " + \
        str(self.line_ct_stack[0]) + \
        " with no end of cdprog command block.")
    # Exit command back to OS/8 monitor.
    self.simh.os8_escape (caller="cdprog escape from decoder failed sending ^c")
    self.simh.os8_send_ctrl ('c')
    self.simh.os8_cfm_monitor ("failed to get to monitor with ^c")

    return "fail"


  #### check_exists ####################################################
  # Check existence of all files needed
  
  def check_exists (s, image_copyins):
    for copyin in image_copyins:
      image = copyin[1]
      image_path = dirs.os8mi + image
      if (not os.path.isfile(image_path)):
          print("Required file: " + image_path + " not found.")
          mkos8_abort(s)
      # else: print("Found " + image_path)

#!/usr/bin/env @PYCMD@
# -*- coding: utf-8 -*-
########################################################################
# simh/__init__.py - A wrapper class around pexpect for communicating
#   with an instance of the PiDP-8/I SIMH simulator running OS/8.
#
#   See ../doc/class-simh.md for a usage tutorial.
#
# Copyright © 2017 by Jonathan Trites, © 2017-2020 by William Cattey
# and Warren Young.
#
# 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

import tempfile
import time
import re
import sys

import pidp8i

#### simh #############################################################
# Object to manage a running SIMH process programmatically with pexpect.
# Functions in this file are organized from lower level to higher
# level where possible.


#### Private functions ################################################


#######################################################################
#  simh class

class simh:
  #### constants ######################################################
  # pexpect object instance, set by ctor
  _child = None

  # Constant used by os8_kbd_delay, assembled in stages:
  #
  # 1. PDP-8 RS-232 bits per character: 7-bit ASCII plus necessary
  #    start, stop, and parity bits.

  # 5. Invert to get seconds per character, that being the delay value.
  _bpc = 7 + 1 + 1 + 1                                       # [1]
  _ips_ratio = float (pidp8i.ips.current) / pidp8i.ips.pdp8i # [2]
  _pdp8i_safe_bps = 300                                      # [3]
  _host_safe_cps = _pdp8i_safe_bps * _ips_ratio / _bpc       # [4]
  _os8_kbd_delay = 1 / _host_safe_cps                        # [5]


  #### _simh_replies #################################################
  # Array of items that describe replies one might get from SIMH.
  # Each item is a 2 element array consisting of:
  #    [0] A help string that describes the reply.
  #        Match against this string when testing error values.
  #        This value may not be unique. When not unique
  #        the multiple values should represent the same error.
  #
  #    [1] A regular expression for pexpect to use to match on it.
  #        It is a good idea to terminate status messages with "\r"
  #        in order to confirm we've got the whole line,
  #        and prompts with "$" to terminate the search.
  #
  #        For speed and efficiency an array of compiled
  #        regular expressions, indexed to _simh_replies
  #        is created by __init__: simh_replies_rex
  
  _simh_replies = [
    # Prompts:
    ["Prompt", "sim> $"],
    # Guard against case we used the simh table when we meant the OS/8 table. 
    ["Monitor Prompt", "\n\\.$"],
    ["Non-existent device", "Non-existent device"],
    ]

  ####_os8_replies ##################################################
  # Simiar to _simh_replies, but describing replies from OS/8
  # when it is running under SIMH.
  # Each item is a 3 element array consisting of:
  #    [0] A help string that describes the reply.
  #        Match against this string when testing error values.
  #        This value may not be unique. When not unique
  #        the multiple values should represent the same error.
  #
  #    [1] A regular expression for pexpect to use to match on it.
  #        It is a good idea to terminate status messages with "\r"
  #        in order to confirm we've got the whole line,
  #        and prompts with "$" to terminate the search.
  #
  #        For speed and efficiency an array of compiled
  #        regular expressions, indexed to _simh_replies
  #        is created by __init__: os8_replies_rex
  #
  #    [2] A True/False indicator if the command returned to the
  #        keyboard monitor, rather than continuing in the program.    

  _os8_replies = [
    # Prompts:
    ["Monitor Prompt", "\n\\.$", True],
    ["Command Decoder Prompt", "\n\\*$", False],
    ["PIP Continue", "\\^$", True],                  # Newline NOT always present! 
    # OS/8 Handbook 1974 page 1-43/81 Keyboard Monitor Error Messages:
    ["Directory I/O Error", "MONITOR ERROR 2 AT \d+ \\(DIRECTORY I/O ERROR\\)", True],
    ["I/O Error on SYS", "MONITOR ERROR 5 AT \d+ \\(I/O ERROR ON SYS\\)", True],
    ["Directory I/O Error", "MONITOR ERROR 6 AT \d+ \\(DIRECTORY I/O ERROR\\)\r", True],
    ["Device not available", "(\S+) NOT AVAILABLE", False],
    ["File not found", "(\S+) NOT FOUND", False],
    #  OS/8 Handbook 1974 page 1-51/89 Command Decoder Error Messages
    ["Illegal Syntax", "ILLEGAL SYNTAX", False],
    ["File does not exist", "(\S+) DOES NOT EXIST", False],
    #  ["(\S+) NOT FOUND", False],                                 # See above
    ["Too many files", "TOO MANY FILES", False],
    #  OS/8 Handbook 1974 page 1-75/113 CCL Error Messages
    ["Bad Device", "BAD DEVICE", False],
    ["Bad Extension", "BAD EXTENSION", False],
    #"",  OS/8 Handbook 1974 page 1-106/144 PIP Error Messages
    ["ARE YOU SURE?", "ARE YOU SURE\\?", False],
    ["BAD DIRECTORY ON DEVICE", "BAD DIRECTORY ON DEVICE #\s?\d+", False],
    ["BAD SYSTEM HEAD", "BAD SYSTEM HEAD", False],
    ["CAN'T OPEN OUTPUT FILE", "CAN'T OPEN OUTPUT FILE", False],
    ["DEVICE NOT A DIRECTORY DEVICE", "DEVICE #\d+ NOT A DIRECTORY DEVICE", False],
    ["DIRECTORY ERROR", "DIRECTORY ERROR", False],
    ["ERROR DELETING FILE", "ERROR DELETING FILE", False],
    ["ILLEGIAL BINARY INPUT, FILE", "ILLEGIAL BINARY INPUT, FILE #\d+", False],
    ["INPUT ERROR", "INPUT ERROR, FILE #\s?\d+", False],
    ["IO ERROR--CONTINUING", "IO ERROR IN \\(file name\\) --CONTINUING", False],
    ["NO ROOM FOR OUTPUT FILE", "NO ROOM FOR OUTPUT FILE", False],
    ["NO ROOM--CONTINUING", "NO ROOM IN \\(file name\\) --CONTINUING", False],
    ["OUTPUT ERROR", "OUTPUT ERROR", False],
    ["PREMATURE END OF FILE", "PREMATURE END OF FILE, FILE #\s?\d+", False],
    ["ZERO SYS?", "ZERO SYS?", False],
    #"",  OS/8 Handbook 1974 page 2-81/244: DIRECT Error Messages
    ["BAD INPUT DIRECTORY", "BAD INPUT DIRECTORY", False],
    ["DEVICE DOES NOT HAVE A DIRECTORY", "DEVICE DOES NOT HAVE A DIRECTORY", False],
    ["ERROR CLOSING FILE", "ERROR CLOSING FILE", False],
    ["ERROR CLOSING FILE", "ERROR CLOSING FILE", False],
    ["ERROR READING INPUT DIRECTORY", "ERROR READING INPUT DIRECTORY", False],
    ["ILLEGAL *", "ILLEGAL \\*", False],
    #"",  OS/8 Handbook 1974 page: 2-109/272: FOTP Error Messages
    ["ERROR ON INPUT DEVICE, SKIPPING", "ERROR ON INPUT DEVICE, SKIPPING \\((\S+)\\)", False],
    ["ERROR ON OUTPUT DEVICE, SKIPPING", "ERROR ON OUTPUT DEVICE, SKIPPING \\((\S+)\\)", False],
    ["ERROR READING INPUT DIRECTORY", "ERROR READING INPUT DIRECTORY", False],
    ["ERROR READING OUTPUT DIRECTORY", "ERROR READING OUTPUT DIRECTORY", False],
    ["ILLEGAL ?", "ILLEGAL \\?", False],
    ["NO FILES OF THE FORM", "NO FILES OF THE FORM: (\S+)", False],
    ["NO ROOM, SKIPPING", "NO ROOM, SKIPPING \\((\S+)\\)", False],
    ["SYSTEM ERROR-CLOSING FILE", "SYSTEM ERROR-CLOSING FILE", False],
    ["USE PIP FOR NON-FILE STRUCTURED DEVICE", "USE PIP FOR NON-FILE STRUCTURED DEVICE", False],
    ["LINE TOO LONG IN FILE", "LINE TOO LONG IN FILE#\d+", False],
    ]
  

  # Pattern to match a SIMH command.  The command verb ends up in
  # match().group(1), and anything after the verb in group(3).
  _simh_comm_re = re.compile ("^\s*(\S+)(\s+(.*))?$")

  # Significant prefixes of SIMH command verbs that transition from SIMH
  # command context back into the simulation: BOOT, CONTINUE, and GO.

    self._child = pexpect.spawn (os.path.join (basedir, 'bin', sim))
    self._valid_pip_options = ["/A", "/B", "/I"]
    self._os8_file_re = re.compile("(\S+):(\S+)?")
    self._os8_error_match_strings = []
    self._os8_fatal_check = []
    self.verbose = False



    # We keep track of the command context and transition automatically.
    self._context = "simh"
    

    # Pre-compile our os8_replies regexps.
    self._os8_replies_rex = []

    for item in self._os8_replies:
      self._os8_replies_rex.append(re.compile(item[1].encode()))




    # Pre-compile our simh_replies regexps.
    self._simh_replies_rex = []
    for item in self._simh_replies:
      self._simh_replies_rex.append(re.compile(item[1].encode()))
        
    # Turn off pexpect's default inter-send() delay.  We add our own as
    # necessary.  The conditional tracks an API change between 3 and 4.
    pev4 = (pkg_resources.get_distribution("pexpect").parsed_version >
            pkg_resources.parse_version("4.0"))
    self._child.delaybeforesend = None if pev4 else 0

    # Wait for the simulator's startup message.
    if not self.try_wait ('PDP-8 simulator V.*git commit id: [0-9a-f]', 10):
      raise RuntimeError ('Simulator failed to start')







  #################### simh pexpect Abstraction layer ##################





  # Ideally these should be the public interface to pexpect
  # used with the simh object








































































































  





























  #### set_logfile #####################################################


















  def set_logfile (self, lf):




















    self._child.logfile = lf



































































  #### send_line #######################################################












  # Sends the given line "blind", without before or after checks

























































































  def send_line (self, line):

    self._child.sendline (line)









































































































  #### read_tail #######################################################
  # Watch for a literal string, then get what follows on that line.

  def read_tail (self, head, timeout = -1):
    self._child.expect_exact ([head], timeout)
    return self._child.readline ()












































  #### spin ############################################################
  # Let child run without asking anything more from it, with an optional
  # timeout value.  If no value is given, lets child run indefinitely.

  def spin (self, timeout = None):
    self._child.expect (pexpect.EOF, timeout = timeout)

          "waiting for " + str(matches) + "\n")
      return False
    except:
      sys.stderr.write ("Failed to match " + str(matches) + 
          ": unknown exception.\n")
      return False


  ######################## Utility Functions #############################
    
  #### test_result ######################################################
  # Given a result number, an expected result, and an array of result elements,
  # return True if the result matched expected value.
  # If caller is not the empty string, print a message about it.
  #
  # This routine does the repetitive work of testing results returned
  # from running a command, and optionally printing status.

  def test_result (self, reply, expected, results, caller, debug=False):
    # Cover case of utter failure.
    if reply == -1:
      if debug or caller != "":
        print (caller + ": failure.")
      return False
    reply_ID = results[reply][0]
    if debug:
      print ("test_result: Got reply: " + str(reply) + " -> "  + reply_ID)
      print("\tmatch before: {" + self._child.before.decode() + "}")
      print("\tmatch after: {" + self._child.after.decode() + "}")
    if reply_ID.lower() == expected.lower():
      return True
    else:
      if caller != "":
        print (caller + ": Expected: \"" + expected + "\". Instead got: \"" + reply_ID + "\".")
      return False      

  
  ##################### Basic SIMH Interaction ###########################
  # Use these to work with simh under pexpect

  
  #### esc_to_simh  ######################################################
  # Unconditionally go to SIMH
  def esc_to_simh (self, debug=False):
    self._child.sendcontrol ('e')
    reply = self._child.expect (self._simh_replies_rex)  # Wait to get simh prompt
    self.simh_test_result(reply, "Prompt", "esc_to_simh")
    self._context = "simh"
    if debug:
      print("esc_to_simh: reply: " + str(reply) + " -> " + self._simh_replies[reply][0])
      print("\tmatch before: {" + self._child.before.decode() + "}")
      print("\tmatch after: {" + self._child.after.decode() + "}")
    return reply


  #### simh_test_result #################################################
  # Convenience wrapper for test_result that uses SIMH replies.

  def simh_test_result (self, reply, expected, caller, debug=False):
    return self.test_result (reply, expected, self._simh_replies, caller)

  
  #### simh_send_line ########################################################
  # Send a line to simh while managing context.
  # If we are not in the simh context call esc_to_simh which will
  #    send ^e, and set the context to simh.
  # If we issue a command that enters os8 context, set context "os8".
  # It is up to the caller to then do an expect to confirm success.

  def simh_send_line (self, cmd, debug=False):
    if debug: print ("Context: " + self._context)
    if self._context != "simh":
      self.esc_to_simh()
    if debug: print ("simh_send_line: Sending: " + cmd)
    self._child.sendline (cmd)
    m = re.match (self._simh_comm_re, cmd)
    if m != None and m.group(1)[:1].upper() in self._enters_os8_context:
      self._context = "os8"

  

  #### simh_cmd ########################################################
  # If we are not in the simh context call esc_to_simh which will
  #    send ^e, and set the context to simh.
  # If we issue a command that enters os8 context, set context "os8".
  # Wait for a reply for error checking.
  # replies is an optional argument that defaults to _simh_replies_rex
  
  def simh_cmd (self, cmd, replies=None, debug=False):
    if replies == None: replies = self._simh_replies_rex
    self.simh_send_line (cmd, debug=debug)
    reply = self._child.expect(replies)
    if debug:
      print("\tGot reply: " + str(reply) + " -> " + self._simh_replies[reply][0])
      print("\tmatch before: {" + self._child.before.decode() + "}")
      print("\tmatch after: {" + self._child.after.decode() + "}")
    return reply


  #### quit ############################################################
  # Quits the simulator and waits for it to exit
  # By calling simh_send_line, we are careful to look to our context
  # and escape to SIMH if necessary.

  def quit (self):
    self.simh_send_line("quit")
  

  #### zero_core #######################################################
  # From SIMH context, zero the entire contents of core, which is
  # assumed to be 32 kWords.
  #
  # SIMH's PDP-8 simulator doesn't start with core zeroed, on purpose,
  # because the actual hardware did not do that.  SIMH does not attempt
  # to simulate the persistence of core memory by saving it to disk
  # between runs, but the SIMH developers are right to refuse to do this
  # by default: you cannot trust the prior state of a PDP-8's core
  # memory before initializing it yourself.
  #
  # See os8_zero_core () for a less heavy-handed alternative for use
  # when running under OS/8.

  def zero_core (self):
    reply = self.simh_cmd ('de all 0')
    self.simh_test_result(reply, "Prompt", "simh_zero_core")


  ################# PDP-8 SIMH Interaction #############################
  # High level interfaces to learn about and change device configurations
  # for the PDP-8 under SIMH.
  
  #### describe_dev_config #############################################
  # We provide an interface to alter SIMH device configurations for
  # specific parameters and specific devices
  #
  # dev configs supported:  rx, tti, tape
  #
  # rx:     RX8E, RX28   RX8E is the simh name for RX01 support.

      return self.parse_show_tti(lines)
    else: return None

      
  #### do_simh_show  ###################################################
  # Calls show on the device name.
  # Returns array of lines from output.
  # This is focused on OS/8 devices.

  def do_simh_show (self, name):
    supported_shows = ["dt", "td", "tti", "rx"]
    if name not in supported_shows: return None
    
    ucname = name.upper()
    self.simh_send_line("show " + name)
    self._child.expect(ucname + "\s+(.+)\r")
    lines = self._child.after.decode().split ("\r")
    return lines


  #### parse_show_tape_dev  ############################################
  # Returns current state of DECtape support.

        return False
      else:
        for unit in attached_from.keys():
          if attached_from[unit] != "":
            det_comm = "det " + from_tape + unit
            if self.verbose:
              print(det_comm + "(Had: " + attached_from[unit] + ")")
            reply = self.simh_cmd(det_comm)
            self.simh_test_result(reply, "Prompt", "set_tape_config: " + det_com)
        reply = self.simh_cmd("set " + from_tape + " disabled")
        self.simh_test_result(reply, "Prompt", "set_tape_config disable " + from_tape)

    lines = self.do_simh_show(to_tape)
    to_status = self.parse_show_tape_dev(lines)

    if to_status == None:
      print("do_tape_change: Trouble parsing \'show " + to_tape + \
          "\' output from simh. Giving up on:")
      self.do_print_lines (lines)
      return False
    elif to_status != "disabled":
      print(to_tape + " already is enabled.")
    else:
      reply = self.simh_cmd("set " + to_tape + " enabled")
      self.simh_test_result(reply, "Prompt", "set_tape_config enable " + to_tape)

    # Test to confirm to_tape is now enabled.

    lines = self.do_simh_show(to_tape)
    to_status = self.parse_show_tape_dev(lines)

    if to_status == None:

    rx_type = self.parse_show_rx_dev (lines)
    if rx_type == None:
      print("do_rx_change: Trouble parsing \'show rx\' output from simh.  Giving up on:")
      self.do_print_lines(lines)
      return False
    elif rx_type == "disabled":
      if self.verbose: print("rx is disabled. Enabling...")
      reply = self.simh_cmd("set rx enabled")
      self.simh_test_result(reply, "Prompt", "set_rx_config enable  rx")
      # Retry getting rx info
      lines = self.do_simh_show("rx")
      rx_type = self.parse_show_rx_dev (lines)
      if rx_type == None:
        print("do_rx_change after re-enable: Trouble parsing \`show rx\` output from simh. Giving up on:")
        self.do_print_lines(lines)
        return False

      self.do_print_lines(lines)
    else:
      for unit in attached_rx.keys():
        if attached_rx[unit] != "":
          det_comm = "det rx" + unit
          if self.verbose:
            print(det_comm + "(Had: " + attached_rx[unit] + ")")
          reply = self.simh_cmd(det_comm)
          self.simh_test_result(reply, "Prompt", "set_rx_config detach: " + det_comm)

    reply = self.simh_cmd("set rx " + to_rx)
    self.simh_test_result(reply, "Prompt", "set_rx_config set rx " + to_rx)

    # Test to confirm new setting of RX
    lines = self.do_simh_show("rx")
    rx_type = self.parse_show_rx_dev (lines)

    if rx_type == None:
      print("Failed change of rx to " + to_rx + \

      print("do_tti_change: Trouble parsing \'show tti\' output from simh. Giving up on:")
      self.do_print_lines(lines)
      return False
    elif tti_type == to_tti:
      print("tti device is already set to " + to_tti)
      return None

    reply = self.simh_cmd("set tti " + to_tti)
    self.simh_test_result(reply, "Prompt", "set_tti_config setting tti " + to_tti)

    # Test to confirm new setting of tti
    lines = self.do_simh_show("tti")
    tti_type = self.parse_show_tti (lines)
    
    if tti_type == None:
      print("Failed change of tti to " + to_tti + \
          ". Parse fail on \'show tti\'.")
      return False
    elif tti_type != to_tti: 
      print("Failed change of tti to " + to_tti + ". Instead got: " + \
          tti_type)
      return False
    else:
      return True

  ############### Basic OS/8 Interaction ###############################
  # Intereact with OS/8 under SIMH.

  #### os8_kbd_delay ###################################################
  # Artificially delay the media generation process to account for the
  # fact that OS/8 lacks a modern multi-character keyboard input buffer.
  # It is unsafe to send text faster than a contemporary terminal could,
  # though we can scale it based on how much faster this host is than a
  # real PDP-8.  See the constants above for the calculation.

  def os8_kbd_delay (self):
    time.sleep (self._os8_kbd_delay)


  #### os8_send_str ########################################################
  # Core of os8_send_line.  Also used by code that needs to send text
  # "blind" to OS/8, without expecting a prompt and without a CR, as
  # when driving TECO.

  def os8_send_str (self, str):
    for i in range (0, len (str)):
      self.os8_kbd_delay ()
      self._child.send (str[i])


  #### os8_send_ctrl ###################################################
  # Send a control character to OS/8 corresponding to the ASCII letter
  # given.  We precede it with the OS/8 keyboard delay, since we're
  # probably following a call to os8_send_line or os8_cmd.

  def os8_send_ctrl (self, char):
    cc = char[0].lower ()
    self.os8_kbd_delay ()
    self._child.sendcontrol (cc)
    
    if cc == 'e': self._context = 'simh'


  #### os8_send_line ###################################################
  # Core of os8_cmd.  Also used by code that needs to send text
  # "blind" to OS/8, without expecting a prompt, as when driving EDIT.

  def os8_send_line (self, line):
    self.os8_send_str (line)
    self._child.send ("\r")


  #### os8_test_result ##################################################
  # Convenience wrapper for test_result that uses OS/8 replies.

  def os8_test_result (self, reply, expected, caller, debug=False):
    return self.test_result (reply, expected, self._os8_replies, caller, debug)


  #### mk_os8_name # ###################################################
  # Create an OS/8 filename: of the form XXXXXX.YY
  # From a POSIX path.

  def mk_os8_name(self, dev, path):
    bns = os.path.basename (path)
    bns = re.sub("-|:|\(|\)|!", "", bns)
    bns = bns.upper()
    if "." not in bns:
      return dev + bns[:min(6, len(bns))]
    else:
      dot = bns.index('.')
      return dev + bns[:min(6, dot, len(bns))] + "." + bns[dot+1: dot+3]


  #### os8_cmd_ ###################################################
  # Send the given command to OS/8.
  # replies is an array of possible replies that command will get.
  # Returns the index into the replies array that pexpect got,
  # or -1 if the command could not be run.
  # replies is an optional argument which defaults to _os8_replies_rex

  def os8_cmd (self, cmd, replies=None, debug=False, timeout=60):
    if replies == None: replies = self._os8_replies_rex
    if self._context != 'os8': 
      print("OS/8 is not running. Cannot execute: " + cmd)
      return -1
    if debug:
      print("os8_cmd: sending: " + cmd)
      print("\tPrevious match before: {" + self._child.before.decode() + "}")
      print("\tPrevious match after: {" + self._child.after.decode() + "}")
    self.os8_send_line (cmd)
    reply = self._child.expect (replies, timeout = timeout)
    if debug:
      print("\tmatch before: {" + self._child.before.decode() + "}")
      print("\tmatch after: {" + self._child.after.decode() + "}")
    return reply
    

  #### os8_cfm_monitor ##################################################
  # Confirm return to OS/8 monitor.
  # This function is necessary so that we know our command has returned to OS/8.
  # Without this test, the next _child.expect hits a monitor prompt instead of
  # what it will be looking for.
  # If caller is not empty, it will emit an error string if the prompt wasn't seen.
  # Returns True if we are where we expect.

  def os8_cfm_monitor (self, caller, debug=False):
    reply = self._child.expect(self._os8_replies_rex)
    return self.os8_test_result(reply, "Monitor Prompt", caller, debug=debug)


  #### os8_ctrl_c ##################################################
  # Return to OS/8 monitor using the ^C given escape character.
  # We need to listen for the ^C echo or else cfm_monitor gets confused.
  # Confirm we got our monitor prompt.
  # Optional caller argument enables a message if escape failed.
  # Note: OS/8 will respond to this escape IMMEDIATELY,
  # even if it has pending output.
  # You will need to make sure all pending output is in
  # a known state and the running program is quiescent
  # before calling this method. Otherwise pexpect may get lost.

  def os8_ctrl_c (self, caller = "", debug=False):
    self.os8_send_ctrl ("c")
    self._child.expect("\\^C")
    return self.os8_cfm_monitor (caller)


  #### os8_escape ##################################################
  # Return to OS/8 monitor using the escape (^]) character.
  # We need to listen for the $ echo or else cfm_monitor gets confused.
  # Confirm we got our monitor prompt.
  # Optional caller argument enables a message if escape failed.
  # Note: OS/8 will respond to this escape IMMEDIATELY,
  # even if it has pending output.
  # You will need to make sure all pending output is in
  # a known state and the running program is quiescent
  # before calling this method. Otherwise pexpect may get lost.

  def os8_escape (self, caller = "", debug=False):
    self.os8_send_ctrl ('[')
    self._child.expect("\\$")
    return self.os8_cfm_monitor (caller)


  #### simh_restart_os8 #######################################################
  # Abstraction on returning to OS/8 monitor from within SIMH.
  # It is common practice to "load address 7600; start" at the console.
  
  def simh_restart_os8 (self, caller = "", debug=False):
    # Note we're calling simh with os8 replies because we will
    # be switching contexts.
    # simh_cmd manages the context, and checks for success
    # by expecting a command prompt.
    reply = self.simh_cmd ('go 7600', self._os8_replies_rex, debug=debug)
    # We test our reply with os8_test result because we're in OS/8 now.
    self.os8_test_result(reply, "Monitor Prompt", caller)

    
  #### simh_resume_os8 ##########################################################
  # Continue execution of OS/8.
  # This has been extremely tricky to get right.
  # What we must do is give OS/8 a chance to wake up.
  # We do this by asking pexpect to show us our "cont\n" echo and then
  # we do an os8_kbd_delay()
  # We carefully use simh_send_line to send the command so that we
  # know to set the os8 context.
  # WARNING! Using simh_resume_os8 without having booted OS/8
  # has undefined reslts.

  def simh_resume_os8 (self):
    self.simh_send_line ("cont")
    # Give OS/8 a chance to wake up.
    self._child.expect("cont\r")
    self.os8_kbd_delay()


  #### os8_zero_core ###################################################
  # Starting from OS/8 context, bounce out to SIMH context and zero all
  # of core excepting:
  #
  # 0. zero page - many apps put temporary data here
  # 1. the top pages of fields 1 & 2 - OS/8 is resident here
  # 2. the top page of field 2 - OS/8's TD8E driver (if any) lives here
  #
  # We then restart OS/8, which means we absolutely need to do #1 and
  # may need to do #2.  We could probably get away with zeroing page 0.
  #
  # All of the above explains why we have this special OS/8 alternative
  # to the zero_core() method.

  def os8_zero_core (self):
    reply = self.simh_cmd ('de 00200-07577 0')
    self.simh_test_result(reply, "Prompt", "os8_zero_core 00200-07577")
    reply = self.simh_cmd ('de 10000-17577 0')
    self.simh_test_result(reply, "Prompt", "os8_zero_core de 10000-17577 0")
    reply = self.simh_cmd ('de 20000-27577 0')
    self.simh_test_result(reply, "Prompt", "os8_zero_core de 20000-27577 0")
    reply = self.simh_cmd ('de 30000-77777 0')
    self.simh_test_result(reply, "Prompt", "os8_zero_core de 30000-37577 0")
    self.simh_restart_os8 ()


  #### os8_squish ########################################################
  # Wraps the OS/8 SQUISH command for a given device.

  def os8_squish (self, device, caller = ""):
    reply = self.os8_cmd ("SQUISH " + device + ":")
    self.os8_test_result (reply, "ARE YOU SURE?", caller)
    reply = self.os8_cmd ("Y")
    self.os8_test_result (reply, "Monitor Prompt", caller)


  #### os8_pip_to ###################################################
  # Send a copy of a local file to OS/8 using PIP.
  #
  # The file is sent via the SIMH paper tape device through PIP
  # specifying a transfer option.  If no option is specified,
  # ASCII is assumed.
  #
  # In ASCII mode, we pre-process with txt2ptp which translates
  # POSIX ASCII conventions to OS/8 conventions.  In all other
  # modes, we do not do any translation.
  #
  # However, we should supply a sacrificial NULL as an additional character
  # because the OS/8 PTR driver throws the last character away. (NOT DONE YET)
  #
  # Entry context should be inside OS/8.  Exit context is inside OS/8.
  #

  def os8_pip_to (self, path, os8name, option = None, debug=False):
    if option == None: option = ""
    # If os8name is just a device, synthesize an upcased name from
    # the POSIX file basename.
    if not os.path.exists(path):
      print(path + " not found. Skipping.")
      return
    m = re.match(self._os8_file_re, os8name)
    if m != None and (m.group(2) == None or m.group(2) == ""):
        dest = self.mk_os8_name(os8name, path)
    else:
        dest = os8name

    # Gross hack:
    # The command decoder prompt that comes when we continue a PTR/PTP
    # does not have a newline.  But everything else that matches on
    # a command decoder prompt NEEDS that newline. Otherwise we match
    # on asterisks in file specs.
    # Remember to decrement replies on this rex list if we use
    # _os8_replies

    pip_rex = [re.compile("\\*$".encode())]
    pip_rex.extend(self._os8_replies_rex)
    
    did_conversion = False
    if option == "" or option == "/A":
      # Convert text file to SIMH paper tape format in current dir of path.
      if self.verbose: print("Format converting " + path)
      bdir = pidp8i.dirs.build
      # Create uniquified temp path name.
      pt   = path + "-" + str(os.getpid()) + ".pt_temp"
      tool = os.path.join (bdir, 'bin', 'txt2ptp')
      subprocess.call (tool + ' < ' + path + ' > ' + pt, shell = True)
      did_conversion = True
    elif option not in self._valid_pip_options:
      print("Invalid PIP option: " + option + ". Ignoring: " + path + \
          " to OS/8.")
      return
    else:
      pt = path

    # TODO: Sacrificial extra character code goes here.

    # Paper tape created, so attach it read-only and copy it in.  We're
    # relying on txt2ptp to insert the Ctrl-Z EOF marker at the end of
    # the file.
    self.esc_to_simh (debug)
    reply = self.simh_cmd ('attach -r ptr ' + pt, debug=debug)
    self.simh_test_result(reply, "Prompt", "os8_pip_to attaching ptr")
    # Enter OS/8.
    self.simh_restart_os8 (caller="os8_pip_to")
    
    reply = self.os8_cmd ('R PIP', debug=debug)
    # Has PIP Startup been successful?
    if self.os8_test_result (reply, "Command Decoder Prompt", "os8_pip_to 0", \
                             debug=debug) == False: return

    # Give file and test for ready to send,
    reply = self.os8_cmd (dest + '<PTR:' + option, debug=debug)
    if self.os8_test_result (reply, "PIP Continue", "os8_pip_to 1", debug=debug) == False:
      # If we got "PIP Continue" we keep going. Otherwise return.
      # Send escape if reply indicates we didn't go back to the monitor.
      if self._os8_replies[reply][2] == False:
        self.os8_send_ctrl ('[')
      return

    # Finish transfer
    # The test for success is implicit.
    self.os8_send_ctrl ('[')
    reply = self._child.expect (pip_rex)
    if reply != 0:
      self.os8_test_result (reply - 1, "Command Decoder Prompt", "os8_pip_to 2", debug=debug)
    # If we did not return to monitor hit escape to exit PIP.
    if self._os8_replies[reply - 1][2] == False:
        self.os8_send_ctrl ('[')      # Success or Non-fatal error.
        # Must exit PIP and wait for monitor prompt. Complain if we don't get it!
        reply = self._child.expect (self._os8_replies_rex)
        self.os8_test_result (reply, "Monitor Prompt", "os8_pip_to 3")
    # detach ptr
    # self.esc_to_simh ()
    # self.simh_cmd ('detach ptr ')
    # self.os8_restart ()
    
    # Remove the temp file if we created one.
    if did_conversion:
      os.remove (pt)


  #### os8_pip_from ###################################################
  # Fetch a file from OS/8 to a local path using PIP.
  #
  # The OS/8 source filename is synthesized from the basename of the path,
  # upcasing if necessary.
  #
  # The file is sent via the SIMH paper tape device through PIP
  # specifying a transfer option.  If no option is specified,
  # ASCII is assumed.
  #
  # In ASCII mode, we post-process with ptp2txt which translates
  # POSIX ASCII conventions to OS/8 conventions.  In all other
  # modes, we do not do any translation.
  #
  # Entry context should be inside OS/8.  Exit context is inside OS/8.

  def os8_pip_from (self, os8name, path, option = None, debug=False):
    if option == None: option = ""
    # If path is not a file, use the name portion of os8name.
    if os.path.isdir(path):
      colon = os8name.find(':')
      if colon == -1:                # No dev, just a name.
        path = path + "/" + os8name
      else:
        path = path + "/" + os8name[colon+1:]

    if option != "" and option not in self._valid_pip_options:
      print("Invalid PIP option: " + option + \
          ". Ignoring os8_pip_from on: " + path)
      return

    self.esc_to_simh(debug)
    reply = self.simh_cmd ('attach ptp ' + path, debug=debug)
    self.simh_test_result(reply, "Prompt", "os8_pip_from attachng ptp")
    # Enter OS/8.
    self.simh_restart_os8 (caller="os8_pip_from 0")
    
    reply = self.os8_cmd ('R PIP', debug=debug)
    # Has PIP Startup been successful?
    if self.os8_test_result (reply, "Command Decoder Prompt", "os8_pip_from 0") == False: return
    
    # Issue file transfer spec.
    reply = self.os8_cmd ('PTP:<' + os8name + option, debug=debug)
    # Test for Success
    if self.os8_test_result (reply, "Command Decoder Prompt", "os8_pip_from 1") == False:
      # There is an empty PTP file we need to remove.
      os.remove(path)
      # Was this a fatal error?
      if self._os8_replies[reply][2] == False:
        self.os8_send_ctrl ('[')      # Non-fatal error. Must exit PIP
      return

    self.os8_send_ctrl ('[')      # exit PIP
    # Must wait for monitor prompt. Complain if we don't get it!
    reply = self._child.expect (self._os8_replies_rex)
    self.os8_test_result (reply, "Monitor Prompt", "os8_pip_from 2")

    self.esc_to_simh(debug)
    reply = self.simh_cmd ('detach ptp', debug=debug)  # Clean flush of buffers.
    self.simh_test_result(reply, "Prompt", "os8_pip_from detaching ptp")
    # Enter OS/8.
    self.simh_restart_os8(caller="os8_pip_from 3")

    if option == "" or option == "/A":
      if self.verbose: print("Format converting " + path)
      # Convert text file to SIMH paper tape format
      bdir = pidp8i.dirs.build
      # Create uniquified temp path name.
      pf = path + "-" + str(os.getpid()) + ".pf_temp"
      os.rename(path, pf)
      tool = os.path.join (bdir, 'bin', 'ptp2txt')
      subprocess.call (tool + ' < ' + pf + ' > ' + path, shell = True)
      os.remove(pf)

/PALTST.PA
/
/ Trivial PAL8 program to provoke some errors when compiled.
/

	*200
START,	CLA CLL
	TAD UNDEF
	DCA UNDEF2

$

# OS/8 Combined Kit patches to apply

# This script can be run from a parallel make
# So we create a scratch version of the system rk05 to prevent conflicts.
# We have to do this anyway for TD8E since we change the DECtape configuration.

mount rk0 $bin/v3d.rk05 required scratch
boot rk0

# Our built image inherits whether or not INIT is set.
# A blank tape will complain "NO CCL!" on first boot.
# So first thing SET SYS NO INIT

os8 SET SYS NO INIT

begin enabled td8e
  # For TD8E we run BUILD twice
  # First from SYS to change switch from TC08 to TD8E
  # Then  to build the TD8E head from either RKB1 for v3f or from SYS for v3d.



  begin build SYS:BUILD
    DELETE DTA0,DTA1
    INSERT TD8A,DTA0,DTA1
    BOOT
  end build

  configure tape td

  begin enabled v3d
    mount dt0 $os8mo/v3d-tc08.tu56 new
  end enabled v3d

  begin enabled v3f
    mount dt0 $os8mo/v3f-tc08.tu56 new
    # v3f needs device drivers from a V3d Distribution DECtape
    mount dt1 $os8mi/al-4712c-ba-os8-v3d-2.1978.tu56 readonly required
  end enabled v3f

end enabled tc08

# Now build the system head.
# v3f is more complicated because it installs a new KBM and CD.
# Additionally that version of BUILD.SV contained NO drivers.

    PRINT
    BOOT
    end build

end enabled v3d

begin enabled v3f



  os8 COPY DSK:<RKB1:OS8.BN,CD.BN

  begin build RKB1:BUILD
    LOAD DTA1:RK8ESY.BN
    LOAD DTA1:RK8ENS.BN
    LOAD DTA1:PT8E.BN
    

    INSERT RK05,RKA2,RKB2
    
    BUILD DSK:OS8.BN DSK:CD.BN
    BOOT
  end build

  # Explicit unmount to avoid possible race condition.
  # Unmount the right device
  begin enabled td8e
    umount td1
  end enabled td8e
  begin enabled tc08
    umount dt1
  end enabled tc08
end enabled v3f

os8 SAVE DTA0 BUILD.SV

# cusp-copyin.os8 uses the value of v3d or v3f enablement
# already present in the environment.
include $media/os8/scripts/cusp-copyin.os8

mount rk0 $bin/v3d.rk05 required scratch
mount dt1 $os8mi/al-4712c-ba-os8-v3d-2.1978.tu56 ro required

boot rk0

print Confirm testing for failure to start build:

begin build SYS:FOO.SV
end build

print Now test for malformed begin end: empty name:

begin build SYS:BUILD.SV
end

print Now test for malformed begin end: wrong name:

begin build SYS:BUILD.SV
end foo

print Now do a simple couple BUILD commands:

begin build SYS:BUILD.SV
LOAD DTA1:RK8ESY.BN
PRINT
BOOT
end build

print try saving boot

os8 SAVE DSK BUILD.SV

print now confirm malformed FOTP command is reported

begin cdprog FOTP
DTA0:<NOTME.PA
end cdprog FOTP

print now confirm FOTP File not found errors are reported.
begin cdprog SYS FOTP
TTY:<NOTME.PA
end cdprog SYS FOTP

mount rk0 $bin/v3d.rk05 required scratch
mount dt0 $os8mo/pal-test.tu56 new
mount rk1 $bin/v3d-src.rk05 required

boot rk0

print Create test tape
os8 ZERO DTA0:
cpto $os8mi/PALTST.PA DTA0:
os8 COPY DTA0:<RKB1:BOOT.PA

print Enable output from OS/8 commands
enable transcript

print Confirm right things happen when source not found.
pal8 FOO.BN<FOO.PA
print Same command using 'os8'
os8 PAL8 FOO.BN<FOO.PA

print Confirm a good build is successful:
pal8 DTA0:BOOT.BN<DTA0:BOOT.PA
print Same command using 'os8'
os8 PAL8 DTA0:BOOT.BN<DTA0:BOOT.PA

print Confirm we display errors:
pal8 FOO.BN<DTA0:PALTST.PA
print Same command using 'os8'
os8 pal8 FOO.BN<DTA0:PALTST.PA

print Test 3-arg Pal8 command.
pal8 FOO.BN,FOO.LS<DTA0:BOOT.PA
print Same command using 'os8'
os8 PAL8 FOO.BN,FOO.LS<DTA0:BOOT.PA

print Test 3-arg PAL8 command with errors.
pal8 FOO.BN,FOO.LS<DTA0:PALTST
print Try the same 3-arg PAL8 command via os8 with transcript
os8 PAL8 FOO.BN,FOO.LS<DTA0:PALTST

mount rk0 $bin/v3d.rk05 required scratch

boot rk0

mount dt0 $os8mo/v3d-tc08.tu56 required

resume

enable transcript

os8 DIR DTA0:

disable transcript

os8 DIR RKB0:

# Tests 1 build for CUSPS
mount rk0 $os8mo/v3d.rk05 required scratch
mount rk1 $os8mo/uni-bf2-obj.rk05 required

print Build tester

boot rk0

print Building LIBSET.SV
pal8 RKB1:LIBSET.BN<RKA1:LIBSET.PA
begin cdprog SYS:ABSLDR.SV
RKB1:LIBSET.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:LIBSET.SV;12600=6000
os8 DEL RKB1:LIBSET.BN

print Assemble Library Modules
print ATAN
begin cdprog RKB1:SABR.SV
RKB1:ATAN.RL<RKA1:ATAN.SB
end cdprog RKB1:SABR.SV

print What happens if we give too many args?
print SQRT / TRIG Bad.
begin cdprog RKB1:SABR.SV
RKB1:SQRT.RL<RKA1:SQRT.SB
RKB1:TRIG.RL<RKA1:TRIG.SB
end cdprog RKB1:SABR.SV

enable transcript
os8 DIR RKA1:
disable transcript

# print Use our newly build LIBSET to create LIB8.RL from our library RL files.

# begin cdprog RKB1:LIBSET.SV
# RKB1:LIB8.RL<*.RL
# end cdprog RKB1:LIBSET.SV

# Build OS/8 BASIC and FORTRAN II from source

mount rk0 $os8mo/v3d.rk05 required scratch
copy $obj/uni-bf2-src.rk05 $os8mo/uni-bf2-obj.rk05
mount rk1 $os8mo/uni-bf2-obj.rk05 required

boot rk0

print Building BASIC.SV
pal8 RKB1:BASIC.BN<RKA1:BASIC.PA
begin cdprog SYS:ABSLDR.SV
RKB1:BASIC.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:BASIC.SV;3211
os8 DEL RKB1:BASIC.BN

print Building BCOMP.SV
pal8 RKB1:BCOMP.BN<RKA1:BCOMP.PA
begin cdprog SYS:ABSLDR.SV
RKB1:BCOMP.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:BCOMP.SV;7000
os8 DEL RKB1:BCOMP.BN

print Building BLOAD.SV
pal8 RKB1:BLOAD.BN<RKA1:BLOAD.PA
begin cdprog SYS:ABSLDR.SV
RKB1:BLOAD.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:BLOAD.SV;7605
os8 DEL RKB1:BLOAD.BN

print Building BRTS.SV, BASIC.AF, BASIC.SF, BASIC.FF from BRTS.PA
pal8 RKB1:BRTS.BN<RKA1:BRTS.PA/W
begin cdprog SYS:ABSLDR.SV
RKB1:BRTS.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:BRTS.SV 0-6777;7605
os8 SAVE RKB1:BASIC.AF 3400-4577;7605 
os8 SAVE RKB1:BASIC.SF 12000-13177;7605
os8 SAVE RKB1:BASIC.FF 13400-14577;7605
os8 DEL RKB1:BRTS.BN

print Building SABR.SV from SABR.PA and SPATCH.PA
pal8 RKB1:SABR.BN<RKA1:SABR.PA
pal8 RKB1:SPATCH.BN<RKA1:SPATCH.PA
begin cdprog SYS:ABSLDR.SV
RKB1:SABR.BN
RKB1:SPATCH.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:SABR.SV
os8 DEL RKB1:SABR.BN,RKB1:SPATCH.BN

print Building LOADER.SV
pal8 RKB1:LOADER.BN<RKA1:LOADER.PA
begin cdprog SYS:ABSLDR.SV
RKB1:LOADER.BN/9
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:LOADER.SV
os8 DEL RKB1:LOADER.BN

print Building FORT.SV from FORT.PA and FPATCH.PA
pal8 RKB1:FORT.BN<RKA1:FORT.PA
pal8 RKB1:FPATCH.BN<RKA1:FPATCH.PA
begin cdprog SYS:ABSLDR.SV
RKB1:FORT.BN
RKB1:FPATCH.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:FORT.SV
os8 DEL RKB1:FORT.BN,FPATCH.BN

print Building LIBSET.SV
pal8 RKB1:LIBSET.BN<RKA1:LIBSET.PA
begin cdprog SYS:ABSLDR.SV
RKB1:LIBSET.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:LIBSET.SV;12600=6000
os8 DEL RKB1:LIBSET.BN

print Assemble Library Modules
print ATAN
begin cdprog RKB1:SABR.SV
RKB1:ATAN.RL<RKA1:ATAN.SB
end cdprog RKB1:SABR.SV

print FLOAT
begin cdprog RKB1:SABR.SV
RKB1:FLOAT.RL<RKA1:FLOAT.SB
end cdprog RKB1:SABR.SV

print GENIOX
begin cdprog RKB1:SABR.SV
RKB1:GENIOX.RL<RKA1:GENIOX.SB
end cdprog RKB1:SABR.SV

print INTEGR
begin cdprog RKB1:SABR.SV
RKB1:INTEGR.RL<RKA1:INTEGR.SB
end cdprog RKB1:SABR.SV

print IOH
begin cdprog RKB1:SABR.SV
RKB1:IOH.RL<RKA1:IOH.SB
end cdprog RKB1:SABR.SV

print IOPEN
begin cdprog RKB1:SABR.SV
RKB1:IOPEN.RL<RKA1:IOPEN.SB
end cdprog RKB1:SABR.SV

print IPOWRS
begin cdprog RKB1:SABR.SV
RKB1:IPOWRS.RL<RKA1:IPOWRS.SB
end cdprog RKB1:SABR.SV

print POWERS
begin cdprog RKB1:SABR.SV
RKB1:POWERS.RL<RKA1:POWERS.SB
end cdprog RKB1:SABR.SV

print RWTAPE
begin cdprog RKB1:SABR.SV
RKB1:RWTAPE.RL<RKA1:RWTAPE.SB
end cdprog RKB1:SABR.SV

print SQRT
begin cdprog RKB1:SABR.SV
RKB1:SQRT.RL<RKA1:SQRT.SB
end cdprog RKB1:SABR.SV

print TRIG
begin cdprog RKB1:SABR.SV
RKB1:TRIG.RL<RKA1:TRIG.SB
end cdprog RKB1:SABR.SV

print UTILTY
begin cdprog RKB1:SABR.SV
RKB1:UTILTY.RL<RKA1:UTILTY.SB
end cdprog RKB1:SABR.SV

print Use our newly built LIBSET to create LIB8.RL from our library RL files.

begin cdprog RKB1:LIBSET.SV
RKB1:LIB8.RL<RKB1:ATAN.RL,RKB1:FLOAT.RL,RKB1:GENIOX.RL,RKB1:INTEGR.RL
RKB1:IOH.RL,RKB1:IOPEN.RL,RKB1:IPOWRS.RL,RKB1:POWERS.RL,RKB1:RWTAPE.RL
RKB1:SQRT.RL,RKB1:TRIG.RL,RKB1:UTILTY.RL
end cdprog RKB1:LIBSET.SV

# Comments begin with an octothorpe
# Blank lines are ignored.

# OS/8 Writes on the system device (architectural flaw).
# Since this might be run from a parallel make, we mount the system
# with the scratch option to make a unique copy.
mount rk0 $os8mo/v3d.rk05 required scratch
copy $obj/uni-cusps-src.rk05 $os8mo/uni-cusps-obj.rk05
mount rk1 $os8mo/uni-cusps-obj.rk05 required

boot rk0

print Building DIRECT.SV
pal8 RKB1:DIRECT.BN<RKA1:DIRECT.PA
begin cdprog SYS:ABSLDR.SV
RKB1:DIRECT.BN(89P)=14600
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:DIRECT.SV;14600=6403
os8 DEL RKB1:DIRECT.BN

print Building FOTP.SV
pal8 RKB1:FOTP.BN<RKA1:FOTP.PA
begin cdprog SYS:ABSLDR.SV
RKB1:FOTP.BN(89P)=14600
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:FOTP.SV;14600=6403
os8 DEL RKB1:FOTP.BN

print Building PIP.SV
pal8 RKB1:PIP.BN<RKA1:PIP.PA
begin cdprog SYS:ABSLDR.SV
RKB1:PIP.BN(89P)=13000
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:PIP.SV;13000=6403
os8 DEL RKB1:PIP.BN

print Building HELP.SV
pal8 RKB1:HELP.BN<RKA1:HELP.PA
begin cdprog SYS:ABSLDR.SV
RKB1:HELP.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:HELP.SV=3401
os8 DEL RKB1:HELP.BN

print Building BOOT.SV
pal8 RKB1:BOOT.BN<RKA1:BOOT.PA
begin cdprog SYS:ABSLDR.SV
RKB1:BOOT.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:BOOT.SV
os8 DEL RKB1:BOOT.BN

print Building EPIC.SV
pal8 RKB1:EPIC.BN<RKA1:EPIC.PA
begin cdprog SYS:ABSLDR.SV
RKB1:EPIC.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:EPIC.SV
os8 DEL RKB1:EPIC.BN

print Building FUTIL.SV
pal8 RKB1:FUTIL.BN<RKA1:FUTIL.PA
begin cdprog SYS:ABSLDR.SV
RKB1:FUTIL.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:FUTIL.SV;6400=0400
os8 DEL RKB1:FUTIL.BN

print Building SET.SV
pal8 RKB1:SET.BN<RKA1:SET.PA
begin cdprog SYS:ABSLDR.SV
RKB1:SET.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:SET.SV
os8 DEL RKB1:SET.BN

print Building EDIT.SV
pal8 RKB1:EDIT.BN<RKA1:EDIT.PA
begin cdprog SYS:ABSLDR.SV
RKB1:EDIT.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:EDIT.SV
os8 DEL RKB1:EDIT.BN

print Building PAL8.SV
pal8 RKB1:PAL8.BN<RKA1:PAL8.PA
begin cdprog SYS:ABSLDR.SV
RKB1:PAL8.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:PAL8.SV
os8 DEL RKB1:PAL8.BN

print Building CREF.SV
pal8 RKB1:CREF.BN<RKA1:CREF.PA
begin cdprog SYS:ABSLDR.SV
RKB1:CREF.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:CREF.SV
os8 DEL RKB1:CREF.BN

print Building BITMAP.SV
pal8 RKB1:BITMAP.BN<RKA1:BITMAP.PA
begin cdprog SYS:ABSLDR.SV
RKB1:BITMAP.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:BITMAP.SV;12000=6001
os8 DEL RKB1:BITMAP.BN

print Building SRCCOM.SV
pal8 RKB1:SRCCOM.BN<RKA1:SRCCOM.PA
begin cdprog SYS:ABSLDR.SV
RKB1:SRCCOM.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:SRCCOM.SV
os8 DEL RKB1:SRCCOM.BN

print Building TECO.SV
pal8 RKB1:TECO.BN<RKA1:TECO.PA/W
begin cdprog SYS:ABSLDR.SV
RKB1:TECO.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:TECO.SV=2000
os8 DEL RKB1:TECO.BN

print Building RXCOPY.SV
pal8 RKB1:RXCOPY.BN<RKA1:RXCOPY.PA
begin cdprog SYS:ABSLDR.SV
RKB1:RXCOPY.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:RXCOPY.SV;16000=7403
os8 DEL RKB1:RXCOPY.BN

print Building RKLFMT.SV
pal8 RKB1:RKLFMT.BN<RKA1:RKLFMT.PA
begin cdprog SYS:ABSLDR.SV
RKB1:RKLFMT.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:RKLFMT.SV=0000
os8 DEL RKB1:RKLFMT.BN

print Building MCPIP.SV
pal8 RKB1:MCPIP.BN<RKA1:MCPIP.PA
begin cdprog SYS:ABSLDR.SV
RKB1:MCPIP.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:MCPIP.SV;12000=6403
os8 DEL RKB1:MCPIP.BN

print Building MSBAT.SV
pal8 RKB1:MSBAT.BN<RKA1:MSBAT.PA
begin cdprog SYS:ABSLDR.SV
RKB1:MSBAT.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:MSBAT.SV=0000
os8 DEL RKB1:MSBAT.BN

print Building PIP10.SV
pal8 RKB1:PIP10.BN<RKA1:PIP10.PA
begin cdprog SYS:ABSLDR.SV
RKB1:PIP10.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:PIP10.SV=2000
os8 DEL RKB1:PIP10.BN

print Building CAMP.SV
pal8 RKB1:CAMP.BN<RKA1:CAMP.PA
begin cdprog SYS:ABSLDR.SV
RKB1:CAMP.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:CAMP.SV=2000
os8 DEL RKB1:CAMP.BN

print Building DTCOPY.SV
pal8 RKB1:DTCOPY.BN<RKA1:DTCOPY.PA
begin cdprog SYS:ABSLDR.SV
RKB1:DTCOPY.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:DTCOPY.SV=2000
os8 DEL RKB1:DTCOPY.BN

print Building DTFRMT.SV
pal8 RKB1:DTFRMT.BN<RKA1:DTFRMT.PA
begin cdprog SYS:ABSLDR.SV
RKB1:DTFRMT.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:DTFRMT.SV;1000=2000
os8 DEL RKB1:DTFRMT.BN

print Building TDCOPY.SV
pal8 RKB1:TDCOPY.BN<RKA1:TDCOPY.PA
begin cdprog SYS:ABSLDR.SV
RKB1:TDCOPY.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:TDCOPY.SV=2000
os8 DEL RKB1:TDCOPY.BN

print Building TDFRMT.SV
pal8 RKB1:TDFRMT.BN<RKA1:TDFRMT.PA
begin cdprog SYS:ABSLDR.SV
RKB1:TDFRMT.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:TDFRMT.SV;1000=2000
os8 DEL RKB1:TDFRMT.BN

# Creates an OS/8 Combined Kit binary rk05 image from compiled
# Object rk05 images.
# Based on v3d-dist-rk05.os8, and the v3f stuff in all-tu56.os8

# I'm not sure if we can build an RK05 system from scratch
# when booted from RK05, so we'll bootstrap using the OS/8
# distribution DECtape
mount dt0 $os8mi/al-4711c-ba-os8-v3d-1.1978.tu56 required scratch

# rk0 holds the media we build
mount rk0 $os8mo/uni-dist.rk05 new
# rk1  holds the system object image.
mount rk1 $os8mo/uni-sys-obj.rk05
# rk2 holds the CUSPS object image
mount rk2 $os8mo/uni-cusps-obj.rk05

boot dt0

# Our built image inherits whether or not INIT is set.
# A blank tape will complain "NO CCL!" on first boot.
# So first thing SET SYS NO INIT

os8 SET SYS NO INIT

print BUILD the system head
# BUILD requires our OS8.BN and CD.BN to be on DSK:
os8 COPY DSK:<RKB1:OS8.BN,CD.BN

begin build RKB1:BUILD
# But our build has no handlers
LOAD RKB1:RK8ESY.BN
LOAD RKB1:RK8ENS.BN
LOAD RKB1:RXNS.BN
LOAD RKB1:KL8E.BN
LOAD RKB1:LPSV.BN
LOAD RKB1:TC08SY.BN
LOAD RKB1:TC08NS.BN
LOAD RKB1:PT8E.BN
LOAD RKB1:TD8ESY.BN
LOAD RKB1:ROMMSY.BN
LOAD RKB1:TD8EA.BN
# We could load more TD8E non-system drivers
# But there is limited space, so we elect not to.
# LOAD RKB1:TD8EB.BN
# LOAD RKB1:TD8EC.BN
# LOAD RKB1:TD8ED.BN
SYSTEM RK8E
INSERT KL8E,TTY
INSERT LPSV,LPT
INSERT PT8E,PTR
INSERT PT8E,PTP
INSERT RK8E,RKA0,RKB0
INSERT RK05,RKA1,RKB1
INSERT RK05,RKA2,RKB2
INSERT TC,DTA0,DTA1
DSK RK8E:RKB0
PRINT
BUILD DSK:OS8.BN DSK:CD.BN
BOOT
end build

os8 SAVE SYS BUILD.SV
# There is stuff we have to do to get a batch-literate BUILD here.

print copying in CUSPS.

begin cdprog RKB2:FOTP.SV
RKA0:<RKB1:CCL.SV
RKA0:<RKB1:RESORC.SV
RKA0:<RKB1:BATCH.SV
RKA0:<RKB2:FOTP.SV
RKA0:<RKB2:DIRECT.SV
RKA0:<RKB2:BOOT.SV
RKA0:<RKB2:EDIT.SV
RKA0:<RKB2:EPIC.SV
RKA0:<RKB2:PIP.SV
RKA0:<RKB2:SET.SV
RKA0:<RKB2:FUTIL.SV
RKA0:<RKB2:PAL8.SV
RKA0:<RKB2:BITMAP.SV
RKA0:<RKB2:CREF.SV
RKA0:<RKB2:SRCCOM.SV
RKA0:<RKB2:HELP.SV
RKA0:<RKB2:RXCOPY.SV
RKA0:<RKA1:HELP.HL
RKA0:<RKB2:TECO.SV
RKA0:<RKB2:CAMP.SV
RKA0:<RKB2:DTCOPY.SV
RKA0:<RKB2:DTFRMT.SV
RKA0:<RKB2:MCPIP.SV
RKA0:<RKB2:MSBAT.SV
RKA0:<RKB2:PIP10.SV
RKA0:<RKB2:RKLFMT.SV
RKA0:<RKB2:TDCOPY.SV
RKA0:<RKB2:TDFRMT.SV
RKA0:<RKA1:??SYS.BI
end cdprog RKB2:FOTP.SV

os8 R CCL

# Initialize RKB0:
os8 ZERO DSK:

os8 SET TTY COL 3
begin default crt
  os8 SET TTY SCOPE
end default crt

umount rk1
umount rk2
# rk1  holds the BASIC/FORTRAN II object image.
mount rk1 $os8mo/uni-bf2-obj.rk05

# We install SABR and LOADER even if F2 disabled because
# we use them for the C compiler.
print copying in BASIC and SABR and LOADER
begin cdprog SYS:FOTP.SV
RKA0:<RKB1:BLOAD.SV
RKA0:<RKB1:BRTS.SV
RKA0:<RKB1:BCOMP.SV
RKA0:<RKB1:BASIC.*
RKA0:<RKB1:SABR.SV
RKA0:<RKB1:LOADER.SV
# Copy in the BASIC UF.PA source. Maybe make it later
# Note it's starting address on the v3d dist is 7605.
RKB0:<RKA1:UF.PA
end cdprog SYS:FOTP.SV

print Bringing in optional packages build from Combined Kit source

begin default fortran-ii
begin cdprog SYS:FOTP.SV
RKA0:<RKB1:FORT.SV
RKA0:<RKB1:LIBSET.SV
RKA0:<RKB1:*.RL
end cdprog SYS:FOTP.SV
end default fortran-ii

# We're done with BASIC and FORTRAN II object rk05.

# Copying in Music score files and source code...
begin enabled music
print Music score files and source code
mount dt1 $os8mi/subsys/music.tu56 ro required
os8 COPY RKB0:<DTA1:*.*
umount dt1
end enabled music

# Adventure
begin default advent
mount dt1 $os8mi/subsys/advent.tu56 ro required
os8 COPY RKB0:<DTA1:*.*
umount dt1
end default advent

# BASIC games and demos
begin default ba
mount dt1 $os8mi/subsys/ba.tu56 ro required
os8 COPY RKB0:<DTA1:*.*
umount dt1
end default ba

# Kermit-12
begin default k12
mount dt1 $os8mi/subsys/k12.tu56 ro required
os8 COPY RKA0:<DTA1:*.*
umount dt1
end default k12

# FORTRAN IV
begin default fortran-iv
# rk1 holds the FORTRAN IV object image
mount rk1 $os8mo/uni-fiv-obj.rk05
os8 COPY RKA0:<RKB1:*.*
umount rk1
end default fortran-iv

# MACREL V2
# In future we will build this from source
begin default macrel
mount dt1 $os8mi/al-5642c-ba-macrel-v2-futil-v8b-by-hand.tu56 ro required
os8 COPY RKA0:<DTA1:MACREL.SV,LINK.SV,KREF.SV,OVRDRV.MA
umount dt1
end default macrel

# Files from local.tu56
mount dt1 $os8mi/local.tu56 ro required

begin default chess
os8 COPY RKA0:<DTA1:CHESS.*
end default chess

# TECO VTEDIT setup
begin enabled vtedit
os8 COPY RKA0:<DTA1:VTEDIT.*
os8 COPY RKA0:<DTA1:TECO.IN
end enabled vtedit

# DCP Disassembler: DCP24.SV, and DCP16.SV as DCP.SV
begin default dcp
os8 COPY RKA0:<DTA1:DCP24.SV,DCP.SV,DCP16.SV
end default dcp
umount dt1

# FOCAL69 .BN files installed on DSK:
begin enabled focal69
mount dt1 $os8mi/subsys/focal69.tu56 ro required
os8 COPY RKB0:<DTA1:FOCAL.BN,4WORD.BN,4KVT.BN,8KVT.BN,8KNOVT.BN
umount dt1
end enabled focal69

# U/W FOCAL
begin default uwfocal
mount dt1 $os8mi/subsys/uwfocal-v4e-2.tu56 ro required
os8 COPY RKA0:<DTA1:UWF16K.SV
umount dt1
end default uwfocal

# Further system initialization

begin default lcmod
os8 SUBMIT SYS:LCSYS.BI
# os8 SUBMIT SYS:LCBAS.BI
end default lcmod

# INIT message setting stuff goes here
# Implement the config option to enable/disable INIT
# By default we enable it.
# We may be building from distribution media with INIT enabled.
# So always SET SYS NO INIT
# and undo it by default, to be overridden if --disable-os8-init is set.
# Only copy init.cm and init.tx if init is enabled.

os8 SET SYS NO INIT
begin default init
cpto $os8mi/init.cm
# Location of init.tx is funky so that test-os8-run will be able to
# sanitize it.
cpto $build/media/os8/uni-init.tx DSK:INIT.TX
os8 SET SYS INIT
end default init

# Squish of SYS and DSK goes here
os8 SQUISH DSK:/O
os8 SQUISH SYS:/O

# Build OS/8 FORTRAN IV from source
# BASED on FORGEN.BI

mount rk0 $os8mo/v3d.rk05 required scratch
copy $obj/uni-fiv-src.rk05 $os8mo/uni-fiv-obj.rk05
mount rk1 $os8mo/uni-fiv-obj.rk05 required

boot rk0

print Assemble FORTRAN IV
# Uses CCL "LOAD" command instead of running ABSLDR.

pal8 RKB1:F4.BN<RKA1:F4.PA
os8 LOAD RKB1:F4.BN
os8 SAVE RKB1 F4.SV;12200=100
os8 DEL RKB1:F4.BN

pal8 RKB1:PASS2.BN<RKA1:PASS2.PA
os8 LOAD RKB1:PASS2.BN
os8 SAVE RKB1 PASS2.SV;5000=100
os8 DEL RKB1:PASS2.BN

pal8 RKB1:PASS2O.BN<RKA1:PASS2O,PASS2.PA
os8 LOAD RKB1:PASS2O.BN
os8 SAVE RKB1 PASS2O.SV;7605=100
os8 DEL RKB1:PASS2O.BN

pal8 RKB1:PASS3.BN<RKA1:PASS3.PA
os8 LOAD RKB1:PASS3.BN
os8 SAVE RKB1 PASS3.SV;400=100
os8 DEL RKB1:PASS3.BN

pal8 RKB1:LOAD.BN<RKA1:LOAD.PA
os8 LOAD RKB1:LOAD.BN
os8 SAVE RKB1 LOAD.SV;200=100
os8 DEL RKB1:LOAD.BN

pal8 RKB1:FRTS.BN<RKA1:RTS.PA,RTL.PA/W/K
os8 LOAD RKB1:FRTS.BN
os8 SAVE RKB1 FRTS.SV;200=100
os8 DEL RKB1:FRTS.BN

pal8 RKB1:RALF.BN<RKA1:RALF.PA/W
os8 LOAD RKB1:RALF.BN
os8 SAVE RKB1 RALF.SV;200=100
os8 DEL RKB1:RALF.BN

pal8 RKB1:LIBRA.BN<RKA1:LIBRA.PA
os8 LOAD RKB1:LIBRA.BN
os8 SAVE RKB1 LIBRA.SV;200=100
os8 DEL RKB1:LIBRA.BN

os8 COPY DSK:<RKA1:FORLIB.BI

os8 ASSIGN RKA1 SRCE
os8 ASSIGN RKB1 TARG
os8 SUBMIT FORLIB.BI

enable transcript
os8 DIR RKB1:
disable transcript

# Takes an OS8 V3D binary rk05 image and applies patches.
# Bootstrapping issue: we use XXX-dist.rk05 to build the C compiler.
# So we install it in this phase.

copy $os8mo/uni-dist.rk05 $os8mo/uni.rk05
mount rk0 $os8mo/uni.rk05 required

boot rk0

# Perform patching here.

# Ian Schofield's CC8 compiler
# Don't install this in v3d-dist because we need
# v3d packs to build it.
begin default cc8
umount dt1
mount dt1 $os8mo/cc8.tu56 ro required
os8 COPY RKA0:<DTA1:*.SV
os8 COPY RKB0:<DTA1:*.SV/V
end default cc8

# Comments begin with an octothorpe
# Blank lines are ignored.

# OS/8 Writes on the system device (architectural flaw).
# Since this might be run from a parallel make, we mount the system
# with the scratch option to make a unique copy.
mount rk0 $os8mo/v3d.rk05 required scratch
copy $obj/uni-sys-src.rk05 $os8mo/uni-sys-obj.rk05
mount rk1 $os8mo/uni-sys-obj.rk05 required

boot rk0

print Building BUILD.SV
pal8 RKB1:BUILD.BN<RKA1:BUILD.PA

begin cdprog SYS:ABSLDR.SV
RKB1:BUILD.BN
end cdprog SYS:ABSLDR.SV

os8 SAVE RKB1:BUILD.SV

print Assembling OS8.BN and CD.BN
pal8 RKB1:OS8.BN<RKA1:OS8.PA
pal8 RKB1:CD.BN<RKA1:CD.PA

print Assembling handlers

print Character oriented handlers
pal8 RKB1:ASR33.BN<RKA1:ASR33.PA
pal8 RKB1:BAT.BN<RKA1:BAT.PA
pal8 RKB1:CR8E.BN<RKA1:CR8E.PA
pal8 RKB1:VR12.BN<RKA1:VR12.PA
pal8 RKB1:VT50.BN<RKA1:VT50.PA
pal8 RKB1:KL8E.BN<RKA1:KL8E.PA
pal8 RKB1:L645.BN<RKA1:L645.PA
pal8 RKB1:LPSV.BN<RKA1:LPSV.PA
pal8 RKB1:LQP.BN<RKA1:LQP.PA
pal8 RKB1:LSPT.BN<RKA1:LSPT.PA
pal8 RKB1:PT8E.BN<RKA1:PT8E.PA

print Tape handlers
pal8 RKB1:CS.BN<RKA1:CS.PA
pal8 RKB1:LINCNS.BN<RKA1:LINCNS.PA
pal8 RKB1:LINCSY.BN<RKA1:LINCSY.PA
pal8 RKB1:TC08NS.BN<RKA1:TC08NS.PA
pal8 RKB1:TC08SY.BN<RKA1:TC08SY.PA
pal8 RKB1:TD8EA.BN<RKA1:TD8EA.PA
pal8 RKB1:TD8EB.BN<RKA1:TD8EB.PA
pal8 RKB1:TD8EC.BN<RKA1:TD8EC.PA
pal8 RKB1:TD8ED.BN<RKA1:TD8ED.PA
pal8 RKB1:TD8ESY.BN<RKA1:TD8ESY.PA
pal8 RKB1:TM8E.BN<RKA1:TM8E.PA

print Disk handlers
pal8 RKB1:DF32NS.BN<RKA1:DF32NS.PA
pal8 RKB1:DF32SY.BN<RKA1:DF32SY.PA
pal8 RKB1:RF08NS.BN<RKA1:RF08NS.PA
pal8 RKB1:RF08SY.BN<RKA1:RF08SY.PA
pal8 RKB1:RK08NS.BN<RKA1:RK08NS.PA
pal8 RKB1:RK08SY.BN<RKA1:RK08SY.PA
pal8 RKB1:RK8ENS.BN<RKA1:RK8ENS.PA
pal8 RKB1:RK8ESY.BN<RKA1:RK8ESY.PA
pal8 RKB1:RL0.BN<RKA1:RL0.PA
pal8 RKB1:RL1.BN<RKA1:RL1.PA
pal8 RKB1:RL2.BN<RKA1:RL2.PA
pal8 RKB1:RL3.BN<RKA1:RL3.PA
pal8 RKB1:RLC.BN<RKA1:RLC.PA
pal8 RKB1:RLSY.BN<RKA1:RLSY.PA
pal8 RKB1:ROMMSY.BN<RKA1:ROMMSY.PA
pal8 RKB1:RX78C.BN<RKA1:RX78C.PA
pal8 RKB1:RXNS.BN<RKA1:RXNS.PA
pal8 RKB1:RXSY1.BN<RKA1:RXSY1.PA
pal8 RKB1:RXSY2.BN<RKA1:RXSY2.PA

print Other handlers
pal8 RKB1:DUMP.BN<RKA1:DUMP.PA
pal8 RKB1:VXNS.BN<RKA1:VXNS.PA
pal8 RKB1:VXSY.BN<RKA1:VXSY.PA

print Building BATCH.SV
pal8 RKB1:BATCH.BN<RKA1:BATCH.PA
begin cdprog SYS:ABSLDR.SV
RKB1:BATCH.BN
end cdprog SYS:ABSLDR.SV
os8 SAVE RKB1:BATCH.SV

print Running BATCH job to build CCL.SV and RESORC.SV
os8 ASSIGN RKA1 IN
os8 ASSIGN RKB1 OUT
os8 COPY DSK:<RKA1:RESORC.BI
os8 COPY DSK:<RKA1:CCL.BI
os8 SUBMIT CCL.BI

PiDP-8/I @VERSION@ - OS/8 V3D Combined Kit - KBM V3T - CCL V3A
Built from source by @BUILDUSER@ on @BUILDTS@

Restart address = 07600

Type:
    .DIR                -  to get a list of files on DSK:
    .DIR SYS:           -  to get a list of files on SYS:
    .R PROGNAME         -  to run a system program
    .HELP FILENAME      -  to type a help file

/1.1 OS8 BINARY MAP (BITMAP) V4
/
/
/
/
/
/
/
/
/
/COPYRIGHT  (C)  1972,1973,1974,1975 BY DIGITAL EQUIPMENT CORPORATION
/
/
/
/
/
/
/
/
/
/
/THE INFORMATION IN THIS DOCUMENT 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 ANY ERRORS THAT MAY APPEAR IN THIS DOCUMENT.
/
/THE SOFTWARE DESCRIBED IN THIS DOCUMENT IS FURNISHED TO THE PURCHASER
/UNDER A LICENSE FOR USE ON A SINGLE COMPUTER SYSTEM AND CAN BE COPIED
/(WITH INCLUSION OF DIGITAL'S COPYRIGHT NOTICE) ONLY FOR USE IN SUCH
/SYSTEM, EXCEPT AS MAY OTHERWISE BE PROVIDED IN WRITING BY DIGITAL.
/
/DIGITAL EQUIPMENT CORPORATION ASSUMES NO RESPONSIBILITY FOR THE USE
/OR RELIABILITY OF ITS SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY
/DIGITAL.
/
/
/
/
/
/
/
/
/
/
/NO CHANGES MADE FOR OS/8 V3C

	VERSION=	4
	SUBVER=		01	/LOCATED AT "VERLOC" AS 60+VERSION^100+SUBVER

XR=	10
LOADXR=	11
XFIELD=	20	/HOLDS FIELD WE ARE "STORING" INTO
ORIGIN=	21	/HOLDS CURRENT ORIGIN
OUT=	22
B1=	23
B3=	24
C1=	25
COLCTR=	27
WD=	30
WD1=	31
WD2=	32
FILPTR=	33
FLDNO=	35

/OS/8 EQUIVALENCES

MPARAM=	7643
JSBITS=	7746
MIFILE=	7617
PTP=	20
DCB=	7760

/BUFFER AND DEVICE HANDLER ASSIGNMENTS

OUCTL=	4200
OUBUF=	6000
OUDEVH=	6400
	FIELD 1
	*2000

BITMAP,	JMP CALLCD
	JMP NOCD	/CHAINED ENTRY POINT
NEXTCD,	TAD I	(MPARAM-1
	SPA CLA
	JMP I	(BUILD	/ALTMODE TERMINATES INPUT, STARTS OUTPUT
CALLCD,	JMS I (200
	5		/COMMAND DECODE
	0216		/DEFAULT EXTENSION IS .BN
NOCD,	TAD	(LDRPCH
	DCA	OUT
	ISZ	ONCE
	JMP	CDCOOL
	CLA CLL CMA RTL
	CDF 0
	AND I	(JSBITS	/REMOVE "DON'T CARE ABOUT CD AREA" BIT
	DCA I	(JSBITS
	CDF 10
	JMS I	(CTINIT
CDCOOL,	TAD I (MPARAM+1
	AND (100
	SZA CLA		/IS /R SWITCH ON?
	JMS I (CTINIT	/YES - RE-INITIALIZE LOADER TABLES
LD7400,	7400
	TAD (MIFILE
	DCA FILPTR
	JMP I	(NEWFIL
ONCE,	-1
/SUBROUTINE TO "LOAD" A WORD.
/INCREMENTS TWO-BIT QUANTITY CORRESPONDING TO THE WORD.
/FIELD 0 IS MAPPED INTO WORDS 00000-01377,FIELD 1 INTO 01400-02777
/FIELDS 4-7 ARE MAPPED INTO 20000-25777

LOADWD,	0		/ENTER WITH LOW 4 BITS OF ORIGIN IN AC
	CLL RAL
	TAD	(BITTBL-1
	DCA	LOADXR
	TAD I	LOADXR	/GET WORD IN THE 3-WORD SET
	DCA	LDOFST	/(WHICH MAPS 16 WORDS)
	TAD I	LOADXR	/GET THE LOW ORDER BIT OF THE PAIR
	DCA	LDBIT	/WHICH MAPS THIS WORD
	TAD	ORIGIN	/NOW FIND OUT WHICH TRIPLEWORD TO USE
	RTL
	RTL
	AND	(7407
	TAD	XFIELD
	RTL
	RTL
	CDF 0
	RTL
	RAL
	SZL
CDF20Y,	CDF 20		/NOP'ED IF NO FIELD 2 IN MACHINE
	CLL RTR		/FIELDS 4-7 MAPPED IN FIELD 2
	DCA	LTEMP
	TAD	LTEMP
	CLL RAL
	TAD	LTEMP
	TAD	LDOFST
	DCA	LTEMP
	TAD	LDBIT
	CLL RAL
	TAD	LDBIT
	AND I	LTEMP
	SNA CLA		/IF COUNT IS AT 3 (MAX),
	JMP I	LOADWD	/DON'T INCREMENT IT
	TAD	LDBIT
	CIA
	TAD I	LTEMP
	DCA I	LTEMP
	RDF
	CDF 10
	SZA CLA
	DCA I	(F4FLAG	/SEARCH FIELD 2 IF WE STORED THERE
	JMP I	LOADWD
LDOFST,	0
LDBIT,	0
LTEMP,	0
/BIT TABLE FOR MAPPING

BITTBL,	0;2000;0;400;0;100;0;20;0;4;0;1
	1;2000;1;400;1;100;1;20;1;4;1;1
	2;2000;2;400;2;100;2;20;2;4;2;1
	PAGE
NEWFIL,	TAD (7001
	DCA HANDLR
	TAD I FILPTR
	AND (7760
	SZA		/LENGTH OF 256 BLOCKS IMPLIES AT LEAST 256
	TAD (17
	CLL CML RTR
	RTR
	DCA RCDCNT
	TAD I FILPTR
	ISZ FILPTR
	SNA
	JMP I	(NEXTCD	/FILE POINTER = 0 MEANS NO MORE INPUT FILES
	JMS I (200
	1		/ASSIGN
HANDLR,	7001		/LOAD INTO 7000 IF NOT ALREADY LOADED
	JMP I (IOERR
	TAD I FILPTR
	DCA RECNO
	ISZ FILPTR
	CLA CMA
	DCA CHCNT
	DCA REOF
	TAD I (MPARAM	/TEST FOR /I
	AND (10
	SNA CLA
	JMP I (LOADER	/I IS NOT ON
	JMP I (OERR	/NO!
GETCH,	0		/GET-NEXT-INPUT-CHARACTER ROUTINE
	JMS I	(CTCTST
	ISZ JMPGET
	ISZ CHCNT
JMPX,	JMP JMPGET
	TAD REOF
	SZA CLA
	JMP I GETCH	/EOF REACHED BEFORE LOGICAL END - ERROR
	CLL
	TAD	RCDCNT
	TAD	(6
	SNL
	DCA	RCDCNT
	SZL
	ISZ	REOF
	CLL CMA CML RTR
	RTR
	RTR
	TAD	(1411
	DCA	RCTL
	CIF 0
	JMS I HANDLR
RCTL,	0		/READ RECORDS INTO FIELD 1
PBUFFR,	BUFFER
RECNO,	0
	JMP RERROR
	TAD	RECNO
	TAD	(6
	DCA	RECNO
	TAD	(-4401
	DCA CHCNT
	TAD PBUFFR
	DCA CHPTR
	TAD JMPX
	DCA JMPGET
	JMP GETCH+1
JMPGET,	JMP .
	JMP CHAR1
	JMP CHAR2
	TAD JMPX
	DCA JMPGET
	TAD I CHPTR
	AND (7400
	CLL RTR
	RTR
	TAD CHTMP
	RTR
	RTR
	ISZ CHPTR
	JMP GCHCOM
CHAR2,	TAD I CHPTR
	AND (7400
	DCA CHTMP
	ISZ CHPTR
CHAR1,	TAD I CHPTR
GCHCOM,	AND (377
	ISZ GETCH
	JMP I GETCH
RERROR,	SPA CLA
	JMP I (IOERR	/AN ACTUAL READ ERROR - AMAZING!
	ISZ REOF
	JMP RECNO+2
REOF,	0
CHCNT,	0
CHPTR,	0
CHTMP,	0
RCDCNT,	0
ZTST,	0		/TEST A BLOCK OF THE BITMAP FOR ALL ONES
	DCA	B3	/LENGTH OF THE BLOCK IN AC
	TAD	LOADXR
	DCA	XR
	STA
	JMS I	(XCDF
	AND I	XR
	ISZ	B3
	JMP	.-2
	CDF 10
	CMA
	SZA
	JMP I	ZTST
	TAD	XR
	DCA	LOADXR	/UPDATE LOADXR IF ALL ZEROES
	JMP I	ZTST
	PAGE
ITSOVR,	JMS ASSEMB	/GET THE CHECKSUM
	CIA
	TAD LCKSUM
	SZA CLA		/IS IT GOOD?
	JMP I (BADCKS	/NO
	TAD I (MPARAM+1
	AND L40
	SNA CLA		/IF /S IS NOT SET,
	JMP I (NEWFIL	/ONLY ONE PROGRAM PER FILE.
LOADER,	DCA LCKSUM
	JMS GETFLD
	DCA XFIELD
	TAD (200
	DCA ORIGIN	/INITIALIZE FOR PROGRAM
	JMS I (GETCH
	JMP I (NEWFIL
	SNA
	JMP .-3
	TAD (-200	/FIND SOME LEADER
	SZA CLA
	JMP LOADER+1
LEADER,	JMS I (GETCH
	JMP I (NEWFIL
	SNA
	JMP LOADER+1
	TAD (-200	/FIND END OF LEADER
	SNA
	JMP LEADER
NEWWD,	SMA		/FIELD SETTING?
	JMP FIELDW	/YES
	TAD (200
	DCA WD1		/STORE 1ST CHAR
	JMS I (GETCH
	JMP I (BADINP
	DCA WD2		/2D CHAR
	JMS I (GETCH
	JMP I (BADINP
	TAD (-200	/IF THIS IS LEADER, WE HAVE THE CHECKSUM
	SNA
	JMP ITSOVR
	DCA WD
	JMS ASSEMB
	SNL		/ORIGIN OR DATA?
	JMP DATAWD	/DATA
	DCA ORIGIN
	JMP GETNXT
DATAWD,	CLA
	TAD	ORIGIN
	AND	(17
	JMS I (LOADWD	/GO SET THE CORRECT BIT(S)
	CDF 10
	ISZ ORIGIN
L40,	40
GETNXT,	TAD WD1
	TAD WD2
	TAD LCKSUM
	DCA LCKSUM
	TAD WD
	JMP NEWWD

ASSEMB,	0
	TAD WD1
	CLL RTL
	RTL
	RTL
	TAD WD2
	JMP I ASSEMB

FIELDW,	TAD (-32
	SNA
	JMP CTLZ
	TAD (-46
	SPA
	JMP NOTXP
	DCA WD1
	TAD WD1
	AND (7
	SZA CLA
	JMP NOTXP
	TAD WD1
	AND (70
	DCA XFIELD
	JMS I (GETCH
	JMP I (BADINP
	TAD (-200
	SZA
	JMP NEWWD
NOTXP,	CLA
	TAD LCKSUM
	SNA CLA
	JMP LOADER
	JMP I (BADINP
LCKSUM,	0

CTLZ,	TAD LCKSUM
	SZA CLA
	JMP I (BADINP
	JMP I (NEWFIL
GETFLD,	0		/ROUTINE TO CHECK FOR OPTION 0-7
	DCA C1		/AND RETURN LOWEST-NUMBERED VALUE
	TAD I (MPARAM+2
	AND (1774
	SNA
	JMP I GETFLD
	RTL
	RAL
	ISZ C1
	SNL
	JMP .-3
	CLA CMA
	TAD C1
	CLL RTL
	RAL
	JMP I GETFLD
	PAGE
ERPCH,	0
	AND (77		/GET LOW ORDER 6 BITS
	SZA
	JMP NZCHAR
	JMS ERR
FILMSG,	TEXT	/, FILE 0/
	JMP I	(BITMAP
NZCHAR,	TAD	(240
	AND	(77
	TAD	(240
	JMS I	OUT	/PRINT
	JMP I ERPCH	/AND RETURN

LDRPCH,	0
	TLS
	TSF
	JMP .-1
	CLA
	JMP I LDRPCH

ERR,	0
	CLA
	CDF 10
	TAD I (FILPTR	/ZERO CHAR GETS REPLACED BY "FILE #"
	TAD (322	/MAGIC NUMBER
	CLL CML RAR	/AC NOW CONTAINS " #"
	DCA FILMSG+3
ERRLUP,	TAD I ERR
	SNA
	JMP EOMESG	/MESSAGE MUST BE EVEN NUMBER OF CHARS LONG
	RTR
	RTR
	RTR
	JMS ERPCH
	TAD I ERR
	JMS ERPCH
	ISZ ERR
	JMP ERRLUP
EOMESG,	JMS I	(ECRLF
	JMP I	ERR	/RETURN
IOERR,	JMS ERR
	TEXT	%I/O ERROR%
	JMP I	(BITMAP
BADINP,	JMS ERR
	TEXT	/BAD INPUT/
	JMP I	(BITMAP
BADCKS,	JMS ERR
	TEXT	/ BAD CHECKSUM/
	JMP I	(BITMAP
NULERR,	JMS ERR
	TEXT	/NO INPUT/
	JMP I	(BITMAP
OUTERR,	TAD	(LDRPCH
	DCA	OUT
	JMS ERR
	TEXT	/ERROR ON OUTPUT DEVICE/
	JMP I	(CALLCD
OERR,	JMS ERR
	TEXT %NO /I!%
	JMP I	(BITMAP
CTINIT,	0
	CLA CLL CML RTR
	DCA	C1
	DCA	B1
	DCA	0	/STRAIGHT-8 CROCK
CTINLP,	CDF 0
	CLA CMA
	DCA I B1
CDF20X,	CDF 20
	STA
	DCA I	B1
	JMP	CTFLD2	/*** THIS INSTR SKIPPED IF 8K PDP-8!!!
	DCA	CDF20X	/DUE TO BUG IN EXTENDED MEMORY CONTROLLER
	TAD	ERR+1	/A CLA
	CDF 10
	DCA I	(CDF20Y
CTFLD2,	ISZ	B1
	ISZ C1
	JMP CTINLP
	CDF 10
	JMP I CTINIT
	PAGE
/GENERAL OUTPUT ROUTINES

	/JMS I (OOPEN		INITIALIZES THE OUTPUT ROUTINE
	/ERROR RETURN		AC>0 IF NO OUTPUT DEVICE/FILE, AC<0 IF ERROR

	/JMS I (OCHAR		OUTPUTS A CHARACTER
	/ERROR RETURN		OUTPUT ERROR OR TOO MUCH OUTPUT

	/JMS I (OCLOSE		CLOSES THE OUTPUT FILE
	/ERROR RETURN		FILE TOO LARGE TO BE CLOSED OR OUTPUT ERROR

	/JMS I (OTYPE		RETURNS DCB WORD OF OUTPUT DEVICE IN AC



	/PARAMETERS NEEDED:

	/OUBUF=		ADDRESS OF OUTPUT BUFFER
	/OUCTL=		OUTPUT BUFFER CONTROL WORD (MUST BE NEGATIVE)
	/OUDEVH=	ADDRESS OF PAGE FOR OUTPUT HANDLER

	/ASSUMES I/O MONITOR IS RESIDENT IN CORE.
	/CAN BE CALLED FROM ANY FIELD WITH BUFFERS IN ANY FIELD.

OUFLD=	OUCTL&70
OOPEN,	0
OU7600,	7600
	TAD OU7601
	DCA OUBLK
	TAD (OUDEVH+1
	DCA OUHNDL
	CDF 10
	TAD I	(7604
	SNA		/IF OUTPUT HAS NO EXTENSION,
	TAD	(1520	/GIVE IT THE EXTENSION .MP
	DCA I	(7604
OUASGN,	TAD I OU7600		/GET DEVICE NUMBER WORD OF OUTPUT FILE ENTRY
	AND (17			/STRIP OFF ANY LENGTH INFO
	SNA			/IS THERE AN OUTPUT DEVICE?
	JMP USETTY		/NO - INHIBIT OUTPUT
	JMS I (200
	1			/ASSIGN, FETCH HANDLER
OUHNDL,	0			/OUTPUT DEVICE HANDLER ENTRY
	HLT			/HUH?
OUENTR,	TAD I OU7600
	JMS I (200
	3			/ENTER OUTPUT FILE
OUBLK,	7601			/REPLACED WITH STARTING BLOCK
OUELEN,	0			/REPLACED WITH LENGTH OF HOLE
	JMP OEFAIL		/FAILED - MAYBE WE ASKED TOO MUCH
	DCA OUCCNT
	JMS I (OUSETP
	CDF CIF 10		/RESTORE CALLING FIELDS
	JMP I OOPEN
OEFAIL,	TAD I OU7600
	AND (7760		/GET REQUESTED LENGTH
	SNA CLA			/WAS IT AN INDEFINITE REQUEST
	JMP I	(OUTERR		/YES - CANNOT ENTER THE FILE
	TAD I OU7600
	AND (17			/MAKE THE REQUESTED LENGTH ZERO
	DCA I OU7600
	JMP OUENTR		/TRY, TRY AGAIN
USETTY,	DCA	TTYNO
	JMS I	(200
	12
	5524
TTYNO,	0
	0
	HLT	/NO TELETYPE!
	TAD	TTYNO
	DCA I	OU7600
	JMP	OUASGN
OUTDMP,	0
	DCA OUCTLW		/STORE THE CONTROL WORD
	CDF 10
	TAD OUCCNT
	SNA
	ISZ OUCTLW
	TAD OUBLK
	DCA OUREC		/COMPUTE THE STARTING BLOCK NUMBER OF THIS TRANSFER
	TAD OUCTLW
	CLL RTL
	RTL
	RTL
	AND (17			/COMPUTE THE NUMBER OF RECORDS
	TAD OUCCNT		/UPDATE THE NUMBER OF BLOCKS IN THE FILE
	DCA OUCCNT
	TAD OUCCNT
	CLL CML
	TAD OUELEN
	SNL SZA CLA		/DOES THE LENGTH EXCEED THE GIVEN LENGTH?
	JMP I (OUTERR		/YES - SIGNAL OUTPUT ERROR
	CIF 0
	JMS I OUHNDL
OUCTLW,	0
	OUBUF
OUREC,	0
	JMP I	(OUTERR
	JMP I OUTDMP
OCLOSE,	0
	CDF 10
	JMS I (OTYPE
	AND (770
	TAD (-PTP		/CHECK FOR PAPER TAPE PUNCH OUTPUT
	SZA CLA			/AND SKIP ^Z OUTPUT IF TRUE
	TAD (232		/OUTPUT A ^Z
	JMS I (OCHAR
	JMS I (OCHAR
FILLLP,	JMS I (OCHAR
	JMS I (OTYPE		/GET TYPE OF OUTPUT DEVICE
	SPA CLA
	TAD (100		/IF ITS A DIRECTORY DEVICE FORCE A RECORD
	TAD (77			/BOUNDARY - OTHERWISE A HALF-RECORD
	AND I (OUDWCT
	SZA CLA			/UP TO THE BOUNDARY YET?
	JMP FILLLP		/NO - FILL WITH ZEROS
	TAD I (OUDWCT		/GET DOUBLEWORD COUNT LEFT
	TAD (OUCTL&3700
	SNA			/A FULL WRITE LEFT?
	JMP NODUMP		/YES - DON'T DO IT - THE ^Z IS ALREADY OUT
	TAD (4000+OUFLD		/PUT IN THE FIELD BITS AND THE WRITE BIT
	JMS OUTDMP
NODUMP,	TAD I OU7600		/GET THE DEVICE NUMBER
	JMS I (200
	4			/CLOSE THE OUTPUT FILE
OU7601,	7601			/POINTER TO THE OUTPUT FILE NAME
OUCCNT,	0
	JMP I	(OUTERR
	CDF CIF 10		/RESTORE CALLING FIELDS
	JMP I OCLOSE
	PAGE
OUCTMP=	OUCTL&3700
OUSETP,	0			/ROUTINE TO INITIALIZE CHARACTER POINTERS
	TAD (-OUCTMP		/GET SIZE OF BUFFER IN DOUBLEWORDS
	DCA OUDWCT
	TAD (OUBUF
	DCA OUPTR		/INITIALIZE WORD POINTER
	TAD OUJMPE
	DCA OUJMP		/INITIALIZE THREE-WAY CHARACTER SWITCH
	JMP I OUSETP

OCHAR,	0
	AND (377
	DCA OUTEMP
	RDF
	TAD CDIF0
	DCA OUCRET
	CDF OUFLD		/SET DATA FIELD TO BUFFER'S FIELD
	ISZ OUJMP		/BUMP THE CHARACTER SWITCH
OUJMP,	HLT			/THREE WAY CHARACTER SWITCH
	JMP OCHAR1
	JMP OCHAR2
OCHAR3,	TAD OUTEMP
	CLL RTL
	RTL
	AND (7400
	TAD I OUPOLD
	DCA I OUPOLD		/UPDATE FIRST WORD OF TWO WITH HIGH
	TAD	OUTEMP		/ORDER 4 BITS OF THIRD CHAR
	CLL RTR
	RTR
	RAR
	AND (7400
	TAD I OUPTR
	DCA I OUPTR		/UPDATE SECOND WORD FROM LOW ORDER 4 BITS
	TAD OUJMPE
	DCA OUJMP		/RESET SWITCH
	ISZ OUPTR
	ISZ OUDWCT		/BUMP DOUBLEWORD COUNTER EVERY 3 CHARS
	JMP OUCRET
	TAD (OUCTL		/LOAD CONTROL WORD FOR A FULL WRITE
	JMS I (OUTDMP		/DUMP THE BUFFER
	JMS OUSETP		/RE-INITIALIZE THE POINTERS
	JMP OUCRET
OCHAR2,	TAD OUPTR
	DCA OUPOLD		/SAVE POINTER TO FIRST WORD OF TWO
	ISZ OUPTR		/BUMP WORD POINTER TO SECOND WORD
OCHAR1,	TAD OUTEMP
	DCA I OUPTR
OUCRET,	HLT			/RESTORE CALLING FIELDS
	JMP I OCHAR
OUTEMP,	0
OUPOLD,	0
OUPTR,	0
OUJMPE,	JMP OUJMP
OUDWCT,	0
OTYPE,	0
	RDF
	TAD CDIF0
	DCA OTRTN
	CDF 10
	TAD I (7600
	AND (17
	TAD (DCB-1
	DCA OUTEMP
	TAD I OUTEMP
OTRTN,	HLT
	JMP I OTYPE

DOBITS,	0
	DCA	B3
	JMS I	(XCDF
	TAD I	LOADXR
	CDF 10
	DCA	B1
BITLP,	TAD	B1
	CLL RTL
	DCA	B1
	TAD	B1
	CMA CML RAL
	AND	(3
	TAD	(260
	JMS I OUT
	ISZ COLCTR
	TAD	COLCTR
	AND	(7
	SZA CLA
	JMP BITISZ
	TAD I	(TTOFLG
	SNA CLA		/IF OUTPUT IS NOT TO TTY,
	TAD (240	/PUT A SPACE AFTER EVERY GROUP OF 8
	SZA 
	JMS I OUT
BITISZ,	ISZ	B3
	JMP	BITLP
	JMP I	DOBITS
CTCTST,	0
	TAD	(200
	KRS
	TAD (-203
	SNA CLA			/IS THE TELETYPE BUFFER A ^C
	KSF			/WITH THE TELETYPE FLAG ON?
	JMP I CTCTST			/NO
CDIF0,	CDF CIF 0		/YES - GO TO MONITOR
	JMP I (7605		/THROUGH THE "DON'T SAVE CORE" RETURN

	PAGE
BUILD,	STA
	DCA	SOMTHN
	TAD	(-10
	DCA	FLDNO
	TAD	MAPSKP
	DCA	F4SKP	/INITIALIZE ONCE-ONLY SKIP
FLDLP,	TAD	FLDNO
	AND	(4
	CLL RTL
	TAD	(CDF
	DCA	CDFX	/STORE A CDF 0 OR CDF 20
	TAD	FLDNO
	RTR
	SZL SPA CLA	/IF FLDNO IS 0 OR 4,
	JMP	NOT04	/INITIALIZE LOADXR TO 0
F4SKP,	SKP
F4FLAG,	JMP	MAPOVR	/ZEROED IF INFO IN FIELD 2
	DCA	F4SKP
	STA
	DCA	LOADXR
NOT04,	TAD	(-1400
	JMS I	(ZTST
	SZA CLA		/FIELD EMPTY?
	JMP	NONEMP	/NO
FLDISZ,	ISZ	FLDNO
	JMP	FLDLP
MAPOVR,	ISZ	SOMTHN	/WAS THERE ANY INPUT?
MAPSKP,	SKP
	JMP I	(NULERR
	JMS I	(ECRLF
	JMS I	(ECRLF
	JMS I	(OCLOSE
	CDF CIF 0
	JMP I	(7605

NONEMP,	ISZ	SOMTHN	/HAVE WE OUTPUT ANYTHING YET?
	JMP	NOTFST
	JMS I	(OOPEN	/NO - OPEN OUTPUT FILE NOW
	JMS I	(OTYPE
	SNA CLA		/SET MODE OF OUTPUT - /T INVERTS
	TAD	(20	/NORMAL TTY/NO TYY DISTINCTION
	TAD I	(MPARAM+1
	AND	(20
	DCA I	(TTOFLG
	TAD	(OCHAR
	DCA	OUT
NOTFST,	JMS I	(EJECT1	/PAGE HEADING
	TAD	(-100
	DCA	PAGECT
PAGELP,	TAD	FLDNO
	TAD	(270
	JMS I	OUT
	TAD	PAGECT
	AND	(70
	CLL RTR
	RAR
	TAD	(260	/OUTPUT LOC (HIGH 3 DIGITS) AT LEFT MARGIN
	JMS I	OUT
	TAD	PAGECT
	AND	(7
	TAD	(260
	JMS I	OUT
	TAD	(260
	JMS I	OUT
	TAD	(260
	JMS I	OUT
	TAD	(240
	JMS I	OUT
	DCA	COLCTR
	TAD	(-14
	JMS I	(ZTST	/IF ALL 64 WORDS ARE ZERO,
	SNA CLA
	JMP NO1ND0	/DON'T PRINT LINE
	TAD	(-4
	DCA	SOMTHN
DOBTLP,	TAD	(-6
	JMS I	(DOBITS	/OUTPUT 4 TRIPLEWORDS FOR 64 LOCATIONS
	TAD	(-6
	JMS I	(DOBITS
	TAD	(-4
	JMS I	(DOBITS
	ISZ	SOMTHN
	JMP	DOBTLP
NO1ND0,	JMS I	(ECRLF
	CLA IAC
	AND	PAGECT
	SZA CLA
	JMS I	(ECRLF	/SKIP A LINE EVERY PDP-8 PAGE
	TAD	PAGECT
	TAD	(41
	SNA CLA
	JMS I	(EJECT1	/NEW PAGE AT LOCATION 4000
	ISZ	PAGECT
	JMP	PAGELP
	JMP	FLDISZ
PAGECT,	0
SOMTHN,	0

XCDF,	0
CDFX,	HLT
	JMP I	XCDF
	PAGE
EJECT1,	0
	TAD	FLDNO
	TAD	(4070
	DCA	FLDNUM
	TAD	TTOFLG
	SZA CLA		/TELETYPE STYLE OUTPUT?
	JMP	EJKTTY	/YES
	TAD	(214	/NO - FORM FEED
	JMS I	OUT
PRTFLD,	JMS I	(ERR
	TEXT	/ BITMAP  V/
	*.-1
VERLOC,	60+VERSION^100+SUBVER	/V5A, ETC...
	TEXT	/   FIELD/
	*.-1
FLDNUM,	TEXT	/ 0/
	JMS	ECRLF
	TAD	TTOFLG
	SNA CLA		/IF NOT TTY OUTPUT,
	JMP EJKLPT	/DON'T PRINT HORIZONTAL GUIDE

	JMS I	(ERR
	TEXT	/      0000000011111111222222223333333344444444555555556666666677777777/
	JMS I	(ERR
	TEXT	/      0123456701234567012345670123456701234567012345670123456701234567/
EJKLPT,	JMS	ECRLF
	JMP I	EJECT1
EJKTTY,	TAD	(-13
	DCA	EJKTMP
	JMS	ECRLF
	ISZ	EJKTMP
	JMP	ECRLFX
	JMS I	(ERR
	TEXT	/----/
	JMS	ECRLF
	JMP	PRTFLD
EJKTMP,	0

ECRLF,	0
	TAD	(215
	JMS I	OUT
ECRLFX,	TAD	(212
	JMS I	OUT
	JMP I	ECRLF

TTOFLG,	0		/20 IF TTY-STYLE OUTPUT
	PAGE
	BUFFER=.
	$-$-$


/BOOT.PA		17
/OS/8 V3D WITH RL01,RX02 AND VXA0 DEVICES
/
/
/
/
/
/
/
/
/
/COPYRIGHT  (C)  1974,1975,1977 BY DIGITAL EQUIPMENT CORPORATION
/
/
/
/
/
/
/
/
/
/
/THE INFORMATION IN THIS DOCUMENT 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 ANY ERRORS THAT MAY APPEAR IN THIS DOCUMENT.
/
/THE SOFTWARE DESCRIBED IN THIS DOCUMENT IS FURNISHED TO THE PURCHASER
/UNDER A LICENSE FOR USE ON A SINGLE COMPUTER SYSTEM AND CAN BE COPIED
/(WITH INCLUSION OF DIGITAL'S COPYRIGHT NOTICE) ONLY FOR USE IN SUCH
/SYSTEM, EXCEPT AS MAY OTHERWISE BE PROVIDED IN WRITING BY DIGITAL.
/
/DIGITAL EQUIPMENT CORPORATION ASSUMES NO RESPONSIBILITY FOR THE USE
/OR RELIABILITY OF ITS SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY
/DIGITAL.
/
/
/
/
/
/
/
/
/
/
	/SR

/FIXES MADE FOR MAINTENANCE RELEASE:

/1.	ADDED RX01 (FLOPPY BOOTSTRAP)
/2.	LEFT PATCH SPACE IN NAME TABLE

/	26-DEC-77

/1.	ADDED RL BOOTSTRAP (S.R.)


	*1
	HLT
	JMP I (7600
	*100

INNER,	0
OUTR,	-20
CODE,	0
LENGTH,	0
	*200

START,	CLA		/ALLOW BEING CHAINED TO
	TAD I (7600
	SPA CLA
	JMP OS8IN
	ISZ INNER
	JMP .-1
	ISZ OUTR
	JMP .-3
	JMS I (TESTRK
COSIN,	TAD I (7776
COMN,	CIA
	DCA CODE
	TAD (TABLE
	DCA PTR
LOOP,	TAD I PTR
	SNA
	JMP I (OS8
	TAD CODE
	SZA CLA
	JMP NXT
	IOF
	ISZ PTR
	TAD I PTR
	DCA OLDLOC
	ISZ PTR
	TAD I PTR
	DCA NEWLOC
	ISZ PTR
	TAD I PTR
	CIA
	DCA LENGTH
XXLUP,	TAD I OLDLOC
	DCA I NEWLOC
	ISZ OLDLOC
	ISZ NEWLOC
	ISZ LENGTH
	JMP XXLUP
	ISZ PTR
	TAD I PTR
	DCA TEMP
	TAD HLTSWT
	SNA CLA
	HLT
	CLL
	JMP I TEMP
HLTSWT,	1

NXT,	TAD PTR
	TAD (5
	DCA PTR
	JMP LOOP

OLDLOC,	0
NEWLOC,	0
PTR,	0
SCAN,	0
OS8IN,	TAD I (7600
	TAD (-4207
	SZA CLA
	JMP I (RETRY
	TAD I (1000
	TAD (777
	SNA CLA
	TAD (600
	TAD (1000-1
	DCA SCAN
SKAN,	ISZ SCAN
	TAD I SCAN
	SNA
	JMP I (RETRY
	AND (177
	TAD (-"/!7600
	SZA CLA
	JMP SKAN
	ISZ SCAN
	TAD I SCAN
	AND (77
	CLL RTL
	RTL
	RTL
	DCA TEMP
	ISZ SCAN
	TAD I SCAN
	AND (77
	TAD TEMP
	DCA TEMP
	ISZ SCAN
	TAD I SCAN
	AND (177
	TAD (-".!7600
	DCA HLTSWT
	TAD TEMP
	JMP COMN

TEMP,	0
	PAGE
TABLE,	2403	/TC
	DECTAP
	7554
	25
	7554

	2213	/RK
RKADR,	RK8
	21
	11
	21

	2404	/TD
	TD8E
	7277
	34
	7277

	1424	/LT
	LINCTP
	4400
	7
	4400

	2206	/RF
	RF08
	7746
	7
	7746

	2024	/PT
	BINLDR
	7626
	152
	7700

	3205	/ZE
	ZERO
	4
	6
	4

	2431	/TY
	TYPSET
	7730
	42
	7730

	0414	/DL
	DIAL
	4012
	6
	4012

	0301	/CA
	CAS
	4000
	40
	4000

	0415	/DM
	DSKMON
	171
	16
	174

	2605	/VE
	VERS
	VERS
	1
	VERS

	0424	/DT
	TAPE
	TAPE
	1
	TAPE

	0413	/DK
	DISK
	DISK
	1
	DISK

	2205	/RE
	RK8E
	21
	11
	21

	2523	/US
	1
	1
	1
	RETRY

	2230	/RX
	RX01
	RX8E
	42
	RXSTRT

	2214	/RL
	RL01
	1
	35
	1

	2630	/VX
	VXA0
	0
	7
	0
	ZBLOCK 3^5	/PATCH SPACE

	0

/FORMAT:

/SIXBIT OF 2-CHARACTER NAME
/ADDRESS OF BOOTSTRAP CODE IN BOOT
/ADDRESS WHERE BOOTSTRAP CODE IS TO BE MOVED TO
/LENGTH OF BOOTSTRAP IN WORDS
/STARTING ADDRESS OF BOOTSTRAP
DECTAP,	7600
	6774
	1374
	6766
	6771
	5360
	7240
	1354
	3773
	1354
	3772
	1375
	6766
	5376
	7754
	7755
	0600
	0220
	6771
	5376
RK8,	6732
	6751
	6745
	5023
	6742
	6753
	6755
	6733
	5031

RK8E,	7000
	7000
	7000
	7000
	7201
	6742
	6742
	6743
	5031
TD8E,	6007
	1312
	4312
	4312
	6773
	5303
	6777
	3726
	2326
	5303
	5732
	2000
	1300
	6774
	6771
	5315
	6776
	0331
	1327
	7640
	5315
	2321
	5712
	7354
	7756
	7747
	0077
	7400
LINCTP,	6141
	1020
	0020
	0004
	0700
	0000
	6020
RF08,	6643
	6615
	7600
	6603
	6622
	5352
	5752
/	1000 IS OS/8 LINE BUUFFER
/	1600 IS PS/8 LINE BUFFERE

	*2000

BINLDR,	0000
	3212
	4260
	1300
	7750
	5237
	2212
	7040
	5227
	1212
	7640
	5230
	1214
	0274
	1341
	7510
	2226
	7750
	5626
	1214
	0256
	1257
	3213
	5230
	0070
	6201
	0000
	0000
	6031
	5262
	6036
	3214
	1214
	5660
	6011
	5270
	6016
	5265
	0300
	4343
	7041
	1215
	7402
	6032
	6014
	6214
	1257
	3213
	7604
	7700
	1353
	1352
	3261
	4226
	5313
	3215
	1213
	3336
	1214
	3376
	4260
	3355
	4226
	5275
	4343
	7420
	5336
	3216
	1376
	1355
	1215
	5315
	0000
	3616
	2216
	7600
	5332
	0000
	1376
	7106
	7006
	7006
	1355
	5743
	5262
	0006
	0000
	0000
	6014
	6011
	5357
	6016
	7106
	7006
	7510
	5374
	7006
	6011
	5367
	6016
	7420
	3776
	3376
	5357
	0000
	5301
ZERO,	1005
	3410
	5004
	5404
	0011
	2010
DIAL,	6141
	1020
	0020
	0004
	0701
	7300
/	7300
/	6002
/	6042
/	6022
/	6012
/	6032
/	6601
/	6764
/	1221
/	3010
/	1622
/	2222
/	7450
/	5620
/	3410
/	5212
/	7730
/	7727
/	0223
TYPSET,	6774
	1347
	4341
	7240
	1353
	3355
	1352
	4341
	5753
	7777
	6766
	3354
	6771
	5344
	5741
	4600
	7777
	7777
	4220
	7400
	7777
	7777
	7777
	6014
	6011
	5360
	7106
	6012
	7420
	5357
	5756
	4356
	3373
	4356
VXA0,	7200
1206
	6200
	6207
	5605
	0000
	7000
PTCLEV,	"A
L3,	"5
LV,	"V
VERS,	TAD LV
	JMS I (PUT
	TAD L3
	JMS I (PUT
	TAD PTCLEV
	JMS I (PUT
	JMP I PRETRY
PRETRY,	RETRY
DSKMON,	7577
	7750
	7751
	1171
	3572
	1172
	3573
	6643
	6615
	6603
	6602
	5203
	5606
	7600
CAS,	1237
	1206
	6704
	6706
	6703
	5204
	7264
	6702
	7610
	3211
	3636
	1205
	6704
	6706
	6701
	5216
	7002
	7430
	1636
	7022
	3636
	7420
	2236
	2235
	5215
	7346
	7002
	3235
	5201
	7737
	3557
	7730
	LCD=6751
	SDN=6755
	SER=6754
	STR=6753
	XDR=6752

RX01,	RELOC 20
RX8E,
/  DEVICE IOT SYMBOLIC EQUATES
/
LCD=6751		/LOAD COMMAND
XDR=6752		/TRANSFER DATA
STR=6753		/SKIP IF READY TO TRANSFER
SER=6754		/SKIP ON ERROR
SDN=6755		/SKIP ON DONE
/
/
/
/
READ,	TAD	UNIT	/TRY NEXT COMBINATION OF DENSITY AND UNIT
	TAD	CON360	/ADDING IN 360
	AND	CON420	/KEEPING ONLY 420 BITS
	DCA	UNIT	/CYCLES 400,420,0,20,400,,,,,,,,
	CLL CLA CML IAC RTL /COMMAND TO READ DISK - MUST BE ON OMNIBUS!
	TAD	UNIT	/UNIT AND DENSITY
	LCD		/COMMAND TO CONTROLLER
	CLL CLA IAC	/TO SET SECTOR AND TRACK TO 1
	JMS	LOAD	/SECTOR TO CONTROLLER, LEAVES AC ALONE
	JMS	LOAD	/AND TRACK
LITRAL,	7004		/LEAVING A 2 IN AC; SERVES AS LITERAL
/
/  FOLLOWING IS PART OF WAIT LOOP, SAME SECONDARY BOOTS, OLD PRIMARY BOOT
/
RXSTRT,
XSTRT,	SDN		/HAS DONE COME UP; CODE STARTS HERE!
	JMP	LOAD+1	/NO, GO CHECK FOR READY TO TRANSFER
/
/  NOW, DONE OR ERROR
/
	SER		/SKIP ON AN ERROR, TRY ANOTHER DENSITY ETC.
	SNA		/NASTY, AC=2 FOR ABOUT TO DO SILO, 0 ON START-UP
	JMP	READ	/START-UP, GO SET UP UNIT, THEN READ TO SILO
	TAD	UNIT	/AC ALREADY 2, PUT IN UNIT, DENSITY
	LCD		/TO EMPTY THE SILO
	TAD	UNIT	/SET UP LOC 60 FOR OLD SECONDARY BOOT
	AND	CON360	/KEEPING UNLY DENSITY BIT
	TAD	LITRAL	/ADDING IN 7004, BECAUSE THAT'S WHAT SYS WANTS
	DCA	RX1SAV	/OLD SECONDARY BOOT MOVES IT TO HANDLER
CON360,	360		/LITERAL; EXECUTES IN LINE AS A NO-OP
/			/FALLS THRU TO NEXT PAGE OF LISTING
/
/
/  FOLLOWING CODE SAME AS OLD PRIMARY BOOT
/
	JMS	LOAD	/GRAB NEXT ITEM FROM SILO
	DCA	2	/TRADITION; SECONDARY BOOT STARTS LOADING AT 2 !
	ISZ	50	/INCREMENT LOAD ADDRESS
	JMP	47	/GO BACK FOR ANOTHER
/
/  SECONDARY BOOT LOADS OVER PRIMARY BOOT UNIT LOCATION 47 IS LOADED,
/  THEN CONTROL PASSES TO SECONDARY BOOT
/
LOAD,	0		/SUBROUTINE TO GIVE AND TAKE DATA FROM CONTROLLER
	STR		/IS HE READY TO TALK TO US?
	JMP XSTRT	/NO, IS HE PERHAPS DONE WITH SILO, OR IN ERROR?
	XDR		/YES, DATA IN OR OUT;IF DATA TO CONTROLLER, AC UNCHANGED
	JMP I	LOAD	/NO MAGIC, JUST EXIT FROM SUBROUTINE
/
/  60 GOES TO OLD SECONDARY BOOT
/  61 HAS DENSITY AND UNIT THAT BOOTED SUCCESSFULLY
/
/
CON420,			/USE IT TO HOLD 420 LITERAL TO START OUT
RX1SAV,	420		/UNIT^20+7004 TO GO TO SYS HANDLER
UNIT,	20		/<DENSITY^400>+<UNIT^20> THAT BOOTED OK
/

	RELOC
	PAGE
L2213,	2213
	DIML=6615
DISK,	CLA IAC
	DIML
	SNA CLA
	JMP GOTRF
	TAD (70
	6732
	SNA CLA
	JMP GOTRK8
	CLA IAC
	6744
	SZA CLA
	JMP I PRETR
	STA		/RE
GOTRF,	TAD L2206	/RF
	JMP I PCOMN
L2206,	2206
GOTRK8,	TAD L2213	/RK
	JMP I PCOMN
PRETR,	RETRY
TAPE,	6141		/LINC
	17		/COMPL AC
	2		/PDP
	IAC
	SNA CLA
	JMP GOTLTA
	TAD (70
	6774
	CLA
	6772
	NOP
	TAD M70
	SNA CLA
	JMP GOTTC
	STL CLA RAR
	6774
	CLA
	6776
	SMA CLA
	JMP I PRETR
GOTTD,	CLA IAC
GOTTC,	TAD L2403	/TC
	JMP I PCOMN
GOTLTA,	TAD L1424	/LT
	JMP I PCOMN
L1424,	1424
L2403,	2403
PCOMN,	COMN
M70,	-70
/	0000
CRLF,	0
	TAD L215
	JMS PUT
	TAD L212
	JMS PUT
	JMP I CRLF

L215,	215
L212,	212

PUT,	0
	TLS
	TSF
	JMP .-1
	CLA
	JMP I PUT

GET,	0
	KSF
	JMP .-1
	KRB
	AND (177
	TLS
	TSF
	JMP .-1
	TAD (-003
	SNA
	JMP I (7605
	TAD (003-177
	SNA
	JMP I (RETRY
	TAD (177-015
	SNA
	ISZ GET
	TAD (015
	AND (77
	JMP I GET

TESTRK,	0
	TAD (70
	6732
	SNA CLA
	JMP I TESTRK
RK05,	TAD (RK8E
	DCA I (RKADR
	JMP I TESTRK
	PAGE
OS8,	TAD ("N
	JMS I (PUT
	TAD ("O
	JMS I (PUT
	CLA IAC
	DCA I (HLTSWT
RETRY,	JMS I (CRLF
	TAD ("/
	JMS I (PUT
	JMS I (GET
	SKP
	JMP RETRY
	CLL RTL
	RTL
	RTL
	DCA I (TEMP
	JMS I (GET
	SKP
	JMP RETRY
	TAD I (TEMP
	DCA I (TEMP
	JMS I (GET
	JMP .-1
	CLA
	JMS I (CRLF
	TAD I (TEMP
	JMP I (COMN
RL01,	6600
	7201
	4027
	1004
	4027
	6615
	7002
	7012
	6615
	0025
	7004
	6603
	7325
	4027
	7332
	6605
	1026
	6607
	7327
	4027
	0377
	7600
	0000
	6604
	6601
	5031
	6617
	5427
	5001
	PAGE
	FIELD 0
	*200
	$


/11 OS8 CAMP

/
/S.R.
/
/
/CASSETTE & MAGTAPE POSITIONER		(CAMP)
/
/
/
/
/
/
/THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE VITHOUT NOTICE
/AND SHOULD NOT BE CONTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT
/CORPORATION. DIGITAL EQUIPMENT CORPORATION ASSUMES NO RESPONSIBILITY
/FOR ANY ERRORS THAT MAY APPEAR IN THIS DOCUMENT.
/
/THE SOFTWARE DESCRIBED IN THIS DOCUMENT IS FURNISHED TO THE PURCHASER
/UNDER A LICENSE FOR USE ON A SINGLE COMPUTER SYSTEM AND CAN BE COPIED
/(WITH INCLUSION OF DIGITAL'S COPYRIGHT NOTICE) ONLY FOR USE IN SUCH
/SYSTEM, EXCEPT AS MAY OTHERWISE BE PROVIDED IN WRITING BY DIGITAL.
/
/DIGITAL EQUIPMENT CORPORATION ASSUMES NO RESPONSIBILITY FOR THE USE
/OR RELIABILITY OF ITS SOFTWARE ON EQUIPMENT THAT IS NOT SUPPLIED BY
/DIGITAL.
/
/
/	COPYRIGHT (C) 1973,1975,1977 BY DIGITAL EQUIPMENT CORPORATION.
/
/
/
/

/	MUST SKIP LOCS 1000-1377

	LINBUF=1000

	XR1=11
	XR2=12
	XR3=13

	*20

TEMP,	0
T,	0
T2,	0
LINPTR,	0
T3,	0
FLAG,	0
SPKNT,	0
DEVTYP,	0		/DEVICE TYPE (BITS 6-11)
ENTRY,	0		/HANDLER ENTRY POINT
NUM,	0
TYP,	0		/0 MEANS 'F', 1 MEANS 'R'
T4,	0
DEVNUM,	0
DCW,	0		/DEVICE CONTROL WORD
DCWPTR,	0
USR,	200		/POINTS TO USR ENTRY POINT
ESCBIT,	0		/1 MEANS USER TYPED ALTMODE
CNT,	0
CTOFLG,	0		/-1 MEANS SAW ^O
COUNT,	0
PTR,	0
DHIT,	0		/DEVICE HANDLER INFO TABLE - 1
DHI,	0		/DEVICE HANDLER INFO
DBLK,	0		/DEVICE HANDLER BLOCK
VNOPTR,	0		/PTS TO VERSION # IN HANDLER
VNO,	0		/CURRENT HANDLER VERSION NUMBER
SAVPTR,	0
NO,	0		/1 MEANS 'NO'
FLG,	1		/1 MEANS SAW NO DIGITS
P,	0
RR,	0
NUCODE,	0

/	MAGTAPE SPECIAL CODES

	REWKOD=1
	SKFKOD=3	/SKIP FORWARD FILE
	UNLKOD=4
	EOFKOD=5
	SKPKOD=2	/FORWARD RECORD
	BAKKOD=SKPKOD+4000
	BKFKOD=SKFKOD+4000

	DTLA=6766

/0000-0777	/CAMP
/1000-1377	/OS/8 LINE BUFFER
/1400-1777	/PS/8 LINE BUFFER
/2000-		/CAMP
/7000-7177	/I/O BUFFER
/7200-7577	/OS/8 HANDLER
/7600-7777	/OS/8

	DLDC=6746
	DLAG=6743
	PAGE
	*200

START,	SKP
	JMP CHN
	TAD ("#
	JMS I [TYPE
	JMS I [READ	/READ A LINE INTO OS/8 LINE BUFFER
CHN,	TAD [LINBUF	/CHAIN ENTRY ADDRESS
	DCA LINPTR	/INITIALIZE POINTER TO LINE BUFFER
	STA
	JMS I [SPACE	/IGNORE LEADING SPACES
	JMS GETTWO	/GET TWO CHARS
	DCA TEMP
	JMS I [SCAN	/SCAN PAST EXTRA LETTERS OR DIGITS
	TAD TEMP
	JMS I [BRANCH	/GO TO APPROPRIATE ROUTINE
	-2313;SKIP	/SK
	-0517;EOF	/EO
	-0201;BACK	/BA
	-2205;REWIND	/RE
	-2516;UNLOAD	/UN
	-2605;VERSION	/VE
	-1005;HELP	/HE
	-2664;V4	/V4
	-2305;SYNTAX	/SE
	SETLOC=.-1
	0
	SNA CLA
	JMP I [GOAWAY
	JMP I [SYNTAX	/NONE OF THESE

/V1 FEATURES:
/FIXES SINCE FIELD TEST RELEASE:

/1.	ADDED CASSETTE SUPPORT
/2.	FIXED BUG RE IMMEDIATE ALTMOD
/3.	CHANGED SPECIAL CODES TO AGREE WITH NEW MAGTAPE HANDLER
/4.	IGNORE NULLS ON INPUT
/5.	ALLOW UNLOADING AN RK8E

/CHANGES MADE TO V3:

/1.	SET COMMAND IMPLEMENTED

/MAINTENANCE RELEASE CHANGES:

/1.	TOOK OUT 'SET' SINCE WE DON'T WANT TO SUPPORT IT 
/	UNTIL OS/8 V4
/2.	FIXED BUG RE AT EOF AND BOF MESSAGES
/3.	CHANGED CAMP TO USE NEW TM8E HANDLER
/	NOTE: CAMP WILL NOT WORK PROPERLY WITH
/	TM8E HANDLERS PRIOR TO VERSION F
/4.	PROPERLY FIND EOT EVEN IF WE'RE JUST
/	BEFORE A FILE MARK.
/5.	GIVE AT BOT OR EOT MESSAGE IF SEE REFLECTIVE SPOT
/6.	CHANGED VERSION NUMBER TO V4
/7.	ENSURE THAT USER CAN'T PASS OVER EOD

/V3D CHANGES:

/1.	FIXED BUG WITH UNLOADING RKS
/	GETTWO

/GET TWO LETTERS OR DIGITS FROM INPUT LINE, PACK IN SIXBIT
/ADVANCE PAST THEM. SUBSTITUTE NULL IF NOT FOUND.

GETTWO,	0
	JMS GETSIX
	CLL RTL
	RTL
	RTL
	DCA T2
	JMS GETSIX
	TAD T2		/COMBINE
	JMP I GETTWO

GETSIX,	0		/GET A SIXBIT LETTER OR DIGIT (OR NULL)
	JMS ALPHA	/IS IT ALPHANUMERIC?
	JMP NOTALPH	/NO
	AND [77		/YES
	JMP I GETSIX	/TRUNCATE TO SIXBIT
NOTALPH,CLA
	JMS BACKC
	JMP I GETSIX	/RETURN NULL

GETC,	0		/GET A CHARACTER, ADVANCE POINTER
	TAD I LINPTR
	AND [177	/ALWAYS RETURN 8-BIT
	SZA
	TAD [200	/WITH HIGH ORDER BIT ON
	ISZ LINPTR	/ADVANCE SCAN
	JMP I GETC	/RETURN

BACKC,	0		/MOVE SCAN POINTER BACK ONE
	STA
	TAD LINPTR
	DCA LINPTR
	JMP I BACKC	/RETURN
/RETURN 1	NOT OF TYPE DESIRED
/RETURN 2	DESIRED TYPE
/IN BOTH CASES, CHAR IS LEFT IN AC

ALPHA,	0		/LOOK FOR ALPHANUMERIC
	JMS I [GETC
	JMS LETTER	/IS IT A LETTER?
	JMP TRYDIG	/NO, TRY DIGIT
	JMP GOTAL	/YES
TRYDIG,	JMS DIGIT	/IS IT A DIGIT?
	JMP I ALPHA	/NO, AINT LETTER OR DIGIT
GOTAL,	ISZ ALPHA	/YES, EITHER LETTER OR DIGIT
	JMP I ALPHA	/RETURN WITH IT IN AC

LETTER,	0		/LOOK FOR LETTER
	TAD (-"A
	CLL
	TAD ("A-"Z-1
	SNL
	ISZ LETTER
	TAD ("Z+1	/RESTORE CHAR
	JMP I LETTER

DIGIT,	0		/LOOK FOR DIGIT
	TAD (-"0
	CLL
	TAD ("0-"9-1	/(DECIMAL)
	SNL
	ISZ DIGIT
	TAD ("9+1	/RESTORE DIGIT TO CHARACTER FORM
	JMP I DIGIT	/AND RETURN WITH IT IN AC
	PAGE
SYNTAX,	CLA
	JMS PRINT
	TEXT	/? SYNTAX ERROR/
GOAWAY,	TAD ESCBIT
	SZA CLA
	JMP I [7605	/LINE ENDED WITH ESCAPE
	TAD I [READ	/WAS 'READ' EVER CALLED?
	SZA CLA
	JMP I [START	/YES, GET A NEW LINE
	JMP I [7605	/NO, WE MUST'VE BEEN CHAINED TO, RECALL KBM

PRINT,	0
	TAD I PRINT
	RTR
	RTR
	RTR
	JMS PRIN
	TAD I PRINT
	JMS PRIN
	ISZ PRINT
	JMP PRINT+1
LV,	JMS I [CRLF
	ISZ PRINT
	JMP I PRINT

PRIN,	0
	AND [77
	SNA
	JMP LV
	TAD [240
	AND [77
	TAD [240
	DCA T3
	TAD [200
	KRS
	TAD (-203
	SNA
	JMP CTRLC
	TAD (203-217	/^O
	SNA CLA
	JMS CTRLO
	TAD T3
	JMS I [TYPE
	JMP I PRIN
CTRLC,	TAD ["^
	JMS I [TYPE
	TAD ("C
	JMS I [TYPE	/ECHO "^C"
	JMS I [DELAYY
	JMP I [7600	/THEN GO AWAY
CTRLO,	0
	KCC		/CLEAR OUT ^O
	TAD ["^
	JMS I [TYPE
	TAD ("O
	JMS I [TYPE
	JMS I [CRLF
	STA
	DCA CTOFLG	/STOP ECHOING
	JMP I CTRLO

VERSION,JMS PRINT
	TEXT	\OS/8 CAMP V5A\
	JMP I [START
NUMBIG,	JMS PRINT
	TEXT	/? NUMBER TOO BIG/
	JMP I [GOAWAY
NONEX,	JMS PRINT
	TEXT	/? CAN'T - DEVICE DOESN'T EXIST/
	JMP I [GOAWAY

SYSERR,	JMS PRINT
	TEXT	\? I/O ERROR ON SYS:\
	JMP I [GOAWAY
	PAGE
HELP,	JMS I [PRINT
	TEXT	/BACKSPACE DEV: N FILES/
	JMS I [PRINT
	TEXT	/BACKSPACE DEV: N RECORDS/
	JMS I [PRINT
	TEXT	/EOF DEV:/
H2,	JMP H1	/	JMS I [PRINT
	TEXT	/SET DEV: [NO] ATTRIB [N]/
H1,	JMS I [PRINT
	TEXT	/SKIP DEV: N FILES/
	JMS I [PRINT
	TEXT	/SKIP DEV: N RECORDS/
	JMS I [PRINT
	TEXT	/SKIP DEV: EOD/
	JMS I [PRINT
	TEXT	/REWIND DEV:/
	JMS I [PRINT
	TEXT	/UNLOAD DEV:/
	JMS I [PRINT
	TEXT	/VERSION/
	JMS I [PRINT
	TEXT	/HELP/
	JMP I [START
BADEV,	CLA
	JMS I [PRINT
	TEXT	/? CAN'T FOR THIS DEVICE/
	JMP I [GOAWAY

V4,	TAD (SET
	DCA I (SETLOC
	TAD H1
	DCA H2
	JMP I [START
	PAGE
	*2000

/ORIGIN PAST OS/8 LINE BUFFER AT 1000.
/SKIP PAST PS/8 LINE BUFFER (AT 1400) JUST IN CASE
/PS/8 USERS WISH TO PATCH THIS PROGRAM

/SCAN PAST EXTRA LETTERS OR DIGITS

SCAN,	0
	JMS I [ALPHA
	JMP NOPE
	CLA
	JMP SCAN+1
NOPE,	CLA
	JMS I [BACKC
	JMP I SCAN

/SCAN PAST SPACES; GIVE ERROR IF NO SPACES FOUND UNLESS AC=-1

SPACE,	0
	DCA FLAG	/SET AC=-1 TO PREVENT ERROR ON NO SPACES FOUND
	DCA SPKNT	/INITIALIZE SPACE COUNTER
	SKP		/JUMP INTO LOOP
GOTSP,	ISZ SPKNT
	JMS I [GETC	/GET NEXT CHAR
	TAD (-240
	SNA CLA		/IS IT A SPACE?
	JMP GOTSP	/YES, COUNT IT
	JMS I [BACKC	/NO, PUT IT BACK
	ISZ FLAG	/CHECK FLAG
	SKP		/USER DIDN'T SPECIFY FLAG
	JMP I SPACE	/-0 MEANT DON'T CHECK IF FOUND SPACE
	TAD SPKNT	/HOW MANY SPACES DID WE FIND?
	SZA CLA
	JMP I SPACE	/SOME.  OK
	JMP I [SYNTAX	/NONE.  TSK. TSK.
BRANCH,	0
	DCA T
BR2,	TAD I BRANCH
	ISZ BRANCH
	SNA
	JMP NOTFND
	TAD T
	SNA CLA
	JMP FOUND
	ISZ BRANCH
	JMP BR2

FOUND,	TAD I BRANCH
	DCA T
	JMP I T		/FOUND ITEM IN COLUMN 1, JUMP TO ADDRESS IN COL 2

NOTFND,	TAD T
	JMP I BRANCH	/IF NOT FOUND IN COL 1, RETURN WITH AC INTACT
CHECKR,	0
	TAD DCW
	RAL
	SMA CLA
	JMP I CHECKR
RONLY,	JMS I [PRINT
	TEXT	/? CAN'T - DEVICE IS READ-ONLY/
	JMP I [GOAWAY
CHECKW,	0
	TAD DCW
	RTL
	SMA CLA
	JMP I CHECKW
WONLY,	JMS I [PRINT
	TEXT	/? CAN'T - DEVICE IS WRITE-ONLY/
	JMP I [GOAWAY
ONUM,	0
	DCA NUM
	CLA IAC
	DCA FLG
ONM1,	JMS I [GETC
	TAD (-"0-10	/CONVERT TO DIGIT
	CLL
	TAD (10
	SNL
	JMP OEON
	DCA T4
	DCA FLG
	TAD NUM
	AND [7000
	SZA CLA
	JMP I [NUMBIG
	TAD NUM
	CLL RTL
	RAL
	TAD T4
	DCA NUM
	JMP ONM1
OEON,	CLA
	JMS I [BACKC
	TAD NUM
	JMP I ONUM
	PAGE
/READ A LINE INTO OS/8 LINE BUFFER

READ,	0
	DCA CTOFLG	/ALLOW ECHOING
RD1,	TAD [LINBUF
	DCA LINPTR
	DCA ESCBIT
GT,	JMS GET
LOOK,	JMS I [BRANCH
	-377;RUBOUT
	-217;GT		/^O
	-203;CTRLC	/^C
	-212;LF		/LINE FEED
	-215;CR		/CARRIAGE RETURN
	-375;ESCAPE	/ALTMODE
	-376;ESCAPE	/ALTMODE (2ND FLAVOR)
	-233;ESCAPE	/ESCAPE
	-225;CTRLU	/^U
	-200;GT		/IGNORE NULLS
	0
	DCA TEMP	/NONE OF THESE
	TAD LINPTR
	TAD (-LINBUF-377
	SNA CLA		/AT END OF LINE BUFFER?
	JMP GT		/YES, DON'T ACCEPT CHAR
	TAD TEMP	/NO, RETRIEVE CHAR
	JMS TYPE	/ECHO IT
	TAD TEMP	/INSERT IN BUFFER
	DCA I LINPTR
	ISZ LINPTR	/BUMP POINTER
	JMP GT		/NEXT

CTRLU,	TAD ["^
	JMS TYPE
	TAD ("U
	JMS TYPE	/ECHO "^U" <CR><LF>
	JMS I [CRLF
	JMP RD1
RUBOUT,	TAD LINPTR
	TAD [-LINBUF
	SNA
	JMP BOL		/AT BEGIN OF LINE
	TAD [LINBUF-1
	DCA LINPTR	/MOVE POINTER BACK ONE
	TAD ["\
	JMS TYPE	/ECHO "\"
RUB3,	TAD I LINPTR
	JMS TYPE	/ECHO RUBBED-OUT CHARACTER
GT2,	JMS GET
	JMS I [BRANCH
	-377;RUB2
	-216;GT2	/IGNORE ^O
	-203;CTRLC	/^C
	0
	DCA TEMP	/A NEW CHAR
	TAD ["\
	JMS TYPE	/ENCLOSE RUBBED-OUT CHARS IN \'S
	TAD TEMP
	JMP LOOK

RUB2,	TAD LINPTR
	TAD [-LINBUF
	SNA
	JMP BOL2
	TAD [LINBUF-1
	DCA LINPTR
	JMP RUB3

BOL2,	TAD ["\
	JMS TYPE
BOL,	JMS I [CRLF
	JMP RD1

ESCAPE,	TAD ("$		/ECHO ESCAPE AS DOLLAR SIGN
	JMS TYPE
	ISZ ESCBIT	/NOTE ESCAPE
CR,	DCA I LINPTR	/INSERT 0 AT END
	JMS I [CRLF
	JMP I READ	/RETURN, WE GOT LINE
GET,	0
	KSF
	JMP .-1
	KRB
	AND [177
	TAD [200	/FORCE TO 8-BIT
	JMP I GET

TYPE,	0
	DCA TYPEM
	JMS I [DELAYY
	DCA .-1		/DELAY FIRST TIME THRU TO LET THINGS QUIET DOWN
	TAD CTOFLG
	SZA CLA
	JMP I TYPE	/NO ECHOING
	TAD TYPEM
	TLS
	TSF
	JMP .-1
	CLA
	JMP I TYPE

TYPEM,	0

LF,	DCA I LINPTR	/TEMPORARILY INSERT A 0 SENTINEL
	TAD [LINBUF-1
	DCA XR1
	JMS I [CRLF
	TAD ["#
	JMS I [TYPE
LFLP,	TAD I XR1
	SNA
	JMP I [GT	/FINHSHED, GET SOME MORE CHARS
	JMS I [TYPE	/ECHO CURRENT CHARS
	JMP LFLP
	PAGE
EOF,	JMS I [SPACE	/SPAN OVER SPACES
	JMS I [GETDEV	/GET DEVICE
	JMS I [CHECKR
	TAD DEVTYP
	JMS I [BRANCH
	-20;MAGEOF
	-27;CASEOF
	ZBLOCK 2
	0
	JMP I [BADEV

SKIP,	JMS I [SPACE
	JMS I [GETDEV
	JMS I [CHECKW
	JMS GETNUM
	TAD DEVTYP
	JMS I [BRANCH
	-20;MAGSKP
	-27;CASSKP
	0
	JMP I [BADEV

REWIND,	JMS I [SPACE
	JMS I [GETDEV
	JMS I [CHECKW
	TAD DEVTYP
	JMS I [BRANCH
	-20;MAGREW
	-27;CASREW
	-16;TCREW
/	-17;LTREW
	ZBLOCK 4	/PATCH SPACE
	0
	TAD DCW
	SMA CLA
	JMP I [BADEV	/NOT FILE STRUCTURED
	CLA IAC		/READ BLOCK 0 TO REWIND
	DCA I [BLK
	TAD (100
	JMS I [GO
	JMP I [GOAWAY
UNLOAD,	JMS I [SPACE
	JMS I [GETDEV
	JMS I [CHECKW
	TAD DEVTYP
	JMS I [BRANCH
	-20;MAGUNL
/	-27;CASUNL
	-16;TCUNL
	-21;TDUNL
/	-17;LTUNL
	-23;RKEUNL
	ZBLOCK 2
	0
	JMP I [BADEV

BACK,	JMS I [SPACE
	JMS I [GETDEV
	JMS I [CHECKW
	JMS GETNUM
	TAD TYP
	SPA CLA
	JMP I [SYNTAX	/CAN'T BACKSPACE TO EOD
	TAD DEVTYP
	JMS I [BRANCH
	-20;MAGBAK
	-27;CASBAK
	0
	JMP I [BADEV
GETNUM,	0		/PARSE OFF :NNNN [F ! R]  OR EOD
	CLA IAC
	DCA NUM
	DCA TYP
	JMS I [GETC
	SNA
	JMP I GETNUM	/EOL
	TAD (-":
	SZA CLA
	JMP I [SYNTAX
	STA
	JMS I [SPACE	/OPTIONAL SPACES
	TAD I LINPTR
	SNA
	JMP I GETNUM	/EOL
	TAD (-"E
	SNA CLA
	JMP EO
	JMS I [NUMBER
	DCA NUM
	STA
	JMS I [SPACE	/MORE OPTIONAL SPACES
	DCA TYP
	JMS I [GETC
	SNA
	JMP I GETNUM	/NO F OR R.  F ASSUMED
	TAD (-"F
	SNA
	JMP R		/0 MEANS 'F'
	TAD ("F-"R
	SZA CLA
	JMP I [SYNTAX
	CLA IAC		/1 MEANS 'R'
R,	DCA TYP
	JMP I GETNUM
EO,	STA		/-1 MEANS 'E'
	JMP R
	PAGE
/GET A DECIMAL NUMBER, RETURN IT IN AC

NUMBER,	0
	DCA NUM
	CLA IAC
	DCA FLG
NM1,	JMS I [GETC
	JMS I [DIGIT
	JMP EON
	TAD (-"0	/CONVERT TO DIGIT
	DCA T4
	DCA FLG		/NOTE PASSAGE OF A DIGIT
	TAD NUM
	AND [7000
	SZA CLA
	JMP I [NUMBIG
	TAD NUM
	CLL RTL
	TAD NUM
	CLL RAL
	TAD T4
	SZL
	JMP I [NUMBIG
	DCA NUM
	JMP NM1

EON,	CLA
	JMS I [BACKC
	TAD FLG
	SZA
	DCA NUM		/IF NO DIGITS, RETURN A 1
	TAD NUM
	JMP I NUMBER
/	GETDEV

/PARSES OFF A DEVICE NAME (1-4 CHARS)
/DETERMINES IF IT EXISTS
/LOADS HANDLER INTO 7200-7577 IF NOT ALREADY IN CORE
/SETS ENTRY POINT ADDRESS AT 'ENTRY'
/SETS DEVICE NUMBER AT 'DEVNUM'
/SETS DEVICE CONTROL WORD AT 'DCW'
/SETS 'DEVTYP'

GETDEV,	0
	JMS I [GETTWO
	DCA WD1
	JMS I [GETTWO
	DCA WD2
	TAD WD1
	TAD WD2
	DCA WD1		/COMBINE TWO WORDS INTO 1 (IN WD1)
	TAD WD2
	SNA CLA
	JMP INQ
	TAD WD1		/OS/8 KLUDGE FOR UNIQUENESS
	CLL RAL
	STL RAR		/FORCE BIT 0 ON IF 2ND WORD WAS NON-ZERO
	DCA WD1
INQ,	DCA WD2
	CIF 10
	JMS I USR
	12		/INQUIRE
WD1,	0		/DEVICE NAME
WD2,	0		/GETS DEVICE NUMBER
WD3,	0		/GETS ENTRY POINT
	JMP I [NONEX	/DEVICE DOESN'T EXIST
	TAD WD3
	SZA		/IS HANDLER ALREADY IN CORE?
	JMP INCORE	/YES
	TAD WD1
	DCA DW1
	TAD (7201	/ALLOW TWO PAGE HANDLER IN 7200
	DCA DW3
	DCA DW2
	CIF 10
	JMS I USR
	1		/FETCH
DW1,	0		/DEVICE NAME
DW2,	0		/GETS DEVICE NUMBER
DW3,	0		/GETS ENTRY POINT
	JMP I [NONEX	/DOESN'T EXIST
	TAD DW2
	DCA DEVNUM
	TAD DW3
	DCA ENTRY
	JMP GETYP
INCORE,	DCA ENTRY
	TAD WD2
	DCA DEVNUM
GETYP,	TAD DEVNUM
	TAD (7757
	DCA DCWPTR	/POILT INTO DEVICE CONTROL WGRD TABLE
	CDF 10
	TAD I DCWPTR	/GET DCW
	DCA DCW
	TAD DCW
	RTR
	RAR
	AND [77
	DCA DEVTYP
	STA
	TAD I (37	/GET ADDRESS OF DHIT
	DCA DHIT
	TAD DHIT
	TAD DEVNUM
	DCA DHI
	TAD I DHI
	CDF 0
	DCA DHI
	TAD DHI
	RTL
	RTL
	RTL
	AND (17
	SZA
	TAD (15
	DCA DBLK
	JMP I GETDEV

DELAYY,	0
	TAD (-10
	DCA OUTER
	ISZ ZER
	JMP .-1
	ISZ OUTER
	JMP .-3
	JMP I DELAYY
ZER,	0
OUTER,	-10
	PAGE
LOADPT,	TAD I (FUNCT
	TAD (-REWKOD
	SNA CLA
	JMP I [GOAWAY	/LOAD POINT ON A REWIND IS NOT AN ERROR
READBT,	JMS I [PRINT
	TEXT	/? CAN'T - AT BOT OR EOT/
	JMP I [GOAWAY
READEOF,JMS I [PRINT
	TEXT	/% CAN'T - AT EOF/
	JMP I [GOAWAY

READBOF,JMS I [PRINT
	TEXT	/% CAN'T - AT BOF/
	JMP I [GOAWAY

CASSKP,	DCA I (DIR
	TAD TYP
	SNA CLA
	JMP CSKPF
	JMP I (NOTIMPL

CGO,	0
	DCA CFUNCT
	JMS I ENTRY
CFUNCT,	0
CBUFR,	7000
CBLK,	-1
	SKP
	JMP I CGO
	DCA TEMP
	TAD TEMP
	SMA CLA
	JMP I (END	/SOFT ERROR
	JMS I [PRINT
	TEXT	\? CAN'T - I/O ERROR\
	JMP I [GOAWAY

CASEOF,	JMS CGO
	JMP I [GOAWAY

CASREW,	TAD (REWKOD
	JMS CGO
	JMP I [GOAWAY
CSKPF,	TAD NUM
	SNA
	IAC
	CIA
	DCA COUNT
	TAD (SKFKOD
	JMS CGO
	ISZ COUNT
	JMP .-3
	JMP I [GOAWAY

CASBAK,	CLA IAC
	DCA I (DIR
	TAD TYP
	SZA CLA
	JMP CBAKBLK
	TAD NUM
	CMA
	DCA COUNT
	TAD (BKFKOD
	JMS CGO
	ISZ COUNT
	JMP .-3
	JMP I [GOAWAY

CBAKBLK,TAD NUM
	SNA
	IAC
	CIA
	DCA COUNT
	TAD (BAKKOD
	JMS CGO
	ISZ COUNT
	JMP .-3
	JMP I [GOAWAY
	PAGE
TCREW,	JMS TCR
	JMP I [GOAWAY

TCUNL,	JMS TCR
	TAD ENTRY
	IAC
	RTR
	RTR
	AND [7000
	DTLA		/SELECT ANOTHER UNIT
	JMP I [GOAWAY

TCR,	0
	TAD ENTRY
	TAD (-7607
	SZA CLA		/SYSTEM TC08 DECTAPE MUST BE UNIT 0
	TAD ENTRY
	RTR
	RTR
	AND [7000	/ISOLATE UNIT # IN BITS 0-2
	TAD (600	/GO REVERSE
	DTLA
	JMP I TCR
TDUNL,	TAD (-7607
	SZA CLA
	TAD ENTRY
	DCA TEMP
	TAD TEMP
	RTR
	RAR
	CLA RAR
	DCA UNIT
	TAD TEMP
	AND [3
	CIA
	TAD [77		/GET DEV CODE
	CLL RTL
	RAL
	TAD (6004	/BUILD 'SDLC'
	DCA BSDLC
	TAD UNIT
	TAD (3000	/GO, REVERSE
BSDLC,	HLT
	CLA
	JMP I [GOAWAY
UNIT,	0
TTCODE,	0
	TAD NO
	SZA CLA
	JMP I [SYNTAX
	JMS I [ONUM
	SNA
	JMP I [SYNTAX
	DCA NUCODE
	TAD NUCODE
	AND [7700
	SZA CLA
	JMP I [NUMBIG
	JMS I [TTST1
	TAD (7200
	DCA RR
	JMS GETIOT
	JMP I [OLDERR
	CIA
	DCA T2
TTLP,	JMS GETIOT
	JMP I [OLDERR
	CIA
	DCA T3
	TAD T3
	CIA
	TAD T2
	SNA
	JMP TTLP
	SMA CLA
	JMP .+3
	TAD T3
	DCA T2		/T2 CONTAINS NEG OF SMALLER IOT
	TAD (7200
	DCA RR
TTLP2,	JMS GETIOT
	JMP I TTCODE
	TAD T2
	SZA CLA
	CLA IAC
	TAD NUCODE
	CLL RTL
	RAL
	DCA T3
	TAD I RR
	AND (7007
	TAD T3
	DCA I RR
	JMP TTLP2
GETIOT,	0
	ISZ RR
	TAD RR
	TAD (-7600
	SNA CLA
	JMP I GETIOT
	TAD I RR
	AND [7000
	TAD [-6000
	SZA CLA
	JMP GETIOT+1
	TAD I RR
	RTR
	RAR
	AND [77
	TAD (-20
	CLL RAR
	SNA
	JMP GETIOT+1
	RAL
	TAD (20
	ISZ GETIOT
	JMP I GETIOT
	PAGE
MAGSKP,	DCA DIR
	TAD TYP
	SNA
	JMP SKPF
	SPA CLA
	JMP SKPEOD
	TAD NUM
	SNA
	CLA IAC
	CIA
	DCA WC
	TAD (SKPKOD
	JMS GO
	JMP I [GOAWAY

MAGEOF,	TAD (EOFKOD
	JMS GO
	JMP I [GOAWAY

SKPF,	TAD NUM
	SNA
	JMP SKP0
	CIA
	DCA WC
	JMS I (FUDGE	/DON'T LET GUY TRICK US INTO GOING PAST EOD
	TAD (SKFKOD
	JMS GO
	JMP I [GOAWAY

SKPEOD,	JMS I (FUDGE	/DON'T LET GUY TRICK US INTO GOING PAST EOD
	JMS I ENTRY
	SKFKOD
	0
	0		/SKIP 4096 FILES
	SMA
	SKP CLA
	JMP CHKBOT
	JMP I [GOAWAY

MAGBAK,	CLA IAC
	DCA DIR
	TAD TYP
	SNA CLA
	JMP BAKF
	TAD NUM
	SNA
	CLA IAC
	CIA
	DCA WC
	TAD (BAKKOD
	JMS GO
	JMP I [GOAWAY
BAKF,	TAD NUM
	CMA
	DCA WC2
	JMS I ENTRY
	BKFKOD
	0
WC2,	-1		/
	SMA
	SKP CLA
	JMP CHKBOT
	TAD (SKPKOD	/SKIP 1 RECORD FORWARD
	JMP SKY

CHKBOT,	DCA TEMP
	TAD TEMP
	AND (1000
	SNA CLA
	JMP IOE
	JMP I (READBT
MAGUNL,	TAD (UNLKOD
	JMS GO
	JMP I [GOAWAY

MAGREW,	TAD (REWKOD
	JMS GO
	JMP I [GOAWAY

GO,	0
	DCA FUNCT
	JMS I ENTRY
FUNCT,	0
BUFR,	7000
WC,
BLK,	-1
	SKP		/I/O ERROR
	JMP I GO
	DCA TEMP
	TAD TEMP
	SMA CLA
	JMP END		/SOFT ERROR
	TAD TEMP
	AND (1000
	SZA CLA
	JMP I [LOADPT
IOE,	TAD TEMP
	JMP I [IOERR

DIR,	0		/0- FORWARD ;  1- BACKWARDS

END,	TAD TYP
	SNA CLA
	JMP I (EODERR	/V3C NEW HANDLER CALL
	TAD DIR		/SAW FILE MARK
	SNA CLA		/V3C
	JMP I [READEOF	/AT END OF FILE
	JMP I [READBOF	/AT BEGIN OF FILE
SKP0,	JMS I ENTRY
	SKFKOD
	0		/IRRELEVANT
	-1		/ADVANCE 1 FILE
	SMA
	SKP CLA
	JMP I [IOERR	/HARD ERROR
	TAD (BAKKOD
SKY,	DCA SKX		/V3C
	JMS I ENTRY
SKX,	BAKKOD
	0		/IRREL
	-1		/BACK OVER FILE MARK
	SMA
	SKP CLA
	JMP I [IOERR
	JMP I [GOAWAY
	PAGE
IOERR,	AND (3777
	CLL RAL
	DCA TEMP
	JMS I [PRINT
	TEXT	\? CAN'T - I/O ERROR\
	TAD (-13	/11 BITS TO LOOK AT
	DCA CNT
	TAD (JLIST
	DCA JM
IOLUP,	TAD TEMP
	RAL
	DCA TEMP
	SZL
	JMP I JM
IOCONT,	ISZ JM
	ISZ CNT
	JMP IOLUP
	JMP I [GOAWAY

JM,	0

JLIST,	JMP BIT1
	JMP BIT2
	JMP BIT3
	JMP BIT4
	JMP BIT5
	JMP BIT6
	JMP BIT7
	JMP BIT8
	JMP I (BIT9
	JMP I (BIT10
	JMP I (BIT11
BIT1,	JMS I [PRINT
	TEXT	/(REWINDING)/
	JMP IOCONT
BIT2,	JMS I [PRINT
	TEXT	/(BOT)/
	JMP IOCONT
BIT3,	JMS I [PRINT
	TEXT	/(SELECT ERROR)/
	JMP IOCONT
BIT4,	JMS I [PRINT
	TEXT	/(PARITY ERROR)/
	JMP IOCONT
BIT5,	JMS I [PRINT
	TEXT	/(EOF)/
	JMP IOCONT
BIT6,	JMS I [PRINT
	TEXT	/(RECORD LENGTH INCORRECT)/
	JMP IOCONT
BIT7,	JMS I [PRINT
	TEXT	/(TIMING ERROR)/
	JMP IOCONT
BIT8,	JMS I [PRINT
	TEXT	/(EOT)/
	JMP IOCONT
RKEUNL,	CLL
	TAD ENTRY
	TAD (200
	SNL CLA
	TAD ENTRY
	AND (6		/ISOLATE UNIT
	TAD (2000	/WRITE PROTECT DISK
	DLDC		/LOAD COMMAND REGISTER
	DLAG
	JMP I [GOAWAY
	PAGE
BIT9,	JMS I [PRINT
	TEXT	/(WRITE LOCK-OUT)/
	JMP I (IOCONT
BIT10,	JMS I [PRINT
	TEXT	/(READ COMPARE ERROR)/
	JMP I (IOCONT
BIT11,	JMS I [PRINT
	TEXT	/(ILLEGAL FUNCTION)/
	JMP I (IOCONT
NOTIMPL,JMS I [PRINT
	TEXT	/% OPERATION NOT YET IMPLEMENTED/
	JMP I [GOAWAY
EODERR,	JMS I [PRINT
	TEXT	/? CAN'T - AT EOD/
	JMP I [GOAWAY
/THIS ROUTINE PREVENTS US FROM GOING PAST EOD WHEN
/SKIPPING FORWARD FILES.
/IT DOES THIS BY THE FOLLOWING ALGORITHM:
/FIRST WE BACKSPACE A RECORD.
/IF WE SAW DATA, THEN OK, WE RETURN TO THE USER;
/THIS WILL NOT AFFECT HIS SKIP FILE COUNT.
/IF WE SAW A FILE MARK, THEN WE SKIP FORWARD
/BACK OVER THAT FILE, IGNORING THE FILE MARK ERROR.
/IF WE SAW BOT, THEN, OK NO ERROR.

FUDGE,	0
	JMS I ENTRY	/V3C ALL NEW
	BAKKOD
TM,	0
	-1
	SKP
	JMP I FUDGE
	SPA
	JMS BER
	SZA CLA
	JMS FRWD
	JMP I FUDGE

/IF ERROR WAS BOT, OK

BER,	0
	DCA TM
	TAD TM
	AND (1000
	SZA CLA
	JMP I BER	/BOT OK, NO FRWD
	TAD TM
	JMP I [IOERR

FRWD,	0
	JMS I ENTRY
	SKPKOD
	0
	-1
	SMA
	SKP CLA
	JMP I [IOERR
	JMP I FRWD
	PAGE
SET,	JMS I [SPACE
	DCA VNO		/V3C
	JMS I [GETDEV
	JMS I [GETC
	JMS I [BRANCH
	-":;COLN
	-" ;COLN
	-"-;HYPH
	0
	JMP I [SYNTAX	/NO : OR BLANK AFTER NAME
COLN,	STA
	JMS I [SPACE	/IGNORE OPTIONAL SPACES
	JMS I [GETC
	SNA
	JMP I [SYNTAX
	TAD (-"-
	SNA CLA
	JMP HYPH
	JMS I [BACKC
COLN2,	DCA NAM1
	DCA NAM2
	TAD (MAIN-1	/LOOK FOR DEVICE TYPE IN MAIN TABLE
MNLUP,	DCA XR1
	TAD I XR1
	SMA SZA
	JMP NOTYP	/NOT FOUND
	TAD DEVTYP
	SNA CLA
	JMP FNDTYP
	TAD XR1
	TAD (3		/POINT TO NEXT ENTRY
	JMP MNLUP
FNDTYP,	TAD I XR1	/GET GENERIC NAME
	DCA NAM1
	TAD I XR1
	DCA NAM2
	DCA AUXFLG
	TAD I XR1	/GET PTR TO DEVICE TABLE
INTO,	DCA PTR
	DCA NO
	TAD LINPTR
	DCA SAVPTR	/SAVE SCAN POINTER
	JMS I [GETTWO
	TAD (-1617
	SNA CLA		/ARE NEXT TWO CHARS 'NO'?
	JMS SAWNO	/YES
	TAD SAVPTR	/NO
	DCA LINPTR	/RESTORE PTR
SCNLUP,	TAD I PTR
	SNA		/GET NEXT KEYWORD POINTER
	JMP NOKEY
	ISZ PTR		/POINT TO PTR TO ROUTINE
	JMS I [KEYSRCH
	JMP NOF		/NOT FOUND
	TAD I PTR	/FOUND
	DCA PTR		/GET PTR TO ROUTINE
	JMS I (HREAD	/READ HANDLER
	JMS I PTR	/CALL ROUTINE
	JMS I (HWRITE	/REWRITE HANDLER
	JMP I [GOAWAY
HYPH,	JMS I [ALPHA
	JMP I [BADV
	DCA VNO
	TAD VNO
	SNA
	JMP I [BADV
	AND [17
	DCA VNO
	JMS I [SPACE	/IGNORE SPACE
	JMP COLN2
NOKEY,	TAD AUXFLG
	SNA CLA
	JMP NOO
	JMS I [PRINT
	TEXT	\? UNKNOWN ATTRIBUTE FOR DEVICE  \
	*.-1
NAM1,	0
NAM2,	0
	0
	JMP I [GOAWAY

SAWNO,	0
	ISZ NO
	STA
	JMS I [SPACE
	TAD LINPTR
	DCA SAVPTR
	JMP I SAWNO

NOTYP,	CLA
	ISZ AUXFLG
	TAD (AUX	/SEARCH AUXILIARY TABLE
	JMP INTO
NOF,	ISZ PTR
	TAD SAVPTR
	DCA LINPTR
	JMP SCNLUP

AUXFLG,	0

NOO,	ISZ AUXFLG
	TAD (AUX
	DCA PTR
	JMP SCNLUP
	PAGE
HREAD,	0
	TAD DBLK
	SNA
	JMP RESERR
	DCA BLOCK
	JMS I (7607
	200		/READ 2 PAGES
L7200,	7200		/INTO 7200-7577
BLOCK,	0		/FROM THIS BLOCK ON SYSTEM DEVICE
	JMP I [SYSERR
	TAD DHI
	AND (177	/GET RELATIVE ENTRY PT
	TAD L7200
	DCA ENTRY
	TAD VNO
	SZA CLA		/V3C
	JMP I HREAD	/VNO ALREADY SET BY - COMMAND
	TAD ENTRY
VLOOP,	DCA VNOPTR
	TAD I VNOPTR
	CLL
	TAD (-33
	SZL CLA
	JMP BACKV
	TAD I VNOPTR
	SNA
	JMP OLDERR
	DCA VNO
	JMP I HREAD
BACKV,	STA
	TAD VNOPTR
	JMP VLOOP

RESERR,	JMS I [PRINT
	TEXT	/? CAN'T - DEVICE IS RESIDENT/
	JMP I [GOAWAY
OLDERR,	CLA
	JMS I [PRINT
	TEXT	/? CAN'T - OBSOLETE HANDLER/
	JMP I [GOAWAY

HWRITE,	0
	TAD BLOCK
	DCA BLKTWO
	JMS I (7607
	4200
	7200
BLKTWO,	0
	JMP I [SYSERR
	JMP I HWRITE
NEWERR,	CLA
	JMS I [PRINT
	TEXT	/? CAN'T - UNKNOWN VERSION OF THIS HANDLER/
	JMP I [GOAWAY
	PAGE
MAIN,	-0;	DEVICE TTY;	TTYTBL
	-1;	DEVICE PTR;	PTRTBL
	-2;	DEVICE PTP;	PTPTBL
	-3;	DEVICE CDR;	CDRTBL
	-4;	DEVICE LPT;	LPTTBL
	-20;	DEVICE MTA;	MTATBL
	1
	ZBLOCK 20
/TABLE ENDS WITH A POSITIVE NON-ZERO NUMBER
CDRTBL,	CODE;CDCODE
	ZBLOCK 4
	0

LPTTBL,	WIDTH;LPWDTH
	LC;LPLC
	LV8E;LPLV
	ZBLOCK 4
	0

MTATBL,	PARITY;MTAPAR
	DENSITY;MTADEN
	FILES;MTAFIL
	ZBLOCK 4
	0
TTYTBL,	WIDTH;TTWIDTH
	CODE;TTCODE
	ALT;TTALT
	ECHO;TTECHO
	LC;TTLC
	PAYGE;TTPAGE
	TAB;TTTAB
	FILL;TTFILL
	FLAGG;TTFLAG
	CTRL;TTCTRL
	GAG;TTGAG
	DELAY;TTDELAY
	ZBLOCK 10
	0

AUX,	LOC;GENLOC
	FILES;GENFIL
	READO;GENREA
	VERS;GENVER
	ZBLOCK 10
	0
	PAGE
WIDTH,	"W;"I;"D;"T;"H;0
LC,	"L;"C;0
LV8E,	"L;"V;4000+"8;4000+"E;0
CODE,	"C;"O;"D;"E;0
ALT,	"A;"L;"T;4000+"M;4000+"O;4000+"D;4000+"E;0
ECHO,	"E;"C;"H;"O;0
PAYGE,	"P;"A;"G;"E;0
TAB,	"T;"A;"B;0
LOC,	"L;"O;"C;4000+"A;4000+"T;4000+"I;4000+"O;4000+"N;0
FILES,	"F;"I;"L;"E;4000+"S;0
READO,	"R;"E;"A;"D;4000+"O;4000+"N;4000+"L;4000+"Y;0
VERS,	"V;"E;"R;4000+"S;4000+"I;4000+"O;4000+"N;0
PARITY,	"P;"A;"R;4000+"I;4000+"T;4000+"Y;0
DENSITY,"D;"E;"N;4000+"S;4000+"I;4000+"T;4000+"Y;0
FILL,	"F;"I;"L;"L;0
FLAGG,	"F;"L;"A;"G;0
CTRL,	"C;"T;"R;"L;0
EVEN,	"E;4000+"V;4000+"E;4000+"N;0
ODD,	"O;4000+"D;4000+"D;0
DELAY,	"D;"E;"L;"A;"Y;0
GAG,	"G;"A;"G;0
	PAGE
LPWDTH,	0
	JMS I (GETWID
	JMS LPTST1
	TAD NUM
	CMA
	DCA I (7200
	JMP I LPWDTH

LPTST1,	0
	TAD I (7201
	SPA CLA
	JMP L645
	TAD VNO
	JMS I [BRANCH
	-1;OLDERR
	-2;LPTOK
	ZBLOCK 4
	0
	JMP I [NEWERR
LPTOK,	JMP I LPTST1

L645,	JMS I [PRINT
	TEXT	/? CAN'T AFFECT ANNALEX LPT/
	JMP I [GOAWAY
ASRTST,	0
	TAD DHI
	SPA CLA
	JMP I ASRTST
	JMS I [PRINT
	TEXT	/? CAN'T - NOT KL8E HANDLER/
	JMP I [GOAWAY
GENVER,	0
	TAD NO
	SZA CLA
	JMP I [SYNTAX
	JMS I [ALPHA
	JMP BADV
	DCA NUM
	TAD NUM
	AND (40
	SZA CLA
	JMP BADV
	TAD NUM
	AND (37
	DCA I VNOPTR
	JMP I GENVER

GENREA,	0
	CDF 10
	TAD I DCWPTR
	CLL RTL
	CLL RAL
	TAD NO
	RAR
	CML RAR
	RAR
	DCA I DCWPTR
	CDF 0
	JMP I GENREA

GENFIL,	0
	CDF 10
	TAD I DCWPTR
	CLL RAL
	CLL RAL		/ZERO LINK
	TAD NO
	RAR
	CML RAR
	DCA I DCWPTR
	CDF 0
	JMP I GENFIL
BADV,	CLA
	JMS I [PRINT
	TEXT	/? BAD VERSION LETTER/
	JMP I [GOAWAY

CRLF,	0
	TAD [215
	JMS I (TYPE
	TAD [212
	JMS I (TYPE
	JMP I CRLF
	PAGE
LPLV,	0
	JMS I (LPTST1
	TAD NO
	CLL RTL
	RTL
	TAD (4
	DCA I (7201
	JMP I LPLV

LPLC,	0
	JMS I (LPTST1
	TAD NO
	CLL RTL
	RTL
	RAL
	CIA
	DCA I (7202
	JMP I LPLC

TTALT,	0
	JMS I [TTST1
	JMP I [NOTIMPL
	JMP I TTALT

TTECHO,	0
	JMS I [TTST1
	TAD NO
	SZA CLA
	TAD (SKP CLA-SZA
	TAD (SZA
	DCA I (7200+120
	JMP I TTECHO

TTPAGE,	0
	JMS I (ASRTST
	TAD VNO
	JMS I [BRANCH
	-1;OLDERR
	-2;OLDERR
	-3;OLDERR
	-4;PAGOK
	ZBLOCK 2
	0
	JMP I [NEWERR
PAGOK,	TAD I (7200+216
	TAD (-SNA
	SZA CLA
	JMP I [REASEM
	TAD NO
	SNA CLA
	TAD (SZA CLA-CLA
	TAD (CLA
	DCA I (7200+216
	JMP I TTPAGE
TTTAB,	0
	JMS I [TTST1
	JMS I [GETC
	SNA
	JMP TTEO
	TAD (-"/
	SNA CLA
	JMS I [GETC
	TAD (-"N
	SZA CLA
	JMP I [SYNTAX
	JMP NOTEC
TTEO,	TAD NO
	SNA CLA
	TAD (5000
	TAD L200
	JMS I (TECO
NOTEC,	JMS I [SRCH
L200,	200;100;7
	JMP I [REASEM
	DCA TEMP
	STA CLL RAL	/-2
	TAD TEMP
	DCA T2
	TAD TEMP
	TAD (3
	DCA T3
	TAD NO
	SNA CLA
	JMP SETAB
	TAD TEMP
	TAD (-4
	DCA T4
	TAD T4
	AND (77
	TAD (1200	/TAD TTY240
	DCA I T2
	TAD (SZA CLA
	DCA I T3
	JMP I TTTAB
SETAB,	TAD TEMP
	TAD (-12
	DCA T4
	TAD I T4
	DCA I T2
	TAD (SKP CLA
	DCA I T3
	JMP I TTTAB
	PAGE
TTFILL,	0
	JMS I [TTST1
	JMS I [SRCH
	200;100;1377
	JMP I [REASEM
	TAD (-1
	DCA TEMP
	TAD NO
	CLL RAL
	TAD (2
	TAD TEMP
	DCA T2
	TAD I T2
	DCA I TEMP
	JMP I TTFILL

REASEM,	JMS I [PRINT
	TEXT	/? CAN'T - MUST REASSEMBLE KL8E SOURCE/
	JMP I [GOAWAY

TTDELAY,0
	JMS I [TTST1
	JMP I [NOTIMPL
	JMP I TTDELAY
/ENTER WITH PTR TO POSSIBLE KEYWORD IN AC

KEYSRCH,0
	DCA KPTR
KL,	TAD I KPTR
	ISZ KPTR
	SNA
	JMP GOTKEY
	CIA
	DCA TEMP
	JMS I [ALPHA	/IS IT ALPHANUMERIC?
	JMP EOK		/NO
	TAD TEMP	/COMPARE
	CLL RAL		/LOW ORDER 11 BITS
	SNA CLA
	JMP KL		/MATCHED, KEEP LOOKING
	JMP I KEYSRCH	/DIDN'T MATCH
EOK,	JMS I [BACKC
	TAD TEMP
	CIA		/INPUT STREAM RAN OUT OR HIT SPACE
	SPA CLA
	JMP GOTKEY	/SPACE OR EOL MATCH FLAGGED CHARACTER
	JMP I KEYSRCH

KPTR,	0

GOTKEY,	JMS I [SCAN
	STA		/SKIP EXTRA STUFF
	JMS I [SPACE
	ISZ KEYSRCH	/TAKE GOOD RETURN 2
	JMP I KEYSRCH

PTRTBL,	ZBLOCK 4
	0

PTPTBL,	ZBLOCK 4
	0
	PAGE
TTGAG,	0
	JMS TTST1
	JMP I [NOTIMPL
	JMP I TTGAG

TTFLAG,	0
	JMS TTST1
	JMS I [SRCH
	200;200;247
	JMP I [REASEM
	TAD (-2
	DCA TEMP
	TAD NO
	SNA CLA
	TAD (SZA CLA-CLA
	TAD (CLA
	DCA I TEMP
	JMP I TTFLAG

TTLC,	0
	JMS TTST1
	JMS I [SRCH
	200;200;377
	JMP I [REASEM
	TAD (5
	DCA TEMP
	TAD I TEMP
	CLL
	TAD [200
	SNL CLA
	JMP I [REASEM
	TAD NO
	SNA CLA
	TAD [40		/SNA CLA
	TAD (7610	/SKP CLA
	DCA I TEMP
	JMP I TTLC

TTCTRL,	0
	JMS TTST1
	JMP I [NOTIMPL
	JMP I TTCTRL
TTWIDTH,0
	JMS GETWID
	JMS TTST1
	TAD NUM
	AND [7
	SZA CLA
	JMP I [BADWID
	TAD NUM
	TAD [-200
	SNA CLA
	JMP I [BADWID
	JMS I [SRCH
	200;200;7600
	JMP I [REASEM
	IAC
	DCA TEMP
	TAD I TEMP
	AND [177
	TAD (177+7200
	DCA T2
	TAD TEMP
	IAC
	DCA T3
	TAD NUM
	CIA
	DCA I T3
	TAD I T3
	DCA I T2
	JMP I TTWIDTH
GETWID,	0
	TAD NO
	SZA CLA
	JMP I [SYNTAX
	JMS OPTEQ
	JMS I [NUMBER
	SNA
	JMP I (BADWID
	DCA NUM
	TAD FLG
	SZA CLA
	JMP I [SYNTAX	/NO DIGITS
	TAD NUM
	AND [7400
	SZA CLA
	JMP I [NUMBIG
	JMP I GETWID

TTST1,	0
	JMS I (ASRTST
	TAD VNO
	JMS I [BRANCH
	-1;OLDERR
	-2;OLDERR
	-3;TTOK
	-4;TTOK		/V3C
	ZBLOCK 4
	0
	JMP I [NEWERR
TTOK,	JMP I TTST1
OPTEQ,	0
	JMS I [GETC
	TAD (-"=
	SZA CLA
	JMP NOE
	JMS I [SPACE
	JMP I OPTEQ
NOE,	JMS I [BACKC
	JMP I OPTEQ
	PAGE
BADWID,	JMS I [PRINT
	TEXT	/? ILLEGAL WIDTH/
	JMP I [GOAWAY

OPRIN,	0
	DCA N3
	TAD (-4
	DCA OKNT
OPLP,	TAD N3
	JMS DGP
	TAD N3
	RTL
	RAL
	DCA N3
	ISZ OKNT
	JMP OPLP
	JMP I OPRIN

DGP,	0
	RTL
	RTL
	AND [7
	TAD [60
	JMS I [TYPE
	JMP I DGP

OKNT,	0
N3,	0
NUM2,	0
GTEM,	0
SRCH,	0
	TAD I SRCH
	ISZ SRCH
	TAD (7200-1
	DCA XR1
	TAD I SRCH
	ISZ SRCH
	CIA
	DCA CNT
	TAD I SRCH
	CIA
	DCA TEMP
	ISZ SRCH
SRLUP,	TAD I XR1
	TAD TEMP
	SNA CLA
	JMP SRFND
	ISZ CNT
	JMP SRLUP
	JMP I SRCH
SRFND,	ISZ SRCH
	TAD XR1
	JMP I SRCH
GENLOC,	0
	TAD NO
	SZA CLA
	JMP I [SYNTAX
	JMS I [ONUM
	DCA NUM2
	TAD FLG
	SZA CLA
	JMP I [SYNTAX
	JMS I [GETC
	DCA TEMP
	TAD TEMP
	SNA
	JMP ENOL
	TAD (-"=
	SZA CLA
	JMP I [SYNTAX
ENOL,	TAD DHI
	SPA CLA
	TAD (-200
	TAD (-200
	CLL
	TAD NUM2
	SZL CLA
	JMP I [NUMBIG
	TAD NUM2
	TAD (7200	/BASE OF HANDLER
	DCA NUM2
	TAD TEMP
	SNA CLA
	JMP ODT
GETNEW,	JMS I [ONUM
	DCA NUM
	TAD FLG
	SZA CLA
	JMP I GENLOC
	JMS I [GETC
	SZA CLA
	JMP I [SYNTAX
	TAD NUM
	DCA I NUM2
	JMP I GENLOC
ODT,	TAD I NUM2
	JMS OPRIN
	TAD ("/
	JMS I [TYPE
	TAD I [READ
	DCA GTEM	/SAVE CHAIN STATUS
	JMS I [READ
	TAD [LINBUF
	DCA LINPTR
	TAD GTEM
	DCA I [READ
	JMP GETNEW
	PAGE
MTAPAR,	0
	TAD NO
	SZA CLA
	JMP I [SYNTAX
	JMS MTST1
	TAD LINPTR
	DCA SAVPTR
	TAD (EVEN
	JMS I [KEYSRCH
	SKP
	JMP SETE
	TAD SAVPTR
	DCA LINPTR
	TAD (ODD
	JMS I [KEYSRCH
	JMP I [SYNTAX
	TAD (400
SETE,	TAD (2
	DCA I (7200
	JMP I MTAPAR

MTST1,	0
	TAD VNO
	JMS I [BRANCH
	-1;OLDERR
	-2;OLDERR
	-3;OLDERR
	-4;MTOK
	-5;MTOK
	-6;MTOK
	ZBLOCK 4
	0
	JMP I [NEWERR
MTOK,	JMP I MTST1

MTADEN,	0
	JMS MTST1
	TAD NO
	SZA CLA
	JMP I [SYNTAX
	JMP I [NOTIMP
	JMP I MTADEN
MTAFIL,	0
	JMS MTST1
	TAD NO
	DCA I (7201
	JMP I MTAFIL

BADCOD,	JMS I [PRINT
	TEXT	/? UNKNOWN CARD CODE/
	JMP I [GOAWAY

/SUPPOSED TO WORK ON ALL VERSIONS

CDCODE,	0
	TAD NO
	SZA CLA
	JMP I [SYNTAX
	JMS I (OPTEQ
	JMS I [NUMBER
	TAD (-32	/026
	SNA
	JMP C026
	TAD (32-35	/029
	SZA CLA
	JMP BADCOD
	JMS CHANGE
	LIST1;LIST2
	JMP I CDCODE
C026,	JMS CHANGE
	LIST1;LIST3
	JMP I CDCODE
CHANGE,	0
	TAD I CHANGE
	DCA P1
	ISZ CHANGE
	TAD I CHANGE
	DCA P2
	ISZ CHANGE
CHLUP,	TAD I P1
	SNA
	JMP I CHANGE
	TAD (7200	/BASE OF HANDLER
	DCA P3
	TAD I P2
	DCA I P3
	ISZ P1
	ISZ P2
	JMP CHLUP

P1,	0
P2,	0
P3,	0
	PAGE
LIST1,	304;305;306
	314;315;316
	324;325;326;327
	334;335;336
	0

LIST2,	3203;4007;3502
	7514;0577;3637
	0104;1211;3374;0641
	7316;3410;1376

LIST3,	7735;4076;0774
	3314;1002;0305
	3204;1273;3606;1341
	3716;1175;3401
TECNAM,	FILENAME TECO.SV

TECO,	0
	DCA SA
	TAD (TECNAM
	DCA ARG1
	CLA IAC		/LOOKUP ON SYS
	CIF 10
	JMS I USR
	2
ARG1,	TECNAM		/STARTING BLOCK
	0
	JMP I TECO	/NOT FOUND
	TAD ARG1
	DCA BLKN
	JMS I (7607
	100		/READ 1 PAGE FROM TECO
	7000		/BUFFER
BLKN,	0
	JMP I [SYSERR
	TAD BLKN
	DCA BLKN2
	TAD SA
	DCA I (7002	/REL LOC 2 IS S.A.
	JMS I (7607
	4100
	7000
BLKN2,	0
	JMP I [SYSERR
	JMP I TECO

SA,	0
	PAGE

/7000-7177 BUFFER FOR TECO CCB
/7200-7577 BUFFER FOR HANDLER
	FIELD 0
	*200
	$