IMPORT FGL module

Syntax

IMPORT FGL modulename 

1. modulename is an identifier defining the module to be imported (without the file extension).

Usage

With IMPORT FGL modulename, the symbols of the named .42m module can be referenced in the current module.

The name specified after the IMPORT FGL instruction is case-sensitive.

The imported module symbols that can be referenced are:

• Public functions
• Public constants
• Public types
• Public module variables

Compilation with IMPORT FGL

IMPORT FGL instructs the fglcomp compiler and fglrun runtime system to load/check the specified modules.

When using only IMPORT FGL to define module dependency, there is no longer a need to link programs or use libraries.

With IMPORT FGL, the compiler can check the number of parameters and returning values in functions calls, and the autocompletion in source code editors is improved as it can suggest all imported symbols.

Auto-compilation of (local) imported modules

It is recommended to compile imported modules before compiling the importing module.

The FGLLDPATH environment variable specifies the directories to search for the .42m modules used by IMPORT FGL.

When the imported module is located in the same directory as the compiled module, if the 42m file of the imported module does not exist, or is older than the corresponding source file, fglcomp will automatically compile the imported module.

Avoid circular module references

Circular references are not allowed. For example, when module A imports module B, which in turn imports module A, you cannot compile one of the modules because the 42m file of the imported module is needed.

In case of circular module reference, fglcomp will give error -8403, indicating that the imported module cannot be found:

IMPORT FGL module_b
FUNCTION func_a()
  CALL func_b()
END FUNCTION

IMPORT FGL module_a
FUNCTION func_b()
  CALL func_a()
END FUNCTION

Identify used modules with fglrun --print-imports

When migrating existing projects using traditional linking, after compiling all the .4gl sources, consider using the --print-imports option of fglrun, to print the IMPORT FGL suggestions for all the modules specified in the fglrun command line.

$ cat main.4gl
MAIN
    CALL func1()
END MAIN
$ cat mod1.4gl
FUNCTION func1()
   CALL func2()
END FUNCTION
$ cat mod2.4gl
FUNCTION func2()
   CALL func1()
END FUNCTION

$ fglrun --print-imports main.42m mod1.42m mod2.42m
-- in main.4gl
IMPORT FGL mod1

-- in mod1.4gl
IMPORT FGL mod2

-- in mod2.4gl
# Cyclic import: IMPORT FGL mod1
#   caused by CALL func1

Scope of module symbols (PRIVATE/PUBLIC)

The PRIVATE/PUBLIC modifiers can be used to hide / publish symbols to other modules.

PUBLIC DEFINE custlist DYNAMIC ARRAY OF RECORD
  id INT,
  name VARCHAR(50),
  address VARCHAR(200)
END RECORD
...
PRIVATE FUNCTION myfunction()
...
END FUNCTION

Resolving symbol name conflicts with module prefix

If a symbol is defined twice with the same name in two different modules, the symbol must be qualified by the name of the module.

This feature overcomes the traditional 4GL limitation, requiring unique function names within a program.

In the following example, both imported modules define the same "init()" function, but this can be resolved, by adding the module name followed by a dot before the function names:

IMPORT FGL orders 
IMPORT FGL customers 
MAIN
  CALL orders.init()
  CALL customers.init()
  ...
END MAIN

If a symbol is defined twice with the same name in the current and the imported module, an unqualified symbol will reference the current module symbol.

The following example calls the "init()" function with and without a module qualifier. The second call will reference the local function:

IMPORT FGL orders 
MAIN
  CALL orders.init()  -- orders module function 
  CALL init()  -- local function 
  ...
END MAIN
FUNCTION init()
  ...
END FUNCTION

Mixing IMPORT FGL and .42r linking

Traditional linking is still supported for backward compatibility. To ease migration from traditional linking to imported modules, you can mix IMPORT FGL usage with fgllink.

By default, even when IMPORT FGL is used, fglcomp does not raise an error, if a referenced function is not found in the imported modules. This is mandatory to compile the 42m file to be linked later with the module defining the missing function.

Use the -W implicit or the --resolve-calls option to check for imported functions.

For more details about the linker, see Linking programs.