public void AccessClassFunction() { ParsedLine line = new ParsedLine("public: unsigned long long int testClass::testFunction() 0xFFFFFFFF"); ParsedClass theClass = new ParsedClass(line); ParsedFunction func = new ParsedFunction(line, theClass); bool decorators = func.accessLevel.HasValue && func.accessLevel.Value == FuncAccessLevel.PUBLIC && !func.isStatic && !func.isVirtual && !func.isConstructor && !func.isDestructor && !func.callingConvention.HasValue; if (!decorators) { Assert.Fail("Decorators failed to pass"); } bool returnType = func.returnType.isBaseType && func.returnType.baseType.Value == BuiltInCppTypes.UNSIGNED_LONG_LONG_INT && func.returnType.type == "unsigned long long int" && !func.returnType.isConst && !func.returnType.isPointer && !func.returnType.isConstPointer && !func.returnType.isReference; if (!returnType) { Assert.Fail("Return type failed to pass"); } Assert.IsTrue(func.parameters.Count == 0, "Param count failed to pass"); bool names = func.parentClass.name == "testClass" && func.name == "testFunction"; if (!names) { Assert.Fail("Names failed to pass"); } bool end = !func.isConst && func.address == 0xFFFFFFFF; if (!end) { Assert.Fail("End failed to pass"); } }
private void insertPlatformData(List<ParsedClass> classes) { // Some platforms have weird data which we don't know the layout of but need to know the size // to properly resolve members. // This is hackery to handle it. if (CommandLine.args.target == CommandLineArgs.WINDOWS) { } else { ParsedClass pthread_cond_t = new ParsedClass("pthread_cond_t"); pthread_cond_t.addData(new List<NamedCppType> { new NamedCppType("char m_placeholder[48];") }); classes.Add(pthread_cond_t); ParsedClass pthread_mutex_t = new ParsedClass("pthread_mutex_t"); pthread_mutex_t.addData(new List<NamedCppType> { new NamedCppType("char m_placeholder[24];") }); classes.Add(pthread_mutex_t); } }
private List<ParsedClass> getClasses(List<ParsedLine> parsedLines, List<ParsedTypedef> typedefs) { var parsedClassDict = new Dictionary<string, ParsedClass>(); var parsedFunctionDict = new Dictionary<ParsedClass, List<ParsedFunction>>(); foreach (ParsedLine line in parsedLines) { if (line.className == null) { continue; } ParsedClass thisClass = null; parsedClassDict.TryGetValue(handleTemplatedName(line.className), out thisClass); if (thisClass == null) { thisClass = new ParsedClass(line); parsedClassDict[thisClass.name] = thisClass; parsedFunctionDict[thisClass] = new List<ParsedFunction>(); } parsedFunctionDict[thisClass].Add(new ParsedFunction(line, thisClass, typedefs)); } List<ParsedClass> parsedClasses = parsedClassDict.Values.OrderBy(theClass => theClass.name).ToList(); foreach (KeyValuePair<ParsedClass, List<ParsedFunction>> pair in parsedFunctionDict) { pair.Key.addFunctions(pair.Value); } return parsedClasses; }
private void addStructsToClasses(List<ParsedStruct> structs, List<ParsedClass> classes) { List<ParsedClass> classesToAdd = new List<ParsedClass>(); foreach (ParsedStruct theStruct in structs) { ParsedClass matchingClass = null; foreach (ParsedClass theClass in classes) { if (theClass.name == theStruct.name) { matchingClass = theClass; break; } } List<NamedCppType> data = theStruct.members.Select(member => member.data).ToList(); if (matchingClass == null) { ParsedClass newParsedClass = new ParsedClass(theStruct.name); newParsedClass.addData(data); newParsedClass.addAttributes(theStruct.attributes); classesToAdd.Add(newParsedClass); } else { matchingClass.addData(data); matchingClass.addAttributes(theStruct.attributes); } } classes.AddRange(classesToAdd); classes = classes.OrderBy(theClass => theClass.name).ToList(); foreach (ParsedStruct theStruct in structs) { ParsedClass matchingClass = null; foreach (ParsedClass theClass in classes) { if (theClass.name == theStruct.name) { matchingClass = theClass; break; } } Debug.Assert(matchingClass != null); foreach (string inh in theStruct.inheritsFrom) { ParsedClass inheritsFromClass = null; foreach (ParsedClass theClass in classes) { if (theClass.name == inh) { inheritsFromClass = theClass; break; } } Debug.Assert(inheritsFromClass != null); if (matchingClass != null) { matchingClass.inherits.Add(inheritsFromClass); } } } }
private static void buildClassSource(List<string> body, ParsedClass theClass) { body.Add("#include \"" + theClass.name + ".hpp\""); body.Add("#include \"Functions.hpp\""); body.Add(""); if (theClass.sourceDependencies.Count > 0) { body.AddRange(theClass.sourceDependencies.Select(dependency => String.Format("#include \"{0}.hpp\"", dependency.name))); body.Add(""); } body.Add("namespace " + CommandLine.args.libNamespace + " {"); body.Add(""); body.Add("namespace " + CommandLine.args.classNamespace + " {"); body.Add(""); body.AddRange(theClass.asClassSource()); body.Add("}"); body.Add(""); body.Add("}"); }
private static void buildClassHeader(List<string> header, ParsedClass theClass) { header.Add("#pragma once"); header.Add(""); header.Add("#include <cstdint>"); header.Add(""); header.AddRange(theClass.headerDependencies.Select(dependency => String.Format("#include \"{0}.hpp\"", dependency.name))); header.AddRange(theClass.unknownDependencies.Select(dependency => String.Format("#include \"unknown_{0}.hpp\"", dependency.type))); if (theClass.headerDependencies.Count > 0 || theClass.unknownDependencies.Count > 0) { header.Add(""); } header.Add("namespace " + CommandLine.args.libNamespace + " {"); header.Add(""); header.Add("namespace " + CommandLine.args.classNamespace + " {"); header.Add(""); if (theClass.sourceDependencies.Count > 0) { header.Add("// Forward class declarations (defined in the source file)"); header.AddRange(theClass.sourceDependencies.Select(dependency => String.Format("class {0};", dependency.name))); header.Add(""); } header.AddRange(theClass.asClassHeader()); header.Add("}"); header.Add(""); header.Add("}"); }
public ParsedFunction(ParsedLine line, ParsedClass theClass, List<ParsedTypedef> typedefs) { name = SymbolParser.handleTemplatedName(line.functionName); if (theClass != null) { parentClass = theClass; accessLevel = stringToAccessLevel(line.accessLevel); int templateIndex = theClass.name.IndexOf("Templated", StringComparison.Ordinal); if (templateIndex != -1) { // This is a template. Let's check for template ctor/dtor names. string className = parentClass.name.Substring(0, templateIndex); if (name == className) { name = theClass.name; isConstructor = true; } else if (name == "~" + className) { name = theClass.name; isDestructor = true; } } if (name == parentClass.name) { isConstructor = true; } else if (name == "~" + parentClass.name) { isDestructor = true; } isVirtual = line.isVirtual; isConst = line.isConst; } isStatic = line.isStatic; friendlyName = makeFriendlyName(); if (line.returnType != null) { returnType = new CppType(SymbolParser.handleTemplatedName(line.returnType), typedefs); } parameters = new List<CppType>(); foreach (string parameter in line.parameters.Split(',')) { CppType param = new CppType(SymbolParser.handleTemplatedName(parameter), typedefs); if (!param.isBaseType || param.isPointer || (param.baseType.HasValue && param.baseType.Value != BuiltInCppTypes.VOID)) { parameters.Add(param); } } callingConvention = stringToCallingConv(line.callingConvention); address = Convert.ToUInt32(line.address, 16); }
public void Types() { ParsedLine line = new ParsedLine("CExoLinkedList<unsigned long>::AddTail(unsigned long *) 0x80B1670"); ParsedClass theClass = new ParsedClass(line); ParsedFunction func = new ParsedFunction(line, theClass); }
public void templateReturnType() { ParsedLine line = new ParsedLine("template<templateInner> testFunc()"); ParsedClass theClass = new ParsedClass(line); ParsedFunction func = new ParsedFunction(line, theClass); Assert.IsTrue(func.returnType.type == SymbolParser.SymbolParser.handleTemplatedName("template<templateInner>"), "Return type was invalid."); }
public void templateParamType() { ParsedLine line = new ParsedLine("testFunc(template<templateInner>)"); ParsedClass theClass = new ParsedClass(line); ParsedFunction func = new ParsedFunction(line, theClass); Assert.IsTrue(func.parameters[0].type == SymbolParser.SymbolParser.handleTemplatedName("template<templateInner>"), "Params type was invalid."); }
public void templateNestedBadThings() { ParsedLine line = new ParsedLine("template<template<template<unsigned long long int>>> template<template<template<unsigned long long int>>>::testFunc(template<template<template<unsigned long long int>>>, template<template<template<unsigned long long int>>>***, template<template<template<unsigned long long int>>>&)"); ParsedClass theClass = new ParsedClass(line); ParsedFunction func = new ParsedFunction(line, theClass); }
public void templatedClassNameSpace() { ParsedLine line = new ParsedLine("template<unsigned long long int>::testFunc()"); ParsedClass theClass = new ParsedClass(line); ParsedFunction func = new ParsedFunction(line, theClass); Assert.IsTrue(func.parentClass.name == SymbolParser.SymbolParser.handleTemplatedName("template<unsignedlonglongint>"), "Return type was invalid."); }
public void templateClassType() { ParsedLine line = new ParsedLine("template<templateInner>::testFunc()"); ParsedClass theClass = new ParsedClass(line); ParsedFunction func = new ParsedFunction(line, theClass); Assert.IsTrue(func.parentClass.name == SymbolParser.SymbolParser.handleTemplatedName("template<templateInner>"), "Class name was invalid."); }
public void NoReturnTypeFreeStandingFunction() { ParsedLine line = new ParsedLine("testFunction() 0xFFFFFFFF"); ParsedClass theClass = new ParsedClass(line); ParsedFunction func = new ParsedFunction(line, theClass); bool decorators = !func.accessLevel.HasValue && !func.isStatic && !func.isVirtual && !func.isConstructor && !func.isDestructor && !func.callingConvention.HasValue; if (!decorators) { Assert.Fail("Decorators failed to pass"); } Assert.IsTrue(func.returnType == null, "Return type failed to pass."); Assert.IsTrue(func.parameters.Count == 0, "Param count failed to pass"); bool names = func.parentClass.name == ParsedClass.FREE_STANDING_CLASS_NAME && func.name == "testFunction"; if (!names) { Assert.Fail("Names failed to pass"); } bool end = !func.isConst && func.address == 0xFFFFFFFF; if (!end) { Assert.Fail("End failed to pass"); } }
public void FreeStandingFunctionParams() { ParsedLine line = new ParsedLine("unsigned long long int testFunction(unsigned char*** const, const bool, UserType&) 0xFFFFFFFF"); ParsedClass theClass = new ParsedClass(line); ParsedFunction func = new ParsedFunction(line, theClass); bool decorators = !func.accessLevel.HasValue && !func.isStatic && !func.isVirtual && !func.isConstructor && !func.isDestructor && !func.callingConvention.HasValue; if (!decorators) { Assert.Fail("Decorators failed to pass"); } bool returnType = func.returnType.isBaseType && func.returnType.baseType.Value == BuiltInCppTypes.UNSIGNED_LONG_LONG_INT && func.returnType.type == "unsigned long long int" && !func.returnType.isConst && !func.returnType.isPointer && !func.returnType.isConstPointer && !func.returnType.isReference; if (!returnType) { Assert.Fail("Return type failed to pass"); } bool names = func.parentClass.name == ParsedClass.FREE_STANDING_CLASS_NAME && func.name == "testFunction"; if (!names) { Assert.Fail("Names failed to pass"); } Assert.IsTrue(func.parameters.Count == 3, "Param count failed to pass"); bool param1 = func.parameters[0].isBaseType && func.parameters[0].baseType.Value == BuiltInCppTypes.UNSIGNED_CHAR && func.parameters[0].type == "unsigned char" && !func.parameters[0].isConst && func.parameters[0].isPointer && func.parameters[0].pointerDepth == 3 && func.parameters[0].isConstPointer && !func.parameters[0].isReference; if (!param1) { Assert.Fail("Param1 failed to pass"); } bool param2 = func.parameters[1].isBaseType && func.parameters[1].baseType.Value == BuiltInCppTypes.BOOL && func.parameters[1].type == "bool" && func.parameters[1].isConst && !func.parameters[1].isPointer && !func.parameters[1].isConstPointer && !func.parameters[1].isReference; if (!param2) { Assert.Fail("Param2 failed to pass"); } bool param3 = !func.parameters[2].isBaseType && func.parameters[2].type == "UserType" && !func.parameters[2].isConst && !func.parameters[2].isPointer && !func.parameters[2].isConstPointer && func.parameters[2].isReference; if (!param3) { Assert.Fail("Param3 failed to pass"); } bool end = !func.isConst && func.address == 0xFFFFFFFF; if (!end) { Assert.Fail("End failed to pass"); } }