10 Jun 16 21:10, you wrote to me:

 ml>> what is your bot_bar procedure?
 ml>>

 JL> --snip---

 JL> Procedure bot_bar;

i've gone back to your original post where i asked you if you were still stuck
on this... it needs a few additional items added to make it stand alone for
development and testing... a routine or two and the display files... i have no
idea what they are supposed to contain so in plain ascii, what do the files
onen.ans, oney.ans, oneh.ans contain? i'm guessing that oneh.ans is a header of
 some kind and maybe the others are yes and no prompts but what are they
prompting? i just need simple basics to work with... here's what i've worked up
 with full debugging and my displaykey routine... i don't see any problem with
the UPARR or DNARR keys and getting into either TOP_BAR or BOT_BAR... here's
everything i have and the display files at the bottom...

NOTE: this message is over 475 lines long...


==== Begin "oneliners.pas"  ====
program oneliners;
{$mode objfpc}

uses
  crt, classes, sysutils;

type
  userrec=record
            name : string[36];
          end;

var  Twriters  : array[1..10] of string;
var  Toneliner : array[1..10] of string;
var  S         : string;
var  Foneline  : string;
var  Ch1       : char;
var  Ch2       : char;
var  Count2    : byte;
var  thisuser  : userrec;

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.sorted := false;
  filecontents := TStringList.Create;
  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 : byte;

Begin
  writeln('  SHOW: entering SHOW routine');
  writeln('  SHOW: going to PRINTF(''oneh.ans'')');
  printf('oneh.ans');
  writeln('  SHOW: back from PRINTF(''oneh.ans'')');
  writeln('  SHOW: displaying current oneliners');
  For Count := 1 To 10 Do
    Begin;
      write(Twriters[Count],' - ');
      WriteLn(Toneliner[Count]);
    End;
  writeln('  SHOW: finished displaying current oneliners');
  writeln('  SHOW: leaving SHOW routine');
End; // show
//### end show procedure ########################################

//### begin init procedure ######################################
Procedure init;

Var f1 : textfile;
var Count : byte;
var myfilecode : word;

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: look for oneliner.lst');
  fOneLine := ('./oneliner.lst');
  If Not fileExists(fOneLine) Then
    Begin
      writeln('  INIT: creating oneliner.lst with default entries');
      Assign(f1, fOneLine);
      ReWrite(f1);
      For Count := 1 To 10 Do
        Begin
          WriteLn(f1,'Ia! Cthulhu!');
          WriteLn(f1,'IGNATIUS');
        End;
      Close(f1);
    End;

  writeln('  INIT: reading oneliner.lst');
  Assign(f1, fOneLine);
// make sure to turn off iochecking if using IoResult
  {$I-}
  Reset(f1);
// turn iochecking back on
  {$I+}
// grab the IoResult to our own variable
  myfilecode := IoResult;
// reverse the logic from "= 0" to "<> 0" so we can print an error message
  If myfilecode <> 0 Then
    begin
      writeln('  INIT: ioresult ',myfilecode,' while reading oneliner.lst');
      writeln('  INIT: aborting program');
      halt;
    end
  else
    Begin
      For Count := 1 To 10 Do
        Begin
          ReadLn(f1, Toneliner[Count]);
          ReadLn(f1, Twriters[Count]);
        End;
      Close(f1);
    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(''onen.ans'')');
  printf('onen.ans');
  writeln('  BOT_BAR: back from PRINTF(''onen.ans'')');
  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;

Var f1 : textfile;
var Count : byte;

Begin
  writeln('  TOP_BAR: entering TOP_BAR routine');
  ch1 := #00;
  ch2 := #00;
  writeln('  TOP_BAR: going to PRINTF(''oney.ans'')');
  printf('oney.ans');
  writeln('  TOP_BAR: back from PRINTF(''oney.ans'')');
  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(''oneline.asc'')');
      printf('oneline.asc');
      writeln('  TOP_BAR: back from PRINTF(''oneline.asc'')');
      // temp readln replacing inputl to avoid needing entire impulse code
      readln(s);
      If s = '' then
        Begin
          WriteLn('aborted');
          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;

      For Count := 1 To 9 Do
        Begin
          Count2 := Count + 1;
          Toneliner[Count] := Toneliner[Count2];
          Twriters[Count] := Twriters[Count2];
        End;

      tWriters[10]:=thisuser.name;
      tOneliner[10] := s;

      Assign(f1, fOneLine);
      ReWrite(f1);
      For Count := 1 To 10 do
        Begin
          WriteLn(f1,tOneliner[Count]);
          WriteLn(f1,tWriters[Count]);
        End;
      Close(f1);
    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
  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');
End.

==== End "oneliners.pas" ====



==== Begin "oneh.ans"  ====

                          ONELINERS! Whoohoo!

                  Displaying 10 most recent oneliners.
===============================================================================
==== End "oneh.ans" ====



==== Begin "onen.ans"  ====

this is onen.ans. what is it supposed to say?

==== End "onen.ans" ====



==== Begin "oney.ans"  ====

Do you want to add to the oneliners? ENTER=Yes, any other key=no

==== End "oney.ans" ====



==== Begin "oneline.asc"  ====

this is oneline.asc. what is it supposed to say??

==== End "oneline.asc" ====



==== Begin "oneliner.lst"  ====
Ia! Cthulhu!
IGNATIUS
Ia! Cthulhu!
IGNATIUS
Ia! Cthulhu!
IGNATIUS
Ia! Cthulhu!
IGNATIUS
Ia! Cthulhu!
IGNATIUS
Ia! Cthulhu!
IGNATIUS
Ia! Cthulhu!
IGNATIUS
Ia! Cthulhu!
IGNATIUS
foobery foober foo
my goofy user
this is my oneliner!
my goofy user
==== End "oneliner.lst" ====


)\/(ark

Always Mount a Scratch Monkey

... Men find it difficult to make eye contact cause breasts don't have eyes.
---
 * Origin:  (1:3634/12.73)