Informix-4GL

Origins Informix-4GL (I-4GL) is a fourth-generation programming language (4GL, hence its 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. 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. IBM Acquisition Following Informix's acquisition by IBM in 2001 for $1 billion Despite its age, Informix-4GL remained widely used to develop business applications, and a sizable market still exists around it due to its popularity. 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. With the acquisition of Actian, now the Data Division of HCLSoftware, by HCL back in 2021, it became responsible for the commercialization of the HCL Informix brand of products within the HCL group, which includes HCL Informix 4GL. ==Description==

Informix-4GL includes embedded SQL, a report writer language, a form language, and a limited set of imperative capabilities (functions, if and while statements, arrays, etc.). The language is particularly close to a natural language and is easy to learn and use. The Form Painter, Screen Code Generator, Report Code Generator (Featurizer) enabled adding custom business logic. It also had, as additional components a menu system, and a front-end graphical user interface (GUI) called Generator. The 4GL portfolio is historically divided into two main lines: the C Compiler–based model (compiled applications) and the Rapid Development System (RDS) model (interpreted/p-code applications), with both options featuring complementary components, like an interactive debugger for dumb terminals and SQL/Database connectivity tools. 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. 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. • The 4GL source code is converted into ESQL/C statements, producing a corresponding embedded SQL (.ec) file. • The ESQL/C code is converted into C programming language, producing a standard C (.c) file. • The C compiler processes the C code, yielding an object (.o) file. • 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. 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 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. ==Informix-4GL Syntax==

Informix-4GL uses a procedural, business-oriented syntax designed for rapid development of database applications. The language integrates SQL statements directly into program logic and provides built-in constructs for forms, reports, and transaction handling. Its syntax is intentionally readable and close to natural language, reflecting its focus on business workflows rather than low-level programming. Overall, Informix-4GL syntax emphasizes tight integration with the database, structured procedural logic, and built-in support for user interaction, enabling the rapid development of data-centric business applications. A typical Informix-4GL program is structured around MAIN, function blocks, and database interaction statements. "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. • 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 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 keyword and can be invoked from 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, 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 ==Informix-4GL and other products==

Another flavor of Informix programming-tool produced was called Informix-NewEra, which supported object-oriented programming and a level of code-compatibility with Informix-4GL, while also trying to address its drawbacks, namely: it only handles a 'character' interface (older ASCII screen terminals); and it is 'database dependent', limited to the Informix database. However, for various reasons, Informix-NewEra arrived too late to the market and never gained adoption{{Cite web|title=INFORMIX'S NEW ERA IS NOT GONE – JUST NO LONGER RELEVANT allowing to modernize Informix-4GL applications, while preserving existing language knowledge and skills. These products are primarily: • Four Js Genero BDL – an x4GL programming language provided as part of the Genero platform by the French software company Four Js Development Tools (4Js). Genero BDL was inspired by and is largely compatible with Informix-4GL, preserving its syntax and database-centric programming model while extending it with modern user interfaces, multi-database connectivity, and cross-platform deployment capabilities. 4Js Genero is commonly used to modernize existing Informix-4GL applications while maintaining compatibility with legacy code and development practices. • Querix4GL – an x4GL programming language from the British developer Querix. Querix4GL is available under Querix Lycia, a complete development platform compatible with Informix-4GL, with graphical solutions based on Windows and Java, and with support to multiple databases. Querix launched Lycia, with an Eclipse-based environment, at the end of 2010. Later releases included a new state generator based on Jasper and BIRT, the integration of the Java language into 4GL applications, as well as new .NET and Web/mobile clients, HTML5 and Ajax technology. • Aubit 4GL – an Open Source x4GL toolkit licensed under the GNU General Public License. ==References==