public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.processName = node.InnerText; this.cachedComp = comp; }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.enc = comp.EncodedFile; this.cachedComp = comp; }
/// <summary> /// Load template data /// </summary> /// <param name="comp">compiler object</param> /// <param name="node">xml node object</param> public void Load(ICompilateurInstance comp, XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.name = node.Attributes.GetNamedItem("name").Value; this.legendes.Load(node.SelectSingleNode("legendes")); this.xmlCode = node.SelectSingleNode("code").InnerXml; }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.uniqueContainer = comp.Unique.ComputeNewString(); this.codingName = node.Attributes.GetNamedItem("name").Value; this.xmlCode = node.SelectSingleNode("code"); }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.expression = node.SelectSingleNode("expression").InnerText; this.labelTrue = node.SelectSingleNode("iftrue").InnerText; this.labelFalse = node.SelectSingleNode("iffalse").InnerText; }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.varName = node.SelectSingleNode("terme").InnerText; this.tabName = node.SelectSingleNode("tableau").InnerText; this.cachedComp = comp; }
/// <summary> /// Load statement data /// </summary> /// <param name="comp">compiler object</param> /// <param name="node">xml node object</param> public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.language = node.Attributes.GetNamedItem("language").Value; this.command = node.Attributes.GetNamedItem("command").Value; this.expression = node.Attributes.GetNamedItem("expression").Value; this.cachedComp = comp; }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.varName = node.SelectSingleNode("variable").InnerText; this.expression = node.SelectSingleNode("expression").InnerText; // on en a besoin pour plus tard dans la conversion this.cachedComp = comp; }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.tabName = node.SelectSingleNode("tableau").InnerText; this.expression = node.SelectSingleNode("expression").InnerText; this.fieldName = node.SelectSingleNode("variable").InnerText; this.enc = comp.EncodedFile; this.cachedComp = comp; }
/// <summary> /// Fill a new method /// </summary> /// <param name="comp">compilation</param> /// <param name="subProc">sub process object</param> /// <param name="converter">language converter</param> /// <param name="f">new function</param> /// <param name="file">writing in</param> public static void FillNewMethod(ICompilateurInstance comp, IProcess subProc, ICodeConverter converter, IFunction f, FinalFile file) { // la fonction est implémentée converter.PushFunction(converter.CurrentFunction); f.PropagateControlFlow(converter.CurrentFunction); converter.SetCurrentFunction(f); subProc.FunctionName = converter.ProcessAsFunction; converter.CurrentFunction.ForwardControlFlowSub(); comp.Convert(converter, subProc, file); converter.CurrentFunction.BackwardControlFlowSub(); converter.SetCurrentFunction(converter.PopFunction()); }
/// <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> /// Inject this object onto the injector /// </summary> /// <param name="injector">injector object</param> /// <param name="comp">the compiler object</param> /// <param name="node">xml node object</param> /// <param name="modifier">modifier after, before or replace</param> public void Inject(Injector injector, ICompilateurInstance comp, System.Xml.XmlNode node, string modifier) { this.Load(comp, node); if (comp.UnderConversion) { string s = String.Empty; if (!this.IsComputable(injector.InjectedProcess, out s)) { throw new Exception(s); } } }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } // remove whitespace string innerText = node.InnerText; this.text = innerText.Replace(" ", "").Replace("\t", "").Replace("\n\r", ""); this.cachedComp = comp; this.enc = comp.EncodedFile; }
/// <summary> /// Call coding process /// Uses a newer variable in which you are adding it in the coding process /// </summary> /// <param name="comp">compilation</param> /// <param name="proc">process</param> /// <param name="converter">language converter</param> /// <param name="coding">coding object</param> /// <param name="varName">name of the variable</param> /// <param name="desiredDataType">desired data type of the variable</param> /// <param name="file">writing in</param> public static void CallCoding(ICompilateurInstance comp, IProcessInstance proc, ICodeConverter converter, Coding coding, string varName, EnumDataType desiredDataType, FinalFile file) { IProcess subProc = comp.GetCodingProcess(coding.UniqueCodingName); // la fonction courante est associée à ce processus // ce processus ne crée pas de fonction subProc.FunctionName = converter.ProcessAsFunction; // les instructions du coding sont stockées dans un processus à part // mais il n'y a pas de création d'une nouvelle fonction et cela implique // que je dois ranger les variables utilisées dans le processus au dessus // afin qu'elles soient déjà connues dans le processus du coding IData var = Helper.ConvertNonComputableVariableType(proc, converter, varName, desiredDataType); // mais j'ajoute la variable en local dans la fonction courante // pour ne pas qu'elle devienne un paramètre de la fonction courante Helper.AddIntoLocal(converter, var); comp.Convert(converter, subProc, file); comp.RemoveCodingProcess(coding.UniqueCodingName); }
/// <summary> /// Load template data /// </summary> /// <param name="comp">compiler object</param> /// <param name="node">xml node object</param> public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.path = node.Attributes.GetNamedItem("path").Value; this.name = node.Attributes.GetNamedItem("name").Value; this.legendes.Load(node.SelectSingleNode("legendes")); this.pars = new Dictionary <string, string>(); foreach (XmlNode paramNode in node.SelectNodes("params/param")) { if (!this.pars.ContainsKey(paramNode.InnerText)) { this.pars.Add(paramNode.InnerText, ""); } } this.xmlCode = node.SelectSingleNode("code").InnerXml; }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.writerName = node.Attributes.GetNamedItem("name").Value; this.filePath = new List <string>(); if (node.SelectNodes("file")[0].FirstChild != null) { foreach (XmlNode paramNode in node.SelectNodes("file/expression")) { string paramValue = paramNode.InnerText; this.filePath.Add(paramValue); } } // on en a besoin pour la conversion this.cachedComp = comp; }
/// <summary> /// Load injector data /// </summary> /// <param name="comp">compiler object</param> /// <param name="node">xml node object</param> public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.name = node.Attributes.GetNamedItem("name").Value; this.injectedProcess = comp.CurrentProcess; this.current = this.injectedProcess.Objects.IndexOf(this); this.before = this.after = this.current; // si je suis dans un squelette if (this.injectedProcess.Name.StartsWith("Skeleton:")) { this.skeleton = this.injectedProcess.Name.Substring(9) + "/"; } else { this.skeleton = ""; } }
/// <summary> /// Load object from xml node /// </summary> /// <param name="comp">this compiler</param> /// <param name="node">xml node object</param> public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } this.language = node.Attributes.GetNamedItem("language").Value; this.name = node.Attributes.GetNamedItem("name").Value; this.legendes.Load(node.SelectSingleNode("legendes")); this.refs.Clear(); foreach (XmlNode paramNode in node.SelectNodes("references/ref")) { if (!this.refs.Contains(paramNode.InnerText)) { this.refs.Add(paramNode.InnerText); } } this.xmlCode = node.SelectSingleNode("code").InnerXml; // on en a besoin pour la conversion this.cachedComp = comp; }
public Texte(ICompilateurInstance comp, IProcessInstance proc) { this.cachedComp = comp; this.cachedProc = proc; }
public void Inject(Injector injector, ICompilateurInstance comp, System.Xml.XmlNode node, string modifier) { this.Load(comp, node); }
public Affectation(ICompilateurInstance comp) { this.cachedComp = comp; }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { this.localeName = node.InnerText; this.enc = comp.EncodedFile; }
public static void IsolatedFunction(ICompilateurInstance comp, IProcessInstance proc, ICodeConverter converter, IsolatedFunctionDelegate d) { if (converter.CurrentFunction.IsStaticControlFlow) { Dictionary <string, IParameter> varNames, leftNames; Action <KeyValuePair <string, IParameter> > action; TypedVariable tv; IFunction prec = converter.CurrentFunction; IFunction thisFunc = new Function(); thisFunc.IndentSize = prec.IndentSize; thisFunc.IsVisible = true; thisFunc.StrictName = "inner_" + comp.Unique.ComputeNewString(); thisFunc.PropagateControlFlow(prec); // ajoute la fonction dans la liste converter.ImplementedFunctions.Add(thisFunc); // change la fonction courante converter.SetCurrentFunction(thisFunc); d(); // retourne à la fonction précédente pour traiter le changement de type converter.SetCurrentFunction(prec); // supprime la fonction de la liste converter.ImplementedFunctions.Remove(thisFunc); leftNames = new Dictionary <string, IParameter>(); // élimine les variables passées en paramètre qui n'ont pas changé de type thisFunc.Parameters.ForEach(new Action <IParameter>(delegate(IParameter par) { if (!leftNames.ContainsKey(par.VariableName) && par.Order != EnumParameterOrder.E_NEW) { leftNames.Add(par.VariableName, par); } })); // enregistre le nom distinct des variables passées en paramètre qui soient mutable et initiale varNames = new Dictionary <string, IParameter>(); thisFunc.Parameters.ForEach(new Action <IParameter>(delegate(IParameter par) { if (!varNames.ContainsKey(par.VariableName) && leftNames.ContainsKey(par.VariableName) && par.IsMutableParameter && par.Order == EnumParameterOrder.E_NEW) { varNames.Add(par.VariableName, par); } })); // modifie toutes les variables en SimpleType action = new Action <KeyValuePair <string, IParameter> >(delegate(KeyValuePair <string, IParameter> kv) { Regex reg = new Regex(@"\$\[([^:]*):([a-z]+_" + kv.Key + @")\]"); thisFunc.Source = reg.Replace(thisFunc.Source, new MatchEvaluator(delegate(Match m) { string type = m.Groups[1].Value; string name = m.Groups[2].Value; int pos = name.IndexOf('_'); string result = String.Empty; if (pos != -1) { result = "$[" + type + ":st_" + name.Substring(pos + 1) + "]"; } else { result = "$[" + type + ":st_" + name + "]"; } return(result); })); tv = new TypedVariable(kv.Value.VariableName, kv.Value.FormalParameter, kv.Value.DataType, EnumDataType.E_SIMPLETYPE); tv.MoveType(converter, proc.CurrentScope); }); foreach (KeyValuePair <string, IParameter> kv in varNames.Except(leftNames)) { action(kv); } // copie de l'implémentation de cette fonction dans la fonction en cours prec.Source += thisFunc.Source; // copies des variables locales de cette fonction dans la fonction en cours thisFunc.LocalVariables.ForEach(new Action <IStructure>(delegate(IStructure loc) { if (!converter.CurrentFunction.LocalVariables.Exists(new Predicate <IStructure>(delegate(IStructure cur) { return(cur.PrefixedFieldName == loc.PrefixedFieldName); }))) { converter.CurrentFunction.LocalVariables.Add(loc); } })); // mettre à jour les paramètres foreach (KeyValuePair <string, IParameter> kv in varNames.Except(leftNames)) { List <IParameter> pars = thisFunc.Parameters.FindAll(new Predicate <IParameter>(delegate(IParameter par) { return(par.VariableName == kv.Key); })); if (pars.Count > 1) { pars.ForEach(new Action <IParameter>(delegate(IParameter update) { if (update.Order == EnumParameterOrder.E_LAST) { tv = new TypedVariable(update.VariableName, update.FormalParameter, EnumDataType.E_SIMPLETYPE, update.DataType); tv.MoveType(converter, proc.CurrentScope); } })); } else if (pars.Count == 1) { tv = new TypedVariable(pars[0].VariableName, pars[0].FormalParameter, EnumDataType.E_SIMPLETYPE, pars[0].DataType); tv.MoveType(converter, proc.CurrentScope); } } } else { d(); } }
public void ConvertToParallel(ICodeConverter converter, ICompilateurInstance comp, IProcessInstance previousProc, FinalFile file) { EndJobs ej = new EndJobs(); this.cachedComp = comp; this.cachedPreviousFunc = converter.ImplementedFunctions.FindLast(new Predicate <IFunction>(delegate(IFunction search) { return(search.StrictName == previousProc.FunctionName); })); // première instruction this.Statements[0].Convert(converter, previousProc, file); // implémenter les fonctions job_xxx for (int index = 1; index < this.Statements.Count - 1; ++index) { ICompiler tache = this.Statements[index]; // Check if it's a call job (blindage) if (tache is CallJob) { CallJob cj = this.Statements[index] as CallJob; ej.Jobs.Add(cj); this.cachedProc = this.cachedComp.GetJobProcess(cj.ProcessName); // Ecriture du code de la fonction IFunction newFunc = Helper.MakeNewMethod(converter, this.cachedProc); Helper.FillNewMethod(comp, this.cachedProc, converter, newFunc, file); newFunc.IsJob = true; //if (this.cachedProc.HasChanged) previousProc.HasChanged = true; // aller chercher les variables exterieures au processus appellé this.cachedFunc = converter.ImplementedFunctions.FindLast(new Predicate <IFunction>(delegate(IFunction func) { return(func.IsJob && func.StrictName == cj.ProcessName); })); if (!converter.CallingFunctions.Exists(new Predicate <IFunction>(delegate(IFunction func) { return(func.IsJob && func.StrictName == cj.ProcessName && func.InstanceNumber == this.cachedFunc.InstanceNumber); }))) { converter.CallingFunctions.Add(this.cachedFunc); } // convertir pour le parallèllisme if (!this.alreadyInstantiated) { // create a new structure to contain all external values string structTypeName = this.cachedComp.Unique.ComputeNewString(); ++converter.CurrentFunction.PrivateVariableCounter; string structInstanceName = structTypeName + converter.CurrentFunction.PrivateVariableCounter.ToString(); // Construit une structure et indique que l'instance doit être mutable this.structRef = converter.CreateNewField(structTypeName, structInstanceName, true); } // ajoute une instance de la structure déclarée dans la fonction en cours if (converter.IsStronglyTyped) { this.cachedFunc.InstancesStructure.Add(this.Structure.PrefixedFieldName, this.Structure.StructureType); } else { this.cachedFunc.InstancesStructure.Add(this.Structure.FieldName, this.Structure.StructureType); } // créer un nouveau paramètre et y inscrire tous les autres paramètres Converters.Parameter parStructure = new Parameter(); parStructure.EffectiveParameter = this.Structure.PrefixedFieldName; parStructure.FormalParameter = this.Structure.PrefixedFieldName; parStructure.VariableName = this.Structure.FieldName; parStructure.IsComputable = false; parStructure.IsMutableParameter = true; // stocker tous les paramètres dans le nouveau paramètre de type structure List <IStructure> newParams = this.GetElements(this.structList, converter, this.cachedFunc).ToList(); parStructure.StructureReferences.AddRange(newParams); this.structList = newParams; parStructure.DataType = EnumDataType.E_STRUCTURE; this.cachedFunc.Parameters.Clear(); this.cachedFunc.Parameters.Add(parStructure); this.alreadyInstantiated = true; } } // ajout de la structure converter.Convert(this); // création des instructions en parallèle // appels des fonctions job_xxx for (int index = 1; index < this.Statements.Count - 1; ++index) { ICompiler tache = this.Statements[index]; // Check if it's a call job (blindage) if (tache is CallJob) { CallJob cj = tache as CallJob; cj.StructureReference = this.Structure; this.cachedProc = this.cachedComp.GetJobProcess(cj.ProcessName); this.cachedProc.MakeOneInstance(previousProc, new RunInnerInstanceProcess(delegate(IProcessInstance previous, IProcessInstance i) { cj.Convert(converter, i, file); })); } } // attendre la fin de toutes les tâches ej.WaitForAllJobs(converter); // dernière instruction this.Statements[this.Statements.Count - 1].Convert(converter, previousProc, file); }
public void Load(ICompilateurInstance comp, System.Xml.XmlNode node) { }
public CallJob(ICompilateurInstance comp) { this.cachedComp = comp; }