12 Jun 16 06:38, you wrote to me:   
      
    ml>> i've gone back to your original post where i asked you if you were stil   
    ml>>   
      
    JL> Hmm. Not sure why the quoted portions are truncated. But, anyway, you are   
    JL> correct about the oneh.ans, onen.ans, and oney.ans files.   
      
   can you provide simple ASCII versions of those files, please? i can't tell   
   what they should say by the code context... i made a guess at two of them   
   but...   
      
    JL> I'll try the code out.   
      
   the main thing is all the additional debugging code so we can follow the logic   
   flow... i think it can be completely revised and simplified... as i haven't   
   looked at it, i'm pretty sure that a lot could be rewritten using new   
   techniques which are simplier and easier to use... the PRINTF routine i threw   
   in there using TStringList is one example...   
      
    JL> Thank you!   
      
   luckily enough, i had a few hours to try to work with it yesterday... there   
   are some problems (initial file loading if it doesn't exist) but they can be   
   worked around... personally, i think i'd restructure the oneliners file to   
   contain all the info on one like and then maybe break it apart for display...   
   TStringList would works great for lines of text... using a TStringList would   
   also allow for moving away from the older style of manually doing all the file   
   reading and writing as TStringList already handles that on its own with   
   LoadFromFile and SaveToFile... like this small rewrite...   
      
   ==== Begin "myoneliners.pas"  ====   
   program myoneliners;   
   {$mode objfpc}   
      
   uses   
     crt, classes, sysutils;   
      
   type   
     userrec=record   
               name : string[36];   
             end;   
      
   const onehfname      = './oneh.ans';   
   const onenfname      = './onen.ans';   
   const oneyfname      = './oney.ans';   
   const onelinefname   = './oneline.asc';   
   const onelinersfname = './oneliners.lst';   
      
   var  S            : string;   
   var  Ch1          : char;   
   var  Ch2          : char;   
   var  thisuser     : userrec;   
   var  theoneliners : TStringList;   
      
      
   procedure displaykey(var thechar1, thechar2 : char);   
      
   begin   
     case thechar1 of   
       #00 : begin   
               write('    double character key - ');   
               case thechar2 of   
                 #16 : writeln('ALT-Q');   
                 #17 : writeln('ALT-W');   
                 #18 : writeln('ALT-E');   
                 #19 : writeln('ALT-R');   
                 #20 : writeln('ALT-T');   
                 #21 : writeln('ALT-Y');   
                 #22 : writeln('ALT-U');   
                 #23 : writeln('ALT-I');   
                 #24 : writeln('ALT-O');   
                 #25 : writeln('ALT-P');   
      
                 #30 : writeln('ALT-A');   
                 #31 : writeln('ALT-S');   
                 #32 : writeln('ALT-D');   
                 #33 : writeln('ALT-F');   
                 #34 : writeln('ALT-G');   
                 #35 : writeln('ALT-H');   
                 #36 : writeln('ALT-J');   
                 #37 : writeln('ALT-K');   
                 #38 : writeln('ALT-L');   
      
                 #44 : writeln('ALT-Z');   
                 #45 : writeln('ALT-X');   
                 #46 : writeln('ALT-C');   
                 #47 : writeln('ALT-V');   
                 #48 : writeln('ALT-B');   
                 #49 : writeln('ALT-N');   
                 #50 : writeln('ALT-M');   
      
                 #59 : writeln('F1');   
                 #60 : writeln('F2');   
                 #61 : writeln('F3');   
                 #62 : writeln('F4');   
                 #63 : writeln('F5');   
                 #64 : writeln('F6');   
                 #65 : writeln('F7');   
                 #66 : writeln('F8');   
                 #67 : writeln('F9');   
                 #68 : writeln('F10');   
      
                 #71 : writeln('HOME');   
                 #72 : writeln('UPARR');   
                 #73 : writeln('PGUP');   
      
                 #75 : writeln('LFARR');   
      
                 #77 : writeln('RTARR');   
      
                 #79 : writeln('END');   
                 #80 : writeln('DNARR');   
                 #81 : writeln('PGDN');   
                 #82 : writeln('INSERT');   
                 #83 : writeln('DELETE');   
      
                 #104 : writeln('ALT-F1');   
                 #105 : writeln('ALT-F2');   
                 #106 : writeln('ALT-F3');   
                 #107 : writeln('ALT-F4');   
                 #108 : writeln('ALT-F5');   
                 #109 : writeln('ALT-F6');   
                 #110 : writeln('ALT-F7');   
                 #111 : writeln('ALT-F8');   
                 #112 : writeln('ALT-F9');   
                 #113 : writeln('ALT-F10');   
      
                 #133 : writeln('F11');   
                 #134 : writeln('F12');   
      
                 #139 : writeln('ALT-F11');   
                 #140 : writeln('ALT-F12');   
               else   
                 writeln('    unknown double character key = #',ord(thechar1),'   
   #',ord(thechar2));   
               end; {case thechar2}   
             end; {begin thechar1 = #00}   
     else   
       begin   
         write('    single character key - ');   
         case thechar1 of   
           #01 : writeln('CTRL-A');   
           #02 : writeln('CTRL-B');   
           #03 : writeln('CTRL-C');   
           #04 : writeln('CTRL-D');   
           #05 : writeln('CTRL-E');   
           #06 : writeln('CTRL-F');   
           #07 : writeln('CTRL-G');   
           #08 : writeln('BCKSPC');   
           #09 : writeln('TAB');   
           #10 : writeln('LF');   
           #11 : writeln('VT');   
           #12 : writeln('FF');   
           #13 : writeln('ENTER');   
           #14 : writeln('CTRL-N');   
           #15 : writeln('CTRL-O');   
           #16 : writeln('CTRL-P');   
           #17 : writeln('CTRL-Q');   
           #18 : writeln('CTRL-R');   
           #19 : writeln('CTRL-S');   
           #20 : writeln('CTRL-T');   
           #21 : writeln('CTRL-U');   
           #22 : writeln('CTRL-V');   
           #23 : writeln('CTRL-W');   
           #24 : writeln('CTRL-X');   
           #25 : writeln('CTRL-Y');   
           #26 : writeln('CTRL-Z');   
           #27 : writeln('ESC');   
           #28 : writeln('FS');   
           #29 : writeln('GS');   
           #30 : writeln('RS');   
           #31 : writeln('US');   
           #32 : writeln('SPACE');   
         else   
           writeln(chr(byte(thechar1)),' = #',ord(thechar1));   
         end; {case thechar1}   
       end; {begin}   
     end;   
   end;   
      
   //### begin printf procedure ####################################   
   //### temporary routine to provide printf without needing the   
   //### entire impulse package   
   procedure printf(thefile : string);   
      
   var   
     filecontents : TStringList;   
     thisline : integer;   
      
   begin   
     writeln('      PRINTF: entering PRINTF routine');   
     writeln('      PRINTF: creating stringlist to hold file contents');   
     filecontents := TStringList.Create;   
     filecontents.sorted := false;   
     try   
       writeln('      PRINTF: attempting to load file ',thefile);   
       filecontents.LoadFromFile(thefile);   
       writeln('      PRINTF: display ',IntToStr(filecontents.Count),' lines');   
       for thisline := 0 to filecontents.Count-1 do   
         begin   
           writeln(filecontents.Strings[thisline]);   
         end;   
     finally   
       writeln('      PRINTF: dump stringlist contents and free memory');   
       if Assigned(filecontents) then   
         FreeAndNil(filecontents);   
     end;   
     writeln('      PRINTF: leaving PRINTF routine');   
   end;   
   //### end printf procedure ######################################   
      
   //### begin show procedure ######################################   
   Procedure show;   
      
   var Count : integer;   
      
   Begin   
     writeln('    SHOW: entering SHOW routine');   
     writeln('    SHOW: going to PRINTF(''',onehfname,''')');   
     printf(onehfname);   
     writeln('    SHOW: back from PRINTF(''',onehfname,''')');   
     writeln('    SHOW: displaying current oneliners');   
     for count := 0 to theoneliners.Count-1 do   
       begin   
         writeln(theoneliners.Strings[count]);   
       end;   
     writeln('    SHOW: finished displaying current oneliners');   
     writeln('    SHOW: leaving SHOW routine');   
   End; // show   
   //### end show procedure ########################################   
      
   //### begin init procedure ######################################   
   Procedure init;   
      
   var Count : byte;   
      
   Begin   
     writeln('  INIT: entering INIT routine');   
   //  GetThisUser;   
   // just stuff something into thisuser.name to get the prog to run   
     writeln('  INIT: assign thisuser.name');   
     thisuser.name := 'my goofy user';   
      
     writeln('  INIT: creating stringlist to hold oneliners file contents');   
     theoneliners := TStringList.Create;   
     theoneliners.sorted := false;   
     try   
       writeln('  INIT: loading default writers and oneliners');   
       For Count := 1 To 10 Do   
         Begin   
           theoneliners.add('IGNATIUS: Ia! Cthulhu!');   
         End;   
       writeln('  INIT: defaults loaded');   
      
       if FileExists(onelinersfname) then   
         begin   
           writeln('  INIT: attempting to load oneliners file ',onelinersfname);   
           theoneliners.LoadFromFile(onelinersfname);   
         end   
       else   
         begin   
           writeln('  INIT: writing initial oneliners file ',onelinersfname);   
           theoneliners.SaveToFile(onelinersfname);   
         end;   
      
       writeln('  INIT: oneliners file contains ',IntToStr(theoneliners.Count),'   
   lines');   
     finally   
     end;   
     writeln('  INIT: leaving INIT routine');   
   End; // Init   
   //### end init procedure ########################################   
      
   //### begin bot_bar procedure ###################################   
   Procedure bot_bar;   
      
   Begin   
     writeln('  BOT_BAR: entering BOT_BAR routine');   
     ch1 := #00;   
     ch2 := #00;   
     writeln('  BOT_BAR: going to PRINTF(''',onenfname,''')');   
     printf(onenfname);   
     writeln('  BOT_BAR: back from PRINTF(''',onenfname,''')');   
     writeln('  BOT_BAR: any key to show or ENTER to exit BOT_BAR');   
     Ch1 := ReadKey;   
     case ch1 of   
       #00 : begin   
               ch2 := readkey;   
               displaykey(ch1,ch2);   
             end; {begin ch1 = #00}   
     else   
       displaykey(ch1,ch2);   
     end; {case ch1}   
     If Ch1 = #13 then   
       Begin   
         writeln('  BOT_BAR: leaving BOT_BAR via ENTER key');   
         exit;   
       End;   
     writeln('  BOT_BAR: going to SHOW routine');   
     show;   
     writeln('  BOT_BAR: back from SHOW routine');   
     writeln('  BOT_BAR: leaving BOT_BAR via normal exit');   
   End; // bot_bar   
   //### end bot_bar procedure #####################################   
      
   //### begin top_bar procedure ###################################   
   Procedure top_bar;   
      
   Begin   
     writeln('  TOP_BAR: entering TOP_BAR routine');   
     ch1 := #00;   
     ch2 := #00;   
     writeln('  TOP_BAR: going to PRINTF(''',oneyfname,''')');   
     printf(oneyfname);   
     writeln('  TOP_BAR: back from PRINTF(''',oneyfname,''')');   
     writeln('  TOP_BAR: any key to exit TOP_BAR or ENTER to add a oneliner');   
     Ch1 := ReadKey;   
     case ch1 of   
       #00 : begin   
               ch2 := readkey;   
               displaykey(ch1,ch2);   
             end; {begin ch1 = #00}   
     else   
       displaykey(ch1,ch2);   
     end; {case ch1}   
     If Ch1 = #13 then   
       Begin   
         writeln('  TOP_BAR: going to PRINTF(''',onelinefname,''')');   
         printf(onelinefname);   
         writeln('  TOP_BAR: back from PRINTF(''',onelinefname,''')');   
         // temp readln replacing inputl to avoid needing entire impulse code   
         readln(s);   
         If s = '' then   
           Begin   
             WriteLn('  TOP_BAR: aborted adding new oneliner');   
             writeln('  TOP_BAR: going to SHOW routine');   
             show;   
             writeln('  TOP_BAR: back from SHOW routine');   
             writeln('  TOP_BAR: leaving TOP_BAR via blank oneliner line');   
             Exit;   
           End;   
      
         writeln('  TOP_BAR: deleting oldest oneliner from top of list');   
         theoneliners.delete(0);   
         writeln('  TOP_BAR: adding new oneliner to bottom of list');   
         theoneliners.add(thisuser.name+': '+s);   
         writeln('  TOP_BAR: saving modified oneliners file ',onelinersfname);   
         theoneliners.SaveToFile(onelinersfname);   
      
       End;   
     writeln('  TOP_BAR: going to SHOW routine');   
     show;   
     writeln('  TOP_BAR: back from SHOW routine');   
     writeln('  TOP_BAR: leaving TOP_BAR via normal exit');   
   End; // top_bar   
   //### end top_bar procedure #####################################   
      
   //### begin position procedure ##################################   
   Procedure position;   
      
   Begin   
     writeln('  POSITION: entering POSITION routine');   
     writeln('  POSITION: do show routine');   
     show;   
     writeln('  POSITION: any key to continue or ENTER to exit');   
     Repeat   
       ch1 := #00;   
       ch2 := #00;   
       ch1 := ReadKey;   
       case ch1 of   
         #00 : begin   
                 ch2:=ReadKey;   
                 displaykey(ch1,ch2);   
                 case ch2 of   
                   #80 : begin   
                           writeln('  POSITION: going to BOT_BAR routine');   
                           bot_bar;   
                           writeln('  POSITION: back from BOT_BAR routine');   
                         end;   
                   #72 : begin   
                           writeln('  POSITION: going to TOP_BAR routine');   
                           top_bar;   
                           writeln('  POSITION: back from TOP_BAR routine');   
                         end;   
                 end;   
               end;   
       else   
         displaykey(ch1,ch2);   
       end; {case ch1}   
     until ch1=#13;   
     writeln('  POSITION: leaving POSITION routine');   
   end;   
   //### end position procedure ####################################   
      
   Begin   
     try   
       writeln('MAIN: going to INIT routine');   
       init;   
       writeln('MAIN: back from INIT routine');   
       writeln('MAIN: going to POSITION routine');   
       Position;   
       writeln('MAIN: back from POSITION routine');   
       writeln('MAIN: dump stringlist contents and free memory');   
     finally   
       if Assigned(theoneliners) then   
         FreeAndNil(theoneliners);   
     end;   
   End.   
      
   ==== End "myoneliners.pas" ====   
      
   )\/(ark   
      
   Always Mount a Scratch Monkey   
      
   ... Machine-independent Program: program which will not run on any machine.   
   ---   
    * Origin:  (1:3634/12.73)