[r6993]: sandbox / jlf / _diary.txt Maximize Restore History

Download this file

_diary.txt    990 lines (780 with data), 48.5 kB

  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
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
Sandbox for experimental work, some ideas to investigate :
Try to understand the internal locks.
--> added some dbgprintf (Windows and Linux), now must analyze...
Allow extension of the predefined ooRexx classes to get something similar to C# extension methods (but more powerful).
--> unlock the define method : see samples/functional for an example of use.
unlock the inherit method
added ::extension directive
>>-::EXTENSION--classname----+-------------------+-----------------><
+-INHERIT--iclasses-+
Add the "in" keyword to the DO repetitor : Similar to "over" but calls the method "supplier" instead of "makearray".
See if a thread could return more than one result and become a generator when synchronized with : do i in generator ...
--> done with .Coactivity
Export the classes instantiated by the parser and make expression instances available from an ooRexx script.
Inspired by C# LINQ and the expression tree API.
See if that can be used to write macros (i.e. transform expression tree), user directives, DSL...
Named parameters (by opposition to positional parameters).
In C#, they say it's useful for calling COM services.
I have some Excel macros that would be simpler to call with that.
--> I started to think about that, but it appears that the ooRexx arguments are not easy to manage by name.
It's because the arguments are not declared in a single place at the begining of a procedure/routine/method.
They can be declared several times, and complex expressions can be used (stem, instance's attribute, ...).
Moreover, named arguments can be passed in any order, and that's a problem with current management by array.
So, I give up...
Deferred evaluation of parameters.
Let the routine/method decide which parameters must be evaluated, ex : iif(cond, iftrue, ifalse)
Investigate the Activation stack (reify ? closure ? continuation ?)
Unicode ?
--> added support for wide-chars in oodialog.
--> in progress : m17n (but this is not the way proposed by Rick)
Extension of the message term : keyword and multiple dispatch.
http://atomo-lang.org/
http://slatelanguage.org/
===============================================================================
2011 june 13
More work on pipe.
.sort : refactoring of the internal helpers.
Now a single indexedValueComparator handles all the kinds of comparisons
(by value, by index, by expression).
.sort : added option 'strict'
.sort : can sort on several criteria.
The order in which the options are passed is the order in which they are executed.
A 'value' or 'index' or expression option is impacted only by the preceding options.
.inject : a limit can be specified with option recursive : recursive.10
===============================================================================
2011 june 09
More work on pipe.rex.
Added support to pass options to a pipeStage (use the blank operator) :
.myStage[arg1, arg2, ...] option1 option2 ...
.sort : added options byValue, byIndex, ascending, descending, caseless, quickSort.
.sortWith : added option quickSort.
.inject : added option recursive.
In case of infinite recursion, the recursion is stopped. This is detected
by keeping a stack of items already processed.
===============================================================================
2011 june 09
The alternate syntax [] for pipeStage gave me the idea to do the same for the yield
method of the coactivity class.
.yield[value]
is equivalent to (and more compact than)
.Coactivity~yield(value)
Remember : the blank operator would be still more compact,
.yield value
but unfortunately a result is mandatory (an operator is not a message instruction),
and that triggers a command if the result is not used... So forget this syntax.
Side note : I start to find this triggering of commands seriously annoying !
Too easy to trigger a command accidentaly. Yes, I could use a security manager, but
would be tedious to put it *everywhere*.
To investigate : a message instruction can trigger a command only if surrounded by ().
Not possible to apply this rule all the time, including expressions ?
rm "*".lst --> the string "rm *.lst" would be assigned to the variable RESULT.
(rm "*".lst) --> the string "rm *.lst" would be submitted as a command to the external environment.
That way, the programmer controls explicitely where a command can be triggered.
Code review :
SourceFile.cpp
RexxSource::instruction
this->messageNew
RexxSource::messageNew
new RexxInstructionMessage
this->commandNew
RexxSource::commandNew
_expression = this->expression(TERM_EOC)
RexxSource::expression
this->subExpression(terminators)
new RexxInstructionCommand
InstructionParser.cpp
RexxInstructionCommand
RexxSource::commandNew
expression = this->expression(TERM_EOC)
MessageInstruction.cpp
RexxInstructionMessage::execute (assign the RESULT variable)
CommandInstruction.cpp
RexxInstructionCommand::execute
RexxObject *result = this->expression->evaluate(context, stack);
***HERE*** could decide to assign result to RESULT instead of triggering command
RexxString *command = REQUEST_STRING(result); /* force to string form */
context->command(context->getAddress(), command);
Side note :
A message term can have one of the following forms :
receiver~messagename:symbol(expression, ...)
receiver~~messagename:symbol(expression, ...)
receiver[expression, ...]
The receiver is a term.
Would it make sense to add that ?
receiver(expression, ...)
Probably not, according to my tests :
.c~"()" -- the method "()" is called
.c() -- could not find routine ".C"
::class c
::method "()" class
A function call is a term in an expression calling a routine.
function_name(expression, ...)
The function_name is a literal string or a single symbol, which is taken to be a constant.
So no way to have something similar to the C++ operator().
===============================================================================
2011 may 29
Modified pipe.rex to keep the index information of the collection passed as argument to ~go.
Useful when working with a collection of methods, where the name of the methods is available
only through the indexes.
Added the extension ~pipe to all objects.
myObject~pipe(myPipeline)
Added extensions to pipe.rex, to benefit from doers :
inject
do
select
Added the extension ~each to all the collections.
Added the extensions ~each and ~reduce to the suppliers.
Fixed a bug in rgf_util2 :
dump2 was not working with suppliers, because ~items was called.
Concurrency trace : report information about ovd, even if not yet assigned to the RexxActivation.
See getReserveCount and getVariableDictionary in RexxActivation.hpp.
Debug of semaphores : the variable name was overwritten, fixed.
===============================================================================
2011 may 29
Adaptation of concurrency trace to support 64 bits pointers.
Now, concurrency trace is displayed only when env variable RXTRACE_CONCURRENCY=ON
The debug messages for semaphores and mutexes are very costly : about 400 times
slower than main/trunk... Now, those messages are controlled by conditional
compilation, and activated only in debug configuration.
Slow learning curve of xcode4 under MacOsX, experimentation of several configurations :
gcc/debug
$oorexx_src_dir/configure --prefix=$oorexx_delivery CFLAGS="-g -O0 -D_DEBUG" CXXFLAGS="-g -O0 -D_DEBUG"
gcc/default :
$oorexx_src_dir/configure --prefix=$oorexx_delivery
gcc/release
$oorexx_src_dir/configure --prefix=$oorexx_delivery CFLAGS="-g -O3" CXXFLAGS="-g -O3"
Currently using gcc only, but plan to test llvmgcc.
Each configuration is initialized by running a shell script located in the appropriate delivery folder.
If debug from xcode4 is needed, then must launch xcode4 from the config's shell : open -a xcode4
The directory layout is like that :
oorexx
build
main
trunk
gcc
default : run configure here
sandbox
jlf
trunk
gcc
debug : run configure here
default : run configure here
release : run configure here
delivery
main
trunk
gcc
default : setenv.sh to declare config variables
sandbox
jlf
trunk
gcc
debug : setenv.sh to declare config variables
default : setenv.sh to declare config variables
release : setenv.sh to declare config variables
svn
main
trunk
sandbox
jlf
trunk
===============================================================================
2011 mar 18
Added an early traceEntry for proper diagnostic in case of deadlock of guarded method.
See test cases in samples/concurrency :
deadlock1.rex
deadlock2.rex
Fixed in RexxActivation::run
===============================================================================
2011 mar 17
I have a small problem with doers :
Any routine/method created by StringDoer will have a lookup scope limited to the
doers package, because the routines/methods are created from the doers package,
not from the caller's package.
StringDoer~doer accepts a context parameter to let the caller pass its own lookup scope,
but this is tedious to pass it explicitely at each call.
Example from oorexxshell :
say .color -- The COLOR class
"say .color"~doer~do -- .COLOR because the COLOR class is not visible from doers
"say .color"~doer(.context)~do -- The COLOR class
I provide the convenience routine "Doers.AddVisibilityFrom" which lets see from doers
the same packages/methods/routines as the caller.
Usage from caller's package :
call Doers.AddVisibilityFrom(.context)
::requires "extension/doers.cls"
With this sequence, no need to pass explicitely the .Context when creating a doer :
"say .color"~doer~do -- The COLOR class
This problem would not exist if we had support for first-class expressions/instructions
that are parsed in place, instead of being parsed by StringDoer.
https://sourceforge.net/mailarchive/message.php?msg_id=19911593
https://sourceforge.net/mailarchive/message.php?msg_id=19912031
The proposed syntax [expr] lets defer the evaluation of expr, but is not supposed to
support instructions (why not ?).
Maybe
c = .Coactivity~new("do i = 1 to 10 ; .Coactivity~yield(i) ; end")
could become
c = .Coactivity~new([do i = 1 to 10 ; .Coactivity~yield(i) ; end])
In this case, the context is the "good" context, i.e. the context of the place from where
the block is parsed. The distinction expression/instructions is similar to the distinction
eval/apply in Lisp : You evaluate an expression, you apply a method/routine to a list of
arguments.
===============================================================================
2011 mar 17
m17n :
Don't use strong types by default, because gcc can't compile as-is.
Fixed compilation errors under Linux.
===============================================================================
2011 mar 16
I learned recently that ooRexx manages nested guard conditions...
So, I added new informations in the trace output :
- variable dictionary id (3rd column)
- nesting counter (4th column)
Raw trace, generated by rexx :
00004fec 7efc0fb0 7efc10f0 00001* 79 *-* if start
00004fec 7efc0fb0 7efc10f0 00001* >V> START => "1"
00004fec 7efc0fb0 7efc10f0 00001* >>> "1"
00004fec 7efc0fb0 7efc10f0 00001* 79 *-* then
00004fec 7efc0fb0 7efc10f0 00001* 79 *-* self~start
00004fec 7efc0fb0 7efc10f0 00001* >V> SELF => "a Coactivity"
00004fec 7efc9918 7efc10f0 00002* >I> Method START with scope "The Coactivity class" in package D:\local\Rexx\ooRexx\svn\sandbox\jlf\samples\concurrency\coactivity.cls
...
00004fec 7efc9918 7efc10f0 00002* 93 *-* reply self
00004fec 7efc9918 7efc10f0 00002* >V> SELF => "a Coactivity"
00004fec 7efc9918 7efc10f0 00002* >>> "a Coactivity"
00004fec 7efc0fb0 7efc10f0 00001* >>> "a Coactivity"
00004fec 7eee9be8 00000000 00000 >M> "NEW" => "a Coactivity"
0000478c 7efc9918 7efc10f0 00001* >I> Method START with scope "The Coactivity class" in package D:\local\Rexx\ooRexx\svn\sandbox\jlf\samples\concurrency\coactivity.cls
00004fec 7eee9be8 00000000 00000 >>> "a Coactivity"
0000478c 7efc9918 7efc10f0 00001* 94 *-* .Activity~local~empty
Human readable trace, generated by rexx trace/tracer using raw trace as input :
T1 A4 V2 1* 79 *-* if start
T1 A4 V2 1* >V> START => "1"
T1 A4 V2 1* >>> "1"
T1 A4 V2 1* 79 *-* then
T1 A4 V2 1* 79 *-* self~start
T1 A4 V2 1* >V> SELF => "a Coactivity"
T1 A5 V2 2* >I> Method START with scope "The Coactivity class" in package D:\local\Rexx\ooRexx\svn\sandbox\jlf\samples\concurrency\coactivity.cls
...
T1 A5 V2 2* 93 *-* reply self
T1 A5 V2 2* >V> SELF => "a Coactivity"
T1 A5 V2 2* >>> "a Coactivity"
T1 A4 V2 1* >>> "a Coactivity"
T1 A3 >M> "NEW" => "a Coactivity"
T2 A5 V2 1* >I> Method START with scope "The Coactivity class" in package D:\local\Rexx\ooRexx\svn\sandbox\jlf\samples\concurrency\coactivity.cls
T1 A3 >>> "a Coactivity"
T2 A5 V2 1* 94 *-* .Activity~local~empty
===============================================================================
2011 mar 10
Implemented an emulation of coroutine, named "coactivity" to follow the ooRexx
vocabulary. This is not a "real" coroutine implementation, because it's based on
ooRexx threads and synchronization. But at least you have all the functionalities
of a stackful asymmetric coroutine (resume + yield). All is in place to support
symmetric coroutines (yield only), but the scheduler remains to implement.
For a better support of coactivity, I'm thinking to modify the interpreter :
Arguments can be passed by the consumer when he resumes a coactivity.
For the first resume, the traditional arguments declaration can be used on the producer side.
But for the following resumes, it's less declarative : you get only an array returned by yield.
I'd like to use the traditional arguments declaration everywhere...
consumer : res = coactivity~resume(arg1, arg2)
res = coactivity~resume(arg1, arg2)
...
producer : use strict arg arg1, arg2
res = f(arg1, arg2)...
args = coactivity~yield(res) --> returns an array of arguments
use strict arg arg1, arg2 --> but this array of arguments can't be read that way
...
For an example of coroutine implementation for the HotSpot JVM, see :
http://ssw.jku.at/Research/Papers/Stadler11Master
I found the reading interesting because :
- Java, like ooRexx, has synchronized threads.
- Java, like ooRexx, doesn't support real coroutines.
- With the proposed implementation for JVM, operations on coroutines implicitly always
operate on the current thread. This allows the system to assume that only a minimal amount
of synchronization is necessary.
===============================================================================
2011 mar 10
For all scripts under jlf/sandbox/samples, use path relative to samples in requires,
assuming the path to samples will be in the PATH.
Refactoring of extension :
- Separation between code for standard ooRexx (in subdirectory std), and sandbox.
- Removed factory.rex : can be replaced by ~enhanced
- When ~enhanced can't be used then use delegation
Current pattern for standard ooRexx, to extend a predefined class, assuming that
the name of the predefined class is "ClassName", and the name of the extension
is "Extension" (no need of that with ::extension) :
::class ClassNameExtension mixinclass Object public
::method init
expose className -- optional : an encapsulated instance of the predefined class
use arg className=.nil
::method myMethod
expose className
if var("className"), className <> .nil then self = className -- delegates to the encapsulated instance
-- here your extension code which depends on self
::class ExtendedClassName subclass ClassName public inherit ClassNameExtension1 ClassNameExtension2 ...
The level of integration brougth by extension/std is poor compared to the integration with ::extension !
Most of the time, you will create instances of your extended class.
Ex : .ExtendedString~new("say 2*arg(1)")~doer~do(10) -- display 20
But sometimes, you must work with instances returned by the interpreter, and you can't create an instance
of your extended class. In this case, you create an instance of your extension mixin which encapsulates the
instance returned by the interpreter.
Ex : routine = .context~package~findRoutine("multiply_by_2")
doer = .RoutineDoer~new(routine)
doer~do(10) -- display 20
::routine multiply_by_2
say 2*arg(1)
===============================================================================
2011 mar 09
Send the trace output to the debug output.
Made the debug output of SysSemaphore and SysMutex compatible with trace output.
Now I get the trace lines and the interpreter locks in the same stream, and I can
parse them with tracer.rex (could be faster, but...).
0001eab4 7eff0af8 * 89 *-* reply self
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.release : before ReleaseMutex(0x1fb4) from ActivityManager::unlockKernel (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.release : after ReleaseMutex(0x1fb4) from ActivityManager::unlockKernel (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.requestImmediate : before WaitForSingleObject(0x1fb4) from ActivityManager::lockKernelImmediate (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.requestImmediate : after WaitForSingleObject(0x1fb4) from ActivityManager::lockKernelImmediate (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.release : before ReleaseMutex(0x1fb4) from ActivityManager::unlockKernel (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.release : after ReleaseMutex(0x1fb4) from ActivityManager::unlockKernel (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.requestImmediate : before WaitForSingleObject(0x1fb4) from ActivityManager::lockKernelImmediate (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.requestImmediate : after WaitForSingleObject(0x1fb4) from ActivityManager::lockKernelImmediate (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.release : before ReleaseMutex(0x1fb4) from ActivityManager::unlockKernel (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.release : after ReleaseMutex(0x1fb4) from ActivityManager::unlockKernel (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.requestImmediate : before WaitForSingleObject(0x1fb4) from ActivityManager::lockKernelImmediate (0x55dec0)
0001eab4 00000000 ...... ... (SysMutex)ActivityManager::kernelSemaphore.requestImmediate : after WaitForSingleObject(0x1fb4) from ActivityManager::lockKernelImmediate (0x55dec0)
0001eab4 7eff0af8 * >V> SELF => "a COACTIVITY"
===============================================================================
2011 feb 27
Implemented the script samples\trace\tracer.rex.
This script lets :
- replace hexadecimal values by more human-readable values like T1, A1.
- generate a CSV file, for further analysis with your favorite tool.
Can be used as a pipe filter (reads from stdin) :
rexx my_traced_script.rex 2>&1 | rexx tracer
or can read from a file :
rexx tracer -csv my_trace_file.txt
===============================================================================
2011 feb 24
Added thread id, activation id and lock flag in the lines printed by trace.
Should help to analyze the traces of a multithreaded script.
Not sure yet to have covered all the cases, since I modified only this method :
RexxActivity::traceOutput
But looks good on my first tests.
The extract below illustrates quite well the problem of interleaved traces.
See after the reply, two threads are running concurrently.
coroutine~start -- guarded
coroutine~resume -- unguarded
0000ccac 7efcae78 * >I> Method START with scope "The COROUTINE class" in package D:\local\Rexx\ooRexx\svn\sandbox\jlf\samples\generator\coroutine.cls
...<snip>...
0000ccac 7efcae78 * 92 *-* status = .Coroutine~suspended
0000ccac 7efcae78 * >E> .COROUTINE => "The COROUTINE class"
0000ccac 7efcae78 * >M> "SUSPENDED" => "1"
0000ccac 7efcae78 * >>> "1"
0000ccac 7efcae78 * >=> STATUS <= "1"
0000ccac 7efcae78 * 93 *-* guard off
0000ccac 7efcae78 94 *-* reply self
0000ccac 7efcae78 >V> SELF => "a COROUTINE"
0000ccac 7efcae78 >>> "a COROUTINE"
0000c8dc 7efcae78 >I> Method START with scope "The COROUTINE class" in package D:\local\Rexx\ooRexx\svn\sandbox\jlf\samples\generator\coroutine.cls
0000ccac 7efd0968 >I> Method RESUME with scope "The COROUTINE class" in package D:\local\Rexx\ooRexx\svn\sandbox\jlf\samples\generator\coroutine.cls
0000c8dc 7efcae78 95 *-* signal on any
0000ccac 7efd0968 162 *-* expose status yieldValue
0000c8dc 7efcae78 96 *-* guard on when status <> .Coroutine~suspended
0000ccac 7efd0968 163 *-* if status == .Coroutine~notStarted
0000c8dc 7efcae78 * >V> STATUS => "1"
0000ccac 7efd0968 >V> STATUS => "1"
If you redirect the stderr to a file, and open it with Excel, then you can filter by thread and/or by activation.
===============================================================================
2010 nov 14
I have reached a state where the interpreter is no longer broken by m17n.
The most difficult bugs were because of the default constructor of rxStringSize.
By assigning 0 (a good practice for me), I had nasty bugs in the parser.
Solved by leaving the attribute uninitialized...
Remember :
RexxSource::sayNew
RexxObject *_expression = this->expression(TERM_EOC);
RexxInstruction *newObject = new_instruction(SAY, Say); <-- location is copied from this->clause by RexxSource::sourceNewObject
new ((void *)newObject) RexxInstructionSay(_expression); <-- boom ! location is overwritten by default constructor of rxStringSize
inline RexxBuffer *new_buffer(sizeB_t s) { return new (size_v(s)) RexxBuffer; } <-- bufferSize and dataLength were always 0 !
void *RexxBuffer::operator new(size_t size, size_t _length)
newBuffer->bufferSize = _length; <-- initialized here, *before* the execution of default constructor
newBuffer->dataLength = _length; <-- same problem
Now, the next step is probably to change the signature of the methods in StringUtil,
to pass a IRexxString parameter, instead of a couple (char*, size_t) which are the
internal attributes stringData and length.
===============================================================================
2010 oct 10
rexx.h
Defined strong types to detect misuse between 'size in bytes' and 'size in chars'.
When changing the sources for m17n, I activate the strong types.
Otherwise I use the weak types.
See rxStringSize.
===============================================================================
2010 sept 24
Started a review of the NetRexx specification, in unicode/_readme.odt.
The goal is to see how the issues reported by Rick are covered by NetRexx.
===============================================================================
2010 sept 20
Fixed the build of m17n under Linux.
Had to rename all the *.c files to *.cpp, because .c source files are not correctly
built by Makefile.am.
Note about Parrot :
The charset/encoding merge has been moved in Parrot's trunk.
I will probably apply this merge.
===============================================================================
2010 sep 05
Found a bug, fixed in sandbox, to fix in trunk.
.mutablebuffer~new('abcdef')~replaceat('XXX', 1, 16)
makes the interpreter crash.
Parrot charset/encoding merge :
http://lists.parrot.org/pipermail/parrot-dev/2010-September/004678.html
I will wait for the move in Parrot's trunk before analysing that.
===============================================================================
2010 aug 28
Added encoding to RexxString (m17n) : I borrowed the Parrot's implementation
(the overall design is kept, but a lot of things has been adapted to ooRexx).
For the moment, I have three sources of inspiration : Parrot, Ruby, Falcon
I choosed Parrot to start, because it uses ICU if available at compile-time.
It's a minimal use, but at least I can put my hands on ICU through a concrete work.
One pointer for charset and one pointer for encoding is probably too much, but this is
how Parrot is implemented... And a third pointer is coming, for NFG.
[2010 aug 25] New, there is an RFC to merge charsets and encodings :
http://lists.parrot.org/pipermail/parrot-dev/2010-August/004633.html
Ruby's m17n is more complete than Parrot's, but seems more difficult to apprehend.
The encoding is stored as a 16 bits index.
Falcon is not like Parrot or Ruby, its internal charset is Unicode only.
I'm interested by its "string polymorphism".
The string manager (ako encoding) is stored as a pointer.
See unicode/_readme.odt for more details.
To build with ICU under Windows :
set HAVE_ICU=1 <-- assign 0 or put this line in comment if you don't want to build with ICU
set icu_dir=D:\local\Unicode\ICU\icu4c-4_4_1-Win32-msvc9
set PATH=%icu_dir%\bin;%PATH%
set INCLUDE=%icu_dir%\include;%INCLUDE%
set LIB=%icu_dir%\lib;%LIB%
The environment variable HAVE_ICU is tested in buildorx.bat :
set ICU_OPTION=
if defined HAVE_ICU set ICU_OPTION="HAVE_ICU=%HAVE_ICU%"
NMAKE /F INTERPRETER.MAK %ICU_OPTION%
interpreter.mak :
!IFNDEF HAVE_ICU
HAVE_ICU=0
!ENDIF
!IF "$(HAVE_ICU)" == "0"
ICU_OPTIONS=
!ELSE
ICU_OPTIONS=/DHAVE_ICU
!ENDIF
Careful if building from Visual Studio (no problem when building from Cmd shell) :
The INCLUDE environment variable is redefined by Visual Studio, and because of that,
the ICU headers are not found. You must launch Visual Studio like that :
vcexpress /useenv
See makeorx_verbose.bat for more details to build from Visual Studio.
===============================================================================
2010 july 3
Continue Unicode review : added notes about Falcon.
Adapted ooRexxTry to use utf8 encoding and Arial Unicode MS.
Preloads all the main components (math, ftp, socket, bsf, hostemu, ...).
===============================================================================
2010 july 3
Debug crash in gc
RexxMemory::markObjectsMain
markObject->live(liveMark);
0x003d2b8c --> this is 0x7eee1ac0->behaviour
Access violation reading location 0x44414550 --> this is the vfptr of the behaviour of a string
((*(RexxVirtualBase*)(&(*(RexxInternalObject*)(&*markObject))))).__vfptr
RexxMemory::mark(RexxObject *markObject)
pushLiveStack((RexxObject *)markObject->behaviour);
markObject = 0x7eee1ac0 --> see below, this is the 30th element of string array
[RexxString]
if tmp<2 then -- start at first char
called by RexxArray::live(size_t liveMark) ArrayClass.cpp
where this = 0x7f30ed70
this->objects = 7f30ed98
arrayPtr=7f30ee0c
0x7f30ee0c - 0x7f30ed98 = 116 = 29 * 4 --> this is the 30th element
element 1 to 13 : not a string... but doesn't be a problem
+ (*(RexxString*)this->get(14)).stringData 0x7eee36a4 " len1=length(arg1string) -- get length of string" char [4]
+ (*(RexxString*)this->get(15)).stringData 0x7eee3704 " newArr=.array~new -- create new array for the arguments" char [4]
+ (*(RexxString*)this->get(16)).stringData 0x7eee376c " newArr[1]=new1string -- "new"-string" char [4]
+ (*(RexxString*)this->get(18)).stringData 0x7eee37e4 " prepend="" -- optional prepend string (if positioning before start!)" char [4]
+ (*(RexxString*)this->get(20)).stringData 0x7eee388c " arg2startori=arg2start -- save passed-in value, if any" char [4]
+ (*(RexxString*)this->get(21)).stringData 0x7eee38f4 " if arg4pad=="" then arg4pad=" "-- define blank as the default pad char" char [4]
+ (*(RexxString*)this->get(23)).stringData 0x7eee398c " if arg(3,"Exists") then -- start in "target"-string" char [4]
+ (*(RexxString*)this->get(24)).stringData 0x7eee2dfc " do" char [4]
+ (*(RexxString*)this->get(25)).stringData 0x7eee2e2c " if datatype(arg2start,"W") then" char [4]
+ (*(RexxString*)this->get(26)).stringData 0x7eee2e7c " do" char [4]
+ (*(RexxString*)this->get(27)).stringData 0x7eee2eac " if arg2start<0 then -- negative, start from right" char [4]
+ (*(RexxString*)this->get(28)).stringData 0x7eee2f14 " do" char [4]
+ (*(RexxString*)this->get(29)).stringData 0x7eee2f44 " tmp=len1+arg2start+1 -- get starting position" char [4]
+ (*(RexxString*)this->get(30)).stringData 0x7eee1ae4 " if tmp<2 then -- start at first char" char [4]
+ (*(RexxString*)this->get(31)).stringData 0x7eee1b44 " do" char [4]
+ (*(RexxString*)this->get(32)).stringData 0x7eee1b7c " if tmp<0 then" char [4]
The behaviour of the 30th element is broken :
+ ((*(RexxVirtualBase*)(&(*(RexxInternalObject*)(&*(((*(RexxInternalObject*)(&*(this->get(28))))).behaviour)))))).__vfptr 0x003aa62c const RexxBehaviour::`vftable' *
+ ((*(RexxVirtualBase*)(&(*(RexxInternalObject*)(&*(((*(RexxInternalObject*)(&*(this->get(29))))).behaviour)))))).__vfptr 0x003aa62c const RexxBehaviour::`vftable' *
+ ((*(RexxVirtualBase*)(&(*(RexxInternalObject*)(&*(((*(RexxInternalObject*)(&*(this->get(30))))).behaviour)))))).__vfptr 0x44414548 *
+ ((*(RexxVirtualBase*)(&(*(RexxInternalObject*)(&*(((*(RexxInternalObject*)(&*(this->get(31))))).behaviour)))))).__vfptr 0x003aa62c const RexxBehaviour::`vftable' *
+ ((*(RexxVirtualBase*)(&(*(RexxInternalObject*)(&*(((*(RexxInternalObject*)(&*(this->get(32))))).behaviour)))))).__vfptr 0x003aa62c const RexxBehaviour::`vftable' *
the behaviour of 30th element is stored at 0x7eee1acc
called by RexxMemory::markObjectsMain(RexxObject *rootObject)
where rootObject =
+ rootObject 0x003d2a90 class RexxMemory memoryObject {markWord=1 markReason=1 variableCache=0x7f5b55a8 ...} RexxObject *
called by RexxMemory::markObjects()
called by RexxMemory::collect()
objectclass.hpp
inline void setBehaviour(RexxBehaviour *b) { behaviour = b; } <-- this method is called to assign the behavior of type 22 (T_String)
> rexx.dll!RexxInternalObject::setBehaviour(RexxBehaviour * b) Line 265 + 0x10 bytes C++
rexx.dll!RexxObject::initializeNewObject(unsigned int mark, void * vft, RexxBehaviour * b) Line 362 C++
rexx.dll!RexxMemory::newObject(unsigned int requestLength, unsigned int type) Line 1134 C++
rexx.dll!new_object(unsigned int s, unsigned int t) Line 422 + 0x1e bytes C++
rexx.dll!RexxString::newString(const char * string, unsigned int length) Line 1894 + 0xd bytes C++
rexx.dll!new_string(const char * s, unsigned int l) Line 521 C++
rexx.dll!RexxSource::get(unsigned int _position) Line 838 + 0x1d bytes C++
rexx.dll!RexxSource::extractSource(SourceLocation & location) Line 1119 + 0x10 bytes C++ <-- counter = 735
rexx.dll!RexxCode::getSource() Line 199 C++
rexx.dll!BaseExecutable::source() Line 149 C++
rexx.dll!CPPCode::run(RexxActivity * activity, RexxMethod * method, RexxObject * receiver, RexxString * messageName, RexxObject * * argPtr, unsigned int count, ProtectedObject & result) Line 144 + 0x6 bytes C++
rexx.dll!RexxMethod::run(RexxActivity * activity, RexxObject * receiver, RexxString * msgname, RexxObject * * argPtr, unsigned int count, ProtectedObject & result) Line 325 C++
rexx.dll!RexxObject::messageSend(RexxString * msgname, RexxObject * * arguments, unsigned int count, ProtectedObject & result) Line 793 C++
rexx.dll!RexxExpressionStack::send(RexxString * message, unsigned int count, ProtectedObject & result) Line 74 + 0x33 bytes C++
rexx.dll!RexxExpressionMessage::evaluate(RexxActivation * context, RexxExpressionStack * stack) Line 139 C++
rexx.dll!RexxExpressionMessage::evaluate(RexxActivation * context, RexxExpressionStack * stack) Line 123 + 0x23 bytes C++
rexx.dll!RexxInstructionAssignment::execute(RexxActivation * context, RexxExpressionStack * stack) Line 122 + 0x1d bytes C++
rexx.dll!RexxActivation::run(RexxObject * _receiver, RexxString * msgname, RexxObject * * _arglist, unsigned int _argcount, RexxInstruction * start, ProtectedObject & resultObj) Line 522 C++
rexx.dll!RexxCode::call(RexxActivity * activity, RoutineClass * routine, RexxString * msgname, RexxObject * * argPtr, unsigned int argcount, RexxString * calltype, RexxString * environment, int context, ProtectedObject & result) Line 116 C++
rexx.dll!RexxCode::call(RexxActivity * activity, RoutineClass * routine, RexxString * msgname, RexxObject * * argPtr, unsigned int argcount, ProtectedObject & result) Line 92 C++
rexx.dll!RoutineClass::call(RexxActivity * activity, RexxString * msgname, RexxObject * * argPtr, unsigned int argcount, ProtectedObject & result) Line 234 C++
rexx.dll!InterpreterInstance::runRequires(RexxActivity * activity, RexxString * name, RoutineClass * code) Line 877 C++
rexx.dll!InterpreterInstance::loadRequires(RexxActivity * activity, RexxString * shortName, RexxString * fullName) Line 932 C++
rexx.dll!RexxSource::loadRequires(RexxActivity * activity, RexxString * target) Line 6082 + 0x14 bytes C++
rexx.dll!PackageClass::loadPackage(RexxString * name, RexxArray * s) Line 366 + 0x16 bytes C++ <-- rgf_util2.rex
The previous behaviour is overwritten by
inline void insertAfter(DeadObject *newDead) DeadObject.hpp
where newDead = 7eee1ac0
rexx.dll!DeadObject::insertAfter(DeadObject * newDead) Line 89 C++
rexx.dll!DeadObjectPool::add(DeadObject * obj) Line 165 C++
> rexx.dll!NormalSegmentSet::addDeadObject(char * object, unsigned int length) Line 461 C++
rexx.dll!MemorySegmentSet::sweep() Line 1170 C++
rexx.dll!RexxMemory::collect() Line 1038 C++
rexx.dll!NormalSegmentSet::handleAllocationFailure(unsigned int allocationLength) Line 1272 C++
rexx.dll!RexxMemory::newObject(unsigned int requestLength, unsigned int type) Line 1117 + 0x12 bytes C++ <-- length = 48, we are in "small object" part (lesser than LargeBlockThreshold 4096)
rexx.dll!new_object(unsigned int s, unsigned int t) Line 422 + 0x1e bytes C++
rexx.dll!RexxString::newString(const char * string, unsigned int length) Line 1894 + 0xd bytes C++
rexx.dll!new_string(const char * s, unsigned int l) Line 521 C++
rexx.dll!new_string(const char * s, unsigned int l) Line 521 C++
rexx.dll!RexxSource::get(unsigned int _position) Line 838 + 0x1d bytes C++
rexx.dll!RexxSource::extractSource(SourceLocation & location) Line 1119 + 0x10 bytes C++ <-- counter = 754
rexx.dll!RexxCode::getSource() Line 199 C++
rexx.dll!BaseExecutable::source() Line 149 C++
rexx.dll!CPPCode::run(RexxActivity * activity, RexxMethod * method, RexxObject * receiver, RexxString * messageName, RexxObject * * argPtr, unsigned int count, ProtectedObject & result) Line 144 + 0x6 bytes C++
rexx.dll!RexxMethod::run(RexxActivity * activity, RexxObject * receiver, RexxString * msgname, RexxObject * * argPtr, unsigned int count, ProtectedObject & result) Line 325 C++
rexx.dll!RexxObject::messageSend(RexxString * msgname, RexxObject * * arguments, unsigned int count, ProtectedObject & result) Line 793 C++
rexx.dll!RexxExpressionStack::send(RexxString * message, unsigned int count, ProtectedObject & result) Line 74 + 0x33 bytes C++
rexx.dll!RexxExpressionMessage::evaluate(RexxActivation * context, RexxExpressionStack * stack) Line 139 C++
rexx.dll!RexxExpressionMessage::evaluate(RexxActivation * context, RexxExpressionStack * stack) Line 123 + 0x23 bytes C++
rexx.dll!RexxInstructionAssignment::execute(RexxActivation * context, RexxExpressionStack * stack) Line 122 + 0x1d bytes C++
rexx.dll!RexxActivation::run(RexxObject * _receiver, RexxString * msgname, RexxObject * * _arglist, unsigned int _argcount, RexxInstruction * start, ProtectedObject & resultObj) Line 522 C++
rexx.dll!RexxCode::call(RexxActivity * activity, RoutineClass * routine, RexxString * msgname, RexxObject * * argPtr, unsigned int argcount, RexxString * calltype, RexxString * environment, int context, ProtectedObject & result) Line 116 C++
rexx.dll!RexxCode::call(RexxActivity * activity, RoutineClass * routine, RexxString * msgname, RexxObject * * argPtr, unsigned int argcount, ProtectedObject & result) Line 92 C++
rexx.dll!RoutineClass::call(RexxActivity * activity, RexxString * msgname, RexxObject * * argPtr, unsigned int argcount, ProtectedObject & result) Line 234 C++
rexx.dll!InterpreterInstance::runRequires(RexxActivity * activity, RexxString * name, RoutineClass * code) Line 877 C++
rexx.dll!InterpreterInstance::loadRequires(RexxActivity * activity, RexxString * shortName, RexxString * fullName) Line 932 C++
rexx.dll!RexxSource::loadRequires(RexxActivity * activity, RexxString * target) Line 6082 + 0x14 bytes C++
rexx.dll!PackageClass::loadPackage(RexxString * name, RexxArray * s) Line 366 + 0x16 bytes C++ <-- rgf_util2.rex
while loading rgf_util2.rex
Why is 0x7eee1ac0 a dead object ?
In RexxSource::extractSource, the array "source" is created, but is not a ProtectedObject.
===============================================================================
2010 may 15
Fix build under Windows for dbgprintf (link error).
Changed the build for "oodialog" target :
Builds both oodialogA and oodialogW (and not just oodialogA as before)
Ex :
makeorx BOTH oodialog clean --> cleans the debug & release files of oodialogA and oodialogW
makeorx BOTH oodialog --> builds the debug & release files of oodialogA and oodialogW
Made a review of the conversions and removed those unneeded.
opts can remain byte-char.
strdupupr and strdupupr_nospace can remain byte-char.
setControlData can remain byte-char. The conversion is done internally.
putUnicodeText converts to wide-char, so no need to convert byte-char to wide-char before calling it (but keep the wide-char signature)
===============================================================================
2010 may 15
Added the function dbgprintf to write debug strings.
Under Windows, it calls OutputDebugString.
Under Linux, it calls syslog.
Remember, typical debug session under PuppyLinux (with busybox) :
Open a console :
syslogd -S -C # -S Smaller loggin output. -C Log to share mem buffer (read it using logred).
logread -f
The output of syslog is displayed by logread in this console (lock management, on client and server side).
Open a console, launch rxapi.
Has been compiled to stay as a foreground process.
It sends debug strings to stderr, more easy to follow in this console (messages between client and server).
Open a console, run the rexx command. The two other consoles are updated with debug infos.
[2011 apr 25 update]
Under MacOsX, I see this message in console : process exceeded 500 log messages per second limit.
To bypass this limit :
Edit /System/Library/LaunchDaemons/com.apple.syslogd.plist with xcode (binary format)
Search for : <string>/usr/sbin/syslogd</string>
Add these lines to the program arguments section :
<string>-mps_limit</string>
<string>0</string>
A value of 0 disables the limit. The default is 500 messages per second.
Restart the syslog daemon with:
sudo launchctl unload /System/Library/LaunchDaemons/com.apple.syslogd.plist
sudo launchctl load /System/Library/LaunchDaemons/com.apple.syslogd.plist
-----
LOG_DEBUG messages still not visible in console...
Probably because of /etc/asl.conf :
# save everything from emergency to notice
? [<= Level notice] store
Remember :
Emergency (level 0)
Alert (level 1)
Critical (level 2)
Error (level 3)
Warning (level 4)
Notice (level 5)
Info (level 6)
Debug (level 7)
-----
Create the file /var/log/debug.log :
sudo touch /var/log/debug.log
Add this line to /etc/syslog.conf to get the debug messages in /var/log/debug.log :
*.debug /var/log/debug.log
then restart the syslogd daemon as explained above.
===============================================================================
2010 may 14
More work on wide-chars in oodialog.
Fixed a crash in the conversion A2W and W2A : The length must be asked to the Windows service,
and not calculated with bad assumptions as I did.
Something not clear to me :
In oodMessaging.cpp, there is a message queue implemented as a string.
Each element is separated by a special character 0xFF.
This message queue is declared rxcharT, so it's a wide-char string when building the wide-char configuration.
Several methods have a rexxMethod parameter, and I declared it rxcharT.
But normally, a method name is always a byte-char string, there is no need to convert it to wide-char...
Problem : if I declare it as rxcharA, then what should I do with the pMessageQueue ?
Can I declare it rxcharA ? in this case, I must encode wide-char to byte-char each time a message is added
Or is it better to keep it rxcharW ? Currently addDialogMessage takes two wide-char arguments...
It's a matter of conversion boundary...
The japanese characters are not properly displayed by MessageBox (i.e. InfoDialog).
It seems that under XP, one must install files for complex scripts.
Not needed under Vista.
--> go to the "Regional and Language Options" control panel, go to the "Languages" tab,
and select "Install filesfor complex script...".
You need to reboot :-(
--> good, after reboot it works...
===============================================================================
2010 may 13
More work on wide-chars in oodialog.
New configuration names : oodialogA and oodialogW.
No longer needed to pass "WCHAR=1" to build the wide-char configuration.
makeorx DEBUG builds both configurations
makeorx DEBUG oodialogA builds the byte-char configuration
makeorx DEBUG oodialogA clean cleans the byte-char configuration
makeorx DEBUG oodialogW builds the wide-char configuration
makeorx DEBUG oodialogW clean cleans the wide-char configuration
makeorx DEBUG oodialog like oodialogA
byte-char and wide-char configurations of oodialog are working, tested with oodialog examples.
There are some problems, but I have the same problems in trunk, so I assume there are some work in progress there...
Test of wide-char configuration :
It's not enough to put win32dbg/wchar in fromt of %PATH%, you must also rename
or remove win32dbg/oodialog.dll because it's this DLL which is loaded by default.
See unicode/ooRexx/oodtree.png for a screenshot with french, german, hebrew, russian, greek, etc...
Summary of the changes made to the oodtree example :
oodtree.rex, added : call setCodePage 65001 -- UTF-8
oodtree.rc, changed : FONT 8, "Arial Unicode MS"
oodtree.inp, added UTF-8 strings for demo
===============================================================================
2010 may 9
Added support for wide-chars in oodialog.
Currently, the "A" Windows API is called, and the conversion occurs there, inside Windows, based on the current locale.
When compiling ooDialog with wide chars UTF-16, the "W" API is called directly, making the dialogs Unicode-enabled.
GTK+ uses UTF-8 internally. Most of the Unix-style operating systems use UTF-8 internally.
So it's natural to use multi-byte chars in ooRexx instead of wide chars, and to provide string services which supports UTF-8.
But the case of ooDialog is different :
This is a Windows-only sub-system, and for better integration with Windows, it must use UTF-16 chars internally.
The conversion to UTF-16 is under the responsability of ooDialog, which lets support code pages that are different
from the system's default code page. Typically, we can pass UTF-8 string to ooDialog which convert them to UTF-16 strings
before calling the Windows "W" API.
By default, the byte-char configuration is built when buildling the whole interpreter :
makeorx DEBUG
To build the byte-char configuration only, enter :
makeorx DEBUG oodialog
or
makeorx DEBUG oodialog "WCHAR=0"
To clean the byte-char configuration, enter :
makeorx DEBUG oodialog clean
or
makeorx DEBUG oodialog clean "WCHAR=0"
To build the wide-char configuration, enter :
makeorx DEBUG oodialog "WCHAR=1"
The output files are generated in the subdirectory win32dbg\wchar
To clean the wide-char configuration, enter :
makeorx DEBUG oodialog clean "WCHAR=1"
===============================================================================
2010 april 28
rgf_util2 wrappers to make the services of Rony available as methods on predefined classes.
For proof of concept... For a real library of methods, rgf_util2 should be rewritten to use
the variable "self" where appropriate, instead of passing the object as first parameter.
===============================================================================
2010 april 25
Add ::extension directive
todo : Limit the extension to new methods, raise an error if redefining a predefined method
(but keep ~define unlocked for investigation).
todo : I don't manage dependencies on ExtensionDirective
See RexxSource::resolveDependencies, there is maybe something to do there.
Currently, if the same method is extended several times, then it's the "last" extension who wins...
The definition of "last" depends on the order of resolution of ::requires
See samples\extension\test_extension_order.rex
Remember :
Unlike ::class, you can have several ::extension in the same source for the same class.
So the current check for duplicate method in an ExtensionDirective is not very useful.
The interpreter will complain for that :
::extension object
::method m
::method m
but not for that :
::extension object
::method m
::extension object
::method m
===============================================================================
2010 april 24
Unlock ~define
Creation of sandbox :
cd D:\local\Rexx\ooRexx\svn\sandbox
mkdir jlf
svn add jlf
svn commit jlf
svn copy https://oorexx.svn.sourceforge.net/svnroot/oorexx/main/trunk https://oorexx.svn.sourceforge.net/svnroot/oorexx/sandbox/jlf
svn update jlf
rev 5812
merge 5812-5835 from main/trunk
merge 5835-5957 from main/trunk
merge 5957-5988 from main/trunk
merge 5988-6048 from main/trunk
merge 6048-6142 from main/trunk
merge 6142-6189 from main/trunk
merge 6189-6500 from main/trunk
merge 6500-6784 from
main/trunk/api
main/trunk/extension/hostemu
main/trunk/interpreter
main/trunk/platform
main/trunk/rexxapi
merge 6784-6976 from
main/trunk/configure.ac (except oodialog)
main/trunk/Makefile.am
main/trunk/makeorx.bat
main/trunk/extensions/platform/unix
main/trunk/extensions/rexxutil
main/trunk/extensions/rxsock
main/trunk/interpreter
main/trunk/platform/unix
main/trunk/rexxapi
Remember todo :
merge 6500-xxxx from main/trunk/extensions/platform/windows/oodialog
merge 6500-xxxx from main/trunk/samples
merge 6784-xxxx from main/trunk/platform/windows