On 19 Feb 2008 05:04:35 GMT, Andrew Reilly
<andrew-newspost@[EMAIL PROTECTED]
> wrote:
> On Mon, 18 Feb 2008 12:22:29 -0800, llothar wrote:
>
> > I think the most important for this would be a runtime that allows you
> > to program
> > in a C style with explicit memory management and without GC.
> If you're keen to program in C style with explicit memory management,
> then there are several (many!) choices available: most languages
designed
> before 1990 should fit the bill (but not most of the lisp family, of
> course). Fortran and Forth are extreme cases: only stack and globals.
Original Fortran did not allow recursion and so routine locals could
be, and often were, static not stack. Indeed one somewhat common
(though not standard) use of the ENTRY feature was for one call to set
(store into) static locals for use by subsequent calls, effectively
like routines of a module/package or methods of a singleton class.
Since F90 it also has dynamic (heap) allocation, with in some cases
implicit deallocation based on the same lifetime as stack variables,
but never GC; these features were actually in development before 1990.
Some Forths have per-task/thread/etc. data, called (a bit confusingly)
USER variables or data; I don't recall for sure if that started before
1990 but I think so. It also has at least two stacks (data and return)
and sometimes three (float-pt data separate from other data).
> Pascal or Modula-2 might suit an Eiffeler a little better. There's C,
C+
> + and Objective-C, of course. If you were really keen to manually
manage
> objects, it might be possible to use SmallEiffel with the "no-GC"
option:
> just allocate pools of objects at startup and be careful to *never* make
> a new object after that. Doesn't sound like much fun, IMO.
>
Ada might also be a possibility: fairly regular though mildly verbose
syntax (largely designed by an individual, with -- comments and
caseinsensitive!); emphasis on safety and robustness, with some
overrides for efficiency; several memory-management options from
implicit to explicit, theoretically allowing but not in practice using
GC; a dialect called SPARK using annotations to provide compile-time
proving; generics; exceptions. Ada05 added object-based invocation
syntax and multiple-interface-inheritance; 95 had previously added
single-inheritance polymorphism, for only marked types. Available as a
GCC-based (true-)compiler called GNAT originally forked but as of IIRC
4.1 about two years ago merged back to GCC trunk and thus available in
'vanilla' releases (under a modified GPL that allows you to use it on
non-libre), plus a small handful of commercial implementations.
- formerly david.thompson1 || achar(64) || worldnet.att.net
|
