Joe-Bob says, "Check it out!"


Topaz 0.10 includes LOTS of new stuff.  Most importantly, it actually
_runs_code_!  You have to build the Op tree by hand -- no parsing --
but still, doggone it, it's nice to have 'hello world' run!

Here's the ChangeLog entry:

        Short list:
        * Ops are now generated from '*.ops' files using the new Perl
          program 'tools/genops'.
        * Compilation infrastructure works: UserCode objects can be
          created Op by Op.  See  (No parsing yet.)
        * Runtime infrastructure works:
           > UserCode objects run.
           > Stack is flushed between statements.
           > Control structures nest.
           > Arbitrary cleanups can be registered (a la 'savestack').
           > Stack is of Values, not Scalars.  (duh)
        * Context (list/scalar) is supported, both statically
          (compile-time) and dynamically (run-time).
        * Command line processing works.
        * Debugging flags are available: '-Dt' and '-Ds'.
        * There is a beginning of diagnostics (warn and die), including
          '-w' and a framework for lexical warnings.
        * RealGlobScalar implements the equivalent of an SVt_GV that does
          _not_ have SVf_FAKE set -- i.e. it does aliasing when you assign
          to it.
        * Compatibility Note #1: I am no longer targeting Microsoft Visual
        C++.  The EGCS team have set themselves the goal of source
        compatibility with VC++, and they seem to already be most of the
        way there.  EGCS's support for MS's non-standard language features
        eliminates the final obstacle to our using it under Windows.

        * Compatibility Note #2: EGCS's standard library still doesn't
        quite have the hang of e.g. std::memcpy() vs. ::memcpy().  So you
        might have to tweak calls of <string.h> functions and other C
        Grody Details:

        * Inst classes implement run-time behavior of Ops.  Each
        compilation in progress has an arena for Ops and an area for
        Insts.  Once the Ops are all built, their compile() methods are
        called to create Insts in the Inst arena.  The Ops are then
        superfluous and can be deleted.  The Inst arena is then attached
        to the UserCode, _defining_ it.  At runtime, Insts are executed
        via their run() methods.  Insts are allocated sequentially from
        their arena, so there is usually no need for the equivalent of
        op_next.  (But heaven forfend an Inst multiply inherit!)

        * BasicInst.{hh,cc}: Some Insts are so basic that they don't
        necessarily come from corresponding Ops:
        NOP_Inst   (do nothing)
        EndInst    (stop a run loop)
        JumpInst   (low-level goto)
        MarkInst   (push a stack mark).

        * proto.ops defines prototype (test) ops for development:
        srcfile    (new source file)
        state      (new statement: flush stack, new source line)
        const      (constant value -- scalar only, for now anyway)
        glob       (*GLOBAL)
        glob_scalar ($GLOBAL)
        glob_array (@GLOBAL)
        glob_hash  (%GLOBAL)
        glob_code  (&GLOBAL)

        * math.ops defines math ops:
        add, subtract, multiply, divide, modulo

        * Some template trickery simplifies the declaration of
        smart pointers -- ValuePtr is now exactly the same as
Chip Salzenberg          - a.k.a. -           <[EMAIL PROTECTED]>
        "He's Mr. Big of 'Big And Tall' fame."  // MST3K

Reply via email to