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)); }