Full-View - Windows for Pick

The usage of the FULL-VIEW pre-compiler is discussed later on in this chapter. An overview of what the pre-compiler does will be presented at this point so that you can more fully understand what some of the FULL-VIEW functions are trying to accomplish.

The following areas of BASIC are processed by the FULL-VIEW pre-compiler:

INPUT STATEMENTS

FULL-VIEW also supports some versions of the INPUT @(X,Y) statements including use of validation masks. Unfortunately, different Pick implementations have functionally different methods of processing INPUT @(X,Y) statements and so FULL-VIEW's method of processing this statement may be different from the system's method for your particular machine. FULL-VIEW processes this statement to be compatible with Ultimate's Pick implementation. This implementation was chosen mainly because it seems to be without bugs (unlike some other implementations), and in general it makes sense to write programs in this manner.

FULL-VIEW FUNCTIONS

FULL-VIEW EXTERNAL SUBROUTINES

SMART-TREE SUPPORT

For example, if you have a program file named BP, you would create this workfile by typing:

    CREATE-FILE DATA BP,COMPILE.SOURCE 11,1

    PC filename itemlist {/options}

The "itemlist" is a list of item-ids, separated by spaces, of the programs that you wish to compile. A "]" may be specified to compile all programs and if the "itemlist" is blank, any active SELECT list may be used.

The "options" are single letters that are used to control various functions of the pre-compiler. Available option letters are:

B

Do not compile the code after it is generated.

C

Compile with the alternate syntax file. This option is used to interface applications with the SMART-TREE BTREE system without interfacing with the windowing functions.

D

Do not delete the generated code from the workfile. This allows you to examine the code to more fully understand what the pre-compiler is doing.

E

Edit the generated code after it is compiled. The pre-compiler will EXECUTE the system editor, allowing examination of the generated code.

A

Execute the BASIC command with a (C) option.

M

Execute the BASIC command with an (M) option.

S

Execute the BASIC command with an (S) option.

Q

Do not crunch the output code. The pre-compiler will normally try to crunch the main-line code by replacing any line longer than 25 characters with an INCLUDE of that line. This makes the main-line program much smaller and will usually allow you to compile nearly any program regardless of size. However, if you wish to examine the pre-compiled output (i.e. with the E option), this makes the program very difficult to read. This option is only significant on systems that; a) have INCLUDE or $INCLUDE; b) do not have $CHAIN; and c) are not unlimited item-size implementations.

• Compile a single program.

  
  

    PC BP CUST.FILE.MAINT

• Compile several programs.

  
  

    PC BP CUST.FILE.MAINT CUST.ACCT.MAINT

• Compile all programs within a file.

  
  

    PC BP *

• Compile programs from a SELECT list.

  
  

    GET-LIST PROGRAMS.LIST
    PC BP

• Compile a program and then edit the generated code.

  
  

    PC BP CUST.FILE.MAINT /D
    ED BP,COMPILE.SOURCE CUST.FILE.MAINT

*$PC OFF

Turn the pre-compiler off for lines that follow.

Turn the pre-compiler back on for lines that follow.

Begin using the specified syntax file for the lines that follow.

1. The pre-compiler has a limitation of the amount of code that it can process on some systems. This limitation comes from the fact that the pre-compiler is itself a BASIC program and BASIC string space is limited on some machines. The pre-compiler tries very hard to get around this situation, but it is still remotely possible that you may have a program that hits this limitation.

   
   

2. The pre-compiler can, at an absolute maximum, generate programs that are 32K on any machine that is not unlimited item-size. This limitation is actually delayed if the machine which you are on supports either $CHAIN or INCLUDE/$INCLUDE. If you system supports $CHAIN, the generated program will automatically link to extension programs when they get to large. If your system only supports INCLUDE or $INCLUDE, the pre-compiler will try to compress your program by changing large lines into included items that are one line long each.

   
   

3. The pre-compiler supports most formats of INCLUDE, INSERT, and $CHAIN with the following syntax's:

   
   

    INCLUDE item
    INCLUDE file item
    INCLUDE item FROM file
    $INCLUDE item
    $INCLUDE file item
    INSERT item
    INSERT file item
    $INSERT item
    $INSERT file item
    $CHAIN item
    $CHAIN file item

INCLUDE operates with the pre-compiler even on those systems where the operating system does not support INCLUDE.

1. If you pre-compile a program on a system that does not support a native INCLUDE-type statement, you may have difficulty with some IF/THEN/ELSE syntax forms within the included module. The problems only occur with statements that are single-line forms of the IF statement or include forms such as END ELSE IF ... on a single line.

   
   

2. Statements that contain system delimiters within quotes (value or sub-value marks) will fail to compile correctly if they are also within statements that the pre-compiler is processing. With SMART-TREE, these statements include:

   
   

3. File I/O statements.
   
4. INCLUDEd statements.
   

1. Single-line IF THEN ELSE type statements may fail to compile correctly if they are on the same line as statements that are pre-compiled. This is due to difficulties that the pre-compiler has in determining which ELSE or END clause goes with which IF or THEN clause. You should note that some Pick vendor's BASIC compilers have similar trouble, so it is a good idea to not use single-line IF THEN ELSE statements in all but the simplest cases.
   

SUBROUTINES THAT ARE ACTUALLY IMPLEMENTED AS MACROS

    GET.SCR                 START.CHILD.SUB         GET.SCR.DATA
    GET.SCR.PARMS           PRINT.MESSAGE           GET.SCR.STATUS
    SENTENCE                GET.SCR.WINDOW

SUBROUTINES THAT ACTUALLY CALL EXTERNAL SUBROUTINES