synta 0.2.2

ASN.1 parser, decoder, and encoder library with DER/BER support and C FFI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

# CHOICE Dispatch


This page documents how synta-codegen generates C code for ASN.1 CHOICE types.

## Struct Layout

A CHOICE type generates a tagged union: an enum for the active variant plus a
union of all variant types:

```c
typedef enum {
    TypeName_TAG_Variant1,
    TypeName_TAG_Variant2,
    /* ... */
} TypeNameTag;

typedef struct {
    TypeNameTag tag;
    union {
        Variant1Type variant1;
        Variant2Type variant2;
        /* ... */
    } value;
} TypeName;
```

## Decode Pattern

The generated decode function calls `synta_decoder_peek_tag()` on the decoder
(without entering any container) and dispatches to the variant's decode
function based on the tag class and number:

```c,ignore
SyntaTag peeked;
err = synta_decoder_peek_tag(decoder, &peeked);
if (err != SyntaErrorCode_Success) return err;

if (peeked.class_ == SyntaTagClass_Universal && peeked.number == 16) {
    out->tag = TypeName_TAG_Variant1;
    return Variant1Type_decode(decoder, &out->value.variant1);
} else if (peeked.class_ == SyntaTagClass_Universal && peeked.number == 2) {
    out->tag = TypeName_TAG_Variant2;
    return Variant2Type_decode(decoder, &out->value.variant2);
}
return SyntaErrorCode_InvalidTag;
```

## Encode Pattern

The generated encode function switches on `value->tag`:

```c,ignore
switch (value->tag) {
case TypeName_TAG_Variant1:
    return Variant1Type_encode(encoder, &value->value.variant1);
case TypeName_TAG_Variant2:
    return Variant2Type_encode(encoder, &value->value.variant2);
default:
    return SyntaErrorCode_InvalidTag;
}
```

## Free Pattern

The generated free function also switches on `tag` to call the correct
variant's cleanup:

```c
void TypeName_free(TypeName *value) {
    if (value == NULL) return;
    switch (value->tag) {
    case TypeName_TAG_Variant1:
        Variant1Type_free(&value->value.variant1);
        break;
    case TypeName_TAG_Variant2:
        Variant2Type_free(&value->value.variant2);
        break;
    default:
        break;
    }
}
```

## Example

```asn1
AttributeValue ::= CHOICE {
    utf8String    UTF8String,
    printable     PrintableString,
    ia5String     IA5String
}
```

Generated types:

```c
typedef enum {
    AttributeValue_TAG_utf8String,
    AttributeValue_TAG_printable,
    AttributeValue_TAG_ia5String,
} AttributeValueTag;

typedef struct {
    AttributeValueTag tag;
    union {
        SyntaOctetString *utf8String;
        SyntaOctetString *printable;
        SyntaOctetString *ia5String;
    } value;
} AttributeValue;
```

Usage:

```c,ignore
AttributeValue av = {0};
SyntaErrorCode err = AttributeValue_decode(decoder, &av);
if (err == SyntaErrorCode_Success) {
    switch (av.tag) {
    case AttributeValue_TAG_utf8String:
        /* use av.value.utf8String */
        break;
    case AttributeValue_TAG_printable:
        /* use av.value.printable */
        break;
    default:
        break;
    }
    AttributeValue_free(&av);
}
```