Currently, all tests must be defined in Testing.cs. This can be solved more easily.

It could also be a proper test framework, such as XUnit be used.

I think there are a few more things to be done before the implementation. For example, the restructuring of the project structure. Tests should be in a separate folder.

Due to some fairly poor design on my part, we need a way to define an internal functions (BIFs, system APIs) pass type, e.g. by value/const or by reference.

It's different for user defined features because the VM handles whether it's a value or reference (at runtime):

• Handles passing by ref or value here (no typecheck): https://github.com/worksofbarry/NetRPG/blob/master/NetRPG/Language/Reader.cs#L1127
• Handles converting to/from ref (kind of type check?): https://github.com/worksofbarry/NetRPG/blob/master/NetRPG/Runtime/VM.cs#L169

Moral of the story is that Reader.cs somehow needs to know all the internal functions and their reference types in order to construct a correct bytecode, otherwise we may be stuck writing all internal functions as pass by reference only (and I don't think there are any BIFs that have that)

• https://github.com/worksofbarry/NetRPG/blob/master/NetRPG/Language/Reader.cs#L1076
• https://github.com/worksofbarry/NetRPG/blob/master/NetRPG/Language/Reader.cs#L1122

It looks like when a module is added to the virtual machine (VM class) all the global variables are added to a VM global variable list, when in fact each module has its own set of global variable. The export keyword is what makes it global across all modules, import would allow the user of a program global variable.

https://github.com/worksofliam/NetRPG/blob/master/NetRPG/Runtime/VM.cs#L54

Same goes for shared memory. Shared memory is only across modules, not whole programs.

Proven with this commit: 61551bb

The implementation of the CALL operation can be very useful. CALL should be not only accessible from RPG code. Executing the CALL operation from C# can be really useful too. For example to call RPG programs for testing. (See #19)

Is the support for older RPG Versions planned?

I think most of the production applications still use older RPG Versions in fixed format (RPG 3 / fixed ILE and upwards).

I just created the build-in function %subst (Substring). Following things are not working. I think these things should be processed on a higher level and not in the substring implementation because in other bif's are similar problems.

Case 1: Use substring to change values (working on i)

resultb = 'Hello';
%subst(resultb:1:1) = 'D';

resultb is still "Hello" and not "Dello"

Case 2: Preprocessing of arguments (working on i)

resultb = %subst('Hello World':5+2:10-7);

Failing because of calculations in the second and third argument.

Right now all the runtime functions are loaded whenever the VM starts:

https://github.com/worksofbarry/NetRPG/blob/master/NetRPG/Runtime/Functions/Function.cs#L10

Instead, we should only be loading the functions that are needed. This also means we can implement system APIs and load them based on the extproc.

Hey! Nice idea and project of you! I cloned it immediately after I discovered it.

Unfortunately 2 tests are not working at the moment.

time_bif_time1.rpgle returns "False" instead of "True"

bif_float.rpgle is printing "Float is not a ready data type."

Maybe they are not important but I think with every commit all tests should work. Maybe I'll take a look at it.

I found out while writing unit tests for printf that some of the other assignment operators have not been implemented.

As listed here: https://stackoverflow.com/a/24397216/4763757

Parsing it out will be no problem, but since the hex is in EBCDIC, we will need to convert that to a regular string.

Luckily, C# contains a bunch of EBCDIC encodings (not all of them!!) which we can use to convert hex at runtime:

• https://stackoverflow.com/a/724905/4763757
• https://docs.microsoft.com/en-us/dotnet/api/system.text.encoding.getencodings?view=netframework-4.8

This example on this issue will now allow for us to implement text only, numeric only, uppercase only, lower case only, max length, etc in NetRPG.

gui-cs/Terminal.Gui#265

Currently, all input boxes allow for numeric or character, even if it's specifically a numeric or character field.

https://www.ibm.com/support/knowledgecenter/en/ssw_ibm_i_72/rzasd/freectlopt.htm

Right now, we have RPG source code in the RPGCode directory and all other objects (like JSON tables and display files) in the objects folder. I believe we should consolidate all that source into one folder.

This means changing hardcoded paths in the some of the code.

NetRPG has a concept of system APIs called internal APIs, since they are internal to the VM.

It would be cool to create implementations of the QSNDDTAQ and QRCVDTAQ APIs.

You can see example RPG code here: https://www.mysamplecode.com/2012/03/as400-rpgle-data-queue-tutorial.html

Binding directories will have to work a little differently for NetRPG.

A binding directory could simply be a text file, which contains the path to the other modules which will be loaded at runtime.

The VM can may need to include new instructions to load modules (VM#AddModule) at runtime.

Every time we execute a procedure we are building the jump tables.

This can be seen here: https://github.com/worksofbarry/NetRPG/blob/master/NetRPG/Runtime/VM.cs#L187

This is only really noticeable when you are making use of procedures.

We can really make it better if we just build this table once per procedure.

https://www.ibm.com/support/knowledgecenter/en/ssw_ibm_i_72/rzasd/freectlopt.htm

The CCSID number provided would have to match an IBM i codepage. For example:

• CCSID(37) would become IBM037
• CCSID(285) would become IBM285

Implement driver using ODBC. This would allow:

• RLA functions to be implemented over SQL
• calling other ILE programs using SQL stored procedures
• calling other ILE export functions using SQL stored procedures

https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_72/rzasd/zzfor.htm#zzfor

There are a few files where initialization via reflection would be pretty useful.

For example:

Testing.cs - Tests could be loaded and activated via annotation
Function.cs (AddFunctionReference) - Same here. It would be easier to just write the function class and add the RPG keyword via annotation or getter.

But this is only a nice to have ;)

https://github.com/worksofliam/NetRPG/blob/master/NetRPG/Language/DDS.cs#L232

• Needs a new property to list indicators which needs to be enable for it to show

https://github.com/worksofliam/NetRPG/blob/master/NetRPG/Language/DDS.cs#L37

• Parse out condition columns (https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_73/rzakc/rzakcconditionfield.htm)

https://github.com/worksofliam/NetRPG/blob/master/NetRPG/Runtime/Typing/Files/Display.cs#L105

• Needs a second parameter to pass in Indicators to compare if local fields should be displayed or not

https://github.com/worksofliam/NetRPG/blob/master/NetRPG/Runtime/Typing/Files/Display.cs#L98

• Check if varName key exists first.