To mark symbols up with metadata.

• §1. Forms

§1. Forms.

typedef struct inter_annotation_form {
    inter_ti annotation_ID;
    int textual_flag;
    struct text_stream *annotation_keyword;
    CLASS_DEFINITION
} inter_annotation_form;

typedef struct inter_annotation {
    struct inter_annotation_form *annot;
    inter_ti annot_value;
    struct inter_annotation *next;
} inter_annotation;

typedef struct inter_annotation_set {
    struct inter_annotation *anns;
} inter_annotation_set;

inter_annotation_form *invalid_IAF = NULL;
inter_annotation_form *name_IAF = NULL;

• The structure inter_annotation_form is accessed in 3/dfn, 3/iibf and here.
• The structure inter_annotation is accessed in 2/sym, 3/dfn and here.
• The structure inter_annotation_set is private to this section.

§2.

inter_annotation_set Inter::Annotations::new_set?Usage of Inter::Annotations::new_set:
Symbols - §2
Definition - §4(void) {
    inter_annotation_set set;
    set.anns = NULL;
    return set;
}

void Inter::Annotations::add_to_set?Usage of Inter::Annotations::add_to_set:
Symbols - §4
Definition - §4(inter_annotation_set *set, inter_annotation A) {
    inter_annotation *NA = CREATE(inter_annotation);
    NA->annot = A.annot;
    NA->annot_value = A.annot_value;
    NA->next = NULL;
    inter_annotation *L = set->anns;
    if (L) {
        while ((L) && (L->next)) L = L->next;
        L->next = NA;
    } else {
        set->anns = NA;
    }
}

void Inter::Annotations::copy_set_to_symbol?Usage of Inter::Annotations::copy_set_to_symbol:
The Variable Construct - §2
The Constant Construct - §2
The Property Construct - §2
The Local Construct - §2(inter_annotation_set *set, inter_symbol *S) {
    if (set)
        for (inter_annotation *A = set->anns; A; A = A->next)
            Inter::Symbols::annotate(S, *A);
}

void Inter::Annotations::transpose_set?Usage of Inter::Annotations::transpose_set:
Symbols - §4(inter_annotation_set *set, inter_ti *grid, inter_ti grid_extent, inter_error_message **E) {
    for (inter_annotation *A = set->anns; A; A = A->next)
        Inter::Defn::transpose_annotation(A, grid, grid_extent, E);
}

void Inter::Annotations::write_set?Usage of Inter::Annotations::write_set:
Symbols - §4(OUTPUT_STREAM, inter_annotation_set *set, inter_tree_node *F) {
    for (inter_annotation *A = set->anns; A; A = A->next)
        Inter::Defn::write_annotation(OUT, F, *A);
}

int Inter::Annotations::exist?Usage of Inter::Annotations::exist:
The Comment Construct - §1
The Symbol Construct - §1
The Version Construct - §2
The Pragma Construct - §2
The Link Construct - §2
The Append Construct - §2
The PackageType Construct - §2
The Instance Construct - §2
The PropertyValue Construct - §2
The Permission Construct - §2
The Primitive Construct - §2
The Label Construct - §2
The Inv Construct - §2
The Ref Construct - §2
The Val Construct - §2
The Lab Construct - §2
The Code Construct - §2
The Evaluation Construct - §2
The Reference Construct - §2
The Cast Construct - §2
The Splat Construct - §2(inter_annotation_set *set) {
    if ((set) && (set->anns)) return TRUE;
    return FALSE;
}

inter_annotation *Inter::Annotations::find?Usage of Inter::Annotations::find:
Symbols - §4
The Constant Construct - §2(const inter_annotation_set *set, inter_ti ID) {
    if (set)
        for (inter_annotation *A = set->anns; A; A = A->next)
            if (A->annot->annotation_ID == ID)
                return A;
    return NULL;
}

inter_annotation_form *Inter::Annotations::form?Usage of Inter::Annotations::form:
Canonical Annotations - §3
Inter in Binary Files - §1.3(inter_ti ID, text_stream *keyword, int textual) {
    inter_annotation_form *IAF;
    LOOP_OVER(IAF, inter_annotation_form)
        if (Str::eq(keyword, IAF->annotation_keyword)) {
            if (IAF->annotation_ID == ID)
                return IAF;
            else
                return NULL;
        }

    IAF = CREATE(inter_annotation_form);
    IAF->annotation_ID = ID;
    IAF->annotation_keyword = Str::duplicate(keyword);
    IAF->textual_flag = textual;
    return IAF;
}

inter_annotation Inter::Annotations::invalid_annotation?Usage of Inter::Annotations::invalid_annotation:
Definition - §3(void) {
    inter_annotation IA;
    IA.annot = invalid_IAF;
    IA.annot_value = 0;
    return IA;
}

inter_annotation Inter::Annotations::value_annotation?Usage of Inter::Annotations::value_annotation:
Definition - §3(inter_annotation_form *IAF, inter_ti V) {
    inter_annotation IA;
    IA.annot = IAF;
    IA.annot_value = V;
    return IA;
}

int Inter::Annotations::is_invalid?Usage of Inter::Annotations::is_invalid:
Inter in Binary Files - §1.4.2(inter_annotation IA) {
    if ((IA.annot == NULL) || (IA.annot->annotation_ID == INVALID_IANN)) return TRUE;
    return FALSE;
}
inter_annotation Inter::Annotations::from_bytecode?Usage of Inter::Annotations::from_bytecode:
Symbols - §4
Inter in Binary Files - §1.4.2(inter_ti c1, inter_ti c2) {
    inter_annotation_form *IAF;
    LOOP_OVER(IAF, inter_annotation_form)
        if (c1 == IAF->annotation_ID) {
            inter_annotation IA;
            IA.annot = IAF;
            IA.annot_value = c2;
            return IA;
        }
    return Inter::Annotations::invalid_annotation();
}

void Inter::Annotations::set_to_bytecode?Usage of Inter::Annotations::set_to_bytecode:
Inter in Binary Files - §1.1.3.2(FILE *fh, inter_annotation_set *set) {
    unsigned int c = 0;
    for (inter_annotation *A = set->anns; A; A = A->next) c++;
    BinaryFiles::write_int32(fh, c);
    for (inter_annotation *A = set->anns; A; A = A->next) {
        inter_ti c1 = 0, c2 = 0;
        Inter::Annotations::to_bytecode(*A, &c1, &c2);
        BinaryFiles::write_int32(fh, (unsigned int) c1);
        BinaryFiles::write_int32(fh, (unsigned int) c2);
    }
}

void Inter::Annotations::to_bytecode(inter_annotation IA, inter_ti *c1, inter_ti *c2) {
    *c1 = IA.annot->annotation_ID;
    *c2 = IA.annot_value;
}