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); }
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); } } } //----------------------- }