Informix-4GL

Origins

Informix-4GL (I-4GL) is a fourth-generation programming language ( 4GL, hence it's name), developed by Informix Corporation during the mid-1980s, as an evolution of its earlier Informix SQL (ISQL) toolset — launched in 1984 for character-based applications. It was specifically designed for the rapid development of client-side business applications connected to relational databases like Informix.

Development of Informix-4GL began in 1985 at Informix Corporation, then operating as Relational Database Systems, under the leadership of chief architect Chris Maloney and Roy Harrington. The language evolved from ISQL, integrating ISQL's forms (Perform) and reporting (Ace) capabilities with added procedural extensions for customization, validation, and navigation.

Additionally, Informix Corporation bundled complementary CASE tools from FourGen Software Technologies, Inc. ("FOURGEN"), founded in 1983 in Seattle, to support Rapid Application Development (RAD) with Informix and IBM DB2 databases. Marketed until 1996 as "Forms" and "Menu" components, these tools extended Informix-4GL's capabilities for screen design and navigation. In 1995, FourGen shifted its strategic focus to enterprise Document Management System (DMS) solutions, and the company underwent a series of corporate transitions—becoming Endura Software Corporation, merging into HK Systems, Inc., and subsequently transitioning to Irista, Inc.—before its financial and document-management assets, including FourGen intellectual property, were acquired by Gillani, Inc. in 2002.^[5]

Informix-4GL enhancements in the 1990s and 2000s added ANSI SQL compliance, transaction handling (e.g., isolation levels like READ COMMITTED), cross-platform portability to Windows, Linux, and AIX, and integration with ESQL/C for embedding SQL in C code.^[6]

IBM Acquisition

Following Informix's acquisition by IBM in 2001 for $1 billion^[7], I-4GL was rebranded as IBM Informix-4GL and integrated into the broader Informix ecosystem, supporting versions of Informix Dynamic Server (IDS) up to 12.10.

By the mid-2000s, IBM positioned Informix-4GL as a legacy tool for modernization, recommending migration to Enterprise Generation Language (EGL) within Rational Software Development Platform for web-enabled, J2EE-compatible applications addressing limitations like character-only UIs and tight Informix dependency.^[6]

Despite its age, Informix-4GL remained widely used to develop business applications, and a sizable market still exists around it due to its popularity.^[8] With accounting being an inherently text based activity, it is often chosen for its purely text-based interface to optimize data entry efficiency. These tools are available today on major flavors of UNIX and Red Hat Linux and SUSE Linux operating systems.

Recent history

In April 2017, IBM signed an agreement with HCL Technologies, delegating development, sales, and support of Informix products, including 4GL, to HCL while continuing to market it as IBM Informix, with a number of IBM employees working on Informix moving to HCL.^[9]

With the acquisition of Actian, now the Data Division of HCLSoftware, by HCL back in 2021^[10], it became responsible for the commercialization of the HCL Informix brand of products within the HCL group, which includes HCL Informix 4GL.

Informix-4GL C Compiler

The C Compiler uses a preprocessor to generate INFORMIX-ESQL/C source code. This code is preprocessed in turn to produce C source code, which is then compiled and linked as object code in an executable command file.^[12]

It is specifically designed to run as a client on a network, connected to an Informix database engine service. It has a mechanism for calling C functions and conversely, to be called from executing C programs. Applications compiled through the C Compiler executes faster, but compiles slower, executables are bigger, and may not be as portable as applications compiled through RDS.

The following list details the steps performed when generating an executable through the Informix-4GL C Compiler.^[13]

1. The 4GL source code is converted into ESQL/C statements, producing a corresponding embedded SQL (.ec) file.
2. The ESQL/C code is converted into C Programming Language, producing a standard C (.c) file.
3. The C compiler processes the C code, yielding an object (.o) file.
4. The linker links the object files together with all appropriate libraries (.a files), and creates the actual executable program, which usually has a .4ge extension.

Informix-4GL RDS

The Informix-4GL Rapid Development System (RDS) uses a compiler to produce intermediate byte code, or pseudo-machine code (called p-code), in a single step, which is then executed by an interpreter.^[12]

In contrast to the Informix-4GL C Compiler, it skips steps 2 through 4 in the previous list, processing directly the 4GL code and producing a p-code file (.4go or .4gi, depending how the program is compiled), which can then be executed by the interpreter, or debugged by the debugger ^[13]

A particular feature is the comprehensive error checking which is built into the final executable and the extremely helpful error messages produced by both compilers and executables. It also features embedded modal statements for changing compiler and executable behavior (e.g. causing the compiler to include memory structures matching database schema structures and elements, or to continue executing in spite of error conditions, which can be trapped later on).

Informix-4GL SKUs

Following the distinction between the two main approaches—C Compiler and RDS—the Informix-4GL product line is organized into a set of SKUs that implement each model. Both tracks are typically offered in Developer and Runtime editions, with additional supporting components such as debugging tools and SQL connectivity modules. Together, these SKUs support the full lifecycle of Informix-4GL applications, from development to deployment and execution.

The following list summarizes the main Informix-4GL SKUs available today and their primary purpose:

• Informix 4GL C Compiler – Developer Edition: Complete environment for developing compiled 4GL applications in C. Allows writing, compiling, testing, and packaging programs for production.

• Informix 4GL C Compiler – Runtime Edition: License focused only on running already compiled 4GL applications. Used in production; does not include development tools.

• Informix 4GL Rapid Development System (RDS) – Developer Edition: RAD platform for creating interpreted 4GL applications (p-code), including forms, menus, and business logic. Focused on rapid development.

• Informix 4GL Rapid Development System (RDS) – Runtime Edition: Execution environment for applications generated in RDS. Allows running interpreted programs in production, without development resources.

• Informix 4GL Interactive Debugger: Debugging tool for 4GL applications (both C Compiler and RDS). Supports execution analysis, variables, and program flow.

• Informix 4GL SQL/Database Support Components: Components that support connectivity and execution of SQL commands in 4GL applications, integrating the runtime with the Informix database.

"Hello, world!" example

An example of a "Hello, World!" program in Informix-4GL:

MAIN
    DISPLAY "Hello, Informix 4GL!"
END MAIN

Assuming the code is located in a hello.4gl file, below are the step-by-step instructions for compiling and running it, using the Informix-4GL C Compiler.

% c4gl -o hello.4ge hello.4gl
% hello.4ge
Hello, Informix 4GL!

Variables and control flow

Informix-4GL provides a broad set of built-in data types for handling business data and integrates them with structured control-flow constructs. Variables are declared using the DEFINE statement, and program logic is expressed through readable procedural elements such as IF, CASE, WHILE, and FOREACH. Informix-4GL Compiled C code doesn't automatically initialize any variables, while p-code initializes all locally-defined variables to 0.^[13]

### Global variables ###
GLOBALS
DEFINE
 order_id INTEGER
END GLOBALS

MAIN
    ### Local variables ###
    -- Numeric types
    DEFINE quantity SMALLINT
    DEFINE total_amount DECIMAL(12,2)
    DEFINE discount_rate FLOAT    

    -- Character types
    DEFINE cust_name CHAR(30)
    DEFINE address VARCHAR(100)

    -- Date and time types
    DEFINE order_date DATE
    DEFINE created_at DATETIME YEAR TO SECOND
    DEFINE duration INTERVAL HOUR TO MINUTE

    -- Logical/flag usage (typically SMALLINT)
    DEFINE is_active SMALLINT

    -- Record (structured type)
    DEFINE customer RECORD
        customer_id INTEGER,
        first_name CHAR(30),
        last_name CHAR(30),
        credit_limit DECIMAL(10,2)
    END RECORD

    ### Variable assignment ###
    LET cust_name = "John Doe"
    LET quantity = 5
    LET total_amount = 250.00
    LET order_date = TODAY
    LET created_at = CURRENT YEAR TO SECOND
    LET duration = INTERVAL(2) HOUR TO MINUTE
    LET is_active = 1

    ### Control flow example ###
    IF total_amount > 100 THEN
        DISPLAY cust_name, "eligible for discount."
    END IF
    IF total_amount <= 100 THEN
        DISPLAY cust_name, "standard pricing applies."
    END IF
END MAIN

Embedded SQL

Informix 4GL supports embedded SQL for direct interaction with the database.

DATABASE stores

MAIN
    DEFINE cust_id INTEGER
    DEFINE cust_name CHAR(30)

    SELECT customer_num, fname
        INTO cust_id, cust_name
        FROM customer
        WHERE customer_num = 101

    DISPLAY cust_id, cust_name
END MAIN

Cursor example

MAIN
    DEFINE cust_id INTEGER
    DEFINE cust_name CHAR(30)

    DATABASE stores

    DECLARE c1 CURSOR FOR
        SELECT customer_num, fname FROM customer

    FOREACH c1 INTO cust_id, cust_name
        DISPLAY cust_id, cust_name
    END FOREACH
END MAIN

Functions

Functions in Informix-4GL encapsulate reusable logic and can accept input variables (parameters), and have associated values to be returned to the function that invoked it (return values), but can also be invoked without assigning the return value when used for procedural operations such as logging or validations. They are defined using the FUNCTION keyword and can be invoked from MAIN or other functions. Functions provide a structured way to implement reusable business logic within Informix-4GL applications.

MAIN
    DEFINE amount DECIMAL(10,2)
    DEFINE discount DECIMAL(10,2)

    LET amount = 150.00

    -- Calling the function
    LET discount = calculate_discount(amount)

    DISPLAY "Amount:", amount
    DISPLAY "Discount:", discount
END MAIN


FUNCTION calculate_discount(p_amount DECIMAL(10,2))
    DEFINE result DECIMAL(10,2)

    IF p_amount > 100 THEN
        LET result = p_amount * 0.10
    ELSE
        LET result = 0
    END IF

    RETURN result
END FUNCTION

Forms and user interaction

Informix-4GL includes native support for character-based user interfaces, allowing developers to define data entry screens, menus, and interaction flows directly in the language. Forms are typically defined in external ASCII form specification files (.per), which describe screen layout, fields, labels, and attributes.

These form files are compiled into binary form definitions and then referenced by 4GL programs for runtime interaction. This approach separates presentation from application logic while maintaining tight integration with database fields and records. While the instructions section to an ISQL Perform file was very important, this section inside a 4GL form file is optional,^[6] and thus was not used in this example.

Create the Form file: Design the form in an ASCII file (custform.per)

DATABASE stores

SCREEN
{
Customer Entry Form
-------------------
Customer Name:    [f001          ]
Customer Phone:   [f002          ]
Customer Address: [f003          ]
}
END

TABLES
customer

ATTRIBUTES
f001 = customer.customer_name;
f002 = customer.phone;
f003 = customer.address;
END

Compile the Form: Use the form compiler to create the compiled .frm file.

form4gl custform.per

Use the Form in 4GL Code: OPEN WINDOW defines the window and loads the compiled .frm file, DISPLAY FORM makes the form visible, and INPUT binds screen fields to database records or variables.

MAIN
    DEFINE cust_rec RECORD LIKE customer.*

    -- Open a window
    OPEN WINDOW w1 AT 1,1 WITH FORM "custform"

    -- Display the form
    DISPLAY FORM custform

    -- Input data
    INPUT cust_rec.customer_name, cust_rec.phone, cust_rec.address
        FROM f001, f002, f003

    CLOSE WINDOW w1
END MAIN