void ResolveBaseTypes() { //2. resolve allbase type foreach (CodeTypeDeclaration typedecl in typedeclDic.Values) { //resolve base type List <CodeTypeReference> baseTypes = typedecl.BaseTypes; if (baseTypes.Count == 0) { //eg. struct } else { foreach (CodeTypeReference baseType in baseTypes) { CefResolvingContext resolvingContext = new CefResolvingContext(this, typedecl, ResolvingContextKind.Base); baseType.ResolvedType = resolvingContext.ResolveType(baseType); if (baseType.ResolvedType == null) { throw new NotSupportedException(); } } } } }
void AddMoreTypeInfo() { //-------- //copy all Freeze(); // Dictionary <string, TypeSymbol> tempSymbols = new Dictionary <string, TypeSymbol>(); int typeCount = typeSymbols.Count; foreach (var kp in typeSymbols) { tempSymbols.Add(kp.Key, kp.Value); } //Cef- find tune detail of base type foreach (TypeSymbol t in tempSymbols.Values) { switch (t.TypeSymbolKind) { default: throw new NotSupportedException(); case TypeSymbolKind.Simple: { SimpleTypeSymbol simpleType = (SimpleTypeSymbol)t; if (simpleType.PrimitiveTypeKind == PrimitiveTypeKind.NotPrimitiveType) { //resolve base type CodeTypeDeclaration typedecl = simpleType.CreatedByTypeDeclaration; if (typedecl != null && typedecl.BaseTypes != null && typedecl.BaseTypes.Count > 0) { CefResolvingContext ctx = new CefResolvingContext(this, null, ResolvingContextKind.Base); simpleType.BaseType = ctx.ResolveType(typedecl.BaseTypes[0]); } else { } } else { } } break; case TypeSymbolKind.TypeDef: { CTypeDefTypeSymbol typedefSymbol = (CTypeDefTypeSymbol)t; CefResolvingContext ctx = new CefResolvingContext(this, null, ResolvingContextKind.Base); typedefSymbol.ReferToTypeSymbol = ctx.ResolveType(typedefSymbol.OriginalTypeDecl); } break; } } //------- //assign bridge information //------- //swap this.typeSymbols = tempSymbols; }
public void RegisterType(string typeName, TypeSymbol tt) { if (_freeze) { if (!(typeName.StartsWith("cef_") && CefResolvingContext.IsAllLowerLetter(typeName))) { Console.WriteLine(typeName); } else { //for cef only! } } typeSymbols.Add(typeName, tt); }
internal TypeSymbol RegisterBaseCToCppTypeSymbol(CodeTypeReference cToCppTypeReference) { #if DEBUG if (!CefResolvingContext.IsAllLowerLetter(cToCppTypeReference.Name)) { //cef-name convention throw new NotSupportedException(); } #endif TypeSymbol found; if (!typeSymbols.TryGetValue(cToCppTypeReference.Name, out found)) { //if not found then create the new simple type found = new SimpleTypeSymbol(cToCppTypeReference.Name); RegisterType(cToCppTypeReference.Name, found); } return(cToCppTypeReference.ResolvedType = found); }
void ResolveTypeMembers() { foreach (CodeTypeDeclaration typedecl in typedeclDic.Values) { foreach (CodeMethodDeclaration metDecl in typedecl.GetMethodIter()) { switch (metDecl.MethodKind) { default: throw new NotSupportedException(); case MethodKind.Ctor: case MethodKind.Dtor: { foreach (CodeMethodParameter p in metDecl.Parameters) { CefResolvingContext resolvingContext = new CefResolvingContext(this, typedecl, ResolvingContextKind.MethodParReturnType); // p.ParameterType.ResolvedType = resolvingContext.ResolveType(p.ParameterType); } } break; case MethodKind.Normal: { //resolve return type and type parameter { CefResolvingContext resolvingContext = new CefResolvingContext(this, typedecl, ResolvingContextKind.MethodParReturnType); // metDecl.ReturnType.ResolvedType = resolvingContext.ResolveType(metDecl.ReturnType); } foreach (CodeMethodParameter p in metDecl.Parameters) { CefResolvingContext resolvingContext = new CefResolvingContext(this, typedecl, ResolvingContextKind.MethodPar); // p.ParameterType.ResolvedType = resolvingContext.ResolveType(p.ParameterType); } } break; } } } }
public void SetTypeSystem(List <CodeCompilationUnit> compilationUnits) { Reset(); //----------------------- this.compilationUnits = compilationUnits; //----------------------- //resolve cu's file path foreach (CodeCompilationUnit cu in compilationUnits) { //check absolute path for include file foreach (IncludeFileDirective includeDirective in cu._includeFiles) { //remove " from begin and end of the original IncludeFile if (includeDirective.SystemFolder) { continue; } // string include_file = includeDirective.IncludeFile.Substring(1, includeDirective.IncludeFile.Length - 2); includeDirective.ResolvedAbsoluteFilePath = RootFolder + "\\" + include_file; //check if (!System.IO.File.Exists(includeDirective.ResolvedAbsoluteFilePath)) { //file not found if (!(includeDirective.ResolvedAbsoluteFilePath.EndsWith("mac.h") || includeDirective.ResolvedAbsoluteFilePath.EndsWith("linux.h"))) { throw new NotSupportedException(); } } } // _compilationUnitDics.Add(cu.Filename, cu); } List <CodeMethodDeclaration> cppMethodList = new List <CodeMethodDeclaration>(); //----------------------- //1. collect foreach (CodeCompilationUnit cu in compilationUnits) { // RegisterTypeDeclaration(cu.GlobalTypeDecl); //extract type from global typedecl foreach (CodeMemberDeclaration mb in cu.GlobalTypeDecl.GetMemberIter()) { switch (mb.MemberKind) { case CodeMemberKind.Method: { //check if this method has C++ explicit ower type CodeMethodDeclaration metDecl = (CodeMethodDeclaration)mb; if (metDecl.CppExplicitOwnerType != null) { //add this to typedecl later cppMethodList.Add(metDecl); } } break; case CodeMemberKind.TypeDef: { CodeCTypeDef ctypeDef = (CodeCTypeDef)mb; // CTypeDefTypeSymbol ctypedefTypeSymbol = new CTypeDefTypeSymbol(ctypeDef.Name, ctypeDef.From); ctypedefTypeSymbol.CreatedTypeCTypeDef = ctypeDef; //--- TypeSymbol existing; if (TryGetType(ctypeDef.Name, out existing)) { throw new NotSupportedException(); } RegisterType(ctypeDef.Name, ctypedefTypeSymbol); } break; case CodeMemberKind.Type: { RegisterTypeDeclaration((CodeTypeDeclaration)mb); } break; } } int typeCount = cu.TypeCount; for (int i = 0; i < typeCount; ++i) { RegisterTypeDeclaration(cu.GetTypeDeclaration(i)); } } //----------------------- //temp fix int methodCount = cppMethodList.Count; if (methodCount > 0) { //find owner and add the implementation for (int i = 0; i < methodCount; ++i) { CodeMethodDeclaration metdecl = cppMethodList[i]; if (metdecl.LineComments != null) { //for cef, some line comment has transformation info } } } //----------------------- ResolveBaseTypes(); ResolveTypeMembers(); //----------------------- AddMoreTypeInfo(); // var cefTypeBridgeTxPlanner = new CefTypeBridgeTransformPlanner(); cefTypeBridgeTxPlanner.AssignTypeBridgeInfo(this.typeSymbols); // this.Planner = cefTypeBridgeTxPlanner; //----------------------- //do class classification foreach (CodeTypeDeclaration t in typedeclDic.Values) { string name = t.Name; if (name.EndsWith("Callback")) { _v_callBackClasses.Add(t); } else if (name.EndsWith("Handler")) { _v_handlerClasses.Add(t); } else if (name.EndsWith("CToCpp")) { //implementation cToCppClasses.Add(t); } else if (name.EndsWith("CppToC")) { //implementation cppToCClasses.Add(t); } else { switch (t.Kind) { default: { if (t.IsGlobalCompilationUnitType) { _fileModuleClasses.Add(t); } else if (t.IsTemplateTypeDefinition) { _templateClasses.Add(t); } else if (t.BaseIsVirtual) { _v_instanceClasses.Add(t); } else { if (t.BaseTypes != null && t.BaseTypes.Count > 0) { CodeTypeReference baseType = t.BaseTypes[0]; if (baseType.ResolvedType != null) { switch (baseType.Name) { default: break; case "CefStructBase": case "CefBaseScoped": case "CefBaseRefCounted": _cefBaseTypes.Add(t); break; } } } else { switch (t.Name) { default: break; case "CefScopedSandboxInfo": case "CefBaseRefCounted": case "CefBaseScoped": case "CefRefCount": break; } } } } break; case TypeKind.Enum: if (!CefResolvingContext.IsAllLowerLetter(name)) { } _enumClasses.Add(t); break; case TypeKind.Struct: if (!CefResolvingContext.IsAllLowerLetter(name)) { if (name.EndsWith("Traits")) { } else { } } _plainCStructs.Add(t); break; } } } //----------------------- //for analysis foreach (CodeTypeDeclaration t in typedeclDic.Values) { TypeSymbol resolvedType = t.ResolvedType; if (t.BaseTypes.Count == 0) { // } else { TypeSymbol baseType = t.BaseTypes[0].ResolvedType; TypeHierarchyNode found; if (!hierarchy.TryGetValue(baseType, out found)) { found = new TypeHierarchyNode(baseType); hierarchy.Add(baseType, found); } if (found.Type != resolvedType) { found.AddTypeSymbol(resolvedType); } } } //----------------------- }