Today, however, Clarion apps have many disadvantages:
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:
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:
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;
}
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:
! 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
// 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#:
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
Field1.Text
Field1.Text = ""
Drive.IconList[1] = "drvlcl.ico"
Classes
Printer.Device
Window.FoundCtl.ScreenText
Window.FoundCtl.Text = P.Value
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.
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
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
}
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.
