/// <summary> /// Helper method for generating the string representation of a given VarName. /// </summary> /// <param name="name">The VarName for which to generate a string representation.</param> /// <returns>The string representation of the VarName.</returns> public static string GetString(VarName name) { switch (name) { case VarName.Tc: case VarName.FirstLocal: case VarName.SecondLocal: return(name.ToString()); case VarName.StaticObjectField: return(GetString(VarType.TestClass) + "." + nameof(TestClass.StaticObjectField)); case VarName.StaticIntegerField: return(GetString(VarType.TestClass) + "." + nameof(TestClass.StaticIntegerField)); case VarName.InstanceObjectField: return(VarName.Tc.ToString() + "." + nameof(TestClass.InstanceObjectField)); default: throw new NotImplementedException("Unhandled VarName"); } }
public override AstStatement Clone() => CopyValuesTo(new AstForStmt( VarName?.Clone() as AstIdExpr, IndexName?.Clone() as AstIdExpr, Collection.Clone(), Body.Clone(), Arguments?.Select(a => a.Clone() as AstArgument)?.ToList(), Label?.Clone() as AstIdExpr));
/// <summary> /// Method for generating a string representation of a call to a non-TestClass method. /// </summary> /// <param name="callingVar">The variable that calls this method.</param> /// <param name="methodName">The method name to be called.</param> /// <param name="args">The list of arguments of the method.</param> /// <returns>A string representation of the method call.</returns> public static string CallMethod(VarName callingVar, string methodName, string[] args = null) { var concatArgs = args == null ? string.Empty : string.Join(",", args); return(GetString(callingVar) + "." + methodName + "(" + concatArgs + ");\n"); }
public override string ToString() { if (!string.IsNullOrEmpty(VarName)) { return(VarName.ToString()); } else { return(this.ID.ToString()); } }
public override int GetHashCode() { unchecked { var hashCode = (VarName != null ? VarName.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (VarTag != null ? VarTag.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (VarArrays != null ? VarArrays.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (DefaultValue != null ? DefaultValue.GetHashCode() : 0); return(hashCode); } }
/// <summary> /// Parse all variables in template /// </summary> private void ParseVariables() { int idxCurrent = 0; while ((idxCurrent = this._ParsedBlock.IndexOf(this.VariableTagBegin, idxCurrent)) != -1) { string VarName, VarValue; int idxVarTagEnd; idxVarTagEnd = this._ParsedBlock.IndexOf(this.VariableTagEnd, (idxCurrent + this.VariableTagBegin.Length)); if (idxVarTagEnd == -1) { throw new Exception(String.Format("Index {0}: could not find Variable End Tag", idxCurrent)); } // Getting Variable Name VarName = this._ParsedBlock.Substring((idxCurrent + this.VariableTagBegin.Length), (idxVarTagEnd - idxCurrent - this.VariableTagBegin.Length)); // Checking for Modificators string[] VarParts = VarName.Split(this.ModificatorTag.ToCharArray()); VarName = VarParts[0]; // Getting Variable Value // If Variable doesn't exist in _hstValue then // Variable Value equal empty string // [added 6/6/2006] If variable is null than it will also has empty string VarValue = String.Empty; if (this._hstValues.ContainsKey(VarName) && this._hstValues[VarName] != null) { VarValue = this._hstValues[VarName].ToString(); } // Apply All Modificators to Variable Value for (int i = 1; i < VarParts.Length; i++) { this.ApplyModificator(ref VarValue, VarParts[i]); } // Replace Variable in Template this._ParsedBlock = this._ParsedBlock.Substring(0, idxCurrent) + VarValue + this._ParsedBlock.Substring(idxVarTagEnd + this.VariableTagEnd.Length); // Add Length of added value to Current index // to prevent looking for variables in the added value // Fixed Date: April 5, 2006 idxCurrent += VarValue.Length; } }
private void UpdateVar() { if (IsVarable) { try { var vars = TWS.Vars.Where(v => v.VarName.ToLower() == VarName.ToLower()); if (vars.Count() > 0) { vars.Single().Update(Value); } else { TWS.Vars.Add(new Param(VarName, Value)); } } catch { } } }
protected override CalResult SingOperate() { if (!IsSetValue) { if (CalCurrent.VarDataPool.ContainsKey(VarName)) { if (CalCurrent.CurrentIndex == -1) { return(CalCurrent.VarDataPool[VarName]); } else { var y = CalCurrent.VarDataPool[VarName]; if (y.Results != null) { return(new CalResult { Result = y.Results[CalCurrent.CurrentIndex], ResultType = y.ResultType }); } else { return(y); } } } else { throw new ExpressErrorException("变量" + VarName + "未赋值!"); } } return(new CalResult { Result = VarName.ToString(), ResultType = typeof(string) }); }
private void ReadFromPlayerPrefs() { VarName v = 0; int i = 0; string varName = VarName.Players.ToString(); // check language and set default if (!PlayerPrefs.HasKey(VarName.Language.ToString())) { //if user runs the game for the first time if (Application.systemLanguage == SystemLanguage.English) { Config.SetVar(VarName.Language, 0); } else if (Application.systemLanguage == SystemLanguage.Russian) { Config.SetVar(VarName.Language, 1); } } //iterate through enum. //while enum has such name. //when getting out of enum`s range varName will become integer without name. while (varName != i.ToString()) { int c; //check if there is such key, if not then player prefs does not exist. So leave default config values. if (PlayerPrefs.HasKey(varName)) { c = PlayerPrefs.GetInt(varName); Config.SetVar(v, c); //print("Read " + c.ToString() + varName); } i++; v++; varName = ((VarName)i).ToString(); } }
/// <summary> /// Generates a string representation of value assignment to a variable. /// </summary> /// <param name="name">The name of the variable to be assigned to.</param> /// <param name="value">The string representation of the value to be assigned.</param> /// <returns>String representation of the value assignment statement.</returns> public static string Assign(VarName name, string value) => $"{GetString(name)} = {value};\n";
/// <summary> /// Generates a string representation for object dereference via GetHashCode. /// </summary> /// <param name="name">The variable name for the object being dereferenced.</param> /// <returns>The string representation of the variable dereference.</returns> public static string DerefObject(VarName name) => name == VarName.None ? string.Empty : $"_ = {GetString(name)}.GetHashCode();\n";
/// <summary> /// Generates a string representation for variable declaration. /// </summary> /// <param name="type">The type of the variable being declared.</param> /// <param name="name">The name of the variable being declared.</param> /// <returns>The string representation of the variable declaration.</returns> public static string Declare(VarType type, VarName name) => $"{GetString(type)} {GetString(name)};\n";
/// <summary> /// Returns a string representing the first array element for the input variable name. The /// variable must correspond to an array type. /// </summary> /// <param name="name">The variable name referencing the array.</param> /// <returns>The string representation for the first element of the array.</returns> public static string GetFirstArrayElement(VarName name) => GetString(name) + "[0]";
public static void SwitchVar(VarName name) { switch (name) { case VarName.Players: Players = Cycle(Players, MinPlayers, MaxPlayers); break; case VarName.Cards: if (Cards == MinCards) { Cards = MaxCards; } else { Cards = MinCards; } break; case VarName.Face: CardsFace++; if (CardsFace >= totalFaces) { CardsFace = 0; } break; case VarName.Background: CardsBackground++; if (CardsBackground >= totalBackgrounds) { CardsBackground = 0; } break; case VarName.Table: Table++; if (Table >= totalTables) { Table = 0; } break; case VarName.Language: Language++; if (Language >= totalLanguages) { Language = 0; } break; case VarName.AutoBet: AutoBet = !AutoBet; break; case VarName.TwoBeatsAce: TwoBeatsAce = !TwoBeatsAce; break; case VarName.UntilOneEliminated: UntilOneEliminated = !UntilOneEliminated; break; case VarName.Giveaway: Giveaway = !Giveaway; break; default: break; } }
public static void SetVar(VarName name, int val) { switch (name) { case VarName.Players: if (val >= MinPlayers && val <= MaxPlayers) { Players = val; } break; case VarName.Cards: if (val >= MinCards && val <= MaxCards) { Cards = val; } break; case VarName.AutoBet: if (val > 0) { AutoBet = true; } else { AutoBet = false; } break; case VarName.TwoBeatsAce: if (val > 0) { TwoBeatsAce = true; } else { TwoBeatsAce = false; } break; case VarName.UntilOneEliminated: if (val > 0) { UntilOneEliminated = true; } else { UntilOneEliminated = false; } break; case VarName.Giveaway: if (val > 0) { Giveaway = true; } else { Giveaway = false; } break; case VarName.Face: if (val < totalFaces && val >= 0) { CardsFace = val; } break; case VarName.Background: if (val < totalBackgrounds && val >= 0) { CardsBackground = val; } break; case VarName.Table: if (val < totalTables && val >= 0) { Table = val; } break; case VarName.Language: if (val < totalLanguages && val >= 0) { Language = val; } break; } }
/// <summary> /// Find next Token in Program /// </summary> /// <returns>Found Token Type</returns> private Token FindNextToken(ref ArrayList ProgramToTokenize) { /* Workings of method * 1. Search for End of Program * 2. Search for Numbers * 3. Search for Special characters * 4. Search for Quoted Strings * 5. Search for Keywords * 6. Search for Known variables * 7. Search for New variables */ /////////////////////////////////////////////////////////////////////////// // // Search for End of Program // /////////////////////////////////////////////////////////////////////////// // Check for End of program if ((SourceCode[SourceCodePosition] == (char)0) || (SourceCodePosition > SourceCode.Length)) { return(new EndOfInputToken(this, "")); } /////////////////////////////////////////////////////////////////////////// // // Search for Numbers // /////////////////////////////////////////////////////////////////////////// // Token is a Number if (CHECK_FOR_NUMBER.IndexOf(SourceCode[SourceCodePosition]) != -1) { // Retrieve number for (int i = 0; i < (MAX_NUM_LENGTH + 1); ++i) { // Check if next char is numeric if (CHECK_FOR_NUMBER.IndexOf(SourceCode[SourceCodePosition + i]) == -1) { // Check number length if (i > 0) { // Incease Program Search Position SourceCodeNextPosition = SourceCodePosition + i; // If we expect a Line number return LineNumberToken else return NumberToken if (ExpectLineNumber) { ExpectLineNumber = false; return(new LineNumberToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } else { ExpectLineNumber = false; return(new NumericToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } } else { throw new BasicParserException(BasicParserException.UNKNOWN_ERROR); } } } throw new BasicParserException(BasicParserException.NUMBER_TO_LONG); } // Reset ExectLineNumber ExpectLineNumber = false; /////////////////////////////////////////////////////////////////////////// // // Search for Special characters // /////////////////////////////////////////////////////////////////////////// // Check for Single character tokens switch (SourceCode[SourceCodePosition]) { // NewLine Character case '\n': // Increase Program Search Position SourceCodeNextPosition = SourceCodePosition + 1; // After new line expect line number ExpectLineNumber = true; // A Single Text Token on a Line is a LabelToken if (ProgramToTokenize.Count >= 2) { if (ProgramToTokenize[ProgramToTokenize.Count - 1].GetType().Equals(typeof(TextToken)) && ProgramToTokenize[ProgramToTokenize.Count - 2].GetType().Equals(typeof(EndOfLineToken))) { ProgramToTokenize[ProgramToTokenize.Count - 1] = new LabelToken(this, ((TextToken)ProgramToTokenize[ProgramToTokenize.Count - 1]).Content); } } else if (ProgramToTokenize.Count == 1) { if (ProgramToTokenize[ProgramToTokenize.Count - 1].GetType().Equals(typeof(TextToken))) { ProgramToTokenize[ProgramToTokenize.Count - 1] = new LabelToken(this, ((TextToken)ProgramToTokenize[ProgramToTokenize.Count - 1]).Content); } } // Return EndOfLine Token return(new EndOfLineToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // NewLine within CodeLine case ':': // Increase Program Search Position SourceCodeNextPosition = SourceCodePosition + 1; // After new line expect line number ExpectLineNumber = true; // A Single Text Token on a Line is a LabelToken if (ProgramToTokenize.Count >= 2) { if (ProgramToTokenize[ProgramToTokenize.Count - 1].GetType().Equals(typeof(TextToken)) && ProgramToTokenize[ProgramToTokenize.Count - 2].GetType().Equals(typeof(EndOfLineToken))) { ProgramToTokenize[ProgramToTokenize.Count - 1] = new LabelToken(this, ((TextToken)ProgramToTokenize[ProgramToTokenize.Count - 1]).Content); } } else if (ProgramToTokenize.Count == 1) { if (ProgramToTokenize[ProgramToTokenize.Count - 1].GetType().Equals(typeof(TextToken))) { ProgramToTokenize[ProgramToTokenize.Count - 1] = new LabelToken(this, ((TextToken)ProgramToTokenize[ProgramToTokenize.Count - 1]).Content); } } // Return EndOfLine Token return(new EndOfLineToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Comma case ',': SourceCodeNextPosition = SourceCodePosition + 1; return(new CommaToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Semicolon case ';': SourceCodeNextPosition = SourceCodePosition + 1; return(new SemicolonToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Plus case '+': SourceCodeNextPosition = SourceCodePosition + 1; return(new PlusToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Minus case '-': SourceCodeNextPosition = SourceCodePosition + 1; return(new MinusToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Logical And case '&': SourceCodeNextPosition = SourceCodePosition + 1; return(new AndToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Logical Or case '|': SourceCodeNextPosition = SourceCodePosition + 1; return(new OrToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Multiply case '*': SourceCodeNextPosition = SourceCodePosition + 1; return(new MultiplyToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Divide case '/': SourceCodeNextPosition = SourceCodePosition + 1; return(new DivideToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Modulus case '%': SourceCodeNextPosition = SourceCodePosition + 1; return(new ModulusToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Left Parenthis case '(': SourceCodeNextPosition = SourceCodePosition + 1; return(new LeftParenToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Right Parenthis case ')': SourceCodeNextPosition = SourceCodePosition + 1; return(new RightParenToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Less Than case '<': SourceCodeNextPosition = SourceCodePosition + 1; if (SourceCodeNextPosition < SourceCode.Length) { // <> becomes NotEqual if (SourceCode[SourceCodeNextPosition] == '>') { SourceCodeNextPosition = SourceCodeNextPosition + 1; return(new NotEqualToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } // <= becomes LessOrEqual if (SourceCode[SourceCodeNextPosition] == '=') { SourceCodeNextPosition = SourceCodeNextPosition + 1; return(new LessOrEqualToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } } // Return Less Than return(new LessThenToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // In combination with = becomes NotEqual Token case '!': SourceCodeNextPosition = SourceCodePosition + 1; if (SourceCodeNextPosition < SourceCode.Length) { // Check if next Token is EqualToken if (SourceCode[SourceCodeNextPosition] == '=') { SourceCodeNextPosition = SourceCodeNextPosition + 1; return(new NotEqualToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } } // If not != then ignore break; // Greater Than case '>': SourceCodeNextPosition = SourceCodePosition + 1; if (SourceCodeNextPosition < SourceCode.Length) { // >= becomes MoreOrEqual if (SourceCode[SourceCodeNextPosition] == '=') { SourceCodeNextPosition = SourceCodeNextPosition + 1; return(new MoreOrEqualToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } } // return GreaterThen return(new GreaterThenToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // Equals case '=': SourceCodeNextPosition = SourceCodePosition + 1; // If previous token is an Text token make it a variables // (Equal becomes assignment character) if (ProgramToTokenize[ProgramToTokenize.Count - 1].GetType().Equals(typeof(TextToken))) { String VariableName = ((TextToken)ProgramToTokenize[ProgramToTokenize.Count - 1]).Content; VariableNames.Add(VariableName); // If $ then it is an String variable else Numeric if (VariableName[VariableName.Length - 1] == '$') { ProgramToTokenize[ProgramToTokenize.Count - 1] = new StringVariableToken(this, VariableName); } else { ProgramToTokenize[ProgramToTokenize.Count - 1] = new NumericVariableToken(this, VariableName); } } // Return Equals return(new EqualToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); // REM case '\'': SourceCodeNextPosition = SourceCodePosition + 1; // Skip source until EndOfLine or EndOfProgram while (SourceCodeNextPosition < SourceCode.Length) { if (SourceCode[SourceCodeNextPosition] == '\n') { break; } SourceCodeNextPosition++; } return(new RemToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } /////////////////////////////////////////////////////////////////////////// // // Search for Quoted Strings // /////////////////////////////////////////////////////////////////////////// // Check for quote if (SourceCode[SourceCodePosition] == '\"') { SourceCodeNextPosition = SourceCodePosition; // Use extra string to check for backslashes String QuotedString = ""; bool IgnoreNextQuote = false; // Search for end of string do { // Check for backslash, Don't ignore a second backslash if ((!IgnoreNextQuote) && (SourceCode[SourceCodeNextPosition] == '\\')) { // Backslash found, ignore next quote as string end // Don't add to string IgnoreNextQuote = true; } else { // Add to string QuotedString += SourceCode[SourceCodeNextPosition]; // Reset quote search IgnoreNextQuote = false; } SourceCodeNextPosition++; } while ((IgnoreNextQuote) || (SourceCode[SourceCodeNextPosition] != '\"')); SourceCodeNextPosition++; // Return String return(new StringToken(this, QuotedString + "\"")); } /////////////////////////////////////////////////////////////////////////// // // Search for Keywords // /////////////////////////////////////////////////////////////////////////// // Check for keywords foreach (KeywordTokenConstructor kt in KeywordTokens) { // Check if keyword is not longer then remaining program code if (kt.Keyword.Length <= (SourceCode.Length - SourceCodePosition)) { // Check for token if (SourceCodeLower.Substring(SourceCodePosition, kt.Keyword.Length) == kt.Keyword) { // Check if it's the whole keyword that we've found if ((SourceCode.Length - SourceCodePosition - kt.Keyword.Length) != 0) { if (CHECK_END_OF_TOKEN.IndexOf(SourceCode[SourceCodePosition + kt.Keyword.Length]) == -1) { continue; } } // Return keyword if found SourceCodeNextPosition = SourceCodePosition + kt.Keyword.Length; if (kt.Keyword == "rem") { SourceCodeNextPosition = SourceCodePosition + 1; while (SourceCodeNextPosition < SourceCode.Length) { if (SourceCode[SourceCodeNextPosition] == '\n') { break; } SourceCodeNextPosition++; } } return(kt.TokenConstructor(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } } } /////////////////////////////////////////////////////////////////////////// // // Search for Known variables // /////////////////////////////////////////////////////////////////////////// // Check for variables foreach (String VarName in VariableNames) { // Check if variable name is not longer then remaining program code if (VarName.Length <= (SourceCode.Length - SourceCodePosition)) { // Check for token if (SourceCodeLower.Substring(SourceCodePosition, VarName.Length) == VarName.ToLower()) { // Check if it's the whole keyword that we've found if ((SourceCode.Length - SourceCodePosition - VarName.Length) != 0) { if (CHECK_END_OF_VARIABLE_NAME.IndexOf(SourceCode[SourceCodePosition + VarName.Length]) == -1) { continue; } } // Return keyword if found SourceCodeNextPosition = SourceCodePosition + VarName.Length; if (VarName[VarName.Length - 1] == '$') { return(new StringVariableToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } else { return(new NumericVariableToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } } } } /////////////////////////////////////////////////////////////////////////// // // Search for New variables // /////////////////////////////////////////////////////////////////////////// // Search for new Variable Names, If preceeded by LET or FOR then make it a new variable for (int i = 0; i < (MAX_VARIABLENAME_LENGTH + 1); ++i) { // Search for End of TextToken if ((CHECK_END_OF_VARIABLE_NAME.IndexOf(SourceCode[SourceCodePosition + i])) != -1) { if (i > 0) { SourceCodeNextPosition = SourceCodePosition + i; String TxtPart = SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition); if (ProgramToTokenize.Count > 0) { if (ProgramToTokenize[ProgramToTokenize.Count - 1].GetType().Equals(typeof(ForToken))) { String VariableName = SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition); VariableNames.Add(VariableName); if (VariableName[VariableName.Length - 1] == '$') { return(new StringVariableToken(this, VariableName)); } else { return(new NumericVariableToken(this, VariableName)); } } if (ProgramToTokenize[ProgramToTokenize.Count - 1].GetType().Equals(typeof(LetToken))) { String VariableName = SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition); VariableNames.Add(VariableName); if (VariableName[VariableName.Length - 1] == '$') { return(new StringVariableToken(this, VariableName)); } else { return(new NumericVariableToken(this, VariableName)); } } } // No FOR or LET make it a TextToken return(new TextToken(this, SourceCode.Substring(SourceCodePosition, SourceCodeNextPosition - SourceCodePosition))); } else { throw new BasicParserException(BasicParserException.VARIABLENAME_UNEXPECTED_END); } } } // Failed to find next token throw new BasicParserException(BasicParserException.UNKNOWN_ERROR); }
public override string ToString() { var nl = Environment.NewLine; return($"catch ({(Type != null ? Type.ToString() : "")} {(VarName != null ? VarName.ToString() : "")}) {{{nl} {Body}{nl}}}{nl}"); }
/// <summary> /// Method for generating a string representation of a returned variable. /// </summary> /// <param name="returnedVar">The variable that is returned in this statement.</param> /// <returns>A string representation of the return statement.</returns> public static string ReturnVar(VarName returnedVar) { return("return " + GetString(returnedVar) + ";\n"); }
public StepBuilder Done() { VarName.NotNull("name").NotEmptyString("name"); _parent.AddReplaceVarMap(this); return(_parent); }
public override int GetHashCode() { return(VarName.GetHashCode() ^ VarValue.GetHashCode()); }
public override string ToString() { return($"catch ({Type.ToStringWithTrailSpace()}{(VarName.ToStringNullable())})\n{{{Body}}}"); }