public static Variable BuildVariable(XElement data) { string name = data.Attribute("Name")?.ToString(); VarTypes type = Variable.TypeFromGuid[new Guid(data.Attribute("Type").Value)]; string description = data.Attribute("Descr")?.Value; XElement def = data.Element("DefValue"); switch (type) { case VarTypes.String: return(new String(name, type, description, def)); // break; case VarTypes.Integer: return(new Integer(name, type, description, def)); // break; case VarTypes.Array: return(new Variable(name, type, description)); // break; case VarTypes.Table: return(new Table(name, type, description, def)); // break; default: return(null); // break; } }
public Table(string name, VarTypes type, string description, XElement def) : base(name, type, description) { m_rowNames = new List <string>(); m_columnNames = new List <string>(); Rows = int.Parse(def.Attribute("RowCount").Value); Columns = int.Parse(def.Attribute("ColumnCount").Value); var cols = def.Element("Columns"); for (int i = 0; i < Columns; i++) { m_columnNames.Add(cols.Attribute("ColumnName" + i).Value); } m_data = new string[Rows, Columns]; var r = 0; foreach (var row in def.Elements("Row")) { var thisRow = new Row(Columns, row); var c = 0; foreach (var col in thisRow.Data) { m_data[r, c++] = DecodeUnicodeString(col); } r++; } }
public void Set(Variable var1, VarTypes varTpe, Variable var2, VarTypes var2Type) { Var1 = var1; Var1Type = varTpe; Var2 = var2; Var2Type = var2Type; }
public static void AddArg(this Function func, VarTypes type) { Variable var = new Variable(); var.VarType = type; func.Arguments.Add(var); }
public ArrayVariableNode(string name, VarTypes type, int start, int end) : base(name, type) { variableName = name; this.type = type; startIndex = start; endIndex = end; }
public VarArray(AstArrayTypeName type, VarLocation location) : base(type) { // Obtain our array size ArraySize = VarTypes.ParseArrayTypeComponents(BaseType).arraySize; // Set our type name ArrayTypeName = type; // Set our element parser with the given array element/base type. ElementObject = VarTypes.GetVariableObject(ArrayTypeName.BaseType, location); // Define our bounds variables int storageSlotCount = 1; if (ArraySize.HasValue) { // If an element doesn't fit in a single slot, we keep the storage format as is, and slot count = element count * element slot count. // If an element fits in a single slot, we try to compact multiple into a single slot. if (ElementObject.SizeBytes >= UInt256.SIZE) { storageSlotCount = ArraySize.Value * ElementObject.StorageEntryCount; } else { // Determine how many elements we can fit in a slot. int elementsPerSlot = UInt256.SIZE / ElementObject.SizeBytes; // Figure out how many slots we'll actually need to store the element count. storageSlotCount = (int)Math.Ceiling(ArraySize.Value / (double)elementsPerSlot); } } // Initialize our bounds. InitializeBounds(storageSlotCount, UInt256.SIZE, location); }
public void Set(Ray var1, VarTypes varTpe, Ray var2, VarTypes var2Type) { Var1 = var1; Var1Type = varTpe; Var2 = var2; Var2Type = var2Type; }
public SetVariable(XElement data, XElement children) : base("Set Variable Value", OperTypes.SetVariable, data, children) { VariableName = data.Attribute("VariableName")?.Value; var typenumber = int.Parse(data.Attribute("VariableType").Value); VariableType = Variable.TypeFromNumber[typenumber]; }
//=========== HELPERS ============ #region Helpers /**<summary>Parses a variable based on its type.</summary>*/ private object ParseVariable(VarTypes type, string text) { try { switch (type) { case VarTypes.Bool: return(bool.Parse(text)); case VarTypes.Byte: return(byte.Parse(text)); case VarTypes.Short: return(short.Parse(text)); case VarTypes.Int: return(int.Parse(text)); case VarTypes.Float: return(float.Parse(text)); case VarTypes.String: return(text); case VarTypes.Color: return(ParseColor(text)); case VarTypes.UseSound: return(ParseUseSound(text)); } return(null); } catch (Exception ex) { return(ex); } }
public VarFixedBytes(AstElementaryTypeName type) : base(type) { // Determine the size of our fixed array. int sizeBytes = VarTypes.GetFixedArraySizeInBytes(BaseType); // Initialize our bounds InitializeBounds(1, sizeBytes); }
public VarInt(AstElementaryTypeName type) : base(type) { // Obtain our size in bytes int sizeBytes = VarTypes.GetIntegerSizeInBytes(BaseType, GenericType); // Initialize our bounds InitializeBounds(1, sizeBytes); }
public void OnEventAddAgain(string name, Domains domain, VarTypes varType, string question) { var handler = EventAddAgain; if (handler != null) { handler(name, domain, varType, question); } }
public VarBase(AstElementaryTypeName type) { // Set our type Type = type; // Obtain the components of our type and set them. BaseType = VarTypes.ParseTypeComponents(type.TypeDescriptions.TypeString).baseType; // Obtain our generic type. GenericType = VarTypes.GetGenericType(BaseType); }
public Integer(string name, VarTypes type, string description, XElement def) : base(name, type, description) { if (int.TryParse(def.Elements().FirstOrDefault()?.ToString(), out var temp)) { Default = temp; } else { Default = null; } }
/**<summary>Constructs the base variable.</summary>*/ public VarInfo(VarTypes type, string internalName, VarSetters setter = VarSetters.Normal) { this.Type = type; if (internalName != "") { this.Field = typeof(Item).GetField(internalName); } else { this.Field = null; } this.Setter = setter; }
public bool isPercentageScan; //next scan public ScanParameters() { //default config ScanOption = ScanOptions.soExactValue; VarType = VarTypes.vtDword; RoundingType = RoundingTypes.rtExtremerounded; StartAddress = 0; StopAddress = (UInt64)(Int64.MaxValue); ProtectionFlags = "+W-C"; //wirable, not copy-on-write, and ignore execute AlignmentType = FastScanMethods.fsmAligned; AlignmentValue = "4"; isHexadecimalInput = false; isUTF16Scan = false; isCaseSensitive = false; isPercentageScan = false; }
protected Color getColor(VarTypes t) { switch (t) { case VarTypes.Int: return(intColor); case VarTypes.Float: return(floatColor); case VarTypes.Bool: return(boolColor); case VarTypes.Object: return(objectColor); case VarTypes.MatineeData: return(interpDataColor); default: return(Color.Black); } }
private void FOnEventAddAgain(string name, Domains domains, VarTypes varTypes, string question) { //2. Если ОК, то выполняется проверка на совпадение var same = _esCopy.Variables.Where(x => x.Name.ToLower() == name.ToLower()).Select(x => x); if (same.Any()) { MessageBox.Show("Переменная с таким именем уже существует."); return; } //3. Если Не совпадает, то новая переменная добавляется в копию БД var variable = new Variables { Name = name, Domains = domains, VarTypes = varTypes, Question = question }; _esCopy.Variables.InsertOnSubmit(variable); _esCopy.SubmitChanges(); FillListViewVariables(); if (!_somethingChanged) { Text += "*"; } _somethingChanged = true; }
public dynamic GetParameterType(string paramName, ReturnType returnType) { VarTypes ret = GetVarType(paramName); if (returnType == ReturnType.AsEnum) { return(ret); } if (ret == VarTypes.TypeArray) { return("Array"); } if (ret == VarTypes.TypeFloat) { return("Float"); } if (ret == VarTypes.TypeInteger) { return("Integer"); } if (ret == VarTypes.TypeOther) { return("Other"); } if (ret == VarTypes.TypeTagged) { return("Tagged"); } return(null); }
public DeclarationsNode Declarations() { var declarations = new DeclarationsNode(); while (token.value == "var") { Match(TokenTypes.ID, "var"); VarTypes type = VarTypes.NONE; var tempList = new List <string>();//holds the names of declared variables Match(TokenTypes.ID); tempList.Add(returnToken.value); while (token.value == ",") { Match(TokenTypes.COMMA); Match(TokenTypes.ID); tempList.Add(returnToken.value); } Match(TokenTypes.COLON); if (token.value == "array")//if its an array { Match(TokenTypes.ID, "array"); Match(TokenTypes.LBRACKET); Match(TokenTypes.NUM); int startIndex = int.Parse(returnToken.value); Match(TokenTypes.COLON); Match(TokenTypes.NUM); int endIndex = int.Parse(returnToken.value); Match(TokenTypes.RBRACKET); Match(TokenTypes.ID, "of"); if (token.value == "integer") { type = VarTypes.INT; } else if (token.value == "real") { type = VarTypes.REAL; } Match(TokenTypes.ID); foreach (var name in tempList) { var var = new ArrayVariableNode(name, type, startIndex, endIndex); declarations.variableList.Add(var); } } else//if its not an array { if (token.value == "integer") { type = VarTypes.INT; } else if (token.value == "real") { type = VarTypes.REAL; } Match(TokenTypes.ID); foreach (var name in tempList) { var vari = new VariableNode(name, type); declarations.variableList.Add(vari); } } Match(TokenTypes.SEMICOLON); } return(declarations); }
public Variable(string name, VarTypes type, string description) { Name = name; Type = type; Description = description; }
public static string GetTypeName(this VarTypes type, Assembly asm, int StructID, int dimension) { string name = ""; try { switch (type) { case VarTypes.StrucRef: name = "ref " + asm.Structures[StructID].Name; break; case VarTypes.Struct: name = asm.Structures[StructID].Name; break; case VarTypes.ArrayStruct: name = asm.Structures[StructID].Name + dimension.GetDimension(); break; case VarTypes.IntRef: name = "ref int"; break; case VarTypes.FloatRef: name = "ref float"; break; case VarTypes.StringRef: name = "ref string"; break; case VarTypes.ArrayIntRef: name = "ref int" + dimension.GetDimension(); break; case VarTypes.ArrayFloatRef: name = "ref float" + dimension.GetDimension(); break; case VarTypes.ArrayStringRef: name = "ref string" + dimension.GetDimension(); break; case VarTypes.ArrayStructRef: name = "ref " + asm.Structures[StructID].Name + dimension.GetDimension(); break; case VarTypes.ArrayInt: name = "int" + dimension.GetDimension(); break; case VarTypes.ArrayFloat: name = "float" + dimension.GetDimension(); break; case VarTypes.ArrayString: name = "string" + dimension.GetDimension(); break; case VarTypes.ArrayBool: name = "bool" + dimension.GetDimension(); break; case VarTypes.ArrayDelegate: name = "delegate" + dimension.GetDimension(); break; default: name = type.ToString().ToLower(); break; } } catch { name = type.ToString().ToLower(); } return(name); }
public SubProgramNode SubProgram() { SubProgramNode subProgramNode = new SubProgramNode(); Match(TokenTypes.ID); subProgramNode.id = returnToken.value; if (token.value == "(") { bool end; Match(TokenTypes.LPAR); do { VarTypes type = VarTypes.NONE; var tempList = new List <string>();//holds the names of declared variables Match(TokenTypes.ID); tempList.Add(returnToken.value); while (token.value == ",") { Match(TokenTypes.COMMA); Match(TokenTypes.ID); tempList.Add(returnToken.value); } Match(TokenTypes.COLON); if (token.value == "array")//if its an array { Match(TokenTypes.ID, "array"); Match(TokenTypes.LBRACKET); Match(TokenTypes.NUM); int startIndex = int.Parse(returnToken.value); Match(TokenTypes.COLON); Match(TokenTypes.NUM); int endIndex = int.Parse(returnToken.value); Match(TokenTypes.RBRACKET); Match(TokenTypes.ID, "of"); if (token.value == "integer") { type = VarTypes.INT; } else if (token.value == "real") { type = VarTypes.REAL; } Match(TokenTypes.ID); foreach (var name in tempList) { var var = new ArrayVariableNode(name, type, startIndex, endIndex); subProgramNode.argumentList.Add(var); } } else//if its not an array { if (token.value == "integer") { type = VarTypes.INT; } else if (token.value == "real") { type = VarTypes.REAL; } Match(TokenTypes.ID); foreach (var name in tempList) { var vari = new VariableNode(name, type); subProgramNode.argumentList.Add(vari); } } end = token.value == ")"; if (!end) { Match(TokenTypes.SEMICOLON); } } while (!end); Match(TokenTypes.RPAR); if (token.value == ":") { Match(TokenTypes.COLON); Match(TokenTypes.ID); subProgramNode.type = returnToken.value; } Match(TokenTypes.SEMICOLON); } subProgramNode.declarations = Declarations(); SubProgramDeclarations(subProgramNode.methodList); CompoundStatement(subProgramNode.statementList); return(subProgramNode); }
public VariableNode(string name, VarTypes type) { variableName = name; this.type = type; }
protected Color getColor(VarTypes t) { switch (t) { case VarTypes.Int: return Color.FromArgb(34, 218, 218);//cyan case VarTypes.Float: return Color.FromArgb(23, 23, 213);//blue case VarTypes.Bool: return Color.FromArgb(215, 37, 33); //red case VarTypes.Object: return Color.FromArgb(219, 39, 217);//purple case VarTypes.MatineeData: return Color.FromArgb(222, 123, 26);//orange default: return Color.Black; } }
public static Loop Random(Random random) => new Loop(VarTypes.Random(random), OpTypes.Random(random), VarTypes.Random(random));
//=========== HELPERS ============ #region Helpers /**<summary>Registers a variable.</summary>*/ private static void AddVar(VarTypes type, string internalName, string externalName, VarSetters setter = VarSetters.Normal) { VarInfoList.Add(externalName, new VarInfo(type, internalName, setter)); }
public String(string name, VarTypes type, string description, XElement def) : base(name, type, description) { Default = def.Elements().FirstOrDefault()?.Value; }
protected void prepareErrorDescription() { switch (ErrorType) { case "ZeroDivisionError": PositionInLine = Value.LastIndexOf("/"); break; case "TypeError": { Match noArgsMatch = functionWithoutArgsRegex.Match(Description); if (noArgsMatch.Success) { string functionName = noArgsMatch.Groups[1].Value; int argsRequired = int.Parse(noArgsMatch.Groups[2].Value); Description = $"<{functionName}> FUNCTION too less args (required {argsRequired} more)"; break; } Match functionErrorMatch = functionArguementsRegex.Match(Description); if (functionErrorMatch.Success) { int argsRequired = int.Parse(functionErrorMatch.Groups[2].Value); int argsGiven = int.Parse(functionErrorMatch.Groups[3].Value); Description = $"<{functionErrorMatch.Groups[1].Value}> FUNCTION too many args (takes {argsRequired} args only)"; break; } Match binaryOperationErrorMatch = binaryOperationArgumentsRegex.Match(Description); if (binaryOperationErrorMatch.Success) { string operation = binaryOperationErrorMatch.Groups[1].Value; string type1 = binaryOperationErrorMatch.Groups[2].Value; string type2 = binaryOperationErrorMatch.Groups[3].Value; PositionInLine = Value.LastIndexOf(operation); operation = Token.GetTokenType(operation).ToString(); VarTypes varType = VarTypes.NONE_VAR; if (StringVarTypes.TryGetValue(type1, out varType)) { type1 = varType.ToString(); } if (StringVarTypes.TryGetValue(type2, out varType)) { type2 = varType.ToString(); } Description = $"operation << {type1} {operation} {type2} >> is impossible"; break; } break; } case "NameError": { Match nameErrorMatch = nameErrorRegex.Match(Description); if (nameErrorMatch.Success) { string name = nameErrorMatch.Groups[1].Value; Description = $"<<{name}>> UNKNOWN_VAR"; PositionInLine = Value.IndexOf(name); } break; } default: break; } }
protected Color getColor(VarTypes t) { switch (t) { case VarTypes.Int: return intColor; case VarTypes.Float: return floatColor; case VarTypes.Bool: return boolColor; case VarTypes.Object: return objectColor; case VarTypes.MatineeData: return interpDataColor; default: return Color.Black; } }