This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Porting/todo.pod: Add task to clean up pods
[perl5.git] / Porting / todo.pod
CommitLineData
7711098a
GS
1=head1 NAME
2
c3143508 3todo - Perl TO-DO list
7711098a
GS
4
5=head1 DESCRIPTION
e50bb9a1 6
049aabcb 7This is a list of wishes for Perl. The most up to date version of this file
c3143508 8is at L<http://perl5.git.perl.org/perl.git/blob_plain/HEAD:/Porting/todo.pod>
049aabcb
NC
9
10The tasks we think are smaller or easier are listed first. Anyone is welcome
11to work on any of these, but it's a good idea to first contact
12I<perl5-porters@perl.org> to avoid duplication of effort, and to learn from
13any previous attempts. By all means contact a pumpking privately first if you
14prefer.
e50bb9a1 15
0bdfc961
NC
16Whilst patches to make the list shorter are most welcome, ideas to add to
17the list are also encouraged. Check the perl5-porters archives for past
b4af8972
RB
18ideas, and any discussion about them. One set of archives may be found at
19L<http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/>
938c8732 20
617eabfa
NC
21What can we offer you in return? Fame, fortune, and everlasting glory? Maybe
22not, but if your patch is incorporated, then we'll add your name to the
23F<AUTHORS> file, which ships in the official distribution. How many other
24programming languages offer you 1 line of immortality?
938c8732 25
0865247f
KW
26=head1 Tasks that need only a little Perl knowledge
27
28=head2 Fix POD errors in Perl documentation
29
30Perl documentation is furnished in POD (Plain Old Documentation); see
31L<perlpod>. We also have a utility that checks for various errors in
32this documentation: F<t/porting/podcheck.t>. Unfortunately many files
33have errors in them, and there is a database of known problems, kept in
34F<t/porting/known_pod_issues.dat>. The most prevalent errors are lines
35too wide to fit in a standard terminal window, but there are more
36serious problems as well; and there are items listed there that are not
37in fact errors. The task would be to go through and clean up the
38documentation. This would be a good way to learn more about Perl.
39
0bdfc961 40=head1 Tasks that only need Perl knowledge
e50bb9a1 41
de2b17d8
NC
42=head2 Migrate t/ from custom TAP generation
43
44Many tests below F<t/> still generate TAP by "hand", rather than using library
96090e4f 45functions. As explained in L<perlhack/TESTING>, tests in F<t/> are
de2b17d8
NC
46written in a particular way to test that more complex constructions actually
47work before using them routinely. Hence they don't use C<Test::More>, but
48instead there is an intentionally simpler library, F<t/test.pl>. However,
49quite a few tests in F<t/> have not been refactored to use it. Refactoring
50any of these tests, one at a time, is a useful thing TODO.
51
0d8e5a42
RGS
52The subdirectories F<base>, F<cmd> and F<comp>, that contain the most
53basic tests, should be excluded from this task.
54
0be987a2
NC
55=head2 Automate perldelta generation
56
57The perldelta file accompanying each release summaries the major changes.
58It's mostly manually generated currently, but some of that could be
59automated with a bit of perl, specifically the generation of
60
61=over
62
63=item Modules and Pragmata
64
65=item New Documentation
66
67=item New Tests
68
69=back
70
71See F<Porting/how_to_write_a_perldelta.pod> for details.
72
0bdfc961 73=head2 Make Schwern poorer
e50bb9a1 74
613bd4f7 75We should have tests for everything. When all the core's modules are tested,
0bdfc961
NC
76Schwern has promised to donate to $500 to TPF. We may need volunteers to
77hold him upside down and shake vigorously in order to actually extract the
78cash.
3958b146 79
831efc5a
JK
80=head2 Write descriptions for all tests
81
82Many individual tests in the test suite lack descriptions (or names, or labels
83-- call them what you will). Many files completely lack descriptions, meaning
84that the only output you get is the test numbers. If all tests had
85descriptions, understanding what the tests are testing and why they sometimes
86fail would both get a whole lot easier.
87
0bdfc961 88=head2 Improve the coverage of the core tests
e50bb9a1 89
e1020413 90Use Devel::Cover to ascertain the core modules' test coverage, then add
02f21748 91tests that are currently missing.
30222c0f 92
0bdfc961 93=head2 test B
e50bb9a1 94
0bdfc961 95A full test suite for the B module would be nice.
e50bb9a1 96
0bdfc961 97=head2 A decent benchmark
e50bb9a1 98
617eabfa 99C<perlbench> seems impervious to any recent changes made to the perl core. It
0bdfc961
NC
100would be useful to have a reasonable general benchmarking suite that roughly
101represented what current perl programs do, and measurably reported whether
102tweaks to the core improve, degrade or don't really affect performance, to
103guide people attempting to optimise the guts of perl. Gisle would welcome
4e1c9055
NC
104new tests for perlbench. Steffen Schwingon would welcome help with
105L<Benchmark::Perl::Formance>
6168cf99 106
0bdfc961 107=head2 fix tainting bugs
6168cf99 108
0bdfc961
NC
109Fix the bugs revealed by running the test suite with the C<-t> switch (via
110C<make test.taintwarn>).
e50bb9a1 111
0bdfc961 112=head2 Dual life everything
e50bb9a1 113
0bdfc961
NC
114As part of the "dists" plan, anything that doesn't belong in the smallest perl
115distribution needs to be dual lifed. Anything else can be too. Figure out what
116changes would be needed to package that module and its tests up for CPAN, and
117do so. Test it with older perl releases, and fix the problems you find.
e50bb9a1 118
a393eb28
RGS
119To make a minimal perl distribution, it's useful to look at
120F<t/lib/commonsense.t>.
121
0bdfc961 122=head2 POSIX memory footprint
e50bb9a1 123
0bdfc961
NC
124Ilya observed that use POSIX; eats memory like there's no tomorrow, and at
125various times worked to cut it down. There is probably still fat to cut out -
126for example POSIX passes Exporter some very memory hungry data structures.
e50bb9a1 127
8c422da5
NC
128=head2 makedef.pl and conditional compilation
129
130The script F<makedef.pl> that generates the list of exported symbols on
131platforms which need this. Functions are declared in F<embed.fnc>, variables
132in F<intrpvar.h>. Quite a few of the functions and variables are conditionally
133declared there, using C<#ifdef>. However, F<makedef.pl> doesn't understand the
134C macros, so the rules about which symbols are present when is duplicated in
135the Perl code. Writing things twice is bad, m'kay. It would be good to teach
136F<.pl> to understand the conditional compilation, and hence remove the
137duplication, and the mistakes it has caused.
e50bb9a1 138
801de10e
NC
139=head2 use strict; and AutoLoad
140
141Currently if you write
142
143 package Whack;
144 use AutoLoader 'AUTOLOAD';
145 use strict;
146 1;
147 __END__
148 sub bloop {
149 print join (' ', No, strict, here), "!\n";
150 }
151
152then C<use strict;> isn't in force within the autoloaded subroutines. It would
153be more consistent (and less surprising) to arrange for all lexical pragmas
154in force at the __END__ block to be in force within each autoloaded subroutine.
155
773b3597
RGS
156There's a similar problem with SelfLoader.
157
91d0cbf6
NC
158=head2 profile installman
159
160The F<installman> script is slow. All it is doing text processing, which we're
161told is something Perl is good at. So it would be nice to know what it is doing
162that is taking so much CPU, and where possible address it.
163
c69ca1d4 164=head2 enable lexical enabling/disabling of individual warnings
a9ed9b74
JV
165
166Currently, warnings can only be enabled or disabled by category. There
167are times when it would be useful to quash a single warning, not a
168whole category.
91d0cbf6 169
85234543
KW
170=head2 document diagnostics
171
172Many diagnostic messages are not currently documented. The list is at the end
173of t/porting/diag.t.
174
0bdfc961 175=head1 Tasks that need a little sysadmin-type knowledge
e50bb9a1 176
0bdfc961
NC
177Or if you prefer, tasks that you would learn from, and broaden your skills
178base...
e50bb9a1 179
cd793d32 180=head2 make HTML install work
e50bb9a1 181
78b489b0 182There is an C<install.html> target in the Makefile. It's marked as
adebf063
NC
183"experimental". It would be good to get this tested, make it work reliably, and
184remove the "experimental" tag. This would include
185
186=over 4
187
188=item 1
189
190Checking that cross linking between various parts of the documentation works.
191In particular that links work between the modules (files with POD in F<lib/>)
192and the core documentation (files in F<pod/>)
193
194=item 2
195
78b489b0
NC
196Improving the code that split C<perlfunc> into chunks, preferably with
197general case code added to L<Pod::Functions> that could be used elsewhere.
198
617eabfa
NC
199Challenges here are correctly identifying the groups of functions that go
200together, and making the right named external cross-links point to the right
78b489b0
NC
201page. Currently this works reasonably well in the general case, and correctly
202parses two or more C<=items> giving the different parameter lists for the
203same function, such used by C<substr>. However it fails completely where
204I<different> functions are listed as a sequence of C<=items> but share the
205same description. All the functions from C<getpwnam> to C<endprotoent> have
206individual stub pages, with only the page for C<endservent> holding the
207description common to all. Likewise C<q>, C<qq> and C<qw> have stub pages,
208instead of sharing the body of C<qx>.
209
210Note also the current code isn't ideal with the two forms of C<select>, mushing
211them both into one F<select.html> with the two descriptions run together.
212Fixing this may well be a special case.
adebf063
NC
213
214=back
3a89a73c 215
0bdfc961
NC
216=head2 compressed man pages
217
218Be able to install them. This would probably need a configure test to see how
219the system does compressed man pages (same directory/different directory?
220same filename/different filename), as well as tweaking the F<installman> script
221to compress as necessary.
222
30222c0f
NC
223=head2 Add a code coverage target to the Makefile
224
225Make it easy for anyone to run Devel::Cover on the core's tests. The steps
226to do this manually are roughly
227
228=over 4
229
230=item *
231
232do a normal C<Configure>, but include Devel::Cover as a module to install
f11a3063 233(see L<INSTALL> for how to do this)
30222c0f
NC
234
235=item *
236
237 make perl
238
239=item *
240
241 cd t; HARNESS_PERL_SWITCHES=-MDevel::Cover ./perl -I../lib harness
242
243=item *
244
245Process the resulting Devel::Cover database
246
247=back
248
249This just give you the coverage of the F<.pm>s. To also get the C level
250coverage you need to
251
252=over 4
253
254=item *
255
256Additionally tell C<Configure> to use the appropriate C compiler flags for
257C<gcov>
258
259=item *
260
261 make perl.gcov
262
263(instead of C<make perl>)
264
265=item *
266
267After running the tests run C<gcov> to generate all the F<.gcov> files.
268(Including down in the subdirectories of F<ext/>
269
270=item *
271
272(From the top level perl directory) run C<gcov2perl> on all the C<.gcov> files
273to get their stats into the cover_db directory.
274
275=item *
276
277Then process the Devel::Cover database
278
279=back
280
281It would be good to add a single switch to C<Configure> to specify that you
282wanted to perform perl level coverage, and another to specify C level
283coverage, and have C<Configure> and the F<Makefile> do all the right things
284automatically.
285
02f21748 286=head2 Make Config.pm cope with differences between built and installed perl
0bdfc961
NC
287
288Quite often vendors ship a perl binary compiled with their (pay-for)
289compilers. People install a free compiler, such as gcc. To work out how to
290build extensions, Perl interrogates C<%Config>, so in this situation
291C<%Config> describes compilers that aren't there, and extension building
292fails. This forces people into choosing between re-compiling perl themselves
293using the compiler they have, or only using modules that the vendor ships.
294
295It would be good to find a way teach C<Config.pm> about the installation setup,
296possibly involving probing at install time or later, so that the C<%Config> in
297a binary distribution better describes the installed machine, when the
298installed machine differs from the build machine in some significant way.
299
728f4ecd
NC
300=head2 linker specification files
301
302Some platforms mandate that you provide a list of a shared library's external
303symbols to the linker, so the core already has the infrastructure in place to
4e1c9055
NC
304do this for generating shared perl libraries. Florian Ragwitz has been working
305to offer this for the GNU toolchain, to allow Unix users to test that the
728f4ecd 306export list is correct, and to build a perl that does not pollute the global
32d539f5 307namespace with private symbols, and will fail in the same way as msvc or mingw
4e1c9055 308builds or when using PERL_DL_NONLAZY=1. See the branch smoke-me/rafl/ld_export
728f4ecd 309
a229ae3b
RGS
310=head2 Cross-compile support
311
4e1c9055
NC
312We get requests for "how to cross compile Perl". The vast majority of these
313seem to be for a couple of scenarios:
314
315=over 4
316
317=item *
318
319Platforms that could build natively using F<./Configure> (I<e.g.> Linux or
320NetBSD on MIPS or ARM) but people want to use a beefier machine (and on the
321same OS) to build more easily.
322
323=item *
324
325Platforms that can't build natively, but no (significant) porting changes
326are needed to our current source code. Prime example of this is Android.
327
328=back
329
330There are several scripts and tools for cross-compiling perl for other
331platforms. However, these are somewhat inconsistent and scattered across the
332codebase, none are documented well, none are clearly flexible enough to
333be confident that they can support any TARGET/HOST plaform pair other than
334that which they were developed on, and it's not clear how bitrotted they are.
335
336For example, C<Configure> understands C<-Dusecrosscompile> option. This option
a229ae3b 337arranges for building C<miniperl> for TARGET machine, so this C<miniperl> is
4e1c9055
NC
338assumed then to be copied to TARGET machine and used as a replacement of
339full C<perl> executable. This code is almost 10 years old. Meanwhile, the
340F<Cross/> directory contains two different approaches for cross compiling to
341ARM Linux targets, relying on hand curated F<config.sh> files, but that code
342is getting on for 5 years old, and requires insider knowledge of perl's
343build system to draft a F<config.sh> for a new platform.
344
345Jess Robinson has sumbitted a grant to TPF to work on cleaning this up.
0bdfc961 346
98fca0e8
NC
347=head2 Split "linker" from "compiler"
348
349Right now, Configure probes for two commands, and sets two variables:
350
351=over 4
352
b91dd380 353=item * C<cc> (in F<cc.U>)
98fca0e8
NC
354
355This variable holds the name of a command to execute a C compiler which
356can resolve multiple global references that happen to have the same
357name. Usual values are F<cc> and F<gcc>.
358Fervent ANSI compilers may be called F<c89>. AIX has F<xlc>.
359
b91dd380 360=item * C<ld> (in F<dlsrc.U>)
98fca0e8
NC
361
362This variable indicates the program to be used to link
363libraries for dynamic loading. On some systems, it is F<ld>.
364On ELF systems, it should be C<$cc>. Mostly, we'll try to respect
365the hint file setting.
366
367=back
368
8d159ec1
NC
369There is an implicit historical assumption from around Perl5.000alpha
370something, that C<$cc> is also the correct command for linking object files
371together to make an executable. This may be true on Unix, but it's not true
372on other platforms, and there are a maze of work arounds in other places (such
373as F<Makefile.SH>) to cope with this.
98fca0e8
NC
374
375Ideally, we should create a new variable to hold the name of the executable
376linker program, probe for it in F<Configure>, and centralise all the special
377case logic there or in hints files.
378
379A small bikeshed issue remains - what to call it, given that C<$ld> is already
8d159ec1
NC
380taken (arguably for the wrong thing now, but on SunOS 4.1 it is the command
381for creating dynamically-loadable modules) and C<$link> could be confused with
382the Unix command line executable of the same name, which does something
383completely different. Andy Dougherty makes the counter argument "In parrot, I
384tried to call the command used to link object files and libraries into an
385executable F<link>, since that's what my vaguely-remembered DOS and VMS
386experience suggested. I don't think any real confusion has ensued, so it's
387probably a reasonable name for perl5 to use."
98fca0e8
NC
388
389"Alas, I've always worried that introducing it would make things worse,
390since now the module building utilities would have to look for
391C<$Config{link}> and institute a fall-back plan if it weren't found."
8d159ec1
NC
392Although I can see that as confusing, given that C<$Config{d_link}> is true
393when (hard) links are available.
98fca0e8 394
75585ce3
SP
395=head2 Configure Windows using PowerShell
396
397Currently, Windows uses hard-coded config files based to build the
398config.h for compiling Perl. Makefiles are also hard-coded and need to be
399hand edited prior to building Perl. While this makes it easy to create a perl.exe
400that works across multiple Windows versions, being able to accurately
401configure a perl.exe for a specific Windows versions and VS C++ would be
402a nice enhancement. With PowerShell available on Windows XP and up, this
403may now be possible. Step 1 might be to investigate whether this is possible
404and use this to clean up our current makefile situation. Step 2 would be to
405see if there would be a way to use our existing metaconfig units to configure a
406Windows Perl or whether we go in a separate direction and make it so. Of
407course, we all know what step 3 is.
408
0bdfc961
NC
409=head1 Tasks that need a little C knowledge
410
411These tasks would need a little C knowledge, but don't need any specific
412background or experience with XS, or how the Perl interpreter works
413
3d826b29
NC
414=head2 Weed out needless PERL_UNUSED_ARG
415
416The C code uses the macro C<PERL_UNUSED_ARG> to stop compilers warning about
417unused arguments. Often the arguments can't be removed, as there is an
418external constraint that determines the prototype of the function, so this
419approach is valid. However, there are some cases where C<PERL_UNUSED_ARG>
420could be removed. Specifically
421
422=over 4
423
424=item *
425
426The prototypes of (nearly all) static functions can be changed
427
428=item *
429
430Unused arguments generated by short cut macros are wasteful - the short cut
431macro used can be changed.
432
433=back
434
bcbaa2d5
RGS
435=head2 -Duse32bit*
436
437Natively 64-bit systems need neither -Duse64bitint nor -Duse64bitall.
438On these systems, it might be the default compilation mode, and there
439is currently no guarantee that passing no use64bitall option to the
440Configure process will build a 32bit perl. Implementing -Duse32bit*
e12cb30b 441options would be nice for perl 5.18.0.
bcbaa2d5 442
fee0a0f7 443=head2 Profile Perl - am I hot or not?
62403a3c 444
fee0a0f7
NC
445The Perl source code is stable enough that it makes sense to profile it,
446identify and optimise the hotspots. It would be good to measure the
447performance of the Perl interpreter using free tools such as cachegrind,
448gprof, and dtrace, and work to reduce the bottlenecks they reveal.
449
450As part of this, the idea of F<pp_hot.c> is that it contains the I<hot> ops,
451the ops that are most commonly used. The idea is that by grouping them, their
452object code will be adjacent in the executable, so they have a greater chance
453of already being in the CPU cache (or swapped in) due to being near another op
454already in use.
62403a3c
NC
455
456Except that it's not clear if these really are the most commonly used ops. So
fee0a0f7
NC
457as part of exercising your skills with coverage and profiling tools you might
458want to determine what ops I<really> are the most commonly used. And in turn
459suggest evictions and promotions to achieve a better F<pp_hot.c>.
62403a3c 460
91d0cbf6
NC
461One piece of Perl code that might make a good testbed is F<installman>.
462
a229ae3b 463=head2 Improve win32/wince.c
0bdfc961 464
a229ae3b 465Currently, numerous functions look virtually, if not completely,
c23989d1 466identical in both F<win32/wince.c> and F<win32/win32.c> files, which can't
6d71adcd
NC
467be good.
468
c5b31784
SH
469=head2 Use secure CRT functions when building with VC8 on Win32
470
471Visual C++ 2005 (VC++ 8.x) deprecated a number of CRT functions on the basis
472that they were "unsafe" and introduced differently named secure versions of
473them as replacements, e.g. instead of writing
474
475 FILE* f = fopen(__FILE__, "r");
476
477one should now write
478
479 FILE* f;
480 errno_t err = fopen_s(&f, __FILE__, "r");
481
482Currently, the warnings about these deprecations have been disabled by adding
483-D_CRT_SECURE_NO_DEPRECATE to the CFLAGS. It would be nice to remove that
484warning suppressant and actually make use of the new secure CRT functions.
485
486There is also a similar issue with POSIX CRT function names like fileno having
487been deprecated in favour of ISO C++ conformant names like _fileno. These
26a6faa8 488warnings are also currently suppressed by adding -D_CRT_NONSTDC_NO_DEPRECATE. It
c5b31784
SH
489might be nice to do as Microsoft suggest here too, although, unlike the secure
490functions issue, there is presumably little or no benefit in this case.
491
038ae9a4
SH
492=head2 Fix POSIX::access() and chdir() on Win32
493
494These functions currently take no account of DACLs and therefore do not behave
495correctly in situations where access is restricted by DACLs (as opposed to the
496read-only attribute).
497
498Furthermore, POSIX::access() behaves differently for directories having the
499read-only attribute set depending on what CRT library is being used. For
500example, the _access() function in the VC6 and VC7 CRTs (wrongly) claim that
501such directories are not writable, whereas in fact all directories are writable
502unless access is denied by DACLs. (In the case of directories, the read-only
503attribute actually only means that the directory cannot be deleted.) This CRT
504bug is fixed in the VC8 and VC9 CRTs (but, of course, the directory may still
505not actually be writable if access is indeed denied by DACLs).
506
507For the chdir() issue, see ActiveState bug #74552:
b4af8972 508L<http://bugs.activestate.com/show_bug.cgi?id=74552>
038ae9a4
SH
509
510Therefore, DACLs should be checked both for consistency across CRTs and for
511the correct answer.
512
513(Note that perl's -w operator should not be modified to check DACLs. It has
514been written so that it reflects the state of the read-only attribute, even
515for directories (whatever CRT is being used), for symmetry with chmod().)
516
16815324
NC
517=head2 strcat(), strcpy(), strncat(), strncpy(), sprintf(), vsprintf()
518
519Maybe create a utility that checks after each libperl.a creation that
520none of the above (nor sprintf(), vsprintf(), or *SHUDDER* gets())
521ever creep back to libperl.a.
522
523 nm libperl.a | ./miniperl -alne '$o = $F[0] if /:$/; print "$o $F[1]" if $F[0] eq "U" && $F[1] =~ /^(?:strn?c(?:at|py)|v?sprintf|gets)$/'
524
525Note, of course, that this will only tell whether B<your> platform
526is using those naughty interfaces.
527
2a930eea 528=head2 -D_FORTIFY_SOURCE=2
de96509d 529
2a930eea 530Recent glibcs support C<-D_FORTIFY_SOURCE=2> which gives
de96509d 531protection against various kinds of buffer overflow problems.
2a930eea 532It should probably be used for compiling Perl whenever available,
de96509d 533Configure and/or hints files should be adjusted to probe for the
2a930eea 534availability of these feature and enable it as appropriate.
16815324 535
8964cfe0
NC
536=head2 Arenas for GPs? For MAGIC?
537
538C<struct gp> and C<struct magic> are both currently allocated by C<malloc>.
539It might be a speed or memory saving to change to using arenas. Or it might
540not. It would need some suitable benchmarking first. In particular, C<GP>s
541can probably be changed with minimal compatibility impact (probably nothing
542outside of the core, or even outside of F<gv.c> allocates them), but they
543probably aren't allocated/deallocated often enough for a speed saving. Whereas
544C<MAGIC> is allocated/deallocated more often, but in turn, is also something
545more externally visible, so changing the rules here may bite external code.
546
3880c8ec
NC
547=head2 Shared arenas
548
549Several SV body structs are now the same size, notably PVMG and PVGV, PVAV and
550PVHV, and PVCV and PVFM. It should be possible to allocate and return same
551sized bodies from the same actual arena, rather than maintaining one arena for
552each. This could save 4-6K per thread, of memory no longer tied up in the
553not-yet-allocated part of an arena.
554
8964cfe0 555
6d71adcd
NC
556=head1 Tasks that need a knowledge of XS
557
558These tasks would need C knowledge, and roughly the level of knowledge of
559the perl API that comes from writing modules that use XS to interface to
560C.
561
e851c105
DG
562=head2 Write an XS cookbook
563
564Create pod/perlxscookbook.pod with short, task-focused 'recipes' in XS that
565demonstrate common tasks and good practices. (Some of these might be
566extracted from perlguts.) The target audience should be XS novices, who need
567more examples than perlguts but something less overwhelming than perlapi.
568Recipes should provide "one pretty good way to do it" instead of TIMTOWTDI.
569
5b7d14ff
DG
570Rather than focusing on interfacing Perl to C libraries, such a cookbook
571should probably focus on how to optimize Perl routines by re-writing them
572in XS. This will likely be more motivating to those who mostly work in
573Perl but are looking to take the next step into XS.
574
575Deconstructing and explaining some simpler XS modules could be one way to
576bootstrap a cookbook. (List::Util? Class::XSAccessor? Tree::Ternary_XS?)
577Another option could be deconstructing the implementation of some simpler
578functions in op.c.
579
0b162fb0 580=head2 Document how XSUBs can use C<cv_set_call_checker> to inline themselves as OPs
05fb4e20
NC
581
582For a simple XSUB, often the subroutine dispatch takes more time than the
0b162fb0
NC
583XSUB itself. v5.14.0 now allows XSUBs to register a function which will be
584called when the parser is finished building an C<entersub> op which calls
585them.
586
587Registration is done with C<Perl_cv_set_call_checker>, is documented at the
588API level in L<perlapi>, and L<perl5140delta/Custom per-subroutine check hooks>
589notes that it can be used to inline a subroutine, by replacing it with a
590custom op. However there is no further detail of the code needed to do this.
591It would be useful to add one or more annotated examples of how to create
592XSUBs that inline.
593
594This should provide a measurable speed up to simple XSUBs inside
05fb4e20
NC
595tight loops. Initially one would have to write the OP alternative
596implementation by hand, but it's likely that this should be reasonably
597straightforward for the type of XSUB that would benefit the most. Longer
598term, once the run-time implementation is proven, it should be possible to
599progressively update ExtUtils::ParseXS to generate OP implementations for
600some XSUBs.
601
318bf708
NC
602=head2 Remove the use of SVs as temporaries in dump.c
603
604F<dump.c> contains debugging routines to dump out the contains of perl data
605structures, such as C<SV>s, C<AV>s and C<HV>s. Currently, the dumping code
606B<uses> C<SV>s for its temporary buffers, which was a logical initial
607implementation choice, as they provide ready made memory handling.
608
609However, they also lead to a lot of confusion when it happens that what you're
610trying to debug is seen by the code in F<dump.c>, correctly or incorrectly, as
611a temporary scalar it can use for a temporary buffer. It's also not possible
612to dump scalars before the interpreter is properly set up, such as during
613ithreads cloning. It would be good to progressively replace the use of scalars
614as string accumulation buffers with something much simpler, directly allocated
615by C<malloc>. The F<dump.c> code is (or should be) only producing 7 bit
616US-ASCII, so output character sets are not an issue.
617
618Producing and proving an internal simple buffer allocation would make it easier
619to re-write the internals of the PerlIO subsystem to avoid using C<SV>s for
620B<its> buffers, use of which can cause problems similar to those of F<dump.c>,
621at similar times.
622
5d96f598
NC
623=head2 safely supporting POSIX SA_SIGINFO
624
625Some years ago Jarkko supplied patches to provide support for the POSIX
626SA_SIGINFO feature in Perl, passing the extra data to the Perl signal handler.
627
628Unfortunately, it only works with "unsafe" signals, because under safe
629signals, by the time Perl gets to run the signal handler, the extra
630information has been lost. Moreover, it's not easy to store it somewhere,
631as you can't call mutexs, or do anything else fancy, from inside a signal
632handler.
633
634So it strikes me that we could provide safe SA_SIGINFO support
635
636=over 4
637
638=item 1
639
640Provide global variables for two file descriptors
641
642=item 2
643
644When the first request is made via C<sigaction> for C<SA_SIGINFO>, create a
645pipe, store the reader in one, the writer in the other
646
647=item 3
648
649In the "safe" signal handler (C<Perl_csighandler()>/C<S_raise_signal()>), if
650the C<siginfo_t> pointer non-C<NULL>, and the writer file handle is open,
651
652=over 8
653
654=item 1
655
656serialise signal number, C<struct siginfo_t> (or at least the parts we care
657about) into a small auto char buff
658
659=item 2
660
661C<write()> that (non-blocking) to the writer fd
662
663=over 12
664
665=item 1
666
667if it writes 100%, flag the signal in a counter of "signals on the pipe" akin
668to the current per-signal-number counts
669
670=item 2
671
672if it writes 0%, assume the pipe is full. Flag the data as lost?
673
674=item 3
675
676if it writes partially, croak a panic, as your OS is broken.
677
678=back
679
680=back
681
682=item 4
683
684in the regular C<PERL_ASYNC_CHECK()> processing, if there are "signals on
685the pipe", read the data out, deserialise, build the Perl structures on
686the stack (code in C<Perl_sighandler()>, the "unsafe" handler), and call as
687usual.
688
689=back
690
691I think that this gets us decent C<SA_SIGINFO> support, without the current risk
692of running Perl code inside the signal handler context. (With all the dangers
693of things like C<malloc> corruption that that currently offers us)
694
695For more information see the thread starting with this message:
b4af8972 696L<http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2008-03/msg00305.html>
5d96f598 697
6d71adcd
NC
698=head2 autovivification
699
700Make all autovivification consistent w.r.t LVALUE/RVALUE and strict/no strict;
701
702This task is incremental - even a little bit of work on it will help.
703
704=head2 Unicode in Filenames
705
706chdir, chmod, chown, chroot, exec, glob, link, lstat, mkdir, open,
707opendir, qx, readdir, readlink, rename, rmdir, stat, symlink, sysopen,
708system, truncate, unlink, utime, -X. All these could potentially accept
709Unicode filenames either as input or output (and in the case of system
710and qx Unicode in general, as input or output to/from the shell).
711Whether a filesystem - an operating system pair understands Unicode in
712filenames varies.
713
714Known combinations that have some level of understanding include
715Microsoft NTFS, Apple HFS+ (In Mac OS 9 and X) and Apple UFS (in Mac
716OS X), NFS v4 is rumored to be Unicode, and of course Plan 9. How to
717create Unicode filenames, what forms of Unicode are accepted and used
718(UCS-2, UTF-16, UTF-8), what (if any) is the normalization form used,
719and so on, varies. Finding the right level of interfacing to Perl
720requires some thought. Remember that an OS does not implicate a
721filesystem.
722
723(The Windows -C command flag "wide API support" has been at least
724temporarily retired in 5.8.1, and the -C has been repurposed, see
725L<perlrun>.)
726
87a942b1
JH
727Most probably the right way to do this would be this:
728L</"Virtualize operating system access">.
729
6d71adcd
NC
730=head2 Unicode in %ENV
731
732Currently the %ENV entries are always byte strings.
87a942b1 733See L</"Virtualize operating system access">.
6d71adcd 734
799c141b
SH
735(See RT ticket #113536 for information on Win32's handling of %ENV,
736which was fixed to work with native ANSI codepage characters in the
737environment, but still doesn't work with other characters outside of
738that codepage present in the environment.)
739
1f2e7916
JD
740=head2 Unicode and glob()
741
742Currently glob patterns and filenames returned from File::Glob::glob()
87a942b1 743are always byte strings. See L</"Virtualize operating system access">.
1f2e7916 744
6d71adcd
NC
745=head2 use less 'memory'
746
747Investigate trade offs to switch out perl's choices on memory usage.
748Particularly perl should be able to give memory back.
749
750This task is incremental - even a little bit of work on it will help.
751
752=head2 Re-implement C<:unique> in a way that is actually thread-safe
753
754The old implementation made bad assumptions on several levels. A good 90%
755solution might be just to make C<:unique> work to share the string buffer
756of SvPVs. That way large constant strings can be shared between ithreads,
757such as the configuration information in F<Config>.
758
759=head2 Make tainting consistent
760
761Tainting would be easier to use if it didn't take documented shortcuts and
762allow taint to "leak" everywhere within an expression.
763
764=head2 readpipe(LIST)
765
766system() accepts a LIST syntax (and a PROGRAM LIST syntax) to avoid
767running a shell. readpipe() (the function behind qx//) could be similarly
768extended.
769
6d71adcd
NC
770=head2 Audit the code for destruction ordering assumptions
771
772Change 25773 notes
773
774 /* Need to check SvMAGICAL, as during global destruction it may be that
775 AvARYLEN(av) has been freed before av, and hence the SvANY() pointer
776 is now part of the linked list of SV heads, rather than pointing to
777 the original body. */
778 /* FIXME - audit the code for other bugs like this one. */
779
780adding the C<SvMAGICAL> check to
781
782 if (AvARYLEN(av) && SvMAGICAL(AvARYLEN(av))) {
783 MAGIC *mg = mg_find (AvARYLEN(av), PERL_MAGIC_arylen);
784
785Go through the core and look for similar assumptions that SVs have particular
786types, as all bets are off during global destruction.
787
749904bf
JH
788=head2 Extend PerlIO and PerlIO::Scalar
789
790PerlIO::Scalar doesn't know how to truncate(). Implementing this
791would require extending the PerlIO vtable.
792
793Similarly the PerlIO vtable doesn't know about formats (write()), or
794about stat(), or chmod()/chown(), utime(), or flock().
795
796(For PerlIO::Scalar it's hard to see what e.g. mode bits or ownership
797would mean.)
798
799PerlIO doesn't do directories or symlinks, either: mkdir(), rmdir(),
800opendir(), closedir(), seekdir(), rewinddir(), glob(); symlink(),
801readlink().
802
94da6c29
JH
803See also L</"Virtualize operating system access">.
804
d6c1e11f
JH
805=head2 Organize error messages
806
807Perl's diagnostics (error messages, see L<perldiag>) could use
a8d0aeb9 808reorganizing and formalizing so that each error message has its
d6c1e11f
JH
809stable-for-all-eternity unique id, categorized by severity, type, and
810subsystem. (The error messages would be listed in a datafile outside
c4bd451b
CB
811of the Perl source code, and the source code would only refer to the
812messages by the id.) This clean-up and regularizing should apply
d6c1e11f
JH
813for all croak() messages.
814
815This would enable all sorts of things: easier translation/localization
816of the messages (though please do keep in mind the caveats of
817L<Locale::Maketext> about too straightforward approaches to
818translation), filtering by severity, and instead of grepping for a
819particular error message one could look for a stable error id. (Of
820course, changing the error messages by default would break all the
821existing software depending on some particular error message...)
822
823This kind of functionality is known as I<message catalogs>. Look for
824inspiration for example in the catgets() system, possibly even use it
825if available-- but B<only> if available, all platforms will B<not>
de96509d 826have catgets().
d6c1e11f
JH
827
828For the really pure at heart, consider extending this item to cover
829also the warning messages (see L<perllexwarn>, C<warnings.pl>).
3236f110 830
0bdfc961 831=head1 Tasks that need a knowledge of the interpreter
3298bd4d 832
0bdfc961
NC
833These tasks would need C knowledge, and knowledge of how the interpreter works,
834or a willingness to learn.
3298bd4d 835
10517af5
JD
836=head2 forbid labels with keyword names
837
838Currently C<goto keyword> "computes" the label value:
839
840 $ perl -e 'goto print'
841 Can't find label 1 at -e line 1.
842
343c8006
JD
843It is controversial if the right way to avoid the confusion is to forbid
844labels with keyword names, or if it would be better to always treat
845bareword expressions after a "goto" as a label and never as a keyword.
10517af5 846
de6375e3
RGS
847=head2 truncate() prototype
848
849The prototype of truncate() is currently C<$$>. It should probably
850be C<*$> instead. (This is changed in F<opcode.pl>)
851
565590b5
NC
852=head2 error reporting of [$a ; $b]
853
854Using C<;> inside brackets is a syntax error, and we don't propose to change
855that by giving it any meaning. However, it's not reported very helpfully:
856
857 $ perl -e '$a = [$b; $c];'
858 syntax error at -e line 1, near "$b;"
859 syntax error at -e line 1, near "$c]"
860 Execution of -e aborted due to compilation errors.
861
862It should be possible to hook into the tokeniser or the lexer, so that when a
863C<;> is parsed where it is not legal as a statement terminator (ie inside
864C<{}> used as a hashref, C<[]> or C<()>) it issues an error something like
865I<';' isn't legal inside an expression - if you need multiple statements use a
866do {...} block>. See the thread starting at
b4af8972 867L<http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2008-09/msg00573.html>
565590b5 868
e053a921
RS
869=head2 strict as warnings
870
871See L<http://markmail.org/message/vbrupaslr3bybmvk>, where Josua ben Jore
872writes: I've been of the opinion that everything strict.pm does ought to be
873able to considered just warnings that have been promoted to 'FATAL'.
874
718140ec
NC
875=head2 lexicals used only once
876
877This warns:
878
879 $ perl -we '$pie = 42'
880 Name "main::pie" used only once: possible typo at -e line 1.
881
882This does not:
883
884 $ perl -we 'my $pie = 42'
885
886Logically all lexicals used only once should warn, if the user asks for
d6f4ea2e
SP
887warnings. An unworked RT ticket (#5087) has been open for almost seven
888years for this discrepancy.
718140ec 889
a3d15f9a
RGS
890=head2 UTF-8 revamp
891
85c006b6
KW
892The handling of Unicode is unclean in many places. In the regex engine
893there are especially many problems. The swash data structure could be
894replaced my something better. Inversion lists and maps are likely
895candidates. The whole Unicode database could be placed in-core for a
896huge speed-up. Only minimal work was done on the optimizer when utf8
897was added, with the result that the synthetic start class often will
898fail to narrow down the possible choices when given non-Latin1 input.
4e1c9055 899Karl Williamson has been working on this - talk to him.
a3d15f9a 900
636e63cb
NC
901=head2 state variable initialization in list context
902
903Currently this is illegal:
904
905 state ($a, $b) = foo();
906
a2874905 907In Perl 6, C<state ($a) = foo();> and C<(state $a) = foo();> have different
a8d0aeb9 908semantics, which is tricky to implement in Perl 5 as currently they produce
a2874905 909the same opcode trees. The Perl 6 design is firm, so it would be good to
a8d0aeb9 910implement the necessary code in Perl 5. There are comments in
a2874905
NC
911C<Perl_newASSIGNOP()> that show the code paths taken by various assignment
912constructions involving state variables.
636e63cb 913
a393eb28
RGS
914=head2 A does() built-in
915
916Like ref(), only useful. It would call the C<DOES> method on objects; it
917would also tell whether something can be dereferenced as an
918array/hash/etc., or used as a regexp, etc.
919L<http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2007-03/msg00481.html>
920
921=head2 Tied filehandles and write() don't mix
922
923There is no method on tied filehandles to allow them to be called back by
924formats.
4fedb12c 925
53967bb9
RGS
926=head2 Propagate compilation hints to the debugger
927
928Currently a debugger started with -dE on the command-line doesn't see the
929features enabled by -E. More generally hints (C<$^H> and C<%^H>) aren't
930propagated to the debugger. Probably it would be a good thing to propagate
931hints from the innermost non-C<DB::> scope: this would make code eval'ed
932in the debugger see the features (and strictures, etc.) currently in
933scope.
934
d10fc472 935=head2 Attach/detach debugger from running program
1626a787 936
cd793d32
NC
937The old perltodo notes "With C<gdb>, you can attach the debugger to a running
938program if you pass the process ID. It would be good to do this with the Perl
0bdfc961
NC
939debugger on a running Perl program, although I'm not sure how it would be
940done." ssh and screen do this with named pipes in /tmp. Maybe we can too.
1626a787 941
0bdfc961
NC
942=head2 LVALUE functions for lists
943
944The old perltodo notes that lvalue functions don't work for list or hash
945slices. This would be good to fix.
946
0bdfc961
NC
947=head2 regexp optimiser optional
948
949The regexp optimiser is not optional. It should configurable to be, to allow
950its performance to be measured, and its bugs to be easily demonstrated.
951
ef36c6a7
RGS
952=head2 C</w> regex modifier
953
954That flag would enable to match whole words, and also to interpolate
955arrays as alternations. With it, C</P/w> would be roughly equivalent to:
956
957 do { local $"='|'; /\b(?:P)\b/ }
958
b4af8972
RB
959See
960L<http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2007-01/msg00400.html>
ef36c6a7
RGS
961for the discussion.
962
0bdfc961
NC
963=head2 optional optimizer
964
965Make the peephole optimizer optional. Currently it performs two tasks as
966it walks the optree - genuine peephole optimisations, and necessary fixups of
967ops. It would be good to find an efficient way to switch out the
968optimisations whilst keeping the fixups.
969
970=head2 You WANT *how* many
971
972Currently contexts are void, scalar and list. split has a special mechanism in
973place to pass in the number of return values wanted. It would be useful to
974have a general mechanism for this, backwards compatible and little speed hit.
975This would allow proposals such as short circuiting sort to be implemented
976as a module on CPAN.
977
978=head2 lexical aliases
979
e12cb30b 980Allow lexical aliases (maybe via the syntax C<my \$alias = \$foo>).
0bdfc961 981
de535794 982=head2 Self-ties
2810d901 983
de535794 984Self-ties are currently illegal because they caused too many segfaults. Maybe
a8d0aeb9 985the causes of these could be tracked down and self-ties on all types
de535794 986reinstated.
0bdfc961
NC
987
988=head2 Optimize away @_
989
990The old perltodo notes "Look at the "reification" code in C<av.c>".
991
87a942b1
JH
992=head2 Virtualize operating system access
993
994Implement a set of "vtables" that virtualizes operating system access
995(open(), mkdir(), unlink(), readdir(), getenv(), etc.) At the very
996least these interfaces should take SVs as "name" arguments instead of
997bare char pointers; probably the most flexible and extensible way
e1a3d5d1
JH
998would be for the Perl-facing interfaces to accept HVs. The system
999needs to be per-operating-system and per-file-system
1000hookable/filterable, preferably both from XS and Perl level
87a942b1
JH
1001(L<perlport/"Files and Filesystems"> is good reading at this point,
1002in fact, all of L<perlport> is.)
1003
e1a3d5d1
JH
1004This has actually already been implemented (but only for Win32),
1005take a look at F<iperlsys.h> and F<win32/perlhost.h>. While all Win32
1006variants go through a set of "vtables" for operating system access,
e1020413 1007non-Win32 systems currently go straight for the POSIX/Unix-style
e1a3d5d1
JH
1008system/library call. Similar system as for Win32 should be
1009implemented for all platforms. The existing Win32 implementation
1010probably does not need to survive alongside this proposed new
1011implementation, the approaches could be merged.
87a942b1
JH
1012
1013What would this give us? One often-asked-for feature this would
94da6c29
JH
1014enable is using Unicode for filenames, and other "names" like %ENV,
1015usernames, hostnames, and so forth.
1016(See L<perlunicode/"When Unicode Does Not Happen">.)
1017
1018But this kind of virtualization would also allow for things like
1019virtual filesystems, virtual networks, and "sandboxes" (though as long
1020as dynamic loading of random object code is allowed, not very safe
1021sandboxes since external code of course know not of Perl's vtables).
1022An example of a smaller "sandbox" is that this feature can be used to
1023implement per-thread working directories: Win32 already does this.
1024
1025See also L</"Extend PerlIO and PerlIO::Scalar">.
87a942b1 1026
52960e22
JC
1027=head2 repack the optree
1028
1029Repacking the optree after execution order is determined could allow
057163d7 1030removal of NULL ops, and optimal ordering of OPs with respect to cache-line
2723c0fb 1031filling. I think that
057163d7
NC
1032the best way to do this is to make it an optional step just before the
1033completed optree is attached to anything else, and to use the slab allocator
2723c0fb
FC
1034unchanged--but allocate a single slab the right size, avoiding partial
1035slabs--, so that freeing ops is identical whether or not this step runs.
057163d7
NC
1036Note that the slab allocator allocates ops downwards in memory, so one would
1037have to actually "allocate" the ops in reverse-execution order to get them
1038contiguous in memory in execution order.
1039
b4af8972
RB
1040See
1041L<http://www.nntp.perl.org/group/perl.perl5.porters/2007/12/msg131975.html>
057163d7
NC
1042
1043Note that running this copy, and then freeing all the old location ops would
1044cause their slabs to be freed, which would eliminate possible memory wastage if
1045the previous suggestion is implemented, and we swap slabs more frequently.
52960e22 1046
12e06b6f
NC
1047=head2 eliminate incorrect line numbers in warnings
1048
1049This code
1050
1051 use warnings;
1052 my $undef;
1053
1054 if ($undef == 3) {
1055 } elsif ($undef == 0) {
1056 }
1057
18a16cc5 1058used to produce this output:
12e06b6f
NC
1059
1060 Use of uninitialized value in numeric eq (==) at wrong.pl line 4.
1061 Use of uninitialized value in numeric eq (==) at wrong.pl line 4.
1062
18a16cc5
NC
1063where the line of the second warning was misreported - it should be line 5.
1064Rafael fixed this - the problem arose because there was no nextstate OP
1065between the execution of the C<if> and the C<elsif>, hence C<PL_curcop> still
1066reports that the currently executing line is line 4. The solution was to inject
1067a nextstate OPs for each C<elsif>, although it turned out that the nextstate
1068OP needed to be a nulled OP, rather than a live nextstate OP, else other line
1069numbers became misreported. (Jenga!)
12e06b6f
NC
1070
1071The problem is more general than C<elsif> (although the C<elsif> case is the
1072most common and the most confusing). Ideally this code
1073
1074 use warnings;
1075 my $undef;
1076
1077 my $a = $undef + 1;
1078 my $b
1079 = $undef
1080 + 1;
1081
1082would produce this output
1083
1084 Use of uninitialized value $undef in addition (+) at wrong.pl line 4.
1085 Use of uninitialized value $undef in addition (+) at wrong.pl line 7.
1086
1087(rather than lines 4 and 5), but this would seem to require every OP to carry
1088(at least) line number information.
1089
1090What might work is to have an optional line number in memory just before the
1091BASEOP structure, with a flag bit in the op to say whether it's present.
1092Initially during compile every OP would carry its line number. Then add a late
1093pass to the optimiser (potentially combined with L</repack the optree>) which
1094looks at the two ops on every edge of the graph of the execution path. If
1095the line number changes, flags the destination OP with this information.
1096Once all paths are traced, replace every op with the flag with a
1097nextstate-light op (that just updates C<PL_curcop>), which in turn then passes
1098control on to the true op. All ops would then be replaced by variants that
1099do not store the line number. (Which, logically, why it would work best in
1100conjunction with L</repack the optree>, as that is already copying/reallocating
1101all the OPs)
1102
18a16cc5
NC
1103(Although I should note that we're not certain that doing this for the general
1104case is worth it)
1105
52960e22
JC
1106=head2 optimize tail-calls
1107
1108Tail-calls present an opportunity for broadly applicable optimization;
1109anywhere that C<< return foo(...) >> is called, the outer return can
1110be replaced by a goto, and foo will return directly to the outer
1111caller, saving (conservatively) 25% of perl's call&return cost, which
1112is relatively higher than in C. The scheme language is known to do
1113this heavily. B::Concise provides good insight into where this
1114optimization is possible, ie anywhere entersub,leavesub op-sequence
1115occurs.
1116
1117 perl -MO=Concise,-exec,a,b,-main -e 'sub a{ 1 }; sub b {a()}; b(2)'
1118
1119Bottom line on this is probably a new pp_tailcall function which
1120combines the code in pp_entersub, pp_leavesub. This should probably
1121be done 1st in XS, and using B::Generate to patch the new OP into the
1122optrees.
1123
e12cb30b 1124=head2 Add C<0odddd>
0c397127
KW
1125
1126It has been proposed that octal constants be specifiable through the syntax
1127C<0oddddd>, parallel to the existing construct to specify hex constants
1128C<0xddddd>
1129
bf7d9bd8
AC
1130=head2 Revisit the regex super-linear cache code
1131
1132Perl executes regexes using the traditional backtracking algorithm, which
1133makes it possible to implement a variety of powerful pattern-matching
1134features (like embedded code blocks), at the cost of taking exponential time
1135to run on some pathological patterns. The exponential-time problem is
1136mitigated by the I<super-linear cache>, which detects when we're processing
1137such a pathological pattern, and does some additional bookkeeping to avoid
1138much of the work. However, that code has bit-rotted a little; some patterns
1139don't make as much use of it as they should. The proposal is to analyse
1140where the current cache code has problems, and extend it to cover those cases.
1141
1142See also
1143L<http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2013-01/msg00339.html>
1144
0bdfc961
NC
1145=head1 Big projects
1146
1147Tasks that will get your name mentioned in the description of the "Highlights
e12cb30b 1148of 5.18.0"
0bdfc961
NC
1149
1150=head2 make ithreads more robust
1151
45a81a90 1152Generally make ithreads more robust.
0bdfc961
NC
1153
1154This task is incremental - even a little bit of work on it will help, and
1155will be greatly appreciated.
1156
07577ec1
FC
1157One bit would be to determine how to clone directory handles on systems
1158without a C<fchdir> function (in sv.c:Perl_dirp_dup).
6c047da7 1159
59c7f7d5
RGS
1160Fix Perl_sv_dup, et al so that threads can return objects.
1161
6bda09f9
YO
1162=head2 Add class set operations to regexp engine
1163
1164Apparently these are quite useful. Anyway, Jeffery Friedl wants them.
1165
1166demerphq has this on his todo list, but right at the bottom.
44a7a252
JV
1167
1168
1169=head1 Tasks for microperl
1170
1171
1172[ Each and every one of these may be obsolete, but they were listed
1173 in the old Todo.micro file]
1174
44a7a252
JV
1175=head2 do away with fork/exec/wait?
1176
1177(system, popen should be enough?)
1178
1179=head2 some of the uconfig.sh really needs to be probed (using cc) in buildtime:
1180
1181(uConfigure? :-) native datatype widths and endianness come to mind
1182