1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
Always check out the latest perl5-porters discussions on these subjects
before embarking on an implementation tour.
Bugs
remove recursion in regular expression engine
fix memory leaks during compile failures
make signal handling safe
Tie Modules
VecArray Implement array using vec()
SubstrArray Implement array using substr()
VirtualArray Implement array using a file
ShiftSplice Defines shift et al in terms of splice method
Would be nice to have
pack "(stuff)*", "(stuff)?", "(stuff)+", "(stuff)4", ...
contiguous bitfields in pack/unpack
lexperl
bundled perl preprocessor/macro facility
this would solve many of the syntactic nice-to-haves
use posix calls internally where possible
gettimeofday (possibly best left for a module?)
format BOTTOM
-i rename file only when successfully changed
all ARGV input should act like <>
report HANDLE [formats].
support in perlmain to rerun debugger
regression tests using __DIE__ hook
lexically scoped functions: my sub foo { ... }
the basic concept is easy and sound,
the difficulties begin with self-referential
and mutually referential lexical subs: how to
declare the subs?
lexically scoped typeglobs? (lexical I/O handles work now)
wantlvalue? more generalized want()/caller()?
named prototypes: sub foo ($foo, @bar) { ... } ?
regression/sanity tests for suidperl
iterators/lazy evaluation/continuations/first/
first_defined/short-circuiting grep/??
This is a very thorny and hotly debated subject,
tread carefully and do your homework first
generalise Errno way of extracting cpp symbols and use that in
Errno, Fcntl, POSIX (ExtUtils::CppSymbol?)
the _r-problem: for all the {set,get,end}*() system database
calls (and a couple more: readdir, *rand*, crypt, *time,
tmpnam) there are in many systems the _r versions
to be used in re-entrant (=multithreaded) code
Icky things: the _r API is not standardized and
the _r-forms require per-thread data to store their state
cross-compilation support
host vs target: compile in the host, get the executable to
the target, get the possible input files to the target,
execute in the target (and do not assume a UNIXish shell
in the target! e.g. no command redirection can be assumed),
get possible output files back to to host. this needs to work
both during Configure and during the build. You cannot assume
shared filesystems between the host and the target (you may need
e.g. ftp), executing the target executable may involve e.g. rsh
a way to make << and >> to shift bitvectors instead of numbers
Possible pragmas
debugger
optimize (use less qw[memory cpu])
Optimizations
constant function cache
switch structures
foreach(reverse...)
cache eval tree (unless lexical outer scope used (mark in &compiling?))
rcatmaybe
shrink opcode tables via multiple implementations selected in peep
cache hash value? (Not a win, according to Guido)
optimize away @_ where possible
tail recursion removal
"one pass" global destruction
rewrite regexp parser for better integrated optimization
LRU cache of regexp: foreach $pat (@pats) { foo() if /$pat/ }
Vague possibilities
ref function in list context?
make tr/// return histogram in list context?
loop control on do{} et al
explicit switch statements
built-in globbing
compile to real threaded code
structured types
autocroak?
modifiable $1 et al
|
