llvm/mlir/lib/CAPI/IR/BuiltinAttributes.cpp

//===- BuiltinAttributes.cpp - C Interface to MLIR Builtin Attributes -----===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "mlir-c/BuiltinAttributes.h"
#include "mlir-c/Support.h"
#include "mlir/CAPI/AffineMap.h"
#include "mlir/CAPI/IR.h"
#include "mlir/CAPI/IntegerSet.h"
#include "mlir/CAPI/Support.h"
#include "mlir/IR/AsmState.h"
#include "mlir/IR/Attributes.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/BuiltinTypes.h"

usingnamespacemlir;

MlirAttribute mlirAttributeGetNull() { … }

//===----------------------------------------------------------------------===//
// Location attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsALocation(MlirAttribute attr) { … }

//===----------------------------------------------------------------------===//
// Affine map attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAAffineMap(MlirAttribute attr) { … }

MlirAttribute mlirAffineMapAttrGet(MlirAffineMap map) { … }

MlirAffineMap mlirAffineMapAttrGetValue(MlirAttribute attr) { … }

MlirTypeID mlirAffineMapAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// Array attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAArray(MlirAttribute attr) { … }

MlirAttribute mlirArrayAttrGet(MlirContext ctx, intptr_t numElements,
                               MlirAttribute const *elements) { … }

intptr_t mlirArrayAttrGetNumElements(MlirAttribute attr) { … }

MlirAttribute mlirArrayAttrGetElement(MlirAttribute attr, intptr_t pos) { … }

MlirTypeID mlirArrayAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// Dictionary attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsADictionary(MlirAttribute attr) { … }

MlirAttribute mlirDictionaryAttrGet(MlirContext ctx, intptr_t numElements,
                                    MlirNamedAttribute const *elements) { … }

intptr_t mlirDictionaryAttrGetNumElements(MlirAttribute attr) { … }

MlirNamedAttribute mlirDictionaryAttrGetElement(MlirAttribute attr,
                                                intptr_t pos) { … }

MlirAttribute mlirDictionaryAttrGetElementByName(MlirAttribute attr,
                                                 MlirStringRef name) { … }

MlirTypeID mlirDictionaryAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// Floating point attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAFloat(MlirAttribute attr) { … }

MlirAttribute mlirFloatAttrDoubleGet(MlirContext ctx, MlirType type,
                                     double value) { … }

MlirAttribute mlirFloatAttrDoubleGetChecked(MlirLocation loc, MlirType type,
                                            double value) { … }

double mlirFloatAttrGetValueDouble(MlirAttribute attr) { … }

MlirTypeID mlirFloatAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// Integer attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAInteger(MlirAttribute attr) { … }

MlirAttribute mlirIntegerAttrGet(MlirType type, int64_t value) { … }

int64_t mlirIntegerAttrGetValueInt(MlirAttribute attr) { … }

int64_t mlirIntegerAttrGetValueSInt(MlirAttribute attr) { … }

uint64_t mlirIntegerAttrGetValueUInt(MlirAttribute attr) { … }

MlirTypeID mlirIntegerAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// Bool attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsABool(MlirAttribute attr) { … }

MlirAttribute mlirBoolAttrGet(MlirContext ctx, int value) { … }

bool mlirBoolAttrGetValue(MlirAttribute attr) { … }

//===----------------------------------------------------------------------===//
// Integer set attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAIntegerSet(MlirAttribute attr) { … }

MlirTypeID mlirIntegerSetAttrGetTypeID(void) { … }

MlirAttribute mlirIntegerSetAttrGet(MlirIntegerSet set) { … }

MlirIntegerSet mlirIntegerSetAttrGetValue(MlirAttribute attr) { … }

//===----------------------------------------------------------------------===//
// Opaque attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAOpaque(MlirAttribute attr) { … }

MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, MlirStringRef dialectNamespace,
                                intptr_t dataLength, const char *data,
                                MlirType type) { … }

MlirStringRef mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr) { … }

MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr) { … }

MlirTypeID mlirOpaqueAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// String attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAString(MlirAttribute attr) { … }

MlirAttribute mlirStringAttrGet(MlirContext ctx, MlirStringRef str) { … }

MlirAttribute mlirStringAttrTypedGet(MlirType type, MlirStringRef str) { … }

MlirStringRef mlirStringAttrGetValue(MlirAttribute attr) { … }

MlirTypeID mlirStringAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// SymbolRef attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsASymbolRef(MlirAttribute attr) { … }

MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, MlirStringRef symbol,
                                   intptr_t numReferences,
                                   MlirAttribute const *references) { … }

MlirStringRef mlirSymbolRefAttrGetRootReference(MlirAttribute attr) { … }

MlirStringRef mlirSymbolRefAttrGetLeafReference(MlirAttribute attr) { … }

intptr_t mlirSymbolRefAttrGetNumNestedReferences(MlirAttribute attr) { … }

MlirAttribute mlirSymbolRefAttrGetNestedReference(MlirAttribute attr,
                                                  intptr_t pos) { … }

MlirTypeID mlirSymbolRefAttrGetTypeID(void) { … }

MlirAttribute mlirDisctinctAttrCreate(MlirAttribute referencedAttr) { … }

//===----------------------------------------------------------------------===//
// Flat SymbolRef attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAFlatSymbolRef(MlirAttribute attr) { … }

MlirAttribute mlirFlatSymbolRefAttrGet(MlirContext ctx, MlirStringRef symbol) { … }

MlirStringRef mlirFlatSymbolRefAttrGetValue(MlirAttribute attr) { … }

//===----------------------------------------------------------------------===//
// Type attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAType(MlirAttribute attr) { … }

MlirAttribute mlirTypeAttrGet(MlirType type) { … }

MlirType mlirTypeAttrGetValue(MlirAttribute attr) { … }

MlirTypeID mlirTypeAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// Unit attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAUnit(MlirAttribute attr) { … }

MlirAttribute mlirUnitAttrGet(MlirContext ctx) { … }

MlirTypeID mlirUnitAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// Elements attributes.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAElements(MlirAttribute attr) { … }

MlirAttribute mlirElementsAttrGetValue(MlirAttribute attr, intptr_t rank,
                                       uint64_t *idxs) { … }

bool mlirElementsAttrIsValidIndex(MlirAttribute attr, intptr_t rank,
                                  uint64_t *idxs) { … }

int64_t mlirElementsAttrGetNumElements(MlirAttribute attr) { … }

//===----------------------------------------------------------------------===//
// Dense array attribute.
//===----------------------------------------------------------------------===//

MlirTypeID mlirDenseArrayAttrGetTypeID() { … }

//===----------------------------------------------------------------------===//
// IsA support.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsADenseBoolArray(MlirAttribute attr) { … }
bool mlirAttributeIsADenseI8Array(MlirAttribute attr) { … }
bool mlirAttributeIsADenseI16Array(MlirAttribute attr) { … }
bool mlirAttributeIsADenseI32Array(MlirAttribute attr) { … }
bool mlirAttributeIsADenseI64Array(MlirAttribute attr) { … }
bool mlirAttributeIsADenseF32Array(MlirAttribute attr) { … }
bool mlirAttributeIsADenseF64Array(MlirAttribute attr) { … }

//===----------------------------------------------------------------------===//
// Constructors.
//===----------------------------------------------------------------------===//

MlirAttribute mlirDenseBoolArrayGet(MlirContext ctx, intptr_t size,
                                    int const *values) { … }
MlirAttribute mlirDenseI8ArrayGet(MlirContext ctx, intptr_t size,
                                  int8_t const *values) { … }
MlirAttribute mlirDenseI16ArrayGet(MlirContext ctx, intptr_t size,
                                   int16_t const *values) { … }
MlirAttribute mlirDenseI32ArrayGet(MlirContext ctx, intptr_t size,
                                   int32_t const *values) { … }
MlirAttribute mlirDenseI64ArrayGet(MlirContext ctx, intptr_t size,
                                   int64_t const *values) { … }
MlirAttribute mlirDenseF32ArrayGet(MlirContext ctx, intptr_t size,
                                   float const *values) { … }
MlirAttribute mlirDenseF64ArrayGet(MlirContext ctx, intptr_t size,
                                   double const *values) { … }

//===----------------------------------------------------------------------===//
// Accessors.
//===----------------------------------------------------------------------===//

intptr_t mlirDenseArrayGetNumElements(MlirAttribute attr) { … }

//===----------------------------------------------------------------------===//
// Indexed accessors.
//===----------------------------------------------------------------------===//

bool mlirDenseBoolArrayGetElement(MlirAttribute attr, intptr_t pos) { … }
int8_t mlirDenseI8ArrayGetElement(MlirAttribute attr, intptr_t pos) { … }
int16_t mlirDenseI16ArrayGetElement(MlirAttribute attr, intptr_t pos) { … }
int32_t mlirDenseI32ArrayGetElement(MlirAttribute attr, intptr_t pos) { … }
int64_t mlirDenseI64ArrayGetElement(MlirAttribute attr, intptr_t pos) { … }
float mlirDenseF32ArrayGetElement(MlirAttribute attr, intptr_t pos) { … }
double mlirDenseF64ArrayGetElement(MlirAttribute attr, intptr_t pos) { … }

//===----------------------------------------------------------------------===//
// Dense elements attribute.
//===----------------------------------------------------------------------===//

//===----------------------------------------------------------------------===//
// IsA support.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsADenseElements(MlirAttribute attr) { … }

bool mlirAttributeIsADenseIntElements(MlirAttribute attr) { … }

bool mlirAttributeIsADenseFPElements(MlirAttribute attr) { … }

MlirTypeID mlirDenseIntOrFPElementsAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// Constructors.
//===----------------------------------------------------------------------===//

MlirAttribute mlirDenseElementsAttrGet(MlirType shapedType,
                                       intptr_t numElements,
                                       MlirAttribute const *elements) { … }

MlirAttribute mlirDenseElementsAttrRawBufferGet(MlirType shapedType,
                                                size_t rawBufferSize,
                                                const void *rawBuffer) { … }

MlirAttribute mlirDenseElementsAttrSplatGet(MlirType shapedType,
                                            MlirAttribute element) { … }
MlirAttribute mlirDenseElementsAttrBoolSplatGet(MlirType shapedType,
                                                bool element) { … }
MlirAttribute mlirDenseElementsAttrUInt8SplatGet(MlirType shapedType,
                                                 uint8_t element) { … }
MlirAttribute mlirDenseElementsAttrInt8SplatGet(MlirType shapedType,
                                                int8_t element) { … }
MlirAttribute mlirDenseElementsAttrUInt32SplatGet(MlirType shapedType,
                                                  uint32_t element) { … }
MlirAttribute mlirDenseElementsAttrInt32SplatGet(MlirType shapedType,
                                                 int32_t element) { … }
MlirAttribute mlirDenseElementsAttrUInt64SplatGet(MlirType shapedType,
                                                  uint64_t element) { … }
MlirAttribute mlirDenseElementsAttrInt64SplatGet(MlirType shapedType,
                                                 int64_t element) { … }
MlirAttribute mlirDenseElementsAttrFloatSplatGet(MlirType shapedType,
                                                 float element) { … }
MlirAttribute mlirDenseElementsAttrDoubleSplatGet(MlirType shapedType,
                                                  double element) { … }

MlirAttribute mlirDenseElementsAttrBoolGet(MlirType shapedType,
                                           intptr_t numElements,
                                           const int *elements) { … }

/// Creates a dense attribute with elements of the type deduced by templates.
template <typename T>
static MlirAttribute getDenseAttribute(MlirType shapedType,
                                       intptr_t numElements,
                                       const T *elements) { … }

MlirAttribute mlirDenseElementsAttrUInt8Get(MlirType shapedType,
                                            intptr_t numElements,
                                            const uint8_t *elements) { … }
MlirAttribute mlirDenseElementsAttrInt8Get(MlirType shapedType,
                                           intptr_t numElements,
                                           const int8_t *elements) { … }
MlirAttribute mlirDenseElementsAttrUInt16Get(MlirType shapedType,
                                             intptr_t numElements,
                                             const uint16_t *elements) { … }
MlirAttribute mlirDenseElementsAttrInt16Get(MlirType shapedType,
                                            intptr_t numElements,
                                            const int16_t *elements) { … }
MlirAttribute mlirDenseElementsAttrUInt32Get(MlirType shapedType,
                                             intptr_t numElements,
                                             const uint32_t *elements) { … }
MlirAttribute mlirDenseElementsAttrInt32Get(MlirType shapedType,
                                            intptr_t numElements,
                                            const int32_t *elements) { … }
MlirAttribute mlirDenseElementsAttrUInt64Get(MlirType shapedType,
                                             intptr_t numElements,
                                             const uint64_t *elements) { … }
MlirAttribute mlirDenseElementsAttrInt64Get(MlirType shapedType,
                                            intptr_t numElements,
                                            const int64_t *elements) { … }
MlirAttribute mlirDenseElementsAttrFloatGet(MlirType shapedType,
                                            intptr_t numElements,
                                            const float *elements) { … }
MlirAttribute mlirDenseElementsAttrDoubleGet(MlirType shapedType,
                                             intptr_t numElements,
                                             const double *elements) { … }
MlirAttribute mlirDenseElementsAttrBFloat16Get(MlirType shapedType,
                                               intptr_t numElements,
                                               const uint16_t *elements) { … }
MlirAttribute mlirDenseElementsAttrFloat16Get(MlirType shapedType,
                                              intptr_t numElements,
                                              const uint16_t *elements) { … }

MlirAttribute mlirDenseElementsAttrStringGet(MlirType shapedType,
                                             intptr_t numElements,
                                             MlirStringRef *strs) { … }

MlirAttribute mlirDenseElementsAttrReshapeGet(MlirAttribute attr,
                                              MlirType shapedType) { … }

//===----------------------------------------------------------------------===//
// Splat accessors.
//===----------------------------------------------------------------------===//

bool mlirDenseElementsAttrIsSplat(MlirAttribute attr) { … }

MlirAttribute mlirDenseElementsAttrGetSplatValue(MlirAttribute attr) { … }
int mlirDenseElementsAttrGetBoolSplatValue(MlirAttribute attr) { … }
int8_t mlirDenseElementsAttrGetInt8SplatValue(MlirAttribute attr) { … }
uint8_t mlirDenseElementsAttrGetUInt8SplatValue(MlirAttribute attr) { … }
int32_t mlirDenseElementsAttrGetInt32SplatValue(MlirAttribute attr) { … }
uint32_t mlirDenseElementsAttrGetUInt32SplatValue(MlirAttribute attr) { … }
int64_t mlirDenseElementsAttrGetInt64SplatValue(MlirAttribute attr) { … }
uint64_t mlirDenseElementsAttrGetUInt64SplatValue(MlirAttribute attr) { … }
float mlirDenseElementsAttrGetFloatSplatValue(MlirAttribute attr) { … }
double mlirDenseElementsAttrGetDoubleSplatValue(MlirAttribute attr) { … }
MlirStringRef mlirDenseElementsAttrGetStringSplatValue(MlirAttribute attr) { … }

//===----------------------------------------------------------------------===//
// Indexed accessors.
//===----------------------------------------------------------------------===//

bool mlirDenseElementsAttrGetBoolValue(MlirAttribute attr, intptr_t pos) { … }
int8_t mlirDenseElementsAttrGetInt8Value(MlirAttribute attr, intptr_t pos) { … }
uint8_t mlirDenseElementsAttrGetUInt8Value(MlirAttribute attr, intptr_t pos) { … }
int16_t mlirDenseElementsAttrGetInt16Value(MlirAttribute attr, intptr_t pos) { … }
uint16_t mlirDenseElementsAttrGetUInt16Value(MlirAttribute attr, intptr_t pos) { … }
int32_t mlirDenseElementsAttrGetInt32Value(MlirAttribute attr, intptr_t pos) { … }
uint32_t mlirDenseElementsAttrGetUInt32Value(MlirAttribute attr, intptr_t pos) { … }
int64_t mlirDenseElementsAttrGetInt64Value(MlirAttribute attr, intptr_t pos) { … }
uint64_t mlirDenseElementsAttrGetUInt64Value(MlirAttribute attr, intptr_t pos) { … }
float mlirDenseElementsAttrGetFloatValue(MlirAttribute attr, intptr_t pos) { … }
double mlirDenseElementsAttrGetDoubleValue(MlirAttribute attr, intptr_t pos) { … }
MlirStringRef mlirDenseElementsAttrGetStringValue(MlirAttribute attr,
                                                  intptr_t pos) { … }

//===----------------------------------------------------------------------===//
// Raw data accessors.
//===----------------------------------------------------------------------===//

const void *mlirDenseElementsAttrGetRawData(MlirAttribute attr) { … }

//===----------------------------------------------------------------------===//
// Resource blob attributes.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsADenseResourceElements(MlirAttribute attr) { … }

MlirAttribute mlirUnmanagedDenseResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, void *data, size_t dataLength,
    size_t dataAlignment, bool dataIsMutable,
    void (*deleter)(void *userData, const void *data, size_t size,
                    size_t align),
    void *userData) { … }

template <typename U, typename T>
static MlirAttribute getDenseResource(MlirType shapedType, MlirStringRef name,
                                      intptr_t numElements, const T *elements) { … }

MlirAttribute mlirUnmanagedDenseBoolResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const int *elements) { … }
MlirAttribute mlirUnmanagedDenseUInt8ResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const uint8_t *elements) { … }
MlirAttribute mlirUnmanagedDenseUInt16ResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const uint16_t *elements) { … }
MlirAttribute mlirUnmanagedDenseUInt32ResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const uint32_t *elements) { … }
MlirAttribute mlirUnmanagedDenseUInt64ResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const uint64_t *elements) { … }
MlirAttribute mlirUnmanagedDenseInt8ResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const int8_t *elements) { … }
MlirAttribute mlirUnmanagedDenseInt16ResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const int16_t *elements) { … }
MlirAttribute mlirUnmanagedDenseInt32ResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const int32_t *elements) { … }
MlirAttribute mlirUnmanagedDenseInt64ResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const int64_t *elements) { … }
MlirAttribute mlirUnmanagedDenseFloatResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const float *elements) { … }
MlirAttribute mlirUnmanagedDenseDoubleResourceElementsAttrGet(
    MlirType shapedType, MlirStringRef name, intptr_t numElements,
    const double *elements) { … }
template <typename U, typename T>
static T getDenseResourceVal(MlirAttribute attr, intptr_t pos) { … }

bool mlirDenseBoolResourceElementsAttrGetValue(MlirAttribute attr,
                                               intptr_t pos) { … }
uint8_t mlirDenseUInt8ResourceElementsAttrGetValue(MlirAttribute attr,
                                                   intptr_t pos) { … }
uint16_t mlirDenseUInt16ResourceElementsAttrGetValue(MlirAttribute attr,
                                                     intptr_t pos) { … }
uint32_t mlirDenseUInt32ResourceElementsAttrGetValue(MlirAttribute attr,
                                                     intptr_t pos) { … }
uint64_t mlirDenseUInt64ResourceElementsAttrGetValue(MlirAttribute attr,
                                                     intptr_t pos) { … }
int8_t mlirDenseInt8ResourceElementsAttrGetValue(MlirAttribute attr,
                                                 intptr_t pos) { … }
int16_t mlirDenseInt16ResourceElementsAttrGetValue(MlirAttribute attr,
                                                   intptr_t pos) { … }
int32_t mlirDenseInt32ResourceElementsAttrGetValue(MlirAttribute attr,
                                                   intptr_t pos) { … }
int64_t mlirDenseInt64ResourceElementsAttrGetValue(MlirAttribute attr,
                                                   intptr_t pos) { … }
float mlirDenseFloatResourceElementsAttrGetValue(MlirAttribute attr,
                                                 intptr_t pos) { … }
double mlirDenseDoubleResourceElementsAttrGetValue(MlirAttribute attr,
                                                   intptr_t pos) { … }

//===----------------------------------------------------------------------===//
// Sparse elements attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsASparseElements(MlirAttribute attr) { … }

MlirAttribute mlirSparseElementsAttribute(MlirType shapedType,
                                          MlirAttribute denseIndices,
                                          MlirAttribute denseValues) { … }

MlirAttribute mlirSparseElementsAttrGetIndices(MlirAttribute attr) { … }

MlirAttribute mlirSparseElementsAttrGetValues(MlirAttribute attr) { … }

MlirTypeID mlirSparseElementsAttrGetTypeID(void) { … }

//===----------------------------------------------------------------------===//
// Strided layout attribute.
//===----------------------------------------------------------------------===//

bool mlirAttributeIsAStridedLayout(MlirAttribute attr) { … }

MlirAttribute mlirStridedLayoutAttrGet(MlirContext ctx, int64_t offset,
                                       intptr_t numStrides,
                                       const int64_t *strides) { … }

int64_t mlirStridedLayoutAttrGetOffset(MlirAttribute attr) { … }

intptr_t mlirStridedLayoutAttrGetNumStrides(MlirAttribute attr) { … }

int64_t mlirStridedLayoutAttrGetStride(MlirAttribute attr, intptr_t pos) { … }

MlirTypeID mlirStridedLayoutAttrGetTypeID(void) { … }