diff --git a/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/clang.kt b/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/clang.kt index 80309266321..bfd1a93bceb 100644 --- a/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/clang.kt +++ b/Interop/Indexer/prebuilt/nativeInteropStubs/kotlin/clang/clang.kt @@ -2,10 +2,12 @@ package clang import kotlinx.cinterop.* -fun asctime(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.asctime(_arg0) - return interpretCPointer(res) +fun asctime(arg0: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.asctime(_arg0) + interpretCPointer(res) + } } fun clock(): clock_t { @@ -13,10 +15,12 @@ fun clock(): clock_t { return res } -fun ctime(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.ctime(_arg0) - return interpretCPointer(res) +fun ctime(arg0: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.ctime(_arg0) + interpretCPointer(res) + } } fun difftime(arg0: time_t, arg1: time_t): Double { @@ -28,55 +32,63 @@ fun difftime(arg0: time_t, arg1: time_t): Double { fun getdate(arg0: String?): CPointer? { return memScoped { - val _arg0 = arg0?.toCString(memScope).rawPtr + val _arg0 = arg0?.cstr?.getPointer(memScope).rawValue val res = externals.getdate(_arg0) interpretCPointer(res) } } -fun gmtime(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.gmtime(_arg0) - return interpretCPointer(res) -} - -fun localtime(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.localtime(_arg0) - return interpretCPointer(res) -} - -fun mktime(arg0: CPointer?): time_t { - val _arg0 = arg0.rawValue - val res = externals.mktime(_arg0) - return res -} - -fun strftime(arg0: String?, arg1: size_t, arg2: String?, arg3: CPointer?): size_t { +fun gmtime(arg0: CValuesRef?): CPointer? { return memScoped { - val _arg0 = arg0?.toCString(memScope).rawPtr + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.gmtime(_arg0) + interpretCPointer(res) + } +} + +fun localtime(arg0: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.localtime(_arg0) + interpretCPointer(res) + } +} + +fun mktime(arg0: CValuesRef?): time_t { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.mktime(_arg0) + res + } +} + +fun strftime(arg0: CValuesRef?, arg1: size_t, arg2: String?, arg3: CValuesRef?): size_t { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue val _arg1 = arg1 - val _arg2 = arg2?.toCString(memScope).rawPtr - val _arg3 = arg3.rawValue + val _arg2 = arg2?.cstr?.getPointer(memScope).rawValue + val _arg3 = arg3?.getPointer(memScope).rawValue val res = externals.strftime(_arg0, _arg1, _arg2, _arg3) res } } -fun strptime(arg0: String?, arg1: String?, arg2: CPointer?): CPointer? { +fun strptime(arg0: String?, arg1: String?, arg2: CValuesRef?): CPointer? { return memScoped { - val _arg0 = arg0?.toCString(memScope).rawPtr - val _arg1 = arg1?.toCString(memScope).rawPtr - val _arg2 = arg2.rawValue + val _arg0 = arg0?.cstr?.getPointer(memScope).rawValue + val _arg1 = arg1?.cstr?.getPointer(memScope).rawValue + val _arg2 = arg2?.getPointer(memScope).rawValue val res = externals.strptime(_arg0, _arg1, _arg2) interpretCPointer(res) } } -fun time(arg0: CPointer?): time_t { - val _arg0 = arg0.rawValue - val res = externals.time(_arg0) - return res +fun time(arg0: CValuesRef?): time_t { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.time(_arg0) + res + } } fun tzset(): Unit { @@ -84,36 +96,40 @@ fun tzset(): Unit { return res } -fun asctime_r(arg0: CPointer?, arg1: String?): CPointer? { +fun asctime_r(arg0: CValuesRef?, arg1: CValuesRef?): CPointer? { return memScoped { - val _arg0 = arg0.rawValue - val _arg1 = arg1?.toCString(memScope).rawPtr + val _arg0 = arg0?.getPointer(memScope).rawValue + val _arg1 = arg1?.getPointer(memScope).rawValue val res = externals.asctime_r(_arg0, _arg1) interpretCPointer(res) } } -fun ctime_r(arg0: CPointer?, arg1: String?): CPointer? { +fun ctime_r(arg0: CValuesRef?, arg1: CValuesRef?): CPointer? { return memScoped { - val _arg0 = arg0.rawValue - val _arg1 = arg1?.toCString(memScope).rawPtr + val _arg0 = arg0?.getPointer(memScope).rawValue + val _arg1 = arg1?.getPointer(memScope).rawValue val res = externals.ctime_r(_arg0, _arg1) interpretCPointer(res) } } -fun gmtime_r(arg0: CPointer?, arg1: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val _arg1 = arg1.rawValue - val res = externals.gmtime_r(_arg0, _arg1) - return interpretCPointer(res) +fun gmtime_r(arg0: CValuesRef?, arg1: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val _arg1 = arg1?.getPointer(memScope).rawValue + val res = externals.gmtime_r(_arg0, _arg1) + interpretCPointer(res) + } } -fun localtime_r(arg0: CPointer?, arg1: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val _arg1 = arg1.rawValue - val res = externals.localtime_r(_arg0, _arg1) - return interpretCPointer(res) +fun localtime_r(arg0: CValuesRef?, arg1: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val _arg1 = arg1?.getPointer(memScope).rawValue + val res = externals.localtime_r(_arg0, _arg1) + interpretCPointer(res) + } } fun posix2time(arg0: time_t): time_t { @@ -133,37 +149,47 @@ fun time2posix(arg0: time_t): time_t { return res } -fun timelocal(arg0: CPointer?): time_t { - val _arg0 = arg0.rawValue - val res = externals.timelocal(_arg0) - return res +fun timelocal(arg0: CValuesRef?): time_t { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.timelocal(_arg0) + res + } } -fun timegm(arg0: CPointer?): time_t { - val _arg0 = arg0.rawValue - val res = externals.timegm(_arg0) - return res +fun timegm(arg0: CValuesRef?): time_t { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.timegm(_arg0) + res + } } -fun nanosleep(__rqtp: CPointer?, __rmtp: CPointer?): Int { - val ___rqtp = __rqtp.rawValue - val ___rmtp = __rmtp.rawValue - val res = externals.nanosleep(___rqtp, ___rmtp) - return res +fun nanosleep(__rqtp: CValuesRef?, __rmtp: CValuesRef?): Int { + return memScoped { + val ___rqtp = __rqtp?.getPointer(memScope).rawValue + val ___rmtp = __rmtp?.getPointer(memScope).rawValue + val res = externals.nanosleep(___rqtp, ___rmtp) + res + } } -fun clock_getres(__clock_id: clockid_t, __res: CPointer?): Int { - val ___clock_id = __clock_id - val ___res = __res.rawValue - val res = externals.clock_getres(___clock_id, ___res) - return res +fun clock_getres(__clock_id: clockid_t, __res: CValuesRef?): Int { + return memScoped { + val ___clock_id = __clock_id + val ___res = __res?.getPointer(memScope).rawValue + val res = externals.clock_getres(___clock_id, ___res) + res + } } -fun clock_gettime(__clock_id: clockid_t, __tp: CPointer?): Int { - val ___clock_id = __clock_id - val ___tp = __tp.rawValue - val res = externals.clock_gettime(___clock_id, ___tp) - return res +fun clock_gettime(__clock_id: clockid_t, __tp: CValuesRef?): Int { + return memScoped { + val ___clock_id = __clock_id + val ___tp = __tp?.getPointer(memScope).rawValue + val res = externals.clock_gettime(___clock_id, ___tp) + res + } } fun clock_gettime_nsec_np(__clock_id: clockid_t): __uint64_t { @@ -172,29 +198,37 @@ fun clock_gettime_nsec_np(__clock_id: clockid_t): __uint64_t { return res } -fun clock_settime(__clock_id: clockid_t, __tp: CPointer?): Int { - val ___clock_id = __clock_id - val ___tp = __tp.rawValue - val res = externals.clock_settime(___clock_id, ___tp) - return res +fun clock_settime(__clock_id: clockid_t, __tp: CValuesRef?): Int { + return memScoped { + val ___clock_id = __clock_id + val ___tp = __tp?.getPointer(memScope).rawValue + val res = externals.clock_settime(___clock_id, ___tp) + res + } } -fun clang_getCString(string: CXString): CPointer? { - val _string = string.rawPtr - val res = externals.clang_getCString(_string) - return interpretCPointer(res) +fun clang_getCString(string: CValue): CPointer? { + return memScoped { + val _string = string.getPointer(memScope).rawValue + val res = externals.clang_getCString(_string) + interpretCPointer(res) + } } -fun clang_disposeString(string: CXString): Unit { - val _string = string.rawPtr - val res = externals.clang_disposeString(_string) - return res +fun clang_disposeString(string: CValue): Unit { + return memScoped { + val _string = string.getPointer(memScope).rawValue + val res = externals.clang_disposeString(_string) + res + } } -fun clang_disposeStringSet(set: CPointer?): Unit { - val _set = set.rawValue - val res = externals.clang_disposeStringSet(_set) - return res +fun clang_disposeStringSet(set: CValuesRef?): Unit { + return memScoped { + val _set = set?.getPointer(memScope).rawValue + val res = externals.clang_disposeStringSet(_set) + res + } } fun clang_getBuildSessionTimestamp(): Long { @@ -211,8 +245,8 @@ fun clang_VirtualFileOverlay_create(options: Int): CXVirtualFileOverlay? { fun clang_VirtualFileOverlay_addFileMapping(arg0: CXVirtualFileOverlay?, virtualPath: String?, realPath: String?): CXErrorCode { return memScoped { val _arg0 = arg0.rawValue - val _virtualPath = virtualPath?.toCString(memScope).rawPtr - val _realPath = realPath?.toCString(memScope).rawPtr + val _virtualPath = virtualPath?.cstr?.getPointer(memScope).rawValue + val _realPath = realPath?.cstr?.getPointer(memScope).rawValue val res = externals.clang_VirtualFileOverlay_addFileMapping(_arg0, _virtualPath, _realPath) CXErrorCode.byValue(res) } @@ -225,13 +259,15 @@ fun clang_VirtualFileOverlay_setCaseSensitivity(arg0: CXVirtualFileOverlay?, cas return CXErrorCode.byValue(res) } -fun clang_VirtualFileOverlay_writeToBuffer(arg0: CXVirtualFileOverlay?, options: Int, out_buffer_ptr: CPointer>?, out_buffer_size: CPointer?): CXErrorCode { - val _arg0 = arg0.rawValue - val _options = options - val _out_buffer_ptr = out_buffer_ptr.rawValue - val _out_buffer_size = out_buffer_size.rawValue - val res = externals.clang_VirtualFileOverlay_writeToBuffer(_arg0, _options, _out_buffer_ptr, _out_buffer_size) - return CXErrorCode.byValue(res) +fun clang_VirtualFileOverlay_writeToBuffer(arg0: CXVirtualFileOverlay?, options: Int, out_buffer_ptr: CValuesRef>?, out_buffer_size: CValuesRef?): CXErrorCode { + return memScoped { + val _arg0 = arg0.rawValue + val _options = options + val _out_buffer_ptr = out_buffer_ptr?.getPointer(memScope).rawValue + val _out_buffer_size = out_buffer_size?.getPointer(memScope).rawValue + val res = externals.clang_VirtualFileOverlay_writeToBuffer(_arg0, _options, _out_buffer_ptr, _out_buffer_size) + CXErrorCode.byValue(res) + } } fun clang_free(buffer: COpaquePointer?): Unit { @@ -255,7 +291,7 @@ fun clang_ModuleMapDescriptor_create(options: Int): CXModuleMapDescriptor? { fun clang_ModuleMapDescriptor_setFrameworkModuleName(arg0: CXModuleMapDescriptor?, name: String?): CXErrorCode { return memScoped { val _arg0 = arg0.rawValue - val _name = name?.toCString(memScope).rawPtr + val _name = name?.cstr?.getPointer(memScope).rawValue val res = externals.clang_ModuleMapDescriptor_setFrameworkModuleName(_arg0, _name) CXErrorCode.byValue(res) } @@ -264,19 +300,21 @@ fun clang_ModuleMapDescriptor_setFrameworkModuleName(arg0: CXModuleMapDescriptor fun clang_ModuleMapDescriptor_setUmbrellaHeader(arg0: CXModuleMapDescriptor?, name: String?): CXErrorCode { return memScoped { val _arg0 = arg0.rawValue - val _name = name?.toCString(memScope).rawPtr + val _name = name?.cstr?.getPointer(memScope).rawValue val res = externals.clang_ModuleMapDescriptor_setUmbrellaHeader(_arg0, _name) CXErrorCode.byValue(res) } } -fun clang_ModuleMapDescriptor_writeToBuffer(arg0: CXModuleMapDescriptor?, options: Int, out_buffer_ptr: CPointer>?, out_buffer_size: CPointer?): CXErrorCode { - val _arg0 = arg0.rawValue - val _options = options - val _out_buffer_ptr = out_buffer_ptr.rawValue - val _out_buffer_size = out_buffer_size.rawValue - val res = externals.clang_ModuleMapDescriptor_writeToBuffer(_arg0, _options, _out_buffer_ptr, _out_buffer_size) - return CXErrorCode.byValue(res) +fun clang_ModuleMapDescriptor_writeToBuffer(arg0: CXModuleMapDescriptor?, options: Int, out_buffer_ptr: CValuesRef>?, out_buffer_size: CValuesRef?): CXErrorCode { + return memScoped { + val _arg0 = arg0.rawValue + val _options = options + val _out_buffer_ptr = out_buffer_ptr?.getPointer(memScope).rawValue + val _out_buffer_size = out_buffer_size?.getPointer(memScope).rawValue + val res = externals.clang_ModuleMapDescriptor_writeToBuffer(_arg0, _options, _out_buffer_ptr, _out_buffer_size) + CXErrorCode.byValue(res) + } } fun clang_ModuleMapDescriptor_dispose(arg0: CXModuleMapDescriptor?): Unit { @@ -311,11 +349,12 @@ fun clang_CXIndex_getGlobalOptions(arg0: CXIndex?): Int { return res } -fun clang_getFileName(SFile: CXFile?, retValPlacement: NativePlacement): CXString { - val _SFile = SFile.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getFileName(_SFile, _retValPlacement) - return interpretPointed(res) +fun clang_getFileName(SFile: CXFile?): CValue { + return memScoped { + val _SFile = SFile.rawValue + val res = externals.clang_getFileName(_SFile, alloc().rawPtr) + interpretPointed(res).readValue() + } } fun clang_getFileTime(SFile: CXFile?): time_t { @@ -324,11 +363,13 @@ fun clang_getFileTime(SFile: CXFile?): time_t { return res } -fun clang_getFileUniqueID(file: CXFile?, outID: CPointer?): Int { - val _file = file.rawValue - val _outID = outID.rawValue - val res = externals.clang_getFileUniqueID(_file, _outID) - return res +fun clang_getFileUniqueID(file: CXFile?, outID: CValuesRef?): Int { + return memScoped { + val _file = file.rawValue + val _outID = outID?.getPointer(memScope).rawValue + val res = externals.clang_getFileUniqueID(_file, _outID) + res + } } fun clang_isFileMultipleIncludeGuarded(tu: CXTranslationUnit?, file: CXFile?): Int { @@ -341,7 +382,7 @@ fun clang_isFileMultipleIncludeGuarded(tu: CXTranslationUnit?, file: CXFile?): I fun clang_getFile(tu: CXTranslationUnit?, file_name: String?): CXFile? { return memScoped { val _tu = tu.rawValue - val _file_name = file_name?.toCString(memScope).rawPtr + val _file_name = file_name?.cstr?.getPointer(memScope).rawValue val res = externals.clang_getFile(_tu, _file_name) interpretCPointer(res) } @@ -354,138 +395,165 @@ fun clang_File_isEqual(file1: CXFile?, file2: CXFile?): Int { return res } -fun clang_getNullLocation(retValPlacement: NativePlacement): CXSourceLocation { - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getNullLocation(_retValPlacement) - return interpretPointed(res) +fun clang_getNullLocation(): CValue { + return memScoped { + val res = externals.clang_getNullLocation(alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_equalLocations(loc1: CXSourceLocation, loc2: CXSourceLocation): Int { - val _loc1 = loc1.rawPtr - val _loc2 = loc2.rawPtr - val res = externals.clang_equalLocations(_loc1, _loc2) - return res +fun clang_equalLocations(loc1: CValue, loc2: CValue): Int { + return memScoped { + val _loc1 = loc1.getPointer(memScope).rawValue + val _loc2 = loc2.getPointer(memScope).rawValue + val res = externals.clang_equalLocations(_loc1, _loc2) + res + } } -fun clang_getLocation(tu: CXTranslationUnit?, file: CXFile?, line: Int, column: Int, retValPlacement: NativePlacement): CXSourceLocation { - val _tu = tu.rawValue - val _file = file.rawValue - val _line = line - val _column = column - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getLocation(_tu, _file, _line, _column, _retValPlacement) - return interpretPointed(res) +fun clang_getLocation(tu: CXTranslationUnit?, file: CXFile?, line: Int, column: Int): CValue { + return memScoped { + val _tu = tu.rawValue + val _file = file.rawValue + val _line = line + val _column = column + val res = externals.clang_getLocation(_tu, _file, _line, _column, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getLocationForOffset(tu: CXTranslationUnit?, file: CXFile?, offset: Int, retValPlacement: NativePlacement): CXSourceLocation { - val _tu = tu.rawValue - val _file = file.rawValue - val _offset = offset - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getLocationForOffset(_tu, _file, _offset, _retValPlacement) - return interpretPointed(res) +fun clang_getLocationForOffset(tu: CXTranslationUnit?, file: CXFile?, offset: Int): CValue { + return memScoped { + val _tu = tu.rawValue + val _file = file.rawValue + val _offset = offset + val res = externals.clang_getLocationForOffset(_tu, _file, _offset, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_Location_isInSystemHeader(location: CXSourceLocation): Int { - val _location = location.rawPtr - val res = externals.clang_Location_isInSystemHeader(_location) - return res +fun clang_Location_isInSystemHeader(location: CValue): Int { + return memScoped { + val _location = location.getPointer(memScope).rawValue + val res = externals.clang_Location_isInSystemHeader(_location) + res + } } -fun clang_Location_isFromMainFile(location: CXSourceLocation): Int { - val _location = location.rawPtr - val res = externals.clang_Location_isFromMainFile(_location) - return res +fun clang_Location_isFromMainFile(location: CValue): Int { + return memScoped { + val _location = location.getPointer(memScope).rawValue + val res = externals.clang_Location_isFromMainFile(_location) + res + } } -fun clang_getNullRange(retValPlacement: NativePlacement): CXSourceRange { - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getNullRange(_retValPlacement) - return interpretPointed(res) +fun clang_getNullRange(): CValue { + return memScoped { + val res = externals.clang_getNullRange(alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getRange(begin: CXSourceLocation, end: CXSourceLocation, retValPlacement: NativePlacement): CXSourceRange { - val _begin = begin.rawPtr - val _end = end.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getRange(_begin, _end, _retValPlacement) - return interpretPointed(res) +fun clang_getRange(begin: CValue, end: CValue): CValue { + return memScoped { + val _begin = begin.getPointer(memScope).rawValue + val _end = end.getPointer(memScope).rawValue + val res = externals.clang_getRange(_begin, _end, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_equalRanges(range1: CXSourceRange, range2: CXSourceRange): Int { - val _range1 = range1.rawPtr - val _range2 = range2.rawPtr - val res = externals.clang_equalRanges(_range1, _range2) - return res +fun clang_equalRanges(range1: CValue, range2: CValue): Int { + return memScoped { + val _range1 = range1.getPointer(memScope).rawValue + val _range2 = range2.getPointer(memScope).rawValue + val res = externals.clang_equalRanges(_range1, _range2) + res + } } -fun clang_Range_isNull(range: CXSourceRange): Int { - val _range = range.rawPtr - val res = externals.clang_Range_isNull(_range) - return res +fun clang_Range_isNull(range: CValue): Int { + return memScoped { + val _range = range.getPointer(memScope).rawValue + val res = externals.clang_Range_isNull(_range) + res + } } -fun clang_getExpansionLocation(location: CXSourceLocation, file: CPointer?, line: CPointer?, column: CPointer?, offset: CPointer?): Unit { - val _location = location.rawPtr - val _file = file.rawValue - val _line = line.rawValue - val _column = column.rawValue - val _offset = offset.rawValue - val res = externals.clang_getExpansionLocation(_location, _file, _line, _column, _offset) - return res +fun clang_getExpansionLocation(location: CValue, file: CValuesRef?, line: CValuesRef?, column: CValuesRef?, offset: CValuesRef?): Unit { + return memScoped { + val _location = location.getPointer(memScope).rawValue + val _file = file?.getPointer(memScope).rawValue + val _line = line?.getPointer(memScope).rawValue + val _column = column?.getPointer(memScope).rawValue + val _offset = offset?.getPointer(memScope).rawValue + val res = externals.clang_getExpansionLocation(_location, _file, _line, _column, _offset) + res + } } -fun clang_getPresumedLocation(location: CXSourceLocation, filename: CPointer?, line: CPointer?, column: CPointer?): Unit { - val _location = location.rawPtr - val _filename = filename.rawValue - val _line = line.rawValue - val _column = column.rawValue - val res = externals.clang_getPresumedLocation(_location, _filename, _line, _column) - return res +fun clang_getPresumedLocation(location: CValue, filename: CValuesRef?, line: CValuesRef?, column: CValuesRef?): Unit { + return memScoped { + val _location = location.getPointer(memScope).rawValue + val _filename = filename?.getPointer(memScope).rawValue + val _line = line?.getPointer(memScope).rawValue + val _column = column?.getPointer(memScope).rawValue + val res = externals.clang_getPresumedLocation(_location, _filename, _line, _column) + res + } } -fun clang_getInstantiationLocation(location: CXSourceLocation, file: CPointer?, line: CPointer?, column: CPointer?, offset: CPointer?): Unit { - val _location = location.rawPtr - val _file = file.rawValue - val _line = line.rawValue - val _column = column.rawValue - val _offset = offset.rawValue - val res = externals.clang_getInstantiationLocation(_location, _file, _line, _column, _offset) - return res +fun clang_getInstantiationLocation(location: CValue, file: CValuesRef?, line: CValuesRef?, column: CValuesRef?, offset: CValuesRef?): Unit { + return memScoped { + val _location = location.getPointer(memScope).rawValue + val _file = file?.getPointer(memScope).rawValue + val _line = line?.getPointer(memScope).rawValue + val _column = column?.getPointer(memScope).rawValue + val _offset = offset?.getPointer(memScope).rawValue + val res = externals.clang_getInstantiationLocation(_location, _file, _line, _column, _offset) + res + } } -fun clang_getSpellingLocation(location: CXSourceLocation, file: CPointer?, line: CPointer?, column: CPointer?, offset: CPointer?): Unit { - val _location = location.rawPtr - val _file = file.rawValue - val _line = line.rawValue - val _column = column.rawValue - val _offset = offset.rawValue - val res = externals.clang_getSpellingLocation(_location, _file, _line, _column, _offset) - return res +fun clang_getSpellingLocation(location: CValue, file: CValuesRef?, line: CValuesRef?, column: CValuesRef?, offset: CValuesRef?): Unit { + return memScoped { + val _location = location.getPointer(memScope).rawValue + val _file = file?.getPointer(memScope).rawValue + val _line = line?.getPointer(memScope).rawValue + val _column = column?.getPointer(memScope).rawValue + val _offset = offset?.getPointer(memScope).rawValue + val res = externals.clang_getSpellingLocation(_location, _file, _line, _column, _offset) + res + } } -fun clang_getFileLocation(location: CXSourceLocation, file: CPointer?, line: CPointer?, column: CPointer?, offset: CPointer?): Unit { - val _location = location.rawPtr - val _file = file.rawValue - val _line = line.rawValue - val _column = column.rawValue - val _offset = offset.rawValue - val res = externals.clang_getFileLocation(_location, _file, _line, _column, _offset) - return res +fun clang_getFileLocation(location: CValue, file: CValuesRef?, line: CValuesRef?, column: CValuesRef?, offset: CValuesRef?): Unit { + return memScoped { + val _location = location.getPointer(memScope).rawValue + val _file = file?.getPointer(memScope).rawValue + val _line = line?.getPointer(memScope).rawValue + val _column = column?.getPointer(memScope).rawValue + val _offset = offset?.getPointer(memScope).rawValue + val res = externals.clang_getFileLocation(_location, _file, _line, _column, _offset) + res + } } -fun clang_getRangeStart(range: CXSourceRange, retValPlacement: NativePlacement): CXSourceLocation { - val _range = range.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getRangeStart(_range, _retValPlacement) - return interpretPointed(res) +fun clang_getRangeStart(range: CValue): CValue { + return memScoped { + val _range = range.getPointer(memScope).rawValue + val res = externals.clang_getRangeStart(_range, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getRangeEnd(range: CXSourceRange, retValPlacement: NativePlacement): CXSourceLocation { - val _range = range.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getRangeEnd(_range, _retValPlacement) - return interpretPointed(res) +fun clang_getRangeEnd(range: CValue): CValue { + return memScoped { + val _range = range.getPointer(memScope).rawValue + val res = externals.clang_getRangeEnd(_range, alloc().rawPtr) + interpretPointed(res).readValue() + } } fun clang_getSkippedRanges(tu: CXTranslationUnit?, file: CXFile?): CPointer? { @@ -495,10 +563,12 @@ fun clang_getSkippedRanges(tu: CXTranslationUnit?, file: CXFile?): CPointer(res) } -fun clang_disposeSourceRangeList(ranges: CPointer?): Unit { - val _ranges = ranges.rawValue - val res = externals.clang_disposeSourceRangeList(_ranges) - return res +fun clang_disposeSourceRangeList(ranges: CValuesRef?): Unit { + return memScoped { + val _ranges = ranges?.getPointer(memScope).rawValue + val res = externals.clang_disposeSourceRangeList(_ranges) + res + } } fun clang_getNumDiagnosticsInSet(Diags: CXDiagnosticSet?): Int { @@ -514,11 +584,11 @@ fun clang_getDiagnosticInSet(Diags: CXDiagnosticSet?, Index: Int): CXDiagnostic? return interpretCPointer(res) } -fun clang_loadDiagnostics(file: String?, error: CPointer?, errorString: CPointer?): CXDiagnosticSet? { +fun clang_loadDiagnostics(file: String?, error: CValuesRef?, errorString: CValuesRef?): CXDiagnosticSet? { return memScoped { - val _file = file?.toCString(memScope).rawPtr - val _error = error.rawValue - val _errorString = errorString.rawValue + val _file = file?.cstr?.getPointer(memScope).rawValue + val _error = error?.getPointer(memScope).rawValue + val _errorString = errorString?.getPointer(memScope).rawValue val res = externals.clang_loadDiagnostics(_file, _error, _errorString) interpretCPointer(res) } @@ -561,12 +631,13 @@ fun clang_disposeDiagnostic(Diagnostic: CXDiagnostic?): Unit { return res } -fun clang_formatDiagnostic(Diagnostic: CXDiagnostic?, Options: Int, retValPlacement: NativePlacement): CXString { - val _Diagnostic = Diagnostic.rawValue - val _Options = Options - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_formatDiagnostic(_Diagnostic, _Options, _retValPlacement) - return interpretPointed(res) +fun clang_formatDiagnostic(Diagnostic: CXDiagnostic?, Options: Int): CValue { + return memScoped { + val _Diagnostic = Diagnostic.rawValue + val _Options = Options + val res = externals.clang_formatDiagnostic(_Diagnostic, _Options, alloc().rawPtr) + interpretPointed(res).readValue() + } } fun clang_defaultDiagnosticDisplayOptions(): Int { @@ -580,26 +651,29 @@ fun clang_getDiagnosticSeverity(arg0: CXDiagnostic?): CXDiagnosticSeverity { return CXDiagnosticSeverity.byValue(res) } -fun clang_getDiagnosticLocation(arg0: CXDiagnostic?, retValPlacement: NativePlacement): CXSourceLocation { - val _arg0 = arg0.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getDiagnosticLocation(_arg0, _retValPlacement) - return interpretPointed(res) +fun clang_getDiagnosticLocation(arg0: CXDiagnostic?): CValue { + return memScoped { + val _arg0 = arg0.rawValue + val res = externals.clang_getDiagnosticLocation(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getDiagnosticSpelling(arg0: CXDiagnostic?, retValPlacement: NativePlacement): CXString { - val _arg0 = arg0.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getDiagnosticSpelling(_arg0, _retValPlacement) - return interpretPointed(res) +fun clang_getDiagnosticSpelling(arg0: CXDiagnostic?): CValue { + return memScoped { + val _arg0 = arg0.rawValue + val res = externals.clang_getDiagnosticSpelling(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getDiagnosticOption(Diag: CXDiagnostic?, Disable: CPointer?, retValPlacement: NativePlacement): CXString { - val _Diag = Diag.rawValue - val _Disable = Disable.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getDiagnosticOption(_Diag, _Disable, _retValPlacement) - return interpretPointed(res) +fun clang_getDiagnosticOption(Diag: CXDiagnostic?, Disable: CValuesRef?): CValue { + return memScoped { + val _Diag = Diag.rawValue + val _Disable = Disable?.getPointer(memScope).rawValue + val res = externals.clang_getDiagnosticOption(_Diag, _Disable, alloc().rawPtr) + interpretPointed(res).readValue() + } } fun clang_getDiagnosticCategory(arg0: CXDiagnostic?): Int { @@ -608,18 +682,20 @@ fun clang_getDiagnosticCategory(arg0: CXDiagnostic?): Int { return res } -fun clang_getDiagnosticCategoryName(Category: Int, retValPlacement: NativePlacement): CXString { - val _Category = Category - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getDiagnosticCategoryName(_Category, _retValPlacement) - return interpretPointed(res) +fun clang_getDiagnosticCategoryName(Category: Int): CValue { + return memScoped { + val _Category = Category + val res = externals.clang_getDiagnosticCategoryName(_Category, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getDiagnosticCategoryText(arg0: CXDiagnostic?, retValPlacement: NativePlacement): CXString { - val _arg0 = arg0.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getDiagnosticCategoryText(_arg0, _retValPlacement) - return interpretPointed(res) +fun clang_getDiagnosticCategoryText(arg0: CXDiagnostic?): CValue { + return memScoped { + val _arg0 = arg0.rawValue + val res = externals.clang_getDiagnosticCategoryText(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } } fun clang_getDiagnosticNumRanges(arg0: CXDiagnostic?): Int { @@ -628,12 +704,13 @@ fun clang_getDiagnosticNumRanges(arg0: CXDiagnostic?): Int { return res } -fun clang_getDiagnosticRange(Diagnostic: CXDiagnostic?, Range: Int, retValPlacement: NativePlacement): CXSourceRange { - val _Diagnostic = Diagnostic.rawValue - val _Range = Range - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getDiagnosticRange(_Diagnostic, _Range, _retValPlacement) - return interpretPointed(res) +fun clang_getDiagnosticRange(Diagnostic: CXDiagnostic?, Range: Int): CValue { + return memScoped { + val _Diagnostic = Diagnostic.rawValue + val _Range = Range + val res = externals.clang_getDiagnosticRange(_Diagnostic, _Range, alloc().rawPtr) + interpretPointed(res).readValue() + } } fun clang_getDiagnosticNumFixIts(Diagnostic: CXDiagnostic?): Int { @@ -642,30 +719,32 @@ fun clang_getDiagnosticNumFixIts(Diagnostic: CXDiagnostic?): Int { return res } -fun clang_getDiagnosticFixIt(Diagnostic: CXDiagnostic?, FixIt: Int, ReplacementRange: CPointer?, retValPlacement: NativePlacement): CXString { - val _Diagnostic = Diagnostic.rawValue - val _FixIt = FixIt - val _ReplacementRange = ReplacementRange.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getDiagnosticFixIt(_Diagnostic, _FixIt, _ReplacementRange, _retValPlacement) - return interpretPointed(res) +fun clang_getDiagnosticFixIt(Diagnostic: CXDiagnostic?, FixIt: Int, ReplacementRange: CValuesRef?): CValue { + return memScoped { + val _Diagnostic = Diagnostic.rawValue + val _FixIt = FixIt + val _ReplacementRange = ReplacementRange?.getPointer(memScope).rawValue + val res = externals.clang_getDiagnosticFixIt(_Diagnostic, _FixIt, _ReplacementRange, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getTranslationUnitSpelling(CTUnit: CXTranslationUnit?, retValPlacement: NativePlacement): CXString { - val _CTUnit = CTUnit.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getTranslationUnitSpelling(_CTUnit, _retValPlacement) - return interpretPointed(res) +fun clang_getTranslationUnitSpelling(CTUnit: CXTranslationUnit?): CValue { + return memScoped { + val _CTUnit = CTUnit.rawValue + val res = externals.clang_getTranslationUnitSpelling(_CTUnit, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_createTranslationUnitFromSourceFile(CIdx: CXIndex?, source_filename: String?, num_clang_command_line_args: Int, clang_command_line_args: CPointer>?, num_unsaved_files: Int, unsaved_files: CPointer?): CXTranslationUnit? { +fun clang_createTranslationUnitFromSourceFile(CIdx: CXIndex?, source_filename: String?, num_clang_command_line_args: Int, clang_command_line_args: CValuesRef>?, num_unsaved_files: Int, unsaved_files: CValuesRef?): CXTranslationUnit? { return memScoped { val _CIdx = CIdx.rawValue - val _source_filename = source_filename?.toCString(memScope).rawPtr + val _source_filename = source_filename?.cstr?.getPointer(memScope).rawValue val _num_clang_command_line_args = num_clang_command_line_args - val _clang_command_line_args = clang_command_line_args.rawValue + val _clang_command_line_args = clang_command_line_args?.getPointer(memScope).rawValue val _num_unsaved_files = num_unsaved_files - val _unsaved_files = unsaved_files.rawValue + val _unsaved_files = unsaved_files?.getPointer(memScope).rawValue val res = externals.clang_createTranslationUnitFromSourceFile(_CIdx, _source_filename, _num_clang_command_line_args, _clang_command_line_args, _num_unsaved_files, _unsaved_files) interpretCPointer(res) } @@ -674,17 +753,17 @@ fun clang_createTranslationUnitFromSourceFile(CIdx: CXIndex?, source_filename: S fun clang_createTranslationUnit(CIdx: CXIndex?, ast_filename: String?): CXTranslationUnit? { return memScoped { val _CIdx = CIdx.rawValue - val _ast_filename = ast_filename?.toCString(memScope).rawPtr + val _ast_filename = ast_filename?.cstr?.getPointer(memScope).rawValue val res = externals.clang_createTranslationUnit(_CIdx, _ast_filename) interpretCPointer(res) } } -fun clang_createTranslationUnit2(CIdx: CXIndex?, ast_filename: String?, out_TU: CPointer?): CXErrorCode { +fun clang_createTranslationUnit2(CIdx: CXIndex?, ast_filename: String?, out_TU: CValuesRef?): CXErrorCode { return memScoped { val _CIdx = CIdx.rawValue - val _ast_filename = ast_filename?.toCString(memScope).rawPtr - val _out_TU = out_TU.rawValue + val _ast_filename = ast_filename?.cstr?.getPointer(memScope).rawValue + val _out_TU = out_TU?.getPointer(memScope).rawValue val res = externals.clang_createTranslationUnit2(_CIdx, _ast_filename, _out_TU) CXErrorCode.byValue(res) } @@ -695,13 +774,13 @@ fun clang_defaultEditingTranslationUnitOptions(): Int { return res } -fun clang_parseTranslationUnit(CIdx: CXIndex?, source_filename: String?, command_line_args: CPointer>?, num_command_line_args: Int, unsaved_files: CPointer?, num_unsaved_files: Int, options: Int): CXTranslationUnit? { +fun clang_parseTranslationUnit(CIdx: CXIndex?, source_filename: String?, command_line_args: CValuesRef>?, num_command_line_args: Int, unsaved_files: CValuesRef?, num_unsaved_files: Int, options: Int): CXTranslationUnit? { return memScoped { val _CIdx = CIdx.rawValue - val _source_filename = source_filename?.toCString(memScope).rawPtr - val _command_line_args = command_line_args.rawValue + val _source_filename = source_filename?.cstr?.getPointer(memScope).rawValue + val _command_line_args = command_line_args?.getPointer(memScope).rawValue val _num_command_line_args = num_command_line_args - val _unsaved_files = unsaved_files.rawValue + val _unsaved_files = unsaved_files?.getPointer(memScope).rawValue val _num_unsaved_files = num_unsaved_files val _options = options val res = externals.clang_parseTranslationUnit(_CIdx, _source_filename, _command_line_args, _num_command_line_args, _unsaved_files, _num_unsaved_files, _options) @@ -709,31 +788,31 @@ fun clang_parseTranslationUnit(CIdx: CXIndex?, source_filename: String?, command } } -fun clang_parseTranslationUnit2(CIdx: CXIndex?, source_filename: String?, command_line_args: CPointer>?, num_command_line_args: Int, unsaved_files: CPointer?, num_unsaved_files: Int, options: Int, out_TU: CPointer?): CXErrorCode { +fun clang_parseTranslationUnit2(CIdx: CXIndex?, source_filename: String?, command_line_args: CValuesRef>?, num_command_line_args: Int, unsaved_files: CValuesRef?, num_unsaved_files: Int, options: Int, out_TU: CValuesRef?): CXErrorCode { return memScoped { val _CIdx = CIdx.rawValue - val _source_filename = source_filename?.toCString(memScope).rawPtr - val _command_line_args = command_line_args.rawValue + val _source_filename = source_filename?.cstr?.getPointer(memScope).rawValue + val _command_line_args = command_line_args?.getPointer(memScope).rawValue val _num_command_line_args = num_command_line_args - val _unsaved_files = unsaved_files.rawValue + val _unsaved_files = unsaved_files?.getPointer(memScope).rawValue val _num_unsaved_files = num_unsaved_files val _options = options - val _out_TU = out_TU.rawValue + val _out_TU = out_TU?.getPointer(memScope).rawValue val res = externals.clang_parseTranslationUnit2(_CIdx, _source_filename, _command_line_args, _num_command_line_args, _unsaved_files, _num_unsaved_files, _options, _out_TU) CXErrorCode.byValue(res) } } -fun clang_parseTranslationUnit2FullArgv(CIdx: CXIndex?, source_filename: String?, command_line_args: CPointer>?, num_command_line_args: Int, unsaved_files: CPointer?, num_unsaved_files: Int, options: Int, out_TU: CPointer?): CXErrorCode { +fun clang_parseTranslationUnit2FullArgv(CIdx: CXIndex?, source_filename: String?, command_line_args: CValuesRef>?, num_command_line_args: Int, unsaved_files: CValuesRef?, num_unsaved_files: Int, options: Int, out_TU: CValuesRef?): CXErrorCode { return memScoped { val _CIdx = CIdx.rawValue - val _source_filename = source_filename?.toCString(memScope).rawPtr - val _command_line_args = command_line_args.rawValue + val _source_filename = source_filename?.cstr?.getPointer(memScope).rawValue + val _command_line_args = command_line_args?.getPointer(memScope).rawValue val _num_command_line_args = num_command_line_args - val _unsaved_files = unsaved_files.rawValue + val _unsaved_files = unsaved_files?.getPointer(memScope).rawValue val _num_unsaved_files = num_unsaved_files val _options = options - val _out_TU = out_TU.rawValue + val _out_TU = out_TU?.getPointer(memScope).rawValue val res = externals.clang_parseTranslationUnit2FullArgv(_CIdx, _source_filename, _command_line_args, _num_command_line_args, _unsaved_files, _num_unsaved_files, _options, _out_TU) CXErrorCode.byValue(res) } @@ -748,7 +827,7 @@ fun clang_defaultSaveOptions(TU: CXTranslationUnit?): Int { fun clang_saveTranslationUnit(TU: CXTranslationUnit?, FileName: String?, options: Int): Int { return memScoped { val _TU = TU.rawValue - val _FileName = FileName?.toCString(memScope).rawPtr + val _FileName = FileName?.cstr?.getPointer(memScope).rawValue val _options = options val res = externals.clang_saveTranslationUnit(_TU, _FileName, _options) res @@ -767,13 +846,15 @@ fun clang_defaultReparseOptions(TU: CXTranslationUnit?): Int { return res } -fun clang_reparseTranslationUnit(TU: CXTranslationUnit?, num_unsaved_files: Int, unsaved_files: CPointer?, options: Int): Int { - val _TU = TU.rawValue - val _num_unsaved_files = num_unsaved_files - val _unsaved_files = unsaved_files.rawValue - val _options = options - val res = externals.clang_reparseTranslationUnit(_TU, _num_unsaved_files, _unsaved_files, _options) - return res +fun clang_reparseTranslationUnit(TU: CXTranslationUnit?, num_unsaved_files: Int, unsaved_files: CValuesRef?, options: Int): Int { + return memScoped { + val _TU = TU.rawValue + val _num_unsaved_files = num_unsaved_files + val _unsaved_files = unsaved_files?.getPointer(memScope).rawValue + val _options = options + val res = externals.clang_reparseTranslationUnit(_TU, _num_unsaved_files, _unsaved_files, _options) + res + } } fun clang_getTUResourceUsageName(kind: CXTUResourceUsageKind): CPointer? { @@ -782,55 +863,68 @@ fun clang_getTUResourceUsageName(kind: CXTUResourceUsageKind): CPointer(res) } -fun clang_getCXTUResourceUsage(TU: CXTranslationUnit?, retValPlacement: NativePlacement): CXTUResourceUsage { - val _TU = TU.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCXTUResourceUsage(_TU, _retValPlacement) - return interpretPointed(res) +fun clang_getCXTUResourceUsage(TU: CXTranslationUnit?): CValue { + return memScoped { + val _TU = TU.rawValue + val res = externals.clang_getCXTUResourceUsage(_TU, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_disposeCXTUResourceUsage(usage: CXTUResourceUsage): Unit { - val _usage = usage.rawPtr - val res = externals.clang_disposeCXTUResourceUsage(_usage) - return res +fun clang_disposeCXTUResourceUsage(usage: CValue): Unit { + return memScoped { + val _usage = usage.getPointer(memScope).rawValue + val res = externals.clang_disposeCXTUResourceUsage(_usage) + res + } } -fun clang_getNullCursor(retValPlacement: NativePlacement): CXCursor { - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getNullCursor(_retValPlacement) - return interpretPointed(res) +fun clang_getNullCursor(): CValue { + return memScoped { + val res = externals.clang_getNullCursor(alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getTranslationUnitCursor(arg0: CXTranslationUnit?, retValPlacement: NativePlacement): CXCursor { - val _arg0 = arg0.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getTranslationUnitCursor(_arg0, _retValPlacement) - return interpretPointed(res) +fun clang_getTranslationUnitCursor(arg0: CXTranslationUnit?): CValue { + return memScoped { + val _arg0 = arg0.rawValue + val res = externals.clang_getTranslationUnitCursor(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_equalCursors(arg0: CXCursor, arg1: CXCursor): Int { - val _arg0 = arg0.rawPtr - val _arg1 = arg1.rawPtr - val res = externals.clang_equalCursors(_arg0, _arg1) - return res +fun clang_equalCursors(arg0: CValue, arg1: CValue): Int { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val _arg1 = arg1.getPointer(memScope).rawValue + val res = externals.clang_equalCursors(_arg0, _arg1) + res + } } -fun clang_Cursor_isNull(cursor: CXCursor): Int { - val _cursor = cursor.rawPtr - val res = externals.clang_Cursor_isNull(_cursor) - return res +fun clang_Cursor_isNull(cursor: CValue): Int { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_Cursor_isNull(_cursor) + res + } } -fun clang_hashCursor(arg0: CXCursor): Int { - val _arg0 = arg0.rawPtr - val res = externals.clang_hashCursor(_arg0) - return res +fun clang_hashCursor(arg0: CValue): Int { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_hashCursor(_arg0) + res + } } -fun clang_getCursorKind(arg0: CXCursor): CXCursorKind { - val _arg0 = arg0.rawPtr - val res = externals.clang_getCursorKind(_arg0) - return CXCursorKind.byValue(res) +fun clang_getCursorKind(arg0: CValue): CXCursorKind { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getCursorKind(_arg0) + CXCursorKind.byValue(res) + } } fun clang_isDeclaration(arg0: CXCursorKind): Int { @@ -863,10 +957,12 @@ fun clang_isAttribute(arg0: CXCursorKind): Int { return res } -fun clang_Cursor_hasAttrs(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_hasAttrs(_C) - return res +fun clang_Cursor_hasAttrs(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_hasAttrs(_C) + res + } } fun clang_isInvalid(arg0: CXCursorKind): Int { @@ -893,52 +989,66 @@ fun clang_isUnexposed(arg0: CXCursorKind): Int { return res } -fun clang_getCursorLinkage(cursor: CXCursor): CXLinkageKind { - val _cursor = cursor.rawPtr - val res = externals.clang_getCursorLinkage(_cursor) - return CXLinkageKind.byValue(res) +fun clang_getCursorLinkage(cursor: CValue): CXLinkageKind { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_getCursorLinkage(_cursor) + CXLinkageKind.byValue(res) + } } -fun clang_getCursorVisibility(cursor: CXCursor): CXVisibilityKind { - val _cursor = cursor.rawPtr - val res = externals.clang_getCursorVisibility(_cursor) - return CXVisibilityKind.byValue(res) +fun clang_getCursorVisibility(cursor: CValue): CXVisibilityKind { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_getCursorVisibility(_cursor) + CXVisibilityKind.byValue(res) + } } -fun clang_getCursorAvailability(cursor: CXCursor): CXAvailabilityKind { - val _cursor = cursor.rawPtr - val res = externals.clang_getCursorAvailability(_cursor) - return CXAvailabilityKind.byValue(res) +fun clang_getCursorAvailability(cursor: CValue): CXAvailabilityKind { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_getCursorAvailability(_cursor) + CXAvailabilityKind.byValue(res) + } } -fun clang_getCursorPlatformAvailability(cursor: CXCursor, always_deprecated: CPointer?, deprecated_message: CPointer?, always_unavailable: CPointer?, unavailable_message: CPointer?, availability: CPointer?, availability_size: Int): Int { - val _cursor = cursor.rawPtr - val _always_deprecated = always_deprecated.rawValue - val _deprecated_message = deprecated_message.rawValue - val _always_unavailable = always_unavailable.rawValue - val _unavailable_message = unavailable_message.rawValue - val _availability = availability.rawValue - val _availability_size = availability_size - val res = externals.clang_getCursorPlatformAvailability(_cursor, _always_deprecated, _deprecated_message, _always_unavailable, _unavailable_message, _availability, _availability_size) - return res +fun clang_getCursorPlatformAvailability(cursor: CValue, always_deprecated: CValuesRef?, deprecated_message: CValuesRef?, always_unavailable: CValuesRef?, unavailable_message: CValuesRef?, availability: CValuesRef?, availability_size: Int): Int { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val _always_deprecated = always_deprecated?.getPointer(memScope).rawValue + val _deprecated_message = deprecated_message?.getPointer(memScope).rawValue + val _always_unavailable = always_unavailable?.getPointer(memScope).rawValue + val _unavailable_message = unavailable_message?.getPointer(memScope).rawValue + val _availability = availability?.getPointer(memScope).rawValue + val _availability_size = availability_size + val res = externals.clang_getCursorPlatformAvailability(_cursor, _always_deprecated, _deprecated_message, _always_unavailable, _unavailable_message, _availability, _availability_size) + res + } } -fun clang_disposeCXPlatformAvailability(availability: CPointer?): Unit { - val _availability = availability.rawValue - val res = externals.clang_disposeCXPlatformAvailability(_availability) - return res +fun clang_disposeCXPlatformAvailability(availability: CValuesRef?): Unit { + return memScoped { + val _availability = availability?.getPointer(memScope).rawValue + val res = externals.clang_disposeCXPlatformAvailability(_availability) + res + } } -fun clang_getCursorLanguage(cursor: CXCursor): CXLanguageKind { - val _cursor = cursor.rawPtr - val res = externals.clang_getCursorLanguage(_cursor) - return CXLanguageKind.byValue(res) +fun clang_getCursorLanguage(cursor: CValue): CXLanguageKind { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_getCursorLanguage(_cursor) + CXLanguageKind.byValue(res) + } } -fun clang_Cursor_getTranslationUnit(arg0: CXCursor): CXTranslationUnit? { - val _arg0 = arg0.rawPtr - val res = externals.clang_Cursor_getTranslationUnit(_arg0) - return interpretCPointer(res) +fun clang_Cursor_getTranslationUnit(arg0: CValue): CXTranslationUnit? { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getTranslationUnit(_arg0) + interpretCPointer(res) + } } fun clang_createCXCursorSet(): CXCursorSet? { @@ -952,646 +1062,773 @@ fun clang_disposeCXCursorSet(cset: CXCursorSet?): Unit { return res } -fun clang_CXCursorSet_contains(cset: CXCursorSet?, cursor: CXCursor): Int { - val _cset = cset.rawValue - val _cursor = cursor.rawPtr - val res = externals.clang_CXCursorSet_contains(_cset, _cursor) - return res -} - -fun clang_CXCursorSet_insert(cset: CXCursorSet?, cursor: CXCursor): Int { - val _cset = cset.rawValue - val _cursor = cursor.rawPtr - val res = externals.clang_CXCursorSet_insert(_cset, _cursor) - return res -} - -fun clang_getCursorSemanticParent(cursor: CXCursor, retValPlacement: NativePlacement): CXCursor { - val _cursor = cursor.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorSemanticParent(_cursor, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getCursorLexicalParent(cursor: CXCursor, retValPlacement: NativePlacement): CXCursor { - val _cursor = cursor.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorLexicalParent(_cursor, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getOverriddenCursors(cursor: CXCursor, overridden: CPointer>?, num_overridden: CPointer?): Unit { - val _cursor = cursor.rawPtr - val _overridden = overridden.rawValue - val _num_overridden = num_overridden.rawValue - val res = externals.clang_getOverriddenCursors(_cursor, _overridden, _num_overridden) - return res -} - -fun clang_disposeOverriddenCursors(overridden: CPointer?): Unit { - val _overridden = overridden.rawValue - val res = externals.clang_disposeOverriddenCursors(_overridden) - return res -} - -fun clang_getIncludedFile(cursor: CXCursor): CXFile? { - val _cursor = cursor.rawPtr - val res = externals.clang_getIncludedFile(_cursor) - return interpretCPointer(res) -} - -fun clang_getCursor(arg0: CXTranslationUnit?, arg1: CXSourceLocation, retValPlacement: NativePlacement): CXCursor { - val _arg0 = arg0.rawValue - val _arg1 = arg1.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursor(_arg0, _arg1, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getCursorLocation(arg0: CXCursor, retValPlacement: NativePlacement): CXSourceLocation { - val _arg0 = arg0.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorLocation(_arg0, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getCursorExtent(arg0: CXCursor, retValPlacement: NativePlacement): CXSourceRange { - val _arg0 = arg0.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorExtent(_arg0, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getCursorType(C: CXCursor, retValPlacement: NativePlacement): CXType { - val _C = C.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorType(_C, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getTypeSpelling(CT: CXType, retValPlacement: NativePlacement): CXString { - val _CT = CT.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getTypeSpelling(_CT, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getTypedefDeclUnderlyingType(C: CXCursor, retValPlacement: NativePlacement): CXType { - val _C = C.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getTypedefDeclUnderlyingType(_C, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getEnumDeclIntegerType(C: CXCursor, retValPlacement: NativePlacement): CXType { - val _C = C.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getEnumDeclIntegerType(_C, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getEnumConstantDeclValue(C: CXCursor): Long { - val _C = C.rawPtr - val res = externals.clang_getEnumConstantDeclValue(_C) - return res -} - -fun clang_getEnumConstantDeclUnsignedValue(C: CXCursor): Long { - val _C = C.rawPtr - val res = externals.clang_getEnumConstantDeclUnsignedValue(_C) - return res -} - -fun clang_getFieldDeclBitWidth(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_getFieldDeclBitWidth(_C) - return res -} - -fun clang_Cursor_getNumArguments(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_getNumArguments(_C) - return res -} - -fun clang_Cursor_getArgument(C: CXCursor, i: Int, retValPlacement: NativePlacement): CXCursor { - val _C = C.rawPtr - val _i = i - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Cursor_getArgument(_C, _i, _retValPlacement) - return interpretPointed(res) -} - -fun clang_Cursor_getNumTemplateArguments(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_getNumTemplateArguments(_C) - return res -} - -fun clang_Cursor_getTemplateArgumentKind(C: CXCursor, I: Int): CXTemplateArgumentKind { - val _C = C.rawPtr - val _I = I - val res = externals.clang_Cursor_getTemplateArgumentKind(_C, _I) - return CXTemplateArgumentKind.byValue(res) -} - -fun clang_Cursor_getTemplateArgumentType(C: CXCursor, I: Int, retValPlacement: NativePlacement): CXType { - val _C = C.rawPtr - val _I = I - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Cursor_getTemplateArgumentType(_C, _I, _retValPlacement) - return interpretPointed(res) -} - -fun clang_Cursor_getTemplateArgumentValue(C: CXCursor, I: Int): Long { - val _C = C.rawPtr - val _I = I - val res = externals.clang_Cursor_getTemplateArgumentValue(_C, _I) - return res -} - -fun clang_Cursor_getTemplateArgumentUnsignedValue(C: CXCursor, I: Int): Long { - val _C = C.rawPtr - val _I = I - val res = externals.clang_Cursor_getTemplateArgumentUnsignedValue(_C, _I) - return res -} - -fun clang_equalTypes(A: CXType, B: CXType): Int { - val _A = A.rawPtr - val _B = B.rawPtr - val res = externals.clang_equalTypes(_A, _B) - return res -} - -fun clang_getCanonicalType(T: CXType, retValPlacement: NativePlacement): CXType { - val _T = T.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCanonicalType(_T, _retValPlacement) - return interpretPointed(res) -} - -fun clang_isConstQualifiedType(T: CXType): Int { - val _T = T.rawPtr - val res = externals.clang_isConstQualifiedType(_T) - return res -} - -fun clang_Cursor_isMacroFunctionLike(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_isMacroFunctionLike(_C) - return res -} - -fun clang_Cursor_isMacroBuiltin(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_isMacroBuiltin(_C) - return res -} - -fun clang_Cursor_isFunctionInlined(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_isFunctionInlined(_C) - return res -} - -fun clang_isVolatileQualifiedType(T: CXType): Int { - val _T = T.rawPtr - val res = externals.clang_isVolatileQualifiedType(_T) - return res -} - -fun clang_isRestrictQualifiedType(T: CXType): Int { - val _T = T.rawPtr - val res = externals.clang_isRestrictQualifiedType(_T) - return res -} - -fun clang_getPointeeType(T: CXType, retValPlacement: NativePlacement): CXType { - val _T = T.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getPointeeType(_T, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getTypeDeclaration(T: CXType, retValPlacement: NativePlacement): CXCursor { - val _T = T.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getTypeDeclaration(_T, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getDeclObjCTypeEncoding(C: CXCursor, retValPlacement: NativePlacement): CXString { - val _C = C.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getDeclObjCTypeEncoding(_C, _retValPlacement) - return interpretPointed(res) -} - -fun clang_Type_getObjCEncoding(type: CXType, retValPlacement: NativePlacement): CXString { - val _type = type.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Type_getObjCEncoding(_type, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getTypeKindSpelling(K: CXTypeKind, retValPlacement: NativePlacement): CXString { - val _K = K.value - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getTypeKindSpelling(_K, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getFunctionTypeCallingConv(T: CXType): CXCallingConv { - val _T = T.rawPtr - val res = externals.clang_getFunctionTypeCallingConv(_T) - return CXCallingConv.byValue(res) -} - -fun clang_getResultType(T: CXType, retValPlacement: NativePlacement): CXType { - val _T = T.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getResultType(_T, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getNumArgTypes(T: CXType): Int { - val _T = T.rawPtr - val res = externals.clang_getNumArgTypes(_T) - return res -} - -fun clang_getArgType(T: CXType, i: Int, retValPlacement: NativePlacement): CXType { - val _T = T.rawPtr - val _i = i - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getArgType(_T, _i, _retValPlacement) - return interpretPointed(res) -} - -fun clang_isFunctionTypeVariadic(T: CXType): Int { - val _T = T.rawPtr - val res = externals.clang_isFunctionTypeVariadic(_T) - return res -} - -fun clang_getCursorResultType(C: CXCursor, retValPlacement: NativePlacement): CXType { - val _C = C.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorResultType(_C, _retValPlacement) - return interpretPointed(res) -} - -fun clang_isPODType(T: CXType): Int { - val _T = T.rawPtr - val res = externals.clang_isPODType(_T) - return res -} - -fun clang_getElementType(T: CXType, retValPlacement: NativePlacement): CXType { - val _T = T.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getElementType(_T, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getNumElements(T: CXType): Long { - val _T = T.rawPtr - val res = externals.clang_getNumElements(_T) - return res -} - -fun clang_getArrayElementType(T: CXType, retValPlacement: NativePlacement): CXType { - val _T = T.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getArrayElementType(_T, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getArraySize(T: CXType): Long { - val _T = T.rawPtr - val res = externals.clang_getArraySize(_T) - return res -} - -fun clang_Type_getNamedType(T: CXType, retValPlacement: NativePlacement): CXType { - val _T = T.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Type_getNamedType(_T, _retValPlacement) - return interpretPointed(res) -} - -fun clang_Type_getAlignOf(T: CXType): Long { - val _T = T.rawPtr - val res = externals.clang_Type_getAlignOf(_T) - return res -} - -fun clang_Type_getClassType(T: CXType, retValPlacement: NativePlacement): CXType { - val _T = T.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Type_getClassType(_T, _retValPlacement) - return interpretPointed(res) -} - -fun clang_Type_getSizeOf(T: CXType): Long { - val _T = T.rawPtr - val res = externals.clang_Type_getSizeOf(_T) - return res -} - -fun clang_Type_getOffsetOf(T: CXType, S: String?): Long { +fun clang_CXCursorSet_contains(cset: CXCursorSet?, cursor: CValue): Int { return memScoped { - val _T = T.rawPtr - val _S = S?.toCString(memScope).rawPtr + val _cset = cset.rawValue + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_CXCursorSet_contains(_cset, _cursor) + res + } +} + +fun clang_CXCursorSet_insert(cset: CXCursorSet?, cursor: CValue): Int { + return memScoped { + val _cset = cset.rawValue + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_CXCursorSet_insert(_cset, _cursor) + res + } +} + +fun clang_getCursorSemanticParent(cursor: CValue): CValue { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_getCursorSemanticParent(_cursor, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getCursorLexicalParent(cursor: CValue): CValue { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_getCursorLexicalParent(_cursor, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getOverriddenCursors(cursor: CValue, overridden: CValuesRef>?, num_overridden: CValuesRef?): Unit { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val _overridden = overridden?.getPointer(memScope).rawValue + val _num_overridden = num_overridden?.getPointer(memScope).rawValue + val res = externals.clang_getOverriddenCursors(_cursor, _overridden, _num_overridden) + res + } +} + +fun clang_disposeOverriddenCursors(overridden: CValuesRef?): Unit { + return memScoped { + val _overridden = overridden?.getPointer(memScope).rawValue + val res = externals.clang_disposeOverriddenCursors(_overridden) + res + } +} + +fun clang_getIncludedFile(cursor: CValue): CXFile? { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_getIncludedFile(_cursor) + interpretCPointer(res) + } +} + +fun clang_getCursor(arg0: CXTranslationUnit?, arg1: CValue): CValue { + return memScoped { + val _arg0 = arg0.rawValue + val _arg1 = arg1.getPointer(memScope).rawValue + val res = externals.clang_getCursor(_arg0, _arg1, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getCursorLocation(arg0: CValue): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getCursorLocation(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getCursorExtent(arg0: CValue): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getCursorExtent(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getCursorType(C: CValue): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_getCursorType(_C, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getTypeSpelling(CT: CValue): CValue { + return memScoped { + val _CT = CT.getPointer(memScope).rawValue + val res = externals.clang_getTypeSpelling(_CT, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getTypedefDeclUnderlyingType(C: CValue): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_getTypedefDeclUnderlyingType(_C, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getEnumDeclIntegerType(C: CValue): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_getEnumDeclIntegerType(_C, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getEnumConstantDeclValue(C: CValue): Long { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_getEnumConstantDeclValue(_C) + res + } +} + +fun clang_getEnumConstantDeclUnsignedValue(C: CValue): Long { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_getEnumConstantDeclUnsignedValue(_C) + res + } +} + +fun clang_getFieldDeclBitWidth(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_getFieldDeclBitWidth(_C) + res + } +} + +fun clang_Cursor_getNumArguments(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getNumArguments(_C) + res + } +} + +fun clang_Cursor_getArgument(C: CValue, i: Int): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val _i = i + val res = externals.clang_Cursor_getArgument(_C, _i, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_Cursor_getNumTemplateArguments(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getNumTemplateArguments(_C) + res + } +} + +fun clang_Cursor_getTemplateArgumentKind(C: CValue, I: Int): CXTemplateArgumentKind { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val _I = I + val res = externals.clang_Cursor_getTemplateArgumentKind(_C, _I) + CXTemplateArgumentKind.byValue(res) + } +} + +fun clang_Cursor_getTemplateArgumentType(C: CValue, I: Int): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val _I = I + val res = externals.clang_Cursor_getTemplateArgumentType(_C, _I, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_Cursor_getTemplateArgumentValue(C: CValue, I: Int): Long { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val _I = I + val res = externals.clang_Cursor_getTemplateArgumentValue(_C, _I) + res + } +} + +fun clang_Cursor_getTemplateArgumentUnsignedValue(C: CValue, I: Int): Long { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val _I = I + val res = externals.clang_Cursor_getTemplateArgumentUnsignedValue(_C, _I) + res + } +} + +fun clang_equalTypes(A: CValue, B: CValue): Int { + return memScoped { + val _A = A.getPointer(memScope).rawValue + val _B = B.getPointer(memScope).rawValue + val res = externals.clang_equalTypes(_A, _B) + res + } +} + +fun clang_getCanonicalType(T: CValue): CValue { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_getCanonicalType(_T, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_isConstQualifiedType(T: CValue): Int { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_isConstQualifiedType(_T) + res + } +} + +fun clang_Cursor_isMacroFunctionLike(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_isMacroFunctionLike(_C) + res + } +} + +fun clang_Cursor_isMacroBuiltin(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_isMacroBuiltin(_C) + res + } +} + +fun clang_Cursor_isFunctionInlined(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_isFunctionInlined(_C) + res + } +} + +fun clang_isVolatileQualifiedType(T: CValue): Int { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_isVolatileQualifiedType(_T) + res + } +} + +fun clang_isRestrictQualifiedType(T: CValue): Int { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_isRestrictQualifiedType(_T) + res + } +} + +fun clang_getPointeeType(T: CValue): CValue { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_getPointeeType(_T, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getTypeDeclaration(T: CValue): CValue { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_getTypeDeclaration(_T, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getDeclObjCTypeEncoding(C: CValue): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_getDeclObjCTypeEncoding(_C, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_Type_getObjCEncoding(type: CValue): CValue { + return memScoped { + val _type = type.getPointer(memScope).rawValue + val res = externals.clang_Type_getObjCEncoding(_type, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getTypeKindSpelling(K: CXTypeKind): CValue { + return memScoped { + val _K = K.value + val res = externals.clang_getTypeKindSpelling(_K, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getFunctionTypeCallingConv(T: CValue): CXCallingConv { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_getFunctionTypeCallingConv(_T) + CXCallingConv.byValue(res) + } +} + +fun clang_getResultType(T: CValue): CValue { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_getResultType(_T, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getNumArgTypes(T: CValue): Int { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_getNumArgTypes(_T) + res + } +} + +fun clang_getArgType(T: CValue, i: Int): CValue { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val _i = i + val res = externals.clang_getArgType(_T, _i, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_isFunctionTypeVariadic(T: CValue): Int { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_isFunctionTypeVariadic(_T) + res + } +} + +fun clang_getCursorResultType(C: CValue): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_getCursorResultType(_C, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_isPODType(T: CValue): Int { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_isPODType(_T) + res + } +} + +fun clang_getElementType(T: CValue): CValue { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_getElementType(_T, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getNumElements(T: CValue): Long { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_getNumElements(_T) + res + } +} + +fun clang_getArrayElementType(T: CValue): CValue { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_getArrayElementType(_T, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getArraySize(T: CValue): Long { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_getArraySize(_T) + res + } +} + +fun clang_Type_getNamedType(T: CValue): CValue { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_Type_getNamedType(_T, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_Type_getAlignOf(T: CValue): Long { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_Type_getAlignOf(_T) + res + } +} + +fun clang_Type_getClassType(T: CValue): CValue { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_Type_getClassType(_T, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_Type_getSizeOf(T: CValue): Long { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_Type_getSizeOf(_T) + res + } +} + +fun clang_Type_getOffsetOf(T: CValue, S: String?): Long { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val _S = S?.cstr?.getPointer(memScope).rawValue val res = externals.clang_Type_getOffsetOf(_T, _S) res } } -fun clang_Cursor_getOffsetOfField(C: CXCursor): Long { - val _C = C.rawPtr - val res = externals.clang_Cursor_getOffsetOfField(_C) - return res -} - -fun clang_Cursor_isAnonymous(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_isAnonymous(_C) - return res -} - -fun clang_Type_getNumTemplateArguments(T: CXType): Int { - val _T = T.rawPtr - val res = externals.clang_Type_getNumTemplateArguments(_T) - return res -} - -fun clang_Type_getTemplateArgumentAsType(T: CXType, i: Int, retValPlacement: NativePlacement): CXType { - val _T = T.rawPtr - val _i = i - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Type_getTemplateArgumentAsType(_T, _i, _retValPlacement) - return interpretPointed(res) -} - -fun clang_Type_getCXXRefQualifier(T: CXType): CXRefQualifierKind { - val _T = T.rawPtr - val res = externals.clang_Type_getCXXRefQualifier(_T) - return res -} - -fun clang_Cursor_isBitField(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_isBitField(_C) - return res -} - -fun clang_isVirtualBase(arg0: CXCursor): Int { - val _arg0 = arg0.rawPtr - val res = externals.clang_isVirtualBase(_arg0) - return res -} - -fun clang_getCXXAccessSpecifier(arg0: CXCursor): CX_CXXAccessSpecifier { - val _arg0 = arg0.rawPtr - val res = externals.clang_getCXXAccessSpecifier(_arg0) - return CX_CXXAccessSpecifier.byValue(res) -} - -fun clang_Cursor_getStorageClass(arg0: CXCursor): CX_StorageClass { - val _arg0 = arg0.rawPtr - val res = externals.clang_Cursor_getStorageClass(_arg0) - return CX_StorageClass.byValue(res) -} - -fun clang_getNumOverloadedDecls(cursor: CXCursor): Int { - val _cursor = cursor.rawPtr - val res = externals.clang_getNumOverloadedDecls(_cursor) - return res -} - -fun clang_getOverloadedDecl(cursor: CXCursor, index: Int, retValPlacement: NativePlacement): CXCursor { - val _cursor = cursor.rawPtr - val _index = index - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getOverloadedDecl(_cursor, _index, _retValPlacement) - return interpretPointed(res) -} - -fun clang_getIBOutletCollectionType(arg0: CXCursor, retValPlacement: NativePlacement): CXType { - val _arg0 = arg0.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getIBOutletCollectionType(_arg0, _retValPlacement) - return interpretPointed(res) -} - -fun clang_visitChildren(parent: CXCursor, visitor: CXCursorVisitor?, client_data: CXClientData?): Int { - val _parent = parent.rawPtr - val _visitor = visitor.rawValue - val _client_data = client_data.rawValue - val res = externals.clang_visitChildren(_parent, _visitor, _client_data) - return res -} - -fun clang_getCursorUSR(arg0: CXCursor, retValPlacement: NativePlacement): CXString { - val _arg0 = arg0.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorUSR(_arg0, _retValPlacement) - return interpretPointed(res) -} - -fun clang_constructUSR_ObjCClass(class_name: String?, retValPlacement: NativePlacement): CXString { +fun clang_Cursor_getOffsetOfField(C: CValue): Long { return memScoped { - val _class_name = class_name?.toCString(memScope).rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_constructUSR_ObjCClass(_class_name, _retValPlacement) - interpretPointed(res) + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getOffsetOfField(_C) + res } } -fun clang_constructUSR_ObjCCategory(class_name: String?, category_name: String?, retValPlacement: NativePlacement): CXString { +fun clang_Cursor_isAnonymous(C: CValue): Int { return memScoped { - val _class_name = class_name?.toCString(memScope).rawPtr - val _category_name = category_name?.toCString(memScope).rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_constructUSR_ObjCCategory(_class_name, _category_name, _retValPlacement) - interpretPointed(res) + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_isAnonymous(_C) + res } } -fun clang_constructUSR_ObjCProtocol(protocol_name: String?, retValPlacement: NativePlacement): CXString { +fun clang_Type_getNumTemplateArguments(T: CValue): Int { return memScoped { - val _protocol_name = protocol_name?.toCString(memScope).rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_constructUSR_ObjCProtocol(_protocol_name, _retValPlacement) - interpretPointed(res) + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_Type_getNumTemplateArguments(_T) + res } } -fun clang_constructUSR_ObjCIvar(name: String?, classUSR: CXString, retValPlacement: NativePlacement): CXString { +fun clang_Type_getTemplateArgumentAsType(T: CValue, i: Int): CValue { return memScoped { - val _name = name?.toCString(memScope).rawPtr - val _classUSR = classUSR.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_constructUSR_ObjCIvar(_name, _classUSR, _retValPlacement) - interpretPointed(res) + val _T = T.getPointer(memScope).rawValue + val _i = i + val res = externals.clang_Type_getTemplateArgumentAsType(_T, _i, alloc().rawPtr) + interpretPointed(res).readValue() } } -fun clang_constructUSR_ObjCMethod(name: String?, isInstanceMethod: Int, classUSR: CXString, retValPlacement: NativePlacement): CXString { +fun clang_Type_getCXXRefQualifier(T: CValue): CXRefQualifierKind { return memScoped { - val _name = name?.toCString(memScope).rawPtr + val _T = T.getPointer(memScope).rawValue + val res = externals.clang_Type_getCXXRefQualifier(_T) + res + } +} + +fun clang_Cursor_isBitField(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_isBitField(_C) + res + } +} + +fun clang_isVirtualBase(arg0: CValue): Int { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_isVirtualBase(_arg0) + res + } +} + +fun clang_getCXXAccessSpecifier(arg0: CValue): CX_CXXAccessSpecifier { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getCXXAccessSpecifier(_arg0) + CX_CXXAccessSpecifier.byValue(res) + } +} + +fun clang_Cursor_getStorageClass(arg0: CValue): CX_StorageClass { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getStorageClass(_arg0) + CX_StorageClass.byValue(res) + } +} + +fun clang_getNumOverloadedDecls(cursor: CValue): Int { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_getNumOverloadedDecls(_cursor) + res + } +} + +fun clang_getOverloadedDecl(cursor: CValue, index: Int): CValue { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val _index = index + val res = externals.clang_getOverloadedDecl(_cursor, _index, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_getIBOutletCollectionType(arg0: CValue): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getIBOutletCollectionType(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_visitChildren(parent: CValue, visitor: CXCursorVisitor?, client_data: CXClientData?): Int { + return memScoped { + val _parent = parent.getPointer(memScope).rawValue + val _visitor = visitor.rawValue + val _client_data = client_data.rawValue + val res = externals.clang_visitChildren(_parent, _visitor, _client_data) + res + } +} + +fun clang_getCursorUSR(arg0: CValue): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getCursorUSR(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_constructUSR_ObjCClass(class_name: String?): CValue { + return memScoped { + val _class_name = class_name?.cstr?.getPointer(memScope).rawValue + val res = externals.clang_constructUSR_ObjCClass(_class_name, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_constructUSR_ObjCCategory(class_name: String?, category_name: String?): CValue { + return memScoped { + val _class_name = class_name?.cstr?.getPointer(memScope).rawValue + val _category_name = category_name?.cstr?.getPointer(memScope).rawValue + val res = externals.clang_constructUSR_ObjCCategory(_class_name, _category_name, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_constructUSR_ObjCProtocol(protocol_name: String?): CValue { + return memScoped { + val _protocol_name = protocol_name?.cstr?.getPointer(memScope).rawValue + val res = externals.clang_constructUSR_ObjCProtocol(_protocol_name, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_constructUSR_ObjCIvar(name: String?, classUSR: CValue): CValue { + return memScoped { + val _name = name?.cstr?.getPointer(memScope).rawValue + val _classUSR = classUSR.getPointer(memScope).rawValue + val res = externals.clang_constructUSR_ObjCIvar(_name, _classUSR, alloc().rawPtr) + interpretPointed(res).readValue() + } +} + +fun clang_constructUSR_ObjCMethod(name: String?, isInstanceMethod: Int, classUSR: CValue): CValue { + return memScoped { + val _name = name?.cstr?.getPointer(memScope).rawValue val _isInstanceMethod = isInstanceMethod - val _classUSR = classUSR.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_constructUSR_ObjCMethod(_name, _isInstanceMethod, _classUSR, _retValPlacement) - interpretPointed(res) + val _classUSR = classUSR.getPointer(memScope).rawValue + val res = externals.clang_constructUSR_ObjCMethod(_name, _isInstanceMethod, _classUSR, alloc().rawPtr) + interpretPointed(res).readValue() } } -fun clang_constructUSR_ObjCProperty(property: String?, classUSR: CXString, retValPlacement: NativePlacement): CXString { +fun clang_constructUSR_ObjCProperty(property: String?, classUSR: CValue): CValue { return memScoped { - val _property = property?.toCString(memScope).rawPtr - val _classUSR = classUSR.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_constructUSR_ObjCProperty(_property, _classUSR, _retValPlacement) - interpretPointed(res) + val _property = property?.cstr?.getPointer(memScope).rawValue + val _classUSR = classUSR.getPointer(memScope).rawValue + val res = externals.clang_constructUSR_ObjCProperty(_property, _classUSR, alloc().rawPtr) + interpretPointed(res).readValue() } } -fun clang_getCursorSpelling(arg0: CXCursor, retValPlacement: NativePlacement): CXString { - val _arg0 = arg0.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorSpelling(_arg0, _retValPlacement) - return interpretPointed(res) +fun clang_getCursorSpelling(arg0: CValue): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getCursorSpelling(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_Cursor_getSpellingNameRange(arg0: CXCursor, pieceIndex: Int, options: Int, retValPlacement: NativePlacement): CXSourceRange { - val _arg0 = arg0.rawPtr - val _pieceIndex = pieceIndex - val _options = options - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Cursor_getSpellingNameRange(_arg0, _pieceIndex, _options, _retValPlacement) - return interpretPointed(res) +fun clang_Cursor_getSpellingNameRange(arg0: CValue, pieceIndex: Int, options: Int): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val _pieceIndex = pieceIndex + val _options = options + val res = externals.clang_Cursor_getSpellingNameRange(_arg0, _pieceIndex, _options, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getCursorDisplayName(arg0: CXCursor, retValPlacement: NativePlacement): CXString { - val _arg0 = arg0.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorDisplayName(_arg0, _retValPlacement) - return interpretPointed(res) +fun clang_getCursorDisplayName(arg0: CValue): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getCursorDisplayName(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getCursorReferenced(arg0: CXCursor, retValPlacement: NativePlacement): CXCursor { - val _arg0 = arg0.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorReferenced(_arg0, _retValPlacement) - return interpretPointed(res) +fun clang_getCursorReferenced(arg0: CValue): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getCursorReferenced(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getCursorDefinition(arg0: CXCursor, retValPlacement: NativePlacement): CXCursor { - val _arg0 = arg0.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorDefinition(_arg0, _retValPlacement) - return interpretPointed(res) +fun clang_getCursorDefinition(arg0: CValue): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getCursorDefinition(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_isCursorDefinition(arg0: CXCursor): Int { - val _arg0 = arg0.rawPtr - val res = externals.clang_isCursorDefinition(_arg0) - return res +fun clang_isCursorDefinition(arg0: CValue): Int { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_isCursorDefinition(_arg0) + res + } } -fun clang_getCanonicalCursor(arg0: CXCursor, retValPlacement: NativePlacement): CXCursor { - val _arg0 = arg0.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCanonicalCursor(_arg0, _retValPlacement) - return interpretPointed(res) +fun clang_getCanonicalCursor(arg0: CValue): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getCanonicalCursor(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_Cursor_getObjCSelectorIndex(arg0: CXCursor): Int { - val _arg0 = arg0.rawPtr - val res = externals.clang_Cursor_getObjCSelectorIndex(_arg0) - return res +fun clang_Cursor_getObjCSelectorIndex(arg0: CValue): Int { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getObjCSelectorIndex(_arg0) + res + } } -fun clang_Cursor_isDynamicCall(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_isDynamicCall(_C) - return res +fun clang_Cursor_isDynamicCall(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_isDynamicCall(_C) + res + } } -fun clang_Cursor_getReceiverType(C: CXCursor, retValPlacement: NativePlacement): CXType { - val _C = C.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Cursor_getReceiverType(_C, _retValPlacement) - return interpretPointed(res) +fun clang_Cursor_getReceiverType(C: CValue): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getReceiverType(_C, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_Cursor_getObjCPropertyAttributes(C: CXCursor, reserved: Int): Int { - val _C = C.rawPtr - val _reserved = reserved - val res = externals.clang_Cursor_getObjCPropertyAttributes(_C, _reserved) - return res +fun clang_Cursor_getObjCPropertyAttributes(C: CValue, reserved: Int): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val _reserved = reserved + val res = externals.clang_Cursor_getObjCPropertyAttributes(_C, _reserved) + res + } } -fun clang_Cursor_getObjCDeclQualifiers(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_getObjCDeclQualifiers(_C) - return res +fun clang_Cursor_getObjCDeclQualifiers(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getObjCDeclQualifiers(_C) + res + } } -fun clang_Cursor_isObjCOptional(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_isObjCOptional(_C) - return res +fun clang_Cursor_isObjCOptional(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_isObjCOptional(_C) + res + } } -fun clang_Cursor_isVariadic(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_Cursor_isVariadic(_C) - return res +fun clang_Cursor_isVariadic(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_isVariadic(_C) + res + } } -fun clang_Cursor_getCommentRange(C: CXCursor, retValPlacement: NativePlacement): CXSourceRange { - val _C = C.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Cursor_getCommentRange(_C, _retValPlacement) - return interpretPointed(res) +fun clang_Cursor_getCommentRange(C: CValue): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getCommentRange(_C, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_Cursor_getRawCommentText(C: CXCursor, retValPlacement: NativePlacement): CXString { - val _C = C.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Cursor_getRawCommentText(_C, _retValPlacement) - return interpretPointed(res) +fun clang_Cursor_getRawCommentText(C: CValue): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getRawCommentText(_C, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_Cursor_getBriefCommentText(C: CXCursor, retValPlacement: NativePlacement): CXString { - val _C = C.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Cursor_getBriefCommentText(_C, _retValPlacement) - return interpretPointed(res) +fun clang_Cursor_getBriefCommentText(C: CValue): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getBriefCommentText(_C, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_Cursor_getMangling(arg0: CXCursor, retValPlacement: NativePlacement): CXString { - val _arg0 = arg0.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Cursor_getMangling(_arg0, _retValPlacement) - return interpretPointed(res) +fun clang_Cursor_getMangling(arg0: CValue): CValue { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getMangling(_arg0, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_Cursor_getCXXManglings(arg0: CXCursor): CPointer? { - val _arg0 = arg0.rawPtr - val res = externals.clang_Cursor_getCXXManglings(_arg0) - return interpretCPointer(res) +fun clang_Cursor_getCXXManglings(arg0: CValue): CPointer? { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getCXXManglings(_arg0) + interpretCPointer(res) + } } -fun clang_Cursor_getModule(C: CXCursor): CXModule? { - val _C = C.rawPtr - val res = externals.clang_Cursor_getModule(_C) - return interpretCPointer(res) +fun clang_Cursor_getModule(C: CValue): CXModule? { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_getModule(_C) + interpretCPointer(res) + } } fun clang_getModuleForFile(arg0: CXTranslationUnit?, arg1: CXFile?): CXModule? { @@ -1613,18 +1850,20 @@ fun clang_Module_getParent(Module: CXModule?): CXModule? { return interpretCPointer(res) } -fun clang_Module_getName(Module: CXModule?, retValPlacement: NativePlacement): CXString { - val _Module = Module.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Module_getName(_Module, _retValPlacement) - return interpretPointed(res) +fun clang_Module_getName(Module: CXModule?): CValue { + return memScoped { + val _Module = Module.rawValue + val res = externals.clang_Module_getName(_Module, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_Module_getFullName(Module: CXModule?, retValPlacement: NativePlacement): CXString { - val _Module = Module.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_Module_getFullName(_Module, _retValPlacement) - return interpretPointed(res) +fun clang_Module_getFullName(Module: CXModule?): CValue { + return memScoped { + val _Module = Module.rawValue + val res = externals.clang_Module_getFullName(_Module, alloc().rawPtr) + interpretPointed(res).readValue() + } } fun clang_Module_isSystem(Module: CXModule?): Int { @@ -1648,161 +1887,199 @@ fun clang_Module_getTopLevelHeader(arg0: CXTranslationUnit?, Module: CXModule?, return interpretCPointer(res) } -fun clang_CXXConstructor_isConvertingConstructor(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_CXXConstructor_isConvertingConstructor(_C) - return res +fun clang_CXXConstructor_isConvertingConstructor(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_CXXConstructor_isConvertingConstructor(_C) + res + } } -fun clang_CXXConstructor_isCopyConstructor(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_CXXConstructor_isCopyConstructor(_C) - return res +fun clang_CXXConstructor_isCopyConstructor(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_CXXConstructor_isCopyConstructor(_C) + res + } } -fun clang_CXXConstructor_isDefaultConstructor(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_CXXConstructor_isDefaultConstructor(_C) - return res +fun clang_CXXConstructor_isDefaultConstructor(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_CXXConstructor_isDefaultConstructor(_C) + res + } } -fun clang_CXXConstructor_isMoveConstructor(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_CXXConstructor_isMoveConstructor(_C) - return res +fun clang_CXXConstructor_isMoveConstructor(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_CXXConstructor_isMoveConstructor(_C) + res + } } -fun clang_CXXField_isMutable(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_CXXField_isMutable(_C) - return res +fun clang_CXXField_isMutable(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_CXXField_isMutable(_C) + res + } } -fun clang_CXXMethod_isDefaulted(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_CXXMethod_isDefaulted(_C) - return res +fun clang_CXXMethod_isDefaulted(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_CXXMethod_isDefaulted(_C) + res + } } -fun clang_CXXMethod_isPureVirtual(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_CXXMethod_isPureVirtual(_C) - return res +fun clang_CXXMethod_isPureVirtual(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_CXXMethod_isPureVirtual(_C) + res + } } -fun clang_CXXMethod_isStatic(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_CXXMethod_isStatic(_C) - return res +fun clang_CXXMethod_isStatic(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_CXXMethod_isStatic(_C) + res + } } -fun clang_CXXMethod_isVirtual(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_CXXMethod_isVirtual(_C) - return res +fun clang_CXXMethod_isVirtual(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_CXXMethod_isVirtual(_C) + res + } } -fun clang_CXXMethod_isConst(C: CXCursor): Int { - val _C = C.rawPtr - val res = externals.clang_CXXMethod_isConst(_C) - return res +fun clang_CXXMethod_isConst(C: CValue): Int { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_CXXMethod_isConst(_C) + res + } } -fun clang_getTemplateCursorKind(C: CXCursor): CXCursorKind { - val _C = C.rawPtr - val res = externals.clang_getTemplateCursorKind(_C) - return CXCursorKind.byValue(res) +fun clang_getTemplateCursorKind(C: CValue): CXCursorKind { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_getTemplateCursorKind(_C) + CXCursorKind.byValue(res) + } } -fun clang_getSpecializedCursorTemplate(C: CXCursor, retValPlacement: NativePlacement): CXCursor { - val _C = C.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getSpecializedCursorTemplate(_C, _retValPlacement) - return interpretPointed(res) +fun clang_getSpecializedCursorTemplate(C: CValue): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_getSpecializedCursorTemplate(_C, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getCursorReferenceNameRange(C: CXCursor, NameFlags: Int, PieceIndex: Int, retValPlacement: NativePlacement): CXSourceRange { - val _C = C.rawPtr - val _NameFlags = NameFlags - val _PieceIndex = PieceIndex - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorReferenceNameRange(_C, _NameFlags, _PieceIndex, _retValPlacement) - return interpretPointed(res) +fun clang_getCursorReferenceNameRange(C: CValue, NameFlags: Int, PieceIndex: Int): CValue { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val _NameFlags = NameFlags + val _PieceIndex = PieceIndex + val res = externals.clang_getCursorReferenceNameRange(_C, _NameFlags, _PieceIndex, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getTokenKind(arg0: CXToken): CXTokenKind { - val _arg0 = arg0.rawPtr - val res = externals.clang_getTokenKind(_arg0) - return CXTokenKind.byValue(res) +fun clang_getTokenKind(arg0: CValue): CXTokenKind { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val res = externals.clang_getTokenKind(_arg0) + CXTokenKind.byValue(res) + } } -fun clang_getTokenSpelling(arg0: CXTranslationUnit?, arg1: CXToken, retValPlacement: NativePlacement): CXString { - val _arg0 = arg0.rawValue - val _arg1 = arg1.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getTokenSpelling(_arg0, _arg1, _retValPlacement) - return interpretPointed(res) +fun clang_getTokenSpelling(arg0: CXTranslationUnit?, arg1: CValue): CValue { + return memScoped { + val _arg0 = arg0.rawValue + val _arg1 = arg1.getPointer(memScope).rawValue + val res = externals.clang_getTokenSpelling(_arg0, _arg1, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getTokenLocation(arg0: CXTranslationUnit?, arg1: CXToken, retValPlacement: NativePlacement): CXSourceLocation { - val _arg0 = arg0.rawValue - val _arg1 = arg1.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getTokenLocation(_arg0, _arg1, _retValPlacement) - return interpretPointed(res) +fun clang_getTokenLocation(arg0: CXTranslationUnit?, arg1: CValue): CValue { + return memScoped { + val _arg0 = arg0.rawValue + val _arg1 = arg1.getPointer(memScope).rawValue + val res = externals.clang_getTokenLocation(_arg0, _arg1, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getTokenExtent(arg0: CXTranslationUnit?, arg1: CXToken, retValPlacement: NativePlacement): CXSourceRange { - val _arg0 = arg0.rawValue - val _arg1 = arg1.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getTokenExtent(_arg0, _arg1, _retValPlacement) - return interpretPointed(res) +fun clang_getTokenExtent(arg0: CXTranslationUnit?, arg1: CValue): CValue { + return memScoped { + val _arg0 = arg0.rawValue + val _arg1 = arg1.getPointer(memScope).rawValue + val res = externals.clang_getTokenExtent(_arg0, _arg1, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_tokenize(TU: CXTranslationUnit?, Range: CXSourceRange, Tokens: CPointer>?, NumTokens: CPointer?): Unit { - val _TU = TU.rawValue - val _Range = Range.rawPtr - val _Tokens = Tokens.rawValue - val _NumTokens = NumTokens.rawValue - val res = externals.clang_tokenize(_TU, _Range, _Tokens, _NumTokens) - return res +fun clang_tokenize(TU: CXTranslationUnit?, Range: CValue, Tokens: CValuesRef>?, NumTokens: CValuesRef?): Unit { + return memScoped { + val _TU = TU.rawValue + val _Range = Range.getPointer(memScope).rawValue + val _Tokens = Tokens?.getPointer(memScope).rawValue + val _NumTokens = NumTokens?.getPointer(memScope).rawValue + val res = externals.clang_tokenize(_TU, _Range, _Tokens, _NumTokens) + res + } } -fun clang_annotateTokens(TU: CXTranslationUnit?, Tokens: CPointer?, NumTokens: Int, Cursors: CPointer?): Unit { - val _TU = TU.rawValue - val _Tokens = Tokens.rawValue - val _NumTokens = NumTokens - val _Cursors = Cursors.rawValue - val res = externals.clang_annotateTokens(_TU, _Tokens, _NumTokens, _Cursors) - return res +fun clang_annotateTokens(TU: CXTranslationUnit?, Tokens: CValuesRef?, NumTokens: Int, Cursors: CValuesRef?): Unit { + return memScoped { + val _TU = TU.rawValue + val _Tokens = Tokens?.getPointer(memScope).rawValue + val _NumTokens = NumTokens + val _Cursors = Cursors?.getPointer(memScope).rawValue + val res = externals.clang_annotateTokens(_TU, _Tokens, _NumTokens, _Cursors) + res + } } -fun clang_disposeTokens(TU: CXTranslationUnit?, Tokens: CPointer?, NumTokens: Int): Unit { - val _TU = TU.rawValue - val _Tokens = Tokens.rawValue - val _NumTokens = NumTokens - val res = externals.clang_disposeTokens(_TU, _Tokens, _NumTokens) - return res +fun clang_disposeTokens(TU: CXTranslationUnit?, Tokens: CValuesRef?, NumTokens: Int): Unit { + return memScoped { + val _TU = TU.rawValue + val _Tokens = Tokens?.getPointer(memScope).rawValue + val _NumTokens = NumTokens + val res = externals.clang_disposeTokens(_TU, _Tokens, _NumTokens) + res + } } -fun clang_getCursorKindSpelling(Kind: CXCursorKind, retValPlacement: NativePlacement): CXString { - val _Kind = Kind.value - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCursorKindSpelling(_Kind, _retValPlacement) - return interpretPointed(res) +fun clang_getCursorKindSpelling(Kind: CXCursorKind): CValue { + return memScoped { + val _Kind = Kind.value + val res = externals.clang_getCursorKindSpelling(_Kind, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getDefinitionSpellingAndExtent(arg0: CXCursor, startBuf: CPointer>?, endBuf: CPointer>?, startLine: CPointer?, startColumn: CPointer?, endLine: CPointer?, endColumn: CPointer?): Unit { - val _arg0 = arg0.rawPtr - val _startBuf = startBuf.rawValue - val _endBuf = endBuf.rawValue - val _startLine = startLine.rawValue - val _startColumn = startColumn.rawValue - val _endLine = endLine.rawValue - val _endColumn = endColumn.rawValue - val res = externals.clang_getDefinitionSpellingAndExtent(_arg0, _startBuf, _endBuf, _startLine, _startColumn, _endLine, _endColumn) - return res +fun clang_getDefinitionSpellingAndExtent(arg0: CValue, startBuf: CValuesRef>?, endBuf: CValuesRef>?, startLine: CValuesRef?, startColumn: CValuesRef?, endLine: CValuesRef?, endColumn: CValuesRef?): Unit { + return memScoped { + val _arg0 = arg0.getPointer(memScope).rawValue + val _startBuf = startBuf?.getPointer(memScope).rawValue + val _endBuf = endBuf?.getPointer(memScope).rawValue + val _startLine = startLine?.getPointer(memScope).rawValue + val _startColumn = startColumn?.getPointer(memScope).rawValue + val _endLine = endLine?.getPointer(memScope).rawValue + val _endColumn = endColumn?.getPointer(memScope).rawValue + val res = externals.clang_getDefinitionSpellingAndExtent(_arg0, _startBuf, _endBuf, _startLine, _startColumn, _endLine, _endColumn) + res + } } fun clang_enableStackTraces(): Unit { @@ -1810,7 +2087,7 @@ fun clang_enableStackTraces(): Unit { return res } -fun clang_executeOnThread(fn: CFunctionPointer?, user_data: COpaquePointer?, stack_size: Int): Unit { +fun clang_executeOnThread(fn: CPointer>?, user_data: COpaquePointer?, stack_size: Int): Unit { val _fn = fn.rawValue val _user_data = user_data.rawValue val _stack_size = stack_size @@ -1825,12 +2102,13 @@ fun clang_getCompletionChunkKind(completion_string: CXCompletionString?, chunk_n return CXCompletionChunkKind.byValue(res) } -fun clang_getCompletionChunkText(completion_string: CXCompletionString?, chunk_number: Int, retValPlacement: NativePlacement): CXString { - val _completion_string = completion_string.rawValue - val _chunk_number = chunk_number - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCompletionChunkText(_completion_string, _chunk_number, _retValPlacement) - return interpretPointed(res) +fun clang_getCompletionChunkText(completion_string: CXCompletionString?, chunk_number: Int): CValue { + return memScoped { + val _completion_string = completion_string.rawValue + val _chunk_number = chunk_number + val res = externals.clang_getCompletionChunkText(_completion_string, _chunk_number, alloc().rawPtr) + interpretPointed(res).readValue() + } } fun clang_getCompletionChunkCompletionString(completion_string: CXCompletionString?, chunk_number: Int): CXCompletionString? { @@ -1864,33 +2142,38 @@ fun clang_getCompletionNumAnnotations(completion_string: CXCompletionString?): I return res } -fun clang_getCompletionAnnotation(completion_string: CXCompletionString?, annotation_number: Int, retValPlacement: NativePlacement): CXString { - val _completion_string = completion_string.rawValue - val _annotation_number = annotation_number - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCompletionAnnotation(_completion_string, _annotation_number, _retValPlacement) - return interpretPointed(res) +fun clang_getCompletionAnnotation(completion_string: CXCompletionString?, annotation_number: Int): CValue { + return memScoped { + val _completion_string = completion_string.rawValue + val _annotation_number = annotation_number + val res = externals.clang_getCompletionAnnotation(_completion_string, _annotation_number, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getCompletionParent(completion_string: CXCompletionString?, kind: CPointer?, retValPlacement: NativePlacement): CXString { - val _completion_string = completion_string.rawValue - val _kind = kind.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCompletionParent(_completion_string, _kind, _retValPlacement) - return interpretPointed(res) +fun clang_getCompletionParent(completion_string: CXCompletionString?, kind: CValuesRef?): CValue { + return memScoped { + val _completion_string = completion_string.rawValue + val _kind = kind?.getPointer(memScope).rawValue + val res = externals.clang_getCompletionParent(_completion_string, _kind, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getCompletionBriefComment(completion_string: CXCompletionString?, retValPlacement: NativePlacement): CXString { - val _completion_string = completion_string.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getCompletionBriefComment(_completion_string, _retValPlacement) - return interpretPointed(res) +fun clang_getCompletionBriefComment(completion_string: CXCompletionString?): CValue { + return memScoped { + val _completion_string = completion_string.rawValue + val res = externals.clang_getCompletionBriefComment(_completion_string, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getCursorCompletionString(cursor: CXCursor): CXCompletionString? { - val _cursor = cursor.rawPtr - val res = externals.clang_getCursorCompletionString(_cursor) - return interpretCPointer(res) +fun clang_getCursorCompletionString(cursor: CValue): CXCompletionString? { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val res = externals.clang_getCursorCompletionString(_cursor) + interpretCPointer(res) + } } fun clang_defaultCodeCompleteOptions(): Int { @@ -1898,13 +2181,13 @@ fun clang_defaultCodeCompleteOptions(): Int { return res } -fun clang_codeCompleteAt(TU: CXTranslationUnit?, complete_filename: String?, complete_line: Int, complete_column: Int, unsaved_files: CPointer?, num_unsaved_files: Int, options: Int): CPointer? { +fun clang_codeCompleteAt(TU: CXTranslationUnit?, complete_filename: String?, complete_line: Int, complete_column: Int, unsaved_files: CValuesRef?, num_unsaved_files: Int, options: Int): CPointer? { return memScoped { val _TU = TU.rawValue - val _complete_filename = complete_filename?.toCString(memScope).rawPtr + val _complete_filename = complete_filename?.cstr?.getPointer(memScope).rawValue val _complete_line = complete_line val _complete_column = complete_column - val _unsaved_files = unsaved_files.rawValue + val _unsaved_files = unsaved_files?.getPointer(memScope).rawValue val _num_unsaved_files = num_unsaved_files val _options = options val res = externals.clang_codeCompleteAt(_TU, _complete_filename, _complete_line, _complete_column, _unsaved_files, _num_unsaved_files, _options) @@ -1912,63 +2195,78 @@ fun clang_codeCompleteAt(TU: CXTranslationUnit?, complete_filename: String?, com } } -fun clang_sortCodeCompletionResults(Results: CPointer?, NumResults: Int): Unit { - val _Results = Results.rawValue - val _NumResults = NumResults - val res = externals.clang_sortCodeCompletionResults(_Results, _NumResults) - return res +fun clang_sortCodeCompletionResults(Results: CValuesRef?, NumResults: Int): Unit { + return memScoped { + val _Results = Results?.getPointer(memScope).rawValue + val _NumResults = NumResults + val res = externals.clang_sortCodeCompletionResults(_Results, _NumResults) + res + } } -fun clang_disposeCodeCompleteResults(Results: CPointer?): Unit { - val _Results = Results.rawValue - val res = externals.clang_disposeCodeCompleteResults(_Results) - return res +fun clang_disposeCodeCompleteResults(Results: CValuesRef?): Unit { + return memScoped { + val _Results = Results?.getPointer(memScope).rawValue + val res = externals.clang_disposeCodeCompleteResults(_Results) + res + } } -fun clang_codeCompleteGetNumDiagnostics(Results: CPointer?): Int { - val _Results = Results.rawValue - val res = externals.clang_codeCompleteGetNumDiagnostics(_Results) - return res +fun clang_codeCompleteGetNumDiagnostics(Results: CValuesRef?): Int { + return memScoped { + val _Results = Results?.getPointer(memScope).rawValue + val res = externals.clang_codeCompleteGetNumDiagnostics(_Results) + res + } } -fun clang_codeCompleteGetDiagnostic(Results: CPointer?, Index: Int): CXDiagnostic? { - val _Results = Results.rawValue - val _Index = Index - val res = externals.clang_codeCompleteGetDiagnostic(_Results, _Index) - return interpretCPointer(res) +fun clang_codeCompleteGetDiagnostic(Results: CValuesRef?, Index: Int): CXDiagnostic? { + return memScoped { + val _Results = Results?.getPointer(memScope).rawValue + val _Index = Index + val res = externals.clang_codeCompleteGetDiagnostic(_Results, _Index) + interpretCPointer(res) + } } -fun clang_codeCompleteGetContexts(Results: CPointer?): Long { - val _Results = Results.rawValue - val res = externals.clang_codeCompleteGetContexts(_Results) - return res +fun clang_codeCompleteGetContexts(Results: CValuesRef?): Long { + return memScoped { + val _Results = Results?.getPointer(memScope).rawValue + val res = externals.clang_codeCompleteGetContexts(_Results) + res + } } -fun clang_codeCompleteGetContainerKind(Results: CPointer?, IsIncomplete: CPointer?): CXCursorKind { - val _Results = Results.rawValue - val _IsIncomplete = IsIncomplete.rawValue - val res = externals.clang_codeCompleteGetContainerKind(_Results, _IsIncomplete) - return CXCursorKind.byValue(res) +fun clang_codeCompleteGetContainerKind(Results: CValuesRef?, IsIncomplete: CValuesRef?): CXCursorKind { + return memScoped { + val _Results = Results?.getPointer(memScope).rawValue + val _IsIncomplete = IsIncomplete?.getPointer(memScope).rawValue + val res = externals.clang_codeCompleteGetContainerKind(_Results, _IsIncomplete) + CXCursorKind.byValue(res) + } } -fun clang_codeCompleteGetContainerUSR(Results: CPointer?, retValPlacement: NativePlacement): CXString { - val _Results = Results.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_codeCompleteGetContainerUSR(_Results, _retValPlacement) - return interpretPointed(res) +fun clang_codeCompleteGetContainerUSR(Results: CValuesRef?): CValue { + return memScoped { + val _Results = Results?.getPointer(memScope).rawValue + val res = externals.clang_codeCompleteGetContainerUSR(_Results, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_codeCompleteGetObjCSelector(Results: CPointer?, retValPlacement: NativePlacement): CXString { - val _Results = Results.rawValue - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_codeCompleteGetObjCSelector(_Results, _retValPlacement) - return interpretPointed(res) +fun clang_codeCompleteGetObjCSelector(Results: CValuesRef?): CValue { + return memScoped { + val _Results = Results?.getPointer(memScope).rawValue + val res = externals.clang_codeCompleteGetObjCSelector(_Results, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_getClangVersion(retValPlacement: NativePlacement): CXString { - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_getClangVersion(_retValPlacement) - return interpretPointed(res) +fun clang_getClangVersion(): CValue { + return memScoped { + val res = externals.clang_getClangVersion(alloc().rawPtr) + interpretPointed(res).readValue() + } } fun clang_toggleCrashRecovery(isEnabled: Int): Unit { @@ -1985,10 +2283,12 @@ fun clang_getInclusions(tu: CXTranslationUnit?, visitor: CXInclusionVisitor?, cl return res } -fun clang_Cursor_Evaluate(C: CXCursor): CXEvalResult? { - val _C = C.rawPtr - val res = externals.clang_Cursor_Evaluate(_C) - return interpretCPointer(res) +fun clang_Cursor_Evaluate(C: CValue): CXEvalResult? { + return memScoped { + val _C = C.getPointer(memScope).rawValue + val res = externals.clang_Cursor_Evaluate(_C) + interpretCPointer(res) + } } fun clang_EvalResult_getKind(E: CXEvalResult?): CXEvalResultKind { @@ -2023,17 +2323,19 @@ fun clang_EvalResult_dispose(E: CXEvalResult?): Unit { fun clang_getRemappings(path: String?): CXRemapping? { return memScoped { - val _path = path?.toCString(memScope).rawPtr + val _path = path?.cstr?.getPointer(memScope).rawValue val res = externals.clang_getRemappings(_path) interpretCPointer(res) } } -fun clang_getRemappingsFromFileList(filePaths: CPointer>?, numFiles: Int): CXRemapping? { - val _filePaths = filePaths.rawValue - val _numFiles = numFiles - val res = externals.clang_getRemappingsFromFileList(_filePaths, _numFiles) - return interpretCPointer(res) +fun clang_getRemappingsFromFileList(filePaths: CValuesRef>?, numFiles: Int): CXRemapping? { + return memScoped { + val _filePaths = filePaths?.getPointer(memScope).rawValue + val _numFiles = numFiles + val res = externals.clang_getRemappingsFromFileList(_filePaths, _numFiles) + interpretCPointer(res) + } } fun clang_remap_getNumFiles(arg0: CXRemapping?): Int { @@ -2042,13 +2344,15 @@ fun clang_remap_getNumFiles(arg0: CXRemapping?): Int { return res } -fun clang_remap_getFilenames(arg0: CXRemapping?, index: Int, original: CPointer?, transformed: CPointer?): Unit { - val _arg0 = arg0.rawValue - val _index = index - val _original = original.rawValue - val _transformed = transformed.rawValue - val res = externals.clang_remap_getFilenames(_arg0, _index, _original, _transformed) - return res +fun clang_remap_getFilenames(arg0: CXRemapping?, index: Int, original: CValuesRef?, transformed: CValuesRef?): Unit { + return memScoped { + val _arg0 = arg0.rawValue + val _index = index + val _original = original?.getPointer(memScope).rawValue + val _transformed = transformed?.getPointer(memScope).rawValue + val res = externals.clang_remap_getFilenames(_arg0, _index, _original, _transformed) + res + } } fun clang_remap_dispose(arg0: CXRemapping?): Unit { @@ -2057,20 +2361,24 @@ fun clang_remap_dispose(arg0: CXRemapping?): Unit { return res } -fun clang_findReferencesInFile(cursor: CXCursor, file: CXFile?, visitor: CXCursorAndRangeVisitor): CXResult { - val _cursor = cursor.rawPtr - val _file = file.rawValue - val _visitor = visitor.rawPtr - val res = externals.clang_findReferencesInFile(_cursor, _file, _visitor) - return CXResult.byValue(res) +fun clang_findReferencesInFile(cursor: CValue, file: CXFile?, visitor: CValue): CXResult { + return memScoped { + val _cursor = cursor.getPointer(memScope).rawValue + val _file = file.rawValue + val _visitor = visitor.getPointer(memScope).rawValue + val res = externals.clang_findReferencesInFile(_cursor, _file, _visitor) + CXResult.byValue(res) + } } -fun clang_findIncludesInFile(TU: CXTranslationUnit?, file: CXFile?, visitor: CXCursorAndRangeVisitor): CXResult { - val _TU = TU.rawValue - val _file = file.rawValue - val _visitor = visitor.rawPtr - val res = externals.clang_findIncludesInFile(_TU, _file, _visitor) - return CXResult.byValue(res) +fun clang_findIncludesInFile(TU: CXTranslationUnit?, file: CXFile?, visitor: CValue): CXResult { + return memScoped { + val _TU = TU.rawValue + val _file = file.rawValue + val _visitor = visitor.getPointer(memScope).rawValue + val res = externals.clang_findIncludesInFile(_TU, _file, _visitor) + CXResult.byValue(res) + } } fun clang_index_isEntityObjCContainerKind(arg0: CXIdxEntityKind): Int { @@ -2079,72 +2387,94 @@ fun clang_index_isEntityObjCContainerKind(arg0: CXIdxEntityKind): Int { return res } -fun clang_index_getObjCContainerDeclInfo(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.clang_index_getObjCContainerDeclInfo(_arg0) - return interpretCPointer(res) +fun clang_index_getObjCContainerDeclInfo(arg0: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.clang_index_getObjCContainerDeclInfo(_arg0) + interpretCPointer(res) + } } -fun clang_index_getObjCInterfaceDeclInfo(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.clang_index_getObjCInterfaceDeclInfo(_arg0) - return interpretCPointer(res) +fun clang_index_getObjCInterfaceDeclInfo(arg0: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.clang_index_getObjCInterfaceDeclInfo(_arg0) + interpretCPointer(res) + } } -fun clang_index_getObjCCategoryDeclInfo(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.clang_index_getObjCCategoryDeclInfo(_arg0) - return interpretCPointer(res) +fun clang_index_getObjCCategoryDeclInfo(arg0: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.clang_index_getObjCCategoryDeclInfo(_arg0) + interpretCPointer(res) + } } -fun clang_index_getObjCProtocolRefListInfo(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.clang_index_getObjCProtocolRefListInfo(_arg0) - return interpretCPointer(res) +fun clang_index_getObjCProtocolRefListInfo(arg0: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.clang_index_getObjCProtocolRefListInfo(_arg0) + interpretCPointer(res) + } } -fun clang_index_getObjCPropertyDeclInfo(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.clang_index_getObjCPropertyDeclInfo(_arg0) - return interpretCPointer(res) +fun clang_index_getObjCPropertyDeclInfo(arg0: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.clang_index_getObjCPropertyDeclInfo(_arg0) + interpretCPointer(res) + } } -fun clang_index_getIBOutletCollectionAttrInfo(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.clang_index_getIBOutletCollectionAttrInfo(_arg0) - return interpretCPointer(res) +fun clang_index_getIBOutletCollectionAttrInfo(arg0: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.clang_index_getIBOutletCollectionAttrInfo(_arg0) + interpretCPointer(res) + } } -fun clang_index_getCXXClassDeclInfo(arg0: CPointer?): CPointer? { - val _arg0 = arg0.rawValue - val res = externals.clang_index_getCXXClassDeclInfo(_arg0) - return interpretCPointer(res) +fun clang_index_getCXXClassDeclInfo(arg0: CValuesRef?): CPointer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.clang_index_getCXXClassDeclInfo(_arg0) + interpretCPointer(res) + } } -fun clang_index_getClientContainer(arg0: CPointer?): CXIdxClientContainer? { - val _arg0 = arg0.rawValue - val res = externals.clang_index_getClientContainer(_arg0) - return interpretCPointer(res) +fun clang_index_getClientContainer(arg0: CValuesRef?): CXIdxClientContainer? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.clang_index_getClientContainer(_arg0) + interpretCPointer(res) + } } -fun clang_index_setClientContainer(arg0: CPointer?, arg1: CXIdxClientContainer?): Unit { - val _arg0 = arg0.rawValue - val _arg1 = arg1.rawValue - val res = externals.clang_index_setClientContainer(_arg0, _arg1) - return res +fun clang_index_setClientContainer(arg0: CValuesRef?, arg1: CXIdxClientContainer?): Unit { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val _arg1 = arg1.rawValue + val res = externals.clang_index_setClientContainer(_arg0, _arg1) + res + } } -fun clang_index_getClientEntity(arg0: CPointer?): CXIdxClientEntity? { - val _arg0 = arg0.rawValue - val res = externals.clang_index_getClientEntity(_arg0) - return interpretCPointer(res) +fun clang_index_getClientEntity(arg0: CValuesRef?): CXIdxClientEntity? { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val res = externals.clang_index_getClientEntity(_arg0) + interpretCPointer(res) + } } -fun clang_index_setClientEntity(arg0: CPointer?, arg1: CXIdxClientEntity?): Unit { - val _arg0 = arg0.rawValue - val _arg1 = arg1.rawValue - val res = externals.clang_index_setClientEntity(_arg0, _arg1) - return res +fun clang_index_setClientEntity(arg0: CValuesRef?, arg1: CXIdxClientEntity?): Unit { + return memScoped { + val _arg0 = arg0?.getPointer(memScope).rawValue + val _arg1 = arg1.rawValue + val res = externals.clang_index_setClientEntity(_arg0, _arg1) + res + } } fun clang_IndexAction_create(CIdx: CXIndex?): CXIndexAction? { @@ -2159,79 +2489,86 @@ fun clang_IndexAction_dispose(arg0: CXIndexAction?): Unit { return res } -fun clang_indexSourceFile(arg0: CXIndexAction?, client_data: CXClientData?, index_callbacks: CPointer?, index_callbacks_size: Int, index_options: Int, source_filename: String?, command_line_args: CPointer>?, num_command_line_args: Int, unsaved_files: CPointer?, num_unsaved_files: Int, out_TU: CPointer?, TU_options: Int): Int { +fun clang_indexSourceFile(arg0: CXIndexAction?, client_data: CXClientData?, index_callbacks: CValuesRef?, index_callbacks_size: Int, index_options: Int, source_filename: String?, command_line_args: CValuesRef>?, num_command_line_args: Int, unsaved_files: CValuesRef?, num_unsaved_files: Int, out_TU: CValuesRef?, TU_options: Int): Int { return memScoped { val _arg0 = arg0.rawValue val _client_data = client_data.rawValue - val _index_callbacks = index_callbacks.rawValue + val _index_callbacks = index_callbacks?.getPointer(memScope).rawValue val _index_callbacks_size = index_callbacks_size val _index_options = index_options - val _source_filename = source_filename?.toCString(memScope).rawPtr - val _command_line_args = command_line_args.rawValue + val _source_filename = source_filename?.cstr?.getPointer(memScope).rawValue + val _command_line_args = command_line_args?.getPointer(memScope).rawValue val _num_command_line_args = num_command_line_args - val _unsaved_files = unsaved_files.rawValue + val _unsaved_files = unsaved_files?.getPointer(memScope).rawValue val _num_unsaved_files = num_unsaved_files - val _out_TU = out_TU.rawValue + val _out_TU = out_TU?.getPointer(memScope).rawValue val _TU_options = TU_options val res = externals.clang_indexSourceFile(_arg0, _client_data, _index_callbacks, _index_callbacks_size, _index_options, _source_filename, _command_line_args, _num_command_line_args, _unsaved_files, _num_unsaved_files, _out_TU, _TU_options) res } } -fun clang_indexSourceFileFullArgv(arg0: CXIndexAction?, client_data: CXClientData?, index_callbacks: CPointer?, index_callbacks_size: Int, index_options: Int, source_filename: String?, command_line_args: CPointer>?, num_command_line_args: Int, unsaved_files: CPointer?, num_unsaved_files: Int, out_TU: CPointer?, TU_options: Int): Int { +fun clang_indexSourceFileFullArgv(arg0: CXIndexAction?, client_data: CXClientData?, index_callbacks: CValuesRef?, index_callbacks_size: Int, index_options: Int, source_filename: String?, command_line_args: CValuesRef>?, num_command_line_args: Int, unsaved_files: CValuesRef?, num_unsaved_files: Int, out_TU: CValuesRef?, TU_options: Int): Int { return memScoped { val _arg0 = arg0.rawValue val _client_data = client_data.rawValue - val _index_callbacks = index_callbacks.rawValue + val _index_callbacks = index_callbacks?.getPointer(memScope).rawValue val _index_callbacks_size = index_callbacks_size val _index_options = index_options - val _source_filename = source_filename?.toCString(memScope).rawPtr - val _command_line_args = command_line_args.rawValue + val _source_filename = source_filename?.cstr?.getPointer(memScope).rawValue + val _command_line_args = command_line_args?.getPointer(memScope).rawValue val _num_command_line_args = num_command_line_args - val _unsaved_files = unsaved_files.rawValue + val _unsaved_files = unsaved_files?.getPointer(memScope).rawValue val _num_unsaved_files = num_unsaved_files - val _out_TU = out_TU.rawValue + val _out_TU = out_TU?.getPointer(memScope).rawValue val _TU_options = TU_options val res = externals.clang_indexSourceFileFullArgv(_arg0, _client_data, _index_callbacks, _index_callbacks_size, _index_options, _source_filename, _command_line_args, _num_command_line_args, _unsaved_files, _num_unsaved_files, _out_TU, _TU_options) res } } -fun clang_indexTranslationUnit(arg0: CXIndexAction?, client_data: CXClientData?, index_callbacks: CPointer?, index_callbacks_size: Int, index_options: Int, arg5: CXTranslationUnit?): Int { - val _arg0 = arg0.rawValue - val _client_data = client_data.rawValue - val _index_callbacks = index_callbacks.rawValue - val _index_callbacks_size = index_callbacks_size - val _index_options = index_options - val _arg5 = arg5.rawValue - val res = externals.clang_indexTranslationUnit(_arg0, _client_data, _index_callbacks, _index_callbacks_size, _index_options, _arg5) - return res +fun clang_indexTranslationUnit(arg0: CXIndexAction?, client_data: CXClientData?, index_callbacks: CValuesRef?, index_callbacks_size: Int, index_options: Int, arg5: CXTranslationUnit?): Int { + return memScoped { + val _arg0 = arg0.rawValue + val _client_data = client_data.rawValue + val _index_callbacks = index_callbacks?.getPointer(memScope).rawValue + val _index_callbacks_size = index_callbacks_size + val _index_options = index_options + val _arg5 = arg5.rawValue + val res = externals.clang_indexTranslationUnit(_arg0, _client_data, _index_callbacks, _index_callbacks_size, _index_options, _arg5) + res + } } -fun clang_indexLoc_getFileLocation(loc: CXIdxLoc, indexFile: CPointer?, file: CPointer?, line: CPointer?, column: CPointer?, offset: CPointer?): Unit { - val _loc = loc.rawPtr - val _indexFile = indexFile.rawValue - val _file = file.rawValue - val _line = line.rawValue - val _column = column.rawValue - val _offset = offset.rawValue - val res = externals.clang_indexLoc_getFileLocation(_loc, _indexFile, _file, _line, _column, _offset) - return res +fun clang_indexLoc_getFileLocation(loc: CValue, indexFile: CValuesRef?, file: CValuesRef?, line: CValuesRef?, column: CValuesRef?, offset: CValuesRef?): Unit { + return memScoped { + val _loc = loc.getPointer(memScope).rawValue + val _indexFile = indexFile?.getPointer(memScope).rawValue + val _file = file?.getPointer(memScope).rawValue + val _line = line?.getPointer(memScope).rawValue + val _column = column?.getPointer(memScope).rawValue + val _offset = offset?.getPointer(memScope).rawValue + val res = externals.clang_indexLoc_getFileLocation(_loc, _indexFile, _file, _line, _column, _offset) + res + } } -fun clang_indexLoc_getCXSourceLocation(loc: CXIdxLoc, retValPlacement: NativePlacement): CXSourceLocation { - val _loc = loc.rawPtr - val _retValPlacement = retValPlacement.alloc().rawPtr - val res = externals.clang_indexLoc_getCXSourceLocation(_loc, _retValPlacement) - return interpretPointed(res) +fun clang_indexLoc_getCXSourceLocation(loc: CValue): CValue { + return memScoped { + val _loc = loc.getPointer(memScope).rawValue + val res = externals.clang_indexLoc_getCXSourceLocation(_loc, alloc().rawPtr) + interpretPointed(res).readValue() + } } -fun clang_Type_visitFields(T: CXType, visitor: CXFieldVisitor?, client_data: CXClientData?): Int { - val _T = T.rawPtr - val _visitor = visitor.rawValue - val _client_data = client_data.rawValue - val res = externals.clang_Type_visitFields(_T, _visitor, _client_data) - return res +fun clang_Type_visitFields(T: CValue, visitor: CXFieldVisitor?, client_data: CXClientData?): Int { + return memScoped { + val _T = T.getPointer(memScope).rawValue + val _visitor = visitor.rawValue + val _client_data = client_data.rawValue + val res = externals.clang_Type_visitFields(_T, _visitor, _client_data) + res + } } val __llvm__: Int = 1 @@ -2520,7 +2857,7 @@ class __darwin_pthread_handler_rec(override val rawPtr: NativePtr) : CStructVar( companion object : Type(24, 8) - val __routine: CFunctionPointerVar + val __routine: CPointerVar> get() = memberAt(0) val __arg: COpaquePointerVar @@ -2924,7 +3261,7 @@ class CXCursorAndRangeVisitor(override val rawPtr: NativePtr) : CStructVar() { val context: COpaquePointerVar get() = memberAt(0) - val visit: CFunctionPointerVar + val visit: CPointerVar> get() = memberAt(8) } @@ -3248,28 +3585,28 @@ class IndexerCallbacks(override val rawPtr: NativePtr) : CStructVar() { companion object : Type(64, 8) - val abortQuery: CFunctionPointerVar + val abortQuery: CPointerVar> get() = memberAt(0) - val diagnostic: CFunctionPointerVar + val diagnostic: CPointerVar> get() = memberAt(8) - val enteredMainFile: CFunctionPointerVar + val enteredMainFile: CPointerVar> get() = memberAt(16) - val ppIncludedFile: CFunctionPointerVar + val ppIncludedFile: CPointerVar> get() = memberAt(24) - val importedASTFile: CFunctionPointerVar + val importedASTFile: CPointerVar> get() = memberAt(32) - val startedTranslationUnit: CFunctionPointerVar + val startedTranslationUnit: CPointerVar> get() = memberAt(40) - val indexDeclaration: CFunctionPointerVar + val indexDeclaration: CPointerVar> get() = memberAt(48) - val indexEntityReference: CFunctionPointerVar + val indexEntityReference: CPointerVar> get() = memberAt(56) } @@ -4277,7 +4614,7 @@ typealias CXCursorSetVar = CPointerVarWithValueMappedTo typealias CXCursorSet = CPointer typealias CXCursorVisitorVar = CPointerVarWithValueMappedTo -typealias CXCursorVisitor = CFunctionPointer +typealias CXCursorVisitor = CPointer> typealias CXClientDataVar = CPointerVarWithValueMappedTo typealias CXClientData = COpaquePointer @@ -4289,7 +4626,7 @@ typealias CXCompletionStringVar = CPointerVarWithValueMappedTo -typealias CXInclusionVisitor = CFunctionPointer +typealias CXInclusionVisitor = CPointer> typealias CXEvalResultVar = CPointerVarWithValueMappedTo typealias CXEvalResult = COpaquePointer @@ -4310,7 +4647,7 @@ typealias CXIdxClientFileVar = CPointerVarWithValueMappedTo typealias CXIdxClientFile = COpaquePointer typealias CXFieldVisitorVar = CPointerVarWithValueMappedTo -typealias CXFieldVisitor = CFunctionPointer +typealias CXFieldVisitor = CPointer> typealias __darwin_wint_tVar = CInt32VarWithValueMappedTo<__darwin_wint_t> typealias __darwin_wint_t = Int @@ -4341,61 +4678,67 @@ object CFunctionType4 : CAdaptedFunctionTypeImpl<(CXCursor, COpaquePointer?) -> } } -object CFunctionType5 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CXCursor, CXSourceRange) -> CXVisitorResult>(UInt32, Pointer, Struct(UInt32, SInt32, Struct(Pointer, Pointer, Pointer)), Struct(Struct(Pointer, Pointer), UInt32, UInt32)) { +object CFunctionType5 : CAdaptedFunctionTypeImpl<(COpaquePointer?) -> Unit>(Void, Pointer) { + override fun invoke(function: (COpaquePointer?) -> Unit, args: CArray, ret: COpaquePointer) { + val res = function(args[0].value!!.reinterpret().pointed.value) + } +} + +object CFunctionType6 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CXCursor, CXSourceRange) -> CXVisitorResult>(UInt32, Pointer, Struct(UInt32, SInt32, Struct(Pointer, Pointer, Pointer)), Struct(Struct(Pointer, Pointer), UInt32, UInt32)) { override fun invoke(function: (COpaquePointer?, CXCursor, CXSourceRange) -> CXVisitorResult, args: CArray, ret: COpaquePointer) { val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret().pointed, args[2].value!!.reinterpret().pointed) ret.reinterpret().pointed.value = res } } -object CFunctionType6 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?) -> Int>(SInt32, Pointer, Pointer) { +object CFunctionType7 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?) -> Int>(SInt32, Pointer, Pointer) { override fun invoke(function: (COpaquePointer?, COpaquePointer?) -> Int, args: CArray, ret: COpaquePointer) { val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret().pointed.value) ret.reinterpret().pointed.value = res } } -object CFunctionType7 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?, COpaquePointer?) -> Unit>(Void, Pointer, Pointer, Pointer) { +object CFunctionType8 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?, COpaquePointer?) -> Unit>(Void, Pointer, Pointer, Pointer) { override fun invoke(function: (COpaquePointer?, COpaquePointer?, COpaquePointer?) -> Unit, args: CArray, ret: COpaquePointer) { val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret().pointed.value, args[2].value!!.reinterpret().pointed.value) } } -object CFunctionType8 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?, COpaquePointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer, Pointer) { +object CFunctionType9 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?, COpaquePointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer, Pointer) { override fun invoke(function: (COpaquePointer?, COpaquePointer?, COpaquePointer?) -> COpaquePointer?, args: CArray, ret: COpaquePointer) { val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret().pointed.value, args[2].value!!.reinterpret().pointed.value) ret.reinterpret().pointed.value = res } } -object CFunctionType9 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer) { +object CFunctionType10 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer) { override fun invoke(function: (COpaquePointer?, CPointer?) -> COpaquePointer?, args: CArray, ret: COpaquePointer) { val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret>().pointed.value) ret.reinterpret().pointed.value = res } } -object CFunctionType10 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer) { +object CFunctionType11 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer) { override fun invoke(function: (COpaquePointer?, CPointer?) -> COpaquePointer?, args: CArray, ret: COpaquePointer) { val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret>().pointed.value) ret.reinterpret().pointed.value = res } } -object CFunctionType11 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer) { +object CFunctionType12 : CAdaptedFunctionTypeImpl<(COpaquePointer?, COpaquePointer?) -> COpaquePointer?>(Pointer, Pointer, Pointer) { override fun invoke(function: (COpaquePointer?, COpaquePointer?) -> COpaquePointer?, args: CArray, ret: COpaquePointer) { val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret().pointed.value) ret.reinterpret().pointed.value = res } } -object CFunctionType12 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> Unit>(Void, Pointer, Pointer) { +object CFunctionType13 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> Unit>(Void, Pointer, Pointer) { override fun invoke(function: (COpaquePointer?, CPointer?) -> Unit, args: CArray, ret: COpaquePointer) { val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret>().pointed.value) } } -object CFunctionType13 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> Unit>(Void, Pointer, Pointer) { +object CFunctionType14 : CAdaptedFunctionTypeImpl<(COpaquePointer?, CPointer?) -> Unit>(Void, Pointer, Pointer) { override fun invoke(function: (COpaquePointer?, CPointer?) -> Unit, args: CArray, ret: COpaquePointer) { val res = function(args[0].value!!.reinterpret().pointed.value, args[1].value!!.reinterpret>().pointed.value) } diff --git a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt index ea69557ae90..2493d87a1c0 100644 --- a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt +++ b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Indexer.kt @@ -45,25 +45,23 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { override val macroConstants = mutableListOf() - private fun getDeclarationId(cursor: CXCursor): DeclarationID = memScoped { - val usr = clang_getCursorUSR(cursor, memScope).convertAndDispose() - DeclarationID(usr) + private fun getDeclarationId(cursor: CValue): DeclarationID { + val usr = clang_getCursorUSR(cursor).convertAndDispose() + return DeclarationID(usr) } - private fun getStructDeclAt(cursor: CXCursor): StructDeclImpl { + private fun getStructDeclAt(cursor: CValue): StructDeclImpl { val declId = getDeclarationId(cursor) return structById.getOrPut(declId) { - memScoped { - val cursorType = clang_getCursorType(cursor, memScope) - val typeSpelling = clang_getTypeSpelling(cursorType, memScope).convertAndDispose() + val cursorType = clang_getCursorType(cursor) + val typeSpelling = clang_getTypeSpelling(cursorType).convertAndDispose() - StructDeclImpl(typeSpelling) - } + StructDeclImpl(typeSpelling) } } - private fun getEnumDefAt(cursor: CXCursor): EnumDefImpl { + private fun getEnumDefAt(cursor: CValue): EnumDefImpl { if (clang_isCursorDefinition(cursor) == 0) { TODO("support enum forward declarations") } @@ -71,19 +69,17 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { val declId = getDeclarationId(cursor) return enumById.getOrPut(declId) { - memScoped { - val cursorType = clang_getCursorType(cursor, memScope) - val typeSpelling = clang_getTypeSpelling(cursorType, memScope).convertAndDispose() + val cursorType = clang_getCursorType(cursor) + val typeSpelling = clang_getTypeSpelling(cursorType).convertAndDispose() - val baseType = convertType(clang_getEnumDeclIntegerType(cursor, memScope)) as PrimitiveType + val baseType = convertType(clang_getEnumDeclIntegerType(cursor)) as PrimitiveType - EnumDefImpl(typeSpelling, baseType) - } + EnumDefImpl(typeSpelling, baseType) } } - private fun builtinVaListType(type: CXType, name: String, underlying: Type): Type { - assert (type.kind.value == CXType_Typedef) + private fun builtinVaListType(type: CValue, name: String, underlying: Type): Type { + assert (type.kind == CXType_Typedef) val declarationId = DeclarationID("c:@T@$name") val structDeclaration = structById.getOrPut(declarationId) { @@ -100,11 +96,11 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { return ConstArrayType(RecordType(structDeclaration), 1) } - fun getTypedef(type: CXType): Type = memScoped { - val declCursor = clang_getTypeDeclaration(type, memScope) + fun getTypedef(type: CValue): Type { + val declCursor = clang_getTypeDeclaration(type) val name = getCursorSpelling(declCursor) - val underlying = convertType(clang_getTypedefDeclUnderlyingType(declCursor, memScope)) + val underlying = convertType(clang_getTypedefDeclUnderlyingType(declCursor)) if (name == "__builtin_va_list") { // On some platforms (e.g. macOS) libclang reports `__builtin_va_list` to be defined as array using @@ -136,8 +132,8 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { /** * Computes [StructDef.hasNaturalLayout] property. */ - fun structHasNaturalLayout(structDefCursor: CXCursor): Boolean { - val defKind = structDefCursor.kind.value + fun structHasNaturalLayout(structDefCursor: CValue): Boolean { + val defKind = structDefCursor.kind when (defKind) { @@ -161,23 +157,22 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { } } - private fun convertCursorType(cursor: CXCursor) = memScoped { - convertType(clang_getCursorType(cursor, memScope)) - } + private fun convertCursorType(cursor: CValue) = + convertType(clang_getCursorType(cursor)) - fun convertType(type: CXType): Type = memScoped { + fun convertType(type: CValue): Type { val primitiveType = convertUnqualifiedPrimitiveType(type) if (primitiveType != UnsupportedType) { return primitiveType } - val kind = type.kind.value + val kind = type.kind return when (kind) { - CXType_Elaborated -> convertType(clang_Type_getNamedType(type, memScope)) + CXType_Elaborated -> convertType(clang_Type_getNamedType(type)) CXType_Unexposed -> { - val canonicalType = clang_getCanonicalType(type, memScope) - if (canonicalType.kind.value != CXType_Unexposed) { + val canonicalType = clang_getCanonicalType(type) + if (canonicalType.kind != CXType_Unexposed) { convertType(canonicalType) } else { throw NotImplementedError() @@ -188,19 +183,27 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { CXType_Typedef -> getTypedef(type) - CXType_Record -> RecordType(getStructDeclAt(clang_getTypeDeclaration(type, memScope))) - CXType_Enum -> EnumType(getEnumDefAt(clang_getTypeDeclaration(type, memScope))) + CXType_Record -> RecordType(getStructDeclAt(clang_getTypeDeclaration(type))) + CXType_Enum -> EnumType(getEnumDefAt(clang_getTypeDeclaration(type))) - CXType_Pointer -> PointerType(convertType(clang_getPointeeType(type, memScope))) + CXType_Pointer -> { + val pointeeType = clang_getPointeeType(type) + val canonicalPointeeType = clang_getCanonicalType(pointeeType) + if (clang_isConstQualifiedType(canonicalPointeeType) != 0) { + PointerToConstType(convertType(pointeeType)) + } else { + PointerType(convertType(pointeeType)) + } + } CXType_ConstantArray -> { - val elemType = convertType(clang_getArrayElementType(type, memScope)) + val elemType = convertType(clang_getArrayElementType(type)) val length = clang_getArraySize(type) ConstArrayType(elemType, length) } CXType_IncompleteArray -> { - val elemType = convertType(clang_getArrayElementType(type, memScope)) + val elemType = convertType(clang_getArrayElementType(type)) IncompleteArrayType(elemType) } @@ -208,10 +211,10 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { if (clang_isFunctionTypeVariadic(type) != 0) { UnsupportedType } else { - val returnType = convertType(clang_getResultType(type, memScope)) + val returnType = convertType(clang_getResultType(type)) val numArgs = clang_getNumArgTypes(type) val paramTypes = (0..numArgs - 1).map { - convertType(clang_getArgType(type, it, memScope)) + convertType(clang_getArgType(type, it)) } FunctionType(paramTypes, returnType) } @@ -221,12 +224,11 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { } } - fun indexDeclaration(info: CXIdxDeclInfo): Unit = memScoped { - val cursor = info.cursor + fun indexDeclaration(info: CXIdxDeclInfo): Unit { + val cursor = info.cursor.readValue() val entityInfo = info.entityInfo.pointed!! - val entityName = entityInfo.name.value?.asCString()?.toString() + val entityName = entityInfo.name.value?.toKString() val kind = entityInfo.kind.value - when (kind) { CXIdxEntity_Field -> { val name = entityName!! @@ -234,14 +236,14 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { val offset = clang_Cursor_getOffsetOfField(cursor) val container = info.semanticContainer.pointed!! - val structDef = getStructDeclAt(container.cursor).def!! + val structDef = getStructDeclAt(container.cursor.readValue()).def!! structDef.fields.add(Field(name, type, offset)) } CXIdxEntity_Struct, CXIdxEntity_Union -> { val structDecl = getStructDeclAt(cursor) if (clang_isCursorDefinition(cursor) != 0) { - val type = clang_getCursorType(cursor, memScope) + val type = clang_getCursorType(cursor) val size = clang_Type_getSizeOf(type) val align = clang_Type_getAlignOf(type).toInt() val hasNaturalLayout = structHasNaturalLayout(cursor) @@ -251,17 +253,17 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { CXIdxEntity_Function -> { val name = entityName!! - val returnType = convertType(clang_getCursorResultType(cursor, memScope)) + val returnType = convertType(clang_getCursorResultType(cursor)) val argNum = clang_Cursor_getNumArguments(cursor) val args = (0 .. argNum - 1).map { - val argCursor = clang_Cursor_getArgument(cursor, it, memScope) + val argCursor = clang_Cursor_getArgument(cursor, it) val argName = getCursorSpelling(argCursor) val type = convertCursorType(argCursor) Parameter(argName, type) } val binaryName = when (language) { - Language.C -> clang_Cursor_getMangling(cursor, memScope).convertAndDispose() + Language.C -> clang_Cursor_getMangling(cursor).convertAndDispose() } functionByName[name] = FunctionDecl(name, args, returnType, binaryName) @@ -274,9 +276,9 @@ internal class NativeIndexImpl(val language: Language) : NativeIndex() { CXIdxEntity_EnumConstant -> { val container = info.semanticContainer.pointed!! val name = entityName!! - val value = clang_getEnumConstantDeclValue(info.cursor) + val value = clang_getEnumConstantDeclValue(info.cursor.readValue()) - val constants = getEnumDefAt(container.cursor).constants + val constants = getEnumDefAt(container.cursor.readValue()).constants val existingConstant = constants.find { it.name == name } if (existingConstant == null) { val constant = EnumConstant(name, value, isExplicitlyDefined = !cursor.isLeaf()) diff --git a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/MacroConstants.kt b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/MacroConstants.kt index 073688f9823..9ebc889aad9 100644 --- a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/MacroConstants.kt +++ b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/MacroConstants.kt @@ -1,7 +1,7 @@ package org.jetbrains.kotlin.native.interop.indexer import clang.* -import kotlinx.cinterop.memScoped +import kotlinx.cinterop.CValue import java.io.File /** @@ -16,7 +16,7 @@ internal fun findMacroConstants(library: NativeLibrary, nativeIndex: NativeIndex nativeIndex.macroConstants.addAll(constants) } -private typealias TypeConverter = (CXType) -> Type +private typealias TypeConverter = (CValue) -> Type /** * For each name expands the macro with this name declared in the library, @@ -123,8 +123,8 @@ private fun processCodeSnippet( var longValue: Long? = null var doubleValue: Double? = null - val visitor: CursorVisitor = { cursor: CXCursor, parent: CXCursor -> - val kind = cursor.kind.value + val visitor: CursorVisitor = { cursor, parent -> + val kind = cursor.kind when { state == VisitorState.EXPECT_VARIABLE && kind == CXCursorKind.CXCursor_VarDecl -> { state = VisitorState.EXPECT_VARIABLE_VALUE @@ -144,10 +144,7 @@ private fun processCodeSnippet( state == VisitorState.EXPECT_VARIABLE_VALUE && clang_isExpression(kind) != 0 -> { state = VisitorState.EXPECT_ENUM - type = memScoped { - val cursorType = clang_getCursorType(cursor, memScope) - typeConverter(cursorType) - } + type = typeConverter(clang_getCursorType(cursor)) CXChildVisitResult.CXChildVisit_Continue } @@ -204,7 +201,7 @@ private fun collectMacroConstantsNames(library: NativeLibrary): List { val translationUnit = library.parse(index, options).ensureNoCompileErrors() try { visitChildren(translationUnit) { cursor, parent -> - if (cursor.kind.value == CXCursorKind.CXCursor_MacroDefinition && canMacroBeConstant(cursor)) { + if (cursor.kind == CXCursorKind.CXCursor_MacroDefinition && canMacroBeConstant(cursor)) { val spelling = getCursorSpelling(cursor) result.add(spelling) } @@ -221,7 +218,7 @@ private fun collectMacroConstantsNames(library: NativeLibrary): List { return result.toList() } -private fun canMacroBeConstant(cursor: CXCursor): Boolean { +private fun canMacroBeConstant(cursor: CValue): Boolean { if (clang_Cursor_isMacroFunctionLike(cursor) != 0) { return false diff --git a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/NativeIndex.kt b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/NativeIndex.kt index fba56d6e16d..091e47370f4 100644 --- a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/NativeIndex.kt +++ b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/NativeIndex.kt @@ -94,6 +94,8 @@ interface PrimitiveType : Type object VoidType : Type +object CharType : PrimitiveType + object Int8Type : PrimitiveType object UInt8Type : PrimitiveType @@ -116,7 +118,14 @@ data class RecordType(val decl: StructDecl) : Type data class EnumType(val def: EnumDef) : Type -data class PointerType(val pointeeType : Type) : Type +open class PointerType(val pointeeType : Type) : Type + +/** + * The type of pointer that can't be used to modify pointed data. + * + * TODO: refactor type representation and support type modifiers more generally. + */ +class PointerToConstType(pointeeType: Type) : PointerType(pointeeType) data class FunctionType(val parameterTypes: List, val returnType: Type) : Type diff --git a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Utils.kt b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Utils.kt index adf11c2dd51..8b3bf8d4b41 100644 --- a/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Utils.kt +++ b/Interop/Indexer/src/main/kotlin/org/jetbrains/kotlin/native/interop/indexer/Utils.kt @@ -4,23 +4,28 @@ import clang.* import kotlinx.cinterop.* import java.io.File -internal fun CXString.convertAndDispose(): String { +internal val CValue.kind: CXTypeKind get() = this.useContents { kind.value } + +internal val CValue.kind: CXCursorKind get() = this.useContents { kind.value } + +internal fun CValue.convertAndDispose(): String { try { - return clang_getCString(this)!!.asCString().toString() + return clang_getCString(this)!!.toKString() } finally { clang_disposeString(this) } } -internal fun getCursorSpelling(cursor: CXCursor) = memScoped { - clang_getCursorSpelling(cursor, memScope).convertAndDispose() -} +internal fun getCursorSpelling(cursor: CValue) = + clang_getCursorSpelling(cursor).convertAndDispose() -internal fun convertUnqualifiedPrimitiveType(type: CXType): Type = when (type.kind.value) { +internal fun convertUnqualifiedPrimitiveType(type: CValue): Type = when (type.kind) { // TODO: is e.g. CXType_Int guaranteed to be int32_t? - CXTypeKind.CXType_Char_U, CXTypeKind.CXType_UChar -> UInt8Type - CXTypeKind.CXType_Char_S, CXTypeKind.CXType_SChar -> Int8Type + CXTypeKind.CXType_Char_U, CXTypeKind.CXType_Char_S -> CharType + + CXTypeKind.CXType_UChar -> UInt8Type + CXTypeKind.CXType_SChar -> Int8Type CXTypeKind.CXType_UShort -> UInt16Type CXTypeKind.CXType_Short -> Int16Type @@ -71,9 +76,7 @@ internal fun getCompileErrors(translationUnit: CXTranslationUnit): Sequence CXChildVisitResult +internal typealias CursorVisitor = (cursor: CValue, parent: CValue) -> CXChildVisitResult -internal fun visitChildren(parent: CXCursor, visitor: CursorVisitor) { +internal fun visitChildren(parent: CValue, visitor: CursorVisitor) { val visitorPtr = StableObjPtr.create(visitor) val clientData = visitorPtr.value clang_visitChildren(parent, staticCFunction { cursor, parent, clientData -> val visitor = StableObjPtr.fromValue(clientData!!).get() as CursorVisitor - visitor(cursor, parent) + visitor(cursor.readValue(), parent.readValue()) }, clientData) } -internal fun visitChildren(translationUnit: CXTranslationUnit, visitor: CursorVisitor) { - memScoped { - visitChildren(clang_getTranslationUnitCursor(translationUnit, memScope), visitor) - } -} +internal fun visitChildren(translationUnit: CXTranslationUnit, visitor: CursorVisitor) = + visitChildren(clang_getTranslationUnitCursor(translationUnit), visitor) -internal fun CXCursor.isLeaf(): Boolean { +internal fun CValue.isLeaf(): Boolean { var hasChildren = false visitChildren(this) { _, _ -> @@ -112,7 +112,7 @@ internal fun CXCursor.isLeaf(): Boolean { internal fun List.toNativeStringArray(placement: NativePlacement): CArray> { return placement.allocArray(this.size) { index -> - this.value = this@toNativeStringArray[index].toCString(placement)!!.asCharPtr() + this.value = this@toNativeStringArray[index].cstr.getPointer(placement) } } diff --git a/Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmNativeMem.kt b/Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmNativeMem.kt index 17e6ed49875..6353d8a060c 100644 --- a/Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmNativeMem.kt +++ b/Interop/Runtime/src/jvm/kotlin/kotlinx/cinterop/JvmNativeMem.kt @@ -60,6 +60,8 @@ object nativeMemUtils { unsafe.copyMemory(source, baseOffset, null, dest.address, length.toLong()) } + fun zeroMemory(dest: NativePointed, length: Int): Unit = unsafe.setMemory(dest.address, length.toLong(), 0) + internal class NativeAllocated(override val rawPtr: NativePtr) : NativePointed fun alloc(size: Long, align: Int): NativePointed { diff --git a/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Types.kt b/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Types.kt index 3496cd9252d..cb7d045661c 100644 --- a/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Types.kt +++ b/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Types.kt @@ -33,10 +33,49 @@ inline fun NativePointed.reinterpret(): T = interpre */ interface CPointed : NativePointed +/** + * Represents a reference to (possibly empty) sequence of C values. + * It can be either a stable pointer [CPointer] or a sequence of immutable values [CValues]. + * + * [CValuesRef] is designed to be used as Kotlin representation of pointer-typed parameters of C functions. + * When passing [CPointer] as [CValuesRef] to the Kotlin binding method, the C function receives exactly this pointer. + * Passing [CValues] has nearly the same semantics as passing by value: the C function receives + * the pointer to the temporary copy of these values, and the caller can't observe the modifications to this copy. + * The copy is valid until the C function returns. + */ +abstract class CValuesRef { + /** + * If this reference is [CPointer], returns this pointer. + * Otherwise copies the referenced values to [placement] and returns the pointer to the copy. + */ + abstract fun getPointer(placement: NativePlacement): CPointer +} + +/** + * The (possibly empty) sequence of immutable C values. + * It is self-contained and doesn't depend on native memory. + */ +abstract class CValues : CValuesRef() { + /** + * Copies the values to [placement] and returns the pointer to the copy. + */ + override abstract fun getPointer(placement: NativePlacement): CPointer +} + +fun CValues.placeTo(placement: NativePlacement) = this.getPointer(placement) + +/** + * The single immutable C value. + * It is self-contained and doesn't depend on native memory. + * + * TODO: consider providing an adapter instead of subtyping [CValues]. + */ +abstract class CValue : CValues() + /** * C pointer. */ -class CPointer internal constructor(val rawValue: NativePtr) { +class CPointer internal constructor(val rawValue: NativePtr) : CValuesRef() { override fun equals(other: Any?): Boolean { if (this === other) { @@ -51,6 +90,8 @@ class CPointer internal constructor(val rawValue: NativePtr) { } override fun toString() = this.cPointerToString() + + override fun getPointer(placement: NativePlacement) = this } /** @@ -69,7 +110,7 @@ inline val CPointer.pointed: T // `null` value of `CPointer?` is mapped to `nativeNullPtr` val CPointer<*>?.rawValue: NativePtr - get() = this?.rawValue ?: nativeNullPtr + get() = if (this != null) this.rawValue else nativeNullPtr fun CPointer<*>.reinterpret(): CPointer = interpretCPointer(this.rawValue)!! @@ -217,7 +258,7 @@ typealias CPointerVar = CPointerVarWithValueMappedTo> /** * The value of this variable. */ -inline var > CPointerVarWithValueMappedTo

.value: P? +inline var

> CPointerVarWithValueMappedTo

.value: P? get() = interpretCPointer(nativeMemUtils.getNativePtr(this)) as P? set(value) = nativeMemUtils.putNativePtr(this, value.rawValue) diff --git a/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Utils.kt b/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Utils.kt index df337917b24..9a0483e9fe7 100644 --- a/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Utils.kt +++ b/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Utils.kt @@ -43,8 +43,6 @@ class Arena(private val parent: NativeFreeablePlacement = nativeHeap) : NativePl } -fun NativePlacement.alloc(size: Int, align: Int) = alloc(size.toLong(), align) - /** * Allocates variable of given type. * @@ -138,12 +136,9 @@ inline fun > } fun NativePlacement.allocArrayOf(elements: ByteArray): CArray { - val res = allocArray(elements.size) - var index = 0 - for (byte in elements) { - res[index++].value = byte - } - return res + val result = allocArray(elements.size) + nativeMemUtils.putByteArray(elements, result, elements.size) + return result } fun NativePlacement.allocArrayOf(vararg elements: Float): CArray { @@ -157,56 +152,139 @@ fun NativePlacement.allocArrayOf(vararg elements: Float): CArray { fun NativePlacement.allocPointerTo() = alloc>() +fun zeroValue(size: Int, align: Int): CValue = object : CValue() { + override fun getPointer(placement: NativePlacement): CPointer { + val result = placement.alloc(size, align) + nativeMemUtils.zeroMemory(result, size) + return interpretCPointer(result.rawPtr)!! + } +} + +inline fun zeroValue(): CValue = + zeroValue(sizeOf().toInt(), alignOf()) + +private fun NativePlacement.placeBytes(bytes: ByteArray, align: Int): CPointer { + val result = this.alloc(size = bytes.size, align = align) + nativeMemUtils.putByteArray(bytes, result, bytes.size) + return interpretCPointer(result.rawPtr)!! +} + +fun CPointed.readValues(size: Int, align: Int): CValues { + val bytes = ByteArray(size) + nativeMemUtils.getByteArray(this, bytes, size) + + return object : CValues() { + override fun getPointer(placement: NativePlacement): CPointer = placement.placeBytes(bytes, align) + } +} + +inline fun T.readValues(count: Int): CValues = + this.readValues(size = count * sizeOf().toInt(), align = alignOf()) + +fun CPointed.readValue(size: Int, align: Int): CValue { + val bytes = ByteArray(size) + nativeMemUtils.getByteArray(this, bytes, size) + return object : CValue() { + override fun getPointer(placement: NativePlacement): CPointer = placement.placeBytes(bytes, align) + } +} + +// Note: can't be declared as property due to possible clash with a struct field. +// TODO: find better name. +inline fun T.readValue(): CValue = this.readValue(sizeOf().toInt(), alignOf()) + /** - * The zero-terminated string. + * Calls the [block] with temporary copy if this value as receiver. */ -class CString(override val rawPtr: NativePtr) : CPointed { +inline fun CValue.useContents(block: T.() -> R): R = memScoped { + this@useContents.placeTo(memScope).pointed.block() +} - companion object { - fun fromArray(array: CArray) = array.reinterpret() - } +inline fun CValue.copy(modify: T.() -> Unit): CValue = useContents { + this.modify() + this.readValue() +} - fun length(): Int { - val array = reinterpret>() +inline fun cValue(initialize: T.() -> Unit): CValue = + zeroValue().copy(modify = initialize) - var res = 0 - while (array[res].value != 0.toByte()) { - ++res +inline fun createValues(count: Int, initializer: T.(index: Int) -> Unit) = memScoped { + val array = allocArray(count, initializer) + array[0].readValues(count) +} + +fun cValuesOf(vararg elements: Byte): CValues = object : CValues() { + override fun getPointer(placement: NativePlacement) = placement.allocArrayOf(elements)[0].ptr +} + +// TODO: optimize other [cValuesOf] methods: + +fun cValuesOf(vararg elements: Short): CValues = + createValues(elements.size) { index -> this.value = elements[index] } + +fun cValuesOf(vararg elements: Int): CValues = + createValues(elements.size) { index -> this.value = elements[index] } + +fun cValuesOf(vararg elements: Long): CValues = + createValues(elements.size) { index -> this.value = elements[index] } + +fun cValuesOf(vararg elements: Float): CValues = object : CValues() { + override fun getPointer(placement: NativePlacement) = placement.allocArrayOf(*elements)[0].ptr +} + +fun cValuesOf(vararg elements: Double): CValues = + createValues(elements.size) { index -> this.value = elements[index] } + +fun cValuesOf(vararg elements: CPointer?): CValues> = + createValues(elements.size) { index -> this.value = elements[index] } + +fun ByteArray.toCValues() = cValuesOf(*this) +fun ShortArray.toCValues() = cValuesOf(*this) +fun IntArray.toCValues() = cValuesOf(*this) +fun LongArray.toCValues() = cValuesOf(*this) +fun FloatArray.toCValues() = cValuesOf(*this) +fun DoubleArray.toCValues() = cValuesOf(*this) +fun Array?>.toCValues() = cValuesOf(*this) + +fun List?>.toCValues() = this.toTypedArray().toCValues() + +/** + * TODO: should the name of the function reflect the encoding? + * + * @return the value of zero-terminated UTF-8-encoded C string constructed from given [kotlin.String]. + */ +val String.cstr: CValues + get() { + val bytes = encodeToUtf8(this) + + return object : CValues() { + override fun getPointer(placement: NativePlacement): CPointer { + val result = placement.allocArray(bytes.size + 1) + nativeMemUtils.putByteArray(bytes, result, bytes.size) + result[bytes.size].value = 0.toByte() + return result[0].ptr + } } - return res } - override fun toString(): String { - val array = reinterpret>() +/** + * TODO: should the name of the function reflect the encoding? + * + * @return the [kotlin.String] decoded from given zero-terminated UTF-8-encoded C string. + */ +fun CPointer.toKString(): String { + val nativeBytes = this.reinterpret>().pointed - val len = this.length() - val bytes = ByteArray(len) - - nativeMemUtils.getByteArray(array[0], bytes, len) - return decodeFromUtf8(bytes) // TODO: encoding + var length = 0 + while (nativeBytes[length].value != 0.toByte()) { + ++length } - fun asCharPtr() = reinterpret().ptr + val bytes = ByteArray(length) + nativeMemUtils.getByteArray(nativeBytes, bytes, length) + return decodeFromUtf8(bytes) } -fun CString.Companion.fromString(str: String?, placement: NativePlacement): CString? { - if (str == null) { - return null - } - - val bytes = encodeToUtf8(str) // TODO: encoding - val len = bytes.size - val nativeBytes = placement.allocArray(len + 1) - - nativeMemUtils.putByteArray(bytes, nativeBytes[0], len) - nativeBytes[len].value = 0 - - return CString.fromArray(nativeBytes) -} - -fun CPointer.asCString() = CString.fromArray(this.reinterpret>().pointed) -fun String.toCString(placement: NativePlacement) = CString.fromString(this, placement) - class MemScope : NativePlacement { private val arena = Arena() diff --git a/Interop/Runtime/src/native/kotlin/kotlinx/cinterop/NativeMem.kt b/Interop/Runtime/src/native/kotlin/kotlinx/cinterop/NativeMem.kt index bc2d7ddabbf..12c857b8ed5 100644 --- a/Interop/Runtime/src/native/kotlin/kotlinx/cinterop/NativeMem.kt +++ b/Interop/Runtime/src/native/kotlin/kotlinx/cinterop/NativeMem.kt @@ -30,6 +30,7 @@ object nativeMemUtils { @Intrinsic external fun getNativePtr(mem: NativePointed): NativePtr @Intrinsic external fun putNativePtr(mem: NativePointed, value: NativePtr) + // TODO: optimize fun getByteArray(source: NativePointed, dest: ByteArray, length: Int) { val sourceArray: CArray = source.reinterpret() for (index in 0 .. length - 1) { @@ -37,6 +38,7 @@ object nativeMemUtils { } } + // TODO: optimize fun putByteArray(source: ByteArray, dest: NativePointed, length: Int) { val destArray: CArray = dest.reinterpret() for (index in 0 .. length - 1) { @@ -44,6 +46,14 @@ object nativeMemUtils { } } + // TODO: optimize + fun zeroMemory(dest: NativePointed, length: Int): Unit { + val destArray: CArray = dest.reinterpret() + for (index in 0 .. length - 1) { + destArray[index].value = 0 + } + } + private class NativeAllocated(override val rawPtr: NativePtr) : NativePointed fun alloc(size: Long, align: Int): NativePointed { diff --git a/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt b/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt index c6fb4d91bdd..36fcba432d7 100644 --- a/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt +++ b/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/StubGenerator.kt @@ -173,7 +173,8 @@ class StubGenerator( return when (this) { is VoidType -> "void" - is Int8Type -> "char" + is CharType -> "char" + is Int8Type -> "signed char" is UInt8Type -> "unsigned char" is Int16Type -> "short" is UInt16Type -> "unsigned short" @@ -214,7 +215,7 @@ class StubGenerator( val PrimitiveType.kotlinType: String get() = when (this) { - is Int8Type, is UInt8Type -> "Byte" + is CharType, is Int8Type, is UInt8Type -> "Byte" is Int16Type, is UInt16Type -> "Short" is Int32Type, is UInt32Type -> "Int" is IntPtrType, is UIntPtrType, // TODO: 64-bit specific @@ -326,7 +327,7 @@ class StubGenerator( private fun mirror(type: PrimitiveType): TypeMirror.ByValue { val varTypeName = when (type) { - is Int8Type, is UInt8Type -> "CInt8Var" + is CharType, is Int8Type, is UInt8Type -> "CInt8Var" is Int16Type, is UInt16Type -> "CInt16Var" is Int32Type, is UInt32Type -> "CInt32Var" is IntPtrType, is UIntPtrType, // TODO: 64-bit specific @@ -439,11 +440,52 @@ class StubGenerator( ) } + fun representCFunctionParameterAsValuesRef(type: Type): Type? { + val pointeeType = when (type) { + is PointerType -> type.pointeeType + is ArrayType -> type.elemType + else -> return null + } + + val unwrappedPointeeType = pointeeType.unwrapTypedefs() + if (unwrappedPointeeType is VoidType || unwrappedPointeeType is FunctionType) { + // Passing `void`s or function by value is not very sane: + return null + } + + return pointeeType + } + + fun representCFunctionParameterAsString(type: Type): Boolean { + val unwrappedType = type.unwrapTypedefs() + return unwrappedType is PointerToConstType && unwrappedType.pointeeType.unwrapTypedefs() == CharType + } + fun getCFunctionParamBinding(type: Type): OutValueBinding { - if (treatCFunctionParameterAsString(type)) { + if (representCFunctionParameterAsString(type)) { return OutValueBinding( - kotlinType = "String?", - kotlinConv = { name -> "$name?.toCString(memScope).rawPtr" }, + kotlinType = "String?", // TODO: mention the C type (e.g. with annotation). + kotlinConv = { name -> "$name?.cstr?.getPointer(memScope).rawValue" }, + memScoped = true, + kotlinJniBridgeType = "NativePtr" + ) + } + + representCFunctionParameterAsValuesRef(type)?.let { + val pointeeMirror = mirror(it) + return OutValueBinding( + kotlinType = "CValuesRef<${pointeeMirror.pointedTypeName}>?", + kotlinConv = { name -> "$name?.getPointer(memScope).rawValue" }, + memScoped = true, + kotlinJniBridgeType = "NativePtr" + ) + } + if (type.unwrapTypedefs() is RecordType) { + // TODO: this case should probably be handled more generally. + val typeMirror = mirror(type) + return OutValueBinding( + kotlinType = "CValue<${typeMirror.pointedTypeName}>", + kotlinConv = { name -> "$name.getPointer(memScope).rawValue" }, // TODO: eliminate this copying memScoped = true, kotlinJniBridgeType = "NativePtr" ) @@ -452,8 +494,6 @@ class StubGenerator( return getOutValueBinding(type) } - private fun treatCFunctionParameterAsString(type: Type) = type is PointerType && type.pointeeType is Int8Type - fun getCallbackRetValBinding(type: Type): OutValueBinding { if (type.unwrapTypedefs() is VoidType) { return OutValueBinding( @@ -484,12 +524,21 @@ class StubGenerator( ) } - fun getCFunctionRetValBinding(type: Type): InValueBinding { - when (type.unwrapTypedefs()) { - is VoidType -> return InValueBinding("Unit") + fun getCFunctionRetValBinding(func: FunctionDecl): InValueBinding { + when { + func.returnsVoid() -> return InValueBinding("Unit") + func.returnsRecord() -> { + // TODO: this case should probably be handled more generally. + val typeMirror = mirror(func.returnType) + return InValueBinding( + kotlinJniBridgeType = "NativePtr", + conv = { name -> "interpretPointed<${typeMirror.pointedTypeName}>($name).readValue()" }, + kotlinType = "CValue<${typeMirror.pointedTypeName}>" + ) + } } - return getInValueBinding(type) + return getInValueBinding(func.returnType) } fun getCallbackParamBinding(type: Type): InValueBinding { @@ -637,7 +686,10 @@ class StubGenerator( /** * Constructs [InValueBinding] for return value of Kotlin binding for given C function. */ - private fun retValBinding(func: FunctionDecl) = getCFunctionRetValBinding(func.returnType) + private fun retValBinding(func: FunctionDecl) = getCFunctionRetValBinding(func) + + private fun FunctionDecl.returnsRecord(): Boolean = this.returnType.unwrapTypedefs() is RecordType + private fun FunctionDecl.returnsVoid(): Boolean = this.returnType.unwrapTypedefs() is VoidType /** * Constructs [OutValueBinding]s for parameters of Kotlin binding for given C function. @@ -647,13 +699,10 @@ class StubGenerator( getCFunctionParamBinding(param.type) }.toMutableList() - val retValType = func.returnType - if (retValType.unwrapTypedefs() is RecordType) { - val retValMirror = mirror(retValType) - + if (func.returnsRecord()) { paramBindings.add(OutValueBinding( - kotlinType = "NativePlacement", - kotlinConv = { name -> "$name.alloc<${retValMirror.pointedTypeName}>().rawPtr" }, + kotlinType = "should not be used", + kotlinConv = { throw UnsupportedOperationException() }, kotlinJniBridgeType = "NativePtr" )) } @@ -674,7 +723,7 @@ class StubGenerator( } }.toMutableList() - if (func.returnType.unwrapTypedefs() is RecordType) { + if (func.returnsRecord()) { paramNames.add("retValPlacement") } @@ -685,7 +734,14 @@ class StubGenerator( * Produces to [out] the definition of Kotlin binding for given C function. */ private fun generateKotlinBindingMethod(func: FunctionDecl) { - val paramNames = paramNames(func) + val paramNames = paramNames(func).toList().let { + if (func.returnsRecord()) { + // The last parameter should be present only in C adapter. + it.dropLast(1) + } else { + it + } + } val paramBindings = paramBindings(func) val retValBinding = retValBinding(func) @@ -716,7 +772,13 @@ class StubGenerator( externalParamName + }.toMutableList() + + if (func.returnsRecord()) { + val retValMirror = mirror(func.returnType) + arguments.add("alloc<${retValMirror.pointedTypeName}>().rawPtr") } + val callee = when (platform) { KotlinPlatform.JVM -> "externals.${func.name}" KotlinPlatform.NATIVE -> func.kotlinExternalName @@ -741,7 +803,7 @@ class StubGenerator( } block(header) { - val memScoped = paramBindings.any { it.memScoped } + val memScoped = paramBindings.any { it.memScoped } || func.returnsRecord() if (memScoped) { block("return memScoped") { generateBody(true) @@ -782,7 +844,8 @@ class StubGenerator( private fun getFfiType(type: Type): String { return when(type) { is VoidType -> "Void" - is Int8Type -> "SInt8" + is CharType, is Int8Type -> "SInt8" + // TODO: libffi has separate representation for char type. is UInt8Type -> "UInt8" is Int16Type -> "SInt16" is UInt16Type -> "UInt16" @@ -829,8 +892,12 @@ class StubGenerator( return true } - return this.parameters.any { treatCFunctionParameterAsString(it.type) } || - this.returnType.unwrapTypedefs() is RecordType + return this.returnsRecord() || + this.parameters.map { it.type }.any { + it.unwrapTypedefs() is RecordType || + representCFunctionParameterAsString(it) || + representCFunctionParameterAsValuesRef(it) != null + } } /** @@ -842,8 +909,8 @@ class StubGenerator( return true } - val parameterTypes = this.parameters.map { it.type } - return (parameterTypes + returnType).any { it.unwrapTypedefs() is RecordType } + return this.returnsRecord() || + this.parameters.map { it.type }.any { it.unwrapTypedefs() is RecordType } } private fun FunctionType.requiresAdapterOnNative(): Boolean { @@ -1187,7 +1254,6 @@ class StubGenerator( * Produces to [out] the implementation of JNI function used in Kotlin binding for given C function. */ private fun generateCJniFunction(func: FunctionDecl) { - val funcReturnType = func.returnType.unwrapTypedefs() val paramNames = paramNames(func) val paramBindings = paramBindings(func) val retValBinding = retValBinding(func) @@ -1241,8 +1307,8 @@ class StubGenerator( if (cReturnType == "void") { out("$callExpr;") - } else if (funcReturnType is RecordType) { - out("*(${funcReturnType.decl.spelling}*)retValPlacement = $callExpr;") + } else if (func.returnsRecord()) { + out("*(${func.returnType.getStringRepresentation()}*)retValPlacement = $callExpr;") out("return ($cReturnType) retValPlacement;") } else { out("return ($cReturnType) ($callExpr);") diff --git a/InteropExample/src/main/kotlin/main.kt b/InteropExample/src/main/kotlin/main.kt index a000c9359d7..56249089102 100644 --- a/InteropExample/src/main/kotlin/main.kt +++ b/InteropExample/src/main/kotlin/main.kt @@ -24,7 +24,7 @@ fun main(args: Array) = memScoped { } val error = errorRef.value if (error != null) { - println(error.asCString().toString()) + println(error.toKString()) return } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt index 2c6415b544f..3e4cc799875 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt @@ -140,7 +140,7 @@ internal class CodeGenerator(override val context: Context) : ContextUtils { private var cleanupLandingpad: LLVMBasicBlockRef? = null fun setName(value: LLVMValueRef, name: String) = LLVMSetValueName(value, name) - fun getName(value: LLVMValueRef) = LLVMGetValueName(value)?.asCString().toString() + fun getName(value: LLVMValueRef) = LLVMGetValueName(value)?.toKString() fun plus (arg0: LLVMValueRef, arg1: LLVMValueRef, name: String = ""): LLVMValueRef = LLVMBuildAdd (builder, arg0, arg1, name)!! fun mul (arg0: LLVMValueRef, arg1: LLVMValueRef, name: String = ""): LLVMValueRef = LLVMBuildMul (builder, arg0, arg1, name)!! @@ -221,10 +221,7 @@ internal class CodeGenerator(override val context: Context) : ContextUtils { } fun gep(base: LLVMValueRef, index: LLVMValueRef): LLVMValueRef { - memScoped { - val args = allocArrayOf(index) - return LLVMBuildGEP(builder, base, args[0].ptr, 1, "")!! - } + return LLVMBuildGEP(builder, base, cValuesOf(index), 1, "")!! } fun updateReturnRef(value: LLVMValueRef, address: LLVMValueRef) { @@ -277,30 +274,28 @@ internal class CodeGenerator(override val context: Context) : ContextUtils { private fun callRaw(llvmFunction: LLVMValueRef, args: List, lazyLandingpad: () -> LLVMBasicBlockRef?): LLVMValueRef { - memScoped { - val rargs = allocArrayOf(args)[0].ptr - if (LLVMIsAFunction(llvmFunction) != null /* the function declaration */ && - (LLVMGetFunctionAttr(llvmFunction) and LLVMNoUnwindAttribute) != 0) { + val rargs = args.toCValues() + if (LLVMIsAFunction(llvmFunction) != null /* the function declaration */ && + (LLVMGetFunctionAttr(llvmFunction) and LLVMNoUnwindAttribute) != 0) { - return LLVMBuildCall(builder, llvmFunction, rargs, args.size, "")!! - } else { - val landingpad = lazyLandingpad() + return LLVMBuildCall(builder, llvmFunction, rargs, args.size, "")!! + } else { + val landingpad = lazyLandingpad() - if (landingpad == null) { - // When calling a function that is not marked as nounwind (can throw an exception), - // it is required to specify a landingpad to handle exceptions properly. - // Runtime C++ function can be marked as non-throwing using `RUNTIME_NOTHROW`. - val functionName = getName(llvmFunction) - val message = "no landingpad specified when calling function $functionName without nounwind attr" - throw IllegalArgumentException(message) - } - - val success = basicBlock() - val result = LLVMBuildInvoke(builder, llvmFunction, rargs, args.size, success, landingpad, "")!! - positionAtEnd(success) - return result + if (landingpad == null) { + // When calling a function that is not marked as nounwind (can throw an exception), + // it is required to specify a landingpad to handle exceptions properly. + // Runtime C++ function can be marked as non-throwing using `RUNTIME_NOTHROW`. + val functionName = getName(llvmFunction) + val message = "no landingpad specified when calling function $functionName without nounwind attr" + throw IllegalArgumentException(message) } + + val success = basicBlock() + val result = LLVMBuildInvoke(builder, llvmFunction, rargs, args.size, success, landingpad, "")!! + positionAtEnd(success) + return result } } @@ -312,10 +307,10 @@ internal class CodeGenerator(override val context: Context) : ContextUtils { fun addPhiIncoming(phi: LLVMValueRef, vararg incoming: Pair) { memScoped { - val incomingValues = allocArrayOf(incoming.map { it.second }) - val incomingBlocks = allocArrayOf(incoming.map { it.first }) + val incomingValues = incoming.map { it.second }.toCValues() + val incomingBlocks = incoming.map { it.first }.toCValues() - LLVMAddIncoming(phi, incomingValues[0].ptr, incomingBlocks[0].ptr, incoming.size) + LLVMAddIncoming(phi, incomingValues, incomingBlocks, incoming.size) } } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt index a07b34552f4..530046126ad 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt @@ -193,11 +193,9 @@ internal class Llvm(val context: Context, val llvmModule: LLVMModuleRef) { } private fun importMemset() : LLVMValueRef { - memScoped { - val parameterTypes = allocArrayOf(int8TypePtr, int8Type, int32Type, int32Type, int1Type) - val functionType = LLVMFunctionType(LLVMVoidType(), parameterTypes[0].ptr, 5, 0) - return LLVMAddFunction(llvmModule, "llvm.memset.p0i8.i32", functionType)!! - } + val parameterTypes = cValuesOf(int8TypePtr, int8Type, int32Type, int32Type, int1Type) + val functionType = LLVMFunctionType(LLVMVoidType(), parameterTypes, 5, 0) + return LLVMAddFunction(llvmModule, "llvm.memset.p0i8.i32", functionType)!! } internal fun externalFunction(name: String, type: LLVMTypeRef): LLVMValueRef { diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt index 03f8f8e4f87..693c5e9ae00 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/HashUtils.kt @@ -28,7 +28,7 @@ public fun base64Encode(data: ByteArray): String { val bytes = allocArrayOf(data) EncodeBase64(bytes.ptr, data.size, result.ptr, resultSize) // TODO: any better way to do that without two copies? - return CString.fromArray(result).toString() + return result[0].ptr.toKString() } } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt index 1bbac47fdbb..e5e073f2f18 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt @@ -276,12 +276,10 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid // Creates static struct InitNode $nodeName = {$initName, NULL}; fun createInitNode(initFunction: LLVMValueRef, nodeName: String): LLVMValueRef { - memScoped { - val nextInitNode = LLVMConstNull(pointerType(kNodeInitType)) // Set InitNode.next = NULL. - val argList = allocArrayOf(initFunction, nextInitNode)[0].ptr // Allocate array of args. - val initNode = LLVMConstNamedStruct(kNodeInitType, argList, 2)!! // Create static object of class InitNode. - return context.llvm.staticData.placeGlobal(nodeName, constPointer(initNode)).llvmGlobal // Put the object in global var with name "nodeName". - } + val nextInitNode = LLVMConstNull(pointerType(kNodeInitType)) // Set InitNode.next = NULL. + val argList = cValuesOf(initFunction, nextInitNode) // Construct array of args. + val initNode = LLVMConstNamedStruct(kNodeInitType, argList, 2)!! // Create static object of class InitNode. + return context.llvm.staticData.placeGlobal(nodeName, constPointer(initNode)).llvmGlobal // Put the object in global var with name "nodeName". } //-------------------------------------------------------------------------// @@ -1334,13 +1332,10 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid val fieldInfo = context.llvmDeclarations.forField(value) val typePtr = pointerType(fieldInfo.classBodyType) - memScoped { - val args = allocArrayOf(kImmOne) - val objectPtr = LLVMBuildGEP(codegen.builder, thisPtr, args[0].ptr, 1, "") - val typedObjPtr = codegen.bitcast(typePtr, objectPtr!!) - val fieldPtr = LLVMBuildStructGEP(codegen.builder, typedObjPtr, fieldInfo.index, "") - return fieldPtr!! - } + val objectPtr = LLVMBuildGEP(codegen.builder, thisPtr, cValuesOf(kImmOne), 1, "") + val typedObjPtr = codegen.bitcast(typePtr, objectPtr!!) + val fieldPtr = LLVMBuildStructGEP(codegen.builder, typedObjPtr, fieldInfo.index, "") + return fieldPtr!! } //-------------------------------------------------------------------------// @@ -1893,21 +1888,23 @@ internal class CodeGeneratorVisitor(val context: Context) : IrElementVisitorVoid //-------------------------------------------------------------------------// // Create type { i32, void ()*, i8* } - val kCtorType = memScoped { - val ctorType = LLVMPointerType(kVoidFuncType, 0) - val typeList = allocArrayOf(LLVMInt32Type(), ctorType, kInt8Ptr)[0].ptr - LLVMStructType(typeList, 3, 0) - }!! + val kCtorType = LLVMStructType( + cValuesOf( + LLVMInt32Type(), + LLVMPointerType(kVoidFuncType, 0), + kInt8Ptr + ), + 3, 0)!! //-------------------------------------------------------------------------// // Create object { i32, void ()*, i8* } { i32 1, void ()* @ctorFunction, i8* null } - fun createGlobalCtor(ctorFunction: LLVMValueRef) = memScoped { + fun createGlobalCtor(ctorFunction: LLVMValueRef): ConstPointer { val priority = kImmInt32One val data = kNullInt8Ptr - val argList = allocArrayOf(priority, ctorFunction, data)[0].ptr + val argList = cValuesOf(priority, ctorFunction, data) val ctorItem = LLVMConstNamedStruct(kCtorType, argList, 3)!! - constPointer(ctorItem) + return constPointer(ctorItem) } //-------------------------------------------------------------------------// diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmDeclarations.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmDeclarations.kt index a528169aa34..488444ef22f 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmDeclarations.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmDeclarations.kt @@ -123,14 +123,12 @@ private fun ContextUtils.getDeclaredFields(classDescriptor: ClassDescriptor): Li } private fun ContextUtils.createClassBodyType(name: String, fields: List): LLVMTypeRef { - val fieldTypes = fields.map { getLLVMType(if (it.isDelegated) context.builtIns.nullableAnyType else it.type) }.toTypedArray() + val fieldTypes = fields.map { getLLVMType(if (it.isDelegated) context.builtIns.nullableAnyType else it.type) } val classType = LLVMStructCreateNamed(LLVMGetModuleContext(context.llvmModule), name)!! - memScoped { - val fieldTypesNativeArrayPtr = allocArrayOf(*fieldTypes)[0].ptr - LLVMStructSetBody(classType, fieldTypesNativeArrayPtr, fieldTypes.size, 0) - } + LLVMStructSetBody(classType, fieldTypes.toCValues(), fieldTypes.size, 0) + return classType } diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt index 489b63f192a..d1a31ee8f4c 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/LlvmUtils.kt @@ -31,24 +31,15 @@ internal fun constPointer(value: LLVMValueRef) = object : ConstPointer { } private class ConstGetElementPtr(val pointer: ConstPointer, val index: Int) : ConstPointer { - override val llvm = memScoped { - // TODO: squash multiple GEPs - val indices = intArrayOf(0, index).map { Int32(it).llvm } - val indicesArray = allocArrayOf(indices) - LLVMConstInBoundsGEP(pointer.llvm, indicesArray[0].ptr, indices.size)!! - } + override val llvm = LLVMConstInBoundsGEP(pointer.llvm, cValuesOf(Int32(0).llvm, Int32(index).llvm), 2)!! + // TODO: squash multiple GEPs } internal fun ConstPointer.bitcast(toType: LLVMTypeRef) = constPointer(LLVMConstBitCast(this.llvm, toType)!!) internal class ConstArray(val elemType: LLVMTypeRef?, val elements: List) : ConstValue { - override val llvm = memScoped { - val values = elements.map { it.llvm }.toTypedArray() - - val valuesNativeArrayPtr = allocArrayOf(*values)[0].ptr - LLVMConstArray(elemType, valuesNativeArrayPtr, values.size)!! - } + override val llvm = LLVMConstArray(elemType, elements.map { it.llvm }.toCValues(), elements.size)!! } internal open class Struct(val type: LLVMTypeRef?, val elements: List) : ConstValue { @@ -57,11 +48,7 @@ internal open class Struct(val type: LLVMTypeRef?, val elements: List): LLVMTypeRef = memScoped { - LLVMStructType(allocArrayOf(types)[0].ptr, types.size, 0)!! -} +internal fun structType(types: List): LLVMTypeRef = + LLVMStructType(types.toCValues(), types.size, 0)!! internal fun ContextUtils.numParameters(functionType: LLVMTypeRef) : Int { // Note that type is usually function pointer, so we have to dereference it. @@ -192,20 +178,21 @@ internal fun ContextUtils.externalGlobal(name: String, type: LLVMTypeRef): LLVMV } internal fun functionType(returnType: LLVMTypeRef, isVarArg: Boolean = false, vararg paramTypes: LLVMTypeRef) = - memScoped { - val paramTypesPtr = allocArrayOf(*paramTypes)[0].ptr - LLVMFunctionType(returnType, paramTypesPtr, paramTypes.size, if (isVarArg) 1 else 0)!! - } + LLVMFunctionType( + returnType, + cValuesOf(*paramTypes), paramTypes.size, + if (isVarArg) 1 else 0 + )!! fun llvm2string(value: LLVMValueRef?): String { if (value == null) return "" - return LLVMPrintValueToString(value)!!.asCString().toString() + return LLVMPrintValueToString(value)!!.toKString() } fun llvmtype2string(type: LLVMTypeRef?): String { if (type == null) return "" - return LLVMPrintTypeToString(type)!!.asCString().toString() + return LLVMPrintTypeToString(type)!!.toKString() } fun getStructElements(type: LLVMTypeRef): List { diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt index ad88bcafe10..fd97be999d6 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/MetadataGenerator.kt @@ -61,7 +61,7 @@ class MetadataReader(file: File) : Closeable { val errorRef = allocPointerTo() val res = LLVMCreateMemoryBufferWithContentsOfFile(file.toString(), bufRef.ptr, errorRef.ptr) if (res != 0) { - throw Error(errorRef.value?.asCString()?.toString()) + throw Error(errorRef.value?.toKString()) } llvmContext = LLVMContextCreate()!! @@ -80,7 +80,7 @@ class MetadataReader(file: File) : Closeable { memScoped { val len = alloc() val str1 = LLVMGetMDString(node, len.ptr)!! - val str = str1.asCString().toString() + val str = str1.toKString() return str } @@ -117,10 +117,7 @@ class MetadataReader(file: File) : Closeable { internal class MetadataGenerator(override val context: Context): ContextUtils { private fun metadataNode(args: List): LLVMValueRef { - memScoped { - val references = allocArrayOf(args) - return LLVMMDNode(references[0].ptr, args.size)!! - } + return LLVMMDNode(args.toCValues(), args.size)!! } private fun metadataFun(fn: LLVMValueRef, info: String): LLVMValueRef { diff --git a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt index ae07dc95135..c5f7f55aa9f 100644 --- a/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt +++ b/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/Runtime.kt @@ -21,7 +21,7 @@ class Runtime(private val bitcodeFile: String) { val res = LLVMCreateMemoryBufferWithContentsOfFile(bitcodeFile, bufRef.ptr, errorRef.ptr) if (res != 0) { - throw Error(errorRef.value?.asCString()?.toString()) + throw Error(errorRef.value?.toKString()) } val moduleRef = alloc() @@ -45,9 +45,9 @@ class Runtime(private val bitcodeFile: String) { val objHeaderType = getStructType("ObjHeader") val arrayHeaderType = getStructType("ArrayHeader") - val target = LLVMGetTarget(llvmModule)!!.asCString().toString() + val target = LLVMGetTarget(llvmModule)!!.toKString() - val dataLayout = LLVMGetDataLayout(llvmModule)!!.asCString().toString() + val dataLayout = LLVMGetDataLayout(llvmModule)!!.toKString() val targetData = LLVMCreateTargetData(dataLayout)!! diff --git a/backend.native/tests/interop/basics/opengl_teapot.kt b/backend.native/tests/interop/basics/opengl_teapot.kt index 6b2a044c88f..56abd7b2e7a 100644 --- a/backend.native/tests/interop/basics/opengl_teapot.kt +++ b/backend.native/tests/interop/basics/opengl_teapot.kt @@ -65,16 +65,9 @@ fun initialize() { // specify implementation-specific hints glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST) - memScoped { - val ambLight: CArray = allocArrayOf(0.1f, 0.1f, 0.1f, 1.0f) - val diffuse: CArray = allocArrayOf(0.6f, 0.6f, 0.6f, 1.0f) - val specular: CArray = allocArrayOf(0.7f, 0.7f, 0.3f, 1.0f) - - glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambLight[0].ptr) - glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse[0].ptr) - glLightfv(GL_LIGHT0, GL_SPECULAR, specular[0].ptr) - } - + glLightModelfv(GL_LIGHT_MODEL_AMBIENT, cValuesOf(0.1f, 0.1f, 0.1f, 1.0f)) + glLightfv(GL_LIGHT0, GL_DIFFUSE, cValuesOf(0.6f, 0.6f, 0.6f, 1.0f)) + glLightfv(GL_LIGHT0, GL_SPECULAR, cValuesOf(0.7f, 0.7f, 0.3f, 1.0f)) glEnable(GL_LIGHT0) glEnable(GL_COLOR_MATERIAL) diff --git a/runtime/src/main/kotlin/konan/internal/InteropBoxing.kt b/runtime/src/main/kotlin/konan/internal/InteropBoxing.kt index ef2098ee539..6da63966143 100644 --- a/runtime/src/main/kotlin/konan/internal/InteropBoxing.kt +++ b/runtime/src/main/kotlin/konan/internal/InteropBoxing.kt @@ -38,7 +38,7 @@ class NativePointedBox(val value: NativePointed) { fun boxNativePointed(value: NativePointed?) = if (value != null) NativePointedBox(value) else null fun unboxNativePointed(box: NativePointedBox?) = box?.value -class CPointerBox(val value: CPointer<*>) { +class CPointerBox(val value: CPointer) : CValuesRef() { override fun equals(other: Any?): Boolean { if (other !is CPointerBox) { return false @@ -50,7 +50,9 @@ class CPointerBox(val value: CPointer<*>) { override fun hashCode() = value.hashCode() override fun toString() = value.toString() + + override fun getPointer(placement: NativePlacement) = value.getPointer(placement) } -fun boxCPointer(value: CPointer<*>?) = if (value != null) CPointerBox(value) else null +fun boxCPointer(value: CPointer?) = if (value != null) CPointerBox(value) else null fun unboxCPointer(box: CPointerBox?) = box?.value \ No newline at end of file diff --git a/samples/tetris/tetris.kt b/samples/tetris/tetris.kt index fa65c86f440..d13b39b0a54 100644 --- a/samples/tetris/tetris.kt +++ b/samples/tetris/tetris.kt @@ -491,7 +491,7 @@ class Game(width: Int, height: Int, val visualizer: GameFieldVisualizer, val use } -fun get_SDL_Error() = SDL_GetError()!!.asCString().toString() +fun get_SDL_Error() = SDL_GetError()!!.toKString() class SDL_Visualizer(val width: Int, val height: Int): GameFieldVisualizer, UserInput { private val CELL_SIZE = 20