public CXChildVisitResult Visit(CXCursor cursor, CXCursor parent, IntPtr data) { if (cursor.IsInSystemHeader()) { return CXChildVisitResult.CXChildVisit_Continue; } var cursorKind = cursor.kind; if (cursorKind == CXCursorKind.CXCursor_MacroDefinition) { var macroName = clang.getCursorSpelling(cursor).ToString(); if (m_visitedMacros.Contains(macroName)) { return CXChildVisitResult.CXChildVisit_Continue; } m_visitedMacros.Add(macroName); var expression = getMacroExpression(cursor); if (string.IsNullOrWhiteSpace(expression)) { return CXChildVisitResult.CXChildVisit_Continue; } m_tw.WriteLine(@"public const int {0} = {1};", macroName, expression); } return CXChildVisitResult.CXChildVisit_Continue; }
public ParameterSyntax PortParameter(CXCursor paramDecl) { string paramName = paramDecl.ToString (); CXType type = clang.getCursorType (paramDecl); // We can't pass void as function parameter if (type.kind == CXTypeKind.CXType_Void) throw new ArgumentException (); var paramId = SF.Identifier (paramName); ParameterSyntax paramSyntax = SF.Parameter (paramId); if (type.kind == CXTypeKind.CXType_ObjCObjectPointer) { type = type.GetPointee (); TypeSyntax typeSyntax = PortType (type); return paramSyntax.WithType (typeSyntax); } if (type.kind == CXTypeKind.CXType_Pointer) { type = type.GetPointee (); if(type.kind == CXTypeKind.CXType_Void) // original type was void* return paramSyntax.WithType(CommonTypes.IntPtrTypeSyntax); TypeSyntax typeSyntax = PortType (type); return paramSyntax.WithType (typeSyntax).WithModifiers (SF.TokenList (SF.Token (SyntaxKind.OutKeyword))); } TypeSyntax ts = PortType (type); return paramSyntax.WithType (ts); }
public void WriteFunction(CXCursor cursor, string prefixStrip) { var functionType = clang.getCursorType(cursor); var functionName = clang.getCursorSpelling(cursor).ToString(); var resultType = clang.getCursorResultType(cursor); m_tw.WriteLine(@"[DllImport({0}, EntryPoint = ""{1}"", CallingConvention = {2})]", m_libraryVarName, functionName, functionType.CallingConventionSpelling()); m_tw.Write(@"public static extern "); FunctionHelper.WriteReturnType(resultType, m_tw); if (functionName.StartsWith(prefixStrip)) { functionName = functionName.Substring(prefixStrip.Length); } m_tw.Write(@" " + functionName + @"("); var numArgTypes = clang.getNumArgTypes(functionType); for (uint i = 0; i < numArgTypes; ++i) { FunctionHelper.WriteArgument(functionType, clang.Cursor_getArgument(cursor, i), m_tw, i); } m_tw.WriteLine(@");"); m_tw.WriteLine(); }
public static string GetTextFromCompoundStmt(CXCursor cursor) { var stmts = cursor.GetChildren (); CXSourceLocation start = clang.getCursorLocation (stmts.First ()); CXSourceLocation end = clang.getRangeEnd (clang.getCursorExtent (stmts.Last ())); CXFile file; uint line1, line2; uint column1, column2; uint offset1, offset2; clang.getFileLocation (start, out file, out line1, out column1, out offset1); clang.getFileLocation (end, out file, out line2, out column2, out offset2); string filePath = clang.getFileName (file).ToString (); // We have to read bytes first and then convert them to utf8 string // because .net string is utf16 char array, but clang handles utf8 src text only. // clang's offset means byte offset (not utf16 char offset) uint count = offset2 - offset1 + 1; byte[] text = new byte[count]; using(FileStream fs = File.OpenRead(filePath)) { fs.Seek (offset1, SeekOrigin.Begin); fs.Read (text, 0, (int)count); } return Encoding.UTF8.GetString (text); }
public TranslationUnitPorter(CXCursor translationUnit, string ns, IBindingLocator bindingLocator) { if (translationUnit.kind != CXCursorKind.CXCursor_TranslationUnit) throw new ArgumentException (); if (string.IsNullOrWhiteSpace (ns)) throw new ArgumentException (); if (bindingLocator == null) throw new ArgumentNullException (); this.translationUnit = translationUnit; this.bindingLocator = bindingLocator; cu = SyntaxFactory.CompilationUnit (); IEnumerable<UsingDirectiveSyntax> usings = CreateUsings (); foreach (var u in usings) cu = cu.AddUsings (u); var nsDecl = CreateNamespace (ns); foreach (var c in PortClasses ()) nsDecl = nsDecl.AddMembers (c); cu = cu.AddMembers (nsDecl); }
private void WriteFunction(CXCursor cursor, string prefixStrip) { var functionType = clang.getCursorType(cursor); var functionName = clang.getCursorSpelling(cursor).ToString(); var resultType = clang.getCursorResultType(cursor); _tw.WriteLine($@"[DllImport({_libraryVarName}, " + $@"EntryPoint = ""{functionName}"", " + $@"CallingConvention = {functionType.CallingConventionSpelling()}, CharSet = CharSet.Ansi)]"); if (resultType.IsPtrToConstChar()) _tw.WriteLine(@"[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(ConstCharPtrMarshaler))]"); _tw.Write(@"public static extern "); FunctionHelper.WriteReturnType(resultType, _tw); if (functionName.StartsWith(prefixStrip)) functionName = functionName.Substring(prefixStrip.Length); _tw.Write(@" " + functionName + @"("); var numArgTypes = clang.getNumArgTypes(functionType); for (uint i = 0; i < numArgTypes; ++i) FunctionHelper.WriteArgument(functionType, clang.Cursor_getArgument(cursor, i), _tw, i); _tw.WriteLine(@");"); _tw.WriteLine(); }
public CXChildVisitResult Visit(CXCursor cursor, CXCursor parent, IntPtr data) { if (cursor.IsInSystemHeader()) { return CXChildVisitResult.CXChildVisit_Continue; } CXCursorKind curKind = clang.getCursorKind(cursor); // look only at function decls if (curKind == CXCursorKind.CXCursor_FunctionDecl) { var functionName = clang.getCursorSpelling(cursor).ToString(); if (this.visitedFunctions.Contains(functionName)) { return CXChildVisitResult.CXChildVisit_Continue; } this.visitedFunctions.Add(functionName); Extensions.WriteFunctionInfoHelper(cursor, this.tw, this.prefixStrip); return CXChildVisitResult.CXChildVisit_Continue; } return CXChildVisitResult.CXChildVisit_Recurse; }
public CXChildVisitResult Visit(CXCursor cursor, CXCursor parent, IntPtr data) { if (cursor.IsInSystemHeader()) { return CXChildVisitResult.CXChildVisit_Continue; } CXCursorKind curKind = clang.getCursorKind(cursor); if (curKind == CXCursorKind.CXCursor_StructDecl) { this.fieldPosition = 0; var structName = clang.getCursorSpelling(cursor).ToString(); // struct names can be empty, and so we visit its sibling to find the name if (string.IsNullOrEmpty(structName)) { var forwardDeclaringVisitor = new ForwardDeclarationVisitor(cursor); clang.visitChildren(clang.getCursorSemanticParent(cursor), forwardDeclaringVisitor.Visit, new CXClientData(IntPtr.Zero)); structName = clang.getCursorSpelling(forwardDeclaringVisitor.ForwardDeclarationCursor).ToString(); if (string.IsNullOrEmpty(structName)) { structName = "_"; } } if (!this.visitedStructs.Contains(structName)) { this.IndentedWriteLine("public partial struct " + structName); this.IndentedWriteLine("{"); this.indentLevel++; clang.visitChildren(cursor, this.Visit, new CXClientData(IntPtr.Zero)); this.indentLevel--; this.IndentedWriteLine("}"); this.tw.WriteLine(); this.visitedStructs.Add(structName); } return CXChildVisitResult.CXChildVisit_Continue; } if (curKind == CXCursorKind.CXCursor_FieldDecl) { var fieldName = clang.getCursorSpelling(cursor).ToString(); if (string.IsNullOrEmpty(fieldName)) { fieldName = "field" + this.fieldPosition; // what if they have fields called field*? :) } this.fieldPosition++; this.IndentedWriteLine(cursor.ToMarshalString(fieldName)); return CXChildVisitResult.CXChildVisit_Continue; } return CXChildVisitResult.CXChildVisit_Recurse; }
public ObjCCategoryImplDeclContext(CXCursor categoryImplDecl) { if (categoryImplDecl.kind != CXCursorKind.CXCursor_ObjCCategoryImplDecl) throw new ArgumentException (); ObjCCategoryImpl = categoryImplDecl; ExtendedClassRef = GetExtendedClass (ObjCCategoryImpl); }
public ObjCImplementationDeclContext(CXCursor cursor) { if (cursor.kind != CXCursorKind.CXCursor_ObjCImplementationDecl) throw new ArgumentException (); ImplCursor = cursor; DeclCursor = clang.getCanonicalCursor (cursor); SuperClassRef = GetSuperClass (DeclCursor); }
public static void ArgumentHelper(CXType functionType, CXCursor paramCursor, TextWriter tw, uint index) { var numArgTypes = clang.getNumArgTypes(functionType); var type = clang.getArgType(functionType, index); var cursorType = clang.getCursorType(paramCursor); var spelling = clang.getCursorSpelling(paramCursor).ToString(); if (string.IsNullOrEmpty(spelling)) { spelling = "param" + index; } switch (type.kind) { case CXTypeKind.CXType_Pointer: var pointee = clang.getPointeeType(type); switch (pointee.kind) { case CXTypeKind.CXType_Pointer: tw.Write(pointee.IsPtrToConstChar() && clang.isConstQualifiedType(pointee) != 0 ? "string[]" : "out IntPtr"); break; case CXTypeKind.CXType_FunctionProto: tw.Write(clang.getTypeSpelling(cursorType).ToString()); break; case CXTypeKind.CXType_Void: tw.Write("IntPtr"); break; case CXTypeKind.CXType_Char_S: tw.Write(type.IsPtrToConstChar() ? "[MarshalAs(UnmanagedType.LPStr)] string" : "IntPtr"); // if it's not a const, it's best to go with IntPtr break; case CXTypeKind.CXType_WChar: tw.Write(type.IsPtrToConstChar() ? "[MarshalAs(UnmanagedType.LPWStr)] string" : "IntPtr"); break; default: CommonTypeHandling(pointee, tw, "out "); break; } break; default: CommonTypeHandling(type, tw); break; } tw.Write(" @"); tw.Write(spelling); if (index != numArgTypes - 1) { tw.Write(", "); } }
public CXChildVisitResult Visit(CXCursor cursor, CXCursor parent, IntPtr data) { if (cursor.IsInSystemHeader()) { return CXChildVisitResult.CXChildVisit_Continue; } var cursorKind = clang.getCursorKind(cursor); // look only at function decls if (cursorKind == CXCursorKind.CXCursor_FunctionDecl) { var functionName = clang.getCursorSpelling(cursor).ToString(); if (m_visitedFunctions.Contains(functionName)) { return CXChildVisitResult.CXChildVisit_Continue; } string libraryName; if (m_exportMap.TryGetValue(functionName, out libraryName)) { if (!string.Equals(libraryName, m_libraryName, StringComparison.InvariantCultureIgnoreCase)) { string message = string.Format(@"Warning: Function {0} belongs to {1}. Skipping generation for {2}.", functionName, libraryName, m_libraryName); Console.WriteLine(message); return CXChildVisitResult.CXChildVisit_Continue; } } else { m_visitedFunctions.Add(functionName); string message = string.Format(@"Info: Unknow function export {0}. Skipping generation for {1}.", functionName, m_libraryName); Console.WriteLine(message); return CXChildVisitResult.CXChildVisit_Continue; } m_visitedFunctions.Add(functionName); WriteFunction(cursor, m_prefixStrip); return CXChildVisitResult.CXChildVisit_Continue; } return CXChildVisitResult.CXChildVisit_Recurse; }
static void Dump(CXCursor cursor, StringBuilder sb, int level, int mask) { for (int i = 1; i <= level; i++) { if (IsSet (mask, level - i)) { if (i == level) sb.Append ("|-"); else sb.Append ("| "); } else { if (i == level) sb.Append ("`-"); else sb.Append (" "); } } sb.AppendFormat ("{0} {1}\n", cursor.kind, cursor.ToString ()); CXCursor[] children = cursor.GetChildren ().ToArray(); for (int i = 0; i < children.Length; i++) Dump (children[i], sb, level + 1, (mask << 1) | (i == children.Length - 1 ? 0 : 1)); }
public CXChildVisitResult Visit(CXCursor cursor, CXCursor parent, IntPtr data) { if (cursor.IsInSystemHeader()) { return CXChildVisitResult.CXChildVisit_Continue; } if (clang.equalCursors(cursor, m_beginningCursor) != 0) { m_beginningCursorReached = true; return CXChildVisitResult.CXChildVisit_Continue; } if (m_beginningCursorReached) { ForwardDeclarationCursor = cursor; return CXChildVisitResult.CXChildVisit_Break; } return CXChildVisitResult.CXChildVisit_Recurse; }
private string getMacroExpression(CXCursor cursor) { var tu = clang.Cursor_getTranslationUnit(cursor); var range = clang.getCursorExtent(cursor); IntPtr pTokens; uint numTokens; clang.tokenize(tu, range, out pTokens, out numTokens); var sbValue = new StringBuilder(); for (var n = 1; n < numTokens; n++) { var offset = n*Marshal.SizeOf<CXToken>(); var token = Marshal.PtrToStructure<CXToken>(pTokens + offset); var tokenKind = clang.getTokenKind(token); if (tokenKind != CXTokenKind.CXToken_Comment) { var spelling = clang.getTokenSpelling(tu, token).ToString(); if (spelling == @"#" || spelling == @"}" || spelling == @"L" || spelling == @"enum" || spelling == @"int" || spelling == @"int8_t" || spelling == @"int64_t" || spelling == @"struct" || spelling == @"typedef") { continue; } sbValue.Append(spelling); } } disposeTokens(tu, pTokens, numTokens); return sbValue.ToString(); }
public static extern void getDefinitionSpellingAndExtent(CXCursor @param0, out IntPtr @startBuf, out IntPtr @endBuf, out uint @startLine, out uint @startColumn, out uint @endLine, out uint @endColumn);
public static extern CXResult findReferencesInFile(CXCursor @cursor, CXFile @file, CXCursorAndRangeVisitor @visitor);
internal CXXDestructorDecl(CXCursor handle) : base(handle, CXCursorKind.CXCursor_Destructor, CX_DeclKind.CX_DeclKind_CXXDestructor) { _operatorDelete = new Lazy <FunctionDecl>(() => TranslationUnit.GetOrCreate <FunctionDecl>(Handle.GetSubDecl(0))); _operatorDeleteThisArg = new Lazy <Expr>(() => TranslationUnit.GetOrCreate <Expr>(Handle.GetExpr(0))); }
public static extern CXSourceRange getCursorReferenceNameRange(CXCursor @C, uint @NameFlags, uint @PieceIndex);
internal GenericSelectionExpr(CXCursor handle) : base(handle, CXCursorKind.CXCursor_GenericSelectionExpr, CX_StmtClass.CX_StmtClass_GenericSelectionExpr) { }
internal CXXThisExpr(CXCursor handle) : base(handle, CXCursorKind.CXCursor_CXXThisExpr, CX_StmtClass.CX_StmtClass_CXXThisExpr) { }
internal AccessSpecDecl(CXCursor handle) : base(handle, CXCursorKind.CXCursor_CXXAccessSpecifier, CX_DeclKind.CX_DeclKind_AccessSpec) { }
internal VarDecl(CXCursor handle) : this(handle, CXCursorKind.CXCursor_VarDecl, CX_DeclKind.CX_DeclKind_Var) { }
internal DoStmt(CXCursor handle) : base(handle, CXCursorKind.CXCursor_DoStmt) { }
internal UnresolvedUsingValueDecl(CXCursor handle) : base(handle, CXCursorKind.CXCursor_UsingDeclaration, CX_DeclKind.CX_DeclKind_UnresolvedUsingValue) { }
internal EnumConstantDecl(CXCursor handle) : base(handle, CXCursorKind.CXCursor_EnumConstantDecl, CX_DeclKind.CX_DeclKind_EnumConstant) { _initExpr = new Lazy <Expr>(() => TranslationUnit.GetOrCreate <Expr>(Handle.InitExpr)); }
internal FieldDecl(CXCursor handle) : this(handle, CXCursorKind.CXCursor_FieldDecl, CX_DeclKind.CX_DeclKind_Field) { }
internal FloatingLiteral(CXCursor handle) : base(handle, CXCursorKind.CXCursor_FloatingLiteral) { }
internal OMPParallelSectionsDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPParallelSectionsDirective) { }
internal DecompositionDecl(CXCursor handle) : base(handle, CXCursorKind.CXCursor_UnexposedDecl, CX_DeclKind.CX_DeclKind_Decomposition) { }
internal OMPBarrierDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPBarrierDirective) { }
internal NonTypeTemplateParmDecl(CXCursor handle) : base(handle, CXCursorKind.CXCursor_NonTypeTemplateParameter) { }
internal CXXStdInitializerListExpr(CXCursor handle) : base(handle, CXCursorKind.CXCursor_UnexposedExpr, CX_StmtClass.CX_StmtClass_CXXStdInitializerListExpr) { Debug.Assert(NumChildren is 1); }
internal OMPDistributeDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPDistributeDirective, CX_StmtClass.CX_StmtClass_OMPDistributeDirective) { }
internal ImportDecl(CXCursor handle) : base(handle, CXCursorKind.CXCursor_ModuleImportDecl, CX_DeclKind.CX_DeclKind_Import) { }
internal OMPTaskgroupDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPTaskgroupDirective, CX_StmtClass.CX_StmtClass_OMPTaskgroupDirective) { }
public static extern CXString Cursor_getBriefCommentText(CXCursor @C);
internal ObjCStringLiteral(CXCursor handle) : base(handle, CXCursorKind.CXCursor_ObjCStringLiteral, CX_StmtClass.CX_StmtClass_ObjCStringLiteral) { }
public static extern CXModule Cursor_getModule(CXCursor @C);
public static extern uint CXXMethod_isVirtual(CXCursor @C);
internal MacroDefinitionRecord(CXCursor handle) : base(handle, CXCursorKind.CXCursor_MacroDefinition) { }
public static extern CXCursorKind getTemplateCursorKind(CXCursor @C);
internal BinaryConditionalOperator(CXCursor handle) : base(handle, CXCursorKind.CXCursor_UnexposedExpr, CX_StmtClass.CX_StmtClass_BinaryConditionalOperator) { }
internal CXXConstCastExpr(CXCursor handle) : base(handle, CXCursorKind.CXCursor_CXXConstCastExpr) { }
public static extern CXSourceRange Cursor_getCommentRange(CXCursor @C);
internal ObjCAtThrowStmt(CXCursor handle) : base(handle, CXCursorKind.CXCursor_ObjCAtThrowStmt, CX_StmtClass.CX_StmtClass_ObjCAtThrowStmt) { }
public static extern CXString Cursor_getMangling(CXCursor @param0);
internal CXXAddrspaceCastExpr(CXCursor handle) : base(handle, CXCursorKind.CXCursor_CXXAddrspaceCastExpr, CX_StmtClass.CX_StmtClass_CXXAddrspaceCastExpr) { }
public static extern uint CXXMethod_isStatic(CXCursor @C);
internal OMPGenericLoopDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPGenericLoopDirective, CX_StmtClass.CX_StmtClass_OMPGenericLoopDirective) { }
public static extern uint CXXMethod_isConst(CXCursor @C);
internal MemberExpr(CXCursor handle) : base(handle, CXCursorKind.CXCursor_MemberRefExpr, CX_StmtClass.CX_StmtClass_MemberExpr) { }
public static extern CXCursor getSpecializedCursorTemplate(CXCursor @C);
internal CXXNoexceptExpr(CXCursor handle) : base(handle, CXCursorKind.CXCursor_UnaryExpr, CX_StmtClass.CX_StmtClass_CXXNoexceptExpr) { Debug.Assert(NumChildren is 1); }
public static extern void annotateTokens(CXTranslationUnit @TU, out CXToken @Tokens, uint @NumTokens, out CXCursor @Cursors);
internal NamespaceAliasDecl(CXCursor handle) : base(handle, CXCursorKind.CXCursor_NamespaceAlias, CX_DeclKind.CX_DeclKind_NamespaceAlias) { _aliasedNamespace = new Lazy <NamedDecl>(() => TranslationUnit.GetOrCreate <NamedDecl>(Handle.GetSubDecl(0))); _namespace = new Lazy <NamespaceDecl>(() => TranslationUnit.GetOrCreate <NamespaceDecl>(Handle.GetSubDecl(1))); }
public static extern CXCompletionString getCursorCompletionString(CXCursor @cursor);
internal CXXThisExpr(CXCursor handle) : base(handle, CXCursorKind.CXCursor_CXXThisExpr) { }
public static extern CXComment Cursor_getParsedComment(CXCursor @C);
internal OMPTaskDirective(CXCursor handle) : base(handle, CXCursorKind.CXCursor_OMPTaskDirective) { }