home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / music / 194 / pascal / pascal.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1987-11-18  |  16.8 KB  |  663 lines
  1. {$S2}
  2. PROGRAM Pas_Main ;
  3.  
  4.   CONST
  5.     {$I gemconst.pas}
  6.     {$I pascal.i}
  7.     max_option = 30 ;       { Maximum number of options in one dialog }
  8.  
  9.   TYPE
  10.     {$I gemtype.pas}
  11.     opt_range = 1..max_option ;
  12.     opt_array = PACKED ARRAY [ opt_range ] OF boolean ;
  13.     opt_set = SET OF opt_range ;
  14.     prog_name = PACKED ARRAY [ 1..13 ] OF char ;
  15.     cmd_tail = PACKED ARRAY [ 0..255 ] OF char ;
  16.     environment = cmd_tail ;
  17.     env_ptr = ^environment ;
  18.  
  19.   VAR
  20.     envp : env_ptr ;
  21.     zero_word : integer ;
  22.     menu : Menu_Ptr ;
  23.     dummy : integer ;
  24.     last_was_gem,
  25.     link_gem : boolean ;        { The only link option! }
  26.     cmp_opts : opt_array ;
  27.     bad_res,
  28.     temp_path,
  29.     addl_files,
  30.     addl_libs : Str255 ;
  31.     work_path,
  32.     cmp_name,
  33.     link_name,
  34.     edit_name,
  35.     run_name : Path_Name ;
  36.     fullx, fully, fullw, fullh : integer ;
  37.  
  38.   {$I gemsubs.pas}
  39.  
  40.   PROCEDURE Form_Dial( cmd, sx, sy, sw, sh, ex, ey, ew, eh : integer ) ;
  41.     EXTERNAL ;
  42.   PROCEDURE Obj_Draw(dial: Dialog_Ptr; start, depth, cx, cy, cw, ch: integer);
  43.     EXTERNAL;
  44.   PROCEDURE IO_Check( on : boolean ) ;
  45.     EXTERNAL ;
  46.   FUNCTION IO_Result : integer ;
  47.     EXTERNAL ;
  48.  
  49.  
  50.  
  51. { Do_About - Perform the "Personal Pascal Info" Dialog box. }
  52.  
  53.   PROCEDURE Do_About ;
  54.  
  55.     VAR
  56.       about : Dialog_Ptr ;
  57.  
  58.     BEGIN
  59.       Find_Dialog( PASINFO, about ) ;
  60.       Center_Dialog( about ) ;
  61.       dummy := Do_Dialog( about, 0 ) ;
  62.       Obj_SetState( about, INFOBTN, None, true ) ;
  63.       End_Dialog( about ) ;
  64.     END ;
  65.  
  66.  
  67.  
  68. PROCEDURE Set_Defaults ;
  69.  
  70.   TYPE
  71.     c_path = PACKED ARRAY [ 1..80 ] OF char ;
  72.  
  73.   VAR
  74.     opt : opt_range ;
  75.     path : c_path ;
  76.     i : integer ;
  77.  
  78.   FUNCTION d_getdrv : integer ;
  79.     GEMDOS( $19 ) ;
  80.  
  81.   PROCEDURE d_getpath( VAR path_buf : c_path ; drive : integer ) ;
  82.     GEMDOS( $47 ) ;
  83.  
  84.   BEGIN
  85.     FOR opt := 1 TO max_option DO
  86.       IF opt IN [ FORGEM,ERRPAUSE,CHNLINK,DBGOPT,STKOPT,RNGOPT ]
  87.         THEN cmp_opts[ opt ] := true ;
  88.     work_path[1] := chr( ord('A') + d_getdrv ) ;
  89.     work_path[2] := ':' ;
  90.     d_getpath( path, 0 ) ;      { Get default path } ;
  91.     i := 1 ;
  92.     WHILE (path[i] <> chr(0)) AND (path[i] <> ' ') AND (i <= 64 ) DO
  93.       BEGIN
  94.         work_path[i+2] := path[i] ;
  95.         i := i + 1 ;
  96.       END ;
  97.     i := i + 1 ;
  98.     work_path[0] := chr(i) ;
  99.     work_path := concat( work_path, '\*.PAS' ) ;
  100. (* Personal Pascal clears all globals to 0's!
  101.     temp_path[0] := chr(0) ;
  102.     edit_name[0] := chr(0) ;
  103.     run_name[0]  := chr(0) ;
  104.     addl_files[0] := chr(0) ;
  105.     addl_libs[0]  := chr(0) ;
  106. *)
  107.     last_was_gem := true ;
  108.     link_gem := true ;
  109.   END ;
  110.  
  111.  
  112.  
  113. PROCEDURE Read_Options ;
  114.  
  115.   VAR
  116.     f : text ;
  117.     version : integer ;
  118.     temp : integer ;
  119.     opt : opt_range ;
  120.  
  121.   BEGIN
  122.     IO_Check( false ) ;
  123.     reset( f, 'PASCAL.INF' ) ;
  124.     IO_Check( true ) ;
  125.     IF IO_Result = 0 THEN
  126.       BEGIN
  127.         readln( f, version ) ;
  128.         FOR opt := 1 TO max_option DO
  129.           IF opt IN [ FORGEM,ERRPAUSE,CHNLINK,DBGOPT,STKOPT,RNGOPT,CLROPT ]
  130.            THEN
  131.             BEGIN
  132.               readln( f, temp ) ;
  133.               cmp_opts[ opt ] := temp <> 0 ;
  134.             END ;
  135.         readln( f, temp ) ;
  136.         link_gem := temp <> 0 ;
  137.         readln( f, temp_path ) ;
  138.         readln( f, addl_files ) ;
  139.         readln( f, addl_libs ) ;
  140.         IF length( temp_path ) <> 0 THEN
  141.           work_path := concat( temp_path, '*.PAS' ) ;
  142.       END
  143.   END ;
  144.  
  145.  
  146.  
  147. PROCEDURE Save_Options ;
  148.  
  149.   VAR
  150.     f : text ;
  151.     junk : integer ;
  152.     alert : Str255 ;
  153.     opt : opt_range ;
  154.  
  155.   BEGIN
  156.     IO_Check( false ) ;
  157.     rewrite( f, 'PASCAL.INF' ) ;
  158.     IO_Check( true ) ;
  159.     IF IO_Result <> 0 THEN
  160.       BEGIN
  161.         Find_Alert( ERROPTS, alert ) ;
  162.         junk := Do_Alert( alert, 1 ) ;
  163.       END
  164.     ELSE
  165.       BEGIN
  166.         writeln( f, $100:1 ) ;  { Version 1.00 }
  167.         FOR opt := 1 TO max_option DO
  168.           IF opt IN [ FORGEM,ERRPAUSE,CHNLINK,DBGOPT,STKOPT,RNGOPT,CLROPT ]
  169.            THEN
  170.             writeln( f, ord( cmp_opts[opt] ):1 ) ;
  171.         writeln( f, ord( link_gem ):1 ) ;
  172.         writeln( f, temp_path ) ;
  173.         writeln( f, addl_files ) ;
  174.         writeln( f, addl_libs ) ;
  175.       END
  176.   END ;
  177.  
  178.  
  179.  
  180. PROCEDURE bconin( dev : integer ) ;     { Really a function! }
  181.   BIOS( 2 ) ;
  182.  
  183. PROCEDURE bconout( dev, c : integer ) ;
  184.   BIOS( 3 ) ;
  185.  
  186. PROCEDURE out_esc( c : char ) ;
  187.  
  188.   BEGIN
  189.     bconout( 2, 27 ) ;
  190.     bconout( 2, ord(c) ) ;
  191.   END ;
  192.  
  193. PROCEDURE Tos_Screen ;
  194.  
  195.   BEGIN
  196.     Hide_Mouse ;
  197.     out_esc( 'E' ) ;        { Clear screen }
  198.     out_esc( 'e' ) ;        { and cursor on }
  199.   END ;
  200.  
  201.  
  202.  
  203. PROCEDURE Redraw_Screen ;
  204.  
  205.   BEGIN
  206.     Form_Dial( 3, 0, 0, 0, 0, fullx, fully, fullw, fullh ) ;
  207.   END ;
  208.  
  209.  
  210.  
  211. PROCEDURE Gem_Screen ;
  212.  
  213.   BEGIN
  214.     out_esc( 'f' ) ;        { Cursor off }
  215.     Show_Mouse ;
  216.   END ;
  217.  
  218.  
  219.  
  220. FUNCTION Call_Overlay( prog : prog_name ; VAR cmd_line : Str255 ;
  221.                             tos : boolean ) : integer ;
  222.  
  223.   VAR
  224.     i : integer ;
  225.     tail : cmd_tail ;
  226.  
  227.   FUNCTION p_exec( load : integer ; VAR name : prog_name ;
  228.                     VAR tail : cmd_tail ; VAR envp : env_ptr ) : integer ;
  229.     GEMDOS( $4B ) ;
  230.  
  231.   BEGIN
  232.     FOR i := 1 TO length( cmd_line ) DO
  233.       tail[i] := cmd_line[i] ;
  234.     tail[ length(cmd_line)+1 ] := chr(0) ;
  235.     tail[0] := chr( length(cmd_line) ) ;
  236.     prog[13] := chr(0) ;
  237.     Erase_Menu( menu ) ;
  238.     IF tos THEN
  239.       Tos_Screen ;
  240.     Call_Overlay := p_exec( 0, prog, tail, envp ) ;
  241.     IF tos THEN
  242.       Gem_Screen ;
  243.     Redraw_Screen ;
  244.     Draw_Menu( menu ) ;
  245.   END ;
  246.  
  247.  
  248.  
  249. { Strip_Extension - Remove the extension from a Path_Name variable. }
  250.  
  251. PROCEDURE Strip_Extension( VAR fn : Path_Name ) ;
  252.  
  253.   VAR
  254.     i : integer ;
  255.     done : boolean ;
  256.  
  257.   BEGIN
  258.     i := length( fn ) ;
  259.     done := false ;
  260.     WHILE NOT done DO
  261.       BEGIN
  262.         IF i < 1 THEN
  263.           done := true
  264.         ELSE IF (fn[i] = ':') OR (fn[i] = '\') THEN
  265.           done := true
  266.         ELSE IF fn[i] = '.' THEN
  267.           BEGIN
  268.             fn[0] := chr(i-1) ;
  269.             done := true ;
  270.           END
  271.         ELSE
  272.           i := i - 1 ;
  273.       END ;
  274.   END ;
  275.  
  276.  
  277.  
  278. { Do_Link - Call the linker with a desired file as input. }
  279.  
  280. PROCEDURE Do_Link( name : Path_Name ; for_gem : boolean ) ;
  281.  
  282.   VAR
  283.     junk : integer ;
  284.     extension : STRING [ 5 ] ;
  285.     libs : STRING ;
  286.     cmd_line : Str255 ;
  287.     x, y, w, h : integer ;
  288.     dial : Dialog_Ptr ;
  289.  
  290.   BEGIN
  291.     last_was_gem := for_gem ;
  292.     Strip_Extension( name ) ;
  293.     cmd_line := name ;
  294.     IF for_gem THEN
  295.       BEGIN
  296.         extension := '.PRG=' ;
  297.         libs := ',PASGEM,PASLIB' ;
  298.       END
  299.     ELSE
  300.       BEGIN
  301.         extension := '.TOS=' ;
  302.         libs := ',PASLIB' ;
  303.       END ;
  304.     cmd_line := concat( '! ', name, extension, name ) ;
  305.     IF length(addl_files) > 0 THEN
  306.       cmd_line := concat( cmd_line, ',', addl_files ) ;
  307.     IF length(addl_libs) > 0 THEN
  308.       cmd_line := concat( cmd_line, ',', addl_libs ) ;
  309.     cmd_line := concat( cmd_line, libs ) ;
  310.     Find_Dialog( LOADING, dial ) ;
  311.     Set_DText( dial, LOADNAME, 'LINKER.PRG', System_Font, TE_Left ) ;
  312.     Center_Dialog( dial ) ;
  313.     Obj_Size( dial, Root, x, y, w, h ) ;
  314.     Obj_Draw( dial, Root, Max_Depth, x, y, w, h ) ;
  315.     junk := Call_Overlay( 'linker.prg   ', cmd_line, false ) ;
  316.   END ;
  317.  
  318.  
  319.  
  320. { Do_Compile - Call the compiler with a desired file as input. }
  321.  
  322. FUNCTION Do_Compile : integer ;
  323.  
  324.   VAR
  325.     cmp_code : integer ;
  326.     cmd_line : Str255 ;
  327.     name : Path_Name ;
  328.     x, y, w, h,
  329.     i : integer ;
  330.     dial : Dialog_Ptr ;
  331.  
  332.   BEGIN
  333.     last_was_gem := cmp_opts[ FORGEM ] ;
  334.     name := edit_name ;
  335.     Strip_Extension( name ) ;
  336.     cmd_line := concat( name, ' ', temp_path, ' /UGEM' ) ;
  337.     IF cmp_opts[ FORGEM ] THEN
  338.       cmd_line := concat( cmd_line, ' /GEM' ) ;
  339.     IF cmp_opts[ ERRPAUSE ] THEN
  340.       cmd_line := concat( cmd_line, ' /PAUSE' ) ;
  341.     IF cmp_opts[ DBGOPT ] THEN
  342.       cmd_line := concat( cmd_line, ' /DEBUG' ) ;
  343.     IF NOT cmp_opts[ STKOPT ] THEN
  344.       cmd_line := concat( cmd_line, ' /NOCHECK' ) ;
  345.     IF cmp_opts[ RNGOPT ] THEN
  346.       cmd_line := concat( cmd_line, ' /CHECK' ) ;
  347.     IF cmp_opts[ CLROPT ] THEN
  348.       cmd_line := concat( cmd_line, ' /CLEAR' ) ;
  349.     Find_Dialog( LOADING, dial ) ;
  350.     Set_DText( dial, LOADNAME, 'COMPILER.PRG', System_Font, TE_Left ) ;
  351.     Center_Dialog( dial ) ;
  352.     Obj_Size( dial, Root, x, y, w, h ) ;
  353.     Obj_Draw( dial, Root, Max_Depth, x, y, w, h ) ;
  354.     cmp_code := Call_Overlay( 'compiler.prg ', cmd_line, false ) ;
  355.     Do_Compile := 0 ;
  356.     IF cmp_code = 2 THEN        { User wants to edit! }
  357.       BEGIN
  358.         Do_Compile := 1 ;
  359.         i := 0 ;
  360.         WHILE envp^[i] <> chr(0) DO
  361.           BEGIN
  362.             edit_name[i+1] := envp^[i] ;
  363.             i := i + 1 ;
  364.           END ;
  365.         edit_name[0] := chr(i) ;
  366.       END
  367.     ELSE IF (cmp_code = 0) AND (cmp_opts[ CHNLINK ]) THEN
  368.       Do_Link( name, cmp_opts[FORGEM] ) ;
  369.   END ;
  370.  
  371.  
  372.  
  373. { Do_Edit - Pass control to the Lohse editor. }
  374.  
  375. FUNCTION Do_Edit : integer ;
  376.  
  377.   VAR
  378.     cmd_line : Str255 ;
  379.     i : integer ;
  380.  
  381.   BEGIN
  382.     cmd_line := edit_name ;
  383.     IF Call_Overlay( 'editor.prg   ', cmd_line, true ) = 1 THEN
  384.       Do_Edit := 2
  385.     ELSE
  386.       Do_Edit := 0 ;
  387.   END ;
  388.  
  389.  
  390.  
  391. { Compile_Edit - Loop for "compile-edit-link" process. }
  392.  
  393. PROCEDURE Compile_Edit( which : integer ) ;
  394.  
  395.   VAR
  396.     i : integer ;
  397.  
  398.   BEGIN
  399.     Strip_Extension( work_path ) ;
  400.     work_path := concat( work_path, '.PAS' ) ;
  401.     IF Get_In_File( work_path, edit_name ) AND (length(edit_name) <> 0) THEN
  402.       WHILE which <> 0 DO
  403.         BEGIN
  404.           IF which = 1 THEN     { Editor phase! }
  405.             BEGIN
  406.               which := Do_Edit ;
  407.               FOR i := length( edit_name ) DOWNTO 1 DO
  408.                 IF edit_name[i] = ' ' THEN
  409.                   edit_name[0] := chr( i-1 ) ;
  410.             END
  411.           ELSE
  412.             which := Do_Compile ;
  413.         END ;
  414.   END ;
  415.  
  416.  
  417.  
  418. PROCEDURE Call_Linker ;
  419.  
  420.   BEGIN
  421.     Strip_Extension( work_path ) ;
  422.     work_path := concat( work_path, '.O' ) ;
  423.     IF Get_In_File( work_path, link_name ) AND (length(link_name) <> 0) THEN
  424.       Do_Link( link_name, link_gem ) ;
  425.   END ;
  426.  
  427.  
  428.  
  429. PROCEDURE Call_Program ;
  430.  
  431.   TYPE
  432.     environment = PACKED ARRAY [ 1..9 ] OF char ;
  433.  
  434.   VAR
  435.     i : integer ;
  436.     name, tail : cmd_tail ;
  437.     env : environment ;
  438.  
  439.   PROCEDURE p_exec( load : integer ; VAR name, tail : cmd_tail ;
  440.                         VAR env : environment ) ;
  441.     GEMDOS( $4B ) ;
  442.  
  443.   FUNCTION Is_Gem_Name : boolean ;
  444.  
  445.     VAR
  446.       i : integer ;
  447.  
  448.     BEGIN
  449.       Is_Gem_Name := false ;
  450.       IF length( run_name ) > 3 THEN
  451.         BEGIN
  452.           i := length( run_name ) - 3 ;
  453.           IF (run_name[i]='.') AND (run_name[i+1]='P') AND (run_name[i+2]='R')
  454.            AND (run_name[i+3]='G') THEN
  455.             Is_Gem_name := true ;
  456.         END
  457.     END ;
  458.  
  459.   BEGIN
  460.     Strip_Extension( work_path ) ;
  461.     IF last_was_gem THEN
  462.       work_path := concat( work_path, '.PRG' )
  463.     ELSE
  464.       work_path := concat( work_path, '.TOS' ) ;
  465.     IF Get_In_File( work_path, run_name ) AND (length(run_name) <> 0) THEN
  466.       BEGIN
  467.         last_was_gem := Is_Gem_Name ;
  468.         tail[0] := chr(0) ;
  469.         tail[1] := chr(0) ;
  470.         FOR i := 1 TO length( run_name ) DO
  471.           name[i-1] := run_name[i] ;
  472.         name[ length(run_name) ] := chr(0) ;
  473.         env := 'PATH=A:\ ' ;
  474.         env[9] := chr(0) ;
  475.         Erase_Menu( menu ) ;
  476.         IF NOT last_was_gem THEN
  477.           Tos_Screen ;
  478.         p_exec( 0, name, tail, env ) ;
  479.         IF NOT last_was_gem THEN
  480.           BEGIN
  481.             writeln( 'Hit any key to continue...' ) ;
  482.             bconin( 2 ) ;       { Get a key from the BIOS! }
  483.             Gem_Screen ;
  484.           END ;
  485.         Redraw_Screen ;
  486.         Draw_Menu( menu ) ;
  487.       END
  488.   END ;
  489.  
  490.  
  491.  
  492. PROCEDURE Link_Options ;
  493.  
  494.   VAR
  495.     dial : Dialog_Ptr ;
  496.     button : integer ;
  497.  
  498.   BEGIN
  499.     Find_Dialog( LNKOPTS, dial ) ;
  500.     Center_Dialog( dial ) ;
  501.     IF link_gem THEN
  502.       BEGIN
  503.         Obj_SetState( dial, LFORGEM, Selected, false ) ;
  504.         Obj_SetState( dial, LFORTOS, Normal, false ) ;
  505.       END
  506.     ELSE
  507.       BEGIN
  508.         Obj_SetState( dial, LFORGEM, Normal, false ) ;
  509.         Obj_SetState( dial, LFORTOS, Selected, false ) ;
  510.       END ;
  511.     Set_DText( dial, LNKADDL, addl_files, System_Font, TE_Left ) ;
  512.     Set_DText( dial, LNKLIBS, addl_libs, System_Font, TE_Left ) ;
  513.     button := Do_Dialog( dial, LNKADDL ) ;
  514.     Obj_SetState( dial, button, Normal, true ) ;
  515.     End_Dialog( dial ) ;
  516.     IF button = LNKOK THEN
  517.       BEGIN
  518.         link_gem := Obj_State( dial, LFORGEM ) = Selected ;
  519.         Get_DEdit( dial, LNKADDL, addl_files ) ;
  520.         Get_DEdit( dial, LNKLIBS, addl_libs ) ;
  521.       END ;
  522.   END ;
  523.  
  524.  
  525.  
  526. { Compiler_Options - Allow the user to change various options within the
  527.     compiler by activating the "Personal Pascal Compiler Options" dialog. }
  528.  
  529. PROCEDURE Compiler_Options ;
  530.  
  531.   VAR
  532.     dial : Dialog_Ptr ;
  533.     button : integer ;
  534.     opt : opt_range ;
  535.  
  536.   BEGIN
  537.     Find_Dialog( CMPOPTS, dial ) ;
  538.     Center_Dialog( dial ) ;
  539.     { First, we need to ensure that the state of various dialog objects
  540.       matches the state of our internal variables! }
  541.     FOR opt := 1 TO max_option DO
  542.       IF opt IN [ FORGEM,ERRPAUSE,CHNLINK,DBGOPT,STKOPT,RNGOPT,CLROPT ]
  543.         THEN Obj_SetState( dial, opt, Normal, false ) ;
  544.     FOR opt := 1 TO max_option DO
  545.       IF opt IN [ ERRPAUSE,CHNLINK,DBGOPT,STKOPT,RNGOPT,CLROPT ] THEN
  546.         IF cmp_opts[ opt ] THEN
  547.           Obj_SetState( dial, opt, Checked, false ) ;
  548.     IF cmp_opts[ FORGEM ] THEN
  549.       Obj_SetState( dial, FORGEM, Selected, false )
  550.     ELSE
  551.       Obj_SetState( dial, FORTOS, Selected, false ) ;
  552.     Set_DText( dial, TEMPPATH, temp_path, System_Font, TE_Left ) ;
  553.     button := Do_Dialog( dial, TEMPPATH ) ;
  554.     WHILE (button <> CMPOK) AND (button <> CMPCAN) DO
  555.       BEGIN
  556.         IF Obj_State(dial, button) = Normal THEN
  557.           Obj_SetState( dial, button, Checked, true )
  558.         ELSE
  559.           Obj_SetState( dial, button, Normal, true ) ;
  560.         button := Redo_Dialog( dial, TEMPPATH ) ;
  561.       END ;
  562.     Obj_SetState( dial, button, Normal, true ) ;
  563.     End_Dialog( dial ) ;
  564.     IF button = CMPOK THEN
  565.       BEGIN
  566.         FOR opt := 1 TO max_option DO
  567.           IF opt IN [ ERRPAUSE,CHNLINK,DBGOPT,STKOPT,RNGOPT,CLROPT ] THEN
  568.             cmp_opts[ opt ] := Obj_State( dial, opt ) = Checked ;
  569.         cmp_opts[ FORGEM ] := Obj_State( dial, FORGEM ) = Selected ;
  570.         Get_DEdit( dial, TEMPPATH, temp_path ) ;
  571.       END ;
  572.   END ;
  573.  
  574.  
  575.  
  576. { Do_Menu - Perform a menu operation which was selected by the user with the
  577.     mouse.  The chosen menu title and item are passed in the parameters
  578.     'title' and 'item', respectively. }
  579.  
  580.   FUNCTION Do_Menu( title, item : integer ) : boolean ;
  581.  
  582.     VAR
  583.       done : boolean ;
  584.  
  585.     BEGIN
  586. (*    Menu_Hilight( menu, title ) ; *)
  587.       done := false ;
  588.       CASE item OF
  589.         MIINFO:
  590.           Do_About ;
  591.         MIEDIT :    Compile_Edit( 1 ) ;
  592.         MICOMPIL :  Compile_Edit( 2 ) ;
  593.         MILINK :    Call_Linker ;
  594.         MIRUN:      Call_Program ;
  595.         MICMPOPT :  Compiler_Options ;
  596.         MILNKOPT :  Link_Options ;
  597.         MISAVOPT:   Save_Options ;
  598.         MIQUIT:     done := true ;
  599. (*      OTHERWISE:
  600.           done := Do_Alert( '[3][Not yet implemented...|Abort?][ Yes |No]', 0 )
  601.                     = 1 ; *)
  602.       END ;
  603.       Menu_Normal( menu, title ) ;
  604.       Do_Menu := done ;
  605.     END ;
  606.  
  607.   PROCEDURE Event_Loop ;
  608.  
  609.     VAR
  610.       which : integer ;
  611.       done : boolean ;
  612.       msg : Message_Buffer ;
  613.  
  614.     BEGIN
  615.       REPEAT
  616.         which := Get_Event( E_Message|E_Keyboard|E_Button, 1, 1, 1, 0,
  617.                     false, 0, 0, 0, 0, false, 0, 0, 0, 0,
  618.                     msg, dummy, dummy, dummy, dummy, dummy, dummy ) ;
  619.         IF which & E_Message <> 0 THEN
  620.           done := Do_Menu( msg[3], msg[4] ) ;
  621.       UNTIL done ;
  622.     END ;
  623.  
  624. FUNCTION Low_Resolution : boolean ;
  625.  
  626.   FUNCTION get_rez : integer ;
  627.     XBIOS( 4 ) ;
  628.  
  629.   BEGIN
  630.     Low_Resolution := (get_rez = 0) ;
  631.   END ;
  632.  
  633.   BEGIN
  634.     IF Init_Gem <> -1 THEN
  635.       BEGIN
  636.         IF NOT Load_Resource( 'pascal.rsc' ) THEN
  637.           dummy := Do_Alert( '[3][PASCAL.RSC not found!][ Cancel ]', 0 )
  638.         ELSE IF Low_Resolution THEN
  639.           BEGIN
  640.             Find_Alert( LOWRES, bad_res ) ;
  641.             dummy := Do_Alert( bad_res, 0 ) ;
  642.           END
  643.         ELSE
  644.           BEGIN
  645.             Set_Defaults ;
  646.             Read_Options ;
  647.             new( envp ) ;
  648.             envp^[0] := chr(0) ;
  649.             zero_word := 0 ;
  650.             Find_Menu( PASMENU, menu ) ;
  651.             Draw_Menu( menu ) ;
  652.             Border_Rect( 0, fullx, fully, fullw, fullh ) ;
  653.             Set_Mouse( M_Arrow ) ;
  654.             Do_About ;
  655.             Event_Loop ;
  656.             Erase_Menu( menu ) ;
  657.           END ;
  658.         Exit_Gem ;
  659.       END ;
  660.   END.
  661.  
  662. { End of pasmain.pas }
  663.