}* FIC3.TXT LOADED AUTOMATICALLY BY F3 WHICH IS LISA GJ2 FIC3 }* }* THE PROGRAMMING LANGUAGE CREATED WITH CREATIVELY IMPROVED }* }* INSPIRATIONS FROM MANY FEATURES OF FORTH AND VAGUELY SOME }* }* FEATURES FROM OTHER LANGUAGES INCL PERL, JAVA, PASCAL, C, }* }* SIMULA AND ESTHETICALLY LISP. IT IS ULTIMATELY MADE FOR }* }* THE FIRST-HAND LISA GJ2 FIC3 LT COMPUTER, AND IT PROVIDES }* }* FOUNDATION ALSO FOR 1ST-HAND ROOM/DEPTH (3D), LIGHT3D.TXT. }* }* THE FIRST COMPILER FOR THIS TYPE OF TEXT, FIRTH, WAS }* }* PRODUCED AND RELEASED IN MARCH 2006, WITH NOVEL STACK }* }* STRUCTURES WHICH HAVE BEEN FOUND TO BE EXCESSIVELY FRUITFUL!!!}* }* THIS TEXT COMPRISES ALL HIGHER-LEVEL FUNCTIONS IN THE RIPE }* }* FUNNY LOVELY STANDARDIZED (DECEMBER 2010 VERSION) OF F3. }* }* IT IS ACCEPTABLE THAT YOU QUOTE AND USE PORTIONS OF THIS }* }* CODE AS LONG AS YOU REFER TO ITS ORIGIN. IT IS WRITTEN }* }* ENTIRELY BY ARISTO TACOMA, AS ALWAYS WITH L.A.H. AS HELP. }* COMPILEFAST LOOKSTK VAR SCREEN-LENGTH 25 SCREEN-LENGTH SET //BT TXT-CLS '10' SCREEN-LENGTH IS SEVERAL( BT| //BT NOOP BT| VAR FONT-H 400 FONT-H SET VAR FONT-V 250 FONT-V SET VAR THIS-IS-W THIS-IS-W SETBASIS VAR CHAR-SPACE 18 CHAR-SPACE SET //BT H-RIGHT FONT-H IS 10 ADD BT| //BT H-SUPER-RIGHT FONT-H IS 11 ADD BT| VAR FGRAPH-ACTIVATED FGRAPH-ACTIVATED SETBASIS //BT SEEBYINDEX CRLN & & ## %LENGTH F// N1 ## %GET # %GET ( }, } ( N1 8 MOD NOZ NOT = CRLN === KEYTOUCH = KEY RM RMS RMS GOFORWARD2 === |N GOLABEL2: && && CRLN BT| //BT FUNNYRFFG RFFG RFFG MUL ABS RFFG DIV2 ADD ABS RFFG MUL ABS INC8 SWITCH MOD INC BT| //BT MAKETWO >N9 >N8 N8 %MAKE >N2 N8 %MAKE >N1 N8 F// N11 FUNNYRFFG N1 N3 %PUT |N N8 F// N1 N1 N4 %PUT |N N1 N2 BT| //BT =-> BT| :=-> GETFUNCNUM :IS ? SETWARPADDRESS //BT >>> BT| :>>> GETFUNCNUM :IS ? SETWARPADDRESS //BT [ BT| :[ GETFUNCNUM :MAKENEWLIST ? SETWARPADDRESS //BT ] BT| :] GETFUNCNUM :LISTOK ? SETWARPADDRESS //BT < BT| COMPILETIME //BT ; BT| COMPILETIME //BT )) BT| COMPILETIME (LET FREE-CLS BE (( )) (( (( SOLIDCURSOR )) (( 2 => TEXTCOLORBG )) (( 0 => TEXTCOLOR )) (( CLS )) )) OK) (LET AT BE (( )) (( (( FREE-CLS )) (( }TIME 10:00 AM} => LISACODE )) (( FREE-CLS )) (( }* * * * * } ; 1600 => SEVERAL( )) (( FREE-CLS )) (( }DATE 04-10-2006} => LISACODE )) (( FREE-CLS )) (( }* * * * * } ; 1600 => SEVERAL( )) (( 446 => GOODPAUSE )) (( FREE-CLS )) (( }AT: Renewal happened.} => POP )) (( CRLN ; CRLN ; CRLN )) )) OK) (LET CM BE AT OK) (LET FREE-CLS-COMPLEMENT BE (( )) (( (( SOLIDCURSOR )) (( 2 => TEXTCOLOR )) (( 0 => TEXTCOLORBG )) (( CLS )) )) OK) (LET FREE-ACTION BE (( )) (( (( )) )) OK) (LET RAM-REFRESH BE (( )) (( (( RH_ENABLED => NOT (MATCHED (( DARKER )) (( CLS )) (( }THANK YOU!! } ; 15 => SEVERAL( )) (( LOOKSTK ; STK ; VARSTK ; 500 => GOODPAUSE )) (( }RAM REFRESH } ; 62 => SEVERAL( )) )(OTHER (( CRLN ; CRLN ; CRLN ; CRLN ; CRLN )) MATCHED) )) (( XO )) )) OK) (LET GJ-COLORS BE (( )) (( (( 255 (COUNT (( ^0 ; N1 => >>V ; ^0 ; N1 => >>V => WRITEPAL )) COUNTUP) )) (( ^0 ; ^63 ; ^0 ; ^0 => WRITEPAL )) (( ^0 ; ^0 ; ^0 ; ^1 => WRITEPAL )) (( ^63 ; ^63 ; ^63 ; ^2 => WRITEPAL )) (( ^0 ; ^55 ; ^0 ; ^64 => WRITEPAL )) (( ^0 ; ^17 ; ^0 ; ^254 => WRITEPAL )) (( ^0 ; ^21 ; ^0 ; ^255 => WRITEPAL )) (( PUTPAL )) )) OK) (LET RAM-PM BE (( >N5 >N4 )) (( (( N5 %MAKE => & )) (( N5 (COUNT N6 => %MAKE => ; N1 ; # => %PUT COUNTUP) )) (( # => => )) (( && )) )) OK) (( LOOKSTK )) (LET FREE-B BE (( )) (( (( ^256 FR => GETV => DEC => => )) )) OK) (LET FREE-H BE (( )) (( (( ^1024 FR => GETV => => )) )) OK) (LET FREE-V BE (( )) (( (( ^768 FR => GETV => => )) )) OK) (LET START-GRAPHICS BE (( )) (( (( LATENTSC )) (( LATENTSC )) (( SOLIDCURSOR )) (( CLS )) (( FGRAPH-ACTIVATED => SETDANCE )) (( FGRAPH )) (( SHOWMOUSE )) (( UNSHOWMOUSE )) (( GETPAL )) (( CLS )) (( SHOWMOUSE )) )) OK) (LET SWITCH-TO-TEXT-MODE BE (( )) (( (( FUNCURSOR )) (( -1 18 => MODELLER )) )) OK) (LET SWITCH-BACK-TO-GRAPHICS-MODE BE (( )) (( (( -1 14 => MODELLER )) (( SOLIDCURSOR )) )) OK) (( LOOKSTK )) (LET VALUE BE (( ; )) (( => # %GET ## %GET => => )) OK) (LET SET-VALUE BE (( ; ; )) (( => # %GET ## %PUT )) OK) (LET FITTING BE (( => & ; & ; >N1 )) (( (( SWITCHV )) (( ## => %LENGTH => >N8 )) (( N8 => ISBASIS (MATCHED 0 ; && && ; EXIT MATCHED) )) (( 1 >N6 )) (( N8 ; N6 => SUB => INC => >N9 )) (( N9 => ISBASIS (MATCHED (( 0 ; && && ; EXIT )) MATCHED) )) (( GOLABEL4: (( N9 ; 2 => INTGREATER (MATCHED (( N1 ; N6 VALUE => INTGREATER ; N8 VALUE ; N1 => INTGREATER => AND (MATCHED (( N9 => DIV2 ; N6 => ADD => >N5 )) (( N5 VALUE ; N1 => INTGREATER (MATCHED N5 => >N8 )(OTHER N5 => >N6 MATCHED) )) (( N8 ; N6 => SUB => INC => >N9 )) (( GOUP4 )) )(OTHER (( N8 VALUE ; N1 => EQN (MATCHED (( N8 ; && && ; EXIT )) )(OTHER (( N6 VALUE ; N1 => EQN (MATCHED (( N6 ; && && ; EXIT )) )(OTHER (( 0 ; && && ; EXIT )) MATCHED) )) MATCHED) )) MATCHED) )) )(OTHER (( N9 => ISDANCE (MATCHED (( N6 VALUE ; N1 => EQN (MATCHED (( N6 ; && && ; EXIT )) )(OTHER (( 0 ; && && ; EXIT )) MATCHED) )) )(OTHER (( N8 VALUE ; N1 => EQN (MATCHED (( N8 ; && && ; EXIT )) )(OTHER (( N6 VALUE ; N1 => EQN (MATCHED (( N6 ; && && ; EXIT )) )(OTHER (( 0 ; && && ; EXIT )) MATCHED) )) MATCHED) )) MATCHED) )) MATCHED) )) )) )) OK) (LET UPCNUM BE (( ; )) (( (( ; => ONE ; 97 ; 122 => WITH (MATCHED (( ; -32 => ADD ; )) MATCHED) )) (( ; => => )) )) OK) (LET NORMAL-YESORENTER BE (( => RMBLUPC => )) (( (( KEEPLETTERS => LENGTH => 0 ; EQN (MATCHED (( RM ; Y => => EXIT )) MATCHED) ONE ; :Y => EQ => SWITCH ; :YES => EQ => ORR => => )) )) OK) (LET SETLENGTH BE (( => >N1 ; LENGTH => >N2 )) (( (( N1 N2 => SUB => >N3 )) (( N3 => ISPRO (MATCHED (( ; N3 => MAKEBL => CONCAT => => )) )(OTHER (( N3 => SG => ISPRO (MATCHED (( N1 => INC ; N3 => SG => SUBSTR => RM ; => => )) MATCHED) MATCHED) )) OK) (LET VARSTR-LEN BE (( GETV >N1 )) (( (( N1 BYTEMEM> => => )) )) OK) (LET VARSTR-INCLEN BE (( GETV >N1 )) (( (( 250 ; N1 BYTEMEM> => INTGREATER (MATCHED N1 BYTEMEM> INC N1 >BYTEMEM MATCHED) )) )) OK) (LET VARSTR-DECLEN BE (( GETV >N1 )) (( (( N1 BYTEMEM> => A (MATCHED DEC N1 >BYTEMEM MATCHED) )) )) OK) (LET VARSTR-SETLEN BE (( >N1 ; GETV >N2 )) (( (( N1 N2 >BYTEMEM )) )) OK) (LET VARSTR-SETBASIS BE (( GETV >N1 )) (( (( 0 N1 >BYTEMEM )) (( 250 (COUNT 32 N1 N3 ADD >BYTEMEM COUNTUP) )) OK) (( LOOKSTK )) (LET VARSTR-TOCHN BE (( >N2 ; >N1 ; GETV >N3 )) (( (( N1 ; N2 N3 ADD => >BYTEMEM )) )) OK) (LET VARSTR-CHN BE (( >N1 ; GETV >N2 )) (( (( N1 N2 ADD => BYTEMEM> => => )) )) OK) (LET VARSTR-EXPAND BE (( >N1 ; # >N2 )) (( (( ONEV => VARSTR-INCLEN )) (( N1 ; ONEV VARSTR-LEN ; ONEV => VARSTR-TOCHN )) (( && )) )) OK) (LET RIGHTADJUST BE (( => >N1 ; RMBL => LENGTH => >N2 )) (( (( N1 N2 => SUB => >N3 )) (( N3 => ISPRO (MATCHED (( ; N3 => MAKEBL => SWITCH => CONCAT => => )) )(OTHER (( N3 => SG => ISPRO (MATCHED (( N1 => SETLENGTH => => )) MATCHED) MATCHED) )) OK) (LET DIVIDE-TEXT-IN-TWO BE (( => LENGTH )) (( (( => >N1 )) (( 2 ; N1 => INTGREATER (MATCHED }} ; SWITCH ; EXIT MATCHED) )) (( N1 ; DIV2 => >N2 )) (( 1 ; N2 => SUBSTR => SWITCH => => )) )) OK) (LET MAKECH BE (( => >N6 ; >N5 )) (( (( N6 => ISPRO (MATCHED (( N6 => MAKEBL )) (( N6 (COUNT N7 N1 TOCHN COUNTUP) )) )(OTHER }} MATCHED) )) )) OK) (LET TEN-TO BE (( => >N6 )) 1 ; 48 N6 => MAKECH => CONCAT => => OK) (LET FIX-NUMBER BE (( >N1 ; EXTRACTNUMBERSTUFF => LENGTH => >N2 )) (( (( }.} 1 FINL => >N8 )) (( N8 => ISPRO (MATCHED (( N2 N8 => SUB => >N9 )) (( N9 N1 => SUB => >N10 )) (( N10 => SG => ISPRO (MATCHED (( 48 ; N10 => SG => MAKECH ; => CONCAT => => )) )(OTHER (( N1 => TEN-TO => STKTORICH => ONER ; STKTORICH => *R => ROUNDR => SWITCHR => \R => RICHTOSTK )) MATCHED) )) )(OTHER (( }.} CONCAT )) (( 48 ; N1 => MAKECH ; => CONCAT => => )) MATCHED) )) )) OK) (( LOOKSTK )) ((DATA YESORENTER-HOUSE )) ((DATA YNIN-HOUSE )) ((DATA NEW-CLS-HOUSE )) ((DATA ENTERPLS-HOUSE )) (( }NORMAL-YESORENTER} => ? YESORENTER-HOUSE <>> H )) OK) (( LOOKSTK )) (LET TXT-YNIN BE (( )) (( (( } [ENTER=YES]} => POPS )) (( READLN => YESORENTER => => )) )) OK) (LET TXT-ENTERPLS BE (( )) (( (( } [ENTER], PLS} => POPS )) (( READLN => RM )) )) OK) (( }TXT-YNIN} => ? YNIN-HOUSE < ? ENTERPLS-HOUSE < ? NEW-CLS-HOUSE <>> H )) OK) (LET ENTERPLS BE (( )) (( ENTERPLS-HOUSE >>> H )) OK) (LET NEW-CLS BE (( )) (( NEW-CLS-HOUSE >>> H )) OK) ((DATA ADDR-HOUSE }+R} => ? ADDR-HOUSE <>> H )) OK) ((DATA SUBR-HOUSE }-R} => ? SUBR-HOUSE <>> H )) OK) (LET ROUND-100-UP (( >N1 )) (( (( N1 ; 100 => MOD => NOZ (MATCHED N1 ; 100 => DIV => INC ; 100 => MUL => => )(OTHER N1 ; 100 => DIV ; 100 => MUL => => MATCHED) )) OK) (LET Y-TO-1 BE (( => )) (( (MATCHED 1 => => )(OTHER 0 => => MATCHED) )) OK) (LET TEXT>MATRIX (( => & >N1 LENGTH => >N2 )) BE (( (( N2 (COUNT N1 => CHN => N1 ; N3 ; # => PM COUNTUP) )) (( 0 ; N2 INC ; N3 ; # => PM )) (( RM ; && )) )) OK) (LET MATRIX>TEXT (( => & >N1 )) BE (( (( # N1 => %GET => & )) (( # => NOZ (MATCHED (( # => %LENGTH => >N9 )) (( N9 => ISPRO (MATCHED N9 => MAKEBL (COUNT N1 => # %GET ; N1 => TOCHN COUNTUP) => => )(OTHER }} MATCHED) )) )(OTHER }} MATCHED) )) (( && && )) )) OK) (( LOOKSTK )) ((DATA MINI-FILE 4 %MAKE MINI-FILE < %MAKE ; 1 MINI-FILE >>> => %PUT 200 => %MAKE ; 2 MINI-FILE >>> => %PUT 200 => %MAKE ; 3 MINI-FILE >>> => %PUT 200 => %MAKE ; 4 MINI-FILE >>> => %PUT )) (LET MAKE-MINI-FILE BE (( => => )) (( (( MINI-FILE >>> & )) (( 4 ; # => TEXT>MATRIX )) (( 3 ; # => TEXT>MATRIX )) (( 2 ; # => TEXT>MATRIX )) (( 1 ; # => TEXT>MATRIX )) (( ; # => PM2FILE => RM )) (( && )) )) OK) (LET DONE-GRAPHICS BE (( )) (( (( CLEAR_KEYBUF )) (( -1 18 => MODELLER )) (( -1 24 => MODELLER )) (( FGRAPH-ACTIVATED => SETBASIS )) (( BIGVIDEOREFRESH )) (( FIXF )) (( CLEAR_KEYBUF )) )) )) OK) (( }N1} => ? ; }TEXT>MATRIX} => ? ; 88 ADD => POKE )) (( LOOKSTK )) (LET NEWKEY (( )) BE (( (( KEYNUM TOV9 )) (( FKEYALT TOV5 )) (( FKEYCTRL TOV6 )) (( FKEYSHIFT TOV7 )) (( FKEYNUM TOV8 )) )) OK) (LET SOME-TEXT BE (( )) (( (( SWITCH-TO-TEXT-MODE )) )) OK) (LET MORE-GRAPHICS BE (( )) (( (( SWITCH-BACK-TO-GRAPHICS-MODE )) )) OK) ((DATA XO-STATUS-ON XO-STATUS-ON => SETBASIS )) (LET XO-STATUS BE XO-STATUS-ON SETDANCE OK) (LET FT BE (( )) (( )) OK) (( }FT} => GETFUNCNUM ; }UNSHOWMOUSE} => ? => SETWARPADDRESS )) (LET FEET BE (( )) (( )) OK) (( }FEET} => GETFUNCNUM ; }SHOWMOUSE} => ? => SETWARPADDRESS )) (LET FT-CLS BE (( )) (( (( CLEAR_KEYBUF )) (( FT ; CLS ; FEET )) )) OK) (LET RICH BE (( )) (( )) OK) (( LOOKSTK )) (( }RICH} => GETFUNCNUM ; }EXTRACTNUMBERSTUFF} => ? => SETWARPADDRESS )) (LET V1UP V1 ADD TOV1 OK) (LET V2UP V2 ADD TOV2 OK) (LET V3UP V3 ADD TOV3 OK) (LET V4UP V4 ADD TOV4 OK) (LET V5UP V5 ADD TOV5 OK) (LET V5UP V5 ADD TOV5 OK) (LET V6UP V6 ADD TOV6 OK) (LET V6UP V6 ADD TOV6 OK) (LET V7UP V7 ADD TOV7 OK) (LET V8UP V8 ADD TOV8 OK) (LET V9UP V9 ADD TOV9 OK) (LET V9UP V9 ADD TOV9 OK) (LET V10UP V10 ADD TOV10 OK) (LET V11UP V11 ADD TOV11 OK) (LET ADDVAR-WITHIN BE (( ; ; ; )) (( (( # => PEEK ; BRIDGE => ADD ; ANGEL ; 1 => SWITCH => WITH (MATCHED ADDVAR )(OTHER RM && MATCHED) )) )) OK) ((DATA CLICK-DURATION 35 CLICK-DURATION < DEC )) (( (( 15 TWO DIV INC => ANGEL ANGEL => => )) (( MOD INC => => )) )) OK) (LET BYTEPOS-CH BE (( => DEC )) (( (( 15 TWO DIV INC => ANGEL ANGEL => => )) (( TWICE MOD INC => => )) )) OK) (( LOOKSTK )) (LET GB BE (( ; ; ; )) (( (( TWICE => TWO )) (( DEC SWITCH MANTRA => GM => ASCII => ANGEL ANGEL )) (( SWITCH YANTRA => GM => ASCII => CONCAT => => )) (( SWITCH RM )) )) OK) (LET GBD BE (( ; ; ; )) (( (( TWICE => TWO )) (( DEC SWITCH MANTRA => GM => ASCII => ANGEL ANGEL )) (( SWITCH YANTRA => GM => ASCII => CONCAT => HEX2DEC => => )) (( SWITCH RM )) )) OK) (LET UP-TO-EVEN BE (( ; )) (( (( ONE => MOD2 => ISDANCE (MATCHED INC MATCHED) => => )) )) OK) (LET UP-TO-HIGHER-EVEN BE (( ; )) (( (( ONE => MOD4 => ONE => ISPRO (MATCHED 4 SWITCH SUB BRIDGE ADD SWITCH MATCHED) => => )) (( RM )) )) OK) (LET UP-TO-EVEN8 BE (( ; )) (( (( ONE => MOD8 => ONE => ISPRO (MATCHED 8 SWITCH SUB BRIDGE ADD SWITCH MATCHED) => => )) (( RM )) )) OK) (LET FLOOR-EVEN BE (( ; )) (( (( ONE => MOD2 => ISDANCE (MATCHED DEC MATCHED) => => )) )) OK) (LET RELEASE-MATRIX BE (( => & )) (( (( # => %LENGTH (COUNT (( N1 ; # => %GET => %FREE )) COUNTUP) )) (( # => %FREE )) (( && )) )) OK) (LET GET-PAINTING-RAM BE (( )) (( (( 32 21000 RAM-PM => => )) )) OK) (LET LOAD-PAINTING BE (( & ; )) (( (( }.TXT} => CONCAT ; # => FILE2PM => RM )) (( && )) )) OK) (( LOOKSTK )) (LET DURATION-MOUSE BE (( )) (( (( MMOTION )) (( 33 => GOODPAUSE )) (( MMOTION )) (( => AND => => )) )) OK) (LET UNTIL-TOUCHING BE (( )) (( (( DURATION-MOUSE ; MOUSECLICK ; KEYTOUCH => TRIPLEORR => NOT => => )) )) OK) (LET ENTER-OR-CLICK (( )) BE (( (( GOLABEL1: (( MOUSECLICK => )) (( CLICK-DURATION >>> GOODPAUSE )) (( => (MATCHED EXIT MATCHED) )) (( KEYTOUCH => (MATCHED KEYNUM 13 EQN = EXIT == CLEAR_KEYBUF === MATCHED) )) GOUP1 )) )) OK) (LET ANY-KEY-OR-CLICK (( )) BE (( (( GOLABEL1: (( MOUSECLICK => )) (( CLICK-DURATION >>> GOODPAUSE )) (( => (MATCHED EXIT MATCHED) )) (( KEYTOUCH => (MATCHED CLEAR_KEYBUF EXIT MATCHED) )) GOUP1 )) )) OK) (( LOOKSTK )) ((DATA PAINTING-START 1079 PAINTING-START <>> => )) (( # 2 5 GB ; # 2 4 GB => CONCAT => HEX2DEC => UP-TO-HIGHER-EVEN => => )) (( # 2 9 GB ; # 2 8 GB => CONCAT => HEX2DEC => UP-TO-HIGHER-EVEN => => )) (( TWO => MUL => => )) (( && )) )) OK) (LET REAL-TXT-FILE BE (( ; )) (( (( ONE => RMBL => TOLEN => ISBASIS (MATCHED RM NO ; EXIT MATCHED) )) (( ONE }.TXT} => CONCAT => ALREADYFILE (MATCHED YES )(OTHER RM NO MATCHED) )) )) OK) (LET LISA-PAINT-1-1-ESSENCE BE (( )) (( (( V2 ; V3 ; V11 => PUTPIXEL )) )) OK) (LET LISA-PAINT-ESSENCE BE (( )) (( (( V2 V8 ADD ; V3 V9 ADD ; V11 => PUTPIXEL )) )) OK) (( LOOKSTK )) ((DATA LISA-PAINT-1-1-ESSENCE-HOUSE }LISA-PAINT-1-1-ESSENCE} => ? => LISA-PAINT-1-1-ESSENCE-HOUSE < ? => LISA-PAINT-ESSENCE-HOUSE <>> ; # => FORVPM )) (( && )) )) OK) (( LOOKSTK )) (LET A-KEY BE (( )) (( (( CLEAR_KEYBUF )) (( KEYNUM => ISBASIS = KEY RM === )) (( CLEAR_KEYBUF )) )) OK) (LET LISA-PAINT BE (( & >N2 >N1 )) (( (( VLOTS ; N1 => TOV8 ; N2 => TOV9 ; VFREE ; LISA-PAINT-ESSENCE-HOUSE >>> ; # => FORVPM )) (( && )) )) OK) (( LOOKSTK )) (LET MAKE-SMART-PAINTING BE (( ; )) (( (( VLOTS )) (( => => TOV3 )) (( V3 => PAINTING-STATUS => TOV10 ; TOV11 ; TOV9 ; TOV8 )) (( V9 ; V11 => RAM-PM => >N5 )) (( V9 => INC => TOV4 )) (( 1 => TOV5 )) (( V10 (COUNT (( (( DECV4 )) (( V4 => ISBASIS (MATCHED INCV5 ; V9 => TOV4 MATCHED) )) (( V3 ; N2 N1 => SUB ; V8 ADD => BYTEPOS => GBD ; V4 ; V5 ; N7 => PM )) COUNTUP) )) (( N5 => => )) (( VFREE )) )) OK) (( LOOKSTK )) (LET LEISURE-PAINT BE (( ; ; ; )) (( (( VLOTS )) (( => => TOV3 ; DEC TOV2 ; DEC TOV1 )) (( V3 => PAINTING-STATUS => TOV10 ; TOV11 ; TOV9 ; TOV8 )) (( V9 => INC => TOV4 )) (( 1 => TOV5 )) (( V10 (COUNT (( (( DECV4 )) (( V4 => ISBASIS (MATCHED INCV5 ; V9 => TOV4 MATCHED) )) (( V4 V1 ADD ; V5 V2 ADD ; V3 ; N2 N1 SUB V8 ADD => BYTEPOS => GBD => PUTPIXEL )) COUNTUP) )) (( VFREE )) )) OK) (( LOOKSTK )) (LET GET-SMART-PAINTING BE (( ; )) (( (( GET-PAINTING-RAM => & )) (( ; # => LOAD-PAINTING )) (( # => MAKE-SMART-PAINTING => => )) (( # => RELEASE-MATRIX ; && )) )) OK) (LET LISA-PAINT-THIS BE (( ; ; ; )) (( (( => GET-SMART-PAINTING => & )) (( FT ; ; # => LISA-PAINT ; FEET )) (( # => RELEASE-MATRIX ; && )) )) OK) (LET LISA-PAINT-THIS-1-1 BE (( ; )) (( (( => GET-SMART-PAINTING => & )) (( FT ; # => LISA-PAINT-1-1 ; FEET )) (( # => RELEASE-MATRIX ; && )) )) OK) (( LOOKSTK )) (LET EASY-PAINT BE (( ; ; ; )) (( (( ONE => }.TXT} CONCAT => ALREADYFILE (MATCHED (( ONE => GET-SMART-PAINTING => & )) (( ANGEL ANGEL TWO ; # => FT LISA-PAINT FEET )) (( # => RELEASE-MATRIX ; && )) MATCHED) )) (( RM RM RM )) )) OK) (LET CONVERT-XYWH-TO-XYXY BE (( ; ; ; ; )) (( (( => TANTRA ADD DEC => => )) (( => SWITCH YANTRA ADD DEC SWITCH => => )) )) OK) (LET PAINT-SIZE BE (( => & )) (( (( 1 ; # => %GET => %LENGTH )) (( # => %LENGTH )) (( && )) )) OK) (LET TEXT-IS-SOMETHING BE (( ; )) (( (( => ONE => RMBL => TOLEN => ISPRO (MATCHED YES )(OTHER RM NO MATCHED) => => )) )) OK) (( LOOKSTK )) (LET MATR>TEXT (( => & >N1 )) BE (( (( N1 # => %GET => & )) (( # => NOZ (MATCHED (( # => %LENGTH => >N9 )) (( N9 => ISPRO (MATCHED (( N9 => MAKEBL )) (( N9 (COUNT N1 ; # => %GET => AFFIRM (MATCHED (( ; N1 => TOCHN )) )(OTHER (( ; N1 => DEC => SETLENGTH )) (( RMS RMS && && ; EXIT )) MATCHED) COUNTUP) => => )(OTHER }} MATCHED) )) )(OTHER }} MATCHED) )) (( && && )) )) OK) (( LOOKSTK )) (LET ISDIGIT BE (( ; )) (( (( ; => ONE => GETASCII ; 48 ; 57 => WITH => => )) )) OK) (LET AMOUNT-IN-LIST BE (( & )) (( (( 1 ; # => %GET => => )) (( && )) )) OK) (LET START-IN-LIST BE (( & )) (( (( 3 ; 2 ; # => %PUT )) (( && )) )) OK) (LET RECENT-IN-LIST BE (( & )) (( (( 1 ; # => %GET => INC => INC ; 2 ; # => %PUT )) (( && )) )) OK) (LET BEYOND-LIST BE (( & )) (( (( 1 ; # => %GET => INC INC INC ; 2 ; # => %PUT )) (( && )) )) OK) (LET SLENDER-LIST BE (( & )) (( (( 1 ; # => %GET => A (MATCHED (( ; => ONE => DEC ; 1 ; # => %PUT )) (( ; => INC INC ; 2 ; # => %GET => EQN (MATCHED 2 ; # => %GET => DEC ; 2 ; # => %PUT MATCHED) )) MATCHED) (( && )) )) OK) (LET EMPTY-LIST BE (( & )) (( (( 0 ; 1 ; # => %PUT )) (( # => START-IN-LIST )) (( && )) )) OK) (LET THIS-IN-LIST BE (( & )) (( (( 2 ; # => %GET ; # => %GET )) (( && )) )) OK) (LET SET-CURRENT-POS-IN-LIST BE (( & ; )) (( (( ; INC INC ; 2 ; # => %PUT )) (( && )) )) OK) (LET GET-CURRENT-POS-IN-LIST BE (( & )) (( (( 2 ; # => %GET => DEC DEC )) (( && )) )) OK) (LET INTO-LIST-AT-THIS-POS BE (( & ; ; )) (( (( ; ; => INC INC ; # => %PUT )) (( && )) )) OK) (LET INTO-LIST-HERE BE (( & ; )) (( (( ; 2 ; # => %GET ; # => %PUT )) (( && )) )) OK) (LET ISNT-BEFORE-LIST BE (( & )) (( (( 2 ; # => %GET ; 2 => INTGREATER => => )) (( && )) )) OK) (LET ADDITIONAL-IN-LIST BE (( & )) (( (( 1 ; # => %GET INC INC ; 2 ; # => %GET => INTGTOREQUAL => => )) (( && )) )) OK) (LET LIST-EXTRA-SPACE BE (( & )) (( (( # => %LENGTH ; 5 => SUB ; 1 ; # => %GET => SUB => => )) (( && )) )) OK) (LET YOUNGER-IN-LIST BE (( & )) (( (( 2 ; # => %GET ; 2 => INTGREATER (MATCHED 2 ; # => %GET => DEC ; 2 ; # => %PUT MATCHED) )) (( && )) )) OK) (LET NEXT-IN-LIST BE (( & )) (( (( 1 ; # => %GET INC INC ; 2 ; # => %GET => INTGTOREQUAL (MATCHED 2 ; # => %GET => INC ; 2 ; # => %PUT MATCHED) )) (( && )) )) OK) (LET LIST BE (( >N1 )) (( (( N1 5 ADD => %MAKE => & )) (( # => EMPTY-LIST )) (( # => => )) (( && )) )) OK) (LET FREE-LIST BE (( & )) (( (( # => %FREE )) (( && )) )) OK) (LET EXTEND-LIST BE (( & >N1 )) (( (( # => %LENGTH ; 5 => SUB ; 1 ; # => %GET => INTGREATER (MATCHED (( 1 ; # => %GET => INC => ONE ; 1 ; # => %PUT ; INC INC => ONE ; 2 ; # => %PUT ; N1 ; SWITCH ; # => %PUT )) MATCHED) (( && )) )) OK) (LET EXTEND-LIST-IF-WITH BE (( & >N10 >N9 >N1 )) (( (( N1 ; N9 ; N10 => WITH (MATCHED N1 ; # => EXTEND-LIST MATCHED) )) (( && )) )) OK) (LET NUMBERS-TO-LIST BE (( & >N7 >N8 ; )) (( (( ; } } => CONCAT )) (( ; => LENGTH )) (( }} => ANGEL ANGEL (COUNT (( N1 => CH => ISDIGIT (MATCHED (( ANGEL => SWITCH => CONCAT => SWITCH )) )(OTHER (( RM )) (( BRIDGE => TOLEN => NOZ (MATCHED (( SWITCH ; N10 ; N9 ; # => EXTEND-LIST-IF-WITH )) (( }} => SWITCH )) MATCHED) )) MATCHED) )) COUNTUP) )) (( RM RM )) (( && )) )) OK) (LET LOOP-THROUGH-LIST BE (( & >N1 )) (( (( # => START-IN-LIST )) (( GOLABEL1: (( # => ADDITIONAL-IN-LIST (MATCHED (( # => THIS-IN-LIST ; N1 => H )) (( # => NEXT-IN-LIST )) (( GOUP1 )) MATCHED) )) )) (( && )) )) OK) (LET SHOW-LIST BE (( & )) (( (( }POPS} => ? ; # => LOOP-THROUGH-LIST )) (( && )) )) OK) (LET CONVERSE-THROUGH-LIST BE (( & >N1 )) (( (( # => BEYOND-LIST )) (( GOLABEL1: (( # => YOUNGER-IN-LIST )) (( # => ISNT-BEFORE-LIST (MATCHED (( # => THIS-IN-LIST ; N1 => H )) (( GOUP1 )) MATCHED) )) (( && )) )) OK) (LET SHOW-LIST-REVERSE BE (( & )) (( (( }POPS} => ? ; # => CONVERSE-THROUGH-LIST )) (( && )) )) OK) (LET CLEAR-MATRIX-ESSENCE BE (( )) (( (( 0 => TOV11 )) )) OK) ((DATA CLEAR-MATRIX-HOUSE }CLEAR-MATRIX-ESSENCE} => ? CLEAR-MATRIX-HOUSE <>> ; # => FORVPM )) (( && )) )) OK) (( VARSTRING CD-LAB-MODELS-FILE }MODELS} CD-LAB-MODELS-FILE => >VARSTR )) ((DATA CD-CURR-X 480 CD-CURR-X <>> ; CARTOON-HEIGHT >>> => MUL ANIMATION-TRIX-H < LIST YOGA4D_COM <>> ; CD-AMOUNTS >>> => INC ; CARTOON-HEIGHT >>> => MUL => RAM-PM ANIMATION-TRIX <>> 10 ADD ; CARTOON-HEIGHT >>> 10 ADD ; => RAM-PM => ANIMATION-CARTOON <>> >>V => WRITEPAL )) (( ^0 ^255 ^0 64 >>V => WRITEPAL )) (( PUTPAL )) )) OK) ((DATA MY-PALETTE-HOUSE }MY-PALETTE-ESSENCE} => ? MY-PALETTE-HOUSE <>> => H )) )) OK) ((DATA KEY-ENTER 13 KEY-ENTER < ok)} POP ; CRLN )) (( } sketch } POP )) (( CRLN CRLN )) )) OK) (LET SET-RANGE BE (( ; ; ; )) (( (( TANTRA ; BRIDGE => INTGREATER (MATCHED (( ANGEL => ANGEL )) (( RM ; RM )) )(OTHER (( RM )) (( TWO => INTLESSTHAN (MATCHED (( SWITCH => RM )) )(OTHER (( RM )) MATCHED) MATCHED) )) )) OK) ((DATA PEN-X )) ((DATA PEN-Y )) ((DATA PEN-DEGREE )) ((DATA PEN-COLOR )) (LET PEN-ORIGO BE (( )) (( (( 768 => DIV2 PEN-Y < DIV2 PEN-X < PEN-COLOR < PEN-DEGREE <N1 )) (( (( N1 ; 0 ; 3599 => SET-RANGE ; PEN-DEGREE => ADDVAR )) (( PEN-DEGREE >>> ; 3599 INTGREATER (MATCHED -3600 PEN-DEGREE => ADDVAR MATCHED) )) )) OK) (LET PEN-RIGHT BE (( >N1 )) (( (( N1 ; 0 ; 3599 => SET-RANGE => SG ; PEN-DEGREE => ADDVAR )) (( PEN-DEGREE >>> => SG => ISPRO (MATCHED 3600 PEN-DEGREE => ADDVAR MATCHED) )) )) OK) (LET PEN-RADIANS BE (( )) (( PEN-DEGREE >>> => STKTORICH ; $10 => \R ; $180 => \R ; $3.14151926 => *R )) OK) (LET PEN-X1Y1-X2Y2 BE (( >N1 )) (( (( PEN-X >>> >N4 )) (( PEN-Y >>> >N6 )) (( N4 ; PEN-RADIANS => ONER => COSR ; N1 => STKTORICH => *R => RICHTOSTK => ADD => >N8 ; N6 ; SINR ; N1 => STKTORICH => *R => RICHTOSTK => SUB => >N10 ; )) (( N4 ; N6 ; N8 ; N10 => => )) )) OK) (LET PEN-FORWARD BE (( >N1 )) (( (( N1 => PEN-X1Y1-X2Y2 ; PEN-Y <N1 )) (( (( N1 => PEN-X1Y1-X2Y2 ; TWO >N1 >N2 ; 1 ; 1 ; PEN-COLOR >>> => FT PAINTLINE FEET )) (( N1 PEN-Y <N1 )) (( (( N1 => PEN-X1Y1-X2Y2 ; TWO >N1 >N2 ; 4 ; 3 ; PEN-COLOR >>> => FT PAINTLINE FEET )) (( N1 PEN-Y < TOV6 TOV5 TOV4 TOV3 TOV2 TOV1 )) (( (( V3 ; V1 => SUB ; V5 => DIV => DEC => TOV7 )) (( V4 ; V2 => SUB ; V5 => DIV => DEC DEC => TOV8 )) (( V7 (COUNT V8 (COUNT N3 V5 => MUL V1 => ADD ; N1 V5 => MUL V2 => ADD ; BRIDGE V5 => ADD ; BRIDGE V5 => ADD ; V6 => RECT COUNTUP) COUNTUP) )) (( VFREE )) )) OK) (LET BASICS-STANDARDS BE (( )) (( (( START-GRAPHICS )) (( XO-STATUS-ON => SETBASIS )) )) OK) (( LOOKSTK )) (LET LAB-CLR BE (( >N4 >N3 >N2 >N1 )) (( (( CARTOON-WIDTH >>> >N6 )) (( N1 ; N2 ; N1 N6 ADD ; N2 CARTOON-HEIGHT >>> ADD ; CD-BG >>> => FT RECTFILL FEET )) (( N1 N6 ADD N6 10 DIV ADD ; N2 ; BRIDGE N6 ADD ; BRIDGE CARTOON-HEIGHT >>> ADD ; CD-BG >>> => FT RECTFILL FEET )) (( N3 ; N4 ; N3 400 => ADD ; N4 400 => ADD ; CD-BG >>> => FT RECTFILL FEET )) )) OK) (LET MAKE-YOGA4D_COM-ALL-FRESH BE (( )) (( (( YOGA4D_COM >>> %EMPTY )) )) OK) (LET MAKE-YOGA6D_COM-ALL-FRESH BE (( )) (( (( YOGA6D_COM => SETDANCE )) )) OK) (( LOOKSTK )) (LET LETS-TRAVEL BE (( )) (( (( ANIMATION-TRIX >>> CLEAR-MATRIX )) (( ANIMATION-CARTOON >>> CLEAR-MATRIX )) )) OK) (( LOOKSTK )) (( LOOKSTK )) (LET CARTOON-PIXEL BE (( ; ; )) (( (( CD-FG >>> => FT PUTPIXEL FEET )) )) OK) (LET SKETCH-PIXEL BE (( ; ; )) (( (( BRIDGE INC ; BRIDGE INC ; CD-FG >>> => FT RECTFILL FEET )) )) OK) (LET FREE-CARTOON-PIXEL BE (( ; ; )) (( (( CD-BG >>> => FT PUTPIXEL FEET )) )) OK) (LET FREE-SKETCH-PIXEL BE (( ; ; )) (( (( BRIDGE INC ; BRIDGE INC ; CD-BG >>> => FT RECTFILL FEET )) )) OK) (( LOOKSTK )) (LET DISPLAY-SKETCH-AGAIN BE (( >N2 >N1 )) (( (( CARTOON-HEIGHT >>> (COUNT (( CARTOON-WIDTH >>> (COUNT N1 ; N3 ; V1 => GM => ISDANCE (MATCHED N5 N1 TWICE ADD ; N6 N3 TWICE ADD => SKETCH-PIXEL MATCHED) COUNTUP) )) COUNTUP) )) )) OK) (LET DISPLAY-CARTOON-AGAIN BE (( >N2 >N1 )) (( (( CARTOON-HEIGHT >>> (COUNT CARTOON-WIDTH >>> (COUNT (( N1 ; N3 ; V1 => GM => ISDANCE (MATCHED N5 N1 ADD ; N6 N3 ADD => CARTOON-PIXEL MATCHED) )) COUNTUP) COUNTUP) )) )) OK) (LET FRESH-RENDER BE (( >N2 >N1 )) (( (( CARTOON-HEIGHT >>> (COUNT CARTOON-WIDTH >>> (COUNT (( N1 ; N3 ; V1 => GM => ISDANCE (MATCHED N5 N1 ADD ; N6 N3 ADD => CARTOON-PIXEL MATCHED) )) COUNTUP) COUNTUP) )) )) OK) (( LOOKSTK )) (LET UPDATE-IN-SKETCH BE (( >N4 >N3 >N2 >N1 )) (( (( N3 N1 TWICE ADD ; N4 N2 TWICE ADD )) (( N1 ; N2 ; V1 => GM => ISDANCE = SKETCH-PIXEL == FREE-SKETCH-PIXEL === )) )) OK) (LET UPDATE-IN-CARTOON BE (( >N4 >N3 >N2 >N1 )) (( (( N3 N1 ADD ; N4 N2 ADD )) (( N1 ; N2 ; V1 => GM => ISDANCE = CARTOON-PIXEL == FREE-CARTOON-PIXEL === )) )) OK) (( LOOKSTK )) (LET IS-ANY-IN-LIST BE (( & )) (( (( # => START-IN-LIST )) (( # => ADDITIONAL-IN-LIST => => )) (( && )) )) OK) (LET IS-THIS-IN-LIST BE (( & >N1 )) (( (( # => START-IN-LIST )) (( GOLABEL1: (( # => ADDITIONAL-IN-LIST (MATCHED (( # => THIS-IN-LIST ; N1 => EQN (MATCHED (( Y => => )) (( && ; EXIT )) MATCHED) (( # => NEXT-IN-LIST )) (( GOUP1 )) MATCHED) )) )) (( && )) (( N => => )) )) OK) (( LOOKSTK )) (LET AT-LEAST-NUMBER-1-IN-LIST BE (( & )) (( (( # => IS-ANY-IN-LIST => NOT (MATCHED (( 1 ; # => EXTEND-LIST )) MATCHED) )) (( && )) )) OK) ((DATA ANIMATION-EXTRA )) ((DATA IS-SKETCH-IN-RENDER-LIST )) (LET FIND-OUT-IS-SKETCH-IN-RENDER-LIST BE (( )) (( (( YOGA6D_COM >>> ; YOGA4D_COM >>> => IS-THIS-IN-LIST => Y-TO-1 IS-SKETCH-IN-RENDER-LIST <>> EMPTY-LIST )) (( YOGA4D_COM >>> AT-LEAST-NUMBER-1-IN-LIST )) )) OK) (LET READY-WITH-YOGA6D_COM BE (( )) (( (( YOGA6D_COM => SETDANCE )) (( ANIMATION-EXTRA => SETBASIS )) )) OK) (LET READY-BOTH-FOR-LAB BE (( )) (( (( READY-WITH-YOGA4D_COM )) (( READY-WITH-YOGA6D_COM )) (( IS-SKETCH-IN-RENDER-LIST => SETDANCE )) )) OK) (LET UPDATE-ANIMATION-EXTRA BE (( )) (( (( CARTOON-HEIGHT >>> ; YOGA6D_COM >>> => DEC => MUL ANIMATION-EXTRA <>> => ONE ; ANGEL => DEC => MUL => SWITCH => => ; ; )) )) OK) ((DATA LAB-RENDER-X )) ((DATA LAB-RENDER-Y )) (LET FRESH-RENDER-FASTER-ESSENCE BE (( ; )) (( (( FT )) (( ANIMATION-TRIX >>> & )) (( ; FIND-START-IN-TRIX )) (( ; ; (COUNT CARTOON-WIDTH >>> (COUNT (( N1 ; BRIDGE N3 ADD ; # => GM => ISDANCE (MATCHED LAB-RENDER-X >>> N1 ADD ; LAB-RENDER-Y >>> N3 ADD => CD-FG >>> => PUTPIXEL MATCHED) )) COUNTUP) COUNTUP) ; RM )) (( && )) (( FEET )) )) OK) ((DATA FRESH-RENDER-FASTER-HOUSE }FRESH-RENDER-FASTER-ESSENCE} => ? FRESH-RENDER-FASTER-HOUSE <>> ; YOGA4D_COM >>> => LOOP-THROUGH-LIST )) )) OK) (( LOOKSTK )) (LET IS-PIXEL-IN-RENDER BE (( >N2 >N1 )) (( (( ANIMATION-TRIX >>> & )) (( YOGA4D_COM >>> & )) (( CARTOON-HEIGHT >>> ; )) (( # => START-IN-LIST )) (( GOLABEL1: (( # => ADDITIONAL-IN-LIST (MATCHED (( # => THIS-IN-LIST => DEC ; BRIDGE => MUL ; N2 => ADD ; N1 => SWITCH ; ## => GM => ISDANCE (MATCHED (( RM ; && ; && )) (( Y => => ; EXIT )) MATCHED) (( # => NEXT-IN-LIST )) (( GOUP1 )) MATCHED) )) )) (( RM ; && ; && )) (( N => => )) )) OK) (LET UPDATE-IN-RENDER-MAYBE BE (( >N4 >N3 >N2 >N1 )) (( (( IS-SKETCH-IN-RENDER-LIST => VISBASIS = EXIT === )) (( N1 ; N2 ; ANIMATION-EXTRA >>> ADD ; ANIMATION-TRIX >>> => GM => ISDANCE (MATCHED (( N3 N1 ADD ; N4 N2 ADD ; CD-FG >>> FT PUTPIXEL FEET )) )(OTHER (( N1 ; N2 => IS-PIXEL-IN-RENDER => NOT (MATCHED (( N3 N1 ADD ; N4 N2 ADD ; CD-BG >>> FT PUTPIXEL FEET )) MATCHED) MATCHED) )) )) OK) (LET DISPLAY-SKETCH-AGAIN-FASTER BE (( >N2 >N1 )) (( (( FT )) (( ANIMATION-TRIX >>> & )) (( YOGA6D_COM >>> => FIND-START-IN-TRIX )) (( ; ; (COUNT (( CARTOON-WIDTH >>> (COUNT (( N1 ; BRIDGE N3 ADD ; # => GM => ISDANCE (MATCHED N5 N1 TWICE ADD ; N6 N3 TWICE ADD => BRIDGE INC ; BRIDGE INC ; CD-FG >>> => RECTFILL MATCHED) )) COUNTUP) )) COUNTUP) ; RM )) (( && )) (( FEET )) )) OK) (LET DISPLAY-CARTOON-AGAIN-FASTER BE (( >N2 >N1 )) (( (( FT )) (( ANIMATION-TRIX >>> & )) (( YOGA6D_COM >>> => FIND-START-IN-TRIX )) (( ; ; (COUNT CARTOON-WIDTH >>> (COUNT (( N1 ; BRIDGE N3 ADD ; # => GM => ISDANCE (MATCHED N5 N1 ADD ; N6 N3 ADD => CD-FG >>> => PUTPIXEL MATCHED) )) COUNTUP) COUNTUP) ; RM )) (( && )) (( FEET )) )) OK) (( LOOKSTK )) (LET NEW-PALETTE-ESSENCE BE (( )) (( (( ^191 ^245 ^0 CD-BG >>> >>V => WRITEPAL )) (( ^0 ^255 ^0 64 >>V => WRITEPAL )) (( ^46 ^18 ^51 255 >>V => WRITEPAL )) (( PUTPAL )) )) OK) (( }NEW-PALETTE-ESSENCE} => ? MY-PALETTE-HOUSE <N4 >N3 >N2 >N1 )) (( (( CARTOON-WIDTH >>> >N6 )) (( N1 ; N2 ; N1 N6 ADD ; N2 CARTOON-HEIGHT >>> ADD ; CD-BG >>> => FT RECTFILL FEET )) (( N3 ; N4 ; N3 400 => ADD ; N4 400 => ADD ; CD-BG >>> => FT RECTFILL FEET )) )) OK) (LET RENDER-CLR BE (( >N4 >N3 >N2 >N1 )) (( (( CARTOON-WIDTH >>> >N6 )) (( N1 N6 ADD N6 10 DIV ADD ; N2 ; BRIDGE N6 ADD ; BRIDGE CARTOON-HEIGHT >>> ADD ; CD-BG >>> => FT RECTFILL FEET )) )) OK) ((DATA INPUT-FILE-WIDTH 100 INPUT-FILE-WIDTH < %LENGTH (COUNT (( N1 ; # => %GET => ISBASIS (MATCHED (( N1 => DEC => => )) (( && ; RMS ; RMS ; EXIT )) MATCHED) COUNTUP) )) (( # => %LENGTH => => )) (( && )) )) OK) ((DATA FIND-MAX-LINE-NUM-DATA )) (LET FIND-MAX-LINE-NUM-ESSENCE BE (( )) (( (( V3 FIND-MAX-LINE-NUM-DATA < TOV2 )) )) OK) (LET FIND-MAX-LINE-NUM BE (( & )) (( (( FIND-MAX-LINE-NUM-DATA => SETBASIS )) (( }FIND-MAX-LINE-NUM-ESSENCE} => ? ; # => FORVPM )) (( FIND-MAX-LINE-NUM-DATA >>> => => )) (( && )) )) OK) (LET FIX-BLANK-LINES-IN-FILE BE (( & )) (( (( # => FIND-MAX-LINE-NUM (COUNT (( 1 ; N1 ; # => GM => NOZ NOT (MATCHED 32 ; 1 ; N1 ; # => PM MATCHED) )) COUNTUP) )) (( && )) )) OK) (LET CONVBAT-ALLOCATE-RAM BE (( )) (( (( }* BEFORE WE READ IN ANYTHING, THE PC ALLOCATES RAM..} => POP )) (( }* (AS SAID, THE VARIABLES IN THE CONVBAT.TXT} => POP )) (( }* ARE VERY EASY TO CHANGE IF E.G. YOU TRY THIS} => POP )) (( }* WITH AN ANTIQUE PC INSTEAD OF A Y2000-COMPLIANT PC.)} => POP )) (( }* BY THE WAY, THIS UTILITY CAN ALSO BE USED IN ORDER TO} => POP )) (( }* MAKE TEXT FILES WHICH ARE PUT INTO THE OPERATING} => POP )) (( }* APPROACH FROM A VARIETY OF OTHER PROGRAMS CONFORM TO} => POP )) (( }* THE F3 STANDARD, THAT A LINE WHICH IS EMPTY MUST} => POP )) (( }* HAVE AT LEAST ONE SPACE CHARACTER TO COUNT.} => POP )) (( }* .} => POP )) (( TRANSLATION-TABLE-WIDTH >>> ; TRANSLATION-TABLE-HEIGHT >>> => RAM-PM TRANSLATION-TABLE < POP )) (( INPUT-FILE-WIDTH >>> ; IO-FILE-HEIGHT >>> ; 20 => ADD => RAM-PM INPUT-FILE < POP )) (( OUTPUT-FILE-WIDTH >>> ; IO-FILE-HEIGHT >>> ; 20 => ADD => RAM-PM OUTPUT-FILE < POP )) (( }* ..DONE ALLOCATING RAM! } => POP )) )) OK) ((DATA USES-TRANSLATION-TABLE )) (LET ASK-FOR-WHEREABOUTS-OF-CONVBAT2 BE (( )) (( (( CLS )) (( }************************convbat*********************} => POP )) (( }* HI! THIS PROGRAM WILL CONVERT ONE OR SEVERAL FILES} => POP )) (( }* ACCORDING TO ONE OR SEVERAL PATTERN SUBSTITUTIONS} => POP )) (( }* WHICH ARE SPECIFIED IN CONVBAT2.TXT IN AN EASY FORMAT.} => POP )) (( }* YOU CAN EDIT CONVBAT2.TXT YOURSELF IN ANY EDITOR.} => POP )) (( }* THE FIRST FORTY LINES IS A COMMENTARY SECTION,} => POP )) (( }* AND IT DESCRIBES ITSELF. MORE COMMENTS ALSO INSIDE} => POP )) (( }* THE BEGINNING OF THE SOURCE OF THIS EASY PROGRAM.} => POP )) (( }* THIS IS SUITABLE E.G. WHEN CONVERTING FROM A WORD} => POP )) (( }* PROCESSOR FORMAT, PERHAPS THROUGH OOWRITER (IN THE} => POP )) (( }* MANNER DESCRIBED IN THE COMMENTS IN THIS PROGRAM} => POP )) (( }* TO A .TXT FORM, SO AS TO CLEANSE THE .TXT FROM} => POP )) (( }* ASCII CODES WHICH ARE HIGHER THAN 127, E.G. ETHNIC} => POP )) (( }* CHARACTERS -- AND WITH MANY SUBSTITUTIONS IN A ROW,} => POP )) (( }* THIS CAN BE SEEN AS A 'SUBSTITUTION MACRO'. YOU CAN ALSO} => POP )) (( }* REPLACE A WORD WITH NAUGHT, OR ANY WORD WITH ANY OTHER,} => POP )) (( }* -- AND THIS PROGRAM IS MADE SO THAT THE LINES MUST NOT BE} => POP )) (( }* ANY WIDER THAN 100, AND RESULTING LINES NOT ANY WIDER THAN} => POP )) (( }* 500, AND AMOUNT OF LINES NOT ANY WIDER THAN 10000 -- BUT} => POP )) (( }* THIS YOU CAN E A S I L Y CHANGE (DO SO IF PC HAS LITTLE RAM!).} => POP )) (( }* THIS ALSO ONLY LOOKS FOR PATTERNS FOUND AS A WHOLE IN A LINE.} => POP )) (( }* PLEASE KNOW CORRECT FILENAMES BEFORE STARTING, THIS OVERWRITES!} => POP )) (( ENTERPLS )) (( CLS )) (( }*======> DO YOU WISH TO USE A TRANSLATION TABLE (E.G. CONVBAT2)} => POP )) (( }*======> (OR IS YOUR BUSINESS NOW JUST TO CONVERT A TEXT FILE} => POP )) (( }*======> INTO THE STANDARD USED ALSO BY MONET AND KINGLINE, } => POP )) (( }*======> WITH ONE SPACE CHAR ON EACH EMPTY LINE?)} => POP )) (( }*======> SO, USE TABLE?} => POPS )) (( USES-TRANSLATION-TABLE => YNIN = SETDANCE == SETBASIS === )) (( USES-TRANSLATION-TABLE => VISDANCE (MATCHED (( }*======> PLEASE GIVE FOLDER/FILENAME (WITHOUT .TXT) FOR YOUR} => POP )) (( }*======> TABLE [ENTER FOR CONVBAT2] } => POPS )) (( READLN => RMBL => LENGTH => NOZ NOT (MATCHED RM ; :CONVBAT2 MATCHED) )) (( ONE => TRANSLATION-TABLE-NAME >VARSTR )) (( ; => REAL-TXT-FILE = RM ; Y == N === => => )) )(OTHER (( Y => => )) MATCHED) )) OK) (LET READ-IN-CONVBAT2 BE (( )) (( (( TRANSLATION-TABLE-NAME VARSTR> ; }.TXT} => CONCAT ; TRANSLATION-TABLE >>> => FILE2PM ; RM )) )) OK) (LET NULL-TO-ASCII-SPACE BE (( ; )) (( (( ; ONE => ISBASIS = RM ; 32 === => => )) )) OK) (LET NULL-TO-ASCII-ZERO BE (( ; )) (( (( ; ONE => ISBASIS = RM ; 48 === => => )) )) OK) ((DATA AMOUNT-SUBSTITUTIONS )) (LET ENCODE-CONVERSION-TABLE BE (( )) (( (( AMOUNT-SUBSTITUTIONS >>> => TWICE => >N8 )) (( N8 => ISBASIS = EXIT === )) (( TRANSLATION-TABLE >>> => & )) (( N8 (COUNT (( N1 ; 40 => ADD ; # => %GET => >N8 )) (( N8 => ACTIVE-LENGTH => UP-TO-EVEN => >N10 )) (( 1 => >N11 )) (( 1 => >N7 )) (( GOLABEL2: )) (( N11 ; N10 => INTGREATER = GOFORWARD4 === )) (( N11 ; N8 => %GET ; 47 => EQN (MATCHED (( }/} => POPS )) (( INCN11 )) (( N11 ; N8 => %GET => NULL-TO-ASCII-ZERO => ASCII ; )) (( INCN11 )) (( N11 ; N8 => %GET => NULL-TO-ASCII-ZERO => ASCII ; )) (( INCN11 )) (( N11 ; N8 => %GET => NULL-TO-ASCII-ZERO => ASCII ; )) (( ; ; ; => CONCAT => CONCAT => >N6 )) (( N6 ; N7 ; N1 ; # => PM )) (( INCN7 )) )(OTHER (( }=} => POPS )) (( INCN11 )) (( N11 ; N8 => %GET => NULL-TO-ASCII-SPACE => >N6 )) (( N6 ; N7 ; N1 ; # => PM )) (( INCN7 )) MATCHED) )) (( INCN11 )) (( GOUP2 )) (( GOLABEL4: )) (( 0 ; N7 ; N1 ; # => PM )) (( SPACE )) COUNTUP) )) (( && )) )) OK) (LET ASK-FOR-FILE-TO-CONVERT BE (( )) (( (( }********************************************************} => POP )) (( }* BATCH CONVERSION -- SPECIFY INPUT FILE} => POP )) (( }*======> PLEASE GIVE FOLDER/FILENAME (WITHOUT .TXT) FOR} => POP )) (( }*======> TEXT [E.G. MYFOLDER/LETTER1] } => POPS )) (( READLN => RMBL => ONE INPUT-FILE-NAME >VARSTR )) (( ; => REAL-TXT-FILE = RM ; Y == N === => => )) )) OK) (LET READ-IN-FILE-TO-CONVERT-ESSENCE BE (( )) (( (( V11 SG ISPRO = 256 V11 ADD TOV11 === )) )) OK) (LET READ-IN-FILE-TO-CONVERT BE (( )) (( (( INPUT-FILE-NAME VARSTR> ; }.TXT} => CONCAT ; INPUT-FILE >>> => FILE2PM ; RM )) (( }READ-IN-FILE-TO-CONVERT-ESSENCE} => ? ; INPUT-FILE >>> => FORVPM )) )) OK) (LET ASK-FOR-NAME-OF-CONVERTED BE (( )) (( (( }********************************************************} => POP )) (( }* SPECIFY OUTPUT FILE. NB: ANY SAME-NAMED FILE IS OVERWRITTEN!!!} => POP )) (( }*======> PLEASE GIVE FOLDER/FILENAME (WITHOUT .TXT) FOR NEW FILE} => POP )) (( }*======> [ENTER TO OVERWRITE INPUT FILE] } => POPS )) (( READLN => RMBL => LENGTH => NOZ NOT (MATCHED RM ; INPUT-FILE-NAME VARSTR> MATCHED) )) (( ONE => OUTPUT-FILE-NAME >VARSTR )) (( ; => TOLEN => ISPRO => => )) )) OK) (( LOOKSTK )) ((DATA CURRENT-POS )) (LET DO-GOOD-WORK BE (( >N3 >N1 >N5 )) (( (( AMOUNT-SUBSTITUTIONS >>> => TWICE (COUNT (( 1 ; N1 ; ### => GM ; N7 => EQN (MATCHED (( }:} => ( )) (( N1 ; ### => %GET => ACTIVE-LENGTH => ONE DEC >N6 (COUNT (( N1 ; N3 ; ### => GM ; (( N5 N1 DEC ADD ; N7 ; ## => GM => NOT_INTEQUAL = RMS RMS ; GOFORWARD3 === )) COUNTUP) )) (( }*} => ( )) (( N1 INC ; ### => %GET => ACTIVE-LENGTH (COUNT (( N1 ; N3 INC ; ### => GM ; CURRENT-POS >>> ; N7 ; # => PM )) (( CURRENT-POS => INCVAR )) COUNTUP) (( RMS ; RMS ; N1 N4 ADD => => ; EXIT )) (( GOLABEL3: )) MATCHED) )) (( INCN1 )) COUNTUP) )) (( N5 ; CURRENT-POS >>> ; N3 ; # => PM )) (( CURRENT-POS => INCVAR )) (( N1 => => )) )) OK) (( LOOKSTK )) (LET CONVERT-IT BE (( )) (( (( }* CONVERSION PROCEEDING!} => POP )) (( SOLIDCURSOR )) (( TRANSLATION-TABLE >>> & )) (( INPUT-FILE >>> & )) (( OUTPUT-FILE >>> & )) (( DOCUMENT-LENGTH >>> (COUNT (( CURRENT-POS => SETDANCE )) (( INPUT-FILE-WIDTH >>> (COUNT (( N1 ; N3 ; ## => GM => >N5 )) (( N5 => NOZ NOT = RMS RMS GOFORWARD4 === )) (( USES-TRANSLATION-TABLE => VISDANCE (MATCHED (( N5 ; N1 ; N3 => DO-GOOD-WORK => >N1 )) )(OTHER (( N5 ; N1 ; N3 ; # => PM )) MATCHED) )) COUNTUP) )) (( GOLABEL4: )) COUNTUP) )) (( && && && )) (( CRLN )) (( }* ALRIGHT. WILL SAVE NEXT. PLS CHECK SAVED FILE ***********} => POP )) (( FUNCURSOR )) )) OK) (LET ADD-APPEND-LINES BE (( )) (( (( OUTPUT-FILE >>> & )) (( DOCUMENT-LENGTH >>> >N8 )) (( 10 (COUNT (( }APPEND-LINE-} ; N1 => CONCAT => ? => H ; )) (( ONEV => VARSTR-LEN => ISPRO (MATCHED (( INCN10 )) (( ; VARSTR> ; N10 ; # => TEXT>MATRIX )) )(OTHER (( RMV )) MATCHED) )) COUNTUP) )) (( && )) )) OK) (LET STORE-IT BE (( )) (( (( OUTPUT-FILE-NAME VARSTR> ; }.TXT} => CONCAT ; OUTPUT-FILE >>> => PM2FILE ; RM )) )) OK) (( LOOKSTK )) (( 10 AMOUNT-APPEND-LINES <VARSTR )) (( }} APPEND-LINE-2 >VARSTR )) (( }} APPEND-LINE-3 >VARSTR )) (( }} APPEND-LINE-4 >VARSTR )) (( }} APPEND-LINE-5 >VARSTR )) (( }} APPEND-LINE-6 >VARSTR )) (( }} APPEND-LINE-7 >VARSTR )) (( }} APPEND-LINE-8 >VARSTR )) (( }} APPEND-LINE-9 >VARSTR )) (( }} APPEND-LINE-10 >VARSTR )) (( LOOKSTK )) (LET ASK-WHETHER-INTERACTOR-WANTS-MORE BE (( )) (( (( }* MORE CONVERSIONS?} => POPS )) (( YNIN => ONE (MATCHED (( INPUT-FILE >>> => CLEAR-MATRIX )) (( OUTPUT-FILE >>> => CLEAR-MATRIX )) MATCHED) => => )) )) OK) (( LOOKSTK )) (LET SAY-THANKS BE (( )) (( (( }*} => POP )) (( }*} => POP )) (( }* PROGRAM DONE.} => POPS ; ENTERPLS )) (( }*} => POP )) (( }*} => POP )) (( }*} => POP )) (( }********************ALWAYS PLEASED TO SERVE YOU!} => POP )) )) OK) (( LOOKSTK )) (LET CONVERSION BE (( )) (( (( USES-TRANSLATION-TABLE => SETDANCE )) (( ASK-FOR-WHEREABOUTS-OF-CONVBAT2 => NOT = EXIT === )) (( CONVBAT-ALLOCATE-RAM )) (( READ-IN-CONVBAT2 )) (( USES-TRANSLATION-TABLE => VISDANCE (MATCHED (( TRANSLATION-TABLE >>> FIX-BLANK-LINES-IN-FILE )) (( TRANSLATION-TABLE >>> => FIND-MAX-LINE-NUM ; 40 => SUB => DIV2 AMOUNT-SUBSTITUTIONS <>> ; 0 ; TRANSLATION-TABLE-HEIGHT >>> ; 42 SUB => SET-RANGE AMOUNT-SUBSTITUTIONS < POPS )) (( AMOUNT-SUBSTITUTIONS >>> POPS )) (( }PAIRS.} => POP )) (( CRLN )) (( ENTERPLS )) (( CLS )) (( }************ ENCODING IT:} => POPS )) (( ENCODE-CONVERSION-TABLE )) MATCHED) )) (( CRLN )) (( }******* READY TO ACT} => POP )) (( CLEAR_KEYBUF )) (( GOLABEL4: )) (( ASK-FOR-FILE-TO-CONVERT => NOT = EXIT === )) (( READ-IN-FILE-TO-CONVERT )) (( INPUT-FILE >>> FIND-MAX-LINE-NUM DOCUMENT-LENGTH <>> ; }************** HIGHEST-NUMBERED TEXT LINE W/CONTENT:} => POPS ; POP )) (( }****** (INSERTS ONE BLANK INTO EMPTY LINES, } => POP )) (( }****** UP TO THE COMPLETING LINE WITH SOMETHING ON IT,} => POP )) (( }****** SO IT WILL WORK BETTER WITH TOHTML5 AND SO ON.)} => POP )) (( INPUT-FILE >>> FIX-BLANK-LINES-IN-FILE )) (( ASK-FOR-NAME-OF-CONVERTED => NOT = EXIT === )) (( CONVERT-IT )) (( ADD-APPEND-LINES )) (( STORE-IT )) (( ASK-WHETHER-INTERACTOR-WANTS-MORE => = CLS GOUP4 === )) )) OK) (( LOOKSTK )) (LET CONVBAT BE (( )) (( (( CONVERSION )) (( SAY-THANKS )) (( RAM-REFRESH )) )) OK) **** =======INFO=TO=THE=PROGRAMMER=============================== THE NEXT COUPLE OF DOZENS OF TEXTLINES IS AN EXAMPLE OF A SUITABLE BATCH CONVERSION TABLE FOR CONVBAT, WHICH YOU CAN EXTRACT AND PUT IN A FILE AND CALL E.G. CONVBAT2.TXT ============================================================ This is line 1: The forty first lines in each batch translation table are just comment lines, the next are pairwise what is to be matched against and then what it is to be substituted with, when there is match -- that is, line 41 has match, 42 has substitute, and so on. This is inputted to CONVBAT.TXT. This is a translation table which I have found useful in preparing some texts for the html when they have some commonly found letters in Norwegian texts, but they are merely included as an example. I just made it fit with a particular job I had, so feel free to expand it yourself. The program substitutes when it finds a match, then moves ahead in the document at once. Since we need in this file to refer to other than plain 7-bit ascii characters, I have made a code. The code allows you to either give the text as text, or to give the text by its ascii number. To give the text Hello world, you can type =H=e=l=l=o= =w=o=r=l=d But to give the ascii code 243 followed by 245, followed by blank followed by the same, try /243/245= =H=e=l=l=o= =w=o=r=l=d So this can be what is matched against -- or what is inserted instead of what is found. The code format is the same. Note that the correct format of a number less than three digits begins with zeroes so that the number size is three in length: like /031/007 and so on. There is no trouble about writing e.g. =/ if you want the slash character matched against, but in this file, please do not insert any extra blanks at all. No 8-bit code in this file. Line 40: ***********ENTER CODE ON NEXT:******** /195/165 =&=a=r=i=n=g=; /195/133 =&=A=r=i=n=g=; /195/184 =&=o=s=l=a=s=h=; /195/152 =&=O=s=l=a=s=h=; /195/166 =&=a=e=l=i=g=; /195/134 =&=A=E=l=i=g=; ============================================================ THE ABOVE COUPLE OF DOZENS OF TEXTLINES IS AN EXAMPLE OF A SUITABLE BATCH CONVERSION TABLE FOR CONVBAT, WHICH YOU CAN EXTRACT AND PUT IN A FILE AND CALL E.G. CONVBAT2.TXT ============================================================ { ((DATA KEEP-GOING )) ((DATA INPUT-FILE-HEIGHT )) ((DATA OUTPUT-FILE-HEIGHT )) ((DATA AMOUNT-LINES-ORIGINALLY )) ((DATA VERIFIED-DOCUMENT-LENGTH )) (LET CALC-AMOUNT-LINES-IN-TXT-OF-ANY-WIDTH BE (( ; )) (( (( ; }.TXT} => CONCAT => COUNTLINES => RM ; RM => => )) )) OK) (LET ACTIVE-LENGTH BE (( & )) (( (( # => %LENGTH (COUNT (( N1 ; # => %GET => ISBASIS (MATCHED (( N1 => DEC => => )) (( && ; RMS ; RMS ; EXIT )) MATCHED) COUNTUP) )) (( # => %LENGTH => => )) (( && )) )) OK) (LET WORDWRAP-ASK-FOR-FILE-TO-CONVERT BE (( )) (( (( CLS )) (( }************************wordwrap*********************} => POP )) (( }* HI! THIS PROGRAM WILL DO WORDWRAP ON .TXT FILES,} => POP )) (( }* WHICH MIGHT POSSIBLY HAVE FEW LINESHIFTS IN THEM.} => POP )) (( }* THIS WORDWRAP HAS BEEN DESIGNED SO THAT IT WORKS} => POP )) (( }* SMOOTHLY EVEN THOUGH THERE ARE EIGHT-BIT CODES} => POP )) (( }* IN IT. } => POP )) (( ENTERPLS ; CLS )) (( }* WORDWRAP -- SPECIFY INPUT .TXT FILE} => POP )) (( }*======> PLEASE GIVE FOLDER/FILENAME (WITHOUT .TXT) FOR} => POP )) (( }*======> TEXT [E.G. MYFOLDER/LETTER1] } => POPS )) (( READLN => RMBL => ONE INPUT-FILE-NAME >VARSTR )) (( ; => REAL-TXT-FILE = RM ; Y == N === => => )) )) OK) (LET READ-IN-FILE-TO-CONVERT-ESSENCE BE (( )) (( (( V11 SG ISPRO = 256 V11 ADD TOV11 === )) )) OK) (( LOOKSTK )) (LET ALLOCATE-INPUT-FILE-SPACE BE (( )) (( (( }* ALLOCATING (NEW) INPUT FILE W/MAX PARAGRAPH LENGTH: } => POPS )) (( INPUT-FILE-WIDTH >>> => POPS )) (( INPUT-FILE-WIDTH >>> ; INPUT-FILE-HEIGHT >>> ; 20 => ADD => RAM-PM INPUT-FILE < POP )) )) OK) (( LOOKSTK )) (LET WORDWRAP-READ-IN-FILE BE (( )) (( (( }* LOOKING AT INPUT FILE (MAYBE AGAIN)..} => POPS )) (( INPUT-FILE-NAME VARSTR> ; }.TXT} => CONCAT ; INPUT-FILE >>> => FILE2PM ; RM )) (( }* DONE} => POP )) )) OK) (( LOOKSTK )) ((DATA ARE-ALL-IN-RIGHTMOST-DATA )) (LET ARE-ALL-IN-RIGHTMOST-COLUMN-UNUSED BE (( & )) (( (( 1 ; # => %GET => %LENGTH => & ; SWITCHV )) (( # => %LENGTH (COUNT (( ## ; N1 ; # => GM => NOZ (MATCHED (( N1 ARE-ALL-IN-RIGHTMOST-DATA < => )) (( EXIT )) MATCHED) )) COUNTUP) )) (( && && )) (( Y => => )) )) OK) (( LOOKSTK )) (LET READ-IN-WITH-FLEXIBLY-ADJUSTED-LINE-WIDTH BE (( )) (( (( SOLIDCURSOR )) (( INPUT-FILE-NAME VARSTR> => CALC-AMOUNT-LINES-IN-TXT-OF-ANY-WIDTH AMOUNT-LINES-ORIGINALLY < POPS )) (( AMOUNT-LINES-ORIGINALLY >>> => POP )) (( }THIS COUNT INCLUDES EXTRA LINESHIFTS AT THE COMPLETION OF THE } => POP )) (( }FILE, WHICH WILL NOT BE INCLUDED IN THE WORDWRAPPED OUTPUT.} => POP )) (( ENTERPLS )) (( AMOUNT-LINES-ORIGINALLY >>> ; 20 => ADD => INPUT-FILE-HEIGHT < MUL INPUT-FILE-WIDTH <>> => ARE-ALL-IN-RIGHTMOST-COLUMN-UNUSED (MATCHED RMS ; RMS ; GOFORWARD4 MATCHED) )) (( INPUT-FILE >>> => RELEASE-MATRIX )) COUNTUP) )) (( }IT SEEMS YOU MAY HAVE TO FIX SOME EXTRAORDINARY LONG PARAGRAPHS} => POP )) (( }IN SOMETHING LIKE SETEDIT, BY MANUALLY INSERTING SOME LINESHIFTS,} => POP )) (( }AND THEN TRY THIS ROUTINE AFTER THAT IS DONE. HOPE YOU GET IT RIGHT.} => POP )) (( KEEP-GOING => SETBASIS ; EXIT )) (( ENTERPLS )) (( GOLABEL4: )) (( }IT SEEMS TO HAVE LINES (IE, PARAGRAPHS WITHOUT LINESHIFTS) } => POP )) (( }WITH AN AMOUNT OF CHARACTERS WITHIN (POSSIBLY WELL WITHIN) } => POPS )) (( INPUT-FILE-WIDTH >>> POP )) (( }READ-IN-FILE-TO-CONVERT-ESSENCE} => ? ; INPUT-FILE >>> => FORVPM )) (( INPUT-FILE >>> => FIX-BLANK-LINES-IN-FILE )) (( INPUT-FILE >>> => FIND-MAX-LINE-NUM => POPS )) (( } <================== LINES PRESENTLY IN RAM.} => POP )) (( FUNCURSOR )) )) OK) (( LOOKSTK )) (LET ASK-FOR-NEW-LINE-LENGTH BE (( )) (( (( }=====> WHAT IS THE NEW MAXIMUM LINE LENGTH? [ENTER FOR 50] } => POPS )) (( READLN => HEAL => >N1 )) (( N1 => ISBASIS = 50 >N1 === )) (( N1 ; 4 ; INPUT-FILE-WIDTH >>> => DEC => SET-RANGE => >N1 )) (( N1 OUTPUT-FILE-WIDTH < POPS )) (( OUTPUT-FILE-WIDTH >>> => POP )) )) OK) (( LOOKSTK )) (LET WORDWRAP-NEW-FILE-NAME BE (( )) (( (( }********************************************************} => POP )) (( }* SPECIFY OUTPUT FILE. NB: ANY SAME-NAMED FILE IS OVERWRITTEN!!!} => POP )) (( }*======> PLEASE GIVE FOLDER/FILENAME (WITHOUT .TXT) FOR NEW FILE.} => POP )) (( }*======> NOTE THAT THIS ROUTINE ONLY INSERTS, NOT REMOVES, LINESHIFTS.} => POP )) (( }*======> IT ONLY INSERTS WHERE REAL BLANKS ARE FOUND (EXCEPT WHEN} => POP )) (( }*======> A STRING OF NONBLANK CHARACTERS ARE WIDER THAN MAX WIDTH).} => POP )) (( }*======> NORMALLY, GIVE NEW NAME NEXT UNLESS YOU ARE SURE.} => POP )) (( }*======> [ENTER TO OVERWRITE INPUT FILE] } => POPS )) (( READLN => RMBL => LENGTH => NOZ NOT (MATCHED RM ; INPUT-FILE-NAME VARSTR> MATCHED) )) (( ONE => OUTPUT-FILE-NAME >VARSTR )) (( ; => TOLEN => ISPRO => => )) )) OK) (( LOOKSTK )) (LET ESTIMATE-OUTPUT-FILE-HEIGHT BE (( )) (( (( INPUT-FILE-WIDTH >>> ; 100 => MUL ; OUTPUT-FILE-WIDTH >>> => DIV => >N1 )) (( INPUT-FILE-HEIGHT >>> ; N1 => MUL ; 4 => MUL ; 100 => DIV OUTPUT-FILE-HEIGHT < POP )) (( }* [WIDTH MAX} => POPS )) (( OUTPUT-FILE-WIDTH >>> ( )) (( }, NEW MAX HEIGHT} => POPS )) (( OUTPUT-FILE-HEIGHT >>> => ( )) (( }]} => POP )) (( }[NORMALLY ALLOCATES MUCH MORE THAN ENOUGH.]} => POP )) (( OUTPUT-FILE-WIDTH >>> ; OUTPUT-FILE-HEIGHT >>> ; 20 => ADD => RAM-PM OUTPUT-FILE <N1 )) (( (( OUTPUT-CHAR-NUM => SETDANCE )) (( OUTPUT-LINE-NUM => SETDANCE )) (( OUTPUT-CHAR-NUM-FOR-MOST-RECENT-SPACE => SETBASIS )) )) OK) (LET OUTPUT-NEW-LINE BE (( )) (( (( OUTPUT-CHAR-NUM => SETDANCE )) (( OUTPUT-LINE-NUM => INCVAR )) (( 32 ; OUTPUT-CHAR-NUM >>> ; OUTPUT-LINE-NUM >>> ; # => PM )) )) OK) (LET MOVE-OVER-AFTER-MOST-RECENT-SPACE BE (( )) (( (( OUTPUT-CHAR-NUM-FOR-MOST-RECENT-SPACE >>> >N7 )) (( OUTPUT-FILE-WIDTH >>> >N8 )) (( OUTPUT-LINE-NUM >>> >N9 )) (( N7 => ISPRO (MATCHED (( 0 ; N7 ; N9 => DEC ; # => PM )) (( N8 ; N7 => SUB (COUNT (( N1 ; N9 => ADD ; N11 => DEC ; # => GM ; OUTPUT-CHAR-NUM >>> ; N11 ; # => PM )) (( 0 ; N1 ; N9 => ADD ; N11 => DEC ; # => PM )) (( OUTPUT-CHAR-NUM => INCVAR )) COUNTUP) )) (( }*} => ( )) MATCHED) )) (( OUTPUT-CHAR-NUM-FOR-MOST-RECENT-SPACE => SETBASIS )) )) OK) (LET GIVE-CHAR-TO-OUTPUT BE (( >N1 )) (( (( OUTPUT-CHAR-NUM >>> ; OUTPUT-FILE-WIDTH >>> => INTGREATER (MATCHED (( OUTPUT-NEW-LINE )) (( MOVE-OVER-AFTER-MOST-RECENT-SPACE )) MATCHED) )) (( N1 ; OUTPUT-CHAR-NUM >>> ; OUTPUT-LINE-NUM >>> ; # => PM )) (( N1 ; 32 => EQN (MATCHED (( OUTPUT-CHAR-NUM >>> OUTPUT-CHAR-NUM-FOR-MOST-RECENT-SPACE < INCVAR )) )) OK) (LET ORDINARY-OUTPUT-LINESHIFT BE (( )) (( (( }.} => ( )) (( OUTPUT-NEW-LINE )) (( OUTPUT-CHAR-NUM-FOR-MOST-RECENT-SPACE => SETBASIS )) (( OUTPUT-FILE-HEIGHT >>> ; 10 => SUB ; OUTPUT-LINE-NUM >>> => INTLTOREQUAL (MATCHED (( CRLN )) (( }* ******* THE PARTICULAR CHARACTER } => POP )) (( }OF THIS INPUT FILE} => POP )) (( }IS SUCH THAT, WITH} => POP )) (( }THIS NEW LINE WIDTH, IT SEEMS} => POP )) (( }THAT MASSES OF LINES} => POP )) (( }(TOO MANY) ARE GENERATED.} => POP )) (( }PLEASE LOOK INTO THIS. TKS.} => POP )) (( KEEP-GOING => SETBASIS )) (( EXIT )) MATCHED) )) )) )) OK) (LET DO-THE-WORD-WRAP BE (( )) (( (( }* WORD-WRAP PROCEEDING!} => POP )) (( SOLIDCURSOR )) (( INPUT-FILE >>> & )) (( OUTPUT-FILE >>> & )) (( INIT-OUTPUT-LINE-NUMS )) (( INPUT-FILE-HEIGHT >>> (COUNT INPUT-FILE-WIDTH >>> (COUNT (( N1 ; N3 ; ## => GM => >N5 )) (( N5 => NOZ (MATCHED N5 ; CTRL-I >>> => EQN (MATCHED (( 32 => GIVE-CHAR-TO-OUTPUT )) (( 32 => GIVE-CHAR-TO-OUTPUT )) )(OTHER (( N5 => GIVE-CHAR-TO-OUTPUT )) MATCHED) )(OTHER (( N1 ; 1 => INTGREATER (MATCHED (( ORDINARY-OUTPUT-LINESHIFT )) MATCHED) )) (( RMS ; RMS ; GOFORWARD4 )) MATCHED) )) COUNTUP) (( GOLABEL4: )) COUNTUP) )) (( OUTPUT-NEW-LINE )) (( && && )) (( CRLN )) (( }* DONE THE WORD-WRAP ON SPACES. PLS CHECK RESULT. ***********} => POP )) (( }* ANY TABULATOR CHARACTER WAS CONVERTED TO TWO BLANKS.} => POP )) (( }* HAVE INSERTED SPACE CHARACTER INTO ANY EMPTY LINES ALSO.} => POP )) (( FUNCURSOR )) )) OK) (LET SAVE-THE-FILE BE (( )) (( (( }* WILL SAVE FILE..} => POPS )) (( OUTPUT-FILE-NAME VARSTR> ; }.TXT} => CONCAT ; OUTPUT-FILE >>> => PM2FILE ; RM )) (( }DONE} => POP )) )) OK) (( LOOKSTK )) (LET SAY-THANKS BE (( )) (( (( }*} => POP )) (( }*} => POP )) (( }* PROGRAM DONE.} => POPS ; ENTERPLS )) (( }*} => POP )) (( }*} => POP )) (( }*} => POP )) (( }********************ALWAYS PLEASED TO SERVE YOU!} => POP )) )) OK) (( LOOKSTK )) (LET WORDWRAP-CONVERSION BE (( )) (( (( KEEP-GOING => SETDANCE )) (( WORDWRAP-ASK-FOR-FILE-TO-CONVERT => NOT = EXIT === )) (( READ-IN-WITH-FLEXIBLY-ADJUSTED-LINE-WIDTH )) (( KEEP-GOING => VISBASIS = EXIT === )) (( ASK-FOR-NEW-LINE-LENGTH )) (( ESTIMATE-OUTPUT-FILE-HEIGHT )) (( ALLOCATE-OUTPUT-FILE-SPACE )) (( WORDWRAP-NEW-FILE-NAME => NOT = EXIT === )) (( DO-THE-WORD-WRAP )) (( KEEP-GOING => VISBASIS = EXIT === )) (( SAVE-THE-FILE )) )) OK) (( LOOKSTK )) (LET WORDWRAP BE (( )) (( (( WORDWRAP-CONVERSION )) (( SAY-THANKS )) (( RAM-REFRESH )) )) OK) (LET NAME-GREATER BE (( & ; ; ; ; )) (( (( ; => SWITCH => DEC => SWITCH )) (( ; (COUNT (( (( ONE ; N1 => ADD )) => ONE ; YANTRA ; # => GM => ; SWITCH ; MANTRA ; # => GM => TWO ; ; => INTGREATER (MATCHED (( 5 => SEVERALRM )) (( && ; RMS ; RMS ; N => => )) (( EXIT )) MATCHED) ; ; )) (( ; ; => BRIDGE => INTGREATER (MATCHED (( 4 => SEVERALRM )) (( && ; RMS ; RMS ; Y => => )) (( EXIT )) MATCHED) ; )) (( ; => ISBASIS (MATCHED (( RMS ; RMS )) (( GOFORWARD4 )) MATCHED) )) COUNTUP) )) (( GOLABEL4: )) (( 3 => SEVERALRM )) (( && )) (( N => => )) )) OK) (LET NAME-GTOREQUAL BE (( & ; ; ; ; )) (( (( ; => SWITCH => DEC => SWITCH )) (( ; (COUNT (( (( ONE ; N1 => ADD )) => ONE ; YANTRA ; # => GM => ; SWITCH ; MANTRA ; # => GM => TWO ; ; => INTGREATER (MATCHED (( 5 => SEVERALRM )) (( && ; RMS ; RMS ; N => => )) (( EXIT )) MATCHED) ; ; )) (( ; ; => BRIDGE => INTGREATER (MATCHED (( 4 => SEVERALRM )) (( && ; RMS ; RMS ; Y => => )) (( EXIT )) MATCHED) ; )) (( ; => ISBASIS (MATCHED (( RMS ; RMS )) (( GOFORWARD4 )) MATCHED) )) COUNTUP) )) (( GOLABEL4: )) (( 3 => SEVERALRM )) (( && )) (( Y => => )) )) OK) (LET NAME-EQUAL BE (( & ; ; ; ; )) (( (( ; => SWITCH => DEC => SWITCH )) (( ; (COUNT (( (( ONE ; N1 => ADD )) => ONE ; MANTRA ; # => GM => ONE ; ; ANGEL ; MANTRA ; # => GM => NOT_INTEQUAL (MATCHED (( 4 => SEVERALRM )) (( && ; RMS ; RMS ; N => => )) (( EXIT )) MATCHED) ; )) (( ; => ISBASIS (MATCHED (( RMS ; RMS )) (( GOFORWARD4 )) MATCHED) )) COUNTUP) )) (( GOLABEL4: )) (( 3 => SEVERALRM )) (( && )) (( Y => => )) )) OK) (LET MINIMUM-ZERO BE (( ; )) (( (( ONE ; ISSIGNED => (MATCHED RM ; 0 MATCHED) )) )) OK) (LET FLAGFLIP BE (( ; )) (( (( ; => ONEV => VISBASIS (MATCHED ; => SETDANCE )(OTHER ; => SETBASIS MATCHED) )) )) OK) (LET TEXT-CLR-KEY BE (( )) (( (( KEYNUM => ISBASIS (MATCHED (( KEYNUM => RM )) MATCHED) )) (( CLEAR_KEYBUF )) )) OK) (LET MAKE-SAFE-8-SIZE-FILENAME (( ; )) (( (( ; => UPCM => TOSTANDARDSPACE => RMBL => FILTERSPECCHARS => REMOVEDOT ; 8 => SETMAXLEN => LENGTH => ISBASIS (MATCHED (( RM )) (( }DOC-NAME} )) MATCHED) )) (( ; => => )) )) OK) (LET INCREASE-VAR-IF-THIS-IS-HIGHER BE (( ; ; )) (( (( ; ; => SWITCHV => TWOV )) (( ; ; => IS ; IS => INTGREATER (MATCHED (( ; ; => IS < SETBASIS )) ((DATA B9-F9-MODE B9-F9-MODE => SETBASIS )) ((DATA B9-F10-MODE B9-F10-MODE => SETBASIS )) ((DATA B9-F11-MODE B9-F11-MODE => SETBASIS )) ((DATA B9-F12-MODE B9-F12-MODE => SETBASIS )) ((DATA B9-SHOULD-LOAD-FONT-ON-STARTUP B9-SHOULD-LOAD-FONT-ON-STARTUP => SETDANCE )) ((DATA B9-HAS-LOADED-FONT B9-HAS-LOADED-FONT => SETBASIS )) (( VARSTRING B9-FONT }B9FONT.TXT} ; B9-FONT => >VARSTR )) ((DATA B9-POP-CHN-HOUSE B9-POP-CHN-HOUSE => SETBASIS )) ((DATA FILE-SHOULD-BE-STORED )) ((DATA FONT-EDIT-ASCII-NUMBER )) ((DATA THEFONT THEFONT => SETBASIS )) ((DATA BACKUPFONT BACKUPFONT => SETBASIS )) ((DATA B9-FONT-Y B9-FONT-Y => SETDANCE )) ((DATA B9-FONT-X B9-FONT-X => SETDANCE )) ((DATA B9-FONT-WIDTH 12 B9-FONT-WIDTH < SETDANCE )) ((DATA B9-POP-BG B9-POP-BG => SETBASIS )) (LET B9-EXTRA-INIT-VARS BE (( )) (( (( THEFONT => VISBASIS (MATCHED (( 2512 ; 111 => RAM-PM THEFONT <>> => CLEAR-MATRIX )) MATCHED) )) (( BACKUPFONT => VISBASIS (MATCHED (( 2512 ; 111 => RAM-PM BACKUPFONT <>> => CLEAR-MATRIX )) MATCHED) )) (( FILE-SHOULD-BE-STORED => SETBASIS )) (( B9-SHOULD-LOAD-FONT-ON-STARTUP => VISDANCE (MATCHED (( B9-FONT => VARSTR> ; THEFONT >>> => FILENUM2PM => ISDANCE (MATCHED (( B9-HAS-LOADED-FONT => SETDANCE )) )(OTHER (( THEFONT >>> => CLEAR-MATRIX )) MATCHED) )) (( }FONTB9.TXT} ; BACKUPFONT >>> => FILENUM2PM ; RM )) MATCHED) )) )) OK) (LET B9-FONT-START BE (( ; ; )) (( (( ; 5 => SUB B9-FONT-Y < SUB B9-FONT-X <>> ; V2 50 MOD => ADD ; B9-FONT-Y >>> ; V2 50 DIV => ADD ; B9-FONT-CURRENT-COLOR >>> => PUTPIXEL )) )) OK) (( }B9-POP-CHN-ESSENCE} => ? B9-POP-CHN-HOUSE <N1 )) (( (( N1 ; 5 => EQN (MATCHED (( B9-FONT-X >>> 14 ADD ; B9-FONT-Y >>> 6 ADD ; BRIDGE B9-FONT-WIDTH >>> => ADD 21 ADD ; BRIDGE B9-FONT-HEIGHT >>> => ADD INC8 ; B9-POP-BG >>> => RECTFILL )) )(OTHER (( VLOTS )) (( 1 => TOV2 )) (( N1 => TOV3 )) (( N1 => TOV4 )) (( VFREE )) (( B9-POP-CHN-HOUSE >>> ; THEFONT >>> => FORVPM2 )) MATCHED) )) (( B9-FONT-WIDTH >>> ; B9-FONT-X => ADDVAR )) )) OK) (LET B9-POP BE (( >N5 >N4 LENGTH >N8 )) (( (( N4 ; N5 => B9-FONT-START )) (( N8 (COUNT (( ; N1 => CHN => B9-POP-CHN )) COUNTUP) )) (( RM )) )) OK) (LET GIRL-BEAUTY-POP BE (( ; )) (( (( ^35 FR GETV ; 12 => MUL => >N9 )) (( ^28 FR GETV ; 25 => MUL => >N11 )) (( ; => LENGTH => MAKEBL ; N9 ; N11 => B9-POP ; )) (( ; N9 ; N11 => B9-POP )) )) OK) (LET SEVERAL-B9-POP (( >N7 >N6 >N5 ; )) (( (( N5 (COUNT (( ; => ONE ; )) (( ; (( N8 ; (( N1 => DEC ; B9-FONT-WIDTH >>> => MUL )) => ADD )) ; N9 => B9-POP )) COUNTUP) ; RM )) )) OK) ((DATA B9-PRPOP-CHN-HOUSE B9-PRPOP-CHN-HOUSE => SETBASIS )) ((DATA B9-PRFONT-Y B9-PRFONT-Y => SETDANCE )) ((DATA B9-PRFONT-X B9-PRFONT-X => SETDANCE )) (LET B9-PRFONT-START BE (( ; ; )) (( (( ; 5 => SUB B9-PRFONT-Y < SUB B9-PRFONT-X <>> ; V2 50 MOD => ADD ; B9-PRFONT-Y >>> ; V2 50 DIV => ADD ; B9-FONT-CURRENT-COLOR >>> => PUTPIXEL )) )) OK) (( }B9-PRPOP-CHN-ESSENCE} => ? B9-PRPOP-CHN-HOUSE <N1 )) (( (( N1 ; 5 => EQN (MATCHED (( B9-PRFONT-X >>> 14 ADD ; B9-PRFONT-Y >>> 6 ADD ; BRIDGE B9-FONT-WIDTH >>> => ADD 21 ADD ; BRIDGE B9-FONT-HEIGHT >>> => ADD INC8 ; B9-POP-BG >>> => RECTFILL )) )(OTHER (( VLOTS )) (( 1 => TOV2 )) (( N1 => TOV3 )) (( N1 => TOV4 )) (( VFREE )) (( B9-PRPOP-CHN-HOUSE >>> ; THEFONT >>> => FORVPM2 )) MATCHED) )) (( B9-FONT-WIDTH >>> ; B9-PRFONT-X => ADDVAR )) )) OK) (LET B9-PRPOP BE (( >N5 >N4 LENGTH >N8 )) (( (( N4 ; N5 => B9-PRFONT-START )) (( N8 (COUNT (( ; N1 => CHN => B9-PRPOP-CHN )) COUNTUP) )) (( RM )) )) OK) (LET SEVERAL-B9-PRPOP (( >N7 >N6 >N5 ; )) (( (( N5 (COUNT (( ; => ONE ; )) (( ; (( N8 ; (( N1 => DEC ; B9-FONT-WIDTH >>> => MUL )) => ADD )) ; N9 => B9-PRPOP )) COUNTUP) ; RM )) )) OK) (LET BACKUPFONTWRITE BE (( ; ; ; )) (( (( BACKUPFONT => VISBASIS => NOT (MATCHED (( THEFONT >>> => & )) (( BACKUPFONT >>> THEFONT < B9-POP )) (( # THEFONT < B9-POP )) MATCHED) )) )) OK) (( LOOKSTK )) (LET REMAKE-FONT-EDIT-FIELD-LINES BE (( )) (( (( FT )) (( 300 ; 100 ; 300 ; 500 ; 1 ; 2 => DOTTED_RECT )) (( 100 ; 300 ; 500 ; 300 ; 1 ; 2 => DOTTED_RECT )) (( FEET )) )) OK) (LET CLEAR-FONT-EDIT-FIELD BE (( )) (( (( THEFONT >>> => & )) (( FONT-EDIT-ASCII-NUMBER >>> -27 => ADD ; # => %GET => %EMPTY )) (( 600 ; 200 ; 650 ; 250 ; 185 => FT RECTFILL FEET )) (( 700 ; 200 ; 750 ; 250 ; 187 => FT RECTFILL FEET )) (( 100 ; 100 ; 500 ; 500 ; 185 => FT RECTFILL FEET )) (( REMAKE-FONT-EDIT-FIELD-LINES )) (( && )) )) OK) (LET REDISPLAY-FONT-EDIT-FIELD-ETC BE (( )) (( (( THEFONT >>> => & )) (( 600 ; 200 ; 650 ; 250 ; 185 => FT RECTFILL FEET )) (( 700 ; 200 ; 750 ; 250 ; 187 => FT RECTFILL FEET )) (( 100 ; 100 ; 500 ; 500 ; 185 => FT RECTFILL FEET )) (( REMAKE-FONT-EDIT-FIELD-LINES )) (( FT )) (( }current ascii-number: } ; 100 ; 670 => BACKUPFONTWRITE )) (( } } ; 350 ; 670 => LUCIDWRITE )) (( FONT-EDIT-ASCII-NUMBER >>> ; 350 ; 670 => BACKUPFONTWRITE )) (( } ( e.g. } ; FONT-EDIT-ASCII-NUMBER >>> => ASCII => CONCAT ; } )} => CONCAT ; 400 ; 670 => BACKUPFONTWRITE )) (( }space to clr one; r-click / l-click (up) the ascii outside of field} ; 100 ; 700 => BACKUPFONTWRITE )) (( }Will ALWAYS save when [ESC] is pressed. Backup your B9FONT first!!!!} 100 ; 730 => BACKUPFONTWRITE )) (( FEET )) (( FONT-EDIT-ASCII-NUMBER >>> -27 ADD ; # => %GET => & )) (( 2500 (COUNT (( N1 ; # => %GET => ISDANCE (MATCHED (( N1 50 MOD => >N5 )) (( N1 50 DIV => >N6 )) (( FT )) (( N5 600 ADD ; N6 200 ADD ; 1 => PUTPIXEL )) (( N5 700 ADD ; N6 200 ADD ; 1 => PUTPIXEL )) (( N5 MUL8 100 ADD ; N6 MUL8 100 ADD ; BRIDGE 7 ADD ; BRIDGE 7 ADD ; 1 => RECTFILL )) (( FEET )) MATCHED) )) COUNTUP) )) (( && )) (( && )) )) OK) (LET FONT-EDIT-SAVE BE (( )) (( (( THEFONT >>> => & )) (( B9-FONT => VARSTR> ; # => PM2FILENUM ; RM )) (( && )) )) OK) (LET B9-FONT-EDIT BE (( )) (( (( THEFONT >>> => & )) (( 97 FONT-EDIT-ASCII-NUMBER < DEC DEC UP-TO-EVEN8 >N2 DEC DEC UP-TO-EVEN8 >N1 )) (( MMOTION => Y-TO-1 => >N8 )) (( MOUSECLICK => Y-TO-1 => >N9 )) (( MOUSECLICKR => Y-TO-1 => >N10 )) (( N1 ; 106 ; 494 => WITH ; N2 ; 106 ; 494 => WITH => AND (MATCHED (( N1 ; 100 => SUB => DIV8 => >N3 )) (( N2 ; 100 => SUB => DIV8 => >N4 )) (( N9 => ISDANCE (MATCHED (( N3 600 ADD ; N4 200 ADD ; 1 => FT PUTPIXEL FEET )) (( N3 700 ADD ; N4 200 ADD ; 1 => FT PUTPIXEL FEET )) (( REMAKE-FONT-EDIT-FIELD-LINES )) (( N3 ; N4 50 MUL => ADD => >N10 )) (( 1 ; N10 ; FONT-EDIT-ASCII-NUMBER >>> -27 ADD ; # => PM )) (( N10 50 MOD MUL8 100 ADD ; N10 50 DIV MUL8 100 ADD ; BRIDGE 7 ADD ; BRIDGE 7 ADD ; 1 => FT RECTFILL FEET )) )(OTHER (( N10 => ISDANCE = (( N3 600 ADD ; N4 200 ADD ; 185 => FT PUTPIXEL FEET )) (( N3 700 ADD ; N4 200 ADD ; 187 => FT PUTPIXEL FEET )) (( REMAKE-FONT-EDIT-FIELD-LINES )) (( N3 ; N4 50 MUL => ADD => >N10 )) (( 0 ; N10 ; FONT-EDIT-ASCII-NUMBER >>> -27 ADD ; # => PM )) (( N10 50 MOD MUL8 100 ADD ; N10 50 DIV MUL8 100 ADD ; BRIDGE 7 ADD ; BRIDGE 7 ADD ; 185 => FT RECTFILL FEET )) === )) MATCHED) )) )(OTHER (( N9 => ISDANCE (MATCHED (( FONT-EDIT-ASCII-NUMBER => >>> => INC ; 32 ; 126 => SET-RANGE FONT-EDIT-ASCII-NUMBER < GOODPAUSE )) )(OTHER (( N10 => ISDANCE (MATCHED (( FONT-EDIT-ASCII-NUMBER => >>> => DEC ; 32 ; 126 => SET-RANGE FONT-EDIT-ASCII-NUMBER < GOODPAUSE )) MATCHED) )) MATCHED) )) MATCHED) )) (( KEYTOUCH = (( KEYNUM => >N11 )) (( 32 ; N11 => EQN = CLEAR-FONT-EDIT-FIELD == 27 ; N11 => EQN = GOFORWARD4 === === )) === )) (( GOUP1 )) (( GOLABEL4: )) (( CLEAR_KEYBUF )) (( FONT-EDIT-SAVE )) (( && )) )) OK) (( LOOKSTK )) (LET MOREFONT BE (( )) (( (( B9-EXTRA-INIT-VARS )) (( START-GRAPHICS )) (( GJ-COLORS )) (( }Welcome to MOREFONT!} ; 200 ; 280 => B9-POP )) (( 1 => SECS )) (( CLS )) (( B9-FONT-EDIT )) (( GOLABEL4: )) (( DONE-GRAPHICS )) (( RAM-REFRESH )) )) OK) (( VARSTRING IS-ANYTHING-ON-MAIN-STACK-DATA )) (LET IS-ANYTHING-ON-MAIN-STACK BE (( )) (( (( 0 => & )) (( ; ONE => IS-ANYTHING-ON-MAIN-STACK-DATA => >VARSTR )) (( # => ISBASIS (MATCHED (( && )) (( Y => => )) )(OTHER (( && ; && )) (( N => => )) MATCHED) )) )) OK) ((DATA FILTER-NON7ASCII-CHARS-HOUSE )) (LET FILTER-NON7ASCII-CHARS-ESSENCE BE (( )) (( (( 32 ; V11 => INTGREATER (MATCHED (( 42 => TOV11 )) )(OTHER (( V11 ; 126 => INTGREATER (MATCHED (( 42 => TOV11 )) MATCHED) )) MATCHED) )) )) OK) (( }FILTER-NON7ASCII-CHARS-ESSENCE} => ? FILTER-NON7ASCII-CHARS-HOUSE <N1 )) (( (( VLOTS )) (( 1 => TOV2 )) (( 1 => TOV3 )) (( N1 => TOV4 )) (( VFREE )) (( FILTER-NON7ASCII-CHARS-HOUSE >>> ; # => FORVPM2 )) (( && )) )) OK) (LET MANUAL-CLEAR-KEYBUF BE (( )) (( (( GOLABEL4: )) (( KEYTOUCH (MATCHED (( KEYNUM => ISBASIS (MATCHED (( KEYNUM ; RM )) MATCHED) )) (( GOUP4 )) MATCHED) )) )) OK) (LET ENSURE-BYTE-RANGE-ESSENCE BE (( )) (( (( V11 => ISPRO (MATCHED (( V11 ; 255 => INTGREATER (MATCHED (( 255 => TOV11 )) MATCHED) )(OTHER (( 0 => TOV11 )) MATCHED) )) OK) ((DATA ENSURE-BYTE-RANGE-HOUSE }ENSURE-BYTE-RANGE-ESSENCE} => ? ENSURE-BYTE-RANGE-HOUSE <>> ; # => FORVPM )) (( && )) )) OK) (LET BMPTXT>GJP BE (( ; )) (( (( ; => TOSTANDARDSPACE RMBL => UPCM => LENGTH => ISBASIS = RM EXIT === )) (( ; => ONE ; }.TXT} => CONCAT => ALREADYFILE => NOT => = RM ; EXIT === )) (( ; ONE => GET-SMART-PAINTING => & )) (( # => ISBASIS = && ; EXIT === )) (( # => ENSURE-BYTE-RANGE )) (( ; }.GJP} => CONCAT ; # => PM2GJPFILE ; RM )) (( # => RELEASE-MATRIX )) (( && )) )) OK) (( VARSTRING B9-READLN-LINE )) (LET B9-NEW-INIT-VARS BE (( )) (( (( 85 => MAKEBL ; B9-READLN-LINE => >VARSTR )) )) OK) (LET GJ-ON BE (( )) (( (( START-GRAPHICS )) (( B9-EXTRA-INIT-VARS )) (( B9-NEW-INIT-VARS )) (( 100 => GOODPAUSE )) (( GJ-COLORS )) (( 50 => GOODPAUSE )) (( CLS ; FT )) )) OK) (LET GJ-DONE BE (( )) (( (( DONE-GRAPHICS )) (( LIGHTER )) (( 180 => GOODPAUSE )) (( RAM-REFRESH )) )) OK) (LET BE (( )) (( (( 33 => GOODPAUSE )) (( GOLABEL1: 50 => GOODPAUSE )) (( UNTIL-TOUCHING = GOUP1 === )) (( GJ-DONE )) )) OK) (LET PING BE (( )) (( (( GJ-ON )) (( GOLABEL4: )) (( } INTUITION HAPPINESS NUDISM WHOLENESS } => GIRL-BEAUTY-POP )) (( } ECSTATIC GOODNESS HEALTH LONGLEGGED } => GIRL-BEAUTY-POP )) (( } TANTRIC INTELLIGENCE ECSTASY NIRVANA } => GIRL-BEAUTY-POP )) (( } COMPASSION EMPATHY LOVING THINSPO HEALTH } => GIRL-BEAUTY-POP )) (( 25 => GOODPAUSE )) (( KEYTOUCH NOT = GOUP4 === )) (( GJ-DONE )) )) OK) (LET TEXT-MARKER-B9 BE (( )) (( (( B9-FONT-X >>> 14 ADD ; B9-FONT-Y >>> 6 ADD ; BRIDGE B9-FONT-WIDTH >>> => ADD ; BRIDGE B9-FONT-HEIGHT >>> => ADD ; B9-FONT-CURRENT-COLOR >>> => RECTFILL )) )) OK) (LET UN-TEXT-MARKER-B9 BE (( )) (( (( B9-FONT-X >>> 14 ADD ; B9-FONT-Y >>> 6 ADD ; BRIDGE B9-FONT-WIDTH >>> => ADD ; BRIDGE B9-FONT-HEIGHT >>> => ADD ; B9-POP-BG >>> => RECTFILL )) )) OK) (LET B9-READLN BE (( >N3 >N2 >N1 )) (( (( FT )) (( 85 => MAKEBL ; B9-READLN-LINE => >VARSTR )) (( N2 ; N3 => B9-FONT-START )) (( 0 => >N4 )) (( GOLABEL1: )) (( TEXT-MARKER-B9 )) (( KEYNUM => >N8 )) (( UN-TEXT-MARKER-B9 )) (( N8 ; KEY-ENTER >>> => EQN = GOFORWARD4 === )) (( N8 ; 32 ; 126 => WITH (MATCHED (( N1 ; N4 => INTGREATER (MATCHED (( INCN4 )) )(OTHER (( B9-FONT-WIDTH >>> => SG ; B9-FONT-X => ADDVAR )) (( 32 => B9-POP-CHN )) (( B9-FONT-WIDTH >>> => SG ; B9-FONT-X => ADDVAR )) MATCHED) (( N8 => B9-POP-CHN )) (( N8 ; N4 ; B9-READLN-LINE => VARSTR-TOCHN )) )(OTHER (( (( N8 ; 8 => EQN )) (( N4 => NOZ )) => AND (MATCHED (( B9-FONT-WIDTH >>> => SG ; B9-FONT-X => ADDVAR )) (( 32 => B9-POP-CHN )) (( B9-FONT-WIDTH >>> => SG ; B9-FONT-X => ADDVAR )) (( TEXT-MARKER-B9 )) (( DECN4 )) MATCHED) )) MATCHED) )) (( GOUP1 )) (( GOLABEL4: )) (( N4 ; B9-READLN-LINE => VARSTR-SETLEN )) (( B9-READLN-LINE => VARSTR> => => )) )) OK) (LET B9-YNIN BE (( >N5 >N4 )) (( (( } [ENTER for YES] } => N4 N5 B9-POP )) (( 20 N4 300 ADD N5 B9-READLN => YESORENTER => => )) )) OK) (LET B9-ENTERPLS BE (( >N5 >N4 )) (( (( } /ENTER, PLS/ } => N4 N5 B9-POP )) (( 1 N4 250 ADD N5 B9-READLN => RM )) )) OK) (LET MAXIMUM-OF-THREE BE (( >N3 >N2 >N1 )) (( (( N1 ; N2 => INTGREATER (MATCHED (( N3 ; N1 => INTGREATER (MATCHED N3 => => )(OTHER N1 => => MATCHED) )) )(OTHER (( N3 ; N2 => INTGREATER (MATCHED N3 => => )(OTHER N2 => => MATCHED) )) MATCHED) )) )) OK) (LET %ADDPUT BE (( & ; ; )) (( (( ; ; => ONE ; # => %GET ; ANGEL => ADD ; SWITCH ; # => %PUT )) (( && )) )) OK) (LET STR>ARRAY BE (( ; )) (( (( ; => LENGTH => %MAKE => & )) (( LENGTH (COUNT (( ; N1 => CHN ; N1 ; # => %PUT )) COUNTUP) )) (( RM )) (( # => => )) (( && )) )) OK) (LET ARRAY>STR BE (( & )) (( (( # => %LENGTH => MAKEBL ; )) (( LENGTH (COUNT (( N1 ; # => %GET ; )) (( ; ; N1 => TOCHN )) COUNTUP) )) (( ; => => )) (( && )) )) OK) (LET STR>EXISTING-ARRAY BE (( & ; )) (( (( ; => LENGTH ; # => >MEM )) (( # => %LENGTH (COUNT (( ; N1 => CHN ; N1 ; # => %PUT )) COUNTUP) )) (( RM )) (( && )) )) OK) (LET SET-MAX BE (( >N2 >N1 )) (( (( N1 ; N2 => INTGREATER (MATCHED (( N2 => => )) )(OTHER (( N1 => => )) MATCHED) )) )) OK) (LET DECSUMMAX BE (( >N3 >N2 >N1 )) (( (( N1 ; N2 => ADD => DEC => >N4 )) (( N4 ; N3 => INTGREATER (MATCHED (( N3 ; N1 => SUB => INC => >N2 )) (( N2 => ISPRO => NOT = 0 >N2 === )) MATCHED) )) (( N2 => => )) )) OK) (LET SEGMENT-FIND-THIS-WORD-START (( & >N8 )) (( (( # => ACTIVE-LENGTH => >N4 )) (( N8 ; N4 => INTGREATER = 1 => => ; && ; EXIT === )) (( N8 => ISBASIS = 1 => => ; && ; EXIT === )) (( N8 ; # => %GET ; 32 => EQN = 1 => => ; && ; EXIT === )) (( N8 => ISDANCE = 1 => => ; && ; EXIT === )) (( N8 (COUNT (( N2 ; N1 => SUB => INC ; # => %GET => >N7 )) (( N7 => ISPRO (MATCHED (( 33 ; N7 => INTGREATER = N2 ; N1 => SUB => INC INC => => ; RMS RMS ; && ; EXIT === )) MATCHED) )) COUNTUP) (( 1 => => )) (( && )) )) OK) (LET SEGMENT-NOZ-START BE (( & >N4 )) ( (( (( N4 => ISBASIS = && EXIT === )) (( # => %LENGTH => DEC => >N6 )) (( N6 => ISPRO => NOT = && EXIT === )) (( N4 ; N6 => SET-MAX => >N4 )) (( N4 (COUNT (( N1 ; # => %GET => ISBASIS (MATCHED (( 32 ; N1 ; # => %PUT )) MATCHED) )) COUNTUP) )) (( && )) )) OK) (LET TRANSFER-SEGMENT BE (( & & SWITCHV >N1 )) (( (( N1 => ISBASIS = && && EXIT === )) (( # => %LENGTH => >N5 )) (( ## => %LENGTH => DEC => >N6 )) (( N6 => ISPRO => NOT = && && EXIT === )) (( N1 ; N5 ; N6 => DECSUMMAX => >N5 )) (( N5 => ISBASIS = && && EXIT === )) (( (( N1 => DEC )) ; # => SEGMENT-NOZ-START )) (( # => INC4 => >N9 )) (( ## ; (( N1 => MUL4 )) => ADD => >N10 )) (( N5 => >N11 )) (( N9 ; N10 ; N11 => COPYNUMS )) (( && && )) )) OK) (LET INSERT-SEGMENT BE (( & & SWITCHV >N1 )) (( (( N1 => ISBASIS = && && EXIT === )) (( # => %LENGTH => >N5 )) (( ## => %LENGTH => DEC => >N6 )) (( N6 => ISPRO => NOT = && && EXIT === )) (( N1 ; N5 ; N6 => DECSUMMAX => >N5 )) (( N5 => ISBASIS = && && EXIT === )) (( N6 ; N1 => INTGREATER (MATCHED (( ## ; (( N1 => MUL4 )) => ADD => >N9 )) (( ## ; (( N1 ; N5 => ADD => MUL4 )) => ADD => >N10 )) (( N6 ; (( N1 ; N5 => ADD )) => SUB => ADD => >N11 )) (( N11 => ISPRO = N9 ; N10 ; N11 => COPYNUMSHIGH === )) MATCHED) )) (( N1 ; ## ; # => TRANSFER-SEGMENT )) (( && && )) )) OK) (LET NOZ-ONLY-BEFORE-N BE (( & DEC >N5 )) (( (( # => %LENGTH ; N5 => SUB (COUNT (( 0 ; (( N1 ; N7 => ADD )) ; # => %PUT )) COUNTUP) )) (( && )) )) OK) (LET NOZ-ONLY-BEFORE-ACTIVELENGTH BE (( & )) (( (( # => %LENGTH (COUNT (( N1 ; # => %GET => ISBASIS (MATCHED (( N1 ; # => NOZ-ONLY-BEFORE-N )) (( RMS ; RMS ; && ; EXIT )) MATCHED) )) COUNTUP) )) (( && )) )) OK) (LET RM-SEGMENT BE (( & >N2 >N1 )) (( (( # => %LENGTH => >N7 )) (( (( N1 => ISBASIS )) ; (( N2 => ISBASIS )) ; (( N7 => ISBASIS )) => TRIPLEORR = && EXIT === )) (( N2 => ISBASIS = && EXIT === )) (( N1 ; N2 => ADD => >N3 )) (( # ; (( N3 => MUL4 )) => ADD => >N9 )) (( # ; (( N1 => MUL4 )) => ADD => >N10 )) (( N7 ; N3 => SUB => INC => >N11 )) (( N11 => ISPRO = N9 ; N10 ; N11 => COPYNUMS === )) (( # => NOZ-ONLY-BEFORE-ACTIVELENGTH )) (( && )) )) OK) (LET REPLACE-SEGMENT BE (( & & SWITCHV >N2 >N1 )) (( (( N1 => ISBASIS = && && EXIT === )) (( # => %LENGTH => >N5 )) (( ## => %LENGTH => DEC => >N6 )) (( N1 ; N6 => INTGREATER = && && EXIT === )) (( N2 => ISPRO (MATCHED (( N1 ; N2 ; ## => RM-SEGMENT )) MATCHED) )) (( N5 => ISPRO (MATCHED (( N1 ; ## ; # => INSERT-SEGMENT )) MATCHED) )) (( && && )) )) OK) (( LOOKSTK )) ((DATA BROWSER-MATRIX 6 ; 8 => RAM-PM BROWSER-MATRIX < SETBASIS )) (LET RO-OFF BE RO-MODE => SETBASIS OK) ((DATA B9-PAGE-LENGTH )) ((DATA B9-PAGE-WIDTH )) ((DATA B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN )) ((DATA B9-CLIPBOARD )) (( VARSTRING B9-CLIPBOARD-FIRST-LINE )) ((DATA B9-CLIPBOARD-AMOUNT-LINES )) (( VARSTRING B9-DOC-NAME )) ((DATA B9-FILE-SHOULD-BE-STORED )) ((DATA B9-EDIT-X )) ((DATA B9-EDIT-Y )) ((DATA B9-LINE-NUM )) ((DATA B9-TOP-LINE-NUM 37000 B9-TOP-LINE-NUM < VISBASIS (MATCHED (( }B9} ; 980 ; 18 => B9-POP )) (( } } ; 800 ; 695 => B9-POP )) (( }$} ; B9-LINE-NUM >>> => CONCAT ; }*} => CONCAT ; B9-LINE-POS >>> => CONCAT ; } } => CONCAT ; 800 ; 695 => B9-POP )) MATCHED) )) )) OK) (LET B9-UNDERLINECURRENT-POS BE (( )) (( (( B9-MARKING-ON => VISDANCE (MATCHED (( B9-EDIT-X >>> 12 MUL ; B9-EDIT-Y >>> 25 MUL 35 ADD ; BRIDGE ; 10 => ADD ; BRIDGE ; 10 => ADD ; 0 => RECTFILL )) (( B9-EDIT-X >>> 12 MUL ; B9-EDIT-Y >>> 25 MUL 35 ADD ; BRIDGE ; 10 => ADD ; BRIDGE ; 10 => ADD ; 1 => RECT )) )(OTHER (( B9-EDIT-X >>> 12 MUL ; B9-EDIT-Y >>> 25 MUL 35 ADD ; BRIDGE ; 10 => ADD ; BRIDGE ; 10 => ADD ; 1 => RECTFILL )) MATCHED) )) OK) (LET B9-UN-UNDERLINECURRENT-POS BE (( )) (( (( B9-EDIT-X >>> 12 MUL ; B9-EDIT-Y >>> 25 MUL 35 ADD ; BRIDGE ; 10 => ADD ; BRIDGE ; 10 => ADD ; 0 => RECTFILL )) )) OK) (LET B9-SHOW-NORMAL-GOODS-AND-GET-PAYMENTS-INSTANTLY BE (( )) (( (( B9-F9-MODE => VISBASIS (MATCHED (( }F1 GET F2 STORE F3 REPL F4 SCAN F5 PUT F6 INFO CTR-P PRT F8 JUMP} => 22 705 B9-POP )) (( B9-UPDATE-LINE-POS )) MATCHED) )) OK) (LET B9-NEW-LINES BE (( >N7 >N6 )) (( (( N6 ; B9-MAX-LINE-USED >>> => INTGREATER = EXIT === )) (( B9-WORK-SPACE >>> => & )) (( N7 ; B9-MAX-LINE-USED >>> => ADD => >N9 )) (( (( B9-MAX-LINE-USED >>> ; N6 => DEC => SUB )) => NOZ (MATCHED (( (( N6 => INC => MUL4 ; # => ADD )) ; (( (( N6 => INC ; N7 => ADD )) => MUL4 ; # => ADD )) ; (( B9-MAX-LINE-USED >>> ; N6 => DEC => SUB )) => COPYNUMSHIGH )) MATCHED) )) (( N7 (COUNT (( B9-PAGE-WIDTH >>> => INC => %MAKE => & )) (( 32 ; 1 ; # => %PUT )) (( GETV ; (( N1 ; N8 => ADD )) ; # => %PUT )) COUNTUP) )) (( N7 ; B9-MAX-LINE-USED => ADDVAR )) (( && )) )) OK) (LET B9-REFRESH BE (( )) (( (( 1 ; B9-REFRESH-DANCERS-WITHIN >>> => %GET => H )) (( 2 ; B9-REFRESH-DANCERS-WITHIN >>> => %GET => H )) (( 3 ; B9-REFRESH-DANCERS-WITHIN >>> => %GET => H )) )) OK) (LET B9-COPY-OVER-TO-CLIPBOARD (( )) (( (( B9-CLIPBOARD >>> => & )) (( BROWSER-MATRIX >>> => & )) (( (( 1 ; 3 ; # => GM => NOZ )) ; (( 2 ; 4 ; # => GM => NOZ )) => AND (MATCHED (( 1 ; 3 ; # => GM => >N5 )) (( 2 ; 3 ; # => GM => >N6 )) (( 78 => >N9 )) (( 2 ; 4 ; # => GM ; N6 => EQN = 1 ; 4 ; # => GM => >N9 === )) (( N9 ; N5 => SUB => INC => >N9 )) (( N9 (COUNT (( N1 ; N7 => ADD => DEC ; N8 ; B9-WORK-SPACE >>> => GM ; N1 ; 1 ; ## => PM )) COUNTUP) )) (( (( 2 ; 3 ; # => GM )) ; (( 2 ; 4 ; # => GM )) => EQN => NOT (MATCHED (( 2 ; 4 ; # => GM => >N6 )) (( N6 ; (( 2 ; 3 ; # => GM )) => SUB => INC => >N1 )) (( 1 ; 4 ; # => GM (COUNT (( N1 ; N8 ; B9-WORK-SPACE >>> => GM ; N1 ; N3 ; ## => PM )) COUNTUP) )) (( (( 2 ; 4 ; # => GM )) ; (( 2 ; 3 ; # => GM )) => SUB => DEC => >N2 )) (( N2 => ISPRO (MATCHED (( N2 (COUNT (( N1 ; (( 2 ; 3 ; # => GM )) => ADD ; B9-WORK-SPACE >>> => %GET => INC4 => >N7 )) (( N1 => INC ; ## => %GET => INC4 => >N8 )) (( 78 => >N9 )) (( N7 ; N8 ; N9 => COPYNUMS )) COUNTUP) )) MATCHED) )) MATCHED) )) (( ## => FIX-BLANK-LINES-IN-FILE )) (( 1 ; ## => MATR>TEXT ; B9-CLIPBOARD-FIRST-LINE => >VARSTR )) MATCHED) )) (( (( 2 ; 4 ; # => GM )) ; (( 2 ; 3 ; # => GM )) => SUB => INC B9-CLIPBOARD-AMOUNT-LINES <>> => & )) (( B9-CLIPBOARD-FIRST-LINE => VARSTR-LEN => ISBASIS (MATCHED (( 1 ; 4 ; BROWSER-MATRIX >>> => GM => NOZ (MATCHED (( # => CLEAR-MATRIX )) (( B9-COPY-OVER-TO-CLIPBOARD )) (( B9-CLIPBOARD-FIRST-LINE => VARSTR> => => )) )(OTHER (( }} => => )) MATCHED) )) )(OTHER (( B9-CLIPBOARD-FIRST-LINE => VARSTR> => => )) MATCHED) )) (( && )) )) OK) (LET B9-PUT-IT-GOOD BE (( )) (( (( B9-CLIPBOARD >>> => & )) (( B9-WORK-SPACE >>> => & )) (( B9-REQUEST-CLIPBOARD-FIRST-LINE => TOLEN => ISPRO (MATCHED (( B9-LINE-POS >>> (COUNT (( N1 ; B9-LINE-NUM >>> ; # => GM => ISBASIS (MATCHED (( 32 ; N1 ; B9-LINE-NUM >>> ; # => PM )) MATCHED) )) COUNTUP) )) (( B9-CLIPBOARD-AMOUNT-LINES => VISDANCE (MATCHED (( 1 ; ## => %GET => >N8 )) (( N8 => ACTIVE-LENGTH => >N9 )) (( N9 ; B9-LINE-POS >>> => ADD ; 79 => INTGREATER (MATCHED (( 78 ; B9-LINE-POS >>> => SUB => INC => >N9 )) MATCHED) )) (( 78 ; (( B9-LINE-POS >>> ; N9 => ADD )) => SUB => INC => >N10 )) (( N10 => ISPRO (MATCHED (( N10 (COUNT (( (( N2 ; N1 => SUB => INC )) ; B9-LINE-POS >>> => ADD => DEC ; B9-LINE-NUM >>> ; # => GM ; )) (( ; (( N2 ; N1 => SUB => INC )) ; N11 ; B9-LINE-POS >>> => ADD => ADD => DEC ; B9-LINE-NUM >>> ; # => PM )) COUNTUP) )) MATCHED) )) (( N9 (COUNT (( N1 ; N10 => %GET ; N1 ; B9-LINE-POS >>> => ADD => DEC ; B9-LINE-NUM >>> ; # => PM )) COUNTUP) )) )(OTHER (( B9-CLIPBOARD-AMOUNT-LINES => VISBASIS = && ; && ; EXIT === )) (( B9-CLIPBOARD-AMOUNT-LINES >>> ; B9-LINE-NUM >>> => ADD ; 35000 => INTGREATER = CLS ; } The text would, it seems, then exceed workspace.} 10 100 B9-POP A-KEY ; && ; && ; EXIT === )) (( 79 => %MAKE => >N1 )) (( B9-LINE-NUM >>> ; # => %GET => INC4 => >N2 )) (( N1 => INC4 => >N3 )) (( 78 => >N4 )) (( N2 ; N3 ; N4 => COPYNUMS )) (( B9-LINE-POS >>> ; (( 78 ; BRIDGE => SUB => INC )) ; (( B9-LINE-NUM >>> ; # => %GET )) ; (( 1 ; ## => %GET )) => REPLACE-SEGMENT )) (( B9-LINE-NUM >>> ; B9-CLIPBOARD-AMOUNT-LINES >>> => DEC => B9-NEW-LINES )) (( B9-CLIPBOARD-AMOUNT-LINES >>> => DEC (COUNT (( (( N1 INC ; ## => %GET => INC4 )) ; (( N1 ; B9-LINE-NUM >>> ADD ; # => %GET => INC4 )) ; 78 => COPYNUMS )) COUNTUP) )) (( B9-CLIPBOARD-AMOUNT-LINES >>> ; ## => %GET => ACTIVE-LENGTH => >N5 )) (( 1 ; B9-LINE-POS >>> => DEC ; N1 => RM-SEGMENT )) (( N1 => ACTIVE-LENGTH ; N1 => >MEM )) (( N5 => INC ; (( B9-CLIPBOARD-AMOUNT-LINES >>> => DEC ; B9-LINE-NUM >>> => ADD ; # => %GET )) ; N1 => INSERT-SEGMENT )) (( N1 => %FREE )) MATCHED) )) MATCHED) )) (( && )) (( && )) )) OK) (( LOOKSTK )) (LET B9-EDIT-RANGE-CONTROL BE (( )) (( (( B9-EDIT-X >>> ; 2 ; 79 => SET-RANGE B9-EDIT-X <>> ; 2 ; 22 => SET-RANGE B9-EDIT-Y <>> ; 1 ; B9-TOP-LINE-NUM >>> => SET-RANGE B9-LINE-NUM <>> ; 1 ; 78 => SET-RANGE B9-LINE-POS < ADDVAR )) )) OK) (LET B9-EDIT-NEXTER BE (( )) (( (( 2 ; B9-EDIT-Y => ADDVAR )) )) OK) (LET B9-EDIT-LEFTER BE (( )) (( (( -1 B9-EDIT-X => ADDVAR )) )) OK) (LET B9-EDIT-LEFTER-10 BE (( )) (( (( -10 B9-EDIT-X => ADDVAR )) )) OK) (LET B9-EDIT-LEFTER-2 BE (( )) (( (( -2 B9-EDIT-X => ADDVAR )) )) OK) (LET B9-EDIT-LEFTMOST BE (( )) (( (( 2 B9-EDIT-X < INCVAR )) )) OK) (LET B9-EDIT-RIGHTER-10 BE (( )) (( (( 10 ; B9-EDIT-X => ADDVAR )) )) OK) (LET B9-EDIT-RIGHTER-2 BE (( )) (( (( 2 ; B9-EDIT-X => ADDVAR )) )) OK) (LET B9-EDIT-RIGHTER-4 BE (( )) (( (( 4 ; B9-EDIT-X => ADDVAR )) )) OK) (LET B9-EDIT-RIGHTMOST BE (( )) (( (( 79 B9-EDIT-X <>> ; B9-MAX-LINE-USED >>> => INTGREATER = EXIT === )) (( B9-LINE-NUM >>> ; B9-WORK-SPACE >>> => %GET => & )) (( 1 => >N1 )) (( B9-PAGE-WIDTH >>> => MAKEBL ; 12 ; B9-EDIT-Y >>> 25 MUL => B9-POP )) (( GOLABEL4: )) (( B9-PAGE-WIDTH >>> ; N1 => INTGTOREQUAL (MATCHED (( N1 ; # => %GET => A (MATCHED (( ; => ASCII ; N1 12 MUL 12 ADD ; B9-EDIT-Y >>> 25 MUL B9-POP )) (( INCN1 )) (( GOUP4 )) MATCHED) )) MATCHED) )) (( B9-UPDATE-LINE-POS )) (( B9-UNDERLINECURRENT-POS )) (( && )) )) OK) (LET B9-DISPLAY-THIS-CHAR-AT-CURRENT-LINE BE (( >N1 )) (( (( N1 => ASCII ; B9-EDIT-X >>> => DEC ; 12 => MUL ; B9-EDIT-Y >>> ; 25 => MUL => B9-POP )) (( B9-UPDATE-LINE-POS )) (( B9-UNDERLINECURRENT-POS )) )) OK) (LET B9-REDISPLAY-ALL-TEXT-HERE BE (( )) (( (( B9-WORK-SPACE >>> => & )) (( B9-MAX-LINE-USED >>> => ISPRO (MATCHED (( B9-PAGE-LENGTH >>> (COUNT (( } } ; B9-PAGE-WIDTH >>> ; 24 ; N1 TWICE 25 MUL => SEVERAL-B9-POP )) (( B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> ; N1 => ADD => DEC ; B9-MAX-LINE-USED >>> => INTGREATER (MATCHED (( RMS ; RMS )) (( GOFORWARD4 )) MATCHED) )) (( B9-PAGE-WIDTH >>> (COUNT (( N1 ; (( B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> ; N3 => ADD => DEC )) ; # => GM => AFFIRM (MATCHED (( ; => ONE ; ; )) (( ; 32 ; 126 => WITH (MATCHED (( ; ONE => ASCII => N1 ; 12 => MUL 12 ADD ; (( N3 ; 50 => MUL => B9-POP )) MATCHED) )) (( ; => RM )) )(OTHER (( RMS ; RMS )) (( GOFORWARD2 )) MATCHED) )) COUNTUP) )) (( GOLABEL2: )) COUNTUP) )) MATCHED) )) (( GOLABEL4: )) (( B9-UPDATE-LINE-POS )) (( && )) )) OK) (LET B9-COMPLETE-MARKING-ON BE (( )) (( (( BROWSER-MATRIX >>> => & )) (( 2 ; 3 ; # => GM => ISPRO => NOT (MATCHED (( # => CLEAR-MATRIX )) (( B9-MARKING-ON => SETBASIS )) (( B9-CLIPBOARD-AMOUNT-LINES => SETBASIS )) (( B9-CLIPBOARD-FIRST-LINE => VARSTR-SETBASIS )) (( && ; EXIT )) MATCHED) )) (( B9-MARKING-ON => VISBASIS = && ; EXIT === )) (( B9-CLIPBOARD >>> => CLEAR-MATRIX )) (( B9-LINE-POS >>> => >N9 )) (( B9-LINE-NUM >>> => >N10 )) (( 1 ; 3 ; # => GM => >N7 )) (( 2 ; 3 ; # => GM => >N8 )) (( N8 ; N10 => EQN (MATCHED (( N9 ; N7 => INTGTOREQUAL (MATCHED (( N9 ; 1 ; 4 ; # => PM )) (( N10 ; 2 ; 4 ; # => PM )) )(OTHER (( N9 ; 1 ; 3 ; # => PM )) (( N10 ; 2 ; 3 ; # => PM )) (( N7 ; 1 ; 4 ; # => PM )) (( N8 ; 2 ; 4 ; # => PM )) MATCHED) )) )(OTHER (( N10 ; N8 => INTGREATER (MATCHED (( N9 ; 1 ; 4 ; # => PM )) (( N10 ; 2 ; 4 ; # => PM )) )(OTHER (( N9 ; 1 ; 3 ; # => PM )) (( N10 ; 2 ; 3 ; # => PM )) (( N7 ; 1 ; 4 ; # => PM )) (( N8 ; 2 ; 4 ; # => PM )) MATCHED) )) MATCHED) )) (( (( (( 2 ; 4 ; # => GM )) ; (( 2 ; 3 ; # => GM )) => SUB => INC )) ; 270 => INTGREATER (MATCHED (( # => CLEAR-MATRIX )) (( CLS )) (( } THE CLIPBOARD (OF SIZE 270 LINES, BY THE WAY) } => 22 100 B9-POP )) (( } SEEMS TO REQUIRE SOME OTHER BOUNDARIES THAN THESE,} => 22 125 B9-POP )) (( } -- COULD YOU BE SO V E R Y KIND AS TO TRY AGAIN? } => 22 150 B9-POP )) (( A-KEY )) (( B9-REFRESH )) MATCHED) )) (( B9-MARKING-ON => SETBASIS )) (( B9-REQUEST-CLIPBOARD-FIRST-LINE => RM )) (( B9-UPDATE-LINE-POS )) (( && )) )) OK) (LET B9-STD-FRAME BE (( )) (( (( CLS )) (( B9-SHOW-NORMAL-GOODS-AND-GET-PAYMENTS-INSTANTLY )) )) OK) (( LOOKSTK )) (LET B9-SAVE-THIS-DOC-NOW BE (( )) (( (( B9-WORK-SPACE >>> => & )) (( B9-FILE-SHOULD-BE-STORED => SETBASIS )) (( # => FIX-BLANK-LINES-IN-FILE )) (( B9-DOC-NAME => VARSTR> ; }.TXT} => CONCAT ; # => PM2FILE ; RM )) (( && )) )) OK) (LET B9-GET-NEW-DOC-NAME BE (( )) (( (( CLS )) (( } S T O R I N G Y O U R G R E A T W O R K S ! ! ! ! ! ! !} => 22 50 B9-POP )) (( } P L E A S E G I V E N E W D O C - N A M E :} => 22 75 B9-POP )) (( } (8-DIGITS MAX, DASH - AND HYPHEN _ AND DIGITS OKAY, .TXT} => 22 100 B9-POP )) (( } IS ADDED BY MACHINE AUTOMATICALLY. IF EXISTING FILE HAS} => 22 125 B9-POP )) (( } THIS NAME, IT IS AUTOMATICALLY OVERWRITTEN, SO BE CERTAIN.} => 22 150 B9-POP )) (( } ===========================================>} => 22 175 B9-POP )) (( 8 700 175 B9-READLN => MAKE-SAFE-8-SIZE-FILENAME => ONE ; }.TXT} => CONCAT ; ; )) (( } THANKS.} => 22 200 B9-POP )) (( } WILL USE:} => 22 225 B9-POP )) (( } ===========================================>} => 22 250 B9-POP )) (( ; => 700 250 B9-POP )) (( ; B9-DOC-NAME => >VARSTR )) )) OK) (LET B9-EXIT-MAYBE-BROWSE-MODE (( )) (( (( RO-MODE => VISDANCE (MATCHED (( CLS )) (( } BELOVED AMATEUR USER OF THE B9 EDITOR! I WELCOME YOUR} => 22 50 B9-POP )) (( } ENTERPRISING SPIRIT! BUT THE EDITOR HAS BEEN OPENED} => 22 75 B9-POP )) (( } IN A MODE TO BROWSE FILES ONLY. PLEASE REOPEN IN A SAVE/WRITE MODE} => 22 100 B9-POP )) (( } ANY DOCUMENTS WHICH SHOULD BE ALTERED. PROMISE YOU'LL REMEMBER} => 22 125 B9-POP )) (( } AND BE A BETTER CITIZEN FROM NOW ON ;) } => 22 150 B9-POP )) (( 22 175 B9-YNIN ; RM )) (( YES => => )) )(OTHER (( NO => => )) MATCHED) )) )) OK) (LET B9-STORE-FILE-OPTION (( )) (( (( B9-EXIT-MAYBE-BROWSE-MODE = EXIT === )) (( CLS )) (( } >>>>>>>>>>>>>>>>>>>>>> T H E B9 S T O R E O P T I O N} => 22 50 B9-POP )) (( B9-FILE-SHOULD-BE-STORED => VISDANCE (MATCHED (( } OUR SPIES TELL US THAT DOCUMENT M I G H T HAVE} => 22 75 B9-POP )) (( } BEEN UPDATED SOMEHOW (AS A RESULT OF YOUR KEYACTIONS).} => 22 100 B9-POP )) (( } IF IT IS NOT STORED AT THIS POINT, WHAT IS IN RAM IS CLEARED.} => 22 125 B9-POP )) MATCHED) )) (( } > > > > > D O C U M E N T N A M E : } => 22 150 B9-POP )) (( B9-DOC-NAME => VARSTR> => 620 150 B9-POP )) (( }======== (.TXT IS AUTOADDED)} => 620 175 B9-POP )) (( } (THE PRESENT & STANDARD FILE FOLDER, C:\BOEHM\BOEHMIAN IS NORMALLY USED.} => 22 200 B9-POP )) (( } (BEWARE: ONLY IF YOU WANT OVERWRITE, GIVE NAME OF AN EXISTING FILE.)} => 22 225 B9-POP )) (( } ****====>!!!!! w a n t t o S A V E ????} => 22 250 B9-POP )) (( } ****====>!!!!! w a n t t o S A V E ????} => 22 275 B9-POP )) (( } ****====>!!!!! w a n t t o S A V E ????} => 22 300 B9-POP )) (( 22 325 B9-YNIN (MATCHED (( CLS )) (( } > > > > > D O C U M E N T N A M E : } => 22 50 B9-POP )) (( B9-DOC-NAME => VARSTR> => 800 50 B9-POP )) (( B9-DOC-NAME => VARSTR> => 800 75 B9-POP )) (( B9-DOC-NAME => VARSTR> => 800 100 B9-POP )) (( } WANT TO SAVE UNDER THE E X I S T I N G NAME?} 22 125 B9-POP )) (( } (IF NEW NAME, PLS AVOID SIMILAR NAMES AS OS NAMES)} 22 150 B9-POP )) (( } WANT TO SAVE UNDER THE E X I S T I N G NAME?} 22 175 B9-POP )) (( } WANT TO SAVE UNDER THE E X I S T I N G NAME?} 22 200 B9-POP )) (( } WANT TO SAVE UNDER THE E X I S T I N G NAME?} 22 225 B9-POP )) (( } [PLS TYPE AN 'N' IF YOU WANT NEW NAME] } 22 250 B9-POP )) (( 22 275 B9-YNIN => NOT (MATCHED (( B9-GET-NEW-DOC-NAME )) MATCHED) )) (( B9-SAVE-THIS-DOC-NOW )) (( } IT SHOULD BE SAVED NOW. DO PLS CHECK IN ALL IMPORTANT CASES,} => 22 300 B9-POP )) (( } AND CERTAINLY IF YOU HAVE USED AN UNUSUAL FILENAME.} => 22 325 B9-POP )) (( } (NORMALLY, BLANK LINES IN THE COMPLETION OF THE DOCUMENT ARE} => 22 350 B9-POP )) (( } NOT NECESSARILY INCLUDED, SO LINE COUNT MAY BE DIFFERENT.)} => 22 375 B9-POP )) (( 22 400 B9-ENTERPLS )) MATCHED) )) (( B9-LINE-NUM => SETDANCE )) (( B9-LINE-POS => SETDANCE )) (( B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN => SETDANCE )) (( B9-EDIT-TOP-LEFT )) )) OK) (LET B9-MAYBE-STORE-FILE (( )) (( (( (( B9-FILE-SHOULD-BE-STORED => VISDANCE )) (( RO-MODE => VISBASIS )) => AND (MATCHED (( B9-STORE-FILE-OPTION )) MATCHED) )) )) OK) (LET WORD BE (( )) (( (( RO-MODE => SETDANCE )) (( }MTDOC} ; }B9} => ? => H )) )) OK) (LET B9-FETCH-FILE BE (( )) (( (( B9-WORK-SPACE >>> => & )) (( # => CLEAR-MATRIX )) (( B9-FILE-SHOULD-BE-STORED => SETBASIS )) (( B9-DOC-NAME => VARSTR> => CALC-AMOUNT-LINES-IN-TXT-OF-ANY-WIDTH B9-MAX-LINE-USED <>> => ISPRO => NOT (MATCHED (( B9-MAX-LINE-USED => SETDANCE )) MATCHED) )) (( B9-MAX-LINE-USED >>> ; 1 ; B9-TOP-LINE-NUM >>> => SET-RANGE B9-MAX-LINE-USED < VARSTR> ; }.TXT} => CONCAT ; # => FILE2PM ; RM )) (( # => FIX-BLANK-LINES-IN-FILE )) (( B9-MAX-LINE-USED >>> ; # => FILTER-NON7ASCII-CHARS )) (( # => ARE-ALL-IN-RIGHTMOST-COLUMN-UNUSED => NOT (MATCHED (( # => CLEAR-MATRIX )) (( B9-MAX-LINE-USED => SETDANCE )) (( CLS )) (( } LOOK, MY DEAR FRIEND, I DON'T KNOW HOW YOU HAVE PRODUCED} => 22 50 B9-POP )) (( } THIS SURELY EMINENT TEXT FILE, BUT I KNOW, FOR FACT, E.G. LINE} => 22 75 B9-POP )) (( ARE-ALL-IN-RIGHTMOST-DATA >>> ; } HAS BEEN PRODUCED BY SOME OTHER EDITOR THAT THIS.} => CONCAT => 22 100 B9-POP )) (( } WHAT I AM TRYING TO POINT OUT IS THAT YOU NEED TO RUN STH LIKE} => 22 125 B9-POP )) (( } THE WORDWRAP PROGRAM ON THIS. IT IS FAIRLY STRAIGHTFORWARD.} => 22 150 B9-POP )) (( } DO THAT, AND FIX UP PARAGRAPHS AFTERWARDS, FOR WE MUST HAVE} => 22 175 B9-POP )) (( } MAXIMUM 78 IN CHARACTER LINE LENGTH OF ALL B9 DOCUMENTS.} => 22 200 B9-POP )) (( } GREAT LUCK ON YOUR MISSION. AND WELCOME BACK ON THIS.} => 22 225 B9-POP )) (( } =========> I WILL IMPROVE IN THE FUTURE:} => 22 250 B9-POP )) (( 22 275 B9-YNIN => RM )) (( CLS )) (( B9-LINE-NUM => SETDANCE )) )(OTHER (( B9-LINE-NUM >>> ; 1 ; B9-MAX-LINE-USED >>> => SET-RANGE B9-LINE-NUM <>> => & )) (( B9-MAYBE-STORE-FILE )) (( CLS )) (( } P L E A S E T E L L W H I C H F I L E T O G E T :} => 22 50 B9-POP )) (( RO-MODE => VISDANCE (MATCHED (( } *******====> BROWSE-MODE IS ON. START IN ANOTHER WAY TO STORE ALSO.} => 22 500 B9-POP )) (( } !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!} => 22 525 B9-POP )) )(OTHER MATCHED) )) (( } (FROM THE NORMAL STANDARD FOLDER C:\BOEHM\BOEHMIAN. THE PROGRAM} => 22 100 B9-POP )) (( } ASSUMES THAT YOU ARE FAMILIAR WITH THE FILENAME YOU WANT TO WORK} => 22 125 B9-POP )) (( } ON, -- IF IN DOUBT CONSULT A PROGRAM WHICH GIVES A FILELIST.} => 22 150 B9-POP )) (( } THIS EDITOR AUTOMATICALLY ASSUMES .TXT IS THE RIGHT EXTENSION.} => 22 175 B9-POP )) (( } IF FILENAME UNKNOWN, YOU WILL GET A NEW EMPTY BLANK WORKSPACE.} => 22 200 B9-POP )) (( } IF YOU JUST [INS]-MARKED SOMETHING, YOU CAN USE F5 TO PUT IT IN THE NEW.} => 22 225 B9-POP )) (( } THE FILENAME YOU INDCATE HERE WILL BE SUGGESTED WHEN YOU SAVE IT.)} => 22 250 B9-POP )) (( } LOAD / GET=================================>} => 22 275 B9-POP )) (( 8 800 275 B9-READLN => MAKE-SAFE-8-SIZE-FILENAME => ONE ; }.TXT} => CONCAT ; ; )) (( } THANKS. CURRENT FILENAME IS SET TO THIS --} => 22 325 B9-POP )) (( } (AND FILE WILL BE ACCESSED IF EXISTS)} => 22 350 B9-POP )) (( } ===========================================>} => 22 375 B9-POP )) (( ; => 800 375 B9-POP )) (( ; B9-DOC-NAME => >VARSTR )) (( B9-FETCH-FILE )) (( B9-LINE-NUM => SETDANCE )) (( B9-LINE-POS => SETDANCE )) (( B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN => SETDANCE )) (( B9-EDIT-TOP-LEFT )) (( 22 400 B9-ENTERPLS )) (( CLS )) (( && )) )) OK) (LET B9-FUNCTR-U BE (( )) (( (( B9-CASE-SCAN => FLAGFLIP )) )) OK) (LET B9-FUNCTR-W BE (( )) (( (( B9-WORDWRAPPING => FLAGFLIP )) (( CLS )) (( B9-WORDWRAPPING => VISDANCE (MATCHED (( }GREAT LUCK WITH YOUR WRITING! WORDWRAPPING} ; 50 ; 100 => B9-POP )) (( }IS NOW IN THE DARING POSITION OF "ON"!!!} ; 50 ; 150 => B9-POP )) (( }YOU GOTTA BE KIND'A TOUGH TO DO THIS.} ; 50 ; 200 => B9-POP )) (( }BEWARE! IT K I L L S LINES UNDERNEATH IT.} ; 50 ; 250 => B9-POP )) (( }AND FOR SPEED AND FLOW OF WRITING, GET THE} ; 50 ; 300 => B9-POP )) (( }TEXT CURSOR RIGHT HIGH UP ON THE PAGE. WATCH} ; 50 ; 350 => B9-POP )) (( }THE LINESHIFTS, THEY ARE PART OF YOUR COMMUNICATION.} ; 50 ; 400 => B9-POP )) (( }THE PRO'S IN B9 KNOW THAT CTR-X IS PGDN, CTR-Q IS PGUP,} ; 50 ; 450 => B9-POP )) (( }CTR-K IS AHEAD, CTR-G IS UP, AND MORE SUCH DEEP STUFF.} ; 50 ; 500 => B9-POP )) (( }-- ARISTO} ; 50 ; 550 => B9-POP )) )(OTHER (( }WORDWRAP NOW IN THE POSITION "OFF". HERE IS, BY THE WAY,} ; 10 ; 25 => B9-POP )) (( }A LIST OF *TOP SECRET* EXTRA WAYS TO ACCESS THE FUNCTIONS:} ; 10 ; 50 => B9-POP )) (( }CTR-C INSERT (COPY) CTR-V PASTE (F5) CTR-T SHIFT-TABL} ; 10 ; 75 => B9-POP )) (( }CTR-G UP CTR-Z LEFT CTR-X NEXT PAGE CTR-N COMPL.PAGE} ; 10 ; 100 => B9-POP )) (( }CTR-K RIGHT [ENTER], AS ALWAYS, FOR NEXT LINE CTR-Q UP PAGE} ; 10 ; 125 => B9-POP )) (( }ARE THERE MORE NOW? OH YES, CTR-O OPEN (F1) CTR-S SAVE (F2)} ; 10 ; 150 => B9-POP )) (( }WITH CTR-F FIND (F4) AND CTR-E REPLACE (F3) WHERE THESE, AS} ; 10 ; 175 => B9-POP )) (( }BEFORE, CAN BE REPEATED WITH CTR-L, AND IF CTR-U (ON/OFF) IS} ; 10 ; 200 => B9-POP )) (( }PRESSED BEFORE CTR-F OR CTR-E, UPPERCASE/LOWERCASE SENSITIVITY} ; 10 ; 225 => B9-POP )) (( }IS TOGGLED (IT IS NORMALLY OFF, SO IT'S EASIER TO FIND WORDS.} ; 10 ; 250 => B9-POP )) (( }THEN CTR-J JUMP (F8), AND.. YES, CTR-Y FOR INSERT LINES (SH-INS)} 10 ; 275 => B9-POP )) (( }AND CTR-R FOR DELETE LINES (SH-REMOVE). TO INSERT A LINESHIFT} ; 10 ; 300 => B9-POP )) (( }IN THE MIDDLE OF THE LINE, MAKE TWO BLANK LINES SOMEWHERE,} ; 10 ; 325 => B9-POP )) (( }GO TO FIRST OF THESE, CTR-C, PRESS ENTER, CTR-C AGAIN, THEN} ; 10 ; 350 => B9-POP )) (( }GET INTO POSITION OF THE LINE AND PRESS CTR-V.} ; 10 ; 375 => B9-POP )) MATCHED) )) (( 50 ; 600 => B9-ENTERPLS )) (( CLS )) (( CLEAR_KEYBUF )) (( B9-REFRESH )) )) OK) (LET B9-FUNCTR-L BE (( )) (( (( B9-RECENT-SCAN-REPL-WARP => VISBASIS (MATCHED (( EXIT )) MATCHED) )) (( CLS )) (( }MOVING AHEAD ONE!} => 22 50 B9-POP )) (( B9-EDIT-X >>> ; 77 => INTGREATER (MATCHED (( B9-MAX-LINE-USED >>> ; B9-LINE-NUM >>> => INTGREATER (MATCHED (( B9-LINE-NUM => INCVAR )) (( B9-LINE-NUM >>> B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN < SETDANCE )) (( 2 ; B9-EDIT-X < INCVAR )) (( B9-EDIT-X => INCVAR )) MATCHED) (( B9-RECENT-SCAN-REPL-WARP >>> H )) (( B9-REFRESH )) )) OK) (LET B9-PR-REDISPLAY-CURRENT-PAGE BE (( )) (( (( B9-WORK-SPACE >>> => & )) (( B9-MAX-LINE-USED >>> => ISPRO (MATCHED (( 29 (COUNT (( B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> ; N1 => ADD => DEC ; B9-MAX-LINE-USED >>> => INTGREATER (MATCHED (( RMS ; RMS )) (( GOFORWARD4 )) MATCHED) )) (( B9-PAGE-WIDTH >>> (COUNT (( N1 ; (( B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> ; N3 => ADD => DEC )) ; # => GM => AFFIRM (MATCHED (( ; => ONE ; ; )) (( ; 32 ; 126 => WITH (MATCHED (( ; ONE => ASCII => N1 ; 12 => MUL 42 ADD ; (( B9-F9-MODE => VISBASIS (MATCHED (( N3 ; 25 => MUL => B9-PRPOP )) )(OTHER (( N3 ; 25 => MUL => B9-POP )) MATCHED) MATCHED) )) (( ; => RM )) )(OTHER (( RMS ; RMS )) (( GOFORWARD2 )) MATCHED) )) COUNTUP) )) (( GOLABEL2: )) COUNTUP) )) MATCHED) )) (( GOLABEL4: )) (( && )) )) OK) (LET B9-FUNCTR-I BE (( )) (( (( 74 ; B9-LINE-POS >>> => INTGREATER (MATCHED (( B9-UN-UNDERLINECURRENT-POS )) (( B9-EDIT-RIGHTER-2 )) (( 2 B9-LINE-POS => ADDVAR )) (( B9-EDIT-RANGE-CONTROL )) (( B9-UNDERLINECURRENT-POS )) MATCHED) )) )) OK) (LET B9-FUNSHIFT-IND BE (( )) (( (( 74 ; B9-LINE-POS >>> => INTGREATER (MATCHED (( B9-UN-UNDERLINECURRENT-POS )) (( B9-EDIT-RIGHTER-4 )) (( 4 B9-LINE-POS => ADDVAR )) (( B9-EDIT-RANGE-CONTROL )) (( B9-UNDERLINECURRENT-POS )) MATCHED) )) )) OK) (LET B9-FUNCTR>-ARROW BE (( )) (( (( B9-UN-UNDERLINECURRENT-POS )) (( B9-EDIT-RIGHTER-10 )) (( 10 B9-LINE-POS => ADDVAR )) (( B9-EDIT-RANGE-CONTROL )) (( B9-UNDERLINECURRENT-POS )) )) OK) (LET B9-FUNCTR<-ARROW BE (( )) (( (( B9-UN-UNDERLINECURRENT-POS )) (( B9-EDIT-LEFTER-10 )) (( -10 B9-LINE-POS => ADDVAR )) (( B9-EDIT-RANGE-CONTROL )) (( B9-UNDERLINECURRENT-POS )) )) OK) (LET B9-MAX-LINE-USED-AT-LEAST-THIS BE (( >N6 )) (( (( B9-WORK-SPACE >>> => & )) (( N6 ; 1 ; B9-TOP-LINE-NUM >>> => SET-RANGE => >N6 )) (( B9-MAX-LINE-USED >>> => >N7 )) (( N6 ; N7 => INTGREATER (MATCHED (( N6 ; N7 => SUB (COUNT (( 32 ; 1 ; (( N1 ; N9 => ADD )) ; # => PM )) COUNTUP) )) (( N6 B9-MAX-LINE-USED <>> ; 21 => INTGREATER (MATCHED (( B9-MAX-LINE-USED >>> ; B9-LINE-NUM >>> => INTGTOREQUAL )) (MATCHED (( B9-LINE-NUM => INCVAR )) (( B9-LINE-NUM >>> => B9-MAX-LINE-USED-AT-LEAST-THIS )) (( B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN => INCVAR )) (( B9-STD-FRAME )) (( B9-REDISPLAY-ALL-TEXT-HERE )) MATCHED) )) )(OTHER (( B9-EDIT-NEXTER )) (( B9-LINE-NUM => INCVAR )) (( B9-EDIT-RANGE-CONTROL )) MATCHED) (( B9-UNDERLINECURRENT-POS )) )) OK) (LET B9-FUN<-ARROW BE (( )) (( (( B9-UN-UNDERLINECURRENT-POS )) (( B9-EDIT-LEFTER )) (( -1 ; B9-LINE-POS => ADDVAR )) (( B9-EDIT-RANGE-CONTROL )) (( B9-UNDERLINECURRENT-POS )) )) OK) (LET B9-FUN^-ARROW BE (( )) (( (( B9-UN-UNDERLINECURRENT-POS )) (( (( B9-EDIT-Y >>> ; 2 => EQN )) (( B9-LINE-NUM >>> ; 1 => INTGREATER )) => AND (MATCHED (( -1 B9-LINE-NUM => ADDVAR )) (( -1 B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN => ADDVAR )) (( B9-STD-FRAME )) (( B9-REDISPLAY-ALL-TEXT-HERE )) (( B9-UNDERLINECURRENT-POS )) )(OTHER (( B9-EDIT-UPPER )) (( -1 ; B9-LINE-NUM => ADDVAR )) (( B9-EDIT-RANGE-CONTROL )) (( B9-UNDERLINECURRENT-POS )) MATCHED) )) OK) (LET B9-FUN>-ARROW BE (( )) (( (( B9-UN-UNDERLINECURRENT-POS )) (( B9-EDIT-RIGHTER )) (( B9-LINE-POS => INCVAR )) (( B9-EDIT-RANGE-CONTROL )) (( B9-UNDERLINECURRENT-POS )) )) OK) (LET B9-FUNF1 BE (( )) (( (( B9-LOAD-NEW-FILE )) (( CLEAR_KEYBUF )) (( B9-REFRESH )) )) OK) (LET B9-FUNF2 BE (( )) (( (( B9-STORE-FILE-OPTION )) (( CLEAR_KEYBUF )) (( B9-REFRESH )) )) OK) (LET B9-SCAN-ACTION-ESSENCE BE (( )) (( (( V10 => NOZ (MATCHED (( V10 => TOV2 )) (( V10 ; V3 ; # => GM => TOV11 )) (( 0 => TOV10 )) MATCHED) )) (( V8 ; V11 => INTEQUAL (MATCHED (( V7 => %LENGTH => DEC (COUNT (( (( N1 ; V2 => ADD )) ; V3 ; # => GM => A (MATCHED (( ; N1 => INC ; V7 => %GET => NOT_INTEQUAL (MATCHED RMS RMS GOFORWARD3 MATCHED) )) )(OTHER RMS RMS GOFORWARD4 MATCHED) )) COUNTUP) )) (( V2 ; B9-LINE-POS < INC ; B9-EDIT-X < INC => TOV2 )) (( 1 => TOV4 )) (( }* * * * * * * * * * * * * * FOUND IT!} => 22 400 B9-POP )) (( }* * * * * * $ * * * * * * * FOUND IT!} => 22 425 B9-POP )) (( }* * * * * * * * * * * * * * FOUND IT!} => 22 450 B9-POP )) (( EXIT )) (( GOLABEL3: )) (( GOLABEL4: )) MATCHED) )) )) OK) (LET B9-SCAN-ACTION BE (( )) (( (( }SCANNING THE TEXT >>>>CASE-EXACT<<< 22 200 B9-POP )) (( }SCANNING FROM PRESENT POSITION ONWARDS FOR:} => 22 225 B9-POP )) (( }"} ; B9-SCAN-ARRAY >>> => ARRAY>STR ; }"} => CONCAT => CONCAT ; 22 ; 250 B9-POP )) (( VLOTS )) (( B9-LINE-POS >>> => TOV10 )) (( B9-LINE-NUM >>> => TOV3 )) (( B9-MAX-LINE-USED >>> => TOV4 )) (( B9-SCAN-ARRAY >>> => TOV7 )) (( 1 ; V7 => %GET => TOV8 )) (( VFREE )) (( B9-SCAN-ACTION-HOUSE >>> ; B9-WORK-SPACE >>> => FORVPM2 )) (( }**** DONE! ****} => 22 680 B9-POP )) (( A-KEY )) )) OK) (( }B9-SCAN-ACTION-ESSENCE} => ? B9-SCAN-ACTION-HOUSE < NOZ (MATCHED (( V10 => TOV2 )) (( V10 ; V3 ; # => GM => TOV11 )) (( 0 => TOV10 )) MATCHED) )) (( V8 ; V11 => UPCNUM => INTEQUAL (MATCHED (( V7 => %LENGTH => DEC (COUNT (( (( N1 ; V2 => ADD )) ; V3 ; # => GM => A (MATCHED (( ; => UPCNUM ; N1 => INC ; V7 => %GET => NOT_INTEQUAL (MATCHED RMS RMS GOFORWARD3 MATCHED) )) )(OTHER RMS RMS GOFORWARD4 MATCHED) )) COUNTUP) )) (( V2 ; B9-LINE-POS < INC ; B9-EDIT-X < INC => TOV2 )) (( 1 => TOV4 )) (( }* * * * * * * * * * * * * * FOUND IT!} => 22 400 B9-POP )) (( }* * * * * * $ * * * * * * * FOUND IT!} => 22 400 B9-POP )) (( }* * * * * * * * * * * * * * FOUND IT!} => 22 400 B9-POP )) (( EXIT )) (( GOLABEL3: )) (( GOLABEL4: )) MATCHED) )) )) OK) (LET B9-SCAN-ACTION-UPC BE (( )) (( (( }SCANNING THE TEXT >>>>CASE-LIBERAL<<< 22 200 B9-POP )) (( }SCANNING FROM PRESENT POSITION ONWARDS FOR:} => 22 225 B9-POP )) (( }"} ; B9-SCAN-ARRAY >>> => ARRAY>STR ; }"} => CONCAT => CONCAT ; 22 250 B9-POP )) (( VLOTS )) (( B9-LINE-POS >>> => TOV10 )) (( B9-LINE-NUM >>> => TOV3 )) (( B9-MAX-LINE-USED >>> => TOV4 )) (( B9-SCAN-ARRAY >>> => TOV7 )) (( 1 ; V7 => %GET => TOV8 )) (( VFREE )) (( B9-SCAN-ACTION-UPC-HOUSE >>> ; B9-WORK-SPACE >>> => FORVPM2 )) (( }**** DONE! ****} => 22 680 B9-POP )) (( A-KEY )) )) OK) (( }B9-SCAN-ACTION-UPC-ESSENCE} => ? B9-SCAN-ACTION-UPC-HOUSE < NOZ (MATCHED (( V10 => TOV2 )) (( V10 ; V3 ; # => GM => TOV11 )) (( 0 => TOV10 )) MATCHED) )) (( V8 ; V11 => INTEQUAL (MATCHED (( V7 => %LENGTH => DEC (COUNT (( (( N1 ; V2 => ADD )) ; V3 ; # => GM => A (MATCHED (( ; N1 => INC ; V7 => %GET => NOT_INTEQUAL (MATCHED RMS RMS GOFORWARD3 MATCHED) )) )(OTHER RMS RMS GOFORWARD4 MATCHED) )) COUNTUP) )) (( V2 ; B9-LINE-POS < INC ; B9-EDIT-X < INC => TOV2 )) (( 1 => TOV4 )) (( B9-LINE-NUM >>> ; B9-WORK-SPACE >>> => %GET => >N7 )) (( B9-LINE-POS >>> ; B9-SCAN-ARRAY >>> => %LENGTH ; N7 ; B9-REPL-ARRAY >>> => REPLACE-SEGMENT )) (( B9-FILE-SHOULD-BE-STORED => SETDANCE )) (( }* * * * * * * * * * * * * * REPLACED IT!} 22 400 B9-POP )) (( }* * * * * * $ * * * * * * * REPLACED IT!} 22 425 B9-POP )) (( }* * * * * * * * * * * * * * REPLACED IT!} 22 450 B9-POP )) (( EXIT )) (( GOLABEL3: )) (( GOLABEL4: )) MATCHED) )) )) OK) (LET B9-REPL-ACTION BE (( )) (( (( }SCANNING THE TEXT >>>>CASE-EXACT<<<< FOR REPLACE!} 22 200 B9-POP )) (( }SCANNING FROM PRESENT POSITION ONWARDS FOR:} 22 225 B9-POP )) (( }"} ; B9-SCAN-ARRAY >>> => ARRAY>STR ; }"} => CONCAT => CONCAT ; 22 250 B9-POP )) (( VLOTS )) (( B9-LINE-POS >>> => TOV10 )) (( B9-LINE-NUM >>> => TOV3 )) (( B9-MAX-LINE-USED >>> => TOV4 )) (( B9-SCAN-ARRAY >>> => TOV7 )) (( 1 ; V7 => %GET => TOV8 )) (( VFREE )) (( B9-REPL-ACTION-HOUSE >>> ; B9-WORK-SPACE >>> => FORVPM2 )) (( }**** DONE! ****} => 22 680 B9-POP )) (( A-KEY )) )) OK) (( }B9-REPL-ACTION-ESSENCE} => ? B9-REPL-ACTION-HOUSE < NOZ (MATCHED (( V10 => TOV2 )) (( V10 ; V3 ; # => GM => TOV11 )) (( 0 => TOV10 )) MATCHED) )) (( V8 ; V11 => UPCNUM => INTEQUAL (MATCHED (( V7 => %LENGTH => DEC (COUNT (( (( N1 ; V2 => ADD )) ; V3 ; # => GM => A (MATCHED (( ; => UPCNUM ; N1 => INC ; V7 => %GET => NOT_INTEQUAL (MATCHED RMS RMS GOFORWARD3 MATCHED) )) )(OTHER RMS RMS GOFORWARD4 MATCHED) )) COUNTUP) )) (( V2 ; B9-LINE-POS < INC ; B9-EDIT-X < INC => TOV2 )) (( 1 => TOV4 )) (( B9-LINE-NUM >>> ; B9-WORK-SPACE >>> => %GET => >N7 )) (( B9-LINE-POS >>> ; B9-SCAN-ARRAY >>> => %LENGTH ; N7 ; B9-REPL-ARRAY >>> => REPLACE-SEGMENT )) (( B9-FILE-SHOULD-BE-STORED => SETDANCE )) (( }* * * * * * * * * * * * * * REPLACED IT!} => 22 400 B9-POP )) (( }* * * * * * $ * * * * * * * REPLACED IT!} => 22 425 B9-POP )) (( }* * * * * * * * * * * * * * REPLACED IT!} => 22 450 B9-POP )) (( EXIT )) (( GOLABEL3: )) (( GOLABEL4: )) MATCHED) )) )) OK) (LET B9-REPL-ACTION-UPC BE (( )) (( (( }SCANNING THE TEXT >>>>CASE-LIBERAL<<<< REPLACE!} => 22 200 B9-POP )) (( }SCANNING FROM PRESENT POSITION ONWARDS FOR:} => 22 225 B9-POP )) (( }"} ; B9-SCAN-ARRAY >>> => ARRAY>STR ; }"} => CONCAT => CONCAT ; 22 ; 250 B9-POP )) (( VLOTS )) (( B9-LINE-POS >>> => TOV10 )) (( B9-LINE-NUM >>> => TOV3 )) (( B9-MAX-LINE-USED >>> => TOV4 )) (( B9-SCAN-ARRAY >>> => TOV7 )) (( 1 ; V7 => %GET => TOV8 )) (( VFREE )) (( B9-REPL-ACTION-UPC-HOUSE >>> ; B9-WORK-SPACE >>> => FORVPM2 )) (( }**** DONE! ****} => 22 680 B9-POP )) (( A-KEY )) )) OK) (( }B9-REPL-ACTION-UPC-ESSENCE} => ? B9-REPL-ACTION-UPC-HOUSE <>>>REPLACE<<<< ANY SIMPLE TEXT PATTERN WITH ANOTHER.} => 22 25 B9-POP )) (( } -- STARTING FROM WHERE THE TEXT MARKER IS POSITIONED NOW,} => 22 50 B9-POP )) (( } AND -- IF YOU PRESS CTR-L YOU CAN LOOP MOST RECENT SCAN/REPL,} => 22 75 B9-POP )) (( } BUT CTR-L IS SOMETHING YOU PRESS WHEN THE TEXT IS SHOWING.} => 22 100 B9-POP )) (( } ONCE YOU HAVE PRESSED THIS KEY, YOU MUST TYPE IN TEXT --} => 22 125 B9-POP )) (( } -- OR PRESS ENTER TO GET A LINE/WORD WHICH YOU HAVE [INS]-MARKED} => 22 150 B9-POP )) (( } TO SEARCH FOR. YOU WILL BE ASKED WHETHER YOU'RE CERTAIN TO GO AHEAD.} => 22 175 B9-POP )) (( } DURING ORDINARY TEXT VIEWING MODE, CTR-U SHIFTS SCAN CASE-SENSITIVITY.} => 22 200 B9-POP )) (( } THE TEXT SCAN/REPL IS IN MODE:} => 22 225 B9-POP )) (( B9-CASE-SCAN => VISDANCE (MATCHED (( }>>>>UP/LCASE-STRICT} => 640 225 B9-POP )) )(OTHER (( }>>>>UP/LCASE-LIBERAL} => 640 225 B9-POP )) MATCHED) )) (( } TEXT TO MATCH FOR: (OR ENTER FOR FIRST LINE OF ANY RECENT [INS] CLIP)} => 22 250 B9-POP )) (( } ==>} => 22 275 B9-POP )) (( 70 120 275 B9-READLN => TOSTANDARDSPACE => LENGTH => ISBASIS (MATCHED (( RM )) (( B9-REQUEST-CLIPBOARD-FIRST-LINE ; )) MATCHED) )) (( ; => LENGTH => ISBASIS (MATCHED (( RM )) (( GOFORWARD4 )) MATCHED) )) (( CLS )) (( B9-CASE-SCAN => VISBASIS (MATCHED (( ; => UPCM ; )) MATCHED) )) (( ; B9-SCAN-ARRAY >>> => STR>EXISTING-ARRAY )) (( } EXACT TEXT TO REPLACE THIS WITH (ENTERING NOTHING MEANS REMOVE):} => 22 25 B9-POP )) (( } ==>} => 22 50 B9-POP )) (( 70 120 50 B9-READLN => TOSTANDARDSPACE ; )) (( ; B9-REPL-ARRAY >>> => STR>EXISTING-ARRAY )) (( } ****** ONLY ONE REPLACE WILL BE DONE. CTR-L REPEATEDLY FOR MORE.} => 22 75 B9-POP )) (( } =========> PLEASE STORE OFTEN UNDER NEW NAMES WHEN BIG CHANGES ===========>} => 22 100 B9-POP )) (( } ************* PLEASE S A V E FIRST IF UNCERTAIN!!!! (TYPE N HERE)} => 22 125 B9-POP )) (( } **** A B S O L U T E L Y SURE TO DO R E P L A C E?} => 22 150 B9-POP )) (( 22 175 B9-YNIN (MATCHED (( B9-CASE-SCAN => VISDANCE (MATCHED (( }B9-REPL-ACTION} => ? B9-RECENT-SCAN-REPL-WARP < ? B9-RECENT-SCAN-REPL-WARP < 22 50 B9-POP )) (( } -- STARTING FROM WHERE THE TEXT MARKER IS POSITIONED NOW,} => 22 75 B9-POP )) (( } AND -- IF YOU PRESS CTR-L YOU CAN LOOP MOST RECENT SCAN/REPL,} => 22 100 B9-POP )) (( } BUT CTR-L (LOOK) IS SOMETHING YOU PRESS WHEN THE TEXT IS SHOWING.} => 22 125 B9-POP )) (( } ONCE YOU HAVE PRESSED THIS KEY, YOU MUST TYPE IN TEXT --} => 22 150 B9-POP )) (( } -- OR PRESS ENTER TO GET A LINE/WORD WHICH YOU HAVE [INS]-MARKED} => 22 175 B9-POP )) (( } TO SEARCH FOR. THE TEXT SCAN/REPL IS NOW IN MODE:} => 22 200 B9-POP )) (( B9-CASE-SCAN => VISDANCE (MATCHED (( }>>>>UP/LCASE-STRICT} => 640 200 B9-POP )) )(OTHER (( }>>>>UP/LCASE-LIBERAL} => 640 200 B9-POP )) MATCHED) )) (( } CLICK CTR-U DURING ORDINARY TEXT VIEWING MODE TO SWITCH BETWEEN} => 22 225 B9-POP )) (( } HAVING SCAN/REPL CASE SENSITIVE OR MATCHING ON BOTH CASES.} => 22 250 B9-POP )) (( } TEXT TO MATCH FOR: (OR ENTER FOR FIRST LINE OF ANY RECENT [INS] CLIP)} => 22 275 B9-POP )) (( } ==>} => 22 300 B9-POP )) (( 70 120 300 B9-READLN => LENGTH => ISBASIS (MATCHED (( RM )) (( B9-REQUEST-CLIPBOARD-FIRST-LINE ; )) MATCHED) )) (( ; => TOSTANDARDSPACE ; )) (( ; => LENGTH => ISBASIS (MATCHED (( RM )) (( GOFORWARD4 )) MATCHED) )) (( CLS )) (( B9-CASE-SCAN => VISDANCE (MATCHED (( ; B9-SCAN-ARRAY >>> ; STR>EXISTING-ARRAY )) (( }B9-SCAN-ACTION} => ? B9-RECENT-SCAN-REPL-WARP < UPCM ; B9-SCAN-ARRAY >>> ; STR>EXISTING-ARRAY )) (( }B9-SCAN-ACTION-UPC} => ? B9-RECENT-SCAN-REPL-WARP <>> ; B9-WORK-SPACE >>> => GM => A (MATCHED (( ; => ASCII => LPCM => GETASCII ; N1 ; B9-LINE-NUM >>> ; B9-WORK-SPACE >>> => PM )) MATCHED) )) COUNTUP) )) (( B9-REFRESH )) )) OK) (LET B9-FUNF5 BE (( )) (( (( B9-MAX-LINE-USED >>> ; B9-LINE-NUM >>> => INC => INC => INTGREATER => NOT (MATCHED (( CLS )) (( }HI LOVELY BENIGN INTERACTOR! FOR ESSENCE NUMBER REASONS,} ; 50 ; 50 => B9-POP )) (( }THIS EDITOR IS A VERY CARE-TAKING ABOUT E V E R Y LIMIT!!!} ; 50 ; 100 => B9-POP )) (( }HAVE A COUPLE LINES (EG, BLANK) AFTER THE INSERTION POINT.} ; 50 ; 150 => B9-POP )) (( }THEN TRY AGAIN! ALWAYS REMEMBER, B9 IS HERE TO HELP YOU} ; 50 ; 200 => B9-POP )) (( 300 ; 250 => B9-ENTERPLS )) (( CLS )) (( B9-REFRESH )) (( EXIT )) MATCHED) )) (( B9-LINE-NUM >>> => INC => B9-MAX-LINE-USED-AT-LEAST-THIS )) (( B9-FUNV-ARROW )) (( B9-LINE-NUM >>> => INC => B9-MAX-LINE-USED-AT-LEAST-THIS )) (( B9-FUNV-ARROW )) (( B9-LINE-NUM >>> => INC => B9-MAX-LINE-USED-AT-LEAST-THIS )) (( B9-FUNV-ARROW )) (( B9-FUN^-ARROW )) (( B9-FUN^-ARROW )) (( B9-FUN^-ARROW )) (( B9-MARKING-ON => VISBASIS (MATCHED (( B9-COMPLETE-MARKING-ON )) (( B9-PUT-IT-GOOD )) (( B9-FILE-SHOULD-BE-STORED => SETDANCE )) (( B9-REFRESH )) )(OTHER (( B9-COMPLETE-MARKING-ON )) (( B9-REFRESH )) MATCHED) )) )) OK) (LET B9-FUNCTR-F5 BE (( )) (( (( 78 (COUNT (( N1 ; B9-LINE-NUM >>> ; B9-WORK-SPACE >>> => GM => A (MATCHED (( ; => ASCII => UPCM => GETASCII ; N1 ; B9-LINE-NUM >>> ; B9-WORK-SPACE >>> => PM )) MATCHED) COUNTUP) )) (( B9-REFRESH )) )) OK) (LET B9-FUNF6 BE (( )) (( (( CLS )) (( } ===info=on=the=fantastic=B9=typewriter! // the present filename:} => 22 25 B9-POP )) (( B9-DOC-NAME => VARSTR> => 850 25 B9-POP )) (( } use ctr with arrows to go faster on a line. WORDWRAP:} => 22 50 B9-POP )) (( B9-WORDWRAPPING => VISDANCE (MATCHED }ON} )(OTHER }[]} MATCHED) => 950 50 B9-POP )) (( } } => 22 75 B9-POP )) (( RO-MODE => VISDANCE (MATCHED (( }READ-ONLY} => 870 75 B9-POP )) )(OTHER MATCHED) )) (( } you can press ctr-d to get up SPC.} => 22 100 B9-POP )) (( } / ctr-f6:rest screen} => 600 100 B9-POP )) (( } for insertion of many blanks or lineshift, use ins and f5 very smart.} => 22 125 B9-POP )) (( } adjust wordwrap and ctr-f6 password in completing lines of this file. } => 22 150 B9-POP )) (( } get a file in by f1, store it by f2. you mark text by clicking 'ins'} => 22 175 B9-POP )) (( } key then moving. arrows, pgu, pgn. ctr-pgu/pgn for start/completion.} => 22 200 B9-POP )) (( } the completion of marking of text is by click 'ins' again. then you can} => 22 225 B9-POP )) (( } put (f5) it. you can put it as many times as you like. Ctr-p shows tight.} => 22 250 B9-POP )) (( } you can also use f5 (after a single press on [INS]) to complete marking.} => 22 275 B9-POP )) (( } then move text position marker to where you want it inserted, press f5.} => 22 300 B9-POP )) (( } in other words: mark text with [ins], move text-marker (max 270 lines),} => 22 325 B9-POP )) (( } [ins] to complete. earlier clipboard is erased next time [ins] is touched!} => 22 350 B9-POP )) (( } (if you are careful to preserve the f5 content, you can open another} => 22 375 B9-POP )) (( } file with f1 and f5 put it in there. you can also specify a new file} => 22 400 B9-POP )) (( } name -- one that you create -- in order to clear the document, with f1.} => 22 425 B9-POP )) (( } then you can paste it in there. } => 22 450 B9-POP )) (( } CTR-W TOGGLES WORDWRAP. watch, wordwrap deletes line right after present!} => 22 475 B9-POP )) (( } save often with f2! use ctr-ins to insert new lines, ctr-del remove many.} => 22 500 B9-POP )) (( } the program will exit if you press 'esc'; or shift to new doc by f1. } => 22 525 B9-POP )) (( } f4, scan, means text search; replace by f3. keytab moves 2 (try shift).} => 22 550 B9-POP )) (( } most recent replace (or scan) can be looped by ctr-l. save first!} => 22 575 B9-POP )) (( } the ctr-f3 puts all of present line to lowercase, ctr-f5 uppercase.} => 22 600 B9-POP )) (( } for flow of good writing try dimming the text -- f9, f10, f11 and f12.} => 22 625 B9-POP )) (( } you can also save with ctr-s.} => 22 725 B9-POP )) (( A-KEY )) (( CLEAR_KEYBUF )) (( B9-REFRESH )) )) OK) ((DATA B9-CURRENT-POS-AT-LINE-END B9-CURRENT-POS-AT-LINE-END => SETDANCE )) (LET B9-ACTIVE-LENGTH-WITH-NONSPACE-CHK BE (( & )) (( (( B9-CURRENT-POS-AT-LINE-END => SETBASIS )) (( # => %LENGTH => ONE => >N8 ; )) (( ; (COUNT (( N1 ; # => %GET => >N3 )) (( N3 => ISBASIS (MATCHED (( N1 => DEC => >N10 )) (( N2 => >N1 )) )(OTHER (( N3 ; 32 => INTGREATER (MATCHED (( N1 B9-CURRENT-POS-AT-LINE-END < => )) (( && )) )) OK) (LET B9-ENSURE-NOZ-EARLIER-ON-THIS-LINE BE (( >N7 >N6 )) (( (( 2 ; N6 => INTGREATER = EXIT === )) (( N7 ; B9-WORK-SPACE >>> %GET => & )) (( N6 (COUNT (( N1 ; # => %GET => ISBASIS (MATCHED (( 32 ; N1 ; # => %PUT )) MATCHED) )) COUNTUP) )) (( && )) )) OK) (LET B9-INSERT-ROOM-FOR-ANOTHER-RIGHT-HERE BE (( )) (( (( B9-LINE-NUM >>> ; B9-MAX-LINE-USED >>> => INTGREATER = B9-LINE-NUM >>> B9-MAX-LINE-USED <>> ; B9-WORK-SPACE >>> => %GET => & )) (( # => B9-ACTIVE-LENGTH-WITH-NONSPACE-CHK => >N5 )) (( B9-LINE-POS >>> => >N8 )) (( N8 ; N5 => INTGREATER (MATCHED (( N8 ; B9-LINE-NUM >>> => B9-ENSURE-NOZ-EARLIER-ON-THIS-LINE )) MATCHED) )) (( B9-PAGE-WIDTH >>> ; N8 => EQN (MATCHED (( 32 ; N8 ; # => %PUT )) (( && )) (( EXIT )) MATCHED) )) (( N5 => INC ; N8 => EQN (MATCHED (( 32 ; N8 ; # => %PUT )) (( && )) (( EXIT )) MATCHED) )) (( N5 ; N8 => SUB => INC => >N9 )) (( N5 => INC ; B9-PAGE-WIDTH >>> => INTGREATER (MATCHED (( DECN9 )) MATCHED) )) (( (( N8 => MUL4 ; # => ADD )) ; (( N8 => INC => MUL4 ; # => ADD )) ; N9 => COPYNUMSHIGH )) (( 32 ; N8 ; # => %PUT )) (( && )) )) OK) (( LOOKSTK )) (LET B9-FUNCTR-F6 BE (( )) (( (( 1 ; 1 ; 1024 ; 768 ; 1 => RECTFILL )) (( KEYNUM ; RM )) (( CLS )) (( B9-REFRESH )) )) OK) (LET CONNECT-TO-GJ-NETWORK BE (( )) (( (( )) )) OK) (LET B9-FUNF7 BE (( )) (( (( CONNECT-TO-GJ-NETWORK )) )) OK) (LET B9-FUNCTR-F7 BE (( )) (( (( B9-SHOW-CODES => FLAGFLIP )) )) OK) (LET B9-FUNF8 BE (( )) (( (( CLS )) (( } HERE ONE CAN HEALTHILY JUMP TO ANYWHERE, WITH REMARKABLE EASE.} => 20 444 B9-POP )) (( } IT'S FUN TO WARP. (HINT: FOR COMPLETING LINE, TYPE A VERY HIGH NUM)} => 20 274 B9-POP )) (( } ENTER FOR FIRST LINE, OR LINE NUMBER:} => 20 304 B9-POP )) (( 6 500 304 B9-READLN => HEAL => >N5 )) (( N5 ; 1 ; B9-MAX-LINE-USED >>> => SET-RANGE => >N5 )) (( N5 B9-LINE-NUM < SETDANCE )) (( B9-LINE-NUM >>> B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN < SETBASIS )) (( B9-F11-MODE => SETBASIS )) (( B9-F12-MODE => SETBASIS )) (( B9-F9-MODE => FLAGFLIP )) (( B9-F9-MODE => VISDANCE (MATCHED (( ^0 ; ^0 ; ^0 ; ^0 => WRITEPAL )) (( ^0 ; ^10 ; ^0 ; ^1 => WRITEPAL )) (( PUTPAL )) )(OTHER (( GJ-COLORS )) MATCHED) )) (( CLS )) (( B9-REFRESH )) )) OK) (LET B9-FUNF10 BE (( )) (( (( B9-F9-MODE => SETDANCE )) (( B9-F11-MODE => SETBASIS )) (( B9-F12-MODE => SETBASIS )) (( B9-F10-MODE => FLAGFLIP )) (( B9-F10-MODE => VISDANCE (MATCHED (( ^0 ; ^0 ; ^0 ; ^0 => WRITEPAL )) (( ^0 ; ^20 ; ^0 ; ^1 => WRITEPAL )) (( PUTPAL )) )(OTHER (( B9-F9-MODE => SETBASIS )) (( GJ-COLORS )) MATCHED) )) (( CLS )) (( B9-REFRESH )) )) OK) (LET B9-FUNF11 BE (( )) (( (( B9-F9-MODE => SETDANCE )) (( B9-F10-MODE => SETBASIS )) (( B9-F12-MODE => SETBASIS )) (( B9-F11-MODE => FLAGFLIP )) (( B9-F11-MODE => VISDANCE (MATCHED (( ^0 ; ^0 ; ^0 ; ^0 => WRITEPAL )) (( ^0 ; ^30 ; ^0 ; ^1 => WRITEPAL )) (( PUTPAL )) )(OTHER (( B9-F9-MODE => SETBASIS )) (( GJ-COLORS )) MATCHED) )) (( CLS )) (( B9-REFRESH )) )) OK) (LET B9-FUNF12 BE (( )) (( (( B9-F9-MODE => SETDANCE )) (( B9-F10-MODE => SETBASIS )) (( B9-F11-MODE => SETBASIS )) (( B9-F12-MODE => FLAGFLIP )) (( B9-F12-MODE => VISDANCE (MATCHED (( ^0 ; ^0 ; ^0 ; ^0 => WRITEPAL )) (( ^0 ; ^191 ; ^0 ; ^1 => WRITEPAL )) (( PUTPAL )) )(OTHER (( B9-F9-MODE => SETBASIS )) (( GJ-COLORS )) MATCHED) )) (( CLS )) (( B9-REFRESH )) )) OK) (LET B9-FUNINSERT BE (( )) (( (( BROWSER-MATRIX >>> => & )) (( B9-CLIPBOARD-FIRST-LINE => VARSTR-SETBASIS )) (( B9-CLIPBOARD-AMOUNT-LINES => SETBASIS )) (( B9-LINE-POS >>> => >N9 )) (( B9-LINE-NUM >>> => >N10 )) (( B9-MARKING-ON => VISBASIS (MATCHED (( N9 ; 1 ; 3 ; # => PM )) (( N10 ; 2 ; 3 ; # => PM )) (( 0 ; 1 ; 4 ; # => PM )) (( 0 ; 2 ; 4 ; # => PM )) (( B9-MARKING-ON => SETDANCE )) )(OTHER (( B9-COMPLETE-MARKING-ON )) MATCHED) )) (( B9-UNDERLINECURRENT-POS )) (( && )) )) OK) (LET B9-FUNDELK BE (( )) (( (( B9-LINE-NUM >>> ; B9-MAX-LINE-USED >>> => INTGREATER = EXIT === )) (( B9-LINE-NUM >>> ; B9-WORK-SPACE >>> => %GET => & )) (( # => ACTIVE-LENGTH => >N5 )) (( B9-LINE-POS >>> => >N8 )) (( N8 ; N5 => INTGREATER = && ; EXIT === )) (( (( N8 => INC => MUL4 ; # => ADD )) ; (( N8 => MUL4 ; # => ADD )) ; (( N5 ; N8 => SUB )) => COPYNUMS )) (( 0 ; N5 ; # => %PUT )) (( B9-REDISPLAY-CURRENT-LINE )) (( B9-FILE-SHOULD-BE-STORED => SETDANCE )) (( && )) )) OK) (LET B9-FUNBP BE (( )) (( (( B9-LINE-POS >>> ; 1 => INTGREATER (MATCHED (( B9-FUN<-ARROW )) (( B9-FUNDELK )) MATCHED) )) )) OK) (LET B9-FUNCTR-INS BE (( )) (( (( B9-LINE-NUM >>> ; B9-MAX-LINE-USED >>> => INTGTOREQUAL = EXIT === )) (( B9-MAX-LINE-USED >>> ; B9-TOP-LINE-NUM >>> => INTGTOREQUAL (MATCHED (( CLS )) (( } AT THE MOMENT, THE AMOUNT OF LINES IN THIS TEXT} => 22 50 B9-POP )) (( } SEEMS TO MATCH THE MAXIMUM AMOUNT OF LINES CURRENTLY} => 22 75 B9-POP )) (( } RESERVED, NAMELY 35000. THE ADVICE, WITH SUCH A GRAND TEXT} => 22 100 B9-POP )) (( } IS TO SEE IF IT IS POSSIBLE TO WORK WITH CONSIDERABLY} => 22 125 B9-POP )) (( } MORE HANDABLE SECTIONS OF IT. OR MANUALLY DELETE LINES} => 22 150 B9-POP )) (( } TO GIVE ROOM FOR MORE. THANK YOU.} => 22 175 B9-POP )) (( 22 200 B9-ENTERPLS )) (( CLS )) (( B9-REFRESH )) (( EXIT )) MATCHED) )) (( CLS )) (( } AFTER THE PRESENT LINE, WHICH IS LINE NUMBER} => 22 50 B9-POP )) (( B9-LINE-NUM >>> => 800 50 B9-POP )) (( } DO YOU WANT TO INSERT A CERTAIN NUMBER OF NEW LINES?} => 22 75 B9-POP )) (( } (THIS IS THE CTR-INS KEY; THE CONVERSE IS CTR-DEL KEY.)} => 22 100 B9-POP )) (( } =========> PLEASE STORE OFTEN UNDER NEW NAMES WHEN BIG CHANGES} => 22 125 B9-POP )) (( } =========> LARGER NUMBERS THAN 270 AUTOMATICALLY CORRECTED } => 22 150 B9-POP )) (( } =========> LINES ARE CREATED AFTER THE PRESENT LINE } => 22 175 B9-POP )) (( } vvvvv} => 22 200 B9-POP )) (( } HOW MANY LINES INSERT HERE (MAX 270)? (ENTER=GO BACK)} => 22 225 B9-POP )) (( CLEAR_KEYBUF )) (( 3 900 250 B9-READLN => HEAL => >N1 )) (( CLEAR_KEYBUF )) (( N1 => ISBASIS = GOFORWARD4 === )) (( N1 ; 1 ; 270 => SET-RANGE => >N1 )) (( B9-MAX-LINE-USED >>> ; N1 => ADD ; B9-TOP-LINE-NUM >>> => INTGREATER (MATCHED (( } THIS WOULD RESULT IN A TEXT BIGGER THAN 35000 LINES.} => 22 300 B9-POP )) (( } TRY WITH A SMALLER NUMBER. CONSIDER WORKING WITH A PORTION} => 22 325 B9-POP )) (( } OF THE TEXT AT A TIME. THANK YOU.} => 22 350 B9-POP )) (( 22 375 B9-ENTERPLS )) (( B9-REFRESH )) (( EXIT )) MATCHED) )) (( N1 => ISPRO (MATCHED (( B9-LINE-NUM >>> ; N1 => B9-NEW-LINES )) (( B9-LINE-POS => SETDANCE )) (( B9-LINE-NUM >>> B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN < SETDANCE )) (( GOLABEL4: )) (( B9-REFRESH )) )) OK) (LET B9-RM-LINES BE (( >N7 >N6 )) (( (( N6 ; B9-MAX-LINE-USED >>> => INTGREATER = EXIT === )) (( B9-WORK-SPACE >>> => & )) (( (( N6 ; N7 => ADD => DEC )) ; B9-MAX-LINE-USED >>> => INTGREATER (MATCHED (( B9-MAX-LINE-USED >>> ; N6 => SUB => INC => >N7 )) MATCHED) )) (( N6 ; N7 => ADD => >N3 )) (( B9-MAX-LINE-USED >>> ; N3 => SUB => INC => >N4 )) (( (( N3 => MUL4 ; # => ADD )) ; (( N6 => MUL4 ; # => ADD )) ; N4 => COPYNUMS )) (( N7 => SG ; B9-MAX-LINE-USED => ADDVAR )) (( N7 (COUNT (( B9-PAGE-WIDTH >>> => INC => %MAKE ; (( B9-MAX-LINE-USED >>> ; N1 => ADD )) ; # => %PUT )) COUNTUP) )) (( && )) )) OK) (LET B9-FUNCTR-DELK BE (( )) (( (( B9-LINE-NUM >>> ; B9-MAX-LINE-USED >>> => INTGREATER = EXIT === )) (( CLS )) (( } CTR-DEL KEY IS PRESSED.} => 22 125 B9-POP )) (( } DELETE THE PRESENT LINE, WHICH IS LINE NUMBER} => 22 150 B9-POP )) (( B9-LINE-NUM >>> => 800 150 B9-POP )) (( } AND A CERTAIN NUMBER OF ADDITIONAL LINES? } => 22 175 B9-POP )) (( } (THE CONVERSE IS CTR-INS KEY, WHICH INSERTS.)} => 22 200 B9-POP )) (( } =========> PLEASE STORE OFTEN UNDER NEW NAMES WHEN BIG CHANGES} => 22 225 B9-POP )) (( } =========> LARGER NUMBERS THAN 270 AUTOMATICALLY CORRECTED } => 22 250 B9-POP )) (( } =========> IF UNCERTAIN, PRESS ENTER THEN SAVE WITH CTR-S } => 22 275 B9-POP )) (( } HOW MANY LINES DELETE HERE (MAX 270)? (ENTER=GO BACK)} 22 300 B9-POP )) (( CLEAR_KEYBUF )) (( 3 900 300 B9-READLN => HEAL => >N1 )) (( CLEAR_KEYBUF )) (( N1 => ISBASIS = GOFORWARD4 === )) (( N1 ; 1 ; 270 => SET-RANGE => >N1 )) (( N1 => ISPRO (MATCHED (( B9-LINE-NUM >>> ; N1 => B9-RM-LINES )) (( B9-LINE-NUM >>> ; B9-MAX-LINE-USED >>> => INTGREATER ; B9-LINE-NUM >>> ; 1 => INTGREATER => AND (MATCHED (( -1 ; B9-LINE-NUM => ADDVAR )) MATCHED) )) (( B9-LINE-POS => SETDANCE )) (( B9-LINE-NUM >>> B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN < SETDANCE )) (( GOLABEL4: )) (( B9-REFRESH )) )) OK) (LET B9-FUNENDK BE (( )) (( (( B9-UN-UNDERLINECURRENT-POS )) (( B9-PAGE-WIDTH >>> ; B9-LINE-POS <>> ; B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> => ADD ; 1 ; B9-MAX-LINE-USED >>> => SET-RANGE B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN <>> ; B9-MAX-LINE-USED >>> => EQN (MATCHED (( B9-PAGE-LENGTH >>> => DEC => SG ; B9-MAX-LINE-USED >>> => ADD ; 1 ; B9-MAX-LINE-USED >>> => SET-RANGE B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN <>> B9-LINE-NUM < SETDANCE )) (( B9-EDIT-TOP-LEFT )) (( B9-REDISPLAY-ALL-TEXT-HERE )) (( B9-UNDERLINECURRENT-POS )) )) OK) (LET B9-FUNCTR-P BE (( )) (( (( CLS )) (( }AMOUNT OF PAGES TO VIEW TIGHTER: } ; 14 ; 415 => B9-POP )) (( 5 ; 700 ; 415 => B9-READLN => HEAL => >N7 )) (( N6 => ISBASIS = B9-REFRESH ; EXIT === )) (( CLS )) (( VLOTS )) (( N7 (COUNT (( CLS )) (( B9-PR-REDISPLAY-CURRENT-PAGE )) (( A-KEY )) (( B9-LINE-NUM >>> => >N5 )) (( 29 ; B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> => ADD ; 1 ; B9-MAX-LINE-USED >>> => SET-RANGE B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN <>> B9-LINE-NUM < SETDANCE )) (( B9-LINE-NUM >>> ; N5 => INTGREATER => NOT (MATCHED (( RMS ; RMS ; GOFORWARD4 )) MATCHED) )) COUNTUP) )) (( GOLABEL4: )) (( VFREE )) (( B9-REFRESH )) )) OK) (LET B9-FUNPGU BE (( )) (( (( B9-UN-UNDERLINECURRENT-POS )) (( B9-STD-FRAME )) (( B9-PAGE-LENGTH >>> => SG ; B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> => ADD ; 1 ; B9-MAX-LINE-USED >>> => SET-RANGE B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN <>> B9-LINE-NUM < SETDANCE )) (( B9-EDIT-TOP-LEFT )) (( B9-REDISPLAY-ALL-TEXT-HERE )) (( B9-UNDERLINECURRENT-POS )) )) OK) (LET B9-FUNHOME BE (( )) (( (( B9-UN-UNDERLINECURRENT-POS )) (( B9-LINE-POS => SETDANCE )) (( B9-EDIT-LEFTMOST )) (( B9-UNDERLINECURRENT-POS )) )) OK) (LET B9-FUNCTR-PGU BE (( )) (( (( B9-UN-UNDERLINECURRENT-POS )) (( B9-STD-FRAME )) (( B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN => SETDANCE )) (( B9-LINE-NUM => SETDANCE )) (( B9-LINE-POS => SETDANCE )) (( B9-EDIT-TOP-LEFT )) (( B9-REDISPLAY-ALL-TEXT-HERE )) (( B9-UNDERLINECURRENT-POS )) )) OK) (LET B9-FUNCTR-PGN BE (( )) (( (( B9-UN-UNDERLINECURRENT-POS )) (( B9-STD-FRAME )) (( B9-PAGE-LENGTH >>> => DEC => SG ; B9-MAX-LINE-USED >>> => ADD ; 1 ; B9-MAX-LINE-USED >>> => SET-RANGE B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN <>> B9-LINE-NUM < SETDANCE )) (( B9-EDIT-TOP-LEFT )) (( B9-REDISPLAY-ALL-TEXT-HERE )) (( B9-UNDERLINECURRENT-POS )) )) OK) ((DATA B9-FKEYNUM )) ((DATA B9-FKEYCTR )) ((DATA B9-FKEYSHI )) (LET B9-FUN-KEYS BE (( )) (( (( B9-FKEYNUM >>> => >N1 )) (( B9-FKEYCTR >>> => >N2 )) (( N1 ; FUNC-KEY-HOME >>> => EQN = B9-FUNHOME == N1 ; 83 => EQN N2 => ISDANCE AND = B9-FUNCTR>-ARROW == N1 ; 82 => EQN N2 => ISDANCE AND = B9-FUNCTR<-ARROW == N1 ; 85 => EQN = B9-FUNV-ARROW == N1 ; 82 => EQN = B9-FUN<-ARROW == N1 ; 84 => EQN = B9-FUN^-ARROW == N1 ; 83 => EQN = B9-FUN>-ARROW == N1 ; FUNC-KEY-F1 >>> => EQN = B9-FUNF1 == N1 ; FUNC-KEY-F2 >>> => EQN = B9-FUNF2 == N1 ; FUNC-KEY-F3 >>> => EQN N2 => ISDANCE AND = B9-FUNCTR-F3 == N1 ; FUNC-KEY-F3 >>> => EQN = B9-FUNF3 == N1 ; FUNC-KEY-F4 >>> => EQN = B9-FUNF4 == N1 ; FUNC-KEY-F5 >>> => EQN N2 => ISDANCE AND = B9-FUNCTR-F5 == N1 ; FUNC-KEY-F5 >>> => EQN = B9-FUNF5 == N1 ; FUNC-KEY-F6 >>> => EQN N2 => ISDANCE AND = B9-FUNCTR-F6 == N1 ; FUNC-KEY-F6 >>> => EQN = B9-FUNF6 == N1 ; FUNC-KEY-F7 >>> => EQN N2 => ISDANCE AND = B9-FUNCTR-F7 == N1 ; FUNC-KEY-F7 >>> => EQN = B9-FUNF7 == N1 ; FUNC-KEY-F8 >>> => EQN = B9-FUNF8 == N1 ; FUNC-KEY-F9 >>> => EQN = B9-FUNF9 == N1 ; FUNC-KEY-F10 >>> => EQN = B9-FUNF10 == N1 ; FUNC-KEY-F11 >>> => EQN = B9-FUNF11 == N1 ; FUNC-KEY-F12 >>> => EQN = B9-FUNF12 == N1 ; FUNC-KEY-INS >>> => EQN N2 => ISDANCE AND = B9-FUNCTR-INS == N1 ; FUNC-KEY-DEL >>> => EQN N2 => ISDANCE AND = B9-FUNCTR-DELK == N1 ; FUNC-KEY-INS >>> => EQN = B9-FUNINSERT == N1 ; FUNC-KEY-DEL >>> => EQN = B9-FUNDELK == N1 ; FUNC-KEY-END >>> => EQN = B9-FUNENDK == N1 ; FUNC-KEY-PGUP >>> => EQN N2 => ISDANCE AND = B9-FUNCTR-PGU == N1 ; FUNC-KEY-PGDN >>> => EQN N2 => ISDANCE AND = B9-FUNCTR-PGN == N1 ; FUNC-KEY-PGDN >>> => EQN = B9-FUNPGN == N1 ; FUNC-KEY-PGUP >>> => EQN = B9-FUNPGU === === === === === === === === === === === === === === === === === === === === === === === === === === === === === === === === )) )) OK) (( LOOKSTK )) (LET B9-ACTUAL-WORD-OVER-TO-NEXT-LINE BE (( )) (( (( B9-WORK-SPACE >>> => & )) (( B9-LINE-NUM >>> => >N10 )) (( B9-FUNV-ARROW )) (( B9-EDIT-RANGE-CONTROL )) (( B9-FUNHOME )) (( B9-UN-UNDERLINECURRENT-POS )) (( B9-LINE-NUM >>> ; N10 => EQN = && ; EXIT === )) (( N10 ; # => %GET => >N9 )) (( B9-LINE-NUM >>> ; # => %GET => >N11 )) (( N9 => ACTIVE-LENGTH => >N4 )) (( N4 => ISBASIS = GOFORWARD3 === )) (( N4 ; WORDWRAPPING-WHERE >>> => DEC => SET-MAX => >N4 )) (( N4 ; N9 => SEGMENT-FIND-THIS-WORD-START => >N3 )) (( 2 ; N3 => INTGREATER = GOFORWARD4 === )) (( N4 ; N3 => SUB => INC => >N5 )) (( (( N9 ; N3 => MUL4 => ADD )) ; (( N11 => INC4 )) ; N5 => COPYNUMS )) (( N5 => INC ; N11 => NOZ-ONLY-BEFORE-N )) (( N3 ; N9 => NOZ-ONLY-BEFORE-N )) (( N5 ; B9-LINE-POS => ADDVAR )) (( N5 ; B9-EDIT-X => ADDVAR )) (( B9-EDIT-RANGE-CONTROL )) (( GOLABEL3: )) (( GOLABEL4: )) (( B9-REFRESH )) (( && )) )) OK) (LET B9-TYPEWRITER-NORMAL BE (( )) (( (( GOLABEL4: )) (( KEYNUM => >N1 )) (( FKEYNUM B9-FKEYNUM < Y-TO-1 B9-FKEYCTR < Y-TO-1 B9-FKEYSHI < WITH (MATCHED (( B9-UN-UNDERLINECURRENT-POS )) (( B9-LINE-NUM >>> => B9-MAX-LINE-USED-AT-LEAST-THIS )) (( B9-FILE-SHOULD-BE-STORED => SETDANCE )) (( B9-INSERT-ROOM-FOR-ANOTHER-RIGHT-HERE )) (( N1 ; B9-LINE-POS >>> ; B9-LINE-NUM >>> ; B9-WORK-SPACE >>> => PM )) (( B9-LINE-NUM ; B9-MAX-LINE-USED => INCREASE-VAR-IF-THIS-IS-HIGHER )) (( B9-PAGE-WIDTH >>> ; B9-LINE-POS >>> => INTGREATER (MATCHED (( B9-EDIT-X => INCVAR )) (( B9-LINE-POS => INCVAR )) MATCHED) )) (( B9-EDIT-RANGE-CONTROL )) (( B9-LINE-NUM >>> => INC => B9-MAX-LINE-USED-AT-LEAST-THIS )) (( B9-LINE-POS >>> => DEC ; B9-CURRENT-POS-AT-LINE-END >>> => INTGREATER (MATCHED (( N1 => B9-DISPLAY-THIS-CHAR-AT-CURRENT-LINE )) (( B9-UNDERLINECURRENT-POS )) )(OTHER (( B9-REDISPLAY-CURRENT-LINE )) MATCHED) )) (( (( B9-LINE-POS >>> ; WORDWRAPPING-WHERE >>> => INTGTOREQUAL )) ; (( B9-WORDWRAPPING => VISDANCE )) => AND ; (( 35000 ; B9-LINE-NUM >>> => INTGREATER )) => AND (MATCHED (( B9-ACTUAL-WORD-OVER-TO-NEXT-LINE )) (( B9-UNDERLINECURRENT-POS )) MATCHED) )) (( B9-LINE-NUM >>> => INC => B9-MAX-LINE-USED-AT-LEAST-THIS )) )(OTHER (( N1 ; KEY-ENTER >>> => EQN (MATCHED (( B9-LINE-NUM >>> => INC => B9-MAX-LINE-USED-AT-LEAST-THIS )) (( B9-FUNV-ARROW )) (( B9-UN-UNDERLINECURRENT-POS )) (( B9-FILE-SHOULD-BE-STORED => SETDANCE )) (( B9-EDIT-LEFTMOST )) (( B9-LINE-POS => SETDANCE )) (( B9-UNDERLINECURRENT-POS )) (( B9-UPDATE-LINE-POS )) )(OTHER (( N1 ; KEY-ESC >>> => EQN = EXIT === )) (( 2 ; N1 => INTGTOREQUAL = B9-FUN-KEYS == N1 ; CTRL-I >>> => EQN B9-FKEYSHI => VISDANCE AND = B9-FUNSHIFT-IND == N1 ; CTRL-I >>> => EQN = B9-FUNCTR-I == N1 ; 20 => EQN = B9-FUNSHIFT-IND == N1 ; 8 => EQN = B9-FUNBP == N1 ; 21 => EQN = B9-FUNCTR-U == N1 ; 4 => EQN = }SPC-RUN} => ? => H ; CLS ; B9-STD-FRAME ; B9-REDISPLAY-ALL-TEXT-HERE ; B9-UNDERLINECURRENT-POS == N1 ; 22 => EQN = B9-FUNF5 == N1 ; 23 => EQN = B9-FUNCTR-W == N1 ; 12 => EQN = B9-FUNCTR-L == N1 ; 16 => EQN = B9-FUNCTR-P == N1 ; 3 => EQN = B9-FUNINSERT == N1 ; 7 => EQN = B9-FUN^-ARROW == N1 ; 11 => EQN = B9-FUN>-ARROW == N1 ; 26 => EQN = B9-FUN<-ARROW == N1 ; 24 => EQN = B9-FUNPGN == N1 ; 14 => EQN = B9-FUNCTR-PGN == N1 ; 17 => EQN = B9-FUNPGU == N1 ; 15 => EQN = B9-FUNF1 == N1 ; 19 => EQN = B9-FUNF2 == N1 ; 18 => EQN = B9-FUNCTR-DELK == N1 ; 25 => EQN = B9-FUNCTR-INS == N1 ; 6 => EQN = B9-FUNF4 == N1 ; 5 => EQN = B9-FUNF3 == N1 ; 10 => EQN = B9-FUNF8 === === === === === === === === === === === === === === === === === === === === === === === === === )) MATCHED) )) MATCHED) )) (( GOUP4 )) )) OK) (( LOOKSTK )) (LET CLEANSE-STACKS-PRETTY-MUCH BE (( )) (( (( RMV RMV RMV RMV RMV RMV RMV RMV )) (( RMV RMV RMV RMV RMV RMV RMV RMV )) (( RMV RMV RMV RMV RMV RMV RMV RMV )) (( RMV RMV RMV RMV RMV RMV RMV RMV )) (( RMV RMV RMV RMV RMV RMV RMV RMV )) (( RMV RMV RMV RMV RMV RMV RMV RMV )) (( RMR RMR RMR RMR RMR RMR RMR RMR )) (( RMR RMR RMR RMR RMR RMR RMR RMR )) (( RM RM RM RM RM RM RM RM )) (( RM RM RM RM RM RM RM RM )) (( RM RM RM RM RM RM RM RM )) (( RM RM RM RM RM RM RM RM )) OK) )) (LET B9-INIT-VARS BE (( )) (( (( B9-CLIPBOARD-AMOUNT-LINES => SETBASIS )) (( 3 => %MAKE ; B9-REFRESH-DANCERS-WITHIN < ? ; 1 ; B9-REFRESH-DANCERS-WITHIN >>> => %PUT )) (( }B9-REDISPLAY-ALL-TEXT-HERE} => ? ; 2 ; B9-REFRESH-DANCERS-WITHIN >>> => %PUT )) (( }B9-UNDERLINECURRENT-POS} => ? ; 3 ; B9-REFRESH-DANCERS-WITHIN >>> => %PUT )) (( B9-RECENT-SCAN-REPL-WARP => SETBASIS )) (( 79 => MAKEBL ; B9-CLIPBOARD-FIRST-LINE => >VARSTR )) (( 0 ; B9-CLIPBOARD-FIRST-LINE => VARSTR-SETLEN )) (( 0 ; 1 ; 3 ; BROWSER-MATRIX >>> => PM )) (( 0 ; 2 ; 3 ; BROWSER-MATRIX >>> => PM )) (( 0 ; 1 ; 4 ; BROWSER-MATRIX >>> => PM )) (( 0 ; 2 ; 4 ; BROWSER-MATRIX >>> => PM )) (( 300 => %MAKE B9-SCAN-ARRAY < %MAKE B9-REPL-ARRAY < SETDANCE )) (( B9-EDIT-TOP-LEFT )) (( B9-LINE-NUM => SETDANCE )) (( B9-LINE-POS => SETDANCE )) (( B9-MARKING-ON => SETBASIS )) (( }DOC-NAME} ; B9-DOC-NAME => >VARSTR )) (( B9-MAX-LINE-USED => SETDANCE )) (( B9-FILE-SHOULD-BE-STORED => SETBASIS )) (( B9-CASE-SCAN => SETBASIS )) )) OK) (LET B9-START BE (( )) (( (( CLS )) } LISA GJ2 FIC3 IS PROUD TO PRESENT ITS ABSOLUTELY NAKED BENIGN B9 EDITOR!} ; => 22 50 B9-POP )) (( B9-INIT-VARS )) (( B9-FILE-TO-START-SHOWING => VARSTR> ; B9-DOC-NAME => >VARSTR )) (( } ***B9 ALLOTING THE RAM IT WANTS***} => 22 75 B9-POP )) (( 79 ; B9-TOP-CLIPBOARD-NUM >>> 5 ADD => RAM-PM B9-CLIPBOARD < 22 100 B9-POP )) (( 79 ; B9-TOP-LINE-NUM >>> 5 ADD => RAM-PM B9-WORK-SPACE < 22 125 B9-POP )) (( B9-FETCH-FILE )) (( } ***} => 22 150 B9-POP )) (( B9-LINE-NUM => SETDANCE )) (( B9-LINE-POS => SETDANCE )) (( B9-TOP-OF-PAGE-LINE-NUMBER-SHOWN => SETDANCE )) (( B9-EDIT-TOP-LEFT )) (( CLEAR_KEYBUF )) (( B9-STD-FRAME )) (( B9-REDISPLAY-ALL-TEXT-HERE )) (( B9-UNDERLINECURRENT-POS )) (( B9-TYPEWRITER-NORMAL )) (( B9-MAYBE-STORE-FILE )) )) OK) (LET B9 BE (( ; )) (( (( IS-ANYTHING-ON-MAIN-STACK => NOT (MATCHED (( }NEW-TEXT} ; )) MATCHED) )) (( ; => TOSTANDARDSPACE => RMBL => UPCM B9-FILE-TO-START-SHOWING => >VARSTR )) (( CLEANSE-STACKS-PRETTY-MUCH )) (( GJ-ON )) (( B9-START )) (( GJ-DONE )) )) OK) (( LOOKSTK )) (LET LAB-LOADER BE (( )) (( (( 1 ; 550 ; 1024 ; 780 ; 0 => FT RECTFILL FEET )) (( }LOAD .TXT MODEL (OR ENTER TO GO BACK AGAIN)} ; 50 ; 700 => B9-POP )) (( 8 ; 750 ; 700 => B9-READLN ; )) (( 1 ; 550 ; 1024 ; 780 ; CD-SURROUND >>> => FT RECTFILL FEET )) (( ; => RMBL => UPCM => LENGTH => ISPRO (MATCHED (( LETS-TRAVEL )) (( READY-BOTH-FOR-LAB )) (( ANIMATION-TRIX >>> >N5 )) (( ; KEEPDIGITSLETTERS => RMBL => UPCM ; }.TXT} CONCAT ; N5 => FILENUM2PM ; RM )) (( CARTOON-HEIGHT >>> (COUNT (( CARTOON-WIDTH >>> (COUNT (( N1 ; N3 ; N9 => GM ; N1 ; N3 ; V1 => PM )) COUNTUP) COUNTUP) )) )(OTHER (( ; RM )) MATCHED) )) )) OK) (LET LAB-SAVE-MODELS BE (( )) (( (( 1 ; 550 ; 1024 ; 780 ; 0 => FT RECTFILL FEET )) (( }SAVE YOUR ART WITH WHAT FILENAME?} ; 50 ; 700 => B9-POP )) (( 8 ; 750 ; 700 => B9-READLN ; )) (( 1 ; 550 ; 1024 ; 780 ; CD-SURROUND >>> => FT RECTFILL FEET )) (( ; => RMBL => UPCM => LENGTH => ISPRO (MATCHED (( KEEPDIGITSLETTERS => RMBL => UPCM ; }.TXT} => CONCAT ; V1 => PM2FILENUM ; RM )) (( 0 ; 1 ; 1 ; V1 => PM )) )(OTHER (( RM ; )) MATCHED) )) )) OK) (LET LAB-PERFORM BE (( )) (( (( VLOTS )) (( 550 => >N6 ; 150 => >N7 )) (( 82 => >N8 ; 132 => >N9 )) (( ANIMATION-CARTOON >>> => TOV1 )) (( N6 N7 N8 N9 => LAB-CLR )) (( 1 => TOV4 )) (( GOLABEL1: (( MOUSEXY => >N2 >N1 )) (( N1 => UP-TO-EVEN => >N1 )) (( N2 => UP-TO-EVEN => >N2 )) (( N1 ; N8 INC INC ; ONE 392 ADD => WITH ; N2 ; N9 INC INC ; ONE 392 ADD => WITH => AND (MATCHED (( MOUSECLICK => Y-TO-1 => >N5 )) (( MOUSECLICKR => Y-TO-1 => >N11 )) (( N5 ISDANCE ; N11 ISDANCE => ORR (MATCHED (( N1 ; N8 => SUB => DIV2 => >N3 )) (( N2 ; N9 => SUB => DIV2 => >N4 )) (( N5 ISDANCE = 1 == 0 === ; N3 ; N4 => THREE ; V1 => PM ; ANIMATION-EXTRA >>> ADD ; ANIMATION-TRIX >>> PM )) (( N5 ISDANCE = 1 == 0 === ; N3 INC ; N4 => THREE ; V1 => PM ; ANIMATION-EXTRA >>> ADD ; ANIMATION-TRIX >>> PM )) (( N3 ; N4 ; N8 ; N9 => UPDATE-IN-SKETCH )) (( N3 ; N4 ; N6 ; N7 => UPDATE-IN-CARTOON )) (( N3 ; N4 ; N6 ; CARTOON-WIDTH >>> ONE 10 DIV ADD ADD ; N7 => UPDATE-IN-RENDER-MAYBE )) (( INCN3 )) (( N3 ; N4 ; N8 ; N9 => UPDATE-IN-SKETCH )) (( N3 ; N4 ; N6 ; N7 => UPDATE-IN-CARTOON )) (( N3 ; N4 ; N6 ; CARTOON-WIDTH >>> ONE 10 DIV ADD ADD ; N7 => UPDATE-IN-RENDER-MAYBE )) MATCHED) )) MATCHED) )) (( KEYTOUCH (MATCHED (( NEWKEY )) (( V9 0 EQN = (( V8 FUNC-KEY-F1 >>> EQN = (( 0 => TOV4 )) (( CLEAR_KEYBUF )) == V8 FUNC-KEY-F3 >>> EQN = == V8 FUNC-KEY-F6 >>> EQN = == V8 FUNC-KEY-F7 >>> EQN = (( N6 N7 N8 N9 => LAB-CLR )) (( READY-BOTH-FOR-LAB )) (( N8 ; N9 => DISPLAY-SKETCH-AGAIN-FASTER )) (( N6 ; N7 => DISPLAY-CARTOON-AGAIN-FASTER )) (( N6 CARTOON-WIDTH >>> ONE 10 DIV ADD ADD ; N7 => FRESH-RENDER-FASTER )) (( CLEAR_KEYBUF )) == V8 FUNC-KEY-F11 >>> EQN = (( N6 N7 N8 N9 => LAB-CLR )) (( LAB-LOADER )) (( N8 ; N9 => DISPLAY-SKETCH-AGAIN-FASTER )) (( N6 ; N7 => DISPLAY-CARTOON-AGAIN-FASTER )) (( N6 CARTOON-WIDTH >>> ONE 10 DIV ADD ADD ; N7 => FRESH-RENDER-FASTER )) (( CLEAR_KEYBUF )) == V8 FUNC-KEY-F12 >>> EQN = (( N6 N7 N8 N9 => LAB-CLR )) (( READY-BOTH-FOR-LAB )) (( LETS-TRAVEL )) === === === === === === )) == V9 KEY-ENTER >>> EQN = (( ANIMATION-TRIX >>> >>V )) (( LAB-SAVE-MODELS )) (( V>> )) (( CLEAR_KEYBUF )) === === )) MATCHED) )) (( V4 => ISDANCE = GOUP1 === )) )) (( VFREE )) )) OK) (LET LAB BE (( )) (( (( L )) (( }THE LISA CARTOON DIMENSION LAB} => POP )) (( }THIS IS FOR ART SKETCHING ON THE PC.} => POP )) (( }THE PROGRAM SEE CAN CONVERT TO .GJP.} => POP )) (( }TO FACILIATE THE DRAWING PROCESS, SKETCH IS} => POP )) (( }SHOWN THREE TIMES -- YOU DRAW IT TWICE THE SIZE.} => POP )) (( }YOU SKETCH WITH CLICKS ON MOUSE (AND RIGHT-CLICKS)} => POP )) (( }IN LEFTMOST, LARGEST AREA. REMEMBER F1 QUITS,} => POP )) (( }AND USE ENTER TO SAVE. TO FOCUS MAXIMALLY} => POP )) (( }ON THE PC AS A CANVAS, THERE IS NO TEXT SHOWN.} => POP )) (( }THE FULL AND SIMPLE SET OF COMMANDS ARE HERE:} => POP )) (( }(THIS IS GOOD AS BACKGROUND FOR SPRING BI PAINTINGS.)} => POP )) (( }F11:LOAD F12:CLEAR F1:QUIT} => POP )) (( }ENTER:SAVE} => POP )) (( }MEMORIZE THESE AND PRESS ENTER TO GO ON.} => POP )) (( ENTERPLS )) (( GJ-ON )) (( ANIMATION-TRIX >>> => NOZ (MATCHED (( ANIMATION-TRIX >>> => RELEASE-MATRIX )) MATCHED) )) (( 150 CD-AMOUNTS <>> ; CARTOON-HEIGHT >>> => MUL ANIMATION-TRIX-H <>> ; CD-AMOUNTS >>> => INC ; CARTOON-HEIGHT >>> => MUL => RAM-PM ANIMATION-TRIX <>> => FT RECTFILL FEET )) (( LETS-TRAVEL )) (( LAB-PERFORM )) (( GJ-DONE )) )) OK) (LET IMGS BE (( )) (( (( GJ-ON )) (( FT )) (( }IMGS: here you can quickly view Lisa's .GJP images,} 100 ; 30 => B9-POP )) (( }when these have a common initial name,} 100 ; 60 => B9-POP )) (( }with numbers 1..n after it (e.g. SAMPLE1 etc).} 100 ; 90 => B9-POP )) (( }ESC new name, ENTER next} 100 ; 120 => B9-POP )) (( 200 ; 200 => RAM-PM => & )) (( 480 ; 180 ; 719 ; 423 ; 1 => RECTFILL )) (( }} ; )) (( GOLABEL1: )) (( FT )) (( }Initial name: } ; 100 ; 550 => B9-POP )) (( ; => RM )) (( 30 ; 300 ; 550 => B9-READLN => TOSTANDARDSPACE => RMBL => UPCM ; )) (( ; => LENGTH => ISBASIS = RM ; && ; GJ-DONE EXIT === )) (( N1 ; 300 ; 600 => B9-POP )) (( 1 >N1 )) (( GOLABEL2: (( }Present # is } ; 100 ; 600 => B9-POP )) (( N1 ; 300 ; 600 => B9-POP )) (( } } ; 100 ; 630 => B9-POP )) (( 480 ; 180 ; 719 ; 423 ; 1 => RECTFILL )) (( # => CLEAR-MATRIX )) (( ; => ONE ; N1 ; }.GJP} => CONCAT => CONCAT ; # => GJPFILE2PM ; RM )) (( 500 ; 200 ; # => LISA-PAINT )) (( GOLABEL3: )) (( KEYNUM => >N2 )) (( N2 ; KEY-ESC >>> => EQN (MATCHED (( GOUP1 )) MATCHED) )) (( INCN1 )) (( GOUP2 )) )) OK) (( VARSTRING SEE-DOCNAME }DOC-NAME} ; SEE-DOCNAME => >VARSTR )) ((DATA SEE-DOCUMENT SEE-DOCUMENT => SETBASIS )) ((DATA SEE-CURRENT-IMAGE SEE-CURRENT-IMAGE => SETBASIS )) ((DATA SEE-NEXT-NOTE-LINE SEE-NEXT-NOTE-LINE => SETDANCE )) ((DATA SCRSAVER-FLAG SCRSAVER-FLAG => SETDANCE )) ((DATA SEE-NOTE-FILE 45 ; 7 => RAM-PM SEE-NOTE-FILE < SETBASIS )) (( VARSTRING SEE-CONV-DOC-NAME }} SEE-CONV-DOC-NAME => >VARSTR )) ((DATA SEE-MAX-LINE-NUM SEE-MAX-LINE-NUM => SETBASIS )) ((DATA SEE-TOP-OF-PAGE SEE-TOP-OF-PAGE => SETDANCE )) ((DATA CURVY-CURVES-1 CURVY-CURVES-1 => SETBASIS )) ((DATA CURVY-CURVES-2 )) (LET CURVY-CURVES-MAKER BE (( >N8 >N7 >N6 >N5 >N4 )) (( (( N4 => ISBASIS ; N5 => ISBASIS => ORR = EXIT === )) (( N4 ; CURVY-CURVES-2 >>> ADD ; N5 ; CURVY-CURVES-2 >>> ADD ; (( N6 ; CURVY-CURVES-2 >>> ADD ; N7 ; CURVY-CURVES-2 >>> ADD ; N8 => LINE )) (( N4 ; CURVY-CURVES-2 >>> ADD ; N5 ; CURVY-CURVES-2 >>> ADD ; BRIDGE 2 ADD ; BRIDGE 2 ADD ; 1 => RECTFILL )) (( N6 ; CURVY-CURVES-2 >>> ADD ; N7 ; CURVY-CURVES-2 >>> ADD ; BRIDGE 2 ADD ; BRIDGE 2 ADD ; 1 => RECTFILL )) )) OK) (LET CURVY-CURVES BE (( )) (( (( 11 => >N2 )) (( 0 => >N5 )) (( 11 => >N2 )) (( 11 => >N5 )) (( GOLABEL3: )) (( CLS )) (( ^200 FR GETV CURVY-CURVES-2 < SETBASIS )) (( N1 ; 3 => EQN (MATCHED (( 180 => >N9 )) )(OTHER (( 570 => >N9 )) MATCHED) )) (( ^40 FR GETV 5 ADD (COUNT (( N6 ; N1 => MUL => >N8 )) (( 0 => >N10 )) (( CURVY-CURVES-1 >>> ; )) (( 110 ; N1 ; 14 => MUL => ADD ; N11 )) (( ; BRIDGE CURVY-CURVES-1 < CURVY-CURVES-MAKER )) COUNTUP) )) (( GOLABEL2: )) COUNTUP) )) (( ^0 ; ^10 FR ; ^0 ; ^0 => WRITEPAL )) (( ^0 ; ^32 FR ; ^0 ; ^1 => WRITEPAL )) (( PUTPAL )) (( 3 => SECS )) (( KEYTOUCH => NOT = GOUP3 === )) )) OK) (LET SEE-INIT-VARS BE (( )) (( (( SEE-DOCUMENT => VISBASIS (MATCHED (( CLS )) (( }READYING WORKSPACE IN RAM...} ; 100 ; 350 => B9-POP )) (( 79 ; 37000 => RAM-PM SEE-DOCUMENT < SETBASIS )) (( SEE-CURRENT-IMAGE => VISBASIS (MATCHED (( 200 ; 200 => RAM-PM SEE-CURRENT-IMAGE < RECTFILL )) (( }F8 OPEN F9 SKETCH>GJP F1 EXIT F5 NEXT F6 PREV F11/F12 MANY} ; )) (( SEE-MAX-LINE-NUM >>> ; 1 => INTGREATER (MATCHED (( ; } } => CONCAT ; SEE-MAX-LINE-NUM >>> => CONCAT ; )) (( ; }%} => CONCAT ; SEE-TOP-OF-PAGE >>> => CONCAT ; )) MATCHED) )) (( ; 31 ; 740 => B9-POP )) )) OK) (LET SEE-FETCH-GRAPH-NAME-HERE BE (( >N5 )) (( (( SEE-DOCUMENT >>> => & )) (( N5 ; # => MATR>TEXT ; )) (( ; => LENGTH ; 9 => INTGREATER (MATCHED (( ; 1 ; 9 => SUBSTR => ONE ; }>>>gjp:/:} => TXTEQUAL (MATCHED (( ; RM )) (( ; => RMBL => UPCM => }.GJP} => CONCAT ; )) (( ; SEE-DOCNAME => VARSTR> ; }/} => CONCAT => SWITCH => CONCAT => => )) (( && ; EXIT )) )(OTHER (( ; }>>>gjp:::} => TXTEQUAL (MATCHED (( ; => RMBL => UPCM => }.GJP} => CONCAT => => )) (( && ; EXIT )) )(OTHER (( RM )) MATCHED) )) MATCHED) )) )(OTHER (( RM )) MATCHED) )) (( }} )) (( && )) )) OK) (LET SEE-DISPLAY-PAGE BE (( )) (( (( SEE-DOCUMENT >>> => & )) (( SEE-MAX-LINE-NUM >>> => ISPRO (MATCHED (( 29 (COUNT (( SEE-TOP-OF-PAGE >>> ; N1 => ADD => DEC ; SEE-MAX-LINE-NUM >>> => INTGREATER (MATCHED (( RMS ; RMS )) (( GOFORWARD4 )) MATCHED) )) (( 78 (COUNT (( N1 ; (( SEE-TOP-OF-PAGE >>> ; N3 => ADD => DEC )) ; # => GM => AFFIRM (MATCHED (( ; => ONE ; ; )) (( ; 32 ; 126 => WITH (MATCHED (( ; ONE => ASCII ; (( N1 ; 12 => MUL 14 ADD )) ; (( N3 DEC ; 25 => MUL )) => B9-POP )) MATCHED) )) (( ; => RM )) )(OTHER (( RMS ; RMS )) (( GOFORWARD2 )) MATCHED) )) COUNTUP) )) (( GOLABEL2: )) COUNTUP) )) MATCHED) )) (( GOLABEL4: )) (( && )) )) OK) (LET SEE-DISPLAY-ALSO-PAGE-GRAPHICS BE (( )) (( (( SEE-CURRENT-IMAGE >>> => & )) (( SEE-DOCUMENT >>> => & )) (( 805 ; 1 ; 1024 ; 740 ; 1 => RECTFILL )) (( SEE-MAX-LINE-NUM >>> => ISPRO (MATCHED (( 1 => >N5 )) (( 29 (COUNT (( SEE-TOP-OF-PAGE >>> ; N1 => ADD => DEC ; SEE-MAX-LINE-NUM >>> => INTGREATER (MATCHED (( RMS ; RMS )) (( GOFORWARD4 )) MATCHED) )) (( N1 ; SEE-TOP-OF-PAGE >>> => ADD => DEC => SEE-FETCH-GRAPH-NAME-HERE => LENGTH => ISPRO (MATCHED (( ## => CLEAR-MATRIX )) (( ; ## => GJPFILE2PM ; RM )) (( 4 ; N7 => INTGREATER (MATCHED (( 810 ; 23 ; N7 DEC ; 210 => MUL => ADD ; )) )(OTHER (( 82 ; N7 4 SUB ; 205 => MUL => ADD ; 3 ; )) (( ; => TWO ; BRIDGE 201 ADD ; BRIDGE 201 ADD ; 1 => RECTFILL )) MATCHED) )) (( ; ## => LISA-PAINT )) (( INCN7 )) (( N7 ; 6 => INTGREATER (MATCHED (( RMS ; RMS ; && ; && ; EXIT )) MATCHED) )) )(OTHER (( ; => RM )) MATCHED) )) COUNTUP) )) MATCHED) )) (( GOLABEL4: )) (( && ; && )) )) OK) (LET LABTXT>GJP BE (( ; )) (( (( SEE-CURRENT-IMAGE >>> => & )) (( # => CLEAR-MATRIX )) (( ; => ONE ; }.TXT} => CONCAT ; # => FILENUM2PM ; RM )) (( 200 (COUNT 200 (COUNT (( N1 ; N3 ; # => GM => ISDANCE (MATCHED (( 0 ; N1 ; N3 ; # => PM )) )(OTHER (( 63 ; N1 ; N3 ; # => PM )) MATCHED) )) COUNTUP) COUNTUP) )) (( ; => }.GJP} => CONCAT ; # => PM2GJPFILE ; RM )) (( && )) )) OK) (LET SEE-FETCH-FILE BE (( )) (( (( SEE-DOCNAME => VARSTR> ; }.TXT} => CONCAT => ALREADYFILE => NOT (MATCHED (( } DIDN'T FIND THE FILE. TRY AGAIN WITH NEW FILENAME.} => 22 ; 375 B9-POP )) (( }DOC-NAME} ; SEE-DOCNAME => >VARSTR )) (( 100 ; 400 => B9-ENTERPLS )) (( CLS )) MATCHED) )) (( GOLABEL4: )) (( SEE-DOCNAME => VARSTR> ; )) (( ; => ONE => CALC-AMOUNT-LINES-IN-TXT-OF-ANY-WIDTH SEE-MAX-LINE-NUM < CONCAT ; SEE-DOCUMENT >>> => FILE2PM RM )) (( SEE-DOCUMENT >>> => FIX-BLANK-LINES-IN-FILE )) (( SEE-MAX-LINE-NUM >>> ; SEE-DOCUMENT >>> => FILTER-NON7ASCII-CHARS )) (( SEE-DOCUMENT >>> => ARE-ALL-IN-RIGHTMOST-COLUMN-UNUSED => NOT (MATCHED (( SEE-DOCUMENT >>> => CLEAR-MATRIX )) (( SEE-MAX-LINE-NUM => SETDANCE )) (( CLS )) (( } LOOK, MY DEAR FRIEND, I DON'T KNOW HOW YOU HAVE PRODUCED} => 22 50 B9-POP )) (( } THIS SURELY EMINENT TEXT FILE, BUT I KNOW, FOR FACT, E.G. LINE} => 22 75 B9-POP )) (( ARE-ALL-IN-RIGHTMOST-DATA >>> ; } HAS BEEN PRODUCED BY SOME OTHER EDITOR THAN B9.} => CONCAT => 22 100 B9-POP )) (( } WHAT I AM TRYING TO POINT OUT IS THAT YOU NEED TO RUN STH LIKE} => 22 125 B9-POP )) (( } THE WORDWRAP PROGRAM ON THIS. IT IS FAIRLY STRAIGHTFORWARD.} => 22 150 B9-POP )) (( } DO THAT, AND FIX UP PARAGRAPHS AFTERWARDS, FOR WE MUST HAVE} => 22 175 B9-POP )) (( } MAXIMUM 78 IN CHARACTER LINE LENGTH OF ALL B9 DOCUMENTS.} => 22 200 B9-POP )) (( } GREAT LUCK ON YOUR MISSION. AND WELCOME BACK ON THIS.} => 22 225 B9-POP )) (( } =========> I WILL IMPROVE IN THE FUTURE:} => 22 250 B9-POP )) (( 22 275 B9-YNIN => RM )) (( GOUP4 )) MATCHED) )) (( SEE-TOTAL-POTENTIAL-OF-LOVE )) (( SEE-DISPLAY-PAGE )) (( SEE-DISPLAY-ALSO-PAGE-GRAPHICS )) )) OK) (LET SEE-OPEN-FILE BE (( )) (( (( SEE-TOP-OF-PAGE => SETDANCE )) (( SEE-MAX-LINE-NUM => SETDANCE )) (( SEE-DOCUMENT >>> => CLEAR-MATRIX )) (( CLS )) (( } THE 'SEE' PROGRAM BY A.T. REMEMBER THAT [F3] IS THERE FOR YOU:} => 22 50 B9-POP )) (( } YOU ENTER UP TO 7 LINES, AND OPEN IN EDITOR AS CUTENOTE.TXT.} => 22 75 B9-POP )) (( } TO GO TO BEGINNING OF ANY TEXT, JUST GO BACK HERE AND OPEN ANEW!} => 22 100 B9-POP )) (( } DO YOU WANT TO OPEN A BOOK, NEWPAPER, WHATEVER, PRODUCED} => 22 150 B9-POP )) (( } WITH SOMETHING LIKE THE B9 EDITOR, INTO THIS 'SEE' VIEWER?} => 22 175 B9-POP )) (( } THEN TYPE IN FULL FILENAME, NOT INCLUDING THE .TXT,} => 22 200 B9-POP )) (( } HERE (OR PRESS ENTER FOR FILE "DOC-NAME"): } => 22 225 B9-POP )) (( 8 700 225 B9-READLN => RMBL => LENGTH => ISPRO (MATCHED (( ; => MAKE-SAFE-8-SIZE-FILENAME ; )) )(OTHER (( ; => RM )) (( }DOC-NAME} ; )) MATCHED) )) (( ; SEE-DOCNAME => >VARSTR )) (( } THANKS.} => 22 250 B9-POP )) (( } WILL USE ========>} => 22 275 B9-POP )) (( SEE-DOCNAME => VARSTR> => 400 ; 275 B9-POP )) (( } (BEST FOR 'SEE' STYLE OF TEXTS)} => 22 325 B9-POP )) (( } ATTEMPT TO OPEN?} => 22 350 B9-POP )) (( 220 ; 350 => B9-YNIN (MATCHED (( SEE-FETCH-FILE )) MATCHED) )) )) OK) (LET SEE-GO-TO-NEXT BE (( )) (( (( 5 ; SEE-MAX-LINE-NUM >>> => INTGREATER = EXIT === )) (( SEE-TOP-OF-PAGE >>> ; 29 => ADD ; 1 ; SEE-MAX-LINE-NUM >>> => SET-RANGE => >N5 )) (( N5 ; 29 => DIV ; 29 => MUL => INC SEE-TOP-OF-PAGE <>> => INTGREATER = EXIT === )) (( SEE-TOP-OF-PAGE >>> ; 290 => ADD ; 1 ; SEE-MAX-LINE-NUM >>> => SET-RANGE => >N5 )) (( N5 ; 29 => DIV ; 29 => MUL => INC SEE-TOP-OF-PAGE <>> => INTGREATER = EXIT === )) (( SEE-TOP-OF-PAGE >>> ; 2900 => ADD ; 1 ; SEE-MAX-LINE-NUM >>> => SET-RANGE => >N5 )) (( N5 ; 29 => DIV ; 29 => MUL => INC SEE-TOP-OF-PAGE <>> => INTGREATER = EXIT === )) (( SEE-TOP-OF-PAGE >>> ; 29 => SUB ; 1 ; SEE-MAX-LINE-NUM >>> => SET-RANGE => >N5 )) (( N5 ; 29 => DIV ; 29 => MUL => INC SEE-TOP-OF-PAGE < 22 50 B9-POP )) (( } WITH THE LISA LAB, INTO .GJP?} => 22 75 B9-POP )) (( } THEN TYPE IN FULL FILENAME, NOT INCLUDING THE .TXT,} => 22 100 B9-POP )) (( } HERE: } => 22 125 B9-POP )) (( 8 700 125 B9-READLN => MAKE-SAFE-8-SIZE-FILENAME ; SEE-CONV-DOC-NAME => >VARSTR )) (( } THANKS.} => 22 150 B9-POP )) (( } WILL USE ========>} => 22 175 B9-POP )) (( SEE-CONV-DOC-NAME => VARSTR> => 400 ; 175 B9-POP )) (( } ONLY TRY THIS IF THAT .TXT IS REALLY A SKETCH.} => 22 225 B9-POP )) (( } GO AHEAD?} => 22 250 B9-POP )) (( 220 ; 250 => B9-YNIN (MATCHED (( SEE-CONV-DOC-NAME => VARSTR> ; }.TXT} => CONCAT => ALREADYFILE (MATCHED (( SEE-CONV-DOC-NAME => VARSTR> => LABTXT>GJP )) (( } IF THE SKETCH WAS IN GOOD ORDER, CONVERSION TOOK PLACE!} => 22 ; 275 B9-POP )) )(OTHER (( } DIDN'T FIND THE FILE. TRY AGAIN.} => 22 ; 275 B9-POP )) MATCHED) )) MATCHED) )) (( 100 ; 300 => B9-ENTERPLS )) (( CLS )) (( SEE-TOTAL-POTENTIAL-OF-LOVE )) (( SEE-DISPLAY-PAGE )) (( SEE-DISPLAY-ALSO-PAGE-GRAPHICS )) )) OK) (LET SEE-NOTE-TAKING BE (( )) (( (( 62 => MAKEBL ; 31 ; 740 => B9-POP )) (( 45 ; 31 ; 740 => B9-READLN ; )) (( ; ONE => RMBL => TOLEN => ISPRO (MATCHED ; SEE-NEXT-NOTE-LINE >>> ; SEE-NOTE-FILE >>> => TEXT>MATRIX )) (( SEE-NEXT-NOTE-LINE => INCVAR )) (( SEE-NEXT-NOTE-LINE >>> ; 7 => INTGREATER (MATCHED (( SEE-NEXT-NOTE-LINE => SETDANCE )) MATCHED) )) (( }CUTENOTE.TXT} ; SEE-NOTE-FILE >>> => PM2FILE ; RM )) )(OTHER (( RM )) MATCHED) )) (( SEE-TOTAL-POTENTIAL-OF-LOVE )) (( SEE-DISPLAY-PAGE )) (( SEE-DISPLAY-ALSO-PAGE-GRAPHICS )) )) OK) (LET SEE-RESPOND-TO-KEY BE (( )) (( (( GOLABEL4: )) (( KEYNUM => >N5 )) (( FKEYNUM => >N6 )) (( N6 ; FUNC-KEY-F1 >>> => EQN = SEE-STATUS-FOR-EXIT => SETDANCE == N6 ; FUNC-KEY-F2 >>> => EQN = SCRSAVER-FLAG => FLAGFLIP == N6 ; FUNC-KEY-F3 >>> => EQN = SEE-NOTE-TAKING == N6 ; FUNC-KEY-F5 >>> => EQN = SEE-GO-TO-NEXT == N6 ; FUNC-KEY-F6 >>> => EQN = SEE-PREV == N6 ; FUNC-KEY-F8 >>> => EQN = SEE-OPEN-FILE == N6 ; FUNC-KEY-F9 >>> => EQN = SEE-SKETCH-TO == N6 ; FUNC-KEY-F11 >>> => EQN = SEE-MANY-PAGES-AHEAD == N6 ; FUNC-KEY-F12 >>> => EQN = SEE-VERY-MANY-PAGES-AHEAD == GOUP4 === === === === === )) === === === === )) )) OK) (LET SEE-MAIN-LOOP BE (( )) (( (( }SEEEXAMP} ; SEE-DOCNAME => >VARSTR )) (( SEE-FETCH-FILE )) (( SEE-GO-TO-NEXT ; SEE-GO-TO-NEXT )) (( GOLABEL4: )) (( SEE-RESPOND-TO-KEY )) (( SEE-STATUS-FOR-EXIT => VISBASIS (MATCHED GOUP4 MATCHED) )) )) OK) (LET MANY BE (( >N4 ; )) (( (( ; => ? => >N7 )) (( N4 (COUNT (( N9 => H )) COUNTUP) )) )) OK) (LET SEE BE (( )) (( (( GJ-ON )) (( SEE-INIT-VARS )) (( SEE-TOTAL-POTENTIAL-OF-LOVE )) (( SEE-DISPLAY-PAGE )) (( SEE-DISPLAY-ALSO-PAGE-GRAPHICS )) (( SEE-MAIN-LOOP )) (( GJ-DONE )) )) OK) (LET PALETTE-EDITOR BE NOOP OK) (LET FLIPPER BE NOOP OK) ((DATA SPC-MATRIX SPC-MATRIX => SETBASIS )) ((DATA SPC-MATRIX-X SPC-MATRIX-X => SETDANCE )) ((DATA SPC-MATRIX-Y SPC-MATRIX-Y => SETDANCE )) ((DATA CALCULATION-X CALCULATION-X => SETDANCE )) ((DATA CALCULATION-Y CALCULATION-Y => SETDANCE )) (( LOOKSTK )) ((DATA LINE-UNITS 85 ; 50 => RAM-PM LINE-UNITS <>> => & )) (( # => CLEAR-MATRIX )) (( 0 => >N6 )) (( ; => LENGTH (COUNT (( ; N1 => CHN ; 32 => EQN => NOT (MATCHED (( INCN8 )) (( N8 ; 50 => INTGREATER = RM N8 ; RMS RMS && ; EXIT === )) (( 0 => >N4 )) (( GOLABEL4: )) (( ; N1 ; N4 => ADD => CHN ; N4 INC ; N8 ; # => PM )) (( INCN4 )) (( N1 N4 ADD ; 79 => INTGREATER = RM N8 ; RMS RMS && ; EXIT === )) (( ; N1 ; N4 => ADD => CHN ; 32 => EQN => NOT = GOUP4 === )) (( N1 ; N4 => ADD => >N1 )) MATCHED) )) COUNTUP) )) (( ; RM )) (( N6 => => )) (( && )) )) OK) (LET LINE-UNITS-TESTER BE (( )) (( (( GOLABEL4: )) (( CLS )) (( }HI!! PLEASE TYPE A LINE (MAX 79 CHARS) TO TEST LINE-UNITS:} => POP )) (( }(OR YOU CAN JUST PRESS [ENTER] TO EXIT THIS TEST PROGRAM)} => POP )) (( READLN => LENGTH => ISBASIS = RM ; CLS ; EXIT === )) (( ; => ONE => LINE-TO-UNITS => >N5 ; )) (( CLS )) (( }WE SEE HERE THAT THE FOLLOWING LINE: } => POP )) (( ; => POP )) (( }HAS THIS MANY UNITS: } ; N5 => CONCAT => POP )) (( }PRESS ENTER TO SEE THEM: } => POPS )) (( READLN ; RM )) (( N5 (COUNT (( }>>>} => ( )) (( N1 ; LINE-UNITS >>> => MATR>TEXT => ( )) (( }<<<} => POP )) COUNTUP) )) (( }DONE! (PLEASE PRESS ENTER TO START AGAIN)} => POPS )) (( READLN ; RM ; GOUP4 )) )) OK) (( LOOKSTK )) (LET TO-ON-OFF BE (( ; )) (( (( ; = }ON} == }OFF} === )) )) OK) (LET FIX-NUMBER-BETTER BE (( >N1 ; EXTRACTNUMBERSTUFF => LENGTH => >N2 )) (( (( }.} 1 FINL => >N8 )) (( N8 => ISPRO (MATCHED (( N2 N8 => SUB => >N9 )) (( N9 N1 => SUB => >N10 )) (( N10 => SG => ISPRO (MATCHED (( 48 ; N10 => SG => MAKECH ; => CONCAT => => )) )(OTHER (( N1 => TEN-TO => STKTORICH => ONER ; STKTORICH => *R => ROUNDR => SWITCHR => \R => RICHTOSTK ; N1 => FIX-NUMBER => => )) MATCHED) )) )(OTHER (( }.} CONCAT )) (( 48 ; N1 => MAKECH ; => CONCAT => => )) MATCHED) )) )) OK) (LET TEXT>MATRIX-HERE BE (( & >N6 >N5 ; )) (( (( DECN5 )) (( ; => LENGTH (COUNT (( ; N1 => CHN ; N1 ; N7 => ADD ; N8 ; # => PM )) COUNTUP) )) (( RM ; && )) )) OK) (LET PM-WIDTH-HERE BE (( ; ; )) (( (( ; ; => %GET => %LENGTH => => )) )) OK) (LET MATR>TEXT-HERE BE (( & >N6 >N5 ; )) (( (( DECN5 )) (( }} ; )) (( N6 ; # => PM-WIDTH-HERE ; N5 => SUB (COUNT (( ; N1 ; N7 => ADD ; N8 ; # => GM => >N3 )) (( N3 => ISBASIS = RMS ; RMS ; && ; => => ; EXIT == == ; N3 => ASCII => CONCAT ; === )) COUNTUP) )) (( RM ; && )) (( ; => => )) )) OK) (LET IS-SEXY BE (( >N5 )) (( (( N5 ; 48 ; 57 => WITH ; N5 ; 43 => EQN ; N5 => 45 => EQN => TRIPLEORR => => )) )) OK) (LET IS-DASH-LIKE BE (( >N5 )) (( (( N5 ; 43 => EQN ; N5 => 45 => EQN => ORR => => )) )) OK) ((DATA PRETTIFY-NUMBER-DECIMALS 0 PRETTIFY-NUMBER-DECIMALS < ISBASIS = EXIT === )) (( ; 1 => CHN => IS-SEXY (MATCHED (( ; => RMBL ; )) (( PRETTIFY-NUMBER-DECIMALS => VISBASIS => NOT = ; PRETTIFY-NUMBER-DECIMALS >>> => FIX-NUMBER-BETTER ; === (( ; }.} 1 => FINL => >N5 ; )) (( N5 => ISBASIS (MATCHED (( ; => LENGTH => >N5 ; )) )(OTHER (( DECN5 )) MATCHED) )) (( N5 => DEC DEC DEC => >N2 )) (( ; 1 ; CHN => IS-DASH-LIKE = DECN2 === ; )) (( N2 (COUNT (( ; },} ; N7 ; N1 => SUB => DEC => INSERT ; )) (( INCN1 ; INCN1 )) COUNTUP) )) MATCHED) )) (( ; 14 => ALIGNR ; 14 => SETMAXLEN => )) )) OK) (LET NUMBERS-GET-ALIGNED BE (( ; )) (( (( LENGTH => ISBASIS = RM ; 14 => MAKEBL => => ; EXIT === )) (( ; 14 => SETMAXLEN ; )) (( ; 1 => CHN => IS-SEXY (MATCHED (( ; => RMBL ; )) (( ; 14 => ALIGNR => => )) MATCHED) ; )) )) OK) (LET SPC-SCREENSAVER BE (( )) (( (( CLS )) (( GOLABEL4: )) (( KEYTOUCH = MANUAL-CLEAR-KEYBUF ; EXIT === )) (( 100 ; ^333 FR GETV => ADD => GOODPAUSE )) (( ^900 FR GETV ; ^720 FR GETV ; BRIDGE ^250 FR GETV ADD ; BRIDGE ^450 FR GETV ADD ; ^2 FR GETV DEC ; )) (( ^5 FR GETV ; 3 => EQN = ; ^2 FR GETV DEC => DOTTED_RECT == ^2 FR GETV ; 1 => EQN = ; RECTFILL == ; RECT === === )) (( GOUP4 )) )) OK) ((DATA /FREE1 )) ((DATA /FREE2 )) ((DATA /FREE3 )) ((DATA /FREE4 )) ((DATA /FREE5 )) ((DATA /FREE6 )) ((DATA /FREE7 )) ((DATA /FREE8 )) ((DATA AUTO-RECALC AUTO-RECALC => SETDANCE )) (( VARSTRING SPC-LINE-GOT )) ((DATA THIS-LINE-IS-THE-FIRST-LINE THIS-LINE-IS-THE-FIRST-LINE => SETDANCE )) (( VARSTRING SPC-FORMULA-GOT )) ((DATA QTY QTY => SETBASIS )) ((DATA SPC-FILENAME )) (LET BASQTY BE (( )) (( (( QTY => SETBASIS )) )) OK) (LET QQTY BE (( )) (( (( QTY >>> => => )) )) OK) (LET QTYUP BE (( )) (( (( QTY => INCVAR )) )) OK) (LET OFQTY BE (( )) (( (( -1 ; QTY => ADDVAR )) )) OK) (( LOOKSTK )) (LET A1B2-FORM BE (( >N5 >N4 )) (( (( N4 ; 64 => ADD => ASCII ; N5 => CONCAT => => )) )) OK) (LET FROM-A1B2-FORM BE (( ; )) (( (( ; => RMBL => LENGTH ; 2 => INTLESSTHAN = RM ; 1 ; 1 ; EXIT === )) (( ; 1 => CHN ; 64 => SUB ; 1 ; 5 => SET-RANGE => SWITCH ; ; )) (( ; => LENGTH => DEC ; 2 => SWITCH => SUBSTR => SWITCH ; RM ; )) (( ; ; => => )) )) OK) (LET FROM-H1L2-ETC-FORM BE (( ; )) (( (( RM )) (( 1 ; 1 => => )) )) OK) (LET RC-RIGHT-RANGES BE (( ; ; )) (( (( ; ; => SWITCH ; 1 ; 5 => SET-RANGE => SWITCH ; ; )) (( ; 1 ; 390 => SET-RANGE ; )) (( ; ; => => )) )) OK) (LET RC-CONTENT BE (( >N6 >N5 )) (( (( SPC-MATRIX >>> => & )) (( N5 => DEC ; 44 => MUL => INC => >N4 )) (( ; N4 ; N6 ; # => MATR>TEXT-HERE => => )) (( && )) )) OK) (LET YES-GIRL BE (( ; ; )) (( (( ; ; => RC-RIGHT-RANGES => RC-CONTENT => EXTRACTNUMBERSTUFF => STKTORICH )) )) OK) (LET RC-CONTENT-THIS BE (( )) (( (( SPC-MATRIX >>> => & )) (( SPC-MATRIX-X >>> => DEC ; 44 => MUL => INC => >N4 )) (( N4 ; SPC-MATRIX-Y >>> ; # => MATR>TEXT-HERE => => )) (( && )) )) OK) (LET ASSERT-MAX-R BE (( >N5 )) (( (( N5 ; 5 => INTGREATER = 5 == N5 === )) )) OK) (LET ASSERT-MAX-C BE (( >N5 )) (( (( N5 ; 390 => INTGREATER = 390 == N5 === )) )) OK) (( LOOKSTK )) (LET R-FORMULA BE (( >N5 )) (( (( SPC-MATRIX >>> => & )) (( N5 ; 400 ; 4000 => WITH => NOT = }??} ; && ; EXIT === )) (( N5 ; # => MATR>TEXT => => )) (( && )) )) OK) (LET FREE-R-FORMULA BE (( >N5 )) (( (( SPC-MATRIX >>> => & )) (( N5 ; # => %GET => %EMPTY )) (( && )) )) OK) (LET NEW-R-FORMULA BE (( ; >N5 )) (( (( SPC-MATRIX >>> => & )) (( N5 => ISBASIS = && ; EXIT === )) (( ; 79 => SETMAXLEN ; )) (( N5 ; # => %GET => %EMPTY )) (( ; N5 ; # => TEXT>MATRIX )) (( && )) )) OK) (LET NEXT-FREE-FORMULA-POSITION BE (( )) (( (( SPC-MATRIX >>> => & )) (( 0 => >N5 )) (( 3000 (COUNT (( 1 ; N1 ; 400 => ADD ; # => GM => ISBASIS (MATCHED (( N1 ; 400 => ADD => >N7 )) (( RMS ; RMS )) (( GOFORWARD4 )) MATCHED) )) COUNTUP) )) (( GOLABEL4: )) (( N5 => => )) (( && )) )) OK) (( LOOKSTK )) (LET HAS-A-FORMULA BE (( >N6 >N5 )) (( (( SPC-MATRIX >>> => & )) (( N5 => 44 => MUL => DEC => >N4 )) (( N4 ; N6 ; # => GM => ISBASIS => NOT => => )) (( && )) )) OK) (LET HAS-THIS-A-FORMULA BE (( )) (( (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => HAS-A-FORMULA => => )) )) OK) (LET FREE-RC-FORMULA-REFERENCE BE (( >N6 >N5 )) (( (( SPC-MATRIX >>> => & )) (( N5 => 44 => MUL => DEC => >N4 )) (( 0 ; N4 ; N6 ; # => PM )) (( && )) )) OK) (LET FREE-RC-REFERENCE-AND-FORMULA-AND-IF-ANY BE (( >N6 >N5 )) (( (( SPC-MATRIX >>> => & )) (( N5 ; 44 => MUL => DEC => >N4 )) (( N4 ; N6 ; # => GM => >N7 )) (( 0 ; N4 ; N6 ; # => PM )) (( N7 => ISBASIS => NOT = N7 => FREE-R-FORMULA === )) (( && )) )) OK) (LET THIS-RC-HAS-NOW-FORMULA-REFERENCE BE (( >N1 )) (( (( SPC-MATRIX >>> => & )) (( SPC-MATRIX-X >>> ; 44 => MUL => DEC => >N5 )) (( N1 ; N5 ; SPC-MATRIX-Y >>> ; # => PM )) (( && )) )) OK) (LET GET-RC-FORMULA BE (( >N6 >N5 )) (( (( SPC-MATRIX >>> => & )) (( N5 ; 44 => MUL => DEC => >N5 )) (( N5 ; N6 ; # => GM => >N8 )) (( N8 => R-FORMULA => => )) (( && )) )) OK) (LET GET-RC-FORMULA-THIS BE (( )) (( (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => GET-RC-FORMULA => => )) )) OK) (LET RC-CONTENT-OR-FORMULA BE (( >N6 >N5 )) (( (( N5 ; N6 => HAS-A-FORMULA (MATCHED (( N5 ; N6 => GET-RC-FORMULA => => )) )(OTHER (( N5 ; N6 => RC-CONTENT => => )) MATCHED) )) )) OK) (LET RC-CONTENT-OR-FORMULA-THIS BE (( )) (( (( HAS-THIS-A-FORMULA (MATCHED (( GET-RC-FORMULA-THIS => => )) )(OTHER (( RC-CONTENT-THIS => => )) MATCHED) )) )) OK) (LET MATR-ITEM-SECOND-AND-ON BE (( & >N5 )) (( (( }} ; )) (( N5 ; # => PM-WIDTH-HERE => DEC (COUNT (( N1 INC ; N7 ; # => GM => ISBASIS = RMS RMS ; GOFORWARD4 === )) (( ; N1 INC ; N7 ; # => GM => ASCII => CONCAT ; )) COUNTUP) )) (( GOLABEL4: && )) (( ; => => )) )) OK) (LET MATR-ITEM-ABBREVIATED BE (( & >N5 )) (( (( }} ; )) (( N5 ; # => PM-WIDTH-HERE => DEC => DEC (COUNT (( N1 INC INC ; N7 ; # => GM => ISBASIS = RMS RMS ; GOFORWARD4 === )) (( ; N1 INC ; N7 ; # => GM => ASCII => CONCAT ; )) COUNTUP) )) (( GOLABEL4: && )) (( ; => => )) )) OK) (LET FROM-CODED-FORM BE (( ; )) (( (( ; => FROM-A1B2-FORM => => )) )) OK) (LET CHECK-FIRST-LINE BE (( )) (( (( THIS-LINE-IS-THE-FIRST-LINE >>> ; 1 ; 376 => SET-RANGE THIS-LINE-IS-THE-FIRST-LINE <>> ; 1 ; 390 => SET-RANGE SPC-MATRIX-Y <>> => >N5 )) (( THIS-LINE-IS-THE-FIRST-LINE >>> => >N6 )) (( N5 ; N6 ; ONE 14 ADD => WITH => => )) )) OK) (LET CALC-RIGHT-FIRST-LINE BE (( )) (( (( SPC-MATRIX-Y >>> => >N5 )) (( N5 ; 14 => SUB ; 1 ; 376 => SET-RANGE THIS-LINE-IS-THE-FIRST-LINE <>> ; THIS-LINE-IS-THE-FIRST-LINE >>> => DEC => SUB => => )) )) OK) (LET LONG-LEGGED BE (( ; )) (( (( ; => FROM-CODED-FORM => RC-CONTENT => => )) )) OK) (LET WE-LIKE-MINI-SKIRTS BE (( ; )) (( (( LINE-UNITS >>> => & )) (( ; => LINE-TO-UNITS => >N5 )) (( N5 => ISBASIS = && ; EXIT === )) (( N5 (COUNT (( 1 ; N1 ; # => GM => >N6 )) (( N6 => IS-SEXY = N1 ; # => MATR>TEXT => EXTRACTNUMBERSTUFF => STKTORICH ; QTYUP == N6 ; 58 => EQN = N1 ; # => MATR-ITEM-SECOND-AND-ON => LONG-LEGGED => EXTRACTNUMBERSTUFF => STKTORICH ; QTYUP == N6 ; 125 => EQN = N1 ; # => MATR-ITEM-ABBREVIATED == N1 ; # => MATR>TEXT => ? => H === === === )) COUNTUP) )) (( && )) )) OK) (( LOOKSTK )) (LET NEW-RC-CONTENT BE (( ; >N6 >N5 )) (( (( SPC-MATRIX >>> => & )) (( ; 14 => SETLENGTH ; )) (( N5 => DEC ; 44 => MUL => INC => >N4 )) (( ; N4 ; N6 ; # => TEXT>MATRIX-HERE )) (( && )) )) OK) (LET NEW-RC-CONTENT-THIS BE (( ; )) (( (( SPC-MATRIX >>> => & )) (( ; 14 => SETLENGTH ; )) (( SPC-MATRIX-X >>> => DEC ; 44 => MUL => INC => >N4 )) (( ; N4 ; SPC-MATRIX-Y >>> ; # => TEXT>MATRIX-HERE )) (( && )) )) OK) (LET RICH-TO-SPC (( >N6 >N5 ; )) (( (( RICHTOSTK => PRETTIFY-NUMBER ; N5 ; N6 => NEW-RC-CONTENT )) )) OK) (LET RICH-TO-THIS-IN-SPC (( ; )) (( (( RICHTOSTK => PRETTIFY-NUMBER => NEW-RC-CONTENT-THIS )) )) OK) (LET RMR-THIS-MANY BE (( >N3 ; )) (( (( N3 => ISPRO => NOT = EXIT === )) (( N3 (COUNT (( RMR )) COUNTUP) )) )) OK) (LET DONE-SPC-RICHSTK-AND-COPY (( >N6 >N5 ; )) (( (( QTY >>> => >N3 )) (( N3 => ISPRO (MATCHED (( ; N5 ; N6 => RICH-TO-SPC )) MATCHED) )) (( N3 => DEC => RMR-THIS-MANY )) (( BASQTY )) )) OK) (LET DONE-SPC-RICHSTK-AND-COPY-TO-THIS (( ; )) (( (( QTY >>> => >N3 )) (( N3 => ISPRO (MATCHED (( ; => RICH-TO-THIS-IN-SPC )) MATCHED) )) (( N3 => DEC => RMR-THIS-MANY )) (( BASQTY )) )) OK) (LET FORMULA-DO BE (( ; ; )) (( (( ; CALCULATION-Y < SETBASIS )) (( BASQTY )) (( CALCULATION-X >>> ; CALCULATION-Y >>> => GET-RC-FORMULA => WE-LIKE-MINI-SKIRTS ; )) (( ; CALCULATION-X >>> ; CALCULATION-Y >>> => DONE-SPC-RICHSTK-AND-COPY )) (( PRETTIFY-NUMBER-DECIMALS => SETBASIS )) )) OK) (LET THIS-FORMULA-DO BE (( )) (( (( SPC-MATRIX-Y >>> CALCULATION-Y <>> CALCULATION-X < SETBASIS )) (( BASQTY )) (( GET-RC-FORMULA-THIS => WE-LIKE-MINI-SKIRTS => DONE-SPC-RICHSTK-AND-COPY-TO-THIS )) (( PRETTIFY-NUMBER-DECIMALS => SETBASIS )) )) OK) (LET SPC-RECALC-NOW BE (( )) (( (( 2 (COUNT (( 390 (COUNT (( 5 (COUNT (( (( N1 ; N3 => HAS-A-FORMULA (MATCHED (( N1 ; N3 => FORMULA-DO )) MATCHED) )) COUNTUP) )) COUNTUP) )) COUNTUP) )) )) OK) (LET REFRESH-MATRPOS-UPDATE BE (( )) (( (( } } ; 920 ; 8 => B9-POP )) (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => A1B2-FORM 920 ; 8 => B9-POP )) (( 920 ; 8 ; BRIDGE 50 ADD ; BRIDGE 25 ADD ; 1 ; 0 => DOTTED_RECT )) )) OK) (LET SPC-ACTUAL-XY BE (( >N6 >N5 )) (( (( N5 ; 170 => MUL ; 50 => SUB => => )) (( N6 ; THIS-LINE-IS-THE-FIRST-LINE >>> => DEC => SUB ; 40 => MUL ; 125 => ADD => => )) )) OK) (LET SPC-ACTUAL-XY-POP BE (( ; >N6 >N5 )) (( (( N5 ; 170 => MUL ; 50 => SUB ; )) (( N6 ; THIS-LINE-IS-THE-FIRST-LINE >>> => DEC => SUB ; 40 => MUL ; 125 => ADD ; )) (( ; ; ; => B9-POP )) )) OK) (LET SPC-ACTUAL-XY-THIS BE (( )) (( (( SPC-MATRIX-X >>> ; 170 => MUL ; 50 => SUB => => )) (( MATRIX-VISIBLE-Y ; 40 => MUL ; 125 => ADD => => )) )) OK) (LET SPC-ACTUAL-XY-THIS-CLR BE (( )) (( (( 14 => MAKEBL ; SPC-ACTUAL-XY-THIS => B9-POP )) )) OK) (LET SPC-POP-THIS BE (( ; )) (( (( ; => SPC-ACTUAL-XY-THIS => B9-POP )) )) OK) (LET PRETTIFIED-SPC-POP-THIS BE (( ; )) (( (( ; => PRETTIFY-NUMBER ; SPC-ACTUAL-XY-THIS => B9-POP )) )) OK) (LET SPC-REFRESH-THIS-POS (( )) (( (( RC-CONTENT-THIS => SPC-POP-THIS )) )) OK) (LET REFRESH-RC-DISPLAY BE (( >N6 >N5 )) (( (( N5 ; N6 => RC-CONTENT ; N5 ; N6 => SPC-ACTUAL-XY-POP )) )) OK) (LET REFRESH-SPC-LINE BE (( >N5 )) (( (( N5 ; THIS-LINE-IS-THE-FIRST-LINE >>> => ONE ; 14 => ADD => WITH => NOT = EXIT === )) (( N5 ; THIS-LINE-IS-THE-FIRST-LINE >>> => DEC => SUB ; 40 => MUL ; 160 => ADD => >N6 )) (( 150 ; N6 ; 1024 ; BRIDGE 35 ADD ; 0 => RECTFILL )) (( 5 (COUNT (( N1 ; N7 => REFRESH-RC-DISPLAY )) COUNTUP) )) )) OK) (LET REFRESH-THIS-SPC-LINE BE (( )) (( (( 5 (COUNT (( N1 ; SPC-MATRIX-Y >>> => REFRESH-RC-DISPLAY )) COUNTUP) )) )) OK) (LET SPC-REFRESH-PAGE BE (( )) (( (( CLS )) }[ESC] FOR INFO, [SPACE] BEFORE DATA, SLASH / BEFORE FORMULA S P C} 5 ; 5 => B9-POP )) (( } 12345678901234 SAVE BY CTR-F } ; } GREAT BUSINESS W/LISA GJ2 FIC3 SPC} => CONCAT ; 5 ; 45 => B9-POP )) (( }>>> } ; 5 ; 85 => B9-POP )) (( (( 57 ; 75 ; 223 ; 75 ; 0 ; 1 => DOTTED_RECT )) (( } A% B% C% D% E%} 5 ; 125 => B9-POP )) (( THIS-LINE-IS-THE-FIRST-LINE >>> => DEC => >N1 )) (( 15 (COUNT (( N3 ; N1 => ADD ; 3 => ALIGNR ; }%} => CONCAT ; 5 ; (( N1 ; 40 => MUL ; 120 => ADD )) => B9-POP )) (( N3 ; N1 => ADD => REFRESH-SPC-LINE )) COUNTUP) )) )) OK) (( LOOKSTK )) (LET UNPOSITION-MATRIX-MARKER BE (( >N5 >N4 )) (( (( N4 ; 170 => MUL ; 20 => SUB => >N4 )) (( N5 ; THIS-LINE-IS-THE-FIRST-LINE >>> => DEC => SUB ; 40 => MUL ; 160 => ADD => >N5 )) (( N4 ; N5 ; BRIDGE 137 ADD ; BRIDGE 3 ADD ; 0 => RECTFILL )) )) OK) (LET SPC-CLR-LN BE (( )) (( (( 45 ; 85 ; 1000 ; BRIDGE 30 ADD ; 0 => RECTFILL )) )) OK) (LET TO-SPC-READLN-LN BE (( ; )) (( (( ; 52 ; 85 => B9-POP )) )) OK) (LET SPC-READLN-RIGHT-INFO BE (( ; )) (( (( 55 => SETLENGTH )) (( ; 370 ; 85 => B9-POP )) )) OK) (LET EXPAND-A-DOT-TO-ZERO-THEN-DOT BE (( ; )) (( (( ; => LENGTH => ISBASIS = ; EXIT === )) (( ; 1 => CHN ; 46 => EQN = ; }0} ; 1 => INSERT ; === ; )) )) OK) (LET SPC-READLN BE (( )) (( (( SPC-CLR-LN )) (( }::TYPE DATA (PLS USE ___ INSTEAD OF --- TO MAKE LINE)} ; => SPC-READLN-RIGHT-INFO )) (( 14 ; 52 ; 85 => B9-READLN ; )) (( SPC-CLR-LN )) (( ; => EXPAND-A-DOT-TO-ZERO-THEN-DOT ; )) (( ; => NUMBERS-GET-ALIGNED ; )) (( ; SPC-LINE-GOT => >VARSTR )) )) OK) (LET SPC-READLN-QUESTION BE (( )) (( (( 14 ; 52 ; 85 => B9-READLN ; SPC-LINE-GOT => >VARSTR )) )) OK) (LET SPC-READLN-FILENAME BE (( )) (( (( 8 ; 52 ; 85 => B9-READLN => MAKE-SAFE-8-SIZE-FILENAME SPC-FILENAME => >VARSTR )) )) OK) (LET SPC-FORMULA-READLN (( )) (( (( SPC-CLR-LN )) (( 79 ; 52 ; 85 => B9-READLN => UPCM ; SPC-FORMULA-GOT => >VARSTR )) )) OK) (LET POSITION-MATRIX-MARKER BE (( >N5 >N4 )) (( (( N4 ; 1 ; 5 => SET-RANGE => ONE => >N4 ; SPC-MATRIX-X < SET-RANGE => SPC-MATRIX-Y < MUL ; 20 => SUB => >N4 )) (( IS-FIRST-LINE-RIGHT-NUMBERED => Y-TO-1 => >N9 )) (( N9 => ISBASIS (MATCHED (( CALC-RIGHT-FIRST-LINE )) (( SPC-REFRESH-PAGE )) (( REFRESH-MATRPOS-UPDATE )) MATCHED) )) (( MATRIX-VISIBLE-Y ; 40 => MUL ; 160 => ADD => >N5 )) (( N4 ; N5 ; BRIDGE 137 ADD ; BRIDGE 3 ADD ; 1 => RECTFILL )) (( N9 => ISDANCE (MATCHED (( SPC-CLR-LN )) (( REFRESH-MATRPOS-UPDATE )) MATCHED) )) (( RC-CONTENT-OR-FORMULA-THIS => TO-SPC-READLN-LN )) )) OK) (LET REFRESH-MARKER BE (( )) (( (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => POSITION-MATRIX-MARKER )) )) OK) (LET ALL-REFRESH BE (( )) (( (( SPC-REFRESH-PAGE )) (( REFRESH-MARKER )) (( REFRESH-MATRPOS-UPDATE )) )) OK) (LET RECALC-ALL-WITH-REFRESH BE (( )) (( (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => UNPOSITION-MATRIX-MARKER )) (( SPC-RECALC-NOW )) (( ALL-REFRESH )) )) OK) (LET MAYBE-AUTO-RECALC-NOW BE (( )) (( (( AUTO-RECALC => VISDANCE (MATCHED (( RECALC-ALL-WITH-REFRESH )) MATCHED) )) )) OK) (LET SPC-READLN-INTO-POSITION BE (( )) (( (( SPC-READLN )) (( SPC-ACTUAL-XY-THIS-CLR )) (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => FREE-RC-REFERENCE-AND-FORMULA-AND-IF-ANY )) (( SPC-LINE-GOT => VARSTR> => ONE => SPC-POP-THIS ; )) (( ; => NEW-RC-CONTENT-THIS )) (( REFRESH-THIS-SPC-LINE )) (( MAYBE-AUTO-RECALC-NOW )) )) OK) (LET SPC-FORMULA-READLN-INTO-POSITION )) (( (( SPC-FORMULA-READLN )) (( SPC-ACTUAL-XY-THIS-CLR )) (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => FREE-RC-REFERENCE-AND-FORMULA-AND-IF-ANY )) (( NEXT-FREE-FORMULA-POSITION => >N5 )) (( SPC-FORMULA-GOT => VARSTR> ; N5 => NEW-R-FORMULA )) (( 0 => NUMBERS-GET-ALIGNED => NEW-RC-CONTENT-THIS )) (( N5 => THIS-RC-HAS-NOW-FORMULA-REFERENCE )) (( REFRESH-THIS-SPC-LINE )) (( MAYBE-AUTO-RECALC-NOW )) )) OK) (LET SPC-USE-INFO BE (( )) (( (( CLS )) (( }The SPC program is made for the love of it, and also,} 10 ; 10 => B9-POP )) (( }so that young, artistically inclined people also can think business-wise.} 10 ; 45 => B9-POP )) (( } >>>>>>> AFTER SAVE, WHEN SATISFIED, PRESS [ESC] TWICE <<<} 10 ; 80 => B9-POP )) (( }But now, [ENTER] for next info page. SPC is a space for business} 10 ; 115 => B9-POP )) (( }calculations. It is a straight-forward program, and it encourages} 10 ; 150 => B9-POP )) (( }fast, elegant, pure arithmetic thinking because it uncluttered.} 10 ; 185 => B9-POP )) (( }A TIP: write filename easily viewable on the top.} 10 ; 220 => B9-POP )) (( }Move around in the space by arrow-keys, scroll page by PgUp/PgDn.} 10 ; 255 => B9-POP )) (( }DELETE CONTENT OF A POSITION BY SPACE BAR FOLLOWED BY A NEW TEXT} 10 ; 290 => B9-POP )) (( }OR A NEW NUMBER; OR BY SLASH (/) FOLLOWED BY FORMULA. THEN [ENTER].} 10 ; 325 => B9-POP )) (( }Enter numbers like 343,343.00 if you like. (See /DOT as for output.)} 10 ; 360 => B9-POP )) (( }SPC has a sound psychological space for the speeds and complexities, incl} 10 ; 395 => B9-POP )) (( }natural nine digit number max width, and five wide columns. In just about} 10 ; 430 => B9-POP )) (( }ANY meaningful calculation, this is a more than good enough resolution!!} 10 ; 465 => B9-POP )) (( }The 12345678901234 digits are there to show size of data field, to aid} 10 ; 500 => B9-POP )) (( }you to shape good text on the matrix page. } 10 ; 535 => B9-POP )) (( }On the next page, you will see the CTR-key combinations. Making SPC} 10 ; 640 => B9-POP )) (( }formulas is a fine art, evolve your skill. Don't stuff many into a file.} 10 ; 675 => B9-POP )) (( }CTR-PGUP / CTR-PGDN shows max height (and keep it neat!). ***ENTER***} 10 ; 710 => B9-POP )) )) OK) (LET SPC-CTR-INFO BE (( )) (( (( CLS )) (( }CTR-KEYS THE THING TO REMEMBER IS THAT YOU OFTEN PRESS [CTRL] BUTTON} 10 ; 10 => B9-POP )) (( }AND F TO PUT THE WHOLE MATRIX -- TEXT, NUMBERS A N D YOUR FORMULAS --} 10 ; 45 => B9-POP )) (( }TO FILE. CTR-R RETRIEVES IT. CTR-R ON ANY OTHER FILE CAUSES PROGRAM EXIT.} 10 ; 80 => B9-POP )) (( } (Use utility program to get text format of SPC matrix files.)} 10 ; 255 => B9-POP )) (( } CTR-R Retrieve ONLY ctr-f-type of saved file. THIS CLEARS RAM!} 10 ; 290 => B9-POP )) (( } CTR-F Saves matrix, internal format: OVERWRITES! GIVE RIGHT NAME!} 10 ; 360 => B9-POP )) (( } CTR-V Toggle on / off the automatic recalc all feature, now: [} AUTO-RECALC => VISDANCE => TO-ON-OFF => CONCAT ; }]} => CONCAT ; 10 ; 430 => B9-POP )) (( } CTR-X Do recalc of all now (twice) (a good check after CTR-R)} 10 ; 465 => B9-POP )) (( } CTR-W Perform this formula at present pos ONLY -- and only once} 10 ; 500 => B9-POP )) }NOTE: ONLY CTR-F ACTUALLY SAVES THE WHOLE MATRIX!! [ENTER], PLEASE} 10 ; 710 => B9-POP )) )) OK) (( LOOKSTK )) (LET /ABOVE BE (( ; )) (( (( RICHTOSTK => >N5 )) (( $0 ; )) (( N5 (COUNT (( CALCULATION-X >>> ; CALCULATION-Y >>> ; N1 => SUB => YES-GIRL ; )) (( ; ; => ADDR ; )) COUNTUP) )) )) OK) (LET /UNDER BE (( ; )) (( (( RICHTOSTK => >N5 )) (( $0 ; )) (( N5 (COUNT (( CALCULATION-X >>> ; CALCULATION-Y >>> ; N1 => ADD => YES-GIRL ; )) (( ; ; => ADDR ; )) COUNTUP) )) )) OK) (LET /RIGHT BE (( ; )) (( (( RICHTOSTK => >N5 )) (( $0 ; )) (( N5 (COUNT (( CALCULATION-X >>> ; N1 => ADD ; CALCULATION-Y >>> => YES-GIRL ; )) (( ; ; => ADDR ; )) COUNTUP) )) )) OK) (LET /LEFT BE (( ; )) (( (( RICHTOSTK => >N5 )) (( $0 ; )) (( N5 (COUNT (( CALCULATION-X >>> ; N1 => SUB ; CALCULATION-Y >>> => YES-GIRL ; )) (( ; ; => ADDR ; )) COUNTUP) )) )) OK) (LET /ADD BE (( ; )) (( (( QQTY => DEC (COUNT (( ; ; => ADDR ; )) (( OFQTY )) COUNTUP) )) )) OK) (LET /THIS BE (( ; )) (( (( CALCULATION-X >>> ; CALCULATION-Y >>> => RC-CONTENT => STKTORICH => => )) OK) (LET /DIV BE (( ; )) (( (( QQTY => DEC (COUNT (( ; ; => \R ; )) (( OFQTY )) COUNTUP) )) )) OK) (LET /IDIV BE (( ; )) (( (( ; ; => RICHTOSTK ; RICHTOSTK => SWITCH => DIV => STKTORICH ; )) (( OFQTY )) )) OK) (LET /IMUL BE (( ; )) (( (( ; ; => RICHTOSTK ; RICHTOSTK => SWITCH => MUL => STKTORICH ; )) (( OFQTY )) )) OK) (LET /MUL BE (( ; )) (( (( QQTY => DEC (COUNT (( ; ; => *R ; )) (( OFQTY )) COUNTUP) )) )) OK) (LET /SUB BE (( ; )) (( (( QQTY => DEC (COUNT (( ; ; => SUBR ; )) (( OFQTY )) COUNTUP) )) )) OK) (LET /SG BE (( ; )) (( (( ; $0 => SWITCHR => SUBR ; )) )) OK) (LET /DOT BE (( ; )) (( (( RICHTOSTK PRETTIFY-NUMBER-DECIMALS < \R ; )) (( ; ; => *R ; )) )) OK) (LET /ONE BE (( ; )) (( (( ; => ONER ; ; )) (( QTYUP )) )) OK) (LET /TWO BE (( ; )) (( (( ; ; => TWOR ; ; ; ; )) (( QTYUP ; QTYUP )) )) OK) (LET /THREE BE (( ; )) (( (( ; ; ; => THREER ; ; ; ; ; ; )) (( QTYUP ; QTYUP ; QTYUP )) )) OK) (LET /IMOD BE (( ; )) (( (( ; ; => RICHTOSTK ; RICHTOSTK => SWITCH => MOD => STKTORICH ; )) (( OFQTY )) )) OK) (LET /SIN BE (( ; )) (( (( ; => SINR ; )) )) OK) (LET /COS BE (( ; )) (( (( ; => COSR ; )) )) OK) (LET /TAN BE (( ; )) (( (( ; => TANR ; )) )) OK) (LET /ASIN BE (( ; )) (( (( ; => ARCSINR ; )) )) OK) (LET /ACOS BE (( ; )) (( (( ; => ARCCOSR ; )) )) OK) (LET /ATAN BE (( ; )) (( (( ; => ARCTANR ; )) )) OK) (LET /R BE (( ; )) (( (( ; => ROUNDR ; )) )) OK) (LET /R2 BE (( ; )) (( (( ; $100 => *R => ROUNDR ; $100 => \R ; )) )) OK) (LET /R1 BE (( ; )) (( (( ; $10 => *R => ROUNDR ; $10 => \R ; )) )) OK) (LET /R3 BE (( ; )) (( (( ; $1000 => *R => ROUNDR ; $1000 => \R ; )) )) OK) (LET /R4 BE (( ; )) (( (( ; $10000 => *R => ROUNDR ; $10000 => \R ; )) )) OK) (LET /R5 BE (( ; )) (( (( ; $100000 => *R => ROUNDR ; $100000 => \R ; )) )) OK) (LET /R6 BE (( ; )) (( (( ; $1000000 => *R => ROUNDR ; $1000000 => \R ; )) )) OK) (LET /R7 BE (( ; )) (( (( ; $10000000 => *R => ROUNDR ; $10000000 => \R ; )) )) OK) (LET /R8 BE (( ; )) (( (( ; $100000000 => *R => ROUNDR ; $100000000 => \R ; )) )) OK) (LET /PI BE (( )) (( (( $3.141593 ; )) (( QTYUP )) )) OK) (LET /EXP BE (( ; )) (( (( ; => EXPR ; )) )) OK) (LET /POWER BE (( ; )) (( (( ; ; => POWERR ; )) (( OFQTY )) )) OK) (LET /LOG BE (( ; )) (( (( ; => LOGR ; )) )) OK) (LET /FOUR BE (( ; )) (( (( ; ; ; ; => FOURR ; ; ; ; ; ; ; ; )) (( 4 ; QTY => ADDVAR )) )) OK) (LET /FIVE BE (( ; )) (( (( ; ; ; ; ; => FIVER ; ; ; ; ; ; ; ; ; ; )) (( 5 ; QTY => ADDVAR )) )) OK) (LET /SWITCH BE (( ; )) (( (( ; ; => SWITCHR ; ; )) )) OK) (LET /ANGEL BE (( ; )) (( (( ; ; ; => ANGELR ; ; ; )) )) OK) (LET /BRIDGE BE (( ; )) (( (( ; ; => BRIDGER ; ; )) (( QTYUP )) )) OK) (( LOOKSTK )) (LET SPC-FORMULA-INFO BE (( )) (( (( CLS )) (( }EXAMPLES OF GOOD FORMULAS. BE SURE, WHEN YOU PUT IN A NEW FORMULA,} 10 ; 10 => B9-POP )) (( }TO SAVE THE EARLIER VERSION FIRST TO ANOTHER NAME; AND TEST IT WELL,} 10 ; 45 => B9-POP )) (( }ALSO BY EXITING THE PROGRAM AND SEE THAT THERE IS NO EXTRA MESSAGE} 10 ; 80 => B9-POP )) (( }WHEN EXITING IT. IF IT IS, GO TO THE EARLIER VERSION OF YOUR MATRIX.} 10 ; 115 => B9-POP )) (( }HERE ARE SOME GOOD FORMULAS. HINT: OFTEN USE 2 /DOT AFTER /ADD.} 10 ; 150 => B9-POP )) (( }To sum five in column above: 5 /ABOVE And add B6: 5 /ABOVE :B6 /ADD} 10 ; 185 => B9-POP )) (( }It's okay with a hyphen (_) line above also. Two decimals 5 /ABOVE 2 /DOT} 10 ; 220 => B9-POP )) (( }For C3+C7-D5: :C3 :C7 /ADD :D5 /SUB Multiply w. 1.25: :A1 1.25 /MUL} 10 ; 255 => B9-POP )) (( }Calc A4+A5+5-1.2 percent: :A4 :A8 5.0 /ADD /ONE 1.2 /PERC /SUB} 10 ; 290 => B9-POP )) (( }To add then display 20 percent of it: :A4 :A8 5.0 /ADD 20 /PERC } 10 ; 325 => B9-POP )) (( }/R /R2 /R3 and up rounds (then maybe use 2 /DOT). /DIV /SWITCH /BRIDGE} } /MOD} => CONCAT 10 ; 360 => B9-POP )) (( }/SIN /COS /TAN /ASIN /ACOS /ATAN /EXP /POWER /IDIV /IMOD /ANGEL /PI etc} 10 ; 500 => B9-POP )) (( }The 'IMOD' means 'integer mod', 'IDIV' means 'integer div'. } 10 ; 535 => B9-POP )) }/ANGEL rotates three numbers, /BRIDGE copies second. Experiment!! ;) } 10 ; 570 => B9-POP )) (( }PLS BE VERY PRECISE IN WRITING AND CHECKING FORMULAS!! ;) SO:} 10 ; 605 => B9-POP )) }SLASH BEFORE FORMULA, THEN ENTER, AND CTR-W TO DO IT (OR CTR-X TO DO ALL)} 10 ; 640 => B9-POP )) (( }Please don't begin numbers with a dot in formulas (0.18 not .18).} 10 ; 675 => B9-POP )) (( }Use a naming convention like MYSPC1, MYSPC2 for files. [ENTER], pls} 10 ; 710 => B9-POP )) )) OK) (LET SPC-FUNV-ARROW BE (( )) (( (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => UNPOSITION-MATRIX-MARKER )) (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> INC => POSITION-MATRIX-MARKER )) )) OK) (LET SPC-FUN<-ARROW BE (( )) (( (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => UNPOSITION-MATRIX-MARKER )) (( SPC-MATRIX-X >>> DEC ; SPC-MATRIX-Y >>> => POSITION-MATRIX-MARKER )) )) OK) (LET SPC-FUN^-ARROW BE (( )) (( (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => UNPOSITION-MATRIX-MARKER )) (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> DEC => POSITION-MATRIX-MARKER )) )) OK) (LET SPC-FUN>-ARROW BE (( )) (( (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => UNPOSITION-MATRIX-MARKER )) (( SPC-MATRIX-X >>> INC ; SPC-MATRIX-Y >>> => POSITION-MATRIX-MARKER )) )) OK) (LET SPC-FUNCTR-PGU BE (( )) (( (( THIS-LINE-IS-THE-FIRST-LINE => SETDANCE )) (( SPC-MATRIX-Y => SETDANCE )) (( SPC-MATRIX-X => SETDANCE )) (( SPC-REFRESH-PAGE )) (( REFRESH-MARKER )) )) OK) (LET SPC-FUNCTR-PGN BE (( )) (( (( 376 ; THIS-LINE-IS-THE-FIRST-LINE <>> ; 375 => INTGREATER = EXIT === )) (( 15 ; THIS-LINE-IS-THE-FIRST-LINE => ADDVAR )) (( 15 ; SPC-MATRIX-Y => ADDVAR )) (( CHECK-MATRIX-Y-RANGE )) (( CHECK-FIRST-LINE )) (( SPC-REFRESH-PAGE )) (( REFRESH-MARKER )) )) OK) (LET SPC-FUNPGU BE (( )) (( (( THIS-LINE-IS-THE-FIRST-LINE => VISDANCE = EXIT === )) (( -15 ; THIS-LINE-IS-THE-FIRST-LINE => ADDVAR )) (( -15 ; SPC-MATRIX-Y => ADDVAR )) (( CHECK-MATRIX-Y-RANGE )) (( CHECK-FIRST-LINE )) (( SPC-REFRESH-PAGE )) (( REFRESH-MARKER )) )) OK) (( LOOKSTK )) (LET SPC-FUN-KEYS BE (( >N3 )) (( (( B9-FKEYNUM >>> => >N1 )) (( B9-FKEYCTR >>> => >N2 )) (( N1 ; 85 => EQN = SPC-FUNV-ARROW == N1 ; 82 => EQN = SPC-FUN<-ARROW == N1 ; 84 => EQN = SPC-FUN^-ARROW == N1 ; 83 => EQN = SPC-FUN>-ARROW == N1 ; FUNC-KEY-PGUP >>> => EQN N2 => ISDANCE AND = SPC-FUNCTR-PGU == N1 ; FUNC-KEY-PGDN >>> => EQN N2 => ISDANCE AND = SPC-FUNCTR-PGN == N1 ; FUNC-KEY-PGDN >>> => EQN = SPC-FUNPGN == N1 ; FUNC-KEY-PGUP >>> => EQN = SPC-FUNPGU == N3 ; 13 => EQN = SPC-FUNV-ARROW == N3 ; 26 => EQN = SPC-FUN<-ARROW == N3 ; 7 => EQN = SPC-FUN^-ARROW == N3 ; 11 => EQN = SPC-FUN>-ARROW == N3 ; 10 => EQN = SPC-FUNCTR-PGU == N3 ; 14 => EQN = SPC-FUNPGN == N3 ; 17 => EQN = SPC-FUNPGU === === === === === === === === === === === === === === === )) )) OK) (( LOOKSTK )) (LET SPC-CLEAR-ALL BE (( )) (( (( SPC-MATRIX >>> => CLEAR-MATRIX )) (( SPC-REFRESH-PAGE )) (( REFRESH-MARKER )) )) OK) (LET SPC-CTRR BE (( )) (( (( SPC-CLR-LN )) (( SPC-CLEAR-ALL )) (( }< SPC-READLN-RIGHT-INFO )) (( SPC-READLN-FILENAME )) (( SPC-CLR-LN )) (( SPC-FILENAME => VARSTR> => }.TXT} => CONCAT => ONE ; ; )) (( ; }ATTEMPT TO ACCESS CTR-F FILE: } ; SWITCH => CONCAT ; => SPC-READLN-RIGHT-INFO )) (( 500 => GOODPAUSE )) (( ; => ONE ; SPC-MATRIX >>> => FILENUM2PM ; RM )) (( SPC-REFRESH-PAGE )) (( REFRESH-MARKER )) (( ; }(AS RULE, RECALC CTR-X AFTER CTR-R) } ; => SWITCH => CONCAT => SPC-READLN-RIGHT-INFO )) )) OK) (LET SPC-CTRF BE (( )) (( (( SPC-CLR-LN )) (( }***< SPC-READLN-RIGHT-INFO )) (( SPC-READLN-FILENAME )) (( SPC-CLR-LN )) (( SPC-FILENAME => VARSTR> ; }.TXT} => CONCAT => ONE ; ; )) (( }MATRIX IN CTR-F FORMAT TO: } ; SWITCH => CONCAT ; => SPC-READLN-RIGHT-INFO ; )) (( ; SPC-MATRIX >>> => PM2FILENUM ; RM )) )) OK) (LET SPC-CTRV BE (( )) (( (( AUTO-RECALC => FLAGFLIP )) )) OK) (LET SPC-CTRX BE (( )) (( (( RECALC-ALL-WITH-REFRESH )) )) OK) (LET SPC-CTRW BE (( )) (( (( THIS-FORMULA-DO )) (( ALL-REFRESH )) )) OK) (LET SPC-INIT-IF-NECESSARY BE (( )) (( (( SPC-MATRIX => VISBASIS (MATCHED (( 250 ; 4000 => RAM-PM SPC-MATRIX < POSITION-MATRIX-MARKER )) (( GOLABEL4: )) (( SECONDS => >N11 )) (( GOLABEL1: )) (( SECONDS ; N11 => SUB ; 24 => INTGREATER (MATCHED (( SPC-SCREENSAVER )) (( ALL-REFRESH )) (( GOFORWARD2 )) MATCHED) )) (( KEYTOUCH => NOT = GOUP1 === )) (( GOLABEL2: )) (( KEYNUM => >N4 )) (( FKEYNUM B9-FKEYNUM < Y-TO-1 B9-FKEYCTR < Y-TO-1 B9-FKEYSHI < EQN (MATCHED (( SPC-READLN-INTO-POSITION )) )(OTHER (( N4 ; KEY-ESC >>> => EQN (MATCHED (( SPC-USE-INFO )) (( KEYNUM ; KEY-ESC >>> => EQN = EXIT === )) (( SPC-CTR-INFO )) (( A-KEY )) (( SPC-FORMULA-INFO )) (( A-KEY )) (( SPC-REFRESH-PAGE )) (( SPC-MATRIX-X >>> ; SPC-MATRIX-Y >>> => => POSITION-MATRIX-MARKER )) )(OTHER (( N4 ; 47 >>> => EQN (MATCHED (( SPC-FORMULA-READLN-INTO-POSITION )) )(OTHER (( 2 ; N4 => INTGTOREQUAL = N4 => SPC-FUN-KEYS == N4 ; CTRL-R >>> => EQN = SPC-CTRR == N4 ; CTRL-F >>> => EQN = SPC-CTRF == N4 ; 22 => EQN = SPC-CTRV == N4 ; 24 => EQN = SPC-CTRX == N4 ; 23 => EQN = SPC-CTRW == 33 ; N4 => INTGREATER = N4 => SPC-FUN-KEYS === === === === === === === )) MATCHED) )) MATCHED) )) MATCHED) )) (( GOUP4 )) )) OK) (( LOOKSTK )) (LET SPC BE (( )) (( (( GJ-ON )) (( SPC-RUN )) (( GJ-DONE )) )) OK) (LET INSPIRED-CLS BE (( )) (( (( ^0 ; (( 128 ; RFFG 64 MOD => ADD => >>V )) ; ^1 ; ^0 => WRITEPAL )) (( ^0 ; (( 128 ; RFFG 64 MOD => ADD => >>V )) ; ^1 ; ^1 => WRITEPAL )) (( PUTPAL )) (( CLS )) )) OK) (LET KEEP-IMPRESSING-THE-PUBLIC BE (( )) (( (( GOLABEL1: )) (( PEN-ORIGO )) (( 2399 => PEN-DEGREE < ADD (COUNT (( KEYTOUCH = CLEAR_KEYBUF ; EXIT === )) (( N4 => ISPRO (MATCHED (( N6 => PEN-RIGHT FT )) )(OTHER (( N6 => PEN-LEFT FT )) MATCHED) )) (( N1 ; N11 => MUL => PEN-DRAW FT )) (( ^10000 FR GETV ; 9990 => INTGREATER (MATCHED (( }HEALTH, BEAUTY, ETC} => GIRL-BEAUTY-POP )) (( 50 ; ^333 FR GETV => ADD => GOODPAUSE )) (( INSPIRED-CLS )) MATCHED) )) COUNTUP) )) (( UNTIL-TOUCHING = GOUP1 === )) (( CLEAR_KEYBUF )) )) OK) (LET SPRING BE (( )) (( (( GJ-ON )) (( KEEP-IMPRESSING-THE-PUBLIC )) (( CLEAR_KEYBUF )) (( GJ-DONE )) )) OK) (( LOOKSTK )) (( 58 WORDWRAPPING-WHERE < SETBASIS ))