XDLCompiler - GitLite

KO | EN

gitlite — search

#javascript #react #ai #llm #golang #machine-learning #rust #docker #macos #kubernetes #awesome-list #pytorch #mcp #openai

XDLCompiler

(★ 129)

The XDL language compiler

파일 탐색기

최종 버전 다운로드 (.zip)

- - dotnet.yml
  - release.yml
- unknown.xdl
- AbiAddedAttribute.cs
- AbiRemovedAttribute.cs
- CFormatter.cs
- ConditionalAttribute.cs
- ForceAbiAttribute.cs
- HeaderGenerator.cs
- IAttributeFactory.cs
- ISyntaxVisitor.cs
- MemoryExtensions.cs
- NoEmitAttribute.cs
- NoImplAttribute.cs
- NoUuidAttribute.cs
- Program.cs
- RawGuid.cs
- RcxReturnAttribute.cs
- RegReturnAttribute.cs
- SyntaxNode.cs
- SyntaxNodeExtensions.cs
- SyntaxVisitor.cs
- TextPosition.cs
- Token.cs
- TokenId.cs
- TokenReader.cs
- TokenReaderState.cs
- UuidAttribute.cs
- XdlReader.cs
- base.h
.gitattributes
.gitignore
Directory.Build.props
LICENSE
README.md
XDLCompiler.csproj

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# XDL Compiler

XDL is a definition language similar to Microsoft IDL but with versioning support and less strict rules.

### Usage

```bash
xdl <input_file>.xdl <output_dir> [prefix]
```

`input_file` : the name of the input xdl file

`output_dir` : the folder where headers are generated into

`prefix` : the prefix to use for the generated factory function and template macros, if no prefix is specified then none of that is generated

The factory function is defined like this

```cpp
template<template<abi_t> typename T>
inline HRESULT PrefixCreateInstance(abi_t ABI, void **ppvObject)
```

So if `prefix` was set to `Example`, the factory will be named `ExampleCreateInstance`.

It can be used like this:

```cpp
abi_t abi;
abi.Major = 10;
abi.Minor = 0;
abi.Build = 15063;
abi.Revision = 0;

IVersionedClassFactory* pClass;
HRESULT hr = PrefixCreateInstance<VersionedClassFactory>(abi, (void**)&pClass);
```

The factory class can be defined like this:

```csharp
[no_uuid]
interface IVersionedClassFactory
{
    HRESULT CreateMyVersionedClass([out] void** ppClass);
};

[force_abi]
class VersionedClassFactory : IVersionedClassFactory
{
};
```

and the implementation of `CreateMyVersionedClass` can look like this:

```cpp
HRESULT CreateMyVersionedClass(void** ppClass)
{
    *ppClass = new MyVersionedClass<ABI>();
}
```

### TODO

- [ ] Support full C declarator syntax (including function pointers)
- [ ] Recognize annotations and translate them to SAL on the C++ types
- [ ] Support for defining constants
- [ ] Support for simple expressions with constants (i.e. `1 + 1`)
- [ ] Proper error checking and better error messages
- [ ] Support for optionally generating headers for imports
- [ ] Support for multiple XDL file inputs

### Examples

The following example showcases how to define a simple interface that makes use of basic XDL versioning features

```csharp
import "unknown.xdl";

namespace simple_example
{
    [uuid("f0d7fd9c-33a3-4fc3-abe1-511c8917dbf6")]
    interface ISimpleClass : IUnknown
    {
        [removed(10,0,15063,0)]
        UINT m_StringsCount;
        
        [added(10,0,15063,0)]
        UINT64 m_StringsCount;
        
        [removed(10,0,15063,0)]
        UINT AddString([in] LPCSTR pString);
        
        [added(10,0,15063,0)]
        UINT64 AddString([in] LPCWSTR lpString);
        
        [removed(10,0,15063,0)]
        UINT GetString([out] LPCSTR pString, [in] UINT size, [in] UINT index);
        
        [added(10,0,15063,0)]
        UINT64 GetString([out] LPCWSTR lpString, [in] UINT64 size, [in] UINT64 index);
    };
    
    class SimpleClass : ISimpleClass
    {
    };
}
```

The following example showcases how to define complex interfaces/classes that make use of more advanced XDL versioning features

```csharp
import "unknown.xdl";

namespace gfx
{
    struct GraphicsClassDesc
    {
        UINT TexturesCapacity;
        [added(6,2,9200,0)] UINT ShadersCapacity;
        [added(10,0,15063,0), removed(10,0,22000,0)] UINT ViewsCapacity;
        [removed(10,0,18362,0)] UINT OpaqueDataCapacity;
    };

[uuid("b54c4d35-8172-4575-9362-a614d34a834b")]
    interface IGraphicsClass : IGraphicsUnknown
    {
        GraphicsClassDesc m_Desc;
        
        HRESULT Initialize([in] IUnknown* pGraphicsDevice);
        void GetDevice([out] IUnknown** ppGraphicsDevice);
        
        [added(10,0,22000,0)]
        HRESULT UpdateDevice(IUnknown* pGraphicsDevice);
    };
    
    class SomeGraphicsClass : IGraphicsClass
    {
    };
    
    enum MemoryPressure
    {
        Low,
        Medium,
        High
    };
    
    struct MemoryInfo
    {
        UINT64 TotalAllocated;
        UINT64 TotalFreed;
        
        [conditional("defined(TRACK_MEMORY_PRESSURE)")]
        MemoryPressure Pressure;
    };
    
    [uuid("1bc4eedb-9043-47ad-9572-590d1e50771b")]
    interface IMemoryManager : IUnknown
    {
        HRESULT AllocateMemory([in] UINT64 size, [out] void** ppMemory);
        
        [removed(10,0,22000,0)]
        UINT64 GetTotalAllocatedMemory();
        
        [removed(10,0,22000,0)]
        UINT64 GetTotalFreedMemory();
        
        [removed(10,0,22000,0)]
        [conditional("defined(TRACK_MEMORY_PRESSURE)")]
        MemoryPressure GetMemoryPressure();
        
        [added(10,0,22000,0)]
        void GetMemoryInfo([out] MemoryInfo* pMemoryInfo);
    };
    
    [uuid("a97f9933-9696-423d-9e2a-44c9cefbd058")]
    interface IMemoryManager2 : [removed(10,0,26100,0)] IUnknown, [added(10,0,26100,0)] IMemoryManager
    {
        HRESULT FreeMemory([in] void* ppMemory);
    };
    
    class MemoryManager : [removed(10,0,26100,0)] IMemoryManager, [added(10,0,22631,0)] IMemoryManager2
    {
    };
}
```