=head1 Plan of Attack

Why do we still have tcl.imc_template? should be generating tcllib.imc,
not tcl.imc. 

clean up expr so that it's not passing around
type indicators. - just use PMCs everywhere. This should speed us up quite
a bit, as it will reduce the need for an Array PMC for every operand.

tail call optimizations - there are several cases where I could use this
and save myself a call. Possible to do right now with PASM - wait for
PIR support before welding in.

Freeze/Thaw of TclWord would allow us to build a braindead compile
option - given a chunk of tcl, generate a chunk of PIR that we can 
emit to be saved, compiled, and then run again.

Look around and see if we can avoid doing as many substr's, particularly
in __parse. (every substring we don't actually need takes up more
resources. better to just index things until we're sure we need
the substring.

Clean up expr. MUUUUCH room for improvement there.

provide a way to access existing library PIR from Tcl.

Add benchmarks?

=over 4

When converting to Tcl*, be sure to take advantage of morphing. Right now,
we're kind of avoiding morphing. (like, having separate new PerlInt and 
PerlString conditionally depending on the code path.) (fixed in string)

=item Dynamic Tcl PMCs, build, switch.

Ok. First, we need to build the dyn pmcs using the new build "group" tag.

Then, we need to go through and eliminate all references to Perl:
(This is done for PerlInt, PerlString. Get rid of PerlHash, PerlArray)

We need to also make sure that we /take/ any PMC and try to do the right
thing. Don't /require/ that someone pass in a TclString when a PerlString
will work fine, thanks.

=item implement [list]

This should now be blindingly simple, given an actual TclList PMC.

=head1 TODO (big pile)

=over 4

=item given freeze/thaw for objects...

Once freeze/thaw is working for tclwords (currently waiting on parrot
support), rewrite proc to preparse
once and cache the result in the generated sub rather than reparsing
each time.

(Though this seems evil, too. There must be a better way.)

=item upvar, uplevel

set a global lexical level - normally inc'd whenever a UDF proc is called,
dec'd whenever a UDF is exited. 

Then, anything that set/get's a lexical should do so from the global level
that we're using.

	uplevel ?level? arg ?arg ...?
	upvar ?level? otherVar myVar ?otherVar myVar ...?

How do we do this and play nice with other languages? I don't think we can.

Language interoperability can presumably be dealt with after we've a language.

=item TclWord

implement C<is_const> to allow for some optimizations in the compiler.
when adding words, default to true, but if at any point we add a variable
or a command, invalidate that. (mostly done!)

Move TclWord namespace into _Tcl::Word, less clutter?

=item (LOW) varnames

Bitten by overuse of generic IMC vars like $I0 - should reduce their usage as
much as possible to simplify upkeep.

=item [[list]] proc

doesn't handle varargs.

support default values (e.g.: proc joe {{drink coffee}} { slurp $drink } )

=item compiler vs. interpreter

it should be possible to further extend our interpreter
this to make an actual compiler,
where the _compiler emits PIR. So, the resulting call from, say, [source]
would be:

	# Note this a change from _parse's current signature 
	(parsed_data_structure,tcl_status,error) = _parse(tcl_code)
	(pir_code,tcl_status,error) = _compile(parsed_data_structure)
	
And now that we have the pir_code, we can either emit the necessary
PIR (ala parrot's -o option) or we can compile and run it.

Caveat: how to support -o with user defined procs - right now, proc is defining
the sub on the fly, where, with a compiler, we may want to defer compilation,
and simply be able to extract the generated PIR.

=item (LOW) speed

Comparing examples/fact.tcl with parrot vs. tclsh (OSX)

 ??/??/??: 8-12 x slower, single call
 05/14/04: 500 calls in a loop slows us down to 60x!

=item Tests

Any future tests, write more like t/tcl_var_subst.t. Eventually cleanup
tests so they're consistent.

=item Add tests for...

tclword, [concat], [join]

=item 

update docs/* - with the parser/interpreter split, things are different.
(And, hopefully, easier.)

=item TCL Pmcs

Then, we can simplify anything that is dealing with numbers to just pass
around the Numbers.


Then, we need to verify that things like [expr 2a + 2b] fail to produce 4.
(That is, Tcl is pickier about numifying than Perl)

=item Dynamic PMCs

get new TCL pmcs to work dynamically, not just statically. This is actually
a big PITA, because of the inter-related PMCs.

(write tests for them)

=item test suite patches

need to patch testall so that it's not so cranky about people
who don't play nice with the new tests...

=item Tcl PMCs

NB: All this code was backed out (of tcl.imc, the dynclasses are still 
checked in) because of the issues with DYN Tcl PMCS!

TclLists now correctly promote natives to their respective types.
Now, fix TclArrays to do the same. (look for references to undef(),
replace with pmc_new(interp,enum_class_TclString) - we'll use the
TclString in the same way they use undef, to auto-morph to the right
value. Lazy, but effective.

Find the bits of code where we were specifically creating a TclString
before inserting it into a TclList, and remove them - should be
able to just add the string and have it JFW at this point.

=item TCL_Object

To simplfy the conversion code, We're going to pass around tcl_object
pmc's instead of strings, both as return values from procedures and
builtins, and pass them in to the strings as well. This will let us
get rid of all the conversion code that's everywhere, and just DTRT.

For now, get working with our current repetoire, strings, arrays, 
and ints. Once we have arrays working in this method, adding in lists
I<should> be a piece of cake. beg borrow and steal from the PerlScalar
implementation, as that does much the same thing we need to.

Ok. Strings, Ints and Floats should inter_convert without a problem.
There are Arrays and Lists also, which are NOT part of the TclObject
Hierarchy. Lists still don't autoconvert to strings, though they should
not sure how to autoconvert a string to a list... perhaps it should
happen automatically on keyed access (which right now does a substr)

Ok. All references to any Perl types (other than PerlUndef, which bears
investigation before we rip it out. - Probably used mainly on hash 
lookups - should ditch it and go with "return NULL;" in the pmcdef, and
then use isnull rather than our current PerlUndef check in IMC)

Now, go through all the commands, ops, and functions to cleanup how
we handle these objects - remember that TclList and TclArray are NOT
currently descended from tclobject, and this may bollux some things up.

=item SArray vs. PerlArray/TclList

investigate using SArray vs. TclList for speed. (many times we don't
know how many slots we're going to need ahead of time, though.) - looks like
we might be able to use them for the expression stuff that we are passing
around.... which, now that we have real Tcl PMCs, can probably go away

(most uses of PerlArray are gone, now that we are using foldup)

=item unfinished commands

[array set] - written - write tests.

[array statistics] - useless?

[array anymore], [array donesearch] [array nextelement], [array startsearch]
 { use iterators }

[global]

[string repeat], [string replace], [string tolower],
[string totitle], [string toupper], [string trim], [string trimleft],
[string trimright], [string compare], [string equal], [string last]

[string bytelength], [string compare], [sring is], [string map],
[string match], [string wordstart], [string wordend]

=item channels

keep track of channels, include stdin, stdout, stderr - keep in a
global hash of name to ParrotIO pmcs. Tie in with "puts" and other
chanel based commands. (some progress made here.)

=item given [list]

[foreach]

=item given REs

"string match" (it's glob-style, but easy to do given REs)

=item given [string match]

The following items require [string match] to be implemented: [array get],
[array names], [array unset]

=item given Unicode

Need unicode support for \u escapes, and for "string wordend",
"string wordstart", "string is", "string bytelength", 

This now works in parrot, modulo support for actually, oh, printing things
out.

=item given arrays

[string map]

=item expr

TBD: big rethunk.

TBD: octal, hex. (there's no way to convert programmatically from an
octal or hex string in parrot to a int?)

TBD: strings, floats as operaands - (many of the math funcs return floats
but you can't specify them, and not everything takes them 
(try, for example, [expr sin(1) + sin(1)] vs [expr sin(1) * sin(1)].)

TBD: blocks, commands, and strings as operands

TBD: logical binary ops & ternary op (need deferred evaluation) ; unary ops;
ops that work on strings only.

TBD: functions that take > 1 arg.

TBD: Argument type requirements - Currently works ONLY on bitand - esp need
to get any that require int-only args, as we can now /generate/ floats,
even if we cannot specify them.

=item misc

tclsh normally does some extra processing that we aren't doing, namely
.tclshrc/tclshrc.tcl, setting of variables argc, argv, argv0, and
tcl_interactive... see also "man n tclvars"

=item misc

interactive tclsh mode currently only waits for EOF and then runs all
commands entered. should have sane defaults for tcl_prompt1, tcl_prompt2
and respect them, and process intermediate input.

=item misc

octal, hex, and unicode escapes are not supported. (Not sure parrot is
ready for this yet)

=item tests 

run a tcl test suite (7.6p2 ?) and pass one test.
(then, pass most of them.) (then, retarget against tcl-latest)

=item misc

(aside - expression needs better error handling support, and perhaps
a rethunk on how we're passing data around - FYI, if we're going to be using
PerlInt, PerlNum, etc, we need to make sure they stringify as tcl
expects them to - a PerlNum of 5 -> "5" instead of "5.0", e.g.)

complete [error] (need global var support)

If the return type of the outermost script is not OK, return the
I<appropriate> code to the system.

=item misc

list variables - stringToList already exists (had to write it for "proc"s
argument handling.) - need to write listToString, need to be able to save
Lists as variables.  - This should now be possible, with the addition of the
Tcl* PMCs.

Expressions are a bit harder because we need an additional
bit of information. (is this an op, an operand, or "a chunk that is yet to
be evaluated)

=item missing procs

Here's a list of commands from the 7.3 Ousterhout book that have yet to be
implemented. Just because something is implemented doesn't mean it's a full
implementation, either. That's what the test suite is for. =-) I've tried
to group them so that any procs that depend on another proc to really work
are so listed, and that related procs are grouped together. Some are SMOPs
at this point, others require me to add features, or refactor. Many already
implemented procs will require updating after procs/features are added.

  upvar, uplevel  should be pretty easy with the lexical pad
    support in parrot. Well, upvar, anyway. implementing uplevel
    may require a rethunk. 

  foreach  {list}

  switch  {regexp regsub "string match"}

  list {llength, linsert, lreplace, lrange, lappend,
          lsearch, lsort, split}

  cd, file, pwd, pid, glob

  seek, tell, open, close, eof, flush, read, gets

  open close

  scan {list}

  info, exec {use exec/spawn opcodes.}

  auto_mkindex*, trace*

  unknown, history [ only in interactive mode ]

  regexp, regsub
 
  * isn't a recent distro of tcl
  
  And, here are more from a more recent tcl in no order.

  after bgerror binary case clock dde
  encoding fblocked fconfigure fcopy fileevent filename
  http interp {setup our current single interp as an object?}
  library lindex load lset memory
  msgcat namespace package packagens
  pkgMkIndex re_syntax registry resource
  safe socket subst tcltest
  update variable vwait
 
  also see "man n tclvars"

=item tests

Long term goal: Run the tcl test suite. Will an  older one, be easier to pass?
Yes, much easier. We still have a ways to go, however. To run all the tests,
run tclsh, sourcing "<tcl distro>tests/all".

The sooner we can do this, the better, as I only want to have tests for
internals, not for any Tcl.

=item 7.6 test suite

missing quite a bit to be able to think about running this, notably:

from all:

[foreach], [lsort], [glob], [string match], [puts stdout], catch

from incr, one of the (easier?) tests to pass:

[string compare], list, source, info, trace {is this still in tcl 8?}, 
concat

which calls "def", which uses:

$tcl_platform, [info exists] , [info commands], unset, array vars,
open, global, uplevel (GAH), regsub (GAH), fconfigure (GAH), file (GAH)
exec (GAH)


=item test commands

cmd_expr should check prededence, parens, etc, as well as all the
defined ops and functions.

=item test macros?

	is_space

=back 4

=cut
