static void GenerateAnsiC(Files files, string designerDir, string outputDir)
{
ConstantsGenerator generator3 = new ConstantsGenerator(
Language.AnsiC,
designerDir + @"\Design\UA Attributes.xml",
outputDir,
files.NodeDictionaries);
generator3.Generate(
"OpcUa",
"Attributes",
designerDir + @"\Design\UA Attributes.csv",
false);
ConstantsGenerator generator4 = new ConstantsGenerator(
Language.AnsiC,
designerDir + @"\Design\UA Status Codes.xml",
outputDir,
files.NodeDictionaries);
generator4.Generate(
"OpcUa",
"StatusCodes",
designerDir + @"\Design\UA Status Codes.csv",
false);
AnsiCGenerator generator7 = new AnsiCGenerator(
designerDir + @"\Design\UA Core Services.xml",
outputDir,
files.TypeDictionaries);
generator7.Generate("OpcUa", "Core", true);
}
static void GenerateDotNet(Files files, string designerDir, string outputDir, string specificationVersion)
{
var resourcePath = "ModelCompiler.Design";
if (!String.IsNullOrEmpty(specificationVersion))
{
resourcePath = $"ModelCompiler.Design.{specificationVersion}";
}
ConstantsGenerator generator7 = new ConstantsGenerator(
Language.DotNet,
$"{designerDir}UA Attributes.xml",
outputDir,
files.NodeDictionaries,
resourcePath);
generator7.Generate(
"Opc.Ua",
"Attributes",
$"{designerDir}UA Attributes.csv",
false);
ConstantsGenerator generator8 = new ConstantsGenerator(
Language.DotNet,
$"{designerDir}UA Status Codes.xml",
outputDir,
files.NodeDictionaries,
resourcePath);
generator8.Generate(
"Opc.Ua",
"StatusCodes",
$"{designerDir}UA Status Codes.csv",
false);
ConstantsGenerator generator9 = new ConstantsGenerator(
Language.CSV,
$"{designerDir}UA Status Codes.xml",
outputDir,
files.NodeDictionaries,
resourcePath);
generator9.Generate(
"Opc.Ua",
"StatusCodes",
$"{designerDir}UA Status Codes.csv",
false);
DotNetGenerator generator10 = new DotNetGenerator(
$"{designerDir}UA Core Services.xml",
outputDir,
files.TypeDictionaries,
resourcePath);
generator10.Generate("Opc.Ua", "Core", true);
}
static void GenerateDotNet(Files files, string modelDir, string csvDir, string outputDir, string specificationVersion)
{
ConstantsGenerator generator7 = new ConstantsGenerator(
Language.DotNet,
$"{modelDir}UA Attributes.xml",
outputDir,
files.NodeDictionaries,
null);
generator7.Generate(
"Opc.Ua",
"Attributes",
$"{csvDir}UA Attributes.csv",
false);
ConstantsGenerator generator8 = new ConstantsGenerator(
Language.DotNet,
$"{modelDir}UA Status Codes.xml",
outputDir,
files.NodeDictionaries,
null);
generator8.Generate(
"Opc.Ua",
"StatusCodes",
$"{csvDir}UA Status Codes.csv",
false);
ConstantsGenerator generator9 = new ConstantsGenerator(
Language.CSV,
$"{modelDir}UA Status Codes.xml",
outputDir,
files.NodeDictionaries,
null);
generator9.Generate(
"Opc.Ua",
"StatusCodes",
$"{csvDir}UA Status Codes.csv",
false);
DotNetGenerator generator10 = new DotNetGenerator(
$"{modelDir}UA Core Services.xml",
outputDir,
files.TypeDictionaries,
null);
generator10.Generate("Opc.Ua", "Core", true);
}
static void GenerateDotNet(Files files, string designerDir, string outputDir)
{
ConstantsGenerator generator7 = new ConstantsGenerator(
Language.DotNet,
designerDir + @"\Design\UA Attributes.xml",
outputDir,
files.NodeDictionaries);
generator7.Generate(
"Opc.Ua",
"Attributes",
designerDir + @"\Design\UA Attributes.csv",
false);
ConstantsGenerator generator8 = new ConstantsGenerator(
Language.DotNet,
designerDir + @"\Design\UA Status Codes.xml",
outputDir,
files.NodeDictionaries);
generator8.Generate(
"Opc.Ua",
"StatusCodes",
designerDir + @"\Design\UA Status Codes.csv",
false);
ConstantsGenerator generator9 = new ConstantsGenerator(
Language.CSV,
designerDir + @"\Design\UA Status Codes.xml",
outputDir,
files.NodeDictionaries);
generator9.Generate(
"Opc.Ua",
"StatusCodes",
designerDir + @"\Design\UA Status Codes.csv",
false);
DotNetGenerator generator10 = new DotNetGenerator(
designerDir + @"\Design\UA Core Services.xml",
outputDir,
files.TypeDictionaries);
generator10.Generate("Opc.Ua", "Core", true);
}
static void GenerateAnsiC(Files files, string designerDir, string outputDir, string specificationVersion)
{
var resourcePath = "Opc.Ua.ModelCompiler.Design";
if (!String.IsNullOrEmpty(specificationVersion))
{
resourcePath = $"Opc.Ua.ModelCompiler.Design.{specificationVersion}";
}
ConstantsGenerator generator3 = new ConstantsGenerator(
Language.AnsiC,
$"{designerDir}UA Attributes.xml",
outputDir,
files.NodeDictionaries,
resourcePath);
generator3.Generate(
"OpcUa",
"Attributes",
$"{designerDir}UA Attributes.csv",
false);
ConstantsGenerator generator4 = new ConstantsGenerator(
Language.AnsiC,
$"{designerDir}UA Status Codes.xml",
outputDir,
files.NodeDictionaries,
resourcePath);
generator4.Generate(
"OpcUa",
"StatusCodes",
$"{designerDir}UA Status Codes.csv",
false);
AnsiCGenerator generator7 = new AnsiCGenerator(
$"{designerDir}UA Core Services.xml",
outputDir,
files.TypeDictionaries,
resourcePath);
generator7.Generate("OpcUa", "Core", true);
}
static void GenerateAnsiC(Files files, string modelDir, string csvDir, string outputDir, string specificationVersion)
{
ConstantsGenerator generator3 = new ConstantsGenerator(
Language.AnsiC,
$"{modelDir}UA Attributes.xml",
outputDir,
files.NodeDictionaries,
null);
generator3.Generate(
"OpcUa",
"Attributes",
$"{csvDir}UA Attributes.csv",
false);
ConstantsGenerator generator4 = new ConstantsGenerator(
Language.AnsiC,
$"{modelDir}UA Status Codes.xml",
outputDir,
files.NodeDictionaries,
null);
generator4.Generate(
"OpcUa",
"StatusCodes",
$"{csvDir}UA Status Codes.csv",
false);
AnsiCGenerator generator7 = new AnsiCGenerator(
$"{modelDir}UA Core Services.xml",
outputDir,
files.TypeDictionaries,
null);
generator7.Generate("OpcUa", "Core", true);
}
/// <summary>
/// Populates tables according to the currently-processed expression.
/// </summary>
/// <param name="processedExpression">The expression that is being processed.</param>
/// <param name="constantsTable">The constants table.</param>
/// <param name="reverseConstantsTable">The reverse-lookup constants table.</param>
/// <param name="symbolTable">The symbols table.</param>
/// <param name="reverseSymbolTable">The reverse-lookup symbols table.</param>
/// <param name="parameterRegistry">The parameters registry.</param>
/// <param name="interpreters">The constant interpreters.</param>
/// <param name="originalExpression">The expression before processing.</param>
/// <param name="openParenthesis">The symbol of an open parenthesis.</param>
/// <param name="allSymbols">All symbols on which to split, in order.</param>
internal static void PopulateTables(
string processedExpression,
Dictionary <string, ConstantNodeBase> constantsTable,
Dictionary <string, string> reverseConstantsTable,
Dictionary <string, ExpressionSymbol> symbolTable,
Dictionary <string, string> reverseSymbolTable,
IParameterRegistry parameterRegistry,
LevelDictionary <Type, IConstantInterpreter> interpreters,
string originalExpression,
string openParenthesis,
string[] allSymbols)
{
// Split expression by all symbols
string[] expressions = processedExpression.Split(
allSymbols,
StringSplitOptions.RemoveEmptyEntries);
foreach (var exp in expressions)
{
if (constantsTable.ContainsKey(exp))
{
// We have a constant
continue;
}
if (reverseConstantsTable.ContainsKey(exp))
{
// We have a constant that has bee evaluated before
continue;
}
if (parameterRegistry.Exists(exp))
{
// We have a parameter
continue;
}
if (symbolTable.ContainsKey(exp))
{
// We have an already-existing symbol
continue;
}
if (reverseSymbolTable.ContainsKey(exp))
{
// We have a symbol value that has been evaluated before
continue;
}
if (exp.Contains(openParenthesis))
{
// We have a part of a function
continue;
}
// Let's check whether it is a constant
if (ConstantsGenerator.CheckAndAdd(
constantsTable,
reverseConstantsTable,
interpreters,
originalExpression,
exp) != null)
{
continue;
}
// It's not a constant, nor something ever encountered before
// Therefore it should be a parameter
_ = parameterRegistry.AdvertiseParameter(exp);
}
}
public string ExtractAllConstants(
string originalExpression,
IDictionary <string, ConstantNodeBase> constantsTable,
IDictionary <string, string> reverseConstantsTable,
MathDefinition mathDefinition)
{
var stringIndicatorString = mathDefinition.StringIndicator;
var stringIndicator = mathDefinition.StringIndicator.AsSpan();
var stringIndicatorLength = stringIndicator.Length;
var escapeCharacter = mathDefinition.EscapeCharacter.AsSpan();
var escapeCharacterLength = escapeCharacter.Length;
var process = originalExpression.AsSpan();
StringBuilder?sb = null;
while (true)
{
var openingPosition = process.IndexOf(
stringIndicator,
StringComparison.CurrentCulture);
if (openingPosition == -1)
{
// No string opening
break;
}
var header = process.Slice(
0,
openingPosition);
var rest = process.Slice(openingPosition + stringIndicatorLength);
int closingPosition;
ReadOnlySpan <char> body;
do
{
closingPosition = rest.IndexOf(stringIndicator, StringComparison.CurrentCulture);
if (closingPosition != -1)
{
body = rest.Slice(
0,
closingPosition);
int occurrences = 0;
while (body.EndsWith(escapeCharacter))
{
occurrences++;
body = body.Slice(
0,
body.Length - escapeCharacterLength);
}
rest = rest.Slice(closingPosition + stringIndicatorLength);
if (occurrences % 2 == 0)
{
break;
}
}
}while (closingPosition != -1);
if (closingPosition == -1)
{
// No string closing
break;
}
// We have a proper string
body = process.Slice(
openingPosition,
process.Length - header.Length - rest.Length);
var itemName = ConstantsGenerator.GenerateStringConstant(
constantsTable,
reverseConstantsTable,
originalExpression,
stringIndicatorString,
body.ToString());
sb ??= new StringBuilder(originalExpression.Length);
#if NETSTANDARD21_OR_GREATER
sb.Append(header);
#else
sb.Append(header.ToString());
#endif
sb.Append(itemName);
process = rest;
}
if (sb == null)
{
return(originalExpression);
}
#if NETSTANDARD21_OR_GREATER
sb.Append(process);
#else
sb.Append(process.ToString());
#endif
return(sb.ToString());
}
static string?ReplaceFunctionsLocal(
string source,
string openParenthesisSymbol,
string closeParenthesisSymbol,
string parameterSeparatorSymbol,
Dictionary <string, ConstantNodeBase> constantsTableReference,
Dictionary <string, string> reverseConstantsTableReference,
Dictionary <string, ExpressionSymbol> symbolTableReference,
Dictionary <string, string> reverseSymbolTableReference,
LevelDictionary <Type, IConstantInterpreter> interpretersReference,
IParameterRegistry parametersTableReference,
string expressionSymbol,
string[] allSymbolsSymbols)
{
var op = -1;
var opl = openParenthesisSymbol.Length;
var cpl = closeParenthesisSymbol.Length;
while (true)
{
op = source.InvariantCultureIndexOf(
openParenthesisSymbol,
op + opl);
if (op == -1)
{
return(null);
}
if (op == 0)
{
continue;
}
var functionHeaderCheck = source.Substring(
0,
op);
if (allSymbolsSymbols.Any(
(
p,
check) => check.InvariantCultureEndsWith(p),
functionHeaderCheck))
{
continue;
}
var functionHeader = functionHeaderCheck.Split(
allSymbolsSymbols,
StringSplitOptions.None).Last();
var oop = source.InvariantCultureIndexOf(
openParenthesisSymbol,
op + opl);
var cp = source.InvariantCultureIndexOf(
closeParenthesisSymbol,
op + cpl);
while (oop < cp && oop != -1 && cp != -1)
{
oop = source.InvariantCultureIndexOf(
openParenthesisSymbol,
oop + opl);
cp = source.InvariantCultureIndexOf(
closeParenthesisSymbol,
cp + cpl);
}
if (cp == -1)
{
continue;
}
var arguments = source.Substring(
op + opl,
cp - op - opl);
var originalArguments = arguments;
var q = arguments;
while (q != null)
{
arguments = q;
q = ReplaceFunctionsLocal(
q,
openParenthesisSymbol,
closeParenthesisSymbol,
parameterSeparatorSymbol,
constantsTableReference,
reverseConstantsTableReference,
symbolTableReference,
reverseSymbolTableReference,
interpretersReference,
parametersTableReference,
expressionSymbol,
allSymbolsSymbols);
}
var argPlaceholders = new List <string>();
foreach (var s in arguments.Split(
new[] { parameterSeparatorSymbol },
StringSplitOptions.RemoveEmptyEntries))
{
TablePopulationGenerator.PopulateTables(
s,
constantsTableReference,
reverseConstantsTableReference,
symbolTableReference,
reverseSymbolTableReference,
parametersTableReference,
interpretersReference,
expressionSymbol,
openParenthesisSymbol,
allSymbolsSymbols);
// We check whether or not this is actually a constant
argPlaceholders.Add(
ConstantsGenerator.CheckAndAdd(
constantsTableReference,
reverseConstantsTableReference,
interpretersReference,
expressionSymbol,
s) ?? (!parametersTableReference.Exists(s)
? SymbolExpressionGenerator.GenerateSymbolExpression(
symbolTableReference,
reverseSymbolTableReference,
s,
false)
: s));
}
var functionCallBody =
$"{functionHeader}{openParenthesisSymbol}{string.Join(parameterSeparatorSymbol, argPlaceholders)}{closeParenthesisSymbol}";
var functionCallToReplace =
$"{functionHeader}{openParenthesisSymbol}{originalArguments}{closeParenthesisSymbol}";
var functionCallItem = SymbolExpressionGenerator.GenerateSymbolExpression(
symbolTableReference,
reverseSymbolTableReference,
functionCallBody,
true);
return(source.Replace(
functionCallToReplace,
functionCallItem));
}
}
