}* FREE TUTORIAL EXAMPLE PROGRAM IN LISA GJ2 FIC3 WRITTEN BY }*
}* ARISTO W.LAH, NORMAL YOGA4D CFDL,  2011:3:10              }*
((DATA NAMESORT-INFILE ))
((DATA NAMESORT-SORTEDFILE ))
((DATA NAMESORT-SORTINDEX )) 
((DATA MAYBE-LPCM }LPCM} => ? MAYBE-LPCM <<ASSERT )) 
((DATA MAYBE-RMBL }RMBL} => ? MAYBE-RMBL <<ASSERT )) 
((DATA NAMESORT-QUANTITY )) 
((DATA NAMESORT-IS-SORTED NAMESORT-IS-SORTED => SETDANCE ))
(LET NAMESORT-FREE BE (( ))                    
  ((  
    (( ^4 FR GETV ; 4 => NOT_INTEQUAL = EXIT === ))
    (( 6 => MAKEBL ;
      20 ; 120 => B9-POP ))
  )) OK) 
(LET NAMESORT-SHOW-STARS BE (( ))                    
  ((  
    (( ^4 FR GETV ; 4 => NOT_INTEQUAL = EXIT === ))
    (( 42 ; ^4 FR GETV ; 2 => ADD => MAKECH ;
      20 ; 120 => B9-POP ))
  )) OK)
(LET NAMESORT-SHOW-STARS-MAYBE BE (( ))                    
  ((  
    (( 2,000,000,000 => RICH => >>V FR GETV ;
      1,000,000,000 => RICH => INTGREATER
      (MATCHED
        (( NAMESORT-SHOW-STARS ))
      )(OTHER
        (( NAMESORT-FREE ))
      MATCHED) ))
  )) OK)
(LET NAMESORT-NOW-TRANSFER-THE-FILERAM BE (( SWITCH => & & ))          
  ((      
    (( NAMESORT-QUANTITY >>> => >N8 )) 
    (( N8  
      (COUNT
        (( N1 ; NAMESORT-SORTINDEX >>> => %GET ; 
          ## => MATR>TEXT 
          => (( MAYBE-LPCM >>> => HYPERCONNECT )) ;
          => (( MAYBE-RMBL >>> => HYPERCONNECT )) ;
          N1 ; # => TEXT>MATRIX ))     
      COUNTUP) ))
    (( && ; && ))
  )) OK)
(LET TEASE BE (( ; ))                    
  ((  
    (( ; => DEC => DEC => >>V FR GETV => INC INC
      (COUNT
        (( NAMESORT-FREE ))  
        (( 20 => GOODPAUSE ))
        (( NAMESORT-SHOW-STARS ))                    
      COUNTUP) ))
  )) OK)
((DATA NAME-SORT-LINES )) 
((DATA NAME-SORT-BASIS ))                            
((DATA NAME-SORT-UPPER ))                       
((DATA NAME-SORT-AUXSTK ))
((DATA NAME-SORT-AUXSTKPTR NAME-SORT-AUXSTKPTR => SETBASIS )) 
(LET NAME-SORT-MAKE-AUXSTK BE (( ; ))                         
  ((
    (( ; => %MAKE NAME-SORT-AUXSTK <<ASSERT ))                                
    (( NAME-SORT-AUXSTKPTR => SETBASIS ))
  )) OK)
(LET NAME-SORT-HAS-AUXSTK-ELEMENTS BE (( ))
  ((
    (( NAME-SORT-AUXSTKPTR => VISBASIS => NOT => => ))
  )) OK)
(LET NAME-SORT-TO-AUXSTK BE (( ; ; ))                       
  ((
    (( 2 ; NAME-SORT-AUXSTKPTR => ADDVAR ))
    (( ; NAME-SORT-AUXSTKPTR >>> => DEC ;                                     
      NAME-SORT-AUXSTK >>> => %PUT ))
    (( ; NAME-SORT-AUXSTKPTR >>> ;                                           
      NAME-SORT-AUXSTK >>> => %PUT ))
  )) OK)
(LET NAME-SORT-AUXSTK-FROM BE (( ))
  ((
    (( NAME-SORT-AUXSTKPTR >>> ;                                  
      NAME-SORT-AUXSTK >>> => %GET ; ))
    (( ; NAME-SORT-AUXSTKPTR >>> => DEC ;                                     
      NAME-SORT-AUXSTK >>> => %GET ; ; => => ))
    (( -2 ; NAME-SORT-AUXSTKPTR => ADDVAR ))
  )) OK)
(LET NAME-SORT BE (( & & NAME-SORT-LINES <<ASSERT ))
  ((      
    (( NAME-SORT-LINES >>> => STKTORICH => LOG2R => RICHTOSTK =>
      TWICE ; 50 => ADD => NAME-SORT-MAKE-AUXSTK ))
    (( NAME-SORT-BASIS => SETDANCE ))
    (( NAME-SORT-LINES >>> NAME-SORT-UPPER <<ASSERT ))
    (( GOLABEL1: ))
      (( 7 ; NAME-SORT-UPPER >>> ; NAME-SORT-BASIS >>>                        
        => SUB => INTGREATER
        (MATCHED
          (( NAMESORT-SHOW-STARS-MAYBE ))
          (( NAME-SORT-BASIS >>> ; NAME-SORT-UPPER >>>                        
            => NOT_INTEQUAL
            (MATCHED
              (( NAME-SORT-BASIS >>> => INC => >N2 ))
              O//
                (( N2 ; ## => %GET => >N8 ))
                (( N8 => >N10 ))                                 
                (( N2 => DEC => >N1 ))
                O//
                  (( N1 ; ## => %GET => >N9 ))                                
                  (( N9 => >N11 ))
                  (( N10 ;                           
                    N11 ; 1 ; 79 ; # => NAME-GTOREQUAL
                    = GOFORWARD2 === ))
                  (( N9 ; N1 => INC ; ## => %PUT ))
                  (( N1 ; 1 => INTGREATER
                |C|  ))
                  (( DECN1 ))
                |A
                (( 0 >N1 ))
                (( GOLABEL2: ))
                (( N8 ; N1 => INC ; ## => %PUT ))
                (( NAME-SORT-UPPER >>> ; N2 => INTGREATER
              |C| ))
                (( INCN2 ))
              |A
            MATCHED)
          (( NAME-SORT-HAS-AUXSTK-ELEMENTS => NOT
            = GOFORWARD4 === ))
          (( NAME-SORT-AUXSTK-FROM => ; ; ))                                  
          (( ; ; NAME-SORT-BASIS <<ASSERT ))
          (( ; NAME-SORT-UPPER <<ASSERT ))
        )(OTHER
          (( NAMESORT-SHOW-STARS-MAYBE )) 
          (( NAME-SORT-BASIS >>> => INC ;
            NAME-SORT-BASIS >>> ; NAME-SORT-UPPER >>> => ADD => DIV2 ;
            ## => %SWITCH ))
          (( NAME-SORT-UPPER >>> ; NAME-SORT-BASIS >>> => INC => TWO ; ;
            ## => %GET => SWITCH ;
            ## => %GET ; 1 ; 79 ; # => NAME-GREATER
              (MATCHED
                (( ; ; ## => %SWITCH ))
              )(OTHER
                (( RM RM ))
              MATCHED)
          (( NAME-SORT-UPPER >>> ; NAME-SORT-BASIS >>> => TWO ; ; 
            ## => %GET ; SWITCH ; 
            ## => %GET ; 1 ; 79 ; # => NAME-GREATER
              (MATCHED
                (( ; ; ## => %SWITCH ))
              )(OTHER
                (( RM RM ))
              MATCHED)
          (( NAME-SORT-BASIS >>> ; NAME-SORT-BASIS >>> => INC => TWO ; ;
            ## => %GET => SWITCH ;
            ## => %GET ; 1 ; 79 ; # => NAME-GREATER
            (MATCHED
              (( ; ; ## => %SWITCH ))
            )(OTHER
              (( RM RM ))
            MATCHED)
          (( NAME-SORT-BASIS >>> => INC => >N1 ))
          (( NAME-SORT-UPPER >>> => >N2 ))
          (( NAME-SORT-BASIS >>> ; ## => %GET => >N10 ))                      
          T//
            O//
              (( INCN1 ))
              (( N10 ;                        
                N1 ; ## => %GET ;                                      
                1 ; 79 ; # => NAME-GREATER
            |C| ))
            |A
            O//
              (( DECN2 ))
              (( N2 ; ## => %GET ;                                         
                N10 ; 1 ; 79 ; # => NAME-GREATER
            |C| ))
            |A
            (( N1 ; N2 => INTGREATER
              (MATCHED |GNT| MATCHED) ))
            (( N1 ; N2 ; ## => %SWITCH ))
          |GT
          (( N2 ; NAME-SORT-BASIS >>> ; ## => %SWITCH ))
          (( NAME-SORT-UPPER >>> => INC ; N1 => SUB ;
            N2 => DEC => INTGTOREQUAL
            (MATCHED
              (( NAME-SORT-UPPER >>> ; N1 => NAME-SORT-TO-AUXSTK ))
              (( N2 => DEC NAME-SORT-UPPER <<ASSERT ))
            )(OTHER
              (( N2 => DEC ; NAME-SORT-BASIS >>> =>                           
                NAME-SORT-TO-AUXSTK ))
              (( N1 ; NAME-SORT-BASIS <<ASSERT ))
            MATCHED)
          ))
        MATCHED)
      (( GOUP1 ))
    (( GOLABEL4: ))
    (( NAME-SORT-AUXSTK >>> => %FREE ))
    (( NAMESORT-FREE )) 
    (( NAMESORT-SHOW-STARS )) 
    (( && ; && ))
  )) OK)
}* NOW THE QUICKSORT ALGORITHM ABOVE WOULD BE EVEN QUICKER IF YOU }* 
}* TOOK AWAY THE NAMESORT-SHOW-STARS AND -FREE STUFF, WHICH JUST   }* 
}* FLASHES SOMETHING ON TO THE SCREEN TO SHOW IT IS WORKING.      }* 
}* IT IS THE KIND OF FUNCTION WHERE IT DOES MAKE SENSE TO HAVE    }* 
}* MOSTLY ALL GOING ON INSIDE ONE BIG BUNDLE OF LOOPS.            }* 
}* IN ALMOST ALL OTHER CASES, SUCH COMPLEXITY WOULD BE DIVIDED    }* 
}* INTO BETWEEN FIVE AND A DOZEN SMALLER ALGORITHMS HIERARCHIALLY.}* 
}* AND IN ALL SUCH CASES WHERE WE ARE USING SMALLER ALGORITHMS,   }* 
}* WE WOULD USE GOLABEL: .. GOUP AND (COUNT .. COUNTUP) LOOPS,    }* 
}* WHICH ARE MUCH, MUCH SIMPLER, WHEN COMBINED WITH (MATCHED ..   }* 
}* )(OTHER .. MATCHED) OR THE SYNONYM = .. == .. ===.             }* 
}* BUT FOR THOSE FEW CASES WHERE WE WANT THIS MANY LOOPS INSIDE   }* 
}* ONE ANOTHER, THOSE EARLY FIRTH LOOP CONSTRUCTS OF MINE ARE     }* 
}* STILL AVAILABLE --   O// .. |C| .. |A   WHERE |C| IS CHECK,    }*
}* A IS FOR 'AGAIN', AND O// IS THE LOOP START -- AND THE OTHER   }* 
}* ONE, MORE COMPLEX, T// ..  GT|  WHICH IS TO 'TRUST A LOOP',    }* 
}* AND 'GT' MEANS GO UP TO THIS TRUST-POINT AGAIN, AND WHICH,     }* 
}* IN ORDER TO EXIT, HAS A .. (MATCHED |GNT| MATCHED) INSIDE IT,  }* 
}* WHICH MEANS, 'GO TO NEXT, AFTER THIS TRUST LOOP', OR POSSIBLY  }* 
}* MANY SUCH |GNT|'S INSIDE ONE LOOP.                             }* 
(LET NAMESORT-NOW-DO-THE-SORT BE (( ))                  
  ((  
    (( NAMESORT-SORTINDEX >>> => & )) 
    (( NAMESORT-SORTEDFILE >>> => & )) 
    (( NAMESORT-SHOW-STARS-MAYBE )) 
    (( 90 => TEASE ))
    (( }BY THE WAY, UNIFORM CASE OF LETTERS?} ; 
      20 ; 80 => B9-POP ))
    (( NAMESORT-SHOW-STARS-MAYBE )) 
    (( 460 ; 80 => B9-YNIN => NOT
      (MATCHED
        (( }NOOP} => ? MAYBE-LPCM <<ASSERT ))
      MATCHED) ))
    (( NAMESORT-SHOW-STARS-MAYBE )) 
    (( 20 => TEASE ))
    (( 70 => MAKEBL ; 20 ; 80 => B9-POP ))
    (( }ANOTHER THING..REMOVE SPACES IN LINES?} ; 
      20 ; 80 => B9-POP ))
    (( NAMESORT-SHOW-STARS-MAYBE )) 
    (( 490 ; 80 => B9-YNIN => NOT
      (MATCHED
        (( }NOOP} => ? MAYBE-RMBL <<ASSERT ))
      MATCHED) ))
    (( NAMESORT-SHOW-STARS-MAYBE )) 
    (( NAMESORT-INFILE >>> ; NAMESORT-SORTEDFILE >>>
      => NAMESORT-NOW-TRANSFER-THE-FILERAM ))
    (( NAMESORT-INFILE >>> => RELEASE-MATRIX ))
    (( NAMESORT-SHOW-STARS-MAYBE )) 
    (( NAMESORT-QUANTITY >>> ; # ; ## => NAME-SORT ))           
    (( && ; && ))
  )) OK)
(LET NAMESORT-SORT-THE-FILE BE (( ; ))
  ((  
    (( CLS ))
    (( RMBL => LENGTH => ISBASIS = RM ; EXIT === ; ))
    (( ; => UPCM ; }.TXT} => CONCAT ; ))
    (( }NAMESORT (.TXT SORTER) CHECKING FOR } ; BRIDGE => CONCAT ;
      } IN STANDARD FOLDER..} => CONCAT ;                           
      => 20 ; 20 => B9-POP ))
    (( ; => ONE => ALREADYFILE => NOT
      (MATCHED
        (( ; RM ))
        (( }PLS CHK FILENAME ETC AND TRY AGAIN, TKS.} ; 
          20 ; 50 => B9-POP ))
        (( A-KEY ))
        (( EXIT ))
      MATCHED) ))
    (( ; => ONE => COUNTLINES => RM ; RM => >N5 ; ))
    (( }FOUND } ; N5 => CONCAT ;                           
      } LINESHIFTS IN IT.} => CONCAT ;
      20 ; 50 => B9-POP ))
    (( 3 ; N5 => INTGREATER =>
      (MATCHED
        (( ; RM ))
        (( }PLS CHK FILE (SHOULD HAVE > 2 LINES) AND} ; 
          20 ; 80 => B9-POP ))
        (( }TRY AGAIN, TKS.} ; 20 ; 110 => B9-POP ))
        (( A-KEY ))
        (( EXIT ))
      MATCHED) ))
    (( }NAME OF NEW FILE (BE SURE ABOUT NAME, AS IT OVERWRITES;} ;
      20 ; 80 => B9-POP ))
    (( }OR JUST PRESS LINESHIFT NOW TO EXIT PROGRAM): } ;
      20 ; 110 => B9-POP ))
    (( 8 ; 850 ; 110 => B9-READLN => RMBL ; )) 
    (( ; ; => LENGTH => ISBASIS = RM ; RM ; EXIT === ))
    (( ; ; => UPCM ; }.TXT} => CONCAT ; ; )) 
    (( CLS ))
    (( }GOOD. PRESS ENTER TO GET RAM TO SORT!} ;
      20 ; 20 => B9-POP ))
    (( A-KEY ))
    (( 79 ; (( N5 ; 20 => ADD )) => RAM-PM
      NAMESORT-INFILE <<ASSERT ))
    (( NAMESORT-INFILE >>> => & )) 
    (( 79 ; (( N5 ; 20 => ADD )) => RAM-PM
      NAMESORT-SORTEDFILE <<ASSERT ))
    (( N5 NAMESORT-QUANTITY <<ASSERT ))
    (( NAMESORT-QUANTITY >>> => %MAKE 
      NAMESORT-SORTINDEX <<ASSERT ))
    (( NAMESORT-QUANTITY >>>
      (COUNT
        (( N1 ; N1 ; NAMESORT-SORTINDEX >>> => %PUT ))
      COUNTUP) ))
    (( }BEST FOR VERY UNRULY LISTS. ENTER TO TRY SORT!} ;
      20 ; 50 => B9-POP ))
    (( A-KEY ))
    (( ; ; => SWITCH ; # => FILE2PM ; RM ; ))
    (( # => FIX-BLANK-LINES-IN-FILE ))
    (( # => FIND-MAX-LINE-NUM 
      NAMESORT-QUANTITY <<ASSERT ))
    (( NAMESORT-QUANTITY >>> ; # => FILTER-NON7ASCII-CHARS ))
    (( && ))
    (( NAMESORT-INFILE >>> =>                              
      ARE-ALL-IN-RIGHTMOST-COLUMN-UNUSED => NOT
      (MATCHED
        (( ; RM ))
        (( }A TINY ISSUE.. PLS CAREFULLY GO THROUGH THE FILE} ;
          20 ; 100 => B9-POP ))
        (( }AND MAKE SURE THAT NO LINES HAVE MORE THAN} ;
          20 ; 130 => B9-POP ))
        (( }79 CHARACTERS, NOT EVEN BLANKS. MAYBE USE   WORDWRAP} ;
          20 ; 160 => B9-POP ))
        (( NAMESORT-IS-SORTED => SETBASIS ))
        (( A-KEY ))
        (( EXIT ))
      MATCHED) ))
    (( NAMESORT-NOW-DO-THE-SORT ))
    (( NAMESORT-SHOW-STARS ))
    (( NAMESORT-IS-SORTED => VISDANCE
      (MATCHED
        (( NAMESORT-FREE ))            
        (( }SORTED! ENTER TO SAVE THE FILE; AND PROGRAM EXITS.} ;
          20 ; 350 => B9-POP ))
        (( }PLS CHK FILE CAREFULLY.} ;
          20 ; 440 => B9-POP ))
        (( }GOOD LUCK!!!} ;
          20 ; 470 => B9-POP ))
        (( A-KEY ))
        (( }NOOP} => ? MAYBE-LPCM <<ASSERT )) 
        (( }NOOP} => ? MAYBE-RMBL <<ASSERT )) 
        (( 79 ; (( NAMESORT-QUANTITY >>> ; 20 => ADD )) => RAM-PM
          NAMESORT-INFILE <<ASSERT ))
        (( NAMESORT-SORTEDFILE >>> ; NAMESORT-INFILE >>>                   
          => NAMESORT-NOW-TRANSFER-THE-FILERAM ))
        (( ; => ONE ; NAMESORT-INFILE >>> => PM2FILE ; RM ))      
      MATCHED) ))
    (( ; RM ))
  )) OK) 
(( LOOKSTK )) 
(LET NAMESORT BE 
  (( 
    (( GJ-ON )) 
    (( }NAMESORT IN LISA GJ2 FIC3. GOOD FOR VERY UNRULY LISTS!} ;       
      20 ; 20 => B9-POP ))
    (( }THIS QSORT2-LIKE PROGRAM DOES UP TO 79 CHARS PR LINE.} ;  
      20 ; 260 => B9-POP ))
    (( }NAME OF .TXT FILE (WITHOUT FOLDERNAME, AND WITHOUT .TXT):}  ;        
      20 ; 650 => B9-POP ))
    (( 8 ; 820 ; 650 => B9-READLN ; ))
    (( ; => NAMESORT-SORT-THE-FILE ))
    (( GJ-DONE ))   
  )) OK)
(( LOOKSTK )) 
(LET AUTOSTART BE NAMESORT OK)