diff options
Diffstat (limited to 'Ryujinx.HLE/HOS/Diagnostics/Demangler/Demangler.cs')
| -rw-r--r-- | Ryujinx.HLE/HOS/Diagnostics/Demangler/Demangler.cs | 1804 |
1 files changed, 902 insertions, 902 deletions
diff --git a/Ryujinx.HLE/HOS/Diagnostics/Demangler/Demangler.cs b/Ryujinx.HLE/HOS/Diagnostics/Demangler/Demangler.cs index 164d5618..b654ba79 100644 --- a/Ryujinx.HLE/HOS/Diagnostics/Demangler/Demangler.cs +++ b/Ryujinx.HLE/HOS/Diagnostics/Demangler/Demangler.cs @@ -8,35 +8,35 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler { class Demangler { - private static readonly string BASE_36 = "0123456789abcdefghijklmnopqrstuvwxyz"; - private List<BaseNode> SubstitutionList = new List<BaseNode>(); - private List<BaseNode> TemplateParamList = new List<BaseNode>(); + private static readonly string Base36 = "0123456789abcdefghijklmnopqrstuvwxyz"; + private List<BaseNode> _substitutionList = new List<BaseNode>(); + private List<BaseNode> _templateParamList = new List<BaseNode>(); - private List<ForwardTemplateReference> ForwardTemplateReferenceList = new List<ForwardTemplateReference>(); + private List<ForwardTemplateReference> _forwardTemplateReferenceList = new List<ForwardTemplateReference>(); public string Mangled { get; private set; } - private int Position; - private int Length; + private int _position; + private int _length; - private bool CanForwardTemplateReference; - private bool CanParseTemplateArgs; + private bool _canForwardTemplateReference; + private bool _canParseTemplateArgs; - public Demangler(string Mangled) + public Demangler(string mangled) { - this.Mangled = Mangled; - Position = 0; - Length = Mangled.Length; - CanParseTemplateArgs = true; + Mangled = mangled; + _position = 0; + _length = mangled.Length; + _canParseTemplateArgs = true; } - private bool ConsumeIf(string ToConsume) + private bool ConsumeIf(string toConsume) { - string MangledPart = Mangled.Substring(Position); + string mangledPart = Mangled.Substring(_position); - if (MangledPart.StartsWith(ToConsume)) + if (mangledPart.StartsWith(toConsume)) { - Position += ToConsume.Length; + _position += toConsume.Length; return true; } @@ -44,31 +44,31 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return false; } - private string PeekString(int Offset = 0, int Length = 1) + private string PeekString(int offset = 0, int length = 1) { - if (Position + Offset >= Length) + if (_position + offset >= length) { return null; } - return Mangled.Substring(Position + Offset, Length); + return Mangled.Substring(_position + offset, length); } - private char Peek(int Offset = 0) + private char Peek(int offset = 0) { - if (Position + Offset >= Length) + if (_position + offset >= _length) { return '\0'; } - return Mangled[Position + Offset]; + return Mangled[_position + offset]; } private char Consume() { - if (Position < Length) + if (_position < _length) { - return Mangled[Position++]; + return Mangled[_position++]; } return '\0'; @@ -76,45 +76,45 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler private int Count() { - return Length - Position; + return _length - _position; } - private static int FromBase36(string Encoded) + private static int FromBase36(string encoded) { - char[] ReversedEncoded = Encoded.ToLower().ToCharArray().Reverse().ToArray(); + char[] reversedEncoded = encoded.ToLower().ToCharArray().Reverse().ToArray(); - int Result = 0; + int result = 0; - for (int i = 0; i < ReversedEncoded.Length; i++) + for (int i = 0; i < reversedEncoded.Length; i++) { - int Value = BASE_36.IndexOf(ReversedEncoded[i]); - if (Value == -1) + int value = Base36.IndexOf(reversedEncoded[i]); + if (value == -1) { return -1; } - Result += Value * (int)Math.Pow(36, i); + result += value * (int)Math.Pow(36, i); } - return Result; + return result; } private int ParseSeqId() { - string Part = Mangled.Substring(Position); - int SeqIdLen = 0; + string part = Mangled.Substring(_position); + int seqIdLen = 0; - for (; SeqIdLen < Part.Length; SeqIdLen++) + for (; seqIdLen < part.Length; seqIdLen++) { - if (!char.IsLetterOrDigit(Part[SeqIdLen])) + if (!char.IsLetterOrDigit(part[seqIdLen])) { break; } } - Position += SeqIdLen; + _position += seqIdLen; - return FromBase36(Part.Substring(0, SeqIdLen)); + return FromBase36(part.Substring(0, seqIdLen)); } // <substitution> ::= S <seq-id> _ @@ -133,28 +133,28 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - char SubstitutionSecondChar = Peek(); - if (char.IsLower(SubstitutionSecondChar)) + char substitutionSecondChar = Peek(); + if (char.IsLower(substitutionSecondChar)) { - switch (SubstitutionSecondChar) + switch (substitutionSecondChar) { case 'a': - Position++; + _position++; return new SpecialSubstitution(SpecialSubstitution.SpecialType.Allocator); case 'b': - Position++; + _position++; return new SpecialSubstitution(SpecialSubstitution.SpecialType.BasicString); case 's': - Position++; + _position++; return new SpecialSubstitution(SpecialSubstitution.SpecialType.String); case 'i': - Position++; + _position++; return new SpecialSubstitution(SpecialSubstitution.SpecialType.IStream); case 'o': - Position++; + _position++; return new SpecialSubstitution(SpecialSubstitution.SpecialType.OStream); case 'd': - Position++; + _position++; return new SpecialSubstitution(SpecialSubstitution.SpecialType.IOStream); default: return null; @@ -164,29 +164,29 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= S_ if (ConsumeIf("_")) { - if (SubstitutionList.Count != 0) + if (_substitutionList.Count != 0) { - return SubstitutionList[0]; + return _substitutionList[0]; } return null; } // ::= S <seq-id> _ - int SeqId = ParseSeqId(); - if (SeqId < 0) + int seqId = ParseSeqId(); + if (seqId < 0) { return null; } - SeqId++; + seqId++; - if (!ConsumeIf("_") || SeqId >= SubstitutionList.Count) + if (!ConsumeIf("_") || seqId >= _substitutionList.Count) { return null; } - return SubstitutionList[SeqId]; + return _substitutionList[seqId]; } // NOTE: thoses data aren't used in the output @@ -217,33 +217,33 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= Te <name> # dependent elaborated type specifier using 'enum' private BaseNode ParseClassEnumType() { - string ElaboratedType = null; + string elaboratedType = null; if (ConsumeIf("Ts")) { - ElaboratedType = "struct"; + elaboratedType = "struct"; } else if (ConsumeIf("Tu")) { - ElaboratedType = "union"; + elaboratedType = "union"; } else if (ConsumeIf("Te")) { - ElaboratedType = "enum"; + elaboratedType = "enum"; } - BaseNode Name = ParseName(); - if (Name == null) + BaseNode name = ParseName(); + if (name == null) { return null; } - if (ElaboratedType == null) + if (elaboratedType == null) { - return Name; + return name; } - return new ElaboratedType(ElaboratedType, Name); + return new ElaboratedType(elaboratedType, name); } // <function-type> ::= [<CV-qualifiers>] [<exception-spec>] [Dx] F [Y] <bare-function-type> [<ref-qualifier>] E @@ -254,40 +254,40 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= Dw <type>+ E # dynamic exception specification with instantiation-dependent types private BaseNode ParseFunctionType() { - CV CVQualifiers = ParseCVQualifiers(); + Cv cvQualifiers = ParseCvQualifiers(); - BaseNode ExceptionSpec = null; + BaseNode exceptionSpec = null; if (ConsumeIf("Do")) { - ExceptionSpec = new NameType("noexcept"); + exceptionSpec = new NameType("noexcept"); } else if (ConsumeIf("DO")) { - BaseNode Expression = ParseExpression(); - if (Expression == null || !ConsumeIf("E")) + BaseNode expression = ParseExpression(); + if (expression == null || !ConsumeIf("E")) { return null; } - ExceptionSpec = new NoexceptSpec(Expression); + exceptionSpec = new NoexceptSpec(expression); } else if (ConsumeIf("Dw")) { - List<BaseNode> Types = new List<BaseNode>(); + List<BaseNode> types = new List<BaseNode>(); while (!ConsumeIf("E")) { - BaseNode Type = ParseType(); - if (Type == null) + BaseNode type = ParseType(); + if (type == null) { return null; } - Types.Add(Type); + types.Add(type); } - ExceptionSpec = new DynamicExceptionSpec(new NodeArray(Types)); + exceptionSpec = new DynamicExceptionSpec(new NodeArray(types)); } // We don't need the transaction @@ -301,13 +301,13 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // extern "C" ConsumeIf("Y"); - BaseNode ReturnType = ParseType(); - if (ReturnType == null) + BaseNode returnType = ParseType(); + if (returnType == null) { return null; } - Reference ReferenceQualifier = Reference.None; + Reference referenceQualifier = Reference.None; List<BaseNode> Params = new List<BaseNode>(); while (true) @@ -324,25 +324,25 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler if (ConsumeIf("RE")) { - ReferenceQualifier = Reference.LValue; + referenceQualifier = Reference.LValue; break; } else if (ConsumeIf("OE")) { - ReferenceQualifier = Reference.RValue; + referenceQualifier = Reference.RValue; break; } - BaseNode Type = ParseType(); - if (Type == null) + BaseNode type = ParseType(); + if (type == null) { return null; } - Params.Add(Type); + Params.Add(type); } - return new FunctionType(ReturnType, new NodeArray(Params), new CVType(CVQualifiers, null), new SimpleReferenceType(ReferenceQualifier, null), ExceptionSpec); + return new FunctionType(returnType, new NodeArray(Params), new CvType(cvQualifiers, null), new SimpleReferenceType(referenceQualifier, null), exceptionSpec); } // <array-type> ::= A <positive dimension number> _ <element type> @@ -354,48 +354,48 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - BaseNode ElementType; + BaseNode elementType; if (char.IsDigit(Peek())) { - string Dimension = ParseNumber(); - if (Dimension.Length == 0 || !ConsumeIf("_")) + string dimension = ParseNumber(); + if (dimension.Length == 0 || !ConsumeIf("_")) { return null; } - ElementType = ParseType(); - if (ElementType == null) + elementType = ParseType(); + if (elementType == null) { return null; } - return new ArrayType(ElementType, Dimension); + return new ArrayType(elementType, dimension); } if (!ConsumeIf("_")) { - BaseNode DimensionExpression = ParseExpression(); - if (DimensionExpression == null || !ConsumeIf("_")) + BaseNode dimensionExpression = ParseExpression(); + if (dimensionExpression == null || !ConsumeIf("_")) { return null; } - ElementType = ParseType(); - if (ElementType == null) + elementType = ParseType(); + if (elementType == null) { return null; } - return new ArrayType(ElementType, DimensionExpression); + return new ArrayType(elementType, dimensionExpression); } - ElementType = ParseType(); - if (ElementType == null) + elementType = ParseType(); + if (elementType == null) { return null; } - return new ArrayType(ElementType); + return new ArrayType(elementType); } // <type> ::= <builtin-type> @@ -413,295 +413,295 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= C <type> # complex pair (C99) // ::= G <type> # imaginary (C99) // ::= <substitution> # See Compression below - private BaseNode ParseType(NameParserContext Context = null) + private BaseNode ParseType(NameParserContext context = null) { // Temporary context - if (Context == null) + if (context == null) { - Context = new NameParserContext(); + context = new NameParserContext(); } - BaseNode Result = null; + BaseNode result = null; switch (Peek()) { case 'r': case 'V': case 'K': - int TypePos = 0; + int typePos = 0; - if (Peek(TypePos) == 'r') + if (Peek(typePos) == 'r') { - TypePos++; + typePos++; } - if (Peek(TypePos) == 'V') + if (Peek(typePos) == 'V') { - TypePos++; + typePos++; } - if (Peek(TypePos) == 'K') + if (Peek(typePos) == 'K') { - TypePos++; + typePos++; } - if (Peek(TypePos) == 'F' || (Peek(TypePos) == 'D' && (Peek(TypePos + 1) == 'o' || Peek(TypePos + 1) == 'O' || Peek(TypePos + 1) == 'w' || Peek(TypePos + 1) == 'x'))) + if (Peek(typePos) == 'F' || (Peek(typePos) == 'D' && (Peek(typePos + 1) == 'o' || Peek(typePos + 1) == 'O' || Peek(typePos + 1) == 'w' || Peek(typePos + 1) == 'x'))) { - Result = ParseFunctionType(); + result = ParseFunctionType(); break; } - CV CV = ParseCVQualifiers(); + Cv cv = ParseCvQualifiers(); - Result = ParseType(Context); + result = ParseType(context); - if (Result == null) + if (result == null) { return null; } - Result = new CVType(CV, Result); + result = new CvType(cv, result); break; case 'U': // TODO: <extended-qualifier> return null; case 'v': - Position++; + _position++; return new NameType("void"); case 'w': - Position++; + _position++; return new NameType("wchar_t"); case 'b': - Position++; + _position++; return new NameType("bool"); case 'c': - Position++; + _position++; return new NameType("char"); case 'a': - Position++; + _position++; return new NameType("signed char"); case 'h': - Position++; + _position++; return new NameType("unsigned char"); case 's': - Position++; + _position++; return new NameType("short"); case 't': - Position++; + _position++; return new NameType("unsigned short"); case 'i': - Position++; + _position++; return new NameType("int"); case 'j': - Position++; + _position++; return new NameType("unsigned int"); case 'l': - Position++; + _position++; return new NameType("long"); case 'm': - Position++; + _position++; return new NameType("unsigned long"); case 'x': - Position++; + _position++; return new NameType("long long"); case 'y': - Position++; + _position++; return new NameType("unsigned long long"); case 'n': - Position++; + _position++; return new NameType("__int128"); case 'o': - Position++; + _position++; return new NameType("unsigned __int128"); case 'f': - Position++; + _position++; return new NameType("float"); case 'd': - Position++; + _position++; return new NameType("double"); case 'e': - Position++; + _position++; return new NameType("long double"); case 'g': - Position++; + _position++; return new NameType("__float128"); case 'z': - Position++; + _position++; return new NameType("..."); case 'u': - Position++; + _position++; return ParseSourceName(); case 'D': switch (Peek(1)) { case 'd': - Position += 2; + _position += 2; return new NameType("decimal64"); case 'e': - Position += 2; + _position += 2; return new NameType("decimal128"); case 'f': - Position += 2; + _position += 2; return new NameType("decimal32"); case 'h': - Position += 2; + _position += 2; // FIXME: GNU c++flit returns this but that is not what is supposed to be returned. return new NameType("half"); //return new NameType("decimal16"); case 'i': - Position += 2; + _position += 2; return new NameType("char32_t"); case 's': - Position += 2; + _position += 2; return new NameType("char16_t"); case 'a': - Position += 2; + _position += 2; return new NameType("decltype(auto)"); case 'n': - Position += 2; + _position += 2; // FIXME: GNU c++flit returns this but that is not what is supposed to be returned. return new NameType("decltype(nullptr)"); //return new NameType("std::nullptr_t"); case 't': case 'T': - Position += 2; - Result = ParseDecltype(); + _position += 2; + result = ParseDecltype(); break; case 'o': case 'O': case 'w': case 'x': - Result = ParseFunctionType(); + result = ParseFunctionType(); break; default: return null; } break; case 'F': - Result = ParseFunctionType(); + result = ParseFunctionType(); break; case 'A': return ParseArrayType(); case 'M': // TODO: <pointer-to-member-type> - Position++; + _position++; return null; case 'T': // might just be a class enum type if (Peek(1) == 's' || Peek(1) == 'u' || Peek(1) == 'e') { - Result = ParseClassEnumType(); + result = ParseClassEnumType(); break; } - Result = ParseTemplateParam(); - if (Result == null) + result = ParseTemplateParam(); + if (result == null) { return null; } - if (CanParseTemplateArgs && Peek() == 'I') + if (_canParseTemplateArgs && Peek() == 'I') { - BaseNode TemplateArguments = ParseTemplateArguments(); - if (TemplateArguments == null) + BaseNode templateArguments = ParseTemplateArguments(); + if (templateArguments == null) { return null; } - Result = new NameTypeWithTemplateArguments(Result, TemplateArguments); + result = new NameTypeWithTemplateArguments(result, templateArguments); } break; case 'P': - Position++; - Result = ParseType(Context); + _position++; + result = ParseType(context); - if (Result == null) + if (result == null) { return null; } - Result = new PointerType(Result); + result = new PointerType(result); break; case 'R': - Position++; - Result = ParseType(Context); + _position++; + result = ParseType(context); - if (Result == null) + if (result == null) { return null; } - Result = new ReferenceType("&", Result); + result = new ReferenceType("&", result); break; case 'O': - Position++; - Result = ParseType(Context); + _position++; + result = ParseType(context); - if (Result == null) + if (result == null) { return null; } - Result = new ReferenceType("&&", Result); + result = new ReferenceType("&&", result); break; case 'C': - Position++; - Result = ParseType(Context); + _position++; + result = ParseType(context); - if (Result == null) + if (result == null) { return null; } - Result = new PostfixQualifiedType(" complex", Result); + result = new PostfixQualifiedType(" complex", result); break; case 'G': - Position++; - Result = ParseType(Context); + _position++; + result = ParseType(context); - if (Result == null) + if (result == null) { return null; } - Result = new PostfixQualifiedType(" imaginary", Result); + result = new PostfixQualifiedType(" imaginary", result); break; case 'S': if (Peek(1) != 't') { - BaseNode Substitution = ParseSubstitution(); - if (Substitution == null) + BaseNode substitution = ParseSubstitution(); + if (substitution == null) { return null; } - if (CanParseTemplateArgs && Peek() == 'I') + if (_canParseTemplateArgs && Peek() == 'I') { - BaseNode TemplateArgument = ParseTemplateArgument(); - if (TemplateArgument == null) + BaseNode templateArgument = ParseTemplateArgument(); + if (templateArgument == null) { return null; } - Result = new NameTypeWithTemplateArguments(Substitution, TemplateArgument); + result = new NameTypeWithTemplateArguments(substitution, templateArgument); break; } - return Substitution; + return substitution; } else { - Result = ParseClassEnumType(); + result = ParseClassEnumType(); break; } default: - Result = ParseClassEnumType(); + result = ParseClassEnumType(); break; } - if (Result != null) + if (result != null) { - SubstitutionList.Add(Result); + _substitutionList.Add(result); } - return Result; + return result; } // <special-name> ::= TV <type> # virtual table @@ -714,155 +714,155 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= T <call-offset> <base encoding> // # base is the nominal target function of thunk // ::= GV <object name> # Guard variable for one-time initialization - private BaseNode ParseSpecialName(NameParserContext Context = null) + private BaseNode ParseSpecialName(NameParserContext context = null) { if (Peek() != 'T') { if (ConsumeIf("GV")) { - BaseNode Name = ParseName(); - if (Name == null) + BaseNode name = ParseName(); + if (name == null) { return null; } - return new SpecialName("guard variable for ", Name); + return new SpecialName("guard variable for ", name); } return null; } - BaseNode Node; + BaseNode node; switch (Peek(1)) { // ::= TV <type> # virtual table case 'V': - Position += 2; - Node = ParseType(Context); - if (Node == null) + _position += 2; + node = ParseType(context); + if (node == null) { return null; } - return new SpecialName("vtable for ", Node); + return new SpecialName("vtable for ", node); // ::= TT <type> # VTT structure (construction vtable index) case 'T': - Position += 2; - Node = ParseType(Context); - if (Node == null) + _position += 2; + node = ParseType(context); + if (node == null) { return null; } - return new SpecialName("VTT for ", Node); + return new SpecialName("VTT for ", node); // ::= TI <type> # typeinfo structure case 'I': - Position += 2; - Node = ParseType(Context); - if (Node == null) + _position += 2; + node = ParseType(context); + if (node == null) { return null; } - return new SpecialName("typeinfo for ", Node); + return new SpecialName("typeinfo for ", node); // ::= TS <type> # typeinfo name (null-terminated byte string) case 'S': - Position += 2; - Node = ParseType(Context); - if (Node == null) + _position += 2; + node = ParseType(context); + if (node == null) { return null; } - return new SpecialName("typeinfo name for ", Node); + return new SpecialName("typeinfo name for ", node); // ::= Tc <call-offset> <call-offset> <base encoding> case 'c': - Position += 2; + _position += 2; if (ParseCallOffset() || ParseCallOffset()) { return null; } - Node = ParseEncoding(); - if (Node == null) + node = ParseEncoding(); + if (node == null) { return null; } - return new SpecialName("covariant return thunk to ", Node); + return new SpecialName("covariant return thunk to ", node); // extension ::= TC <first type> <number> _ <second type> case 'C': - Position += 2; - BaseNode FirstType = ParseType(); - if (FirstType == null || ParseNumber(true).Length == 0 || !ConsumeIf("_")) + _position += 2; + BaseNode firstType = ParseType(); + if (firstType == null || ParseNumber(true).Length == 0 || !ConsumeIf("_")) { return null; } - BaseNode SecondType = ParseType(); + BaseNode secondType = ParseType(); - return new CtorVtableSpecialName(SecondType, FirstType); + return new CtorVtableSpecialName(secondType, firstType); // ::= TH <object name> # Thread-local initialization case 'H': - Position += 2; - Node = ParseName(); - if (Node == null) + _position += 2; + node = ParseName(); + if (node == null) { return null; } - return new SpecialName("thread-local initialization routine for ", Node); + return new SpecialName("thread-local initialization routine for ", node); // ::= TW <object name> # Thread-local wrapper case 'W': - Position += 2; - Node = ParseName(); - if (Node == null) + _position += 2; + node = ParseName(); + if (node == null) { return null; } - return new SpecialName("thread-local wrapper routine for ", Node); + return new SpecialName("thread-local wrapper routine for ", node); default: - Position++; - bool IsVirtual = Peek() == 'v'; + _position++; + bool isVirtual = Peek() == 'v'; if (ParseCallOffset()) { return null; } - Node = ParseEncoding(); - if (Node == null) + node = ParseEncoding(); + if (node == null) { return null; } - if (IsVirtual) + if (isVirtual) { - return new SpecialName("virtual thunk to ", Node); + return new SpecialName("virtual thunk to ", node); } - return new SpecialName("non-virtual thunk to ", Node); + return new SpecialName("non-virtual thunk to ", node); } } // <CV-qualifiers> ::= [r] [V] [K] # restrict (C99), volatile, const - private CV ParseCVQualifiers() + private Cv ParseCvQualifiers() { - CV Qualifiers = CV.None; + Cv qualifiers = Cv.None; if (ConsumeIf("r")) { - Qualifiers |= CV.Restricted; + qualifiers |= Cv.Restricted; } if (ConsumeIf("V")) { - Qualifiers |= CV.Volatile; + qualifiers |= Cv.Volatile; } if (ConsumeIf("K")) { - Qualifiers |= CV.Const; + qualifiers |= Cv.Const; } - return Qualifiers; + return qualifiers; } @@ -870,102 +870,102 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // <ref-qualifier> ::= O # && ref-qualifier private SimpleReferenceType ParseRefQualifiers() { - Reference Result = Reference.None; + Reference result = Reference.None; if (ConsumeIf("O")) { - Result = Reference.RValue; + result = Reference.RValue; } else if (ConsumeIf("R")) { - Result = Reference.LValue; + result = Reference.LValue; } - return new SimpleReferenceType(Result, null); + return new SimpleReferenceType(result, null); } - private BaseNode CreateNameNode(BaseNode Prev, BaseNode Name, NameParserContext Context) + private BaseNode CreateNameNode(BaseNode prev, BaseNode name, NameParserContext context) { - BaseNode Result = Name; - if (Prev != null) + BaseNode result = name; + if (prev != null) { - Result = new NestedName(Name, Prev); + result = new NestedName(name, prev); } - if (Context != null) + if (context != null) { - Context.FinishWithTemplateArguments = false; + context.FinishWithTemplateArguments = false; } - return Result; + return result; } private int ParsePositiveNumber() { - string Part = Mangled.Substring(Position); - int NumberLength = 0; + string part = Mangled.Substring(_position); + int numberLength = 0; - for (; NumberLength < Part.Length; NumberLength++) + for (; numberLength < part.Length; numberLength++) { - if (!char.IsDigit(Part[NumberLength])) + if (!char.IsDigit(part[numberLength])) { break; } } - Position += NumberLength; + _position += numberLength; - if (NumberLength == 0) + if (numberLength == 0) { return -1; } - return int.Parse(Part.Substring(0, NumberLength)); + return int.Parse(part.Substring(0, numberLength)); } - private string ParseNumber(bool IsSigned = false) + private string ParseNumber(bool isSigned = false) { - if (IsSigned) + if (isSigned) { ConsumeIf("n"); } - if (Count() == 0 || !char.IsDigit(Mangled[Position])) + if (Count() == 0 || !char.IsDigit(Mangled[_position])) { return null; } - string Part = Mangled.Substring(Position); - int NumberLength = 0; + string part = Mangled.Substring(_position); + int numberLength = 0; - for (; NumberLength < Part.Length; NumberLength++) + for (; numberLength < part.Length; numberLength++) { - if (!char.IsDigit(Part[NumberLength])) + if (!char.IsDigit(part[numberLength])) { break; } } - Position += NumberLength; + _position += numberLength; - return Part.Substring(0, NumberLength); + return part.Substring(0, numberLength); } // <source-name> ::= <positive length number> <identifier> private BaseNode ParseSourceName() { - int Length = ParsePositiveNumber(); - if (Count() < Length || Length <= 0) + int length = ParsePositiveNumber(); + if (Count() < length || length <= 0) { return null; } - string Name = Mangled.Substring(Position, Length); - Position += Length; - if (Name.StartsWith("_GLOBAL__N")) + string name = Mangled.Substring(_position, length); + _position += length; + if (name.StartsWith("_GLOBAL__N")) { return new NameType("(anonymous namespace)"); } - return new NameType(Name); + return new NameType(name); } // <operator-name> ::= nw # new @@ -1019,7 +1019,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= cv <type> # (cast) (TODO) // ::= li <source-name> # operator "" // ::= v <digit> <source-name> # vendor extended operator (TODO) - private BaseNode ParseOperatorName(NameParserContext Context) + private BaseNode ParseOperatorName(NameParserContext context) { switch (Peek()) { @@ -1027,17 +1027,17 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'a': - Position += 2; + _position += 2; return new NameType("operator&&"); case 'd': case 'n': - Position += 2; + _position += 2; return new NameType("operator&"); case 'N': - Position += 2; + _position += 2; return new NameType("operator&="); case 'S': - Position += 2; + _position += 2; return new NameType("operator="); default: return null; @@ -1046,39 +1046,39 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'l': - Position += 2; + _position += 2; return new NameType("operator()"); case 'm': - Position += 2; + _position += 2; return new NameType("operator,"); case 'o': - Position += 2; + _position += 2; return new NameType("operator~"); case 'v': - Position += 2; + _position += 2; - bool CanParseTemplateArgsBackup = CanParseTemplateArgs; - bool CanForwardTemplateReferenceBackup = CanForwardTemplateReference; + bool canParseTemplateArgsBackup = _canParseTemplateArgs; + bool canForwardTemplateReferenceBackup = _canForwardTemplateReference; - CanParseTemplateArgs = false; - CanForwardTemplateReference = CanForwardTemplateReferenceBackup || Context != null; + _canParseTemplateArgs = false; + _canForwardTemplateReference = canForwardTemplateReferenceBackup || context != null; - BaseNode Type = ParseType(); + BaseNode type = ParseType(); - CanParseTemplateArgs = CanParseTemplateArgsBackup; - CanForwardTemplateReference = CanForwardTemplateReferenceBackup; + _canParseTemplateArgs = canParseTemplateArgsBackup; + _canForwardTemplateReference = canForwardTemplateReferenceBackup; - if (Type == null) + if (type == null) { return null; } - if (Context != null) + if (context != null) { - Context.CtorDtorConversion = true; + context.CtorDtorConversion = true; } - return new ConversionOperatorType(Type); + return new ConversionOperatorType(type); default: return null; } @@ -1086,19 +1086,19 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'a': - Position += 2; + _position += 2; return new NameType("operator delete[]"); case 'e': - Position += 2; + _position += 2; return new NameType("operator*"); case 'l': - Position += 2; + _position += 2; return new NameType("operator delete"); case 'v': - Position += 2; + _position += 2; return new NameType("operator/"); case 'V': - Position += 2; + _position += 2; return new NameType("operator/="); default: return null; @@ -1107,13 +1107,13 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'o': - Position += 2; + _position += 2; return new NameType("operator^"); case 'O': - Position += 2; + _position += 2; return new NameType("operator^="); case 'q': - Position += 2; + _position += 2; return new NameType("operator=="); default: return null; @@ -1122,10 +1122,10 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'e': - Position += 2; + _position += 2; return new NameType("operator>="); case 't': - Position += 2; + _position += 2; return new NameType("operator>"); default: return null; @@ -1133,7 +1133,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler case 'i': if (Peek(1) == 'x') { - Position += 2; + _position += 2; return new NameType("operator[]"); } return null; @@ -1141,25 +1141,25 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'e': - Position += 2; + _position += 2; return new NameType("operator<="); case 'i': - Position += 2; - BaseNode SourceName = ParseSourceName(); - if (SourceName == null) + _position += 2; + BaseNode sourceName = ParseSourceName(); + if (sourceName == null) { return null; } - return new LiteralOperator(SourceName); + return new LiteralOperator(sourceName); case 's': - Position += 2; + _position += 2; return new NameType("operator<<"); case 'S': - Position += 2; + _position += 2; return new NameType("operator<<="); case 't': - Position += 2; + _position += 2; return new NameType("operator<"); default: return null; @@ -1168,19 +1168,19 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'i': - Position += 2; + _position += 2; return new NameType("operator-"); case 'I': - Position += 2; + _position += 2; return new NameType("operator-="); case 'l': - Position += 2; + _position += 2; return new NameType("operator*"); case 'L': - Position += 2; + _position += 2; return new NameType("operator*="); case 'm': - Position += 2; + _position += 2; return new NameType("operator--"); default: return null; @@ -1189,19 +1189,19 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'a': - Position += 2; + _position += 2; return new NameType("operator new[]"); case 'e': - Position += 2; + _position += 2; return new NameType("operator!="); case 'g': - Position += 2; + _position += 2; return new NameType("operator-"); case 't': - Position += 2; + _position += 2; return new NameType("operator!"); case 'w': - Position += 2; + _position += 2; return new NameType("operator new"); default: return null; @@ -1210,13 +1210,13 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'o': - Position += 2; + _position += 2; return new NameType("operator||"); case 'r': - Position += 2; + _position += 2; return new NameType("operator|"); case 'R': - Position += 2; + _position += 2; return new NameType("operator|="); default: return null; @@ -1225,20 +1225,20 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'm': - Position += 2; + _position += 2; return new NameType("operator->*"); case 's': case 'l': - Position += 2; + _position += 2; return new NameType("operator+"); case 'L': - Position += 2; + _position += 2; return new NameType("operator+="); case 'p': - Position += 2; + _position += 2; return new NameType("operator++"); case 't': - Position += 2; + _position += 2; return new NameType("operator->"); default: return null; @@ -1246,7 +1246,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler case 'q': if (Peek(1) == 'u') { - Position += 2; + _position += 2; return new NameType("operator?"); } return null; @@ -1254,16 +1254,16 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'm': - Position += 2; + _position += 2; return new NameType("operator%"); case 'M': - Position += 2; + _position += 2; return new NameType("operator%="); case 's': - Position += 2; + _position += 2; return new NameType("operator>>"); case 'S': - Position += 2; + _position += 2; return new NameType("operator>>="); default: return null; @@ -1271,7 +1271,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler case 's': if (Peek(1) == 's') { - Position += 2; + _position += 2; return new NameType("operator<=>"); } return null; @@ -1288,18 +1288,18 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= <source-name> // ::= <unnamed-type-name> (TODO) // ::= DC <source-name>+ E # structured binding declaration (TODO) - private BaseNode ParseUnqualifiedName(NameParserContext Context) + private BaseNode ParseUnqualifiedName(NameParserContext context) { - BaseNode Result = null; - char C = Peek(); - if (C == 'U') + BaseNode result = null; + char c = Peek(); + if (c == 'U') { // TODO: Unnamed Type Name // throw new Exception("Unnamed Type Name not implemented"); } - else if (char.IsDigit(C)) + else if (char.IsDigit(c)) { - Result = ParseSourceName(); + result = ParseSourceName(); } else if (ConsumeIf("DC")) { @@ -1308,15 +1308,15 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler } else { - Result = ParseOperatorName(Context); + result = ParseOperatorName(context); } - if (Result != null) + if (result != null) { // TODO: ABI Tags //throw new Exception("ABI Tags not implemented"); } - return Result; + return result; } // <ctor-dtor-name> ::= C1 # complete object constructor @@ -1325,54 +1325,54 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= D0 # deleting destructor // ::= D1 # complete object destructor // ::= D2 # base object destructor - private BaseNode ParseCtorDtorName(NameParserContext Context, BaseNode Prev) + private BaseNode ParseCtorDtorName(NameParserContext context, BaseNode prev) { - if (Prev.Type == NodeType.SpecialSubstitution && Prev is SpecialSubstitution) + if (prev.Type == NodeType.SpecialSubstitution && prev is SpecialSubstitution) { - ((SpecialSubstitution)Prev).SetExtended(); + ((SpecialSubstitution)prev).SetExtended(); } if (ConsumeIf("C")) { - bool IsInherited = ConsumeIf("I"); + bool isInherited = ConsumeIf("I"); - char CtorDtorType = Peek(); - if (CtorDtorType != '1' && CtorDtorType != '2' && CtorDtorType != '3') + char ctorDtorType = Peek(); + if (ctorDtorType != '1' && ctorDtorType != '2' && ctorDtorType != '3') { return null; } - Position++; + _position++; - if (Context != null) + if (context != null) { - Context.CtorDtorConversion = true; + context.CtorDtorConversion = true; } - if (IsInherited && ParseName(Context) == null) + if (isInherited && ParseName(context) == null) { return null; } - return new CtorDtorNameType(Prev, false); + return new CtorDtorNameType(prev, false); } if (ConsumeIf("D")) { - char C = Peek(); - if (C != '0' && C != '1' && C != '2') + char c = Peek(); + if (c != '0' && c != '1' && c != '2') { return null; } - Position++; + _position++; - if (Context != null) + if (context != null) { - Context.CtorDtorConversion = true; + context.CtorDtorConversion = true; } - return new CtorDtorNameType(Prev, true); + return new CtorDtorNameType(prev, true); } return null; @@ -1387,7 +1387,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler if (ConsumeIf("fp")) { // ignored - ParseCVQualifiers(); + ParseCvQualifiers(); if (!ConsumeIf("_")) { @@ -1398,8 +1398,8 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler } else if (ConsumeIf("fL")) { - string L1Number = ParseNumber(); - if (L1Number == null || L1Number.Length == 0) + string l1Number = ParseNumber(); + if (l1Number == null || l1Number.Length == 0) { return null; } @@ -1410,7 +1410,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler } // ignored - ParseCVQualifiers(); + ParseCvQualifiers(); if (!ConsumeIf("_")) { @@ -1434,145 +1434,145 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - char FoldKind = Peek(); - bool HasInitializer = FoldKind == 'L' || FoldKind == 'R'; - bool IsLeftFold = FoldKind == 'l' || FoldKind == 'L'; + char foldKind = Peek(); + bool hasInitializer = foldKind == 'L' || foldKind == 'R'; + bool isLeftFold = foldKind == 'l' || foldKind == 'L'; - if (!IsLeftFold && !(FoldKind == 'r' || FoldKind == 'R')) + if (!isLeftFold && !(foldKind == 'r' || foldKind == 'R')) { return null; } - Position++; + _position++; - string OperatorName = null; + string operatorName = null; switch (PeekString(0, 2)) { case "aa": - OperatorName = "&&"; + operatorName = "&&"; break; case "an": - OperatorName = "&"; + operatorName = "&"; break; case "aN": - OperatorName = "&="; + operatorName = "&="; break; case "aS": - OperatorName = "="; + operatorName = "="; break; case "cm": - OperatorName = ","; + operatorName = ","; break; case "ds": - OperatorName = ".*"; + operatorName = ".*"; break; case "dv": - OperatorName = "/"; + operatorName = "/"; break; case "dV": - OperatorName = "/="; + operatorName = "/="; break; case "eo": - OperatorName = "^"; + operatorName = "^"; break; case "eO": - OperatorName = "^="; + operatorName = "^="; break; case "eq": - OperatorName = "=="; + operatorName = "=="; break; case "ge": - OperatorName = ">="; + operatorName = ">="; break; case "gt": - OperatorName = ">"; + operatorName = ">"; break; case "le": - OperatorName = "<="; + operatorName = "<="; break; case "ls": - OperatorName = "<<"; + operatorName = "<<"; break; case "lS": - OperatorName = "<<="; + operatorName = "<<="; break; case "lt": - OperatorName = "<"; + operatorName = "<"; break; case "mi": - OperatorName = "-"; + operatorName = "-"; break; case "mI": - OperatorName = "-="; + operatorName = "-="; break; case "ml": - OperatorName = "*"; + operatorName = "*"; break; case "mL": - OperatorName = "*="; + operatorName = "*="; break; case "ne": - OperatorName = "!="; + operatorName = "!="; break; case "oo": - OperatorName = "||"; + operatorName = "||"; break; case "or": - OperatorName = "|"; + operatorName = "|"; break; case "oR": - OperatorName = "|="; + operatorName = "|="; break; case "pl": - OperatorName = "+"; + operatorName = "+"; break; case "pL": - OperatorName = "+="; + operatorName = "+="; break; case "rm": - OperatorName = "%"; + operatorName = "%"; break; case "rM": - OperatorName = "%="; + operatorName = "%="; break; case "rs": - OperatorName = ">>"; + operatorName = ">>"; break; case "rS": - OperatorName = ">>="; + operatorName = ">>="; break; default: return null; } - Position += 2; + _position += 2; - BaseNode Expression = ParseExpression(); - if (Expression == null) + BaseNode expression = ParseExpression(); + if (expression == null) { return null; } - BaseNode Initializer = null; + BaseNode initializer = null; - if (HasInitializer) + if (hasInitializer) { - Initializer = ParseExpression(); - if (Initializer == null) + initializer = ParseExpression(); + if (initializer == null) { return null; } } - if (IsLeftFold && Initializer != null) + if (isLeftFold && initializer != null) { - BaseNode Temp = Expression; - Expression = Initializer; - Initializer = Temp; + BaseNode temp = expression; + expression = initializer; + initializer = temp; } - return new FoldExpression(IsLeftFold, OperatorName, new PackedTemplateParameterExpansion(Expression), Initializer); + return new FoldExpression(isLeftFold, operatorName, new PackedTemplateParameterExpansion(expression), initializer); } @@ -1585,70 +1585,70 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - bool CanParseTemplateArgsBackup = CanParseTemplateArgs; - CanParseTemplateArgs = false; - BaseNode Type = ParseType(); - CanParseTemplateArgs = CanParseTemplateArgsBackup; + bool canParseTemplateArgsBackup = _canParseTemplateArgs; + _canParseTemplateArgs = false; + BaseNode type = ParseType(); + _canParseTemplateArgs = canParseTemplateArgsBackup; - if (Type == null) + if (type == null) { return null; } - List<BaseNode> Expressions = new List<BaseNode>(); + List<BaseNode> expressions = new List<BaseNode>(); if (ConsumeIf("_")) { while (!ConsumeIf("E")) { - BaseNode Expression = ParseExpression(); - if (Expression == null) + BaseNode expression = ParseExpression(); + if (expression == null) { return null; } - Expressions.Add(Expression); + expressions.Add(expression); } } else { - BaseNode Expression = ParseExpression(); - if (Expression == null) + BaseNode expression = ParseExpression(); + if (expression == null) { return null; } - Expressions.Add(Expression); + expressions.Add(expression); } - return new ConversionExpression(Type, new NodeArray(Expressions)); + return new ConversionExpression(type, new NodeArray(expressions)); } - private BaseNode ParseBinaryExpression(string Name) + private BaseNode ParseBinaryExpression(string name) { - BaseNode LeftPart = ParseExpression(); - if (LeftPart == null) + BaseNode leftPart = ParseExpression(); + if (leftPart == null) { return null; } - BaseNode RightPart = ParseExpression(); - if (RightPart == null) + BaseNode rightPart = ParseExpression(); + if (rightPart == null) { return null; } - return new BinaryExpression(LeftPart, Name, RightPart); + return new BinaryExpression(leftPart, name, rightPart); } - private BaseNode ParsePrefixExpression(string Name) + private BaseNode ParsePrefixExpression(string name) { - BaseNode Expression = ParseExpression(); - if (Expression == null) + BaseNode expression = ParseExpression(); + if (expression == null) { return null; } - return new PrefixExpression(Name, Expression); + return new PrefixExpression(name, expression); } @@ -1661,60 +1661,60 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler { if (Peek() == 'd') { - BaseNode BracedExpressionNode; + BaseNode bracedExpressionNode; switch (Peek(1)) { case 'i': - Position += 2; - BaseNode Field = ParseSourceName(); - if (Field == null) + _position += 2; + BaseNode field = ParseSourceName(); + if (field == null) { return null; } - BracedExpressionNode = ParseBracedExpression(); - if (BracedExpressionNode == null) + bracedExpressionNode = ParseBracedExpression(); + if (bracedExpressionNode == null) { return null; } - return new BracedExpression(Field, BracedExpressionNode, false); + return new BracedExpression(field, bracedExpressionNode, false); case 'x': - Position += 2; - BaseNode Index = ParseExpression(); - if (Index == null) + _position += 2; + BaseNode index = ParseExpression(); + if (index == null) { return null; } - BracedExpressionNode = ParseBracedExpression(); - if (BracedExpressionNode == null) + bracedExpressionNode = ParseBracedExpression(); + if (bracedExpressionNode == null) { return null; } - return new BracedExpression(Index, BracedExpressionNode, true); + return new BracedExpression(index, bracedExpressionNode, true); case 'X': - Position += 2; - BaseNode RangeBeginExpression = ParseExpression(); - if (RangeBeginExpression == null) + _position += 2; + BaseNode rangeBeginExpression = ParseExpression(); + if (rangeBeginExpression == null) { return null; } - BaseNode RangeEndExpression = ParseExpression(); - if (RangeEndExpression == null) + BaseNode rangeEndExpression = ParseExpression(); + if (rangeEndExpression == null) { return null; } - BracedExpressionNode = ParseBracedExpression(); - if (BracedExpressionNode == null) + bracedExpressionNode = ParseBracedExpression(); + if (bracedExpressionNode == null) { return null; } - return new BracedRangeExpression(RangeBeginExpression, RangeEndExpression, BracedExpressionNode); + return new BracedRangeExpression(rangeBeginExpression, rangeEndExpression, bracedExpressionNode); } } @@ -1729,30 +1729,30 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // <initializer> ::= pi <expression>* E # parenthesized initialization private BaseNode ParseNewExpression() { - bool IsGlobal = ConsumeIf("gs"); - bool IsArray = Peek(1) == 'a'; + bool isGlobal = ConsumeIf("gs"); + bool isArray = Peek(1) == 'a'; if (!ConsumeIf("nw") || !ConsumeIf("na")) { return null; } - List<BaseNode> Expressions = new List<BaseNode>(); - List<BaseNode> Initializers = new List<BaseNode>(); + List<BaseNode> expressions = new List<BaseNode>(); + List<BaseNode> initializers = new List<BaseNode>(); while (!ConsumeIf("_")) { - BaseNode Expression = ParseExpression(); - if (Expression == null) + BaseNode expression = ParseExpression(); + if (expression == null) { return null; } - Expressions.Add(Expression); + expressions.Add(expression); } - BaseNode TypeNode = ParseType(); - if (TypeNode == null) + BaseNode typeNode = ParseType(); + if (typeNode == null) { return null; } @@ -1761,13 +1761,13 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler { while (!ConsumeIf("E")) { - BaseNode Initializer = ParseExpression(); - if (Initializer == null) + BaseNode initializer = ParseExpression(); + if (initializer == null) { return null; } - Initializers.Add(Initializer); + initializers.Add(initializer); } } else if (!ConsumeIf("E")) @@ -1775,7 +1775,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - return new NewExpression(new NodeArray(Expressions), TypeNode, new NodeArray(Initializers), IsGlobal, IsArray); + return new NewExpression(new NodeArray(expressions), typeNode, new NodeArray(initializers), isGlobal, isArray); } @@ -1823,8 +1823,8 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= <expr-primary> private BaseNode ParseExpression() { - bool IsGlobal = ConsumeIf("gs"); - BaseNode Expression = null; + bool isGlobal = ConsumeIf("gs"); + BaseNode expression = null; if (Count() < 2) { return null; @@ -1837,8 +1837,8 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler case 'T': return ParseTemplateParam(); case 'f': - char C = Peek(1); - if (C == 'p' || (C == 'L' && char.IsDigit(Peek(2)))) + char c = Peek(1); + if (c == 'p' || (c == 'L' && char.IsDigit(Peek(2)))) { return ParseFunctionParameter(); } @@ -1848,164 +1848,164 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'a': - Position += 2; + _position += 2; return ParseBinaryExpression("&&"); case 'd': case 'n': - Position += 2; + _position += 2; return ParseBinaryExpression("&"); case 'N': - Position += 2; + _position += 2; return ParseBinaryExpression("&="); case 'S': - Position += 2; + _position += 2; return ParseBinaryExpression("="); case 't': - Position += 2; - BaseNode Type = ParseType(); - if (Type == null) + _position += 2; + BaseNode type = ParseType(); + if (type == null) { return null; } - return new EnclosedExpression("alignof (", Type, ")"); + return new EnclosedExpression("alignof (", type, ")"); case 'z': - Position += 2; - Expression = ParseExpression(); - if (Expression == null) + _position += 2; + expression = ParseExpression(); + if (expression == null) { return null; } - return new EnclosedExpression("alignof (", Expression, ")"); + return new EnclosedExpression("alignof (", expression, ")"); } return null; case 'c': switch (Peek(1)) { case 'c': - Position += 2; - BaseNode To = ParseType(); - if (To == null) + _position += 2; + BaseNode to = ParseType(); + if (to == null) { return null; } - BaseNode From = ParseExpression(); - if (From == null) + BaseNode from = ParseExpression(); + if (from == null) { return null; } - return new CastExpression("const_cast", To, From); + return new CastExpression("const_cast", to, from); case 'l': - Position += 2; - BaseNode Callee = ParseExpression(); - if (Callee == null) + _position += 2; + BaseNode callee = ParseExpression(); + if (callee == null) { return null; } - List<BaseNode> Names = new List<BaseNode>(); + List<BaseNode> names = new List<BaseNode>(); while (!ConsumeIf("E")) { - Expression = ParseExpression(); - if (Expression == null) + expression = ParseExpression(); + if (expression == null) { return null; } - Names.Add(Expression); + names.Add(expression); } - return new CallExpression(Callee, Names); + return new CallExpression(callee, names); case 'm': - Position += 2; + _position += 2; return ParseBinaryExpression(","); case 'o': - Position += 2; + _position += 2; return ParsePrefixExpression("~"); case 'v': return ParseConversionExpression(); } return null; case 'd': - BaseNode LeftNode = null; - BaseNode RightNode = null; + BaseNode leftNode = null; + BaseNode rightNode = null; switch (Peek(1)) { case 'a': - Position += 2; - Expression = ParseExpression(); - if (Expression == null) + _position += 2; + expression = ParseExpression(); + if (expression == null) { - return Expression; + return expression; } - return new DeleteExpression(Expression, IsGlobal, true); + return new DeleteExpression(expression, isGlobal, true); case 'c': - Position += 2; - BaseNode Type = ParseType(); - if (Type == null) + _position += 2; + BaseNode type = ParseType(); + if (type == null) { return null; } - Expression = ParseExpression(); - if (Expression == null) + expression = ParseExpression(); + if (expression == null) { - return Expression; + return expression; } - return new CastExpression("dynamic_cast", Type, Expression); + return new CastExpression("dynamic_cast", type, expression); case 'e': - Position += 2; + _position += 2; return ParsePrefixExpression("*"); case 'l': - Position += 2; - Expression = ParseExpression(); - if (Expression == null) + _position += 2; + expression = ParseExpression(); + if (expression == null) { return null; } - return new DeleteExpression(Expression, IsGlobal, false); + return new DeleteExpression(expression, isGlobal, false); case 'n': return ParseUnresolvedName(); case 's': - Position += 2; - LeftNode = ParseExpression(); - if (LeftNode == null) + _position += 2; + leftNode = ParseExpression(); + if (leftNode == null) { return null; } - RightNode = ParseExpression(); - if (RightNode == null) + rightNode = ParseExpression(); + if (rightNode == null) { return null; } - return new MemberExpression(LeftNode, ".*", RightNode); + return new MemberExpression(leftNode, ".*", rightNode); case 't': - Position += 2; - LeftNode = ParseExpression(); - if (LeftNode == null) + _position += 2; + leftNode = ParseExpression(); + if (leftNode == null) { return null; } - RightNode = ParseExpression(); - if (RightNode == null) + rightNode = ParseExpression(); + if (rightNode == null) { return null; } - return new MemberExpression(LeftNode, ".", RightNode); + return new MemberExpression(leftNode, ".", rightNode); case 'v': - Position += 2; + _position += 2; return ParseBinaryExpression("/"); case 'V': - Position += 2; + _position += 2; return ParseBinaryExpression("/="); } return null; @@ -2013,13 +2013,13 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'o': - Position += 2; + _position += 2; return ParseBinaryExpression("^"); case 'O': - Position += 2; + _position += 2; return ParseBinaryExpression("^="); case 'q': - Position += 2; + _position += 2; return ParseBinaryExpression("=="); } return null; @@ -2027,10 +2027,10 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'e': - Position += 2; + _position += 2; return ParseBinaryExpression(">="); case 't': - Position += 2; + _position += 2; return ParseBinaryExpression(">"); } return null; @@ -2038,51 +2038,51 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'x': - Position += 2; + _position += 2; BaseNode Base = ParseExpression(); if (Base == null) { return null; } - BaseNode Subscript = ParseExpression(); + BaseNode subscript = ParseExpression(); if (Base == null) { return null; } - return new ArraySubscriptingExpression(Base, Subscript); + return new ArraySubscriptingExpression(Base, subscript); case 'l': - Position += 2; + _position += 2; - List<BaseNode> BracedExpressions = new List<BaseNode>(); + List<BaseNode> bracedExpressions = new List<BaseNode>(); while (!ConsumeIf("E")) { - Expression = ParseBracedExpression(); - if (Expression == null) + expression = ParseBracedExpression(); + if (expression == null) { return null; } - BracedExpressions.Add(Expression); + bracedExpressions.Add(expression); } - return new InitListExpression(null, BracedExpressions); + return new InitListExpression(null, bracedExpressions); } return null; case 'l': switch (Peek(1)) { case 'e': - Position += 2; + _position += 2; return ParseBinaryExpression("<="); case 's': - Position += 2; + _position += 2; return ParseBinaryExpression("<<"); case 'S': - Position += 2; + _position += 2; return ParseBinaryExpression("<<="); case 't': - Position += 2; + _position += 2; return ParseBinaryExpression("<"); } return null; @@ -2090,31 +2090,31 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'i': - Position += 2; + _position += 2; return ParseBinaryExpression("-"); case 'I': - Position += 2; + _position += 2; return ParseBinaryExpression("-="); case 'l': - Position += 2; + _position += 2; return ParseBinaryExpression("*"); case 'L': - Position += 2; + _position += 2; return ParseBinaryExpression("*="); case 'm': - Position += 2; + _position += 2; if (ConsumeIf("_")) { return ParsePrefixExpression("--"); } - Expression = ParseExpression(); - if (Expression == null) + expression = ParseExpression(); + if (expression == null) { return null; } - return new PostfixExpression(Expression, "--"); + return new PostfixExpression(expression, "--"); } return null; case 'n': @@ -2122,26 +2122,26 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler { case 'a': case 'w': - Position += 2; + _position += 2; return ParseNewExpression(); case 'e': - Position += 2; + _position += 2; return ParseBinaryExpression("!="); case 'g': - Position += 2; + _position += 2; return ParsePrefixExpression("-"); case 't': - Position += 2; + _position += 2; return ParsePrefixExpression("!"); case 'x': - Position += 2; - Expression = ParseExpression(); - if (Expression == null) + _position += 2; + expression = ParseExpression(); + if (expression == null) { return null; } - return new EnclosedExpression("noexcept (", Expression, ")"); + return new EnclosedExpression("noexcept (", expression, ")"); } return null; case 'o': @@ -2150,13 +2150,13 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler case 'n': return ParseUnresolvedName(); case 'o': - Position += 2; + _position += 2; return ParseBinaryExpression("||"); case 'r': - Position += 2; + _position += 2; return ParseBinaryExpression("|"); case 'R': - Position += 2; + _position += 2; return ParseBinaryExpression("|="); } return null; @@ -2164,100 +2164,100 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'm': - Position += 2; + _position += 2; return ParseBinaryExpression("->*"); case 'l': case 's': - Position += 2; + _position += 2; return ParseBinaryExpression("+"); case 'L': - Position += 2; + _position += 2; return ParseBinaryExpression("+="); case 'p': - Position += 2; + _position += 2; if (ConsumeIf("_")) { return ParsePrefixExpression("++"); } - Expression = ParseExpression(); - if (Expression == null) + expression = ParseExpression(); + if (expression == null) { return null; } - return new PostfixExpression(Expression, "++"); + return new PostfixExpression(expression, "++"); case 't': - Position += 2; - LeftNode = ParseExpression(); - if (LeftNode == null) + _position += 2; + leftNode = ParseExpression(); + if (leftNode == null) { return null; } - RightNode = ParseExpression(); - if (RightNode == null) + rightNode = ParseExpression(); + if (rightNode == null) { return null; } - return new MemberExpression(LeftNode, "->", RightNode); + return new MemberExpression(leftNode, "->", rightNode); } return null; case 'q': if (Peek(1) == 'u') { - Position += 2; - BaseNode Condition = ParseExpression(); - if (Condition == null) + _position += 2; + BaseNode condition = ParseExpression(); + if (condition == null) { return null; } - LeftNode = ParseExpression(); - if (LeftNode == null) + leftNode = ParseExpression(); + if (leftNode == null) { return null; } - RightNode = ParseExpression(); - if (RightNode == null) + rightNode = ParseExpression(); + if (rightNode == null) { return null; } - return new ConditionalExpression(Condition, LeftNode, RightNode); + return new ConditionalExpression(condition, leftNode, rightNode); } return null; case 'r': switch (Peek(1)) { case 'c': - Position += 2; - BaseNode To = ParseType(); - if (To == null) + _position += 2; + BaseNode to = ParseType(); + if (to == null) { return null; } - BaseNode From = ParseExpression(); - if (From == null) + BaseNode from = ParseExpression(); + if (from == null) { return null; } - return new CastExpression("reinterpret_cast", To, From); + return new CastExpression("reinterpret_cast", to, from); case 'm': - Position += 2; + _position += 2; return ParseBinaryExpression("%"); case 'M': - Position += 2; + _position += 2; return ParseBinaryExpression("%"); case 's': - Position += 2; + _position += 2; return ParseBinaryExpression(">>"); case 'S': - Position += 2; + _position += 2; return ParseBinaryExpression(">>="); } return null; @@ -2265,140 +2265,140 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek(1)) { case 'c': - Position += 2; - BaseNode To = ParseType(); - if (To == null) + _position += 2; + BaseNode to = ParseType(); + if (to == null) { return null; } - BaseNode From = ParseExpression(); - if (From == null) + BaseNode from = ParseExpression(); + if (from == null) { return null; } - return new CastExpression("static_cast", To, From); + return new CastExpression("static_cast", to, from); case 'p': - Position += 2; - Expression = ParseExpression(); - if (Expression == null) + _position += 2; + expression = ParseExpression(); + if (expression == null) { return null; } - return new PackedTemplateParameterExpansion(Expression); + return new PackedTemplateParameterExpansion(expression); case 'r': return ParseUnresolvedName(); case 't': - Position += 2; - BaseNode EnclosedType = ParseType(); - if (EnclosedType == null) + _position += 2; + BaseNode enclosedType = ParseType(); + if (enclosedType == null) { return null; } - return new EnclosedExpression("sizeof (", EnclosedType, ")"); + return new EnclosedExpression("sizeof (", enclosedType, ")"); case 'z': - Position += 2; - Expression = ParseExpression(); - if (Expression == null) + _position += 2; + expression = ParseExpression(); + if (expression == null) { return null; } - return new EnclosedExpression("sizeof (", Expression, ")"); + return new EnclosedExpression("sizeof (", expression, ")"); case 'Z': - Position += 2; - BaseNode SizeofParamNode = null; + _position += 2; + BaseNode sizeofParamNode = null; switch (Peek()) { case 'T': // FIXME: ??? Not entire sure if it's right - SizeofParamNode = ParseFunctionParameter(); - if (SizeofParamNode == null) + sizeofParamNode = ParseFunctionParameter(); + if (sizeofParamNode == null) { return null; } - return new EnclosedExpression("sizeof...(", new PackedTemplateParameterExpansion(SizeofParamNode), ")"); + return new EnclosedExpression("sizeof...(", new PackedTemplateParameterExpansion(sizeofParamNode), ")"); case 'f': - SizeofParamNode = ParseFunctionParameter(); - if (SizeofParamNode == null) + sizeofParamNode = ParseFunctionParameter(); + if (sizeofParamNode == null) { return null; } - return new EnclosedExpression("sizeof...(", SizeofParamNode, ")"); + return new EnclosedExpression("sizeof...(", sizeofParamNode, ")"); } return null; case 'P': - Position += 2; - List<BaseNode> Arguments = new List<BaseNode>(); + _position += 2; + List<BaseNode> arguments = new List<BaseNode>(); while (!ConsumeIf("E")) { - BaseNode Argument = ParseTemplateArgument(); - if (Argument == null) + BaseNode argument = ParseTemplateArgument(); + if (argument == null) { return null; } - Arguments.Add(Argument); + arguments.Add(argument); } - return new EnclosedExpression("sizeof...(", new NodeArray(Arguments), ")"); + return new EnclosedExpression("sizeof...(", new NodeArray(arguments), ")"); } return null; case 't': switch (Peek(1)) { case 'e': - Expression = ParseExpression(); - if (Expression == null) + expression = ParseExpression(); + if (expression == null) { return null; } - return new EnclosedExpression("typeid (", Expression, ")"); + return new EnclosedExpression("typeid (", expression, ")"); case 't': - BaseNode EnclosedType = ParseExpression(); - if (EnclosedType == null) + BaseNode enclosedType = ParseExpression(); + if (enclosedType == null) { return null; } - return new EnclosedExpression("typeid (", EnclosedType, ")"); + return new EnclosedExpression("typeid (", enclosedType, ")"); case 'l': - Position += 2; - BaseNode TypeNode = ParseType(); - if (TypeNode == null) + _position += 2; + BaseNode typeNode = ParseType(); + if (typeNode == null) { return null; } - List<BaseNode> BracedExpressions = new List<BaseNode>(); + List<BaseNode> bracedExpressions = new List<BaseNode>(); while (!ConsumeIf("E")) { - Expression = ParseBracedExpression(); - if (Expression == null) + expression = ParseBracedExpression(); + if (expression == null) { return null; } - BracedExpressions.Add(Expression); + bracedExpressions.Add(expression); } - return new InitListExpression(TypeNode, BracedExpressions); + return new InitListExpression(typeNode, bracedExpressions); case 'r': - Position += 2; + _position += 2; return new NameType("throw"); case 'w': - Position += 2; - Expression = ParseExpression(); - if (Expression == null) + _position += 2; + expression = ParseExpression(); + if (expression == null) { return null; } - return new ThrowExpression(Expression); + return new ThrowExpression(expression); } return null; } @@ -2411,15 +2411,15 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - private BaseNode ParseIntegerLiteral(string LiteralName) + private BaseNode ParseIntegerLiteral(string literalName) { - string Number = ParseNumber(true); - if (Number == null || Number.Length == 0 || !ConsumeIf("E")) + string number = ParseNumber(true); + if (number == null || number.Length == 0 || !ConsumeIf("E")) { return null; } - return new IntegerLiteral(LiteralName, Number); + return new IntegerLiteral(literalName, number); } // <expr-primary> ::= L <type> <value number> E # integer literal @@ -2439,7 +2439,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler switch (Peek()) { case 'w': - Position++; + _position++; return ParseIntegerLiteral("wchar_t"); case 'b': if (ConsumeIf("b0E")) @@ -2454,43 +2454,43 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; case 'c': - Position++; + _position++; return ParseIntegerLiteral("char"); case 'a': - Position++; + _position++; return ParseIntegerLiteral("signed char"); case 'h': - Position++; + _position++; return ParseIntegerLiteral("unsigned char"); case 's': - Position++; + _position++; return ParseIntegerLiteral("short"); case 't': - Position++; + _position++; return ParseIntegerLiteral("unsigned short"); case 'i': - Position++; + _position++; return ParseIntegerLiteral(""); case 'j': - Position++; + _position++; return ParseIntegerLiteral("u"); case 'l': - Position++; + _position++; return ParseIntegerLiteral("l"); case 'm': - Position++; + _position++; return ParseIntegerLiteral("ul"); case 'x': - Position++; + _position++; return ParseIntegerLiteral("ll"); case 'y': - Position++; + _position++; return ParseIntegerLiteral("ull"); case 'n': - Position++; + _position++; return ParseIntegerLiteral("__int128"); case 'o': - Position++; + _position++; return ParseIntegerLiteral("unsigned __int128"); case 'd': case 'e': @@ -2500,29 +2500,29 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler case '_': if (ConsumeIf("_Z")) { - BaseNode Encoding = ParseEncoding(); - if (Encoding != null && ConsumeIf("E")) + BaseNode encoding = ParseEncoding(); + if (encoding != null && ConsumeIf("E")) { - return Encoding; + return encoding; } } return null; case 'T': return null; default: - BaseNode Type = ParseType(); - if (Type == null) + BaseNode type = ParseType(); + if (type == null) { return null; } - string Number = ParseNumber(); - if (Number == null || Number.Length == 0 || !ConsumeIf("E")) + string number = ParseNumber(); + if (number == null || number.Length == 0 || !ConsumeIf("E")) { return null; } - return new IntegerCastExpression(Type, Number); + return new IntegerCastExpression(type, number); } } @@ -2535,8 +2535,8 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - BaseNode Expression = ParseExpression(); - if (Expression == null) + BaseNode expression = ParseExpression(); + if (expression == null) { return null; } @@ -2546,7 +2546,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - return new EnclosedExpression("decltype(", Expression, ")"); + return new EnclosedExpression("decltype(", expression, ")"); } // <template-param> ::= T_ # first template parameter @@ -2560,16 +2560,16 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - int Index = 0; + int index = 0; if (!ConsumeIf("_")) { - Index = ParsePositiveNumber(); - if (Index < 0) + index = ParsePositiveNumber(); + if (index < 0) { return null; } - Index++; + index++; if (!ConsumeIf("_")) { return null; @@ -2580,65 +2580,65 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // if (IsParsingLambdaParameters) // return new NameType("auto"); - if (CanForwardTemplateReference) + if (_canForwardTemplateReference) { - ForwardTemplateReference ForwardTemplateReference = new ForwardTemplateReference(Index); - ForwardTemplateReferenceList.Add(ForwardTemplateReference); - return ForwardTemplateReference; + ForwardTemplateReference forwardTemplateReference = new ForwardTemplateReference(index); + _forwardTemplateReferenceList.Add(forwardTemplateReference); + return forwardTemplateReference; } - if (Index >= TemplateParamList.Count) + if (index >= _templateParamList.Count) { return null; } - return TemplateParamList[Index]; + return _templateParamList[index]; } // <template-args> ::= I <template-arg>+ E - private BaseNode ParseTemplateArguments(bool HasContext = false) + private BaseNode ParseTemplateArguments(bool hasContext = false) { if (!ConsumeIf("I")) { return null; } - if (HasContext) + if (hasContext) { - TemplateParamList.Clear(); + _templateParamList.Clear(); } - List<BaseNode> Args = new List<BaseNode>(); + List<BaseNode> args = new List<BaseNode>(); while (!ConsumeIf("E")) { - if (HasContext) + if (hasContext) { - List<BaseNode> TemplateParamListTemp = new List<BaseNode>(TemplateParamList); - BaseNode TemplateArgument = ParseTemplateArgument(); - TemplateParamList = TemplateParamListTemp; - if (TemplateArgument == null) + List<BaseNode> templateParamListTemp = new List<BaseNode>(_templateParamList); + BaseNode templateArgument = ParseTemplateArgument(); + _templateParamList = templateParamListTemp; + if (templateArgument == null) { return null; } - Args.Add(TemplateArgument); - if (TemplateArgument.GetType().Equals(NodeType.PackedTemplateArgument)) + args.Add(templateArgument); + if (templateArgument.GetType().Equals(NodeType.PackedTemplateArgument)) { - TemplateArgument = new PackedTemplateParameter(((NodeArray)TemplateArgument).Nodes); + templateArgument = new PackedTemplateParameter(((NodeArray)templateArgument).Nodes); } - TemplateParamList.Add(TemplateArgument); + _templateParamList.Add(templateArgument); } else { - BaseNode TemplateArgument = ParseTemplateArgument(); - if (TemplateArgument == null) + BaseNode templateArgument = ParseTemplateArgument(); + if (templateArgument == null) { return null; } - Args.Add(TemplateArgument); + args.Add(templateArgument); } } - return new TemplateArguments(Args); + return new TemplateArguments(args); } @@ -2652,32 +2652,32 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler { // X <expression> E case 'X': - Position++; - BaseNode Expression = ParseExpression(); - if (Expression == null || !ConsumeIf("E")) + _position++; + BaseNode expression = ParseExpression(); + if (expression == null || !ConsumeIf("E")) { return null; } - return Expression; + return expression; // <expr-primary> case 'L': return ParseExpressionPrimary(); // J <template-arg>* E case 'J': - Position++; - List<BaseNode> TemplateArguments = new List<BaseNode>(); + _position++; + List<BaseNode> templateArguments = new List<BaseNode>(); while (!ConsumeIf("E")) { - BaseNode TemplateArgument = ParseTemplateArgument(); - if (TemplateArgument == null) + BaseNode templateArgument = ParseTemplateArgument(); + if (templateArgument == null) { return null; } - TemplateArguments.Add(TemplateArgument); + templateArguments.Add(templateArgument); } - return new NodeArray(TemplateArguments, NodeType.PackedTemplateArgument); + return new NodeArray(templateArguments, NodeType.PackedTemplateArgument); // <type> default: return ParseType(); @@ -2686,7 +2686,7 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler class NameParserContext { - public CVType CV; + public CvType Cv; public SimpleReferenceType Ref; public bool FinishWithTemplateArguments; public bool CtorDtorConversion; @@ -2700,25 +2700,25 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler { if (Peek() == 'T') { - BaseNode TemplateParam = ParseTemplateParam(); - if (TemplateParam == null) + BaseNode templateParam = ParseTemplateParam(); + if (templateParam == null) { return null; } - SubstitutionList.Add(TemplateParam); - return TemplateParam; + _substitutionList.Add(templateParam); + return templateParam; } else if (Peek() == 'D') { - BaseNode DeclType = ParseDecltype(); - if (DeclType == null) + BaseNode declType = ParseDecltype(); + if (declType == null) { return null; } - SubstitutionList.Add(DeclType); - return DeclType; + _substitutionList.Add(declType); + return declType; } return ParseSubstitution(); } @@ -2726,44 +2726,44 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // <simple-id> ::= <source-name> [ <template-args> ] private BaseNode ParseSimpleId() { - BaseNode SourceName = ParseSourceName(); - if (SourceName == null) + BaseNode sourceName = ParseSourceName(); + if (sourceName == null) { return null; } if (Peek() == 'I') { - BaseNode TemplateArguments = ParseTemplateArguments(); - if (TemplateArguments == null) + BaseNode templateArguments = ParseTemplateArguments(); + if (templateArguments == null) { return null; } - return new NameTypeWithTemplateArguments(SourceName, TemplateArguments); + return new NameTypeWithTemplateArguments(sourceName, templateArguments); } - return SourceName; + return sourceName; } // <destructor-name> ::= <unresolved-type> # e.g., ~T or ~decltype(f()) // ::= <simple-id> # e.g., ~A<2*N> private BaseNode ParseDestructorName() { - BaseNode Node; + BaseNode node; if (char.IsDigit(Peek())) { - Node = ParseSimpleId(); + node = ParseSimpleId(); } else { - Node = ParseUnresolvedType(); + node = ParseUnresolvedType(); } - if (Node == null) + if (node == null) { return null; } - return new DtorName(Node); + return new DtorName(node); } // <base-unresolved-name> ::= <simple-id> # unresolved name @@ -2785,23 +2785,23 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler } ConsumeIf("on"); - BaseNode OperatorName = ParseOperatorName(null); - if (OperatorName == null) + BaseNode operatorName = ParseOperatorName(null); + if (operatorName == null) { return null; } if (Peek() == 'I') { - BaseNode TemplateArguments = ParseTemplateArguments(); - if (TemplateArguments == null) + BaseNode templateArguments = ParseTemplateArguments(); + if (templateArguments == null) { return null; } - return new NameTypeWithTemplateArguments(OperatorName, TemplateArguments); + return new NameTypeWithTemplateArguments(operatorName, templateArguments); } - return OperatorName; + return operatorName; } // <unresolved-name> ::= [gs] <base-unresolved-name> # x or (with "gs") ::x @@ -2810,27 +2810,27 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // # T::N::x /decltype(p)::N::x // ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name> // # A::x, N::y, A<T>::z; "gs" means leading "::" - private BaseNode ParseUnresolvedName(NameParserContext Context = null) + private BaseNode ParseUnresolvedName(NameParserContext context = null) { - BaseNode Result = null; + BaseNode result = null; if (ConsumeIf("srN")) { - Result = ParseUnresolvedType(); - if (Result == null) + result = ParseUnresolvedType(); + if (result == null) { return null; } if (Peek() == 'I') { - BaseNode TemplateArguments = ParseTemplateArguments(); - if (TemplateArguments == null) + BaseNode templateArguments = ParseTemplateArguments(); + if (templateArguments == null) { return null; } - Result = new NameTypeWithTemplateArguments(Result, TemplateArguments); - if (Result == null) + result = new NameTypeWithTemplateArguments(result, templateArguments); + if (result == null) { return null; } @@ -2838,45 +2838,45 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler while (!ConsumeIf("E")) { - BaseNode SimpleId = ParseSimpleId(); - if (SimpleId == null) + BaseNode simpleId = ParseSimpleId(); + if (simpleId == null) { return null; } - Result = new QualifiedName(Result, SimpleId); - if (Result == null) + result = new QualifiedName(result, simpleId); + if (result == null) { return null; } } - BaseNode BaseName = ParseBaseUnresolvedName(); - if (BaseName == null) + BaseNode baseName = ParseBaseUnresolvedName(); + if (baseName == null) { return null; } - return new QualifiedName(Result, BaseName); + return new QualifiedName(result, baseName); } - bool IsGlobal = ConsumeIf("gs"); + bool isGlobal = ConsumeIf("gs"); // ::= [gs] <base-unresolved-name> # x or (with "gs") ::x if (!ConsumeIf("sr")) { - Result = ParseBaseUnresolvedName(); - if (Result == null) + result = ParseBaseUnresolvedName(); + if (result == null) { return null; } - if (IsGlobal) + if (isGlobal) { - Result = new GlobalQualifiedName(Result); + result = new GlobalQualifiedName(result); } - return Result; + return result; } // ::= [gs] sr <unresolved-qualifier-level>+ E <base-unresolved-name> @@ -2884,26 +2884,26 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler { do { - BaseNode Qualifier = ParseSimpleId(); - if (Qualifier == null) + BaseNode qualifier = ParseSimpleId(); + if (qualifier == null) { return null; } - if (Result != null) + if (result != null) { - Result = new QualifiedName(Result, Qualifier); + result = new QualifiedName(result, qualifier); } - else if (IsGlobal) + else if (isGlobal) { - Result = new GlobalQualifiedName(Qualifier); + result = new GlobalQualifiedName(qualifier); } else { - Result = Qualifier; + result = qualifier; } - if (Result == null) + if (result == null) { return null; } @@ -2912,62 +2912,62 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= sr <unresolved-type> [tempate-args] <base-unresolved-name> # T::x / decltype(p)::x else { - Result = ParseUnresolvedType(); - if (Result == null) + result = ParseUnresolvedType(); + if (result == null) { return null; } if (Peek() == 'I') { - BaseNode TemplateArguments = ParseTemplateArguments(); - if (TemplateArguments == null) + BaseNode templateArguments = ParseTemplateArguments(); + if (templateArguments == null) { return null; } - Result = new NameTypeWithTemplateArguments(Result, TemplateArguments); - if (Result == null) + result = new NameTypeWithTemplateArguments(result, templateArguments); + if (result == null) { return null; } } } - if (Result == null) + if (result == null) { return null; } - BaseNode BaseUnresolvedName = ParseBaseUnresolvedName(); - if (BaseUnresolvedName == null) + BaseNode baseUnresolvedName = ParseBaseUnresolvedName(); + if (baseUnresolvedName == null) { return null; } - return new QualifiedName(Result, BaseUnresolvedName); + return new QualifiedName(result, baseUnresolvedName); } // <unscoped-name> ::= <unqualified-name> // ::= St <unqualified-name> # ::std:: - private BaseNode ParseUnscopedName(NameParserContext Context) + private BaseNode ParseUnscopedName(NameParserContext context) { if (ConsumeIf("St")) { - BaseNode UnresolvedName = ParseUnresolvedName(Context); - if (UnresolvedName == null) + BaseNode unresolvedName = ParseUnresolvedName(context); + if (unresolvedName == null) { return null; } - return new StdQualifiedName(UnresolvedName); + return new StdQualifiedName(unresolvedName); } - return ParseUnresolvedName(Context); + return ParseUnresolvedName(context); } // <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix (TODO)> <unqualified-name> E // ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix (TODO)> <template-args (TODO)> E - private BaseNode ParseNestedName(NameParserContext Context) + private BaseNode ParseNestedName(NameParserContext context) { // Impossible in theory if (Consume() != 'N') @@ -2975,22 +2975,22 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - BaseNode Result = null; - CVType CV = new CVType(ParseCVQualifiers(), null); - if (Context != null) + BaseNode result = null; + CvType cv = new CvType(ParseCvQualifiers(), null); + if (context != null) { - Context.CV = CV; + context.Cv = cv; } SimpleReferenceType Ref = ParseRefQualifiers(); - if (Context != null) + if (context != null) { - Context.Ref = Ref; + context.Ref = Ref; } if (ConsumeIf("St")) { - Result = new NameType("std"); + result = new NameType("std"); } while (!ConsumeIf("E")) @@ -2998,124 +2998,124 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // <data-member-prefix> end if (ConsumeIf("M")) { - if (Result == null) + if (result == null) { return null; } continue; } - char C = Peek(); + char c = Peek(); // TODO: template args - if (C == 'T') + if (c == 'T') { - BaseNode TemplateParam = ParseTemplateParam(); - if (TemplateParam == null) + BaseNode templateParam = ParseTemplateParam(); + if (templateParam == null) { return null; } - Result = CreateNameNode(Result, TemplateParam, Context); - SubstitutionList.Add(Result); + result = CreateNameNode(result, templateParam, context); + _substitutionList.Add(result); continue; } // <template-prefix> <template-args> - if (C == 'I') + if (c == 'I') { - BaseNode TemplateArgument = ParseTemplateArguments(Context != null); - if (TemplateArgument == null || Result == null) + BaseNode templateArgument = ParseTemplateArguments(context != null); + if (templateArgument == null || result == null) { return null; } - Result = new NameTypeWithTemplateArguments(Result, TemplateArgument); - if (Context != null) + result = new NameTypeWithTemplateArguments(result, templateArgument); + if (context != null) { - Context.FinishWithTemplateArguments = true; + context.FinishWithTemplateArguments = true; } - SubstitutionList.Add(Result); + _substitutionList.Add(result); continue; } // <decltype> - if (C == 'D' && (Peek(1) == 't' || Peek(1) == 'T')) + if (c == 'D' && (Peek(1) == 't' || Peek(1) == 'T')) { - BaseNode Decltype = ParseDecltype(); - if (Decltype == null) + BaseNode decltype = ParseDecltype(); + if (decltype == null) { return null; } - Result = CreateNameNode(Result, Decltype, Context); - SubstitutionList.Add(Result); + result = CreateNameNode(result, decltype, context); + _substitutionList.Add(result); continue; } // <substitution> - if (C == 'S' && Peek(1) != 't') + if (c == 'S' && Peek(1) != 't') { - BaseNode Substitution = ParseSubstitution(); - if (Substitution == null) + BaseNode substitution = ParseSubstitution(); + if (substitution == null) { return null; } - Result = CreateNameNode(Result, Substitution, Context); - if (Result != Substitution) + result = CreateNameNode(result, substitution, context); + if (result != substitution) { - SubstitutionList.Add(Substitution); + _substitutionList.Add(substitution); } continue; } // <ctor-dtor-name> of ParseUnqualifiedName - if (C == 'C' || (C == 'D' && Peek(1) != 'C')) + if (c == 'C' || (c == 'D' && Peek(1) != 'C')) { // We cannot have nothing before this - if (Result == null) + if (result == null) { return null; } - BaseNode CtOrDtorName = ParseCtorDtorName(Context, Result); + BaseNode ctOrDtorName = ParseCtorDtorName(context, result); - if (CtOrDtorName == null) + if (ctOrDtorName == null) { return null; } - Result = CreateNameNode(Result, CtOrDtorName, Context); + result = CreateNameNode(result, ctOrDtorName, context); // TODO: ABI Tags (before) - if (Result == null) + if (result == null) { return null; } - SubstitutionList.Add(Result); + _substitutionList.Add(result); continue; } - BaseNode UnqualifiedName = ParseUnqualifiedName(Context); - if (UnqualifiedName == null) + BaseNode unqualifiedName = ParseUnqualifiedName(context); + if (unqualifiedName == null) { return null; } - Result = CreateNameNode(Result, UnqualifiedName, Context); + result = CreateNameNode(result, unqualifiedName, context); - SubstitutionList.Add(Result); + _substitutionList.Add(result); } - if (Result == null || SubstitutionList.Count == 0) + if (result == null || _substitutionList.Count == 0) { return null; } - SubstitutionList.RemoveAt(SubstitutionList.Count - 1); - return Result; + _substitutionList.RemoveAt(_substitutionList.Count - 1); + return result; } // <discriminator> ::= _ <non-negative number> # when number < 10 @@ -3141,24 +3141,24 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // <local-name> ::= Z <function encoding> E <entity name> [<discriminator>] // ::= Z <function encoding> E s [<discriminator>] // ::= Z <function encoding> Ed [ <parameter number> ] _ <entity name> - private BaseNode ParseLocalName(NameParserContext Context) + private BaseNode ParseLocalName(NameParserContext context) { if (!ConsumeIf("Z")) { return null; } - BaseNode Encoding = ParseEncoding(); - if (Encoding == null || !ConsumeIf("E")) + BaseNode encoding = ParseEncoding(); + if (encoding == null || !ConsumeIf("E")) { return null; } - BaseNode EntityName; + BaseNode entityName; if (ConsumeIf("s")) { ParseDiscriminator(); - return new LocalName(Encoding, new NameType("string literal")); + return new LocalName(encoding, new NameType("string literal")); } else if (ConsumeIf("d")) { @@ -3168,47 +3168,47 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - EntityName = ParseName(Context); - if (EntityName == null) + entityName = ParseName(context); + if (entityName == null) { return null; } - return new LocalName(Encoding, EntityName); + return new LocalName(encoding, entityName); } - EntityName = ParseName(Context); - if (EntityName == null) + entityName = ParseName(context); + if (entityName == null) { return null; } ParseDiscriminator(); - return new LocalName(Encoding, EntityName); + return new LocalName(encoding, entityName); } // <name> ::= <nested-name> // ::= <unscoped-name> // ::= <unscoped-template-name> <template-args> // ::= <local-name> # See Scope Encoding below (TODO) - private BaseNode ParseName(NameParserContext Context = null) + private BaseNode ParseName(NameParserContext context = null) { ConsumeIf("L"); if (Peek() == 'N') { - return ParseNestedName(Context); + return ParseNestedName(context); } if (Peek() == 'Z') { - return ParseLocalName(Context); + return ParseLocalName(context); } if (Peek() == 'S' && Peek(1) != 't') { - BaseNode Substitution = ParseSubstitution(); - if (Substitution == null) + BaseNode substitution = ParseSubstitution(); + if (substitution == null) { return null; } @@ -3218,50 +3218,50 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler return null; } - BaseNode TemplateArguments = ParseTemplateArguments(Context != null); - if (TemplateArguments == null) + BaseNode templateArguments = ParseTemplateArguments(context != null); + if (templateArguments == null) { return null; } - if (Context != null) + if (context != null) { - Context.FinishWithTemplateArguments = true; + context.FinishWithTemplateArguments = true; } - return new NameTypeWithTemplateArguments(Substitution, TemplateArguments); + return new NameTypeWithTemplateArguments(substitution, templateArguments); } - BaseNode Result = ParseUnscopedName(Context); - if (Result == null) + BaseNode result = ParseUnscopedName(context); + if (result == null) { return null; } if (Peek() == 'I') { - SubstitutionList.Add(Result); - BaseNode TemplateArguments = ParseTemplateArguments(Context != null); - if (TemplateArguments == null) + _substitutionList.Add(result); + BaseNode templateArguments = ParseTemplateArguments(context != null); + if (templateArguments == null) { return null; } - if (Context != null) + if (context != null) { - Context.FinishWithTemplateArguments = true; + context.FinishWithTemplateArguments = true; } - return new NameTypeWithTemplateArguments(Result, TemplateArguments); + return new NameTypeWithTemplateArguments(result, templateArguments); } - return Result; + return result; } private bool IsEncodingEnd() { - char C = Peek(); - return Count() == 0 || C == 'E' || C == '.' || C == '_'; + char c = Peek(); + return Count() == 0 || c == 'E' || c == '.' || c == '_'; } // <encoding> ::= <function name> <bare-function-type> @@ -3269,14 +3269,14 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler // ::= <special-name> private BaseNode ParseEncoding() { - NameParserContext Context = new NameParserContext(); + NameParserContext context = new NameParserContext(); if (Peek() == 'T' || (Peek() == 'G' && Peek(1) == 'V')) { - return ParseSpecialName(Context); + return ParseSpecialName(context); } - BaseNode Name = ParseName(Context); - if (Name == null) + BaseNode name = ParseName(context); + if (name == null) { return null; } @@ -3285,16 +3285,16 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler if (IsEncodingEnd()) { - return Name; + return name; } // TODO: Ua9enable_ifI - BaseNode ReturnType = null; - if (!Context.CtorDtorConversion && Context.FinishWithTemplateArguments) + BaseNode returnType = null; + if (!context.CtorDtorConversion && context.FinishWithTemplateArguments) { - ReturnType = ParseType(); - if (ReturnType == null) + returnType = ParseType(); + if (returnType == null) { return null; } @@ -3302,27 +3302,27 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler if (ConsumeIf("v")) { - return new EncodedFunction(Name, null, Context.CV, Context.Ref, null, ReturnType); + return new EncodedFunction(name, null, context.Cv, context.Ref, null, returnType); } List<BaseNode> Params = new List<BaseNode>(); // backup because that can be destroyed by parseType - CVType CV = Context.CV; - SimpleReferenceType Ref = Context.Ref; + CvType cv = context.Cv; + SimpleReferenceType Ref = context.Ref; while (!IsEncodingEnd()) { - BaseNode Param = ParseType(); - if (Param == null) + BaseNode param = ParseType(); + if (param == null) { return null; } - Params.Add(Param); + Params.Add(param); } - return new EncodedFunction(Name, new NodeArray(Params), CV, Ref, null, ReturnType); + return new EncodedFunction(name, new NodeArray(Params), cv, Ref, null, returnType); } // <mangled-name> ::= _Z <encoding> @@ -3331,37 +3331,37 @@ namespace Ryujinx.HLE.HOS.Diagnostics.Demangler { if (ConsumeIf("_Z")) { - BaseNode Encoding = ParseEncoding(); - if (Encoding != null && Count() == 0) + BaseNode encoding = ParseEncoding(); + if (encoding != null && Count() == 0) { - return Encoding; + return encoding; } return null; } else { - BaseNode Type = ParseType(); - if (Type != null && Count() == 0) + BaseNode type = ParseType(); + if (type != null && Count() == 0) { - return Type; + return type; } return null; } } - public static string Parse(string OriginalMangled) + public static string Parse(string originalMangled) { - Demangler Instance = new Demangler(OriginalMangled); - BaseNode ResNode = Instance.Parse(); + Demangler instance = new Demangler(originalMangled); + BaseNode resNode = instance.Parse(); - if (ResNode != null) + if (resNode != null) { - StringWriter Writer = new StringWriter(); - ResNode.Print(Writer); - return Writer.ToString(); + StringWriter writer = new StringWriter(); + resNode.Print(writer); + return writer.ToString(); } - return OriginalMangled; + return originalMangled; } } } |