/// <summary> /// Defines or update a variable object stored in the scope; the variable data type is an integer only /// Because of assigned from the size of an array, the variable is never computable; /// if the variable was computable, it won't be /// As the variable value has changed, make a mutable parameter if any /// As the variable was not exist in the scope, the variable prefixed name (with a type's prefix) is stored in local /// Identical from ConvertNewDictionaryString except a different data type /// </summary> /// <param name="comp">compilation</param> /// <param name="proc">process</param> /// <param name="converter">language converter</param> /// <param name="varName">variable name to be stored in the scope</param> /// <returns>an added variable object stored in the scope</returns> public static IData ConvertNewDictionarySize(ICompilateur comp, IProcessInstance proc, ICodeConverter converter, string varName) { // control if variable is in the scope if (proc.CurrentScope.Exists(varName)) { // get the variable infos IData myVar = proc.CurrentScope.GetVariable(varName); // update variable if (myVar.TypeExists(EnumDataType.E_NUMBER)) { proc.CurrentScope.Update(varName, "", myVar.PrefixInfo(EnumDataType.E_NUMBER).BelongsTo, false, EnumDataType.E_NUMBER); } else { proc.CurrentScope.Update(varName, "", myVar.BelongsTo, false, EnumDataType.E_NUMBER); } // on met à jour les paramètres en indiquant que la variable est mutable comp.UpdateParameters(converter, proc, varName, true); return(myVar); } else { // créer une nouvelle variable dans le scope; en déduire qu'elle est locale IData added = proc.CurrentScope.Add(varName, "", proc.Name, false, EnumDataType.E_NUMBER); Helper.AddIntoLocal(converter, added); return(added); } }
/// <summary> /// Saving the object into an xml node /// </summary> /// <param name="comp">this compiler</param> /// <param name="writer">Xml writer object</param> /// <param name="child">html child for nested objects</param> public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { writer.WriteStartElement("createmop"); writer.WriteAttributeString("language", this.language); writer.WriteAttributeString("name", this.name); if (this.indent > 0) { writer.WriteAttributeString("indent", this.indent.ToString()); } writer.WriteStartElement("legendes"); this.legendes.Save(writer); writer.WriteEndElement(); writer.WriteStartElement("references"); foreach (string param in this.refs) { writer.WriteStartElement("ref"); writer.WriteString(param); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteStartElement("code"); writer.WriteRaw(this.xmlCode); writer.WriteEndElement(); writer.WriteEndElement(); child = child.NextSibling; }
public void Parse(ICompilateur comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } }
/// <summary> /// Assumes to be a calculable expression /// Evaluates the expression and returns the value /// </summary> /// <param name="comp">compilation</param> /// <param name="proc">process</param> /// <param name="converter">language converter</param> /// <param name="expression">expression</param> /// <returns>a standalone variable object (do not add into the scope)</returns> private static IDataNotInScope ComputeExpression(ICompilateur comp, IProcessInstance proc, ICodeConverter converter, string expression) { // print expression with all variables and additional source o2Mate.Expression expr = new o2Mate.Expression(); IDataNotInScope val = expr.Evaluate(expression, proc.CurrentScope); return(val); }
public void Parse(ICompilateur comp, System.Xml.XmlNode node) { if (node.Attributes.GetNamedItem("indent") != null) { Int32.TryParse(node.Attributes.GetNamedItem("indent").Value, out this.indent); } comp.Parse(comp, node.SelectSingleNode("code")); }
/// <summary> /// Convert the expression with the desired data type /// </summary> /// <param name="comp">compilation</param> /// <param name="proc">process</param> /// <param name="converter">language converter</param> /// <param name="expression">expression</param> /// <param name="desiredType">desired type conversion</param> /// <returns>standalone variable with the result value (do not add into the scope)</returns> private static IDataNotInScope ConvertExpression(ICompilateur comp, IProcessInstance proc, ICodeConverter converter, string expression, o2Mate.EnumDataType desiredType) { // does add additional statements o2Mate.Expression.Convert(converter, expression, proc.CurrentScope, true, desiredType, true); IDataNotInScope res = new Variable("", false, converter.CurrentFunction.DataTypeResult); res.Value = converter.CurrentFunction.CacheSource; return(res); }
public void Parse(ICompilateur 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; }
/// <summary> /// Parse is not load /// </summary> /// <param name="comp">compiler object</param> /// <param name="node">xml node from reading</param> public void Parse(ICompilateur 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; }
public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { writer.WriteStartElement("br"); if (this.indent > 0) { writer.WriteAttributeString("indent", this.indent.ToString()); } writer.WriteEndElement(); child = child.NextSibling; }
/// <summary> /// Parse is not load /// </summary> /// <param name="comp">compiler object</param> /// <param name="node">xml node from reading</param> public void Parse(ICompilateur 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 Parse(ICompilateur 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", ""); }
/// <summary> /// Save this statement into an xml file /// </summary> /// <param name="comp">compiler object</param> /// <param name="writer">xml writer object</param> /// <param name="child">html child to save</param> public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { writer.WriteStartElement("usemop"); writer.WriteAttributeString("language", this.language); writer.WriteAttributeString("command", this.command); writer.WriteAttributeString("expression", this.expression); if (this.indent > 0) { writer.WriteAttributeString("indent", this.indent.ToString()); } writer.WriteEndElement(); child = child.NextSibling; }
/// <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)); }
/// <summary> /// Use this function to convert an expression which can be computable or not /// Returns a variable object to do not store in the scope /// Supply the type to convert /// </summary> /// <param name="comp">compilation</param> /// <param name="proc">process</param> /// <param name="converter">language converter</param> /// <param name="expression">expression</param> /// <param name="desiredType">desired data type result</param> /// <returns>a string with the converted expression</returns> public static string ConvertNewExpression(ICompilateur comp, IProcessInstance proc, ICodeConverter converter, string expression, o2Mate.EnumDataType desiredType) { // convert inline expression using variables stored in scope // does add additional statements o2Mate.Expression.Convert(converter, expression, proc.CurrentScope, true, desiredType, true); // since variable is used, check to all used variable, needed to clarify locals or parameters foreach (string used in converter.CurrentFunction.UsedVariables) { comp.UpdateParameters(converter, proc, used, false); } return(converter.CurrentFunction.CacheSource); }
public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { writer.WriteStartElement("parallel"); if (this.indent > 0) { writer.WriteAttributeString("indent", this.indent.ToString()); } writer.WriteStartElement("code"); // search next sibling child of code System.Windows.Forms.HtmlElement subElement = child.NextSibling; comp.Save(writer, ref subElement, this.indent + 1); writer.WriteEndElement(); writer.WriteEndElement(); child = subElement; }
public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { writer.WriteStartElement("affectation"); if (this.indent > 0) { writer.WriteAttributeString("indent", this.indent.ToString()); } writer.WriteStartElement("variable"); writer.WriteString(this.varName); writer.WriteEndElement(); writer.WriteStartElement("expression"); writer.WriteString(this.expression); writer.WriteEndElement(); writer.WriteEndElement(); child = child.NextSibling; }
public void Parse(ICompilateur 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); } } }
/// <summary> /// Save the statement into an xml file /// </summary> /// <param name="comp">compiler object</param> /// <param name="writer">xml writer object</param> /// <param name="child">html child to save</param> public void Save(ICompilateur comp, XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { writer.WriteStartElement("syntax"); writer.WriteAttributeString("name", this.name); if (this.indent > 0) { writer.WriteAttributeString("indent", this.indent.ToString()); } writer.WriteStartElement("legendes"); this.legendes.Save(writer); writer.WriteEndElement(); writer.WriteStartElement("code"); writer.WriteRaw(this.xmlCode); writer.WriteEndElement(); writer.WriteEndElement(); child = child.NextSibling; }
/// <summary> /// Dans le cas où la variable n'est pas ou plus calculable /// Enregistre une expression dans une variable incalculable permettant d'utiliser l'expression /// dans la conversion d'une variable assignée dont le type est défini par l'inférence de l'expression /// </summary> /// <param name="comp">compilateur</param> /// <param name="proc">process</param> /// <param name="converter">langage de conversion</param> /// <param name="expression">expression</param> /// <param name="varName">variable</param> /// <returns>l'objet variable utilisé</returns> private static IData ConvertExpression(ICompilateur comp, IProcessInstance proc, ICodeConverter converter, string expression, string varName) { EnumDataType fixedDataType = converter.CurrentFunction.DataTypeResult; // 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); // the variable exists in the scope, assumed infer the data type from expression // include additional statements for converting expression o2Mate.Expression.Convert(converter, expression, proc.CurrentScope, true, fixedDataType, true); if (myVar.TypeExists(fixedDataType)) { proc.CurrentScope.Update(varName, converter.CurrentFunction.CacheSource, myVar.PrefixInfo(fixedDataType).BelongsTo, false, fixedDataType); } else { // le nouveau type de données de cette variable doit appartenir au processus // qui a initialisé la variable proc.CurrentScope.Update(varName, converter.CurrentFunction.CacheSource, myVar.BelongsTo, false, fixedDataType); } // on met à jour les paramètres en indiquant que cette variable est mutable comp.UpdateParameters(converter, proc, varName, true); return(myVar); } else { // convert expression including variable name o2Mate.Expression.Convert(converter, expression, proc.CurrentScope, true, fixedDataType, true); // create variable, don't use value and assumes to be non-computable and infer data type by the expression IData added = proc.CurrentScope.Add(varName, converter.CurrentFunction.CacheSource, proc.Name, false, fixedDataType); Helper.AddIntoLocal(converter, added); return(added); } }
/// <summary> /// Parse but not load /// </summary> /// <param name="comp">this compiler</param> /// <param name="node">xml node to read</param> public void Parse(ICompilateur 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; }
/// <summary> /// Parse is not load /// </summary> /// <param name="comp">compiler object</param> /// <param name="node">xml node from reading</param> public void Parse(ICompilateur 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 Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { writer.WriteStartElement("createwriter"); writer.WriteAttributeString("name", this.writerName); if (this.indent > 0) { writer.WriteAttributeString("indent", this.indent.ToString()); } writer.WriteStartElement("file"); foreach (string expression in this.filePath) { writer.WriteStartElement("expression"); writer.WriteString(expression); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteEndElement(); child = child.NextSibling; }
public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { writer.WriteStartElement("condition"); if (this.indent > 0) { writer.WriteAttributeString("indent", this.indent.ToString()); } writer.WriteStartElement("expression"); writer.WriteString(this.expression); writer.WriteEndElement(); writer.WriteStartElement("iftrue"); writer.WriteString(this.labelTrue); writer.WriteEndElement(); writer.WriteStartElement("iffalse"); writer.WriteString(this.labelFalse); writer.WriteEndElement(); writer.WriteEndElement(); child = child.NextSibling; }
/// <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> /// Use this function to convert an expression which can be computable or not /// Returns a variable object to do not store in the scope /// </summary> /// <param name="comp">compilation</param> /// <param name="proc">process</param> /// <param name="converter">language converter</param> /// <param name="expression">expression</param> /// <returns>a standalone variable with its value (do not store it in the scope)</returns> public static IDataNotInScope ConvertNewExpression(ICompilateur comp, IProcessInstance proc, ICodeConverter converter, string expression) { // convert inline expression using variables stored in scope // does not add additional statements o2Mate.Expression.Convert(converter, expression, proc.CurrentScope, false); // switch about calculability if (converter.CurrentFunction.IsComputableExpression) { // the value of the expression can be exactly computed among the execution return(Helper.ComputeExpression(comp, proc, converter, expression)); } else { // since variable is not computable, check to all used variable, needed to clarify locals or parameters foreach (string used in converter.CurrentFunction.UsedVariables) { comp.UpdateParameters(converter, proc, used, false); } // the value of the expression cannot be exactly computed among the execution return(Helper.ConvertExpression(comp, proc, converter, expression)); } }
public void SetCompile(ICompilateur comp) { this.cachedComp = comp; }
public void Parse(ICompilateur comp, System.Xml.XmlNode node) { this.localeName = node.InnerText; }
public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { throw new NotImplementedException(); }
public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child) { writer.WriteStartElement("locale"); writer.WriteString(this.localeName); writer.WriteEndElement(); }
public void Parse(ICompilateur comp, System.Xml.XmlNode node) { throw new NotImplementedException(); }