[Oberon] Seeking ETHZ contact to find out licensing Oberon sources

[thutt at harp-project.com]

Hans Klaver writes:
 > Hi Taylor,
 >
 > Good to see you back after all those years!
 >
 > You wrote i.a.:
 > > Is anyone even interested in a classic Oberon-2 compiler and software?
 >
 >
 > I for one would certainly be interested in a command line Oberon-2
 > compiler with library modules targeting Linux and Raspberry Pi OS
 > (Raspbian).
 >

That's great to know.  Although I was distributing an MS-DOS based
Oberon system back in the early 90s, it was a different time.  I'd
like to make sure that I'm not violating any license that has been
applied since that time.

A bit more detail on the way I'm running Oberon now.  I don't want
folks to expect this is some fabulous system making native
executables....

  The Oberon system is mainly intact.  The Modules module normally
  starts Oberon.Loop, but it has been modified in the sources I am
  using to check for a <module>.<command> provided on the command
  line.  If no compliant commandline is provided, the system halts
  with an error.

  The commandline-provided command is executed.  For example:

    skl-oberon --instruction-count Prime.Execute

     ...
     1226.   9931
     1227.   9941
     1228.   9949
     1229.   9967
     1230.   9973
     Instruction Count: 2716906

  All the underlying Oberon-isms (such as file access) still exist,
  but I/O is limited to (file) 'I/O' and (console) 'O' at this time.
  There are no other devices.

  Access to the host OS is done through a 'vmsvc' (VM service)
  instruction in the virtual CPU.  This instruction is known to the
  intepreter, and special case handling is for each 'service' is
  programmed into the interpeter.  This means that the current number
  of native abilites are limited to what was necessary to bootstrap
  the system to a usable state.

  If I cannot find the license of the ETHZ source, I will still
  release the distribution.  In this case, I will only provide Obj and
  Sym files for files of unknown licenses, and the sources can be
  obtained separately by others, if desired.

  I have gotten permission to distribute Regis Crelier's compiler
  sources (which is the basis for this work), and I have another
  unfinished compiler which is based on Brandis' GSA work that I will
  release when I get it working again.

  Below is an example of everything that is currently built:

   LMSO SKL Compiler  TWH 2020.11.16
   SKLKernel.Mod compiling  Kernel   17556 bytes code      137 bytes data  (mem 3928K/3064K)
   SKLHostOS.Mod compiling  HostOS     352 bytes code        0 bytes data  (mem 3310K/3004K)
   Reals.Mod compiling  Reals    2916 bytes code        0 bytes data  (mem 3247K/2973K)
   SKLConsole.Mod compiling  Console    5804 bytes code        0 bytes data  (mem 3318K/3019K)
   SKLEnvironment.Mod compiling  Environment    3940 bytes code        4 bytes data  (mem 3313K/3010K)
   SKLFileDir.Mod compiling  FileDir   13356 bytes code        4 bytes data  (mem 3476K/3054K)
   Files.Mod compiling  Files   14984 bytes code        0 bytes data  (mem 3526K/3050K)
   DebugIO.Mod compiling  DebugIO    5880 bytes code       28 bytes data  (mem 3425K/3038K)
   SKLModuleInspector.Mod compiling      4420 bytes code       40 bytes data  (mem 3378K/3017K)
   SKLTrap.Mod compiling  Trap    6252 bytes code       16 bytes data  (mem 3408K/3049K)
   CommandLine.Mod compiling  CommandLine    2104 bytes code     4104 bytes data  (mem 3333K/3010K)
   SKLModules.Mod compiling  Modules   30332 bytes code       44 bytes data  (mem 3716K/3104K)
   Types.Mod compiling  Types    1732 bytes code        0 bytes data  (mem 3413K/3017K)
   Objects.Mod compiling  Objects   17392 bytes code      116 bytes data  (mem 3551K/3070K)
   Input.Mod compiling  Input     412 bytes code       44 bytes data  (mem 3333K/3007K)
   Display.Mod compiling  Display    8476 bytes code      184 bytes data  (mem 3543K/3047K)
   DisplayFrame.Mod compiling  DisplayFrame    1876 bytes code        0 bytes data  (mem 3342K/3023K)
   Fonts.Mod compiling  Fonts    8784 bytes code       12 bytes data  (mem 3526K/3105K)
   Texts.Mod compiling  Texts   43736 bytes code       44 bytes data  (mem 3995K/3126K)
   Viewers.Mod compiling  Viewers   11436 bytes code       20 bytes data  (mem 3537K/3046K)
   Oberon.Mod compiling  Oberon   12828 bytes code      206 bytes data  (mem 3746K/3163K)
   MenuViewers.Mod compiling  MenuViewers   15036 bytes code       12 bytes data  (mem 3682K/3083K)
   TextFrames.Mod compiling  TextFrames   50536 bytes code      188 bytes data  (mem 4064K/3168K)
   s3.System.Mod compiling  System   22532 bytes code       84 bytes data  (mem 4086K/3251K)
   KernelTD.Mod compiling  KernelTD     812 bytes code        0 bytes data  (mem 3499K/3000K)
   SKLERR.Mod compiling  SKLERR      12 bytes code        0 bytes data  (mem 3261K/2986K)
   SKLCMDIO.Mod compiling  SKLCMDIO    7620 bytes code      494 bytes data  (mem 3521K/3105K)
   SKLMD.Mod compiling  SKLMD    5520 bytes code       48 bytes data  (mem 3561K/3057K)
   SKLOS.Mod compiling  SKLOS    8876 bytes code      301 bytes data  (mem 3515K/3061K)
   SKLST.Mod compiling  SKLST   32092 bytes code      238 bytes data  (mem 3887K/3151K)
   SKLIE.Mod compiling  SKLIE   38344 bytes code     1139 bytes data  (mem 3973K/3144K)
   SKLT.Mod compiling  SKLT   18852 bytes code      288 bytes data  (mem 3881K/3155K)
   SKLTB.Mod compiling  SKLTB   16944 bytes code        0 bytes data  (mem 3837K/3179K)
   SKLDN.Mod compiling  SKLDN   19336 bytes code     2524 bytes data  (mem 3892K/3199K)
   SKLDS.Mod compiling  SKLDS    1224 bytes code        0 bytes data  (mem 3554K/3070K)
   SKLCGL.Mod compiling  SKLCGL   65972 bytes code      763 bytes data  (mem 4525K/3280K)
   SKLCGH.Mod compiling     82092 bytes code      240 bytes data  (mem 4701K/3288K)
   SKLTH.Mod compiling  SKLTH    2604 bytes code      148 bytes data  (mem 3878K/3207K)
   SKLTT.Mod compiling  SKLTT   27420 bytes code       96 bytes data  (mem 4114K/3262K)
   SKLPU.Mod compiling  SKLPU    4196 bytes code      424 bytes data  (mem 3809K/3167K)
   SKLTU.Mod compiling  SKLTU    7552 bytes code        8 bytes data  (mem 3865K/3251K)
   SKLSTP.Mod compiling  SKLSTP   21484 bytes code        0 bytes data  (mem 4130K/3252K)
   SKLE.Mod compiling  SKLE   34688 bytes code       28 bytes data  (mem 4191K/3198K)
   SKLSP.Mod compiling  SKLSP   31452 bytes code       10 bytes data  (mem 4148K/3214K)
   SKL.Mod compiling  SKL    3640 bytes code      300 bytes data  (mem 4081K/3331K)

 (That is one big compiler invocation.  Of particular note is that the
  GC is invoked between modules -- with open stack frames and local
  pointer variables on the stack.  The GC correctly marks / sweeps the
  stack, too (IIRC, ETHZ's implementation did not handle GC invocation
  with pointers on the stack).)

 Plus, there's the bootstrap loader (including interpreter), a
 disassembler and documentation.  The loader and disassembler are
 written in C/C++, but everything else is Oberon.

 I have three ultimate goals:

   o Make Oberon useful for interfacing with a host OS for
     various tasks.

   o Make the GSA compiler generate code for the virtual CPU.

   o <not ready to disclose>

 Anyone want to help?

thutt