private static string ReplaceStringParameter(UseTemplate ut, string parameterName)
{
string value = ut.Parameters[parameterName];
value = value.Replace("<", "<");
value = value.Replace(">", ">");
value = value.Replace("&", "&");
return(value);
}
/// <summary>
/// Create a value name
/// </summary>
/// <param name="ut">UseTemplate object</param>
/// <param name="valueName">initial name</param>
/// <returns></returns>
public static string CreateValue(UseTemplate ut, string valueName)
{
string var = valueName;
if (ut.Parameters.ContainsKey(valueName))
{
var = Helper.ReplaceStringParameter(ut, valueName);
}
return(var);
}
/// <summary>
/// Call coding process
/// </summary>
/// <param name="comp">compilation</param>
/// <param name="converter">language converter</param>
/// <param name="ut">UseTemplate object</param>
/// <param name="codingName">process name of coding</param>
/// <param name="file">writing in</param>
public static void CallCoding(ICompilateurInstance comp, ICodeConverter converter, UseTemplate ut, string codingName, FinalFile file)
{
Coding coding = ut.GetCoding(codingName);
if (coding != null)
{
IProcess proc = comp.GetCodingProcess(coding.UniqueCodingName);
proc.FunctionName = converter.ProcessAsFunction;
comp.Convert(converter, proc, file);
comp.RemoveCodingProcess(coding.UniqueCodingName);
}
}
/// <summary>
/// Create an expression : expression is written for a specific use template (implemented for a specific language)
/// the expression is converted if the infered data type in the expression is not the fixed data type
/// </summary>
/// <param name="converter">language converter</param>
/// <param name="comp">compilation</param>
/// <param name="proc">process</param>
/// <param name="ut">UseTemplate object</param>
/// <param name="valueName">name of the variable</param>
/// <param name="defaultValue">initial value</param>
/// <param name="desiredDataType">fixed data type</param>
/// <returns>the converted expression</returns>
public static string CreateExprVariable(ICodeConverter converter, ICompilateur comp, IProcessInstance proc, UseTemplate ut, string valueName, string defaultValue, EnumDataType desiredDataType)
{
// init
string value = defaultValue;
if (ut.Parameters.ContainsKey(valueName))
{
value = Helper.ReplaceStringParameter(ut, valueName);
}
// convertir l'expression
o2Mate.Expression.Convert(converter, value, proc.CurrentScope, false, desiredDataType);
// définir en paramètre les variables utilisées
foreach (string used in converter.CurrentFunction.UsedVariables)
{
comp.UpdateParameters(converter, proc, used, false);
}
// convertir à nouveau l'expression mais avec des variables
o2Mate.Expression.Convert(converter, value, proc.CurrentScope, true, desiredDataType, true);
return(converter.CurrentFunction.CacheSource);
}
/// <summary>
/// Create a dependant variable : it's a stored variable in a specific use template (implemented for a specific language)
/// the variable has a data type fixed. If it's not the same, the variable value is converted into the good data type
/// if needed, this variable makes a mutable parameter
/// </summary>
/// <param name="comp">compiler object</param>
/// <param name="converter">language converter</param>
/// <param name="proc">process</param>
/// <param name="ut">UseTemplate object</param>
/// <param name="valueName">name of the variable</param>
/// <param name="desiredDataType">fixed data type</param>
/// <returns>the name of the variable (it comes to non computable)</returns>
public static string CreateDependantVariable(ICompilateur comp, ICodeConverter converter, IProcessInstance proc, UseTemplate ut, string valueName, EnumDataType desiredDataType)
{
string var = valueName;
if (ut.Parameters.ContainsKey(valueName))
{
var = Helper.ReplaceStringParameter(ut, valueName);
}
// important : la variable n'est plus calculable
IData newVar = Helper.ConvertNonComputableVariableType(proc, converter, var, desiredDataType);
comp.UpdateParameters(converter, proc, newVar.Name, true);
return(converter.ReturnVarName(newVar));
}
