PFE 0.33.71 Homepage SourceForge Download Documentation -Overview -The PFE Manual old manual / (book) -ChangeLog -Authors -License (LGPL) -Wordsets / (book) -Functions .. (book) -Dp of ANS Forth -The 4thTutor -Forthprimer.pdf - Old Wordsets - Old Words List Forth Links * Forth Repository * Taygeta Compilation * TinyBoot FirmWare * FiCL, Free Forth * Research Vienna * Research Bournemouth * zForth WebRing Other Links * Tektronix/MPT * Forth Org. (FIG) * Forth Inc. * MPE Ltd. Forths * SF Win32Forth * PD Win32Forth * Neil Bawd generated (C) Guido U. Draheim guidod@gmx.de | ## StackHelp TypeChecking extension `|(``( [string<rp>] -- )``[EXT]` => `"EXTENSIONS"` add a checkstack notation for the LAST word or just try to match the given notation with the stacklayout traced so far - possibly casting a few types as needed. immediate code = [p4_stackhelpcomment] `STACKHELP``( [name] -- )``[EXT]` => `"EXTENSIONS"` show the stackhelp info registered for this name. immediate code = [p4_stackhelp] `STACKHELPS``( [name] -- )``[EXT]` => `"EXTENSIONS"` show all possible stackhelps for this name. immediate code = [p4_stackhelps] `STACKHELP-DEBUG``` => `"EXTENSIONS"` (no description) primitive code = [stackhelp_debug] `NARROW-CHANGER(``( changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` primitive code = [p4_narrow_changer] `NARROW-INPUTLIST(``( changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` primitive code = [p4_narrow_inputlist] `NARROW-OUTPUTLIST(``( changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` primitive code = [p4_narrow_outputlist] `NARROW-INPUT-VARIANT(``( variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` 0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' primitive code = [p4_narrow_input_variant] `NARROW-OUTPUT-VARIANT(``( variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` primitive code = [p4_narrow_output_variant] `NARROW-INPUT-STACK(``( stk-char variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` 0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' primitive code = [p4_narrow_input_stack] `NARROW-OUTPUT-STACK(``( stk-char variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` primitive code = [p4_narrow_output_stack] `NARROW-INPUT-ARGUMENT(``( arg# stk-char variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` 0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' arg# is [0] = TOS and [1] = UNDER, same as the pick values where 3 2 1 0 2 pick . =:= 2 primitive code = [p4_narrow_input_argument] `NARROW-OUTPUT-ARGUMENT(``( arg# stk-char variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` arg# is [0] = TOS and [1] = UNDER, same as the pick values where 3 2 1 0 2 pick . =:= 2 primitive code = [p4_narrow_output_argument] `NARROW-INPUT-ARGUMENT-NAME(``( arg# stk-char variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` 0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' arg# is [0] = TOS and [1] = UNDER, same as the pick values where 3 2 1 0 2 pick . =:= 2 primitive code = [p4_narrow_input_argument_name] `NARROW-OUTPUT-ARGUMENT-NAME(``( arg# stk-char variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` arg# is [0] = TOS and [1] = UNDER, same as the pick values where 3 2 1 0 2 pick . =:= 2 primitive code = [p4_narrow_output_argument_name] `NARROW-INPUT-ARGUMENT-TYPE(``( arg# stk-char variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` 0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' arg# is [0] = TOS and [1] = UNDER, same as the pick values where 3 2 1 0 2 pick . =:= 2 primitive code = [p4_narrow_input_argument_type] `NARROW-OUTPUT-ARGUMENT-TYPE(``( arg# stk-char which# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` arg# is [0] = TOS and [1] = UNDER, same as the pick values where 3 2 1 0 2 pick . =:= 2 primitive code = [p4_narrow_output_argument_type] `CANONIC-INPUT-TYPE(``( arg# stk-char variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` 0 = default, 1 = 'S', 2 = 'R', ... 4 = 'P', ... 7 = 'M', .. 14 = 'F' arg# is [0] = TOS and [1] = UNDER, same as the pick values where 3 2 1 0 2 pick . =:= 2 primitive code = [p4_canonic_input_type] `CANONIC-OUTPUT-TYPE(``( arg# stk-char variant# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` arg# is [0] = TOS and [1] = UNDER, same as the pick values where 3 2 1 0 2 pick . =:= 2 primitive code = [p4_canonic_output_type] `REWRITER-TEST(``( "tracked-stack -- input-stack<rp>" -- )``[EXT]` => `"EXTENSIONS"` suppose that the left side is a tracked stack line during compiling and the right side is a candidate changer input stack. Test whethr the candidate does match and the complete changer would be allowed to run a rewrite in the track stack buffer. Possible conditions include: the left side has not enough arguments or... any argument on the right side has a type specialization that does not match as a valid suffix to their counterpart on the left side. primitive code = [p4_rewriter_test] `REWRITER-INPUT-ARG(``( arg# "tracked-stack -- changer<rp>" -- )``[EXT]` => `"EXTENSIONS"` suppose that the left side is a tracked stack line during compiling and the right side is a candidate changer input stack. Assume the righthand candidate does match - look at the given argument on the left side and show the prefix being copied to the output trackstack when the rewrite-rule is gettin applied later. primitive code = [p4_rewriter_input_arg] `REWRITE-LINE(``( "stack-layout<rp>" -- )``[EXT]` => `"EXTENSIONS"` fill rewrite-buffer with a stack-layout to be processed. see `REWRITE-SHOW.` primitive code = [p4_rewrite_line] `REWRITE-SHOW.``( -- )``[EXT]` => `"EXTENSIONS"` show current rewrite-buffer. primitive code = [p4_rewrite_show] `REWRITE-STACK-TEST(``( "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` check whether this stackhelp does match on current rewrite-buffer and say oK/No respectivly. primitive code = [p4_rewrite_stack_test] `REWRITE-INPUT-ARG(``( arg# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` check whether this stackhelp does match on current rewrite-buffer and in the given input match show us the argument but only the good prefix i.e. the type constraint being cut off already. primitive code = [p4_rewrite_input_arg] `REWRITE-STACK-RESULT(``( "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` rewrite the current rewrite-buffer and show the result that would occur with this stackhelp being applied. primitive code = [p4_rewrite_stack_result] `NARROW-INPUT-NOTATION(``( notation# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` primitive code = [p4_narrow_input_notation] `NARROW-OUTPUT-NOTATION(``( notation# changer# "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` primitive code = [p4_narrow_output_notation] `REWRITE-STACKDEF-TEST(``` => `"EXTENSIONS"` (no description) primitive code = [p4_rewrite_stackdef_test] `REWRITE-STACKDEF-RESULT(``( "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` assume: only one changer (if more are provided then only the first is used) only one stackdef variant in inputlist primitive code = [p4_rewrite_stackdef_result] `REWRITE-CHANGER-SELECT(``` => `"EXTENSIONS"` (no description) primitive code = [p4_rewrite_changer_select] `REWRITE-CHANGER-EXPAND(``` => `"EXTENSIONS"` (no description) primitive code = [p4_rewrite_changer_expand] `REWRITE-CHANGER-RESULT(``` => `"EXTENSIONS"` (no description) primitive code = [p4_rewrite_changer_result] `REWRITE-TEST(``( "stackhelp<rp>" -- )``[EXT]` => `"EXTENSIONS"` Test whether the given changer would match the current line. assume: only one changer (if more are provided then only the first is used) primitive code = [p4_rewrite_test] `REWRITE-SELECT(``` => `"EXTENSIONS"` (no description) primitive code = [p4_rewrite_select] `REWRITE-EXPAND(``` => `"EXTENSIONS"` (no description) primitive code = [p4_rewrite_expand] `REWRITE-RESULT(``` => `"EXTENSIONS"` (no description) primitive code = [p4_rewrite_result]