Context API completed. Updated readme

Author: mrLSD

README.md

@@ -1,19 +1,58 @@
-# Swift LLVM codegen
+# `llvm-api-swift`
 
-`SwiftLLVMCodegen` is a pure Swift interface to the [LLVM API](https://llvm.org/docs/) and its associated libraries. It provides
-native, easy-to-use components to create compilers codegen backend. It contains LLVM bindings,
-components and toolset for `Codegen` implementation on Swift.
+`llvm-api-swift` is a library representing Swift LLVM API, a pure Swift interface to the [LLVM API](https://llvm.org/docs/) and its associated libraries. 
+It provides native, easy-to-use components to create compilers codegen backend. It contains LLVM bindings,
+components and toolset for efficiently use LLVM as compilers backend implementation on Swift.
 
-## Status
+### Compatibility with LLVM-C API
 
-In progress...
+When creating the library, we were guided by **full compatibility** with [LLVM-C API](https://llvm.org/doxygen/group__LLVMC.html).
+For this reason, structurally the library tries to inherit the `LLVM-C API` tree, thereby dividing the library structure into subdirectories. 
+And filling the components also with the appropriate `LLVM-C API`.
+When implementing Swift types, we were guided by the approach of abstracting away from C types, completely transforming them into Swift types. 
+At the same time adhering to the principles of a safety and reliability implementation - without explicit memory management, means of safe techniques, functions provided by Swift.
 
-### Supported LLVM version
 
-**v17.0**
+### Requirements
+- Supported OS: MacOS 12.0 or above
+- Swift lang: 5.9 or above
+
+- Install LLVM:
+```
+brew install llvm
+```
+- Set Environment variables, that provided during `brew` llvm install
+- initialize `pkg-config`:
+```
+./utils/make-pkg-config.swift
+```
 
-## Inspiration
+**NOTE:** Every time, when LLVM is updated or installed new version should be run `pkg-config` step.
 
-Inspired by [SwiftLLVM](https://github.com/llvm-swift/LLVMSwift).
+### Supported LLVM version
 
-## LICENS: [MIT](LICENSE)
+- [x] v17.0
+
+
+### Troubleshooting
+
+If `LLVM-C` head files during compulation doesn't found, make sure that you:
+- installed LLVM
+```
+llv --version
+```
+- Set environment variables for your terminal (for example in `.zshrc`). To get instruction about variables run:
+```
+brew info llvm
+```
+- run pkg-config utility:
+```
+./utils/make-pkg-config.swift
+```
+- if utility doesn't have access right to run:
+```
+chmod +x ./utils/make-pkg-config.swift
+./utils/make-pkg-config.swift
+```
+
+### LICENS: [MIT](LICENSE)

llvm-codegen/CLLVM/bridge.h

@@ -13,7 +13,7 @@
 #include <llvm-c/BitReader.h>
 #include <llvm-c/BitWriter.h>
 #include <llvm-c/Comdat.h>
-    #include <llvm-c/Core.h>
+#include <llvm-c/Core.h>
 #include <llvm-c/DataTypes.h>
 #include <llvm-c/DebugInfo.h>
 #include <llvm-c/Disassembler.h>

llvm-codegen/LLVM/Context.swift

@@ -101,18 +101,17 @@ public class Context: ContextRef {
     /// Return a string representation of the DiagnosticInfo. Use
     /// LLVMDisposeMessage to free the string.
     public func getDiagInfoDescription(diagnosticInfo: DiagnosticInfoRef) -> String? {
-        if let cString = LLVMGetDiagInfoDescription(diagnosticInfo.diagnosticInfoRef) {
-            return String(cString: cString)
-        } else {
-            return nil
-        }
+        guard let cString = LLVMGetDiagInfoDescription(diagnosticInfo.diagnosticInfoRef) else { return nil }
+        return String(cString: cString)
     }
 
     /// Return an enum LLVMDiagnosticSeverity.
     public func getDiagInfoSeverity(diagnosticInfo: DiagnosticInfoRef) -> LLVMDiagnosticSeverity {
         LLVMGetDiagInfoSeverity(diagnosticInfo.diagnosticInfoRef)
     }
 
+    /// Get  Metadata KindId by name in current Context.
+    /// Useful for working with Metadata
     public func getMDKindIDInContext(name: String) -> UInt32 {
         name.withCString { cString in
             LLVMGetMDKindIDInContext(llvm, cString, UInt32(name.utf8.count))
@@ -121,7 +120,7 @@ public class Context: ContextRef {
 
     public func getMDKindID(name: String) -> UInt32 {
         name.withCString { cString in
-            LLVMGetMDKindIDInContext(llvm, cString, UInt32(name.utf8.count))
+            LLVMGetMDKindID(cString, UInt32(name.utf8.count))
         }
     }
 
@@ -192,33 +191,44 @@ public class Context: ContextRef {
     //===============================
 
     /// Get the string attribute's kind.
-    public func getStringAttributeKind() {
-        // const char *LLVMGetStringAttributeKind(LLVMAttributeRef A, unsigned *Length);
+    public func getStringAttributeKind(attributeRef: AttributeRef, length: UInt32) -> String? {
+        var mutLength = length
+        guard let cString = withUnsafeMutablePointer(to: &mutLength, { lengthPtr in
+            LLVMGetStringAttributeKind(attributeRef.attributeRef, lengthPtr)
+        }) else { return nil }
+        return String(cString: cString)
     }
 
     /// Get the string attribute's value.
-    public func getStringAttributeValue() {
-        // const char *LLVMGetStringAttributeValue(LLVMAttributeRef A, unsigned *Length);
+    public func getStringAttributeValue(attributeRef: AttributeRef, length: UInt32) -> String? {
+        var mutLength = length
+        guard let cString = withUnsafeMutablePointer(to: &mutLength, { lengthPtr in
+            LLVMGetStringAttributeValue(attributeRef.attributeRef, lengthPtr)
+        }) else { return nil }
+        return String(cString: cString)
     }
 
     /// Check for the  types of attributes.
-    public func isEnumAttribute() {
-        // LLVMBool LLVMIsEnumAttribute(LLVMAttributeRef A);
+    public func isEnumAttribute(attributeRef: AttributeRef) -> Bool {
+        return LLVMIsEnumAttribute(attributeRef.attributeRef) != 0
     }
 
     /// Check for the  types of attributes.
-    public func isStringAttribute() {
-        // LLVMBool LLVMIsStringAttribute(LLVMAttributeRef A);
+    public func isStringAttribute(attributeRef: AttributeRef) -> Bool {
+        return LLVMIsStringAttribute(attributeRef.attributeRef) != 0
     }
 
     /// Check for the  types of attributes.
-    public func isTypeAttribute() {
-        // LLVMBool LLVMIsTypeAttribute(LLVMAttributeRef A);
+    public func isTypeAttribute(attributeRef: AttributeRef) -> Bool {
+        return LLVMIsTypeAttribute(attributeRef.attributeRef) != 0
     }
 
     /// Obtain a Type from a context by its registered name.
-    public func getTypeByName2() {
-        // LLVMTypeRef LLVMGetTypeByName2(LLVMContextRef C, const char *Name);
+    public func getTypeByName2(name: String) -> TypeRef? {
+        name.withCString { cString in
+            guard let typeRef = LLVMGetTypeByName2(llvm, cString) else { return nil }
+            return Types(llvm: typeRef)
+        }
     }
 
     /// Deinitialize this value and dispose of its resources.