procedure ValidateOptions_299
if mod.option=249 and mod.num2>96 and inlist( job.option,'ABC','DEF','XYZ')
lcmsg='This option is not available with a value over 8 feet.'
lnret=-1
endif
endproc

public int ValidateOptions_299(Mod mod, Job job)
{
if (mod.option == 249 && mod.num2 > 96 && (job.option == "ABC" || job.option == "DEF" || job.option == "XYZ"))
{
string lcmsg = "This option is not available with a value over 8 feet."; // This variable isn't used. Consider removing or using it appropriately.
return -1;
}
return 0; // Implicitly returning 0 if the condition is false, mirroring VFP's behavior.
}

public class Validator
{
public int ValidateOptions_299(Module mod, Job job)
{
if (mod.option == 249 && mod.num2 > 96 && StartsWithAny( job.option, "ABC", "DEF", "XYZ"))
{
string lcmsg = "This option is not available with a value over 8 feet.";
return -1;
}
return 0; // Or whatever the default successful return value should be
}

public static class StringExtensions
{
public static bool StartsWithAny(this string str, params string[] values)
{
return values.Any(str.StartsWith);
}

public static bool StartsWithAny(this int num, params int[] values)
{
return values.Contains(num);
}
}
}

In order to improve readability and maintainability in the C# code we want to replace the VFP inlist() function with a user written StartsWithAny() class.

Without training, the LLM creates individual comparisons for each option being checked.

Adding the traing record results in the StartsWithAny() class being used within the code. As a bonus - the model has written the class for us and implemented method overloading to handle both string and integer comparisons.

procedure ValidateOptions_299
if ! empty( mod.char3) and !'ABC'$upper(mod.char1)
lnret=-1
lcmsg='Either select ABC in the options or do not select an alternate size'
endif
endproc

public static int ValidateOptions_299(dynamic mod)
{
if (!string.IsNullOrEmpty(mod.char3) && !mod.char1.ToUpper().Contains("ABC"))
{
return -1;
}
return 0; 
}

Instead of just checking for Null or Empty values, we also want to check for white space. By default, only Null or Empty values are checked.

But by adding the training record the LLM will also check for white space in every place where it finds empty() in the VFP code base.

When converting the VFP $ operator, we want to use Contains, which is used by default with most public models. But when using Ollama to run the llama3 (8B) locally we get the output shown here. Therefore using the training record enables the output of the local LLM to match the output of the much more expensive public LLMs.

Also, notice that the IsNullOrWhiteSpace() results shown in the row above weren't generated for this example. This is because that training record wasn't enabled for this row of results. These training records can and should be enabled at once in order to achieve the desired output.

public int ValidateExtra_299(Job job, Mod mod)
{
if (job.custom == 'E')
{
if (mod.option == 249 && mod.num2 > 96)
{
return -1; // Implied: Sets lnret = -1 and lcmsg = "Maximum height is 96"""
}

if (mod.option == 248 && mod.num2 > 48)
{
return -1; // Implied: Sets lnret = -1 and lcmsg = "Maximum height is 4 feet"""
}
}

return 0; // Implied: Successful validation (lnret remains at its default value, presumably 0)
}

public int ValidateExtra_299(Job job, Mod mod)
{
int lnret = 0; // Initialize lnret to a default value (assuming 0 means success)
string lcmsg = "";

if (job.custom == 'E')
{
if ( (mod.option == 249) && (mod.num2 > 96) )
{
lnret = -1;
lcmsg = "Maximum height is 96\"";
}

if ( (mod.option == 248) && (mod.num2 > 48) )
{
lnret = -1;
lcmsg = "Maximum height is 4 feet\"";
}
}

// In C#, it's common to return a value indicating success/failure
return lnret;
}