public void Convert(ICodeConverter converter, IProcessInstance proc, FinalFile file)
{
this.cachedProc = proc;
if (proc.CurrentScope.Exists("CrLf"))
{
this.crlf = proc.CurrentScope.GetVariable("CrLf");
}
else
{
this.crlf = new Variable(proc.Name, true);
this.crlf.Value = @"\r\n";
}
if (proc.CurrentScope.Exists(proc.DefaultWriter))
{
this.defaultWriter = proc.CurrentScope.GetVariable(proc.DefaultWriter);
if (!this.defaultWriter.IsGlobal)
{
this.cachedComp.UpdateParameters(converter, proc, this.defaultWriter.Name, true);
}
if (this.parts != null)
{
foreach (ICompiler c in this.parts)
{
c.Convert(converter, proc, file);
}
}
else
{
converter.Convert(this);
}
}
}
public void WriteInPowerShell(ICodeConverter converter)
{
if (this.isFromDict)
{
if (!this.defaultWriter.IsGlobal)
{
converter.CurrentFunction.AddToSource("WriteToFile S[byvalue:" + PowerShellConverter.Escape(this.defaultWriter.Name) + "] $theDict.GetString(\"" + PowerShellConverter.Escape(this.varName) + "\")" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource("WriteToFile $" + PowerShellConverter.Escape(this.defaultWriter.Name) + " $theDict.GetString(\"" + PowerShellConverter.Escape(this.varName) + "\")" + Environment.NewLine);
}
}
else
{
if (!this.defaultWriter.IsGlobal)
{
converter.CurrentFunction.AddToSource("WriteToFile S[byvalue:" + PowerShellConverter.Escape(this.defaultWriter.Name) + "] (S[byvalue:" + PowerShellConverter.Escape(this.varName) + "])" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource("WriteToFile $" + PowerShellConverter.Escape(this.defaultWriter.Name) + " (S[byvalue:" + PowerShellConverter.Escape(this.varName) + "])" + Environment.NewLine);
}
}
}
public void WriteInMicrosoftCPP(ICodeConverter converter)
{
string currentDir = "wstring(L\"" + FinalFile.BuildDirectory.Replace("\\", "\\\\\\\\") + "\")";
this.directories.ForEach(new Action <string>(delegate(string dir)
{
converter.CurrentFunction.AddToSource("this->CreateDirectoryIfNotExists(" + currentDir + " + " + dir.Replace("\\", "\\\\\\\\") + ");" + Environment.NewLine);
currentDir += " + " + dir.Replace("\\", "\\\\\\\\") + " + wstring(L\"" + MicrosoftCPPConverter.Escape(Path.DirectorySeparatorChar.ToString()) + "\")";
}));
string completeFileName = "";
bool first = true;
this.fileName.ForEach(new Action <string>(delegate(string s)
{
if (!first)
{
completeFileName += " + wstring(L\".\") + ";
}
else
{
first = false;
}
completeFileName += s.Replace("\\", "\\\\\\\\");
}));
converter.CurrentFunction.AddToSource("this->EraseFile(" + currentDir + " + " + completeFileName + ");" + Environment.NewLine);
converter.CurrentFunction.AddToSource("$[left:" + MicrosoftCPPConverter.Escape(this.newWriter.PrefixedName) + "] = writer(" + currentDir + " + " + completeFileName + ");" + Environment.NewLine);
converter.CurrentFunction.AddToSource("$[ifptr:" + MicrosoftCPPConverter.Escape(this.newWriter.PrefixedName) + "]Start();" + Environment.NewLine);
}
public void WriteInMicrosoftCPP(ICodeConverter converter)
{
if (this.isFromDict)
{
if (!this.defaultWriter.IsGlobal)
{
converter.CurrentFunction.AddToSource("$[ifptr:" + MicrosoftCPPConverter.Escape(this.defaultWriter.PrefixedName) + "]WriteToFile(this->GetString(wstring(L\"" + MicrosoftCPPConverter.Escape(this.varName) + "\")));" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource(MicrosoftCPPConverter.Escape(this.defaultWriter.PrefixedName) + ".WriteToFile(this->GetString(wstring(L\"" + MicrosoftCPPConverter.Escape(this.varName) + "\")));" + Environment.NewLine);
}
}
else
{
if (!this.defaultWriter.IsGlobal)
{
converter.CurrentFunction.AddToSource("$[ifptr:" + MicrosoftCPPConverter.Escape(this.defaultWriter.PrefixedName) + "]WriteToFile($[byvalue:" + MicrosoftCPPConverter.Escape(this.value.PrefixedName) + "]);" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource(MicrosoftCPPConverter.Escape(this.defaultWriter.PrefixedName) + ".WriteToFile($[byvalue:" + MicrosoftCPPConverter.Escape(this.value.PrefixedName) + "]);" + Environment.NewLine);
}
}
}
public void WriteInVBScript(ICodeConverter converter)
{
IFunction f = converter.ImplementedFunctions.Find(new Predicate <IFunction>(delegate(IFunction func)
{
return(func.Name == this.cachedProc.FunctionName);
}));
if (!converter.CallingFunctions.Exists(new Predicate <IFunction>(delegate(IFunction func) { return(func.StrictName == CallSkeleton.SpecialChars(this.Name) && func.InstanceNumber == f.InstanceNumber); })))
{
converter.CallingFunctions.Add(f);
}
converter.CurrentFunction.AddToSource((f.IsMacro ? "macro_" : f.IsJob ? "job_" : "func_") + f.Name + " ");
bool first = true;
List <string> names = new List <string>();
foreach (IParameter p in f.Parameters)
{
if (!names.Contains(p.VariableName))
{
if (!first)
{
converter.CurrentFunction.AddToSource(", ");
}
else
{
first = false;
}
converter.CurrentFunction.AddToSource(p.VariableName);
names.Add(p.VariableName);
}
}
converter.CurrentFunction.AddToSource(Environment.NewLine);
}
public void WriteInVBScript(ICodeConverter converter)
{
string currentDir = "\"" + FinalFile.BuildDirectory + "\"";
this.directories.ForEach(new Action <string>(delegate(string dir)
{
converter.CurrentFunction.AddToSource("CreateDirectoryIfNotExists " + currentDir + " & " + dir + Environment.NewLine);
currentDir += " & " + dir + " & \"" + Path.DirectorySeparatorChar + "\"";
}));
string completeFileName = "";
bool first = true;
this.fileName.ForEach(new Action <string>(delegate(string s)
{
if (!first)
{
completeFileName += " & \".\" & ";
}
else
{
first = false;
}
completeFileName += s;
}));
converter.CurrentFunction.AddToSource("EraseFile " + currentDir + " & " + completeFileName + Environment.NewLine);
converter.CurrentFunction.AddToSource(this.newWriter.Name + " = Array(" + currentDir + " & " + completeFileName + ", 0, true)" + Environment.NewLine);
}
/// <summary>
/// Special function for CPP conversion
/// It's needed to confirm for each data type of formal parameters to be the same than the effective parameters
/// if not, variable have to be converted in the good data type
/// </summary>
/// <param name="proc">process</param>
/// <param name="converter">language converter instance</param>
/// <param name="newFunc">new function</param>
/// <returns>sequence call statement in CPP</returns>
public static string MakeNewMethodForCPP(IProcess proc, ICodeConverter converter, IFunction newFunc)
{
string callStatement = String.Empty;
callStatement = MicrosoftCPPConverter.Escape((newFunc.IsMacro ? "macro_" : newFunc.IsJob ? "job_" : "func_") + newFunc.Name + "(");
bool first = true;
foreach (IParameter p in newFunc.Parameters)
{
if (!first)
{
callStatement += ", ";
}
else
{
first = false;
}
if (p.IsMutableParameter)
{
callStatement += "$[byref:" + p.EffectiveParameter + "]";
}
else
{
callStatement += "$[byvalue:" + p.EffectiveParameter + "]";
}
}
callStatement += ");" + Environment.NewLine;
return(callStatement);
}
public void WriteInPowerShell(ICodeConverter converter)
{
string currentDir = "\"" + FinalFile.BuildDirectory + "\"";
this.directories.ForEach(new Action <string>(delegate(string dir)
{
converter.CurrentFunction.AddToSource("CreateDirectoryIfNotExists (" + currentDir + " + " + dir + ")" + Environment.NewLine);
currentDir += " + " + dir + " + \"" + PowerShellConverter.Escape(Path.DirectorySeparatorChar.ToString()) + "\"";
}));
string completeFileName = "";
bool first = true;
this.fileName.ForEach(new Action <string>(delegate(string s)
{
if (!first)
{
completeFileName += " + \".\" + ";
}
else
{
first = false;
}
completeFileName += s;
}));
converter.CurrentFunction.AddToSource("EraseFile (" + currentDir + " + " + completeFileName + ")" + Environment.NewLine);
converter.CurrentFunction.AddToSource("S[left:" + PowerShellConverter.Escape(this.newWriter.Name) + "] = @((" + currentDir + " + " + completeFileName + ")" + ", 0, \"\", $true)" + Environment.NewLine);
}
/// <summary>
/// Make a new function with the incremented instance number
/// </summary>
/// <param name="converter">language converter</param>
/// <param name="proc">process object</param>
/// <returns>a new function</returns>
public static IFunction MakeNewMethod(ICodeConverter converter, IProcess proc)
{
IFunction f;
string funName = Process.ProcessAsFunction(proc.Name);
if (Helper.NeedNewMethod(converter, proc, funName))
{
f = new Function();
f.StrictName = funName;
f.InstanceNumber = converter.ImplementedFunctions.FindAll(new Predicate <IFunction>(delegate(IFunction func)
{
return(func.StrictName == funName);
})).Count;
converter.ImplementedFunctions.Add(f);
}
else
{
f = converter.ImplementedFunctions.FindLast(new Predicate <IFunction>(delegate(IFunction func)
{
return(func.StrictName == funName);
}));
// je recrée la fonction
Helper.ClearMethod(f);
}
return(f);
}
/// <summary>
/// Verify if the function need to be renewed
/// </summary>
/// <param name="converter">language converter</param>
/// <param name="curProc">process</param>
/// <param name="newFunc">new function</param>
/// <returns>true or false</returns>
public static bool CheckNewMethod(ICodeConverter converter, IProcess curProc, IFunction newFunc)
{
return(curProc.HasChanged || !converter.ImplementedFunctions.Exists(new Predicate <IFunction>(delegate(IFunction func)
{
return newFunc.Equals(func) && newFunc.InstanceNumber != func.InstanceNumber;
})));
}
/// <summary>
/// Verify if a variable already exists in locals
/// </summary>
/// <param name="converter">language converter</param>
/// <param name="f">funcion</param>
/// <param name="var">variable object</param>
/// <returns>true if is local</returns>
public static bool IsLocal(ICodeConverter converter, IFunction f, IData var)
{
return(f.LocalVariables.Exists(new Predicate <IStructure>(delegate(IStructure st)
{
return (converter.IsStronglyTyped && st.PrefixedFieldName == var.PrefixedName) || (!converter.IsStronglyTyped && st.FieldName == var.Name);
})));
}
/// <summary>
/// Convert a newer variable or an existing variable.
/// Keeps the current value of this variable.
/// </summary>
/// <param name="proc">process object</param>
/// <param name="converter">converter object</param>
/// <param name="varName">name of the variable</param>
/// <param name="desiredDataType">data type to convert</param>
/// <returns>the conversion string result</returns>
public static string ConvertVariableType(IProcessInstance proc, ICodeConverter converter, string varName, EnumDataType desiredDataType)
{
// store the result in the scope with the varName parameter
if (proc.CurrentScope.Exists(varName))
{
string result = String.Empty;
// get the variable infos
IData myVar = proc.CurrentScope.GetVariable(varName);
// specific prefix is used with desired data type
if (myVar.TypeExists(desiredDataType))
{
// if the desired data type is not the current type
if (myVar.DataType != desiredDataType)
{
TypedVariable tv = new TypedVariable(myVar.Name, myVar.Prefix, myVar.DataType, desiredDataType);
result = tv.MoveType(converter, proc.CurrentScope);
}
}
else
{
TypedVariable tv = new TypedVariable(myVar.Name, myVar.Prefix, myVar.DataType, desiredDataType);
result = tv.MoveType(converter, proc.CurrentScope);
}
return(result);
}
else
{
throw new ArgumentException("La variable '" + varName + "' n'existe pas dans le scope");
}
}
/// <summary>
/// Converts a newer variable or an existing variable
/// The variable will be non computable after these changes
/// </summary>
/// <param name="proc">process object</param>
/// <param name="converter">converter object</param>
/// <param name="varName">name of the variable</param>
/// <param name="desiredDataType">data type to convert</param>
/// <returns>the variable (assumes to be present in the scope)</returns>
private static IData ConvertNonComputableVariableType(IProcessInstance proc, ICodeConverter converter, string varName, EnumDataType desiredDataType)
{
// store the result in the scope with the varName parameter
if (proc.CurrentScope.Exists(varName))
{
// get the variable infos
IData myVar = proc.CurrentScope.GetVariable(varName);
// specific prefix is used with desired data type
if (myVar.TypeExists(desiredDataType))
{
// update variable, don't use value and assumes to be non-computable
proc.CurrentScope.Update(varName, "0", myVar.PrefixInfo(desiredDataType).BelongsTo, false, desiredDataType);
}
else
{
// update variable, don't use value and assumes to be non-computable
proc.CurrentScope.Update(varName, "0", myVar.BelongsTo, false, desiredDataType);
}
return(myVar);
}
else
{
// create variable, don't use value and assumes to be non-computable
IData added = proc.CurrentScope.Add(varName, "0", proc.Name, false, desiredDataType);
Helper.AddIntoLocal(converter, added);
return(added);
}
}
/// <summary>
/// Add into the current local variable list (if not exists)
/// </summary>
/// <param name="converter">language converter</param>
/// <param name="f">function</param>
/// <param name="var">variable object</param>
public static void AddIntoLocal(ICodeConverter converter, IFunction f, IData var)
{
if (!Helper.IsLocal(converter, f, var))
{
IStructure st = converter.CreateNewField(converter.RootStructureInstance, var, false);
f.LocalVariables.Add(st);
}
}
/// <summary>
/// Verify if the function need to be renewed
/// </summary>
/// <param name="converter">language converter</param>
/// <param name="proc">process object</param>
/// <param name="funName">function name</param>
/// <returns>true or false</returns>
public static bool NeedNewMethod(ICodeConverter converter, IProcess proc, string funName)
{
return(proc.HasChanged ||
!converter.ImplementedFunctions.Exists(new Predicate <IFunction>(delegate(IFunction func)
{
return func.StrictName == funName;
})));
}
public CodeConverterShould()
{
var serviceProvider = new ServiceCollection()
.AddCSharpToTypeScript()
.BuildServiceProvider();
_codeConverter = serviceProvider.GetRequiredService <ICodeConverter>();
}
public void Convert(ICodeConverter converter, IProcessInstance proc, FinalFile file)
{
// pas de test sur l'existence du tableau dans le dictionnaire
IData res = Helper.ConvertNewExpression(this.cachedComp, proc, converter, this.expression);
this.index = res.ValueString;
// add a new variable or change an existing variable
this.value = Helper.ConvertNewDictionaryArray(this.cachedComp, proc, converter, this.varName);
converter.Convert(this);
}
public void Convert(ICodeConverter converter, IProcessInstance proc, FinalFile file)
{
if (converter.ImplementedFunctions.Exists(new Predicate <IFunction>(delegate(IFunction f) { return(f.StrictName == this.processName); })))
{
converter.Convert(this);
}
else
{
throw new Exception("Pour convertir le programme, les processus doivent être implémentés avant leur exécution; le processus '" + this.processName + "' n'a pas été déclaré.");
}
}
public void WriteInPowerShell(ICodeConverter converter)
{
if (!this.defaultWriter.IsGlobal)
{
converter.CurrentFunction.AddToSource("WriteToFile S[byvalue:" + PowerShellConverter.Escape(this.defaultWriter.Name) + "] $" + PowerShellConverter.Escape(this.crlf.Name) + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource("WriteToFile $" + PowerShellConverter.Escape(this.defaultWriter.Name) + " $" + PowerShellConverter.Escape(this.crlf.Name) + Environment.NewLine);
}
}
public void WriteInMicrosoftCPP(ICodeConverter converter)
{
if (!this.defaultWriter.IsGlobal)
{
converter.CurrentFunction.AddToSource("$[ifptr:" + MicrosoftCPPConverter.Escape(this.defaultWriter.PrefixedName) + "]WriteToFile(" + MicrosoftCPPConverter.Escape(this.crlf.PrefixedName) + ");" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource(MicrosoftCPPConverter.Escape(this.defaultWriter.PrefixedName) + ".WriteToFile(" + MicrosoftCPPConverter.Escape(this.crlf.PrefixedName) + ");" + Environment.NewLine);
}
}
public void WriteInPowerShell(ICodeConverter converter)
{
if (!this.result.IsGlobal)
{
converter.CurrentFunction.AddToSource("S[left:" + PowerShellConverter.Escape(this.varName) + "] = " + this.result.ValueString + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource("$" + PowerShellConverter.Escape(this.varName) + " = " + this.result.ValueString + Environment.NewLine);
}
}
public void WriteInMicrosoftCPP(ICodeConverter converter)
{
if (!this.result.IsGlobal)
{
converter.CurrentFunction.AddToSource("$[left:" + MicrosoftCPPConverter.Escape(this.result.PrefixedName) + "] = " + this.result.ValueString + ";" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource(MicrosoftCPPConverter.Escape(this.result.PrefixedName) + " = " + this.result.ValueString + ";" + Environment.NewLine);
}
}
public void WriteInMicrosoftCPP(ICodeConverter converter)
{
if (!this.defaultWriter.IsGlobal)
{
converter.CurrentFunction.AddToSource("$[ifptr:" + MicrosoftCPPConverter.Escape(this.defaultWriter.PrefixedName) + "]WriteToFile(this->GetField(wstring(L\"" + MicrosoftCPPConverter.Escape(this.tabName) + "\"), " + this.index + ", wstring(L\"" + MicrosoftCPPConverter.Escape(this.fieldName) + "\")));" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource(MicrosoftCPPConverter.Escape(this.defaultWriter.PrefixedName) + ".WriteToFile(this->GetField(wstring(L\"" + MicrosoftCPPConverter.Escape(this.tabName) + "\"), " + this.index + ", wstring(L\"" + MicrosoftCPPConverter.Escape(this.fieldName) + "\")));" + Environment.NewLine);
}
}
public void WriteInPowerShell(ICodeConverter converter)
{
if (!this.defaultWriter.IsGlobal)
{
converter.CurrentFunction.AddToSource("WriteToFile S[byvalue:" + PowerShellConverter.Escape(this.defaultWriter.Name) + "] $theDict.GetArray(\"" + PowerShellConverter.Escape(this.tabName) + "\").Item(" + this.index + ").GetString(\"" + PowerShellConverter.Escape(this.fieldName) + "\")" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource("WriteToFile $" + PowerShellConverter.Escape(this.defaultWriter.Name) + " $theDict.GetArray(\"" + PowerShellConverter.Escape(this.tabName) + "\").Item(" + this.index + ").GetString(\"" + PowerShellConverter.Escape(this.fieldName) + "\")" + Environment.NewLine);
}
}
public void WriteInPowerShell(ICodeConverter converter)
{
if (!this.value.IsGlobal)
{
converter.CurrentFunction.AddToSource("S[left:" + PowerShellConverter.Escape(this.varName) + "] = $theDict.GetString(\"" + PowerShellConverter.Escape(this.stringName) + "\")" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource("$" + PowerShellConverter.Escape(this.varName) + " = $theDict.GetString(\"" + PowerShellConverter.Escape(this.stringName) + "\")" + Environment.NewLine);
}
}
public void WriteInMicrosoftCPP(ICodeConverter converter)
{
if (!this.value.IsGlobal)
{
converter.CurrentFunction.AddToSource("$[left:" + MicrosoftCPPConverter.Escape(value.PrefixedName) + "] = this->GetString(wstring(L\"" + MicrosoftCPPConverter.Escape(this.stringName) + "\"));" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource(MicrosoftCPPConverter.Escape(value.PrefixedName) + " = this->GetString(wstring(L\"" + MicrosoftCPPConverter.Escape(this.stringName) + "\"));" + Environment.NewLine);
}
}
public void WriteInVBScript(ICodeConverter converter)
{
if (this.isFromDict)
{
converter.CurrentFunction.AddToSource("WriteToFile " + this.defaultWriter.Name + ", theDict.GetString(\"" + this.varName + "\")" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource("WriteToFile " + this.defaultWriter.Name + ", " + this.varName + Environment.NewLine);
}
}
/// <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);
}
}
public void WriteInPowerShell(ICodeConverter converter)
{
string printed = this.text.Replace("\\", "\\\\").Replace("\"", "\"\"").Replace("S[", "\\S[").Replace("\r\n", "").Replace(" ", "").Replace("\t", "").Replace('·', ' ').Replace('¬', '\t').Replace("¶", "\" + $" + this.crlf.Name + " + \"");
if (!this.defaultWriter.IsGlobal)
{
converter.CurrentFunction.AddToSource("WriteToFile S[byvalue:" + PowerShellConverter.Escape(this.defaultWriter.Name) + "] (\"" + printed + "\")" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource("WriteToFile $" + PowerShellConverter.Escape(this.defaultWriter.Name) + " (\"" + printed + "\")" + Environment.NewLine);
}
}
public void WriteInMicrosoftCPP(ICodeConverter converter)
{
string printed = this.text.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r\n", "").Replace("$[", "\\$[").Replace(" ", "").Replace("\t", "").Replace('·', ' ').Replace('¬', '\t').Replace("¶", "\") + " + this.crlf.PrefixedName + " + wstring(L\"");
if (!this.defaultWriter.IsGlobal)
{
converter.CurrentFunction.AddToSource("$[ifptr:" + MicrosoftCPPConverter.Escape(this.defaultWriter.PrefixedName) + "]WriteToFile(wstring(L\"" + printed + "\"));" + Environment.NewLine);
}
else
{
converter.CurrentFunction.AddToSource(MicrosoftCPPConverter.Escape(this.defaultWriter.PrefixedName) + ".WriteToFile(wstring(L\"" + printed + "\"));" + Environment.NewLine);
}
}
