Converting Clarion to Native Web Apps

Clarion is a high-level programming language primarily used for developing database-driven Windows applications. It was originally developed by SoftVelocity and has been in use since the late 1980s. Clarion is known for its rapid application development (RAD) capabilities, making it a popular choice for creating business software and database applications. 

Today, however, Clarion apps have many disadvantages:

• As a legacy 4GL tool with a proprietary programming language, it's getting harder and harder to find engineering talent familiar with the tools and language.
• Clarion apps are captive to the desktop
• Clarion apps are old. Finding copies of the development environment to use for maintenance can be impossible, forcing an upgrade to a newer version.
• Clarion uses non-standard approaches to application design, architecture, and nomenclature.

Now is the time to modernize Clarion legacy applications

GAP has the tools, experience, and capabilities to accelerate your path off Clarion. Our automated migration tools parse the Clarion source code and generate C# and the .NET Framework. Let's look at some examples:

Organization

Clarion applications use MAPs and procedures to organize source code. MAPs containe prototypes, program names, local data, modules and source code. 

MEMBER('ProgramFile')
MAP
    MemberProc PROCEDURE
END

! Declarations
val    long

! Procedures
MemberProc PROCEDURE()
    CODE
        ! Procedure code would go here

In C#, that code would look like this:

public static class MemberFileName // the filename of the member module
{
    // Declarations are private because they can only be used
    // within this module in Clarion
    private static int val;
    
    // Procedures are migrated as methods within the class
    public static void MemberProc()
    {
        // procedure code would go here
    }
}

Here's what this looks like graphically: 

Program execution control

Clarion, like some other 4GL systems, will auto-generate source code from form inputs or the developer can write source code in procedures directly using the Clarion programming language, which is C-like but unique. Converting to C# means some language elements can go almost straight across; others need some finessing. Some examples:

CASE statements are often used to avoid a long string of IF statements testing for different conditions. Clarion has one unusual syntax variant of CASE: CASE OROF:

switch (Name[0])
CASE Name[1]    !Get first letter of name. Remember Clarion is 1-based program
  OF 'A' TO 'M'         
  OROF 'a' TO 'm'
    Message('In first half')
  OF 'N' TO 'Z'         
    Message('In second half')
  OROF 'n' TO 'z'       
    Message('In second half but lower case')
END

Converting to C#, we get:

switch (Name[0])
{
    case >= 'A' and <= 'M':
    case >= 'a' and <= 'm':
        Console.WriteLine("In first half");
        break;
    case >= 'N' and <= 'Z':
    case >= 'n' and <= 'z':
        Console.WriteLine("In second half");
        Console.WriteLine("In second half but lower case");
        break;
}

Expressions

Clarion uses expressions in its language, as basically all other procedural programming languages do. Expressions are just formulas for mathematical, string, or logical operations that produce a result. 

Where differences pop up is in the precedence of operators in an expressions; ie, the order in which they are evaluated. In Clarion, precedence is as follows: 

Expression evaluation in C# uses a different set of rules for precedence, you can see a detailed explanation here. This means as expressions get converted to C#, the expression may need to be modified to work correctly with different evaluation order.

String expressions are both common and complex in application code. Clarion is similar to C#, although concatenation uses the "&" character rather than the "+" character in C#. Here's some before and after code:

Clarion

! Variable declaration
StringPlusString STRING(30)
StringPlusVar    STRING(30)
StringPlusFormat STRING(30)
StringPlusNumber STRING(30)
StringPlusProc   STRING(30)
StringPlusExpr   STRING(30)
Name STRING(@S20) !A 20 character string picture field

! Variable usage
StringPlusString = 'Message: ' & 'Classified'      !Concatenate a constant and constant
StringPlusVar = Weight & 'lbs.'                    !Concatenate a constant and variable
StringPlusFormat = 'ID:' & FORMAT(UserId,@P##-##P) !Concatenate a constant and Format
StringPlusNumber = 'Local ' & 404                  !Concatenate a constant and Number
StringPlusProc = 'Time: ' & LocalTime()            !Concatenate a constant and procedure return
StringPlusExpr = 'Sum 8: ' & '5' + '3'             !Concatenate a constant and another expression

C#:

// Variable declaration
string StringPlusString;
string StringPlusVar;
string StringPlusFormat;
string StringPlusNumber;
string StringPlusProc;
string StringPlusExpr;
string Name;

// Variable usage
StringPlusString = "Message: " + "Classified";                  //Concatenate a constant and constant
StringPlusVar = Weight + "lbs.";                                //Concatenate a constant and variable
StringPlusFormat = "ID:" + string.Format("{0:##-##}", UserId);  //Concatenate a constant and Format
StringPlusNumber = "Local " + 404;                              //Concatenate a constant and Number
StringPlusProc = "Time: " + LocalTime();                        //Concatenate a constant and procedure return
StringPlusExpr = "Sum 8: " + (int.Parse("5") + int.Parse("3")); //Concatenate a constant and another expression

Expressions that set properties are a little less readable in Clarion than C#:

Clarion:

String:Field1{PROP:TEXT}

String:Field1{PROP:TEXT} = ''

List:Drive{PROP:IconList, 1} = 'drvlcl.ico'

PRINTER{PROPPRINT:Device}

R:Window$FoundCtl{PROP:ScreenText}

R:Window$FoundCtl{PROP:Text} = P:Value

C#:

Field1.Text

Field1.Text = ""

Drive.IconList[1] = "drvlcl.ico"
Classes
Printer.Device

Window.FoundCtl.ScreenText

Window.FoundCtl.Text = P.Value

Classes

Both Clarion and C# uses classes; a CLASS in Clarion is created when it is declared, although this behavior can be overridden with a TYPE attribute in the class definition. 

Clarion

MyClass class               !Both a data type declaration and an object instance
MyField byte
end

MyClass2 class, type        !Only a data type declaration
MyField byte
end

MyProcedure procedure()
MyNoInstanceObject &MyClass !Object reference
TwoClass &MyClass2          !Object reference
 CODE
 TwoClass &= NEW(MyClass2)  !New statement to start the object lifetime

C#

public class MyClass           // Data type declaration 
{         
 byte MyField;
}
MyClass MyClass = new();        // Object instance

public class MyClass2           // Only a data type declaration
{        
 byte MyField;
}

public void MyProcedure()
{
 MyClass MyNoInstanceObject;  
 MyClass2 TwoClass;             // Object references
 MyNoInstanceObject = new();
 TwoClass = new();              // New statement to start the object lifetime
}

Learn more

Large, complex Clarion applications can be cumbersome to rewrite since so much of the code and logic is hidden behind the 4GL user interface and non-standard programming patterns. If you would like to see some of your Clarion code as C#, click the "Talk to an Engineer" button at the top of the page for a in-depth discussion with our team.